From 5e7ce1048c4e84eb4b3ae9e337183ee90c8115a7 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Thu, 25 Jul 2024 21:00:41 +0300 Subject: [PATCH 01/38] Add GAN model 25/7 --- gan/main.py | 138 +++++++++++++++++++++++++++++++++++++++++++++++++++ gan/mnist.py | 83 +++++++++++++++++++++++++++++++ 2 files changed, 221 insertions(+) create mode 100644 gan/main.py create mode 100644 gan/mnist.py diff --git a/gan/main.py b/gan/main.py new file mode 100644 index 00000000..7192a3bc --- /dev/null +++ b/gan/main.py @@ -0,0 +1,138 @@ +import mnist +from tqdm import tqdm + +import argparse + +import mlx.core as mx +import mlx.nn as nn +import mlx.optimizers as optim +import numpy as np + +# Generator Block +def GenBlock(in_dim:int,out_dim:int): + return nn.Sequential( + nn.Linear(in_dim,out_dim), + nn.BatchNorm(out_dim), + nn.ReLU() + ) + +# Generator Layer +class Generator(nn.Module): + + def __init__(self, z_dim:int = 10, im_dim:int = 784, hidden_dim: int =128): + super(Generator, self).__init__() + # Build the neural network + self.gen = nn.Sequential( + GenBlock(z_dim, hidden_dim), + GenBlock(hidden_dim, hidden_dim * 2), + GenBlock(hidden_dim * 2, hidden_dim * 4), + GenBlock(hidden_dim * 4, hidden_dim * 8), + + + nn.Linear(hidden_dim * 8,im_dim), + nn.Sigmoid() + ) + + def forward(self, noise): + + return self.gen(noise) + + +# return random n,m normal distribution +def get_noise(n_samples:int, z_dim:int)->list: + return np.random.randn(n_samples,z_dim) + +#---------------------------------------------# + +# Discriminator Block +def DisBlock(in_dim:int,out_dim:int): + return nn.Sequential( + nn.Linear(in_dim,out_dim), + nn.LeakyReLU(negative_slope=0.2) + ) + +# Discriminator Layer +class Discriminator(nn.Module): + + def __init__(self,im_dim:int = 784, hidden_dim:int = 128): + super(Discriminator, self).__init__() + + self.disc = nn.Sequential( + DisBlock(im_dim, hidden_dim * 4), + DisBlock(hidden_dim * 4, hidden_dim * 2), + DisBlock(hidden_dim * 2, hidden_dim), + + nn.Linear(hidden_dim,1), + ) + + def forward(self, noise): + + return self.disc(noise) + +def main(args:dict): + seed = 42 + criterion = nn.losses.binary_cross_entropy + n_epochs = 200 + z_dim = 64 + display_step = 500 + batch_size = 128 + lr = 0.00001 + + np.random.seed(seed) + + # Load the data + train_images, train_labels, test_images, test_labels = map( + mx.array, getattr(mnist, args.dataset)() + ) + + gen = Generator(z_dim) + gen_opt = optim.Adam(learning_rate=lr) + disc = Discriminator() + disc_opt = optim.Adam(learning_rate=lr) + + # use partial function + def disc_loss(gen, disc, criterion, real, num_images, z_dim): + noise = get_noise(num_images, z_dim,device) + fake_images = gen(noise) + + fake_disc = disc(fake_images.detach()) + fake_labels = mx.zeros(fake_images.size(0),1) + fake_loss = criterion(fake_disc,fake_labels) + + real_disc = disc(real) + real_labels = mx.ones(real.size(0),1) + real_loss = criterion(real_disc,real_labels) + + disc_loss = (fake_loss + real_loss) / 2 + + return disc_loss + + def gen_loss(gen, disc, criterion, num_images, z_dim): + + noise = get_noise(num_images, z_dim,device) + fake_images = gen(noise) + + fake_disc = disc(fake_images) + fake_labels = mx.ones(fake_images.size(0),1) + + gen_loss = criterion(fake_disc,fake_labels) + + return gen_loss + + # training + + +if __name__ == "__main__": + parser = argparse.ArgumentParser("Train a simple GAN on MNIST with MLX.") + parser.add_argument("--gpu", action="store_true", help="Use the Metal back-end.") + parser.add_argument( + "--dataset", + type=str, + default="mnist", + choices=["mnist", "fashion_mnist"], + help="The dataset to use.", + ) + args = parser.parse_args() + if not args.gpu: + mx.set_default_device(mx.cpu) + main(args) diff --git a/gan/mnist.py b/gan/mnist.py new file mode 100644 index 00000000..c5f920e6 --- /dev/null +++ b/gan/mnist.py @@ -0,0 +1,83 @@ +# Copyright © 2023 Apple Inc. + +import gzip +import os +import pickle +from urllib import request + +import numpy as np + + +def mnist( + save_dir="/tmp", + base_url="https://raw.githubusercontent.com/fgnt/mnist/master/", + filename="mnist.pkl", +): + """ + Load the MNIST dataset in 4 tensors: train images, train labels, + test images, and test labels. + + Checks `save_dir` for already downloaded data otherwise downloads. + + Download code modified from: + https://github.com/hsjeong5/MNIST-for-Numpy + """ + + def download_and_save(save_file): + filename = [ + ["training_images", "train-images-idx3-ubyte.gz"], + ["test_images", "t10k-images-idx3-ubyte.gz"], + ["training_labels", "train-labels-idx1-ubyte.gz"], + ["test_labels", "t10k-labels-idx1-ubyte.gz"], + ] + + mnist = {} + for name in filename: + out_file = os.path.join("/tmp", name[1]) + request.urlretrieve(base_url + name[1], out_file) + for name in filename[:2]: + out_file = os.path.join("/tmp", name[1]) + with gzip.open(out_file, "rb") as f: + mnist[name[0]] = np.frombuffer(f.read(), np.uint8, offset=16).reshape( + -1, 28 * 28 + ) + for name in filename[-2:]: + out_file = os.path.join("/tmp", name[1]) + with gzip.open(out_file, "rb") as f: + mnist[name[0]] = np.frombuffer(f.read(), np.uint8, offset=8) + with open(save_file, "wb") as f: + pickle.dump(mnist, f) + + save_file = os.path.join(save_dir, filename) + if not os.path.exists(save_file): + download_and_save(save_file) + with open(save_file, "rb") as f: + mnist = pickle.load(f) + + def preproc(x): + return x.astype(np.float32) / 255.0 + + mnist["training_images"] = preproc(mnist["training_images"]) + mnist["test_images"] = preproc(mnist["test_images"]) + return ( + mnist["training_images"], + mnist["training_labels"].astype(np.uint32), + mnist["test_images"], + mnist["test_labels"].astype(np.uint32), + ) + + +def fashion_mnist(save_dir="/tmp"): + return mnist( + save_dir, + base_url="http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/", + filename="fashion_mnist.pkl", + ) + + +if __name__ == "__main__": + train_x, train_y, test_x, test_y = mnist() + assert train_x.shape == (60000, 28 * 28), "Wrong training set size" + assert train_y.shape == (60000,), "Wrong training set size" + assert test_x.shape == (10000, 28 * 28), "Wrong test set size" + assert test_y.shape == (10000,), "Wrong test set size" From d426586b03e634fdac80f7e99f1717b1dfa3fa38 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Fri, 26 Jul 2024 16:07:40 +0300 Subject: [PATCH 02/38] Updating GAN Code... --- gan/main.py | 2 +- gan/playground.ipynb | 493 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 494 insertions(+), 1 deletion(-) create mode 100644 gan/playground.ipynb diff --git a/gan/main.py b/gan/main.py index 7192a3bc..cd1a6ff9 100644 --- a/gan/main.py +++ b/gan/main.py @@ -119,7 +119,7 @@ def main(args:dict): return gen_loss - # training + # TODO training... if __name__ == "__main__": diff --git a/gan/playground.ipynb b/gan/playground.ipynb new file mode 100644 index 00000000..2dc3d24d --- /dev/null +++ b/gan/playground.ipynb @@ -0,0 +1,493 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import Library" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import mnist" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import mlx.core as mx\n", + "import mlx.nn as nn\n", + "import mlx.optimizers as optim\n", + "\n", + "from tqdm import tqdm\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GAN Architecture" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generator 👨🏻‍🎨" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def GenBlock(in_dim:int,out_dim:int):\n", + " \n", + " return nn.Sequential(\n", + " nn.Linear(in_dim,out_dim),\n", + " nn.BatchNorm(out_dim),\n", + " nn.ReLU()\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class Generator(nn.Module):\n", + "\n", + " def __init__(self, z_dim:int = 10, im_dim:int = 784, hidden_dim: int =128):\n", + " super(Generator, self).__init__()\n", + " # Build the neural network\n", + " self.gen = nn.Sequential(\n", + " GenBlock(z_dim, hidden_dim),\n", + " GenBlock(hidden_dim, hidden_dim * 2),\n", + " GenBlock(hidden_dim * 2, hidden_dim * 4),\n", + " GenBlock(hidden_dim * 4, hidden_dim * 8),\n", + "\n", + "\n", + " nn.Linear(hidden_dim * 8,im_dim),\n", + " nn.Sigmoid()\n", + " )\n", + " \n", + " def __call__(self, noise):\n", + "\n", + " return self.gen(noise)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Generator(\n", + " (gen): Sequential(\n", + " (layers.0): Sequential(\n", + " (layers.0): Linear(input_dims=100, output_dims=128, bias=True)\n", + " (layers.1): BatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): ReLU()\n", + " )\n", + " (layers.1): Sequential(\n", + " (layers.0): Linear(input_dims=128, output_dims=256, bias=True)\n", + " (layers.1): BatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): ReLU()\n", + " )\n", + " (layers.2): Sequential(\n", + " (layers.0): Linear(input_dims=256, output_dims=512, bias=True)\n", + " (layers.1): BatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): ReLU()\n", + " )\n", + " (layers.3): Sequential(\n", + " (layers.0): Linear(input_dims=512, output_dims=1024, bias=True)\n", + " (layers.1): BatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): ReLU()\n", + " )\n", + " (layers.4): Linear(input_dims=1024, output_dims=784, bias=True)\n", + " (layers.5): Sigmoid()\n", + " )\n", + ")" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gen = Generator(100)\n", + "gen" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def get_noise(n_samples, z_dim):\n", + "\n", + " return np.random.randn(n_samples,z_dim)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discriminator 🕵🏻‍♂️" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def DisBlock(in_dim:int,out_dim:int):\n", + " \n", + " return nn.Sequential(\n", + " nn.Linear(in_dim,out_dim),\n", + " nn.LeakyReLU(negative_slope=0.2)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "class Discriminator(nn.Module):\n", + "\n", + " def __init__(self,im_dim:int = 784, hidden_dim:int = 128):\n", + " super(Discriminator, self).__init__()\n", + "\n", + " self.disc = nn.Sequential(\n", + " DisBlock(im_dim, hidden_dim * 4),\n", + " DisBlock(hidden_dim * 4, hidden_dim * 2),\n", + " DisBlock(hidden_dim * 2, hidden_dim),\n", + "\n", + " nn.Linear(hidden_dim,1),\n", + " )\n", + " \n", + " def __call__(self, noise):\n", + "\n", + " return self.disc(noise)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Discriminator(\n", + " (disc): Sequential(\n", + " (layers.0): Sequential(\n", + " (layers.0): Linear(input_dims=784, output_dims=512, bias=True)\n", + " (layers.1): LeakyReLU()\n", + " )\n", + " (layers.1): Sequential(\n", + " (layers.0): Linear(input_dims=512, output_dims=256, bias=True)\n", + " (layers.1): LeakyReLU()\n", + " )\n", + " (layers.2): Sequential(\n", + " (layers.0): Linear(input_dims=256, output_dims=128, bias=True)\n", + " (layers.1): LeakyReLU()\n", + " )\n", + " (layers.3): Linear(input_dims=128, output_dims=1, bias=True)\n", + " )\n", + ")" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "disc = Discriminator()\n", + "disc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model Training 🏋🏻‍♂️" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Set your parameters\n", + "criterion = nn.losses.binary_cross_entropy\n", + "n_epochs = 200\n", + "z_dim = 64\n", + "display_step = 500\n", + "batch_size = 128\n", + "lr = 0.00001" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "gen = Generator(z_dim)\n", + "gen_opt = optim.Adam(learning_rate=lr)\n", + "disc = Discriminator()\n", + "disc_opt = optim.Adam(learning_rate=lr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Losses" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def disc_loss(gen, disc, criterion, real, num_images, z_dim):\n", + " noise = mx.array(get_noise(num_images, z_dim))\n", + " fake_images = gen(noise)\n", + " \n", + " fake_disc = disc(fake_images)\n", + " \n", + " fake_labels = mx.zeros((len(fake_images),1))\n", + " fake_loss = criterion(fake_disc,fake_labels)\n", + " \n", + " real_disc = disc(real)\n", + " real_labels = mx.ones((len(real),1))\n", + " real_loss = criterion(real_disc,real_labels)\n", + "\n", + " disc_loss = (fake_loss + real_loss) / 2\n", + "\n", + " return disc_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def gen_loss(gen, disc, criterion, num_images, z_dim):\n", + "\n", + " noise = mx.array(get_noise(num_images, z_dim))\n", + " fake_images = gen(noise)\n", + " \n", + " fake_disc = disc(fake_images)\n", + "\n", + " fake_labels = mx.ones((fake_images.size(0),1))\n", + " \n", + " gen_loss = criterion(fake_disc,fake_labels)\n", + "\n", + " return gen_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "train_images, _, test_images, _ = map(\n", + " mx.array, getattr(mnist, 'mnist')()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def batch_iterate(batch_size:int, ipt:list):\n", + " perm = mx.array(np.random.permutation(len(ipt)))\n", + " for s in range(0, ipt.size, batch_size):\n", + " ids = perm[s : s + batch_size]\n", + " yield ipt[ids]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### show batch of images" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for X in batch_iterate(16, train_images):\n", + " fig,axes = plt.subplots(4, 4, figsize=(4, 4))\n", + "\n", + " for i, ax in enumerate(axes.flat):\n", + " img = mx.array(X[i]).reshape(28,28)\n", + " ax.imshow(img,cmap='gray')\n", + " ax.axis('off')\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "0it [00:00, ?it/s]\n", + "0it [00:00, ?it/s]\n" + ] + }, + { + "ename": "TypeError", + "evalue": "'array' object is not callable", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[167], line 21\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_epochs):\n\u001b[1;32m 10\u001b[0m \n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m# Dataloader returns the batches\u001b[39;00m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m real \u001b[38;5;129;01min\u001b[39;00m tqdm(batch_iterate(batch_size, train_images)):\n\u001b[1;32m 13\u001b[0m \n\u001b[1;32m 14\u001b[0m \u001b[38;5;66;03m# Flatten the batch of real images from the dataset\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 19\u001b[0m \n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# Calculate discriminator loss\u001b[39;00m\n\u001b[0;32m---> 21\u001b[0m disc_loss \u001b[38;5;241m=\u001b[39m \u001b[43mdisc_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreal\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 23\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;66;03m# disc_loss.backward(retain_graph=True)\u001b[39;00m\n\u001b[1;32m 25\u001b[0m \n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 27\u001b[0m mx\u001b[38;5;241m.\u001b[39meval(disc\u001b[38;5;241m.\u001b[39mparameters())\n", + "\u001b[0;31mTypeError\u001b[0m: 'array' object is not callable" + ] + } + ], + "source": [ + "batch_size = 8\n", + "cur_step = 0\n", + "mean_generator_loss = 0\n", + "mean_discriminator_loss = 0\n", + "test_generator = True # Whether the generator should be tested\n", + "gen_loss = False\n", + "error = False\n", + "\n", + "for epoch in range(n_epochs):\n", + " \n", + " # Dataloader returns the batches\n", + " for real in tqdm(batch_iterate(batch_size, train_images)):\n", + "\n", + " # Flatten the batch of real images from the dataset\n", + "\n", + " ### Update discriminator ###\n", + " # Zero out the gradients before backpropagation\n", + " # disc_opt.zero_grad()\n", + "\n", + " # Calculate discriminator loss\n", + " disc_loss = disc_loss(gen, disc, criterion, real, batch_size, z_dim)\n", + " \n", + " # Update gradients\n", + " # disc_loss.backward(retain_graph=True)\n", + "\n", + " # Update optimizer\n", + " mx.eval(disc.parameters())\n", + " \n", + " break\n", + " # For testing purposes, to keep track of the generator weights\n", + " if test_generator:\n", + " old_generator_weights = gen.gen[0][0].weight.detach().clone()\n", + "\n", + " ### Update generator ###\n", + " # Hint: This code will look a lot like the discriminator updates!\n", + " # These are the steps you will need to complete:\n", + " # 1) Zero out the gradients.\n", + " # 2) Calculate the generator loss, assigning it to gen_loss.\n", + " # 3) Backprop through the generator: update the gradients and optimizer.\n", + " #### START CODE HERE ####\n", + " gen_opt.zero_grad()\n", + " gen_loss = get_gen_loss(gen, disc, criterion, cur_batch_size, z_dim, device)\n", + " gen_loss.backward(retain_graph=True)\n", + " gen_opt.step()\n", + " #### END CODE HERE ####\n", + "\n", + " # For testing purposes, to check that your code changes the generator weights\n", + " if test_generator:\n", + " try:\n", + " assert lr > 0.0000002 or (gen.gen[0][0].weight.grad.abs().max() < 0.0005 and epoch == 0)\n", + " assert torch.any(gen.gen[0][0].weight.detach().clone() != old_generator_weights)\n", + " except:\n", + " error = True\n", + " print(\"Runtime tests have failed\")\n", + "\n", + " # Keep track of the average discriminator loss\n", + " mean_discriminator_loss += disc_loss.item() / display_step\n", + "\n", + " # Keep track of the average generator loss\n", + " mean_generator_loss += gen_loss.item() / display_step\n", + "\n", + " ### Visualization code ###\n", + " if cur_step % display_step == 0 and cur_step > 0:\n", + " print(f\"Step {cur_step}: Generator loss: {mean_generator_loss}, discriminator loss: {mean_discriminator_loss}\")\n", + " fake_noise = get_noise(cur_batch_size, z_dim, device=device)\n", + " fake = gen(fake_noise)\n", + " show_tensor_images(fake)\n", + " show_tensor_images(real)\n", + " mean_generator_loss = 0\n", + " mean_discriminator_loss = 0\n", + " cur_step += 1\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 591074bea8295981a765ec0289a0640ab374815f Mon Sep 17 00:00:00 2001 From: Shubbair Date: Fri, 26 Jul 2024 16:36:29 +0300 Subject: [PATCH 03/38] Updating GAN Code... --- gan/playground.ipynb | 117 +++++++++++++++++++------------------------ 1 file changed, 51 insertions(+), 66 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 2dc3d24d..98b23839 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -250,13 +250,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 197, "metadata": {}, "outputs": [], "source": [ "gen = Generator(z_dim)\n", + "mx.eval(gen.parameters())\n", "gen_opt = optim.Adam(learning_rate=lr)\n", + "\n", "disc = Discriminator()\n", + "mx.eval(disc.parameters())\n", "disc_opt = optim.Adam(learning_rate=lr)" ] }, @@ -269,22 +272,22 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 198, "metadata": {}, "outputs": [], "source": [ - "def disc_loss(gen, disc, criterion, real, num_images, z_dim):\n", + "def disc_loss(gen, disc, real, num_images, z_dim):\n", " noise = mx.array(get_noise(num_images, z_dim))\n", " fake_images = gen(noise)\n", " \n", " fake_disc = disc(fake_images)\n", " \n", " fake_labels = mx.zeros((len(fake_images),1))\n", - " fake_loss = criterion(fake_disc,fake_labels)\n", + " fake_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", " \n", " real_disc = disc(real)\n", " real_labels = mx.ones((len(real),1))\n", - " real_loss = criterion(real_disc,real_labels)\n", + " real_loss = nn.losses.binary_cross_entropy(real_disc,real_labels,with_logits=True)\n", "\n", " disc_loss = (fake_loss + real_loss) / 2\n", "\n", @@ -293,11 +296,11 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 199, "metadata": {}, "outputs": [], "source": [ - "def gen_loss(gen, disc, criterion, num_images, z_dim):\n", + "def gen_loss(gen, disc, num_images, z_dim):\n", "\n", " noise = mx.array(get_noise(num_images, z_dim))\n", " fake_images = gen(noise)\n", @@ -306,14 +309,14 @@ "\n", " fake_labels = mx.ones((fake_images.size(0),1))\n", " \n", - " gen_loss = criterion(fake_disc,fake_labels)\n", + " gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", "\n", " return gen_loss" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 200, "metadata": {}, "outputs": [], "source": [ @@ -324,7 +327,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 201, "metadata": {}, "outputs": [], "source": [ @@ -344,12 +347,12 @@ }, { "cell_type": "code", - "execution_count": 166, + "execution_count": 202, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -371,26 +374,27 @@ }, { "cell_type": "code", - "execution_count": 167, + "execution_count": 203, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "0it [00:00, ?it/s]\n", "0it [00:00, ?it/s]\n" ] }, { "ename": "TypeError", - "evalue": "'array' object is not callable", + "evalue": "'bool' object is not callable", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[167], line 21\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_epochs):\n\u001b[1;32m 10\u001b[0m \n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m# Dataloader returns the batches\u001b[39;00m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m real \u001b[38;5;129;01min\u001b[39;00m tqdm(batch_iterate(batch_size, train_images)):\n\u001b[1;32m 13\u001b[0m \n\u001b[1;32m 14\u001b[0m \u001b[38;5;66;03m# Flatten the batch of real images from the dataset\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 19\u001b[0m \n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# Calculate discriminator loss\u001b[39;00m\n\u001b[0;32m---> 21\u001b[0m disc_loss \u001b[38;5;241m=\u001b[39m \u001b[43mdisc_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreal\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 23\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;66;03m# disc_loss.backward(retain_graph=True)\u001b[39;00m\n\u001b[1;32m 25\u001b[0m \n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 27\u001b[0m mx\u001b[38;5;241m.\u001b[39meval(disc\u001b[38;5;241m.\u001b[39mparameters())\n", - "\u001b[0;31mTypeError\u001b[0m: 'array' object is not callable" + "Cell \u001b[0;32mIn[203], line 28\u001b[0m\n\u001b[1;32m 23\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[0;32m---> 28\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m \u001b[43mG_loss_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 31\u001b[0m gen_opt\u001b[38;5;241m.\u001b[39mupdate(gen, G_grads)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:34\u001b[0m, in \u001b[0;36mvalue_and_grad..wrapped_value_grad_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapped_value_grad_fn\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 34\u001b[0m value, grad \u001b[38;5;241m=\u001b[39m \u001b[43mvalue_grad_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainable_parameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value, grad\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:28\u001b[0m, in \u001b[0;36mvalue_and_grad..inner_fn\u001b[0;34m(params, *args, **kwargs)\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner_fn\u001b[39m(params, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 27\u001b[0m model\u001b[38;5;241m.\u001b[39mupdate(params)\n\u001b[0;32m---> 28\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: 'bool' object is not callable" ] } ], @@ -403,69 +407,50 @@ "gen_loss = False\n", "error = False\n", "\n", + "D_loss_grad = nn.value_and_grad(disc, disc_loss)\n", + "G_loss_grad = nn.value_and_grad(gen, gen_loss)\n", + "\n", + "\n", "for epoch in range(n_epochs):\n", " \n", " # Dataloader returns the batches\n", " for real in tqdm(batch_iterate(batch_size, train_images)):\n", "\n", " # Flatten the batch of real images from the dataset\n", - "\n", - " ### Update discriminator ###\n", - " # Zero out the gradients before backpropagation\n", - " # disc_opt.zero_grad()\n", - "\n", - " # Calculate discriminator loss\n", - " disc_loss = disc_loss(gen, disc, criterion, real, batch_size, z_dim)\n", " \n", - " # Update gradients\n", - " # disc_loss.backward(retain_graph=True)\n", + " D_loss,D_grads = D_loss_grad(gen, disc, real, batch_size, z_dim)\n", "\n", " # Update optimizer\n", - " mx.eval(disc.parameters())\n", + " disc_opt.update(disc, D_grads)\n", " \n", - " break\n", - " # For testing purposes, to keep track of the generator weights\n", - " if test_generator:\n", - " old_generator_weights = gen.gen[0][0].weight.detach().clone()\n", + " # Update gradients\n", + " \n", + " \n", + " G_loss,G_grads = G_loss_grad(gen, disc, batch_size, z_dim)\n", + " \n", + " # Update optimizer\n", + " gen_opt.update(gen, G_grads)\n", + " \n", + " # Update gradients\n", "\n", - " ### Update generator ###\n", - " # Hint: This code will look a lot like the discriminator updates!\n", - " # These are the steps you will need to complete:\n", - " # 1) Zero out the gradients.\n", - " # 2) Calculate the generator loss, assigning it to gen_loss.\n", - " # 3) Backprop through the generator: update the gradients and optimizer.\n", - " #### START CODE HERE ####\n", - " gen_opt.zero_grad()\n", - " gen_loss = get_gen_loss(gen, disc, criterion, cur_batch_size, z_dim, device)\n", - " gen_loss.backward(retain_graph=True)\n", - " gen_opt.step()\n", - " #### END CODE HERE ####\n", + " \n", "\n", - " # For testing purposes, to check that your code changes the generator weights\n", - " if test_generator:\n", - " try:\n", - " assert lr > 0.0000002 or (gen.gen[0][0].weight.grad.abs().max() < 0.0005 and epoch == 0)\n", - " assert torch.any(gen.gen[0][0].weight.detach().clone() != old_generator_weights)\n", - " except:\n", - " error = True\n", - " print(\"Runtime tests have failed\")\n", + " # # Keep track of the average discriminator loss\n", + " # mean_discriminator_loss += disc_loss.item() / display_step\n", "\n", - " # Keep track of the average discriminator loss\n", - " mean_discriminator_loss += disc_loss.item() / display_step\n", + " # # Keep track of the average generator loss\n", + " # mean_generator_loss += gen_loss.item() / display_step\n", "\n", - " # Keep track of the average generator loss\n", - " mean_generator_loss += gen_loss.item() / display_step\n", - "\n", - " ### Visualization code ###\n", - " if cur_step % display_step == 0 and cur_step > 0:\n", - " print(f\"Step {cur_step}: Generator loss: {mean_generator_loss}, discriminator loss: {mean_discriminator_loss}\")\n", - " fake_noise = get_noise(cur_batch_size, z_dim, device=device)\n", - " fake = gen(fake_noise)\n", - " show_tensor_images(fake)\n", - " show_tensor_images(real)\n", - " mean_generator_loss = 0\n", - " mean_discriminator_loss = 0\n", - " cur_step += 1\n" + " # ### Visualization code ###\n", + " # if cur_step % display_step == 0 and cur_step > 0:\n", + " # print(f\"Step {cur_step}: Generator loss: {mean_generator_loss}, discriminator loss: {mean_discriminator_loss}\")\n", + " # fake_noise = get_noise(cur_batch_size, z_dim, device=device)\n", + " # fake = gen(fake_noise)\n", + " # show_tensor_images(fake)\n", + " # show_tensor_images(real)\n", + " # mean_generator_loss = 0\n", + " # mean_discriminator_loss = 0\n", + " # cur_step += 1\n" ] } ], From 959c623908ed36d6174100d2681183ac84b6a284 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Fri, 26 Jul 2024 16:38:55 +0300 Subject: [PATCH 04/38] Updating GAN Code... --- gan/playground.ipynb | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 98b23839..9bdf4ee6 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -296,7 +296,7 @@ }, { "cell_type": "code", - "execution_count": 199, + "execution_count": 204, "metadata": {}, "outputs": [], "source": [ @@ -307,7 +307,7 @@ " \n", " fake_disc = disc(fake_images)\n", "\n", - " fake_labels = mx.ones((fake_images.size(0),1))\n", + " fake_labels = mx.ones((len(fake_images),1))\n", " \n", " gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", "\n", @@ -316,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": 200, + "execution_count": 205, "metadata": {}, "outputs": [], "source": [ @@ -327,7 +327,7 @@ }, { "cell_type": "code", - "execution_count": 201, + "execution_count": 206, "metadata": {}, "outputs": [], "source": [ @@ -347,12 +347,12 @@ }, { "cell_type": "code", - "execution_count": 202, + "execution_count": 207, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUkAAAFICAYAAADd1gwNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACS7ElEQVR4nOy9Z3Pc2Xaf+3TOOaMbGSBAMJMznBylM8c6ki3pHNlH19eq8gtV3Xf3pT+BP4OrXK6yLcllW1eppJJ0pHNmzkSSk5gDiJwa3Y3OOYf7gt57AAaQMyTy/6licYZsAt0b+7/22mv91lqqXq/XQ0FBQUHhsaj3+g0oKCgo7GcUI6mgoKCwDYqRVFBQUNgGxUgqKCgobINiJBUUFBS2QTGSCgoKCtugGEkFBQWFbVCMpIKCgsI2KEZSQUFBYRu0z/pClUq1k+/jQPFDi5SUNfwOZQ2fH2UNn59nWUPFk1RQUFDYBsVIKigoKGyDYiQVFBQUtkExkgoKCgrboBhJBQUFhW1QjKSCgoLCNihGUkFBQWEbnlknqaCgoPB9eZom8yAMRlCMpIKCwgtDpVKh1WrR6XQMDAwQCARwu90MDg6i1T4wN71ej2w2Sz6fJ5VKcf36darVKjabDaPRiNPpxO/30+v1KBQKNJtNcrkc+XyebrdLp9PZ1c+kGEkFBYUXhlqtxmAwYDabOXfuHKdOneL48eO88847GI1G4IGRXFhYYGFhgVu3bjE/P0+9XsfpdOJyuRgZGeHs2bN0Oh1WVlYoFovMzc1RrVZpt9t0u91d9UAVI6kgUavVaDQa9Ho9Ho8HvV6/5e+0Wq30FFQqFfV6nVqtRqvVolAo0Gq15CZWOFrodDoMBgMWi4X+/n5sNhujo6P09/fj9XoxmUxyP/V6PUwmE1arFZPJhEqlQq1W4/V6iUQiDAwM0N/fT7fbRafTUalUUKvV6PV6CoUCa2trNJvNXftsipFUkBgMBmw2Gz6fjw8++IBIJCL/Tq/XY7fb0el08lq0trbG7Ows6XSaK1eukE6nKZVKVKvVPfwUCnuBy+UiGAwyPDzMH/zBHxAMBgmHw3g8HgwGg7xqC4xGI263G5vNJg/mixcv8tprrxGJRJicnEStVsuDd2lpidXVVW7dusWf/umfkslkdu2zHXgjqVKptvx6EfR6PenOHzavSHiL4vQWf6ZSqbBYLDidTjweD4ODgwwMDMh/J2JFer0eh8OB0WjEYDDQaDTQ6/VYrVZKpRK1Wm2vPtoLQayFVquV//2kvdXr9eh0OvR6PXkFFL8fhITE8yDWQ6PRoFarsdlseDwegsEgIyMj9PX14Xa7sVgs8t88vCab10mtVmOxWHC73bjdbjwez5YYZrfbRaPRkEwmHzG4O82BNpJqtRqXy4XFYsFoNGI2m+WD/zw0m03K5bIMGB/0B1+gUqkYGhpieHgYs9mM1+vFYDDg8XiwWq1YLBa5niMjI9hsNvlvNRoNBoNBxpw0Gg1jY2O4XC6i0ShLS0vodDq63S7FYnEPP+UPx2QyEQgEsFqtTE5OEg6HsVqtuN3uLQZTUCwWWV1dpVwuk0gkyOVyFItFkskknU6HRqNx6A5ZeHC1NplMmEwmhoeHcblcnD17lgsXLuB2uxkaGsJisWwJ12ym2+2yuLjIlStXtsQa5+fnMRqNnD17lsHBQYxGIzqdDpVKhdVqxe/343K50Gg0u/p5D7SRVKlU2Gw26bZ7vd4XYiTL5TKpVIp6vU6lUjlURtLv93Pq1CmcTicjIyNYrVaGhobwer1YrVacTucze+RWq5VQKITNZiMSiVCtVkkmkzv8KXYOvV4vs7Gvvvoqp0+fxuv1MjAwIOOwm9cmmUxy9epVstks9+7dIxaLsb6+TqlUotls0mq1DqWR1Gg0mEwmHA6HPEzefvtt3nvvPWnAtvOke70esViMa9eukUgkaDQadDod1tfXUavV+Hw+ms0mWq1WrrvJZMLlcmG1Wl/IM/592PdGUqPR4HA4MBgM8vRqt9vUajW0Wi3nzp1jYGDgmR/wzX//pB9ko9Egn89TLBb51a9+RaFQeKGfabcQsR6j0Uh/fz92u50LFy5w7tw5LBYLfr9fBtsBKclot9tUKhVarZb8Wp1Oh1arteV3IfVIJBLMzs6ytrZGqVTaq4/73AgvWcTLgsEgFotFPpTCSKrVatRqNVarlf7+ftxuN0ajkeHhYVKpFGNjY2QyGb755hvS6fQef6oXj0jKuN1uTpw4QX9/P8FgUMYQS6USrVaLjY0NCoUCGo0GrVZLt9ulUqnQaDS4du0aq6ur5PN5mezLZrOo1WoWFha4e/euzHQLwyjCOoFAQCYL6/X6jn/efW8k9Xo9Q0NDctMGg0EqlQqJRAK9Xs/PfvYzLly4gF6vx2KxPLOR3O6k63Q6NJtN4vE4CwsLzM/Pv9DPtFuI+KHX6+Vf/at/xcjICCdOnGBqakrGJnu9HqVSiXq9Tjwe5969e5RKJVZWVqhUKvJr1et18vm83Jy1Wg2LxYLdbqdcLnP//n2KxeKua9heJBqNBovFgsPhoL+/n4mJCXkowHd7R3g4Xq8Xp9MptXsi1JDP55mfnycWix1KI+n3+3nttdcIhUJ88MEHDA0NyWtxvV4nGo2Sz+f54osvuH//vjRuzWaT1dVVSqWS9Lq73a5c39XVVaLRKN1uF6PRSDgclt6jwWBAp9Ph9Xo5duwYVquV6enpo20ktVoter0em81GIBAgEAgQDAYJBAJUq1V0Oh0ajUZetYU2azsj+aTg+8N0u13a7bb8PgcNvV6PTqfD6XQSDAbx+/309fURCoVwOp0YjUZp7JrNJtlslnK5zNraGtFolHK5TDwe32IkhXct/l2j0cBsNlOtVqnX61Sr1V2VZewE3W5XfpZ0Os36+jrtdptGoyFfo1ar0el0MrEjEhcWi0WqA7RaLfl8Hrfbjcvlolar7crDvNMIGY/L5SIQCOD3+3E4HJjNZuDBs9RsNkmn02QyGTY2NqQzY7FYaDabbGxsUC6X5R7aTLvdBqBUKrGxsSETgyJkIdZbJA13Kza5b42k2+1mZGSEUCjEH/zBHzA6Oiqv22Izw4MfXKVSQaVSyR/W8yIeBJ1Ot+vxj+dFo9EwPDxMMBhkcnKSd955B6fTydjYGA6HA4BcLsfy8jL/8A//QDqdZm1tjWw2S71ep1QqyXDGZq9QnPjiAOl0OhQKBdLptExSHHTK5TJ37tzBYDCwsrKC2+2WmdXNiCSO0WiUsdy33nqLiYkJmeWNRCL85m/+JkNDQ1y7do2bN2/u0ad6MWi1Wo4fP87IyAinT5/mRz/6EQ6HA7fbDTy4fXU6HeLxOP/4j/8o5WGxWExqbLvdLrVajXa7vSWU8zDxeJxLly6RSCT4zd/8Tfx+P0ajUR7+ZrMZs9m8a1nufWskTSYTwWCQSCTC1NQUk5OT8tQWdDodMpkM5XL5hV/zXqSkaLdQqVRoNBqcTiehUIixsTEuXLiAzWbD5XKh1+spFosUCgU2Nja4ceMG6+vrLC8vH8pr4fdFeEEqlYqNjY0te23zjUPsC4vFQigUwuVyMTg4iM/nQ6/Xy+vlwMAAKpWKpaUlVCrVgZYFCbH38PAwQ0NDDA4ObonXikO0WCyyuLjI0tIS0WiUbDb7vb+XiIdbLBaq1SqtVkte54XBFQmd3WBfGUmRxTIYDBw7dowPPviAQCAgs9ZiUURwWFyJhWfT6/VeyMKVy2VisRixWOzAJCJsNhvDw8M4nU7eeecdTpw4gc/nQ6fTUavVWFpaolKpsLi4yOLiIolEgpmZGUX8/RDCkIn99CTDplKpqNVqpNNp6vU6y8vL0lMX2XCn00mtVsNkMu3a+3/RqNVqKa8bHR3l/PnzRCIRecsSz9vdu3e5du0aS0tLLCwskE6nf7AqxO12MzAwwMjICG63G7PZLMNeQpvabrd37dDZd0ZSJAOOHz/Ob//2b8sY2ub4Q7PZJJPJyBiYSqV6oZ5ksVhkZmbmwBnJs2fP0tfXx09+8hNefvllarUa+XyeXC7HN998w9raGl999RVff/21TDTAwejEspsI4/g0+Y4ISxSLRRYWFjAajdhsNil8djqdtNvtLYLqg4ZIZtntdsbHx3n55ZexWq0YjcYtXuTt27f50z/9U3K5HIuLi9Tr9R+8r9xuN6dOnWJwcBCPx7MljLY53HOkjKRwo3U6HeFwmP7+fvr7+zGZTFvigs1mU16JpqenqVQqdLtdut2u1Es+LYb4sARIaL60Wi1WqxWz2Uw0GmVmZoZEIrHvjaTJZMJisWypdLBYLHQ6HXK5HPPz82SzWZaWlojFYuRyOVqtlmIYXzAicWgwGOShXSwWyWQyB15nuzl7/yTvWqgfSqXSDzZgwjO12WyEw2GCwaAUpIuYZ7VaJZvNkslkdi0Ovi+MpFqtxmQyYbPZ+PGPf8y7774rRcoiFgEPdHzJZJJ79+7x3/7bf2NjY0NetzUajSy3+z6YTCaGhoaw2+2cOHGC0dFR7ty5w//+3/+bbDa77zWSfX19jI2NMTk5ye///u8TDAZlK6rr16/zl3/5l6TTaWZmZmT1kGIgXyxqtRqPx8PAwABut1texe/fv8/8/DzxeHyv3+IPptfr0W63abfbNJtN6vU6BoOBbrcrHZJer0c+n2dlZYVGo7FtUmY7hGpgaGiI9957D4/Hg8PhoNfr0Wg0qNVqbGxscPPmTaLR6NExkiqVCp1Oh9VqxeFwEAwGGRgYwG63y+CscK9LpRKZTIZkMsna2hrxeJxarfZc0hOz2Uy328Vut2O32zGbzcTjceLx+L43kCI8ISRSfr8fr9dLJpOhVCqRy+WIRqOkUilSqdS+94oPIiJZJg55g8EAPLiKF4tFqRo4qAeTCDuIOKDw6MTfid+FEf2htxRRL28wGGQpqNPplLFIoVet1WqUy+Ut8rSdZk+NpF6vx2AwEA6H+Rf/4l8QCoW4ePGidLNVKhXVapWFhQXy+TzffvstV69eJZlMkkwmpZzgeWg2m0SjUfR6PblcjuvXrx+YK5JKpeL06dP80R/9EV6vF4fDQafTYXV1lZWVFe7du8fS0hLFYvFQ6PT2G+Jwd7lcjI6Ocvr0aYxGI9VqlUwmw71797h58+aBVg4IuZ1araZcLlMsFtHr9Y9k+0XZoDBi3zdHIDzIUCjEsWPHZA29Vqul1+tRq9XIZrMyxLab7KmR1Gq1GI1GgsEgb775puw843Q65Wva7Tbr6+vEYjG+/fZbPv74Y6nnexGL1W63pUwhkUg899fbTVQqFYODg7zzzjvyxG00GqTTaZaXl1lbW2NjY+NAGPyDiEajwWw2Y7fb6evrY3BwkEajQaVSoVQqsba2xuLi4oGu3+71erRaLXnVFkUDD3uLQvYE/CAvT61W4/f7GR4epq+vD7vdLlUB4rot+ijstle+p0bSaDTicDhkey632y2vKwKVSiXrjzUaza53Jd7PiPb2KysrUsSs0Wjo6+uTcqharUahUJChiXw+v+/DCAeFzbXeogJHcNTapo2OjvLjH/+YfD7PwsKCbHZSKBS2FY+La7bJZJJ9JIPBoHzWa7UajUZDeuUzMzO7fivaUyMpsrKhUIj+/n4ikcgjpUZqtRqz2SyTOJulKwoPvN+bN28SCASwWCxYrVaOHz/OsWPHmJqa4syZM6TTaT755BNisZissT7sD+5uIDxJ0RZssyRG/DrItezPikql4uLFi4yNjbGxscGXX35JOp3m8uXLzM3NybDY4/acKDO02WycOHGCt956C6/Xi1arpd1uy/j6xx9/zF/91V9RqVQol8u7+vn21EhuVtCLTiGPe41o9e73+xkYGJBib1HXeVQf+F6vJ9ei2+0SDodlE1zRTl9sOCFwrtfr8vokNq+oalB4dsQNRzSIFTcg0YNUjLM4LIhbSyKRQKPREAwGMRqNmEwmaeiELjQUCmEwGBgaGpIJrHQ6TavVktU0omrGZDLh9XpxuVy43W7sdruchdPpdMjn82SzWak02YsenXue3X4aBoOB4eFhIpEIbrebt956i3v37vEnf/Inslj+MNQN/xB6vR737t2jWq3i9/tZXFyUSQQR+B4YGCASiUgDmkwmSafTJBIJrl27JqVCq6ure/1xDgyiPDYQCPD+++8TDofp6+sDYG1tjY8//li2ATssNJtNvvjiC+bm5jhx4gSFQgGPx8PU1JQ8JEQzXrvdTqPR4OLFixQKBVZXV7l58yaZTIYrV66QTCbxeDx4PB76+vp4++238fl8vPzyy/T19cnQRalU4tKlSywuLnL37l2pwVSM5EOI1vDwIIYpNqPdbpctu44yuVxOCpdFwwEhahabVpTIAYTDYZlUyOfzWCwW5ufnUavVRyJ+9iIQsh+z2UwkEqG/v19W1ZRKJVZXV4nFYodKUdDtdonH42QyGfR6PSdOnKDVajE8PEyn09nSFMZsNtPr9QgEAjSbTZxOJ9VqFavVyp07dygUClLmEw6HmZqawu/3y5CRCFXU63VisRjLy8vkcrk96zK1743kZsQPwOfzcerUKVwuF7dv3z7StceNRkOesFevXpVGT8wuHhoawmw2y0ocoaXs7+/n7bffJp/Po9VqiUQistLoeWVVhx2h6Y1EIoyOjhKJRNDr9bJP4q1bt0in07uq5dsNRBeo5eVl/umf/gmHw8H8/Dw+n48TJ05w6tQpNBqNLAARHmE4HObixYuUy2UGBgYoFArYbDbZeOXYsWNYLBZ50KytrXH37l3W19e5fv36njdgOXBGUjTePHnyJC6XS/ZAPKqIUs1iscjGxgbwXemlz+eTTS/OnTtHMBjklVdeYXh4GIfDQTgcplaryY381VdfMT8/rxjJbRDzVgKBAKFQiNHRUfr6+igWizI+fOvWLYrF4qGKScIDI9lqtVheXmZ1dRWDwcDNmzdxu9389Kc/ZWhoSMYTRY5Br9fLXqa9Xo93330X+C4f8Tii0Si//OUvicfjXL9+nWQyuac3nD01kqLec21tjcuXL8sO4JvbSmm1Wlwul2yp73a7ZYXDbvaUOwhsroCAB+srarWXl5fJ5/Po9XparRYOh4PBwUFUKhUej4ehoSEWFhYOXP/M3WTzfOiJiQkGBwel4mJjY4N0Ok0ymZTjLQ5z6EI0mhCZ5rm5OS5fviwTOAaDQTbl1ev1mEymLXtrcyvCh2OMrVaLarUqe5ru9TruqYXJZrMUi0VWVla4du2aNHibjaTdbue1116jr6+Pt956izfeeAO9Xo/H46HRaMiTS+FRxFgGMTdEq9Xy8ccf4/F4OHXqFP/P//P/EAwGpVwoHo8rh84TENdHnU7HuXPn+Df/5t/IDjW1Wo1vv/2Wmzdvcvv27RdSCXYQEHNsRNnrP/3TP2Gz2RgaGsLhcPDuu+8yNTWFz+djcHBwy956+EDfTKPRIJvNyvk3e82ePhGicL5erz9R4CzmjQBbFk3IgpSH+sl0u12Z+RcJrkajQbFYxO12UywWcTqdWK1W+ctgMFCv13e1X99BQEh+DAaDHIshKkxarRa5XI54PE4+nz9SOl4RUmg0GmQyGWw2G2q1GqfTSSKRkMPmRHJnswe5eX9t/m8xvlhIjITsR3iVu6093fcWplarcfv2bVZWVggEAgwPD6PT6WR9p2gfr/Bs1Ot12WZfZBrPnj2L1WqVHmYmk2FxcXHXRbv7GYPBwMTEBF6vl8nJSSKRCN1ul1wuRz6f5/bt21y5ckU2gz6q1Go11tbWSKVSqNVq7t+/zyuvvEIoFJJ9KJ/m2IyOjvLzn/+cTCbDt99+SyqVkuEMMQRwN+O9+95IigYUOp1O1iKL7Kzdbj/QDU33AhF8z+fzRKNRVCoV4+PjAFJXaTAYWF9fV4zkJnQ6HaFQiEgkIkc2iEYWYi0XFxf3+m3uOe12m1wuh1qtptvtEovFcLvdVKtVOdriaRMEAoEAJpOJbDZLp9MhkUiwuLiIVqslm83u+mz3fW8k4bumn81mk0ajceCn8ikcHDZXLp04cYLx8XGZqS2VSkxPT8tmxgpbY7dCZB8Oh+UIhmq1SrfblXFMMY1So9HIIggxUtbpdDIxMUEwGJR6ykQigdPppFgsEo/HKRaLTx0s9rwcKCMpOoGIFvkKCjuNwWDA7XbLxKEITXS7XdLpNF988QXr6+sHroPUTrF5Js74+DgnT55kYmICu92ORqMhkUhQqVRk20PRAs1gMPDzn/8ck8kka7ltNhter1f2q+x0OiwvL9PX10cymeTzzz9naWlJNt7eqRj6rhtJ0bBCq9XKBp6bx5WKDyrkFqIpr16vx2w2y9GSB22S4U4hRLhiUt3TgtpqtVp2rxEbUbRZE7IOJWnzgM1jY71eL3a7HavVikqlkgd2NpsllUod2dLYzYg+C319fdhsNvr6+ggGgzidTjQaDe12W8YWo9Eo8XhcygD1er0c42u32/F6vbIBr+hYDsikmVarxe/3y9LPnQwN7bqRNBqNnD59Gp/PJ8ebVioV4vG47Gzc6XRkSZ3BYCAYDGKz2ZiYmGBkZEQ+2Iep7OuHoFKpOH78OK+88gqJRIKPPvroqfXCYiZOOBzmzJkzcuQAPEjq7CfpxV4i6rMjkQjvvPOOjEVaLBZyuRy5XI6lpSWuX79ONBo98vFb0bBicHCQP/zDPyQcDssEl7hqp9Np/vqv/5pbt26RSCRIJBKy47larSabzfK3f/u3DA0Ncfr0abxeL2+++SZ+v19+fb/fz/vvv0+hUKDb7eLz+ZieniaTyezYnt1xI/nwrGyj0YjP56Ovr0/WFev1egqFgpQHtNttOVjJZDLJWRfilHlYmHoUEZ622+1mZGREyiaeNt9ZNDq2WCyyh6dOp5MhjXq9TrPZPPLhDLVajUajwWq1bjGQGo2GZrNJqVSiUCiQyWR+0Gzpw4bYV06nk7GxMQYHBxkaGsLv98u9Va1WWV5eZnp6mkKhsEX2p1KpqNfr6PV6KpUKVquVWq1GqVSSo3rFHhfNW/r6+sjlcsRisR21BztqJHU6HW+//TanTp2Sf2YymTh+/Dgul4tmsymV9aIhgLjuCSOp1+sJBoNy7q/D4XikwelRQwTFHQ4HFy5c4LXXXsPr9fL111+j0+nI5XKPrRtWqVSy5jgYDOJyuTCbzSSTSSqVCrOzs6ytrVEsFo90ckytVuNyubDZbIyPj/PSSy/hdrvlFMrV1VW++eabPWkAu59QqVSykcqbb77Je++9RyAQ4OTJk9KwZTIZotEo9+7dIxaLyVEsD4cnRAf0brdLNBql2+3icrkolUoEAgHGx8cZHh6WLRMNBgMnT54kGAzS6XSYnp6mXC7vSIu6HTeSr7/+Ov/6X/9r4MFC6HQ6afSEN1Sv10mlUjSbTRmn1Ol0UlMlZm8rccgH6PV6BgYGCIVCnD59mpdffhmTycTg4KDMFj6pucLmWJHD4cBsNjM7O8vq6iqLi4vEYrEj3TAEHjz8drtdjuk9c+aMTBZ2Oh05vzyRSBzpWKQwkiaTiTfffJP/9//9f7fEt1OpFLlcjnv37vF3f/d3pFIpVlZWKBaLj/16Qp4Wi8WIx+MYjUbW19dxOp288847wIN+BB6PB6PRyNTUFL1ej3g8zq9//Wu0Wq3sV/ki2VEjKQK5drsdeGAkhTxAjH8VkgERtxBt7zUaDXq9XnYVOcqe48N0Oh2y2awczgQPKpPOnj0rNWmpVOqRf6dSqXA6nQwNDcngN7ClRdpRT9iI/RiJRDh27BjhcBiNRiMbwFarVRlP28k42H5GdOMym81MTk7KRioitCZanWUyGeLxOLFYjI2NDbLZ7DPfUMSeFFMYK5UKmUwGo9G4JTm5uYJnp9hxI+lwOAiFQgBSRPrwfGydTofb7X6syHS7biFHlUajwdzcHCsrK7z77rv0ej0ikQh//Md/LLs437t375F/p1KpGBkZ4f3338fn82E2m/fg3e9fxF4zGo288sor/PjHPyYQCGAwGGg0GszMzJBKpbh69Srffvut7MB01LDZbPIm88d//MeybaEwkPBAVD4zM8P169e5d+8et27dolarfS8vb7OR3NjYYG5ujl6vx9mzZ7e8Zqf7oO5K4ka44E/6IJsN52Yj+aQP3+125fiBozBD5GHE9DjRLaVarWI0GvF4PPKU39xEV61WY7FYpObP4/HIRsYioF4oFKhWq0fakxTSKLPZjMvlwufzYbPZ6PV6ciyD8Ij2YrTpfkGv1+N0OvF6vYRCIcLh8COlhiI0IeKMm8ezPLzHxHMvbpgCUSdvtVqlbFDIAsWNU3yfnfxZ7LiR/D7XuIdf86R/k81muXnzJhsbG0dexLu8vMzHH3+M3+/n9OnTst+hy+WSsUmXy8Xv/d7vMTo6yoULFxgZGZEzzUulEr/85S/55JNPZJuvo4rVamV8fByfz8f4+Dj9/f2yzC4Wi/GP//iP3Llzh9XV1SNrIOFB2eDbb79NX18ffr//seEwrVYrr+ChUAifz0e5XGZ1dXWLXErMudHr9YyNjeH3++XfGY1GRkdHsdlsOJ1Oqes1mUxSzF+pVEin0zuqytgVneTzxLse928qlQpLS0vEYrEnBoGPAr1ej2w2y9zcHI1Gg+PHj8tYrmihX61WMZvNnD9/nvPnzxOJRPB6vbIdVbFY5P79+3z55Zd7/XH2HIPBIJNaPp8Ph8NBqVSiWCzKBMTVq1eP9EECD67bY2NjshPSwxNO4YFX7vF4gAfrqtFopORns2RKzOs2mUycP3+e4eFh+XcWi4Xx8XEcDgcajUZ+H3ENr1Qq5HI5yuWyrMjZiZvQjhrJTqfD7Owsn376qVTPAzKL/TBiCpvb7ZYnQrfblZIUEQCOx+N88803ZLNZMpnMTn6Efc/a2hpXrlyhWCzy1ltv4XK5OHHiBB988AGZTIbV1VUCgQADAwNb2nulUik++ugjYrEYa2tre/wp9h7hgU9OTtLf34/L5QIeCOzT6TSZTEaWvx1lLxK+M1LbVWaJ2VQixmuxWKjX64RCoS3qCaF91Ov1DA4O4vV65d893Ky30+lQLpdZX1+nVCpx8+ZNotEod+/eJZ/PU6vVDp4n2W63uX79Os1mE5fLJftCitGQD2MwGHjttdfQ6/XAd7G3lZUVCoUCly9f5ssvv6RQKLC0tCRd7KNKr9djfn6epaUl8vk8f/RHf4Tf7+e1115jeHiY1dVVbty4IeeIDAwMyJhvNBrlf/yP/8HS0tKud1XZb4iEjcvl4uWXX2ZkZIRgMAhAtVolFouRSCSU0bv/B9FsRsQbH4dKpcLlcuF0Oun1ehw7dmxLHPFxydiHE7qbk7ZCGphKpfj6669JJBL88z//M9PT09TrdSqVyo4lcHbUSPZ6PfL5PLFYjEqlIr3Hcrn8WOOm0+nweDxyI4qAuWjbFYvFyGazsuO2Uhny3eYRbbucTidarRa32029XmdoaEgGvtVqtax0WF9fJ5fLUSqVjvyDL5rpWiwW7HY7NptN1meL8SLr6+tHWji+mVqtxvr6Os1mE5vNRiaTkcZNzOAW0xM3G0NRwSQ0zw8naUUCRiRlN8/pFuWL8Xic5eVlUqmUTKDttHe/49ft+fl5otGoLD8Uf/44i69SqfjVr36FyWSSfya6awtXW8QfFAO5lXw+z6VLl4hGo5w8eZKRkREikQgnT55Eo9HIEMY333zDJ598Ioc55fP5I6kQ2IzL5aKvr4/R0VEpbalUKmxsbHDt2jX+x//4H2QymSOfJBQsLS3x53/+5+j1etxutyyHhQfjVkZHR2XZqwjvwIPE2IULF/D5fLIWW9Dr9SiXy1SrVeLxOHNzc2SzWa5evUomk5FCc9F0t9lsUigUqNfrO67I2HFPUhg2hZ2l0WiQSCTQ6XRMTExgNpuxWCyyeYU4WJLJJLOzs8TjceX6+H8wGo3yamixWDCZTBSLRSlgXl5eplAoHOnQzmZEllqtVrO+vr5lNpXL5aLT6WC32ymVSrKQBJB13RaLRU4+BWT3r3K5LLPV0WiUVCrFvXv3ZCfyVqtFs9mkXC7vqoN0IPpJKjydbDbLp59+isfjwWQy0ev1ZB/EarXKlStXiMVifPHFF9y+ffuJIY+jhujM/uMf/5j+/n5Zn724uMj8/Dxzc3Py6neUNaSbEXXWKpWKbre75ercbre5ffu27Ckpbo/w4DC6evUqVqtVtuzb/DVFCK1UKpFKpahUKkSjUarVqryK78X0RMVIHhKKxSLffvstFouFkZER3G43g4ODBINBKpUKX375JXfu3OHevXvMzMwoD/z/QaVSMTAwwFtvvYXT6cRsNsv67Fu3brGysiLDPQoP2DyM6+GyzGq1um1XpGctIdxP+1MxkoeMdrvN8vIy33zzDSsrK0SjUUqlEvfv35e60v20AfcD2WyWxcVFPB6PjK+tr6+zvLxMOp1WYt8vkIO49xQjechoNpt89tlnfPXVV7IktNvtyizhUWzIsB29Xo+lpSU+/PBDgsEgjUYDnU7HN998w+eff06j0VDW7IijGMlDRq/Xo1KpPLFVmsJWRFWSGIEaj8fRarWyJ6cyykJB1XvGHaD0cvyOH/rQKGv4HftpDUVNsNFoxO12o1arWVlZkVft/Wok99MaHlSeZQ0VI/kDUDbn86Os4fOjrOHz8yxrqDRqVFBQUNgGxUgqKCgobINiJBUUFBS24ZljkgoKCgpHEcWTVFBQUNgGxUgqKCgobINiJBUUFBS2QTGSCgoKCtugGEkFBQWFbVCMpIKCgsI2KEZSQUFBYRsUI6mgoKCwDYqRVFBQUNgGxUgqKCgobINiJBUUFBS2QTGSCgoKCtvwzOMblEad36E0O31+lDV8fpQ1fH6UprsKCgoKz4liJBUUFBS2QTGSCgoKCtugGEkFBQWFbVCMpIKCgsI2PHN2W+HooFKpMBgMaDQaTCYTRqORRqNBoVCg0+ns61nUCgovGsVIKjyC2WzmxIkTeDweXnnlFS5cuMCdO3f4kz/5E1KpFOVymUajsddvU0FhVzhQ122VSiV/Kewcer2eQCDA4OAgFy9e5Cc/+QmvvvoqTqcTo9GIWn2gts2usXl/Knv08LDvPUmDwcDQ0BA2mw23243L5SKdTnPz5k0qlQrNZpNOp7PXb/NAo1arUalUeL1eIpEIPp+Pt956i1AohMfjIZvNks/nqdfrNBoNut3uXr/lfYVOp2N0dBS/34/P52NgYIBarcaNGzfIZrOk02my2exev02FH8i+N5Imk4mTJ0/S39/P+Pg4Y2Nj3Lt3j42NDeLxON1uVzGSz4lGo0GtVhMKhXjttdfo6+vjRz/6EeFwmEqlQiqVIpfLUa1WaTQayno/hE6n49SpU5w+fZrTp0/z3nvvkUql+C//5b9w//597t27pxjJA8y+M5LimmI2m3E4HLjdbgYGBujv7ycYDOLxeAiHw5w6dYpgMLglRlatVul0OtLb6XQ6ygP9FNRqNXa7HYvFQiQSYXh4GJ/Ph8FgoNvtkk6nicViRKNRaSD1ej16vR6tVovBYKDdblMqlWi323v9cXYFlUqFWq3GaDTidrux2WwMDg4yODiIz+fDaDSi1+sxGo0YjUa02n33mCl8D/bdT0+j0aDRaBgeHua1117D7/fz3nvvEYlEsNlsWK1W+vv7OX78ONVqlXv37smHeG5ujmq1SiwWo16vUyqVqFQqe/2R9jVarZbJyUmGh4e5ePEiv/M7v4PBYKDZbFIoFLh06RIfffQRyWSSdDpNq9XC5/NhtVpxu90Eg0FKpRLXrl0jl8vt9cfZFfR6PQaDgUgkwvvvv08gEOCdd95hcnJSGkWNRoPFYsHhcKDX61GpVIoi4ICyb4ykCHYLL8XpdBIOhwkEAgQCAfx+PwaDAYPBgNlsxm6302g0aDQaGAwG1Go1xWKRcrlMvV6nUqls8SqVONqjqFQqtFotLpeLUChEMBgkEAigUqmIxWJUKhU2NjZYWVmhWCzSbDbp9Xro9Xr5M3C5XKhUKjQazV5/nB1FeI9qtRqTyYTFYsHtdhOJROTaeb1eut0urVaLVqtFr9dTDOMTEOu5+Xfx598XIUnr9Xp0Op0Xvub7wkjqdDrsdjtGo5Hjx48TiUSYmJjgzTffxG63EwwGMRqN8kEUD7dKpWJ4eBi/38/4+Djnzp2j0WiQSqWoVCpcu3aNmzdvUiwWWVtbo9Vq7fEn3T/odDpsNhtOp5PXX3+dt956C5/PR7fbJZ/P8/HHH7O2tsbVq1eJxWLyqq3RaLBarXi9XpxOJ1arlWazeeCNpDikxb4SelC1Wo1Go8FgMNDf34/NZmNycpKJiQl8Ph+nTp3CZrNht9upVCokk0mWl5eJxWJcvnyZ5eVl4vG4YiwfwuVy4Xa7sVqtDA4OYjQa0el0P2gfFQoF0uk05XKZ+fl5yuXyC32v+8JIarVaeZU+ceIEJ0+eZGxsjAsXLqDX6x95vdjQarWavr6+LRuw3W5TKBSoVqtotVqKxSLxeJx4PK4YyU2INXe73Zw4cYI33niDdrtNo9GgVCpx8+ZNpqenWVhYIJ1Oy3+n0+nkNdJiscj422GQvKjVanQ6ndxfnU5H/pnZbGZgYAC/388bb7zBG2+8gdVqJRAIoNVqqVQq1Ot1NjY2uHv3Luvr60xPT7OysnJkYrXPikqlwmazyZvL+fPnsVqtmEymxz7vTyMej7O0tEQqlSIajR5OI2mxWDh+/Dher5eJiQlGRkbwer0/SI+nVqsxGAyoVCrGxsao1WrMz8+zvr5OPp+nVqsd6U0rrowul4szZ84QDAZxu90A5PN5otEoa2trrK+vs7Gx8diYrk6nQ6/XS4Ny0PF4PPh8Pux2O8PDwxgMBkqlEvV6HaPRiM1mw2QyMTQ0hMPhYGRkBJvNhl6vp9FoUKvVmJ2dJZFIsLi4yM2bN8lkMhSLRemRKnyHSqUiFArx0ksv4fF4mJycxGw2y2Tg98XpdOLxeNjY2CCfzxOPx0mlUmQymRfyfveFkfR6vfzoRz9icHCQEydO0N/fj0aj+UELplarsVgsmM1mXn/9dS5evMiXX37J9PS0fPBLpdIOfIqDgVarRa/XMzAwwO/+7u/S39/P0NAQ8OBE/uyzz4hGo9y6dYvV1dVH1AEiJme32zEYDHvwCV4sKpWKoaEhXnrpJYaHh/nd3/1dXC4XiUSCXC6H0+kkFAqh1WrRarWo1Wq0Wi06nY5ms0mxWKRYLPLhhx/yzTffsL6+zszMDM1mU9HwPgGVSsWpU6f41//6X2O324lEInIvfd9DV3j8nU6HjY0NzGYzq6urfPHFF4fDSIoAuNfrxefz4fP5sNlsjzx87XabXq9HuVx+xLMxGAxSimI2m4HvruMmkwl4EP8Q1/JqtUq9Xj+y+kqDwYDVasXhcOD1evF4POh0OtrtNsVikY2NDVKpFNVq9bHhiV6vR7vdlkmcbrdLrVY70N6SyWTC7Xbj8XjweDy43W46nY6MlXs8HjQajUwKCLlZtVp9xHvJZrOUy+Ujube+DyKso1arKZfLNJvNbSuVxCEFDxQwIn6sVqvlFb1erxMMBmm321it1hf2XvfMSKpUKk6fPs3rr7/OwMAAL730El6vVxo6QbvdJpPJUK1W+fTTT/n0009pt9syiTA5OUkoFOLYsWO88sor6HS6R77X0NAQf/zHf0wymeTP//zPuXbtGuVymVwud6QC6iqVinA4zPHjx7ckH5rNJhsbG9y/f59f//rXZDIZCoXCY79Gp9MhlUqhVqtpt9u0223K5TLVanWXP82LQaVS4fP5OHnyJMFgUColhP5RJHJarRbFYpF6vc7MzAwzMzOkUimuX78uE4PZbFapSHoGut0uX3zxBWtra49ctx/3/KpUKqlw0Wq1mM1mdDodXq8Xq9WKTqfDYDBgt9t5++23yefz3L9/n88+++yFPN976kn6fD6mpqbo6+sjGAxit9sfeU2326VarVIsFpmbm+PSpUtSYqHT6aQe0m6302635abejMPh4NSpU2QyGT777DNsNhutVuvIaddUKhUOh4O+vj5CoRButxu73U4ikaBUKpHJZFhdXaVYLD6xgUWv16NWq1EoFKjX67JU8SAnxYxGIx6PB4fDIePgQm4mbhzNZpNarUa1WiUejzM7O8v6+jrffPONlEeJG89R2lM/hF6vx/r6OqlUCo/HQ6PRwGKxPDFxo1KpZKGIXq+Xt01hWEXXKqFd9Xg8OJ3OF/Z+99RIiviOMGzCuG3eZJVKRUopbt26RT6flzEIjUbD7OysrLrpdDq4XC4mJiZwOByyzZdo+eVwODh+/Dj1ep3Z2Vmy2SytVutInPxCDRAKhTh9+jSRSAS9Xk+9XueLL77gxo0b3Llzh3K5vO2adLtdcrkc9XpdepLi12Gh1+uRz+epVCrE43Hu379PpVIhkUhQrVZpt9t0u118Ph+/9Vu/RbfbpV6v02q1SCaTrKysUK/XyeVyNJvNvf44+xKxXwqFAnNzc9KLfJIEaGlpCafTid1up7+/X8bELRbLY73PF8meXrdFckbEFh7n2VUqFT7//HO+/fZbGUzf/JpisYhKpSKRSJBOp+nr68NgMDA4OIhKpZIVEOIHcOLECcxmM51Oh1u3bm0Roh5mxHqHQiHOnz+Pw+HAYDBQqVT4+OOP+cu//EsZa9tuLbrdLtls9lB74eIzplIpvv32W/72b/+WfD7P6uoqlUqFc+fOcfr0aYLBIGfPnsVsNlOtVmk2m9y5c4dPPvlEGlnFSD4e4eg0Gg3y+Tzw9KSNSqXC7/dz5swZ/H4/w8PD9PX1PeJ9vmjFxZ4ZyV6vR7PZpFKpUK1WH/FcWq2WvNaJmJeoYnj46/R6PXnSAywvL9PpdBgZGcHhcADfGQmXy0W9XicQCODxeKhUKuTz+QN9XXwaGo0Gh8OB2WzeEmtLp9MyOys8w2c1fIfJQIoSTKPRKPeT2HuFQoFSqUSj0aCvrw+VSiUbrbjdblmrbbVaabVa5PN5xsbGSKVSxOPxF67ZO4yIvbR5T6lUKnQ6HS6XC71eLzW5Pp+PiYkJ2RFMJG7hwc8xmUxSKpWk4X0R7Ol1O5/Ps7KygkajkdlSsVDi79bW1tjY2CCXy1Gr1Z74tdLpNKVSCYfDQavVIhAI8Du/8ztEIhHpwms0GsbHxxkaGqJarUoB6s2bN1/oou43jEYjx44dIxgMMjk5STgcJpfLcePGDRKJBNFolHq9fqgM37PS6/XIZDLMzs7SbDY5efIker2eVCrF0tISa2trxONxLBYLv//7v8/Y2BgjIyOMjY2h1Wplf01xIwmFQgwNDbG0tMTi4iKZTEbp5P49EQ6Nw+Hg9ddfJxgMMj4+zvDwsJQMGY1GnE4nJpNJxpFzuRy/+tWvWFtbY3Z29oWt+Z4aSVFrufnKKz5Yo9Egl8tJ4/g0zdnmetlEIkG73ZY9EEX2S6VSYTab6fV6UoB6GErqnoaozxaCaeExpdNpksnkgZfwPC+tVotKpbJlHUT1kYh9G41GaQDD4TBut5teryfjt3q9Ho1Gg9PpJBgMUqlUZBb2sMVsdwrRsk88rw6Hg2AwSCQSYWhoiNHRUSwWC36/H51OJ0N07XZbqg/i8TjRaPSFaqH3NCYZCAQ4deoUoVBIaiOFvGdpaYlf/OIXbGxsEIvFqNVqz6Q9azQaLC0tsbGxwdWrV6X+8vjx4xiNRvk6v9/P+fPnWV5e5saNGy9MeLqfEIkxUZ998uRJRkZGaLfbJJNJPvvsM1ZXV4nH43v9VveUVqu1RT8LyEqbiYkJLBYLdrudc+fOyYa6s7OzZDIZbt++TbfblWJ0kRxrtVocO3aMZrNJPB5nY2Njjz/l/mRzbmJgYEC2RpyamsLpdHLy5EncbjdOpxOHw7HFKIqY7+rqKjMzM2xsbPDxxx+TSCRIJpMv7D3uqSfpcDgYGhrC6XTKDFWn06HVapFKpbhx44YU6D5rAFwYAI1Gw+LiIrOzszQaDcbGxrYYSYfDwfDwMJ1OZ8ufHyaEkbRYLExOTnL+/HnMZjPdbpdCocC9e/dYXl5+oibyqCC8RhHyEd2oTCaT7PAjShZ9Ph+Li4vE43FWVlb45JNPaLVauFwuXC4XTqcTp9NJpVKhr6+PfD5PuVxWjOQTEKoLvV5PMBhkYGBANi622+309fVhsVjk61utlhSfi+TYzMwMn376qZxY8KJb9u26kRQZZ9GFxm63Y7VaUavVspqhUqlQKBSkqPmHJFV6vR7xeFxmsN94440d+DT7G4fDweDgIAMDA3g8HsxmM8VikfX1dVZXVymVSs/soR8l1Go1Xq9Xhn+63S4Gg0EmZu7fv8/ly5dJpVKsrKzQ6/W4c+cO3W6X8fFxPB4PRqORsbExNBoNuVyOxcXFI6GieFbMZjMmkwmn08mxY8ew2+2yMKS/vx+Px4PJZJLOU71el4mZO3fuUCqVSCaTlMtlVlZWWFpaksbzRbPrRlKj0chO2D6fD7/fj8lkQqvVytLDXC7HxsYG6+vrFAqFHxQv63a7zM3NsbGxQaPR4Gc/+9kOfJr9TTAY5K233iIcDtPf34/D4WBhYYHr169z//59mexSHtytaDQahoaG6O/vl3/WarVkl/ZPP/2UP/uzP5OSKRHTnp6e5kc/+hFnz57FarXyyiuvMD4+zvr6Ol9//fWO9Do8qDgcDgKBAJOTk/zhH/4hgUCAcDiMy+Xaop0WSRlhF27dusWf/MmfkEgkSCQScsyx0K7uxIG/Z56k2Wx+pIeckPKI+lfxwX8ozWZTNuE9SptT6MRMJpOsz1ar1bRaLQqFAvF4nEwm81hJlcIDRId8eHDgNptN0um0/FUqlWi1WnKPFgoF2T2o0WjIMEe328Vut8sm0Y+Tux0FROzRbrej1+vlwd3f34/f78fj8WC1WtHr9bLUVegoRQgtk8mwtrYmQ3AilLHT7LqR1Ol0Ms4jvEiRqWo0Gty/f5+bN29y//7959YuigU+atlbcfBEIhHeeOMNnE4nnU6HWCzG1atX+Yd/+AcKhYIy2uIZEPHKRCLBX//1X3P//n1mZmZkjbZQaKRSKUqlEsvLy6yvr+N0OnG73bjdbk6ePMnFixdJJpPcvXuXer2+1x9rVxGxcZfLxQcffEAkEmFycpJjx45htVrp6+uTJcbpdJqNjQ2Wl5cpFovMzMyQz+dJJBKkUimKxSKrq6s0m81dm/2+60ZSrVZjs9lwuVxYLBY5DwQeJG1yuRzRaJRsNvvchk2MbThq8guNRiNjvsFgEKvVKpvCijiaOEAe5nGloUeBJ31e4c2Uy2WWlpa4e/cumUxmy7VOdJcSnW0qlQoGgwG3241Op8PtdhMIBGi1WodebvY4hKzHYrEwNDTEsWPHOHHiBMePH5eZbdGjoVqtks1mZcOQO3fukEqlZMZa1NHv5v7cNSMp4gsWi4WTJ08yNTXFwMCA7CZTq9VkE4tr166RzWZfaHxB1IaL7KX4s8OGRqMhEAjIGdo2mw21Ws3c3ByJRILl5WVqtdqWq7Yo3RRNA0Q1VKfToVqtbiviPwwIQ7h5TUTCJhaLcePGDdbX11leXpYdqR73NXq9HrFYjK+++opQKCTbrAkBdL1eP5JGMhwOc+7cOYLBIC+//LKcKrm5GU2n05EaR5EYKxaLRKNRKpXKlp4Cu32A76qRFI0mpqamePXVV2X38VarRalUIpvNMj8/z/Xr13dkITZ7SYfRQMKDUzsYDDI6OiqTNZVKhbm5OWZnZ1lbW9tSny06qIhGukIkLcb0ihK9w8zDEiD47hayvr7OZ599JiU/T9LTitcnEgm++eYbBgcHOXfuHF6vV3ZeyuVyR3K8bDgc5kc/+hHBYJCXXnpJDpvbjDCSc3Nz3Lhxg08//fSZikh2g137iYkWR6KThwjSAjLmI7r5HLWr3otErVbjcDjw+/1SfNvtdimVSlI/5nK5MJvNsn+iqMIRs2s6nY5shXbv3j2y2ewef6qdQyQL0+k0iURCdvARRm9lZYVoNEoqlXqmGJhIForWXvBg71utVoxG44E5nEUcUXjUwA/24kQiplKp0Gq15OygzeNZRA/PSCRCLpdjamqKfD7P8vLynte/75qRtNls0ruJRCIEg0F59SgUCnz99ddEo9Edq/7YXPZ4mPVqYmb5xYsXGRoaQqfT0Wq1iEajzM7OotfrOX78OKOjo/zu7/4uXq8Xm80mW8ppNBopd6lUKvz3//7fX2gd7H5E6O2y2Sw+nw+PxyP3yI0bN/j8889lTPdp1Go1EomEnCK5eejV2tragbluizZkIrMvfv8h8f1iscji4iKNRoPTp0/jdDoxGAxbuvfodDpOnDjBxMQEx44dY3JykpWVFf7rf/2vzM/Pv8iP9r3ZNSMp6l/FdD0hEhX1r8Vicce78Tyug9BhQcR8dTodVqsVt9uNyWSi1WptubJYLBacTieBQIBIJILX65V1x2J8arvdlnXuJpPpULdFA+Q1W8ijNkvGkskkhULhmTOpIrGwOfstGmHo9fofNNxuLxAjLUSvzE6nIw+K75sMFc+32Wwml8vJXq9CHy36KojKGo/HQyAQoFKp7IvwxN6/A74bA5vP53ctrX/YMBgMBAIBXC4Xk5OTTE1NUavVuH//Pvl8nuHhYcxmM2NjY4yOjsqu27FYjNu3b7O2tobZbMZut2MymYhEIlKWcZgNJHyXdBH17JubuObz+e9lEBqNBtlsFq/XK5tmiFEDTqdTGsvn1QDvJCqVildeeYU/+IM/oNvtkslkqNVq3Lt3T8Zlv8+o3GQyyVdffYXVaiUajUpplNfrJRwO88477+BwOKR0TSTS9ost2DdGUqT/D3Nfx51E9N7z+/2yekE0r6hWq3i9Xux2O2fOnOHMmTNUKhXW1tYoFovcuHGDa9eu4XQ68fl88jrkdDqPhHxKaB1LpRIzMzPP9bWEUkNIgsSYEavVitlsltUke52MeBpjY2P85Cc/kQepGNolkp5ra2vP/LVKpRKlUgmNRkMsFsNoNMoRIlNTU5w7dw6z2SzDPd1uVwr198MBvS+MZLPZZG1tjZWVlRcWpBVDr4LBIMeOHZPxDyEj2NjY4M6dO6yurh7YIVab0Wq1srJDdFQSyZlGo4HX65VtvxYWFkgmk1y9epVsNitLFAHZ3FTMrjkKRvJFIoykyMwKbaSY4SJ0wfs9gdNut6nX61IEbjQaMRgMsqP490U00bVarVitVkZGRpiammJwcBCbzSZnuIvRGbOzs0Sj0X3xbO4LI1kul5mdnWVmZuaFnbBqtZrJyUneeOMNxsbGMJlMUv/XbDZZWlrik08+IZlMUiwWX8j33EuEaFl0yoYHybKRkREAaThv377N9evXmZ2d5S//8i/JZDIyIN/pdLDZbOj1eqrVKgaDQTGS3xPhAYnmIc1mE5vNJpu5iFLc/XKVfBKi246QL7XbbSwWyw+aCSXkf3q9XpbJnjt3jvfffx+HwyE7jIsYbiKR4Ouvv5YJtb1m14ykTqeTPeEeHtwjZjm/iAdS1IcajUaCwSDhcBiv1ytV/YVCgWKxKOs/S6XSvr/6PAtCgyoGI23emN1uV3qF6XSatbU1EomEDMQLEbnD4cDtdmOxWKQU67BrJHcCIZsRGXJRyCBkNaIMdz8jPEYh1xFzqESjW8HD/y8Qc7HFvrTb7ZjNZoaHh3G73bL93GbnpVQqyaqwXC5HsVjcF4f0rhlJv9/P66+/TigUwuVy7dj3sdvtvPvuu4TDYd58801eeeUV2Uyj0Wjw1VdfMT09zY0bN5ienpZjUQ86JpOJoaEhBgYG5GherVaLyWSiXC5z69YtkskkH330Eb/+9a9l3MxoNMqxvqKmtl6vc+fOHbLZLKurq/siLnQY0Ol0OBwOisWibPK7XxFNbfV6PZ1ORxo9g8EgjbwwgCID/bDxFPKy8fFxXnnlFZxOJ+Pj47Lnpt1ul4ULtVqNL7/8koWFBW7dusXt27flHt1rds1Imkwm/H4/fr9fzsp9kYiT2mg0Eg6HGRkZYWBgQA5v6vV61Ot1WTwfj8cpFAr74qR6EYiYpMPh2KI/U6lUdDod0uk00WhU9t4Ta2U0GnG73YTDYUKhED6fj3w+Tz6fP3KDrIT3LQT4P1RTK/bi5jHJAp1Od2A8yYd1kcJICkOpUqlkg5qHP6cYuudyuejv7+fEiRO4XC7GxsakcRQ3lWq1SqlUIhqNMjc3x9raGrlcbt8kcXc1JqnT6aTbvhmh79PpdHLmzff5mhqNRg4LCoVCvP3227IFU61WIx6Pc+XKFdLpNFeuXNkyoOmgo9fr0ev1uN1uOSxJDGbP5XKsr6+zsbHBr3/9axYWFlhfX8dutxMMBmWHINGmqlAo8MUXX8hZyNls9lDEa5+GaN3n9/t57bXXsFqt3L9/n1gsJg+LZ90rImwRDAZxOp2yobQwBuIA2i8G4EnUajXS6bTsrWA2m7lw4QIej4d4PM7p06fp9XoEAgGsVusjB4JarZZVRmL8q0j+iIx5PB6XZZy5XE72f324gches6ti8iedosKV1+l0W8qgnsbmfzcwMMBbb71FX18fr776Kn19fbI5w/LyMn/9139NLBZjeXn5UJXZie4qHo+H4eFhRkdHMZlMwINKppmZGVZXV/niiy+4f/++zC4ODw/ze7/3ewQCAUqlEtVqlWvXrvHVV19RKBRYW1s7Mq3UxOS9sbExfv7zn+PxePjFL37BtWvXWFtbI5lMPvOeFDcmn8+Hw+HAarVKpUC1WqVYLMpelPuZer1ONpvFaDRKVcTp06c5deoUqVSKkydPotVq5djmh8sMYev1e3PfBFHjfuvWLWZnZ/mLv/gLMpkM9Xp9X67Lvshum0wmBgcHabfbJBIJ8vm81K5tRuioxEwMvV7P0NAQXq+XY8eOMTo6it1up1arsbGxIetuZ2ZmSCaT5PP5Qzcs3mAwYLPZsFgssnJGZPCF6DeVSuHxeBgbGyMQCODz+RgeHsZms6FSqVhdXSUajTI/Py/nhhyWMMSz4PV6GR8fZ2RkRCa+KpUKqVSKQqHw1Ou2SqWS400HBgY4efIk/f392Gw24IFXls/nKRQKUha0n28xvV6PVCrF3bt3KRaLDA0Nyey28AZFI2fRQepxoQWxbs1mU45f2NjYoFqtcvv2be7cuSNlPvt5TXbVSD4pxuN2u3nvvfeYmJjgs88+Y3p6Wi7s5tfq9XqZhBEtqH72s5/x0ksv4XQ6CYVCNBoNFhcXmZmZ4R//8R/58MMPqdVqZLNZKXM5TNhsNvr7+2XfSIPBILP29+/f59NPP6XdbnPq1CnefPNNJicnmZyclKVy5XKZjz/+mA8//JB6vU65XN6xNvj7EbVazYkTJ/jpT38q+z6KjjS3bt2Skp7t0Ol0si/BxYsX+Z3f+R1sNht+vx+VSkUqlWJ+fp6lpSWZwd3vybC7d++ytLTE+Pg4Xq+X4eFhRkZGCIVCWCwWhoeH5U3uSfFVsY8KhQKxWIxMJsNHH33E2toa8/PzzM/PywTRfp5NvmtGUgSCRbH85gXR6XT4/X56vR5+v59EIiHHfG5+ncViwWKxYDabZWVIOBwmHA5jMpnksKZcLkcikSAWixGNRuUExsOITqeTp7tIOmw+iERTU6FPE+smOrNks1lSqZS8Uu7X03wnER2qrFarlKeJxIuQUW1e081rK6Yq+nw+mfwKBoNytrnwIpPJpExG7FdjsBmh+hDdkURIwmKxyNCZSqWSN7PNYTJRKSN6BmQyGRKJhEweCgnaQRnjvGtGMp/Pc/v2bbLZrLwiC5xOJ6+++iqVSoX+/n7W19e3eDUCUVEiguzimu52u8nlcqysrJBIJPibv/kbVlZWWF5e3tdu/PMimlCIumARinA4HJjNZl5//XUikQjdbld2gc9ms1y7do14PM5XX31FNpvl7t27R8ZzfJher0epVGJ9fZ1utyvr2k+fPk2pVKJQKJBMJmm321tE9+12G5/Px/nz53G5XFy8eJHh4WG8Xq+MQ4pKps8++4wrV66QzWYPXJx3Y2ODP//zP8fpdHLu3DnGx8dlV6PNzSdErXWlUiEWi8nDQSSrkskk9Xqd9fV1qtXqgVqHXTOS1WqVeDyOWq1+RB9mNpsZHByk2+3icDjI5XKyU7kwcCqVCofDIQ1AIBDY0kkolUoRi8VYXV3l5s2bzM/P74uGnTuNSNyYTCbp/Qhpj81mY2hoSLbGbzab5HI5VldXWVhY4JNPPiGTyeybGtm9otFokM/nsdvtsglxOBzm2LFjZDIZ1Go1zWaTarUqjWWz2SQYDHLmzBnZcXtoaEjG5qrVKuvr60SjUW7fvi2nJR60/Vgul7lx4wY6nU7ePrxer2zcIRCGL5fLMTs7K0e+ikTVQVaT7JqRrNfrJJNJ9Ho9lUqFZrO5ZSIdINslqVQqWq2W1FMJTCaTLOtqtVrU63Vu3bpFNBolkUhIaY+YBHjQNuT3RbT3WllZwWazyeC4qKQRlUW1Wo1YLEa5XGZxcZHl5WVSqRSVSkUZcwpyLrZoMqvX6xkdHZUx25MnT0rjKAxdu93G4/Fw8uRJebsRfTjX1tZIp9N88cUXcsb5QV/nbrdLPB6n1+thtVpZXl7e4kmKg0P00xQ3wVqtJjvcH1R21ZMUnUOKxSK1Wk02ehUIb3Gz2HQz4pQWXYMKhQJ///d/zyeffEKxWCSbzUojcVhjkA8jTmir1SqHswut2fLyMjdv3iSXy3Hz5k05CrVUKsmg+kHevC8C0SLt9u3bUqdrsVg4c+YMJ0+efGJn7l6vJ1UW8F0Gd2FhgY8++oh4PM6HH35IPB4/FAnDTqfD0tISKysrW+ZhCx6eDST++zA0uN41I7nZsC0tLcnmr06nc0uFglDzi4SDqOsW9cfi2iMkPfF4nGw2K1utHYYN+X1otVoyez87O0uxWJQyqlgsxvr6OsVikVwuJ/WQh00G9byIkQuZTIaFhQUajQYmk0lKqkQGV/y/8CZFSZ1IToiJimLcQ6VS2feNLL4PRzWxp+o9o5l/3jJCkREzGo0MDQ3hcrmYmpri1KlTsseeTqdjeHgYv98vu2t3u115ZYxGo0SjUWKxGJcvXyabzbKyskI6nd6ycXf6B/lDT8adaI8lQhYWi4W+vj4MBoPU4gkBs5h6KJJY+2Gj76c11Ol06PV6XC4Xp06dwuFwcOzYMfr6+rDZbHi9XsxmM0NDQ9hsNlmkUC6XWV9fp1Qq8c0337C0tMTGxoYcVVAsFne10/6zst/btO0mz7KGuyoBEjKghYUF9Hq9rDcWlThiYJKQXJhMJjqdDsVikUqlwsbGBmtra6yurnL37l1yudyhO62/L5vXVQz6Uvh+tFoteYBMT09viYsLuZTNZsPtdqNWq+VQq0KhIL32+fl57t+/T6FQYGNjY18cRAovhl3zJDd/HXGd9vv9hEIhWdKk0Whwu92yp6EYRFQul2m32+TzeXltFFPt9iJBo5zgz89+XEOtVisrbsQoWFHXbTAYZPNZMTeo2WzKkSOiKUO9Xn9E37tT7Mc1PGg8yxruupF8nu+1XwLAyuZ8fg7iGj7ue+/lnjyIa7jf2FfX7e/DfjGGCgqbUfbl0WR/N7VTUFBQ2GMUI6mgoKCwDYqRVFBQUNgGxUgqKCgobINiJBUUFBS2QTGSCgoKCtugGEkFBQWFbXhmMbmCgoLCUUTxJBUUFBS2QTGSCgoKCtugGEkFBQWFbVCMpIKCgsI2KEZSQUFBYRsUI6mgoKCwDYqRVFBQUNgGxUgqKCgobINiJBUUFBS2QTGSCgoKCtugGEkFBQWFbVCMpIKCgsI2KEZSQUFBYRueeVqiMobyO5RRns+PsobPj7KGz8+zrKHiSSooKChsg2IkFRQUFLZBMZIKCgoK26AYSQUFBYVtUIykgoKCwjYoRlJBQUFhGxQjqaCgoLANz6yTVFBQ+I6HtYbK0NHteVZt5n5cR8VIHgH0ej39/f1YLBaq1Sq1Wo1Go0Eul6PT6Wz7b00mEwaDAYBOp0Ov16Ner9Nut3fjre871Go1r732Gq+++iqVSoWVlRUqlQozMzNsbGzs9dvbVxgMBrRaLT6fj9HRUcxmM5FIBIvFQqPRoNls0mw25X7K5/NUq1UajYb8PR6PU61W9/RzKEbyCGA0GpmcnCQYDJJKpchkMuTzecrl8lONpNlsxul00uv1aLVatNttOp3OkTaS77//Pv/hP/wHkskkH3/8MfF4nHK5rBjJTahUKoxGI2azmYmJCX784x8TCAR44403CAQCFItFCoUCtVqNTCZDrVZjcXGRVCpFoVAgmUySz+cpFovUarU99TD3vZHU6XT4fD5MJhMmkwmz2Uy5XGZ9fZ1Go0Gr1Xrqg35UMRgMmM1mHA4Hfr8fv99PqVSSnmS3293236tUKhwOB/39/fR6PTqdjjSU9Xp9X16NdgOtVovRaMRqtRIIBACw2WzodDq63e6R3o86nQ6r1YpOp6Ovrw+Px8PY2BjhcBiPx4PVasVoNNJut+l2u+j1enq9Ho1Gg0ajIZ9vl8tFKpVibm6OSqVCq9Wi1WrtyWfa90bSbrfzW7/1W4yMjDA+Ps7Y2Bh3797lP//n/0w0GiWdTlMul/f6be4rRPzH4/EwMTGBz+fj1VdfJRQKkUwmiUajz3RlVqvVHD9+nPfeew+NRoNWq6VcLvNXf/VX5PP5I2sQer0evV4Ph8PBxYsXyWQyfP7559y9e5d6vU6lUjmSB4hKpcJut3Pq1ClcLhdvvfUWk5OTeL1eBgcH0ev1WCwWer0eRqMRvV5Pt9vF4/HQ6/UYHR2VN5VOp8Py8jLRaJRerydvP3vBvjeSWq0Wr9dLJBJhdHSUEydOUKvVsNlsGI1GtNp9/xF2Ha1Wi0ajwWaz4ff78fl8OJ1ObDYbarWaWq1Gs9l8pgdZr9djt9vR6/WYzWYsFgsOhwOz2Uyz2aRWq+3CJ9ofqFQqNBqNPIQ0Gg12u512uy33okaj2eN3uTeIQ9RsNss9NzAwwMjICHa7HbfbjVr9QEzT6/VQq9Xy//V6PQAWi0V+vV6vR61Ww2w2o9Pp9vQ5PzAWptfroVKpUKvV6HQ6jEYjFovlyG7KJ6HVajl+/DjhcJipqSneffdddDodlUqFeDxOPp+n0WjIJMx2dLtdbt26RT6fp7+/nzfeeAOj0cibb77J5OQkd+7c4dKlS0ciPqnVanG73VitVux2OwCtVot8Pk82m6VarR7Z0I9KpaK/v5+hoSEGBwf5yU9+gt/vJxKJ4PF40Ol036vzULVapVwuk81m5WEuDKv4793kwBhJQBpJjUaD0WjEYDAoRvIhNBoNAwMDnDp1ivPnz/Mbv/EbNJtNPvnkEzKZDOVyWcaDnkav12NhYYGFhQVOnjzJmTNnMJlMnDhxAq1WS6vV4ssvvzwSRlJ4jU6nE7PZDDzI9pfLZUqlEvV6XV4Tj9JVWzyTXq+XEydOMDY2xttvv43f7//BX7PValEsFikWi1sOHmFoFSP5DOj1ejweD9VqlWg0utdvZ1+hVqsJBAJMTEwQCARQqVTU63WWl5eZmZkhlUr9oE1WLpe5f/8+6XSaqakpXC4X/f39XLhwgXw+z/Ly8p5LNXaSbrcr5SrNZhN4sNYGg0FKXcQVUqVSHWpDKW5zBoOB/v5+bDYb586d49y5c4RCIYxG4xP/rTigc7kc+XyeTqdDo9FApVLJxE673cZsNhMIBHjzzTcZGhpifX2deDxOo9GgUCjQbrdldlyoLXZqzQ+kkTSZTAwPD6PT6Zifn9/rt7Ov0Gq1TExM8Pbbb2OxWFCpVJRKJb766iu++eYbstnsD9pMyWSSX/3qV3i9XgYGBvB6vZw9exaLxcLa2hp/8Rd/ceiNZKlUkg81PPAuheZP3GpEnO0wo9PpsNlsuN1uPvjgA0ZGRjh16hRnz56VxvNxdLtdqY+cnZ3l9u3b1Ot1stksGo2GCxcuMDg4iNPpxOfz4Xa7GRgYoN1uc/fuXWZmZsjlciwsLFAqlZienmZjY4NarSaTtzthKA+kkVSr1ej1euW6vQmVSoVWq8VgMGAymbBarXS7XbLZLJlMhmKxSKlUkg/496XT6VCtVqUh1Ov1WK1WvF4v5XL5SCXQxIMo1lwkbI5Kx2+9Xo/T6cTtdhMIBAiFQtILfNwatFotarUarVaLXC5HrVZjbW2NWCxGrVYjl8uhVqvx+/2oVCoajQYmk0nuMY1Gg9frpVAoYDQaqdfrlMtlKpUKRqORdDpNs9mUmfEXbSgP5M4W1xyj0XgkTu5nwWg0EggE8Hg8eDweTCYTc3NzXLp0iVgsxsLCAvl8/gfHD7vdLu12m3a7jcFgwGazodFo5Cbe7op1GFCpVPIA0ul0wANPUuh3dTrdkfEkQ6EQ7777LsFgkDfeeIOhoSFsNtsjBrLb7dLr9YhGo9y6dYtsNsvVq1dJpVIkEgkSiQTdbpdWq4VKpeKbb77BbDYzNTXFG2+8gd/v59VXX5W3F4/HQ6vV4uLFizIeXK/X+eUvf8n/+l//i3K5TKFQeOF6ygNpJMUJflQ25bOg1Wpl5lU8tOVymbm5uS1Z7edBnNDCYxWSGJvNdug9SfFZRezx4T9TqVRHxpM0m8309/cTDofp7++nr6/vsa/r9XoyTLGyssLGxgbXrl1jfX1dJmY2I9av0+kQDodptVrU63UArFYrVqv1sd8nGo3KWGapVHqBn/QBh3tnHwFEtt/n8/Huu+/S19eH1+ulVquRTCa5d+8eqVSKSqXyXN/HZrMxOTlJIBAgEAhgNpuJRqNcv36d5eXlHdmc+wmdTkcoFMLn8+FyuVCpVDI+uVn+c5gTNgJRcaTT6Z7opPR6PSqVCrVajYWFBT777DOy2SyxWIxisSgPbHHQ6HQ6RkZG8Pl8jI+PMzg4iM/ne2J8czNDQ0P85Cc/IRaL8dFHH7GxsfFCpUKKkTzgiA3m9/t5//33GRwcxG63U61Wicfj3Llzh1wu99xXELvdzokTJwiHwwSDQaxWK8lkko8++ohEIkGhUHhBn2h/Isrs+vv7cTqdwHdx2kqlQrPZpNPpPJO06qCyWUQvwl1P8p57vR7lcpl8Ps/c3ByffPIJhULhEeOlUqnQ6XSYzWZOnTrFiRMnCAQCDA8PY7PZntlI/st/+S+Zn5/nxo0bpNPpF3pgHUgjeVSuNc+COIn1ej02mw273S5riHu93nMHs0VIw2Kx4Pf7ZQlZsVgkn8+TTqelJOMw0+l0KBaLZLNZeQVstVoyMXYUvEmhiTQajbhcLpxOp6yW2Yyo88/n8yQSCfL5PK1Wa8sBsrlCJxAI4HA4GB4eZnBwEJfLhcvlwmw2PxLGEVd4sbe73S6VSkUmJndCCnRgjKSI+SgGcivCQFosFoLBIJFIZIu4WSRbfiiiSUZfXx8XLlzA5/PRbDZZWFhgZmaGO3fuyGvVYabRaDA7O0s8HufVV1+l1+tRKpW4c+cOiUSCWCxGuVw+1J6kMGxut5upqSn8fv8jcUJhIBuNBnNzc9y+fZvZ2dlH9qDFYsFms9Hf389v/MZv4Pf7eeWVVxgdHZW3I6Fi2Uyn05F9B4RaY2FhgZs3b7K2tiYN5YvkwBjJhxGnyWHelM+CODg2VyHVarUtsR6dTve9T1jhNYguQk6nE5fLhcPhkGVjQoZRrVYP/c9BtIoTJZ3wQBhdqVTkw3rYSxLFXtNqtej1+ifGJMVzWalUpORH7Efxy2az4XK58Pl8hMNhGet2u92P/d7tdlvKfMrlsiwJrdVqpNNp2QBjJ240B8ZIilhGr9ej2WySy+XIZrN71j5pv6JSqWRTgIGBAS5cuEAqlWJhYUHGhJ6GVqvF4XBgNBp54403uHjxomwwotfrmZubI5VKUSwWd0ybtt8wmUycOXOGvr4+BgcHj+SNRlxvk8kkN27cIBgMcvr0abxer3yNMJDiAMnlcrTbbVwuFzqdjomJCVwuFyMjI4yOjuJyuRgfH8disTzRQHa7XW7fvs29e/col8vE43FqtRobGxsySy5CHg9nzF8EB8ZIbqbT6VCpVOSJorAVg8EgSzeHh4cxmUzE43G5gZ5m0NRqNVarFZvNxqlTp/jggw+w2+0Eg0F5hd9cEnbYDSQ8EFAPDQ0xOjqKz+c7kkay2+3S7XYpFAosLy/TbDYZHx9/5HUigSXaxnU6HSnhmZqaIhKJcPr0aU6dOiU1t9tJ+Xq9Hmtra1y5coV8Ps/S0hLlcploNLor7dMOpJFsNpsUCgUKhYKsoz2qdDodms0m6XSab7/9llQqxdDQkGxX9eqrr5JMJmk2m6yvr0sR7+MIBAIMDQ1htVoZHR3F6XRy8uRJXC4XrVaL6elpKpUKV69eZWlpiZWVlSNzxdTr9bLCZHNLL4WtiGy1wWBgfHxc6iTT6TRGo5FTp07h8XhkjbfQmG5GeKK1Wo2VlRUKhQK3bt1iaWmJUqlEKpWS5Y27wYE0kq1Wi1QqJd3uo0yr1ZJVDX/zN39DMBjkpz/9KS6Xi4GBAfr7+8lkMlitVpaWlrh06ZLUkQnEJh0bG+P3f//38fv9XLhwAa/Xi9lsxmQysbS0xKeffko8HufSpUssLCxIL+EwI2JwJpNJhhzcbveR9CSfBWEkNRoNr7/+OufPn5eicI1Gg9vtluXEoqT44bUUBnJjY4N/+qd/Ynl5mTt37jA9PS2/lvBqd4MDYSSFYHpzqyTh0h+Fq97TEI0DRIefjY0NUqmUnE8jxgw0m036+/sZHByU9bSiS7ROpyMcDm+pwzUYDFQqFTKZDGtra6yvr5NMJslms5TL5Wdu3HsYEN6NkLIclc/9OETypFwuy4SV6H4kEFIhrVZLp9PBaDSi0WgeK+sRBq9SqVCv12XDimQySTwelzIikdXeyY4/j2PfG0m1Wi0bNjxOk3XUEQ+suJKI7uHr6+uMj4/z5ptvotVqeeWVVzh37hxnzpzhJz/5CalUilu3btFsNhkdHcXv9zM8PMzZs2dl9/JYLMann37K5cuXyWazzM3NUa1WZTzysGe0AVlbXKvVWF1dxWQyYbfbGRwc3Ou3tmek02m+/vprGVt0u91y6NdmREfxbrcrhecPN6QRkp5arcbnn3/OzMwMhUJBJmXu3btHPp+XBlRpuvsYhPuu1+uVjj9PQGT8M5mMrJMVB0utVpNCcFHfHQwGWV9flw0CRDBdyDBE09NCocD8/Dxff/21PNmPYqJM3FxE9vR5a+APOvV6nWQyiU6nk9MMH1e7L+K5T0vKCF1lNBplZmaGTCbD+vq67Be71y349r2R1Gq1+P1++vv7cTgcSizoKXQ6nS0B7lQqhd/v5zd+4zeIRCIYDAY8Ho88dNrtNn6/H7vdTqlU4vLly+Tzedmt5c6dO7IV1WGPPz4OtVqNVquVA67Onj3LwMCAvF4exQIHYSRbrRYffvghCwsLvPzyy7z66qvP1XBGrGWz2ZQNWfZDJdeBMJI+n49IJHLo23G9CDqdDisrK6ysrDA/P8+tW7cYHh6WncqNRiM2mw2Px8PQ0NCWq8v169e5cuUKsViMX/ziF8RisT0d5bkfEBVNdrud06dP89prr20xkIKjZCjr9Tr1ep1SqcRHH32E2+3GbDZz8eLFH2QkNx82KpWKVqu1rwT6+95IPryAR2kzPg8qlQqLxUI4HKavrw+TyYRarZZjCISHJEYNiDK75eVlEonEkR5stRmxNiLjWqlU5MgGkYiwWCyyhdpexMz2CqFXVqvVrKyscOfOHex2O5FI5JnzByJOaTAYiEQi1Go1rFYrWq2WarVKLBaTestqtbonVXb73kgKFOP47IimFIODg/zWb/0WoVCIYDAoSxZrtZocIi8e7G63y8rKCr/4xS/I5/NUq9UjIxTfDhEzazabxONxVlZWpAZVr9cTCAQAcDgcGAwGmQE/CrTbbal2+Pjjj8lkMoyPj/N//9//t1yXpyEaFxsMBt577z1ef/11UqkUsVhMzjNPJBLMzc2xuLgo11fJbj8Dm7uBKHyHED7r9XocDgeBQACv14tGo6HZbMr2VaKru16v33LNEc0qFAP5AFETr9frt3Se2fz34lA6ajcdUc/e6XRkDNzv93/v24fwJsWoXr1eLzsEiYa+qVQKo9FIq9VSJECCzV2fRVZbyDHq9TqFQkGOnFT4DjF3e2BggPPnz3P+/Hn0ej3xeJzl5WWuXr3KjRs3CIVCvPnmm7jdboaGhvB6vXi9Xk6ePEk6nWZ5efm5G/UeBvr6+jh37hzhcFg2hRVSF9EqbfPc7aMgi9qMOEytViv9/f34/X453uKHYjKZCAaDUuNbKpXo6+vDZrORyWS4f/++PMh3Y733vZEUInKVSkW325W1w/V6nWq1ui+yX/sJtVpNKBRicnKSY8eOMTg4SLvdJhqNsrGxwbfffsuvfvUrRkZGCAQC9PX1yQFMVquVvr4+tFot8XhcMZKA0+lkamqKYDAoVQAi3rY5TtloNHa1CmS/IG50RqMRt9uN3W5/7pEq4iZkt9ulZ5rJZEgkEuj1epaWlnb1QNq3RlI09nS73XJmi7juNBoNSqWS0uBiE0LaI8YsnDlzBr1ez+XLl6lUKly7do1kMikF4eVymXQ6jcFgkE1kxYA1nU53pK6N2yFmTIsr4OYZN5VKhXv37hGNRsnlckfOQMJ31XA2m41AIIDL5XpEMynE+OVyWY6FFYbQarUSDoelSP9xChaVSsXg4CCvvvoq8XgctVpNPp9nZmZGltju5NrvWyMp3Hcx/NxgMEjdVK1Wkx2hlbjZA8xmM+Pj4/h8Pl577TXefPNNrl69yt/8zd+QTCal7lGUdeVyOdbX1+n1elKsKwZ8GQwGZcDa/2HzZE6xNuIAyWazXLp0iaWlJZLJ5JHbi5tH6rrdbgYHB/F6vY9ct8W8pVgsxp/+6Z8yMzOD3W7HbrfLprsej4eRkZHHGkm1Ws2JEyeYmJggkUgwODhIIpHgz//8z8lms4/EiV80+9ZIPszD0golafMA4eW4XC76+/tlzEz080smk6RSKUql0iPNQB72jIAjl3x4Fp4kQet0OlItcFTDPsKTFPpbi8XyyAG7WSFQKBTIZDI0Gg1ZqbO8vEyxWESj0VCv12WjZ7VaLb+W2KtWqxWfz0e328XhcGCxWGRN906xb41kq9WSna9FBu0oXmeehtfrpa+vj2PHjvHv/t2/IxAIUK1W5WiFq1evUiwWKZfLW/6dwWAgFAoRiUQeqblVeDY2DwI7ikZy8yzyYDDIxMSEVAJsZnPCNZVKsb6+LhOyCwsLTE9PYzKZGBsbw+/3c/78eX70ox9hNptlYwyBw+Hg9OnTZLNZvv32W3K5HIlEYkd7CexbIynij0rXle0xmUyyz+Ho6CiBQIDp6Wk2NjbI5XJkMpnHJmC0Wi0WiwWr1frI9UhZ6ycj1mazd3QUs9qwNblqMplwOBxPnL8u4obCgxQUi0UZo2w0GqTTaXw+H/V6XYZ/NqPT6XC5XKjVapxOJ06nk2KxuKO3n31rJMVDLForaTSaI1/98TAqlQqv18vU1BQjIyNYLBZUKhWJRIK7d++yvr7+xIfXarUyMTHB0NCQHJHaaDSktEpZ6yezsbFBMplkcXFRXrWPopF8VoQRNZvN2Gw2HA4H9XqdRqOxRXsquucHAgFu3bqF1+tlcnISh8Px2K8ZDoeZmJiQQ8d2as/uWyMp4hyiJ93D/eoUHuDxeDh27JjMEKrVapnFTiQST9w4FouF8fFxRkdHZdWNqJk9qtfHZ6HX65FKpZienmZ5eVkaScX7fjLiWRZG0maz0ev1thhJeHD4APj9fqanp+U8occZSSF1q1QqxOPxo+lJCpSa7Scjhn55PB6cTqfs3Vcul0mlUpTLZfnwijU0mUyPXI1E89R0On1k5mg/CyJ7K/oiij0oihlEZ/ajaiDFwarRaEgmk8zMzGCz2QgGg1viklqtFqPRKNv3Wa1WKTvT6XRSeyqaPZ8+fZqBgQG8Xu+2NeCidZ34WjvFvjeSm1GM5aN4PB55JRFxnVgsJufRCE9SZCHFbO7h4WEMBgPdbld2HJ+enmZ2dlbRn4LMrOr1ekwmk0wgiAbHq6urJBIJKSI/inS7XWq1Gs1mkxs3bvBXf/VXDA0N8du//dt4PB75OqG+qFarBINBwuEw9XqdTCaDzWbj+PHjeDwe3nrrLSYmJvD7/QwNDcl58o+j0+mQTqdZXV0lm80eTQmQEPFuPsE3z95VeICYrb15nUSjU/H/opW+CHqHQiHcbrcU6Iu6WzHH+KgPV4PvjKROp5NzfoQcpV6vk8/nKZfLR9ZACkRStVQqEY/HsVqtj4x0EAkeIR632+14PB4qlYocCubxeIhEIvT39+N0OrHb7Vvm4AhEJ/NSqSQbQx9ZT9JmszE8PEx/fz8mk4lerycF0KLPocKDK0c6nabb7eL1etFqtUxOTvLOO++wsLDAl19+iU6n48yZM/h8Pl5//XVeffVV3G43DoeDVqvFtWvXuHLlCrOzs8oBxINDRojHw+Ew586dw+12y1ja4uIiH3/88WO1p0eNbreLSqUiGo1Kbe6bb74JPCjp3CwvE7PLxTVayIf8fj9Go1HWa4vqpsfdGhOJBJcuXSKZTPLrX/+a6elpSqXSjiYa962RFDEKUebU6/WoVCqk02ny+bySff0/NJtNKpUKJpOJbreLRqPB5/Nx7NgxyuWy9DTD4TADAwOcPXuWN998U3pFhUKBaDQqO5Ar6/oAEUdzOBxEIhGZPGi322QymR3Nph40er2e7CTudDrJ5/O4XK5HrspiH4rJk+FwWK6z8NyfFk4rFAqyFHRubo7V1dUd7+G5b42k0Ejp9Xr5QOdyORYXFxVP8v8gvJpf/vKX0uN2OBz4/X7OnTuHx+ORXVmmpqbweDz09/ejUqnkLJx0Oi1/35zoUVD4Pog5Nfl8nvv371OtVtHpdFsy02IUi9Vqxel0yvLXp7WZ6/V6rKysSMN469YtUqkUhUJhV5oc71sjKWQDJpNJBsw3Nja4c+cO0WhUiZvxYPPcvn2bhYUFpqampLc4ODjI2bNnaTab/PSnP5VZ7c1dlXK5HJcvX5ZJnlgspoj2FX4wYsyH6BMQj8fp6+tjaGhIvkav1zMwMECv13vqgLDNdLtd7t27xyeffMLy8jJffPEFpVJp16RX+9ZIPu5U2VzhoDzMD2i1WlSrVfL5PCsrK3Q6HWw225YGpr1eT47jbDQaNBoNVldXWVtbI5FIUC6XlavjUxBrWK/XlQN6G5rNJul0GpVKxfz8vEzUuN1uKad6VuMoxkOIcsaNjQ2y2SyNRmNXbcC+NZIPIzRZ1WpVPvAKD2JknU6H5eVl/uzP/gyPx8PPf/5zut0uBoMBs9lMs9mUTQTW1takcfz2228pFovk83llPZ9CvV5naWmJbDZLKpVS1usJFAoFvv76awwGAzMzM3g8Hl555RV+9rOf4XQ68Xg8j5QaPolqtcr169dJJpNcvnxZjjbe7ed/3xrJxy1Ct9uVJUzKJn2AiMlUKhVWVlbI5XJyPojJZJKSiWQySSaTYWlpiYWFBVKpFGtra0pj3W0Q1SD1ep1Op0M2myWdTitrtg2iW7taraZWq8lih3w+j1qtlkqVZ0F0sYrFYnL/NptNZRCYQMgJNguixYwWMTVN4TtE84BCocCHH37I3NwcWq0WvV4vH/B6vU4ul1P0kE+h1+vJcsMrV67wH//jf0StVpPJZKjVaty/f1/Zf09h8xpeu3aN//Sf/hNGo1FOlnwWGo0G0WiUcrnM6urqng2n29dGslaryVMcvpO71Ov1Iy/ifZher0ez2aTZbPLll1/y1VdfPfL3Cs+OiN3euHGDmzdvyj9X1vHZ2Bz/vnfvHtPT0z/46+w1+9ZIlkolFhcXKRQK2O12fD4fN27cIJvNKpUOz8B+2FyHBWUtn5+DvIaq3jO++92umRY6SdFmSaPRUK1WqVarMja5V/zQH7hSd/4dyho+P8oaPj/Psob71kjuZ5TN+fwoa/j8KGv4/DzLGirTnhQUFBS2QTGSCgoKCtugGEkFBQWFbVCMpIKCgsI2KEZSQUFBYRueObutoKCgcBRRPEkFBQWFbVCMpIKCgsI2KEZSQUFBYRsUI6mgoKCwDYqRVFBQUNgGxUgqKCgobINiJBUUFBS2QTGSCgoKCtugGEkFBQWFbVCMpIKCgsI2KEZSQUFBYRsUI6mgoKCwDc88CExp+f4dStv850dZw+dHWcPnRxnfoKCgoPCcKEZSQUFBYRsUI6mgoKCwDc8ck1RQUFB4UdhsNqxWKw6Hg+HhYXQ6Hevr6+RyOYrFIplM5gfHXF80ipFUUFDYVVQqFYFAgNHRUaampvj3//7fY7FY+Pu//3tu3rzJ7OwsX3/9Na1Wa6/fKqAYSQUFhV1Eq9Wi0WhwOp309fXR19dHMBjEbDbjdrux2+0YjcZ9lYFXjKSCgsKuoNVq8fl8WCwW3nnnHf7Vv/pXuFwubDYbvV4Pm82G1+vFZrMpRlJBQeHoodFosFgsOBwOBgcHOXPmDDqdDr1eT6PRQK/XYzab0ev1e/1Wt6AYSQUFhV1BpVJhNBqxWq0YjUY0Gg0qlYparUa1WmVxcZFbt24RjUbpdrt7/XYlipFUUFDYFdRqNWazGavVislkQq/X0+12aTQaFItF5ubm+Pbbb8nlcnQ6nb1+u5I9NZJarRatVotarUav1z82DtHr9Wi32/R6PZrN5r7JeCkcboxGIzqdDoPBgNlsRq1WYzAY0Gg06PV6DAYDrVaLSqVCu92mWCxSr9dpNps0Go29fvv7DpVKhU6nw+Px0NfXJ+OO3W6XarVKpVKhUqlQLpdpNBr7Rv4De2wkLRYLTqcTk8mE1+tFp9M98ppOp0OxWKTZbJJKpUilUnvwThWOEhqNhmAwiNfrpa+vj2PHjmE2mwmFQvL3YDBILpfj7t275PN5vvnmG5aWlshms/vuurjXqFQqNBoNdrudV199lampKUZHR1GpVNTrdRKJBBsbG8RiMeLxON1uVzGSOp0OtVotg7hmsxmfz4fRaHzkta1WC51OR71ep1KpoNFo6PV6yib8nqjVarlZN//3ZrrdLp1Oh16vR6vV2lcbdadRqVTS29HpdDidTnw+H8FgkIGBAaxWK5FIBKvVSn9/P5FIhFQqRaPRIJPJsLa2Rrlcpt1uo9frabVa++5h3yuE920ymXC73QQCAaxWKyqVina7TaFQIJ/PU6lUaDabe/12H2HXjaTZbOb8+fP4fD4ikQjhcBibzUY4HH6ikcxkMlSrVS5dusSVK1eoVquk02na7fZuv/0DiU6nIxAIYLFYGB4eZmhoCJvNRiQS2ZJJjMfjLCwskM1m+frrr8lkMnv4rncPvV6P0WjE6/Vy/vx53G43p06dksbR4/Gg0+mwWq3ydwCr1crExAS1Wg23200mk+Hu3bt8/vnn5PN5FhcXKZfLe/zp9h6fz8exY8eIRCIcP36c4eFhbDYbAIlEgr/9279lbW2N5eXlvX2jT2DXjaTBYGBycpJjx44xODjIyMgINpuNgYEBDAbDI69vtVqkUimq1SrFYpGFhQXy+Ty5XE4xks+IVqvF4/Hgdrs5e/YsFy9exOfzcfbsWcxms3zdvXv3uHTpEisrK0xPTx8ZI6nT6TCZTPj9fl577TUikQjnz59neHj4sXFylUpFr9fDaDTS399Pt9slHA7TarVwOBwkk0kSiQTxeFwxkoDD4WBiYoL+/n76+/sJhULy73K5HJcvX2ZxcZFqtbqH7/LJ7IiRVKvVmEwmNBoNNpsNk8mEw+Ggr68Pp9PJhQsX6Ovrw+fz4XK5MJlMqNWP77UhMmLiem61WqnX6098vQIyGeb1ehkYGMBut3Ps2DFcLpc80e12+yPXbYvFQigUol6vP/bAOkzo9XrpXQeDQcLhMKFQiPHxcTweD3q9nlqtRq1Wo1Ao0Gq1ZGy83W7TbrdlLF2v18tKkUAgwOnTp3G73UxPT5PL5eh2u0c6PGQ2m+nr6yMQCMh9Va1WqVarZLNZmfDar2u0I0ZSp9Phdrsxm80MDw8TDAaZmprigw8+wGaz4XA40Ov1skTpcfExgQj4WiwWPB4PHo+HZrOpGMknoFKpZPb11KlT/OxnP8Pj8XDs2DEcDgcWi0UeOg+vucvlYmpqCq1Wi8lk2qNPsPOIg/fcuXP09/dz5swZzp8/j9VqJRgMotPpqFar5PN54vE49+/fp1AoMDc3Ry6Xk9nYQCDAK6+8gsfj4cKFC/IQ8vv9zM/Pc+nSJRKJBM1mc1/G2nYLsa9ELBIgm82yvr5ONBqlWCxSq9X2bfz2hRpJ8eCZzWb8fr+MNYZCIUKhEH6/H4vFgsFgQKvVyqtMp9OhXC7LE7fb7aLT6WQNp0g2iN9F4kHhOzQajVxXt9stvcJgMIjL5cLtdmOz2dDr9VtUBJs3pkajwWg0yoSaw+GgXq8fKkmLuFo7HA4CgQDhcFhmso1Go5SiFQoF+SCvr69TLBaJxWIUCgVpJHu9HrFYjGazSS6Xw+v1Ag863NjtdtxuN263m3w+fySNpJBRifWwWq3yYK5Wq6RSKfL5vJT47VdeqJG0Wq24XC76+/v56U9/SigUIhwO4/F4sNlsOJ1OeRXcbOTy+TzXrl2jUChQqVRoNBqEw2FOnDiByWTC5XI90dNUeIDdbufEiRO4XC7Onj3L8PAw4XCYqakpjEYjZrNZrv2TENfGQCDA66+/jt/v5/bt29y/f38XP8nO4vP5OHnyJKFQiH/5L/8lx44dw263y0SCMIB///d/z1dffSUlPY1Gg2q1SqvVotPp0Ol0ZNzRbrdTrVZJJBJEIhHpTb799tuEw2G++uorrl+/vq8NwYtGq9UyNjZGf38/Fy5cYHx8HLvdjslkotvtMjs7yy9+8Qui0ei+jUUKXqiR1Ov1WK1WfD4fx48fZ3BwkEAggNPpfOzre70evV6ParVKNBolk8mQz+ep1Wp0u10ikQjdbld6n5slFY/bcMLwHqXNCA8+t8FgIBgM4vP5OHHiBFNTU9JbEobxad63EPVbLBYikQidToe1tTXUavW+jRc9K0LiYzabCYfDRCIRxsbGGB8fBx7smUajQaPRoFwuMz8/zzfffEOpVCKVSj3285fLZUqlElarlZWVFekMaDQaTCYTkUgEgNnZ2V39rPsBtVqNx+MhEonI24zZbEaj0dDpdMhmsywtLZFOp/d9gcgLNZJGoxGn04nT6ZTxw4dlPe12m3Q6LWs15+fnyWaz3Llzh3K5TLVapdFosLKywurqKkajEYfDgVar5ebNm8zPz0sXXXxPrVZLOBxmfHycZrPJ/Py8rICo1+uHOnDu8/nw+/0MDAzw3nvvyT594vr4fcISIrRhs9k4d+4cAwMDtFot2u02+XyetbU1ms3mgTmEtFqtPGDHx8cJh8MMDAxw/vx5XC4XDoeDVqvF+vo6a2tr5HI5mWy5fv06uVxu2+qPbrcr443CwIqro0ql2lJRdtRQq9X09fUxNTVFOBxGp9PR7XZlTHdtbY3V1VVKpdK+V6m8cCPpdrvxer3y18O0223i8TjpdJpf/epX/OIXv6BSqZDL5eQD2el0MJvNfP3111KIqlarKZfLUrDbbDZlwbzJZGJycpLf+Z3foVwuSzc+m83Kr3cYjaRKpcLv93Pq1CmOHTvGb/7mbxIMBh+JO36fr6dSqbDZbLz00ktynZvNJqurq6RSqQMlMtdqtTidTmw2G2+99RavvPIKwWCQyclJabxarRaLi4tcunSJaDTKhx9+SC6Xo1arPTWOKET3wkDW63XpFQkjKQonjhoajYZIJMKpU6cIBALodDop58tms6yurrK8vCyVAvuZF24kvV4vTqfzkYe01WpRrVYplUosLi5uyWw1Gg2azaaM9XS7Xfl6jUYjDaLYhL1eTyYpBgYG8Pl8jIyMEAwGaTQanDp1Cr/fz/379+XX3u/B4e+DkEMZDAb6+/uZnJxkYGAAs9mMTqeT8dtarSZ1euJhNRqNzyTvUavVsv/f+Pg43W4Xs9ksfwb7/dARV+uRkREphfL7/fJWAkj9rXhgNzY25E3m+zRY6PV68qCvVqv0ej2ZQbfZbPLnIvb3YUckWbVarVSxiDrtQqFAJpOhUqkcGOflhRlJlUpFKBTi/Pnz9PX1PSIhKRQKLC0tEY/H+f/+v/+P6elpstksmUxGlsPBd/FEYdjEdVEscrfbldd6h8PBb//2b3PhwgV53VapVLz88svUajX+7M/+jL/8y7+URfP7/cR6VvR6vbxS/4t/8S/4/d//fUwmk9Q+ijVLp9PcunWLXq+H0+nEaDQSDofp6+t7pu+jVqs5c+YM4+PjXL58mStXrshmDvs54y3CBqFQiJ///OeMjo4yNDREIBCQHl6pVOKrr75idXWVy5cv88UXX9BsNuXD+30O1Ha7zfr6urxidjod9Ho94XBYitRtNptM/hwEw/BDUavVsjGIyWTCbDbLQ7nZbLK4uMjS0hIbGxtHz0jCd9dth8PxSDa62WxSLBbJ5/MkEgnW19eliPRx9Hq9bU9dg8EgxbuDg4N4PB4cDgdqtRqn00mr1SIQCGCz2eh0OofqyqPRaHA4HHi9XgKBAKFQSK636JokGoNsbGzIGJm4Gm7maTFLq9UqO0Y7nU5KpZL8ue1Xz1x4MSaTib6+PiKRiCxa6HQ6NJtNarUayWSS9fV1ksmkPKwFKpVK7pmn7R3hJW72QIVeVbQE02q1h+aQ3g7xucWvzTcbccBms1npcR8EXqiRDAaDnDt3TlbZbKZcLjM3N0csFpOL9EOvHqIBgd/vl8H4h5MUarWaqakpfvd3f5fZ2VlSqdSB16qJU9rhcHD27FkmJiYYHh6WkiphIKenp1lbW+Pu3bt8+OGH6PV63nrrLcLhMD6fD/iutO5piDhlf38/f/iHf0g8Huef//mfmZ6elsZmv+FwOPD5fAwPD0t9rkga5HI51tbWSCaTfPLJJ8zMzDySvVapVLjdbtkcVjRjeBJ6vZ6JiQmCwSD9/f3SKIibj1ANbL4ZHVbMZjOjo6P4fD6Ghobo6+tDo9FQr9fJ5XLcvHmTGzduEIvFjqaRdDqdjIyMYDAYpLxHUK1WicfjxGIxyuXycxksrVaL1WqVgt3HJYjUajWRSISXXnoJ4FCU2Yk4odlsZmhoiKmpKfx+/xbdabfbJRqNcvv2ba5fv87ly5exWCwMDQ1hMpmo1WrS8MH2cqnNr/N6vbzxxhukUinu3bvHysoKvV6Per2+7za7KDX0+/3yZpPNZimVSiSTSebn54nH49y5c4eZmZlH/r1arcZqteL1euXv23mTWq2WoaEhgsEgHo9HSqbEMyBidEdB62swGGQRg9/vx+VyycO0UqmwsrLCzMzMvg7XPMwLNZLbPSwiqdNsNrcEsn9ITEJoAkOh0LblcwaDQXZBPsgnuEjShEIhTpw4IbuqiAomeFDmdevWLbLZLN9++y0LCwusrq7SbrdpNBosLi5Sq9VQq9U0m01MJpMU9z+MqJoSsSUhsxJ615MnT9Jut1laWuL27dv7LhlRqVRIJBJYrVa++eYb1tbWSCQSZLNZ0uk0S0tL5PN5isXiln9nsVgYHBzEarUyNTVFJBLBYDBgt9u3NZIi/rlZlypCG0KAflRwOBy89NJLDAwMyBhwsVhkeXmZ5eVlisXigUj8beaF124/7EEKLBYLAwMDshbbYDD84JpW4dJHIhEcDsdjX6NSqbBYLPh8vsfGSA8KarUal8uFx+Phtdde49//+3+P2+3G5/PJJiIA0WiU//bf/huLi4tS/iQkVdVqla+//hqj0SgNm9fr5cSJE1u6AAn0ej2RSASLxYLb7ZbxpUAggMPh4P3332dycpJf/vKXTE9P7zsjmc/npVzMYrFgs9lYWFggFotRq9XI5/N0Oh3q9fqWf+fxeHj//ffp6+vjrbfe4vjx49J7f5iHPfHNJbMajYZut0u5XKZQKEiv6SAf1M+Kz+fj937v9zh27Ji8vSWTSS5fvsz6+jqpVOqRdd/vvFAjWa/XyWazsonCZsMkYmnlclnWdD5PTFLUI293jd5c932QEUkIq9WK2+3G5XJJ765Wq8nGr0KDVi6XZdWSaFBcr9fpdDpkMhlsNhvNZlOWiT2MyWTCYDDQaDRkTE4YACHQttls+24+skBIyERyplKpkEqlpDhcZJgfjkOKWLdIUtnt9i0JHPG6h3mcUyDGPZjNZlwul+xkns/nD2UzXjH10GazYbVa5Q1HVDLlcjmy2eyBzAu8UCM5Pz/PP/zDPxAKhXj99de3lCO6XC7ZQioUCrG6ugrwvQL/4kH1er288sorDA0N4fF4XuRH2Heo1Wp5jfN6vTgcDqxWK1qtll6vx+LiInfu3GFubo7FxUU2Njao1WpbdKFio7ZaLVZWVkgmk+h0Or788svHHiBOp5PXXnuNUCjE2bNnZfMMYTREk4gfIljfDcRtplgscuvWLTQajTxMNndfFwjvz2azMT4+ztDQEG63+7kaqRgMBkZHR2UiZ3BwkPv37/MXf/EXssjhIF05n4bo4D42NiYdF7HGmUyGW7dusbGxcSD7a74wI9nr9cjn8ywtLcmhXZsxGAwYDAZqtZoU2IoY2ZOu6AKxUYW0w2KxEAgECAaDj70Kbfc1DhqiLttsNsuZxDqdTnqI+Xye5eVl2anmSTo/4TmVSiVKpdK239PlchEOh+l2u/T398sGBOJrinK7zZrM/Yjoav80RIJKJARtNpvcV0I+9SSEoXt4vUXlUq/XY2BgAHiQvDSbzZRKpUNVKiuE+z6fD7fbLUesiF/1ep1MJiOr6n7o93hYkbFb3vgL9STz+TwLCwvAAyGzEJRuHhFgtVp5//33GRwc5N69e9y9e5dqtUoymZTTEDdrzQwGA319fZjNZjlbZGJiAqfT+dSHVJQ0itikaJx6EGIier0el8uF1Wrl4sWLXLx4kcHBQXnFFkHwS5cu8fHHH8vs7fcVQj+OWq3G9PQ06+vrADQaDfr6+rh48aK8fvd6PSnBKpVKMgZ6EBHGKp1O8+GHHxIKhTh58iQDAwM4HA55GOt0ui37rVKpEIvFqNfrsidiq9WiXq9jMpkYHx/HZrNhMBgYGhoC4P/6v/4vNjY2+Oyzz1hYWDg085r6+/t54403GBgYkJ1+4vE4uVyOhYUFEokE+Xx+2z0iNJUixCEqxERnfa/XS61WI51O02g0pJRwp9kRI6nRaMhkMjKWtdlIWiwW3n33XS5evMinn34KPHDH6/W67CnZ6XTkQhmNRtlN6OWXX5bNTZ8lGaPRaNDpdFgsFvx+v6xFPihGMhAI4PF4ePnll/nggw+kFyk0p2tra1y5coVPP/30hZZd1ut1pqenpUdQq9WYmpri9OnTst+kXq+XRjKTyVAulw+skRSFC6lUio8//hiHw0GxWCSXy0lDaTQaH4lvV6tVFhYWKBQKrK+vk8vlqFQqFAoFeYhHIhE5dVEk3DY2NohGoywvLx8Kj1LoaF9//fUtov1YLMbS0pIMA1UqlSd+1s1D2IRcSqvVyrWfnJxkbGyMXC7H7OysdHYOnJFsNBoUCgVSqRQzMzNUKhUmJyexWCzSXRaGT6VS0dfXx8mTJ0mn07KBhaidFa+12WycOnUKn8/HwMCAFPmKB1g0QRWJjc1NeUXw3Ol0MjExgd1ul9UiwmDuV/R6vdSaOZ1ODAYDKpVKls6trq4yMzNDMpl8Id7jwwjDIbr/eDwearUaFotlS+mZqAU/6Mkx+K75c6/XY3l5mV6vRyaToVgsygz/5oM5n88zOzsrE0OiGknMjxYdhUSfTxH3bDabhEIhhoaGyOfzpFKpA5nIETc94YhYLBaMRqPUieZyOam0eNIeFc2hzWYzTqdTJnxFlZI4kMUtUvwsisWitBc7/Sy/UCMpYmLFYpFOp4PX6+Xf/bt/h9/vl8XuwvBZLBZee+01zp49Sy6X4969ezIru9lIWq1WLly4gM/nk3FNccq0Wi1mZmZYXV0lHA4zOTkpS8FETz+DwcDExAT/9t/+W1KplPwBFotFMpnMvt2cdrudl19+mcHBQYaGhrBYLNTrdUqlEvF4nA8//JArV67ILPZOIIxFLBYDHlxHxXVbNG8QYuGDKrHaTKPRYGNjA7VaTSKRkA+qSEQ8nMjZXIoofonrs8FgYG5uDqfTyR/90R8xODgo9ZQ2m40333wTu93OrVu3+OKLLw6kF67RaPB4PFitVgKBAH6/H5PJhFarpV6vMzMzw2effcba2toTu0eFQiH+7b/9twSDQYaGhuRzbjabt1y7hZfZarVkeEdogAuFAul0esee5RdqJMVGKZfLxONxms2mbNG+ubxLbDQhJTEYDLIruYjriA8sZtu4XK4t36dSqVCv10kmk8Tjcel5iRb8m2fnmEwmAoGA1GiKzb+fEeJtt9stB6WJLHW1WiWXy+3KNEPRBkyIokX9sZADiavRfk7gPCui9Rnw3BUh9XpdhkbS6TSFQkGOjTAYDLjdboLBICsrK1vKSg8S4opsNBrlc7c54VWr1eS1+GE9qdg3TqdTNl0ZHBx8xEg+TKfTwWq1yi76ohvYTrIjX73ZbBKPx8nn8/zd3/0ds7OzDA4OcuHCBSkdUavVuN1uPB6PbGklessJIW4mk0GlUhGLxUilUvLrr62t8etf/5pMJsPGxgaFQkFOuguFQvze7/2ezCjCg8y6x+NBpVJJCY0oz9uvG1OMKx0ZGcHhcKBSqSiXyywtLbG2tkalUtn197R5027uzqTwKCJUUa1W+fzzz2k2mwwNDfHBBx9gMpkYHR3F6XSSzWa5dOmSPPQPUnxShM7EzcJgMMjb4uMQRQpWq1XOvRoZGeHll1+WXd3FTfFJ+0qE0ESHIavVSqVS2dFneUeMZLvdplAoUCqVuH79OtFoVPZ4FCJkob1zu93odLpH6q8zmYzs+PxwVmx6epq/+7u/I5FIyGy4z+cjFosxMjLC+++/v+VraTQarFYrrVYLk8kkM2b7GZHR8/l8siqm0WiQTqfJZDJ7dj0T1x+F7el2u9RqNer1OrOzs7RaLSqVCm+88QZGo1HGmsXtp9Vq7euxqo/jcR1/tnuuxJA6r9fLxMSEHG88PDyM3W4Hni7r2Xz93lwyu5Ps6FcXzUhVKhVzc3N89NFH0kjp9XqGhoYYHR197KmRTCZZWFig0WjIeccCoQkUBlJUMOxEAmOvqFarTE9PU6/XGRoawu/3s7i4yJdffinlFLuNiLcdpAf5WRFhoIf34ouojikUCkSjUVwuFzMzM/j9fnw+n5SmjY2NkclkWFhYOFDt1MR+2NwsW3Q9ElMDxNXY4/FgsVi4cOECfr+fYDBIIBDA5XLJCZVP06SK7yme9U6nsyui/B03kqIUKx6Pc/36dTQajWzYMDExwdTU1GMXZn19nXv37lGr1WQ5mUD0BNy8eTf/kA6DoSwUCly+fJnFxUVefvllJiYmuHHjBn/zN38jpSZ7yXYD2Q4amxUR4qq3+WF8HsPV6/VIpVIyfvz111/T19fH22+/LeNw58+fJxaLkUgk9vzn+n0RmWXhsGyWSYnaf1Gc4Ha7eeeddwiFQltGRG8eL/0s+0kYSNFEZKd7B+z4nVNsNlFPuzkBkclkiMVij72+pVIpCoWClFQ8S4pfnGoitnmQr4Yi9iLkUmIz1mq1Hc1oH0X0er1MPni9XtkgV4wbSCaTz6VDFYe3qCUX2V94YEhEN3MR1xNNk/c7oidArVaTo3g7nQ4WiwWNRoPL5SISieB0OgmFQjidTukgCdH99038CbuRyWSkfdjp0NOuB+bEwjYaDebm5mRVx8M0m03ZiOBZTnLhXYrqB5FNfFyXm4OAxWLh7NmzDA4Oyu7qm0/tw+DB7Rd8Ph+Dg4OMjIzws5/9DLfbLUcbX7p0if/5P/+nHAHyPIdTJpPhiy++IBgMcuHCBTmb6Ld/+7dZWFhgenoagFwuR6FQeFEfb8dot9uyBd3s7Cx3797F7XYzNjaG0WjkzTff5PTp01L+J4o7isUi8XicjY0NXC4Xk5OTmEymZ9rTsViMX/ziF8Tjcb799luWl5d3vPXanmQvxCn5LHXEz4royi20U/V6fUulD7BFdyX++2l143uFXq+XFRrwnTeyn8IJ++V9PC8mkwm32004HOb8+fMEg0GSyST5fJ7V1VWZsX3eTH6j0SCVSqFSqajVavR6PdnvtFarYbfbZW33QUDUZTebTfL5POl0WraJU6vVMvYqECNFarUapVKJdDqNSqXakkt43J7afBstFossLS2xvr5OOp3elYYZ+zvF+z0QNZ16vZ579+7RarWYmJjAZrPJ12i1WkZGRiiVSvj9fsxms6y/3W9jCITo3uFwSM97vyC8+3a7LbWTB9VgirG8J06cYGRkBL1eT6vV4urVq9y8eZPbt2/LTvrP661oNBp5rRdxOPHwbz7cD8JVezO9Xo+VlRU+//xzxsfHmZiYwGq1PvK6ZrPJysoKuVyOeDxOIpHYok19mE6nQ6lUotFosLCwwMrKCouLi3z99ddkMpldS14eGiMpRM9arZaZmRmazSYul2tL9vz/b+/sftK6wzj+xYoF5MBhBwP4RsHNzc2+ZS8x65rsYrtq0ovd7q/b3bKrpb0wWbpszTazbJk6tbYUReUdDh7ej3JA2NXzDKulrVoF/H0S44UniD85z3levw+toG21Wiz7RS013WYk21dU0GRHt9Ce++0HI6koCj744AP4fD7Ol/3777+Yn59nPcqzqDpTXyFNpQCHz5JEqHvRSCaTSfz555+o1Wq4f//+sdfV63XE43Ekk0m+72jO+zjI8yyXy1hcXMQff/yBVCqF5eXlcy1w9Y2RJKiRfWBgADMzM9B1/VBORFEULuqYTCaoqgpVVWGxWFAul3uuuvi2oZYtmlSipU602InEbHupdaWdVqsFXdeRy+VgtVrRaDRw9epVeDweTE1NYWBggMcyT9tiRime9mougCNpol48y/39fVaEf5nRoz3uFCW53W6MjY0d0SWlcLxcLvPq6VAohFQqxeOI50nfGclqtYrFxUWEw2H4/X5cv34dNpsNiqLAbDbjvffeQyAQgK7rqFQqXDja3t7G06dPEYlELvgv6B5MJhMr2ExOTsJut8NsNrOYw8bGBkvddbNYyKvIZrNYXV2FYRi4c+cO7HY7bt26BZfLhYWFBWxubqJcLmNvb+9UXh55ku2CIBQl0KhpPp/vyc6FYrGISqWCiYmJl4bPVqsVN27c4Ha9g4MDFsdoJ5fL4enTp0ilUnjw4AF2dna4ok0F2vOk74wkjTQ2m81D88bkAZBIBs2cGoYBr9eLWq2GWCx2we/+f+j9l8tltFotlse3WCxH5tvfBjSXTXqKtOuGxiM1TeMkfDelAk4CeUGlUom9FEmSeNuiJEloNpsnDoVpEsVut0OWZTidTj5LwzA4gumV1p/joN5FUthq97rJgzaZTEfWhdC5Ul6WVoxkMhmk02n+IsWfi6AvjSTt9KYequOezBTy+Hw+3L9/H/l8HpVKBaurq12RX9M0DT///DNCoRDm5uYwMzODRCKBmzdvIpvNYmtr6621iQwNDWF0dBQOhwP37t3D119/zeNkhmHgn3/+wdLSEtbX13syNGyHmr3Jq9nd3T3UBE3RRiaTwcLCAjKZzBu9vslkQjAYRDAYxOTkJL744gsoisKhfDQaxePHjxGNRi9kiuqsqdVqyGazkCSJm8VJsIIayNtTDYVCAevr6yiVStjZ2YGmaUin0ywq3b5h8aLoOyPZXi0jA3lc20z7DOjs7Cz29/fx448/XsA7Ph5d1/H8+XMUi0Xcvn0biqKwyO2VK1c4T/Y2IAUit9uN2dlZfPnll1yJ1TQN0WgUKysrSKfTPRkavghVr1VV5cEFWjEyMTGB6elpDA8PY2lp6Y1fm3YyTU9PY2pqCp999hlkWYYkSTCZTNA0Devr60in011XPDwJjUYD5XIZxWKRBXSbzSbns19spdrb28POzg5yuRxWV1cRj8eRy+VYRaxcLl/4g7jvjGQ7NLr0qkOm67rphm82m6hWq/yBozWo77zzDgzDONIDehwU5pjNZiiKgqtXr3Leqx1SZXI4HFAUBbIs486dO/B6vfB6vcjlctjf3+eK5Pb2NlRVZYHaXof+/+l0Go8ePcKzZ89w8+ZNXLt2DWazGdevX4fP50OxWEQsFkOhUEA+n+cJmkajgcHBQVbhp0mp0dFRSJKETz75BLdu3eL1xkNDQyxSEolEEA6HoWlaTyjmv4rd3V3Mz8/D7XazI0Iar+09ykShUEA4HGad1Hw+D13XORrshnuyr40kVQw75e+azSZqtVrXtV40Gg1UKhUOAVVVRb1eh8fjYVHXV0EG0m63491334UsywiFQigUCofyRXRjj42NYXZ2FmNjY/jmm2/g9/tZG1RVVaytrSGXyyEUCiGRSPR06087lE+LxWL4/vvv4XK58O2332JoaAhOpxNzc3PY39+Hoiisuh8Oh5HNZjlXRkva7HY7rzu+e/cufD4fbty4gZmZGd6TYxgGNjc3kUqlsLa2huXlZTYKvU4ikcB33313RFbvZY347cI0FPG1f3UDfWskSVwjEonA5/PB7XZjeHiYQwCiXq8jk8mgUCh01aQD5VYHBweRSqX4pkqlUiwjBxxOG9D6CsrF2mw2OJ1OSJKEQCAAl8sFXdc5x0OamiMjI3A4HKyC7vF4IMsyrFYrVFVFOp1GNptFMpmEpmlcZOiGp/xZQqEiAESjUTx//hxer5cXW5GuJxk0SZJYKJoW3lE+U5Zl3m9D60ZoEd3e3h7i8ThisRhUVeUHdLcYhdNAY8f9hKn1mv+ZXhNXNZlMmJycxNjYGD766CNeI0Hy+UQymcQPP/yAra0t/P7771heXn7la5/0w/wmZ0gJb7PZzIarWCwik8nwsvdarQar1Yrh4WG43W58+umnsNlsvJ2OWqAURcHc3BxGRkbw119/4e+//+beMwD4/PPPMTU1hcnJSXz44YewWq1wuVwYHBzETz/9hF9//RW5XI5XbKTTaZRKpVPd1Odxhid5bapEe71eOBwOfPzxx7h37x5cLhcCgQAkSeI+USrq1Ot1VsimtRZms5m/U7tLLpfD2toaz3Bvbm5CVVXE4/ETPXC68Qx7jdc5w772JHO5HHRdh91ux+7uLodPFouFr6tWq4jFYtjc3ESpVLrAd3yYdtFWyoNVq9UjfXSDg4Os2+f1emG321mcYWRkBIFAAG63G8FgECMjI1BVFdlsFjabDZqmodVqYXx8HMFgEOPj4xgdHeW93o1GA4VCAYlEgtsydF3nueN+g/bFG4aBWCzG6wVofC4YDLIatslkQq1WgyzLXBmntjL6ORUNqXNC0zTE43Goqort7W1sbW31nBr5ZaRvjSQA7r+KRCJ48OAB69rJsszXkIeUTqe7KtwmaFcITWW8aJwURWFlZ7rO4XAgEAjg/fffx+3bt+FwOLiaOj4+zlMms7OzaLVaLGNVqVSwsLAAwzA4LPztt9+wsrICXddRLBYP7UXvZyj83drawsOHD+F0OrG+vs6tQVSh9vv9LP9FKjcUktO62ZWVFTx79owLP9VqFfF4nDf9CbqbvjaS9Xod9XodyWQSv/zyCywWC3w+H5xOJ1+j6zoikQgqlUrXjiRSePciJpMJsizj2rVruHLlCnuedrudvceZmZlDDbykBg38ryxNSi4bGxtYXFxEqVRCMplEpVLBkydPEAqF+tJz7AR5gfF4HJlMBlarFRsbG3A6nZiYmMDExAT8fj/8fj8XbdrXCNRqNWxsbCCRSODRo0d4/Pgxi8QKz7G36GsjSTQaDX5qUwhO1Go1VKvVc1E4PmtarRZKpRLi8fgh+XtJkmC1WiHLMsLhMBwOBzweD6xW66H1mxRSR6NRFkAOh8Pc7kMztJfNQLZD1VfDMJDP5zk6oTHCgYGBYwuCpVIJT548we7uLlKpFHvgl/kse5W+Ldy00z4W9aJaORmKN2k76KaEOeXCCBIPsNlsmJ6ext27d+HxePDVV19hdHQUi4uLWFpa4r9B13XMz89jdXWVVX3atSspzD9ruukMX/f3Ui8kqWnTMrvjtCZJfZ9ms2u12pkbyF47w27kUhdu2iFvoB+hlAJBD4KDgwPW7Ts4OOAJHWojajeS6XT6jcftLhuddA8F/c2l8CTPmm5/gpM4BTU2WywW7vd7ceLm4OAAqVTq3NcFdPsZ9gLiDE/P65yhMJInQHw4T484w9MjzvD0vM4Z9uYqQYFAIDgnhJEUCASCDggjKRAIBB147ZykQCAQXEaEJykQCAQdEEZSIBAIOiCMpEAgEHRAGEmBQCDogDCSAoFA0AFhJAUCgaADwkgKBAJBB4SRFAgEgg4IIykQCAQd+A+24wdVB7OiDwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -374,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 203, + "execution_count": 208, "metadata": {}, "outputs": [ { @@ -391,7 +391,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[203], line 28\u001b[0m\n\u001b[1;32m 23\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[0;32m---> 28\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m \u001b[43mG_loss_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 31\u001b[0m gen_opt\u001b[38;5;241m.\u001b[39mupdate(gen, G_grads)\n", + "Cell \u001b[0;32mIn[208], line 28\u001b[0m\n\u001b[1;32m 23\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[0;32m---> 28\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m \u001b[43mG_loss_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 31\u001b[0m gen_opt\u001b[38;5;241m.\u001b[39mupdate(gen, G_grads)\n", "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:34\u001b[0m, in \u001b[0;36mvalue_and_grad..wrapped_value_grad_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapped_value_grad_fn\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 34\u001b[0m value, grad \u001b[38;5;241m=\u001b[39m \u001b[43mvalue_grad_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainable_parameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value, grad\n", "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:28\u001b[0m, in \u001b[0;36mvalue_and_grad..inner_fn\u001b[0;34m(params, *args, **kwargs)\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner_fn\u001b[39m(params, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 27\u001b[0m model\u001b[38;5;241m.\u001b[39mupdate(params)\n\u001b[0;32m---> 28\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[0;31mTypeError\u001b[0m: 'bool' object is not callable" From f176cce74d1772c4eba783f3b73e5a18649a7e09 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sat, 27 Jul 2024 00:19:08 +0300 Subject: [PATCH 05/38] Updating GAN Code... --- gan/playground.ipynb | 4257 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 4217 insertions(+), 40 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 9bdf4ee6..15da8673 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 113, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 114, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 115, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 116, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 117, "metadata": {}, "outputs": [ { @@ -123,7 +123,7 @@ ")" ] }, - "execution_count": 8, + "execution_count": 117, "metadata": {}, "output_type": "execute_result" } @@ -135,12 +135,11 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 118, "metadata": {}, "outputs": [], "source": [ "def get_noise(n_samples, z_dim):\n", - "\n", " return np.random.randn(n_samples,z_dim)" ] }, @@ -153,12 +152,11 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 119, "metadata": {}, "outputs": [], "source": [ "def DisBlock(in_dim:int,out_dim:int):\n", - " \n", " return nn.Sequential(\n", " nn.Linear(in_dim,out_dim),\n", " nn.LeakyReLU(negative_slope=0.2)\n", @@ -167,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 120, "metadata": {}, "outputs": [], "source": [ @@ -191,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 121, "metadata": {}, "outputs": [ { @@ -216,7 +214,7 @@ ")" ] }, - "execution_count": 13, + "execution_count": 121, "metadata": {}, "output_type": "execute_result" } @@ -235,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 122, "metadata": {}, "outputs": [], "source": [ @@ -250,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 197, + "execution_count": 123, "metadata": {}, "outputs": [], "source": [ @@ -272,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": 198, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -282,12 +280,14 @@ " \n", " fake_disc = disc(fake_images)\n", " \n", - " fake_labels = mx.zeros((len(fake_images),1))\n", + " fake_labels = mx.zeros((fake_images.shape[0],1))\n", " fake_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", " \n", " real_disc = disc(real)\n", - " real_labels = mx.ones((len(real),1))\n", - " real_loss = nn.losses.binary_cross_entropy(real_disc,real_labels,with_logits=True)\n", + " real_labels = mx.ones((real.shape[0],1))\n", + "\n", + " # print('Shapes.....',real_disc.shape,real_labels.shape)\n", + " real_loss = nn.losses.binary_cross_entropy(real_disc,real_labels)\n", "\n", " disc_loss = (fake_loss + real_loss) / 2\n", "\n", @@ -296,7 +296,7 @@ }, { "cell_type": "code", - "execution_count": 204, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -307,7 +307,7 @@ " \n", " fake_disc = disc(fake_images)\n", "\n", - " fake_labels = mx.ones((len(fake_images),1))\n", + " fake_labels = mx.ones((fake_images.shape[0],1))\n", " \n", " gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", "\n", @@ -316,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": 205, + "execution_count": 105, "metadata": {}, "outputs": [], "source": [ @@ -327,7 +327,7 @@ }, { "cell_type": "code", - "execution_count": 206, + "execution_count": 106, "metadata": {}, "outputs": [], "source": [ @@ -347,12 +347,12 @@ }, { "cell_type": "code", - "execution_count": 207, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -374,27 +374,4120 @@ }, { "cell_type": "code", - "execution_count": 208, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "0it [00:00, ?it/s]\n" + " 0%| | 139/60000 [00:00<01:22, 726.53it/s]" ] }, { - "ename": "TypeError", - "evalue": "'bool' object is not callable", + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 1%| | 307/60000 [00:00<01:14, 801.44it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 1%| | 471/60000 [00:00<01:13, 808.99it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 1%| | 633/60000 [00:00<01:14, 800.05it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 1%|▏ | 794/60000 [00:01<01:16, 778.34it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 949/60000 [00:01<01:18, 747.52it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 1098/60000 [00:01<01:20, 733.90it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 1240/60000 [00:01<01:28, 660.48it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 1307/60000 [00:01<01:29, 656.89it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 1438/60000 [00:02<01:36, 608.91it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 3%|▎ | 1561/60000 [00:02<01:36, 603.59it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 3%|▎ | 1683/60000 [00:02<01:40, 582.79it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 3%|▎ | 1799/60000 [00:02<01:45, 552.37it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 3%|▎ | 1915/60000 [00:02<01:46, 543.12it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 3%|▎ | 2026/60000 [00:03<01:46, 543.94it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 4%|▎ | 2142/60000 [00:03<01:43, 560.25it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 4%|▍ | 2257/60000 [00:03<01:45, 545.45it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 4%|▍ | 2365/60000 [00:03<01:51, 518.84it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 4%|▍ | 2472/60000 [00:03<01:53, 506.74it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 4%|▍ | 2575/60000 [00:04<01:53, 504.04it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 4%|▍ | 2626/60000 [00:04<02:02, 469.09it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▍ | 2781/60000 [00:04<01:55, 494.90it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▍ | 2831/60000 [00:04<01:56, 490.73it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▍ | 2928/60000 [00:04<02:10, 438.99it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 3023/60000 [00:05<02:05, 453.50it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 3118/60000 [00:05<02:03, 460.44it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 3211/60000 [00:05<02:06, 449.22it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 6%|▌ | 3302/60000 [00:05<02:16, 416.36it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 6%|▌ | 3391/60000 [00:05<02:12, 426.27it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 6%|▌ | 3479/60000 [00:06<02:13, 423.14it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 6%|▌ | 3564/60000 [00:06<02:17, 411.69it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 6%|▌ | 3648/60000 [00:06<02:20, 401.16it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n", + "real shape , (784,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 6%|▌ | 3662/60000 [00:54<14:01, 66.96it/s] \n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[208], line 28\u001b[0m\n\u001b[1;32m 23\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[0;32m---> 28\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m \u001b[43mG_loss_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 31\u001b[0m gen_opt\u001b[38;5;241m.\u001b[39mupdate(gen, G_grads)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:34\u001b[0m, in \u001b[0;36mvalue_and_grad..wrapped_value_grad_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapped_value_grad_fn\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 34\u001b[0m value, grad \u001b[38;5;241m=\u001b[39m \u001b[43mvalue_grad_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainable_parameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value, grad\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:28\u001b[0m, in \u001b[0;36mvalue_and_grad..inner_fn\u001b[0;34m(params, *args, **kwargs)\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner_fn\u001b[39m(params, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 27\u001b[0m model\u001b[38;5;241m.\u001b[39mupdate(params)\n\u001b[0;32m---> 28\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mTypeError\u001b[0m: 'bool' object is not callable" + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[108], line 40\u001b[0m\n\u001b[1;32m 37\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m G_loss_grad(gen, disc, batch_size, z_dim)\n\u001b[1;32m 39\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[0;32m---> 40\u001b[0m \u001b[43mgen_opt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mG_grads\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 42\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[1;32m 43\u001b[0m \n\u001b[1;32m 44\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[38;5;66;03m# mean_discriminator_loss = 0\u001b[39;00m\n\u001b[1;32m 61\u001b[0m \u001b[38;5;66;03m# cur_step += 1\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/optimizers/optimizers.py:29\u001b[0m, in \u001b[0;36mOptimizer.update\u001b[0;34m(self, model, gradients)\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mupdate\u001b[39m(\u001b[38;5;28mself\u001b[39m, model: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmlx.nn.Module\u001b[39m\u001b[38;5;124m\"\u001b[39m, gradients: \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 21\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Apply the gradients to the parameters of the model and update the\u001b[39;00m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;124;03m model with the new parameters.\u001b[39;00m\n\u001b[1;32m 23\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[38;5;124;03m via :func:`mlx.nn.value_and_grad`.\u001b[39;00m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 29\u001b[0m model\u001b[38;5;241m.\u001b[39mupdate(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_gradients\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgradients\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m)\u001b[49m)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/optimizers/optimizers.py:88\u001b[0m, in \u001b[0;36mOptimizer.apply_gradients\u001b[0;34m(self, gradients, parameters)\u001b[0m\n\u001b[1;32m 85\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstep \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 87\u001b[0m \u001b[38;5;66;03m# Apply the update\u001b[39;00m\n\u001b[0;32m---> 88\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_single\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradients\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparameters\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:48\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:49\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[0;32m---> 49\u001b[0m k: \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:48\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:49\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[0;32m---> 49\u001b[0m k: \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:43\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 42\u001b[0m TreeType \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtype\u001b[39m(tree)\n\u001b[0;32m---> 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mTreeType\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[43m \u001b[49m\u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtree\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 46\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:44\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 42\u001b[0m TreeType \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtype\u001b[39m(tree)\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[0;32m---> 44\u001b[0m \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:48\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:49\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[0;32m---> 49\u001b[0m k: \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:43\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 42\u001b[0m TreeType \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtype\u001b[39m(tree)\n\u001b[0;32m---> 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mTreeType\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[43m \u001b[49m\u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtree\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 46\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:44\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 42\u001b[0m TreeType \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtype\u001b[39m(tree)\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[0;32m---> 44\u001b[0m \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:48\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:49\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[0;32m---> 49\u001b[0m k: \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:53\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtree\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/optimizers/optimizers.py:426\u001b[0m, in \u001b[0;36mAdam.apply_single\u001b[0;34m(self, gradient, parameter, state)\u001b[0m\n\u001b[1;32m 424\u001b[0m v \u001b[38;5;241m=\u001b[39m state[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mv\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 425\u001b[0m m \u001b[38;5;241m=\u001b[39m b1 \u001b[38;5;241m*\u001b[39m m \u001b[38;5;241m+\u001b[39m (\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m b1) \u001b[38;5;241m*\u001b[39m gradient\n\u001b[0;32m--> 426\u001b[0m v \u001b[38;5;241m=\u001b[39m b2 \u001b[38;5;241m*\u001b[39m v \u001b[38;5;241m+\u001b[39m (\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m b2) \u001b[38;5;241m*\u001b[39m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msquare\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 427\u001b[0m state[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mm\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m m\n\u001b[1;32m 428\u001b[0m state[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mv\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m v\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -403,20 +4496,27 @@ "cur_step = 0\n", "mean_generator_loss = 0\n", "mean_discriminator_loss = 0\n", - "test_generator = True # Whether the generator should be tested\n", - "gen_loss = False\n", "error = False\n", "\n", "D_loss_grad = nn.value_and_grad(disc, disc_loss)\n", "G_loss_grad = nn.value_and_grad(gen, gen_loss)\n", "\n", "\n", - "for epoch in range(n_epochs):\n", + "for epoch in range(10):\n", " \n", " # Dataloader returns the batches\n", - " for real in tqdm(batch_iterate(batch_size, train_images)):\n", + " # for real in tqdm(batch_iterate(batch_size, train_images)):\n", + " \n", + " for real in tqdm(train_images):\n", "\n", + " \n", + " # real = real.reshape(-1)\n", + " \n", " # Flatten the batch of real images from the dataset\n", + " \n", + " # plt.imshow(real[0].reshape(28,28))\n", + " # print(len(real))\n", + " # break\n", " \n", " D_loss,D_grads = D_loss_grad(gen, disc, real, batch_size, z_dim)\n", "\n", @@ -425,7 +4525,6 @@ " \n", " # Update gradients\n", " \n", - " \n", " G_loss,G_grads = G_loss_grad(gen, disc, batch_size, z_dim)\n", " \n", " # Update optimizer\n", @@ -433,7 +4532,6 @@ " \n", " # Update gradients\n", "\n", - " \n", "\n", " # # Keep track of the average discriminator loss\n", " # mean_discriminator_loss += disc_loss.item() / display_step\n", @@ -452,6 +4550,85 @@ " # mean_discriminator_loss = 0\n", " # cur_step += 1\n" ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shapes..... (1,) (784, 1)\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Inputs shape (1,) does not match targets shape (784, 1).", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[90], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdisc_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreal\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[89], line 14\u001b[0m, in \u001b[0;36mdisc_loss\u001b[0;34m(gen, disc, real, num_images, z_dim)\u001b[0m\n\u001b[1;32m 11\u001b[0m real_labels \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39mones((real\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m],\u001b[38;5;241m1\u001b[39m))\n\u001b[1;32m 13\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mShapes.....\u001b[39m\u001b[38;5;124m'\u001b[39m,real_disc\u001b[38;5;241m.\u001b[39mshape,real_labels\u001b[38;5;241m.\u001b[39mshape)\n\u001b[0;32m---> 14\u001b[0m real_loss \u001b[38;5;241m=\u001b[39m \u001b[43mnn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlosses\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbinary_cross_entropy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreal_disc\u001b[49m\u001b[43m,\u001b[49m\u001b[43mreal_labels\u001b[49m\u001b[43m,\u001b[49m\u001b[43mwith_logits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 16\u001b[0m disc_loss \u001b[38;5;241m=\u001b[39m (fake_loss \u001b[38;5;241m+\u001b[39m real_loss) \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m disc_loss\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/losses.py:155\u001b[0m, in \u001b[0;36mbinary_cross_entropy\u001b[0;34m(inputs, targets, weights, with_logits, reduction)\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;124;03mComputes the binary cross entropy loss.\u001b[39;00m\n\u001b[1;32m 126\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;124;03m array(0.510826, dtype=float32)\u001b[39;00m\n\u001b[1;32m 153\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m inputs\u001b[38;5;241m.\u001b[39mshape \u001b[38;5;241m!=\u001b[39m targets\u001b[38;5;241m.\u001b[39mshape:\n\u001b[0;32m--> 155\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 156\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInputs shape \u001b[39m\u001b[38;5;132;01m{\u001b[39;00minputs\u001b[38;5;241m.\u001b[39mshape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m does not match targets shape \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtargets\u001b[38;5;241m.\u001b[39mshape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 157\u001b[0m )\n\u001b[1;32m 159\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m with_logits:\n\u001b[1;32m 160\u001b[0m loss \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39mlogaddexp(\u001b[38;5;241m0.0\u001b[39m, inputs) \u001b[38;5;241m-\u001b[39m inputs \u001b[38;5;241m*\u001b[39m targets\n", + "\u001b[0;31mValueError\u001b[0m: Inputs shape (1,) does not match targets shape (784, 1)." + ] + } + ], + "source": [ + "disc_loss(gen, disc, real, batch_size, z_dim)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "real.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(8, 784)" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "real.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "real.reshape((-1,len(real))).shape" + ] } ], "metadata": { From a05608c34da55848ebcb7ceba3ad418f1e85ae03 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sat, 27 Jul 2024 00:22:29 +0300 Subject: [PATCH 06/38] Updating GAN Code... --- gan/playground.ipynb | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 15da8673..1f7e7e7d 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -250,7 +250,19 @@ "cell_type": "code", "execution_count": 123, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[123], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m gen \u001b[38;5;241m=\u001b[39m Generator(z_dim)\n\u001b[0;32m----> 2\u001b[0m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m gen_opt \u001b[38;5;241m=\u001b[39m optim\u001b[38;5;241m.\u001b[39mAdam(learning_rate\u001b[38;5;241m=\u001b[39mlr)\n\u001b[1;32m 5\u001b[0m disc \u001b[38;5;241m=\u001b[39m Discriminator()\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], "source": [ "gen = Generator(z_dim)\n", "mx.eval(gen.parameters())\n", From 147cb3d2bc9b1dd8c9326fce40039ab51b941dbf Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sat, 27 Jul 2024 01:09:51 +0300 Subject: [PATCH 07/38] Updating GAN Code... --- gan/playground.ipynb | 64214 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 60005 insertions(+), 4209 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 1f7e7e7d..ed96d59b 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 113, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 115, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 117, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -123,7 +123,7 @@ ")" ] }, - "execution_count": 117, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 119, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -165,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 120, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 121, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -214,7 +214,7 @@ ")" ] }, - "execution_count": 121, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -233,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 122, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -248,21 +248,9 @@ }, { "cell_type": "code", - "execution_count": 123, + "execution_count": 13, "metadata": {}, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[123], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m gen \u001b[38;5;241m=\u001b[39m Generator(z_dim)\n\u001b[0;32m----> 2\u001b[0m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m gen_opt \u001b[38;5;241m=\u001b[39m optim\u001b[38;5;241m.\u001b[39mAdam(learning_rate\u001b[38;5;241m=\u001b[39mlr)\n\u001b[1;32m 5\u001b[0m disc \u001b[38;5;241m=\u001b[39m Discriminator()\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "gen = Generator(z_dim)\n", "mx.eval(gen.parameters())\n", @@ -282,14 +270,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 71, "metadata": {}, "outputs": [], "source": [ "def disc_loss(gen, disc, real, num_images, z_dim):\n", " noise = mx.array(get_noise(num_images, z_dim))\n", " fake_images = gen(noise)\n", - " \n", + " \n", " fake_disc = disc(fake_images)\n", " \n", " fake_labels = mx.zeros((fake_images.shape[0],1))\n", @@ -298,8 +286,7 @@ " real_disc = disc(real)\n", " real_labels = mx.ones((real.shape[0],1))\n", "\n", - " # print('Shapes.....',real_disc.shape,real_labels.shape)\n", - " real_loss = nn.losses.binary_cross_entropy(real_disc,real_labels)\n", + " real_loss = nn.losses.binary_cross_entropy(real_disc,real_labels,with_logits=True)\n", "\n", " disc_loss = (fake_loss + real_loss) / 2\n", "\n", @@ -308,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 72, "metadata": {}, "outputs": [], "source": [ @@ -316,7 +303,6 @@ "\n", " noise = mx.array(get_noise(num_images, z_dim))\n", " fake_images = gen(noise)\n", - " \n", " fake_disc = disc(fake_images)\n", "\n", " fake_labels = mx.ones((fake_images.shape[0],1))\n", @@ -328,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 105, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -339,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 106, + "execution_count": 59, "metadata": {}, "outputs": [], "source": [ @@ -359,12 +345,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUkAAAFICAYAAADd1gwNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACOnElEQVR4nOy955Oc13mnfXXOOU9PDhgMciAJUoREUpJTydm7DuvdcnnT37Nftmr3w1atN7jsWsuWX2stiUtJpCkQJAEBRMbk1NPTOef4foDPQQ8wGABEmO6Z56qaIoieafTzzHnuc587/G5Vt9vtoqCgoKCwK+r9/gAKCgoK/YxiJBUUFBT2QDGSCgoKCnugGEkFBQWFPVCMpIKCgsIeKEZSQUFBYQ8UI6mgoKCwB4qRVFBQUNgDxUgqKCgo7IH2Wb9RpVK9ys8xUHzdJiXlHj5EuYcvjnIPX5xnuYeKJ6mgoKCwB4qRVFBQUNgDxUgqKCgo7IFiJBUUFBT2QDGSCgoKCnugGEkFBQWFPVCMpIKCgsIeKEZSQUFBYQ8UI6mgoKCwB4qRVFBQUNiDZ25LfB2o1Wo8Hg92ux2DwYDZbKbT6ZDJZKjX6xSLRUql0n5/TIUDilqtRq/Xo9FosNlsmM1mGo0G1WqVdrtNqVSi1Wrt+rN6vR6tVovL5SIYDKJSqWg2m7TbbeLxOMlk8jVfzeAj7qder3/sNY1Gg9PpxGQyPfZat9slkUiQyWRoNpvUarWv3cIJfWYk9Xo93/rWtzh37hzDw8McP36ccrnMT3/6UzY3N7l+/To3btx4oQtWUHgSBoOBQCCAxWLh/PnzTE1NkUwmWVtbI5fLcefOHbLZ7GM/p9Fo8Hq92O12PvjgA/71v/7XaLVaEokElUqFv/qrv+IHP/iBsm6fE5vNxsWLFwkGg4+9Zjab+eY3v8nU1NRjrzWbTb7//e/zk5/8hFwux/r6Os1m82t/jr4ykmq1GpfLxfDwMJOTkxw/fpxSqcTy8jKdTofl5eX9/ogDgUqlkl+P/l2326Xb7aJSqVCrH0RbOp3OjgdYpVKh0Wjk94jvEwgPqdPp0Ol0Xs9FvWJUKhVarRa73Y7dbmdoaIixsTG0Wi25XI52u41W++THRa/XYzabCQQCHDt2DK1Wi8PhIJ/P43Q6X9+FvAZ615dard6xzrrd7mNronetPYparX7ifXU4HAwNDREOhx97zWKxMDs7y9GjRx97rdFocPnyZWw2G7Va7YUFPfrKSPY+qOLPRqOR8+fPMzExQSQS4Re/+IWyI++BCFnYbDa5ALVaLVarFb1eT6VSoVKpYDabCQaDqNVqEokEuVxOvofFYmFmZgaHw0EoFCIQCMiFVq1WuXTpEisrKySTSba2tgbeUOr1egwGAxMTE/z+7/8+wWCQ8fFxfD4fKpWKhYWFPX9epVJhNptxOBxYLBY0Gg3tdptYLPbYvT0IWK1W/H4/RqMRv9+PxWKRr1WrVeLxOI1GQ/6d3W7H5/Oh0Wgeey+v18upU6cwm82PvWYymRgbG8NqtT72mk6nIxAIvKQr2pu+MpKA9HTEn41GI0eOHKHRaPDhhx8qMk9PQaVSyUWp1WoxmUzo9Xq8Xi9Go5FcLkc2m8XlcnH06FG0Wi0LCwvE43H5Hk6nk3fffZdQKMTx48c5cuSIvO/5fJ5Op4NKpaLT6RCNRvfrUl8aOp0Ok8lEIBDg4sWLjI2NYbFYMBgMxOPxJ3pBApVKhdFoxGazYTQa0Wg0NJtNMpkMsViMcrn8mq7k9WAymQgGg9hsNmZnZ3G5XPK1fD7P/fv3qVar8u8CgQAzMzO7eowTExP81m/91o736Df6zkg+Su+Rz2w243K5qNVqVCqVgfdgXgYulwu3243RaMTlcmE0GpmYmMDv90svUqfTYbfb0el0lMtlyuUyFouFoaEhGQAvFAryPYUn6XQ6sVqtOzYmrVbLkSNH5P8vLy9Tq9VotVoD6+EPDw9z9OhRZmZm8Hg8GI1G1tfXSaVS3L59m7W1NbLZLPV6fdefV6vVOBwOgsEgdrtdJm22trZYXV09cJ6k3+/n4sWLOJ1OQqHQDk+vUqkQCAR2eJLi3uzmSfp8PnQ63Uv9fN1ul1KpRCKRoFAovLCd6HsjCQ8C4zqdDqfTyfDwMIVCgUgksuMXcRhRqVSMjo5y5swZfD4fp06dwul0MjExQSAQkJtLb+xIxB9F3BHYEVsUsSatVotarX5sYZtMJr71rW/x9ttvo9Pp+PzzzykUCpTL5SdmfvsZtVrN6dOn+ZM/+RO8Xi8TExOoVCquXr3KJ598QiQS4fbt2zQajScG/zUaDeFwmKNHjxIKhVCr1VSrVe7evcvNmzeJRqMDu4HsxszMDP/xP/5HvF7vYzFrsZZ6r3e3dSTQaDS7Zq9fhG63SzKZZHFxkXa7TbvdfqH36zsj2W63ZWKgF3GkcTgctFqtpx6BDjJqtVrGGAOBAMPDw3g8HoLBIA6HA4/HI5MFe4UnxGuP/lfQG/bo/Rmz2YzRaMRkMu2a2BkUdDodWq0Wm82Gx+PBarVSqVRoNpuk02kSiQTZbFZ6yk9CpVLJI7ter5ebUaPReOrPDiJ6vV4muF4XrVaLVquFRqNBq9XuWKuVSoVisShtR7VaJZvN0mw2X8rm1FdGstvtksvliEajeDyeHYZSpVIxNDTEuXPnWFtbY3Nzk1qtto+fdv+wWq18+9vfZmxsjLNnz3L+/HlMJhM2m03GIdVqNa1Wi0aj8cTdXXiLOp3uiTv9bjzqnQ5inFin0zE0NITNZmN8fJyRkREKhQIfffQRqVSKS5cucefOHer1+lM9kd7EjclkGsj70c90u11SqRSJRAKbzcbw8PCOI/pXX33FD3/4QwqFApubmxSLRZaXl1+a9953RrJWq1EqlXaN/1gsFvx+P4VC4bke6oOGXq9nbGyMY8eOMTc3x9zcHGq1+jHPr91uU6/X6XQ6tFqtHbEZrVaLwWCQO/Oj9JYK9dLrdQ6yMVCr1dhsNtxuN06nE7vdTqFQYG1tja2tLba2tkin08/8fjqdDoPBsGeZ0EGiN2zzPOxluHarbhF/LpVKpNNpOp2ODCUJ4vE4169fJ5lMsrCwQLFYfK7P9DT66jfabreJRqOoVCr8fv9jnqQ4blssFulyH6RYz9MwGo3Y7XaCwSBTU1PMzs7KMpVOp0Oz2aTZbLK2tkYymSSZTLK6uiqPIL1GMhgM8s477+xIOAgajQbRaJRqtYrL5cLhcOx6zBlkLBYL3/zmNzl69CgnTpxAo9FQr9fZ3NxkY2PjpT9oB4lEIsEXX3xBMBiUCb5noVarsbCwQD6ff+w10VlXLpcplUpks9kdz38ulyOXy2EymfB6vTucpPv377O0tES1Wn1icu1F6DsjGYlEyGazHDly5LFjjtFoxOl0ymOlWq1+7Bh5kBGlF+FwmJmZGebm5jCbzahUKuk1VioVbt26xe3bt1leXubzzz+nWq1SKpV2JB5Onz6N0+lkdHT0sfhSvV5ndXWVbDbLxMQEer3+uY/k/Y7VauWDDz7gvffek9dWr9fZ2NhgeXl5R7ZfYSfJZJLPPvuMcDiM1+t9ZiNZqVS4ceMG6+vrj73WbDZZXFwkmUyyvb3NysrKjljuo3HxXnoTj6/CFvSVkYSHF7xb2t5iseDz+XA6neh0OnnEPCxGUqPRYDKZZOJE9AvDA8O2vb1NPp9nY2ODjY0N4vE45XKZer1Oo9Gg3W7viCXq9XrZq6xSqchms8RiMXK5HHfv3iWbzaLX63E6nZjNZkwmE51Oh2q1SrPZpFwuy86bQUHUM/p8PqxWKwaDgXK5TDKZJBaLUSwWqVarz5xsEfdTq9Xu+H0cZBqNBrlcDovF8kztfqVSSXqClUpl1xhvp9PBYDBgsVjQ6XQ0m82+SXgNzG9UpVIRDofx+Xw0Gg2sVis6nW7XNqiDiih49vv9OBwOrFarNHjZbJZ/+qd/IhqN8vOf/1yWrdRqtR2bjqibFF0TgUAAo9EIwO3bt/mrv/orUqkUd+7coVQq8bu/+7totVr5b2o0GiKRCKlUikgkQqVSkXHPQcDr9XL27FmGh4cJBoOYzWbu37/PlStXWFlZYX19nUQi8UxlI70G0mq14na7pWd/kCkWiywtLVGv15+pUH5ra4tPP/2USqXyRIEajUZDKBTC7/dTr9e5e/fuy/7YX5uBMpIGg0GqA2k0moEtPXkRRH2j+BJ0Oh0qlYqM6RSLRTqdzq6lVOJnRQlMq9WiWq2STqdZW1sjnU6TTCap1WqUy2W5qwuvvVwuk81mpSfZbrcHwpsXcW2v14vP58NoNKJWq6lUKiQSCVKpFLVa7bnEEISh1Ov1GI1GdDrdgTWSvVUNz3OCEKeOWq322LrtRSj6uFwunE6n/F30Vmfsh17AwBhJBSgUCiwuLlKv12X9nvAMnU4nFy9elLJyer2eVCrF6urqDkPZm4BpNBoUi0WpbnPlyhXu3buHVqvljTfewOPxcPHiRY4fP47ZbEan01Gr1bh37x43b95kYWFhYLptRFx1fHyc7373uwSDQbxeLwCxWExmR5+nrEzURxoMBnw+HyMjIxiNxgNpJNVqtQx1TU9Pc/HiRQKBAB6P56k/Gw6H+c53vvPMx+c33niDX//1Xyefz3P9+nXS6TSpVIpMJkOpVCIWi73Wo7hiJAeIarXK9va2bC9sNpuyO8ZisXD06FHK5TILCwtks1nUajUbGxuPVQmIGKTwIBcXF1lcXOTevXtsbW3hdruZmZlhenqaubk5hoeHpefearWIRCLcu3ePaDQqd/p+R5Q8+Xw+Tp48ic/nw2azAQ8ypysrKxSLxefq4hL3UrR9CqN7EFGpVFLwZHx8nFOnTkkhlafhcrm+Vm92KpXCYrGwvr7O2toaGxsbZDIZksnk4TaSrVZLCuwKNRGHw4HBYJDfIwyDyHAfFkQXR6lU4v79+1IlZXx8XN4To9HI1NQUrVYLm81GqVSiUCgQj8dlQkIkeT799FNsNhubm5tks1k8Hg+//uu/jtPp5MyZMwwNDeF2u1Gr1RSLRba3t0mlUqysrBCJRMjlcn3vQcLD9WIwGDAajZjNZqmI1G63yefzlMtlqtXqQFzPfqDRaDh27BhvvfUWw8PDhMNhmfh6VRgMBqanp3G5XLLtMxaLYTabKRQKbG1t7VpO9LLpKyPZ7XZpNBqywn5paQmfz8eRI0d2/DJEv6fRaHwldVH9SqvVot1uk0ql+MUvfsHm5ibf+c53GB0dlfdEHJXn5ua4desWGo2GeDzOp59+SrValT3Iy8vL/I//8T8wGAwye/3GG2/wve99D4fDwcjIiMw0qlQq0uk0n3zyCdvb21y5coU7d+4MlJ6kiGXbbDYcDgdms5loNEqhUJAq1s/SXXNY0ev1fPDBB/z5n/+59J5fdUuq1Wrl7bff3lHxsry8TDAYZHt7mw8//PDwGUl4YChFD2alUpHS+b0IWfdcLketVtshy3TQ6Xa7tFotMpkMBoOBZDIp/ywyqyIuJgSMtVotHo9HKid1Oh2MRiNWqxWj0YjP55NF5eIYarFYMBqNVKtVisUiqVSKaDRKLBZ7rOay31GpVJhMJmkcRehAfIn623q9Tq1Wo91uyw1JrMfnQSQYBimp9TS63S7VapV8Pi9L0HYzkK1WSyb0ngcR3xUxc7E5Pyp+4XK5pHrV5OSkPAmkUqlXdp/7zkiKxSmO22q1+jFv0ev18u1vf5tIJMJHH31EPp8/EAvxWanVaty6dYvFxUXZbRMIBLhw4QJ2u13WPx47doxgMEgikaDb7bK8vCznBIVCId59913cbjfj4+N4vV4cDofUoRS9sQsLC9y5c4fFxUV++MMfkslknqtdrx/QaDSMj49z7NgxpqenZZhGNCWcPn2abDYrkwK1Wo1kMkmhUJCG4VnXV7vdlqVXYpMfpA3lSTQaDX7yk5+wvb3NuXPn+P3f//1dxXAzmQyfffbZc3t4QknJ5XLh8XgIh8O7GmG/3893vvMdGo0G3/72tymXy/zgBz/gv/yX//LKtBz6zkiKMpNGoyEX2aML1Gg0ymSCzWaT2cTDYijb7TaZTAaVSsXm5qbMYFcqFalEo9VqcTqdskNpbGyMer0ui3rD4TBzc3P4fD6mpqbw+/07er+FJ5ROp1ldXWVlZYW1tbXXcrx52ahUKtmIINZLr5fi9XoZHx+nWCyiUqmoVCo7MvaPapeKNdpbiiXWYK8HKTzSg7AuO50Om5ubdDodXC6XbE4QiGsslUpsbGw890aq1WrRaDR0Oh30ej3NZnNHzkHcX/HsA0xOTgJw9+5ddDod9Xr9cHTcCEqlEmtrazID24vNZuPYsWP4fD4+/fRTrFar3L0PE91ul42NDT799FMCgQClUgmv18sbb7zB5OSkPLpYLBbefvttZmZmqNVq1Go1HA4HMzMzWCwWKb+fzWbZ2tqiVCqxuLgoO28WFhZkDeEg0ul0yGazbGxs4PV65cwa0cE0MTGBwWCgXq+Tz+dpNpuyO6Rer1MqlXYYyUQiIU85Op0Om80mh1X1NjdYrVZcLpcUghAb/6DEcXsRvdXNZpMrV67wl3/5lzvGNuTzebkBLywsUKlUnuv91Wo1N27cwGKxEAqFmJ6exm63Mzs7Kzd7h8Ox688ODQ1x8eJFkskk8/PzB1vgohexIwGPPZzCSGazWYLBIBaLBZVK9cp2kn5mY2ODzc1NXC4X29vbspZtZGSEbrcrjeSFCxceuzePKvlkMhnu3r3L9vY2P/nJT9ja2pJF1oPc/ikk+CKRCENDQ+RyOTl0zmg0Mj4+zvj4+A5PWugXij8LOp0Ot2/flokrEdMU81aEkVSpVFitVhwOhzSKlUpFdkANGt1ul0wmQyaToVarkc/nZTJVeJnr6+uy6PvrrBWxFoWRDAaD/OZv/iZjY2NS/X03hoaG+MY3vkEkEiEajR4eI9loNMhmszidzh2LVNzI3szaQSzefR5EeCKTyQAP2sDW19dxOp1SNv9RgygeZlH3mMlkWFtb4/bt27J4t1AoDOxD3YvoEkqn02xsbHDt2jXsdrsce2E2m+VG29vXLo7Sj6ofud1uuQmJ7xWDrESbohiBYTQaKRQKFItFKpUKqVRKVhiIU5KoeS0WiwMRvxTNDL196mIm+YtspOJnRfcXwJ07d0in03S7XdmKbDabd8QrRb3qq8q0962RLBQKcoSscN0HXcPwVVKpVFheXpb1j5VKhWPHjuHxeHZtA+t0OtRqNYrFIn/zN3/DpUuXSCaTbGxsyGOhSKINOp1Oh1gsRiqVYmtri6+++gqDwYDb7ZbH7ampKVlnqtVqCYfDeDyeHZP+hAGdmppidHRUvr+oKABkhjYcDvNHf/RHUlxEVGukUinq9TrpdJpyuczGxgbz8/Nks1lu3749EElIIWrby8uMvebzeSqVCqurq9y7dw+j0cgf//Efo9PpcLvdUpnqddG3RlLssqLtTcSQFCO5O51Oh3q9jkqlkt7JXuGHXmHeQqFAMpkkHo8/s7jDoCG0NoVau06no1AoyOmG4r+9iS9RiiZ63Hvn/oi1KMY1iI2od/yIeB+j0Uin05GK8Y1GA41GI+tWC4WCVJQXm1M/e+8vY27Ms75/uVxGq9WSzWalXuTr3kT61kiK+rRarUY8HpdxN6Fd1++77X4gEgkicy3qyZ70veLBnJ6eplAocPfuXaLR6IE0kgJRBdBrrAqFAktLS9L4qdVqWSdqs9nwer3o9XpZXC/m+3g8Ho4fP47NZsPv92O32+XgMKFyXiqVMJlMUtrOarWi1Wpl18+JEyd466232Nraolarsbq6SjKZHLgyq4NMXxtJETMrFApkMhn0ev0Tg7eHHRFPEyNiQ6EQTqdz1ziN2GBE54Tf72diYoJEInHgPfXeLiFRf5vNZp/4/RaLBZfLJXU19Xo9NpsNq9XK6OgoTqdT1piK97p79y6pVIqvvvqKTCYjx0M4HA5GR0cxm82Ew2FMJhNDQ0PMzc2xvr7OJ598IpWcFCPZP/S1kRRq28lkkmg0itVq3TFXQ6VSyQC8SqWiWCweWg/TbDYzMjKC2+1mdHRU6kSKUa9C4cbhcOB0OuUxUKfTMTIygk6n21H6I3q9DztC5qter9NqteQxXa/XYzAYZIZbrMlsNsu9e/dIp9NEo1FKpZI0emazmXQ6jV6vZ2lpCbPZjM/n49q1a6RSKebn54nFYs+k0XgYsFqtnDhxAr/fz9mzZxkaGsJqtb52hfy+NpIiLrmxsYFer5fqNAJRxiGKS+PxeF/Hcl4ldrud8+fPMzQ0xLFjxxgfH6dSqZDNZikUCly5coV0Os2RI0c4cuQIFouFYDCIwWBgbm6O2dlZtFot8Xic7e1tLl26pBhJ2DFvuzdxKPRN2+32jux3LBbjs88+k/ddKDWJL+HZ97ZEWq1WWq0WuVyurxS59xuXy8Uf/MEfcPz4caanp5mYmNiXEcZ9ayQFwqPcLXsmOimcTqcsfzmsCHVsm82GyWRCq9VKId5CocD29jbxeFzGxtxuN3a7XfYyC03KkZER1Gq1nB54UDLcL8KjUyhF3FKIioipk/CwLVF0pDxt0xb1mELh6aD0er8Ioi1WzEMXozaeNBqjV+fhVThJfW8k90L05ApRghs3bhzaXdhgMDA0NMTIyIjsqS0Wi6ysrBCNRvnZz37G8vIyfr8fn8/H0aNH+dM//VMCgQBOp1PW9bndbjnXXKj/7BWzO4xYrVbsdjuhUIjh4WGGhoZkneTz0msYD9NQu71wOByEw2E5EfTIkSOyxGo3RJdPIpF4JV1hA20khUiBx+ORxcCHFY1Gg8VikQW3gCxQzmazRKNRNjY2KBQKpFIp9Ho92WxW/gw86GSy2Wx0u108Hg8Oh4NyuXzoRvc+DVEVIIaymUymrx0ne7Sjp5/Z7aj7Ih02j9Lbn+3xeHbMRN8N4akLEZJisfhK7uVAG0mFh4jG//HxcWn0KpUK8XicZDIpM7m1Wo1sNsv8/Dz/5//8HwKBAN/73vc4ffq07C5xOBz86q/+KnNzc/z85z/n0qVLNJtNarWaYix5WBXQ+3XQxZ91Oh0XLlxgbm5O/l21WuX+/fukUiny+fwLnTjUarVUOj9//jy/8Ru/gc/nw+/37/r9tVqNX/ziF6yurnL16lWWlpYol8vPpSz/rChG8oAgjtvDw8PSSFarVdl7LZIPQuCiVquRy+Xwer0cPXqUubk5WTRts9l47733KJVKJJNJbty4IQufD3t8Eh7Wo4r7dZDmkT8JrVbLm2++yW/+5m/Kv8vlcvzwhz9keXmZjY2NF1KqF0YyEAjw5ptv8i//5b/c83RYq9X47LPP+Pjjj9na2mJtbe2VrU3FSA44QqHdYrFgMBh2zCMXAqi7zToWbYmlUonl5WWuX79OMBhkampKZl273S6jo6OcPXuWeDzO7du3FSO5C70P8kEL+RgMBjlOeGhoaMccH6PRyMmTJ/F4PBgMBkqlkhwz+6wJFJvNxsTEBFarlZmZGQKBABMTE0+cOimSNJlMhlQqJds7X+UJRzGSA47D4SAQCBAOh7HZbDJbDQ88yVgsRiKReOwY0mw2KRQK1Ot1fvzjH3P37l0++OADRkZGMJlM8r3ef/99RkdHuXbtGuvr6wMrl6bw9XC5XLz//vsMDQ3x1ltvMTs7K1/rdDrMzs7SaDT4/ve/T7VaJZvNsry8/MzrZHR0lH/37/4dw8PDTE9PEwgEZGvoblQqFVZWVojFYiwsLDA/P/9c422/Dn1vJIXCjejhVtiJKEMRwgq9hc2dTmfHzOxHEa+n02nUajWZTEaWo4j3sdvtBINBXC7XoThWKuxEnCpEgurRwV8mk4lOp0MwGCQYDKLT6chms/L00mu8eid1ihbQYDDI8PCwrBJ40sRJIWZcLpelnmexWHwtM6763kjWajXu379POp1menp6R8eNwovTbrfZ3t4mm81y4sQJkskkjUYDu90ue4yFGs5BT04oPE6tVmN9fV0KEu+GWq3mrbfewu/3k8vlpPBtLBYjl8vJ7zMYDIRCIakS7/P5cLlcsrlht3EQgBwMmEqluHv3Ln/5l39JPB5ncXHxVVzyY/S9kWy1WsTjcVkUrWRXXy7dbpdCoSD740ulkhRz0Gq18s9PGvyksFNs5aCtz2azSSaTkapFT2J0dJTR0VHy+TzBYFBKHcZiMfk9JpOJ2dlZXC4XY2NjjI2NPfPnEEnElZUVPvvsM+Lx+Atd1/PQ90ZSDAVrt9syMCwEURV2R7TACU9QSHR9HUTv8kEQ31V4fprNJslkkmazSTQaJRqNysmTu60pg8FAIBDA4XBgNBoZGRmRr+l0OgKBgBzt+zRqtZqcq3Tz5k3u3bvH6urqc4+GeFEGwkiKSXa5XE7GIPaqwD+sPCpKLFq7SqXSE1u6nvQe4n3q9TrFYvGVZxAV+pNarcbm5ibpdJrl5WWWl5flQLXdjKQwjN1ul6mpqcfWjIh1P0vIrFwu8+WXX7KxscHHH3/MZ599JvU6Xyd9byThYf92uVwmmUxitVrx+Xz7/bH6glarJftWS6USpVIJs9mMwWCQM7WbzabMGIruiF7xWIfDIWW7hDKQWMSlUolEIiGHZykcPkSCT2SURZzRaDTuGGEsMtJf59Qiwj61Wk3Oes9kMqyurhKNRkmn0/vWzDAQRhIe3MTFxUV+/OMfMzo6ygcffPBYpu0wIqTu7XY79+/fp1arMTExQSAQYGhoiO985ztsbm6ysrIii8GFarbdbsdqtfIrv/IrUjloaGhIhjPa7TYLCwv87Gc/Y21tTVEFOsQ0m00+/PBDvvzyS3w+HzMzM3i9Xi5evMjw8DDBYJBQKPS1k6qNRoNr166xtLTE/Pw8ly9fplKpyNPjfsogDoyRhAeCDdFoFLPZTKvVUowkD8cSlEolstmsLPrtdruYTCYCgQCtVkuq/gjVGaPRKEd1Tk1NcfLkSTnzRaVSyWON6PtOJpOKJ9nDbv3KBzkc0el0iMfjxONxWSrm9/uZmprCZDJhsVjweDzyhAI7PUoRzxb3rVf8GB7U9MbjcTY2Nrh//z5Xr159JS2GX4eBMZLdbpdsNsvq6ioWi4VarSZnhyg82EBu3rxJKpXaIVTh9XoxGAz80R/9EclkUhpJofJuNBqZnZ2V2pJCXu3evXukUimuXr3KnTt3BmaS3+ug2WxSrVZ3fAlJOTH58CBLnolxz0LI2el0Mjo6ytjY2I6RFl6vF5vNRrFYlAPQEomELAhfWlqS79lqtVhbWyOZTPbdnKWBMZLwYIJiJBLB5/Mp2nuPUC6X5dS92dlZxsbGMJvN0lv0+XxSl7PZbMp5K73D1UTBbrFY5M6dO2xsbHDr1i1WVlakcVV48ED39sDXajXq9bo0nqKI+qCuTbExACwvL6NSqRgdHZXzy/V6veycsdlsVCoVtra2KBaLLCwskMlk+Kd/+ic+/fTTHU5Ov96vgTGS3W5Xtj2tra3x05/+FJvNxvLyMslkks3NzUPtVTYaDVKpFK1Wi1u3btHpdPB4PHI0g16vl1JXarV6R4+t6MoRMaBMJsOtW7eIxWLymH2QH/rnRRjD7e1tPv74Y7xer/Qe79y5I/VND8v96na7clyuWq3mypUruFwuVlZWcLlc5HI5otEo1WpVGstUKjUwa0rVfcZP2Q9dLqLtTnhBarV6x5jQ11U/9XV/sa/yHqpUKqlKEwqFcLlcTE1N8dZbb2G32xkfH8dut8tkTbFYZGlpSY54qFQqRCIRFhYWyOfzrKysyLavZrP50hdzP97D5/kMQgnIbrej0WhkrE3MMn9ZGot70U/3UFRKiNlJYhqnSACK1ljR9irmke83z3IPB8aThIfzeEWBs8JDRI+76JCo1+uYzWY5jMpgMFAulymXyzgcDrm79xrJaDTK1taWrEl93UW7g4IoSRMjjxUePpuv01l5XQyUkVR4Ot1uV3bI1Ot14vE4Op1OzowWX0K1XMQoxdA1MdfmdQgHKCgMAgN13O4X+umYM6go9/DFUe7hi/Ms91BRLFBQUFDYA8VIKigoKOyBYiQVFBQU9uCZY5IKCgoKhxHFk1RQUFDYA8VIKigoKOyBYiQVFBQU9kAxkgoKCgp7oBhJBQUFhT1QjKSCgoLCHihGUkFBQWEPFCOpoKCgsAeKkVRQUFDYA8VIKigoKOyBYiQVFBQU9kAxkgoKCgp78MzK5IpQ50MUsdMXR7mHL45yD18cRXRXQUFB4QVRjKSCgoLCHihGUkFBQWEPlGmJCocSrVaLy+XCZDIRDAYZGhqiXq+TyWSo1Wpsbm6SyWT2+2Mq9AGKkVQ4lBgMBmZnZwmFQvzKr/wKv/Ebv0E2m+WLL74gFovx93//94qRVAAUI6lwyNBoNOj1eqxWK4FAgHA4TCgUIhQKodfr8fv9dDodzGbzfn9UhT5BMZIKhwq3283U1BTBYJB/8S/+BUePHsXv96NSqTAajYyPj2OxWHA6nWg0GrrdLp1OZ78/tsI+ohhJhUOF0WgkEAgwPDzM3NwcJ0+elK9ptVocDgetVguj0YharVYMpIKS3VY4XIhEjd/vx2Aw7HhNq9Vis9lwOp2Ew2EmJyfx+Xyo1cpjcphRfvsKhwqz2Uw4HGZoaAij0bjjNa1Wi91ux+PxMDo6yuzsLMFgEI1Gs0+fVqEfUI7bCocOlUolv3qp1+vkcjkKhQLpdJpcLke1Wv3a7X8KL45KpUKtVuN2u3G5XOh0OkwmE2q1mkajQavVolgsks1mabVa1Gq1lx4iUYykwqGn2+3S7XZJp9N89tlnxONxLl++zPXr12k2m7Rarf3+iIcSlUqFXq9Hp9PxrW99i/fffx+Px8PMzAxarZbt7W0KhQLXr1/n448/Jp/Ps7GxQaVSeamfQzGSCocKtVqNVqtFo9FIT1JksOv1OvF4nK2tLdLpNMVicZ8/7eFGrVZjMplkHHlychK/38+JEydkaCSbzZJMJvF6vahUKqLR6Ev/HIqRVDgUqNVq1Go1DoeDyclJAoGArIWs1WpUq1U2Nzf5+c9/zvr6OpFIZJ8/sYLb7eZ3fud3GBsb48yZMxw7dgyz2YxWq0WlUmEymWi325w+fRqn08nGxobsmGq1Wi/t2K0YSYVDgfAgrVYroVBoR3a71WpRLpdJJBLcuHGDlZWVff60CgA2m41vfetbnD17lkAggNfrla91Oh30ej0mk4mpqSmmp6e5f/8+//AP/0AkEqHT6fSPkTQajZw6dQq/349Op0Ov18vXut0uuVyOcrlMu91+7EPX63Xq9TrNZlN+z6N0u125K4jvV3gyGo2GkZERvF4ver0es9lMtVrl7t27ZLPZHd8rjptqtfqxJIaI04mvQUckavR6PXa7HZvNhlar+Aj9iNVqxeVyMTIygsvlwmazodPp6Ha7FAoF1tbWqFQqbG5uksvlcLvdBAIBEokEwWCQWq1GNBolkUi8lM/zwqvE4XDwp3/6p1y8eBGbzYbD4ZALstVqcffuXdbX12XmqfeBy2QypFIpSqUSGxsbuxrAdrtNuVym2WySTqcVI/kUdDodFy5c4K233sLpdBIKhYjFYvyn//SfHjOSwjiKGF0v7XZbblC7bV6DhlqtRqPRYLFYCAQCeDwepbSnT/F6vZw5c4axsTFGR0fx+/1oNBo6nQ6RSIS///u/JxaLcfXqVba2tjh58iQXL15EpVIxNzfHxMQEn376af8YSXiwAEVq3uVyybR9u93G7/fLVH29XpdGstvtYjQaMRqNlEolgCcayVKpRKvVkkHcXkPb6XTkw9xsNul0OjQaDTqdDu12+0A84M+DWq3GZrPh9XpxOp14vV4ajQZmsxmj0YjBYMBgMMjfmVqtxmAwyDiPSqWS97DVapHL5cjlcvt9WS+MMJK9Xy/7/XfzyAG5FhX2Rtw7ERIJBoMyBlmv1+V6jMfjbG9vk0qlSKfT5PN5SqUSRqNxxzp/WbywkWw0Gty9exetVitT8zqdTj6I4XAYn8/3WA9sp9Oh1WrRaDRot9tUq9VdYwidTodarUa73aZQKFAoFHa8ViwWaTQapFIpotEopVKJ5eVlisUimUzmMe/pIKNSqdBoNPh8PiYnJzGbzTgcDur1OhMTE9RqNWZnZ5mdncVoNOJwODAYDLjdbqxWq9zcms0myWSSSqXCD37wA3784x8P9JFbpVJhMBiwWq0YjcaXPr5ApVJht9sxmUzSAPdmzguFAqVSSTGWT0Gv16PVajlx4gT/5t/8G9xuN8FgEJVKxfb2NhsbG9y8eZNLly6RSCQoFAq0Wi2q1SqFQgG1Ws3Y2Bh6vR6n0/nSPtcLG8lWq0UmkyESieByuSiXy+j1enmMM5lM2O32Z16Yu8XGhFdTqVQol8vytU6nQy6Xo1KpEI1GMZvNshhYo9FQqVRQq9UHJq72LKjVasxmM06nU3qNFosFt9uN1+tlcnKS06dPY7FY8Hq9GAwGgsEgDodDekONRoNoNEo+n+fKlSuoVKqBv39i49bpdC/VSIqNyWg0YrFY0Gq1O+LynU6HZrMpN3px8lHYibiPOp0Or9fL3NyctBvCGdre3mZ7e1uWaAnEKbXdbmO1WqU3+bLW7UvxJO/cuUM8Hmd5eZkrV65gNBpxuVzo9XpsNhsmkwmHw/HUFi+NRkMgEMDpdO7oitBqtbJ/VgRw4YEBNRgMtFotHA4Hfr+farXKsWPHKJfLLC0tsba2RiKR4O7du1QqFRlrO2iI47PBYMDpdOLz+aQsmFqt5ld/9Vc5d+4cQ0NDDA0NyUWpVqvlBqTX6+XiMhqNNJvNA5Hc0Gg0hMNhpqamGBsbe+FrEt6i0+nkyJEj2Gw2ZmZm8Pl86PV6DAaDNMSdToeFhQVWVlbI5XKsrKzIkiOlSP0hGo2G4eFhfD4f4XAYrVYrT5H1ep379+/zySefsLm5+VhYTpxKW63WK3m2X/gJqNfr3LlzZ4dRM5lMhEIhTCYTbrcbh8PByMgIZ86c2bHLPopwt8UOIgyqWJQ6ne6xn+m9KcJjFMeaW7ducffuXe7evUskEqHZbNLtdg/kkUdkbo1GI06nE7/fL1+z2Wx873vf23Fv6vU62WyWdrst74vYdEQRb7vd3vP3NSio1WrGx8c5f/48k5OTLxyPFJtPMBjkvffeIxgM8uabbzI+Po7BYMBkMkkj2W63uXz5MlevXmVtbY1SqUQul6PdbitGsgdRlTEzM8Pw8LCUqSuXy5RKJW7fvs1HH31EpVKhWq3u+FnhrfetkQQeO87W63UZKxT/Dw8UWHYzdAKdTker1SIaje4wkk9CJCmMRiMmkwmr1YpWq5XHKofDwdDQELlcjnA4jF6vJ5FIyETRQcJoNBIOh/F6vdhsth2viZBFu90mHo+TSCSoVqtkMhna7TZOp1N2NVit1n26gleLiLfudtQWsXGR8NsNEcbQarV4vV68Xi+jo6OMjY3h8/lwOBwYjUbZRtf7c263m9HRUbRaLdlsllwux8bGBtlslnK5TLFYPDCnG1GLKkJter2eYrFIOp3e1TkRJyCLxUIoFGJychKv14taraZer7OyskIqlWJ7e5tKpbIj+SuoVqskk0k6nQ4bGxtYrVby+fxLu6ev5CzVbDZJpVKoVCri8bi8EZ9//vme8SDhhT4tMyU8VqPRyMmTJxkeHmZsbIyTJ09itVoZHR3FYrEwNjZGMBjE5XKRSCTY3t7m008/PZBG0uv18mu/9msMDw8zPj6+47Vms0k8HqdYLPKTn/yE//f//h/lcplkMolKpeLIkSMEg0EuXrzIyMjInhvZQaRWq8l63ic9WHq9nrGxMZxOJ2+99RYXLlzA4/Fw9OhRLBYLRqNx13inWq1menqakZERSqUS3/jGNygUCnz66acsLy+zuLjIV199dWC8SqvVyvHjx7Hb7YyPj+P3+7l58yYffvjhrslZnU6H2+3G7XZz8eJFvvvd78q6yHg8zve//33u3LnD0tIS2Wx21yLxeDxOoVDAYrEQjUaxWCwsLS29tGt6JUay2+3SbDa/1s8+abfvRXiZImPZ6XTQ6XQEAgEajYaMDfXG6NxuN9Vq9cAaABHwDgQCmEymHa+JyoBsNks0GmV5eZlyuUwqlZLeuFarpVAo7Ij39v73ICNisnspyGg0Gmw2Gx6Ph3A4zPj4OA6HA4/HIzf13nBPL6I0RZykisUiKysrlMtlYrHYS8+27wfCUzcajXi9Xlwul4x/b29vYzQad5TpCTQaDSaTSSYXfT7fjnhkLBZjY2ODXC73RJvSaDRoNpuyKqNUKr1UkYu+i8p3Op1nWjRiR5mfnycajXLnzh2++OIL/H4/v/7rv87w8DCjo6OEw2Hgofd5UDEajYyMjDA2NiaP2yLemEwm+cd//EcWFha4e/cuyWSSZrNJu92WCYhgMCgTZmKBViqVr73ZDQrdbpdoNMqVK1dYXl6mVqvteF2cglwuF++88w4zMzPMzc0xNjYmwzqArOOrVCrkcjm5uahUKpxOp7y3drsdo9HIuXPnGB4eptVqce3aNarVqowNDyIOhwOn08n09DS//du/TSgUkqEfjUbD1tYWqVSK+fn5HXW3ZrOZiYkJgsEgHo8Ho9EoQ0Hb29vE43FZjrYXIqQUj8fRaDQ7qmBelL4zkvBs3ovYsUVZgCgWHhoaYnh4mEajgc1m22EkDzJ6vV7uxEJMVhSF5/N5rl27xpUrV2SJlECtVstd3GKxyLKJRqMhyyoOOplMhqWlJba2tmQcXSCMpNVqZXZ2ltOnTxMOh3ckxkQzQ71ep1AokEgk5H3r7fQRcTqj0cjk5CTBYJC7d+9iMBheaeLhdWA2m/F6vYyMjPDmm28yMjIiY5K5XI6ZmRmsVqv0CgUGgwG/308oFMJqtUpPO5fLyfitqId8GqLY/GXTl0by6yCMZrPZlPJJlUplYBfds2K1WuXkv94+V5VKRSaTYXFxkc3NTRKJBOVyeVcj4PV6GRsbw+PxyDrJbDZLOp2mVCod+Hu4G6JmNBgMMj09TSgUkj3xQj2o1WpRKpWo1+ssLy+TSqVIJpNsbGzsMJJTU1OMj4/LIWR6vV5WDYjCf5HMedlaiK8aEfqamJjgG9/4BuPj49jtdjQajVTkWVtbY319nWQyKZO4vZUww8PDDA8Py/uazWa5d+8e6+vrlEqlfS/bO1BGUnTubG1toVarOX78+H5/rFeO2+1mfHycyclJhoaGCAQCsiogEonwox/9iO3tbVZWVkin048tNq1WK6WovF4vGo2GVqtFJBIhGo0eiJbEr4PoHJuenub3fu/3CAaDnDx5kmAwKGt2hZBCLpfjww8/5Pbt22xtbbGwsLDDSJ49e5YTJ04wOzuLz+fD5XJhMpnkUfPtt98mGo2STqcHzkiK0rzz58/z7//9v8dqteJ2u4EH6299fZ3r169z69Yt2XkEDz1sp9PJsWPHGB0dxel0yvDHJ598QiwWk4rj+8mBMZKPctC7bISn43Q6GRkZIRgMotfrpYHsdrtUq1XS6TSZTIZ6vf7EpISo7RMJCNEvn8/nH4vRDSq1Wo18Pv9YjR08fNB7+9eFkbRarfj9frxer2w7FKeWarVKPB4nnU7L0qpMJkOxWNxhJFOpFLFYDJfLRSaTQaVSyZIhIbhRr9dlp9qgrFuRzBKaDU6nE51OR61Wo9FoyKRLIpGQ5TtiDYqaXqvVisPhwG63o9Pp6HQ6VCoVUqkUmUzmsZPPfnDgjKTIsFkslgNRCL0b4pii1+t5++23+dM//VNcLhdutxuVSiWTMolEgps3b0qlpd1Qq9VYrVZpBFQqFdVqlcXFRebn50kmkwPz0D6JdrvN8vIy1WpVdhL1Yjab8fl8lEol2XdttVplGcv58+dlKAMelFTV63VWV1f5m7/5G6LRKAsLC8Tj8cfiuJ1Oh/X1dWkoHQ4HoVCIt99+m/HxcUZGRvjud7/LwsICly5dIplMDowwi8lk4o033iAcDnPs2DFsNhulUon5+XnS6TR/93d/xxdffLGjTrLdbqNSqQgEAoyOjnLixAmOHj1KKBRCrVZL7/zq1atks9m+KNc7cEZSdJ4YDIYDK4XV2+caDAY5duzYDuUTkdUWZT7ZbHbPLLVOp9tR59dut8lms6RSqYE7/u1Gt9sln8+jUqnI5XK71uqJft/e9lej0YjNZsPn82G32+X3i1KWQqHAysoKGxsbbG9vk8/nd/33i8UixWIRi8XC5uam9JbgQUx5eHiYYrEoPdVBmfWt1WoJBAKMjY3hdrvR6/V0Oh1Z/L28vMz9+/cf+zmVSoXZbMbj8chyIbvdLqspSqUSiUSib8ZnHCgjKdReRkdHmZ6elp7VQdJFFPRKc/Vm7pvNJnfu3GFtbY3r169TKBRkz/rTED2w1WqVSCQiC3gHnW63S61Wo1gsPjb9UKVSSUEFoXb9NMQGJFrmyuXyM2dfS6WSlP6DB8dOi8WCzWaTIiS5XK5vDMRuiCy91+vl7NmznD59mpGREVqtFul0mi+//JLNzU1isdhjPys2+HA4zBtvvMHExAQGg0GK1YivftooDoyR7O3CGR0d5ciRIzKALJI6u6mjDyLiWoWh7DWYrVaLO3fucPnyZRYWFsjn888sVCw2EzHvZWVlZeCP2vDgukQ8bLcRsT6fD51OR7lcfiYdwkajQbFYlAbvWY2kEJAuFovy+7VaLVqtVhaqezwe2dbbr4hYrRDHvXjxojy9ZDIZfvnLX7K8vEwymXzsZ3uN5Llz56QSVafTIZvNsr29vaPOtB84MEZSHItGR0fxer04HA60Wi2NRoNyuUw8HicWix2IRITwmM1ms0zWCJHjVqtFPp8nHo+Tz+efuCmoVCrZkSRUloSHJB7iflqoL8pe17LbHO5Go0GlUpE1e4Ds3dbr9XLEwOTkJHq9nrW1taduRo1Gg3Q6LQ1yq9WSG5xWq8XtduP3+weioqB39Ifos65UKnLTqFQqj20cWq0Wl8slY8AejwebzSZHs0SjURYXF4nFYn3lzBwYIzk+Ps4HH3zA8PAwx48fZ2RkhEajQalUYmtriy+++OIxHbpBRZROuN1unE6njKWJB3t1dZXr16/LGrPd0Ol02O12KW6h1WrJ5/Nsbm6ysbFxIDaTr4vQL6zVakQiEebn52U9o5iPYzab6XQ6/PZv/zbb29v87d/+LalUas/3LRQK3L59W27YpVJJziEym80cPXoUk8lEPp9nbW3t9VzsC9B7iimXy7KxI5lMkslkHouDG41Gjh8/TjAY5OzZs8zNzQHI+O6lS5f49NNP2d7e7qtOrwNhJEUgOBgMEggEsFgsGAwGarWajB0VCgWKxWJf3fwXQRyvRRyx0+lQLpfJ5/Pk83mKxeKuiikC0QUiuhyEkRX3ab9r014FIuxSr9dpNBo7BClE3Z5Op5OlKGLTyWazUqFKfK9QBfL5fLTbbVkZsJfHKt5TKDL1fq94P4vFMlD6AsIDF2VRvZJ9QqtUlOMJxXBx0jOZTLKVs1qtks1micViOzQE+oGBN5Kivi0cDvPWW2/JflFRenH//n1u3rwpFcwPQvKm1WrJzPPS0pIs1L158ybpdJpbt27J6ZNPWmwul4u3335bihDodDoymQxXr14lEon0RenFy0RsJPF4nGvXrhEIBJiZmZGeuChLmZubw2QyyVNHJBLh448/Znh4mJGRERnnhgf1pYFAAHhwP61Wq1Qh3w2LxcLU1JQcRCay2QcBh8MhN9s/+ZM/IZFIsLCwwPb2ttxsnE4np0+fZnJyknA4LMvNNjc3SSaTRCIRYrHYnjW9+8FAG8neol8RHxKLvtvtkk6nWV5eJhqNUqlU+qIw9WUgjoP1ep1EIsHW1hbxeJzLly+TTCbZ2tp6anzMbDYzOTkpx3aq1WpKpRIrKysHJnbbixibIEaS1ut1wuGwLIDWaDTY7XZCoRD1ep1MJiOTCffv35enkl6EQHS9Xpdyad1u94kepcFgwOfzydOOMCoHATGkT6VSceHCBTKZjIy1isYEj8fD6OgoExMTUvBDtBGL4vF+jMcOtJEUghZer5fh4WFMJhNqtZpCoUCj0WB1dZVbt24RjUYPjIEUiKPf0tISH330EYVCgdXVVVny8yTEUdFqtTIxMcHIyIgU2i0Wi2xsbJBMJg+ckRRGq1qtkkgkZFJPIBR6Tp06hdfrJZ/Pk81m6Xa7xONxDAYD29vbeL1e7Ha7DFM4HA46nQ7hcJixsTFSqRTVanXXE4soARKC1OJ7Doo3CQ82gqGhIRwOB91ul4mJCer1OqVSCavVyszMzA5xZ7HR1Go1PB4PPp+PWq3WV5oBA20kdTodR44c4ejRoxw9elQW/IrC3hs3bvDJJ59QrVYP1EMv9DqbzSbXrl3j5s2bsnxnNz3DXkTczeVyceLECamLCMijej6fPzCx21663a70lkUsDB7G1bxeLx988AGZTIZoNEo0GpXHwVarxfLyMhaLhdHRUaxWK3q9XnYqHTlyhFwux/z8PFtbW7saSSEcotfrd2R/D5KRNJvNzMzM0O12OXHixI75M6JT7NGZVUJYRUj9JZPJPQWQXzcDayRFoN3j8TA8PCyPjI1Gg2QyKTNsooq/X274y0YYy2dFSOVbrVbZr91qtSiXy1LT8FFh1INEvV4nl8thNptJJBJ4PB55P0Qyq91uEwqFGB8fl3OejUajlEFzuVw0m80ds7zFOiwWi/j9fhlX63a7MhkkxB/EJEsYTAm/3gSYCPcYDAZZjmY0GtFoNHLgWu8oXbEhiDIhkRXPZrPyBNhveYOBNJIi1mG1Wrlw4QK/9Vu/JY8/yWSSjz76iPn5eW7fvk25XFbGeP4zwlsaGRlhfHxclv9sbW1J1fKDvKEApFIprl69Kuv1bty4wZtvvsnbb78tvRq73c5v/dZvcf78eVZWVrh69SrtdpvFxUU2NjZotVqyCFrMWLpw4QLHjh3j1q1beDweGcNst9v4/X6pziQ2qXA4/EpmgL8Oms2mHPH6//1//x83b95kdHRUnkqmpqZkUkp4jFqtVp6AWq0WN27c4NatW6TTaebn58nn89y7d49YLNZ3m/RAGsneQmi/38/o6Kh8TcyMXl1dJZPJHMhSlhfBZDLhdDqx2+2yv71SqZBOp+UR5yAbyXq9TiqVotFosLa2RqfTYXJykk6ns2OInJDu0mg0sqYxk8mQz+elxyO8IrVaLZWCSqUSGxsbO4ryexXyO52OnIXem7QR3tluM1z6DWHsKpUK6+vrcuyFEA8OBoOyFEiUWanVahkSEp05q6urJJNJ7t+/L730fqyqGCgjKZIOfr+fN954g2AwyNDQEIAMDqfTaalo/KzteIcFlUrF8PAwFy5cYGJiQs4dEWVEIlZ30BFtisvLy2SzWSYnJ0kkEphMJux2u0xs6XQ6ZmdnMZvNslWw3W4zPT29Q9wYHtathsNh3n33XZrNppy+KBI9Aq1WK+PAgkqlws2bN7l//z7RaPS13o/nRRjxarXK6uoq8Xicra0tbt26hclkwufzYbVaefvttzly5Ah2u13KwQmFoMuXL/Ppp59SqVSkGG+/Pq8DZyQ1Gg0+n4+LFy8yPDxMKBQCHsaastms3O379abvFyqVilAoxNmzZwkEAjIeuba2xrVr11hfX++7eNCrol6vs7a2xvb2NmfPniWVSmG327FYLGg0GtkF43K5mJqakq1z7XZ7h/ak8AbFf0VDw6M87VhdqVS4e/cu169ff6nzWV4V4n5sbGwAO69PpVJhsVio1Wro9XqGhobw+XzU63WWlpZYX1/nl7/8JVeuXBmI9TZQRtJiseBwOAgGg4TDYYaGhqTkeyqV4saNG2xubpLNZuVgJoWH9aR6vV6qzVitVnkEEkfJfsoovg7a7TaNRoONjQ0uX76M0+lkYmICi8Ui+4rFEVzEwcVGvVd94/PEGdPpNNvb2ywuLpLP5/sycfEsPNo9JHRdhb4APBRzzuVyu46X7VcGxkiqVCqCwSBHjhzhxIkTXLhwgUAgIDXs7t69y3/7b/+NZDLJ0tISxWJxYH4JrxoxNtZsNjM0NMTk5KQcb1qpVIjFYiwuLg7Uwn1RxLCzZrPJJ598wldffYXH4+H06dN4vV4uXrzI3NwcNpsNr9crB4LBy81I379/n7//+78nGo2yubkpE42DilqtRq/XS7XyQCAgQxitVotEIsHm5uaOYXT9zkAYSVFm4XA4CAQCsvXQbDbLEh8xgjKXy1Gr1QZyN35V9AoRGwwGKbArVINqtRq1Wu3AZ7YfRSSpisWiHC8gipnj8Ther5dWq4XRaJSSZr0ydcCeHqWg1WrtKFwXtaydTkd2SMXj8QOxboUHKb5EcrBXCFoU0w8KfW8kdTodPp8Ps9nMN7/5TX7rt34Lt9uN2WymVqtx6dIlFhYWuHr1KltbW4diVvTzotVq8Xg8uFwuXC6XTNgkEgk5EfGwjI/dDVEilsvluHnzJgaDgVgsht/vZ2xsjNOnT2OxWAiFQjJWKY6RYq70k+h2u6yurrK6uirHzjabTVKpFOVymdu3b3PlyhUpxDLo2Gw2jh8/js/nY3x8HK/XS6PRIJFIEIlEuH//Prdv3yaTyQzMhtz3RlIcFcXg8zfffFPGhsrlsqxjW1hYIJfLKQZyF0S21ul0YjabpaJN77CvgyJI/HUQHmWtVmN7exuVSkU2m8VsNnPkyBE0Gg0ul4tut4vD4ZAtd51ORyZ6nkSn0yGdTrO0tCQ9qXq9LmPnYtzqQYmfGwwGQqEQQ0NDuFwuLBYLrVZL6nLG43FZjzso9L2RFHNcxFxpMa1OyPFvbm4yPz9PPB4/tA/50xCCrr09s6LdLhaLydKWQdnZXzUiXtntdtna2uLatWuYzWaWlpbkLBwR07VarU+NUa6trRGJROSxu9VqyURZNps9UOvWYrEwNzfHyMgIHo8HeDhHW8QihSLToND3RlKv1zM2NsbExAR+vx+tVitHDBSLRRYXF/nlL385EEW4+4XYaMbGxqT6SrlcZnFxkUgkcuAe1JeB6PcvlUqsr6/vUC/vVTF/liROr5cuNiLhvT6t137QcDgcvPHGG0xPTxMMBgFIJpNcuXJFzhYfJC8S+thIigl2LpdLyksJNehyuczm5ibxeFzuTApPpve4LXqGRbJLlEspPM5BNGKvClEaJQR3Rf82PJwJNKhizn1rJL1eL0ePHmVoaIj33ntPdjkIodn//b//N1tbW8zPz+/3R+179Ho9ExMTHD9+HL/fj0qlkqME1tfXD8RIC4X9xWQyybk/Nptth8J6pVIhEonIueSDRt8aSdHe5Pf75Zeo8s/n86ysrLC5udnXU+X6BbVajcVikf3a8KAsRXQoDVI5hkJ/otPpMJlMGI1G9Hr9DgUgMWtqUCcD9J2R1Gq1aDQaRkZGeP/99wkEAoRCIUwmE8vLy3Lg+draGvF4fE+BWYUnI7pNDnPpj8LLQTR6HD9+nLm5OZxOJ3q9nnQ6TbValYmrQQ3t9KWR1Gq1hEIhLly4INWK9Xo9yWSSr776iuXlZSnvpfD16B1KpcTcFF4Uv98vRZzFiUXIqW1tbckqikFca31lJEVniJgaJ+aGiOl2sViMpaWlgauz2i/EIHgRTBdlK4+ilP4ovCjpdFrWKmu1WiwWC9vb22QyGVkjOqjrrO+MpJgF7fP58Pl8mEwm2RVy48YNfvrTn1KtVpVj9jOg1WoxmUxYLBY5p9tkMu33x1I4YHS7XSlIrNFo+Ou//mvZqy0UzKvVqmIkXxbC++md5yvmSffOzh7UG74f9NbyiSRNrVaTi1hB4UURoZuDSN8ZyXq9LvtYhVLItWvXpNp47+wQhb1pt9tyjEA+nyeTyVAoFMjn89y6dYtkMilVthUUFHanr4ykkHcXKsVCmWZra4u1tTWy2azSPvccdDodOdirVqtJFWgxCbBUKlGr1ZT7qaCwB31lJAE5L+PWrVv8xV/8BZ1Oh3v37pHJZIjFYsoD/TUoFAr89Kc/5d69exSLRQqFglI+paDwjKi6z2h1XudUN6HX11uQKr76wUh+3c+wX5PxhDK5UCIXX/vZIjZo97AfUe7hi/Ms97AvjWS/oyzOF0e5hy+Ocg9fnJdqJBUUFBQOI0/XnldQUFA4xChGUkFBQWEPFCOpoKCgsAeKkVRQUFDYA8VIKigoKOyBYiQVFBQU9kAxkgoKCgp7oBhJBQUFhT1QjKSCgoLCHihGUkFBQWEPFCOpoKCgsAeKkVRQUFDYA8VIKigoKOzBM4vuKvJKD1Ekql4c5R6+OMo9fHGe5R4qnqSCgoLCHihGUkFBQWEPFCOpoKCgsAeKkVRQUFDYA8VIKigoKOyBYiQVFBQU9kAxkgoKCgp78Mx1kgqHg0dr6JRhmgqHHcVIKkimpqY4d+4cRqMRq9UKwI0bN7h9+zbNZpNaraYYTYVDh2IkFSRHjx7lz//8z3G5XASDQTQaDf/1v/5XIpEIlUqFRqNBu93e74+poPBa6XsjqdFosNvtGAwGrFYrdruder1OJpOh0WhQKpWo1+v7/TEHGp1Oh0ajwWKx4HA4sNvtmEwm1Go1Op0OlUqltLI9BXF/NBoNWq2WbrdLs9mk0+mg0WhQq9WoVCr5X6PRiFarRavVotfrabVaFAoFms0mzWZT2Yz6iL43kmazmXPnzhEMBjl37hxnz55la2uLn/3sZySTSW7cuMHm5uZ+f8yBRa1W43A4sFqthEIhwuEwVqsVrVZLq9WSD7ViJPdGo9Gg0Wgwm83YbDba7TbpdJpGo4HJZMJsNqPRaNDr9eh0OkZGRnA6nTidTgKBAPl8ni+++IJUKkUul6NQKOz3JSn8M31vJDUaDR6Ph6GhISYmJpibm8NoNPLVV19Rq9XQ6XT7/REHGpVKhcFgwGw2YzabMZlMGAyGxzwaJRb5OCqVCo1GIz1DnU6HzWbD5XLRbDap1+vUajVsNhsWiwWtVovRaMRgMBAIBPB4PHg8HoLBINlslqWlJVqtFtVqdb8vTaGHvjeSFouFN954g9OnTzM8PIzJZKLb7ZJKpYjFYsqCekE0Gg2hUIixsTGGhoYwGAw0Gg1u3rxJMplkfn6eTCYjj44KD7HZbExOTmK32zly5AjBYFDGcxuNBisrK5RKJdxuN263G71ej9lsRqfTYbfbMRqNGI1GzGYzlUqF0dFRMpkMP/jBD/j5z3++35en8M/0vZE0GAzMzs5y/vx5dDodOp2OTqdDLpcjm80q8cgXRK1W4/P5GB0dxefzodfrKRaLrKyssLa2RiQSoVgsKp7kLpjNZqampvD5fLz77rscOXIEn8/HyMgItVqNe/fuUSgUCAQC8t7a7XbU6sfLk5vNJmNjYxSLRW7dusXHH3+s3PM+oW+NpF6vx2Kx4HK5MBqNaDQaCoUCpVKJra0tGbtpNBr7/VEHGo1GQzAYZHZ2lmAwiFqtpt1uk8/nyWQyh95TF/FYg8FAOBzekdxyu90cO3YMh8PB6OgoHo8Hi8WCWq1Gq9XidrsxmUw4HA4MBgNarfaJsd1ut0uj0aBWqx3YpI1arZZhCZfLhdfrRavVYrPZZChCr9fT7XbpdDrUajXW1tYolUpks1ny+fy+fO6+NZJWq5WRkRGGh4ex2WwYDAaWl5e5d+8ed+/eZXV1lXg8rhwBXxCdTseJEyf49re/jd1uR6vV0mw2icVirK+vk8/nD7VHo1Kp0Gq1OBwOLl68yNjYGLOzsxw5cgSDwSDvmc1mw2g0ykSXwWBgdHSUbrcrDeNeCbB2u02lUqFUKh3YjV/kFywWC+fPn+fs2bNygzGbzYRCIRwOB+12m2azSTwe52/+5m9YXV3l1q1bipF8FI1Gg8FgkDuwWq2m0+nQaDRoNBpKmcQLIh5+g8GAyWTCarViMBjodru0221qtRrlcplWq7XfH3VfEV6h0WjE5/MRDocJBoP4/X50Op085YhSKeENCm8IoNPp0Ol00Ov12Gw21Gr1jiO3KBdKpVKkUinK5fKB2JjEpqDT6TCZTJhMJsLhMA6Hg3A4TCAQwGq1yg3GZDLJjUacaJxOJ3a7Hb1ev2/X0bdGUmQKbTYber1eZhEVXg5Go5FAIIDX691xTBTZ1UQiwfb2NsVicb8/6r6i1+txOBwEg0Heeecdzp49i9VqxWKxyOx2t9ulWq1SLBbZ2Njg3r171Ot1qtWq9IqazSYjIyPSYxebv3h9e3ub73//+ywuLnLv3r39vuyXgl6vR6vVMjExwfnz5/F6vbzzzjvSOFosFiqVCtFolGazSTKZRKfTEQwGmZqawmQyEQwGqdfrzM/Po1Kp9mXz6FsjKWrKhIEUu4tSs/dyEBlWp9OJyWRCp9PR7XZptVo0m03K5fKBPvo9K+JEY7FYGBoaYmxsbMfrwmNsNBpUKhVSqRRLS0tUq1XpiTcaDVqtljSmZrNZekbCSBaLRebn57l9+za5XG4frvTlIk4qer0ej8fD9PQ0Q0NDvPHGG4TDYXkaTKVS8l4VCgXUajVmsxkArVaLxWKRjtJ+0bdGcjfcbjdTU1PkcjmlPvIF8fl8/MZv/AbhcJjx8XE0Gg2ZTIZoNMrq6irJZJJCoXDojaTwZvx+PwaDAYB6vS6P1ZlMhnK5LJsatre3WVpaQq1W4/V6MZvNTExMMDIyImNuer1eho3m5+e5evUqkUiEjY2Ngb/n4nhtMBg4deoUo6OjzM7O8vbbb2M0Gtnc3GR9fZ21tTXW19cpFotEo1EAzpw5w8jIiHSG+oWBMZIqlQqPx4PBYCAejytG8gUJBAL85m/+pqzz02q1FAoF7t+/z/r6OqlUSun64EGZz/DwMMFgcIeRLBQK5HI5lpaWSKfT/OAHP+D69etUq1UKhQJ2u5233noLvV7P9PQ077//PkajEZvNhkqlolgsUqvV+Oqrr/if//N/ks1mWV9fp1wu7/MVvxgig22xWDh37hzvvPMOY2NjnD17lnK5zI9//GPW1ta4dOkSly5dkicXq9WK1+tlfHx81xKp/WRgjCQgEw16vb6vdppBQvQLiyC5iI0BlMtltra22N7eVupP/5l6vU46nUan03Hz5k1ZhlYqlSgUCrICQBwb1Wo1Ho8Ht9vN5OQkQ0ND+P1+WfoiEhLZbJZcLkcymSSXy1EsFg9EksxgMOD3+3E6nfj9frxeLwBra2vk83lWV1flJizWmEh82e12GR/vp+d7oIykMJBms7nvdptBQdT5eTwebDYbZrNZGsnenvj9KrfoN1KpFL/85S8xGo3Mz89jtVqp1+vU63WazSb5fF7GcOv1OqOjo8zNzTE8PMy/+lf/isnJyR2JHpVKRbPZ5N69eywuLnLjxg02Njao1WoHwki6XC4uXrxIKBTiwoULHD9+nPv37/NXf/VXJJNJLl26xPb2NpVKhWazicFgwOl04vF4OHLkCGfPnpV5iH6hb42kyGL1ZrOEYVQy3V8fUdtnsVik+o8o+xGJh2w2S7PZ3O+P2hc0m02Z8W+32+j1evl34u+73a5MMtpsNoLBIKFQSH4BMjPb6XRkoiaTyZDP56nVagN/v0Vi1WQyEQgECAaDUiilUqmwublJIpEgHo+TSqXkcy1qSkUZmghHCHqVk/aLvjaS7XabdrtNp9PZcVMVvh5qtZpjx45x8eJFpqamsNlsAKTTaXnUTqVS0jtSeIBYi6VSCY1GI+se1Wo1FosFg8HA8ePHCYfDHD16lHfeeQen0ymPmu12W2a5C4UChUKB7e1t4vH4gWn59Pl8hEIhjhw5wnvvvYff7yeRSPCzn/2Mr776iitXrshr771eo9FIKBSSRrW3ekUYXavVqmS3d0Psur0GUvz9QVhU+4FKpSIcDvPWW2/h9/sxmUyoVCpKpRLpdFq2fpVKJaVQ/xE6nc5jcVq9Xi9V3I8cOcKxY8c4fvw4Fy9e3PFQCyNZrVblPRYxSeGJDjoOh4ORkREmJyc5ceIELpeL1dVVbt68yd27d1laWqJWqz32czqdTqohGY3Gx7zI3oaS/aJvjWS1WmV7exuDwSDjPSLpoPB8qFQqKYEmukYcDodsQVxYWGB+fp7FxUVF7YcH98tutz+mAelyuWSGGx5kvn0+HxaLhbNnzzI2NiYV3TudDuVymWazSSQSYXt7m3w+z9raGsVikTt37rC9vU06nR54I6lSqfB6vRw7dozR0VHpdW9tbbG4uMj29vZjm654lr1eLydPniQcDuN2u4GHjlC9Xicej7O1tbWvlRZ9a3FExq/ZbEqhBZPJpBjJr4FWq8XpdGK1WhkbG2Nubk5mWvP5PJ999hk//vGPZYb2sHuRarWaYDBIMBiUAhVWq1V6SMLbsdvtjI2NYTKZ8Hq9WK1WKb5br9dJpVIUi0U+/fRTPv/8c+LxOLdu3ZJJCxFKGvRNSaVSMTY2xgcffIDNZqPZbFIqlbhz5w6XL1+mUqk8lpQSAjajo6P82q/9GqOjozI8IZoaKpUKS0tLLC4ukkwm920z6VuLI25Uq9WSR25xk0QlvtVqPTBZwVeJ2LHdbjdOp1MqrVQqFdnpkM/nqVQqA+/VvAgajUZ63EJj02g0ykRXKBTC6XRKI2m1WnG73VIXUqPRyKRMpVIhEomQy+XY2tqSCQuRqDkIiMLx3u4tnU5HqVSSHVuVSmXXcjLRjSNijlarVdY+i+RWrVYjl8uRTqf3VY2qb43kXtjtds6cOYPL5WJ+fp5YLLbfH6kvEUFwl8vF9773PY4dO8bJkydlMbPYodfX10kkEjQajYH3al4Eu93OqVOncLvdfO973+Ps2bNotVp0Op3cmHubGITwBUCtVpNZ3Hv37pFOp/nFL35BLBYjmUzKUQ6D3E3zKFqtlqGhIex2O1NTU0xOTpLNZrl8+TLxeFx21OyWR7BYLPh8PrxeLy6XS4Z/4EGoLZVKsbm5yVdffcXt27f3tch+II2kCPZWKhXW19f3++P0NWq1Gr1eL0df+Hw+qVaTTqdJJBIUCgWq1eqhNpDw4AjYm6U9deqULEHZCxF/rNVqZLNZ1tbW5NE6Go3KNsaDhsju2+12+VUsFkmn08RiMQqFwq6nPJVKhV6vx2q1YjabZf2zQNSdijKpZDL5Oi/rMQbSSAr5KiU+uTdiIXo8HgKBAKFQSNahiR1f9Bu32+1DfdQG5DF7eHgYq9X6zA0LQrgin8+zsrLCpUuXyGQysqvkoMZ4xUlFSBmKMITI5u/1c8PDw7z55pvMzs5Kb1yE1aLRKJ999pnsZtpvBtLKCIkq8aWwO0Lmy+VySSMpFnIul+Pzzz9nbW2NWCx26L1IeHC/gsEgQ0NDsmbvWeg1kqurq/ziF784MJqQT0M8g71GsjeXsBuiFO3ChQsEg8EdRrLT6RCNRuWRvR+k+gbSSCo8G0ajUepFiuOMaKcrFouUy2VFWLeHTqcje7JTqZQstoeHiURxtK5UKlitVkZHR6WREPqJ4v8frfE9aIh7odPpZAa72+1iMpnkdMhehPiFwWDA7Xbj8/lwOp3AA8MqlKcikQixWIx0Ot0XTQ0DYSSFW9/7pfB0PB4PZ86ckcfHbrcrxRgikYjMuPbDQuwHqtUqm5ub1Go1VCoV8XhcviZq/xqNhixLOX78OP/23/5bvF4vOp1OZmktFgudTodKpXJgj9rwwLDFYjGy2SzxeJxSqUSn08Hv99PtdqUupECr1Uq5uNnZWU6dOiU3lkqlwrVr11hYWODq1atcuXKFarXaF0IrA2EkRYzjIC+4V4HYsV0ulxTVrdVqUslGeJXKUfsB7XabYrGITqd7LFkgXqvX62xubrKxsYHH46HRaNDtdneIRIsH/6Bv5mJ4WW85Wb1ex2QyYbPZcDqd0lOEB+vR4/HgcrlwOp1S9KPVakm1pWg0Sjqd7ivB5743kq1Wi1QqRTQaJRgMYrFYDvQR5mUgjnxDQ0NcuHABv9+P3W6n2+2ysbHBl19+ycLCgpLRfoRCocD169fR6/Vcv35dxsoEogBc1JWGQiH5IIvsrs/nIxAIoNVqD3wNrwhBdLtdlpeX+eijj3C5XExOTkptgO985zvy+0VVislkYnZ2VtZUrq+vk06n+fTTT/niiy/IZDJ9dd/63kiKHTybzeJwOPb74wwEIvvvdDqZmpqSCxMgk8mwtLTE1tZW3+zU/UKtVmNjY+OZv7+3xEXoRYpxs6KN9qAj4q6JRIK7d+8yOTnJm2++idvtxu1276hv1Gg0smjcZDLJ4vtEIkEsFmNxcZHbt2/v49XsTt//Fnvl4JVM9tMRNWhGoxGz2YzFYpELstvtkkqluH//vixuVni5OBwOpqensVgsbG1t9UV29lXTu65KpRI+nw+XyyXl08SmbTAY5FRO0d9eKBS4d+8eW1tbZDKZ/b6UXel7I6lWqzEYDHKnVtgbIWZhs9lkq5jdbpexn83NTT7//HOpiajwcvH5fJw/f56NjQ1u3ry574XQr4tIJEIqlcLr9VIoFHA6nQwPD8vKCpPJhN1ulzO2O50O7XabVCrFpUuX2NjY2JEo6yf63kjCwz5PxZN8Omq1WsbGnE6nvGfNZlMqajcajQOdBDOZTFLBp1cOrlqtyiTBiyCSM0Jw5VFR2MMo5yfua7lcJpFIUKvVUKvVVCoVuWmL0boqlUpOmBSJxFwu17dVFn1vJMVD73a7ZVxNYXfE+NOzZ89y9uxZTpw4gU6nkzVoxWLxUAz3mpiY4PTp07jdbo4ePYrRaOTSpUvcvn2bTCbDxsbG1/aiVSoVgUCAkZERZmZmsNlsO0JBlUpF9msfpnCGUDRKp9N89dVX8ngtYuPinp07d45wOEy5XCafzxOLxVhbW2Nzc7Mvyn12YyCMpBKTfDq9LWJer5fR0VHcbrcsahZqP/26EF8mQsLM7/dz+vRpjEajLFButVpoNJoXasM0m8243W4pytC7LpvNJpVK5dBJzgnveTcRD5fLRavVwmAwUK/XZVa8VqvJmdv9PCWy742kwrOh1Wqx2+04HA6mpqY4ffo0DocDlUpFoVDgs88+Y3V1lYWFhQNd9qNSqRgdHeX999/H4XAwNDSEVqvl/fffZ3p6mjt37gBICa5KpfJcnTFitPHMzAzDw8MYDAbZlthoNIhEIty6dYtkMkmlUnmVlzowtNttarWa/BJjLIR0XL9vJoqRPCBotVpsNhtut5vx8XGOHz8ue2FLpRJXrlzh+vXrRCKRAx8vC4fDvPvuuxiNRhkv9Pl8tNttAoEAy8vLMm4mPOvneVBFLeDQ0JBs9xQeUTQa5d69e1KfU+HBvRXxx0ajQb1ep1QqkclkKBQKfb9p972RFGUC2WxWZm4VHiJKLOx2O3NzcwQCATweD4AULY3H43KGzX6Kl74uhLESsWyhwg4Pss9nzpwhk8lgs9nIZrOk02lZErXXfB9RyiKUlex2+47EWK+3VK/X+/7hf12IbiSDwSAndIrYbb8Vju9G3xvJRqNBNBpleXkZYId8vgIyQD4+Ps4f/uEfMjY2xszMDPCgcPz27dtsbGywsLDA6upq3x9tXgZbW1tcvnyZYDDIhQsXZJZfo9Fw9OhRwuGwHA2QyWS4du0aV65cIZ1Os7CwsKsHKIZSCaWgI0eOPKbyLoZ7FQoFyuWyYiT/GaFcbrfbpfJ7IpHg2rVrRCKRvk9w9b2R7HQ6UnwzHA4DD2sn9Xr9oTeYBoMBm82Gw+EgEAgQCAQwmUzywU0kEiSTyb7qhX3VlMtlYrEYGo2GUqkkPRihJG40GqWSuNlsJh6PE4lE0Gq1xGKxHQo+7XabZrMpy4nMZrMUsjAYDHKedq1Wk8K7ItOr8AAh/iGU3YXo86BsJn1vJMvlMleuXGFrawuTycTc3BxWq5W5uTkcDocMxB82hGL21NQUZ8+eZXJyksnJSfx+v6wLnJ+f5+/+7u9IJBKkUqn9/sivhW63y/z8PKVSifHxceBBjFIkWgQ6nY6hoSE5PuDMmTPEYjF+8YtfyLGvlUqFZDLJysoKJpOJc+fOEQwGOXXqFIFAQNbu1ut1VlZWuHv3Lmtra4fCW38egsEg3/rWtxgaGpKCF/l8nq2tLdLptHLcflEajYZUKP7GN75Bt9tFr9cTCAQAHpNjOiyIWKTf72dubk5Om7Pb7dKjSSQS3Lhxg2w2e6iSCIlEgnQ6TaFQ4Pjx4zQaDQKBwI6ElYjjAni9XmZnZ9na2qJSqZBOp4nH4+TzeTQaDdFoFJPJxPj4OOPj43KuS68SdzqdZmNjg2w22/ee0etGzMAJBoPyeRXx8kGY8d73RlIctwGy2ax84DUajXTdDxtarVbOexazWDweDwaDgXa7zfr6OltbW6ysrFCpVA7dgC9xrblcjqtXr7K2tkaj0SCZTOJyuRgdHZVdM701jlarldnZWUqlEsVikWq1yvHjxzl58iQGg4Hjx4/j8XgIhULy3xGZ2kQiQSQSIZvNHvjqgefFaDTi8XhwOp0yNCG6v5rNZt/fr743ku12WxrGRCJBPB6n2+3K+NJhUFp5FJ1Ox8jICIFAgHPnzvHNb35TFjVXq1Xu3bvHL3/5S+7cuUOxWDwwI0yfFRFLTKVSfPTRR+j1eqLRKHNzc8zNzWE2m6XeYa+RtNvtnDt3bkdbodAyFUIrarUajUaDSqWS86Xz+TyRSITl5WXFk9wFs9lMKBTC7XbLWHm1WpWiuoqRfEHEgm+1WnKCmsjoWiwWnE4nHo9HBuL7/Ya/DNRqtUwgmEwmKfxRLBalVxONRg/9Ayv6gzudDplMhmg0itls5v79+zgcDkZGRrDb7TKZIzqWdnsfQJYRdTodWq0WlUpFqrvncjnK5bIUoVXYiahXFUkt0Zkj9Cj7mYEwkmKhx2Ix7ty5QzAY5MyZM/j9ft58801arRbr6+vcvHmz74PALwOtVksgEGB8fFyWRBUKBe7evUsymeSTTz7h008/pVqt9q1owOtCtMDNz8+zsbHB1atX+dnPfobH4+HXfu3XmJiYYHJykunpaTQaza5G8tGpidVqVWpPfvjhh2xvb3Pr1i3i8fhAPPT7hWhsaDQa5HI5crncngPD+oW+N5Lw0Jssl8uyCFiUdXi9XoaGhsjlcs88AnTQ6dXYhAcPbalUIplMEo/HicVifSs7tR90u11KpRKlUolsNksymcTj8UjxC7fbTb1el5qbe60jsWmXy2Wy2SwbGxtsb2+TzWYPXVjjWeidSyXunVCiEkrv/c5AGEl4sDjX1tb4p3/6J44dO8bx48dxOBzSqywWi4fGSFarVa5du8bq6iq3b9/mRz/6EbVajXg8TrlcZm1tbb8/Yt8iWuRyuRyffvopd+7c4f79+9y/fx+LxUIgENhTt1SsQzGK98qVK9IrUniISqXCarXKTchms6HX69nY2CCTyQxUgmugjGQ0GiWfz9PpdEilUuh0Onw+HzabjaWlpUOjElSv17l79y7AYzqGCnvT7XalruHVq1dRqVRsbGwQiURwOp3MzMzsWVbW6XT46quvuH79OsVikUgkciiUlZ4XlUolE2R2ux2LxQI86ALb2toaKMm+gTGSgJRXSiQSfPbZZ7hcLmq1Gs1mk6WlpUMRj3wUxTC+GOIoLjbgZrMpwxi70el02NjYIJfLye4ahd0RPdui8qLRaBCLxVhdXSWXyw3M2h0oIyliGbdv32Z9fR21Wi3LNYTCiILC8xKLxUilUlLA4mm1t8ITFSMIFB5HVAoIYQu9Xk+lUuHGjRtcvXqVWCymGMlXgTCIohBVQeFl0Gq1DuUp5FXS7XZlqZT4ajablMvlgdMRGCgjqaCgMBiIUQ7FYpH19XU2NzcpFAqUSiXq9fpAbUqKkVRQUHgliK4akf0vFovSQPZ7bWQvipFUUFB4payvr/P973+fer3O+vo65XJ5oJocVN1njJ4eRiGJJ/F1A87KPXyIcg9fnEG5hyIhBvSdF/ks91DxJBUUFF4pold7UHlmT1JBQUHhMHI4+vgUFBQUviaKkVRQUFDYA8VIKigoKOyBYiQVFBQU9kAxkgoKCgp7oBhJBQUFhT1QjKSCgoLCHihGUkFBQWEPFCOpoKCgsAeKkVRQUFDYA8VIKigoKOyBYiQVFBQU9uCZVYAUiaqHDIpEVT+j3MMXR7mHL86z3EPFk1RQUFDYA8VIKigoKOyBYiQVFBQU9kAxkgoKCgp7oBhJBQUFhT1QZtwoKCg8EY1Gg9lsRqPRyL/rdrt0Oh2ZGVapVBgMBoxG43O9t0qlotVqUa1W6XQ6tNttut0urVarr2biKEZSQUHhiXg8Ht5//33cbrc0jPV6nWKxuMNInj59mvPnzz/Xe6vVamKxGF9++SX5fJ5cLkelUiEWi7G8vEy73X4Vl/TcHGgjuVs92GGZe7ZXLdxhuQcKL47ZbGZqaoqhoSFpJCuVCplMRhoxjUbDW2+9xa/+6q+i0Wjodrt7rjGxNlUqFWtra5TLZVKpFPF4nEKhQK1WQ61WK0by62A2mzGZTBiNRlwul/yFdDodstks29vbaDQafD4fZrOZY8eOMTMzQ6VSIZlMUq1WiUQi5HI5isUi2Wz2wBgMvV6Py+XCYDDg9/txOp243W7C4TAAuVyOWq3G9vY2kUiEbrdLs9ncdQZyu92WA+SbzSatVut1X47CPmOz2XA4HIyNjTE3N8fw8DBqtRqVSkWj0aBare7wJMfHx1GpVE81kPBgkxaG0m63c/bsWUqlEoVCgWq1yvz8PBaLhWKxyPb2NuVymVqtRq1We+XXvRsDZSQtFgs+nw+n08n09DQGg4FWq0W322VhYYFEIoHBYGB0dBS/388f//Ef8zu/8zukUilu3rxJJpPh008/ZXl5ma2tLfL5fN/sVi+K0WgkHA7LRTcxMcHMzAzf+MY36Ha7rK2tkcvl+Pzzz/n888+p1+tUKpVdr7/RaBCLxahUKlQqFcVIHkKEgZyenubkyZOMjY1hMBjQah+YjEcNoYhZPqvTIb7P4XDw1ltvyU272+1y69YtrFYriUSCL774glQqRTqdVozkk9BoNLhcLoxGI8PDw9IQTExMYDAYaLfbtNttVCqVdNMDgQB2ux2z2YzRaMRqteLz+dDr9UxOTqLT6QCIxWI0Gg0ajcauHlU/o9FoUKvV2O12bDYbbrebY8eO4XA4mJiYIBwO4/V6MZlMdLtdHA4HarWakZERcrkczWaTSqWy66Ku1+v4/X7K5TIbGxtEIhE6nQ7NZnMfrnRwEb+jYDCIz+dDpVLJZEUkEpGbdD+uvUajQblcJp/PE41G0Wq1OJ1ObDYb9XqdUqlEu92mXq/T7XYxGAwYDAY0Gg0WiwW1eu/CGeFJqtVqDAaD9FK73S52u52RkREsFgv5fJ5UKsXq6iqtVotWqyX/zdd1Cux7I2m1WnnnnXcYHh7m1KlTnDhxArPZjMfjQaPRyDhJKpUiEonIB7tWq+Fyueh2u9hsNo4dO0az2WRycpJKpcKHH35INpsll8sRi8X2bZf6OqjVasxmMwaDgTfeeIMLFy4QDAZ56623cDgcmM1m9Hq9XLQAwWAQv99PKBTi4sWLj2Uoe2m1WuTzeSqVCn/913/NP/zDP1CtVsnlcgfG837VqNVqjEYjRqOR3/u93+MP/uAP0Gq1aLVa8vk8//k//2d+8YtfUKvVKJfL+/1xHyObzVIqlSgWi7jdboLBIKdOnWJiYoJoNMqtW7col8vE43HK5TJDQ0MMDQ3hdDo5cuQIZrN5z/cXRtJisRAKhdDr9ajVatRqNePj4/h8Pmq1GhcuXKBYLPKjH/2In//85/II3mg0ZDb8VdP3RlKj0eB2uwkEAgwPDzM5OYnRaMRms+0IElssFsxms4xrFItFDAaDfA+LxUK320Wv19NqtQgEAjgcDlqt1o7yhn5HrVaj1Wrl9QYCAcbHxwmFQkxOTmK32+UC7Ha7ciGpVCrUajVWqxWr1Sq9mt4guviedrtNsVikWq0yNDSE3W4HIJ/P79t17xfCw+lNhImHufcePloSI9acyWRieHiYubk5dDodWq2WbDaL1+uV4SLhQfUTIh4tPMlms4nP58NmsxGLxdjY2KBYLLK1tUWpVKJWq8lYtsvlwmKx7Pn+4n42Gg2cTqd8NrVaLUajEZPJRLPZRK/XUy6X5clIo9GQzWaBByee17Fp97WRVKlUaLVabDYbLpcLp9OJ3W5Hq9VKd753R1Kr1fIX1Gq1CAaDOxa3SqWSv4jR0VHefvtttra2SCaTfbmbP4rRaMThcOByufiVX/kVxsfHmZqakju3yWQCoNPp0Ol0yGQybG5uUqvVSKVS0ltWqVQYjUY8Hg86nU4+vG63m1AoJD1VnU7H+fPnabfbLC4u8sMf/vDQGEqxTux2O16vF61WK70dn8+H1+vFbDbj8/nQaDQkk0mKxSJGo1HWFRqNRnQ6HW+++SZWq1UaVxE6mp2dJRqNyqNrP1Iqlbh9+zZGo5Hl5WWcTifFYpFkMimP5M1mk0wmw8rKCkajkcuXL8uQ1l6oVCqCwSBvv/02breb6elp/H4/Op0OvV4vnR+j0cgHH3zA1NQUm5ubXLp0iXQ6zZ07d9je3n7l96BvjaTYoUUxq81mk95Tr6ckvlfERAD8fv8T31cEnn0+H3NzcxiNRn7xi1+84qt5Oej1epxOJ6FQiPfee48zZ87ILHYvIk6by+VYXl6mUCiwurpKsVjckVUcHx+XD7VOp6Pb7RIIBKRB0Ol0HDlyBJPJhMlk4qOPPjoURlKlUqHT6TAYDDidTsbGxtDr9fI+TU5OMjExIROIWq2WlZUVEokENpsNp9OJRqNBr9ej0WgYGhraUWhtMBjwer2MjY1RrVb7WrqsVquxtrYGwP3795/4fYlE4mu9/9jYGGq1mlAohNlslnkEcaoxmUyo1WrOnDnDmTNnWFxcpFarsbW1RSQSOZxG0mQyodPp5A4eCASYmZmRi/JlLah2uy2TNv121HkSzWaTYrFIsVikUqlQrVaxWq3Ag2NLLpejXq+zurpKPB4nHo+zvLy8owRKYDKZSCaT6HQ6ec9TqZQ8kgeDQQwGAzqdDqPRiF6v7+uH+WUgTi46nY6pqSlCoRChUIgjR45gMBik0QsEArLMzGw2ywRau92WSTSNRiNPPMLD7/13HA4HXq9Xhj4OK+VymaWlJVKpFPV6nfv37xMOh5mdncVsNkuPXSDCFzqdjunpaVqtFoVCgWQy+cqe474ykmq1GofDgcPhYHJykjfeeAO/38+3vvUtRkZGpBf4Mmi1WlQqFRlLGQRqtRqJRELGZYrFIna7XRb4Li4ukkql+Nu//Vu++OILqtUq+Xx+R8uXQHjparVaHi3Pnj1LPp8nGAzy/vvv4/f75RG/14M/qAiDZrFYePfdd7lw4QIjIyOcOnUKnU63Iwap1WplzLfdbhMMBrFarTidTnw+347s7qMxb2FoJycniUQiB/6+7oUoy1Or1Xz44YdoNBq++c1v8kd/9Ef4/X6sVusOI+lwODh9+jT5fJ56vU4oFOLu3btkMplXVqq270ZSuNUiLma323E6nXi9XkKhkAwWP60vVPR7djodyuWyLK3odrvSWxJxIq1WKz1JUZs1CPT2tWYyGWKxmPRYMpkMkUiEVCpFLBaTMaMnlfmIB10YBpGJFcds8eC2222azebAbCQvgkiICS8vEAjg8Xiw2Wyo1Wqq1SrNZpN6vU69XqfT6dBoNGi1WjLRVa1WaTQaMmTRm8ARiJiw1WrFYDAcaiPZ6XQeqyyJx+NsbW3RbDYJBAK0Wi2sVisWi0Xez06ng9vtJp/Pv3JvfF+NpEajQaPRYLVaZV3U2NgYgUCAubk53nvvPSwWC06n84nvIbLb6XSazc1NMpkMly5dIh6Py+N0MBjkzTffxOVyceLECYaGhqjVaqTTaXK53MAVSxcKBf7v//2/fPnll3i9Xvx+P/l8nvv371MoFIjFYpRKpSeW+MCDuJjP58NisfDOO+8wMzPD1NQU586dw2w2y4xjOp1mdXWVWCw2cPfpebHb7Zw5c0aul7Nnz6LT6Wg2m5TLZa5cuUIymeT+/fvMz8/T6XTkPREnEr1ej8lkwmw2Mzk5icvl4uLFi1y4cEE+yKIrTKVS4Xa7D7WR3I35+Xn++3//7zgcDs6ePYvf7+eDDz7g4sWLmEwmuXHNzc3h8XhkmOhVsa9GUpSzGI1GvF4vdrudcDgsy31GR0dlMuZRhHEUHmO5XCaRSBCLxbh+/Trr6+uylWlychKv10u1WmVqagp44CHVajXpEQwSjUaD1dVVtre3cblceDwe8vk8i4uLVCoVYGdSazd0Oh0Wi0VmFU+ePMno6ChjY2MyrCF2eXG0H7T79Lzo9XqCwSDhcFjWlTabTarVKpVKhUgkwvr6Or/85S+5cuWK3IR616Hw7O12O4VCgWAwyNGjR3f8OyqVCpPJJE9IipHcSTabJZvNyooAn8/H8ePHgYflfDqdDq/XC7Cj7O1VsK9GMhwOMz09TTAY5MKFCzJTa7PZ8Pv9T6xfrNfrZDIZqtUqy8vLJBIJIpEI8/Pz5PN5lpaWpIfYarUolUrU6/UdnTU+n49z587hdru5fv06+XyeVqs1EIag0+nIo5+4PhE6UKlUstBc1JP27rIie+j1ejl58iROp5NTp04xPDyM0+lErVbT7Xap1Wo0Gg3u3bvHT3/6U7a2tgaq4P7rYLPZOHXqFGNjY/IBzOfzMhH25ZdfsrKyQiQSeazrQ/xZnI5sNhvnz59namqK0dHRHQ9xt9ulVCqRyWQol8sDE+553TQaDTY3NykUCmQyGTqdjlyfvbzqZ3bfjKRoiv/Wt77F2NgYv/ZrvyZLWR4tdH6UWq1GNBolm83y0Ucfcfv2bba2tpifn5eGrvdGimLXXiMZCAR44403ZAw0FovJLpR+RyRq4MHRu7ckSmSnRT1lKBSSnqFKpcLj8eD1egmHw3zzm9+Utae9iRmh8Vcul7l9+zY/+clPqNVqO7LjBxGr1cqZM2eYnp6WIZ5sNsu9e/fY3Nzk8uXLLCws7NkSJ+K8NpuNN998k9OnTz8WLup0OhQKBVKplGIk96DRaLCxsYHBYCCdTu+6Kb0OXruRFL3YZrOZUChEIBDA7XbLIPeT6Ha75PN58vk86XSae/fukc1m2dzcJJlMUigUaLVaTxRsyOfzWCwW6QGIIL3NZsPn85FKpchmswNXBygKlM1mM0NDQ7ILRxg/UewscDqdMjFhs9lk+c+jG5IoSG+327tuPAeVR6+x3W7L4/aTVJPgYZ+23+9ncnKSsbEx3G73DsFa0f9eLpfZ3Nxkfn6eeDw+EBvzfvGk9llRG202m6WjUyqVqFarLz3J+NqNpNls5s0332R0dJSzZ89y/vx57Hb7U7PXnU6HO3fucPXqVaLRKJcvXyaXy5FKpfY0kPCgFmthYYFCocA3v/lNWq0WBoOBQCBAo9HgzJkz2O12bty4MXBGUtQxzszM8Gd/9meEw2FCoRBut1tmWAVqtVoeB7Varazx2y3oLQxkb9ztoCPCDNVqFZvNBiC7lbLZ7BMFPkS2Wq/Xc+HCBf7sz/4Mj8fDkSNHsNvt8v42Gg3S6TSpVIof/ehHfPzxxxSLxQOfEHsViHZli8XC+Pg4R48elUIYL7t77rUbSVEL6Xa7cblcsgZvLy9SPLCFQoFIJCKr7QuFAuVymXq9vue/KYqwLRaLPHILQ2EymfD5fJRKpac25fcjWq0Wg8GAzWaTiZdQKITL5ZLlVcAOYyc8F+Et9iqyiH54eFgmpNfr5fcdZGMpysJ6e4JFBvtJYgq9nSFCym98fByn04nFYtlRT1mv18nlcmQyGeLxONFo9NB46K8CcW9Ft53RaHwlWe7XbiQfdZNF//CTLq7VapFKpSiVSly7do2f/vSnFItF0um0TFY8jUqlwvr6OtVqVXqdwjA4HA7ee+89jh8/LjPjg7Ro3W43Y2NjzMzMMDY2xvDwsNx0xIPZaDRIJBJUKhWKxSKlUmmHIRShDr/fz8jIiMwgGgwGpqeneeutt4jFYty5c+dAxyUrlQr37t2jUqlIYWfhce/2AIq6W7PZzPvvv8/s7CynTp0iGAzKelx4kPwpFAqsrKzw4YcfEovFWFpaem0qNgcREZevVquk02mSyaSUAHzZ7IuRFN6J6Mney/qLHuRcLsfa2hq3bt167phDo9EgmUwCSKFZ4bkKBfNKpcIPf/jDr39h+4BKpcJms8n2OY/Hs6OPWwiZ1mo14vG4DE+kUqkdRtJoNEptzkAgIGv9ut0uoVBI9ifPz8/v16W+FkRPsEqlYm5uDkD2YO/WlinEKmw2G8ePH+fdd9+VcmG9IrTlclnWm3788cfEYjFSqZQSi3wBut2ubJaoVCoUCoVXJhTyyo2k6OAQNXler5e5uTlmZmZkQW0vIg6WTCaJRCIUi0WWlpbIZrOsra19rZ3XbDbj9/sJBoM4HA60Wq1cxPV6nc3NTbLZLJlM5qVc8+tCPICJRAKTycTly5fxeDzy9UqlQi6Xk2MrRN/3kzzJWCxGsVjE5XJx8uRJ7HY7gUBA1qiJxNeglEo9L/V6XQomiEFXdrud2dlZbDYbR44cQa1Wy3vodrs5efIkXq+XI0eOEAwGpb6AKNNqNBrcunWL69evs7a2JjPaioDx0xHKVFarVcaIexHdT7VaTbYYv4p1+UqNpKjZs1qtUjRX9AVPTU3t2pIlHsKFhQV++MMfkslkuHPnjjRiX+cmuFwu3nzzTUKhkBRuEP9uuVzmq6++krHOQTv+ZLNZOp0O6XSaQqGwo/0tnU6zsbEhxS9EPHa3TCHA6Ogo169fZ3x8XGbIp6am8Hg8GI1GPvzwQykSexCNZLlcZnFxkUwmIwdd+Xw+3n33XeLxOBsbG7hcLtbW1lhbW2Nqaorf//3fJxwOc+zYMcLhsEyENRoNWS3x4Ycf8pd/+ZfU63V57w7i/XvZGI1GJicn8fv9+P3+x2pNhUJ6sViUzsCreH5fuZG02Wx4PB7ZRePz+bDb7VICCR52doijdbFYJBqNEovFyGQycrE9LUHzJITcmqjU763BbLfbVCqVgd3dW60WtVpNahr2ZrPFxtJoNCiVSk/NooryKofDIe+FXq+XIgPi2Fmr1QbyXj0NIRqr1+vJZDIkk0kMBoMUKvb5fBSLRZncEV05Xq/3sSSNqOVNp9PE43E5qkHJZD8dIb5iNBoJhUKEw2EcDseO7xFGslqtyq65gVQBEsoyouTn3Llz0mhqtVppqEqlEouLixQKBW7cuMHa2hrr6+tcv359R43a14036HQ6nE6nnCbYGwNttVoyVjeISQnheZdKJfL5/I5rE/FIUR3wNPL5PAsLC6hUKnkvTCYTer1eSvj3HnEOGuK4nc/n+fjjjykUChw9epRvfetbOBwO3n//fc6dO0c0GiUajRIIBDh79qzc9OHhbJjNzU3+4i/+gvv377O6ujpQQir7jdiYxsfH+cM//ENOnDhBIBDYUW/aarXY3t5maWmJRCLxSj3zV2ok1Wo1Ho+HyclJRkdHmZqa2lEPKRZNb/3Y0tIS9+/fZ3t7m+3t7RfaeXtlrYTSjTDOvZX7ojZuEHd5IdUFvLCRr9fr5PN5isXijpnKYlcX4ruDNO7ieeh0OnI65ObmplTEb7fbchqlz+fb0dEkhq0JRLeSEBy5ceMGlUrl0B+vn2cOvHheHQ4H09PTHD9+/LGfF/H4XC73RKWrl8UrMZIi6yeSNaIf+9EsdqPRoFarsb6+zj/+4z8SiUTY3NyUwe2vs7B6Rw8EAgH8fj8zMzO8++67UnYfkDJX5XKZTCZDKpWSrX4Kh5t2u83m5ib1eh2n00kqlcJms8kEZCAQkPJnQtFdnHZWV1e5ceMGkUiEeDw+sJvvy0AkBK1Wqxzc9yhimJg4KXa7XYLBIOfPn2d8fBybzbbDAAodWCHocuPGDTY3NwfPk+yNATocDjwej1T06KVer1MoFNjY2OBHP/oRKysrOzy8r/tvW61WjEYjs7OzzM3NceTIEb7xjW9IAQdA1hBWKhXpxQ7icVvh5dNut9nY2CAajTI8PCxVrwOBwI6iceHdiEy2SPz89Kc/JZFISCN5GOkdgeHz+ZiZmdl17k0qlaJYLMoedlGG9s477xAKheQQOjHMTjSGZLNZlpeXuXnzJrlcbvCMpMlkYnJyEo/HQygUkj3CvcmSTqdDKpVifX1d7tov40JFSYtQuhH6lI/2J4t4nSiwFqMPDjMGgwGHwyGHrR1mRHeSWCePrs/etdTpdMhmsyQSCba3t4nFYmSzWRqNxn589H2ht+vF6/XKhJ/RaMTn8zE1NbXrmspkMuh0OsrlsuxsOnr0KMFgUDaaCERtZCqVIplMks/nKZfLr/w+v5Inwefz8bu/+7uMj49z+vRpxsbGpABAb/3YV199xUcffcTW1haFQuGl/NtCBcfpdHLixAm++93vyolrsDMOKhI2KysrLC0tHciM7fPgdDrlPKGn9dIfFsQ6EVqTu9Fqtbh//z53797l+vXrMuF4mDZdMaAuHA7zwQcf4PF4pLqUy+ViaGhox3FbbDKFQoG1tTVqtZqsv/X5fIyMjGAwGB4bTZvP57l58ybRaJTV1VUSicQr71x6JUZSCGIGg0FsNtsO4VwRCxTD7re3t0mn0y8ct+kV8BW1mTabDYfDIesie2+kKMc4yNna50Wv12O327HZbDt2feFVHRShCxFy2e16RC+2aEUUEnJPSjyIkRr5fJ5EIkEmk5H6ngeZ3qSo0GMQDRsjIyNSRFu0HwcCgcfGQMODBgXRMy+MpN1ux263o9PpHotjNptNKcor4sCvmpdqJEUhrcFgwG63SwMF7GjyF2MW7ty5I7N/X3fXFb8kj8cj66mOHz+Ox+NhaGiIVqu1a8BYyFYppRkPcbvdnDhxQo7SAOQ8FyEkMuj3S7QRiuyomJbZ6XSkfJ7FYuE73/kOJ0+eZHJykpMnT+6Yay5oNpuUSiVyuRzXr1/n5z//+UvZ8PsdIapiNBqZmJjA7Xbz1ltv8c4772Cz2QiHw+j1egwGg2zrfNImI2ohhTcoZlKJUr1H8xj5fF4mxrLZ7Ou43JdrJMUuLFL4JpNJeiRiIYpyHzHsZ3Nz84X6LcW/53A4GBsbw+VyMTMzg8fjwel07pD76qVXcv+wl2cIzGYzw8PDsisJHsZuRbG/uGeDijCEwA7vBR5OSxSzbr773e9K4eLdNlrRiCDUqXpFnw8yYsKmmEk1NDTEW2+9xa/8yq/s6Fl/EiIJA8hn91k33kqlwubmJpubmy9dEu1JvFQj6XK5CAaDcqaM0+mUHSD5fJ6NjQ2y2SyXLl1ic3NzRzb7eRC92GazmXA4LGMeU1NT2Gw2hoeHZdmBKAd6dEeKx+NcuXKF9fX1Q1/6I3rZRVzJ5/Oh0+nodDrMz89z+/ZtFhYWpBr8IB8lxWlGbJK9R26LxcL09DQ+n49wOIzb7cZkMj1m9NRq9WMtck8Shz1IiDnsw8PDnD17FofDwdzcHF6vl5GRkV2rV5rNJrlcjlgsJu+jSqUiHA4TDoef+zPY7XaOHz+Ow+GQql6vmpdqJIPBIG+88QZTU1OyBVHcuEQiweXLl4lEIvzDP/wDy8vLeyo974Xdbufs2bP4fD7eeecdpqen5XFbHL/FQt4tDgKwtrbGP/7jP5JMJl+b296PCOk6g8GA1+uVE/5MJhPtdpvPP/+c//W//he5XI719fUdIzAGkVarJT0QEToQhs1ut/Pmm28yPDzM7OysPAY+enwW44/hoU7nowb3oKFSqbBYLFitVs6ePct/+A//QVaviK6sRzeOcrksu+k+++wzGVJTqVR8+9vfJhQKPbf+o8fj4eLFi2xvb7O+vs7GxsZLvc7deKlGUoi/Wq1WaazgoWRXsViUHQ1ihILogHl0dxb9m6LusbcUIBAIMDY2JnvCPR6PFO/d7aaLf793gFY6nSabzVIoFA7FTOknIURIxCgLMURMPPiie0T0fg+ygYSHYRbxZ7EOxfAuIaZgMBhkzDGdTu9YI2KNt9ttefS02+24XC6q1apUEDoIiOSMVqvF7/dLDQaPxyM3U7PZTKvVkp5jqVSi2WwSi8XI5XJsbm7KWkaLxSKLzEXyp/f4/bTPotfr8Xg8tFotfD4fHo9Hiq68Kl6akVSpVFitVoaGhvB6vdKoiQdLzIPOZDI4nU7Gx8cffoh/jhP1xn1E/6bD4eAb3/gGgUBA3lSz2SyFTZ1OJ2azeYdRfpR6vU46naZarXL//n0SiQSfffYZq6urL5Q0OghotVqmpqYYHx+XRyej0ShFHAqFAvl8nmq1OvAGEh6OEoaHU/aE+PPs7CwXL15kdHSUdrvN1tYWt27dkupH7XYblUrFsWPH5Mzno0ePYjQaOX/+PI1Gg5WVFa5du3Zgysl0Op2UK/ud3/kdLl68SCAQkOOexXNeKBSk+O3Vq1fJZDLcunWLjY0NGfpyOp0cO3aMYDAovcjeIXZ7IZ59Md0zn88TiUTweDwsLCxw7dq1V5Ywe6mepCggtVgsO7xIkRwRI1BF4Fx8j06nw2az7TCSZrNZduuImdDiRun1evn9Ykd6EsKLFJJK0WiUSCRCIpGgWCwO5Nxt2DlRUlz/s+zGjx4JdTodLpeLQCCAy+XCaDSi0+lknZ/4OigPfa8nKej1BMVwulgsRj6fJxaLce/evR0qSkajUc4QEpuz1+tleHiYTCZzoOZoixZjq9XK6OgoJ06ckMfuXqek0WjIiQFra2skEgnu3bvHysoK4XBY6kGKDal3Ouej9CZTxfeI51yIrej1esLhMJlMhnQ6jVarfWVJ2FcSkxRuODy8uPHxcX7zN3+TSqVCNpuV7VpqtRqdTieP6PKD/XOZgdlsZmxsbMcAcpHRflL9msjACgm0jY0Nfvazn5HJZFhZWSGVShGPx+Usk0E5GokQhChsNpvN+Hw+AoGA7Gx4UqdMo9Gg3W6TTCbleE548MBfvHhRjn/QarU0Gg2i0ajsaRf9x4O4mTwNMWZ3dnaWsbExDAYDnU6H5eVl5ufnuXnzJhsbG9KTVqvVsh7SbrfT6XTkAyu6QV7FnJX9wmKxcPToUQKBACMjIzgcjse617rdLtFolKtXr8rRF8FgkN/+7d9GrVbLxKpIjImurkfHw4o1KvrfO52OlOg7evQoMzMz8vt1Oh3Hjx/H6/XicDhot9tkMhnm5+cpFosv9R68VCMZCAQ4ffr0juJxkUQZHh4mHA7TbrelJh887PF81JPs5Ume0m7GTXgKrVZLDjWfn5/n//7f/0ssFiOdTu9Q5h4kegvmR0dH8fl8HDlyhKNHj+J0OpmdnX2slg8eBtEbjQYLCwssLi7K6zcYDLz77rtMT09jNBrRaDRUKhXi8Tjb29tkMhlqtdpA3q9nxe12Mz09zcjICEajkW63y9raGleuXGFxcZGtrS0ZklGr1aTTaXK5nBwXoNFoCIVC6HQ65ufnD5RKkslkYmpqipGRkR291MAOIxeLxbhx44ZUE3e5XDKJKzpnRPxWOE69a0oYSbFG//7v/552u43H45Edc1NTU9IG6HQ6Zmdn5bqtVCpsbW2xtbXV30ayXC6TTCZlt8uji0UkaPR6/Y7dVhxZ9jqmPOsRpvdmb25usry8zOLiolQuHuRiaNEXK0ovhoeH5eYjwhy9GxQgRwmoVCparRbBYHBHqYrQ2jQYDNI77/XCB7nc51kRUnAiQ9vpdCgWiySTSUql0g4PundkhtfrlXFKUQB9UHreRSIvHA4zPj7OyMjIDgP5KD6fj7m5Odl9YzAYdpTg9VadALIfXkjLNZtNtre3yeVy3L17l1gsJhV/TCaTzClotVoZBxXvJU5UlUrlldz/l/qOyWSSmzdv4vP5OHbs2GN9l/BQyqzXUO3V9vW8tNttSqUSpVKJS5cu8cMf/lBm2F7VDIzXhdvt5syZMwwNDfEnf/InHD16dNcFKOgtgRIL3O/3c/LkyR3f02sg4UGyLZ1OE4vFKJfLB36UrEgAWq1WNBoNnU6HaDTK3bt3d2hrwk6vSa/X02g05DA1m82G0Wg8EDHJYDDI3Nwc09PTfOc73yEcDj9x5LJKpeL48ePS0xNfvevq0WdcjNUtlUpsb29TLBb58ssvWV5eJpFIsL6+Lr10vV7PqVOn+MY3viFzFUILQsSDjx49ikaj2fUk9aK8VCMp5gobjcY9y2pexCiKnf7RGjfRDVKv10mlUhQKBeLxOIlEglKptGOW8qCi1+txOBw4nU48Ho/UxoQHhu3RB1rsumKhifjv0xbSbhMthfbnQTSW4jp7DZxoWd0tZv2kWdy9M80HHaGdabVaZS/1XuEws9m8w4ju1uEmnlsxpmV7e5tyuUw0GqVYLLK1tUU0GiWfz+8QKtbpdGSzWVKplNzIxLoW84TEeOm+Ttx0u10ymQwLCwvU6/Ud3srLplwuS+UQkTHPZDJEo1EKhQLz8/PkcjlWVlZIJBIvNPqhn7BYLIyOjjI0NPSYodve3uYf//Ef5bjYTqdDIBBgenoau93OkSNHHpsT8iRsNhvvvvsuxWIRt9vN8PAwm5ubXLp0iVKp9Coubd9QqVQEAgFOnTqFw+GQ5U9izIhKpZLzacT3u91uZmZmGB4elp1JxWJRikUfhI1EJE7F5vq0cNheiBrKSqXC0tISuVyOzz77jM8//5xmsymP26lUSoqD9Bq7drvN5cuXKZVK+P1+jh8/jtVqlQI6V65c4cMPP5RJyZfNS49JJhIJbDbbSy8Z6S04rdfrMl4kbnAkEmFhYYFsNstXX31FOp2WBvSgtIvp9XpcLhdOp/MxAdNCocD169dlL3yn02FychKtVovX62V0dPSZjaRer2d8fJxOpyMHpOl0Oq5cufIqLmvfsdlscuMR2X1R9lKpVB4zDhaLRcaGNRqNHAEiREAOwlpTq9WyxO55s/WPXr844ZXLZSKRCNvb21y7do1PPvnkmTy/TqfD2toauVxOtjIKXQafz8fKygpXrlyRo35fNi89yvmiC0QYtWazKRVaBGKxbm5u8uWXX5LJZCgWi1J2TShBFwoF6T0eFAMJD4LdqVQKo9H42Cbkdrt57733yGQyMgwhjKPopNnrfZvNpnwwxLFcpVLJgHy9Xsfr9cqkzkFK6NTrddklIzL8fr+f6elp1Go1kUgEQNZFDg0NMTc3x+joKP9/e+eyk0oTReFlAnqCxgQjARIVW00cGB2YGKf6DMaRT+XDONGRCSMHaiKId6ANfeHS0CAXG7DPaNffHrF/FC+I+xu3pC2KVbuq9tp7eHgYtm3DNE3ouo5yuTwQ861QKCCRSMCyLMTjcZimiXA4jImJiRfP2rYt8pBpjjrnJ+WbVioVJBIJGIaB+/v7N41TvV4XYn18fAyfz4fb21uMjY3h4uJCdFPt6+22k14mCZ0tUJOfTiJ5dXWF/f19KIoiQnRngYFBEkYnjUYDmqbB6/W+cAmFQiFsbW09mySdPOz/QtFitVoVt7xkBfV4PMKD32q1xCququpAiWSj0UCxWIRt2yI6nJ6exsrKCtrtNs7OzgBAWDYlScLa2prICmi326LH+Xt7w/cbqqpC13Xk83nMzc0hEolgfX29o0gCQKlUgizLKBQKODs7exbRKYqCRCKBarUKTdNQq9XenJ9crVZRq9VENwPnZZDTX/8Zv/sPFUlqrEWZ95Qf9VqVaxI0WslJHBuNhjjjcZ4lkkje3d2hWCyK7fZvsRVSlew/f/5AVVWR9uPMQesECSF55oH/tkDksTVNU2wxfT4fZmZm4PF4xGJF7S1+eoGLTtAxETWhIgdOKBTC7OwslpaW0Gq1xBkdpcNQhSDLslAsFoVXeRAWaHKv1Go1KIoiFpDXjtE0TYOiKCKTxFlZK5vNCgMJdSV4D85qS1/JkN3lN9rNoW04HBZJp5ubmwgGg1hdXcXCwkLH5+nGVFVVHB4ewjAMsYXOZrNIJpMd/Zj1eh3ZbPZFPcCv4r0/gl5TQ0ZHR4UHdmNjA9PT01heXhYJ/K8l5FerVcRiMRHlkJdelmU8PDwgFoshk8kgEAhgZmYGU1NT2NnZQSQSQTQaxdHREa6vr0U61UdchH3XGHb6PCoYOz8/j+3tbUxOTuLh4UH0QCLho4ickqVpgS+VStjd3cXBwQFM00Qul/uSOfkVY0gFJchy/FpmBHn9KbfR+f9TJwJnVkq/0M27fHgkWS6XMTw8DEVR0Gq1IEnSq60RaBIWi0Wk02nouo5CoYBKpSIajw96lee38Pj4CMMw0Gw2Icsyms0mAoEAJEkSlw6dkmlpm0L9QJ6enlAqlXBzc4NyuYzz83Ok02mEw2Ex0amoRS6XQyqVQiaTEcIxaJCnf3x8XFgwqQXI0NAQJEkSzzrbWFBkRLseTdMGLtK2LAuqqn73a3wrH367TYe4lmXB5/Ph9PT0WT6fE6d98ObmRmy16SZskCbbR0CRi23biMViSKVSSKVSiEajImWj09kjebHr9br4gTcaDRiGISrFk3De3t4in89jd3cXfr8fyWQSsiyjXC4P5LGGbdvQdV342kdGRkSvdrLhBQKBZxG6ruvQNA3ZbBYnJyfI5/O4vLz88WYFpjMfut3u5e/6KQT/P/plq/jWz33Le3dbwuq99NsYAhClvCYmJkSPm2AwiMXFRXi9XrHAxONxnJ+fI5lMYm9vD7lcTpzrfiX9OIY/jS/fbr/3JZje+Iwx/o3fW7PZFNF1LBZDpVKB3+/H9fX1s94tsizj/v4emqaJ7IpBKSXHvOTTI8lBhFfw3unHMaRCFdTxkyqW/3vOS62IqYDv09PTt5Tc68cx/Gl0M4Ysku+AJ2fv8Bj2Do9h73QzhoNTHZRhGOYTYJFkGIZxgUWSYRjGBRZJhmEYF1gkGYZhXOj6dpthGOY3wpEkwzCMCyySDMMwLrBIMgzDuMAiyTAM4wKLJMMwjAsskgzDMC6wSDIMw7jAIskwDOMCiyTDMIwLfwHicOBLBTGUrAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -386,4120 +372,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(0.677068, dtype=float32)" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z_dim = 64\n", + "gen = Generator(z_dim)\n", + "mx.eval(gen.parameters())\n", + "gen_opt = optim.Adam(learning_rate=lr)\n", + "\n", + "disc = Discriminator()\n", + "mx.eval(disc.parameters())\n", + "disc_opt = optim.Adam(learning_rate=lr)\n", + "\n", + "g_loss = gen_loss(gen, disc, 8, z_dim)\n", + "g_loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 74, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 139/60000 [00:00<01:22, 726.53it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 1%| | 307/60000 [00:00<01:14, 801.44it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 1%| | 471/60000 [00:00<01:13, 808.99it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 1%| | 633/60000 [00:00<01:14, 800.05it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 1%|▏ | 794/60000 [00:01<01:16, 778.34it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 2%|▏ | 949/60000 [00:01<01:18, 747.52it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 2%|▏ | 1098/60000 [00:01<01:20, 733.90it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 2%|▏ | 1240/60000 [00:01<01:28, 660.48it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 2%|▏ | 1307/60000 [00:01<01:29, 656.89it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 2%|▏ | 1438/60000 [00:02<01:36, 608.91it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 3%|▎ | 1561/60000 [00:02<01:36, 603.59it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 3%|▎ | 1683/60000 [00:02<01:40, 582.79it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 3%|▎ | 1799/60000 [00:02<01:45, 552.37it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 3%|▎ | 1915/60000 [00:02<01:46, 543.12it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 3%|▎ | 2026/60000 [00:03<01:46, 543.94it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▎ | 2142/60000 [00:03<01:43, 560.25it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 2257/60000 [00:03<01:45, 545.45it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 2365/60000 [00:03<01:51, 518.84it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 2472/60000 [00:03<01:53, 506.74it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 2575/60000 [00:04<01:53, 504.04it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 2626/60000 [00:04<02:02, 469.09it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▍ | 2781/60000 [00:04<01:55, 494.90it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▍ | 2831/60000 [00:04<01:56, 490.73it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▍ | 2928/60000 [00:04<02:10, 438.99it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 3023/60000 [00:05<02:05, 453.50it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 3118/60000 [00:05<02:03, 460.44it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 3211/60000 [00:05<02:06, 449.22it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▌ | 3302/60000 [00:05<02:16, 416.36it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▌ | 3391/60000 [00:05<02:12, 426.27it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▌ | 3479/60000 [00:06<02:13, 423.14it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▌ | 3564/60000 [00:06<02:17, 411.69it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▌ | 3648/60000 [00:06<02:20, 401.16it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n", - "real shape , (784,)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▌ | 3662/60000 [00:54<14:01, 66.96it/s] \n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[108], line 40\u001b[0m\n\u001b[1;32m 37\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m G_loss_grad(gen, disc, batch_size, z_dim)\n\u001b[1;32m 39\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[0;32m---> 40\u001b[0m \u001b[43mgen_opt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mG_grads\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 42\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[1;32m 43\u001b[0m \n\u001b[1;32m 44\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[38;5;66;03m# mean_discriminator_loss = 0\u001b[39;00m\n\u001b[1;32m 61\u001b[0m \u001b[38;5;66;03m# cur_step += 1\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/optimizers/optimizers.py:29\u001b[0m, in \u001b[0;36mOptimizer.update\u001b[0;34m(self, model, gradients)\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mupdate\u001b[39m(\u001b[38;5;28mself\u001b[39m, model: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmlx.nn.Module\u001b[39m\u001b[38;5;124m\"\u001b[39m, gradients: \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 21\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Apply the gradients to the parameters of the model and update the\u001b[39;00m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;124;03m model with the new parameters.\u001b[39;00m\n\u001b[1;32m 23\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[38;5;124;03m via :func:`mlx.nn.value_and_grad`.\u001b[39;00m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 29\u001b[0m model\u001b[38;5;241m.\u001b[39mupdate(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_gradients\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgradients\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m)\u001b[49m)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/optimizers/optimizers.py:88\u001b[0m, in \u001b[0;36mOptimizer.apply_gradients\u001b[0;34m(self, gradients, parameters)\u001b[0m\n\u001b[1;32m 85\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstep\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstep \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 87\u001b[0m \u001b[38;5;66;03m# Apply the update\u001b[39;00m\n\u001b[0;32m---> 88\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_single\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradients\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparameters\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:48\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:49\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[0;32m---> 49\u001b[0m k: \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:48\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:49\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[0;32m---> 49\u001b[0m k: \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:43\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 42\u001b[0m TreeType \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtype\u001b[39m(tree)\n\u001b[0;32m---> 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mTreeType\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[43m \u001b[49m\u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtree\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 46\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:44\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 42\u001b[0m TreeType \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtype\u001b[39m(tree)\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[0;32m---> 44\u001b[0m \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:48\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:49\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[0;32m---> 49\u001b[0m k: \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:43\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 42\u001b[0m TreeType \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtype\u001b[39m(tree)\n\u001b[0;32m---> 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mTreeType\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[43m \u001b[49m\u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtree\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 46\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:44\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 42\u001b[0m TreeType \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtype\u001b[39m(tree)\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[0;32m---> 44\u001b[0m \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:48\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:49\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TreeType(\n\u001b[1;32m 44\u001b[0m tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[i] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, child \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(tree)\n\u001b[1;32m 46\u001b[0m )\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(tree, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[0;32m---> 49\u001b[0m k: \u001b[43mtree_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchild\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mr\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mis_leaf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_leaf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fn(tree, \u001b[38;5;241m*\u001b[39mrest)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/utils.py:53\u001b[0m, in \u001b[0;36mtree_map\u001b[0;34m(fn, tree, is_leaf, *rest)\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 49\u001b[0m k: tree_map(fn, child, \u001b[38;5;241m*\u001b[39m(r[k] \u001b[38;5;28;01mfor\u001b[39;00m r \u001b[38;5;129;01min\u001b[39;00m rest), is_leaf\u001b[38;5;241m=\u001b[39mis_leaf)\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, child \u001b[38;5;129;01min\u001b[39;00m tree\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 51\u001b[0m }\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtree\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mrest\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/optimizers/optimizers.py:426\u001b[0m, in \u001b[0;36mAdam.apply_single\u001b[0;34m(self, gradient, parameter, state)\u001b[0m\n\u001b[1;32m 424\u001b[0m v \u001b[38;5;241m=\u001b[39m state[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mv\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 425\u001b[0m m \u001b[38;5;241m=\u001b[39m b1 \u001b[38;5;241m*\u001b[39m m \u001b[38;5;241m+\u001b[39m (\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m b1) \u001b[38;5;241m*\u001b[39m gradient\n\u001b[0;32m--> 426\u001b[0m v \u001b[38;5;241m=\u001b[39m b2 \u001b[38;5;241m*\u001b[39m v \u001b[38;5;241m+\u001b[39m (\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m b2) \u001b[38;5;241m*\u001b[39m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msquare\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 427\u001b[0m state[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mm\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m m\n\u001b[1;32m 428\u001b[0m state[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mv\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m v\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + " 0%| | 0/1 [00:00 1\u001b[0m \u001b[43mdisc_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreal\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[89], line 14\u001b[0m, in \u001b[0;36mdisc_loss\u001b[0;34m(gen, disc, real, num_images, z_dim)\u001b[0m\n\u001b[1;32m 11\u001b[0m real_labels \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39mones((real\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m],\u001b[38;5;241m1\u001b[39m))\n\u001b[1;32m 13\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mShapes.....\u001b[39m\u001b[38;5;124m'\u001b[39m,real_disc\u001b[38;5;241m.\u001b[39mshape,real_labels\u001b[38;5;241m.\u001b[39mshape)\n\u001b[0;32m---> 14\u001b[0m real_loss \u001b[38;5;241m=\u001b[39m \u001b[43mnn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlosses\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbinary_cross_entropy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreal_disc\u001b[49m\u001b[43m,\u001b[49m\u001b[43mreal_labels\u001b[49m\u001b[43m,\u001b[49m\u001b[43mwith_logits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 16\u001b[0m disc_loss \u001b[38;5;241m=\u001b[39m (fake_loss \u001b[38;5;241m+\u001b[39m real_loss) \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m disc_loss\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/losses.py:155\u001b[0m, in \u001b[0;36mbinary_cross_entropy\u001b[0;34m(inputs, targets, weights, with_logits, reduction)\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;124;03mComputes the binary cross entropy loss.\u001b[39;00m\n\u001b[1;32m 126\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;124;03m array(0.510826, dtype=float32)\u001b[39;00m\n\u001b[1;32m 153\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m inputs\u001b[38;5;241m.\u001b[39mshape \u001b[38;5;241m!=\u001b[39m targets\u001b[38;5;241m.\u001b[39mshape:\n\u001b[0;32m--> 155\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 156\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInputs shape \u001b[39m\u001b[38;5;132;01m{\u001b[39;00minputs\u001b[38;5;241m.\u001b[39mshape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m does not match targets shape \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtargets\u001b[38;5;241m.\u001b[39mshape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 157\u001b[0m )\n\u001b[1;32m 159\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m with_logits:\n\u001b[1;32m 160\u001b[0m loss \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39mlogaddexp(\u001b[38;5;241m0.0\u001b[39m, inputs) \u001b[38;5;241m-\u001b[39m inputs \u001b[38;5;241m*\u001b[39m targets\n", - "\u001b[0;31mValueError\u001b[0m: Inputs shape (1,) does not match targets shape (784, 1)." + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[69], line 10\u001b[0m\n\u001b[1;32m 7\u001b[0m mx\u001b[38;5;241m.\u001b[39meval(disc\u001b[38;5;241m.\u001b[39mparameters())\n\u001b[1;32m 8\u001b[0m disc_opt \u001b[38;5;241m=\u001b[39m optim\u001b[38;5;241m.\u001b[39mAdam(learning_rate\u001b[38;5;241m=\u001b[39mlr)\n\u001b[0;32m---> 10\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m real \u001b[38;5;129;01min\u001b[39;00m tqdm(batch_iterate(batch_size, train_images)):\n\u001b[1;32m 11\u001b[0m d_loss \u001b[38;5;241m=\u001b[39m disc_loss(gen, disc, real, batch_size, z_dim)\n\u001b[1;32m 13\u001b[0m \u001b[38;5;66;03m# real = real.reshape(-1)\u001b[39;00m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;66;03m# # real = real.view(cur_batch_size, -1)\u001b[39;00m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;66;03m# # Calculate discriminator loss\u001b[39;00m\n\u001b[1;32m 16\u001b[0m \n\u001b[1;32m 17\u001b[0m \u001b[38;5;66;03m# d_loss = disc_loss(gen, disc, real, cur_batch_size, z_dim)\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:1188\u001b[0m, in \u001b[0;36mtqdm.__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1186\u001b[0m dt \u001b[38;5;241m=\u001b[39m cur_t \u001b[38;5;241m-\u001b[39m last_print_t\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dt \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m mininterval \u001b[38;5;129;01mand\u001b[39;00m cur_t \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m min_start_t:\n\u001b[0;32m-> 1188\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mlast_print_n\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1189\u001b[0m last_print_n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlast_print_n\n\u001b[1;32m 1190\u001b[0m last_print_t \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlast_print_t\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:1239\u001b[0m, in \u001b[0;36mtqdm.update\u001b[0;34m(self, n)\u001b[0m\n\u001b[1;32m 1237\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_ema_dn(dn)\n\u001b[1;32m 1238\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_ema_dt(dt)\n\u001b[0;32m-> 1239\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrefresh\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlock_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlock_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1240\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdynamic_miniters:\n\u001b[1;32m 1241\u001b[0m \u001b[38;5;66;03m# If no `miniters` was specified, adjust automatically to the\u001b[39;00m\n\u001b[1;32m 1242\u001b[0m \u001b[38;5;66;03m# maximum iteration rate seen so far between two prints.\u001b[39;00m\n\u001b[1;32m 1243\u001b[0m \u001b[38;5;66;03m# e.g.: After running `tqdm.update(5)`, subsequent\u001b[39;00m\n\u001b[1;32m 1244\u001b[0m \u001b[38;5;66;03m# calls to `tqdm.update()` will only cause an update after\u001b[39;00m\n\u001b[1;32m 1245\u001b[0m \u001b[38;5;66;03m# at least 5 more iterations.\u001b[39;00m\n\u001b[1;32m 1246\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmaxinterval \u001b[38;5;129;01mand\u001b[39;00m dt \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmaxinterval:\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:1344\u001b[0m, in \u001b[0;36mtqdm.refresh\u001b[0;34m(self, nolock, lock_args)\u001b[0m\n\u001b[1;32m 1342\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1343\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39macquire()\n\u001b[0;32m-> 1344\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdisplay\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1345\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m nolock:\n\u001b[1;32m 1346\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:1492\u001b[0m, in \u001b[0;36mtqdm.display\u001b[0;34m(self, msg, pos)\u001b[0m\n\u001b[1;32m 1490\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pos:\n\u001b[1;32m 1491\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmoveto(pos)\n\u001b[0;32m-> 1492\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msp\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__str__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1493\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pos:\n\u001b[1;32m 1494\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmoveto(\u001b[38;5;241m-\u001b[39mpos)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:347\u001b[0m, in \u001b[0;36mtqdm.status_printer..print_status\u001b[0;34m(s)\u001b[0m\n\u001b[1;32m 345\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mprint_status\u001b[39m(s):\n\u001b[1;32m 346\u001b[0m len_s \u001b[38;5;241m=\u001b[39m disp_len(s)\n\u001b[0;32m--> 347\u001b[0m \u001b[43mfp_write\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;130;43;01m\\r\u001b[39;49;00m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43ms\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m \u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mlast_len\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mlen_s\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 348\u001b[0m last_len[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m len_s\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:341\u001b[0m, in \u001b[0;36mtqdm.status_printer..fp_write\u001b[0;34m(s)\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfp_write\u001b[39m(s):\n\u001b[1;32m 340\u001b[0m fp\u001b[38;5;241m.\u001b[39mwrite(\u001b[38;5;28mstr\u001b[39m(s))\n\u001b[0;32m--> 341\u001b[0m \u001b[43mfp_flush\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/utils.py:127\u001b[0m, in \u001b[0;36mDisableOnWriteError.disable_on_exception..inner\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 126\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 127\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 128\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 129\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m e\u001b[38;5;241m.\u001b[39merrno \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m5\u001b[39m:\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/ipykernel/iostream.py:526\u001b[0m, in \u001b[0;36mOutStream.flush\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 524\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpub_thread\u001b[38;5;241m.\u001b[39mschedule(evt\u001b[38;5;241m.\u001b[39mset)\n\u001b[1;32m 525\u001b[0m \u001b[38;5;66;03m# and give a timeout to avoid\u001b[39;00m\n\u001b[0;32m--> 526\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[43mevt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflush_timeout\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[1;32m 527\u001b[0m \u001b[38;5;66;03m# write directly to __stderr__ instead of warning because\u001b[39;00m\n\u001b[1;32m 528\u001b[0m \u001b[38;5;66;03m# if this is happening sys.stderr may be the problem.\u001b[39;00m\n\u001b[1;32m 529\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIOStream.flush timed out\u001b[39m\u001b[38;5;124m\"\u001b[39m, file\u001b[38;5;241m=\u001b[39msys\u001b[38;5;241m.\u001b[39m__stderr__)\n\u001b[1;32m 530\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/threading.py:607\u001b[0m, in \u001b[0;36mEvent.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 605\u001b[0m signaled \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_flag\n\u001b[1;32m 606\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m signaled:\n\u001b[0;32m--> 607\u001b[0m signaled \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cond\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 608\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m signaled\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/threading.py:324\u001b[0m, in \u001b[0;36mCondition.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 322\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 323\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m timeout \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 324\u001b[0m gotit \u001b[38;5;241m=\u001b[39m \u001b[43mwaiter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43macquire\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 325\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 326\u001b[0m gotit \u001b[38;5;241m=\u001b[39m waiter\u001b[38;5;241m.\u001b[39macquire(\u001b[38;5;28;01mFalse\u001b[39;00m)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ - "disc_loss(gen, disc, real, batch_size, z_dim)" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "784" - ] - }, - "execution_count": 86, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "real.shape[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(8, 784)" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "real.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "real.reshape((-1,len(real))).shape" + "z_dim = 64\n", + "gen = Generator(z_dim)\n", + "mx.eval(gen.parameters())\n", + "gen_opt = optim.Adam(learning_rate=lr)\n", + "\n", + "disc = Discriminator()\n", + "mx.eval(disc.parameters())\n", + "disc_opt = optim.Adam(learning_rate=lr)\n", + "\n", + "for real in tqdm(batch_iterate(batch_size, train_images)):\n", + " d_loss = disc_loss(gen, disc, real, batch_size, z_dim)\n" ] } ], From f8b7094fb8069c8be381714e9a316c999ace2e97 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sat, 27 Jul 2024 01:19:50 +0300 Subject: [PATCH 08/38] Updating GAN Code... --- gan/playground.ipynb | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index ed96d59b..d1352ed6 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -402,29 +402,20 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/1 [00:00 Date: Sat, 27 Jul 2024 01:20:00 +0300 Subject: [PATCH 09/38] Updating GAN Code... --- gan/playground.ipynb | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index d1352ed6..400d07b5 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -402,9 +402,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 77, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[77], line 22\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m5\u001b[39m):\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m real \u001b[38;5;129;01min\u001b[39;00m batch_iterate(batch_size, train_images):\n\u001b[1;32m 13\u001b[0m \n\u001b[1;32m 14\u001b[0m \u001b[38;5;66;03m# real = real.reshape(-1)\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m# print(len(real))\u001b[39;00m\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# break\u001b[39;00m\n\u001b[0;32m---> 22\u001b[0m D_loss,D_grads \u001b[38;5;241m=\u001b[39m \u001b[43mD_loss_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreal\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 25\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:34\u001b[0m, in \u001b[0;36mvalue_and_grad..wrapped_value_grad_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapped_value_grad_fn\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 34\u001b[0m value, grad \u001b[38;5;241m=\u001b[39m \u001b[43mvalue_grad_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainable_parameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value, grad\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:28\u001b[0m, in \u001b[0;36mvalue_and_grad..inner_fn\u001b[0;34m(params, *args, **kwargs)\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner_fn\u001b[39m(params, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 27\u001b[0m model\u001b[38;5;241m.\u001b[39mupdate(params)\n\u001b[0;32m---> 28\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[71], line 3\u001b[0m, in \u001b[0;36mdisc_loss\u001b[0;34m(gen, disc, real, num_images, z_dim)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdisc_loss\u001b[39m(gen, disc, real, num_images, z_dim):\n\u001b[1;32m 2\u001b[0m noise \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39marray(get_noise(num_images, z_dim))\n\u001b[0;32m----> 3\u001b[0m fake_images \u001b[38;5;241m=\u001b[39m \u001b[43mgen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnoise\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m fake_disc \u001b[38;5;241m=\u001b[39m disc(fake_images)\n\u001b[1;32m 7\u001b[0m fake_labels \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39mzeros((fake_images\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m],\u001b[38;5;241m1\u001b[39m))\n", + "Cell \u001b[0;32mIn[5], line 19\u001b[0m, in \u001b[0;36mGenerator.__call__\u001b[0;34m(self, noise)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, noise):\n\u001b[0;32m---> 19\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnoise\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/containers.py:23\u001b[0m, in \u001b[0;36mSequential.__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlayers:\n\u001b[0;32m---> 23\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43mm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/containers.py:23\u001b[0m, in \u001b[0;36mSequential.__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlayers:\n\u001b[0;32m---> 23\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43mm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/normalization.py:357\u001b[0m, in \u001b[0;36mBatchNorm.__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 355\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtraining \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrack_running_stats:\n\u001b[1;32m 356\u001b[0m mu \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmomentum\n\u001b[0;32m--> 357\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrunning_mean\u001b[49m \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m mu) \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrunning_mean \u001b[38;5;241m+\u001b[39m mu \u001b[38;5;241m*\u001b[39m mean\n\u001b[1;32m 358\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrunning_var \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m mu) \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrunning_var \u001b[38;5;241m+\u001b[39m mu \u001b[38;5;241m*\u001b[39m var\n\u001b[1;32m 359\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrack_running_stats:\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/base.py:139\u001b[0m, in \u001b[0;36mModule.__setattr__\u001b[0;34m(self, key, val)\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28msuper\u001b[39m(Module, \u001b[38;5;28mself\u001b[39m)\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__getattribute__\u001b[39m(key)\n\u001b[0;32m--> 139\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__setattr__\u001b[39m(\u001b[38;5;28mself\u001b[39m, key: \u001b[38;5;28mstr\u001b[39m, val: Any):\n\u001b[1;32m 140\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(val, (mx\u001b[38;5;241m.\u001b[39marray, \u001b[38;5;28mdict\u001b[39m, \u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 141\u001b[0m \u001b[38;5;66;03m# If attribute was previously set but not in the\u001b[39;00m\n\u001b[1;32m 142\u001b[0m \u001b[38;5;66;03m# dictionary, delete it so we pick it up in future\u001b[39;00m\n\u001b[1;32m 143\u001b[0m \u001b[38;5;66;03m# calls to __getattr__\u001b[39;00m\n\u001b[1;32m 144\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, key) \u001b[38;5;129;01mand\u001b[39;00m key \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], "source": [ "batch_size = 8\n", "cur_step = 0\n", From 88a20b72760919e19c8eb9932a29d87f6941c815 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sun, 28 Jul 2024 01:10:19 +0300 Subject: [PATCH 10/38] Updating GAN Code... --- gan/playground.ipynb | 60170 +---------------------------------------- 1 file changed, 149 insertions(+), 60021 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 400d07b5..8d1bfff5 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -123,7 +123,7 @@ ")" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -165,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -214,7 +214,7 @@ ")" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -233,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -248,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -270,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -295,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -314,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -325,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -345,12 +345,12 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -372,16 +372,32 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def show_images(imgs:list[int]):\n", + " fig,axes = plt.subplots(4, 4, figsize=(4, 4))\n", + "\n", + " for i, ax in enumerate(axes.flat):\n", + " img = mx.array(imgs[i]).reshape(28,28)\n", + " ax.imshow(img,cmap='gray')\n", + " ax.axis('off')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array(0.677068, dtype=float32)" + "array(0.683622, dtype=float32)" ] }, - "execution_count": 41, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -402,9 +418,78 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 20, "metadata": {}, "outputs": [ + { + "data": { + "text/plain": [ + "60000" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(train_images)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 3%|▎ | 6/200 [02:24<1:16:40, 23.71s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step 5: Generator loss: array(8.15901, dtype=float32), discriminator loss: array(nan, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 6%|▌ | 11/200 [04:22<1:13:56, 23.47s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step 10: Generator loss: array(8.52206, dtype=float32), discriminator loss: array(nan, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 8%|▊ | 16/200 [06:18<1:11:26, 23.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step 15: Generator loss: array(8.47402, dtype=float32), discriminator loss: array(nan, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 8%|▊ | 16/200 [06:31<1:15:05, 24.49s/it]\n" + ] + }, { "ename": "KeyboardInterrupt", "evalue": "", @@ -412,21 +497,44 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[77], line 22\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m5\u001b[39m):\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m real \u001b[38;5;129;01min\u001b[39;00m batch_iterate(batch_size, train_images):\n\u001b[1;32m 13\u001b[0m \n\u001b[1;32m 14\u001b[0m \u001b[38;5;66;03m# real = real.reshape(-1)\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m# print(len(real))\u001b[39;00m\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# break\u001b[39;00m\n\u001b[0;32m---> 22\u001b[0m D_loss,D_grads \u001b[38;5;241m=\u001b[39m \u001b[43mD_loss_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreal\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 25\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:34\u001b[0m, in \u001b[0;36mvalue_and_grad..wrapped_value_grad_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapped_value_grad_fn\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 34\u001b[0m value, grad \u001b[38;5;241m=\u001b[39m \u001b[43mvalue_grad_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainable_parameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value, grad\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:28\u001b[0m, in \u001b[0;36mvalue_and_grad..inner_fn\u001b[0;34m(params, *args, **kwargs)\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner_fn\u001b[39m(params, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 27\u001b[0m model\u001b[38;5;241m.\u001b[39mupdate(params)\n\u001b[0;32m---> 28\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[71], line 3\u001b[0m, in \u001b[0;36mdisc_loss\u001b[0;34m(gen, disc, real, num_images, z_dim)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdisc_loss\u001b[39m(gen, disc, real, num_images, z_dim):\n\u001b[1;32m 2\u001b[0m noise \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39marray(get_noise(num_images, z_dim))\n\u001b[0;32m----> 3\u001b[0m fake_images \u001b[38;5;241m=\u001b[39m \u001b[43mgen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnoise\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m fake_disc \u001b[38;5;241m=\u001b[39m disc(fake_images)\n\u001b[1;32m 7\u001b[0m fake_labels \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39mzeros((fake_images\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m],\u001b[38;5;241m1\u001b[39m))\n", - "Cell \u001b[0;32mIn[5], line 19\u001b[0m, in \u001b[0;36mGenerator.__call__\u001b[0;34m(self, noise)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, noise):\n\u001b[0;32m---> 19\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnoise\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/containers.py:23\u001b[0m, in \u001b[0;36mSequential.__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlayers:\n\u001b[0;32m---> 23\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43mm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/containers.py:23\u001b[0m, in \u001b[0;36mSequential.__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlayers:\n\u001b[0;32m---> 23\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43mm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/normalization.py:357\u001b[0m, in \u001b[0;36mBatchNorm.__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 355\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtraining \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrack_running_stats:\n\u001b[1;32m 356\u001b[0m mu \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmomentum\n\u001b[0;32m--> 357\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrunning_mean\u001b[49m \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m mu) \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrunning_mean \u001b[38;5;241m+\u001b[39m mu \u001b[38;5;241m*\u001b[39m mean\n\u001b[1;32m 358\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrunning_var \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m mu) \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrunning_var \u001b[38;5;241m+\u001b[39m mu \u001b[38;5;241m*\u001b[39m var\n\u001b[1;32m 359\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrack_running_stats:\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/base.py:139\u001b[0m, in \u001b[0;36mModule.__setattr__\u001b[0;34m(self, key, val)\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28msuper\u001b[39m(Module, \u001b[38;5;28mself\u001b[39m)\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__getattribute__\u001b[39m(key)\n\u001b[0;32m--> 139\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__setattr__\u001b[39m(\u001b[38;5;28mself\u001b[39m, key: \u001b[38;5;28mstr\u001b[39m, val: Any):\n\u001b[1;32m 140\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(val, (mx\u001b[38;5;241m.\u001b[39marray, \u001b[38;5;28mdict\u001b[39m, \u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mtuple\u001b[39m)):\n\u001b[1;32m 141\u001b[0m \u001b[38;5;66;03m# If attribute was previously set but not in the\u001b[39;00m\n\u001b[1;32m 142\u001b[0m \u001b[38;5;66;03m# dictionary, delete it so we pick it up in future\u001b[39;00m\n\u001b[1;32m 143\u001b[0m \u001b[38;5;66;03m# calls to __getattr__\u001b[39;00m\n\u001b[1;32m 144\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, key) \u001b[38;5;129;01mand\u001b[39;00m key \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n", + "Cell \u001b[0;32mIn[65], line 38\u001b[0m\n\u001b[1;32m 35\u001b[0m gen_opt\u001b[38;5;241m.\u001b[39mupdate(gen, G_grads)\n\u001b[1;32m 37\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[0;32m---> 38\u001b[0m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgen_opt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cur_step \u001b[38;5;241m%\u001b[39m display_step \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m cur_step \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mStep \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: Generator loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mG_loss\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, discriminator loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mD_loss\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] + }, + { + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "batch_size = 8\n", + "batch_size = 16\n", + "display_step = 5\n", "cur_step = 0\n", "mean_generator_loss = 0\n", "mean_discriminator_loss = 0\n", @@ -435,10 +543,10 @@ "G_loss_grad = nn.value_and_grad(gen, gen_loss)\n", "\n", "\n", - "for epoch in tqdm(range(5)):\n", - " \n", - " for real in batch_iterate(batch_size, train_images):\n", - " \n", + "for epoch in tqdm(range(200)):\n", + "\n", + " for real in batch_iterate(batch_size, train_images[:50]):\n", + " cur_batch_size = len(real)\n", " # real = real.reshape(-1)\n", " \n", " # Flatten the batch of real images from the dataset\n", @@ -463,59994 +571,14 @@ " \n", " # Update gradients\n", " mx.eval(gen.parameters(), gen_opt.state)\n", - "\n", + " \n", + " if cur_step % display_step == 0 and cur_step > 0:\n", " print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", - "\n", - " # # Keep track of the average discriminator loss\n", - " # mean_discriminator_loss += disc_loss.item() / display_step\n", - "\n", - " # # Keep track of the average generator loss\n", - " # mean_generator_loss += gen_loss.item() / display_step\n", - "\n", - " # ### Visualization code ###\n", - " # if cur_step % display_step == 0 and cur_step > 0:\n", - " # print(f\"Step {cur_step}: Generator loss: {mean_generator_loss}, discriminator loss: {mean_discriminator_loss}\")\n", - " # fake_noise = get_noise(cur_batch_size, z_dim, device=device)\n", - " # fake = gen(fake_noise)\n", - " # show_tensor_images(fake)\n", - " # show_tensor_images(real)\n", - " # mean_generator_loss = 0\n", - " # mean_discriminator_loss = 0\n", - " # cur_step += 1\n" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "841it [00:00, 4302.26it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "1272it [00:00, 4216.43it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2162it [00:00, 3892.48it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "3019it [00:00, 4091.56it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "3844it [00:00, 4029.28it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "4650it [00:01, 3939.91it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "5458it [00:01, 3936.87it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "6227it [00:01, 3545.49it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "7012it [00:01, 3731.90it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "7390it [00:01, 3631.14it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (8, 1) (8, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "8155it [00:02, 3723.22it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "8894it [00:02, 3526.49it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "9599it [00:02, 3156.01it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "10276it [00:02, 3261.29it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "10949it [00:02, 3314.05it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "11617it [00:03, 3302.76it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "12300it [00:03, 2989.43it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "12965it [00:03, 3146.40it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "13614it [00:03, 3125.70it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "13930it [00:03, 2767.20it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "14528it [00:04, 2874.43it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "15107it [00:04, 2529.70it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "15646it [00:04, 2603.14it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "16166it [00:04, 2521.59it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "16448it [00:04, 2605.58it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "16986it [00:05, 2527.43it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "17536it [00:05, 2377.32it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "18083it [00:05, 2559.46it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "18343it [00:05, 2557.61it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "18862it [00:05, 2306.06it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "19370it [00:06, 2369.58it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "19612it [00:06, 2167.17it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n", - "fake image shape (8, 784)\n", - "Fake Shapes..... (8, 1) (8, 1)\n", - "Real Shapes..... (0, 1) (0, 1)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "19835it [00:06, 3062.01it/s]\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[69], line 10\u001b[0m\n\u001b[1;32m 7\u001b[0m mx\u001b[38;5;241m.\u001b[39meval(disc\u001b[38;5;241m.\u001b[39mparameters())\n\u001b[1;32m 8\u001b[0m disc_opt \u001b[38;5;241m=\u001b[39m optim\u001b[38;5;241m.\u001b[39mAdam(learning_rate\u001b[38;5;241m=\u001b[39mlr)\n\u001b[0;32m---> 10\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m real \u001b[38;5;129;01min\u001b[39;00m tqdm(batch_iterate(batch_size, train_images)):\n\u001b[1;32m 11\u001b[0m d_loss \u001b[38;5;241m=\u001b[39m disc_loss(gen, disc, real, batch_size, z_dim)\n\u001b[1;32m 13\u001b[0m \u001b[38;5;66;03m# real = real.reshape(-1)\u001b[39;00m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;66;03m# # real = real.view(cur_batch_size, -1)\u001b[39;00m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;66;03m# # Calculate discriminator loss\u001b[39;00m\n\u001b[1;32m 16\u001b[0m \n\u001b[1;32m 17\u001b[0m \u001b[38;5;66;03m# d_loss = disc_loss(gen, disc, real, cur_batch_size, z_dim)\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:1188\u001b[0m, in \u001b[0;36mtqdm.__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1186\u001b[0m dt \u001b[38;5;241m=\u001b[39m cur_t \u001b[38;5;241m-\u001b[39m last_print_t\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dt \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m mininterval \u001b[38;5;129;01mand\u001b[39;00m cur_t \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m min_start_t:\n\u001b[0;32m-> 1188\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mlast_print_n\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1189\u001b[0m last_print_n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlast_print_n\n\u001b[1;32m 1190\u001b[0m last_print_t \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlast_print_t\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:1239\u001b[0m, in \u001b[0;36mtqdm.update\u001b[0;34m(self, n)\u001b[0m\n\u001b[1;32m 1237\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_ema_dn(dn)\n\u001b[1;32m 1238\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_ema_dt(dt)\n\u001b[0;32m-> 1239\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrefresh\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlock_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlock_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1240\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdynamic_miniters:\n\u001b[1;32m 1241\u001b[0m \u001b[38;5;66;03m# If no `miniters` was specified, adjust automatically to the\u001b[39;00m\n\u001b[1;32m 1242\u001b[0m \u001b[38;5;66;03m# maximum iteration rate seen so far between two prints.\u001b[39;00m\n\u001b[1;32m 1243\u001b[0m \u001b[38;5;66;03m# e.g.: After running `tqdm.update(5)`, subsequent\u001b[39;00m\n\u001b[1;32m 1244\u001b[0m \u001b[38;5;66;03m# calls to `tqdm.update()` will only cause an update after\u001b[39;00m\n\u001b[1;32m 1245\u001b[0m \u001b[38;5;66;03m# at least 5 more iterations.\u001b[39;00m\n\u001b[1;32m 1246\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmaxinterval \u001b[38;5;129;01mand\u001b[39;00m dt \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmaxinterval:\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:1344\u001b[0m, in \u001b[0;36mtqdm.refresh\u001b[0;34m(self, nolock, lock_args)\u001b[0m\n\u001b[1;32m 1342\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1343\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39macquire()\n\u001b[0;32m-> 1344\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdisplay\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1345\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m nolock:\n\u001b[1;32m 1346\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:1492\u001b[0m, in \u001b[0;36mtqdm.display\u001b[0;34m(self, msg, pos)\u001b[0m\n\u001b[1;32m 1490\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pos:\n\u001b[1;32m 1491\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmoveto(pos)\n\u001b[0;32m-> 1492\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msp\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__str__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1493\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pos:\n\u001b[1;32m 1494\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmoveto(\u001b[38;5;241m-\u001b[39mpos)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:347\u001b[0m, in \u001b[0;36mtqdm.status_printer..print_status\u001b[0;34m(s)\u001b[0m\n\u001b[1;32m 345\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mprint_status\u001b[39m(s):\n\u001b[1;32m 346\u001b[0m len_s \u001b[38;5;241m=\u001b[39m disp_len(s)\n\u001b[0;32m--> 347\u001b[0m \u001b[43mfp_write\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;130;43;01m\\r\u001b[39;49;00m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43ms\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m \u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mlast_len\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mlen_s\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 348\u001b[0m last_len[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m len_s\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/std.py:341\u001b[0m, in \u001b[0;36mtqdm.status_printer..fp_write\u001b[0;34m(s)\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfp_write\u001b[39m(s):\n\u001b[1;32m 340\u001b[0m fp\u001b[38;5;241m.\u001b[39mwrite(\u001b[38;5;28mstr\u001b[39m(s))\n\u001b[0;32m--> 341\u001b[0m \u001b[43mfp_flush\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/tqdm/utils.py:127\u001b[0m, in \u001b[0;36mDisableOnWriteError.disable_on_exception..inner\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 126\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 127\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 128\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 129\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m e\u001b[38;5;241m.\u001b[39merrno \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m5\u001b[39m:\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/ipykernel/iostream.py:526\u001b[0m, in \u001b[0;36mOutStream.flush\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 524\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpub_thread\u001b[38;5;241m.\u001b[39mschedule(evt\u001b[38;5;241m.\u001b[39mset)\n\u001b[1;32m 525\u001b[0m \u001b[38;5;66;03m# and give a timeout to avoid\u001b[39;00m\n\u001b[0;32m--> 526\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[43mevt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflush_timeout\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[1;32m 527\u001b[0m \u001b[38;5;66;03m# write directly to __stderr__ instead of warning because\u001b[39;00m\n\u001b[1;32m 528\u001b[0m \u001b[38;5;66;03m# if this is happening sys.stderr may be the problem.\u001b[39;00m\n\u001b[1;32m 529\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIOStream.flush timed out\u001b[39m\u001b[38;5;124m\"\u001b[39m, file\u001b[38;5;241m=\u001b[39msys\u001b[38;5;241m.\u001b[39m__stderr__)\n\u001b[1;32m 530\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/threading.py:607\u001b[0m, in \u001b[0;36mEvent.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 605\u001b[0m signaled \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_flag\n\u001b[1;32m 606\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m signaled:\n\u001b[0;32m--> 607\u001b[0m signaled \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cond\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 608\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m signaled\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/threading.py:324\u001b[0m, in \u001b[0;36mCondition.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 322\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 323\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m timeout \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 324\u001b[0m gotit \u001b[38;5;241m=\u001b[39m \u001b[43mwaiter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43macquire\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 325\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 326\u001b[0m gotit \u001b[38;5;241m=\u001b[39m waiter\u001b[38;5;241m.\u001b[39macquire(\u001b[38;5;28;01mFalse\u001b[39;00m)\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], - "source": [ - "z_dim = 64\n", - "gen = Generator(z_dim)\n", - "mx.eval(gen.parameters())\n", - "gen_opt = optim.Adam(learning_rate=lr)\n", - "\n", - "disc = Discriminator()\n", - "mx.eval(disc.parameters())\n", - "disc_opt = optim.Adam(learning_rate=lr)\n", - "\n", - "for real in tqdm(batch_iterate(batch_size, train_images)):\n", - " d_loss = disc_loss(gen, disc, real, batch_size, z_dim)\n" + " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", + " fake = gen(fake_noise)\n", + " show_images(fake)\n", + " # print(fake.shape)\n", + " cur_step += 1\n" ] } ], From 3716501e8dc3872e25c11f57e8c70ccd6363ca19 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sun, 28 Jul 2024 17:22:40 +0300 Subject: [PATCH 11/38] Updating GAN Code... --- gan/playground.ipynb | 146 +++++++++---------------------------------- 1 file changed, 31 insertions(+), 115 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 8d1bfff5..f8831135 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -123,7 +123,7 @@ ")" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -165,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -214,7 +214,7 @@ ")" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -233,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -248,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -270,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -295,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -314,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -325,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -345,12 +345,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -372,13 +372,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ - "def show_images(imgs:list[int]):\n", - " fig,axes = plt.subplots(4, 4, figsize=(4, 4))\n", - "\n", + "def show_images(imgs:list[int],num_imgs:int = 25):\n", + " fig,axes = plt.subplots(5, 5, figsize=(4, 4))\n", + " \n", " for i, ax in enumerate(axes.flat):\n", " img = mx.array(imgs[i]).reshape(28,28)\n", " ax.imshow(img,cmap='gray')\n", @@ -394,7 +394,7 @@ { "data": { "text/plain": [ - "array(0.683622, dtype=float32)" + "array(0.738084, dtype=float32)" ] }, "execution_count": 18, @@ -418,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -427,7 +427,7 @@ "60000" ] }, - "execution_count": 20, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -438,103 +438,20 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 3%|▎ | 6/200 [02:24<1:16:40, 23.71s/it]" + " 0%| | 0/200 [00:00 38\u001b[0m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgen_opt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cur_step \u001b[38;5;241m%\u001b[39m display_step \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m cur_step \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mStep \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: Generator loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mG_loss\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, discriminator loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mD_loss\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - }, - { - "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" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ "batch_size = 16\n", - "display_step = 5\n", + "display_step = 50\n", "cur_step = 0\n", "mean_generator_loss = 0\n", "mean_discriminator_loss = 0\n", @@ -545,7 +462,7 @@ "\n", "for epoch in tqdm(range(200)):\n", "\n", - " for real in batch_iterate(batch_size, train_images[:50]):\n", + " for real in batch_iterate(batch_size, train_images):\n", " cur_batch_size = len(real)\n", " # real = real.reshape(-1)\n", " \n", @@ -563,7 +480,6 @@ " # Update gradients\n", " mx.eval(disc.parameters(), disc_opt.state)\n", "\n", - " \n", " G_loss,G_grads = G_loss_grad(gen, disc, batch_size, z_dim)\n", " \n", " # Update optimizer\n", @@ -577,8 +493,8 @@ " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", " fake = gen(fake_noise)\n", " show_images(fake)\n", - " # print(fake.shape)\n", - " cur_step += 1\n" + " show_images(real)\n", + " cur_step += 1" ] } ], From 3e63cd93fe03f36970133d2cd7d5abad906a6a82 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sun, 28 Jul 2024 17:26:24 +0300 Subject: [PATCH 12/38] Updating GAN Code... --- gan/playground.ipynb | 8 -------- 1 file changed, 8 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index f8831135..b087a1b0 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -463,14 +463,6 @@ "for epoch in tqdm(range(200)):\n", "\n", " for real in batch_iterate(batch_size, train_images):\n", - " cur_batch_size = len(real)\n", - " # real = real.reshape(-1)\n", - " \n", - " # Flatten the batch of real images from the dataset\n", - " \n", - " # plt.imshow(real[0].reshape(28,28))\n", - " # print(len(real))\n", - " # break\n", " \n", " D_loss,D_grads = D_loss_grad(gen, disc, real, batch_size, z_dim)\n", "\n", From d17d293df9e9355c222f4e9687ee241bd228c802 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sun, 28 Jul 2024 17:35:36 +0300 Subject: [PATCH 13/38] Updating GAN Code... --- gan/playground.ipynb | 55 ++++++++++++++++++++++---------------------- 1 file changed, 28 insertions(+), 27 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index b087a1b0..be4ae606 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -123,7 +123,7 @@ ")" ] }, - "execution_count": 5, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -165,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -214,7 +214,7 @@ ")" ] }, - "execution_count": 9, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -233,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -248,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -270,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -295,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -314,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -325,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -345,12 +345,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -372,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -388,16 +388,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array(0.738084, dtype=float32)" + "array(0.662747, dtype=float32)" ] }, - "execution_count": 18, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -418,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -427,7 +427,7 @@ "60000" ] }, - "execution_count": 19, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -438,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -450,6 +450,7 @@ } ], "source": [ + "# Train the GAN for only 1000 images\n", "batch_size = 16\n", "display_step = 50\n", "cur_step = 0\n", @@ -462,7 +463,7 @@ "\n", "for epoch in tqdm(range(200)):\n", "\n", - " for real in batch_iterate(batch_size, train_images):\n", + " for real in batch_iterate(batch_size, train_images[:1000]):\n", " \n", " D_loss,D_grads = D_loss_grad(gen, disc, real, batch_size, z_dim)\n", "\n", From c0c82938423b67cf7239bf12804417f380e95bc7 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sun, 28 Jul 2024 17:56:26 +0300 Subject: [PATCH 14/38] Updating GAN Code... --- gan/playground.ipynb | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index be4ae606..281aaacc 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -388,16 +388,16 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array(0.662747, dtype=float32)" + "array(0.675341, dtype=float32)" ] }, - "execution_count": 40, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -418,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -427,7 +427,7 @@ "60000" ] }, - "execution_count": 41, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -438,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -452,7 +452,7 @@ "source": [ "# Train the GAN for only 1000 images\n", "batch_size = 16\n", - "display_step = 50\n", + "display_step = 20\n", "cur_step = 0\n", "mean_generator_loss = 0\n", "mean_discriminator_loss = 0\n", @@ -463,7 +463,7 @@ "\n", "for epoch in tqdm(range(200)):\n", "\n", - " for real in batch_iterate(batch_size, train_images[:1000]):\n", + " for real in batch_iterate(batch_size, train_images[:500]):\n", " \n", " D_loss,D_grads = D_loss_grad(gen, disc, real, batch_size, z_dim)\n", "\n", From a07ef6d03bdb77f888e38a55d465139523b472d4 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Sun, 28 Jul 2024 18:11:39 +0300 Subject: [PATCH 15/38] Updating GAN Code... --- gan/playground.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 281aaacc..8e65fe90 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -445,7 +445,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 0/200 [00:00 Date: Sun, 28 Jul 2024 19:18:35 +0300 Subject: [PATCH 16/38] Updating GAN Code... --- gan/playground.ipynb | 53 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 3 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 8e65fe90..02ed2a68 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -445,14 +445,60 @@ "name": "stderr", "output_type": "stream", "text": [ - " 2%|▏ | 3/200 [11:42<12:47:26, 233.74s/it]" + " 10%|█ | 20/200 [1:17:04<11:32:48, 230.94s/it]" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step 20: Generator loss: array(16.7247, dtype=float32), discriminator loss: array(nan, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 20/200 [1:21:00<12:09:01, 243.01s/it]\n" + ] + }, + { + "ename": "ValueError", + "evalue": "[take] Cannot do a non-empty take from an array with zero elements.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[45], line 37\u001b[0m\n\u001b[1;32m 35\u001b[0m fake \u001b[38;5;241m=\u001b[39m gen(fake_noise)\n\u001b[1;32m 36\u001b[0m show_images(fake)\n\u001b[0;32m---> 37\u001b[0m \u001b[43mshow_images\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreal\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 38\u001b[0m cur_step \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n", + "Cell \u001b[0;32mIn[39], line 5\u001b[0m, in \u001b[0;36mshow_images\u001b[0;34m(imgs, num_imgs)\u001b[0m\n\u001b[1;32m 2\u001b[0m fig,axes \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(\u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m5\u001b[39m, figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m4\u001b[39m))\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, ax \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(axes\u001b[38;5;241m.\u001b[39mflat):\n\u001b[0;32m----> 5\u001b[0m img \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39marray(\u001b[43mimgs\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m)\u001b[38;5;241m.\u001b[39mreshape(\u001b[38;5;241m28\u001b[39m,\u001b[38;5;241m28\u001b[39m)\n\u001b[1;32m 6\u001b[0m ax\u001b[38;5;241m.\u001b[39mimshow(img,cmap\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgray\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 7\u001b[0m ax\u001b[38;5;241m.\u001b[39maxis(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124moff\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: [take] Cannot do a non-empty take from an array with zero elements." + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "# Train the GAN for only 1000 images\n", "batch_size = 16\n", - "display_step = 20\n", + "display_step = 5\n", "cur_step = 0\n", "mean_generator_loss = 0\n", "mean_discriminator_loss = 0\n", @@ -461,7 +507,7 @@ "G_loss_grad = nn.value_and_grad(gen, gen_loss)\n", "\n", "\n", - "for epoch in tqdm(range(200)):\n", + "for epoch in tqdm(range(50)):\n", "\n", " for real in batch_iterate(batch_size, train_images[:500]):\n", " \n", @@ -487,6 +533,7 @@ " fake = gen(fake_noise)\n", " show_images(fake)\n", " show_images(real)\n", + " print(real.shape)\n", " cur_step += 1" ] } From 8d27be144219eb2fe1da68f068f11ac4f00a9c6d Mon Sep 17 00:00:00 2001 From: Shubbair Date: Mon, 29 Jul 2024 01:24:50 +0300 Subject: [PATCH 17/38] Updating GAN Code... --- gan/playground.ipynb | 195 +++++++++++++++++-------------------------- 1 file changed, 75 insertions(+), 120 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 02ed2a68..03e56da3 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -123,7 +123,7 @@ ")" ] }, - "execution_count": 27, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 51, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 52, "metadata": {}, "outputs": [], "source": [ @@ -165,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 54, "metadata": {}, "outputs": [ { @@ -214,7 +214,7 @@ ")" ] }, - "execution_count": 31, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" } @@ -233,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -248,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ @@ -270,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 57, "metadata": {}, "outputs": [], "source": [ @@ -295,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 58, "metadata": {}, "outputs": [], "source": [ @@ -314,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 59, "metadata": {}, "outputs": [], "source": [ @@ -325,15 +325,35 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 133, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "60000" + ] + }, + "execution_count": 133, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(train_images)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, "metadata": {}, "outputs": [], "source": [ - "def batch_iterate(batch_size:int, ipt:list):\n", - " perm = mx.array(np.random.permutation(len(ipt)))\n", - " for s in range(0, ipt.size, batch_size):\n", + "def batch_iterate(batch_size: int, ipt: list):\n", + " perm = np.random.permutation(len(ipt))\n", + " for s in range(0, len(ipt), batch_size):\n", " ids = perm[s : s + batch_size]\n", - " yield ipt[ids]" + " yield [ipt[i] for i in ids]" ] }, { @@ -345,14 +365,14 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 128, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -361,7 +381,7 @@ ], "source": [ "for X in batch_iterate(16, train_images):\n", - " fig,axes = plt.subplots(4, 4, figsize=(4, 4))\n", + " fig,axes = plt.subplots(5, 5, figsize=(5, 5))\n", "\n", " for i, ax in enumerate(axes.flat):\n", " img = mx.array(X[i]).reshape(28,28)\n", @@ -372,36 +392,26 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 147, "metadata": {}, "outputs": [], "source": [ "def show_images(imgs:list[int],num_imgs:int = 25):\n", - " fig,axes = plt.subplots(5, 5, figsize=(4, 4))\n", - " \n", - " for i, ax in enumerate(axes.flat):\n", - " img = mx.array(imgs[i]).reshape(28,28)\n", - " ax.imshow(img,cmap='gray')\n", - " ax.axis('off')\n", - " plt.show()" + " if (imgs.shape[0] > 0): \n", + " fig,axes = plt.subplots(5, 5, figsize=(5, 5))\n", + " \n", + " for i, ax in enumerate(axes.flat):\n", + " img = mx.array(imgs[0]).reshape(28,28)\n", + " ax.imshow(img,cmap='gray')\n", + " ax.axis('off')\n", + " plt.show()" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 148, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array(0.675341, dtype=float32)" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "z_dim = 64\n", "gen = Generator(z_dim)\n", @@ -410,95 +420,40 @@ "\n", "disc = Discriminator()\n", "mx.eval(disc.parameters())\n", - "disc_opt = optim.Adam(learning_rate=lr)\n", - "\n", - "g_loss = gen_loss(gen, disc, 8, z_dim)\n", - "g_loss\n" + "disc_opt = optim.Adam(learning_rate=lr)\n" ] }, { "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "60000" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(train_images)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, + "execution_count": 151, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 10%|█ | 20/200 [1:17:04<11:32:48, 230.94s/it]" + " 7%|▋ | 4/60 [08:34<2:00:03, 128.64s/it]\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Step 20: Generator loss: array(16.7247, dtype=float32), discriminator loss: array(nan, dtype=float32)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 20/200 [1:21:00<12:09:01, 243.01s/it]\n" - ] - }, - { - "ename": "ValueError", - "evalue": "[take] Cannot do a non-empty take from an array with zero elements.", + "ename": "KeyboardInterrupt", + "evalue": "", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[45], line 37\u001b[0m\n\u001b[1;32m 35\u001b[0m fake \u001b[38;5;241m=\u001b[39m gen(fake_noise)\n\u001b[1;32m 36\u001b[0m show_images(fake)\n\u001b[0;32m---> 37\u001b[0m \u001b[43mshow_images\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreal\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 38\u001b[0m cur_step \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n", - "Cell \u001b[0;32mIn[39], line 5\u001b[0m, in \u001b[0;36mshow_images\u001b[0;34m(imgs, num_imgs)\u001b[0m\n\u001b[1;32m 2\u001b[0m fig,axes \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(\u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m5\u001b[39m, figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m4\u001b[39m))\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, ax \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(axes\u001b[38;5;241m.\u001b[39mflat):\n\u001b[0;32m----> 5\u001b[0m img \u001b[38;5;241m=\u001b[39m mx\u001b[38;5;241m.\u001b[39marray(\u001b[43mimgs\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m)\u001b[38;5;241m.\u001b[39mreshape(\u001b[38;5;241m28\u001b[39m,\u001b[38;5;241m28\u001b[39m)\n\u001b[1;32m 6\u001b[0m ax\u001b[38;5;241m.\u001b[39mimshow(img,cmap\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgray\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 7\u001b[0m ax\u001b[38;5;241m.\u001b[39maxis(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124moff\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: [take] Cannot do a non-empty take from an array with zero elements." + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[151], line 24\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[1;32m 22\u001b[0m mx\u001b[38;5;241m.\u001b[39meval(disc\u001b[38;5;241m.\u001b[39mparameters(), disc_opt\u001b[38;5;241m.\u001b[39mstate)\n\u001b[0;32m---> 24\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m \u001b[43mG_loss_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcur_batch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 27\u001b[0m gen_opt\u001b[38;5;241m.\u001b[39mupdate(gen, G_grads)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:34\u001b[0m, in \u001b[0;36mvalue_and_grad..wrapped_value_grad_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapped_value_grad_fn\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 34\u001b[0m value, grad \u001b[38;5;241m=\u001b[39m value_grad_fn(\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainable_parameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value, grad\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/base.py:310\u001b[0m, in \u001b[0;36mModule.trainable_parameters\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 307\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtrainable_parameters\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 308\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Recursively return all the non frozen :class:`mlx.core.array` members of\u001b[39;00m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;124;03m this Module as a dict of dicts and lists.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 310\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfilter_and_map\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainable_parameter_filter\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/base.py:298\u001b[0m, in \u001b[0;36mModule.filter_and_map\u001b[0;34m(self, filter_fn, map_fn, is_leaf_fn)\u001b[0m\n\u001b[1;32m 292\u001b[0m map_fn \u001b[38;5;241m=\u001b[39m map_fn \u001b[38;5;129;01mor\u001b[39;00m (\u001b[38;5;28;01mlambda\u001b[39;00m x: x)\n\u001b[1;32m 293\u001b[0m is_leaf_fn \u001b[38;5;241m=\u001b[39m is_leaf_fn \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m 294\u001b[0m \u001b[38;5;28;01mlambda\u001b[39;00m m, k, v: \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(v, (Module, \u001b[38;5;28mdict\u001b[39m, \u001b[38;5;28mlist\u001b[39m))\n\u001b[1;32m 295\u001b[0m )\n\u001b[1;32m 296\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 297\u001b[0m k: _unwrap(\u001b[38;5;28mself\u001b[39m, k, v, filter_fn, map_fn, is_leaf_fn)\n\u001b[0;32m--> 298\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m filter_fn(\u001b[38;5;28mself\u001b[39m, k, v)\n\u001b[1;32m 300\u001b[0m }\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ "# Train the GAN for only 1000 images\n", - "batch_size = 16\n", - "display_step = 5\n", + "batch_size = 128\n", + "display_step = 15\n", "cur_step = 0\n", "mean_generator_loss = 0\n", "mean_discriminator_loss = 0\n", @@ -507,11 +462,11 @@ "G_loss_grad = nn.value_and_grad(gen, gen_loss)\n", "\n", "\n", - "for epoch in tqdm(range(50)):\n", + "for epoch in tqdm(range(60)):\n", "\n", - " for real in batch_iterate(batch_size, train_images[:500]):\n", + " for real in batch_iterate(batch_size, train_images[:2048]):\n", " \n", - " D_loss,D_grads = D_loss_grad(gen, disc, real, batch_size, z_dim)\n", + " D_loss,D_grads = D_loss_grad(gen, disc, real, cur_batch_size, z_dim)\n", "\n", " # Update optimizer\n", " disc_opt.update(disc, D_grads)\n", @@ -519,7 +474,7 @@ " # Update gradients\n", " mx.eval(disc.parameters(), disc_opt.state)\n", "\n", - " G_loss,G_grads = G_loss_grad(gen, disc, batch_size, z_dim)\n", + " G_loss,G_grads = G_loss_grad(gen, disc, cur_batch_size, z_dim)\n", " \n", " # Update optimizer\n", " gen_opt.update(gen, G_grads)\n", @@ -527,13 +482,13 @@ " # Update gradients\n", " mx.eval(gen.parameters(), gen_opt.state)\n", " \n", - " if cur_step % display_step == 0 and cur_step > 0:\n", + " \n", + " if cur_step % display_step == 0 and cur_step > 0 and batch_size:\n", " print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", " fake = gen(fake_noise)\n", " show_images(fake)\n", " show_images(real)\n", - " print(real.shape)\n", " cur_step += 1" ] } From bacaa9ec0ee0f24957e9c959e664b12ef579a498 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Mon, 29 Jul 2024 01:30:08 +0300 Subject: [PATCH 18/38] Updating GAN Code... --- gan/playground.ipynb | 49 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 03e56da3..89a92668 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -423,6 +423,55 @@ "disc_opt = optim.Adam(learning_rate=lr)\n" ] }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "array(0, dtype=float32)\n" + ] + } + ], + "source": [ + "train_images, train_labels, test_images, test_labels = map(mx.array, mnist.mnist())\n", + "print(min(train_images[0]))\n", + "# train_images = train_images * 2.0 - 1.0 # normalize the image" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 156, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(train_images[0].reshape(28,28),cmap='gray')" + ] + }, { "cell_type": "code", "execution_count": 151, From 306e53c402e869c8425865fb5d9189ee66613d81 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Mon, 29 Jul 2024 19:44:16 +0300 Subject: [PATCH 19/38] Updating GAN Code... --- gan/playground.ipynb | 381 ++++++++++++++++++++----------------------- 1 file changed, 177 insertions(+), 204 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 89a92668..8500a551 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 244, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 245, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 246, "metadata": {}, "outputs": [], "source": [ @@ -62,13 +62,13 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 247, "metadata": {}, "outputs": [], "source": [ "class Generator(nn.Module):\n", "\n", - " def __init__(self, z_dim:int = 10, im_dim:int = 784, hidden_dim: int =128):\n", + " def __init__(self, z_dim:int = 10, im_dim:int = 784, hidden_dim: int = 128):\n", " super(Generator, self).__init__()\n", " # Build the neural network\n", " self.gen = nn.Sequential(\n", @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 248, "metadata": {}, "outputs": [ { @@ -123,7 +123,7 @@ ")" ] }, - "execution_count": 50, + "execution_count": 248, "metadata": {}, "output_type": "execute_result" } @@ -135,12 +135,36 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 249, "metadata": {}, "outputs": [], "source": [ - "def get_noise(n_samples, z_dim):\n", - " return np.random.randn(n_samples,z_dim)" + "# make 2D noise with shape n_samples x z_dim\n", + "def get_noise(n_samples:list[int], z_dim:int)->list[int]:\n", + " return mx.random.normal(shape=(n_samples, z_dim))" + ] + }, + { + "cell_type": "code", + "execution_count": 250, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img = get_noise(28,28)\n", + "plt.imshow(img, cmap='gray')\n", + "plt.axis('off')\n", + "plt.show()" ] }, { @@ -152,20 +176,20 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 251, "metadata": {}, "outputs": [], "source": [ "def DisBlock(in_dim:int,out_dim:int):\n", " return nn.Sequential(\n", " nn.Linear(in_dim,out_dim),\n", - " nn.LeakyReLU(negative_slope=0.2)\n", + " nn.LeakyReLU(negative_slope=0.2),\n", " )" ] }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 252, "metadata": {}, "outputs": [], "source": [ @@ -183,13 +207,12 @@ " )\n", " \n", " def __call__(self, noise):\n", - "\n", " return self.disc(noise)" ] }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 253, "metadata": {}, "outputs": [ { @@ -214,7 +237,7 @@ ")" ] }, - "execution_count": 54, + "execution_count": 253, "metadata": {}, "output_type": "execute_result" } @@ -232,55 +255,34 @@ ] }, { - "cell_type": "code", - "execution_count": 55, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# Set your parameters\n", - "criterion = nn.losses.binary_cross_entropy\n", - "n_epochs = 200\n", - "z_dim = 64\n", - "display_step = 500\n", - "batch_size = 128\n", - "lr = 0.00001" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [], - "source": [ - "gen = Generator(z_dim)\n", - "mx.eval(gen.parameters())\n", - "gen_opt = optim.Adam(learning_rate=lr)\n", - "\n", - "disc = Discriminator()\n", - "mx.eval(disc.parameters())\n", - "disc_opt = optim.Adam(learning_rate=lr)" + "### Losses" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Losses" + "#### Discriminator Loss" ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 254, "metadata": {}, "outputs": [], "source": [ "def disc_loss(gen, disc, real, num_images, z_dim):\n", + " \n", " noise = mx.array(get_noise(num_images, z_dim))\n", " fake_images = gen(noise)\n", " \n", " fake_disc = disc(fake_images)\n", " \n", " fake_labels = mx.zeros((fake_images.shape[0],1))\n", + " \n", " fake_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", " \n", " real_disc = disc(real)\n", @@ -288,14 +290,21 @@ "\n", " real_loss = nn.losses.binary_cross_entropy(real_disc,real_labels,with_logits=True)\n", "\n", - " disc_loss = (fake_loss + real_loss) / 2\n", + " disc_loss = (fake_loss + real_loss) / 2.0\n", "\n", " return disc_loss" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Generator Loss" + ] + }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 255, "metadata": {}, "outputs": [], "source": [ @@ -306,7 +315,7 @@ " fake_disc = disc(fake_images)\n", "\n", " fake_labels = mx.ones((fake_images.shape[0],1))\n", - " \n", + " \n", " gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", "\n", " return gen_loss" @@ -314,146 +323,36 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 256, "metadata": {}, "outputs": [], "source": [ - "train_images, _, test_images, _ = map(\n", - " mx.array, getattr(mnist, 'mnist')()\n", - ")" + "# Get only the training images\n", + "train_images,*_ = map(np.array, mnist.mnist())" ] }, { "cell_type": "code", - "execution_count": 133, + "execution_count": 257, + "metadata": {}, + "outputs": [], + "source": [ + "# Normalize the images to fall between -1,1\n", + "train_images = train_images * 2.0 - 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 258, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "60000" + "" ] }, - "execution_count": 133, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(train_images)" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [], - "source": [ - "def batch_iterate(batch_size: int, ipt: list):\n", - " perm = np.random.permutation(len(ipt))\n", - " for s in range(0, len(ipt), batch_size):\n", - " ids = perm[s : s + batch_size]\n", - " yield [ipt[i] for i in ids]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### show batch of images" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for X in batch_iterate(16, train_images):\n", - " fig,axes = plt.subplots(5, 5, figsize=(5, 5))\n", - "\n", - " for i, ax in enumerate(axes.flat):\n", - " img = mx.array(X[i]).reshape(28,28)\n", - " ax.imshow(img,cmap='gray')\n", - " ax.axis('off')\n", - " break" - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "metadata": {}, - "outputs": [], - "source": [ - "def show_images(imgs:list[int],num_imgs:int = 25):\n", - " if (imgs.shape[0] > 0): \n", - " fig,axes = plt.subplots(5, 5, figsize=(5, 5))\n", - " \n", - " for i, ax in enumerate(axes.flat):\n", - " img = mx.array(imgs[0]).reshape(28,28)\n", - " ax.imshow(img,cmap='gray')\n", - " ax.axis('off')\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 148, - "metadata": {}, - "outputs": [], - "source": [ - "z_dim = 64\n", - "gen = Generator(z_dim)\n", - "mx.eval(gen.parameters())\n", - "gen_opt = optim.Adam(learning_rate=lr)\n", - "\n", - "disc = Discriminator()\n", - "mx.eval(disc.parameters())\n", - "disc_opt = optim.Adam(learning_rate=lr)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 162, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "array(0, dtype=float32)\n" - ] - } - ], - "source": [ - "train_images, train_labels, test_images, test_labels = map(mx.array, mnist.mnist())\n", - "print(min(train_images[0]))\n", - "# train_images = train_images * 2.0 - 1.0 # normalize the image" - ] - }, - { - "cell_type": "code", - "execution_count": 156, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 156, + "execution_count": 258, "metadata": {}, "output_type": "execute_result" }, @@ -474,48 +373,121 @@ }, { "cell_type": "code", - "execution_count": 151, + "execution_count": 259, + "metadata": {}, + "outputs": [], + "source": [ + "def batch_iterate(batch_size: int, ipt: list[int])-> list[int]:\n", + " perm = np.random.permutation(len(ipt))\n", + " for s in range(0, len(ipt), batch_size):\n", + " ids = perm[s : s + batch_size]\n", + " yield ipt[ids]" + ] + }, + { + "cell_type": "code", + "execution_count": 260, + "metadata": {}, + "outputs": [], + "source": [ + "def show_images(imgs:list[int],num_imgs:int = 25):\n", + " if (imgs.shape[0] > 0): \n", + " fig,axes = plt.subplots(5, 5, figsize=(5, 5))\n", + " \n", + " for i, ax in enumerate(axes.flat):\n", + " img = mx.array(imgs[i]).reshape(28,28)\n", + " ax.imshow(img,cmap='gray')\n", + " ax.axis('off')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### show first batch of images" + ] + }, + { + "cell_type": "code", + "execution_count": 261, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD3kklEQVR4nOy9V5OcV5rf+Uvvvc/KyvIFU/CGIIBm03RT3cORZlrqmZGPidjVboQ+xH4B3eyVdLGxitDEhDSSttUT49Q9zSabFvSwBVu+MrMqvfd2L6BzmAVHkCygDN5fRAVIVCIr31Pve57zuP+jGgwGAxQUFBQUFLYR9U5/AAUFBQWF/YdiXBQUFBQUth3FuCgoKCgobDuKcVFQUFBQ2HYU46KgoKCgsO0oxkVBQUFBYdtRjIuCgoKCwrajGBcFBQUFhW1HMS4KCgoKCtuO9mlfqFKpnuXn2FN8F1EDZf2+Rlm/78d3FdVQ1vBrlHvw+/E066d4LgoKCgoK245iXBQUFBQUth3FuCgoKCgobDuKcVFQUFBQ2HYU46KgoKCgsO0oxkVBQUFBYdt56lLk3cSTSgKV2WcKCs+O7SzHVZ7V/c2eMC4ajQa1Ws3IyAjhcBiTyYTP50Ov12O32zEajWQyGdbX16nVaiwtLVGpVOj1evR6vZ3++AoKexaVSoXb7cZms+F0OolEIhiNRnw+HxaL5Tu/by6X48aNG1SrVfL5PLVajU6nQ7vd3sZPr7CT7HrjolKp0Gg0aLVapqamePnll/H5fMzNzWG324lEIrjdbubn53n//fdJJBKUy2U6nQ7NZlMxLgoK3wO1Wo3P5yMajTI5Ocn58+dxu90cO3YMn88nX6dSqaRXMxgMvtEruXPnDn/+53/O5uYmd+7cYXNzk0ajQafTUTyafcKuNS7iZjUYDIRCIWw2G5OTk4yNjeFyufB4PFgsFoxGIxqNBpvNRiQSQavVMjExgVarJZ1Ok06nd/pSFPYwarUao9GIVqvFZrNhs9nQarXyvnsSrVaLZrNJs9mkVCrJA0+3231On/77IzwXETXw+/04nU4sFgsGg0G+bjAY0Ov1GAwGaDQaVCrVFiOhVqu3hNQcDgeTk5NYrVYGgwEOh4NCoUAqlaLdblOpVPbUOik8jGrwlMeE5y19oNFoMBgMeL1efv7znzM5Ocnc3ByHDh2SD7darabT6dDtduVpqVAo8PHHH5NIJPjtb3/LBx98sO0nIUU64vuxl9bPYDAwPj6O0+nk1KlTnD59GqfTyfj4+JbN9UEGgwGJRIJkMsna2hrvv/8+hUKBtbU1CoXC9/pMz1P+xWg08q//9b/mzTffJBAIcPDgQQwGgzS4gna7TalUotvtYjab0ev19Pt9BoMBKpXqIWPcarUolUo0m03W19fJ5/MsLCzwxRdfkMvluHr16vdepyexl+7B3cjTrN+u9Vw0Gg16vR6z2Uw4HGZ8fJxwOIzX62UwGNDtdun1ejQaDZrNJkajEavVSrfbxeVy0Wq1MJvNO30ZzwW1Wo1er0elUskTYq/Xo91uMxgM6Pf73+l9NRrNlg1BnE6/6/vtJYbvP4/Hg9vtJhqNMjMzg9PpZHJyEpPJtGUDFWuvVqsZDAbYbDasVitqtZo7d+6gVqtJp9OUy2X573Y7KpUKq9WK1+vF7XZjt9ulURn+/N1ul3K5LO85ca+0223pyeh0OtRqNWq1GoPBQCAQoNfroVarcTqdNBoNVldXGQwG6PX6nbrkXYlarZZ/ivtMPJv9fl/eT8PPpvg97NR9tmuNi9vtZnp6mtHRUY4cOcKBAwcwGAwUi0WSySSfffYZpVKJUqlEvV7HYrHgcDhotVqsrq5SLpdZW1vbEw/w9yUUCvHmm2/i9Xrx+/3Y7XZu3brFe++9R7lcJpVK0Wg0vtV7qlQqZmZmmJ6eln/Xbre5ceMGm5ub230Ju44DBw7w6quv4na7OXDgAC6Xi1AoRCgUotfrkUwm6XQ6ZDIZyuUyDocDn8+H0WgkGAxiNBrxeDzS+w4Gg+RyOX75y19y/fp1isUimUxm39yfsViM//f//X/J5/OcP3+eAwcOkMlkWFlZQafTSaMciUSIRCLy3wnDYjKZaLVa1Ot14vE4N2/elLnTFz08ptVq8Xq98t4KBALY7Xai0SgajYZYLEaxWJT3VLfblV/i73fkc+/IT30KrFYrU1NTjI6OMjExwdjYmDQm8Xicd955h3Q6TS6Xo16vY7Vacblc9Pt9CoUCnU7nhcm3uFwuXn/9dSYnJ5meniYYDPKb3/yGlZUVUqkUhULhWxsXtVpNJBLh9OnTMhxQq9WIx+MvhHGJRCL83u/9Hn6/nwMHDuB0OuX3isUiGxsbVCoVFhcXSaVShEIh2u02drsdt9uN0WiUOZpQKMTBgwcpFovcvXuXbDZLv98nm83uG+OSyWT4n//zfxKLxaQnvbS0xOeff47RaKTRaBAKhTCZTIyMjMh7SnhGFouFdrtNo9FAp9PhcDhkaE0xLlqcTidOp5MDBw4wOzuL3+/n9OnT6HQ6rl+/TiwWY2Njg4WFBZnbE9V3inF5AKvVSjgcJhAI0O/3qVQq3L17lzt37rC+vk4sFqNQKFCr1Wi1WrTbbdrtNv1+n3q9TrfbpdVq7fRlPBf0ej1utxufz4fJZAIgGAzyyiuvkEgkSKfTlEqlp3ovjUYjy7snJiaYm5uTLnmlUuH69etks1nq9Tq1Wm1fbI46nQ6bzYZerycYDOJyuTh16pQsJKlWq9IjXltbo1qtsrGxQb1el2sbj8dZX1/HaDQyPz+PxWJhcnKSaDSKwWCQhQBHjhxBrVaztLSExWKhVquRSCS+tfF/XgwGAxqNBsViEY1GQzqdRqfTPfS6QqFAt9ul3+/TbDapVCryJK1Wq5mfnycej1MoFIjFYrhcLg4cOCDzMyKP6vF46Ha7nDp1CpfLxcrKCmtra/R6PZlbfVEwm804HA4cDgfnz58nHA4TDAYJhUI4HA6cTidqtRqLxYLZbMbr9crqWIvFglqt5tq1a+j1ehqNBtls9rlWz+5a4+JyuTh69Cgej4der0cmk+G9997jf/yP/0G5XCaRSEhjAo8uhXwRcgMAJpOJ8fFxpqamZBz20KFDjI+Ps7i4yJdffsnq6upTvZder2dkZASPx8P58+f5vd/7PWlcxMm7UqmQTCZlfHyvYzKZiEajuFwu3njjDY4ePcrIyAiHDx+m1+uxurpKoVDgv//3/84vfvELme8bzkGp1WqZWxD5mn/2z/4Z/+Sf/BPcbjdTU1NYLBbeeust3nzzTb766iveffddEokEv/71r3e1cSkUCsTjcarVKr1e75FVcvF4XJYRi/sjHo+ztLREu91meXkZrVaL3W7Hbrdz5MgR/o//4/+QeVSr1YrdbsdqtRIIBFCpVGQyGf72b/+WYrEoDdZ+uN++CbGPud1uDh48yOjoKP/b//a/cfDgQfk9rVaLyWSi2+3idrupVCo4nU6i0ShWq5UjR45gsVj49a9/zbvvvsvGxgZffPEF9Xr9uV3HrjMuwkjo9XpZatzpdOj3+5RKJXlqbrVaL7y7bLFYsNlseL1eTCbTluodnU4nT+TDf/9NqNVq+aBbLBYsFou8obvdLsFgkGg0SrvdZn19fV8YcJ1Oh9frxev1EggEZM5EbGrxeJxcLsfGxoY8iZvNZmlERB+WVquVnnOn06FQKMjGXrPZjNlsxm6343A4ZDl9tVr9Vr+f581gMNiStxsMBvKwMUw6nZbGRTRGigS/OASq1Wp6vR7NZpNUKsXm5qasJDMYDKjVaunBuN1uVCqVLHuG+2HZ/XC/fRN6vR6dTidzVOFwGIfDgdlsplarUavVUKvV8j7L5/Pk83l0Op0shLBYLLjdbpxOJw6Hg2Kx+Mjf27Nk193VJpMJvV6Pw+GQsetMJiPj/SJh9aI3R6pUKl5++WX+wT/4B/LUvR0YDAZGR0eJRCJ4PJ4t3zObzfyjf/SPuHjxIr/4xS+4efPmvjDwLpeLV199lbGxMY4ePcrY2Bg3btzgv/23/0Yul+PevXsUCgU2Nzfp9/v4/X5efvllXC4X4XAYl8uF2+0mHA5TqVT49NNP5eb5f//f/7cMAXm9Xv7xP/7HHDt2DKfTKYsljEbjDq/A4+l0Onz11VcsLS2h1WrR6/WP3KSEQel0OszPz7O6ukq1WpUGp9vtolKpqFarNBoNbt26xZ/92Z/h8/n4wz/8Q06dOoXFYsHpdGIwGBgbGyMQCHDo0CFWV1dlld1+uN+ehEajYXR0lEAgwEsvvcQf/dEfYbVaMRqNbGxscPnyZS5fvgzcPxR1u11u375NIpHA6/USiUQYGRnh2LFjaLVafD4f09PTdLvd536I2VXGRYQUdDqdrKXX6XTU63WKxSKVSoVGo/GtTi+Pqk3fD661SqUiFApx+vRpPB6PzLUM813KEDUaDQ6HA6/X+1Afh2hQHR8f59NPP33uJ6HtRpQNW61WxsfHGR8flzmXRqPB1atXSafT3Lt3j2KxKO9Pi8XC+Pg4fr+f6elp/H4/oVCIqakpCoUClUoFi8XC6uoqly9fxul0Ui6XCYVCvPrqq8B9I+5yuXA4HGi12oeaDncLg8HgWzcjZ7NZstnsQ+8jQtXitH3z5k3cbjfnzp2THpxowrTb7bIM3OPx0Gg09vz99jSo1WocDgd+v5/x8XGOHj2KTqeTyiNra2tcvXoV+Nq4LCwskEwmCYVCsvG80+lID9vlcsmS+OfJrjIug8FAutDVapVyuYxer3+q08pwn4FOp0Oj0ciOYqFN1u/3SaVS1Go1qtUqxWJxVz7QT4vD4WB0dPSRoa90Os3S0hKrq6tPncyH+97JsWPHOHr0KKOjo1uMc6fTYXFxkWw2y/Ly8p72HlUqFRcuXOCVV14hHA5z5MgRWcq+vr4uv0SZsdPp5OjRoxw5cgSPx8OBAwew2WxSKcJms8mH+dixY0QiETqdDhqNhlqtRi6Xo9PpyPcdDAaMjIzQ7/c5d+4cHo+H1dVVEonETi/Nc6HT6VAulwFYW1vj3r17jI2NbZGUga/D5Pu9gdFoNMrc0w9/+ENOnjzJ2NgYg8GAYrHIZ599RiwW4/LlyywtLQHIMKyoji0Wi6ysrKDVaimXyzSbTUwmE8FgkEQi8WJ7LnC/c7fValGtVimVSphMpqfaxMSpUqPRYDabMRgMHDx4kOPHj0t3vt1uMz8/z8bGBslkklKptGeNi0qlwm63Mz4+jk6ne+jhS6VSUqng25QimkwmTp48yYULFx56z06nw61bt7h9+zYLCwt72rio1WpeeeUV/q//6/+SoZ5er8fy8jKpVIqVlRVWV1fpdrvMzMzgdrv52c9+xr/4F/9CehrDm57402w2c/LkSZnw1+l0LCws8Ktf/Yp8Ps/q6iqrq6uEQiEmJiYwmUyyEqjb7b4wxkX0YLTbbVZXV2Xp8dzc3ENr+iJgNBqJRqP4fD7eeOMNfvzjH8sy7GKxyCeffMKNGzdYW1uThxOB+G/hNWu1Wql+IJrQV1dXv1GuaLvZdcZFMNxd+qABUKlUaLVa1Go1NpsNo9EoO/RFWa7RaOTQoUNMTEzIUFu73aZer2M2m+n1eqytre25BKFGo8Hj8WA2m3G73Q9pNgmq1Spra2tsbm7SbDaf+v1FB/CjXGjhUQoV272ISqWShw+LxYJOp5PViPV6XZa6V6tVZmdnUavVHDhwAI/HQzgcRq/XMxgMZLm7KIcXGAwGIpEIBoNBHnY0Go3MO6TTaVZXVzEYDExMTEiPW1SavWiIk/fGxgbRaHTPPY/bhclkYmJignA4LEuMi8Ui8XhcHoZzudwT0wJiXxR7oyiMEgU6Itxbr9efi/r0rjUuT0KUNJpMJhm+ETFKm83G1NSU7NUwGo3yhNntdjl8+DD5fJ6//du/5erVq3suQWixWDh//jxjY2NbShMfJBaLydNypVLZlp/d6/XY2Njgzp07pNPpPbkR6PV6IpEILpcLr9eLSqUin8/zu9/9js3NTd555x3m5+c5efIk/+bf/BsZAhNVN2q1mnK5zOrqKsVikQ8++ICFhQX5/uFwmP/9f//fmZiYeOhnt1otvvrqKynOeOLEied45buTTqfD3bt3SafTeL1eOp2OzPUNHyz3aoThaQkEAvz85z9namoKv99Pr9fjzp07/Pf//t9Jp9N8+eWXsiLvcYgRJHa7XVaciUPO+Pg4R44cwel0srCwQCaTeebXtCeMizjdidOmVquVpXnBYJCRkRGCwaA0LhMTE9hsNgCZROx2uzIZ2+12pdHZa2g0GrxeLyMjI9jt9sdeQ6vVIp/Pb6v4X7/fp9FoUKlUaDabe/KBF96uy+XCZDKhUqlot9tkMhlSqRS5XI58Po9KpZI5gLGxMex2O71ej1arRa1WI5vNksvliMViLC8vy/cXTYSPot/vUy6XyWazVKvVPbl+281gMJBrOqxL9uBr9iui/NpqtcoGSeFNVyqVLU3Q39QLpdPpZEOlyDOLlgSj0YjJZMJkMj238NiuNy6iA9VgMPDyyy8TDAZlkspsNjM2NibDRHa7Hbgfe8zlcrJkOZPJcPPmTVl11mw296TXAvfd5zNnznD+/Hn8fv9zNZBCU2txcZF6vb4nH3qxfgcPHmRmZgaVSkWz2WRtbY1kMsnZs2d5/fXXOXToEIcOHZK9VoPBgIWFBe7du0c8Huf9998nn88Tj8e35LTUavW3CkO+6Gi1WkZHRxkdHSUcDj/3vMBOMzIyIkvgvV4vFotF5ps3Nja4d+8e+Xz+ic2PIgQ2OjrKxYsXiUQiBAIB2TskDlD5fJ5sNvvclEt2vXERpXUGg4EDBw5Ir2R0dBSTyYTL5dqiflyv11leXpaidyJh+N5778kkV7fbJZlM7smEtF6vZ2pqiuPHjz/3ny3i48lk8rn/7O1Cr9czPT3NiRMnZOlmu90ml8tRKBR46aWXOHHihPSIRYVNv98nmUxy7do1lpaWePvttx/pFbrdbmWa4rdArVbj9XrlIXEvRhO+K2JWzszMDGNjYzJ/LELZ+XyejY0NWVX3pPcR63jkyBFCodAW9WpAekKVSuWJobXtZNcZF5EANRgMmEwmrFYrZrMZrVYrPRGDwSBdv2QyKaUhhIilSMi222263S6ZTIa1tTU56a7X6+25sITT6WRkZIRoNCpDfg/S7Xa5c+cOGxsb3Lhx41vdRKIJcGZm5nuNr92tCCFJoSorJEbS6TStVoupqSkCgYDsddHr9WSzWdrtNvF4nHK5zJdffsmVK1fIZDKPNSDdbpd8Pi9L3ofRarWMjY0xOztLJBJ5Ifo2vol+v0+xWGRzc3NLuPBJs3L2G8P7kFiPeDxOPp9/YvJeKEMIw3zs2DFZ2WgwGORhsFgsyjlC1Wr1uUVsdp1x0ev1UvrFZrPhdrtlCAy2NmO1Wi2uXr3K0tISy8vLXL16lUqlQjqdloZEiOkNj0/d6TkH34VgMMiPfvQjRkZG8Hq9j3xNs9nknXfe4Z133iEWi30r9zcSifCjH/2I0dHRbev2301YrVYmJycZHR1lenqaqakpNjY2WFpaotvt8vLLL6NWq5mdnSUcDpPNZlldXSWTyfCrX/1K5lZWVlbo9XqPNdzCGInJisMYDAZOnDjBD3/4QymX/qIjikQajQajo6Pk83mpl/UirY/Yj0Q5+s2bN0kkEo+NrgjlaYvFwssvv8zRo0c5fPgw58+fl+GwXq/H+vo6d+7cYX5+Xhrw51WIs2uMi3DthEy5w+HAZDJhMBhkeZ2gXq+TTCapVCqsr6/Lcj1hVIrFotQe24uhr2F0Op2U3BaqqA+e6rrdLrVajXK5LBPTYiDV06LX67d0jA/T7/elHPpeXU+dTofVasVms2EwGGSiU6yvmGyq1WrpdDqUSiXW19dJp9Mkk0nZF/VNSdV2u83m5iYWi2WLDp7Q5BIHJqFUW6vVKBaL5HK5FzJXMxgMpER8q9WSkYV+v/9CGRfBsPCpXq+X+T7h5Yq/FyXGQj0+FArJFgyNRkOn05FKCLFYjHQ6vUXo93mwK4yLqMc2GAycPHmSAwcOcPLkSaLRKCaT6SHtpaWlJf79v//3crZIuVyWVUziVLlXJv09CbVaTSAQwOv1cubMGd566y1ZQjtMPp/n0qVLJJNJvvjiC+7evSvX4GkRWleBQOCh9a7VasRiMWnQ9yI2m43p6WkikYgM+4nuekG/3yeXy5FOp/noo4/4i7/4iy0b/9Ns/rlcjv/yX/4LVqtVli+nUilZYhsOh5mdnaVSqbC8vMzy8jK/+c1vpMTMi4aQ9Aek7pjYUF9ENBoNkUgErVZLvV5nfn5eTtrV6XRS98/lcsn88/j4uLyXNRqN7L+qVqt88MEH/H//3/9HtVqlWq0+12vZceMyrCdmNBoJBAJMTEwQDAaxWq0PndJVKhWlUokrV66wsrIiZ23sR8QgJY/HQyAQIBqN4nA4Hnpds9lkY2ODeDxONpuVBuBJ0hkP/p3ZbMbpdD6UCATkSb5YLD63ZOB2I8RQh69PFIoIOp0OyWRSVoFdv379Wz+QrVaLxcVFWcocjUZlHkFUPjqdTik/lM1micVirK+vb+v17iXErBbxtR8Ohk/Lo0L04pl3u9243W4ajQZWqxWdTidzdh6Ph8OHD8tDzHBR02AwoNlsUq/X2dzc5N69ezvSk7ajxkVoNolklBjSNDU1hdvtln0FwzMMhKvc7Xa/9el8r6HT6Xj55Zd5/fXXGR8ff6x6rtFoJBwOo9PpOH369BYDNDwidfj1Xq93ixERI41F2fcw9XqdRCLBxsbGnu3MfxKtVkt26H/11VcsLi5y9+7d75X4FJpQYtMIBoN4vV65CdRqNdbX19nc3Ny3h6OnQaPRSO98bGxMDmjT6/VbDkf7sYpMjCfY2NjA7XZTq9Vk/55Op+PkyZOykEnkUXw+n2y98Hq9MkT24Pt2Oh2ZGtgpQ73jxkUkWH/+858TCoUYHR2VnbqibHj4BhPKqcOnnP2KVqvl3Llz/Mt/+S8fK/MC90/goVBINoiGQiH5PZPJxOzs7BaD43K5mJ2d3aKk/KSHuNVqSePyPIcNPS+azSabm5vk83kuX77M1atX2dzc/N5VNWJ+uSg3Fb8juD/VU4R1X+TSZbVajd/vZ2Jigmg0SiAQkAZ4L/ahfVuq1Sqbm5v4/X45n0VM53S73Rw+fBhAygMNC/QOP6vDBqTX69Fut2k2mzuaI90x4yI0nnw+Hy6XC6fTidVqpVKpUK/XKZVKUubbYrGg1+tl4spoNBKJROh2u2xubn4r1d+9hggbPgkhk6/T6Wi1WlvyCAaDAb/fv6V8WWiwPW3CdDgsth83wmazKZOeIiy2HU2iQn7I5/PJEufh381+CP0IXbTh/xYS7yIx/SQMBgNzc3NEIhGCweALl8Rvt9tUq1Wy2Sy3bt2iVCrh9Xql92YwGKSKwXBIutfryVyV1WqVxU9ms1n28YkilJ1iRz0Xr9fL3NwcY2NjjI2NYbVa+eKLL1haWmJpaYnPPvsMjUbD9PQ0LpeLH//4xwQCATweD2+88QaJRIK33357XxuXp8FsNjMxMUG/32d6enrLaWVYzE4gZCGellqtxvLysuwf2m8IbbG1tTVu375NPB6n1+t9r1OfSqXC5/MRCoWYnJzkJz/5CX6/n2AwuI2ffOcRFU2iN81oNHL+/PktIwke53GL6rzR0VE8Ho8cHfFgy4D47/2IOEw3m03+03/6T7jdbo4fP87ExAQ+n4+JiQm63S6rq6tUKhX6/T69Xo9yuSwnwR45ckR25Y+Pj1OtVvn000+5d+8ey8vLL1ZYTDRKWq1W3G43drtdysaXSiUSiYRMcqrVakwmk2yU7Pf76PV6Ke4mEl1i0V9EhO4a8MihYd8V0SdUr9cpl8vUarU9m9B/FO12m1arRbFYJJPJyGmH21USbDAYsNvtOJ1O/H6/jJGLkK/YVPZaaFfMTBKD1qxWK1qtFrPZjMlkIhwOyzlDXq/3id6IVqslGAxKz/vBoWmi2OdRYyX2A+IQU6vV2NzcpFar4fP5MBqN9Pt9rFar9ERENazotheRHaHLJsq4hdSLyCPuFM/duOh0Oim6ePr0aV599VX0ej3lcplkMsmlS5f43e9+R6lUIpfLodFoWFlZIZvNkkwmqdfrmEwmXnrpJQqFAisrK9RqNSlLstce1N1Kv9/n7t27LCwscPPmTW7fvi07qPcDg8GAzz//nA8//JBYLMbVq1e3VUFapVLh9XqZnp6WxRJ2u10qSXz11Vf8+te/plgs7jnP22g0Mjc3J0U9JycnMZlM+P1+WfHpdDplBejjjILIG5hMJmmsHvx+MBjk6NGjaDQaPvvss+dxeTtCo9EgFouh1+vJ5/PYbDZMJhM2m43BYEClUpGFH4PBQM5psdvtshhCpVKxubnJ+vo6CwsL3LlzZ1uFa78tz924aDQaeZITZXWtVot4PE4ul2NhYYFr165teX0mk5HNZu12G71eL93G0dFRgsEgvV6PVCr1vC9n3zIYDEilUty4cYOFhYV9l9saDAasrq7y7rvvks1mWV9f/8YGyW+DKCMPBAL4/X6ZqM7n83Kmi+hh2GuIfgsh437s2DHsdjujo6MyR/BNoZjhhPTjXq9SqXA4HEQiEdLp9HOfpPg8Eb0pwFPtY6Jp0uVyyfCjOLjk83mSyeS2FKV8H577b0sIL05MTBAKhdBqtaTTaT7++GPi8fhDk/hEMgtgdXWVzz77DJ/Px6FDh2ScV1RX7Ee3+bsiejVEqFCUPYq+oFKphFar5fz580xNTe3wp332iDHFQtQPvq7UKZfL2xZSFRMF7XY7p06d4tSpUwQCAfR6Pa1Wi8uXL3Pt2jXm5+f3TBhXVCi53W6i0Sgej4dz584RjUYZGRnB4/FIKffBYECtVpPhvsdtbiLZr9FoMBqNjzUcTqeTaDRKr9fjZz/7Gfl8nrW1NenxZbPZfZuPeRIiNRAIBGTyX4x0EOKUYhrqTvHcjYvJZOLEiROyn0Wn05HJZPjFL37B4uIi+Xx+y+v7/b6MTV+7dg21Wi0nTJpMJiwWi6yWUIzL12xsbPDuu+/Kk/FgMGB9fZ1YLEaxWGRhYQGz2cy/+3f/7oUwLqFQiNdeew2/3y9zdIVCgeXlZVqt1raFUy0WC+fOnWNsbIzXXnuNixcvyrxBJpPh7//+7/nlL38p+7T2AiJHGo1GeeuttwgGg1IfTRSLiKpGIbyYz+dlOeyjNji9Xi+leHw+H1ar9aHXqFQqAoGATGwfOXKEUqnEb37zGzlqu1AovBAlyw9iMpkYHx9ndHRUyr50u11yuZycWLnT6/LcjYtKpcJoNGI2m1GpVDQaDSnd8jg5aCFUWa1WSaVSMgwm5sgHg0Hy+bwcQbvTFnu76Pf7bG5ucuvWLbRarZz1LqbLCTqdDpVKZcvNtLCwwPr6uiwdFpLxmUyGVqslR58+qVS0VquRyWQolUp7Npel1+vRarVyUJIYdy2S+dvVK6XVatHpdFJ5WUh0GAwGqZSczWYplUp7rldIqO+KgVaBQEBOehXhrU6nQy6Xo9VqEYvFpHL040q6zWYzfr9f5hUeZVzg67HbRqMRp9OJVqslFApRq9VoNBpST7BcLr8Q3f2ivN3tdssufrHvNRoNstkshUJhV7QMPHfjIm4Um81Go9FgdXVVDlyqVquPDRWIk7dI8jebTbxeL6dOnWJkZASr1crCwgLlcplSqbRnToVPotls8ud//ue8/fbbuFwuIpGIHJA23LeSTCb56KOPtuRERI5KbJwivNhqtZicnORP//RPGRkZ4dChQ4/82f1+n1u3bvE3f/M31Ov1PbchwtfabB6PRw6i6nQ60ntLp9PbthE5HA5GRkYYHx/nzTff5NChQzgcDlQqFalUikuXLrGxscHm5ua2/LznhTgMWiwWxsfH+eEPfyjLhocT8KlUil/96lekUinu3bvH5uYmzWaTarX6SOPt8/k4efIkHo+H3//933+s0rdAp9PJXrjXX3+dM2fOsLS0xLFjx0gmk7z77ruk02mazeau2FifBSqVimg0yszMDIcPH+bcuXMEg0GMRiO9Xo94PM7vfvc7ksnkN86AeR7siOcilGi73S6NRmPL7JUnITa5YrEoXysst8/nw2Qy0Wq19s2cjH6/L8UNfT4fuVwOu91Op9PZIou/vr7O559/Ti6Xe6r3VavVzMzMMD4+jtPpfOj7QnZHKKruVa9FpVJhsVikqJ9KpZIesJhIuh0/A+6fKD0eDz6fj5GRESKRiMw5VKtVYrEYiURiT1bb6fV6zGYzDoeDQCCA2+2W3xPJ+Hq9zsrKCrFYTM4UEu0DDxpw0XIQCASkDpYoQX7UWIx+vy/zPjqdTsrFwP0qKzH3aS9r3z0NKpUKm81GKBQiGAzi9/vxeDzSEy+Xy2xsbJDL5XaFgd3R8otSqUQmkyGZTH6r+GCj0SCRSKDT6TCZTNJF9Hg8AFJyfz8hlIkNBgP5fH6LVlixWPxWnoVQOBgdHX0oHFEsFvnggw9IJBLcuHFjT4cYNBoNs7OznD17lrm5OXQ6Hd1ul1QqJb3l73N9arVanuJPnz7N7/3e7+Hz+fD7/fT7fb766iuuXbtGPB7n008/lUKVewmtVsuJEyc4fvw4x48f31JaPBgMKJfLFItFlpeXuXHjhowuiKFUD66vUIo+cOAAb731luyJESFyYfQTiQSVSoXV1VVisRgmk0mOAT558qQMOx4/fhy32821a9cwGAzbXvW3WxhuOD179iyRSASj0Uin0+Hu3btsbm5y9epVYrHYlrLlnWRHjIu4OcvlMvF4nHQ6/a1OHGJmhqg8c7lc8qvdbu/LksXh0NTKysqW733bDVJIv0cikYe+VyqV+O1vf8uNGzdYWVnZ88ZlamqKixcv4vP50Ol0Mo8kQmPbYVwCgQBnz57lj//4j6WH1O12uXbtGv/1v/5Xstks9+7de2xyezej1Wo5cuQIb731Fj6fb0uOTqVSSeHF1dVVbt269UR1Z5EjHRkZ4eDBg3L4HXyt5JvL5SgWi3z55ZekUik+/PBDvvjiC5xOJ1NTU/j9fpxOJ8FgEKfTSSQSkeMUBoMBpVJpz4Uev4nhqZOhUIjjx4/jcrnQ6/V0u12Wlpa4ceMGt27dIpFI7ArDAjtgXAaDgXTjgO/UfdvtdqlUKpTL5X3tBj+O77pBjYyMEAqFOHjw4GPHyPZ6PXnC3ot5lmGGRxbY7XYZLv2+U0hFw6DFYuHYsWNEo1FCoRDVapVyuczy8jLFYpEbN27IJP5OqtN+HwaDAblcTh5oJicnpXSQGCOg0+nQ6/XyWRbDvgSik1/0px0+fJipqSnpBYkkvCgNz2azrKyskEwmKRaLMkxbLBZRqVTcuXNHNmiKcJhKpcLpdO7L8chqtVqqJbvdbjlIsdvt0m63SafT0mPcTSHs525c+v2+TPQNBgNZRvxt8iT1ep14PI5KpWJ8fBzYv9pD24VGo+HChQv87Gc/IxwOPzLXAve9wlgsxsLCwo6XMn5fhOLu7OysLKfdDrxeL2+88QbBYJA333yTw4cPy6mo6+vr/D//z//D3bt3qVar1Ov1J45F3u10u11u3rxJo9Hg/PnznDhxQm7gg8EAnU6HxWLBbDZjtVqxWCzU6/UtMX+9Xk80GsXtdvPTn/6Un/zkJ9jtdqxWq5RtEtWMn3/+OZubm7z77rskk0mZF6vX66yurrKxsUGr1eJ3v/ud1DITxQZjY2PcvHlzR9bpWWIwGBgbG8Pn8zE9PU00GpVj3guFAjdu3OD999/f1n6t7WBHjEulUqFQKNDr9TCZTJjNZqlL1G63n2qBhOT+9z2FvgiIMlmXy8Xo6Cgul+uh0KE4BYkSz93iWn9fxAlXIMY1fJtZQKKPQ0xFDQQCcuS0z+fD7XZTrVZJp9NSfmO/DP8SHkU2m5UVncNl8WKWu9lsxuVyUalU0Gq1W/IeQv3c6/Xi9/uldhYgddY6nY7UeBM/a7jiSYza7vV6ZLNZOp2O/N3a7Xb8fv9DumT7BaE07ff7ZftAp9ORY7JFhexuC7s+d+NSrVb5zW9+w/Xr13n11Vd54403sNlsrK+vs7Gxwfz8PLFY7InvodVqZY7lmyS9X3TEqAK73c7s7CwzMzOYTKaH1i0Wi3Ht2jVWVlZ2VI/oWdPpdEgkEiwsLJDL5b7xYRTrZ7VaefXVV/nhD38oK3bEGt69e5dPPvmE//E//ge5XG5fxfzF6OdOp4PD4eDtt9/G6/Vy9OhRPB6P7BSfm5vjT//0T8nn8ywvL0tRRQC73c6FCxcIhUKMjY3hdDrpdDqkUimazSYLCwskk0muX7/O7373OxnyftznERpwQuJfp9MRj8fRarX7au0FNpuNN998k+PHjzM1NYVaraZcLnP16lWSySSxWEx6LS+0cWm1Wty7d49YLMbx48elBPnMzAwWi4VYLPZUxkU0xe3H5P12IrTcRJms3+9/ZAiyWCxy584d4vH4vqy2EfT7fVml+DRlwWL9vF4vL730En/0R38k16/T6bC4uCgT9h9++OGez1M9iJBz6Xa7xONx7ty5QyAQYHR0FLvdLkNTarWal156iWq1itPp3OK5OZ1Ozpw5QyQSkRL9Im9aqVRYWlpieXmZW7dusbCw8MQyWlH2/CD70agIjEYjBw8e5MyZM1KJpNlsEo/H2djY2LXVsTuWcxE9HJcuXZJ9F9FoFI1Gw8TEhJz93O125RQ2Ie89MzPD1NQUwWCQRqMh6+uTySSFQmHPxrefBWLMsRgf+zgymQyXL18mlUrtyV6MR9Hv91lbW+OLL77A4/EQjUYxGAzMzs5KJYf19XV52tNoNHISqtfrJRqNYjKZCAQCWCwWDhw4gEqlkiWy1WqVhYUFUqkUq6uruyrevZ2I3Fsmk+HKlSu43W5UKpWsOBSlxDabDbPZzOzsLH6/X/570S4gqpuKxSKFQoHV1VUKhQK3bt2SjZf7dQ2/C6LVQoTCNBrNloNNqVSiUCjsWvHTHakWE1phN27cQK/XMz09zT/9p/8Ut9vN7Owsm5ubXLp0iXw+T6PRkHLckUiESCTC3NwcR48exe12c+vWLTY2Nrh79y5ra2vUarVdacV3Cp1ORzgcZmJiApfL9diqvEQiwbvvvkupVNo3D3i32+X27dvYbDYOHz4sp5ieOnWK0dFRcrkcn376qcy9iLLbo0ePcuzYMd58800ptSOGrqlUKvL5PB9//DHpdJqFhQXS6TTxeHzPF0A8jk6nI5UNNjY2MJlMrK+v4/V6OXfuHBcuXMDpdMqQaygU2pLPGp6mWqvVpGrv/Pw86XSazz77jFu3br3QM5kehcFgkMrHQtxT5JWazaacQaQYlwcY1gozm81y0lqtVkOj0UhD02q10Gq1aDSaLZ2p/X5fDtgRMV4xMGc3xR13Gq1WK+VPHvRcRBNcs9mUekT7aYMcDAbk83nW19flcDkhmNjr9RgfH+fYsWPymsVBR8xyF+WzQoOsVCpRq9VYW1tjbW2NXC5HJpPZtrHIu51+v0+/30etVlMsFgFkZaFQRhbVn2LdhtdlMBjIDTGTyZBIJMjlco/VFHzRMRqNeL1ePB4PBoMBtVrNYDCQRRD5fH7X6Ig9ih1NWCQSCQqFAvPz89y5cwe73c6JEyeYnJxkenqaM2fOyFOjqJW3WCy02202NjYolUr88pe/5PPPP5fVJeIBULiP2Wzm4sWLXLhwAavVusVzabfbXL58mcXFRa5du7bvHnDRyLi4uIhKpeIf/+N/jMViYXR0lFAohN/v5/d///fl5jfcTyDGOLTbbdbX1ymXy1y+fJmrV6+STqe5du2a9JLFyf5Fue/EmmxsbLC+vs57772H3+/n7NmzcnT56OgosViMGzduSOM9GAxIJBKy+17k93aDDtZuJBgM8uqrrzIyMoLf70ev11Or1aRax+XLl1lfX6dWq+30R30kO2pchCJytVql0+lsUV11uVxMTEzIOS0qlQq9Xi/lT9bX10mn06ytrbG0tESv19tXp+7tYjjn8iBCdl4kBffbyVt0bIuppu12m36/L5v3bDab7JMSiMOJEPpsNBoUCgWZI7h16xaFQoF4PL5rwxHPmuGkujAMhUIBl8tFsVjE7XZjsVhIJpMsLy9vUeZOJBLSqGQyGeWZfQIWi0Xuh8Jz6XQ61Go1KpWK9Fx2K7ui1EqEHBqNBh9//DGLi4tYrVa8Xu+WyiYRHms2m2SzWWq1GktLS3u2+1nh+SGkRILBIIcPH5Y6dMN0u10purixscHt27elcRHVOYlEQvZlKHxNrVbj1q1bmEwm4vE4LpeLQqHw0DREMbDuRfL0vi1iTEQ4HObUqVP4fD7sdrtUKv/0009ZWFjYtR6LYFcYl16vJyuUxLCwp5GDUQyKwtOSy+X48ssvGRkZkdMTH6TX67G8vMzVq1e5evUqf//3f7+lLFu53x5PvV5naWkJgPn5+X3b0PisEarxYoja4cOHZdNzv99naWmJt99+m2w2u+tbBnaFcXkUyo25PQxX5Qk1BCHZ0Ww2WV1d5e7duySTyX19kiyXy3JyoclkeqRMSLvd5sqVKywvL8sTt3IffjeUdfvuiDEDotBGjI5Qq9UyVCvaOXYzu9a4KGwPxWKRX/ziF3zwwQeylNvhcDA5OUm73eaDDz7g3XfflUnp/crGxgb5fB6NRsNf//VfP7L5VpR4irXYrVU4CvsX0X8l+oGWlpYolUpSYl9IZ9VqNcW4KOws3W5XajGJUGOtVpPjd0Up6H5HDO0CtkzsVFDYbQjPpVarkUqlaLfbqNVqTCYThUJBVijudu9QNXjKT/htJPH3O9/ll7pT6zcsdz4cFhOKtCsrK2Qymef6mfbS+u1Gvuumoqzh1+zme1CtVqNSqfB6vYyOjmIwGDCbzWg0GjkWvtvt0mq1dszAPM3PVYzLd2A335h7AWX9vh+Kcfn+KPfg9+Np1m9/DJtXUFBQUNhVKMZFQUFBQWHbUYyLgoKCgsK289Q5FwUFBQUFhadF8VwUFBQUFLYdxbgoKCgoKGw7inFRUFBQUNh2FOOioKCgoLDtKMZFQUFBQWHbUYyLgoKCgsK2oxgXBQUFBYVtRzEuCgoKCgrbjmJcFBQUFBS2HcW4KCgoKChsO4pxUVBQUFDYdhTjoqCgoKCw7SjGRUFBQUFh29E+7QuVKWxfo0yx+34o6/f9UCZRfn+Ue/D7oUyiVFBQUFDYERTjoqCgoKCw7SjGRUFBQUFh21GMi4KCgoLCtvPUCX2FvYlarcZkMqHRaDAYDBgMBnq9Hq1Wi36/T7PZpNPpyNcPBgP5paCgsPOoVCqMRiNarVY+w+LvBYPBgHa7Tb1ep9fr0W636ff7O/WRAcW47FtUKhUqlQqbzcZLL71EIBBgbm6Oubk5CoUCN2/epFgs8tVXX7G2tib/Xb/fp16v0+126ff7O36DKii86JjNZk6ePInP5+Po0aPMzc2h1WrR6/UA9Ho9er0et27d4uOPP6ZQKHDnzh1KpdKOfm7FuOxj1Go1BoOBSCTC5OQk58+f5wc/+AGbm5sYDAZSqRSxWIxMJiP/Ta/Xk56MMDAKCgo7h16vZ2RkhGg0ypkzZ/jBD36ATqfDbDajVqtptVp0Oh1sNhuxWAyDwcDy8vJOf2zFuOxXbDYbPp+PYDDIqVOnOHDgACMjIwBYrVZmZ2cJh8OYzWYuXLgg/12r1WJzc5NarUahUKBQKFCtVtnc3KTVatFqtej1ejt1WQq7FIvFwujoKEajEb1ej1r9dTp3MBjQaDRot9vkcrkthxmFx+NyuRgZGcHn83HhwgUmJibwer2k02lMJhMAOp0OlUqFXq9nbGyMN998k42NDWq1Guvr62SzWfL5/I58fsW47FPsdjvT09OMjY1x8eJF5ubm5ANvs9k4cuQIg8GAl156SeZXBoMBtVqNO3fuUCwWWV1dZW1tjUQiQbvdplKp0O/3FeOi8BA2m40TJ07gcrkwm80yZAP3PeBsNkuj0WB+fp5sNqvk9J4Cj8fDyZMniUQivPHGG8zMzBCPx4nH41gsFoxGo/zS6XRMTU0xPj5OIpEgmUxis9m4deuWYlweh1arxel0YjQasVqtOBwO+b1er8fm5ibFYpFut0u73X6hb1qVSoXFYsFgMDAyMiK9FZvNhkaj2fLa4ZMlQLvdll6Jw+FAp9PRbrcBMBqNFItFSqUSCwsLNJvN53ZNCjuDCKlqNBq5eZlMJpxOp7x3hu8hj8fD7Owsdrsdg8HwkHFxuVw0m015j7ZaLarVKt1ul1arRbfbpdFoUKvVXuhneBiLxUI4HMbn89FoNEin06ysrLCwsIDVaqVer0uP0e12o1Kp0Ol0GAwGXC4XPp8Pk8mESqXakTXd9cbFYrFw8eJFIpEIZ86c4fTp07JKolqt8md/9md89NFHFAoFUqkUvV7vhb05NRoN4+PjjI6Ocu7cOf74j/8Yu92O2+1+7L8ReZVcLsfGxgY6nY5QKITZbGZqaop2u02xWOTs2bOk02n+43/8j0pY4wVAHFCsViujo6N4vV6mp6e5cOECJpMJrVa7xbjodDrsdrv8+wcrmcR91mg0qNfrZLNZrl69SrlcJpFIUCgUWF1dZX5+nm63uxOXvOsIhUK8/vrrGAwG7t69y1dffcWlS5f45JNPsFqtTE1N4fF4+JM/+RNeeuklaVhMJhOHDh3CbrcTi8W4du3ajnz+XW9ctFotbrebYDDI5OQkR44ckTduuVxmZGQEr9crXe/BYEC/338hDYxKpcJqteJ0OvH7/YyOjmKxWGRpsaj+Gv7/drtNt9ulWCySzWYxGAz4fD7gfpWKOIl2Oh3pPYr1f1HWWFyvWq2WG+rwGjzqa6+j0+lwOp04HA6CwSChUIjx8XEOHTqE2WxGp9M90hsW6/IoHa7h+y6ZTFIulykUCsB977harWK1WmWC+kU+KML9vc9kMqFWq+XheX19nZWVFWw2GwCVSoVcLke1WsVkMsnfi91up9lsyqT/TuyJe8K4BINBxsfHcTqdWxbIYDDwk5/8hMOHD/Ppp5/yV3/1V3KxRUjnRULUw9vtdoxGIyqVaktp8cbGBhsbGzSbTfL5PK1Wi2QySalUkuum0+kIBAJYLBaOHTvGoUOH0Gq12Gw2er0ePp9PuunVanXfP/xqtRqLxYJer8fr9eL1etHr9TgcDlQqFZlMhmq1Sr1ep1Qq0el0qFardDqdPb02fr+fP/mTP2FsbAy3243NZsPlcmGz2R7pnXS7XUqlEv1+H71ej1arlX0ZAvF6jUaDy+Xi+PHjNJtN5ubmaDabpNNpfvzjH5PJZHjnnXfY3NykWq1Sq9We+/XvBm7dusV/+A//AZVKRTKZlIU14plOJBIUi0X+7u/+jnv37nH06FFeffVV1Gq1DJVFo1H8fj/NZlP+fp4Xe8K4eDwegsGgPIULdDodp0+f5vTp0wB88sknqNVqyuXyC2tc9Hq9PFnC/dNiq9Wi2WwSj8e5efMm5XKZWCxGtVplYWGBVCpFq9WiXq+jVqux2WyYTCaq1SoWiwW3243X6wXA4XDgdDqB+2HJ/Y5arcZsNmMymQiHw0xNTWGxWAgGg6hUKpaXl8lkMhQKBVQqFc1mk2azKUM7e9XAOJ1OXn31VQ4fPozBYECrffJW0e/3ZQ5FJPRF7mXYCIn/tlgsTE1NAV97NKJCcXV1leXlZRqNBp1O54U1Luvr6ySTSQaDAZ1OZ0vUod1uy/vu008/ZXl5mcFgwNmzZ7FYLPh8PtxuN4FAAJfLRblclgU5z4tdb1yeFr1ej9PppN1uP+Suvyj0ej2SySQajUaGFTQaDfV6nXa7TSKRIB6P02g0yGaztFotCoWCfIh7vZ7s2u/3+xQKBdLpNFqtFo1GI9f4wTDkfkGtVhMMBrcUkBiNRnmwCQaDBINBDAaD9FzcbjflcplarUaxWKTRaJBIJKQnU6lUaLValEolmbTeCzmFarXK9evXqVaruFwuGa4S90qxWKTVasnXt1otWVgjCgB0Op30oAXi7y0WC6FQCIPBgNPpxGw2o9Vq5cZ4/vx5RkZGZLViqVQiFou9UIfGfr8v75Vhw/LgayqVCiqVinw+T7lcBu5Xi4pn1mg0ymKK58m+MS5Wq5VwOIxarWZlZWWnP86O0O12uX37NgsLC3z00Uf8xV/8hQyNie+LOPaDfw7fuJ1OB61WSyKRYGFhAbVaLTuCw+Ewk5OTdLtd1tfX91WTpU6n48iRI8zNzeH3+5mYmMBisTA5OSlzTwaDQaofwNcPvchn1et1FhcXKRaLLC4usry8TD6f5+7du9RqNVKpFJVKZYev9JvJZrP89V//NR6Ph6mpKUZGRigUCsTjcSqVCvPz81tKXEX+bjAYyMOdRqNBpVJtSfzb7XZsNhujo6P8+Mc/xu/3Mzc3J0trDQYDNpuNP/3TP6XZbHL16lXm5+e5d+8ef/VXf/XCGZdvut5+v086nSaTybC2tkYymZQNlQaDQeZN2+32QxWiz5pdb1zEgzz8QD8KsVG+6EnATqezRSvsuyA2S5VKhUajQavVyk3CbDZjs9kwGo3b9Il3DnFNWq0Ws9ksvRNRJCI8Fq/Xi9VqlQn9Xq9Hs9nccp+J5KtWq8Xr9WI0GqnVarRaLUwmE7VaTeZi4P7vqdVq7dp7tdPpkMlk6HQ6mEwmBoMBhUKBjY0NqtUq6XR6i3EZPqgMP6/DG5pKpZLVYjqdTvZPiTCrqHSC+4dFs9mM3+8nHA5TLpfxeDyoVCpqtdoLZWS+CdF3JrTFLBaLfH6F9/hgePJ5sGuNi9jYxOb2qCTiMJVKhbW1NRnuUfh+qFQqgsEgx44dIxQKyfUfHR2l0+lQKBSe+0louxGbWSAQ4JVXXsHr9XLhwgVmZ2flqU8YDY1GI5PL+Xye27dv02g05HuFQiGmpqbQ6/UEg0HUajUjIyOcPXtWhiErlQrvv/8+i4uLrK2tce/evV0rsVOr1bh79y46nY47d+5gNBrpdDoyn1SpVB4peAo8MsciaDabsjJxY2MDs9nM2NiY9JBOnTqF3W5namoKm83G7OwsoVCIsbExAFKpFB9++CFLS0vPYRX2FtVqlXg8TrfbZWxsDIvFgtPpJBqNAnDv3r3n+nl2tXFRq9VoNBr555Msb7vdplwuy6SiwvdHnNodDocMdVitVtxuNxaLZc+OfRWnanGqc7vdzM7OMjIywuzsLJOTkw95yqJXQySdV1ZWZHxbeDPCw3G5XLLhEO57AY1GQ/Z0tNttarWaTMLuxvLlbrcry4S3E2GQqtUqhUIBrVZLOp3G6XTSaDQIBAK0223GxsZQq9U4nU6cTif9fp8DBw5gt9u5evXqjjUG7mZarRblchmr1Sq9Gb1ej91ul82Uz5Nda1xMJhMul0uGKSKRCHa7/aHXCVdcUfHdXlQqlfwdWCwWKeO9sLDAjRs3WF1d3VNrrdfrZYI+Go3idDrx+Xz4/X78fj9nzpzB6XRiMBgolUoyxCDWQaPRkMvlyOVyrK6u8vnnn2/ZfBcXF1lYWMBisRCJRLBarfLLbrcTjUax2+2cPn2aSCTC1NQU0WiUfD7PtWvXKBQKsr/jRWA4jFYqlWi1WszPz9NsNvH5fFQqFUKhENFolEgkgsPh4OjRo4RCIRYWFmTjryjNVbhvuEulElarVR6wzWazLCF/3oVOu9q4BAIBwuEwo6OjjI6OPtLy9no9ut2u/HrRcy7bidlsxu12YzQaGQwG1Ot17ty5wyeffEIymdxTGmMGgwG3243b7eaVV14hGo0yNjYmk/aBQACdTkc+n6dYLFIul8lkMqjVajweDzqdjlwuRzabZWVlhU8//ZRUKiXfX4QgRJjHZrMRDodl8+/Y2Bh2u52zZ88yGAyIxWLMzc2xurpKPp+n2+3KktMXBXEYFGXcmUyGmzdv4vV66XQ6jI2N8corrxCJRHA6nZw4cYJyuczCwgKDwYA7d+6QSqUU4/K/ENWfNpuNbreLSqXaYlyUhP4Q35TM7/f71Go16vU65XKZZrMph2ApfDdEr4zoURC5FmHEq9WqLLndS0bcZDIRDAbxer1EIhEikQherxebzYZOp5MJ9tXVVTY2NqhUKtK4OJ1OdDodzWaTRqNBLpeTfQeCTqdDvV6n3++TzWblf7daLVQqFffu3cPlcuH3+2Wy2uPxUK/XCYfDstLqRe3pGPZkGo0GGxsbDAYDxsbGiEQi0osWTb7j4+MUi0XMZjOtVuuF1xUEZGGK0WiUXorwwHdiX9zVxuWb6PV6xONxNjc3WVxclFLxe+lEvdvQarWyr8HhcMiqMGHAE4kEy8vLe85D9Pv9XLx4kVAoxKuvvsro6KjsuWg2m2SzWcrlMr/85S/56KOPZG4FkIl9j8eD2+0mk8lsSeYDMqQlpDrEBFCDwUAwGCQWi+H3+/mDP/gDjhw5gsPhwGq14vF42NjYYGpqivfee49kMrkTy7MrEAamVCrx8ccfYzKZpHLE+Pg4r776KiaTibNnzzIzM4PRaOTu3btUKhWlkIevhS6DwSB6vV6GHOPxONls9rnvi3vauIju81qtRrPZlDpZCt8dUW5stVqlKq4IX4gS3L2kiiwKQqxWK36/H5/Ph8vlwuFwSG+s3W5TKBTI5/MkEgnW1tao1+sUi0UAOWJWlB+Xy+WHHtThUngR2mo2m+h0OtRqNevr61J2p1arSZVhm82G3++n0+lgtVrRarUvfO5QSMnUajWSySSJRAKTySQLKCwWCzqdDq/Xi8fjkQb9RUdUNhqNRhkCE8UkO1H2vqeNi8L2YzabOX78uJxeaTKZ6HQ6sq9gL5Ufi9JpkbA/f/48LpdLiiQKEcBkMsnHH39MJpNhYWGBYrG4RRtMHFoymYzsXXma3Ihogsvn89y4cUM2EN65c4e5uTnOnj2LTqfj4MGDhEIhlpeXWV1dpVarkclkXmgPXHSnLywsUC6XmZ+fZ21tDa/Xy6uvvsr09DRnzpxBq9WyurrKn/3Zn7G6urrTH3tHMRqNUvZFp9MxGAxkT1KhUFA8F4WdxWAwMD4+zszMDIFAQM7l2Itlx2q1Gq/Xy+TkJNPT0xw4cACLxUK9XqfZbJJIJLh+/TrLy8v8z//5P8lms498H+GRlEqlbzWXXHgf1WqVarWKwWDAbreTSqXQ6/WcOHECnU5HJBLB7XbLqYNarZZcLvdCGxfhCW5sbJBMJllbWyOTycjeK6FN5vV6uXnzJn/5l3+50x95xxFlx0JcFL7uKxI5wOfJnjcu7XZbjlBV+O6IplVRVeX3+zGbzcD9zbXRaNBsNvfEhqfRaDCZTJjNZg4dOsSZM2eYnJwE7jcHLiwsyBLga9eukU6nn0uor9frkU6n6fV6pFIparUaZrNZft5AIMD09DSxWIz19fUXqnLscYgeoFarRS6XQ61WE4/HWV1dRafTyeKTveRRbzci9Gs0GqWMjqg8bDabsuhJCYt9CwaDAc1mk0ql8pAch8K3QxgWq9VKNBplcnJySxNgpVKhXC7viQ1PxOOdTic//OEP+cM//EPpeRWLRS5duiT7dS5fvky3230u19XtdllZWWF9fZ0DBw5QKBQYDAZ4vV5MJhNTU1NyLsfVq1cfKhp4EREeTK1WIxaLSV0zUfJ98OBBLBbLCytWK6o7RR+X0+mU6vHtdptqtUo+n6darSqey7dhWKZ7JyzzfkIYF6PRKHW2hGy/kHsRM2B2O3q9nkAggM/nw+PxyJGwQnYknU6TTCalIvTzvG9EiK3RaFAqldDpdLLE1mq14vP5cDgcL/RJ/FGIghJxGhfqzE+ShNpLiMjB8LUMD/d7Enq9Xiby9Xq9LK0XayVyhIrn8i3odDrcvXuXjz76iFgstidCNrsVIYE+MjJCOBwmFApJ45JOp3nnnXdIJBJsbm7u8Cf9Zvx+P//0n/5TJicnmZubQ6fTkclk+OCDD0gmk7z33nusrq7u6LCzTCbD1atXCYVCuN1uOVZaDHYaHrKlcB9hmOv1uhxlsF+q6sTkT51OJ/v6hGSQGIXxqHtVo9HIg1Q4HMblcqHRaOSYgo2NDbLZrGwwf57saePS7/cpFotsbm4+9ylru4FHNZc+STRQ8CgtK71ej81mw2azySY/8dp6vU48Hicej++JJj+z2SwT+KJUtdFoEI/H5TTOne4nqdfrpNNp9Hq9zBeK9Xe73Yrn8hj6/b48kQ+HMsWzsNeiF0JDUYS1RAGN8GKEUOjwsLAH/73ZbMbpdGK32+W/F/OFRJvGTqzLnjYuLypieJeYbT7896Ojo3JDfVwculqtsra2RqvVkieaSCTCzMwM4XAYh8PBYDBgY2ODVCrF9evXuXPnDul0ek9MnxSnQI/Hs2tHA2xubvLJJ58wPT3Nq6++utMfZ8/Q7XZlybHb7Qbue90zMzM0m01SqRSZTGYHP+HTIZLwc3NznDhxApvNRiQSkcUJKpVKqkRUq1Vu3bolte2Gr0+r1TI9Pc3x48eZnJxEp9NRLpe5deuWVJvYKRTjsscQar46nY7R0VFOnjwpT7l6vZ6XX36ZmZkZdDqdHGz14KklkUhw6dIl2c8hJLqPHj2K3W7fYlxu3LjB/Py8rLDaCydDoTLg8Xh2peIwIHM+okxZ4enodrusra1RKpWYnZ0FvvZUhYDtbjcuIr+i0+k4ceIE/+Jf/AvcbrfsKxNzg0qlkjSWf/VXf8Xq6iq3b9/eMgFWGJdz584RCoXQaDQ0Gg1u3brFrVu3pIzOTrDrjIuw2kajUc5yF8lPMalOJETFeFmR3NuPmEwm6TJ7PB45athoNDI1NcX09LQ0LjqdDr/fj91uf6RkvMBmsxGNRuW44l6vRyAQkFL6oka+Xq+TyWQolUp7Tu7lQRqNBslkklQqtaNFCeL+9ng8RCIRJiYmZH5FJF9rtdqeXutniShLHm4/0Gg02Gw2+VzsdvR6PdPT07hcLtmrY7FYgPvGU9wjQlmi2+0yMzODxWKh2+1uCZWJERji2kWxQ7FYJJ/P76iaxq4zLuJU7nQ6GRsbw+fzkcvlWFxcJBQKEQ6HaTQarK+vy4FD6XR6XyX3BGq1Gr/fj9frZXZ2lh/96Ec4nU4mJydxOByyxl8gjLLQy6pUKo/cpDweD6+//voWUVAxxlitVqPT6WQvxvz8PBsbG3uuj+jB606n03zyySek0+lv1Qi53YjBd8eOHeMf/aN/RDgcxu/3MxgMZCXb5uamImP0GMTMeDETB+43/o6MjDAYDLh9+/YOf8JvxuFw8Cd/8iecOHGCiYkJpqamZKFCo9GQ+5joOXO5XHi9XprNJh9//LHcA/P5PEajkYMHDzI5OUmv16NYLJJOp1leXubevXs7miPddcZF5AqMRiNOpxObzYZKpdoysU/8IqrVqjzB7KeHUZxadDqd1J4Kh8NEo1FcLhfj4+NygJKoABHJvl6vJ0+/xWLxkQZXaFqJskWRm3lwQx4uZdyLJ+nhzyx6dXZymJzQbTMajXg8Huk9CpHBZrNJuVzekW7q3YLwwh9VjCKeC4PBgMFgkNWMGo1Gzs0RCe3dyPBI7WAwKOcKwf37s1gs0m635bMstOY0Gg12ux273S7nW9XrdalcbrfbMRgM1Go1KpUKpVKJarVKvV7f0X1xVxkXcfIW0g5vvPEGLpeLcDiMxWKRrqOQ7kgmk3LQ0H56GIWSrsPh4Kc//Slnz56VMibiwep2uxSLRQqFAu12W96YiUSCfD5PKpViYWHhkTfX2NgYb731Fj6fTxYAPMp4GI1GHA4H5XJ5X1Qv7dTURxFjt1gsvPbaa8zMzHDs2DGOHj2K2WyWM+o3Nze5fv06q6ur++qw9LQYDAbZEPlg173YmI1GIydPniQSifDyyy+j1+vRaDRMT0/jdrv54IMPdm3VmNvtZmpqinA4zOTkJOFwmM3NTW7cuEEymeTSpUsyBN3v94lGoxw9ehS3282pU6dkBMPn88nwmEajYXx8HKPRyJ07d3j77bfl3igM1U6x64yLGD3r8/k4dOiQ9F7EKQW+burL5XI7bp2fBaLD3Ov1cuzYMX74wx/Kme4qlUrW+9dqNTk7JJlMUq/XuX37tpTHuHbt2iNzUUeOHOHgwYN0u128Xu+WB3H4v8XDrNfr90Wj2k4l94eldQ4ePMi5c+eYmJggEolIr1EcFnZKHn03oNPppHEZzv3Bfe9E5B6PHz/OoUOHiEajsuoqEAhgsVgeOa12tyDULyKRCD6fD6fTyeLiInfu3GF5eZlf/epXUrC03+9z8OBBWq0WIyMjzMzM4PV6pcfzKHK5HFeuXCGVSlEqlXZ8X9xVxkUMCgIoFAqyKkLkEQSNRoNYLEY8Ht9XlTYiHu/3+zl//jzhcJjx8XEMBgNarVY2Vi0uLpLP51lZWWFpaUnmV1qtFpubm9LwPnhqEQZrZmaGaDRKOByW/SwPolKpCIfDnDx5Eo/HQ6VSkZufkKLfS4gwo06n2xJifZZYLBbMZjMOh4OpqSncbjdzc3OMjY3hcrlkH0MsFqNcLsvKvFQqte8KVETfhgjFms1m/H6/PEyKPKuYRWK1WmWnudgkRWTjwIEDjI6OypCSmP+yubnJysrKrvRa4H4kIBQKEQgEgPsFM5ubm9y5c4eNjQ2azeaWXpZisShbAEQ0Y3JyUnoqomFSIHqAxFTTnWbXGZdqtUqtViOVShGPx2m327KDWVCpVLh16xZra2v7ao6DkACJRqP87Gc/Y2ZmBofDIT0WuG9YP/roI+7cuSOFF0Ul12Aw2CIZMXz6ValURCIRTp48yezsLIcPH8br9T62E1ytVktl5FgshtFoJJVK8fbbb+9Z4yI0mJ5HtZhKpZKb5fT0NL//+7+Pz+fj8OHDBIPBLb0MX3zxBfF4nPfee49Lly7R6/X2XAHFkxAFIyJ3YLVaCQaDnD17FqfTidvtxm634/P5GBsbk/lWnU5HrVaTAwDb7TZqtZpgMChzsYPBgHQ6zS9+8Qtu3rxJIpHY6ct9LHa7XaowqFQqyuUyS0tLXLp0iXK5TLVa3fLMptNpcrkcer2eq1evYrVa+elPf8o/+Af/AI/Hg8ViwWQyydeLfOtOh8MEu8q4DPOo8cZi8xQjaVut1r4KH5hMJjnnXTyEQg5CjNHN5/Ok02k2NjZkn8TjTinioRaDv0ZGRhgdHSUQCMgBWCJfJSZNajQaOQ9CJKAdDgfBYBBAFgKI0NxewWg0yhBgp9N5oqTGd0GEvjQaDWazGb1eL8cpi5kyHo9HTrWs1WqUSiXS6bRUPxhO6O5FxPMqDKder5fXazabpXcixj2Pjo5is9lwOBxSxVoYkUqlgkajoVgsUq1W5XuLCIYYqiaGvZVKpR0vvf0mRBuB3W6n3+/TbDZlYZLwWoYZPijW63WAJx46LBaLPLgkk0m63a5sNdiJfOOuMy6iCkSM2R2eTSAmqomqn52s/HkWjI6O8tJLLzE5OSlr30VSM5PJcO3aNTY3N/nggw+4ffv2E/shRIza4XBw/vx5RkZGOHv2LKdOnZIPNCBj/Ddu3OB3v/sdTqeTn//85zJ043A45NTEbDbLrVu3SKVSVKtVisXirnC/n4ZIJMI//If/kGQyyW9/+1vi8fi2TtUUitIOh4OTJ0/i8/k4evQohw8fxm63MzIyIoVBAe7evcs777xDMpnkww8/JJ1OUywW95TBHkaEHcX4AL1eLxPSVquVUCiE2WyWOQcRGlOr1VJYMZPJ8OWXX9JqtSgUCrRaLZLJJOl0GqfTyczMDC6XC4vFgsvlkgeucrlMOp3e9eFEl8slG5VzuRzFYpFkMkk2m6Xdbj/2dy+iEN1uV1aQDu8Ngunpaf75P//nbG5uotfrZbuGGBQmDi7beah6ErvKuAwn9EXDpOi9gK8n+7XbbRlb3KunvEchTh5erxej0bilRLher5NKpaQuVjqdfuz7CI9FVN+Mjo4yMTHBxMQEk5OTMgna6XQol8tkMhmWl5e5fPkyXq+Xixcv4nQ6peckkqw6nQ6Px4PNZqPX61GpVHblSN7hkcPixGuxWIhGo/L0LHJSQi32aa9BeNIPetZirR0OB6Ojo4TDYWZnZzl06BB6vV5uBuIhz2azLC4ukkwmWV1dJZfLPbP1eBY8uA6iYEEk44WnODExgd1ul17K2NgY0WhUdtOL3gzRUiAkhjY3N+WY42QyKasnRRMl3C+CEL0h4ms3o9frcblcWK1WeZ1PMydp2CMUz7VWq91y36pUKmw2G5OTkxiNRoLBILVaTUZ5xH0ulKVfOOOi1WqZm5tjamqK06dPMzIyIsMwgMzFiFikKMPdDwwL2A0bVKFCcOfOHd555x3S6TT5fP6R76FWq3G73VitVsbGxjh27Bhut5vTp0/j9/sJhUJyFryoKPn1r3/N9evXZQlzp9Pht7/9Lbdv3+b111/H6XTKjcPhcPCjH/2IsbExlpaWuHHjBqVSibW1NWq12q4xMsVikQ8//JB4PM7hw4eJRqM4HA6OHj3K6OgocF/bK5FIkEgkKJfLrK+vf2MuRiSjrVYr4XAYo9EoVQ1EfsVsNjMzM4Pdbsfv92MwGBgMBpRKJer1Oh9//DFLS0ssLy9z7do12Y+wWxChPeGJPKpKUKPRyHHRbrcbn8+H0WiUfSahUEiGv8LhsDwwajQaMpkMa2trNJtNcrkczWaTtbU1crmcDBOK+0hUgR06dIhQKMTp06ex2+04nU5qtRrXr1+XiuiPmyK6GxEGVYzNflIlpjgYnT17lkgkwvHjxwkGg3Q6HRYWFuj1ejKfZTQasVqt0ksf7nfJZDLMz89TKpW4ffs2qVTqmV/nrjMuBw8e5OLFi0xPTxMKhWTCWcxuyWaz5HI58vn8jnZaPwtEl7yoDBMFDrlcjqWlJT766CM5g+RRqFQq3G43wWCQU6dO8bOf/QyXy0U0GsVqtcqbuNVqEYvFSKVS/O53v+P9998Hvl7jDz74ALvdTjgc5uzZs3JehMPh4JVXXuH06dN89dVX6HQ66dbX6/Vd019QKpX45JNPWFtbw263E4lEcDgcOJ1O2u02Ho9HPmS3bt0imUzK5rPHIdRnLRYLPp+PU6dO4XA4ZAhT9AwN5xlEk2uz2aRUKpHNZvmbv/kbPvjgAxqNxq70/MQBR4S3HtXfpNfrGR0dxeFwMDMzw4EDBzCZTFuGnoVCIXn9wsNotVqsr69z/fp1eSgpl8vMz8+TSCSkByTm8VitVg4fPszLL79MOBzmzJkzmEwmuWHevn2bX/7yl3LW0F5BjMwWzw3wyGdn2Os+ffo0hw4dYm5ujkAgQCqVYnl5WQ6X0+v1cky28J7VarV8z6WlJf7u7/5OKpq8cMZlWIZEbLAPsluFCJ8VImEJ9wX6Op0Oer2efr+P2WyWY3KFUGU0GsXv9zM+Po7L5cJms8lwTD6fJ5/Py/xNJpN5SIyy3+/TaDRQq9Xkcjk2NjZkZ7BWq5X5F5vNhsfjodlsyuT/bvndtFotKVkzPz8vT842mw24nxTVarX4fD4OHDiA3+9Hq9V+owchwrUOh4Pp6WnMZrNUkTaZTDJcK/I4wrsWHnehUGBjY0PmDkXsezesmSAUCslmXafTuaXXRCDK5S0WCyMjI1LNV0gSiVxKpVIhmUzSaDRIJBJUq1WWl5dZXl6mVqtJ2SZAFo74fD4sFgvj4+PY7XZmZ2elXp7o7VpYWCCZTLKwsCAT/nshVyWanS0WCx6PRzZAjo+PU6/XyWazW3JGDoeDQCBAMBiUoVadTkexWCSVSnH37l2KxaJ8/uLxuBzj8OB0zlgsxurqKplM5rl5yrvKuMDXsWuh6PuiIuKpQspFpVIRDAaxWq0MBgNUKhXRaJTx8XHMZrPM0wQCAfmQTkxMoNVq6Xa7NBoNrl27xqeffrpFFfnBUu5ut0s+n6dSqXD37l2+/PJLIpEILpdLVv2Iev3Z2dktN/JuOYGXy2W++OIL9Ho9iUSCDz74gEAgwMzMDDabjYmJCRwOB3Nzc5w/f16u8zd9fnGKF2FCkSMUCraZTEZWLjUaDb766iuuXbtGsVhkZWVFyrsMG5bdhEql4vTp0/zrf/2vcTqdjI6OPlYIUqvVytCZOAiKXhZR0RWPx3nnnXdIpVJ88sknsmtcxPzFfazX6wmHw8zNzfGDH/wAr9cr+6uEQrDIO5ZKJX75y1/y+eefs7m5ydra2o4MwvouVCoVlpeX8fv9HDx4cEux0sbGBh999BHFYlHue+Pj47z55puEQiFeeeUVRkdHyWQyLC0tMT8/z1/+5V/KNe12uzgcDuk9+v3+Lb+7fD7PwsIC9Xr9ueX3dp1xGS5lfJEQCc5ms0m73ZYbj9BaM5vN+Hw+2e+jVqsJh8OMjIzI7wnNKqvVKk/pQlOr2WySTCblNMlUKkWlUnlkdY14UMUIaZvNRrPZRKvVyu8NF1bsttO3KK1utVpkMhk0Gg3tdlt2cNvtdgaDgUw+q1QqaSxE/PpJg9aGCwFEtaIwLq1WS5bEbmxsEIvFKBaLe0b802azyYmGkUgEo9G4xRB8G4YLK9rttvToRF5HrLXVapVJ6JGREdxuN16vF4fDQb1ep16vS6FK4f0lEgmKxeKe0r0TnotoGrXZbHi9XsLhMP1+X3ozYp2FpqDo6zGZTHQ6HXK5nEwPZLNZOZepXq/TbDYxGo20Wq0tPWyiCfrBIWvPkl1nXF5kkskkV65coV6v89prr+HxeAgEAtjtdgKBAAcOHJCbu4jFCpkMkTAVlST5fJ6vvvqKUqnElStX5IlncXFRxvufVDUyGAxIJpPcvHmTUqmEzWbDbDbLTfvatWt8+OGH5PN5ksnkjszo/ib6/T6pVIpyuUwsFmNhYQG9Xo/b7ZY5JIfDIR9mrVbL5OSk7BV4MDQreqvK5bL0RATlcplcLifLY7vdriwD3UvCqjabjZGREXlfCQPa7XZl+PVpiUQi/PSnP6VWq3HmzBnK5TLwdVWo1WqV7ylk871eL71eTypP3Llzh4WFhS1SR0tLS7J8d7fdc08inU7z0UcfEYlEiEajuN1upqencTqdFAoFTp48Sb1el/ddOBzm4MGDGI1GzGYz1WqV69evS/2wXC63pddPHGw0Gg2lUmlLWKzT6ciim+d1L+4q4/KieSsPUq1WicViOJ1OOp0OKpUKq9WK1WrF5/MxPT390Bo97uHKZrOsr6/LkEQsFiOTyTz1ICVRTJBMJtFoNMTjcUwmkzz93Lx5ky+//FL2iuyWkNgw4hqGJYKEl6LVarFYLFsKHbRaLWfPnmVqampL6Eu8V6PRkOOJL1++vEXOXDRFilLP3bgeT4PojTIajTIMKJLywGNzoY/C6XTidDrlMLpWq7WldPtB+RLxc4rFIvfu3SOVSvHVV1/x5ZdfUi6X2dzc3NV9LN9EtVqVoqQiTyT0wmq1GsFgkHa7/ZCxhfv3V6vVIpFIcP36dYrF4kO6iuIQAPc9lZ1mVxgXh8Mh550fOXKEsbExOUdc1LV3Oh0WFxf57LPP5Klmv9FoNMhmsywvL/PrX/+akZERDh48yOjoqAwttNttGbcHHkrGJ5NJGYa5ffu2rMoRvQTfhkKhIP9tvV5Hp9PJwWzDY5L30ulRhGpEDF/0wsD9cM3du3fJ5/PScxlGhAHL5bI8OQvEWuzGXMq3YXFxkb/5m7+RjYpqtZpYLEY6ncblcjE6OirzTMOIfipRSv/giG3RAyMQXlGn0yGdTsuRvuvr63JMr9DPEyf0vWqwBfV6nUQiQaPR4Le//S3Ly8tMTk7KKZqif0xIuKRSKVm2vbGxQblc5quvvpJFErs9z7QrjIvX6+WnP/2p7FCfnp6WcVlRIVKv17l+/Tp/+7d/S7FY3NEhOM+KSqUiQ1b1eh23282/+lf/CqfTuWXWx+LiotT3Gt7I2u02X3zxBQsLC5TLZSkB8V2kToRmUzabRaVS8eWXX275ec/Tvd5uxOm33W4/JHwqrvdxlYriz0et5142KnD/81+7do1KpSLLrHU6HR9//DE3b95kcnKSCxcuYDKZZEJfEAwGeeONN6QO4IOFACJ3A2zxBlutFktLS6ytrTE/P8/7778v712xge7GqrrvglAWMRqNVCoVXC4XP/nJTzCbzdhsNlmRubm5KaMYN27coFAocPXqVTKZjOzz2wuHmF1hXITaqZB3f/DGFYZGTF7cLxLwDyJO1SLx1+/3WVlZ4ebNm7RaLalBJGaIP0i325UyIo/TK/oun0e8937jUQ/nfrzOb4OYcNhut6X+XC6Xo1arkc/nSSQSMiE9/Ay2221u376N0+mUfRdPQ7vd5t69eyQSCeLxOPl8Xnbd7+Q46meBMJDC++31esTjce7cuYPZbCabzcpG01KpxObmpiwIyWQyMvqw2z0WgWrwlObvWW7mBw4c4N/8m3/D2NgYJ0+eZGJiYsvpRsyL/s1vfsPbb79NLBbjww8/lAnC5813OTF8m/UThlSj0ciqGXGCE4J34gZ7cBZLrVaT39+t8elnvX77ne96Yn2aNdTpdPLeMxqNUrm50WhI/TRRzTn8fjqdDrvdvqUs+WmvReQT6vU6lUrluUiU7OQ9KMqvNRqNzEuJCZsqlUrqjIk1EdEbkVPZDQegp1m/XeG5DJcsDrt7w7pFcL/Rym63P1K0bT/R6/VkfmQ/zatR2P10Oh15KHnw8LadQp8vMsP6aPV6nY2NjR3+RM+GXWFcstksv/71r/H5fHJmu9PpJBQKAfcrJUQiu1ar0Wg09nxyT0FBQWE/syuMS6FQ4KOPPsJisWxp4BJDdUQJqEjs76XGKQUFBYUXkV1hXIa7npeXlzGbzSwvL7O2tgbcDw21Wi3m5+dZX18nl8vtirijgoKCgsKj2RUJ/eGfYTabZU286AYWeRhR/y0qqnbKe1ES0t8PZf2+H88yof+ioNyD34+nWb9dZVz2CsqN+f1Q1u/7oRiX749yD34/nmb99m/JlYKCgoLCjqEYFwUFBQWFbUcxLgoKCgoK245iXBQUFBQUth3FuCgoKCgobDtPXS2moKCgoKDwtCiei4KCgoLCtqMYFwUFBQWFbUcxLgoKCgoK245iXBQUFBQUth3FuCgoKCgobDuKcVFQUFBQ2HYU46KgoKCgsO0oxkVBQUFBYdtRjIuCgoKCwrajGBcFBQUFhW1HMS4KCgoKCtuOYlwUFBQUFLYd7dO+UBnx+TXKiNTvh7J+3w9lzPH3R7kHvx/KmGMFBQUFhR1BMS4KCgoKCtuOYlwUFBQUFLadp865KCi86JhMJkwmE06nk5mZGQwGA5VKhXa7TSqVYmVlhV6vt9MfU0FhV6AYFwWFp8TlchEKhTh27Bj/9t/+WzweDysrK2SzWd59913+/M//nEajsdMfU0FhV6AYFwWFJ6BSqTAajeh0OlwuFz6fD7/fTzAYxOPxUKlU6PV6WCwWpZpIQWEIxbgoKDwBs9nMyZMn8fl8TE9PMzU1xcjICDabDbVajUqlYjAYfOfyYAWF/YpiXBQUnoBOpyMcDhONRpmZmWF2dhan04ler1c8FYVdxZPux504/CjGRUHhCWi1WjweD+FwmJGREUZGRjCbzWi1Wvr9PrVajWKxSL1eV7wXhW1Hrf66oFelUuHz+fB6vWi1Wsxm85bvGwwGzGYzGo0GvV6PWq2mXq9Tr9cpFAosLi7SbDbpdDr0+/1n/tkV46Kg8AR0Oh2BQIBoNEo0GmVsbEyGw1qtFrVajXw+T61WU4yLwraiUqnkvSb+OxKJMDc3h8lkwuPxoNV+vYU7HA58Ph8GgwGbzYZWqyWdTpPNZllcXCSXy1EsFhkMBrTb7Wf++RXjss8RCWmNRiO/DAYDdrsdrVaL0WjccoO2Wi02Njao1+u0Wi06nc4Ofvrnj1arRaPRYDabcTgcBINBfD4fLpdLnhQbjQbZbJZqtcry8rKsGHsep0GF/Y8wJg6Hg0AggFarxWq1otfrmZqaYnJyEqPRiMPh2PLsWq1W3G43Wq0Wi8WCRqNBpVJhMBjodDocOnSIQqFAMpmkXC7TarWeqcetGjzlOyvx5a/ZS7pEer2e0dFRrFar/AoGg5w7dw6Xy8XIyAgul0teUyKR4D/+x//IvXv3SCaTpNPpbf9Mu3X9VCoVLpcLi8XC7OwsFy5cwO/3c/HiRUKhEBaLBYvFwvLyMn/5l3/J5uYmn3/+OcvLy9Trdcrl8nPxXhRtse/PbrwHhVHR6XRoNBpOnTrFH/7hH+J2u2Wuz2QyYTAYUKvV0ngINBqNNDbi73u9Hr1ej2KxyOLiIoVCgQ8//JDl5WVisRj37t2j2+1+68/6NOu3KzwXsVBqtXqLG/g0v0xRqTMYDOj3+wwGA3q93pa/fxER66fX63E4HPLLbrcTDoeZmprC4/EwPj6Ox+MB7q+lMD7ZbJZyuYxGo5Fru99RqVRoNBp0Oh12u53R0VHptVitVnQ6HYPBgEajQTweJxaLEY/H2dzc3OmPvisRzzXw0PP8YMjnQcRzK743/FwL+v2+fOb3+v0p1kOtVmM2mzEajfh8PsbHx/H7/Rw+fBiXy/VU79Xv92m1WvT7fdRqNQaDgcFgQCQSwWq1Eg6HqVarFIvFLRWP282OGhdhad1uN0eOHMFut8uTtMlkwm63b0lYPUi/3yeXy1GtVimXyxSLRarVKgsLC5RKJSqVCtVq9Tle0e7BYrHg8Xjw+Xy89dZbjI2NSeNisVgYGRmRCUBxY/X7fRwOBz/5yU84duwY77//Pp988gn1ep1sNvudTjh7CRGLrtfr0uPzeDwyJCG+l0qluH37Nuvr6xSLxZ3+2LsSlUqF3+9namoKo9GI3W5Hr9fL75vNZsLhMEajEZvNhtFopN/vy5N2vV6X/UNms5lCocC9e/doNpvy0JhOp4nFYjSbTTKZDK1Wawev+Puh0+lwu91YrVZ++tOfcvLkSUKhEDMzMxiNRsxm85bXDxtbrVa7pSS+WCxy6dIlMpnMlkOm1WpFrVZz7Ngxjh49yttvv83CwgL1ep12u73tBnrHjYtoTjt+/DjBYJAjR44wOjqK3W4nGAzKkw887JZ2u11WV1fJZrNkMhlisRjZbJZ6vY5Go6HT6bywxkWcfEZHRzl//jyHDx/Gbrdjt9uBrSfD4VOL2WzmzJkz1Ot1crkcS0tLFItF8vn8jlzH86bb7dJut9Fqtfh8Pjwej8xLNRoNWR22vr7O2traC5eTehrEhuZ0Ojl48CA2m41gMLhlg3S5XMzNzWGz2fD7/djtdrrdLp1Oh06nQ6FQoNPp4PF4cLlcxGIx3n//fdm0OhgMWFhYoNPpyIPlXjcuIiH/4x//mD/4gz944uuHjcuwh9jv96lWq1y5coWlpSX5u3C5XBw4cACHw8GRI0cIhUKsra1hMpnkmm83O2pcRIlnNBrl0KFDsvPZbrdjNpsfMiaDweAh19pqtTIYDNDpdBgMBnw+H51Oh2w2y9WrV2m323Q6HXni2U+YTKYtpYcajQafzydv0omJCbxer3ywh084wwz/nVqtxmg0AvcNjcViodFo7Ot4vUqlQqvVotPpmJmZIRQKcfDgQRwOB0ajkVarRavVYnFxkYWFBW7dukW1Wn0oTKNw//4RJ/DZ2VlOnDiBzWbD6XRiMBjk66xWKy6XS6ofwNdhycFggNlsptfrye+ZTCbGxsZoNBryhG6z2XC73ZRKJUZGRigUCmxsbJBOp+n1envG8KtUKiwWCzMzMwSDQZxO50OvEdecy+XI5/M0Gg2ZD52cnMTn88lntFarUSgUyGQy0nBkMhkqlQomk4l4PI7T6eTy5cvU63W63e7+CoupVCrGxsb4wQ9+wNjYGD/60Y/weDzodLqnisWK9/B6vbjdbhl/7XQ6nDp1imq1yl/8xV+Qz+epVquk0+l9F9ZxOp2Ew2EMBoOsZrpw4QKzs7PSuOh0OlktJkKMDxro4T+1Wi02mw2TyYTL5cLpdNJsNp8YntzrqNVqTCYTVquVV199lQsXLhCNRgmHwwAkk0kqlQpvv/02v/rVr8jn8+RyuT2zeT1PNBoNY2NjjI+Pc+HCBf7oj/5ISuM82LMhDjtqtVoeHEW1ngihiYOP0+nkzJkzW57/Xq9Ht9ulVCpx5coVMpkMv/71r/noo49otVr0er1dn4sR1+92u3nllVeIRqOMjIw89DoRMlxaWuLKlSuk02muXbsGwM9//nNOnz4tD0i5XI5YLMbKygrFYpFisSgNt1hjtVpNs9ncYqy3mx1P6Au3zmAwYDKZHumtPAmRBBPodDp5SgoEAvJE02g05Al0vyjXilp3s9mM3+/HYrEQCoUIBAJ4PB6cTqd0lx/0+p7EcGHFkwz9fkGtVksj7HK58Pv9ssxTnICbzSaVSoVsNkutVts399B2M+wFGo1GmTMRz12z2aTZbMrXqtVq9Hr9lpLab3p/UU0l/hTNhQA2mw2dTrdnDpJqtVq2BLjdbhmGHabX68nS4VQqRTweJ5vNkkwmAUilUqTTaenJaTQaLBYLDoeDSqUimyaft5e9Y8ZlMBiQTCa5fPky7XabUqmE1WrFYDBsybN8W9RqNVarFZPJxI9+9CMmJydZWVnhnXfekc1E2Wx2G69kZxCe3+uvv47X6+Xw4cMy/GCxWGSHLrDl9PYoLaxH/d2LFO7R6/Wy83lqaoq5uTl5H4p7M5PJyK/9dEDZToR33O12aTabslGv0WiwuLhIPp/nxo0b3LhxQxoVvV7P5OQkgUDgqX6GTqdjfHwct9uN2WyW/Vqjo6M4nU4CgYAMlZfL5Wd5uduCKGgIhUIcPXqUiYkJbDYb8HVepVwu8+GHHxKPx/n888/5/PPPaTablMtltFot77zzDktLS5w9e5Z/+A//IZFIhDfffJO5uTnee+89qtUqnU5HeinPix31XGq1muwgbTabdLtd6bI9LQ+eqMXJRqfTEY1GZd/CnTt30Gg0JBKJ7b6MHUGtVuN0OhkbGyMQCMjk6IM3z4MGY7hsGx4uERV/9+C/2c+IJjVx8hOl2XDfMDcaDSmjIWLUuz3c8jwR99Bwn8XwSbnf75PP50kmk9y+fZtPPvlE5vaMRiOdTod6vf5UP8tgMGC1WmVIbTg/qFKpMJlMaLVa+f3djlarldfk9XqlBwbI57TRaBCLxVhaWuLevXvcu3dPrq1Wq2VtbY1ms8n4+Li8l8fHx7Fardy6dUuu0fPOO++ocanX62QyGdbW1vjwww9ZXFwkFArhdDpptVoyafpgp7goq9Pr9TIBptVqt5Q6AjKBGIlE+MEPfiANmahE2YvVJTqdjlAohM1m4+DBgxw8eBC73Y7BYNjSE/Cg0ej3+6yurrK6ukqpVGJ5eZlWq4XJZJKnwSNHjshcy+P6E/YTOp1O3kPnz58nHA4TCoUAqFarZLNZstksH3zwAWtraywuLu6JOP7zQqVSEQwGCYfD2O12ZmdnsVqtRCIR3G43k5OT6HQ6arUaqVSK9fV1Njc3yeVyANIIdLtdFhcXn+pnajQarl27Ju95UUovKs2++OILstms7PPY7YiQ2KOEUGu1Gtlslo2NDa5cucLdu3fZ2Nh4qNdHHM5XVlZYXl6WA+3sdjvnzp1DpVKRSCT49NNPqdVqz21ddtxzqdVqqNVq3nvvPbxeLwcPHiQSiVAqlUilUjIsMWwIzGazdH9Pnz6NXq+XVSfDvyCDwYDBYJDGKJvNcvnyZZaXl6nVarTb7T13KhceWTgc5siRIxw+fFgWQQzzqKT90tISv/vd71hbW+O3v/0tlUpFhtFeffVVrFar7Ov4PqHJvYK4L0KhkCwsEUn8crnM8vIy8Xicd999lzt37lCtVvdMLP95oFKpGBkZ4cyZM0SjUX7yk5/g9XpxOBzSk1Cr1ZRKJTY3N1lZWWFjY4NMJkO/35f3ZSwW+1YHmEfd2/D1SX8vGBWBVqvFZDJtCWMLarUasViM1dVVrly5wvXr1x/ar/r9Pul0mkwmw/LyMgsLC/h8Pubm5rDb7fT7fQKBAFevXmV+fv6ZJvAfurZn/hOeApGoarVaaLVayuUy1WpVehjlcnlLjNtgMFCtVjGbzZhMJsrlsixr1ul00jUWyWiNRiPLdj0eD4FAQGpD7TXjIvovRkZGnthk2m63abVadLtdWdCwtLTE+vo6yWRySxhSJF5Frmq/eioPIhL4LpcLh8Mhk8Hw9YOdSCQol8tyvRTuew8i5zE+Pi5LaB0OByaTiVarJRP35XKZbDZLPB4nnU5veeYe/PNFQ61W43A4GB0dJRgMypCiCLvmcjkWFhaIx+NUq9UnGs3BYEA+n+f27dtks1l5UBwMBrJfy2KxUKvVaDQaz6XScVcYl3K5zNWrV9FoNHz22WfodDrZqfso2QdRYaHVavn4449lh/8Pf/hDnE4nExMT0m3W6XRotVrsdjsqlYqjR48yGAy4fv06yWRyT51y4H6F2KlTpzh16hSTk5PA1ye24cR8pVIhkUhQKBS4dOkSm5ub3Lhxg/n5edlpLvpiIpEIExMTTExMyGKAvbYu3xZRYXTkyBFmZmYYHx8nFArJUGoikeDtt9+WXeCVSmXfr8nTYjabeemll4hGo/zgBz/ghz/8IUajEavVSr/f586dOyQSCdbW1rh27RrFYpE7d+5QLBafm/7abkeIyM7OzvLWW28xMjIiCxHq9TqNRoPr16/zn//zfyabzZJKpb7xPW/dukUikcDv95NIJIhGo5w4cYLjx4/TarVkTmZjY+PFMS69Xu87ddKLMsRyuYzD4SCVStHpdAgEAlLcTYTKROmixWLBbrfv2RO6RqPB6XTi9XofajQdDAYyP1UqlWTOYFgDK5/PMxgM5Ho4HA48Ho88dYrczfBGut82AxGuEUlUUc5tMBikLlOlUiGTych4tlId9vW6iWblcDhMMBgkGAyiUqlk2XapVCKdTrOxscHKygqVSkXKNO3FPOd2M1x05HQ6CQaDuFwutFqtfIaFEsTm5iaFQuGp1k0UnHQ6HVKpFCaTiW63u6VYpVqtyt6/Zx0e2xXG5bvS7/floKZOp8Pm5iaBQIC33nqL0dFRJicnGRsbk68f/sXt1Ztcq9USCASYmJiQBlJ8tdttLl26xO3bt0kkEty+fZtarcbGxgbVapVSqcRgMMBkMklBxp/+9KecO3eOUCgkk4qPEhncL6jVaqlldebMGf74j/9YNov2+31u3rxJLBbjs88+Y3l5WfYXKCBLZoPBIK+++ipzc3OEQiFUKhXVapWVlRUKhQLvvPMO169fJ5fLsb6+Lp+5TqejGGnuh2MPHz6M3+/nzJkzHD16FIvFgsFgkI2SS0tL3L59WxqCbxOSFXshQD6fp9vtEgwG+aM/+iNSqRR//dd/zfz8PLVajUql8swMzJ42LsKFrNfrFItFlpaWCIVCTE1NMRgMtpSUiteLKrFOp7MnT+SiBFmULA5rhPV6Pe7evcv777/P6uoq165de6T7K0TyAoEAJ0+e5LXXXnuel7CjCNVZi8XC1NQU58+flwURrVaLWCzG1atXuXfvHqlUikajoYTD/hcmk4lgMMjo6CiHDx/m5MmT8iDSbDaJxWKk02muX7/Ol19++VzHEOwlRFHO+Pg4U1NTjI2NyQIakX8WuZZKpSKbTp8WkWfVaDSy4dflcvHyyy+Ty+W4fv06sVhMhs+fFXvauDwKMXq2UqnIajBx8lar1VgsFlkhtddP5A+6tcMS5E/CYrEwPT1NKBTC4XBseT/YX57KoxA5O6FEIHoJarUaiUSChYUFUqnU99ZcEu8/3Fe0lzdaERYTzZLDHq7Q80ulUlQqFVlMovAw4oAjPGixhkK+SjTtikjDt6Xb7cpm32QySSaTkYU7drudaDTKwYMHWVlZIZPJPDNvct8Zl16vJ/MNjUZjy/eEOmg4HJaKoXuR4WbI73LzORwOXnrpJUZHR/H7/Vvec/hnPOq/9zpCnkR8aTQaedIrFArcunWLzz//XMpmfNehUsNxdZGLGJ45tBd50CgPPz+NRoP19XWpTC5OzHv1Wp8lIm/q8/mwWq0Aslen3W6TTqe/18bfarVYW1tDr9ezuLjI6uqq7DsymUwcP35c5mtv376tGJdvYlijx2az4XA4tqiwCtrt9nMrxXsW9Ho98vk8m5ubcjLisGfmdDoJhUJ0u12pnloqlbbMzDYYDPLfPqjpJDbAbrcrG9P20yah0Wiw2Wx4PB5MJhNw/6QnvN1qtSpzck9zzaK/SnSnDwsEivLudrstN1tR0izKdffSuoqGZlFm3Gw2pZEWxSG1Wg2Px0M+n6der3/n0/d+Rhw8hqWuxL3RaDTkfKrvc3+IA02tViOfz8sGc3H/u91uuUcKw7bdv6d9Y1zEcKyxsTFee+01Dh8+vEWGGu5vIisrK1y+fJn19fU9GUuvVCr83d/9HXfv3pVloOIUaTAYeO211zhx4gSpVIqlpSWZwFtbW5Pv4Xa7cbvduFyuLeqz8PU8iEajIRVVv6nGfq8gwqIvv/wys7OzHDhwALjf03L37l02NzeJx+MUCoWnMqharZapqSmpEiF6FcT8l5mZGSYmJuSI2Wq1SiwWo1AosLKyws2bN+l2u3smyS2S9q1Wi4WFBSwWC36/n0AggNfr5Q/+4A+oVqtMTk5y584dbt++zfvvv68URPwvRFhRp9NhtVpxOp0yLNZsNllbWyOXy3Hnzh1u3br1vQd4CVWOS5cuceDAAQ4cOCClYZxOJ8lkkpGREVkZOXwA3Q72tHEZrmwyGo04HA7cbjeRSIRoNCob4uBrETjR+b8XGyjhvue1urpKu91mZmbmof6fkZERwuEwgUAAh8NBPB7nk08+IZPJAPfXTIxRNRgMWzwXUYLcbDZlrX2z2dyzxQ/DDE/kCwaDjI+P43K5UKlUdDodisUihUJB5gue5r3EoLtQKITP52NsbAy9Xi87ro8dO8bhw4fJZDKYzWZKpRJ6vZ50Ok2lUpFjk4dzMruZTqdDpVKRa5XP52Vvi2iobLfbZDIZut0uxWIRnU4nVXkVtipBi0MI3D/4lstlGZ7drgmn5XKZzc1NfD4f3W5XVktqtVpcLpcc0vYsFDn2lHEZ3iCE1Z+ZmcHv9+P1ehkdHcXr9RIKhWSoApBTFbPZLKurq6yvr1MqlfbkDd/r9chms/T7feLxOPF4HIvFgsvl2rJZicoeg8HAj3/8Yw4ePCjfIxqNMjk5idvtlqJ2wniUy2Xee+89YrEYn3/+OfF4nEajsWdO149Dr9fLqYfT09McOnQIr9crczB2u51qtfqQ3LlIvoqQl0qlwm63MzMzg8Ph4Ny5c0xOTmI2m3E4HFuk4EVFn8ViYWJigkajgd/vp1aryabNXC7HlStXKBQKtNvtXZ0EF6GbXC7HO++8w+3bt7lw4YKchyPk3icmJqTCeblcJp/PMz8/L6eZ7vWDyndFo9HIkHQ0GmV2dhan00mv16NQKHDlyhWpZLAdiK79xcVF3G63HBYmRhyMjIxw7NgxksmkVPHYTvakcREbp9Pp5PXXX+fIkSP4/X7Gx8fR6/UP5RJEmWQqlWJtbY21tbU9m1jtdrvkcjkajQaJRIJ4PI7b7ZanEXFNQu7G6XTyox/9SMqPi81xcnISo9G4RT5GyJS/9957XL9+nXg8TiKR2JPr9CAGgwG3243P52NqaopDhw5tGZBmt9up1+tbvF34OpQ2PHBtdHSU119/nUAgwMWLF5menn7kzxTvL071gsFgwPT0NGNjY6ytrZFMJmVl4243Lr1ej3a7zbvvvitDqhMTE7jdbux2O0ajkbGxMcbGxrBYLHS7XWKxGJubmxSLxT15oNsuhMdiNpuJRqPMzMzINRXGZXV1VUYZvi/CuLRaLUKhEOVyGbvdLg1/JBLh2LFjOBwOrl27JgVFt4tda1xEYlR0BIsKC6fTicvlYnJyErvdzvj4OD6fT3oywxMXq9Uq9XqdZDLJ3bt3SafT0mPZqxvmYDCg3W6jUqmIxWJcvnyZUCiE3W6XCTqhSiBCN3a7fYvbK4zvcD6qUCiwubnJ+vo6qVSKYrH43Oc/PEvEgz08YEogSkCHk5rDmnSRSASn04nNZsNqtcomVjHOQa1Wy/4pMTFQhGH7/b6crChCIiLu7vf7aTabhEIhmbzd7tPjs2DYCG5sbHDt2jXC4bB8PsXJ2GazMTo6KnNTarWabDZLLpfbN/fVd0U8n/1+XxYZiVDjduaoRBGGyO0N5xKFaKbYN4V81Haxa42LEKDU6/UEAgEsFgunTp3i9OnTeDweDh8+jNlsxmw2y5t5OHQxGAxIJBIsLS2xsLDA3/zN38jxn3v59NTv96lUKtRqNd59910+++wz5ubmMJvNUtXX7XbLzVOn0xEOhx+a3zK8VgB3797ll7/8JclkkitXrsg+j/2CSKIKD2+YXq+3pTcKvpZC9/l8vPbaa0xNTTE9Pc309DQ6nQ6z2YxGo8FoNDIYDKhWq1J+SFQjipyVUEQQFULivY8cOYLH42FpaYlAIMDnn3++JwbZiWbkbrfLp59+yuLiInNzc7jdbqLRKF6vF5vNJqMLIhy2vr7ORx99xKVLl+RG96LTarWkuOfCwgJLS0vbWskqhrZVq1Xa7faW/KmYZCtygaLna7sMzK4zLuJkaTKZcDgc8gG32WyEw2Gi0ahUQDabzY98D2GlhcZROp0mlUrJ0ty9jmiWLJVKlEol3G43mUxGVqAItWRxGtHr9Q+NORY3kDjJVCoVNjY2SCaT+1oDSngUvV5vSyOgWC8xHdFkMsn1DAQChEIhRkZGiEQiW7TXRLm2aHwToqCivLnRaGA2m+n3+zIkotPp8Hg8W6YpihP/XmFYILXdbuPxeCgUCjgcDqxWqzS+YoBdKBSi1+vhdDpl6HEvRxC+CyLnMhyOFvfj8GFkOxGe8vDYcoE4ZD7oyW8Xu8a4iFDBgQMH5EN86NAhLBYLgUAAs9ksR9GKSqdH0Wq1WF9fl6NBP/74YzKZDMlkck/3tzyJVCrFL37xCwKBAD/96U85efIkNpsNn8+HRqPZ0iA5rJzc7/fJZDKyxHRlZYVisbjtN/huQHTfw33F4+FQosVi4dChQwSDQRYXF2m32wQCAQ4cOIDH4+HixYtSMblcLsuqKdEBXSwWuXfvHp999pkcgSy+xFgDMQbC5XJhNps5f/48b731Fp1OB4fDgc/nw2Kx7PAqfXtEJVgikeC3v/0toVCIc+fOMTMzg9VqxeVyYTKZOHbsGOPj4ySTSRYWFqhUKmxubu7L5/FxeDweTp48KcOszxqVSkUgEJBFLCI3O2zchTfzLLzIXWNcRIw7HA5z8OBBDhw4wMWLF+Um+WAVz+PodDpSzfbu3btcuXJFNnPtVze8VCpx+fJlHA4HU1NTjIyMAOD1ep/Yed/r9WSNu1izSqWyr8Jhgna7TT6fx2QyyVJPvV4vRzOI6Z5iA5yamuLs2bO4XC5mZ2dxuVxUKhUqlQqNRoNsNku9XpdSMZcvX+Y3v/nNEz0+jUaD3+/HZrPhdDp57bXX6Ha70nvZS56LYNiLvnXrFul0mnA4LCvxhKcSiUTo9XqMjo7K/rN0Ov1CGRer1crExAQjIyOygfdZY7fbGRkZwe/3yxYEkX8VzdJiX9xXTZSiosnlcnHkyBGcTidzc3NyeM5wkn4YEXLodDrkcjk50bJYLFKpVLh37x6FQoG7d+/KWON+dr+FNpZWq5X9KQ/qqj3ouYh/F4/HWVpaemh86n5DeGrtdptcLkcymcRkMuH3+2Wy32KxMDc3J3Mk0Wh0S07l9u3b3Lp1S47tbTabpFIpSqUS6+vr33h4EbmKZrNJq9Wi3W6jVqvx+/0YDAZcLhdGo1GqI+wlWq0Wm5ub1Go1rl+/LvuwRKRBhGUmJyd54403WFpa2lIlt5/vPRGWErniUCgkZV+eBaLvT6/XMzExwZkzZ5iensZkMm0Ji2WzWa5du0YikaBWq23772FHjYvdbicUCnHw4EH+z//z/5TuotVq3ZIzeDAeKJRDq9Uq8/PzxONxNjY2uHfvHtVqlbW1tS0JLNjftfXdblcOsyoWi5RKpS2ClGL9hv9UqVR0u13u3r3LpUuX2NjY2HMb2rdBVDg1m002NjZkSGxychK1Wi1DrRcvXuTcuXNymJPw7gqFAh9//DG//OUvKZVKbGxsyOowETf/pvUbDAayKqxer9NsNrFYLIyNjdHpdAgGg5jNZhla20v3rJh0qtPpaDab3L17l9dee43jx49LeRi1Ws2JEyeYmJjg008/5eOPP/5eGm57BVFsFA6HuXjxIn6/f8vzud2IXJfZbObEiRO89dZbW/ZVQSwW49133yWXy1EsFveH5yI2N4fDwcjICKFQCLfbLRfgcfkUEceu1WpSNXRjY4NEIkEymZSCeSJ0sd9PRMMMd3k/mCh91BoMBgPZrStKYsUMiMeNTt7LiHtBdI5nMhlqtdqW14jih+HwVL/fp1wuUyqVyOVy5PN5qUH2bUM6okdLjOcWFXtCp2sve9jCwML9FoBcLie/RCJfr9djMBhkSbfD4ZDRhv1aQCIQyXMRmnoWz5ho0DQajYTDYRwOhxw/bTabpUK3kPHP5XJyr9wXORfRe6HVajlx4gQ/+9nP8Pv9RCIRrFbrE2UIarWaDEH8/d//Pel0mhs3bhCPx2m1WnL2hjhRvogMG9RHKScPJ/T1ej2vv/46Z8+e5dNPP5VhxlKptO+S+mLzq9VqUlsuFArxyiuvPPFBr9frXL58mbW1Na5evUo8HpdluN8WnU4nY+4iwdpsNpmfnyedTrO2tiYf9L1qZHq9Hslkknw+j81mY2xsjGAwyMWLFwkEArJtIBgMcuzYMZxOJ7du3ZIHm/3IcM+ZaJ94FsYlEolw8uRJfD4fFy5cIBgMEo1GCYfDsiqs2Wzy6aefsrS0xCeffMLm5qYUU91udsRzERIZHo+HqakpnE6nLNF8kGGZ8kajQaVSIZ/PE4vFSCaTxGIxWQX0ovOoKZIPMrxpiQIKuN8M53a76XQ6sglzr25wj0PkPPL5PO12WxZ5iJj4oxDd05lMRp6w+/3+ln6qx/HgNE8x1jYQCOB0OjEYDLRarS2elGi83MsITyyfz8tnUxxWxFobjUY8Hg/1ev2xkYr9hCgDFpv8drzfg18Oh4PR0VFCoRBzc3OMjIxIYwZfV4clk0mWl5dlBe33Fch8HM/duOh0OkZGRnA6nYyPjxMOh2WIYBjRL1Cv12WCfn19nbW1NbLZLDdu3JDS1C86Go0Gs9ksQw0Oh2PLCORhHvf/k5OT/JN/8k+Ix+PUajVWVlYolUr7bn3FMLlut8vCwgIff/wxHo+HmZmZR/ZNGY1GDh06hMfjkR3n9XqdVCpFu92WSgYCEf4QmmRCl0z0zbz22mtMT0/LYoFGo7Glz0BUX+0HcrkcV69eJZ/P89JLL+H1eqVKgs1mY3Z2FqvVyt27d3f6o+4ZRGhR5AstFgujo6NyTpVY01AohNlslqM3hDJ3Pp/nvffe486dO7Ja71kdInfEuITDYUKhkBxW9aBhgfvGpVwuk8vl+PTTT1lfX+fmzZvcvXtXzuTer6XF3xaNRoPFYsFut2Oz2bDZbFsqQ8QJ+8GT9DDRaJTR0VFWV1e5cuWKTCrvV+PSbDZZWVnh888/l9f+KONiMBiYmZkhEong9/uZmpoin89z69YtKaEvOtABeSrXarV4vV5ZAeZ0OnE4HLz22mvMzs7KQWKicGB4rsd+oVAocPPmTZmDqdfrW8JDU1NTWCyWZ5rc3m+IqsZgMMi5c+fw+XycOXOG8fFxKZ4qPCRAGpbV1VU++OADkskkly5dYnl5+ZkfZJ67cVGr1djtdtmd/GDXeKlUknpg9+7dI5/Pc+/ePdLpNIVCQcYH98vpbjvQarWym1x06Is6ejF+ttlsyrUWIYlhfTHxp5CkF93/GxsbO3NRz5DhBtKFhQX532LA13BCX8zJUalUuN1u+v0+NpsNuB/qCQQC0gCLIgmhhedwOLDZbFKR2WQyYTKZZFFBuVyWn0EIO+4ner2eHH6VSqXY2NiQFXF6vR632y3nu9vtdtrt9r7L9T2K4fYAISEkPBGVSkUmk6FcLsuKWa1Wi8PhQK/X4/f78fl8hMNhZmZmcLvdeL1eLBaLvO86nY4MeYlK2s3NTZaWlrbMZ3rWYe8d8VwikQgHDx7E4/E8NMxreXmZ1dVVLl++zF/91V9tqcwRXy9SFdjTYDQaGR0dlYKKk5OTUsCzWq3y5Zdfsrm5KddalETa7XZga5LfbDZz5swZwuEw5XKZu3fv7ru1FlWH9+7dIx6Pc/jwYWZnZxkbG5NCqAKNRoPdbmcwGOBwOBgfH5dCl2LzHA4tDE+iFCEgkWcQpcjlcpmbN2/y2WefkU6n+eSTT2Q56H6i1WrJHN61a9doNBqcOXMGv9+PxWJhenoar9fL1NQUi4uLUjx1Px8cH4weCP3EiYkJfvKTnxCPx3nnnXeYn59Hq9XKaabHjh3D6/UyNzfHoUOHcLvdTE1NbZHQF3mdUqnExx9/LIVtr127RrPZpFgsbhFYfdbsWCmyQGxq4u9Ev0CtViObzUqdq/0ULthuRHGEmMk9nCAVoa1cLifDLw6H47E3l8gVPKkkfL8gyn/z+TypVEqeIEXjrjASwkA8KhH7qBksomFwOHkruqFFl38ulyORSJDNZmXoYr+V44oKPVG0IFoF+v2+nAHTbrdleXa1Wn0mGle7AVHFms/nZRhb3FfCyAQCAQaDAcFgkGQyidFoxGKxYLPZ5EA6oXE3rEc3XGYvClWSyaRs0xAyO89b5fy5G5d2u83i4iLNZhOfz8fRo0e3zJMeGRnBYrFQKpWYmZmRSsYP9iQofE0wGOTnP/85U1NTRKPRLaGubrdLKpVifX0dt9stvcUHK8sebLDcj70uDyJCA4lEgv/yX/4LLpeLEydOyCmV4l4cHx+XobAHEWX1D5Z7D//Z6XTk+IfPPvuM1dVV6bnU63Ups75fT+yNRoOrV68Si8UIhUKcOnUKnU4nlXiFBlmtVtuXxkV4uVeuXOHf/bt/x8jICP/sn/0zOcBPyORcuHCBer3OoUOHyGazsqpWhMMsFovM3Q3fd6JvZW1tjZs3b5JKpXjnnXfY2NiQua6dEAl97sal2+3KYThi+p4IIajVapxOp0xY+Xw+BoMBqVRKMS5PwGazceLECTkTftgTFE2A+XxeJqwfV7L8TWXM+5HBYECxWOTy5csYDAba7TaFQoFQKES/35djjB9nXP7/9s7zOa7zSvNP9+2cc240ciJAMImksuWRLXnGQePa9c7OfJzara3a2v2LZstbs17XeKpmHUbRomSlkRlEAgSIHDvnnPN+0JxX3SBIgiRSA/dXxaJEAiDuxXvved9znvOc3cPW9oLSZ/l8Hl6vF0tLS1hdXcXm5uapdkUg6vU6gsEg0uk0EokE6vU6u2+dA7T2akU4DdCLPRAI4MaNG/B4PHjzzTe71gtNK2232xgYGGDWQJRm3csGi742CZxCoRAbl0FB5jhLCEceXGhMb6VSYV31lIIhZ2ShUIi+vj58//vfRyqVgsPhQCKRQCQSQSQSYUe807rTex46GygpaA8NDbFal8vl6hqJvFeKEsCZu7dke04NuYFAADs7O1AqlZibm3vkeIfO4PKoe9ZoNJjdy8LCAsLhMKLR6Jm5x+R912632QmNXrhCoRBmsxn9/f0oFAqn9sRMPVZkFEunVpvNBofDAbFYzAbP0TsQePRGkFKNxWIRt2/fxvb2Nvx+P1ZWVpDL5VAqlY69Nn3kwaVeryMUCoHjOHi9XgSDQRiNRvbCo19kvZ/P5zE7O4tYLIabN2/i1q1bzDfsrDyc+2GvbnzgWynt+fPn4fF4WHChtNdeNvzHvSCPg84ZLxsbG9jc3GT3qPP35/036N+hl+tZWb+tVovVTsvlMhqNBjulcBwHt9vNToynNbgA3wkc6vU6PvzwQ8zPz+P69evM/Z1OJ/txxy6Xy/D5fIjFYvjNb36DL774oqtYfxJm5RxLQZ8uPJPJwO/3o16vw+12QyKRsCIq+fC02202l2RgYIA19ikUCtYJXK/X2ajQswgZMpZKpa57SPdRqVRCIBB0pR52L7xGo8Gm4lEhMJvNHsflHCu8cOTR0ARNGubHcRwKhcJjpa0UnFUqFWQyGWsq7Qwi9FI8C/b7pDRMp9PgOA4+nw8WiwV6vZ6980gBRs80iUFIbVgul5HL5bCzs4NkMtkllDhJadZjc0Vut9uYn59HqVTC+Pg4bDYbnE4nW4SUZxSLxTh//jzq9TrOnz+Pn//854jH47h//z6y2SybpxEOh7G+vn4mXw6VSgV+v581qOp0uq4xx06nE81mk81x74T+nyZRer1e/NM//RNWV1eRSqWOfffDc3LQ6XQYHByEWq3GyMgItFot7t69i1u3brEA0bleSGGnUqlw4cIFNoBNrVYzqTx5ka2vryMWi52J01y1WsXq6iq2t7exubmJzz77DG63G2+++SbMZjNGRkbgdDrh8/mYjJish9bW1rC+vs56gur1OhuvfdI4Vst9ir5qtZrZxJN8kxamUChkHbw0/CoajaJcLneNLS6VSmxXftYCTKPRQC6XQyaTgcFg6Ep3keTzSR36JGFMpVLw+XzY2to60mvgOfmQbYtOp4PT6YTZbIbP54NCoUCtVgPw3djsVqsFkUjEivUWiwV2ux06nY6dXOjjSOxw1FLZ44LShACYWrBSqWBsbAy1Wg0mkwlarRbJZBI+nw+lUolNiF1cXMTCwgI7KXZ6L540jjW4UNFpeXkZv/nNb2A0GuFwOKDX6+F2uzE1NQWpVPpQgUutVmNiYgLlchkOh4NNwdNoNEin01hbWzt1tiWPI5FI4N1334XNZsP3v/99TE9PQ6VSwWAwsIe4M+AA3f1FAoEA0WgUt27dgt/vRz6fP87L4TmhlEolhMNhNBoNqFQqOJ1OvP766xgcHGR2TdVqFX6/H8lkElarFYODg9DpdLhw4QJMJhP6+/shFArZZiaTycDn82F7exuJROJMnFw6IbFHKBTCjRs3oFKp8PXXX0Or1SKdTiMYDLK0d6PRQCKRYCmyTvHOSeRYgwvVTMrlMj744API5XIMDAzAZrPh0qVL6O/vZ3WDTpRKJQYHB9FutzE0NIRGowGTyYRyuYxwOIxgMHimgksqlcLnn38OrVYLi8UCk8kEk8nE0mN7zXbZ/Wc0lY6XffM8imq1ing8zmoDFosFDocD169fZw2CpVIJ33zzDTY3NzE2NoZXXnkFOp2OpdEIqjskEgmEw2EEAgFks9kT+6I8LGjqaKVSQSwWA/Bwk3mvcqzBhWg2myiVSmg0GojFYqjVapDJZDCZTGwHLpPJ2LTAZrPJJvqRF1Qmk0E6nUY2mz1RRa2joNVqoVKpQCgUYnl5GSKRCBqNBlar9SFVWKcyjP4MAObn5+H3+5HJZFiKg4enE+q2z+VyWFpaQrVahdlshsViYa4a1WoVMpkMBoOBdeB3DkGjEc+JRAKLi4uIx+MIhUIoFArsmT7rnJZ7IGjv80oOu7mOFE6dFiVWqxVKpRJDQ0NsqprVamXHcwCYnp6Gy+XCnTt38P777yOZTGJzc/NQUzvP8sM/7PtH/lVkCtjptLsfqtUqU6bU6/VDTU+cxPvXSzzry+cg7iH1YZjNZiiVSly9ehXXr1+HUChkEljajSuVSmZKeeXKFZhMJkQiEcRiMWxsbOBf/uVfWDGf+n6OKi3Gr8HnYz/370ScXIDvivB06ug0UpTL5cjn82zRUvpLIBDAZDKB4zgkEolDHdl50qEH8yylA3mOHtp8ZDIZlEolxGIxxOPxPftTWq0Wms0marUawuEwG1RFvlfRaJTJaM9atuEscGJOLrshXx2SMorFYpYaoxwlADbFMpVKseE3pVLpUAMMv+t5Pvj793wc58mFIMUXWb7vBZ2eaQKnVCplddZCocDcEEql0pFLafk1+Hzs5/6d2OBykuEX5vPB37/n4yQEl16HX4PPx37u3+n1WuDh4eHhOTb44MLDw8PDc+DwwYWHh4eH58DZd82Fh4eHh4dnv/AnFx4eHh6eA4cPLjw8PDw8Bw4fXHh4eHh4Dhw+uPDw8PDwHDh8cOHh4eHhOXD44MLDw8PDc+DwwYWHh4eH58DhgwsPDw8Pz4HDBxceHh4engOHDy48PDw8PAcOH1x4eHh4eA4cPrjw8PDw8Bw4+x5zzA/K+Q5+0NDzwd+/54MfFvb88Gvw+eCHhfHw8PDwHAt8cOHh4eHhOXD44MLDw8PDc+DwwYWHh4eH58DhgwsPDw8Pz4HDBxceHh4engNn31JkHp6zztNKUZ9VMszDcxrggwsPzx4IhUJwHAeJRAK73Q6VSgWj0QiDwQCZTAaj0QixWMw+ngJJo9FANptFrVbD6uoqNjc3UavVUC6X0Wq1jutyeHiOHD648PDsgVAohFgshlqtxrlz52Cz2TA2NoaxsTEYDAaMj49DLpd3fU673UalUoHP50Mmk8H/+3//D5lMBsViEdVqlQ8uPGcKPrj0IEKhEAKBAEKhEELh3mUzkUgEiUQCgUAAjuMgEAggk8kgk8nQarXQbrfRbrfZfxPNZhOFQgH1eh2NRgPNZpP9W+12G81mk70kT3PaRy6Xw2KxQK/XY3BwEA6HAy6XCyaTCVqtFnK5HFKp9KHPEwgE0Gq1EAqFsFgscDgcSKVSSKVSaDQax3AlJwuNRgO1Wg2ZTAadTgeO41CpVFCr1djHcBwHuVwOjuPYnzUaDVQqFTSbTVQqFdTrdRSLRWSz2VO9Dp8FeuY5joNWq4VGo0GtVkM2m0Wj0UC1Wj2StcgHlx5DIBBAIpGA4zgWLPaqBWg0GlitVojFYigUCojFYng8HvT19aHZbKJUKqHZbD600AqFAu7fv490Oo1cLod8Pg+O49iLNJ/Po1qtotlsotlsHtl1HzVOpxOvv/467HY73nrrLfT19UEqlUIqlYLjuK6UWCdisRg2mw1GoxFXrlxBq9XC+vo6/H4/qtXqEV/FyUIgEGB0dBRXrlyB2+3G9773PSgUCvh8PiSTSfZxcrkc/f39UKlU7M8ymQx2dnZQKpXg8/mQSqWwuLiIr7/+mg/auxAKhdBoNJDL5Xj55ZfxwgsvIBQK4datW8hmswgEAshms4f+ffDB5YRDgYNqABzHsWChUCigUCj2/DyDwQCLxQKJRAKlUgmJRAKXy4X+/n40Gg0UCoWuXSCRzWYRDAa7/m2O46BUKtlJRyAQoFarnergIpPJYLVaYbfb4XA4YLfbAYCd+JrNJjvZtdvtrp+TSCSCSCSCXq+Hw+FAMpmESHR2HjWRSNR1ohYIBOyemM1muN1uDAwMYHJyEiqVCnK5HPF4nH28QqHAyMgI1Go1+7N0Og2pVIp8Pg+BQAClUolIJAKZTMY2SGf1BMNxXFc2QywWQ6PRQKlUwm63Y3BwEGKxGNvb2xCJRMjn82zd0u/1ep2t7YPixK54juMgEonYQysQCNivVquFRqOBVqv1UFrnNCEQCNjDZ7FYMDw8DKVSCYfDAbVaDb1eD51Ot2dqTCqVQqlUskUHfPdiFIlE4DgOrVarK80FACaTCVarlZ1O6vU6pFIpdDodGo0GZmdnEQgEsLW1hQcPHpzaAKPX63Hu3DlYrVYolUoAQKVSQaVSQT6fh8/nQ7lcRjAYZC8+uVwOrVaL69evw2g0wm63QyaToVarQSKRHPMVHQ0ikQjnzp2D2+1mf6ZUKjEzMwOj0QiHwwGbzcZ21hzHwWq1QqPRdH0NmUzW9XUVCgU8Hg9qtRpsNhvK5TL0ej0AIJlM4v79+0eyGz9piMVijI2NwWazQa1Ww2g0QqVSYXR0FDqdDi6XC06nE0NDQxgZGWHrt1KpIB6PIxgMIpVK4ZtvvkEqlUK5XD6wE/aJDS5CoZDVDACwqCwQCLp2iwcdbU8acrkcOp0ObrcbV69ehV6vZ0Vls9kMq9X6WIlsu91mO7tgMIhQKIR2u83SOp2fS4FHp9NBIpGwICSXy2EymVCr1aBWq7GysoJ6vY6lpaVTG1w0Gg36+/thMplY4b5Wq6FYLCKZTGJtbQ3pdBoLCwsIBAJQKpXQaDRwOp0YHR2FXq+H2WyGxWKB1+t9ZBrttMFxHPr7+3Hx4kX2Z0ajET/5yU/g8Xj2/BydTgedTvfYryuVSmGxWLr+rN1uI51Ow+fzYWNj40wGF47j4Ha7MT4+DqvVCo/HA71ejytXrsBoNHZ97MzMTNf/b25uYn5+Hj6fD4FAALVajdVkDoJjDS60qGQyGQwGA4RCIer1Our1OjQaDSwWS9eRj04ztVoNuVyOPezVahWJRAKBQICdaE5DwBGJRJiYmMDk5CQcDgcmJiagUCigUqkgFAqRzWZRKpXYx9PDVigU0Gq1UK/X2emj2WwiEokgGo0+9t6IRCJoNBqIxWLI5XJWeB0cHESr1UIqlUKxWOwqwJ5GaG1JpVKW6lpbW8Pa2hqy2Sy2t7dRLBZZ/l8qlSKVSqHdbqNYLKJer7NU0FmAlHVqtRrDw8OYmppif6dSqdjpbz9Uq1WEQiEUi0X2Z1KpFGq1GiKRCGq1GlKpFDKZDGazGfl8/lQH7846q0ajYaKIvr4+qFQqnDt3Dk6nExqNBiaTCSqVak+xyW5UKhVcLhfEYjGuXLkCh8OB+fl5rK2tHcj3fWwrXyAQwOl0Ynp6GiaTCTMzM1AoFOzl5Xa7MTU1xQqodJKRSqUoFosIhUIol8sIh8PIZDL45ptv8O6776JcLqNSqZyK4CKRSPDmm2/iP//n/wy5XA6NRoNWq4VkMsmunU4iAFCv17GwsACv14tKpYJisciCS6vVQiKRQDqdfuy/STUdkUgEg8EArVYLl8uFl156CRKJBD6fD+l0GqVS6VTc40dRq9WQSqVQr9cRj8fRbDbx29/+Fr/73e/YBqgzPUsp20wmw34+crn8zAQXuVyOvr4+WCwWvPLKK/jhD3/I/o6e3f1SKBTw5z//mdX+ADDVnlqtxuDgIEvVDg4Ootls7utl2qsIhUKmsBsZGcHY2BgGBwfxs5/9DAaDARKJhNVkSUG6n3VnNpuh1+tRKBRgNBqRSCTwy1/+Euvr6wfybB/ryqdCH+1KlEolkyV2yhCpkE15baFQCLPZzI5vCoUCDocDbrcbuVwOkUgElUql5/sKqHBpNBrZqa1arSKdTiOTySAUCiEQCHQFl3A4jGg0imq1yor29ALMZrNPTB0IhUJUq1WIRCK02200Gg1IJBIEAgFIpVIkEglks1mUy+WuzxEIBBCLxRCLxazw33l66jUqlQpisRhKpRJLvyYSCSYpftTDR0IHStee9rQtwXEcVCoVe447hSZUMG61WigUCigUCo+9J6lUCoFAAKFQiP1ZsVhkpyODwcBOQmq1GhqNhmVBDrJmcFzsztRIpVJ2InE6nXA6nbDZbNBqtVCr1ax2WqvVUKvV0Gq1WM10P1Sr1a5MxEGt12MLLtRwlkwmIZPJ2AOZTCYRDAYRiUSwsrICsVjMuqJNJhPMZjMraovFYlitVtTrdQwMDODKlSvw+/345S9/iY2NDdRqtS4lVC8ilUqhUChQLpcRjUYRi8Xwm9/8BisrK8hkMkin011BNJ/Po1wuM6lw5wtuP/ei1WqhUqkwRVg6nUYkEsH29jaEQmFXj0Gz2exSr/X398PhcLC0ZaVSwc7ODjKZzCHeocNhY2MDv/71r1nNSyQSYXV1ld3T3XTuGGkH2RlcT3uAkcvlGBgYgNPphFar7fq7er0Ov9+PXC6HGzdu4JNPPnnsxq9WqyEej6NSqbA/ozStXq/H3/3d3+GFF16ASqXC0NAQ5HI5fvCDH2BoaAizs7NYWVk5tOs8bGhDKZPJoNVqYbPZoNPpcPXqVdhsNng8Hla7SqVSiMfjrDQQiUSwtbWFXC6HtbU15HK5ff2bMpkMLpcLUqkUPp/vwK7lWE8u9XqdpbHoZVgqlZDNZtmDKZFIYLVaoVAomFzOZDJBIpFAoVCwHYxGo4HNZoPZbMbvf/97SCQSlhLqZainolQqIZ/PI51OY2lpCbOzs2wXeNDQjqfRaKBcLiOXyyEWi3V9DKWBqN9GKpUymWmlUoFcLkexWEQ4HD7w7+8oyGQyWFlZYdclk8mQyWQe+VKkUzjtOknVSM2opx0Sguj1+odSVM1mE7lcDolEAgsLC/j444+fOaug0+nw2muvYWhoiNUD6/U6e+Fub28/97UcN2KxuCu4mEwmTExMMOWXw+FALpfD1tYWSqUSMpkMSqUSdnZ2MD8/z9Rfnb1Dj0Or1eLKlSvQaDQHKoo41uCSzWbZzrZarUIikSASibDdeLvdBsdx2N7e7ioY6nQ63LlzB2q1GkNDQ+w0Q42D3//+99Hf34979+7h/v37x3mJB0apVGI1lmw2i0KhcCxFdSosGo1G2Gw26PV6XLhwgfXVGI1GRCIR3L9/H8lksmcluLTRoTSDSCR6aCcoEAigUCggkUjgdDoxMjKCvr4+OBwOyGQyrKysYGNjA/fv3+9KI55GNBoNLl++jIGBgYdUXeVyGQsLC9ja2oLf73+uUxzVDn0+H+RyOQvgkUgEfr8f+Xz+eS/lWCEnDbVajZGREbz11ltMYtxut3H//n18+umnyGaz2NzcZJvzer3OsgzFYvGp1lu1WsXOzg5kMtkTa7JPw7EGl0wmg2w2C5/Ph4WFBQDd+b7O5jTgO9ks5R51Oh3eeustTE1NwePxsKa3t956C4lEAqVSCfPz86ciJVEqlRAMBhEIBJBKpQ7lxPIkBAIBpFIpa8i8ePEiPB4P/sN/+A9wu93s57OyssKa4nq10NpoNNiJg15Yu9cR9SGR/9jbb7/NLF9kMhk2Njbwr//6rwiFQl2qvtOITqfDCy+8gPHx8Yek8aVSCXNzc5ibm8POzs5z/TvNZhPxeBxerxdmsxntdhu1Wg3hcBher3ffqaCTikAgYOKd8fFxvPPOOxCJRGwTfu/ePXz66adIp9PY2trqEi911vee5p1XqVSwtbX11J/3JI5dyvKkgudef1etVtkDn0qlkEwmYTKZAHzXD0N579OCSCSCSqViMkNqgjzMwEkvCaVSCZPJxNIQSqUS/f39GBkZgclkYrumUqmEcrmMra0thEIhxGKxrrx5L0FNqGKxGDqdjqUqOk9iQqEQer0eCoUC4+PjsNvtUCqVyGazLCVIJ/FeFDXsB+q18ng8zJdOLpdDLBYz0QnVUNPp9IEoOXd74gmFQiiVSqjV6p49KRMCgQBqtRpmsxkajYYJayKRCMtcJJNJlrk4qJTrYbxHjj24PAtUvMpms0yTrVarT+0DDIBJMCUSCXuh1Wq1Q1XGUJD2eDz4yU9+wmoqBoMBer0eFosF1WoVXq8Xa2trWF9fh8/nQzAYxN27d1EsFnt2J2k0GjExMQGDwYCrV6/CarXCarV2pXxIIUeiBo1Gg3w+j3v37iEajeKrr77C7OwsU/GcNgQCAV588UW88847UKvVyGaz2NjYQF9fH0wmEx48eIBf//rXiEQiuHv3LuLx+KHUQKVSKfPMi0QiB/71jxJ63i5evIiBgQGIRCKk02l89tlnmJ+fx9bWFra2tnqintyTwYWUTxzHoV6vd0XwTt+nXpciA+iaBUINlFR7ot3LQe46qDBNuV+pVAqj0Qi32w2LxQKXywWtVguFQgG5XM5OLdTEurOzg1gsxqwkei3gUzFeoVDAbDbDbDbD4/EwjzGbzdaV9un0dKL1SLnvVCqFfD5/app6dyMQCKDT6dhLEPh241cqlVAoFJBMJrG9vY14PI5MJnNgdSdqTaDMhFAohEwmg1Kp7Om+IhLIaDQaZuMCfPsOSCQSCIfDSKfTPVO/69mfBA1y6u/vx4ULF+B2u8FxHKrVKmKxGEKhUM/umolGo4FvvvkGKpUKDocD09PTkEgk+OlPf4qZmRncvHkTX331VVd94FmhhU2mgRqNBufOnWOpr4mJCYjFYiQSCSQSCQSDQWxsbKBQKMDr9SKfzyOTyTApNAWWXgrw9LJUKpWYnp7GT37yExgMBgwODkKj0bDi/e7P6fy9WCzi3r17rJn1tAYWQq/XY2hoiHXI12o13LlzBxsbG1heXsby8jKKxeKBpUc5joPNZsPw8DDMZvNTTwc9qYhEIiiVSmi1Wpw/f545RheLRdb34/V6u1wLTjo9GVw63T/NZjP6+/thNBohFArRaDS6uqR7mWazic3NTWbPcPXqVWg0GrzwwgsYGhpCIpHArVu3utxNnxXaeVOntcPhwOuvv8468xUKBbPliEQimJ2dxY0bN9jiPw1pH+ox0Ol06O/vxwsvvACdTgetVrtve5FqtYqtrS0sLS09sVmw1yFBg81mY/enUChgY2MDH374ISKRCILB4IFKsYVCIXQ6HTO/PC11VaFQCLlcDrVaDY/Hg6mpKZRKJXb6TSaTXc7RvcCxBhexWAyJRMIa99rtNqRSKcRiMer1+iPrCWq1mgWUwcFB2O12aDQaJh8lIzvyeupVWq0WotEoe+nfvn0bSqWSORqMjo7ijTfeQCwWw8LCwlPvaoRCIYxGI5RKJSwWC/r6+qDVanHu3DkYDAaYTCaUSiVEIhH4fD4UCgUsLS0hEolgZ2ena7bLaYDjOPT19WF4eBiDg4PsXj/NC4zUPkqlsuc7xXdDElmZTMbUmsPDw8z25sGDB0gmk1heXmY10YM+uQqFQtb/odFoIBAIUKlUsL6+jtXVVSQSiQP9904CEokEHo8HmUwGjUaDlQToFL27l6rZbCKfzzObouOqzRxrcKHu52q1yjqZyeSOzP/2WpwGgwHf+9734HQ6cfnyZYyNjbECVzabxfz8PO7fv99zkX43zWYTOzs78Pl8THlltVrxwx/+EH19fXj55ZcxNDSExcVF+P3+pw4uIpGIdfxeuHABb7/9NlQqFcxmMyQSCbM7efDgAX71q18hFoshGo2yeRCHMQPiOBGLxZiZmcH3vvc9eDwe5tv0NKkXypnr9fpTJz9WqVQYHByEyWTCW2+9hYGBAQwPD4PjOIRCIfz617/G9vY2lpeXEQwGmQXQQSISiWC32zE8PMzqXblcDl9//TXu3r174ovcz4JCocDFixdhMBhQKBSQz+eZt5pAIHjIjqlcLrPNXy6XO73BRaFQdE3vEwqFbDeo0Wig1WpRrVah1+vRbreh1WqhVCpZ5ykV58nnqtlssk58k8nE5KI0+KpcLqNYLLLg1OvQjqRQKDBH41gsBoVCwdwKSA7aaDRY4x/dt70gI0G5XA6z2cwK1eRQTfcykUjA7/fD7/cjHo8jmUwil8v1fLrxcTQaDeaInEqlWIGY+imq1Sor+guFQlaHoftJrtJGo/FAG9JOAkqlEm63G2azGXa7HRaLBe12G8FgkMmNyY7koF0JOtcsjYMg8UA6nT7Qus5x0DlQrbOORxJ4i8WCVquFYrGIQqEAiUTC0oJarbbr2ukdQIPVKCt01BmGQw0uIpEIU1NTGBoaYnlSpVLJ/p9uZuckNApAFEjq9TpSqRTzIaOelpmZGWi1WhgMBgDfvnwDgQD8fj9b5KfJdoPqK2q1Gvl8HjabDS+99BJeffVVyOVy/O3f/i1isRhrVCPLlr12jkqlEh6PBzqdDj/4wQ9w6dIlpgArl8uYnZ1FMpnErVu38M0336BQKCAUCrET5mml0WhgbW2NFfbn5+eZR1ir1WIy0M4R01euXMHAwAD6+vpw7tw5KJVKXL9+HU6nE81mE9vb26fmZDc+Po7//t//O0wmE0wmE6RSKb766iv86U9/YnLjTCZzKC95CmxWq5VNqNzZ2cGdO3ewvb3dk/51ndCmRKvVssZjqVQKvV4PpVKJH/zgBywF3Wg0mI+dQCBg70qiXC5jc3MTmUwGN27cwBdffMGGhB2lwObQggtFYqPRyIYueTweaDQanD9/HiaTqeuh2z0xkf67VqshGo0y+5NIJAK1Wg273Q6FQsEm1lWrVeRyOeRyOZRKpZ7exewFTUHM5XLQarXIZrOYnJyEXC6HwWDAyMgIDAYDYrEYO/GJRKIuSTbtuOlIbbVa4Xa7MTQ0xP6+VqshFAohFAphaWkJc3Nzh5LeOIm0Wi1kMhkEg0Fks1nk83kIhULme7e4uIjFxUV2YqHGPbImos0RyZWpJtDrwYWeTYPBgKmpKdaw3Gw2kclkMD8/zwrOh3WqpWZWSlUC3zon+P1+hMPhnheUkECJro2CBdVbaWDdXux2MSmXy5BKpchkMlhcXGSfe9SuHocSXMgXR6/X4/XXX8fly5dZbr7VauHevXtsYWYyGWi1WoyOjkKpVLJjL0ljqUAql8tZzwUNFyPpcblcxsrKCm7cuMG04KeVRqOBcDiMXC6HTz/9FPl8HhqNBn19fXC73fiLv/gLXL58GdFoFOvr60in07h37x6SySTcbjczv3v11VdhNBoxPDwMiUSCra0t3Lt3D6lUCnNzc0gkEmdCSttJq9VCJBJBuVyGRCKBTCZjJxdKR5JjdKPRQKVSwezsLMLhMFqtFq5du8Z8xmiYk9VqRaVSOZTi9lEgEolw5coVjI+P49q1a5DJZGg0GkgmkygWi/B6vdjZ2Tn0NLTBYMC1a9fgcDhYcDtNUGN4sVjERx99hGg0ypygH1fzo340sVjMlI40UE2tVuPFF1+ERCLB5uYmbty4caTea4cSXFQqFWZmZuByufDqq6/ihRdeYA1VmUwGd+/eRSwWg8/nw87ODlwuF/7yL/8SJpMJBoMBKpWKzTIgO2iaa0KnGhp3HIvFkMvlsLy8jI8++ojZ0J9WKLhQIW9xcRETExP4b//tv8HlcuHcuXNQKBTw+/1YWFiA3+9n0xJdLheuXbuG4eFhvPPOO9Dr9WxX7vf78fvf/x7JZBIbGxvI5XJnJqgQpM7b7QBNdN4PCjJzc3OsyNxoNJjvnclkYmmcTCbDpoP2GmKxGNevX8ePf/xjWK1WSKVSNBoNRKNRJJNJeL1e+Hy+Q0+XkncZ1XxOG5ShSSaT+Oijj3D//n0oFArodLrHqhU7e7NI8anX63H58mVWx3a5XLh9+za+/vrr3g8uHMdBqVRCpVJBJBKh2WwinU5jeXkZ6XQaOzs7SCQSiEajyGazEIvFWFlZYQN/KALbbDY2CIegNAPlGUUiEeRyOWw2G6amppBOp6FUKpHP55klPU0MPE20222WCozFYlhcXEQqlcLw8DDsdjtEIhGsVis4jsO1a9fgdDpx7tw5jI2NwWKxoFarIZvNIhwOI5vNYn19HclkEtls9sC7/nuN/V5751A0gk7cu3/1arMf9bKYTCao1Wo2TC4cDiMQCCCZTB5q0KTalsFggNFohE6nY6mjSqWCTCaDXC53auTwrVaL9bdQev9xa0coFKJQKEAqlSKbzSKXy8FgMMBgMKBUKqHRaLD/N5vNTKZ8FDL5QwkuEokEFosFNpsNHMehWCxicXERv/zlL5nRZLlcZp3l0WgUOzs7zJxRJpNhZmYGP/zhD5mfVSeNRoMVp+RyObRaLV588UX09fUhmUzi5s2biEajWFpawurqKpvK2Is7x8dRKBRQLpeRz+eRSqWg0+nwi1/8Ai+99BLUajUuXryIdruN69evo16vs0me5XKZnfg+/PBDPHjwAMFgEOvr68eqiz8tiEQiZtNP0zl7FaFQCKvVitHRUTYIrVQq4ebNm5ibm8Pa2tqhPVcCgYAp08bGxjA6OgqbzcaCSyaTwfr6ek8bpO6m1WohFoshmUyyAXSPg1SLtKmhxvJMJoOBgQGcP38ek5OTyOVyuHz5MgKBABYXF4/Eg+1QggvJjWUyGTiOYzLOfD7PCqXVapV1hQPf5hwbjQaTfnYW6EghQb+q1SoymQza7XbXmGSHwwG5XA6n0wmO4xCPx9moWmo+6txpUnqNFGpkV0Ino5MOXQs58JJcOR6Ps4VGhVC6VuDbOTqRSITdx2g0ylQ+p2UHSJAHlUgkYrU8EjkcViClNdRZZ+w1qMBMHnJyuZxJ1IvFIpLJJGKx2KEXiaVSKTQaDVQqVZeAB/i2eTCfz7OpqKeFg7Bzovdsq9Vim0qqwxzVZudQgotIJGIyYY1GA6VSCZfLhRdffBHxeByrq6vIZrMwGo0wm83QarUYHh5m3joKhQJWqxUjIyPgOI4FpY2NDWxsbKBUKiGRSIDjOLz22msYGxtjN08ul+O1115DuVzG5OQkvF4vk0nmcjlEIhHkcjn28lWpVJiamoJarUY8HkcqlUImk4Hf7++ZHTxZnVerVbz77ru4c+cOLl++jJ/+9KfQ6XSsZkXpHo7j2Oxtp9PJalSBQOA4L+PAEQqFbKDZ8PAwXnrpJQgEAmxtbSGdTmNlZQWLi4sH6oHWbDaRzWaZutHn87FTei+h0+lw6dIlWK1W9PX1AQDC4TDm5uYQDocxPz+PjY0NFIvFQ0uhCgQCmEwmDA8Pw+FwPGRKSe8EGqnN8y0cx0GlUrG+NdpAq9Xqp7Iyel4O7eRCFhik8jIYDBgaGoJGo2GadKfTiYGBAVitVly7do2NSaUZ0mShQYNylpaWcPPmTRSLRaamsNvtzP7dbDZDJBLBYDCg3W4z37GtrS2WjiuVSqhWqxCLxZBKpTCZTJicnITZbMbW1hYCgQCEQiFCoVDPBJdWq4VqtYpqtcombzabTVy+fBn1eh1msxkKhYJ9PP186vU69Ho9zGYz4vH4qfFpIgQCAbRaLRwOB6ampvDjH/8YAoEA33zzDZvouby8fKAni1arxVKVmUwGqVSqJx265XI5RkZG2IgF4Ns0FHXf+/3+RwofDgqq91itVuh0OpblIEqlEmva5PkOcolWKBQsIJMprVwuP7Ln/FCCS6lUwsrKCsrlMlN8SSQSTE1NoVAowGKxIJfLwWg0wmQyQaPRwOl0QiaTsVnx9IAWi0Wsra2xyWter5f1e4hEIty6dQuxWAx9fX2YnJyESqWCx+NhvlAkW3zttddQKBRw/vz5h04uExMTUKvVsNlsSKfTWFhYwPr6es/thgQCAQvOLpcLDocDarUa6XSaddaTzFar1UKtVmNsbAw6nY65HWQyGXayJCVZryIUCmEwGNDf3w+73c4EJoODgzAYDKjVapDJZKzBrF6vIxQKsYDwLEVP6oSm01CvSrkpd2+z2djGpFKpMDXdYRaEKfNBAe7ixYus1lKr1fDgwQOEQiE8ePCgp9fnQSGVSpn82GAwwOVyYXh4GAMDA9DpdAC+LTskk0kkEokj6wk6lOCSzWZx8+ZNbG1tsZGdSqUSr7zyCjiOYw6+VIyinHij0cDCwgKTKM/OzjJvq2QyyR5aymULBAKEw2GIRCJMTEzgpZdegt1ux49+9CM4nU4oFAro9Xo4nU5MTU2xB7/VanVZLFCnK70MPvjgA7z77rvIZrOHcXsODY7jYLfb4XQ6MT4+jpGREQiFQiwtLSGVSiEWiyEej8PpdOJ73/sedDodrl27BgAIBoO4cOECfD4f/vEf/xEbGxs9X4MRCoVwuVyYnp7G0NAQ9Ho95HI59Ho9Go0GBgcHcfXqVeZAkMvl8Pnnn2NxcZFZaDxtYOicJ0SKxl47tQDfqrTcbjcGBgZYR3yhUMDOzg7rBTosxGIxnE4njEYjrl27hrfeeottBrPZLP74xz/iiy++OBIJ9EmHGnoVCgU8Hg+mp6fhcrlw+fJlDAwMsFNKpVJhDiZH5Xl3KMGl0Wggm81CKBQiEAjAbDZDp9N1FewBsAePbF5qtRpLTQUCAVZopq77vWg2m6hWq0in06yZjXLBNDGRHEQ7hwsRndYzJP3LZDI9+UKgNJDNZoNWq2U2OpFIBKFQiM1iISt/rVYLnU4HhULBOrCr1SoGBwchEAiQSCSQTCZZw2Cv7cAFAgEkEgk7xZLVEKVG0+k0E3yk02nk83kWUPfz8ye3A/oFfLv26T73suU+5e01Gg27Niqg5/P5Q60hUSOqw+GA0WiEVCpFu93uUkbG4/Gevr/PC6nDRCIRzGYzDAYD+vr60NfXx2y2yH+tVqshl8ux9oyjCsiHlhZbX1+HRCJBNBrFxx9/DIvFgpGRka5iEvWhFAoFBINBlMtlNl2xUqmgUCgwM8YnEQqFmN7766+/Zk6iVKx3Op2QSCQPLUZShjUaDczPz2NlZYUNv+o1xGIxGzRETX2RSAS/+93vMDs7y+oyMpkM7733HuvgHRoagt1ux9DQEKuDFYtFfPLJJ/j888+RTqexsbHRkxbydHpVKpXMGuPOnTsIBAK4c+cO/vznP6NWqzFX7kwmg1KptK90Fp0UyThUKBQik8nggw8+wOrqKhYWFnr25SeXy9Hf34+RkRGm0Mrn89jY2EAsFjvUk4vRaMTf/u3f4tKlS7BYLBAIBGwoXSwWw+rqKtbW1lCr1XpyE3gQkBeZWq3Gj370I1y8eJE9w3K5nDWcB4NBeL1e3L9/H+vr64hGo0f2HB9KcKFGHeDb41g4HIbNZkOz2WQa9Xa7jWw2yxp/KA3zrFA9oTNVJpVKoVQqodfrWQF/98NODZb1eh0bGxtYWFhgOfdeQygUsjSgWq1mO5adnR2srq6yF6ZQKITf74dCoYDRaGSSU7I8Ibdb+jySfPdacyWlPMlFl1wdUqkUwuEwtre3sbS09MyD1oRCIVQq1UMjaQOBALPe6UXovtFIbUr1UdPuQcuPqU+D0uRqtRrDw8OYnJwE8F3DMA0BTKVSJ3rKbKdH4kF8rc5eFoLebVqtFn19fRgfH2cjuan9o9VqIZfLsfaEXC53pOKHQ7fcp91FNBpFs9nsSknRTpp6XA6CzqmMm5ubKBaLbG7MXvO1Oz/e7/cjGo32nHS08yUqFArZtX/66aeIRCKIRCJdO3E6rZXLZczPzyMcDmNtbQ0bGxswGo148cUXYTKZMD4+DoVCgdXVVTYTnTqHewHqr+qsn0ilUpw7dw42mw35fB6BQACFQgGRSGTfhU6SdarVarz22mu4dOkSBgYGAHy7prPZ7KG5Ax82Wq0Wer0edrsdEokEzWYT6+vrCAaDWFxcPPCUilgsxujoKOx2OxwOB0ZGRmCz2eByuQAAqVQK2WwWa2tr+P3vf49IJAKv13ug38NBolarodPpUKvVkEqlnut+0cZYq9Xi6tWrzKeuWq1CqVTC6XRCpVJhenoabrcbCoWCpcLJ++2rr77Cp59+inA4fOSqukMPLtSoVi6Xj2xKHBXmd3Z2nnoh9tLOnOh0VCVhgtfrxb/+678inU4jHo93XVenomlpaYn1EywtLTEDTIVCgaGhIczMzMBms2F2dhZisRjlcrlnggsAtvY6g8vY2Bjq9ToCgQCWl5fZrJqnCS6ksLt+/Treeusttmmi3X06ne7J4KLRaOByudjo4maziY2NDdy7dw9ra2sHHlxEIhFGR0dx/vx5XLx4ET/84Q/ZvCfKbvh8PszPz+O3v/0tm2l0UlGpVHA4HCgWi889qItsrdxuN37xi19gYmKC1U40Gg0GBwdZH0vnqaZeryMejyOdTuPOnTv4wx/+cCyqxWOdRHkUnOSFeFCQsken00Eul6NaraJYLCKdTiOTyTxxgXemHaRSKe7fv49MJoOJiQmMjo5CJpPBZDKhWq0iFAod0VU9P+12m6UF9Ho9UwmSOtFut2NmZgaxWAztdpsV9Om0TYV9+n9ylNBoNBgYGIDJZIJWqwXHcV1GrMlkktVweg1yHqfrIg564qharWZS2ampKQwPD8Nms7HsArl4rK2tYX5+Hqurqz0hKrFYLDh//jzK5TJUKtWetSlyOmg0GszJhMQntDY5jmOyYrPZ3NWrRmlschYh4vE4qxfTPBeaCHoc9+3UB5ezgNFoxF/8xV/AYrGwCYixWAxer5eJIp4E+ZRRH4NWq8V/+S//BSMjI1Cr1ZiYmIBWq4XX6+2ZANNsNuH1eiGRSJibLwD28F6+fBnDw8OIxWK4ffs2MpkMQqEQMpkMS6fV63UkEglUKhVmomiz2XD9+nUYjUa4XC6IRCIsLCzgH/7hH5BIJLCxsdGzSiaj0YjR0VH09fUxldhh0NfXh7//+7+Hy+XCxMQEHA4HJBIJOx17vV5kMhn8/ve/x29/+1vW23aSEQgEmJmZwd///d+jVqthc3Nzz1N+rVaDz+dDoVCA1WqF1WqFTCaDVquFRCKBWq2GQqGASqWCwWBgaVg6MVMbxu5O+/v37+N//+//jUQigc3NTaYOO651yAeXUwApR3Q6HUtl0Lje/R7LOxv+0uk0e7nSbp9MGHvJ3bfdbrOXEs0bobqfQCBgI7IFAgFcLhdUKhXrG+is1YjF4oeCi9VqhV6vh0gkYvNagsEgS4f1qoqJ4zhIpVKWYn3Wr0H9a7sdoSl9S3UV2plrtVrm91Yul5l3WSQSOfGpsE7oVEEN3LVajd0PgiZK0kRZh8MBqVTKgotGo2G9K1qtlglR6BmlU3W5XO5yiA+Hw/D7/Ugmk8dSY9kNH1xOAaSw0Wg0bFcO4KlfDhREtFotW+BCoRCVSgWhUAjBYPDYF+zT0G63kUgk0Gg04HQ64fP5mCsEzbsXCoUwGo24dOkS6vU6CyikImw2m6jVamg2m+wlIZfLYTKZIBAIEI/H4ff7sby8zMxDz3JjH7ko0/gMq9XKUl1CoRCTk5MYHx+HwWBgAwJJaUfef8FgEP/3//5frK+vw+v19kxgAQCfz4fPP/+c2dYYDAaYTCbWKQ98u5E7d+4c6vU6MwUVCoUsLSYWi9lzLBAIUK/X2TReGvVeKpWYJHx7exvxeBzhcBjr6+tMJHXc8MHlFEBNolQIpbrC00CfQ2NVVSoV29XX63WmgOqlF2e73UahUECz2UQymUQ6nWapBeC7RjSlUgmlUvnUX79arcLn88Hn8yESiSCbzfZkEX8vnvWFLhQKodFo2MiN4eHhLn+r1157Da+++uqeGx8S/fj9fty+fRuLi4vPdQ1HDZ3619fXu6xzqA/qWaH+q1wuh0AgwMZwb21tIZfLYXZ2Fj6f7wCv5GDgg8spoFqtIhqNQigUYmRkBHa7HaFQCMPDw8xSv1wus+DRmbIwmUxQqVRd/RrDw8PQ6/XweDzI5XJIJBLY3t7uyZMLBUO/348//elPcDgcePvtt5mlydNAKYlSqYRoNIpcLodbt25haWkJa2trPVnA3w05iMfjcZb+UyqVeOGFF+B0OuFyuVAqlZDJZJgyLp/PQyqVMhdeKs5rNBqYzeauk7TD4ej696gulkqlmCotEokglUodx+U/N7FYDAsLC1CpVIhEIlAqlbDb7TAYDMy5/XEbP5LP0yma3M4TiQTK5TIbDU8Dxci14CTCB5dTQKVSgdfrRa1Ww5UrV3D+/Hlks1lcuHCBzeUmE1GpVNp10jl37hxcLhecTiczsZycnIROp2OuvqFQCEtLSwiFQj1XS6AUAZlxejwezMzMoL+//6m/FqXIkskkZmdnEY1G8cEHH+Du3bunZsjazs4O/H4/nE4n5HI5XC4XXn/9dbzyyiusJlKtVlmTKI3R1mg0GB4ehkajYY4Pe52gd9dgyIhycXERs7Oz+OMf/8gUe71IIBBgY8hpE6fX69nmzePxPNbyvtVqIZPJsJk5Xq+XuWp3zgjqhXlBfHA5BVBxUKlUol6vs2I1jTuORCLMY4tsuGUyGaRSKQYHB+FwOGC1WmGxWJgnEXWyBwIBhEKhnjexrNfrKBQKbLSz3+9n6iQalU0vvr1SNiRVJkUZWZFQs2Qv1QUeB53OSJquVCrRaDTYC5GK/QaDARzHodFooN1usxnuSqUSGo2ma6hXJ4VCgXm70dybjY0N+Hw+xONxptDrVfYae02mvMC39+9xwYXk8+VyGel0mqV1exE+uJwCyuUyfD4fG6JWKpVgsVjwox/9CNlsFoODg0ilUnA4HLDb7V06eavVCo1Gw6xf6vU6mzD46aef4quvvkI8Hj+xR+/9UqvV2Byh9957D4uLi7BarbDZbNDpdBgbG2MGl7sffmo4XVxcxO3bt+H3+/HZZ58hnU4jlUo9s33MSaZcLmNnZwelUukhd3CxWAy32w273Y7BwUFUq1VwHMcmzz5Kwtxut7G6uoq5uTkEAgF8+eWXLM1Dzbm95IyxH9rtNorFIhvrEI1Gnyi0ofVGgpJehQ8up4BGo4FCoQCxWMxSYBzHsZ1kJpOBWq1m3fdisZidUGjyZ6cUOZ/PI5lMwu/3Y319HcVisecfekpplUolNmWUThy1Wg12u52lGDof6E4LfWpS8/v92NnZOfF9F88DnYalUilT0FGDn0AggFwuf+TnktJu99cjYYXP58PW1hbu3bvXs/5rTwNdO62/swIfXE4BjUaD9aZ89tlnyGQyUKlUMJlM7OUok8lYvUAikaBarUIgECAQCKBeryOdTiMSiSCfz2NtbQ2ZTAbr6+tIJBI9223eCd0HcuwOhUJYX1+HRqOBXC7HH//4R4jFYojF4ocmHlLg9fl88Pv9Z2KsbrVaRSAQQDqdxvvvv49wOIyRkRG8+uqrj0x5Ad+uxZWVla5G22KxiMXFRSSTSQSDQQSDQVaU5jm9CNr7PM/3UvPcYfMsKZCjuH8ikQjDw8Ow2+1wu92Ymppi46LpxUkGlyqVillyp9NpeL1eLC0tdc0lP6xJlCfx/u3n65+U1Nezfh/Pcg85jmMz7N944w38z//5P6HVah/58dVqFR999BHm5ubYnyWTSfzhD39gPn8n4T6exDXYS+zn/vEnl1NEq9VCoVBAPB4HANaYRblw+kUFfQBIJBIoFouIx+NMslytVh8qTJ52TsIL7yRCadJ4PI7l5WV88MEHj+0JqtVqmJ2dxdbWFvuzfD6PUqnE3+MzBn9yeQZO8q6Hus5pLCypnzrHOgNgrrMURGhgWqdh42Fxku9fL3CUJxfguzUllUqZRc7jvrdKpdKl+Gq1WidObcivwedjP/ePDy7PAL8wnw/+/j0fRx1cTiP8Gnw+9nP/ns4jhIeHh4eHZx/wwYWHh4eH58DhgwsPDw8Pz4HDBxceHh4engOHDy48PDw8PAfOvtViPDw8PDw8+4U/ufDw8PDwHDh8cOHh4eHhOXD44MLDw8PDc+DwwYWHh4eH58DhgwsPDw8Pz4HDBxceHh4engOHDy48PDw8PAcOH1x4eHh4eA4cPrjw8PDw8Bw4fHDh4eHh4Tlw+ODCw8PDw3Pg8MGFh4eHh+fA4YMLDw8PD8+BI9rvB/Lzo7+Dn7/9fPD37/l4ViNz/h5+B78Gn4/93D/+5MLDw8PDc+DwwYWHh4eH58DhgwsPDw8Pz4HDBxceHh4engNn3wV9Hp6zgFAohFAohEwmg1qtBgA0m0202200m000Gg00m01Uq1W0Wi20Wq1j/o55eE4mfHDh4fl3BAIB1Go1FAoFrly5gp/97GcQi8VIpVKoVCqIxWJIJBKIx+OYn59HoVBAuVxGvV4/7m+dh+fEwQcXHp5/RyAQQCqVQqlUor+/H2+88QYkEgnC4TCKxSJ8Ph98Ph8UCgW2trbQaDRQr9fRaDSeWR58Wnhame5Zv19nAT648PD8OxzHoa+vD4ODgxgaGoJKpYJUKkW73UatVoNKpYLD4UAmk0F/fz8KhQKi0Siy2SxCoRA2NjZQrVZRKBTQaDSO+3KOBKvVCpvNBr1ej4mJCSiVyoc+ptlsolQqoVarIZ1OI5VKoVQqIRaLoVqtIpvNolKpHMN3z3OY8MGFh+ff4TgOIyMjuHr1KsbHx6FWq7tqL/39/Wi322i1Wmg0GqjVatjY2EAsFsOtW7dQLBaRz+dRrVbPRHARCASw2+24cuUKhoeH8Td/8zewWq0PfVy9Xkc0GkWpVMLq6ipWV1dZajGTyaDRaPDB5RRyYoOLQCCAUCgEx3FQKpUQi8WQSqWQSqWQSCRQKBTgOI59PB2zq9UqIpEIyuUyKpUKarXacV0CT49BqR2h8FsRZbvdRr1eRzqdRq1WY38vFouhVCohEomg0WjQarXQ19eH6elpZDIZiEQi5HI55PN5FAqFY7uew0IkEkGv10Mul2NgYABDQ0Nwu93spLcbjuOgVqshEolgsVhQLpehUCiQy+WQTqeRyWSQyWTQarX4dNkjEAgErCaoUqkgk8mg0+kgEj36Fd5ut5HL5ZDL5VCr1ZDL5dBsNtl9lslkbB0rlUoIhULU63XU63VUKhX2M3lWTlxw6XyA6eLHx8dhNBrhdrvhcrlgNBoxOTkJuVwO4NubSGqecDiMX/3qV1hfX0cwGEQ4HD7Oy+HpITrXET1k+XweX3zxBcLhMIRCIUQiEaxWKy5fvgyVSgWr1QqHwwG3241r164hmUzixo0bCAQCuHfvHubn54/7sg4M2vCp1Wq8/PLL6Ovrw4svvoiXX34ZcrkcGo1mz8/jOA56vR5arRZ6vR6Tk5PIZDIYHx9HIpFAsVhEPB5Ho9FAtVo94qs6+QgEAojFYohEIkxNTeH8+fNwu9149dVXodVqAexdw2q1Wrh16xbu3buHcDiMb775holQGo0GrFYrJicnodPpMDExAZVKhVgshmQyCa/Xi6+++gqlUumZv+8TF1w4jgPHcSwdoVKpYLPZYDab0dfXh/7+flgsFnYzgO6Xglarhc1mY7ldHp6ngXZtlUoF+XwepVIJ4XAYfr8fIpEIHMeh1Wohk8mg3W5Dq9VCLBZDr9dDp9NBq9XC5XKh2WxCo9FAJBL1vGSZ5NkCgYA9m1arFX19fXA6nXA4HF2nvb0QiURMMAEAEokEpVIJEokEBoMBKpUK5XIZtVqNP73sgqTxUqmUbbIHBgZw7tw56HQ6AHvf92aziUQigVgshlarBa1WyzYItVoNOp0ONpsNBoMB/f390Gg0kMvlkMvlKBQKXZmhZ+FEBReRSITR0VHY7XYMDg7i8uXLUCqVMJvNbGekVqshl8tZobUToVAInU6HN998E+fOncNvf/tbbG9v84uVZ1/U63Xcv38fkUgEZrMZX331FWq1GlZWVpBOp9lLVq1W49atW1Cr1ZiZmYHb7YbD4cDIyAhUKhWmp6fhcDhY2iefzyMcDvecZJk2elSwp3SgyWTC9773PYyOjsJmsz2ToaNMJoPD4YBWq8XPfvYzTE5OYm5uDh9//DGq1SrrLTrLUDDXarV47bXX4HQ6MTMzg5mZGRYIgEcHdKFQiNHRUajVaqRSKUxPT6NUKiGXy6FSqaCvrw9jY2NQKBSwWCyQSCQYGBhgacsbN24gn88/8/d/ooILx3FwuVyYnJzE5cuX8c4770ChUDzy43ffVIFAAJVKhUuXLqFQKODu3bsQCARnfpHy7I9ms4nt7W14vV52cm61Wkin013pGo7jmGQ5k8lgamoKrVYLIyMjUCgUGBgYgMViwcbGBjY2NhCPxxGLxXoquNAOVyQSwWQywe12Qy6XQ6fTwWw2Y2ZmBmNjY8/sFCyRSGAymaDT6fDiiy9ifHwcAPDll1+iXq+j2Wwe5OX0JBRcVCoVLl68iMnJSYyNjWF8fPyhk+Kj3nFOpxNOpxOlUgljY2Oo1WrIZDIol8uw2WzweDxsE9H5s4xEIhCLxc/1/R9ZcJHJZNBqtZBIJDAajVAoFCz9IBKJoFAoIJPJcPnyZYyPj6O/v58Vq2gXU61WUa1WUS6XkUgk0Gw2oVQqIZVKoVarYTAYIBAIIBKJIBaLoVAooNFoUKvVUC6Xz3yQoaIgpRGFQiEMBgOUSiU7GdJD31mYbTQaKJVKqFQq7GVJdYnTBqnB6vU6yuUyWq3WQy+6drvNFE5erxetVgsCgQBWqxUKhQJarRYqlQp2ux2jo6OQSqVMptwra5BOFrRZGxsbY0IayiB0voyazSZrKI1EIkilUqjX6ygWi5BIJHC5XFCpVNBqtQ/VZjiOY+8AvV4PjuOQyWTOvBhHo9HA6XTCbrfD4/HA5XKx1NbTIhKJoFKpUKvVwHEcqtUq1Gp1V8rzoDmy4KLVajE2Nga9Xo+rV6/CZrMhHo8jGo1CoVDAZrNBrVbj4sWLGBgYgEgkgkQiYYqdZrOJZDKJVCqFSCSCW7duoVwuo6+vD0ajEYODg9BqtRAKhZBIJGg2myynmM/nUavVzoQ89HHQTohejiKRCP39/fB4PCyto9frceXKFZhMJvZ5hUIBoVAIiUQC/+t//S/cvHmTFQV75WW5X6g20mq1WP5/9zXS39Xrddy5cwezs7Pw+/1oNpuw2+148803YTabMTk5CZFIhPv37+POnTs9dc/UajUuXboEm82Gv/qrv8K1a9fY5kQoFD6kCqvVakgkEsjn8/jTn/6EBw8eIJlMIhQKQavV4q/+6q/Q39+PsbGxrsBExWqpVAq9Xg+Px4NkMsnqL2cZm82Gl19+GS6XC5cuXcLQ0NAz10GotkWbJ9pcPm9d5XEcenDhOI7lqR0OB/R6Pex2O6xWK8RiMVOF2Ww2KJVK6HQ6KJVKNJtNVCoVNBoN5HI5VKtVRKNRxGIxRKNRhEIhVKtVdrTufAl0/t6r8sbOnUTng/ioj6WCqUQiAcdxbOctFAohl8tZsBaLxcwbSywWw2azsV92ux16vR4WiwUGg4F9fZlMhmazCZFIBLfbzQJNuVw+tbnxvYLKXh9Dp+lMJoNwOAyO41AqlVCtVlkBVqvVQi6Xs81SL2xyqAVAo9GwX500m02WESiVSiiVSgiFQsjlcggGg4hEIkin04hGo6hWq4jH41CpVHC5XHv+WxKJhKlDad2edeg0R0V2iUTyzF+LNgYA2AZzL8hx4iBO2YcaXAQCATQaDcsZ/t3f/R2MRiNLH9RqNdRqNaaG4DgOCoUCjUYD6XQawWAQuVwOCwsLSCQSWF9fx9bWFtNgy2QyjI6Owul0QqfTQSgUsl1luVxGOp1mhdReyOHSAqATBv1OR9fdeVFCJpPBbDZDJpPB4/HAaDTC5/Nhbm4OUqkUV65cgcVigdFohNFoRKlUQiQSAQBMT0/D6XTCYDDAbrdDKpUyFV7n17darTAYDPiv//W/4j/+x/+Id999F//wD/+AUqmEer1+KgPM0xAIBHDjxg243W709/ejVCpBq9ViamoKxWIRHo8HYrEY4XAYuVzuuL/dJyKRSGCxWNimr5Nms4l0Oo1yuYzbt2/jz3/+M/L5PPx+P4rFImKxGLLZLFPeFQoF3Lp1Czs7O9DpdJiZmenqKdJoNFAoFHA4HOjv74dUKsXm5iay2exxXPqJglL8RzEFs91uIxqNIhqNwu/3P/cm6NCDCxU+rVYrzp07B4PBwHbSe0GBoFQqIR6PI5VKYW1tDcFgEMvLy1hdXWUvMq1Wi3a7zZq3qJ5A7rWVSgXFYrFnZKCUcqBCKv1OBbdHFdiUSiUMBgPUajUGBgbY7nBzcxMymQwDAwPo6+uD3W5naUKqFYyMjMDhcECtVsNkMrFF3BksaBcLgEkfV1dXIZFIWDf6WQ8uhUIBPp8P7XYbsViMnahNJhP773w+j0Qicdzf6r4QCASQyWRQKBQQCoXs5ysQCNBqtVAul5HP57Gzs4M7d+4gk8kgEAigUqk8tJlrtVoIh8OsmEw1Kvp61BitUqmg0+lQLBYPNV3TKxxmPWQv2u02W6O5XO6535uHGlyEQiE8Hg9GR0cxMjICpVIJiUTy0JG30Wgw24ytrS3E43H4/X4sLCywF2E+n0cymUS73YZcLofVaoXRaITL5YLVaoVSqezpGdcCgQA2mw19fX2Qy+VwOp2QyWRMdk1Beq9rlEgkTCxhNpuh1WrhdrsxMjICsViMkZERlm7UaDSoVqvQ6/Vot9uwWCxQq9V7dlbz7B8SARQKBWxsbKDVakGtVsPj8bDieKvVYifGk042m8WXX36J5eVl5PN5RKNR6PV6uN1ulMtlfPHFF/B6vZibm2NBhdLYu19KjUYD8XgcpVIJ6+vrmJ+fZ2uUUj0CgQAGgwHnzp2DUqnE559/fhyXfSZptVosvbu8vIxbt25hc3PzuRtaDzW4cByHgYEBXL16lfUA7PUSq9VqSKVSyOVyuH37Nh48eICtrS3cuXOH5f46c+Ak97TZbHC73bBarUca4Q8aSoU5HA5cu3YNJpOJadkpKCgUChgMhsfu6Drzqp33a69707kT7dX7dpKgRslCoYC1tTXk83kMDQ0BAORyOQsuy8vLx/yd7o90Oo3PP/8cUqkUhUIBkUgEQ0NDUCgUyGaz+OSTT3D//n2WRnlcjarRaCAajUIkEmFlZQVzc3NwOp2st4IwGo04f/48ZDLZQ6lZnsOj1WqhWCyiWCziwYMH+Pjjjw/ETPTQC/ok5dyr5lEqlVAsFpFOp7GysoJMJoOtrS2Ew2Hm59T5eTKZjOX/R0ZGYLVamUKMUmLVahWBQADJZBLpdLon0jV0/DUYDBgcHIRer4fZbIZSqYRKpYJcLodMJoNEInnqQND58VTj2gtKJZIoQCgUMsuJ3R9HP9P9FL3PGlQvFIlEyOfzqNfrEIvFcDgcrA+L0kwn/d7RaSyVSiEQCAAAVCoVisUiotEoa8bbb/qEdsj5fJ7JvDshpSelyUj12Qv10sOisw67+9nv3Eju572w++Pp/VsqleD1epHNZuH3+5HL5Q6kdeNQg0u73UapVEI6nUapVHpoMQUCAaysrMDr9eK9995jvja5XO6hvK1AIIDZbIbT6cTExAT+5m/+hqmcyJKj2WwilUrhww8/xObmJpaWlk78A0xSTLFYjMnJSfz85z9nqTAq4lPwfJYTRqdyLpPJIJlM7vlx1LkrEolgNBohk8lgMBiYdxF9jUqlgmq1yl4qvfCSPEoqlQrztXv11VdRKBSgUqnw2muvIR6P4+bNm1heXmazYE46zWYTq6urCAaDkEql+PDDD9FoNBAKhVAoFJ76xZ/P5xEKhaBUKh8qGJOgh1SjOp0OhULhufytepnHPe+71aRPegb3+vhYLIalpSVEIhHcuHED4XAYPp8PoVBoz/6up+XQgwvNt8jn88hkMuyBarfbSCQSiEQiCIVC8Pl8iMViTMYJfFfgFovFzAbBarXCarUyOTNZINCuiNQqgUCgJ1Q5BBVQNRoNpFIpS391Nj7utUPsXFQkc92r6Y+CSyKR2HMhlkolZLNZSKVSyOVyCIXChx5+mmtCzXJ8YHmYVqvFNlJUgyAX4VarBYVCAbFYzPq3Tjq0QazX6xAKhUgmk+wan0VNRKMK9lo/napI+sVLkg+GztICbdwzmQyi0SjC4TC8Xm9XxuggONTg0mw2sbKygng8jrm5OXz55Zcsx9put5FMJhGPx5HL5RCJRNjDCHxbpJbL5VCpVLhw4QLMZjMmJiYwMTEBo9EIi8XSpToLBoNYWFhAIBDA7Owstre3eyK4kLqtVqthZ2cHX3zxBTQaDSwWC0sDUm/K7h86BRyaL1Kv19kuszN1RScMn88Hv9+/Z0CghWc2m/Hzn/+czS7ppNFoYHt7G6FQCDs7O7xS7BF0znypVqsQCARsR261WuFyuZBOpxGJRHri3lGRvnOj86y7WpFIxEwYd+/M6Z7RWq7X6z2j9DwMHrc2OlNh+1lDlUqFDWmj08rGxgbu37+PXC4Hr9eLYrF4oK7UhxpcWq0WAoEAQqEQO4F03hBaSLt3MNQUKJfLodfrcf78eQwMDOD8+fOYnp7eU5abSqXw4MEDBAIB7OzsIBgMHualHSj0oMbjcSwvLzMll1KpZEad1BS5+/PoF6WqZmdnsbS0xHaInQFoa2vrkUaeYrGYzed488039zyVNJtNRKNRpug76w//o6B7Ry9Jal4lCySTycTmw/RCcDlIV2dq5qWm373+rc51fdbXV+eJY/c7cnfW4nHQFNBMJoO5uTmsra1hc3MT8/PzLNtx0GvxSOxfaIHsPkbv7p4XCoUwm81Qq9VwuVwYHx+HXq9nJxeTycQaCWnxhUIhZLNZ3L9/HwsLC0zy2EtQAAiHw7h79y5UKhW8Xi+kUilzP6WGtM77tTu41Gq1rpNLpyyUNOyPWkBSqRQ6nQ56vZ7Zx8tksq6P6QwuJAvn6YYaghUKBftFu/RWq4V8Ps92kGcBSnVRkZ5qKSRs2P2xUqmUndipofqsTamkdKBCoYDRaGSO1PuFaqPU7JpOpxGPx/HgwQNks1ksLCwgHA4zf8bDcjE59OBC3/R+VB8ikQjDw8MYGhrCCy+8gHfeeQcqlQoikairmbDTWHB2dhbLy8uYn5/HJ598gnK53HMDhyjNsLa2hu3tbTYzgyb4yWQyNBoNpuCgHd/u4EKKL7rPe3liPQqFQgG73d71a/fDX6/Xsbm5iW+++QaRSORMq3geBVkdqdVqNt+FGmLJYTkUCj2VyqpXoSZgsVgMg8EAhULB6qUGg+EhJSJlK5RKJbRaLbRaLVOXnSXopEt9RZQi3y/NZpMp8hYWFrC8vIydnR188sknzBGZ6i6H+QyfCMt9sjCXy+WwWCxwu91siM1eN7Uz5dD5MqXaBL2se+1YTWlCgUDAbHEajQYLLnRy6QwulEZ43iFLdHLR6XRdggL6d8jGo1AoMAnqaYBSsBTMqcZF0FqiIjb5XlHtkAxRKW1BFuk6nY4JI6j/JZ/Ps9Hbpzkwy+VylgZUqVTMSkapVMJut7OTy6PUUHQve9UX8FkgqyeO42AymaDRaGCz2aDT6aBWq/flWEDvgkqlwmrZoVCoy+utUCgcWTr7RAQXpVKJkZERGI1G/PjHP8bLL7/M7N/3gjr6S6US69avVqusQ9rn86FYLLI55r0GKToo/UcWNrsXRKfM+HkfQqvVihdffBFOpxNqtbrr7/L5PDY2NhCNRrGxsYFAIIBqtdpTgXsvqHan1+sxPT0NrVaLiYkJOJ3OLqEE+WjNzc3h/v37UCqVcLvdEAgE8Hq9SCQSqNVqqFQqkMvlmJqagsvlgtvthlgsRiqVwvLyMiKRCCKRyKke/yASiTAyMgKn0wmPx4Pz589DpVLB6XSyoKvT6ZhRZSdk218qlVgwPivOyHS6U6lU+NGPfoRLly7B5XLh3LlzzJ3jSZCfYjwex/vvvw+/34+NjQ3s7OygXC4jl8sd6Yb7RAQXmvFis9nQ39+PkZGRx348vXwbjQabjkfGi/l8Hvl8HgKBANVqFaVS6ZEy3pNM5+7tMCWrtHukcdK7u6aB7xwUEokEstksCoVCz93PvaCUjVKphMPhgMlkwrlz5zA0NMSCS61WQywWQ6FQQCwWw+bmJttVchyHdDqNYrEIgUCAer0OqVQKk8kEm83GdufkChyNRp+pN6RXoDSYwWCA2+3G8PAwLly4wGxwntR1T9mGzqzEaVhnT4J63ai/Z2hoCBcuXIBer4fRaHziqYXeFbVajdX0tra2sLm5Ca/XC7/ff0RX0s2xBhfqwrXZbLh+/TqcTidsNtsTP08kEkGr1UKhUIDjONjtdgwMDGB8fBzVapX1y+zs7MDv9yORSGBpaYnp9c/Cgt0PHMexUbMTExOYnJyEXq9/aPpnuVxmqj8KLL268yajRJFIhPHxcUxNTcFiseDy5cvQ6XRwOBwwGAxsjTSbTRiNRjZzfGZmBjKZDEajEQKBANevX0cul0MsFoPX64VOp8Prr7/OZstTUfXu3bsIhUJIpVLHfAcOFkrl6PV6TE5OQqfT4aWXXsLY2Bjz/qNiPtDdzLd7DdHQMKlUCq1WC71ej0ajgWKxeKTXdJSYzWbWu/fiiy/CZDLh8uXLsFqtkMlkT+zzIZFNJpPB5uYm7t69i0QigQcPHiAejx+rs/SxBhexWMx2zC+88AL6+/thtVqf+HkikYjNl+icO0IRnPovFhYWsLKyguXlZaagOkhZZa/DcRycTif6+/sxOTmJ8fFxNtmzk0qlglAohEAg0POnFgouMpkM09PTeOedd2A2m5lh4l5OCPQSnJ6e7vJko91io9HA5uYm7t27B6VSiVdeeQU2m42ttVQqhbm5Ofj9/lMZXKRSKcxmM1599VU4nU689NJLmJiYeKKrxG45LZ18SCVJTtKnFXIdmZycxNDQEP7Tf/pPsNlsTGG4H0hlGggEcOvWLfzud79jJr/HLWw61uDSabv9KHvpzk7nx8nmyEIF+E7Kp9fr4XQ6Ua1WMTExgWQyiZ2dHaRSKT7I4NuHWavVwmKxQKfTMScE+hlQeiKXy7FBbce9YJ8X2mVrtVrYbDaYzWZ27UKhkG1MKEVDKQu6L7RGKVVBn6fVarucrMm7qVAoMEsjKqaeJmicOLlnUDqwc8e9+3l9VPMfBReqwYpEIqawOwjRynFD4hFKHcrlcoyNjeHcuXNwu93MnfxRc5s6oXQ5+YKRjVahUGAy5OPmRNRciL1e9o1GA+FwGIVCgRX79oLmkUilUhgMBkilUgwNDbHcr9lsRiwWwz//8z/j/v37rG/kLMNxHDweDy5evIj+/n6m8qGFTcowr9d7atI6MpkMExMT6Ovrw8WLFzE1NQWxWAyJRMJeZKSGy+fz4DiOea2RRJTy453zdpxOJ0wmE+tzAYBIJILt7W0sLS1hZ2cH8Xi8J6ZQPg1KpRJms5ndT7fbzWb+dNY6O9V0j5qEyHEc5HI57HY7fvGLXyCfz+NXv/oVEokEisUi68voVWjdaLVavPLKK3C73bhy5QquXr0KuVzOVGH78RCs1+vMnPePf/wjPv74YxSLRTYv5yTcp2MNLp0FayrEZ7PZrptbqVTYbG6yhd4L6l4n08dWqwWJRAK1Wo16vQ6n0wmRSMQkoiTp7eWd0PPQuUvU6/Vst9m5qyyXy0ilUuyFSy6/vQydMsiUk+TCZDeSzWaRSCRQqVSQzWbBcRyazSYbM0u/qtUqU5vR6aZTZde5tk/Cg37Q0FpRKBQwm81snLNare7yTiNlHL00d89z2utUQ3OJaMNIKfBsNrtnt3qvQGUAOjW7XC42wG930f5J19fpAkFFfFrDJ4VjDS7U+Le+vo7/83/+T9f8EqJeryMajaJcLqNcLj/ytNHZeDUzM8OUP1RHGB4ehtFoxPT0NCqVCgKBANbX10/lg/8kxGIxNBoN9Ho9RkdHMTMzA5VK1bXAW60W7t27h08//RQ7OzuIxWIoFos9v/OWSCQYGhrC+fPnmXgkm81idXUV2WwWt2/fxsbGBtsFAt82mFIjJO28qYt8bGwMNpsNg4ODuHDhAmsMFAgEsNvtUCgUaLfbuHTpEsLhMLa3tx/pTN0rcBzHnCPefPNN/OxnP4PRaITdbmf9QgCwvr6Ozz77DAAwODgIjUaDvr4+uN3ux3596iMSCoUYGxvDG2+8gXA4jG+++QaFQgHZbPYhK6RewOl04o033oDFYsErr7wCl8vFhCFP6xVGEnpaZ319fWys+0lJ9x9rcKGmwWg0in/7t39jx8ZO/Xuj0UAmk2HNZ4/SvctkMrYLr9VqcDqdMJvNGBsbg1QqZUaXLpcLkUgEhULhzA7JohNL5w5qd72r1WphZ2cHX3/9NTu5nIaeA5FIBIvFgr6+PjYmu1gswufzIRqN4s6dO5ifn0ehUEA6nUar1epKVVDdhYxVX331VTbxc3p6uqvrnHby6XQa/f39EIlEiEajPR9c6MSiVqsxOTmJt956i11354sxFovh5s2bAL5VNdH8JZfL9cRnj4K5zWbDxMQEZDIZtre3IRQKe1Y9Rj6Jdrsdk5OTsNvtXX//NF5hNJ6g0WgwyTL51Z0UTkTNhfoJqLu+s2hMHadPSi+QBUqhUGBjVy9fvtz1MUKhkMkjI5HIifpBHAWU0nG5XHjjjTfgcDjg8Xi65sVQIxvVHKjW1YtpiE6kUilUKhXMZjP7JRQKkUqlEAwGcfv2bTb6gZr36Jp3z3wHvnOlNZvNGBwcZPWWer2OWCyGSqXChADNZhOTk5MwmUyIRqMoFouoVCo96y8mkUjgdrtht9thNpsfMqMl+f/q6iqSySRTPkkkkn11mhN0f8fGxiASibCxsQG5XI5sNtszKjKhUAiXywWz2Yzz58+zDMrjmiJJUEJCGoFAwJwzFAoFGzMCfGeZlc/n8eDBA4TDYdZQftzP7IkJLqVSCQKBYM8TxX5yrNR0VavVsLS0BLVajddee63ruCkSiVj3dSAQOHOzIsiVd2pqCv/jf/wPuN3uh7T0rVYLmUyG5XGpO/2kHLWfFYVCAafTydIybrcbiUQC4XAYy8vLePfdd+H1evf0ZnuUQ7RQKERfXx9mZmZgNpvBcRwbc5xMJqFWq6FUKiGRSPDKK68gn8+zSX+pVKpn/cWkUimmpqYwNjYGj8fDni/aJM7NzWFubg5erxehUAgajQYCgYAJRvaLQCBAX18fXC4X9Ho9vF4vgsEgAoEAotHoYV3egSISiXDu3DlcvnwZk5OTuHLlCkuz7gXJ22u1Gnw+H27dugWO4zA2Nga9Xt81wwr4NmBfvHgRLpcLMpmMnbrJXeI4ORHBheh8mJ/n88nWe69dUud0x7MEjdi1WCwwmUxQq9UPdUxTETaTySCdTrMC/mmY2UIjH+gXx3FMSELTDverHhSLxTCZTDAYDMz7SSgUIpvNslGxsVgMGo2GdV3TkDAytKxUKmx99lqA2at1oPOUR6PLK5VK11wm8hnbvXmkXiHgO6EA1VyoxkWzcNrtNmw2GxvFWygUTuTa7Eyf6nQ6WK1W6PV6pjjcTafBbyKRQCqVYt31ZGBbqVSgUChgsVi6TtJKpRL1eh1GoxFWqxVSqbTrnh4XJyq4HAQymQz9/f2wWCwwGAx79s30mqHl80ILfWxsDK+++iqGhoYe6sKn+5LL5XDnzh34fD5W5D4N94tkrlRwFggESCaTWF1dhdfrfap6ksViwdtvvw2Hw8Hkt+FwGLdv30YwGMQ///M/w+v1MnfksbEx/PVf/zVkMhk8Hg84jsPi4iJrdOu1EwwFkN0GpmTyGYvFsLW1BZFIhIGBAVitVkxOTmJ0dLRr1w18+zIlU0Xa9MlkMthstq7UEd3zXC4HnU6HtbU1PHjwADdv3jz2l+hekOhBrVZjenoar732GrRa7SP9EimlWCwW8f777+Orr75CPB7H1tYWJBIJlpaWYDAY8NOf/hSDg4Nd/w4p9S5duoRMJoNQKIT33nvv2GdanZrg0jkSWavVwmg0PrSQafGfFc8igmTHOp0OHo8HVqsVIpGoa8fX6agai8UQDAaRyWRORREf6LZ/p1NrtVpFLpdjxqBPgtaYSqViqTXKn9NLMhAIYGtrC1tbW+zlIpPJ2FRUuVzODArJxbvXan+Peo5Ifk0miTRygGYE6fV6AN915tOao45yyjjQ16WUNgkInE4n9Ho9+vr6UKlUEA6HT2wGgoIk/bxtNhukUukjv18a005NkYuLi2w8g0QigVQqZelUStvSyVcmk6HdbsNkMqG/v5+NTD9uej64UBObXq+HzWaDzWbD22+/DY/Hg9HR0a6FXKlUsLy8jNnZWWxubp4JGbJUKoXb7YZGo8GFCxdw8eJFaDSah+wlOu257927h7W1NYTD4WP6rk8WFFRGRkYwMjKCwcFB5gMlk8mQTqexurqKjz76CNFoFKlUivUJtVotrK+v4ze/+Q0UCgULJIlEgqV9ei24iEQimEwmOJ1OaLVa9oxRzTObzSIajcLlcuH111+H2WxmNk10rdVqFYlEArlcDh988AHm5uaYpNtoNMJgMLCJlTS1kk42NH6i0Wiw9NxJ2yyqVCpMTk7CarXC4XAwH8RH/azD4TA++OADdgKmse9UO0kkEmw+yxdffAGj0YixsbGuDIROp8PIyAiEQuFDG+vjoKeDC9kpUA58YmIC/f39+P73v4/h4eGuHyTtytfW1nD79m0kEokTtyAPA7FYzObjTE5OsjHRu8nn8/D5fNja2sL8/DxWVlaO4bs9mdCLbXh4GG+++Sb6+vpw5coVqFQqpFIp5HI5bGxs4LPPPmOpIlI90rArr9cLsViM/v5+GAwG5HK5ng0uHMex3bharWZTNjvtglKpFBQKBa5fv85Oap3XSQaz0WgUn376Kf74xz9icnISL730ElwuF6ampqDT6dgz3hlc6vU665Gj4HLSGisVCgXGxsZYo+STXvbRaBS//e1vsbGxwYIu0Wg0mIXQ8vIydDodBgcH0d/f3xVc1Go1hoaG2Ayo4+bQg4tYLO5SRpAa4nle7LTQxGIxBgcHmf0E7RTIgJAWXD6fRyAQQCKRQCQSYdPYTtJiPCw4joNOp4PZbGb3hWi32yiVSmg0GgiFQlhaWkIgEOhZiezj6HSBIP8wKrBT4b1cLnftlum/TSYT5HI5pqen4fF4mIy5Xq9jZ2cHgUAAXq+Xfd3d64rSSAKBgI2DKBaLTDLaa5scCpzFYpFJtikISKVSjI6OMmdkEjJQACAoCGWzWVSrVbTbbRQKBYTDYYhEInZ/dr87yMm7Wq0imUxCq9Wywv5Jqr2IRCJWYJfJZHtuINrtNtLpNCveZzIZppqVy+VoNpuo1+t7pnQBsJRh5/0nAYXJZILVakWhUDi2vqBDDS6kUCJVkkAgQKPRYDLMZ4WKsxqNBn/5l3+Ja9euwW63Y3BwsGuwDpkP+v1+/OEPf0AoFML9+/eZQ/JZCC4SiQR9fX0YGxuDyWR6qFEykUggnU7j5s2b+Kd/+idkMhnE4/Fj/I4Ph2KxiEAgAIFAgGw2i0qlAplMBrfbjWq1yqScBoOBKelIDXbt2jVmi261WtmJI5/P48aNG/jiiy+YY/SjlHVkBROJRBCLxZhxai/OGqIxAjTnpt1uQygUslEGf/3Xf43XXnsNer0eOp2OnTwAsOumoX7kGwgA8Xgcd+/eRSqVQjQahcViYaOPCYlEgqtXrzI3hOXlZSSTSfh8vhMVXJRKJcbHxzEyMgKz2fzIj1tfX8fXX3+Nzc1N+P1+JJNJVquj2hUFm87RBcB3wQX4NlDRRp6yOACwtraGra2tw73YR3DowUUmk0GtVrPIS30EIpGIFQVpZ7efrlTaHdHCtdlscDqdsFgsXYN1aHdVKpWQTqfZFMDT4I+1HziOg0QiYVJYvV7/0FGZdou0eyIPt5P0kB4UlBatVCooFovshUZOBdSn0inTNplM0Ol0cLlcsNls0Gg0UKlUqNVqyOVy7AUbDoeZqu5xa5ik3r0O9aXlcrmuhmfaVZPjr0wmY532tMOmZ56mJnZuNGmSbC6XQyaTQSaTeUjVSMV9cmLWaDTM5+0kQe++x/W0AGD3AwAzr9Tr9dBoNCgWiywVqNPpWJ8auZjsFgdQsKGx3U/bV3TQHGpw4TgOo6OjmJychMViwfDwMBqNBhtkE4lEEAqFUCqVEAqF2PF4LwQCARwOB5xOJ+x2O1544QUYDAZcvnwZHo+n62bTD4zG0m5tbeHLL79EOp3ueeuN/WK32zE9PQ2Hw4FXXnkFw8PDLIdN1Ot1LC0tYW5uDg8ePGC9Cac1uNBGY3Z2FvV6HR6Ph43k7evrQ7VahVQqZTtA2imazWYWmEulEnw+Hz766COEw2H8+c9/hs/nOxVjn/dLpVLBwsICwuEw3G43Wq0We/bo5U/KqN01pUwmg2QyiQcPHuC9995jIhIAXWrFDz/8EA8ePMDbb7/d1dfRic1mw7Vr1+D3+xEMBk9U1/6jUlm7GRkZgVarRSKRwNDQEEqlEqxWK3Q6HXK5HOLxONv00Eh3i8UClUrFVGJ7pWFPAocaXIRCIcxmM4aHh9Hf34+rV6+iXq9DJpMhFApBqVQym/N4PM7yz4+6OVqtFn19fRgYGMDLL78Mk8kEu90OrVbLPobSDI1GA8FgkA1p2tzc7FlPomdBq9ViZGQELpeLFf+IzoatcDiM9fV1FuRPY2ABvkvHUHpMJpPBarWy+snAwMATv0alUkG5XEYikcCdO3fg9/uxs7ODdDp9BFdwcqjX6wiFQshms0wZ10nnbKVOSEGXTCYRCoWwuLiIUCjE/p5+Rvl8HktLS4hGo5iZmXnk96FSqeDxeNBqtfY9XOuooFNE56ltL0wmE0wmE3K5HJRKJarVKhwOB/R6PbLZLCKRCDiOg8ViYSc2mhcEPH/j+WFyqMGl2WxiZ2eH5actFgtkMhkcDgfMZjMcDgfGx8eRzWaxubnJpJt73SiBQICBgQEMDAzAbDYzpQot4lqthlKpxMYb53I53Lt3D8vLy8yO+iwgk8kgFovhcrlw6dIlWK1WZllO1Go1lnagCZOZTOZELtCDplarYX19Hblcjr0EtVotPB4P5HI522lXKhXkcjnmWFCr1RAIBBAIBOD3+7G+vo50On0qxQ9PolNmHQgEsLi4CK1WC4fDsWeTIPWyVCoVzM7O4vbt29jZ2XnkvaOUNnncUdprd3qJPu55BUKHQTabxddff41QKITr168/cTKnWCyGxWJBo9GARqNh40KoWE/uBo9LsRE0VmKvXr+j5FCDS6PRwNLSEjY2NpBMJuF0OmG1WnHx4kWYzWZ2yigUCvB6vUzC+ajgYjabYTKZ2PS7ziN3uVxGPB5HPB7HJ598gkAggHv37mFhYeHEDM85bMgKgkYMfP/734der39ogZXLZfj9ftYBvL29fSr8w/ZDuVzG3NwcxGIxUyt5PB5oNJquojQZoObzeWxtbSGdTuPOnTu4c+cOm3NzEswBjwN6ZsvlMtbX13Hz5k3W4LhXcGk0GojFYshkMvj888/xm9/8hhmjPurrl8tliMVilEolpuLbnWKjfpeTmJJMJBJ47733YDQaodfrMTY21jXBdDfk2E5QzYayMo8LTLsRi8UwGo3I5/Ndytmj5tClyPQA5nI5RCIRAN9OONRqtRCLxZDJZGi1WtDr9U9UkKnVavaipLpKoVBgDVnBYBDJZBKBQACRSITtPM8KQqGQDViiomrncKbdSh2y3XiUhPY0QkV1SscGg0G0220sLS1Br9ezeks6nUYgEEC5XIbP50Mul0MsFmNF7F6UEB80rVYLuVwOfr+fqfCoViUSiVCr1VAul1EsFhEOh5FMJtlUycfdP2pXKJfLyGQyiMViXTt3siPqPN2ctLXbaDRYL1MqlUI8HmcK171qMLuDR6c7wX4hV/h4PI5UKsVGlRwXhx5cSB3m8/nw8ccfsz6UfD4Pu93OBgw5HI4nPqzUf1CpVJBMJlEqlfDNN99ga2uLHc/L5TIbLnbWUhYikQjnz5/HzMwMZmZmmFqHFmitVkO1WsXGxgb+8R//EX6/H36/n7monhVoTa6trSEYDEIqleL9999n94ok8/TSopnk1DNAQfqs0263ma0+DU1zuVzo6+uDyWRCIpFgUuGbN28iHA5jaWkJpVLpsbVValfI5/OYnZ2FWq3GwMAA3njjDfbuoMJ/KBRCPB4/cTZFtVoNkUgE2WwW9+7dg1KpZKOgSexw0M2zwWAQs7OziEQiTB4fDoePLfAeenChNFepVEIkEmHGdnq9HkqlEkajkSkr6MHePTujcw43NRaRZJG8nHZ2drC6usrmZJyFNFgn5KtmMBjgcrlgMBgeUqrQCzObzWJnZwder/dUF/EfBa3JQqHAJMk+n++Yv6vehE5yKpUKsVgMMpmMjc2meSTxeBw+nw+hUAjpdPqJ641OLmR74vf7IZfLUSwWIRQKmYs1jd4uFosn7nknu6lWq4V4PI5QKASFQoFKpdLl+vy0AWavoEybnWw2i1AohHA4zO77cW6wj8z+pVKpsIt99913cfPmTbjdbvT19UGlUrFOVrPZDI1GA4VCAb1ej3q9zhrUyIo6lUphZWUFuVwOOzs7iMfjyOVyKBQKp8LB92lRKpVs5sWlS5eYTLszv9tut+H3+7G2toaFhQXmUnDWAgvPwUJD+gKBAP7lX/6Fjc9WKpXIZrOIxWIolUrw+/0oFotPJRdut9vY2dlBpVLBgwcPMD8/D4lEwuTykUiEbZBOapai2WxiYWEBqVQKg4ODSCQS0Ov1mJqaYgX33b08u6FAVa/XWV2ZrHbo/UhD71ZXV5kjCZUMjosjCy40ACeTySAajUIoFHY5y05MTDD5rN1uZzbSpNIhG+/t7W1EIhHcvn27y8rjLCOXy9Hf38+szaenp5kMkmi324hEIpibm8Pm5uZDDXA8PM8CuWBQk/Jeg/6elXa7zRR6AHDjxo0D+9pHRbPZxMbGBjY2NuD1elEoFFhDLmVrnhRcSJ1XqVTYBrFWq6FQKKBSqeDevXvw+XwsmJOA6bjvz5EbV5JCjNIS8XicSQ0VCgXS6TT0ej3UajXMZjNqtRo2NzeZ5jsSibCu3rNmnf8oOg08O0cWA98G9VgshmKxyBZ5OBw+U0IHnqPjMF9ox/2yfF6oWbxUKuHmzZvY2dmBUql8yNRzN81mk4kggsEggsEgGo0GM0aNRqNseFqnrdBxcyyuyJQfJVWDUCjEwsICe0mS5QHHcUzdQzskCihkmHcSbuJxQxPvqMel88RSKpVw+/Zt+P1+fPnll/i3f/s31gzIw8NzdJCzMcdxuHnzJju57GcmDQWMRqPBMjW0sa7VaqwccJI228dquU8BA8CxSuZOA7uLg7SzIQltKBRii5s/8fHwHD2d77uz4BbS0/NceB5NOBzG/Pw8IpEI3n//fWxvbyORSDD/Nv7Ex8PDc5jwweUUQUGDmla3traYgmR7e/tMKul4eHiOBz64nAJKpRLW19eZCu/u3buIRCJYW1tDJpNBOp0+MUU+Hh6es4Ggvc83Tq+NYj1MnuUlfdj3j2ouND+jUzVyEmSJnZzE+9dLPOvPkr+H38GvwedjP/ePP7mcEijdddI6lXl4eM4m+z658PDw8PDw7JcnC6x5eHh4eHieEj648PDw8PAcOHxw4eHh4eE5cPjgwsPDw8Nz4PDBhYeHh4fnwOGDCw8PDw/PgcMHFx4eHh6eA4cPLjw8PDw8Bw4fXHh4eHh4Dpz/D1otIm3dTkZTAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X = batch_iterate(25, train_images)\n", + "for x in X: \n", + " show_images(x)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 262, + "metadata": {}, + "outputs": [], + "source": [ + "z_dim = 64\n", + "gen = Generator(z_dim)\n", + "mx.eval(gen.parameters())\n", + "gen_opt = optim.Adam(learning_rate=lr)\n", + "\n", + "disc = Discriminator()\n", + "mx.eval(disc.parameters())\n", + "disc_opt = optim.Adam(learning_rate=lr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training Cycle" + ] + }, + { + "cell_type": "code", + "execution_count": 263, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 7%|▋ | 4/60 [08:34<2:00:03, 128.64s/it]\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[151], line 24\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[1;32m 22\u001b[0m mx\u001b[38;5;241m.\u001b[39meval(disc\u001b[38;5;241m.\u001b[39mparameters(), disc_opt\u001b[38;5;241m.\u001b[39mstate)\n\u001b[0;32m---> 24\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m \u001b[43mG_loss_grad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcur_batch_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mz_dim\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 27\u001b[0m gen_opt\u001b[38;5;241m.\u001b[39mupdate(gen, G_grads)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/utils.py:34\u001b[0m, in \u001b[0;36mvalue_and_grad..wrapped_value_grad_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(fn)\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapped_value_grad_fn\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 34\u001b[0m value, grad \u001b[38;5;241m=\u001b[39m value_grad_fn(\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainable_parameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value, grad\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/base.py:310\u001b[0m, in \u001b[0;36mModule.trainable_parameters\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 307\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtrainable_parameters\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 308\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Recursively return all the non frozen :class:`mlx.core.array` members of\u001b[39;00m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;124;03m this Module as a dict of dicts and lists.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 310\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfilter_and_map\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainable_parameter_filter\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/mlx/nn/layers/base.py:298\u001b[0m, in \u001b[0;36mModule.filter_and_map\u001b[0;34m(self, filter_fn, map_fn, is_leaf_fn)\u001b[0m\n\u001b[1;32m 292\u001b[0m map_fn \u001b[38;5;241m=\u001b[39m map_fn \u001b[38;5;129;01mor\u001b[39;00m (\u001b[38;5;28;01mlambda\u001b[39;00m x: x)\n\u001b[1;32m 293\u001b[0m is_leaf_fn \u001b[38;5;241m=\u001b[39m is_leaf_fn \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m 294\u001b[0m \u001b[38;5;28;01mlambda\u001b[39;00m m, k, v: \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(v, (Module, \u001b[38;5;28mdict\u001b[39m, \u001b[38;5;28mlist\u001b[39m))\n\u001b[1;32m 295\u001b[0m )\n\u001b[1;32m 296\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 297\u001b[0m k: _unwrap(\u001b[38;5;28mself\u001b[39m, k, v, filter_fn, map_fn, is_leaf_fn)\n\u001b[0;32m--> 298\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m filter_fn(\u001b[38;5;28mself\u001b[39m, k, v)\n\u001b[1;32m 300\u001b[0m }\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + " 0%| | 0/200 [00:00 0 and batch_size:\n", - " print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", - " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", - " fake = gen(fake_noise)\n", - " show_images(fake)\n", - " show_images(real)\n", - " cur_step += 1" + " if (cur_step + 1) % display_step == 0:\n", + " print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", + " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", + " fake = gen(fake_noise)\n", + " show_images(fake)\n", + " show_images(real)\n", + " cur_step += 1" ] } ], From 4e80759b3944fa02b7c8c31389e8584f957bf36d Mon Sep 17 00:00:00 2001 From: Shubbair Date: Tue, 30 Jul 2024 02:06:52 +0300 Subject: [PATCH 20/38] Updating GAN Code... --- gan/playground.ipynb | 155 +++++++++++++++++++++---------------------- 1 file changed, 77 insertions(+), 78 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 8500a551..40949f7d 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 244, + "execution_count": 369, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 245, + "execution_count": 370, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 246, + "execution_count": 371, "metadata": {}, "outputs": [], "source": [ @@ -55,20 +55,20 @@ " \n", " return nn.Sequential(\n", " nn.Linear(in_dim,out_dim),\n", - " nn.BatchNorm(out_dim),\n", - " nn.ReLU()\n", + " nn.BatchNorm(out_dim, 0.8),\n", + " nn.LeakyReLU(0.2)\n", " )" ] }, { "cell_type": "code", - "execution_count": 247, + "execution_count": 393, "metadata": {}, "outputs": [], "source": [ "class Generator(nn.Module):\n", "\n", - " def __init__(self, z_dim:int = 10, im_dim:int = 784, hidden_dim: int = 128):\n", + " def __init__(self, z_dim:int = 10, im_dim:int = 784, hidden_dim: int = 256):\n", " super(Generator, self).__init__()\n", " # Build the neural network\n", " self.gen = nn.Sequential(\n", @@ -79,17 +79,16 @@ "\n", "\n", " nn.Linear(hidden_dim * 8,im_dim),\n", - " nn.Sigmoid()\n", " )\n", " \n", " def __call__(self, noise):\n", - "\n", - " return self.gen(noise)" + " x = self.gen(noise)\n", + " return mx.tanh(x)" ] }, { "cell_type": "code", - "execution_count": 248, + "execution_count": 394, "metadata": {}, "outputs": [ { @@ -98,32 +97,31 @@ "Generator(\n", " (gen): Sequential(\n", " (layers.0): Sequential(\n", - " (layers.0): Linear(input_dims=100, output_dims=128, bias=True)\n", - " (layers.1): BatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (layers.2): ReLU()\n", + " (layers.0): Linear(input_dims=100, output_dims=256, bias=True)\n", + " (layers.1): BatchNorm(256, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): LeakyReLU()\n", " )\n", " (layers.1): Sequential(\n", - " (layers.0): Linear(input_dims=128, output_dims=256, bias=True)\n", - " (layers.1): BatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (layers.2): ReLU()\n", + " (layers.0): Linear(input_dims=256, output_dims=512, bias=True)\n", + " (layers.1): BatchNorm(512, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): LeakyReLU()\n", " )\n", " (layers.2): Sequential(\n", - " (layers.0): Linear(input_dims=256, output_dims=512, bias=True)\n", - " (layers.1): BatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (layers.2): ReLU()\n", + " (layers.0): Linear(input_dims=512, output_dims=1024, bias=True)\n", + " (layers.1): BatchNorm(1024, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): LeakyReLU()\n", " )\n", " (layers.3): Sequential(\n", - " (layers.0): Linear(input_dims=512, output_dims=1024, bias=True)\n", - " (layers.1): BatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (layers.2): ReLU()\n", + " (layers.0): Linear(input_dims=1024, output_dims=2048, bias=True)\n", + " (layers.1): BatchNorm(2048, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): LeakyReLU()\n", " )\n", - " (layers.4): Linear(input_dims=1024, output_dims=784, bias=True)\n", - " (layers.5): Sigmoid()\n", + " (layers.4): Linear(input_dims=2048, output_dims=784, bias=True)\n", " )\n", ")" ] }, - "execution_count": 248, + "execution_count": 394, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 249, + "execution_count": 374, "metadata": {}, "outputs": [], "source": [ @@ -146,12 +144,12 @@ }, { "cell_type": "code", - "execution_count": 250, + "execution_count": 375, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -176,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 251, + "execution_count": 376, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 252, + "execution_count": 377, "metadata": {}, "outputs": [], "source": [ @@ -199,11 +197,15 @@ " super(Discriminator, self).__init__()\n", "\n", " self.disc = nn.Sequential(\n", - " DisBlock(im_dim, hidden_dim * 4),\n", - " DisBlock(hidden_dim * 4, hidden_dim * 2),\n", + " # DisBlock(im_dim, hidden_dim * 4),\n", + " # DisBlock(hidden_dim * 4, hidden_dim * 2),\n", + " # DisBlock(hidden_dim * 2, hidden_dim),\n", + " \n", + " DisBlock(im_dim, hidden_dim * 2),\n", " DisBlock(hidden_dim * 2, hidden_dim),\n", "\n", " nn.Linear(hidden_dim,1),\n", + " nn.Sigmoid()\n", " )\n", " \n", " def __call__(self, noise):\n", @@ -212,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 253, + "execution_count": 378, "metadata": {}, "outputs": [ { @@ -221,23 +223,20 @@ "Discriminator(\n", " (disc): Sequential(\n", " (layers.0): Sequential(\n", - " (layers.0): Linear(input_dims=784, output_dims=512, bias=True)\n", + " (layers.0): Linear(input_dims=784, output_dims=256, bias=True)\n", " (layers.1): LeakyReLU()\n", " )\n", " (layers.1): Sequential(\n", - " (layers.0): Linear(input_dims=512, output_dims=256, bias=True)\n", - " (layers.1): LeakyReLU()\n", - " )\n", - " (layers.2): Sequential(\n", " (layers.0): Linear(input_dims=256, output_dims=128, bias=True)\n", " (layers.1): LeakyReLU()\n", " )\n", - " (layers.3): Linear(input_dims=128, output_dims=1, bias=True)\n", + " (layers.2): Linear(input_dims=128, output_dims=1, bias=True)\n", + " (layers.3): Sigmoid()\n", " )\n", ")" ] }, - "execution_count": 253, + "execution_count": 378, "metadata": {}, "output_type": "execute_result" } @@ -270,7 +269,7 @@ }, { "cell_type": "code", - "execution_count": 254, + "execution_count": 379, "metadata": {}, "outputs": [], "source": [ @@ -283,14 +282,14 @@ " \n", " fake_labels = mx.zeros((fake_images.shape[0],1))\n", " \n", - " fake_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", + " fake_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels)\n", " \n", " real_disc = disc(real)\n", " real_labels = mx.ones((real.shape[0],1))\n", "\n", - " real_loss = nn.losses.binary_cross_entropy(real_disc,real_labels,with_logits=True)\n", + " real_loss = nn.losses.binary_cross_entropy(real_disc,real_labels)\n", "\n", - " disc_loss = (fake_loss + real_loss) / 2.0\n", + " disc_loss = (fake_loss + real_loss) / 2\n", "\n", " return disc_loss" ] @@ -304,26 +303,27 @@ }, { "cell_type": "code", - "execution_count": 255, + "execution_count": 380, "metadata": {}, "outputs": [], "source": [ "def gen_loss(gen, disc, num_images, z_dim):\n", "\n", " noise = mx.array(get_noise(num_images, z_dim))\n", + " \n", " fake_images = gen(noise)\n", " fake_disc = disc(fake_images)\n", "\n", " fake_labels = mx.ones((fake_images.shape[0],1))\n", " \n", - " gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", + " gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels)\n", "\n", " return gen_loss" ] }, { "cell_type": "code", - "execution_count": 256, + "execution_count": 381, "metadata": {}, "outputs": [], "source": [ @@ -333,7 +333,7 @@ }, { "cell_type": "code", - "execution_count": 257, + "execution_count": 382, "metadata": {}, "outputs": [], "source": [ @@ -343,16 +343,16 @@ }, { "cell_type": "code", - "execution_count": 258, + "execution_count": 383, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 258, + "execution_count": 383, "metadata": {}, "output_type": "execute_result" }, @@ -373,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 259, + "execution_count": 384, "metadata": {}, "outputs": [], "source": [ @@ -386,7 +386,7 @@ }, { "cell_type": "code", - "execution_count": 260, + "execution_count": 385, "metadata": {}, "outputs": [], "source": [ @@ -410,12 +410,12 @@ }, { "cell_type": "code", - "execution_count": 261, + "execution_count": 386, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -431,22 +431,6 @@ " break" ] }, - { - "cell_type": "code", - "execution_count": 262, - "metadata": {}, - "outputs": [], - "source": [ - "z_dim = 64\n", - "gen = Generator(z_dim)\n", - "mx.eval(gen.parameters())\n", - "gen_opt = optim.Adam(learning_rate=lr)\n", - "\n", - "disc = Discriminator()\n", - "mx.eval(disc.parameters())\n", - "disc_opt = optim.Adam(learning_rate=lr)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -456,26 +440,41 @@ }, { "cell_type": "code", - "execution_count": 263, + "execution_count": 391, + "metadata": {}, + "outputs": [], + "source": [ + "lr = 0.002\n", + "z_dim = 100\n", + "\n", + "gen = Generator(z_dim)\n", + "mx.eval(gen.parameters())\n", + "gen_opt = optim.Adam(learning_rate=lr,betas=[0.5, 0.999])\n", + "\n", + "disc = Discriminator()\n", + "mx.eval(disc.parameters())\n", + "disc_opt = optim.Adam(learning_rate=lr,betas=[0.5, 0.999])" + ] + }, + { + "cell_type": "code", + "execution_count": 395, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 0/200 [00:00 Date: Tue, 30 Jul 2024 02:17:12 +0300 Subject: [PATCH 21/38] Updating GAN Code... --- gan/playground.ipynb | 71 +++++++++++++++++++++++++------------------- 1 file changed, 40 insertions(+), 31 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 40949f7d..5088ec21 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 369, + "execution_count": 427, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 370, + "execution_count": 428, "metadata": {}, "outputs": [], "source": [ @@ -31,6 +31,15 @@ "import matplotlib.pyplot as plt" ] }, + { + "cell_type": "code", + "execution_count": 429, + "metadata": {}, + "outputs": [], + "source": [ + "# mx.set_default_device(mx.gpu)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -47,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 371, + "execution_count": 430, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 393, + "execution_count": 431, "metadata": {}, "outputs": [], "source": [ @@ -88,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 394, + "execution_count": 432, "metadata": {}, "outputs": [ { @@ -121,7 +130,7 @@ ")" ] }, - "execution_count": 394, + "execution_count": 432, "metadata": {}, "output_type": "execute_result" } @@ -133,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 374, + "execution_count": 433, "metadata": {}, "outputs": [], "source": [ @@ -144,12 +153,12 @@ }, { "cell_type": "code", - "execution_count": 375, + "execution_count": 434, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAWL0lEQVR4nO3cXWzW9d3H8U+hVChQO7oWWgq1lDKFOmdpwWnBhmWEqYiLDoWNwJI9xEGyGN2WbOMAs5EsJtPEZZlb5qYOlFVlM50PgEp5cD4AhVVKiSJQpUBhFKEtZVCv++ybmPug1+d34H1neb+Or/d1QR/48D/55mQymYwAAJA07P/6DwAA+P+DUQAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEDIzfaFP/zhD+03f+CBB+wm5XMkqa6uzm5KSkrspr293W7uueceu3nppZfsRpJ27txpNw0NDXZz/fXX283evXvtRpJmzJhhN4cPH7abffv22c2sWbPsprCw0G4kqaWlxW6mTJliN83NzXZz7bXX2s3UqVPtRpI+/PBDu7npppvs5uzZs3bT3d1tN5LU0dFhNym/g/fff/+Qr+FJAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEBgFAAAgVEAAIScTCaTyeaFS5cutd+8rKzMbsrLy+1Gkrq6uuwm5WhayhGvqqoqu0k9rNXa2mo3RUVFdnPu3Dm7GTt2rN1I0sDAgN1MnjzZbmbOnGk369ats5vBwUG7kaS7777bbjo7O+1m2rRpdtPU1GQ3Kb+zklRfX283X/va1+zmr3/9q928//77diNJEydOtJuUQ5HZHCnlSQEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAACE3GxfOHv2bPvNf/KTn9jNz372M7uRpOPHj9tNT0+P3Zw5c8Zuzp49azelpaV2I0kjR460m5ycHLsZNsz//8SpU6fsRpKuuuoqu3n22Wft5uOPP7ab6667zm727t1rN5K0ceNGuykoKLCbLVu22E3Kz8OECRPsRpJKSkrspr+/327y8vLsZu7cuXYjSaNGjbKbY8eOJX3WUHhSAAAERgEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAACErK+kvvrqq/ab//znP7ebwsJCu5GkO++8025SrlXecMMNdvPkk0/aTSaTsRsp7fJkytcu5ZLmm2++aTdS2s9ETU2N3Zw7d85uUv5sKddYJWnhwoV2M3HiRLtpamqym4qKCrs5evSo3UjSJ598Yje7du2ym5TvbcrnSNL8+fPtZt68eUmfNRSeFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEDIyWR5ee2ZZ56x37yqqspuHn74YbuRpNmzZ9vNvn377CY3N+sbgmHUqFF2MzAwYDdS2hGvixcv2s3UqVPtprOz024k6cSJE3bzxS9+0W52795tN0VFRXZTWVlpN5J04MABu8nPz7eblINzK1assJuWlha7kaRjx47ZTcrfqa6uzm5Sf297e3vt5oknnrCb1tbWIV/DkwIAIDAKAIDAKAAAAqMAAAiMAgAgMAoAgMAoAAACowAACIwCACAwCgCAwCgAAAKjAAAIWV93O3XqlP3mmzZtsptp06bZjSTV1NTYzenTp+3m8OHDdjNlyhS7+cIXvmA3krR27Vq7WbRokd2cOXPGbi5fvmw3kjR+/Hi76e/vt5srr7zSburr6+3m6NGjdpPa3XbbbXYzZswYu9m/f7/dpP48pPzspXztUv58OTk5diNJ06dPt5sf//jHSZ81FJ4UAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQMj6IF7KEari4mK72bZtm91I0owZM+zm5MmTdjNhwgS7aW9vt5uLFy/ajSStXr3abnbv3m03Kd/blMOAkvTGG2/Yzc0332w311xzjd2kHH3s6emxGyntMODAwIDdnDhxwm4+/vjjz+RzJKm2ttZuPve5z9nN8uXL7eaJJ56wG0l6++237Wbv3r12s2TJkiFfw5MCACAwCgCAwCgAAAKjAAAIjAIAIDAKAIDAKAAAAqMAAAiMAgAgMAoAgMAoAAACowAACFkfxNu1a5f95jU1NXZTUVFhN5L0wgsv2M2PfvQju3nzzTftprS01G4mT55sN5K0ceNGu5k7d67dnD9/3m5SDnhJ0iuvvGI3/f39drNs2TK72bp1q92sXLnSbiRp+PDhdlNdXW03nZ2ddpOfn283b731lt1IUm5u1v9shXnz5tlNb2+v3cycOdNuJOngwYOf2WcNhScFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEDIyWQymWxe+Jvf/MZ+8+7ubru5dOmS3UhpFxfnz59vN++++67d3H777XZz33332Y0k/fKXv7SblMuvPT09dlNbW2s3ktTR0WE3o0aNspuUy6/19fV2M3LkSLuRpP/85z92k3Ld+O6777ablCufKVdIJempp56ym4KCArtZunSp3bz33nt2I0llZWV2U1RUZDf33nvvkK/hSQEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAACErA/ibd++3X7zlINX//znP+1GSjuaNmvWLLtZsGCB3Tz33HN2s2jRIruRpI0bN9rNmDFj7GbatGl289vf/tZuJKmystJudu7caTdf//rX7aa8vNxu2tra7EaSSktL7Wb06NF2c+HCBbtJOZDY2dlpN5I0fvx4u0k5kJjy71dfX5/dSNKePXvsJuX3dseOHUO+hicFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAELI+iPerX/3KfvPi4mK7STnyJEmbNm2ym5QjWVl+uT4l5UhWSUmJ3UjSe++9Zzcp36eUQ3B5eXl2I0nV1dV209XVZTcpP0Pz58+3m/z8fLuRpJaWFrv57ne/azfr16+3m7vuustu1q5dazeSNGfOHLtZvHix3SxZssRubr75ZruR0o4xPvLII3bzt7/9bcjX8KQAAAiMAgAgMAoAgMAoAAACowAACIwCACAwCgCAwCgAAAKjAAAIjAIAIDAKAIDAKAAAQtYH8Z588kn7zYcN8zenvb3dbiTp8uXLdjNlyhS7STkE19nZaTePPvqo3UhpR8ZycnLsJuV4XMqROkm6cOGC3SxYsMBuzp07ZzcTJ060m97eXruRpJ6eHrs5efLkZ/I548aNs5vx48fbjSQ9++yzdjNixAi7mTRpkt3U1NTYjZR2JLGtrc1uNmzYMORreFIAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEBgFAAAgVEAAITcbF946NAh+83r6+vtpq+vz25SPyvlwmVTU5PdVFZW2s1XvvIVu5Gkd955x25SrkF++ctftpudO3fajSRlecj3U8aOHWs3U6dOtZuUi51FRUV2I0mtra12s2bNGrt59dVX7aalpcVuFi1aZDeS1NjYaDcvvPCC3RQXF9tNbm7W/6R+Ssp16JTrwdngSQEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAACEnEyW18ZSDqD19PTYzY033mg3klRRUWE3Z8+etZu8vDy7STnyd/78ebuRpA8++MBu5syZYzcffvih3aQcqZOkuXPn2s0//vEPu5kyZYrdtLW12c0PfvADu5HS/k5dXV12U1BQYDeDg4N2U1ZWZjeSNHLkSLuprq62m46ODrt544037EaSFi9ebDcpByYff/zxIV/DkwIAIDAKAIDAKAAAAqMAAAiMAgAgMAoAgMAoAAACowAACIwCACAwCgCAwCgAAAKjAAAIWR/EW758uf3m9913n928/vrrdiNJx48ft5ucnBy7eeedd+xm1qxZdnPs2DG7kaQRI0bYzfTp0+2mvLzcblKOs0nSiRMn7CblANrAwIDdpByP2717t91I0sWLF+1m2rRpdnP69Gm72b59u93U1tbajSRVVVXZTXNzs92UlpbaTUNDg91I0vr16+2mvr7ebh566KEhX8OTAgAgMAoAgMAoAAACowAACIwCACAwCgCAwCgAAAKjAAAIjAIAIDAKAIDAKAAAAqMAAAhZH8Rbs2aN/eYlJSV2093dbTeStH//fru59tpr7aampsZuNm/ebDeVlZV2I6UdBhwcHLSbbdu22c2dd95pN5I0adIku2lqarKbpUuX2s2ZM2fspq+vz24kqa2tzW7mzp1rN1u2bLGbVatW2c2OHTvsRpI+//nP203Kvyv5+fl2k+U/p/9Lyt+ps7PTblavXj3ka3hSAAAERgEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAACE32xeWlpbabz4wMGA35eXldiOlHZBrbm62mzlz5tjN7bffbjcXLlywG0kaM2aM3RQWFtpNyvepqKjIbqS0A3IpR/Ta29vtZsGCBXaTcthOkg4fPmw33//+9+0m5fv0zDPP2E1eXp7dSNJjjz1mN62trXbz0EMP2U1FRYXdSGnf29TjoUPhSQEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAELK+kppyOfGll16ym/7+fruRpEuXLtnNxYsX7Wb79u12c++999pNytdOkjo6Ouzmtddes5uf/vSndrN37167kaRvfvObdvPyyy/bzZe+9CW7Sfl56OzstBtJGjt2rN28+OKLdnPFFVfYzfnz5+0m9WruqlWr7Obvf/+73ZSVldnNn/70J7uRpIULF9pNY2Nj0mcNhScFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAELI+iHfgwAH7zVOO29XW1tqNJI0YMcJuMpmM3WzatMluWltb7SY3N+tvzafcdddddlNdXW03Dz74oN2kHLaTpHXr1tnNsmXL7ObUqVN2k3II7jvf+Y7dSGlHEk+fPm03dXV1dpNy9HHlypV2I0njxo2zm7feestuUg4X5uXl2Y0klZaW2k13d3fSZw2FJwUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEBgFAAAgVEAAARGAQAQsr66tnXrVvvNFy9ebDcPP/yw3UjS/fffbzfPP/+83RQXF9tNWVmZ3RQWFtqNJB06dMhujh49ajc33HCD3bS3t9uNlPY137Bhg92kHGPcvHmz3RQUFNiNlHYk8bM6+nj27Fm7STlSJ0mNjY12M2yY///f+vp6u3nkkUfsRkr783V1dSV91lB4UgAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQGAUAAAhJ5Plxaxf/OIX9puPGzfObrq7u+0mVcqRv4aGBrv56KOP7KakpMRuJGnixIl2k3KYbPny5Xazc+dOu5GkG2+80W5ycnLspq2tzW7y8/PtJuXnTpKuuuoqu0k5XJhylHLNmjV2c/DgQbuRpOHDh9tNyu9gSjNhwgS7kdIO4qV8/Zqamob+s9jvCgD4r8UoAAACowAACIwCACAwCgCAwCgAAAKjAAAIjAIAIDAKAIDAKAAAAqMAAAiMAgAg5Gb7wpSjaRUVFXZz22232Y0kNTc32011dbXdDAwM2E1NTY3d7N69224k6f3337ebRYsW2U3KIbgxY8bYjSSdOHHCblKOx40ePdpurrjiCrtJPZq2ePFiu0k5HpfyOR988IHd9PX12Y0k7dmzx24eeOABu/n1r39tNyk/q5JUVlZmN9ddd13SZw2FJwUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQMj6Suq3v/1t+827u7vt5umnn7YbSfrqV79qN8ePH7ebjz76yG727dtnNyUlJXYjSdOnT7ebmTNn2s3GjRvtZtSoUXYjSV1dXXZz9dVX282hQ4fsJuUa6ze+8Q27kaRt27bZzZYtW+ymoaHBbtavX283qV+HFStW2E17e7vdpPzeLly40G4kacSIEXaTyWSSPmsoPCkAAAKjAAAIjAIAIDAKAIDAKAAAAqMAAAiMAgAgMAoAgMAoAAACowAACIwCACAwCgCAkPVBvL/85S/2m8+YMcNuioqK7EaSiouL7SblyN+tt95qN3V1dXazbt06u5GkyspKu+no6LCbU6dO2U1eXp7dSFJZWZnd9PX12c2ePXvs5o477rCbzZs3240kHTlyxG5SfvaGDx9uNytXrrSblpYWu5Gk5uZmu6moqLCbxsZGu0k5bCdJg4ODdpPye5ENnhQAAIFRAAAERgEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAyPog3pw5c+w3z8/Pt5vXXnvNbiTpe9/7nt08+OCDdpNyWKu0tNRuent77UZK+5qnHECbPHmy3aQeC3vllVfsprW11W5SjtulHBNMOdYnSStWrLCbf//733aT8ud78cUX7aaqqspuJOn666+3m2HD/P//Hjp0yG4uXbpkN5J0+fJlu/nkk0+SPmsoPCkAAAKjAAAIjAIAIDAKAIDAKAAAAqMAAAiMAgAgMAoAgMAoAAACowAACIwCACAwCgCAkPVBvHnz5tlv/txzz9lNUVGR3UjSo48+ajd//vOf7ebo0aN2k3K4qra21m6ktGNmjY2NdnP48GG7uXDhgt1I0re+9S272bFjh93k5mb96xCef/55u1m2bJndSNK6devs5o9//KPdpByKbGhosJuU75EkTZo0yW7Ky8vt5sCBA3Zz00032Y0kHTlyxG5SDysOhScFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAABEYBABAYBQBAYBQAAIFRAAAERgEAEBgFAEDI+izk66+/br95yiXNd999126ktIuGhYWFdvO73/3Obqqqquwm5aqjJO3fv99upk6dajcpf74VK1bYjSS9/fbbdvOvf/3Lbq6++mq7GRwctJtrrrnGbiRp9erVdrNkyRK72bBhg93ccsstdpP6daisrLSbxx57zG5mz55tN3V1dXYjSb29vXaza9eupM8aCk8KAIDAKAAAAqMAAAiMAgAgMAoAgMAoAAACowAACIwCACAwCgCAwCgAAAKjAAAIjAIAIORkMplMNi9cu3at/ebjxo2zm46ODruRpP7+frs5cuSI3YwePdpuVq5caTdjx461G0l6/PHH7Sbl75RyRG/kyJF2I6UdFKyoqLCb3//+93bz9NNP203KkTpJKigosJuTJ0/aTU1Njd2kHJf8wx/+YDeSVFpaajcpX4d77rnHbrZu3Wo3knTw4EG7Sfk5WrVq1ZCv4UkBABAYBQBAYBQAAIFRAAAERgEAEBgFAEBgFAAAgVEAAARGAQAQGAUAQGAUAACBUQAAhKwP4gEA/vvxpAAACIwCACAwCgCAwCgAAAKjAAAIjAIAIDAKAIDAKAAAAqMAAAj/AyUT0oK8p4s5AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -174,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 376, + "execution_count": 435, "metadata": {}, "outputs": [], "source": [ @@ -187,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 377, + "execution_count": 436, "metadata": {}, "outputs": [], "source": [ @@ -214,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 378, + "execution_count": 437, "metadata": {}, "outputs": [ { @@ -236,7 +245,7 @@ ")" ] }, - "execution_count": 378, + "execution_count": 437, "metadata": {}, "output_type": "execute_result" } @@ -269,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": 379, + "execution_count": 438, "metadata": {}, "outputs": [], "source": [ @@ -303,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": 380, + "execution_count": 439, "metadata": {}, "outputs": [], "source": [ @@ -323,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 381, + "execution_count": 440, "metadata": {}, "outputs": [], "source": [ @@ -333,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 382, + "execution_count": 441, "metadata": {}, "outputs": [], "source": [ @@ -343,16 +352,16 @@ }, { "cell_type": "code", - "execution_count": 383, + "execution_count": 442, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 383, + "execution_count": 442, "metadata": {}, "output_type": "execute_result" }, @@ -373,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 384, + "execution_count": 443, "metadata": {}, "outputs": [], "source": [ @@ -386,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": 385, + "execution_count": 444, "metadata": {}, "outputs": [], "source": [ @@ -410,12 +419,12 @@ }, { "cell_type": "code", - "execution_count": 386, + "execution_count": 445, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -440,32 +449,32 @@ }, { "cell_type": "code", - "execution_count": 391, + "execution_count": 446, "metadata": {}, "outputs": [], "source": [ - "lr = 0.002\n", - "z_dim = 100\n", + "lr = 2e-4\n", + "z_dim = 64\n", "\n", "gen = Generator(z_dim)\n", "mx.eval(gen.parameters())\n", - "gen_opt = optim.Adam(learning_rate=lr,betas=[0.5, 0.999])\n", + "gen_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999]) #,betas=[0.5, 0.9]\n", "\n", "disc = Discriminator()\n", "mx.eval(disc.parameters())\n", - "disc_opt = optim.Adam(learning_rate=lr,betas=[0.5, 0.999])" + "disc_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999])" ] }, { "cell_type": "code", - "execution_count": 395, + "execution_count": 447, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 4%|▍ | 9/200 [00:59<21:10, 6.65s/it]" + " 0%| | 0/200 [00:00 Date: Tue, 30 Jul 2024 02:37:09 +0300 Subject: [PATCH 22/38] Updating GAN Code... --- gan/playground.ipynb | 114 +++++++++++++++++++++++-------------------- 1 file changed, 60 insertions(+), 54 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 5088ec21..3d78894b 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 427, + "execution_count": 573, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 428, + "execution_count": 574, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 429, + "execution_count": 575, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 430, + "execution_count": 576, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 431, + "execution_count": 577, "metadata": {}, "outputs": [], "source": [ @@ -97,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 432, + "execution_count": 578, "metadata": {}, "outputs": [ { @@ -130,7 +130,7 @@ ")" ] }, - "execution_count": 432, + "execution_count": 578, "metadata": {}, "output_type": "execute_result" } @@ -142,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 433, + "execution_count": 579, "metadata": {}, "outputs": [], "source": [ @@ -153,12 +153,12 @@ }, { "cell_type": "code", - "execution_count": 434, + "execution_count": 580, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -183,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 435, + "execution_count": 581, "metadata": {}, "outputs": [], "source": [ @@ -196,34 +196,35 @@ }, { "cell_type": "code", - "execution_count": 436, + "execution_count": 582, "metadata": {}, "outputs": [], "source": [ "class Discriminator(nn.Module):\n", "\n", - " def __init__(self,im_dim:int = 784, hidden_dim:int = 128):\n", + " def __init__(self,im_dim:int = 784, hidden_dim:int = 256):\n", " super(Discriminator, self).__init__()\n", "\n", " self.disc = nn.Sequential(\n", - " # DisBlock(im_dim, hidden_dim * 4),\n", - " # DisBlock(hidden_dim * 4, hidden_dim * 2),\n", - " # DisBlock(hidden_dim * 2, hidden_dim),\n", - " \n", - " DisBlock(im_dim, hidden_dim * 2),\n", + " DisBlock(im_dim, hidden_dim * 4),\n", + " DisBlock(hidden_dim * 4, hidden_dim * 2),\n", " DisBlock(hidden_dim * 2, hidden_dim),\n", - "\n", + " \n", + " nn.Dropout(0.3),\n", " nn.Linear(hidden_dim,1),\n", - " nn.Sigmoid()\n", + " # nn.Sigmoid()\n", " )\n", " \n", " def __call__(self, noise):\n", - " return self.disc(noise)" + " x = noise + 1.0\n", + " x = self.disc(noise)\n", + " out = mx.log(mx.softmax(x)) \n", + " return out" ] }, { "cell_type": "code", - "execution_count": 437, + "execution_count": 583, "metadata": {}, "outputs": [ { @@ -232,20 +233,24 @@ "Discriminator(\n", " (disc): Sequential(\n", " (layers.0): Sequential(\n", - " (layers.0): Linear(input_dims=784, output_dims=256, bias=True)\n", + " (layers.0): Linear(input_dims=784, output_dims=1024, bias=True)\n", " (layers.1): LeakyReLU()\n", " )\n", " (layers.1): Sequential(\n", - " (layers.0): Linear(input_dims=256, output_dims=128, bias=True)\n", + " (layers.0): Linear(input_dims=1024, output_dims=512, bias=True)\n", " (layers.1): LeakyReLU()\n", " )\n", - " (layers.2): Linear(input_dims=128, output_dims=1, bias=True)\n", - " (layers.3): Sigmoid()\n", + " (layers.2): Sequential(\n", + " (layers.0): Linear(input_dims=512, output_dims=256, bias=True)\n", + " (layers.1): LeakyReLU()\n", + " )\n", + " (layers.3): Dropout(p=0.30000000000000004)\n", + " (layers.4): Linear(input_dims=256, output_dims=1, bias=True)\n", " )\n", ")" ] }, - "execution_count": 437, + "execution_count": 583, "metadata": {}, "output_type": "execute_result" } @@ -278,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 438, + "execution_count": 584, "metadata": {}, "outputs": [], "source": [ @@ -312,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": 439, + "execution_count": 585, "metadata": {}, "outputs": [], "source": [ @@ -332,7 +337,7 @@ }, { "cell_type": "code", - "execution_count": 440, + "execution_count": 586, "metadata": {}, "outputs": [], "source": [ @@ -342,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 441, + "execution_count": 587, "metadata": {}, "outputs": [], "source": [ @@ -352,16 +357,16 @@ }, { "cell_type": "code", - "execution_count": 442, + "execution_count": 588, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 442, + "execution_count": 588, "metadata": {}, "output_type": "execute_result" }, @@ -382,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 443, + "execution_count": 589, "metadata": {}, "outputs": [], "source": [ @@ -395,7 +400,7 @@ }, { "cell_type": "code", - "execution_count": 444, + "execution_count": 590, "metadata": {}, "outputs": [], "source": [ @@ -419,12 +424,12 @@ }, { "cell_type": "code", - "execution_count": 445, + "execution_count": 591, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -449,25 +454,25 @@ }, { "cell_type": "code", - "execution_count": 446, + "execution_count": 592, "metadata": {}, "outputs": [], "source": [ - "lr = 2e-4\n", + "lr = 2e-8\n", "z_dim = 64\n", "\n", "gen = Generator(z_dim)\n", "mx.eval(gen.parameters())\n", - "gen_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999]) #,betas=[0.5, 0.9]\n", + "gen_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.9]) #,betas=[0.5, 0.9]\n", "\n", "disc = Discriminator()\n", "mx.eval(disc.parameters())\n", - "disc_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999])" + "disc_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.9])" ] }, { "cell_type": "code", - "execution_count": 447, + "execution_count": 593, "metadata": {}, "outputs": [ { @@ -484,7 +489,7 @@ "display_step = 5000\n", "cur_step = 0\n", "\n", - "batch_size = 128\n", + "batch_size = 64\n", "\n", "D_loss_grad = nn.value_and_grad(disc, disc_loss)\n", "G_loss_grad = nn.value_and_grad(gen, gen_loss)\n", @@ -510,16 +515,17 @@ " gen_opt.update(gen, G_grads)\n", " \n", " # Update gradients\n", - " mx.eval(gen.parameters(), gen_opt.state)\n", - " \n", - " \n", - " if (cur_step + 1) % display_step == 0:\n", - " print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", - " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", - " fake = gen(fake_noise)\n", - " show_images(fake)\n", - " show_images(real)\n", - " cur_step += 1" + " mx.eval(gen.parameters(), gen_opt.state) \n", + " \n", + " print('Losses D={0} G={1}'.format(D_loss,G_loss))\n", + " \n", + " if (cur_step + 1) % display_step == 0:\n", + " print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", + " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", + " fake = gen(fake_noise)\n", + " show_images(fake)\n", + " show_images(real)\n", + " cur_step += 1" ] } ], From 7438b54ecd1ac81483dbffa25e0b7fa066d94e7a Mon Sep 17 00:00:00 2001 From: Shubbair Date: Tue, 30 Jul 2024 02:44:41 +0300 Subject: [PATCH 23/38] Updating GAN Code... --- gan/playground.ipynb | 482 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 439 insertions(+), 43 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 3d78894b..168fbd2e 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 573, + "execution_count": 657, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 574, + "execution_count": 658, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 575, + "execution_count": 659, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 576, + "execution_count": 660, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 577, + "execution_count": 661, "metadata": {}, "outputs": [], "source": [ @@ -97,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 578, + "execution_count": 662, "metadata": {}, "outputs": [ { @@ -130,7 +130,7 @@ ")" ] }, - "execution_count": 578, + "execution_count": 662, "metadata": {}, "output_type": "execute_result" } @@ -142,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 579, + "execution_count": 663, "metadata": {}, "outputs": [], "source": [ @@ -153,12 +153,12 @@ }, { "cell_type": "code", - "execution_count": 580, + "execution_count": 664, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -183,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 581, + "execution_count": 665, "metadata": {}, "outputs": [], "source": [ @@ -196,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 582, + "execution_count": 666, "metadata": {}, "outputs": [], "source": [ @@ -224,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 583, + "execution_count": 667, "metadata": {}, "outputs": [ { @@ -250,7 +250,7 @@ ")" ] }, - "execution_count": 583, + "execution_count": 667, "metadata": {}, "output_type": "execute_result" } @@ -283,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 584, + "execution_count": 668, "metadata": {}, "outputs": [], "source": [ @@ -317,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": 585, + "execution_count": 669, "metadata": {}, "outputs": [], "source": [ @@ -337,7 +337,7 @@ }, { "cell_type": "code", - "execution_count": 586, + "execution_count": 670, "metadata": {}, "outputs": [], "source": [ @@ -347,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 587, + "execution_count": 671, "metadata": {}, "outputs": [], "source": [ @@ -357,16 +357,16 @@ }, { "cell_type": "code", - "execution_count": 588, + "execution_count": 672, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 588, + "execution_count": 672, "metadata": {}, "output_type": "execute_result" }, @@ -387,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 589, + "execution_count": 673, "metadata": {}, "outputs": [], "source": [ @@ -400,7 +400,7 @@ }, { "cell_type": "code", - "execution_count": 590, + "execution_count": 674, "metadata": {}, "outputs": [], "source": [ @@ -424,12 +424,12 @@ }, { "cell_type": "code", - "execution_count": 591, + "execution_count": 675, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -454,32 +454,428 @@ }, { "cell_type": "code", - "execution_count": 592, + "execution_count": 676, "metadata": {}, "outputs": [], "source": [ - "lr = 2e-8\n", - "z_dim = 64\n", + "lr = 1e-4\n", + "z_dim = 128\n", "\n", "gen = Generator(z_dim)\n", "mx.eval(gen.parameters())\n", - "gen_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.9]) #,betas=[0.5, 0.9]\n", + "gen_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999]) #,betas=[0.5, 0.9]\n", "\n", "disc = Discriminator()\n", "mx.eval(disc.parameters())\n", - "disc_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.9])" + "disc_opt = optim.Adam(learning_rate=lr, betas=[0.5, 0.999])" ] }, { "cell_type": "code", - "execution_count": 593, + "execution_count": 679, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 0/200 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 11%|█ | 22/200 [01:56<15:59, 5.39s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.28963, dtype=float32) G=array(5.5491, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 12%|█▏ | 23/200 [02:01<15:38, 5.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.28961, dtype=float32) G=array(5.5491, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 12%|█▏ | 24/200 [02:06<15:28, 5.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.28957, dtype=float32) G=array(5.5491, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 12%|█▎ | 25/200 [02:12<15:15, 5.23s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.28959, dtype=float32) G=array(5.54911, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 13%|█▎ | 26/200 [02:17<15:09, 5.23s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.28964, dtype=float32) G=array(5.54911, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 13%|█▎ | 26/200 [02:19<15:36, 5.38s/it]\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[679], line 32\u001b[0m\n\u001b[1;32m 29\u001b[0m gen_opt\u001b[38;5;241m.\u001b[39mupdate(gen, G_grads)\n\u001b[1;32m 31\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[0;32m---> 32\u001b[0m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgen_opt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m \n\u001b[1;32m 34\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (cur_step \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m) \u001b[38;5;241m%\u001b[39m display_step \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mStep \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: Generator loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mG_loss\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, discriminator loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mD_loss\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -489,7 +885,7 @@ "display_step = 5000\n", "cur_step = 0\n", "\n", - "batch_size = 64\n", + "batch_size = 128\n", "\n", "D_loss_grad = nn.value_and_grad(disc, disc_loss)\n", "G_loss_grad = nn.value_and_grad(gen, gen_loss)\n", @@ -516,16 +912,16 @@ " \n", " # Update gradients\n", " mx.eval(gen.parameters(), gen_opt.state) \n", - " \n", - " print('Losses D={0} G={1}'.format(D_loss,G_loss))\n", - " \n", - " if (cur_step + 1) % display_step == 0:\n", - " print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", - " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", - " fake = gen(fake_noise)\n", - " show_images(fake)\n", - " show_images(real)\n", - " cur_step += 1" + " \n", + " if (cur_step + 1) % display_step == 0:\n", + " print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", + " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", + " fake = gen(fake_noise)\n", + " show_images(fake)\n", + " show_images(real)\n", + " cur_step += 1\n", + "\n", + " print('Losses D={0} G={1}'.format(D_loss,G_loss))" ] } ], From 1e386b5c20f24f69dbe99023f9dbf664d163cfe4 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Tue, 30 Jul 2024 02:56:13 +0300 Subject: [PATCH 24/38] Updating GAN Code... --- gan/playground.ipynb | 1595 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 1368 insertions(+), 227 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 168fbd2e..e9538d8a 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 657, + "execution_count": 701, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 658, + "execution_count": 702, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 659, + "execution_count": 703, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 660, + "execution_count": 704, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 661, + "execution_count": 705, "metadata": {}, "outputs": [], "source": [ @@ -84,10 +84,8 @@ " GenBlock(z_dim, hidden_dim),\n", " GenBlock(hidden_dim, hidden_dim * 2),\n", " GenBlock(hidden_dim * 2, hidden_dim * 4),\n", - " GenBlock(hidden_dim * 4, hidden_dim * 8),\n", "\n", - "\n", - " nn.Linear(hidden_dim * 8,im_dim),\n", + " nn.Linear(hidden_dim * 4,im_dim),\n", " )\n", " \n", " def __call__(self, noise):\n", @@ -97,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 662, + "execution_count": 706, "metadata": {}, "outputs": [ { @@ -120,17 +118,12 @@ " (layers.1): BatchNorm(1024, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", " (layers.2): LeakyReLU()\n", " )\n", - " (layers.3): Sequential(\n", - " (layers.0): Linear(input_dims=1024, output_dims=2048, bias=True)\n", - " (layers.1): BatchNorm(2048, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", - " (layers.2): LeakyReLU()\n", - " )\n", - " (layers.4): Linear(input_dims=2048, output_dims=784, bias=True)\n", + " (layers.3): Linear(input_dims=1024, output_dims=784, bias=True)\n", " )\n", ")" ] }, - "execution_count": 662, + "execution_count": 706, "metadata": {}, "output_type": "execute_result" } @@ -142,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 663, + "execution_count": 707, "metadata": {}, "outputs": [], "source": [ @@ -153,12 +146,12 @@ }, { "cell_type": "code", - "execution_count": 664, + "execution_count": 708, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -183,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 665, + "execution_count": 709, "metadata": {}, "outputs": [], "source": [ @@ -196,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 666, + "execution_count": 710, "metadata": {}, "outputs": [], "source": [ @@ -224,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 667, + "execution_count": 711, "metadata": {}, "outputs": [ { @@ -250,7 +243,7 @@ ")" ] }, - "execution_count": 667, + "execution_count": 711, "metadata": {}, "output_type": "execute_result" } @@ -283,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 668, + "execution_count": 712, "metadata": {}, "outputs": [], "source": [ @@ -317,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": 669, + "execution_count": 713, "metadata": {}, "outputs": [], "source": [ @@ -337,7 +330,7 @@ }, { "cell_type": "code", - "execution_count": 670, + "execution_count": 714, "metadata": {}, "outputs": [], "source": [ @@ -347,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 671, + "execution_count": 715, "metadata": {}, "outputs": [], "source": [ @@ -357,16 +350,16 @@ }, { "cell_type": "code", - "execution_count": 672, + "execution_count": 716, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 672, + "execution_count": 716, "metadata": {}, "output_type": "execute_result" }, @@ -387,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 673, + "execution_count": 717, "metadata": {}, "outputs": [], "source": [ @@ -400,7 +393,7 @@ }, { "cell_type": "code", - "execution_count": 674, + "execution_count": 718, "metadata": {}, "outputs": [], "source": [ @@ -424,12 +417,12 @@ }, { "cell_type": "code", - "execution_count": 675, + "execution_count": 719, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -454,12 +447,12 @@ }, { "cell_type": "code", - "execution_count": 676, + "execution_count": 720, "metadata": {}, "outputs": [], "source": [ - "lr = 1e-4\n", - "z_dim = 128\n", + "lr = 1e-6\n", + "z_dim = 8\n", "\n", "gen = Generator(z_dim)\n", "mx.eval(gen.parameters())\n", @@ -472,307 +465,153 @@ }, { "cell_type": "code", - "execution_count": 679, + "execution_count": 721, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 1/200 [00:05<18:01, 5.43s/it]" + " 0%| | 1/200 [00:05<18:14, 5.50s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28961, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29126, dtype=float32) G=array(4.85983, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 1%| | 2/200 [00:10<17:20, 5.26s/it]" + " 1%| | 2/200 [00:10<17:36, 5.33s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28963, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29126, dtype=float32) G=array(4.85983, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 2%|▏ | 3/200 [00:15<17:08, 5.22s/it]" + " 2%|▏ | 3/200 [00:15<17:25, 5.31s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28957, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85983, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 2%|▏ | 4/200 [00:20<16:55, 5.18s/it]" + " 2%|▏ | 4/200 [00:21<17:13, 5.27s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28956, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85983, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 2%|▎ | 5/200 [00:26<17:02, 5.24s/it]" + " 2%|▎ | 5/200 [00:26<17:06, 5.26s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28958, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85983, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 3%|▎ | 6/200 [00:31<16:52, 5.22s/it]" + " 3%|▎ | 6/200 [00:31<17:02, 5.27s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28962, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85983, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 4%|▎ | 7/200 [00:36<16:38, 5.18s/it]" + " 4%|▎ | 7/200 [00:36<16:53, 5.25s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28961, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85983, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 4%|▍ | 8/200 [00:41<16:49, 5.26s/it]" + " 4%|▍ | 8/200 [00:42<16:45, 5.23s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28955, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 4%|▍ | 9/200 [00:47<16:56, 5.32s/it]" + " 4%|▍ | 9/200 [00:47<16:37, 5.22s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.2896, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 5%|▌ | 10/200 [00:52<17:03, 5.39s/it]" + " 5%|▌ | 10/200 [00:52<16:32, 5.22s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28964, dtype=float32) G=array(5.5491, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▌ | 11/200 [00:58<17:03, 5.42s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.28956, dtype=float32) G=array(5.54911, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▌ | 12/200 [01:03<16:44, 5.35s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.28952, dtype=float32) G=array(5.5491, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▋ | 13/200 [01:08<16:26, 5.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.28963, dtype=float32) G=array(5.5491, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 7%|▋ | 14/200 [01:13<16:11, 5.23s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.28959, dtype=float32) G=array(5.5491, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 15/200 [01:19<16:17, 5.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.2896, dtype=float32) G=array(5.5491, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 16/200 [01:24<16:18, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.28965, dtype=float32) G=array(5.5491, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 17/200 [01:29<16:12, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.28969, dtype=float32) G=array(5.54911, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 9%|▉ | 18/200 [01:35<16:05, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.28959, dtype=float32) G=array(5.5491, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|▉ | 19/200 [01:40<15:58, 5.30s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.28961, dtype=float32) G=array(5.54911, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 20/200 [01:45<15:47, 5.26s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.28956, dtype=float32) G=array(5.54911, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 21/200 [01:50<15:35, 5.23s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.2896, dtype=float32) G=array(5.54911, dtype=float32)\n", - "Step 21: Generator loss: array(5.54911, dtype=float32), discriminator loss: array(2.77676, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85983, dtype=float32)\n", + "Step 10: Generator loss: array(4.85982, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -782,7 +621,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -794,77 +633,1379 @@ "name": "stderr", "output_type": "stream", "text": [ - " 11%|█ | 22/200 [01:56<15:59, 5.39s/it]" + " 6%|▌ | 11/200 [00:58<17:02, 5.41s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28963, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 12%|█▏ | 23/200 [02:01<15:38, 5.30s/it]" + " 6%|▌ | 12/200 [01:03<16:49, 5.37s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28961, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 12%|█▏ | 24/200 [02:06<15:28, 5.28s/it]" + " 6%|▋ | 13/200 [01:08<16:36, 5.33s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28957, dtype=float32) G=array(5.5491, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 12%|█▎ | 25/200 [02:12<15:15, 5.23s/it]" + " 7%|▋ | 14/200 [01:14<16:27, 5.31s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28959, dtype=float32) G=array(5.54911, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 13%|█▎ | 26/200 [02:17<15:09, 5.23s/it]" + " 8%|▊ | 15/200 [01:20<17:14, 5.59s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Losses D=array(2.28964, dtype=float32) G=array(5.54911, dtype=float32)\n" + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 13%|█▎ | 26/200 [02:19<15:36, 5.38s/it]\n" + " 8%|▊ | 16/200 [01:25<17:00, 5.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 8%|▊ | 17/200 [01:31<16:39, 5.46s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 9%|▉ | 18/200 [01:36<16:20, 5.39s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|▉ | 19/200 [01:41<16:08, 5.35s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 20/200 [01:46<15:56, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 21/200 [01:52<15:48, 5.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n", + "Step 21: Generator loss: array(4.85982, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 11%|█ | 22/200 [01:58<16:17, 5.49s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 12%|█▏ | 23/200 [02:03<15:57, 5.41s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 12%|█▏ | 24/200 [02:08<15:44, 5.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 12%|█▎ | 25/200 [02:13<15:31, 5.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 13%|█▎ | 26/200 [02:19<15:24, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 14%|█▎ | 27/200 [02:24<15:17, 5.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 14%|█▍ | 28/200 [02:29<15:13, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 14%|█▍ | 29/200 [02:34<15:03, 5.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 30/200 [02:40<14:57, 5.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 16%|█▌ | 31/200 [02:45<14:50, 5.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", + "Step 31: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 16%|█▌ | 32/200 [02:51<15:13, 5.43s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 16%|█▋ | 33/200 [02:56<15:01, 5.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 17%|█▋ | 34/200 [03:01<14:50, 5.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 18%|█▊ | 35/200 [03:07<14:40, 5.34s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 18%|█▊ | 36/200 [03:12<14:35, 5.34s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 18%|█▊ | 37/200 [03:17<14:27, 5.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 19%|█▉ | 38/200 [03:23<14:23, 5.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|█▉ | 39/200 [03:28<14:16, 5.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 40/200 [03:33<14:09, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 41/200 [03:38<14:00, 5.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 21%|██ | 42/200 [03:44<13:57, 5.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", + "Step 42: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 22%|██▏ | 43/200 [03:50<14:19, 5.47s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 22%|██▏ | 44/200 [03:55<14:07, 5.43s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 22%|██▎ | 45/200 [04:00<13:56, 5.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 23%|██▎ | 46/200 [04:06<13:45, 5.36s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 24%|██▎ | 47/200 [04:11<13:36, 5.34s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 24%|██▍ | 48/200 [04:16<13:30, 5.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 24%|██▍ | 49/200 [04:21<13:23, 5.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 50/200 [04:27<13:17, 5.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 26%|██▌ | 51/200 [04:32<13:10, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 26%|██▌ | 52/200 [04:37<13:03, 5.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 26%|██▋ | 53/200 [04:43<12:57, 5.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", + "Step 53: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADXJ0lEQVR4nOz913Oc2Z3fj7865xzRjRxIAszkkJwZSaORRjOSVjvaWrvs3fJa5VqXXb7wnf1X+MI3vvCFy3vhtUu71kobpO9qFazJ4pDDYRqQIEiCyOicc+7fBX/nTIMEOQwgATSeVxVrAsBG94PzPO9zPuH9UXW73S4KCgoKCgrbiHqn34CCgoKCQv+hiIuCgoKCwrajiIuCgoKCwrajiIuCgoKCwrajiIuCgoKCwrajiIuCgoKCwrajiIuCgoKCwrajiIuCgoKCwrajiIuCgoKCwrajfdJvVKlUL/J97CmexdRAuX5foly/5+NZTTWUa/glyhp8Pp7k+iknFwUFBQWFbUcRFwUFBQWFbeeJw2IKCvsRlUqFXq9Hq9UyNDTE0NAQWq0Wg8FAp9NhfX2dTCZDqVQinU4/c8hKQaHfUMRFQeExaDQa7HY7ZrOZ73//+/yzf/bPsFqteL1eGo0GP//5z7l27Rp3797l0qVLNJvNnX7LCgq7AkVcFBS2QKVSoVar0ev1eDweHA4HoVCIUCiExWLB4/FQq9Vwu93Y7XYMBoOS8FVQ6EERFwWFLTAYDNhsNvx+P//iX/wLJiYmmJ6exufzodVqUavVqNVq7HY7fr8fh8OhiIuCQg99Iy6PurGVGLjCs6DVajGZTLhcLo4cOcKxY8dwu91YLJZN36fX6zGbzej1+h16pwoKu5M9Jy4qlQqVSoVGo0Gn0zE0NITL5cLpdOL3+9HpdFitVtRqNTdv3uT27dtUKhUymQztdnun377CHsHv9/PKK68QDocJh8M4nU4MBsOm72m326ytrTE7O8v6+jqdTmeH3q2Cwu5jT4lLr7AYDAZMJhNHjx5lamqKsbExjh07hsViIRQKodVq+T//5//w05/+lHQ6TaFQUMRF4SsRJ+BQKMSbb77JwMAAIyMjuN3uh07HrVaLxcVFPv/8c2XzoqDwAHtKXLxeLx6PB6PRKCt4pqamGBkZwe/3YzabUavVRCIR2u02iUSCYrFIpVJRwmMKT4ROp0Or1cp8i8fjQa/Xo1KpqNVq1Go1ut0u7XabfD5PuVym0WgowrKNqNVqDAYDWq0Wj8eD1+ul0+nQaDRotVokk0mKxSLtdruvr7vRaMRms8kQrVb75eNarVZjNBpRq9XyxJzNZolGo7vmuuwZcVGr1Zw9e5bvfe97eDweDhw4gMlkkj0IgmQyyc9//nNWVla4efMmd+7codVqKSWiCl+JSNBbrVYmJiZ45ZVXcDqdmM1mut0usViM1dVVGo0GlUqFYrFIJBKRDz1lA7M96HQ6wuEwDoeDH/7wh7zzzjvU63XS6TS5XI6f/vSnXLt2jUqlQqFQ6NvrHgwGOXnyJE6nk/HxcRwOh/ya1WplcHAQvV5Pu92m0+nwu9/9jv/1v/4XpVKJSqWy4wKzZ8RFpVLhdrsZHx/H5/Nx8OBBTCYTpVKJWq1Go9GgWq1SKpVYXV3l7t27xONxSqXSTr/1F45KpUKr1cp/qtVqut2u3NGIm0+EFcX/63a7tFotOp2O/O/9jEqlwmw243Q65R+bzSavZalUIpFI0Gg0KBaLlEolyuWyvIYKmxFrTYSye/+7dy0+iPgdeDweRkZGmJmZoVarkUgkSKfTuN1uDAYDjUbjpX2WncBoNOLz+XC73YyOjuJ2u+XX7HY7IyMjGAwGeVK5e/euFKBOp0Oz2dzRU8yeEBeRvA8EAhw6dAiTyQRAPp+XTWxioebzea5cuUIqlaJYLO7k237hiBvU6XQyMzOD0+nk8OHDDA4OUigUSCQStFot6vU67XYbm82GxWKh2+1Sr9ep1WpcvXqVlZUVuRPfzw9JvV7PG2+8wblz5zh06BB6vZ5Op0OxWKRWq/HZZ5/xy1/+kkajIcNh6+vr5HI5ms3mvhdngUajkaEts9mM0WhkaGgIq9WK2WyW1XVOpxONRiP/nriH9Xo9wWAQi8XC0aNHZYhMo9FgNBoJhUKEw2FisRjZbLZvr7vRaMTj8RAIBJiamiIQCMiv6fV67Hb7prDYmTNn+I//8T+SzWaZm5sjm82ytLTEysqKFJuXya4XF7Hr0Wq1OBwOhoeHAajVapRKJX7/+9/zi1/8Ap1Oh8FgoNlskkgkqNVqO/zOXw4qlQqbzcbMzAyhUIjvfve7nDhxglgsxt27d6nX65RKJVqtFj6fD6/XS6vVkiGFcrlMsVhEpVLti1Pe49BqtRw9epQ/+IM/wGq1otPpaLfblMtlyuUy8/PzfPDBB1KY97MQPw5xv5pMJnn6O3DggNyFO51OWXizVQm3TqeT1XlOpxOdTodOp5M5Bq/Xi9frleu2XxEC7PF4ZNXi4zh48CB+v59MJoPD4SASiVCr1YhGozSbzZceut314iLKjR0OBz6fD5VKRaVSYWVlhVQqRTqdplar0Ww25QXc6VjjyyIcDjM8PMzAwACHDx/G6XSyvr5OMpkkkUiwtLREs9mkVqvRbrex2+3YbDZMJhMejweVSsXBgwfx+XwsLy8zOztLpVIhmUxSr9d3+uO9NDQaDWazGYfDgdVqlbk8lUpFp9OhUChI/7CduEl3OyKcGAwGMRqN+P1+udY8Hg9ms5mRkRFsNhtmsxmTySQFqBe9Xo/RaESn02GxWOSJZb/SbrdpNBqbTsXlcplKpSLzft1uF4vFgtFoBJCCfuDAAbxeL91uF5vNRiaTYWFhgWq1Kp+XL5pd/5szm82cOHGC4eFhRkdHUalU5PN5Ll++TCQSYW1tjUKhsGkHsx92lCqViqNHj/Luu+/i8/k4evQoarWav/zLv+SDDz4gl8uxsbFBu93elHNRq9UMDw/z3e9+l0AgwFtvvcXk5CSffvopf/u3f0ssFuPSpUv7Slz0er2sDBNWLyJH0Gw2iUajRKNRUqkU1Wp132xengThVOB2u/na176G3+/n+PHjjI6Oyt4zrVaLTqdDpVLJHEC5XJbFEAKTyYTP55PiIvKI+5V2u02lUqFarcq8aCaTYXV1lVKpxNraGp1Oh5GREbl2BwcHcblcBAIBWq0Wx44dY21tjfn5eX7yk5+QSqWIx+P7W1zUarU8Wnu9XhmD7XQ6MrkXj8eleu+XnaRKpZI7a4/HQzAYxGq1yoqldDpNMpkkn8+Tz+e3FFqr1UoymUSr1VKv11Gr1VgsFoLBIJ1OZ991m4swjNvtlrtqEctuNpvk83kymQzlcnnfrLMnxWg0YrVa8Xg8DAwMEAgECAaDBAIBjEYjer2ebrdLPp+n3W7Lk1+pVCIajW4Sl0qlQrPZRK/XY7VaZUm42WyWGyORLxS7935EXDe73Y7dbsdoNFIsFkmlUkQiEdbX1ykWi7JxV61WUy6XqVarqFQq2UguTuQ+n49sNsvg4CAGg0GeXFqtFq1W64V9jl0rLhaLBZ/PRygU4mtf+xozMzO43W7K5TLr6+u8//77rK6uEolEdvqtvlRMJhMnT54kGAzy9a9/ndOnTxOPx/mnf/oneerY2Nig2Ww+8gSXSqX43e9+JytLYrEYZrOZ7373u6yurspTYb8jCiLcbjff+MY3GBwcZHh4GK1WS7vdpl6vk81m+eyzz5ibm2NpaUkRlx5UKhWHDh3i9OnTDA8P8/bbb+PxeLDb7ZhMJhKJBJcuXSKTyfDxxx8TiURkj1Cj0SCfz296uAmhMhgM+Hw+rFYrb775Jl/72tekzU6r1WJtbY0bN25QqVT6Lkqh0+mYmZlhZGSEkydP8s4779DpdPjss89IpVLMzc1x8+ZNWq0W1WqVbrcrCyTsdjterxeXy8U3vvENgsEgPp9PphVEPubv//7vmZ2dJZPJEIvFXtg13LXiIi6W2+2WuQWAer1OPp9nbW2NlZWVfZO4F2i1Wvx+P8PDw4RCIfx+P9lslsXFRZaXl4nFYl+ZmK/VaqytrZFOp1laWsLpdDI5Ocno6CiAjN/uB0S+YGhoSOYFVCqVLNOuVqtEo1FWVlbI5XKKuPQghHlqaorh4WEmJydxuVybytyj0SgbGxtcvHiRxcVFWdYtrm3vg00k7Q0GA8FgEIfDwcTEBLVaTf5ORA4slUrJUFE/IQoWRkZGGB4eZmhoSPZT3blzhy+++ILZ2dlN102EDi0WCw6Hg0AgQCgUot1u43A4ZMWew+Egl8tx5coVmex/kexacRkYGOBb3/oWAwMDMvl85coVrl69yuLiIqlUikaj0Xc7l0chquYsFgsHDhzg8OHDmEwmlpaWWFxc5N69e6yurj5V+XWz2eTOnTtUKhU0Gg1nz57FYDBgMBhkc1Y/5xe8Xi9+v59Dhw4xPT3N0NAQTqcTgEQiwc2bN9nY2GBlZYVEIkG5XN7ZN7xL0Ol0DAwMYLVaOX78OGfPnpWnYNEKsLi4yMbGBrdu3SKXyxGNRqlWqwBSJB4UBnFaFMl+cVqx2Wy0223i8bj8PXQ6nb6693ttrcbGxjh9+jTtdpt/+Id/IJfLceHCBTY2NojH4w9dt263i0qlkv1X3W6Xjz76iBs3bnD79m3Gxsbw+/0cO3YMg8HAoUOHUKvVXLlyRZYpvwh2rbiEw2F5zPZ4PAB8/vnn/MVf/AXlcpl0Ov1C44W7DbVaLROdBw8e5PTp0+RyOe7du8fCwgJ37959avPEVqvF/Pw8i4uLhMNhuXPU6/UYDAbZH9OPqFQqfD4fMzMzTE9Pc+TIEUKhkNwFxuNxfv/737OxscHi4uKWN/V+RafTySrFU6dO8dprr9HtdimXy+TzeX73u9/x29/+lkwmw/r6uqyu+6rrJyxedDqdrBwzm81YrVby+bwsrCiVSn23LkUDtNFoZGJigrNnz3L+/Hn+5m/+hnQ6zb1796QbwVbXsdvt0mg0pMDEYjE0Gg0jIyOMjIxw4sQJpqamcDqdTE9PEwgEKBQKfPjhhy8sub+rxEX0bBiNRrxeL06nE5PJRCqVotlsytOKKL8TDYTCU0yr1dLtdikWizSbTQqFglTyvf5gEA1kZrMZi8WCxWIhlUqRyWTIZrMyx/I0n1OELgCZGNRqtVitVux2O4VCoW+TpvClh5VOp9vUQQ7I3IDYIe/19bOdaDQaWWZssVjQaDSUy2WWl5dJp9PEYjFyudwzuxdoNBrZeiCS+fV6nVgsRiwWkyegfsJoNDIwMIDL5UKtVpPNZslms2QyGfL5/FNFacTzTgi+KPKJxWI0m010Oh0ejweXy4Xdbkej0TwUotwOdpW4aDQaJicnGR4e5uTJk0xMTFCv1/nlL3/J8vIyc3NzNJtNDAYDfr8fq9XK1772NaampmSfQqVS4caNG2QyGa5cucIXX3whq1T28gNC9A/0VuPcunWL2dlZVldXZXLvaemtGtFoNJhMJgYHB8nn8ywvL/e1y4HBYJBd42q1eqffzp5Bp9MxOjrK9PQ0fr8fuH/S+7u/+ztWV1f5/PPPWVtbk+L8tJhMJg4ePMjExITsSk+n05w/f16GhvoNj8fDO++8I3v5rl69yuzsLIuLi5TL5Wc6XXS7XVKpFLlcDoCPP/6YgYEBzp07x4EDB7hz5w6Tk5OyvLlSqWzrZ9p14uJwOAgGg7IstNPpUKlUyOfzdLtdrFar9Nyx2WwMDQ0xOjqKxWLBbrfLo7nRaGR5eRmz2Uy9Xt/zjW8iLKbX6+Uf4Xf1PLuOB6+J2M2Lbuh+RpS6i4bJXkTS+UnWjSiTFacftVote2TEyXAvr70HEY68FosFnU4H3N+kiB1ysVh85j4pcXp2OBzSQ6zdblOr1Uin0zJ60S+I9WIymQgEAvh8PiqVCqlUikKhQKVSea6eM9FcXigUiMfjaDQaOp0ORqMRk8mExWKhVqu9kHt9V4iLeHDabDZeeeUVvv3tbxMKheTCmpycxGKxcOrUKTnX3G63Sw8ih8NBrVajXC6j0+k4c+YMnU4Hm82G0+kkEolw6dKlbVfmvY5KpZId0eIB2263pQFoP+e0VCoVoVCIM2fOEAwGpV+dCCdkMhlu3br12ER+7/Xz+/0MDQ3JEnqDwcAXX3whT9v9PvZBp9Ph8/moVqssLi4+02uIUuSBgQGOHDnC4cOH0ev1rK+vs7S0xK1bt4hEIhQKhW1+9zuH3W7H6XQyMjLCgQMHcLlcfPDBB9y8eZP19fVtyy2lUik++OAD6VPm8/lotVq43W5ardYLcULYFeIiGn9EMuvMmTPS+kGr1UpbiXA4LAeBmUwm1Gq1tHtJpVLk83kMBgMTExNYLBbK5TL1eh2j0cj169f7Rlwe5yj7tOh0Okwmk5yyKBKDtVqtr8UF7ocipqamcDgccgfe64C8vr5OOp1+7M5RXD+v18vMzAx2u12GaSuVCsvLy3IOTL8loXvRarXyQSmu5dMimv9cLhfDw8OMjY1Ji6dkMsn6+jqxWKyvTi7Cisnr9TIwMIDD4aBQKHDnzp1tHXBYLBblZikajcrXFjncXgPR7WJXiIter5dmdHa7XQqLEB2v14vJZEKlUpFMJuXRudPpsLGxQS6XI5fLEYvFcLlc+Hw+LBYLNpuNgYEBksnkC7l4O4XYXRcKBekl9ighEEduMQRLp9NJ40qtViutdQ4fPizt+sWUz370dRJVOcIMUVwX0UdRrVap1+ubLPUfvMHFSdtgMHD06FHZfHn48GHMZjOBQAC9Xs/JkyfpdDrEYjGuXr0qu8r3usgISxyj0cjg4CBw3/Vhenoaj8cjeyhKpRKpVGqTBdFWiN/ByMgIZ86cYWhoCLfbjVqtJhqNcvPmTe7evSutd/rpBGi1WgmHw9hsNlZXV9Hr9cRiMQqFwjPnUbeit6hJbIjEALx6vf5CypF3xdPDZDIxNjYmY46iQgTuC8/Q0BCdTofl5WWWlpZkPLxer/PJJ59w+/ZtyuUymUyG8fFxTp8+TSgUwuv1cuDAAdLp9DPvpnYr3W6XRCLBjRs3KJVKj9xdazQaaR5otVqxWq2USiXi8TgGg4Ef/OAHfPOb38Tr9WIwGGRS32q19qUNjGiaFCEYEdYS4lIsFsnn8ySTSXkafvAG12g0WK1WHA4Hb7/9Nq+//jqBQIDR0VEp0HC/j+b06dNcu3aNWCwmbXn2urjU63Xm5+dJp9NMTk7S6XRwuVy88cYb0oZE9GCJ/MujRKH393Hq1Cn+7b/9t9IFWKPRcOfOHf7xH/+RWCwmq0D7BZVKhd/vZ3p6GpVKxRdffEGtVuPu3bskEoltr3IVVY9iwqWwjRFTPbebXSEuojlQ2Jz3hnza7TaFQoF6vU40GmV1dVU29wk76WQySa1WkyZv4kL1lpP2025HIGw0Hpd0Fg9CYQ3h8XioVqvSdVY0qVqtVpmUFt/fr+IieihEs6jIN4mTSz6fl5P8trquwp7E7XbLMQa9JfGAdKNtNpuyV0sMtNvrrhIibKjVakkkEqyvr8sNiSi2GRoakvNuREFOvV6XD0xx+hO5GqfTSSgUkmtRjDXIZrMyub3XRbkXca+ZTCaZMxb5vRdhayNaGSwWC3q9XhafvMjn464QFzFMaHBwEJvNtulrhUKBX/7yl6yurnLjxg1u3rwpL4aYY16pVORgIkG32yWbzbK8vEw8Hu+rhdnLV+1ujEYjR44cYXh4mKNHj3LkyBG63S7NZhO1Wk0oFMLtdkuzRpPJJEdIJ5NJbt++3VfCLOxzhNGi1+uVfS7NZpOVlRXm5+dZXl5+5JoJBAL80R/9EeFwmHPnzjE+Po5Op9tUcaNSqaT1RqVS4fXXXycWi/HRRx/t+YR0s9kkEomQSqX4x3/8R9bX1xkdHeXdd9/F4/Fw5swZjh07xsLCAlNTUyQSCT744APpgtxsNuU8F6fTyTvvvCPX6ODgIPV6nVu3bpFOp7ly5Qpzc3Py7/UDwijWYDAwODjIoUOHWFlZ4de//jXRaJRsNrvtP1M0T4o2BrFxFGGxvhUXcXIRiaXek4dIis7Pz3Pz5k1mZ2e3vBDCPVWUgcL9CycGYvWTVUQvX5Xc12q10oJ7fHyco0ePbso/CXESr6PVanG73dRqNSwWy8v4CC8VIaAWi0WGY8T1EGExMcX0UWvGYrEwPj7O8PAwgUDgoQ2RQJyKxK4ckFVpexlxX4p7s9PpUK/X+eY3v4ndbpdhWLVaTS6Xw2azce3aNTKZjDwhGo1GnE4nPp+PqakpTp48KWcNibLm9fV1EolE302b7D09i5HOkUiEdDpNPB5/IYU04rQtKhl7/fNeVB5rV4hLoVDg8uXLLC0tkc1m+fzzzymXy2SzWfL5PNeuXZMX/lEXwefzcerUKdnz0ul0iMfjzM3Nsbq62je7nl7sdjtDQ0Nks9kt54yoVCparRaRSAS1Ws34+LgsiW00GjJ2Ho1GGR8f58SJE6hUKgYHB7FYLLhcrh36ZLsTMQBraGiI8fFxObr3qzCbzYyOjso8Tz9RKBTkXJFf/OIX+P1+jhw5wtDQEK1Wi5mZGYaHh7Hb7bLbPJ/PY7fbGR0dxW63c+TIEVwuF9lsljt37pBKpXjvvffY2NhgeXm5r4QF7m86xsbGZK9eIpEgk8nIYo8X8XlNJpPcDJXLZe7evcvS0pK0738RFXi7RlyuXbuGXq9nYWEBl8tFIpHg3r17m3yJHnfRhbiEw2E5Jz6ZTDI/P08ymexrcdHpdEQikU1JfdGc1W635ZjTZDIpcwm5XI5SqcT777/PtWvX+Pa3v83Bgwdlybfb7cblcskdjgKy+lCIi0g6fxX9Li6FQkFalLhcLll2HQgEmJ6eRqPRcObMGdrtNolEgmQyidVqZWhoCKPRKE/Nq6urXLx4kUgkIsVlr+entkKv1zM6Osro6ChWq1WKy4v08hPi4vP5KJVKLC4usrKy8kKv8a4QF7GT7h0qVCgUnmhksViYZrNZJlY7nY7s1E+n0y+sGmInEb5qIyMjmEwmcrncJqsWkbwzm80cPHgQl8uFxWIhkUhQLBZZXV2VFi+iMiqdTsuEn/gZ/czTVOOIIW1iXomoChPXKJvNEo1G0el0hMPhTfm/3tfoV1qtlhxOt7CwgFqtllEEk8mE3W6XxqvNZlNW6cH9aydGly8sLJBIJORI6X68b0Xo2e/302q1yGazL6xgwWazyXJnkeMS9/qjhgluF7tCXERXeLVapVKpyB33k1xsrVaLRqORx3GbzSa79ZeWlrh9+/YmG45+QAjqxMQE77zzDqlUimAwuGmOi8/nY2xsDJvNxuTkJHa7neXlZWmz/etf/1oa45VKJYLBIDdu3MDtdjM2NtZ3pdsC0SQpikJ6c06PQ6VS4fV6OXjwoNxx955abt26xc9+9jOcTif/6l/9K8bHx/taTB6kWq2ytraGRqMhGo3KoXb5fB6fz8eZM2fw+/04nU45M0en01Gv15mbm2NxcZGLFy/y85//XOZz9rpl04OICjGz2SzzTNevX+fmzZvE4/FtD02p1WpGRkaYnp7m6NGjvPbaa+j1en76059y9epV2dbxotgV4gJfzr1/2gssfmHChFAkBOv1OvV6/YW4fe4E4qEoyo8bjYZsPhVVX6VSST4sfT4ffr9feq4Jj7VEIkEsFiMSiZDJZGQnviiBNJvNfXG9Hker1ZLVR81mU+4m4X5xSW9jZS8GgwGbzbZlR3OpVJIhht7qm/0iMCL6AF+2D4hcoIhKANJ1Q/y3KA7I5/Pkcjmy2WxfhsJgcwOv6IwXw89KpdK23Xfi52i1WpxOJ8FgEI/HI/0CK5WKPC2+SPHeNeLyLIhQhagV93q96PV6UqnUC62C2AlEHbxarebatWt0Oh3ZbOb3+wkGgzSbTYrFojwBJpNJ1tbW+Oijj6hUKiwuLrK4uEixWJS2Jv0Wdvgqms0ma2trpFIpObnTYrHg8XjQaDQMDAzQbDaJxWIPmfk5nU5GR0cJBoNSjMQ6y2azLC0tUalUqNVqT3Qa6lc0Gg16vR6Px8OhQ4fwer1bhgl72Q/XSowS8fl86PV62Qg9Ozsrraq26+dMTEzgdDr5zne+wxtvvIFGo2FxcVHmt69du/bYisjtYM+Li7DhEB3o4qbvJ2EBpHAYDAZWV1dlLNvpdKLRaAiHw3Q6Hdlwtr6+zvr6OplMhosXLxKPx+Wwpf2MEIJ8Pi/tyLvdLk6nU7rxCjPUB/tWRF7P4XDIk0u73ZYnv1QqhVar7Svvq6dFFJJotVpZACHcjQUP3pf7QVgAac5rs9nk6U3cq9sZttfpdASDQYLBINPT05w6dYp0Os3s7CzxeJzV1VU5WFA5uWyBsP0+fPgwY2NjHDx4EJVKRbVa5d69e0QiEZLJ5E6/zW1DNI2Wy2VmZ2dJpVKsra0xPz+PWq1GrVbT6XTkkKZMJsPa2hrlcpm1tTVp363wJfl8ntXVVXnyEzc/QDAYJBwOy1DNVjd/u90mmUySy+VIp9Oy83y/IjZ7R44cYXR0lOPHj2Oz2dDr9TLsE4lE2NjYwG63Mz4+jlarxefzodVq5VrN5XIsLy/33Vhp0SWv0+mkE4Q45W7X64sN0qFDhxgdHcXlclEsFolEIly5coVYLEYqlXopriV7UlxETNFisfDGG2/wrW99i0AggEajoVgscvnyZe7cucPKykrfnF5Ew1M+n+f9999Ho9Fgt9txOBwywS8mz4k8ili4/WyB86yIUvW5uTnK5TKHDh3CYrHgdrtxOp2Mj48zPT1NIpFgbm5uy676drvN6uoqy8vLcie4nY7Vew3RoPqNb3yD73znO4RCIXw+nzSYLRaLfPDBB3z44YeMjY3xx3/8x/j9fmn6abVaabfbbGxskM/n+05cxDPLaDRSKpVIJpPb+hm1Wi1msxmfz8frr7/O4cOHZSPr0tISv/71rzeJy4tmR8RFJEvFrHZRLSYS1l/1EBSePBaLZdNQoWq1KvMJoqej3+hNnKpUqk0PNOGNJZqx+qlC7kXQbDalGIubTZwCLRYLwWAQQOZSxNAlq9Uqv1+r1aLX67HZbNJWpl8r7R6HeHDa7XZcLhderxer1SptdaLRKIlEgrW1NZLJJGazmWg0SqfTweFwoNfrsVgs+P1+OSZDOJ/3S4GJGClgsVhkpGE7N3wmkwm/3y+bMy0WC9lsllwuRyKRIJ/Pv9Q5TS9dXMS0SWHXPTIyQj6f59atW9Li/KsSW2azWXa4TkxMMDY2RiaTkaeVy5cvc+vWrb4Ul15qtZqsdhIIcVZOKV9NqVQiFovhcDjkDSeu5fDwMH/wB3/A+vq6bEIVXlelUonjx49jMpkIh8NyVLIw/PT5fH014uFJsFqtzMzM4PP5mJmZYXJyUvqtZTIZfvKTn3D16lXi8TjJZFK6/gYCAf7kT/5EVjeePXsWn8/HRx99JEO81Wp1pz/etuBwOOTMn+1sphWby9HRUb71rW8RDoel+8Gnn37KBx98IMdD97W49Ho7eb1ewuGwHEksXGO/Cp1Oh9PpxO12y19UJpMhm81uagjsd/ppV7cTiJNL75wQIS6igxzA5XJhMplkMYCoshEnHJVKJS33RTn8fkOn08nGQJfLtclvrV6vs7y8zNzcnHSFVqvVcpCaaJwWpfWFQkEaO25XBdVuQKfTyVB2bzn28yJO2w6Hg9HRUQKBgPR2y2azLC4uykjOy3QqeWniIqpI7HY73/zmNxkbG5Nleffu3ePChQuyceqrXmNgYIA//MM/JBwO4/P5yOfz3L17l9/+9rfEYjFyudzL+lgKexThmn3v3j0MBgMrKyu0223cbrcUiGAwiF6v5/vf/z7Hjh3DZDJhNpsZHh6WNv1iqFrvULavKrvtR2w2G0ePHmVkZASPxwPcP0U3m03ZIF2tVuX9LZouS6USs7OzMpwmKvXEHzG4rR8QeVBRUahSqZ47uqLRaAiFQjgcDo4ePcorr7yCVqvl9u3bVCoV2Sz5Vc/WF8FLFReNRoPNZuPVV1/l7Nmzcp6D6LXYynyxF9EwGQgE+M53vsPo6KjMsywtLfHxxx/LMlMFha8il8vRaDQwm82sra3JCkQxl0QMVXrrrbeku3alUtmUVzEYDLKBV+Ro9iMiLDYxMYHX6wWQM5dqtdpDc2xqtZqcInvr1i1sNhuHDh1ifHwcu90u//TTvdzpdKQDSa9z+/OcYMTzcGhoiIMHD3Ls2DFKpRKfffYZi4uLzM3N7Vhh00sTFzE+12g04nA4pAdYbyjiUVU2YmcYCAQIBAJMTExgMpnodrvSlntpaUk+APZbY6DCsyHcDnK5HLOzs2SzWWw2G16vV8axxfA0UURSq9Ww2WxPlFMRrgpi8xONRvtmF74VvQ9NgFQqJfOgj5phI65PMpmUI5NFZ7nX6yWVSr2U9/4yEM9AjUYjC2+etSdKhNgsFguTk5NMTU3h9XqlpZOoYhR9XDvBSxMXvV6P3W7H7XYTDodlIj+Xy8lBVVuJi9hNGgwGzp07xze/+U0GBwdxOBw0Gg0+/vhjLly4wPLyMmtra31pdqfwYhCec4uLi/z4xz/G5XLhcrmYnJzcNCkxGAxuGlAnLDy+ilarRbPZZH19nX/6p39iY2ODjY2Nl/DJdgd37tzhf/7P/0ksFntk82673WZ9fR2tVksgEKDdbmMwGBgfHwfuC9S9e/f6okBFVNTpdDpisRj5fJ5isfhMn81mszE9PY3P5+MHP/gBZ86coVQqcfv2bdbW1vjwww+5ffv2jlrpvPScS+9NK0wnhQ+OKD3sdrvS40mn08mEajAYZHBwELfbLR8M6XRa+mSJElyF50eIvVqt7tvqM/G56vW6tAxKp9PkcjkMBoMsGRVr9ElfU6xDERLKZDIkEgkSiUTf+mb1Ik59lUqFWCxGMpn8ysT8g2W5vc+LfkGspd7hdE+LuLZGo5FAICBLj51OJ6VSiUQiQTweJ5fLUSgUdvS+fWni0ul0aLVatFotaSqp1+vx+/0EAgFCoZCcHFmpVAgGg0xNTeF2uzl9+jSBQIDh4WFGRkYoFovcuHGDVCrF9evXuXPnTt8YVO40okFVr9fLKXn1er2vp3mKSYr5fJ4PPviAXC7H6Ogop06dwmKx4PP5MBqNT/Ra5XJZDrcT5Z9ra2tcu3ZN7lT7md7oQ71eJ51Ok8lktqxSEmGisbExjh8/zvDwMGq1mlqtJvMFomS5n9BoNPh8PqxWK+vr6081M8lgMGAymZiamuJP/uRPGBgYkLmp69ev85Of/IR0Ok0sFtvx6/bSxEXEn4XANJtNDAaDDJeJPIz4utvtZmpqioGBAd58802Gh4elSeXa2hobGxtEIhEikQiJROJlfYy+RixGsbsyGo0yt9XPPUPC/aBWq3H37l1qtRqVSkVOU3Q6nU8sLvV6XXo33blzh6WlJTKZDOvr631VVrsVD4a1e922t5qSKjzIhAGrGE7XarVIpVJEo9G+69KH+6JqtVrR6/VPXbau0+kwGo2bhiOKENv6+jqXLl2iWCzuigbqlyYu7XabSqUibQ9isRhutxuPx4PH4+Gtt94imUxSKpWo1WoEAgE5h8Tr9WIwGKR1wcrKChcuXCCRSPRVwm8nqVarMi7ebrfR6XSMjo7y2muvSV+ifhYYuH+CSafTchNUq9Wkk60YoPZVVCoVbt26RTabJR6Pk8lk9kWRSaVSkZNjXS4Xfr8fh8PB1NQUDoeDhYUFCoWCDOvYbDYGBwdxuVwcPHiQAwcOYDabicVibGxsEIvFSCQSfSUujUaDYrGIWq3G6XSi0+lkz0ur1XpsZECECEdGRjh06BCHDx9Gr9fTaDSYm5vjzp07zM/PU6/Xd43V00sTF5EjyeVycja2SqXC7XYTDAb50z/9U3mBO52OVHURp+x2u6yurvLJJ5+wuLjIb37zG7LZbN/vBl8WhUKBpaUlaSFvMpk4fPgwAF988cW+cDzodDpEo1FisRi3b9/mww8/lA/DJ/ULE0n/3qFk4rX7mVKpxI0bN8hkMkxMTMiQ9smTJ4lEIsTjcQqFgryfXS4Xp0+fZmBggFdeeYUTJ04Qj8dZWlqSI3jX19d3xUNyu2g2m+RyOXQ6HZOTk3g8HrxeLzqd7itHuYu83/T0ND/4wQ8IBoMYjUaq1SoXLlzgvffeIx6PyxHTu4GX2qHf7Xalz9DS0pJ0URVhGBGD1el0NBoNabBWq9VoNBosLi6ytrZGIpGgUqlIlVZ4fjqdDo1GQ07/Ew2CTqcTq9XaV4nVxyHWk2gAVHgyms0mmUwGnU4nWwJ0Oh0DAwMAhMNhut0uZrMZo9FIKBRidHRURiXq9TqZTIbFxUVWV1f7Mocqijzq9ToGg0E2jvp8PqrVKtlslmazuSk8rdPppHOBaOANBAKYTCbi8Tj1ep1kMvlShn89LS/d/qVYLPLLX/6S8+fPMz4+LofaiJG8U1NThEIhlpeX+fDDD6X9dj6fl3kW0bW7WxS6HxBhoF7BdrvdjI+PE4lEnrhaSmF/UiwWuXbtGg6Hg1OnTjE8PIzRaOTtt9+mUCjgdruJRCKMjo4yMjKCzWZjaGgInU5HqVRiYWGBjz76iL/+678ml8v15dyharVKLBZDo9Hg8XiYnJzk7NmzZLNZotEo58+fJ5/PywiOMPL0er384Ac/YHx8nMnJSSYmJlhbW+OXv/wlsViMzz77jOXl5a8Mrb1sXvoTo9VqEYvFZGy72+3idrvlES8YDMryzaWlJVKpFLdv3yaTyZDL5RRrlxeECOf0emzp9XpphbJfTi4Kz0az2ZRzbzKZDJlMRoa8rVYrIyMjGI1GDhw4wOTkJEajUTZSFwoF2VJw7949SqVSX4a7W62WnFQqXKA9Hg9DQ0N0u11sNpscvd1qtbBYLDidTnw+HwcOHODAgQN4vV7p27a2tianqu7GkPVLFxdR9tlsNtnY2KBcLmM0Grlz5w5Go5H33nsPu91OPB5nYWFBznsWPQMKCgq7D5FjqtVqfPrpp6TTaY4dO8bbb7+NTqdjenqaiYkJ2VVeKBSYnZ2lUChw9epVlpeXWVpaolwubwoN9ROin8poNJLNZikUCgwMDPCtb32LXC7H9PS0rKxrt9tYrVZpAnrkyBFcLhcbGxtcuXKFhYUFrly5QiKR2LUb7h2JdYhYdjweJx6Pb/pab+K0HxeYgkK/IsTl6tWrsqT77NmzMrxqMpmk5Uk8Hufy5ctEo1E+/vhj7ty5I1sU+pV6vU42m5XiWi6X8fl8jI+P02q1OHfunBzsJ4qahLuxSPpfv36dTz75RLpM71ZhgV04iVIRlJ2hN9kodk6xWIx79+7JcQgKCk9Co9GgUqlIGxKbzYbT6USv10sBicfj3Lp1i3Q6vSnP0M+IeyyTyXDp0iXy+bx02hZf653HJJL5ogxZiMvCwgKJRGLXC/GuExeFnaHRaFAoFCgWi3J3ee3aNemJtRtjugq7DzFqu1qtcv78ea5fvy7Lj3u/p/dhWq/Xd0XT34tGlCIXi0X+x//4H3Jsg4jWPFiKvFUJvHA3EU4nuxlFXBSA+8lGMb4gHo9jsViIRqPE43Gy2axSmafwxAjxqFQqyqakByEenU6HTCaz02/nhaPqPmEc6kmbyPYDz2o4t5sRRo0Wi4Xx8XGsVisbGxtEo1Hq9TqFQmHbwhb9eP1eJs8aOlau4Zcoa/D5eJLrp4jLM6AszOdDuX7PhyIuz4+yBp+PJ7l+SvOCgoKCgsK2o4iLgoKCgsK2o4iLgoKCgsK288Q5FwUFBQUFhSdFObkoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw7irgoKCgoKGw72if9RmUK25coU+yeD+X6PR/KJMrnR1mDz4cyiVJBQUFBYUdQxEVBQUFBYdtRxEVBQUFBYdtRxEVBQUFBYdtRxEVBQUFBYdtRxEVBQUFBYdt54lJkBYX9zvOUoj5r+bCCwl5FEReFfY9Wq8Vms6HT6fD5fNhstoe+R61W4/f78fv9aDQajEYjGo3msa/barVot9tEo1E+//xzSqUSxWKRer3+oj7KvkWj0aBWq/F4PDidTkqlErFYjFartdNvbd+iiIvCvkev1+PxeLBarRw5coShoaGHvketVnPixAmOHTuGyWTC5XKh1W6+fcTJRpxSarUa9XqdS5cukc/n2djYoNlsKuKyzahUKjQaDTqdjsHBQcbHx4lEIqTTaUVcdpA9JS4ajQatVovFYmFgYACdTke326XdbpPP54nFYrTbbTqdzk6/VYU9QCAQIBgMyvVkNpuZnJwkGAw+9L0qlQq/34/NZsNgMDx0cukNmQlxEf+0WCy43W6q1SrFYpFWq0Wz2aTRaLzgT9ifaLVaeXo0m80YDAb8fj9GoxGXy4XBYECn0+3029z37ClxMZvN2Gw2Dh8+zJ//+Z/j9/upVqu0Wi3ef/99fvzjH1Mul6nX64rAKDwWtVrNt7/9bf71v/7X8uGv1+sxmUzo9fqHvl+lUmE0GjEajajVatTqzbUwD+ZUev/bbrdz5MgRgsEgJpOJaDRKJpMhFosp6/QpUavV2Gw2TCYTw8PDTE9PEwwG+da3voXb7ebSpUt88cUX8veksHPsKXHRarXo9XqcTidTU1OEQiEqlQqNRoP5+Xm0Wi1qtVrxAFJ4LOIE7Pf7OXjwIBaLBafTiVarRaVSbQpvdbtdWq2WPCE/TUirXq9Tr9dpNBrytGMwGDAYDA+F1BQej0qlQqvVyvyY1WrF7/czODhIMBhkdHQUt9vNrVu35O9NKaLYWfbUCjcYDDidTux2u/xjsVhot9vyOFytVhVxUXgkRqORyclJvF4vY2NjMqwiNiVi7dTrdUqlEuVymVu3bpFOp4lEImxsbDzxQ0sk9AuFAmtra1SrVTKZDOVymWq1qpxangDxO/F4PExPT+NwODh27BihUAifz0c4HKZer3P+/HkKhQIXL17k+vXrFAoFJey4w+wZcVGpVOj1eiwWCxaLBbPZjMVikV+3WCzodDq5+1RQ2AqdTsfo6ChDQ0MMDAzI+PyDJ95ms0mpVCKdTnPt2jVWV1f54osvmJ2dfWJxEd8nTjzKTvrpUalUqNVqHA4HMzMzBAIB3nzzTSYnJ7FYLFitVlZXV/mnf/on7t69y40bN1hYWNjpt63AHhKXR9Fqteh0OvKfnU5nX9/E4mZ0Op0MDAxgNBrx+XwYjUZqtRrNZpNMJsOtW7eoVqtP9Jo6nQ6LxSJzDSqVSua/ABniyeVylEolGo0GpVJpV+3MrVYrXq8Xj8fD8ePHGRsbY2hoCJ1Oh0ajeWhDkkwmuXz5MqlUilu3bhGNRkmlUjSbzadeX/t9TT4pYu3qdDqcTicGgwGfz4fP5yMUCnHixAkcDgcAiUSCSqVCsVgkFotx9+5d1tfXKZVKO/wpFAR7Wly63a6Ma9dqNSkw+xlRSTM2NsZ3vvMd/H4/Z86cIRAIkMlkyGazXLt2jf/23/7bE4uL0WgkHA7LXIFarSYcDjM+Po5Wq8VoNAIwPz/P4uIi2WyWpaWlXfW78Hq9vPrqqwwMDPDDH/6QQ4cOodPp0Ov1W5507927x1/91V+RSCS4d+8e+XxehrkUoXgxaDQa9Ho9VquV6elpPB4P586d49SpUzgcDoaHh+l2u9y8eZP5+Xnm5ua4ePEiuVyOxcVFSqWSUnq8i9jz4lKr1ahUKtRqNVmGvF9vfhE6FLkpEZcOBoN4vV60Wq3cFYoyWnEa0el0ssKmNwcB96udhoeHpbhoNBoGBgYIh8PyAQ3Im9tqtdJoNKhWq+RyuV3R1yFEUIRSrFar/Fqr1ZLvvdFo0G63iUQiJJNJMpkMpVKJWq22g+++fxGnFbVajdVqxeFw4HA4GBwcxOPxEAgEcLvdGI1Gms0mzWaTVCpFJBIhEokQi8UolUqysGcvoNFocLlcclMG90OnIg/XaDQ2RWK262caDAY0Go2siOx2u3Q6HdrtNpVKhXa7TbPZ3DaB3tPi0m63WVtbY2Njg+XlZYrF4r5OlKrVagYHBxkYGODMmTO89dZb2O12GWJQq9VYLBaWlpZkbsput2MymRgaGmJmZga73c7U1BQOh0N2PRuNRjwejxQWIUBms3lTWe6rr75KpVKRJ5dkMslPfvITbty4scNX5j4iJ/dgiWoikeC9994jlUqxtLREIpEgEolw9+5deTJW2H7EWnI6nZhMJg4fPswbb7yB2+1mZmZGboLUajXpdJpPPvmEbDbLxx9/zOLiIsVikVwuJzcFewW3282/+Tf/hsOHD8v/l8lk+OKLL8jlcty7d49EIkGtVqNYLG7LZtnpdDI9PY3T6eTMmTMMDw/LiE82m+XixYskk0nW19eJx+PP/fNgj4mLqBwRO+pOp0OxWCSVSsnqkP18LBY9ACJGPTw8vKnowWQyodPpMJvNm4TDYrEQCASYmprC4/Hwyiuv4PF40Gg0m0IV4r9VKtVjF3w2m8Xn8xGJRPjNb37zMj76VyJOYlv1PlSrVZaXl1lfX2d2dpbV1VVqtRrlcpl2u0273d6Bd9yfiHtXdNVrtVqZvxscHOTYsWN4PB4OHjyI3W6XodxKpcK9e/eIx+PMzc1x7969Hf4kz4ZarcZkMnHkyBFef/11+f+j0SiVSoVkMkkul6NYLNJut7/yXnsSRI9WMBjE5/Nx4sQJpqenqVarlMtlYrEY6+vrdLtd0un0835EyZ4Sl0AgwNGjRxkfH8dgMOz029l1qNVqBgYGOHjwIAMDA4/0vrLZbMzMzODz+Th58iTDw8MEAgFGR0el0FgsFvkw7nQ6MkEvjuu5XI5MJiNPiSqVCqfTic1mQ61W4/V6abfbmEyml3kJHkm9XiebzWKxWGSTrdioOJ1Ozp49K3NIFouFYrFIOp2mXq+TSqWUsNgzolKp0Ol0eL1e2VEvqj1DoRAmk4nBwUFcLheBQACfz4dKpeLGjRs0m02WlpZYXV0lkUhw69YtisUi2Wx2pz/WU9FbTj02NkY4HCYcDuN0Ojd9z/Hjx8lkMjISsx0/d2BggGAwyNDQEOfOncPj8TA8PIzT6ZRhSL1eL0816XR6W3427CFxUalUBINBTpw4weDgoCIuW6DRaAiFQszMzBAOh7cUFxEKO3LkCLVajR/+8IecOHFC5iQePB0ClMtlstks9XqdSqVCvV5ndXWV27dvy129Wq2WN47X6+XAgQNyl7YbaDQaZDIZzGazzM+p1Wo0Gg1Op5Ovfe1rlMtlWq0WOp2ObDbL+vo6xWKRYrGoiMszIDYnBoOBUCiEy+XC6/Xi9/vxer2cOHECp9PJxMQEPp+PUqlELpeTRSfxeJyrV68yOzsr83d70d5JhI4DgQBnz54lHA4zNDSE2+2W32OxWDAajeRyOS5cuLAtP1elUjE4OMiJEycYGRnh9ddfl1WkdrsduJ+3Fp56Pp+Pubm5bfnZsIfEBb5MSul0OqWXZQvE8ddqtUrx7XQ6VKtV2u025XKZcrlMqVRieHiYVquF2+2WiT6NRkO325XhRXE8LxQKrK+vU6/XqVarNBoN4vE4Kysrm04u9XqdTCZDIBBAo9GQy+Uol8s7eUkk4uSi1+u5desWnU4Hh8MhO/ONRiN6vZ5AIMDk5CT5fF666+r1ehmeEac1JVT21YiuelFSHAgE8Pv9+Hw+nE4nFosFrVZLKpWS+ZN4PC7zDqlUimQySblcloUWe01Yek/0Q0NDjI+PEwgEHtp0PdhjJapfnzUkJow8XS4XoVAIv9+P3W7HarXK1gFRMNBoNORzodlsPvuHfYA9Iy4qlQqDwYDVasVkMinisgViIYfDYVwuF2q1mmazSTQapVAosLq6yurqKn6/n+985ztysfWeAlutFqlUinK5zMWLF7ly5QqJRIK5uTkpLJ1OZ0vjRb1ej06nY3h4mNdee41Wq8X6+vrLvgxbks/nmZ+fZ3l5mWQyidvt5sSJE5w6dQqv18uRI0ewWCycPXuWU6dOyVNapVLh9u3bpNNpPvjgA95//30ajQaVSmXPPeheNkK03W43r7zyClNTU1JcBI1Gg08++YSVlRWi0Sj37t2jXC6TTCapVquyoGI7K6deJlqtlunpaWZmZjh69Ch/8Ad/IO+7XtrtNq1Wi3q9TqFQkJuYZxEXtVqN2WzGZDJx4MABvvGNb+ByuRgaGtpkuNpsNmUBzsrKCmtra+Ryue342MAeEhf4cif0VXM09ivi+uj1elkN1u12qVQqsts8Go1Ky/jeY7lY3LVajVwuR6FQIBKJsLy8TDweZ2lpSZqEPmrB9wp+OBwGeOJemheNKLdsNBqsr6+TzWZxuVwMDAzInJJw2rXZbPJ6VKtVarUaNptN7v5EaFDxr9qa3qR9b6m7WJcajUb+PqrVKrFYTIrL8vIytVqNQqGwrbvonUAULTidToLBoBRWs9m85fe3Wi2Z03zWdSWeASK/5XA4cLvdOBwOjEajdIsWXnmNRoNarSatjraz6m5PiYvC0yNOItFolLm5Oa5duyZ7UAAZalhdXeXGjRtks1muX78uE3vr6+tUq1UZWnvcohdfy2QyfP755/LfdxNiPEOlUuHzzz9nZWWFQCDA0tISLpeLsbExaa3v9XqlXUwoFKLRaODxeFhdXeV3v/ud7OHZzxWKDyLcGwwGgzzhplIpfv7zn+NwODCZTBiNRrnuWq0WsViMXC5HpVKhUCjIZtW9jFarxWq1YrFYmJqa4vTp04RCoUcalorrlEqlsNlsTExMkM/nSSQST3xiMxgMWCwWbDYb09PTeL1emX/V6/UPbcqLxSIrKyvE43E2NjaIRqPbGsZWxKXPEcaJ2WxW9m74fD75QBT5g0QiwdWrV4nH4/z+978nHo9TLpepVCpP/TNLpdKuteHodrtSLAuFAvfu3cPr9UrhqNVq1Go1gsEgLpcLvV6Pz+dDrVbTarWw2WzcuHGDzz//XJ7kFHHZjAhfi2FphUKBK1eu7Mmw1rMiQlM2m41QKMT4+Dh2u/2RUZdWq0WxWKRUKmE0GgkEAgCkUqknvm46nQ6r1YrL5WJiYkJWiYkQ+YNUq1WZ1xI5xe0sXNn14iJKGfV6PTabDYfDIXsuut0uuVxO7nyUEMXjEc1mjUZDTkSMRCLkcjlu3rzJ7OwsuVyOXC4nE4r7gXq9zsbGBvl8nna7zcrKCl6vl4WFBbmLtNvtdDodgsEg1WqVc+fOkUwmWVxcJJlMytDCfl6DwiFifHycsbEx+f9rtRp3794ln8/LB2i/Ip5VHo+H06dP4/f7mZiYkKe2rTzs4vE42WxW2gxVKhU0Gg1Wq5WBgYEtT3EiZNsrPF6vl5GREXw+H4cPH5YOHb0/s91uE4/HKRaL3Lp1i4sXL5LJZFhZWZGnx+1i14uL2AGYzWY8Hg/BYFBWPNTrdWKxGHfu3Hmq4+N+RSTwRM6gXC5LF9nPP/+c9957b5NH2355UJZKJW7duoVKpeLq1auo1WpcLpdsOnv33XcZHR1lbGyMAwcO4PF4MBgMpNNpfvvb3zI3NyeNFPd6OOdZ6S07PnfuHN/85jdlaDGTyfCTn/yEhYUFVlZW+lpcjEajLK/+l//yXzIyMsLQ0BCBQOChEv9ut8vi4qIcF7C2tibtrAwGAx6PB5fLteXPqVQqxGKxTXmp0dFRTp48SSgU4tvf/rYMh/XSbDa5ffs2S0tLXLhwgV/96leymXK7G4Z3vbiI3ZBer5eTAIUvjvDjEX0I++Vh+LT0Dr8SidT19XVqtRqrq6usr6+TSqVkNdh+o9vtPpQ8VqvV6PV61Go18Xgck8lEIBDYZIcjPNaEqWU0GpV+TfsNEWEwGAzY7XZ8Ph9WqxWPx0O328Vms2E2m7Hb7bjdbllu229O5kajUZa4u91u3G63tEnaCuFQ0Ol0cLlcNBoN7Hb7Vz7ky+UyOp2Oer0uXzscDhMKhWQT9FY9ZiIPJkKWIgzcbDa3fd3uenERJm8ulwufz4fX65XVJtVqlUgkwsLCAul0el/e1L30GtH13rBixyQW1p07d/iv//W/YjAY2NjYkFb5e706ZzupVCpEo1GKxSIfffSRnHQ6MTGBVqtlfHycZrOJ2Wzm7NmzfPTRR0QiEUqlkix+2E/odDq50z5w4ADHjh0D7q+9VqtFIBCgXC7j8/mYmZkhk8lw8+ZNmdfrl01NOBzm7Nmz8qQbDAa3HJsN96/N1NQUPp+PdrstN8i9VYi9G8NeyuUy0Wh00z3r8/kYHh6W5d+Pone0gXDU2JfiIrq8hWWEyWSSbsjNZpNyuUwul6NarfbN7ud5EALTuzhFJzogrVuuX7+OSqWiUCgo3edb0OtSG41G5RTJer0ud+fiJOh2u7l375507q3X6/tOXITbrtVqlbt2MSRNVDGJr4mS75WVlaceHb3bEXmSYDAoT2uPQ0zU3YoH8zO9z7dKpYLP59t0crHb7fJ0/TjEM0FEg1qt1lf+nWdh14uLwWBgcnKSoaEhgsEgKpWKarXKxsYGyWSSRCJBLpej0Wjse3HpdDpEIhFu3bq1adc0MjKCzWbjs88+A5Dd+mJXqfBoeptKL1++jM1mIxgM8sorr8jQg06n4/Dhw/zRH/0R8XicTz/9lEQisa325bsV8aDy+Xx85zvfIRwOMzw8LL+m0+lwOBycO3dOWgKpVCpyuZwst/3444+lA3WlUtmz97GwW/na176Gx+PZZBq73Yjue2FuCUj7pschCi6cTicej4eBgQEikQi/+MUviEaj2/oe94S4TExMMD09LcWlVquxsbFBLBaT4qJwXzRisRjz8/MYjUY6nY4UF+HnpFKpZN5F4atpt9ukUinUajVXrlyhWq0yPT3N5OQker0es9ksxUWr1bKyssLy8rKcMdLv4iJOxT6fj29/+9tywqf4mhhRfObMmU2iUavVOHPmDJlMhnw+L53N93oEIhwO89prr71wTz0hLvD4E86DaLVaxsbGGB0dZXx8nCNHjjA/P8/58+f3n7jAl7ujXvZr4vRxdLtdGSYsl8t0u13ZJazX6/F6vYyNjVEqlUilUn3/4NtOut0uxWKRaDSK1Wrl9u3b5HI5hoeHcbvdsvy0UqkQDAYpFAokEold41DwohD5gVqtRjKZxGQyYbPZMBgMsgNcjNau1+ub5gHZbDasVitut1v2dey2ptunpV6vSwdxk8n03G4ivTmXR51KHqxAe5LvE8/UreYbbRd7Qlx62cu7mhdNp9MhmUyysLDAyMgInU5HlnLr9XoOHz7MH/7hH7KyssJ7771HPp/f6be8Z+h2u0QiEel20Gw2CQQC0lXabDYzNTWF3W7n9OnTOJ1Orly5QiqV2um3/kIR1V5i4NTKyor0AxMeWdlslvPnzxOLxWSH/vT0ND/60Y/w+/1ytsjNmzdZW1vb0/mqbDbLwsICTqeT0dHRr8y5PI6tSpcf9X2P+/qjXmsrB/TtZM+Jy36l9/T2qJtP7CDL5bKsWBJzS4THUSgUolwuK/5sz4AYs5vP54lGo7TbbTkG2WQySUNCr9dLsVjEbrfLHXy/nxLFSAO1Wk0ikcBut1MsFkkmk2SzWVZXV4lEIjidThwOB6VSSVYsGQyGTb5Xexnhvq3RaGg0Gl/5mURebiufut4Hv8hVCXPY3u958N9FoYl4vV4hERGfTqdDuVymUChQLpdfSBRoz4nLfnVDNplMeDweOp0O6XR6ywqvbrdLJpOh0WjIXXa73cZqtUqPLDF58pe//OUOfIr+oFgsMjc3x9raGg6Hg9XVVWZmZvj617+OxWLhtddeY3p6Go1GI0cXLC4u9k257VYUi0WuX7+OwWBgfn4eh8NBo9GgXq/TaDRIJpM0Gg0mJiY4e/YsY2NjMi8oBmRls9k9HZnodrusrq7y4Ycf4vf7qdVqmwaCbfX9d+7cYX5+XhpI9n5+8azT6/WyefzkyZMcP35cbjQfvF5iZIYYcCeqasXrtdttWV27uLjI7OysLIzabvacuOxX9Ho9DoeDTqfzyPJh4e7baDTkLBa9Xi8rmsQcjVgs1he7xJ2iXq8TjUZJp9PcuHGDcrmMxWLh1VdfxWg0MjExIacoLi0tEYlEWF1d7WtxqdVqrK2tAbCwsLDpa70WThaLhcnJSYLBIFqtVuYJM5mMzBPuZdLpNPPz8+TzeQYGBh5rBNntdrl27RoffvghjUaDUqm0ZVTCZDIxNTWF1+vF5/Nx7NixTa0GD14zsaER85t6i3dE0U+hUGB2dpbz58/LE8x2s2vFRQy7sVqthMNhxsbGHmmF0K+o1WrC4TAej4fBwUGOHDlCu93m+vXrJBIJEomE7AoXiCSq2C2XSiU55U5U9pjNZoLBILVajXw+3/dJ50eh1+vlLBsRRhBDqZ6ETqdDKpVCq9WytrbGxsaGTFKLk+LZs2e5e/cuS0tLqNXqfeXZ1ttPEQ6HsdvtclqpzWaTu/VsNks2m93TZcgCYeMifOoenNvSS7fbZWFhgWQyKfujtgpPqVQqfD4fQ0NDOByOR0ZvhL9dJpOROS5h9yReR7iC12o11tfXKRQKT7Xmn4ZdKy5ilrnL5eLQoUMcP378kZ2u/YpWq2VmZoYTJ04wPT3NW2+9RbPZ5De/+Q1LS0t8+umnxGKxTTekyAtEo1GuXbsm+w6EM6pWq8VmszE2NoZGo+Hu3bv7VlzMZjNOp1PavwgH6Se9Hu12m0gkQiaTwe/3Mz8/j8fjYWZmBofDwZEjRxgcHOTzzz+XnmX7qUqvd70dPnyYgYEBjh07xoEDB+h0OlQqFXK5HIlEQrob7PUK0HQ6TTabRaVScfny5a8M44vxAr35kQfR6XQMDg4yMzOD3+9/5GuVy2U2NjZYWVnhpz/9KfPz83JmjqDXAUCMPHjUz31edq24iASUOMH0ziPY67ubJ6V3sqTP58Nut8s+gK/abdRqNeLxODqdjnK5TLPZlNdUjJ2tVqu7ZlLky0Kj0eBwODaN3m21WhQKBer1Os1m86nEVlxXkbSu1+sMDQ1JXzLhrzU2NibdJcTf281hMnHCFVZL4s/TdNMbDAZp3RQKhaT9u16vlwPBxImlX+bi9E7MfF47JdFCYDabsVqtskCkF7ExarVacv5LIpGQDtRimudOsGvFBb6skBACs9+S+VqtliNHjvD9739fjncuFArcuXOHy5cvs7Gx8UihjUQivPfeewwNDXH69Gk5qkBUM33jG98gGo3KKYD7BavVyltvvcXY2BhTU1McOnSIQqHA/Pw8mUyGf/zHf3ziXotutysF6YsvviCTyTA0NITBYGBqagq3243T6eT48eP8p//0n0in0/z0pz/l6tWrJJNJ1tfXd+1O3W63c+LECaxWqxSATCbD+vr6E4uA6FYPBoN873vfk2Eds9lMLpfj2rVrcv1ls9mvHEa337Db7YTDYYaGhpiampKl7g9a6EejUbLZLLdv3+bixYty+NdOnwR3tbgIhMj0XlThn9XPi1GcXMQEOzHFTgy6ajQaaDQauYB6r4UYH2swGKRrtLCHMBqN0u3gRXcS7yZEKWc4HGZqaoqZmRmOHTsmG/yEN9bT0NvnISpzksmkHIms1+txu93YbDay2Syffvopy8vL0n5nt6LT6fB6vTidTvR6PcViUfZRPZhEfjCkI+5Vu93O8PAwoVBoU+e+2G2nUini8bhcywqb0ev1OJ1O+af35NJbdixGmMfjcVZXV0mn07vCHWJPiAtsLkGuVquybr6fZ0OIhZPJZDCZTDidTmw2G++88w4HDx7kzp073LlzR869FyGdRqMhk/dWq1XGt8WD02QyMTIyIifl7QfMZjNut5tgMMjhw4c5duwYgUAAnU5Hs9lkfX1d7vaeBeFqm81m+eKLLygWi3S7XTmsSaPRYDAYcLvdDAwMUCgUdr24iPlJJ0+exOl0UigUiMVispejXq/LqZ7VapVEIkGr1SIUCslc6RtvvCF7WwA5jG5+fp5PPvmEjY2NF1IG2w+YTCZ8Ph9+vx+r1YrRaESr1W5aN/V6nQ8//JDz58+TSqVYXV2Vv4+dZs+ISy/CW2xtba3vxUWEI8QNarVaefPNN6nValy+fBmPxyMrVKrVKtlsdtM1sVqtMlYudjJGo5HBwUHpNr0fMJlMcuzrgQMHmJmZQafTodPpaLVaslz4ecRFVOLMzc3JENmxY8fQarXyZ7lcLgKBANFodNeLi8iVvPbaaxw+fFham1SrVVZWVigUCuRyOTKZDLlcjrm5OVqtFseOHWN0dJTR0VFOnTqFwWBArVbT7XbJ5/Osr69z9+5dLl68yMbGxq4NDe40RqNRjhmxWCwP5VvgfvPqhQsX+Ou//mtgd+Wj96S4tNttisUixWKxr4/TwuX45s2bDA4O4nA40Ol00rLc7/dz4MCBTfbbIgQmEA+IrZKBu/nhtt00m02ZQI7H40SjUZlsNhgMhMNhtFothUIBvV5PuVyWeQAxmbM3Wfuom1i4KHc6HRYWFrhx44a0AtFqtXJMcjqdxuPxUK1WH9nfsJOIXh6AYDCIyWTCYDBgtVrlKdBoNMoBYKVSCb1eT6vVYnx8nEAggMPhkCW2sViMcrnMysoKKysrskqx30Pbz4OISNhsNqrVKs1mU0YkxIaxUqlgNpvx+/1ycOJuuZ57Rlx6Ddmq1SrRaJSNjY1dcfx7UTSbTS5evEgkEuHs2bP4/X4Ze7VYLBw5ckSWdQqrlwen+mk0GiwWixSl/UqpVJK5jsuXL1Or1Th8+DAOhwOXy8Ubb7xBqVRifHycjY0NFhcXuXTpEpVKRQ5SE93mwl5jK6rVKrdv30ar1dJsNllZWeHw4cP86Z/+KU6nk1deeYUjR46g1+tZXl4mk8lw7969XXcCz+fzfPrpp9hsNtkzNTU1xRtvvCF7eXqtRMQgum63KyvlGo0GhUKBVCrFP/zDP7C4uMjS0hIrKysyhKicWh5NqVTi3r17NJtN0uk0xWIRo9GIyWSiXq9LR/hAIMCpU6dYW1tjfn5+x3Mtgj0jLsCmRSzqt3fLhXwRdLtd6a4bj8fljBAxQE2Ui/b6jj2JEV2n06HRaOyrme+9n1mYTw4MDMhrIE52vWMdgsEglUqFQqFAq9WS3c6iP+BxO0Qx3a9YLMrmQLVaLRta7Xa73JG+KFfa50GUZ7daLWKxGFarFZvNRjqdxmw2y9h/73rrdX0Qeb5UKkUikWBjY4P19XWi0SjxeHxTj4XC1gjvNb1e/1ARhTiJi9+RcJveTewpcSkWixQKBaLRqFyk/TxFUfiIlUolOdbU5XJx9uxZgsEgLpcLt9uNwWDA6XSi0+mk1ctWYwoE6XSa69evE4vFiMViL/lT7SzlcpkPP/xQlsHWajXcbjcTExM4nU4sFgtTU1McP36cb37zm7RaLdnotrq6Km1cvqrMU6VS4fV6cbvdjIyMyAeveAiIoWMAd+/efSmf/WkQFiLFYpHLly9z584dzp8/z69//WtMJhMDAwMyD2A0Grd8jWQyydLSkiyfz2azlMvlrxRmhfuMj4/zZ3/2ZwQCAcbGxrBarXLAXyqV4pNPPiEWi3HhwgXu3r276zaLe0pc6vU6+XyeQqEgcy79Pvdd+AMVi0U2NjZkE9ro6CihUIhWqyUHVun1erRa7WN3MaJIYHFxkUgk8kI8hXYzjUaDhYUF+fAfGxuj0Whw8OBBbDbbI0fOdrtd5ubmmJ+fl7Y5j9t5i2ZV0UgoQpJipy9OL8VicVeGKzudjgw5l0qlTfM/jEYjU1NTuFwuOb54KzY2Nrh9+za1Wm1f3Kvbjd/v5/Tp03i9XjweD3q9Xoa/S6USi4uLrK+vs7y8zMbGxk6/3YfYU+LSarWk06qIf+8mpX6RiHBgsVjk5s2bxONxHA4HDocDvV4veyo8Hg82m00ObRL+bFqtlnw+T6lUYmNjg/Pnz5NMJvt+3sjjWFtb4+OPP2ZkZAS3243X6yUYDOJ0Oh8KL6pUKlwuF+Pj47RaLarV6lfmC3Q6HVqtVhZiwOaqsng8Tjqd3hMPXZF4F951yWSSUqmEwWBAp9NtuZnJ5/PypKLkVp6eer1OLpeTPUcmk0k+BxqNBuVymVKptGvDi3tGXLrdLq1Wi1qttqm2fr/Qa79x8eLFhxpLRRVJOBzG6/XicrkYHBzEaDQyNDSE2WxmZWWFtbU14vE4n3/++a6sUnpZdLtdbt++zcLCAuPj4zgcDulmYLPZZG9Kr8AMDAwQCAQe6wPVi/i74rVE82Cz2SSXy7GysiJHJOwFRM6z1Wqxtra26fNthUj4KyGwZ6NWq5FIJFCr1QwPDwNfbjLF6Tmfz+/a9bNnxEWlUskjuclkkhPthOHgfkGI7Fao1WoZ5hJJPjEzw2QyEYlEiMViZDKZTXMe9itCsMvlsrQ1sVqtVKtV2a0vBEaj0cg/wlT1aRKo4qEcjUbJ5/MyJLnb4uRPinISefGIUGTvOhPrSJxcxMlwN7JnxAXA6XRiMBhIpVKMjIwAkEgk9l3e4FEIC/hcLkckEmFhYUFanqvVahlKFGW1CvdJJBL84he/kPNGjEYjw8PDHDt2DJPJJKujbDYbNpsNj8cjRxs/CZ1OR+Yd/uEf/oHPP/+cpaUlOUBst+48FXYWseYsFouszhOikk6nWVhYYG1tbdfey3tCXMTRWqvVylOLOLnsxmToTqI8rJ6eer1OJBLZ9P/y+TwWi0WeYITPk8PhkAOunvTk0mq15Ez5lZUVbt26RSqV2nFjQYXdTW+ptwgxiqZeUVb/uGFkO82uFRfRlyCareLxuIxXx2IxotEoyWRyX+VdFF4eqVSKK1euoNVq5bgHUf1lsVj4f//v/z3xNM/efOHVq1eJRCKyO11B4VEkEgkuXLhAIBBArVYTDAblJltUGzocDuknuNvY1eIiFDqXy5FOp2VIR1Q5CZsNBYXtRhgsPopntc5RBEXhSRH9aIFAgHA4jEqlku4IworHZrPt2tlAu1ZcxG6vWCxy9epV2VfQarVYWFiQXc/KzaqwEyjrTuFFIwb+NZtN2fTscrlwOp3SFgZ2r0egqvuEd8lOfABRpSP6NcRbFR3SO1Vl8ywPlt26AHYC5fo9H88qbMo1/JK9sAZFZaLocxFzmAKBAIVCgXv37lGpVKTzwcvkSa7frj25wJenl2w2u9NvRUFBQeGlIkrlm80mmUxG5vi63a7Ms4iO/d3Irj657Fb2wq5nN6Ncv+dDObk8P3ttDWq1WtRqNUajEYPBIBuqhfi87CjOnj+5KCgoKCggGyV3Y+L+Uewuj2YFBQUFhb5AERcFBQUFhW1HERcFBQUFhW3niRP6CgoKCgoKT4pyclFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HaeeFiYMsXuS/baFLvdhnL9ng9lEuXzo6zB5+NJrp9yclFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2HYUcVFQUFBQ2Hae2P5FYe+jVqtRq9UYDAY8Hg86nQ6LxYJerwdAo9HQarUoFos0Gg1yuRz5fH6T1YNWq0Wj0aBSqVCr1XQ6HRqNBp1OZ6c+1rajUqnQ6/WYTCa0Wi0WiwWdToder0ev19Ptdmm327RaLVKpFKVSiXa7TbPZ3Om3rrAP0Wq1qNVqzGYzVqsVtVqNSqXaZFfT7XbpdDq0223K5TKNRmPT/282m89sK/TI97Wtr6awq9HpdBiNRoaGhnj77bfx+/0cOnSIgYEB+fAsFApcvnyZRCLBRx99xIULF2i327TbbdRqNXa7HZPJhE6nw2AwUK/XicVi1Gq1nf5424IQTp/Px8TEBA6Hg5mZGdxuN8FgkEAgQKPRoFQqUSqV+P/+v/+P69evUywWyWQy236DKig8DpVKhc1mw2QyMT4+zqlTp9Dr9eh0uk3f1263qdVq1Go1bt68SSwWk8LSaDRIpVJScLYLRVz2EQaDAavVitvtZmRkhGAwyOTkJENDQ1Is8vk8mUwGk8mEx+PBaDTSbDaleGg0GilEBoOBbre75w39VCoVWq0WlUqFwWBAp9PhdDoJBAI4nU5GRkbw+XyEw2FCoRDNZpN8Pk8+n8fv92O1Wmk2m6hUKkVcFF4KKpUKnU6HVqvFZrNhtVrx+XwMDQ3JNaxWf5n1aLVaVCoVqtUqyWSSer0u/3+tVqNUKtHpdOSf7UARl32CRqPh5MmTfP3rXycYDPLqq69itVrpdDqsra2h1WrRarV0u10mJiYYGRmh0Whgs9lYW1vjs88+o1qtSqERp5m9HBJTq9VoNBqcTicHDx7E6XRy+PBhhoeHsdlseL1eDAYDPp8Pk8mE1WrFYrHQ6XSw2Wy43W7OnTuH1Wrlxo0bJJPJbd/9KShshc/n48yZM7hcLg4ePEgwGMTr9TI0NIRGo0Gj0Wz6/m63S6vVotVqcfLkScrlsgyTpdNpPvzwQ6LRKKurq0QikW15j4q47ANEfmRqaop33nkHt9vNxMQEWq2WhYUFUqmUzMeYzWbGx8exWCyUy2U0Gg03btzg+vXrVCoVWq0WzWZT7nDEv+9F1Go1Wq1Whr4GBgZ45513OHHihDyh9fLgCa1er3Pw4EEMBgPFYvGhG1pB4UVht9s5ffo04XCYV155hdHRUZkn3IoH164IiXU6HdbX1ykUCtjtdkqlkiIuCk+GWq3GarXKMJfX60Wv18td9uXLl1lcXJThHLfbjV6vJxAIYDKZGB0dJZlMotXeXyqtVku+bqvVot1u7ylxUalUMmc0NjbGgQMH8Hg8nDhxApfLhc1mo1arkc1miUQiNBoNyuUyzWYTk8mE0WjE6XRy4MABANbX15mbm0Oj0fD2229TLBZZXFykWCxSqVT6JhfViwgjajQajEYjRqMRg8GAw+FAp9PJHIDI8T0ubNpqtVhZWSGVSlGpVMjlcnJNKSHG+4hwrUajkXm/sbExDh06hM/nw+l0otfrN21uxLUTEYatxKW3wGdgYIBWq8Xdu3e37X0r4tLn6HQ6/H4/TqeT0dFRxsfHyefz3Lx5k2QyyU9/+lOZtG+1WoyMjOB0Ojly5Agul4vh4WFKpZLMr9TrdRmvFTmGvfQQ0Gg0UkTeffdd/uzP/gyTyYTdbketVlOpVCgUCly/fp2f//znZLNZVldXKZVK+P1+fD4fR48e5T/8h/+AyWTi+vXr/OpXv+LrX/86//k//2dyuRz/+3//bxYWFohGo30rLmazGb1ej9/vx+/343a7mZ6exm63MzExgd/vx+Fw4PP5HjrR9T7oyuUyP/vZz/j8889ZXV3l5s2bNBoNarXanlpXLxKNRiMLab72ta/xjW98g2AwyNmzZ7FarbJarPe6CnGu1Wqb7lf4UniMRqMM9wqhmp2d3bb3/cziYjAYsNlsaDQa+cHq9Tq1Wm1TuGSvPXz6DY1Gg8PhwOPxyJLadrtNJpMhkUiQTqflbrHVauF0OimXy1SrVVwuF0ajcVN4qPd3uVd/ryIkoNfrcTgcmEwmLBYL3W6XVCpFOp0mHo8Ti8XI5XIkEgnK5TJw/6YNBoPkcjkajQb5fJ5isUi73ZavMTAwQK1Wo1qtkslkZGy7XxAPO4vFQjAYZHBwEKfTSSgUwmaz4ff7CQaDmM1m7HY7KpVKfn4R91er1ej1elQqFX6/n8HBQarVKhaLBbVavafDrduNOLlYLBZcLhfBYBCfz4fZbMZoNMpQdW+5cbFYpNVqUSqVqFarD71mt9vFarVit9up1WrynheRie3gmcVlbGyMH/7wh9hsNux2O3q9nvn5eW7cuEE+n2dtbY1qtUqj0dj0wRVeLiaTiVOnTjE5OcnY2BgqlUom8FZXV1lbW9tU495sNkkmk0QiEWw2G4FAYIc/wfbSbrfJ5XLywZ/P5+l0OhiNRtrtNhcuXOCzzz5jcXGRL774QopEq9Wi2+1SKBTQarV8/PHHmEwmlpeXZYVdIpHAZDLxx3/8x7RaLf72b/+WarVKpVIhm832jcCYzWZeffVVxsbGmJ6e5siRI+j1eqxWKzqdDrPZjMFgoFQqsby8TKvVkqHF9fV1NjY2cDgcTE1NYTKZmJmZ4dixY1y4cIF6vU4mk2F+fp58Pr/TH3VXoNfrCYfD+P1+Dh8+zIkTJzCZTBgMBjqdDplMhmKxSL1el6HFzz77jFQqRTQaJR6Pb7kRDIVCjI2N0el0yGaz1Go1FhcXt+19P7O4iNCJ1+uVO1yNRkMmk8FoNMqaf/HnwRjqy9z1bhXz3au77qdFhMWGhoZwOBwA1Go11tbWWFlZoVgsbhL9brdLtVqVD4N+u04itNdb99/bGBmNRrl16xaRSIRkMrlpJ1epVKjX66RSKVZXVzGZTOTzeXliL5fLmEwmpqamMBqNXLp0CbPZTKfT2fPl2r1otVoGBgYYHx9nenqaEydOyIbaXorFIrlcjlqtRqFQoF6vc+/ePe7evYvX68VsNuN2u5mZmSEUChGLxQgEAnS7XZnjU7if37TZbLhcLjweD4FAQIYaRYlxPp+XId1UKsXNmzdZX19nZWWFtbW1LV93ZGSEXC6HSqWiVqvRbDbJ5XLb9r6f+TdoNBrxeDz4fD7cbjdGo5Hjx4/jcDioVqskEglqtRqpVIp8Pk+hUCCRSNBsNimXy9Trdcrlsjy+1ev1bXmQqdVqGf4Rx0ZRZgtfNsmlUikikUjfn6ZEPbx4gNbrdarVqmwCfLCrXKfTEQqFGB0dRavVkkwmyeVyfXWdROhgdXWVTz/9lHA4jNPplP0toVCIer2OwWAA7p92ek/e6XSaTz/9FK1Wy/r6Oo1GQwqy0WikXq+j0Wik6GzX2t5NiE2jOAFms1muXr0q83NarZZEIsG9e/fkmms2m6RSKVKpFBaLRZ5g6vU6rVaLarWKx+Oh2Ww+VKm3H1GpVGg0GqxWK9PT00xNTREOh1GpVDSbTXkfv//++9y4cYNarUalUqFcLnP37l353H0U+XxenlREcU6xWNy29/9cORev10sgEMDlcmEymfD7/Zw8eRL4sq56eXmZWCxGJBLh5s2bVCoV4vE45XKZaDTKxsYG9XqdZrO5LWEDkWMwGo34/X48Hg9arVaerESVy61bt4jFYn310NwKYWUiHpRiAYqFt5W4DA4OMj4+TrFYJJFIyJxMvyBOKSsrK3zyySccOnSI06dPYzAYcLlcDA4OUiwWMRqNMinaW7qZTCb5+OOP5Wt1u10qlYr8O41GA51OJx+qjUaj78QFkJ87k8lw584d/uqv/opYLIbNZsNsNhONRllYWJCh8QejFyqVCrvdLpP/1WoVn89Hq9WSlkT7GVEqb7FYOHLkCCdPniQYDEpxyefzpFIpfvvb3/KrX/2KZrMp15p4rj1u3Ql7p162c50+s7iUSiWWlpao1+sYjUbMZvNDR39xnBPhlWq1Sq1Ww+12U6vVCAQCDAwMSDuNBx9gD1Y3fBWiRFJ0lrtcLpxOJ1qtViYPRWVFOp3e1MHar6jVaoxGIxaLBZVKJX8HvTf8g4gmLJE7i8Vi25ro2w10u11KpRLxeByXyyU/o8ViYXR0VIYOxYlb9PiI6yBCXaJqyuPx4PF4ZIJUhCsajYbM1/QLrVaLeDyOyWSiXq9TKpVYWVkhkUiQyWTk/ZzL5eSp5FHXoNFoyHJuAIvFgs1m2xf35lchyoSNRqNMvhuNRuB+iPbu3bvEYjHS6bQM9T7tffoi1+Uzi8vq6ir/9//+XwYHB/nzP/9zPB7PQ9+jVqvx+/24XC5GR0c5duzYJpM0kewU/jYPftBnERfxMBX/NBgM8nV6F2y73eY3v/lNX3dUi4ocYV3SaDRIJpMyVPlgvkX8HWErMT8/z29/+1sikQiVSmWHPsWLIx6PUygUKBaLHDx4kHA4zOTkJKdOnZJ5gEQiwQcffEA0Gn1op6fRaBgcHMTn83H8+HFeeeUVVCoVKysr5HI5otGovMb9JC7lcpnz589z7do1Wc5aLpdZXV2lXq/L/olWq7XJIHErarUa77//PteuXePs2bP84R/+IQaDAbPZ/DI/0q5EnKTF/Ts0NCRtijY2Nvjxj3/M8vIyt2/fluXGu4lnFpdqtUo8Hkej0VAoFGQJcqfTkbYa4mEvHvB2u13+/W63K49xnU5nS8V9Wq8m4QQqfgF6vf6RiUGbzdZXSdYHEZ9NpVLJB4DIDYidtTgpimsm8lTidFcul6UQ9WP4UOyqc7kc8XgcnU7HxMQENpsNj8dDOBxGp9Ph8/lkwlPYZoh1LmxiXC4XdrudZrNJvV6nWCxKm5x+Eha4f2rL5XLSwUGr1cpm06cNn3a7XVnKXa1WZVOmcnJBhvNF7lhUh4nqu42NDSKRCOVy+anWWK9rcu9zovePsHZ6rvf/rH9RxPzUajUff/wxGxsb5PN5stksFotFWog4nU551PX7/ZsaqjQajWzOe7AfZquO0sex1UXa7wtUxGxtNhtOp5NEIiFzYK1Wa5NR44EDBzhz5gxDQ0MMDQ3J47dIxPbbAxK+zL3E43F+9atf4Xa7qVarZLNZjEYjMzMzTExM4Ha7yWQyXLhwgYsXL8oktsFg4MiRI5w6dYpDhw5hsVhknkqE1PqRTqcjQ6viQfWshocajYahoSFCoRCDg4P7/p7txe12c/z4cYaHh7FarXS7XWKxGPF4nPn5edbX14nFYlv2sTwKjUZDIBDAZrNJBwWtVisdFSwWC0ajkUgkIv0En5VnFhehniqVirm5OVKpFLFYjPX1ddxuN8ViEY/Hw8DAAG63m06ng8/n2/Qa4vi8Fc8qLk/6/f2OEFiNRoPJZMJsNsseFpGgF5VkRqOR4eFh3nzzTfx+P16vV1brPC5evtcRG5p8Ps/169cxm82Ew2G5OTp06BBqtRqfz0e5XKZcLsu+llKphF6vZ3h4mCNHjjAwMCA9xkQ5aD+GEgXblYNTq9V4PB5GRkbweDyKuPRgtVoZGRkhHA7L4pJcLsfq6iobGxuk0+mn7gVSq9U4nU78fr/M5YgqSaPRiNvtxuFwcOPGDa5du7Zz4lIqlWi1WiwtLckPmk6nKZfLsqPU6XRiNptxOBz4/X4ZetHpdNKr6VEXoZfeXZHoNeitQOnNq4jXP3jwIJOTk/JrzWaTxcVFUqkUi4uLfVUB9SB6vR673Y7dbt9kJ+9wOBgcHOS1116jUqkQDAax2+0cOnSI0dFRjEYj2WyWTCZDLBYjlUrJUJCg34S8d67FvXv3AFhbW5Mls+FwGJPJxOTkJN/73vcoFAqsr6+j1WqZnp6WfQeRSIRYLMbCwgILCwtks9k9f21eNFqtlpGREY4dO4ZGo2FlZYWNjY2+tM3ZDorFIuvr6w/1YAHyOavT6aRoiHCaeO7q9Xp5z4vCHWHeqtfrcTqd2O120un0c/caPfPfFuXDKpWKRCIhj8biQX/79u1N4SmxixZ9FFarlUAgIEvrHuRxD7BkMsnly5dln0bvg0+v1zMwMIDdbuff/bt/x+TkpPxarVbj97//PZcvX+bmzZt9VwHVi8ViIRQKyR01IK+5KLfVarUcOXJE/rter6dUKjE7O0symeT27dusrq5K8zvgoVgt0BciLZoqL1y4wOeff47b7WZwcJBwOMyPfvQjDh48yLlz53j77bcpl8tEIhHa7TbDw8O43W4ikQi3b99mZWWFTz/9lLt37yoPyCdAp9Nx9OhR3nnnHWZnZ/nggw+IxWLb2m/RL3S7XeLxODdu3GBtbe2hnIgwVBUnHjHjxePxYLVaCQaDGAwGaXIpGn81Go3sDbTb7dhsNnK53HOXgz+XNImH+lYPl0eNfBUNfV913HqcuKTTaXlCarVam8RFlCCLuRu9p5put0u5XCaXy/V1yAKQib/ehLLwg2u1WhgMBlkZ1mw2N8XO0+k00WiUQqHw0PUVu53eMcf9Yu3T7XZpNBo0Gg20Wi2pVAqtVkskEpE3rN/vR6VSyVCvKICo1+skEgmSyaR0Q+7nzct2IAp/RNJaNJ7u5RlB24lWq8VsNksbfTHYS1QgCr9AQSgUYnh4GIvFwuDgIBaLBY/Hg9vtxmKxyMiRuH9Fsysg72XhRbYdvW0v3WNBzB3PZrMkEgkWFhae+jVEHf1WuQCj0cjU1BShUOihHI/wlUokEhSLxb4OWZTLZdbX1zEajdRqNTm6V4iLsD6Zm5sjEonIEanxeJz33nuP+fl57t27t+kmF9VRwsxSr9fTaDSIx+O7shTyeahUKkQiEXK5HH/5l3+Jy+Xij/7oj3j33XfR6XQyPyBOhWtra/zmN78hHo9LJ4p+Xl/PixAVi8WCyWTCZDKhVqtpNBp96WjwLDgcDg4dOoTX65X5lmQySTQaxeFw8Cd/8ieYTCZ5rYaHh5mZmZEpCZ1OJ/9otVq5VkXKQRhe9nb0z83Nsbi4yNraGqVS6bne/0sXF9HxDEin2e1Eq9XidDqld5H4mcLyQxwF+30B9441FQIhyjx7izHS6TR3797FZDJRqVQolUpsbGywtLS0pc+QGIcsmruEK3a/IQoZ6vU6d+7cwWQy8corr1Cr1eSDsTcmLcQ8mUzKsnyFRyNOzb0Pv96TcD/fm0+KiMKIFg4hvLVaDZ/Px+TkJC6XS16roaEhZmZmZNjrUdEfcX1FQZWwLspkMiwuLnL16lVyudwjo09PSt+4w4ldUDAY5MCBA0xOTuL1elGpVGSzWe7cuUMymWRpaUlW8vTzAhYVOOPj41itVuDLxRmJRPjkk09IpVJcvXqV1dVVWTabyWRYX1+Xhoz7HRH+E+WaDodDDm7qxeVyMTMzQyQSIZFIPPeur98Rg+jErCERrtnvCNcHg8EgvRtdLhdWqxWNRsMrr7yCwWDA6XQyPT29qSBKJPMfnO0CkEqlmJ2dlVWP4lkgNpTi5LK6ukosFpM9Ws9D34iL+GUEg0EOHTrEoUOH8Pv9AGSzWS5dukQ0GmVpaYlMJtP3w4hEjfzQ0BA2mw24X4RRKBRYXFzkZz/7GWtrazL0I3YqIhzUr42Tz4KoqBHVOOIh2Lt+XC6X7HW5evXqTr3VPYPJZGJkZISBgQE5SVFxQr4vLqIvUIhL74bm9OnTzMzMyIowETXozS1vRTKZ5MMPPySZTMr5RMKip1arSUHZzlNj3/w2e7tZrVYrVqtVVjtUq1XZzVosFrfNJHM3Io66NpuNUCgkK0QA2XGfSqXI5XIUi0VpuyNmZ4tcTL9ZljwrBoOBsbExOXFRpVJRLpeJxWI0m02Zf2q1WrIJcGRkRHax92sj5dPS656h1WrllFMxYAy+rHbyer3S204grGQajQbRaFRufvplA6TRaOSJReSMx8bGZNJdnEZE7qR3g9NoNGi329LIsldoKpUKlUqFlZUV7t27R6FQkPOMhIPy43wGn4e+EZfeEQDBYJCBgQH5C8hkMpw/f561tTXS6XRfh8T0er10Nn799dflzqfb7RKJRLh+/Trz8/Osrq6STCalyMbjcXK5nMyJ9ctN+zyo1WpcLhc//OEPOXLkCAcPHkStVhOPx/n7v/978vk8oVAIp9PJ0NAQX//61+UAsqWlJS5dusS1a9d2+mPsOL2GsWK44NTUFG+//TbhcJhwOAwgcwgiySwKdoT7ciKRIJvN8jd/8zdcvXpVuk73A+Ik53a7+ef//J/z6quvSiNU0acGX97f4rq0Wi0ymQyVSoVr167xu9/9jkajITfW9+7dY3l5mUajIW12hCiLP8KpYrvpG3HpLdsTTUOiHFcMKxJ5hH59cAofMYvFgsPhwOVybQrjiLBX74RQQbPZfKIEnliQovelX0+AoidLjG4Ih8PS5UD0uYiBeGIktMFgwGq14vf7qVarMk6+30+BYsaSXq+XTuVerxev14vb7ZYna7FBbLfb2O12ub5Ew7awnNHpdA/1Wu01RMJdnOQcDgc+nw+v1yutcEwm0yZhgS8ti5rNpvS7y2QyFAoFotGoNA8V13RpaWlbp0s+DX0jLi6Xi6NHj0r7jm63SyaTIZ1Os7GxQalU6mthgfuVXGfOnOHw4cMcO3ZM1ryLpJ8YRWsymZ7pxhR9Qo1GQ/a7iIXeb7jdbsbGxhgaGmJiYoKhoSGKxSJzc3PcuHGDS5cukUgkZCjj9ddfx2KxYDAYmJ6eZmJiglgsxq1bt2TitJ/X3uNwOBz88Ic/ZGxsjGAwSDAYxOVyMT4+Lq8f3N/gCMPPaDQqZz7F43HS6TS3bt2iWCyysLDwTCaZuwWtVovf78dsNjM1NcXU1BQej4ejR4/icDgYHR2VJ5Zeut2uzJnE43EuX75MLpdjY2ODXC5HKpVifX1dmqoCOxqW7RtxsVqthMNhBgYG5JGwVCqRTCbJZrPSUaCfb3CtVsvY2BhnzpxhbGwMt9str4UYHStKaJ9VXMR1hC9dq/fqTf44hO3L0NCQ3GFnMhkikQhra2ssLS0RjUbl99vtdk6dOoXP5+PAgQOYTCaCwaAsh++X8M2zYDabOXXqFCdPnpTGqFshogxizk4ul+POnTssLi4Si8W4cuVKX1xHjUaD3W7H7XZz6NAhGb4+efKkrOzcaiS8cJCORqMsLi7y4YcfEo/HWV1dJZPJ7MhneRx9Iy5Op5OpqSl8Pp/saBUmb6KprV+FRafT4XA4cDgcDA0NMTo6Srvd5tKlS9ITy2azybBNb5XJ09Lbjf+083b2AqIgwu/3c+rUKcLhsMxZra+vc/HiRRYXF6lWq5s+t7Cct1gssrlSr9ej1+ulTdJ+RYTFxITYXlqtFisrK6RSKeLxOMvLy7K4pFwuE4/HSSaTFAqFPbmJEc3LQkyGhoYwm83SAmtiYoLR0VHpUrwV1WqVhYUFcrkct2/f5vbt2ySTSdbX1ykWi7u2ZaBvxMXn8/HKK6/gcDhkM1YikWBubo7l5eW+TlKbTCaGh4fx+XzMzMxw9OhRrl27xi9/+UssFgt/+qd/is1mw2KxyIX+rD0F/d7gJmLgo6OjfO9738Pj8chGtVu3bvHzn/+cXC5HqVTadB1qtRqZTEY2lgonapPJpIjL/78wQoSCemk0Gly+fJnr16+zsLAgTye9voEvMun8otFoNIyOjjIxMcHMzAzf/e53ZVFD7wZE5F+2olQq8cEHH3Dnzh2++OILbty4IRt8d3M+ry/EpdcUU6vVygeg2E32e0+LTqfD7Xbj9Xpl4rTT6UjzPzG7BR4/5mC/o1KppCjY7XasVitGo5FyuUyhUCCbzVIoFDa5HgjEw0+sswcHMe1nRDhHVDUVi0UMBgN2u12OPBAO3KLoplqt7kkxEYhhhaL/bmhoSI4fsVgs0p5FDE0URQuAzJOK5l1RwSkaIHsH1u1m9ry4iBLH3rpvEbrJ5/Ny7kE/mwg6HA7OnTvH0NCQnJ7YbDZJJBKywkbQLyaTLwKNRiOT+AcPHsTr9dLpdLh48SKRSISrV6/KQWt7+cH3simXy1y4cEH2YHS7XYaHh3n77bfpdrvcvn2bTz75hFKpJMtl9/r1NRqNhEIhHA4Hb775Jm+++aaco9JrHplOp0kmkySTST777DNqtRrnzp3jwIEDWCwW3G437XZbCm7vaW63s+fFRQhL725cLOB6vd73JxexQ/L7/QwMDMhKOeEtptVq98RC3A2o1WqsViter1cOT6rVaiQSCVZWVkgmkw/lWgS9k0+FgIvr3q9r70lptVokEgl5ou50OjIXpdFoKBaLpFIp6YjcD2g0Gmw2G263m1AoxOjoKHq9HqPRKAthOp2OdCBOJBLcvXuXSqXC+Pg4g4ODm3IwW7mc73b2tLiIKXYOhwO32y1/aWKOuThub4d99G7EbDbLqqbJyUmGhoYolUrcvHmTO3fusLKygs/nkwk/MTBImVG+NcJKf3BwEJfLBSBdn79qbLHJZMLv92O1WtnY2CCRSLC6uko6nd7zIZ7npVqtcvPmTdbW1hgdHWV4eFiOfOhXvF4v7777LiMjIxw+fBiz2Uyj0SAWi1Gv14lGo5RKJW7dusXc3By5XE4Oqjt16hTlcllOn9yr7Glx0Wg0uN1uWTcvxEVYReTzeRKJRN/e3GazGY/Hg9/vZ3R0lHA4zNzcHOvr69y7d49IJCJPcICc/mkwGPZ9HmAr1Go1DoeDgYEBWRgiRkOvr69TKBQeebOLBkAxf7xer7OxsUEmk5Fd0fuVer3O/Py8tDg5ePCg3MH3Kx6Ph7fffpuZmRl5z1WrVRKJBIVCgevXr5NIJPjss8+4cOGCzLuYzWY5E8hmsynispNsNRlR/P/ekFk/LmSr1crAwABer1fuBIvFIvF4XO6yxbUR/mHRaJRsNtuXYvu8iAFKVqsVg8EgQxH5fJ5MJvNQj4VKpcLpdGIymQgEAnLGSz6fp1AoKB5tPYh7UXiKuVwuCoWCLLp5cCjdXkeEq3vt77PZLF988QXZbJa7d++SyWQ2jWuHL69Tr6tGvV4nnU5Lw8m9sp72vLhshaiIEiZv/VgKqlKpCAaDnD59Wtrqq1QqNjY2uH79OhsbG7K8UYiLSErfuXNHGcG7BUIsxJjsTqdDpVJheXmZ27dvP1QUotPpZPf+yZMnOXjwIJVKRZ4e8/n8lgPt9htCtA0GAwcOHOBb3/oWjUaDtbU1+YDtt1YBUY7eOylyYWGBv/iLv5DDEkWxjXg+abVaOYSv12w2k8kwNzfH1atX95Qbxp4XFzF1Ta/XP5TUB/p656jX62UvhdjpVKtVWc4pBnqJ6yKSh6VSqa9u5O1ElLT3Vh+K3eNW3+dyuQgGg9I2vlaryT4NRcDvo1Kp5JA50UwpbF56+1n67T4Vm9xek0lRSlyr1eSaEs8ucT+L/he43z8l/AD32mj2PS0uer2eEydOcPbsWQ4dOiSbkMT4zkKhQCqVkpbU/U6n0yESiTA3N4fFYuHIkSOEw2GsVivdbpdUKsWtW7eIRqN7age02xDDmpxOJ6+//jrnzp3D4/FQLpdJJpPMzc1x+/ZtEolE3z0wnwW9Xk8oFMLtdstGStHvIuaJ9ONmR4iKWAPBYJBvfetbZLNZNjY2ZB8a3L9GNpsNm83GzMwMw8PDJJNJbt26xcrKyp4cPrenxUWj0RAOh5mZmSEQCMhdgnBSFTujfly4W9HtdikUCsTjcQYHBxkYGCAUCskjdqlUkrbl/dz386LRaDRYrVacTifj4+McOXKETqdDvV6nWCwSi8UeenjsZzQajXRCttlscqderVap1Wp9uxZ7haXb7WK32zlw4AC5XA6dTrdpjLjBYMDtdmOz2eRJOJVKEYvFZL/aXmNPikvv6FkRoxS5hXq9zsrKCul0WjZt7RfUarUspR0aGiIUCuH3+2V/gbCM6Neb+UUhwhuiOMLr9fLqq6/i9/sZHBzEbDazurrKzZs3iUQicpLnbvV8etkIcfF4PDIHUS6XWVpakv5Y/YboY2m32zIs7XA4mJmZoVKpMDg4uKlARKvVys58MUFXzGDZqxvkPSsuvYkvMQ1QpVJRq9XkMKxYLLbTb/WlolKpCAQCHDx4kFAoxOTkpJyX0el05AyIer2+r0T3WRFiIqp3xJ9QKMT3vvc9hoaGGB8fx2KxEI/H+dWvfkU8HpejtJVrfB+tVovX62VwcBCbzYZKpaJYLDI7Oys3gv2G2My1Wi3pIuLz+XC73Q+FywRChES+r9FokM1m5QjyvcaeFBe1Wi3FxWg0SnGBLwdmmc1mmRTrV4RgiK5dMenP5/PJhWyz2WQisVKpyAqVvbgTetGIeTXZbFY6axsMBgYHB5mampLedRMTE3i9Xux2u5xvE41G5XgHMTpa4Ut6k9siJypGavdjPrTRaLCxsSEdHxwOx2PNKXsdxovFIpVKhXg8TiKRIJ1OK+LystBqtTidTtxuN4FAgFAoJE8uRqNRzuG+dOnSTr/VF4roERCDqLRaLQcPHsRgMODz+RgdHUWlUpHL5YhEIiwuLrKyskKj0VBCY1vQbrdZWFjAaDRy6tQpZmZm8Pv9/OhHP+Kdd97BarVKU8vR0VG63S4ffPABt2/f5saNG1y9elVW9yhsTb1ep1AoUCgUKBaLFAqFvlyLsViMH//4xwwMDPCDH/yAs2fPyoq5x9FsNrl27Rq3b99mdnaW3/72txSLRbLZ7Et659vHnhQXcXIxGo3SxbbX9ddisdBut2Uner/uIkXRQr1el6cXm81GIBDA7XbLeeSxWEw6+gpHVYWH6XQ6siAin89LD6zR0VF8Ph9WqxWLxYJWq8VkMlGtVkmlUty7d09OA9yLO8yXiZhc2mw25SanH9djrVZjcXGRYrHI2bNnZShaNFRuhXDTSCaTrKyssLGxQSwWo1qt7kkB3pPi8jjq9TpLS0vE4/G+TuiLpsjPPvuMfD7P0aNHCYVCmM1mxsbGMBqNGAwGyuUyly9fZmFhgXv37vXt9dgO2u02q6urlEolPB4PGxsbsjxUNFW2223S6TTz8/Ok02k++ugj5ubmFNeDJ0TMvclms2QyGfL5fN+YVfZSq9VYX18nl8tx6dIl1Go1JpMJp9O5padarVYjlUpRKpW4ePEid+/eJZFIbNo47jX6TlwajQbr6+ssLy/vytGf24mY0tdsNrlz5w6NRoOjR48yODgIfNkAeOPGDa5cucLGxsaeXKQvi06nI0s/x8bGZJ/K4OAgVquVYrEoHXw/+ugjotEon3/+OcvLyzv91vcEYmdeLBbJ5/PyevYjwqRSr9czOzsL3Ldr8vl8W4pLoVDg7t275PN5bt26xdramqzu3KvsSXFpt9tUKhVyuRw3b97E6XTKBH82m+XmzZusr6+TTqf7/mEqEoCzs7MyAejz+eTXUqkUy8vLZLPZvpg//qIRIZpYLMbvf/977HY7Pp8Po9FItVqlWq0SjUZlRZiSX/lqhKiIeST7iXa7TTKZ5N69e5hMJmKx2JbiUqlU2NjYoFqtUiwW+2Jm0J4Ul0ajQTqdplQq8bOf/YxPP/0Um82Gx+OhUChw/vx56Ybcz4hyxkgkwk9+8pOHrEvg/uIulUr7xqXgeRHzRq5fv869e/ekkaDI3YlqJ+G0vd8els9Cu92Wkzz7/Z58kHa7ze3bt+VaetSYAbGu9uLclkexJ8VFdOE3Gg3ZT2Cz2eQoUJG83uu/nCdFOPcqbB+iTFbh+el0OvLe3I9iXK/X93R461nZk+ICXzYpxeNxstmsDIu1Wi0KhUJfVqAoKOxFGo0Gi4uLJJNJWcKt0P/sWXGB+wIjXEYVFBR2J61Wi3Q6Tblc3rNWJgpPz54WFwUFhd2PqFrsdrtcvXpVzh3ai06/Ck+OqvuEZ9R+G7b1PDzLsV65fl+iXL/n41nDSrvhGmo0GrRarbQu2imUNfh8PMn1U04uCgoKL412u61ULe4TnvjkoqCgoKCg8KRsXXStoKCgoKDwHCjioqCgoKCw7SjioqCgoKCw7SjioqCgoKCw7SjioqCgoKCw7SjioqCgoKCw7SjioqCgoKCw7SjioqCgoKCw7SjioqCgoKCw7SjioqCgoKCw7SjioqCgoKCw7SjioqCgoKCw7TyxK7JiN/0lil3386Fcv+djL1vu7xaUNfh8PMn1U04uCgoKCgrbjiIuCgoKCgrbjiIuCgoKCgrbjiIuCgoKCgrbjiIuCgoKCgrbjiIuCgoKCgrbzhOXIisoKChsJw+W9j5ribXC7kQRFwUFhZeOx+Ph6NGjmEwmNBoNKpWKlZUV5ubmaLVaO/32FLYBRVwUFBReOj6fj+9973sEAgHUajVqtZoPPviAu3fvKuLSJyjioqDwGNRqNVarFZ1Oh8vlwuPxbPp6q9Wi3W5TKpXI5XI0m03K5fKWD0iVSoXFYkGv19PpdGi1WqhUKrRaLSqVikqlQq1We1kfbUfRaDSYTCZ5PTQaDWazWemC7yMUcVFQeAxGo5EDBw7g8/l4++23eeutt1Cr79fBdDodCoUCtVqN2dlZ3n//fTKZDDdv3iSXyz30WjqdjomJCYLBIOVymVKphEajwW63o9FouHv3LisrKy/5E+4MWq0Wu92Oy+XC4XBgMpnwer2KuPQRirgoKDyASqVCo9Gg1WqxWCz4fD6CwSDj4+McOXJkk7jkcjnK5TLZbBa73U6tVpNf7309rVaLwWDA7XYTCAQol8sYjUa0Wi0ulwu1Wk0ikcBgMNDpdGg2mzvx0V8a4hprNBoMBgNmsxm9Xt/X4qJSqeQftVq96Z+dTodGo/FMRQ1arRa1Wi2vZy/NZpNWq0W326XT6WzXR3my9/VSf5qCwi5GpVJhMpkwGAyMjIxw4sQJXC4XZ86cwe/3Mz4+/siHX6lUYmVlhWw2S71e3/Q1t9vN9PQ0brebt99+m0OHDtFsNmk0GqjVagwGA91ul88++4zZ2Vk2Nja4cuVKX4fIms0m2WwWs9mMzWbb6bfzUrBarfj9foxGI36/H6vVKkOtkUiE3/zmN2Sz2ad6TZ1Ox+HDhxkcHGRoaIiZmRl0Oh1wf/Nz/vx5Ll26RKlUIh6Pv9R8liIuCgo9GI1GLBYLo6OjvPnmmwQCAU6fPo3P53vs36tWq6RSKZl36cVms3Ho0CFCoRDf+MY3OH78+EN/v91uYzQasVqtzM7OcuPGjb4WF5GnKhaLfX9KE5hMJoLBIDabjYMHD+J2uxkaGmJ0dJQbN25w/vz5pxYXrVbL2NgYx48f59SpU7zzzjsYDAbgvoBrtVo2NjZIp9OkUilFXB6FqCqxWq0MDw/LOK3VapXf0263KZfLNJtNIpEI8XicRqNBuVx+6cfCl41KpcJms2E2mzGbzTidTvR6PS6XC6PRuOWxWZDL5YjH49RqNaLRKNVqlXa7Tbvdfsmf4uWjVqvR6/UYDAaOHTvG6OgoBw4cYHR0FKfTidFo3PT99XqdTCZDtVrlzp07RKNRZmdnKRQKVKtVuc4cDgd2u52JiQmOHTvGwMAALpdr02t1u10ajQa1Wo2VlRWuXr3K2tpa3z9wm80mhUIBi8VCo9HY6bfzUrDb7Rw6dAiXy8WBAwdwu914vV48Hg/hcJjp6WksFguxWGzLnN1WaDQahoeHOXLkCKFQaNP9rVarmZiY4Nvf/jbLy8uUy2Xy+TzFYvGh0/WLYE+Ji1arRafTMTg4yLvvvkswGOTs2bOMjY0B9x+utVqNtbU18vk8v/nNb/j444/J5XKsrq72/SLWaDSEQiGCwSCDg4McPnwYl8vF8ePH8Xg8GI3Ghx6Ugps3b/LJJ58Qi8V4//33NwlMvyOSy06nk3fffZe3334bu92O3+9Hq9Wi1W6+TYrFInNzcySTSf7xH/+Ra9eukcvlSCQStNttut0uarWacDjM5OQkx48f54c//CE+n0/uKgXtdptCoUCxWOTSpUv83d/9nQyZ9TP1ep1YLAbAgQMHdvjdvBxCoRBvvfUWgUBAiotGo0GtVmM0GvnOd77D+vo677333hOLi16v5/jx43z/+99/aK1qNBpef/11Tp8+zeXLl8lkMqytrbG0tKSIC9wXDL1ej1qtxul04nA4GBoakg9Rv9+/qcqkXq9Tr9cxGo2EQiFCoRBarZZIJEKz2eyLLmCRBDSZTPJEotPp0Gq1DA0NMTAwID+70+nE7/fjdrsxGAwyafpg7iAQCBAKhYD7OYJKpUK32+3r0IxIqIpwhcfjketJXFuRbG2329RqNarVKvF4nPX1dZLJJPF4nHQ6TaVSod1uo1arZXltIBBgaGiIYDCI3W7HbDbLny0SrNVqlUgkQiaTIZlMUi6X+2KNPgniGuyXzyuiCG63W0YYBEajEZfLRaVSeWgD8jhUKpUsiNgKsaH0er0MDg4CyDX7otn14qLX6xkdHcXhcPDaa6/x6quv4nK5GB8fx2Qy4XQ6gfsLVVTlBAIBmTydmZnhypUrRCIREokEzWZzT+/GxcPLYDBw/PhxTp8+jc1mk2FCn8+H3W6X8XutViv/2e12qVaraLXahypzwuEwb731FolEgm63y9raGpcuXeL69et9e/ObTCbMZjOTk5P86Ec/YmhoSCbeRde4yA3UajWuXLnC1atXicViXLp0iWKxSCKRoFAoyBOLzWbjm9/8JqFQiHPnznHy5Ensdvum0C3c3wSVSiWWl5f57//9v3Pnzh2Wl5f79lo/iChkEJuj/YDNZmNychKfz4fFYtn0NZPJxOjoKEajEbvdvu0/e3R0lH//7/89sViM//Jf/gtra2vb/jMeZNeLiyjV9Pl8HDp0iNdee02KijgCihtSCIxQ8ZGRETweD4VCAbPZjE6n2/Pdv+KmNJlMhMNhjhw5gsfj4eDBg1itVmw2GyaTiW63K/+0223ZtCfKEsVxXGCxWLBarZjNZsbGxmTfRT8iTm56vR6LxYLf7+fYsWOMj4/jdDrlzrH3dFGpVFhbW+OLL74gFosxOztLuVze9JriFDQyMsLExAQzMzMcPXp0k4iLtdpoNKhUKqRSKS5fvswXX3zxci/CDiM2gjqd7qHS7X5EnDBE9OVBtFotDoeDWq32VCeXJ8Vut3P06FECgcBDeb8Xxa4VF4fDQeD/196Z/8Z1Xuf/ubPv+75w30WJlGRblizVlhIndu0sRpKiAdq0KFCgP/Wv6a9t0BZGkCBG+kXiOLFlm7Zka99IcRM55OzrnX3fvz8Y7+sZkpIpieQsuh9ASCyRw5nL997zvuc85zlmMwwGA9566y0MDg5icnISKpUKjUYDLMsC+ObYJxQKabFKIBDQ3LZAIIBSqYTZbMbx48eh0+mwsbGBWCzW4U/39IhEIigUCigUCpw+fRoWiwUnT57EsWPHIJVKoVQqIRAIkMvlkMlkkMvlEI/HUSwWEQ6Hkc/nUS6XUSqVwOfz6XUzmUxQq9XQ6/X02Dw+Pg6DwYClpaUOf+qDRyaT4dSpUzAajXA4HHA4HLBarXA6nbQTHwBYloXH40EqlcLdu3cRjUaxubmJzc1N5HI5VKtVMAxDr+PAwADm5uZgNBpx4cIFWK1WWK3WtsBSrVaxtraGSCQCn8+HR48eIRwOIxqNdupyHDlElKPRaDAzMwO73X5kD7tOwOfzMTw8DIvFgqmpKbq+diKRSGC1Wul93g90dXCZnJzE4OAgfvKTn2BmZobuOLPZLAKBAKrVKjQaDeRyOSKRCNxuN+1TIEopgUAAq9WK+fl5GAwGsCzbk8GltQHv0qVLmJqawuDgIIaGhgCApvtSqRTS6TTC4TAePXqEVCqFBw8eIBaLoVAoIJfL0QKiRCLB3NwcHA4HpqamoFKpIBaLMTU1hVqtho8//hgMw/RVqkYul1M58OTkJGZmZugprjUQxGIx3Lp1C36/H7///e/hcrnaGtFI0Z6k1k6ePIl/+Id/gF6vx9jYGJRK5a66VrlcxoMHD7C4uIgHDx7g6tWrKJfLfa9ibIXH40EgEECj0WB2dhZOp7OvGyf5fD4mJydx6tSpth6UnYjFYtjtdppB6Ae6KrgwDEODxdDQEMbGxmC326FQKMDn82lhNZPJYGNjA/l8HlKpFEKhEOl0GrFYDGq1GsPDw9BoNPShKJPJMDAwQP2hJBIJTRH1CkqlEqOjozCbzbT4zDAMkskkSqUSlRFHo1GkUinE43H4fD5aF0in0ygWiygWi+DxePT4HQgEUKlUoNFoUCqVaF2GyGP7BXKCtVgscDqdMJvNUKvVEAqFNChXq1VEIhGk02m43W48evQIsVgM2Wy2ba1IJBJ6OnY6ndDpdJiamoLBYIBKpaICFCLlzuVyCIfDSKfT2NzchNfrRTweR7lc7un637NA0ocCgQBSqRRSqbTn66BPgsfjQa/XY3h4GCaT6bH1JSJvj8fjbenWx0G82JRK5WMDViulUgmJRIJmMY6CrgouQqEQx48fx8TEBKanp/H6669TSSjwze68VCrB5XLh/fffRyAQQC6XQ7lchlAohFgsxvDwMKanp6mMFPhGCfXWW2+BZVmsrKzQ70un0z2zKx8aGsLf/d3fwWKx4NixY9Dr9fD5fLh79y4CgQA+//xzxONxhMNhJJNJ1Ot1VCoV1Ot1lMvlXRYQ5CYPh8P0Afvyyy9DKBQiEokgm80iHA73zPX5LkZHR/Gzn/0MVqsV58+fh81mg1gspifh5eVlxGIx/N///R9u3LiBcrmMYrGIarWKbDbb9lomkwlvv/02LBYLzp49i7GxMcjlcuoRRm72QqGAfD6PtbU1/O53v0M4HMbq6ioikcgLGVgA0OsjlUqpciqVSqFQKHT6rR0KfD4fc3Nz+NGPfgSJRAKRSLTn1yUSCXz++ecIBoP7KraTDbjZbN6XACAajWJhYQHBYBChUOipP8ez0DXBhexmdDod7HY7bDYbzGYzZDIZGo0GcrkcCoUCisUi4vE4AoEAfD4fUqkUisUiFAoFdDoddDodGo1G21GbnFgajQadH9ErRUQiMVar1bDb7dQ2QiQS0ZNKKBSC2+2m0th0Or3v169UKmAYhjaZ1mo1ZLNZpFKpvjq5kMZbq9VKpaAEUrTP5/OIxWIIBAJtggiGYSAUCmlaVqlUwmazwW63Y3h4GKOjo20/i1zHQqGAZDKJaDQKt9uNUCiESCTy1F3Y/QS5z0kxnwRiIjrpN4gTtsFgeOLXVatVenLZz31HUosk/f9dkNdPJBJH1kPVFcFFJBJBp9NBo9Hg7NmzuHTpEr1w2WwWH374IXw+H1iWRSKRoDdrLpejF8psNuPkyZMYHByEwWCgEkeGYeiNnk6n6S+wF3peBAIBTp8+jYmJCczNzWF8fBxSqRTZbBaJRALXr1/HRx99hGQyia2tLRp89wuPx6MOBzabDVqtFpVKBdFoFMFg8KmCVLdDcvwmk2mXlxXJd6tUKrz33ns4deoUVXMVCgW43W5ks1nIZDJIJBKMj4/jjTfegMlkgtlsbnstklorFAr46quvcOvWLYRCIaysrNAN0osMSU8aDAYIBAI0Gg0kk0kadPsxwBwGOp0OFy5cgMPhoP1p3UZXBBehUAi1Wg2DwYDJyUmcPn2a/lsymcTNmzdx7949hEIhhEIh1Ov1XcFBrVZjfHwcDodjVx6SNMCRgnYulzvSz/esEKUJSb0Q9dH29jaSySTW19dx/fp1lEqlZ7K34fF4UCqVMBgM0Gq1UCgUVG1GBADdHoD3i1wux8DAwJ47SLK5USgUkEqlmJ2dRaFQQCqVojL2WCwGlUoFpVKJiYkJmprcSa1WQyqVQjKZxN27d/Hhhx/SE8yLmAZrhTT+kpMjaVDN5XJIJBIvVAPp86JQKDAzM4OBgYGuVdt1NLgQPyez2Yxz587RNFgkEgHLsvD5fAiHw3C5XLQOQI7PJF1BZkEMDg5iZmYGJpMJUqm07eeUy2VEo1Fa9O52iFRYLpfD4XBgdHSUds0Xi0UsLy8jEAjA4/GgVCo98ylMIBBgamoK09PTsNvtiEajSCQS2N7ehsvl6qv0TTQaxbVr16h9PunpkclkVPVFUl8ymQyVSgVqtRrFYhF8Pp8GGalUCrPZvKsXoVaroVKpgGVZfP311/B6vVhbW0M+n39mK/V+xGAwUKUjcYPOZrOIxWLI5XJ9c51kMhkcDgd0Ot2em5DnRSwWw2AwwGw2P9bSqZVMJoPV1VVaSjgKOhpc5HI5tFotZmZm8Mtf/hJ2ux25XA4bGxu4d+8e/vznPyMej2NrawuZTAaNRqNtd87n82GxWGA2m3Hq1Cm88cYbu2wVACCfz2NrawvBYHBXcbYbIbUntVqN6elpnDlzBqVSCel0GtFoFJ9++ikePnwIv9//XIacYrEYFy5cwDvvvINUKoWtrS34/X7cvn0bm5ubR+I/dFRsb2/jN7/5DUwmE15//XVqyyKVSqm3WLPZbHN8IH9Onz6NRqPRNoNjZ567UqlQldn777+Pe/fuoVKp0MDfLw/N54HH42F4eJj2AUmlUtRqNcRiMbjdbrAs2zdpMY1Gg9deew1OpxMDAwMH/voymQyDg4O04fm7YFkWCwsL8Hg8R2aK2tHgIhaLoVKpoFarodFooFKpaNEpHo8jFoshnU6jVCrtKRvm8XhQq9UwmUxUwiyRSMDj8dpu5lqthnw+j0Kh0BPyY/LwIr0oYrEY5XIZ+XyeFtuJkOF5b0Yi7y4UCojH48hms3TuRCaToUG9F67bkyCn13q9Do/HQ08aJGgQ+bBQKKSKJnI62U/BlFzHVg+ynZuhFx3SdKpSqSCXy6l6kbQRZLPZvgnCfD4fGo0GWq12Xx33QqEQGo0G5XIZg4OD35m6dzqddGO0X1qHlR0FHQsuDMPQLvOJiQmqgvL7/bh//z7W19fh8XhQLBYfm8oi0uUzZ85gYmKCXuyddhvFYhGhUAiBQKAnCqpE3UY8iAQCAfL5PDY3NxEIBLC1tQW32/3cqo9arYaNjQ18/fXXCIVC2NzchEQiwXvvvQelUokvvvgCX331FZ1V0ss1g0Qigfv370MkEmFxcREymQw2mw1OpxNyuRw2mw0ymQxmsxkajQYWiwVjY2NPdfMCoGOLtVot3dBwgE721Ol0GBoagkwmQ7FYRC6Xw927d/HJJ58gl8v1/CaGQLzCRkZG9rR72YlOp8OlS5dQLpfxxhtvfGdwIYa0+0Uul2NkZARCoRB+v/9IUmMdDS5yuZyaTJLAkM1mEQqFwLIsstnsEx+gfD4fer0eAwMD0Ol0dNwn8G1ag4yMJYX8Xli8ZIdHxuASxVsmk6FF5oMQJRClTigUojYkBoMBIyMjcDqd2N7epsaVpCmwVyFu2QCozj8SiSAajUKtVtMTW7VaRblcpv5sTwOxNpFKpZDL5ajVaiiXyx0ZMdtNkFQiqSWq1Wrw+Xx6yiP1VQB9c3Ihc6dIU+13IRaLqeqLjBA5SEQiEVXfHpXd0JEHFx6PB5lMRm1G3njjDWg0GtRqNSQSCXg8HqytrT1xp0zSF1KpFHq9HlarFRqNZteJhQSphw8f4saNG7Rg3e1Uq1WwLItms0l3vjKZDHa7HY1Gg7ocP2/apV6vIxwO07Grb7/9NnQ6HcbGxqDRaKgNPxFD9NsAq0wmA+CbfHQymYREIkE4HIbJZEK9XseJEyf27H6u1+soFotoNpvUW0wsFlN36l/+8pe4ePEifD4fAoEAwuEwbt++/cKeYgQCAc1MGI1GKJVKqqrLZDJ9KXioVCoIBoMQiUSwWCydfjuw2Wz42c9+hlAohP/+7/8+kgDTkeBCDBhJcKnX67SHhQSXJ1lCtDoD6/V6WCwWOnuD0Gw2EYvFsLy8jKWlJdy+fZs+sLsdElxIfw7wzTHbZrOhVqvRVFmtVjuQ4FKr1TAwMIAf/vCH0Gg00Ov1VCxhsVhQrVb70hY9m80im81SebdAIKDBRafTPfaUW6vVkMvl0Gg0aH2G/FEqlXA4HKjX61heXsb6+jru37+PlZWVFzq4GI1G6PV62leVz+dpDbEfB6NVKhWEw2EIBALMzMx0+u3AZrPhvffeQyQSwcLCAm7fvn3oP7NjwUWtVtPiOymEEr+v7/IakkgkcDgcMBqNUKvVEIlEtGGSdFtXKhXqPkvmuPRCYAG+tXon16NWq9E5LlqtFuPj4ygWi4hGo7RIvZ/dHxlzLBQKqfhhenoaDocDIyMjUKlU1MGgNVD3ipvBs0KuG8MwGBwcxPT0NAYHB3cF1Fwuh2KxiEQigfX1dVQqFZqSValUMBgMNDVGZPJWqxXhcJg2Wx7ViNlugkyPdTgc1Ckjm81ic3MToVCor5p1CWQiLklndwMkNdm3BX2hUAibzQar1UrNFxuNBjVKJH+ehMFgwMWLF2Gz2TAyMgKFQkEvWLVapQv29u3bWFhYAMuyPdHfQmg2m6jVajQnnc/nIRAIYLFYoFQq8Ytf/ALnz5/HlStXsLCwQOeCfFfaivTOqFQqjI+PQ6/X48c//jFOnjxJ7XPIw7Fer/e1W+1eSCQSvPPOO/jFL34BuVze1i9F0qwulwtra2t4//33kclk8Nprr2F8fBxzc3P4/ve/T/PrDMPAbrfDaDSCx+Ph3r178Pv9WF5epuN9XxSUSiUuXryI+fl52O12VCoV+Hw+fPDBB3Tsbr+RTCaxsLBAhxy+iBx5cCFDmkiuGvjmxq1Wq/R0Qby/SJQlf8jfkVSYxWKBXC6nD8NqtUoltclkEvF4nMpre60YTYZ8ke5u0vRHmvhIkDYajXQ3TE4vO08wZCdNOsx1Oh0sFgsMBgOsVissFgsEAkHb9X6REAgEkMlk0Gq1MJvNdK4NgZweySiDYDAIj8eDTCaDgYEBOouDNFq2yppJIdVsNqNSqWB7e5tK5XvlJP2skLUkFAqh0+lgMpkgkUhQqVSQy+UQjUYRDoefyrKoVyDu7Y1Gg9aWSDqfYZgjPUF0iq6wfyFHyGg0CrFYTP3BBgYG6LRAPp9P55vrdDqMj4/TfgwACAaDWFtbQzQaxZdffolQKASv1wu/399zlt6NRgOlUgmNRgOXL19GJBLB3NwcfvrTn7alBOVyOebm5pBMJmk3OEkJEojBnUQigdlshtlspuOQyWztYrHYFrxJE2q/P/wIpAg/MDCAkydPtv1bqVTC9vY2UqkUPvnkE3z66adIJBLUhn9lZQV+vx/hcBjxeBxGoxFnzpyB0WikXmQOhwO/+MUvEA6HkcvlqClov9dgpFIp1Go1Nfm02+2Ix+PY2NjA1tYWAoEAotFoXwYXQqVSweeff45sNgun04m5uTkoFArqEtHPdEVwqVar9JTB5/NpYDlx4gTkcjkdPTs8PIzBwUE6rY2ccJrNJlKpFNbX1xEIBHDlyhV4vV56Guo1yEmuXq9jZWUFsVgMAoEA77zzDuRyOXQ6HZrNJgwGA2ZmZuhDLZPJ0KZT8joikQg2mw1yuRxOpxNOp5PO0gCAdDrd9pATCoW7xBH9jk6nw/e//32qkmulVqshEonQ0cZXr15tE1EEg0EEg0F6zR0OB4aHhyGXy+m11Gg0eOmllxCPx/Hhhx/SBkKiOOtXiGegWq2GVquFRqNBJBKhEnCyo+9n6vU6VldXkU6ncezYMRiNxkOzhOk2jjy4kOFJqVQK+XwetVoNYrEYo6Oj1LF2ZmYGBoMBDoeDptDIgKulpSVotVpMT0+Dz+fTeS4ejweLi4uIRqPIZDLPraTqBprNJvL5PBiGwfr6Oi5fvgyj0UgfgsS+nNjJk3oVObk0m01q1y8Wi6FQKKil/vr6OorFIrxeLxKJBFQqFZWJHjt2DHK5vMOf/vCx2WxwOBw4duwYNa4kNRMyJjoej+Prr7+Gx+PB9vb2Y4NBLpfD9vY2stksPv30U1itVrzyyiuYn5+ngVogEGB8fBxnzpzB5uYmMplMT52onxa73Y6LFy/C4XBAo9Gg0WggHA5jcXERW1tbfakS2wlxICApQj6fD7lcTlP6T0Kn08HhcEAsFrfdw/s98ZA6YSQSQSaTgdfrBcuyR1bj6khwSSaTaDabyGQyqFardEwsADrUimEYCASCtuL2lStX8NVXX2F4eBjDw8OQSCRIJBJIJpN4+PAhPvvsM7p778UTy06azSaSySRSqRSazSYqlQqsViv+/u//HpOTk1AqlVAoFNBoNFAqlbsefDv/mwSfcDiMzz77DJFIBPfu3YPb7cbo6ChOnToFu91Ou9b7GYZhMDExgUuXLmFoaAg2mw1qtZoGgmQyiaWlJfj9fnzwwQdYXV19ouIwHo8jlUpBJBJhc3MTCoUC//7v/465uTn6mmKxGC+99BKMRiM+/fRTrK6u9nVwmZiYwD//8z/DYDDAYDCgVqtha2sLX3zxBViW7et0GIG0RJCH+o0bN2gK+ruyA7Ozs3jzzTeh1WoxOjoKjUaDwcHBfQeXRqOBjY0NXL9+HS6XC3/5y1+obdRRcOTBpdlsUgVUNBrF9vY2RCIRLYKSC04ks0S2WKlUUCwWqXstKd6TAisZ33kQflvdBCn8FotFxGIxMAwDt9tNTyStD0QAtFDYOoipUqmgVqshmUwimUwiGAzC7/cjHo+DZVmk02lks1k6b6SfH3jE9l0oFMJgMFBFl0gkospFstv0+Xzw+Xx0RPSTIJsgIi55XMG+1RCzXyHrUSQSQalU0o0KEaikUinkcrm+XmetkOcRaRnYL2QoYrFYpL1nxPFhv2nrdDpNa4KpVOpIjXuPPLiQHHY8Hsef/vQnbG5u0uMemVDH4/GgUqlgNptRLpexsrKCTCaDkydP4vz58xCLxYjH4wgGg/jggw9o930qlaKnnH4jnU5jbW0Nbrcbfr+fXh8y4wX41lJHLBZDr9fD6XSi0WggGo0in89jcXERS0tL1GGZ2OKUSiWkUimwLEstUPoVsViMiYkJGAwGXLhwAW+++Sa13idpyGKxiHv37uG//uu/wLIsIpHIvl9fJBLRgKXVatseAmTtu1wuxGKxvtoEtULuY2KDI5FIqFFoJBKhjtv9vM4OAp/Ph48++gharRbVahWDg4PQ6XS7Jp8+jkajgZWVFfzxj3+kg++Oko6dXADA7/ejUqlAJBJBrVbTkb58Pp/OLymVSlhbW0MymcTU1BTMZjPdyafTaWxtbWFlZaVNituPEHEC6SoXCASw2WxgWZY2OZIGVZlMBovFQv2b/H4/nRN/586dPa8RmRlPVGr9Cp/Ph1arhcVigdVqhc1mo82SjUYD5XIZhUIBsVgMGxsbT93gRwawabXaPedsFItFZDKZnuq7eloEAgFEIhE9PfP5fJqSJV35/bgBPGhIQCCbP51O91QNuM1mk57AO3FPd1QtRlJjfD4fiUSCNvDxeDxIJBK4XC5qRW0ymTAwMACj0YhIJIK7d+8iEolQp2OSiuh3WpVksVgMpVKpbXcsFoshFAqxubmJlZUVWtsiXkePu0b5fB5+v5/2IfRrv4tcLsfrr7+OkydPYnx8vM19oFar4eHDh1hfX8fS0tIz7awVCgXOnDmDyclJDA8Pt13Der2OeDwOn8/XtyN9BQIBJiYm4HA4MDU1BbFYjEKhgMuXL8Pj8WBpaemFuE8PEtJAPTQ0tEvN2M10NLgUi8Un5rIZhoFWq8Xbb7+NoaEh2O12GAwGRCIRLC4uwuv1IhQK9fUucC+I5xWZfbMXewWGJ93U+XweoVAIKpWqr1U8MpkMZ8+exZtvvrnrGtVqNaytrWFhYQFut/uZgotMJsOpU6fw0ksv7bJabzQaSCQSCAQCVKTRbwgEAoyMjODUqVMYGxuDWCxGJpPBl19+idu3byMUCvVlUD1MiPGn0+mESqXqmU1fV/S5PI5ms0l9icbGxtBsNrG+vg6Xy4VQKIRYLPZCKE6ehWd5cLVawzMMQ5u98vl8XxlXPu5URrqpQ6HQvh/+JO2jVqthNBoxMjJCR0gQQQUZ+0BSYqSJsp+CS+uETpPJhKGhIWp902g0aPsBd78+PWRGkE6n2zVldy+q1SodC9/JUeVdHVyAb9IY58+fx9mzZ3Hz5k38/ve/h9vtxp07d5BMJl+4U8tRQB56NpsNJ0+eBMMw+OKLLzr8rg6fer0Ot9uN27dvU8uXJ0EEFFKpFPPz83jzzTdhsVgwPj4OrVZLU27VahXpdBrxeBx+vx9bW1toNBp9FVxIKluhUGB2dhaXLl1qU3aGw2F4vV6u1vIMiEQiOJ1OTExM7Gt4XTabxddffw2fz4fNzc2OrbOuDS5kRgbxw1IoFCiXy/TEQhxquSP24cAwDFXxyWSyvndGJpCC/l60NsKJRCIIBAJqIU8aMg0GA3WWJlQqFTq6O5fL9WXakdgGKZVKqFQqqFQqAO1F6X783EeFSCTa17hk4Jv0bjQaRSAQOJChgs9K1wUXohYbHh7Gyy+/DKvVCj6fj3A4jLW1NVy/fh2pVAqFQqHvdn/dhlKphNVqpWkekUjUF84Hz4pEIoFMJoNer8eJEyeg1Wpx8uRJOJ1OGAwG2Gw2iMXiXQ2obrcbv/71rxEIBPDo0aMOvfvDRaPR4Ny5c7BarRgcHIRYLIbf78fS0hJ1geA4GrLZLK5fv447d+50dIZV1wUXYmliMpkwNzdHm4cymQwikQjcbnffy467AXJyIadGIhPv97TGk4qlIpEIMpmMerpZLBZcvHgRU1NTT3zNRCKBa9euwev1djQHfpjIZDIMDw9jYGAAWq2Wjix/9OgRVXRyHA3lchnb29tYW1vr6PvoquDC5/MxMDAAk8mE48eP49ixY2AYBvfv30cymcTq6irK5fJ35sI5DgYy75x4bgkEgp5zmN5JtVrF1tYWFhcXYTKZYDab21whxsbGcO7cOZRKJWQyGbrRIZNALRYL9Ho9JicnoVKpoNVq9/w5pIFtY2MDS0tLYFmWeun1E2QAnVqtxsTEBAYHB6lcNpFIYGlpibpBczwdxFXaYrHsOyXWTXRVcCHGfnNzc5ibm8PZs2cRiUTw61//Gjdu3OhLlU03I5fL6fRLiUQCkUjU81MUiflptVrFSy+9BJPJRIOLUCjEiRMnwOPxwLIsvF4vLdYbjUZMT09jcnKybfbN41R0jUYD169fx29/+1uwLItAINCXa1cgENDRDfPz8xgdHaXeV5FIBFevXkU8Hkc+n+/wO+09lEolhoaG4HQ692zI7Xa6IriQwUoymaxNz006ejOZDC2E9tvN2S0QGTKZCloulyEQCCAUCqnnW6/o659ErVaj1kE7fZZ4PB50Oh3sdjtkMhkVldjtduh0Omi1Wsjl8j2vA5mkWq1WaU2QuNASW6J+XLtyuZwaU8pkMojFYuomQayFKpXKC1unex6EQiEVNO1HJVar1VAqlVAsFrsiu9AVwUUkEsFsNkOr1eL8+fN46623kMlksLy8DJ/Ph0gkgnQ63RUXrF+p1WooFovI5XKIRCIIBoP0gdpPFItF3L17F1tbW3A6nbh48SJVwgkEAszOzmJ0dBTVahWVSgU8Ho8GGqlU+tgAy7IsNjY2EIlEcPnyZfj9fng8Hni93n3JmnsRhmEwNjaGV199FaOjozAYDBCJRPB4PIjFYvB4PDTg9mNgPWzUajXGx8fhcDj21d9CrF62t7e7op+o48GFOPgSPyaTyQSbzYZyuUxdewuFAmdyd8iQscrEfbpYLPblA7FeryORSFDzTiKPFQgEdBQ0kdE+CaJUJH+y2Sy1I1pZWYHb7aYn7n6GCBxUKhU99abT6V1zlbjg8vSQ3iEyz+q7KJfLSKVSSKfTXXHvdjS4EDfawcFBvPvuu7BarTCbzWBZFg8fPsQf/vAHRKNRxGKxTr7NFwLSRV6tVmkqUqPR9N1DodFoIJ/Po1Kp4M6dO/jtb38Lm82Gs2fP7iuoAN8MBvP7/SgUCggEAkgmk9je3sb9+/eRTqfhdrvbAle/0mw24XK5UK1WoVKpcPPmTYhEIsTjcWSzWfj9/r6sMx0V4XAYX3zxBUZGRvD6669jaGjoiV8fDAbxxRdfIBAIPLXh6mHQ0eBCRsAODAzg+9//PgYGBlCpVJBMJrGxsYHLly/TfDXH4UJOLmROTj6fp6fFfno4EEftUqmElZUVMAyDmZkZHD9+fN/BpVgsYnt7G/F4nHrcuVwuPHjw4IU7YZOZN0C7jLuf1kynYFkWLMsik8nsaxx0NBrFrVu3EIvFjnRuy+PoaHAhE9YGBgagUqkgkUiQz+fp0KoXuWGvGyAF/n4ccEXcogOBAPh8Pj755BPodLp9fW86naZjit1uN2KxGFKp1Au/VvtpfXQThUIBS0tLEIlE0Ov10Ol0EIlEUCgUbemyUqmEeDyORCLRFRvyjgUXhmEwPDyM733ve3A6nbBarVAoFPD5fAgGg0gkEj3fU9HrNBoNWozux7x5OBwGy7JYWlrCwsLCvs05yQmPpBLr9XrfDqnj6DypVAq///3vceXKFbz66qt4+eWX6dCw1v4Xsunhai4AlR6Tjl4ANC3DyY47A5Ek12o1lMtl5PN5lEqlvgwwJHCWSqWuSCNwcOxFrVYDy7Ko1WoIBAJwOBwolUq02E8gQpVuSc129OTidDpx7tw5KvEkw8N8Ph8SicQLn2boBPV6Hel0mqr0vF4vlpaWkEwmX6i55xwc3UKlUqEtGSzL4tq1azQtRk7bzWYTXq+3q1ziOxpcVCoVBgYGaGAplUp07kOhUOirXXKv0Gg0aL8LkdFGIhEUi8Wu2RFxcLxINBoNWtBnWbbD72b/dCy4NBoN3Lp1C//xH/8B4JvoXKlU6CCwUCjUFXnDF418Po87d+7A4/HQv3sRp31ycHA8H0xzn8eDw7D+EAgEu2wN6vV6mxVJN/IsJ6pesk4hDYWERqNxoOmwfr9+h82znui5a/gt3Bp8PvZz/ToaXHoVbmE+H9z1ez644PL8cGvw+TjQ4MLBwcHBwbFfXozZtRwcHBwcRwoXXDg4ODg4DhwuuHBwcHBwHDhccOHg4ODgOHC44MLBwcHBceBwwYWDg4OD48DhggsHBwcHx4HDBRcODg4OjgOHCy4cHBwcHAcOF1w4ODg4OA4cLrhwcHBwcBw4XHDh4ODg4DhwuODCwcHBwXHg7HtYGGc3/S2cXffzwV2/54Oz3H9+uDX4fOzn+nEnFw4ODg6OA4cLLhwcHBwcB86+02IcHBwcz4tMJoNMJoNGo8H4+DhEIhFSqRTy+TxYloXX6+3a8eYcTwcXXDg4OI4EhmGg1+tht9sxNzeHf/u3f4NOp8ODBw/g8/nw9ddfIxwOo1QqdfqtchwAXFqMg4PjSGAYBnK5HEajEUajERaLBWazGWq1GjKZDCKRqNNvkeMA4U4uHBwchwrDMBAIBBAKhZiensYPf/hD2O12SKVSVKtVRKNRbG1tIRaLPbMSjqP74IILBwfHocPn8yEUCmEymTA+Pg69Xg+hUIhGo4F8Po9kMol8Ps8Fl+dkp1y6k9eTCy4cHByHikQiweTkJPR6PSYnJ+FwOCCTycDn81Gv11GtVlEul1GtVrng8gzweDwwDIPh4WHMz8+DYRhks1mUy2VsbW3B4/F05H1xwYWDg+NQkUqlOH78OIaHh3HixAkMDQ3RByIJKqVSCbVardNvtSfh8/ng8XiYmZnBr371K/D5fPj9fmQyGfzlL3+B1+vtSNDumuBCFhuPxwOP963OgGEYiMVi8Pl8iEQiiMViCAQCSKVSCAQCNBoNNBoNVKtVFItFVCoVpFIpVCoVNJvNvtsJMQwDoVAIPp8PmUwGuVz+zK/F4/GgUqkglUqf+HW5XA6hUAiVSuWFfgiQ9UdSPDwej64vqVQKuVwOHo8HiUQCPp9Pv6/ZbKJer6NeryOVSqFQKKBYLNI0UL+tUYJYLIZSqYTBYIDVaoXNZoNKpQKPx0O1WkU6nUY6nUY0GgXLssjlcn17LQ4LhmEgk8kgkUig1Wqh1+sBANFotO052gm6Irjw+Xx6Q0okkjbViEgkgsVigUwmg81mg8VigU6nw8TEBCQSCWq1Gur1OkKhEDY2NhCPx/Hll18iEomgWq323YOQz+dDp9NBLpdjYmICMzMzz7yIxGIxXnnlFQwPD9Obeq+b++HDh/if//kfhMNheL1eJJPJ5/oMvYrBYKBr0Wg0tq3TwcFBzM7OQi6X02I1oVaroVAooFAoYGFhAS6XC1tbW3j48CFdv/34UDWbzZibm4PVasXFixcxPDwMnU4HhmEQj8dx7do1RCIRfPHFF7h37x7K5XLf3a+HjUAggMPhgMViwfT0NMbGxlAul7G5uYlSqYR6vd6599axn9wC2e0JhUIoFApIJBL6b2KxGEajEUqlEjabDU6nEwaDAZOTk1RtUqvVIJPJUKlUIJFIoNFokM/nUSwWUSwW0Ww2e74xi8/nQyAQQCQSQaPRQKFQwGKxYGBg4JmDC8mFT0xMAMBjd9GlUglarRb5fB4CQVcsmeeCnJJb//D5/Cd6RzEMA5VKBYPBALlcDpvNRoNLs9mE0+nE+Pg4FAoFBgcH206UtVoN+Xwe2WwWbrcbxWIRyWSSnrw7+QA4TCQSCUwmE8xmMwwGAwwGA8RiMQCgUqkgEokgEAggHo8jlUp19s32KAzDQCqVQqVSQalUQiaTgWEYNJtN1Gq1jj73uuJJodPpcO7cORgMBkxMTMBms9F/4/P5kMvlEIlEUCqVNPjodDp6czabTcjlcphMJqTTaZjNZrAsi+XlZayuriKfzyMUCvXkrkgkEkEoFMLhcGB+fh4ajQazs7MwGo3Q6/UwGAzPbKjH5/NhNBqfeGoBvgnwFosF9XodXq/3mT9Lp+HxeBAIBDAYDJDJZFAoFFAoFNBqtZiYmHhiepBhGBgMBuh0OkilUrr+yDVTq9UwmUwQCoW7+jV4PB6kUin4fD7OnTuHqakpqFQqeL1eZLNZsCyLSqVyqJ+9E1gsFrz22mswm82wWCw0lQ0ALMvis88+g9frRSAQ6PA77V0YhqGpR4VCAR6Ph1qthnQ6jXg8jkKh0LH31hXBRalU4sSJExgYGMC5c+foTnonZJcJ7N5lazQaOJ1OlEolmM1mpNNpiMVi5HI5xGIxxGKxngwuQqEQEokENpuN3qjnzp2jAfhxAWG/kkSyy3nS1wmFQuh0OhSLxZ5tdCNrh3wWjUYDo9EIk8kEm82G119/HRqN5onfr1AooFQq6QmbnBj3umatf0d+LunzAIBQKAS9Xg+GYWiNsN/QarWYnZ2FwWCARqOhpxYAyGQyePDgAba2tjr4DnsfUnNRq9WQSqVgGAb1eh35fB6ZTIbWnjtBR4ML2XmPjY1hbGwMNpsNCoViz6/d7+6cz+dDoVCAz+fDZrNheHgYAoEAm5ubB/nWjwQejwelUgmNRgO73Y6hoSEYDAa6wyaF4Xq9vmsRiUQiyGQymnJ8XOqMnPyIYqder6NUKrUdp30+H7xeL0KhEIrF4uF+6EOCNPIpFAqcOnUKQ0NDUKlUUKlU0Gq1MBqNkMlkT/x+Ug/8rhTafrBYLDhz5gzC4TCKxSI9vVSr1ed63W6ACE6I+IaomQDQjZ7b7e7LgHrU8Pl8WCwWjI+Pw2QygcfjodFoIJVKgWXZF/PkQnTZL7/8MkZHR/Haa6/tKpI+jidFYqFQCLPZjHq9jtnZWWo5cfPmTeRyuYP8CIcOj8eD2WzG0NAQZmdn8fLLL0OtVkMoFAIAUqkUQqEQyuUyUqlU28lMo9HAarVCIpFAr9c/NuVDVEyZTAYsy6JcLiMWi7X5O62treH27duIx+M9W8zn8XgQiUQwGAz42c9+hvPnz7cpFEUi0XcGjJ11mudhamoKCoUC29vbiEajAIBkMtnzwYXUAIh6TiwWQygUgmEYNBoNbGxs4Pr169jY2Ojog69fEAqFmJqawuuvvw6VSgU+n49KpYJAIICtra2O1rI6GlyI6kan01E53c6bttFooFgsolaroVaroVqt0t02KbKSnTnZHZGdkkwmg16vh0ajgVwuR6FQQKVS6akCamvBmdRfyOcslUo0rxqLxdp2gtlsFrVaDRKJBMVisU0kIRAI6H/ncjmUy+UnBpdwOIxcLodCodBT164VIl8nxU+1Wv3Mr3UQQ6OIhL5er9P/3w+KMRJc1Go15HI5Xa+lUomqxILBIFiW7dm11A2QTZFAIKAtCSKRCLVaDZVKhaoTO7lZ6Uhw4fF44PP5sNvtOH36NE1J7JW6KRQKuHPnDlWW+P1+1Go1+sB89913MTc3B6lUCqVSSW98hmHgdDqh0WjA4/Fw584dBINBbG9vIx6PH/VHfiYajQYymQzC4TASiQRKpRJNzTAMg+3tbXz22WdgWRarq6ttJzOZTAaVSkVTQa0qL71ej9nZWQiFQiwtLSEQCKBUKiGfz6NarSKXy7WdggqFQs9Lu9VqNcbHx3cpuTqF1+vFJ598gkAggO3tbbAs2/OnFuCbID4+Po7JyUkcP36cSo83NzeRTCaxsLCAjz76iG5WOJ4NgUAAlUoFvV4PnU4Hg8GAYrGIWCyGSCSCaDSKaDTa0dRjR4OLUqmExWKBWq3eU+LabDbpEc/n8+HRo0fY2NhAuVxGoVCATCbD/Pw8xsbGwOfz6WmGoFAoIJfLqftqtVpFMBg8yo/63JDPSpoXW3siMpkMfD4fwuEwlpeXkc1m6fcJhUKqUCKNfwSr1QqRSASRSIQ7d+5gc3MTtVoN5XJ5z5pLPyAWi6na6yBFCU86bTxOKNFsNpFKpbC1tYVwOIxMJtOztayd8Hg86PV6OBwOKj2u1WpIJpMIhULwer3Y3t6mJzaOZ4PP59OTuFQqhUQiQalUQqFQQC6XQz6f73jwPtLgQnLbDocDGo0GIyMjMJvNkMlkNLiQFEE0GoXL5UIsFsNXX30Fv9+PcDiMWCxGC9hisRhffPEFwuEw5ubmcPHixbbiNQk0Wq0WL730Emw2GwKBQM8EmGaziWw2i3q9jmQyiVKpRD83CdAkVbZXOrFcLlNpYuu/MwyDmzdvUpuIfD5Pay/9kp4hkOKyyWTCiRMnYLVaoVQqD+S1G40GNVwk16/12pEbPJPJwOv10l1ks9nE+vo6lpaWkM1m+2J+iVgshk6ng1qtxtzcHM6ePQur1QqhUIhSqYRIJAKv14tUKtV3a6wTqFQqzM/Pw2q10q78XC6HQCCAcDjcFWKJIwsuJEcokUgwNjYGu92OsbExWK3WtlMLuUn9fj8WFhYQDoexsLCAYDCIcrncdoPy+Xx8+umnuHXrFvL5PM6dO0dTRq3pMb1eT5U5V69ePaqP/Nw0m01kMhlks1kkEglqb9NsNmm+VSQSQSAQ7Aou5DruRTabpQG2n+1HgG+CC+nTmZ+fh9FohEqlOpDXbjQaYFkW0WiUqu0IzWaT2pr4fD5cuXIFmUyG/ns+n6cP2n6oPYjFYtjtdhiNRpw8eRKvvfYaBAIBBAIBqtUqQqEQtre3kUwmueByAGg0Gpw+fRoOhwMmkwnNZhO5XA4+n4+KfDrNkQUX8jCUSqVwOp0YGxuDwWBoq7M0m02624tEIvB4PGBZltYCdu4MG40GLRSS7yMFrtY0UKsPV+vf9wrEm4pIVcnNSVwLqtUqRCIR9br6rhu33wMKgWEYiEQiyOVy2iyp0Wio2m4nrR5guVwO8Xj8sdYsDMOgWq1ic3MTkUiEphVbG1KTySTS6TQikQjS6XRb6ovIvvvl9yAQCKBUKqFWq6nbBhHj5HI5JBIJxGKxjqdqep3WTbrBYIDJZIJIJEKj0Wg7ubxQwYU84E0mE9566y2cPXuWGv0RyIklEAjgxo0buHz5MjKZDAqFAmq12q4bkezsc7kcIpEIPd0Q/ycCsZBpNBptqqleolqtIpPJUCWOWCzG0NAQLl26hKWlJVy/fh35fB6VSqVni+4HDcMw0Gg0MBgMGBgYwNjY2K5mPgJJx5I01fLyMi5fvkyVinsFgWq1CpfLRU8urcEFAK2REW+x1hoD+Xn9glQqxdDQEOx2O7RaLQQCAXUf8Pl8WFxcxIMHD5DNZvsmoHYC0oxrNBoxPz+PoaEhyOVylMtluN1uKvDpBjudIwsu5NQil8thMBhgNpt3fQ1RR5F0wn7sC8hOs1AoIJVKQSAQwGg0tn0NaaAjDXD73eF3E9VqFfl8nub3gW9uaKIWkUqlVIrI8Q1Ewi2RSCCRSCCTyfbs9yH1KdLvk8vlqEknkXPuFQhqtRq8Xi9VenXDbvGoIZ53UqkUGo2mLXgTh/JUKtVWYJbL5XQH3uq40UqrRJuc1Lm1DXoSJ6dEUj8kzwfSi9YN1+rQgwtZRCaTCSdPnqTy4FaIZX42m8VXX32Fzz77DMFg8KmKUmtra/jf//1fDAwM4J/+6Z+gUCja6i5kzKrBYIDdbkcul0MqleqZABOJRLCwsAC73U7tS4gTQSqVwvT0NORyOVwuF8LhcKffbk+RyWSwvLyMZDKJGzduYGNjAyzLwuv1PtH8r/Wk0yvr6KAZHBzE2NgYhoeH8YMf/ABmsxl2ux0A4HK58MEHH9D+KbPZjLGxMYyMjFDj1b1SlKVSCR6Ph/ZexWIxqq7rhkJ1p+DxeJibm8Orr75KywpCoRCRSIQqRyORCLLZbFfI2o8suKjVampKubPPgNiPFItFrK2t4cqVK7Rpcr+Ew2F8+eWXmJiYwE9+8hN6s5PiPqn5KBQK6PV6NJtNpNPpnnkopFIpLC8vI5PJ4NKlSwBAd+QGgwFOpxPNZpMLLM9AoVDA1tYWgsEgPvnkE9y+fbvTb6knYBgGJpMJx44dw8jICObm5mA0GummLhKJ4OrVq8hms9StfHp6GufPn6dTKUmauvU+zGQyuH//PmKxGJ2k6Pf74fP5XujgwjAMBgYGcOHCBZhMJiiVSvD5fORyOUSjUSQSCaTT6a6pax1qcOHxeDAajdBoNJicnMTs7CxMJtMu/7BisYitrS2wLEuPdE+bjybHwnQ6jWAwSHsa1Gp1W3DR6XSwWq1UwdIrFAoFBINB8Pn8XdJVqVSK0dFRSKVSejOKxWIq8ZbL5W2KPGIB35p6IP00vRJsDxKScuHG7D49pI/MYDC0qRZJE/Pbb7+NUqlElWOTk5NwOp3U3VwoFO665jKZDHa7ndrIOxwOxGIxWCwWZLNZ+P1+pFIpqqLs999Zq6+dXq+HxWKBRqOBQCBAvV6H2+3GysoKvF5vVykPDz24DA8PY3x8HC+99BJ+8IMfUFfZVtLpNO2gDwQCz3SkIzLlaDSK1dVVAMD09DS1+SA9Nk6nE1NTU6hUKnj06FFX/TKeRDqdRi6XQ6lU2uWRplar8fLLL4NlWSwuLmJlZQVarRY2mw0ymQxOp7PttJjL5eD3+1Eul+mAJiJ17vcbdS+I6rDTw5V6DYZhoNPpMD4+DqPRuMu+aXZ2FmNjY23Nza1TPMmGZ+eaE4lEmJmZoXOYGo0G8vk8Vd399a9/xdraGlwuF1KpVN//zvh8PlQqFRQKBRwOB0ZHR6lnWy6Xw927d/Hxxx9T1WK3cKjBhUhBSae8RCJ5rFKnUqk89yQ6IiWtVqt7qqZaB+v0mnU82V2XSiWEQiG43W6o1Wq6g1EqlajValTmrdFo6AyNnanIbDYLgUCAUqlEJd5yuZzKaYkvWa8HGvL+WwvDjUZjl80QsdLI5/NUrtzqNE1eh+sq/xZyEmkVSuzstSLKpsdBruVe15QEHvKaZDSyQCCgIpZIJAIej9f3wUUgEECr1dJMDOnlI6Oy0+k0EolE12UeDj24EHWYUqns+ExnPp8Ps9mMUqmE7e3tjr+fZyGZTOI///M/8eGHH+KnP/0pfv7zn9MmQYPBgH/913/Fz3/+c9o8uJf9CwkiRIXTbDbhcrlw7949RCIRfPrppwiFQn3xMCVGfiTtJxaLd10PjUaDCxcuIJPJoNlswmg0Ih6Pw+PxUDkxUTK2Wuy8qJBR2zKZDFarFRaLhTry7pdqtUrl2TsfiCTLQOz6yWmHqCJnZmagUChQLBZx586dvlinT0KhUODixYuYnJzEiRMnIJFIkMvl4PF4EIvF4HK54Pf7H6tq7BSHXtAXi8VUJttpSPPRzlHKvUSpVMLq6io8Hg9Onz6NRqMBoVBI+3pmZmYAtDv37pRd77SCAUBvVrlcjhs3btApi920WJ+FRqNB6ymVSgWVSoVawhAkEgmsVis0Gg0GBweRSCQgEomQTqdRrVbpTUvcZvvhujwPZLImyUiQrASR+D8JshaJgIdkF1oFOMTaiPws4kghFotpKq5cLtOC9kG4VHczJJ0/OjoKvV4PPp9PLaFYlqUp827j0GsuZrMZExMTu2xeOkGtVkMoFMLGxgai0WhXHSGfBtLbUy6XUSwW0Wg0ds0jae0N2DnpkARZ0tgqEomg0+lw4sQJGI1GeDweWK1WuFwuuN3uDnzCg4EoAqvVKpaXl/HnP/951yRP4Nt+GLFYjGPHjkGv19MGQNK/Uq1W4fV64fP5aG2rW1Q5R41EIqGTY6empqDRaKhDxF6QYFKv17G9vU1tYNbX19vEKQKBgHqUXbp0CVarFQDaepPIaG6RSERPTDwer63/q18gA/+IGnRoaAhKpRKVSgWhUAifffYZbTrvRg49uJhMJoyPj0OtVnfceqVeryMcDmNzcxPRaLQnd59k10zSPcRShKQQWr+OBKBYLNaWzhGLxbTuRJpL9Xo9tFotrFYrQqEQrFYryuUyPB5PzwZh4uCQyWRoesXpdGJ8fLwtuACgO+OZmRk6iphc61wuh0qlgtXVVayuruLRo0fY3Nx8oYPL7Ows5ubmMDk5CbVa/cQUMwku5XIZq6urWFhYgN/vx9WrV9v81shpaGRkBKOjo1CpVNTdm8Dj8ejYZBJcms1mX4oxRCIRNBoNdZkeGhqiTvHhcBiff/45PB5P1w7wO/SjxM5BSHsdYQ/jWEuO1ztfn/TP9GJgIVSrVfB4PITDYTx8+BA6nQ6jo6OQSCRtNibxeBz5fB7r6+ttdhBisZh6QI2NjcFsNlPpskgkopM8yY6UWJj0MqVSCbFYDHw+H2tra2AYBkqlkj7ASEPqXu7SxIVar9djYGAAAHDhwgWkUik644Y05ZKRBaSu1a99GWQ435OmchJfMSJCyeVyWF9fh8/nQywWo64IBDIpVK/X01Rbq6KMmHwmEgnq/VYsFmn9sN9QKpUYHh7G4OAgXZ+5XI6utXw+T8ecdyOHHlyIwum75MWtzY7Py141BaBdcdWrD0tiBlgul3Ht2jWk02mMjY3hH//xH2Eymei0TTJOlmVZXLt2DZFIhL6GUCiERqOBSqXCj3/8Y5w8eRJWqxWjo6NtM3LW1tZw/fp1lMtl5PP5nr6BU6kU7QVoNBqwWCyYnZ3FiRMnoNPpMDEx0eZHRyD1BalUiomJCQwNDaFareLdd99FtVqlD7pHjx7h5s2byGazCAQCKBQKCIfDdITxi0gikcDy8jJisRi+/PJLBINBmlokA/9aMZlMOHPmDJxOJxwOB3Q6HX0etPZiLS4uwuv1Ymlpac8g1S8MDAzg3XffpaIJoVCIRCIBl8sFl8uFeDyOdDrdtffloQYXcoQjD8MnpVdaR74e1nsh74cEu15N95DTSTqdhs/ng1wuB8uy4PP5dLAYmdwZi8UQCATagotIJEIul4NCoaApMJFIBKvVSuswRN5MfKB6PQVUr9dpH08oFEKlUqGplXq9DpPJhHq9DrFYTJsBW2WwwLeOCAzDUCNUtVqNXC6HYrFIfxekaTCdTtMhdt36ADhMyGmRrEVyYmlNhQHfztxpda4mvwfg2xRvsVhEoVBAPB5HOBymJ8d+Cyxk7RGjXzJ0jdyHJKh0+8j2Qw0upIB3/fp1TE9PY2hoaE/dO3H8JYvlIGlVp+TzebhcLty9exe5XK7nb/hEIoFyuUyPyMQdlTRF+v1+FItFpNPptu+r1WrIZrMol8v461//irt372JmZgavvfYadDodjh8/DqVSifHxcVy4cAGBQAA3b95EPp/v0Cc9OEhhPhKJgGVZrKysQKVSYXR0FBqNBq+99hqmpqaoQeBeKZ/WTYlCoYBYLMaJEydgNpuRTqfx4MEDsCyL+/fv04fii9Dst5NAIIDLly8jFothbW0NqVSqrYBP+uCOHTsGu92OwcFBjI+Pw2AwUDUnUfqR3xXLsvjrX/+K1dVVsCzbd9eUtG9IJBJYLBYMDQ3R4FKv17G+vo4//elPCIfDXX8/HvrJhfgD6fX6xw4JIqmeVmni8/7c1t1iawE8Go3C6/U+98/oBgqFAnWDjkaj4PP5tJ5ETmiPu96kO39lZQU8Hg/ZbBYqlQo2mw1TU1MQi8Uwm80YHx8HgI4r/Q4KkrMHgHg8DpfLBYVCge3tbej1ethsNjidTgDYM00GfPMAINeVNAYrFArY7Xa6owyHw4hEIvD5fODxeMhkMn33IPwukskklpeX6UC1nbZFxFDW4XBgenqajiNXq9V0E0rqfdlsFltbW4hEIlhaWsLDhw878ZGOBLFYDLlcDrVaDZPJRGcQkVM3GV3Q7S7ch/rEaDQaiMfj2N7exsDAAO0X2FlXKZVK9NjcjXrtbqd1pDEZQLXfDnsShLPZLH0QkoeA1WrFyZMnAXzjIUXknr2aTtwJcXMoFApgWRaVSgUejwcul4vW/1o3KSRlQ0wYBQLBrrVMxngrlUpUq1VoNBoEg0Fcu3YN2WyWztzpRYhcW6lUwmQy7Tkymij0yDUlReedWQKVSoWRkRFoNBq89NJLmJ6ehkqlojYyPB4P5XIZLpcL29vbCAQCuHXrFrWU71eIotHpdGJ4eJi6u29sbCCTyWB7exvpdLonnLgPPbj4/X7E43EMDAzQJr2dNyVRNLlcrl0pHI7vhsyzAXb7NH0X5JSXSCSwtraGarWKXC6HZrOJsbExjI6Ogs/n4ze/+Q3S6fRzW/R0E6RfqFKpIJ/PQyKRYHl5mXZAx+NxmpYBgKmpKUxNTUGn02FycpLWplrXslQqxeTkJBqNBsbGxpBOp3H//n1Eo1GEQiFa7+lFRCIRVCoVdDodBgYGMDo6uit12Gg0EIlEEIlE4Pf7kUwmkcvldq0Zg8GAixcvwm634+LFi5iammoL6KRh9c6dO/j4448RDodx//595PP5vll/eyEQCDA9PY1XXnkF09PT0Gq1yOVyuH37Nra2trC4uIhYLNYTo6IPPS1GJJmFQgHJZBICgYBKXHd+7fMU9MnCJLJSlUrVs134z8LzLjQSVHK5HBUFEKsUpVIJu92ORqOBUCjUdxYopKmUpMEqlQodWkc69JvNJq2vpFIpmrog60wkEtF+DJJCJK9HHCGIpLmXIYGEpKv2SvWRAWJCoRASiQS1Wo3e71KpFBKJBIODg3A4HLRXhXgOkp4VlmXp0LZYLIZkMolisdizgfm7YBiGOm1oNBqYzWbaIEqsh0hrQS8EFuAIpMhk7rvP58OVK1dgtVpx5swZWCwW+jWtw7yetdGS/GIMBgNmZmZw6tSpXXNjOB5PLpeD1+uFQCCAx+OBRqOhShWn04lf/epXCAaD+O1vf4v79+93+u0eKAqFAlNTU1CpVNBqtajVaojFYrhz5w5VFjYaDSwtLdGJiyMjI1Cr1Zifn6fS2cnJybbaFLE9IhMa8/n8E40cux2SIqxWq4hGo/B4PDQF2Kqs0+v1kEgk1BE9n89DKpVCKBTi2LFjmJ2dhV6vx8zMDA3QAOgpMhaL4Y9//CM8Hg/u3r2Lhw8fUuuefkUikcBsNkOn02F+fh5nz56FTCajBpUulwsPHz7sKWeRI2miBEAts/l8/q5CFAkurfMgnhaSD5ZIJNBqtdDr9X3vOXSQkOZScnrJZrN0YqhCocDY2Bg9EfYLRPJJBq4RCSwRmLAsi2KxuEu2rlKpUC6XoVarYTAYaMDZedMTVwByanmSRUqvQDIM+XyeTuFshWEYKpslwZp03ovFYoyPj2N+fh4qlQoOhwMikYimZltduT0eDx49eoRAIIB4PN6hT3t0ECm2SqWCXq+HyWQC8K3JbCaToae3XuHIJECtsxl2olAocOzYMSgUCty/f/+ZivoGgwHT09NtRTAuuDw9pVIJW1tbNFVks9lo02W5XN5zZEKvYrfb4XA44HQ68b3vfQ8qlQrBYJDWWkjaZ6+gQdJoOp0OZrP5ia7fpPO8XC73dKqWbD54PB5u3ryJYDCIS5cuYWRkpC3jQOa1jI+P47333kO1WqWBdmhoCBaLhTpTNxoNak+0tbWFe/fuIRaL4caNG4hGoy9EYAG+SaGOj4/DYrFAr9fTDMKDBw8QCATw6NEjRCKRnuo3O7LgQpokdzr0At8okSYnJyGXy+HxeODxeJ769bVaLWZmZuiUOy6wPBuVSgVutxu1Wg3Dw8NoNpsQCoVQqVS0ObAfYBgGFosFp0+fxsjICN58800olUp88skniEajNLDsVVMggVcul0Oj0dCREo9bc8QYtFgs9nRwJgG3Vqvh3r172N7exsjIyK77mWQhhoeHYbVaaStAo9GAXC6ntSiGYWgPSzgcxrVr1/C73/2OWhftPBX1MzKZDENDQxgYGIBOp4NAIEA4HMYnn3yCcDiM7e1tsCzb6bf5VHTFk4J0hSsUiqd+eIlEIuqUOjo6CqvVumt3SMwb99Lac7RDemR2DlsjPlL9hEajwdDQEGw2G6RSKX0okvkhO9cRcSywWCyYn5+HXq+n43h3TmHsZ0hTcqlUos7cZDJi6zUg0yaJZX6z2aQnnGKxSAdcPXz4EF6vFy6Xi7odvCg9QeQayeVyWK1WWK1WWmspl8tIJBJIJBI9WW/qiuBC0ga1Wu2xjWt7wePx6A0/MzODv/3bv4Vard6lvc9kMlhcXEQoFOprjfxBQEbKEtlxv8IwDIaHh3Hp0iWo1Wqo1Wo0Gg2a7lIqldBoNPSmZhgGExMTmJiYwMjICH70ox/RwjWppTwuuLTu7HulGPskSE2KYRikUikkEgl6imvdHJL0IdA+rwX4psHyq6++QiQSwccff4yVlRW67kiW40WAzLsymUw4deoUhoeHYTAYAHzz3Nrc3KS1v17jSNNiZE75zroLj8ejJxelUgmFQkELWXvdjER2LBAIoFaraQFfo9FQ91DyMxuNBm3oYlm2L08uZOfD5/OpW22pVHoqixtSoyK5cfJa/Qzp25DJZNQRWSKR0MBisVjoeuHz+bBYLLDZbLBarTCbzVTwsJ8BWf3gxt0K6f8h64wU8HdC3AxaB64RtVkwGKQ9MSQVedD2T92OUCiEXC6HUqmkzz6GYajDRqFQ6NmT3JEFF5ZlcevWLYTDYfzN3/xN278pFApMT0/D4XAgGo3CZDJha2sLt2/fpo6n5GhNRqCqVCooFAr86Ec/wtzcHEZHRyGVStsCSyqVQiaTwcrKCv7yl78gFAohGAwe1Uc+dMj1GBoawk9/+lOYTCbo9XooFAp89dVXeP/995HL5Z44/pQEFbKD0ul0GBkZgdPphE6n2yWM6OeAIxAIMDMzA4fDgVdffRVvvfVW23VTq9V03T3NCbtcLiMajSISifTFaZDMuCmXy9jc3MT169dhs9n27F8DvkmBLS0tgWVZrK6uYm1tjZquEvfoSqXSF6e6p4FhGNhsNszOzmJqagoGgwEymQzRaBTpdBput5s2oXLB5Qnk83laqN+peCAzRDQaDR3U1Gg0sLi4SHd7zWaT7qxFIhEUCgX0ej2OHz+Ov/mbv4FSqaTTGIlooFgsIplMIhQKYXV1FeFwuK8aAMn10Ol0OHfuHIaHh6lVea1Wwx/+8IfvHC/Q2nwqk8moBYfZbG4TRrwI9QQej0fz3k/iaa8F8cbKZrN9sTMnHfTVahWxWAxut5vutveiUqnA7/fD5/Ph66+/xtWrV2kHfr+c5J6V1rqfXC6HSCRCNptFKBSi6bBe3ZAcWXAh8xsymQzW19chl8thNpthtVrpzcrn8+FwOGiaRyKRIJ/P03SWSqWCUqmETCaj8s+pqSkolUqIxWIaUIiNzKNHj+ByueDxeJBIJPZMyfUyarUaOp0OdrsdRqMRer2eqpGcTifeeecdpNNpZLPZthu/UqlQSw5SwLbZbHRi6PHjx2mqEfjWXuagjEVfBJrNJoLBIB3o5vF4EA6He0pK+l00m02Ew2HcvXsXbreb1l52UiwWsb6+jkQiAbfbTS2EXrSTyl4Qs1ij0QihUEil2S6XC7FYrCdPLIQjDS4kUNy5cwfpdBqvvPIKLBYLDS4CgYD6WZ04cQLnz59HLpfD6uoqMpkMbDYbbDYbFAoFrFYrhEIhVYsB3yz2bDaLa9euwe1249q1a7h9+zbN5fbbYtbpdJiensbExAScTicsFgtNW01OTuJf/uVfUCwWEY1G2x5quVwOPp8P5XKZFqPn5+fxve99r22eCVH4EGuYnUGK4/E0Gg1sbm7i5s2bePToEVZWVpBKpfouOG9vb8Pr9YLH4+H//b//99gRBSS1/Th594sIwzDQarUYGRmByWSCUChErVaD3+/H0tIS/H5/T1+rI22iJPYOLMtCKpUiEokgHo9TnyYej0cDBRnFKxQKYbFYIJfLYTAYoNPpaI9BqzKFWM9HIhEEg0EEAgEqdexHSJ2E5P9bC/DNZpPajkilUurXRCBqOtLcJhAIYDKZIJfLIRQKqcdbNpul13V7e3tXkOp1iJXJ8zg9tzYHkwcnkeiGw2H4/X6wLNu3u/XHNUZz7A+ybkhfFRkIlslk6HC7XuVI1WJkKNjNmzexvLxMH3hGoxEnTpxom2MukUho855Go6Hmd+SkstODzO1248qVKwgGg/joo4/g9/v73r5frVbD6XTCbDbv8qySyWTUbNJms7U9AIhFPxFJkK8XCASo1+vIZDIolUpYWVnBo0ePEAwGcffuXaTTabhcriP9jIdJqVRCKpUCwzDQ6XTP9BrVahW1Wg2FQgHpdBr5fB5bW1tIpVL4/PPPcfXqVRSLxZ4fE81x8DSbTeRyOUSjUTpTiWEYhEIh2jTZy2vmSPtcSIolHo8jm80iGAxS9VahUIBQKKTmla1+Y6Se0vo65LhIiv3JZBJer5e+ZutY336FKOdIUCApF5KaIAGH1GH2ssRpdU0gRVoygyMajcLtdiMYDGJzcxPZbLavAjaZ5SIWi1GpVOimZb8FeyIxJsXpVCpF13U8HkcgEEAoFGr73XBwtNKacibWOrlcjm7wuJPLU0AeYvV6HSsrK8hmszCbzfD7/dBqtbDZbNDpdFAoFHQ3WSgU2n4J5KFQrVYRDAaRSqXg8Xjw8OFD+jX9TrPZhNfrxcLCApxOJ1WNkRMfgcfj0e5zMumPUC6XcePGDWxtbSGfz9OaACn2e71eBAIBOtuEBJ9+oNlsYmVlBb/73e9gNBpx/Phxqla02+37eo1qtYrFxUV4PB74fD6srq5Sw8tSqQSfz9eXqTCOg6HZbGJjYwO1Wg1SqRSff/45eDwe7t+/j1gs9tg+v16hIx36pKFsc3MTm5ubMBgMSCaT0Ol0mJ2dxcDAAIxGIy0oJ5NJlEolOjq2VCohmUyiUChgcXERPp8P2WwWyWTyhcoBBwIBOpRJLpdDp9NBqVTSuSJEqqxWq2nQMZlMdGderVZx9+5dXLlyBSzLIhAI0PklrQqxfqTZbMLlciEej8NoNCKdTtM+of0Gl1qthvX1ddy6dQtra2v4+uuvX8h+DY5np9VLkdyX/bJ+usL+pVwuIxKJIJ/Pg8/ng2VZqNVqbG9v07xktVpFMplEKpVCpVKhyiUySrVcLvfMEJ2DgqQHi8UiPB4P4vE4ZDJZWyMbn8+nhXoicSSLuFgsYnl5GaFQCJlMho4xJr1FvaxU2Q/kBJxKpWigkcvlCAQC+/r+crmM+/fvw+12U9noi7T+OA6Wfls7THOfn+gwm+hIEx/5X6J8apUYt06qJAodUsMhN/VRnVieZREc5vUjs2yIv1XrzyL/TSbdtSrsms0mnene6lpN/u2wFnu3XD8itya1K+J2vN+BXqSvipz2jkqm/ay/lxehEXa/dMsa7FX2c/26Irj0GtzCfD646/d8cMHl+eHW4POxn+vXv0ZRHBwcHBwdgwsuHBwcHBwHDhdcODg4ODgOHC64cHBwcHAcOFxw4eDg4OA4cPatFuPg4ODg4Ngv3MmFg4ODg+PA4YILBwcHB8eBwwUXDg4ODo4DhwsuHBwcHBwHDhdcODg4ODgOHC64cHBwcHAcOFxw4eDg4OA4cLjgwsHBwcFx4HDBhYODg4PjwPn/inEVF4OB7cwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 27%|██▋ | 54/200 [04:48<13:18, 5.47s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 28%|██▊ | 55/200 [04:54<13:04, 5.41s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 28%|██▊ | 56/200 [04:59<12:53, 5.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 28%|██▊ | 57/200 [05:05<13:03, 5.48s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 29%|██▉ | 58/200 [05:10<12:50, 5.43s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|██▉ | 59/200 [05:15<12:36, 5.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 60/200 [05:20<12:23, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 61/200 [05:26<12:20, 5.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 31%|███ | 62/200 [05:31<12:12, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 32%|███▏ | 63/200 [05:36<12:04, 5.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", + "Step 63: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9R4ykWXYdfMJ77yPDpDflu7raTU9P9zSHpEQKJEiKGwkQJS60IAQIECRoJwHSStBGW2khCZIgQgJBgRoNSdCMn+7p7urylZXeRGRGRIb33vyL5Ln1omYEZkX2jx/4kQ9IdFdVZmTE+9675txzz9VMJpMJrtbVulpX62pdra9waf+/fgNX62pdrat1tf7/t66cy9W6Wlfral2tr3xdOZerdbWu1tW6Wl/5unIuV+tqXa2rdbW+8nXlXK7W1bpaV+tqfeXryrlcrat1ta7W1frK15VzuVpX62pdrav1la8r53K1rtbVulpX6ytfV87lal2tq3W1rtZXvvQX/cbf+73fg06ng8/ng9vtxsnJCb788kvo9Xp885vfxPz8PMxmMywWCzQaDbRaLUajER4+fIi9vT00m00UCgUYDAYsLy/D7XYjEAggEAhgNBqh3W5jMBigWq2i1WohGAxicXERjUYDf/7nf46TkxPo9XrodDpYrVb4/X4YjUZYLBYYDAZYrVa4XC4AQKfTwXg8RiAQgM/nQ7/fR71eR7vdxosXL5DL5WA0GmE2m2G1WjE/Pw+bzSaf1Wq1wuPxYDgcYnd3F8ViESaTCSaTCRqNBv/yX/7L197of/yP/zG0Wi2i0SgCgQA2Nzfx7W9/G0ajEX/37/5d3LhxA+PxGJPJBIPBAPV6Hb1eD/v7+8hkMmi1WigWizAYDFhfX4fb7Zb9MBqNcDgc0Gq1yGQyKJfLiEajWF9fR6PRwHe+8x0cHx/D5/PB6/VCr9fDbDZDr9cjEonA7Xaj2+2i3W6Dgg0ajQbBYBB+vx9msxlOpxPdbhff/va38ezZMywuLuLGjRswGo2w2WzQ6XTyWfv9PprNJsbjMTQaDTQaDcbjMUajEQDgn/2zf/ba+/crv/Ir0Ol0mJ+fRyQSQSaTwePHj2E2m/Hbv/3b2NjYgEajgU6nQ6/XQ7FYRLfbxdHREQqFAmq1Gk5PT6HVahEMBmG1WmGz2WC326HVaqHXn1+FdruNbrcLl8uFYDCITqeDx48fo1QqYTQaYTwew2AwwOFwwGKx4Pr164hGo5hMJhiPx+h0Otjf30er1cLS0hLm5+cxGo3Q6XTQ6XTw5ZdfIpVKye83m80Ih8OwWCxwOp3yfgwGAyaTiZyDRqOBarWKyWSCf/tv/+1r7x8A/Ot//a9lj3Q6HY6OjvCTn/wERqMRv/Vbv4WNjQ1YLBZYrVb0+30Ui0W0Wi384Ac/kL12uVwwm81IJpNwOp0YDAbo9/uwWq0IBoPQ6/Uol8totVrw+/1IJpNot9v46U9/ikKhAJvNBqvVCpPJBIfDAYPBAI/HA7vdjna7jUajgX6/j3K5jMFggGQyiXg8jvF4jH6/j3a7jR//+Mc4PDzE0tISbt68CYPBAKPRCL1eD61WC61Wi8lkgtFohOFwiLOzMzQaDbnzAPCv/tW/eu39+yf/5J8AAMxmM4xGI3K5HJ4/fw6DwYAPP/wQ8/Pz0Gq1U3dhNBphZ2cHJycnKJVKODg4gF6vFxvocDjgcDhgNBrhdrsBAAcHBygUCpibm8PGxgZardaUDdTr9bBarQgEAjAajfD5fLDZbPJ5e70eCoUC+v0+bty4gbW1NYzHY/R6PfR6Pezt7aFQKMBkMsFiscBoNMLj8UztoU6ng8FgQL/fx8HBAcrl8tQd/q//9b/+tft1Yeficrmg0WjkzUQiEXz961+HTqfD3NwcbDYbMpkM0uk0PB4P3nrrLdjtdty6dQuxWAzZbBbPnz8HAHi9XjidTkwmE5TLZRgMBjHunU4H7XYblUoFz549w2QywdzcHEKhEFqtFprNJjQaDfr9PgaDAbrdLrRarWyuTqeD2WyGwWBAOp3G8+fPYbPZEAqFYDAYsLq6ioWFBRSLRZycnKBWq2F7extGoxGJRAKRSATD4RAnJydywRqNBgCI45xlmUwmAECr1cJoNILZbMYv/MIvwGAwwOfzYTgcolAoIJvNwmq1IhaLwePxwGazYXl5GZlMBk+ePJHParVa5WFPJhO5VEajUYxDKpVCr9eD0+nE/Pw8rFYrrFbr1MVrNBqyb0ajUQIDADg9PcXW1hZcLhcWFhag1Wrh8XjECNVqNfT7fTnIiUQC4XAY7XYb+Xwew+EQ/X4fk8kEJpMJZrN55v1bXFyERqOByWRCs9mEzWbDW2+9JU6/VqshlUrh4OAALpcLd+7cgc/ng9FoRDAYxMnJCcrlMgDA5/PB5XKJEzSbzXC73dDpdKjX66hWqxiPx9DpdJhMJggGg3C5XKhUKqhUKgDOnVCv18PR0RFqtRr0ej1MJhMGg4H87P7+Pra3t2Gz2RAOh6HT6eSMlUolZDIZNBoNlEol6HQ6rK2tYWFhAfV6Xfa00Wig1+vNvG/q4jnmslqt+Oijj2A0GuH1euVZlstlWCwWxGIxBAIBvP/++1hfX0e5XMbx8bG8l+FwiE6ng0ajIcGcTqeD3W6H0WgEAGQyGQyHQ7hcLgnOAGAwGCCdTkOj0aDX68HtdktwZTQaEY/HodFoxG64XC4sLi5Cp9NhfX0d8XgcOp1OgoFUKoVOp4NoNIpQKITRaITBYIDhcIh6vY5utwuLxYLhcDjz/nW7XQDAeDzGYDCAxWLBzZs3xTFMJhPkcjlks1k4nU5cu3YNTqcTGxsbSCQSOD4+xmAwwGQygdfrhd1ux3g8RrVahc1mg8/nk8DPZDKhXq/j2bNnGI1GCAQCskfcJzrcWq0m7w2ABLE6nQ75fB6Hh4dwOp1IJpPQ6/Ww2+3Q6XTy7IbDIQ4ODjAajTA/P494PI5qtSpnkK9vNpvFOV9kXdi50Pgz4mVUQmOu0+lQKpXw6NEjxONxvPfeexKRDIdD8Zaj0QhOpxNWqxW9Xg+1Wg02mw1+vx96vR7FYhHA+UU4PT2FyWTC6uoqXC4Xstks8vm8ZCL0opPJBMPhUIyP1WqFwWBALpfD1tYWwuEwPB4PHA4HEokErFYrNjc3kUql0O12USgUAAAejwfz8/Po9XrI5/PodruoVqvodrtyMWa95IyMu90uWq0WXC4X7t27B6PRCJPJhNFohFKphL29Pfj9fiwvL8Pr9YpRslqtODk5wWg0gsVigclkQq/Xw3A4xHg8BnCebRgMBpjNZgyHQ+RyOUwmE4mIGbEOBgNxcu12G8PhEDabDRaLBTqdTiK/fD6PnZ0diZAYXTscDrTbbTHET58+RaPRwGQygcPhQK1WQ6FQQK/Xk9d3Op3weDwz79/c3BwmkwkajQba7TbcbjdWV1cl2mo2m9jd3cX3v/99LCws4O2330YgEIDZbBbDSYPncrng8/lQKpVQq9Uk89Xr9RgOh2g2mwAAg8EgkTUdDZ1xp9MBAGSzWVSrVVgsFsk66KCPjo5wdHSEUCgEnU4Hh8OBaDQKp9OJzc1N7O3todvtisPy+XxIJpNoNps4PDxEu91Gs9lEr9eDzWaDw+G4lJNpt9sAzqPp0WgEv9+PW7duwWQyyR3K5XLY3t5GIBBAMpmE2+1GMBiETqfDixcvUCwWxUCPRiM5z3q9HpPJRAJQk8mEdrst99lms8HpdKLX66Hb7aLb7eLs7Ayj0UiCGr1eD4PBAJPJhGAwCJPJhM3NTfzkJz9BMpkUA5tIJGAymVAoFHB6eopCoYBHjx6hUqng5s2b0Gq14vhGo5Hck9FodKn96/f7AF7aG7vdjkQiAYPBAIvFAgAolUpic27dugWXywWv1wutVguTyYSTkxO5D1arFfV6HY1GQ7IFo9EoX+12G9lsFkajEfPz83A4HFP7VyqVMBgM0Gw2JcjWarWS1ZjNZvz0pz/F/fv3EY1GJVNikJnP5+WMHR4eigMJhUKo1WrY39+XwIYZr91uv/AeXti5MOrr9/uwWCyymbyAWq0WFosFbrcbWq0WW1tbyGazMJlMMBgMaDQacDgcUw/bZDLB4/HAYDBIykYnYTAYYLfbodfrxSvzIDItnEwmqFaraLfbAg0RFun1etBqtXC73RIFMJIxm80oFosSoTLTYbpOAzwYDCQi5eWZdXW7XYk2xuMxTCaTfC673S6QotFoxGAwwO7uLqxWq8AvNGA0ft1uF16vF8FgEADktfV6vRhRZiiEc5jq0smMx2O0Wi1x1Ha7fQqiHA6HsFqt0Gq1KJfLElExws9ms+j1enJg/X4/PB4PxuOxGFkVqrjM5T49PZX/12g04vj53Hkh6Qi2t7eRz+flczQaDXg8HkwmE3Q6HRSLRRiNRiwuLgqsApwbQbfbLQZSo9GIs+n3+/K9vGQ0YszMJpOJZHQajUbghlqthsFgAIfDAb1ej3a7jU6ng36/L4GHur88w7wLOp3u0tkLnQtfazgcyh7a7XYYDAYA5/es2WxiZ2cHDodDkAY+636/j/F4jG63OwXv8e8mk4mcR6PRKP/P52+xWDCZTBAIBOT5lEolOBwO+Hw+TCYTZLNZsRVerxcGgwGFQgHtdhsejwcWiwX5fF4gY5fLJRn/3NwcGo2GBGM0jAyQZl29Xg8A5J71ej20Wi159jzrwDkCc3BwgFKpBKPRCJ1OJ2UBjUaDer2OVqsFu92OhYUFcfC9Xk+CRZ5BBjbtdlvus06ng8vlkrNdr9fhcDjgcrmg0+lQq9XQaDSg0WgQCARgt9vRbDYlMBiPxygWi8hmsxJ4mUwmOJ1O2Gw2QYjUpdPpprLPv25d2LkcHR0BOE+licEziqZxZurVarXwx3/8xxgOh4jFYggGg7BYLAiHwxgMBkilUmg0GlheXpZM4ezsbOpCsYZC3JnwmcVigc1mQyQSAQA8e/YMp6ensFqtCIfDGI1GOD09Rbvdhl6vRzwex2g0Qi6Xk8xGr9fj6OgI6XQaZrMZGxsbcLvd8Pl88hAYHRCn5cOfddE5c2k0GlSrVdjtdszNzcHr9cLtdsNut6PRaOAv/uIv0Ov1EI/HBW5wu92yf61WCx988AHefPNNtFot7O3tod1ui6PX6XTQ6/UYDAbitOmUeUgGgwEePXqE4+NjJJNJgeeOjo7QbDYlghwOh0ilUtBqtQiHw7Db7VM1D+4faww6nQ4HBwfQaDSw2WwS+VwGknj48CG0Wi1CoRB8Pp9EzYRQmJ0lk0n0ej386Z/+KUajkUCIPJvj8RjpdBqtVgtvvfUW3nvvvalM1e/3w2QyiUMkVMR6FDPjUCgEANjf30c+n4fD4YDb7Uav18Ph4aE820QigX6/j9PTU4E8CAczqmdwYbfb4XQ6BYptt9sSZdLwX2ZVq1WJbC0WC5rNJo6OjmA2m7G0tASLxSJZa7FYxNHRETQaDa5fv47FxUX0+334/X7Zk06ng6WlJaysrMgecp8mk4kEiKPRCJVKBf1+H06nEy6XSzJg7lc6nUYymUQ0GkW328Xjx49RqVRgNpsxPz+PwWCAra0taLVazM3Nwel0IpVKYWtrCyaTCUtLS3C5XLh16xbW1tZwdHQksDADApvNJlnELIuwIgNcnmeLxQKPxyO2hXv9ox/9SFAHOh+LxYLBYICTkxO5wx988AE6nY7c6+FwKJluMBgUm9ZoNCQwZK1lNBrh2bNnODs7g9lsRiAQkPvKoJs1l0KhIM8GOLfpz58/h9lsxurqKtxuN8LhMAKBADqdzlTtiJ+btd2LrAs7F2YUjLyB86yFEf1oNIJer4fNZpPUjUVMGgFuPDeID50pK6MYvr5er5+KdmkUGWXyPdD4/zxPy6iFEBojakZrLM4xNWcNQ03R+TqMXGZZzFLUgp/6ewHI+1IjV9agiHey+Mz9ozMBIGSAwWAg+83XJpZNY6/VaiXD4J78vP3jM+P38YLQ+ZvNZilK0gETAuCZYI1MxYVfd/H8vZqFcb/4Owkd9ft99Ho9+Qz8GS7+2WQyyZkeDodyBtWiOv+d0R2DKQBTxWR1qYVzPie+T61WC7PZLMaB50zda+4fzyehmMuswWAAjUYjtS++F/X50wEyg6UTHwwGchd5N5j1MxPRaDTyPkej0dTrcn9ZF2RG9ur38f+Z6eh0OthsNgn2uD80sLzDdFa0AzynAKayZ2aUsyx+fhpnnhH1nnH/WA/mfVBtETMf7iNhbH7xDk8mE8laAMgZ5PnjfvGMq89SRTL4PHu9nrzWZDKZImhw/1Sby0BIRSH6/f5X71z45l0uF9xuN0KhENbX16HX61Gr1VCv12EwGBCPx2GxWJDJZABAYDHCIow8xuMxgsEgjEYjut2u4PO1Wg3tdht2ux1Wq1UMMAA4HA7JLLa3twW7vHbtGgBM4f42m22K+RONRuV1NBoNVlZW8O6772IwGKBWq0l6eXx8jNFohLm5ualM5/DwEFtbWzNnL9lsFhqNRiAku92O69evw2q1YjAYSGbDyLnVaqHT6cjBU2E67rvP50O5XJ5Kl9PpNHK5HPx+PxYWFqT4OBqNEA6HsbGxgUajIXiqWpcgSSCRSKDX6wkTiLUqkh48Hg9u3bqFX/u1X0O/30e1WhWo5OTkBIPBAEtLSxIlTSYT7OzsYGtra2YD6Xa7p9hgfr8fd+7cmSIJaDQa2O121Ot1AOcwEKEF7ul4PIbNZpNzSZJIoVBAo9HA7u4ucrkcvF6vnAEGTfF4XNhPhBMikYjUxVqtFgaDAfx+P5xOJ4bDISaTiUAfjCztdjtCoRC+/vWvo9ls4sWLF0Is4D3a2NiQbBM4L4zv7+9fKnsuFovQ6XSSoTidTsTjcXHKOp1OiC/5fF6yOQBiUBiQLCwsSCRLA8Rib6lUQr1eh8vlgt1uF4fDoMfj8aDZbKJUKgm8a7fbpwra8XhcziSJNHz+TqcTFosFa2tr+MVf/EUpbI9GI/T7fWxvbwMAbt++DeA8sBsOh8hkMnj06JEEr6+7uPdkC/p8PiwtLYmhp625du0ams0mjo+Phazg8/nkdUwmE9bX16HRaBAKhaRu1Wg00Gg0cHZ2JmxHNZA2mUyIxWKIxWJTdRISVKxWqzg0j8cDp9MpwQ2fMTPTyWSCu3fvwmq1CgxKMsrBwQHG4zFWV1cFRTIYDEilUtjc3Lzw/r22cyEswM3VarVCl2Rk3Ov1JMNglM1ohOkeIxIeWnrtfr8vRhWAbI5WqxXYoNfroVwuo9frwefzIRAICFUTgBSmGXUR3qEH5+cxGo1otVrY2tpCvV4XogCxR7Xecnh4iEqlMrNxbLVakpnQsNGw53I5ucQ08Iwi1CiOl5jUQ4vFIg6U0XW9Xkc+n5faDfDyUqisJUaSNLQ2m00idUKeZAExyrZYLAiFQnJwPR4PWq0Wnj17hlqthlarhVqtJgaE2RGfe7VanXn/GIWyWGsymRCJRATeIeTCM8eLxb3WaDSyHwxYGMmShk3mVjabBXDu6BkZarVaeL1exGIxlMtlZDIZjEYjqYl1Oh1xXoSK2+022u02TCYTAoGAUJ9NJhO8Xi+i0agw0IrFosCYOp0Ofr9fqNwAkM/nhd496+p2u3IvSMTxer2yF4QxWXNUDREXzyCZjGoUy2h8OBxKPYaL95tOiFAt63oMHJkdO51OQSR4By0WizgfnrFgMIh+vy8wU7lcRrVahdPpRCwWk/pgr9dDJpMRFuMsi+eYGYfVahVqPynUZrMZfr8fBoMBp6enGAwGAnnS+bFeYjabYbPZJIgj4tNsNtFoNGC1WtFutyV7oQ0MhUJyD/r9vtxd7jMAQTl4fqxWqzhvPtNwOIxkMolut4u9vT1xbLVaDRaLRc4Gn8XZ2RlKpdKF9+/CzmV1dVU2uNPp4PT0VAxJMBiEz+eT6JoXjIeYm9pqtaYON5laNEq9Xg/BYBDJZBIWiwUOh2OqxkBH0m63JQNgek7apslkQiKRgN1ux9nZmRjnw8PDqaiHzqXZbKLZbKLVak1hsrxYvAButxvr6+szX+63334bAISAkM/n8dOf/hQ2m00KlIx0NRoNnE6nGEVG5HTmjLZVWJHMmPn5eWEkBYNBtFotYfm43W6YzWY0m00pOrPXBwDq9TrMZjOi0ahgw8xM9vf3hSvPPhGHwyFngYaVjpBRN38n+27o3F93ra2tSTGezuDJkyfi8EhFZ3RLKIoZMJ83KdrNZhNarVbOLLOvhYUFJJNJ2O12BAIBiYQbjYYY3nq9jrOzMymEcq94H+bm5uR58qtUKqFSqSASicDlcknPCp0yYVAWdGksaBy8Xi8SicTM+wcAGxsb8v/FYlGyKovFgkAgIJEv4V+fzyewYalUmoJh+F86km63i2KxKMaOEJVWq5V6Al9Dr9dPUZh9Ph88Hg96vR4qlQoMBoP0zfV6PaGMp1IpjEYjMcysS5HGz2zbaDRKnZWIyXg8hsfjwd27d2e+w+vr6wAgnzeXywlkHYvF4HQ6AUCgI+4T3z+zRrUGSZovg+Nut4twOCx3OBKJoNfr4dmzZ6hUKvJ5Go0GKpUKBoMB7HY77Ha7OCiyedXaIeuyo9FIiEtEktgXxnqPmokxIBgMBjCZTNK3dZF1Yedy/fp1jEYjnJyc4OzsDLlcDqenp7DZbPiN3/gNLCwsoFwuo1AoYDwew2q1TtU7mLbyz3q9HvV6XSApFpDW19exsLAA4DxKqlQqyOVyODk5QTQanfL8xF2JJ9ZqNbhcLoRCoSnvXqvVsLOzg8lkgvn5eWGf0LmQuRGLxeD3++X90GkxzXQ4HK97HmV9+OGHGAwGePDgAXZ2dpDJZFAqleB0OvHRRx/B6/UCeFkTUvsC+OdoNCq0bhZneeFpTJeXlxGJRMTIE97Y39+HTqcT+IqRqdvthsvlkqhdq9UikUjI/ul0Ojx69Ah//Md/LM+K9F2z2Sy9QGQRsu5CZl8gEIDH40EikRAsfpbFJtPT01OJ4r/44gtYrVZ84xvfELIDLxPfn8vlgsvlkj83m008ffoUJycn0k9FA24wGHDt2jXEYjH5veVyGQ8ePMDJyYkwdjqdDs7OzqRfgYV8RszhcFjouzqdDicnJ/jkk0/Q6/Uk6ibbjYECDRazC2brzF5ZSL9M5nL79m2MRiPs7u4KZMO+BxbZ6cDJ5nI4HBiPxzg7O5PmYn4uQpSdTkcc7mAwwMrKCsLhsDQ9shk4lUrJPo9GI6EwswXg5OQE6XQaTqdTzvHZ2RkKhQK63S729/fR6XTg9/vFoFYqFYzHY2FCMZjo9XoolUqYTCbSaO33+7G0tDRzzeXGjRsYjUbY29tDOp1GsVhEqVSC3W7Hr/7qryIWiwnEpNa0er2esLmIqhA5IPLQ6XTk/a6vryMWiwl5ieQPQtnM1An/RqNROBwONJtNsaPhcFhsJHuuCL9GIhE4nU50Oh2pMbKnhfeE54DBOWs9S0tLF96vCzsXtdDNqIw032aziVwuh1qtJt25LAIaDIYpOIIem41ALLaquLma8g0GA4nuSbGz2WxSrwEgxS8WTcmQYhprs9kQjUbFqObzedjtdunCZ8TIiJ7fx0idHn5WlglwHu3Q4KqQjc1mE3oxDQ0LbyzMqVRO9UG/+nxUCI0Xu9PpiMPVarUoFovSNMiGS9KiVYiSTpzveXFxUS5NuVyWvhnu9auNfnz/rVZLIDo6wFlWq9USp0V4lrAl+ynI2WcWB0CeK9k6NDbEqFVnqNYVePlHoxE8Ho/0OJydnYlTZvMvsyK1+M7zw0hwbm5Oal+kQTPj4d+rmb9a/OU5oFGedTEbJ3xN6ASAZHKE6eh4VMKD2iBJqIb3h++b+8czSzjH7XZLlpHJZIRhRRSBe8Cz0+l0pA7A3zs/Py9nularSeZECjSjbPXZTSYTcdqsnc3qXFTSAQMAZn7sVyqXy2IDgZflBP6saud+3utz0QZxb51OJ/x+v/SfMSgwGo1yLl6FMAGIzTCZTFhYWJBnQKSG6ESj0ZByhJrxaLVadLtd9Pt9CW4uWve7sHMh15+HcjKZYHFxEcPhEIeHh3j+/LlcDkb+k8lEoBen0wmv1wuNRjOFT3q9XnFE6oa0Wi2R3FhZWcHi4iL29vawu7uLRCKBt99+G3a7HcfHxyiVSpL2ms1mwfZJxQuFQlhdXUW/38f//J//Ew8fPhTpCEaQzASq1aoUwMbjMcrlsuDHl2liOz4+BgApRJpMJsGYm82mZCN8H0yfuZ9sFCT2z0idB5ByGYRmKpUKstksxuMxrl+/jhs3bmBzcxMPHz5EMpnEG2+8IQ6bLKxqtQqNRiPRIC+S1+vF7/3e76HdbuMP//AP8fjxY0QiEaGnVqtVdDodqTUwc9DpziVGMpmMFH9n3b+dnR0AkGfDTG48HiOVSuH58+dSP1H5+MTYXS4XIpEINBqNZGbE89XGSWYgJJhoNBrcvn0bGo0GP/jBD/CjH/0ICwsL+K3f+i2BgkmmGA6HMBqN8hp09F6vF7/5m7+J4XCIP/qjP8KDBw9k/15lBLJuwedP48D+rMsswq5er1dqona7HcA5pZrwYLVaFVkam80mEKrNZsPCwgIMBoMY73a7LXeEAQXlavj5zWYz7ty5g5WVFbx48QLf//73sba2hr/39/4eAoEAut2uvAZh7uPj46neqsXFRdy7dw+tVgv/7b/9N3z++eeCQpAQo1Lx6UABSH2WNmnWM0jjSnjL4XAgHo9Dq9Uil8shl8uhVCqhUChAq9VKXVStPQOQYIH3i8+cwQ8zHTWw3NjYwNLSEr788kt8/vnnSCQS+NVf/dUp6SYGpXRMvA/sFfqH//Afot/v4/d///fx4MEDgc9arRYODg5Qq9Wkz4WKAVqtVvbvdQPsCzsXRm6M0LgxlF4oFotTtEN6UrJEVBwZeMk6IazFSIhRN/FDAFI4ZEMlLzElVYhxMnIkDkwqH40RoblGoyFFcNUL8wDyEr4a9ZDKOctSC/aksxKGoHFmiky4j3vC98kDqXY0q82dzLRarZYUk0kA4CXt9/uyfwwSgJe0Y+KrfB/si6DOFpvHVHhGzapUhhjfD3n7xHJnWTT0wEttJ4fDIYFMpVIRA682ivIcWSwWMQxq3wHplTQ8PDs8g3q9Xpo09Xq94NIkl/As8Zyp55jvhzU0GmQ2dDIjUPeL36/+l//+Kt35dRczAzXjInLATEE9gyrsyjPC4jFlQ9TzqVKRu93uFMOLjakGg0GiZ7ImeccYRNGu8Gf5vL1er6iBqPVJ1iHUv6Md4udmkPY6VNpXlxoA83mTLVepVKb2kI5b3Uf+HAM6ZnUqnZg1OipA8HsIybNzn0QBQoBqxqvaYO6LTqeTYIg2V23zoCNirVy9z7ThapPoRdaFT2smkxFaGr0xox6uZDKJ5eVlKR5RYoQbEY1G5bKqB1in00m38v7+PnZ2doRNwwsAAIFAAMvLy7Db7djf34fBYJBCLKEf4KXmEeG0druN//W//pcY+Nu3b4scgt1ux507d6QngjhyvV6HRqPB8vKybPhl+gzUDIFRAI10qVRCs9lEMBjE2toaWq0WDg8P0el04HQ6hcqYSCSg0+kELlDVB8hWOjo6wubmplBpWVvSarW4ceMGotEoAGB3dxcHBwfwer2w2WyCsdO5NBoNkYsol8v44osvhHn3/vvvw+Vywe/3S9bZ6XTgdrvhdDqn8GAaBFX4c5alGjjVIA4GA3GkCwsLWFlZEao6CQrcv3A4LJGxStZg5Nfv91EqlVAsFuXsMJvl/nzzm9+EzWbDwcEBTk9P5f282h9DuIdU/f/4H/+jGNHl5WWpGxgMBoEo2S9EliOp6yy+XrbPpVAoyGuSMMLMjRnz4uKiNDKenp5KTYpROPs6aBS9Xi8cDofQ29vtNtLpNA4ODhAOh7G8vCwOfTQa4Wtf+xrm5+elWZSZEkk6c3NzU+xSfu6joyP88Ic/FBThF37hFxAKhUQuh/eVagLtdlsIBLFYTGi4l3HQbK8YDoeSpbNE0O12Ua/XEYlE8NZbb8n+EVanFlk8Hhd2GZ0hACEndDodZDIZHB4eIhAIYH5+XuBznU4nDZEWi0Wkbxg02+12EfSlLAz/rlKp4N//+38vjunWrVsIh8NIJBLye3nnCWESOaKdYX/bRdeFd5oPitEXO4fVFQwGcefOHVQqFcFESfGlQCMxQkYqjAZIANjf30cul8Pq6qpsLCM3p9MpUEgmk5nKOshaI0uE/HK3241yuYyf/OQnaLfbWF9fx+LiItxut/xORh+MVmu1GqrVKnQ6HSKRyBTVeVbMmymxGgnQuPG1k8kkVldXUSwWhaHENJW9RYx4aMz54E9PT9Hv94X8cO3aNdy+fVtgmvF4jGQyiY2NDWSzWfz4xz9Gp9NBMpmE3+8XfTdma/1+Hx6PRzTNeLHfe+89rKysiGEiR7/T6SAQCMDr9crFASAOSsWbZ12vNompGS5T/zt37iCbzWJrawvtdlvov4Rl1eyZTb4AJGokXh4Oh0UFgpCN2+3G7du3pc+FF09V1KbxJSzDnq8/+ZM/QafTwbvvvov5+Xlp/iN8wroCGVIqdZ36fKwtzrroQOx2u2QuJGXQeUciEbz99tvI5/NIpVJCkiF9mw6Tz4Hsy1KphNPTU2GNFQoF6PV6XLt2baoXyev1Yn19He12G5lMRog41LXy+/3QaDRTfRfD4bnm2V/8xV+g3+/j448/xsrKimjEVatVHBwcSI9RMBhEPp/H6ekpNJpzde+5uTmpyc26h0RnWBpQG7pZ4/T5fLh37x7K5bLUrugkaaMIkbHOyaCWPW2lUkmYrisrK0JZZh+hyrRlVkKEgUV82hYybE9PT/F//s//QavVwje/+U2srq7C5/MhGAwKoaDdbsPr9cLlcglhazQaIRqNSi+S0+m88D1+LSryeDxGLpeTiJe9B+R7D4dDpNNpgQpY96hWq8hms9jd3f0ZBlQkEplSfnW73dIcqXarE7v2+/3odDqysTabTS4gIR/WIlqtlvRuUEKCDBiVB07nxUsNQAwLmTwqTDfLSiaTGI1GEvES0gEwxaIj1RaA1KfULmn14jG6ZbGbjXEqrZSR/WQyERl54FxlmCqybFBk4MCCuKpCHYvFMBwOpa5FfH40GklE22w2RauKWWStVkM+nxfjPiskQRr4wcEB9vf3RYOKhsJsNqPb7eLk5ATValWkbijfDkACG15GRmIq9ZvZB/u3JpOJ7Lff7xcqPPeA/R7MHLVarRjLbrcrBeSNjQ30+32EQqEp1WCNRjMF7xKCpcouDQ2d+WXWG2+8gfH4XFNqZ2dH2F+Etghb0jCpUTWJGcfHx9DpzkVqe70eotGowNaE+fi6rCmynjccDhGNRhGJRFCr1dDpdKQhlk6WBXreZUKTer1eRhuQ3k5DzECLkDh7kJLJJDQaDdrtNo6Pj6U/ZdYgZ3l5GePxGNlsFkdHR7Db7QgGgwLx0x4y2GIASfuVzWbx4sUL6HQ6NBoNDAYDRCIRzM3NCSTIszgej+Fyuab2Dzi3tevr66jX64IyMAikbaXdJXkEOIf01tfX0e/3p3r+CCerOnqVSkWaW8nEa7fbwjD7yp3LRx99hF6vh//+3/87fvKTn2BxcVEa6zweD1wuF7rdLh48eCAFUsIMuVxODBU7nV0uF5LJJO7evYtSqSS0UDamhUKhqf6Lfr+PjY0NrK+vo1gs4ssvv0S/30csFoPX60W9XpcDzyJWuVwWjax33nlHDDhrMWpD0WQyQavVQqFQgMfjkZ4M0lAZPcx6MO/du4der4fnz5/js88+kx4Ko9EoF3swGKBSqYiGEQvShNEeP34sOLRWq8Xy8rI4RdK7g8HglOLqZPJSyZc6UMFgUMRCmcEx8iQkyAIyIYq7d+8CgGDnhUIBuVxOioJ6vR6PHj3C1tYW1tbW8Lf+1t8CAPzRH/0Rtra2sLKyIrpms6yPP/5YNKf+5E/+BPPz89LgCZyrN1SrVTx+/FiKyDrdueQ45cOz2awUyw2G87k4HBfB+hAhrcFgINkJ63fr6+t4++230Wq1kE6nhTFJhdmjoyP0ej3kcjn5Nzqtjz/+eIo1pNZXGCBls1kUCgUEg0EsLCxgNBrhBz/4AY6OjuD3+xGJRC7FWPzN3/xN9Ho9/Kf/9J/wgx/8AF6vF4uLixKB0zjy/hB7p9YZ+zA0Gg3Ozs4kk6U6Op2Rx+MRKJJ1r+PjY9TrdczPz+PevXtCX+92u0gkEggEAjg7O8Ph4aHArCoD0mQy4fbt29BqtYjFYnC5XCiXy0in09DpdNIwyTOYSCTw/vvvQ6PR4LPPPkM6ncbc3JyMjphlffDBB+j1evgf/+N/4PPPP4ff75csnnUlAILccB/Zy1SpVKS8wM/2jW98A3fv3pUaKmnEoVBInAsZrv1+H++88w7eeustYX12u12sra0hHA7j7OxMziA7/FutluiO8QzSibXbbZkRQzjxyZMnoop97do1jMdjPHjwQFQrgsHghffvws6l1WpJNAG81E4iBMA3q6bujMpepT0Sg1T1x9RCIr0w8BJGIlODv5cSFjzUxBj5HllUZSTKCEiVoqEXprHm6/FA0wDw86iFudddfG8qtZm4LfeR3fkq0UDt21CjLkYorFWxqMfX4f7QQJBVRsICC9rcj1f3j8aWl1ylxHK/WbgE8DOFS8KHaqGV+zvLIr1dzSwYzbOOwuK8ynTjZ+Rz5ZlSabTqFwMP7j/PHveRr08qNF8bgGTMfG7E4kkf5z6pz477QjiNBuZVGFUtVM+6yChS2ZnM3gh5Ea/n86PRUxU3+PkASDBCosNkMpFnwsKxeofUSJ60bVV1nO9NZXWplGY+V+4vm4lZH1PPNG2VCkHzjsy6f6oNpB3iXWKRn7+LhAISdGjU+fzH47GMruDdIxKgEqd4XtVCOwDJNlT6Nds31PqSSrrg4ntgRvoqueAyQQzXhXf5v/yX/4LJ5LyjeHl5GclkUqiKKoOExbmTkxOBA2gEqDPEDX327BlOTk5Qr9exvb2Nfr+P5eVlzM3NSYrb7/dRqVQkWuRG+P1+jEYj1Go1mfNyeHgIrVaLQCAgzmk8HiOfz+Phw4fQ6XSCeafTaezs7MBkMglJgFMXSSxgqsos6nVmGby6fv/3f19gxbm5OayuruKDDz4Q3Ji4NZvzeBjC4bAUYEOhkPDcyQQ7OzuT/R6Px5ifn5eiHvF71gx2d3fRarVEHp/8fBIB7t+/L5GhzWYT1hl58DqdTjLWYrGIdDoNm80m+81eGqvVip2dHTFQrMUQD55l/ef//J/F+Lz77rtIJpN48803Rd2ZLCyODyDUSNhBFe3k3rbbbTx9+lSaIkkMYTYeCoXkLHC+EPsDOG+ETolRt15/rsRts9lQrVYl4uTzWlpags/nk5oGFWnJLCJNmAEBs/hgMCiEi1nXf/gP/wGTyQTHx8fweDxYWlrCL//yL4swJB0B5dqBcyiRk1p9Ph/m5+cxHJ4Pl2Ix/rvf/a6QQAAI1ZvQKWFuq9WKYrGIH/7wh9KrRAmjXq+HdDotd5hwG41xt9tFNpuV++12u9FoNHB4eChsMg4FdLvd6HQ6uH//vjgz0u5Z+J9l/cEf/AHG4/PhXouLi1hYWMAHH3wg9o+N4eycZ9AQj8cF+fB6vej1etJ6sL29LYrRlUpFiCOsLTO7JUGkUCjg888/F3KV2WzG8fExtre3BdLS6XSi0sygtF6v4/HjxwAgFO5KpYLDw0OZRcSatsvlwmAwQKFQkDNoNBolG/3KM5cXL15Aqz0XrqS2FIv6TqdTGm9oUBh9sSeD0Q8zlsFggFKphFKphFarJT0Zi4uLUgBmpMgImpIHbESk46hWq1JEpOYQU3waJDJ7yFwjXstsgQU14LxOwPkb1BDi3IpZD+b29rZcFGLSLJRFIhHY7Xbs7u5OORcAciA5SIqRC8c2s0hJ6IsEBUZLXMRXh8OhvB4Lf+ywpiYZp9ixYM4GMZ1OJzUD0i6Bl/0TrL2RXs0ITx3LMGvUuLm5CY1GI/sWiUTEwDOjIT7MvXu1+Mr6CiNEyg61Wi3phyE8ZDKZ4PP5RJOK56/ZbE7BA4zC+RxIM3c4HFMsPvY+EO7g2GqeddYNGXXzDKiZ/2UmoXIPmXWaTCa43W6RuuG0RjYBMovjneeIbI4lZw2gWCwin88LAsDGXJ/PJ/eImZvRaBQpGIfDgVgsJoQTarvV63WJ8ulk+UU6OjMb9tPQeRPy9Hg8yGazMsaDcjEAfqbZ93XW7u6uGHoaWnbH0/6xc19FWaiAwACWtUEyEcmsBCAtFi6Xa+qOEbVot9vI5XKwWCzw+/0AIHeXcCLPO+0A64Bkf3GyKptR2RNDij0h5nK5LGQsns/XsYEXvukffPABJpOJpMBMOylbwAI6iz9kbJXLZeHHk60TCAQQj8dRq9XEy5PuC7xMY5niqXMhOFKWODiNrMPhwPXr10U5lFS9XC4njYQajQalUgmff/65FHlZAGTjINPxubk5wZv5eS9Dpf3ggw8wGo2wtbUlc92pxHv//n2BHVVa7Gg0ks/g8/nQbDbl8obDYeTzedH0UjukmR0QwuEkznq9LiKZLCqTBj0ej/HWW2/BarVidXUVDocDh4eHOD4+FhE7rfZcJ+rw8BCNRkNkVQqFghinfr8Pt9stDbbFYnGqqD9r5L26ujqV1pPZpdVqZd4KswgVjiqXy1LHo1AoszbCaerl4qRDnU4nUxfZ7NtqteTr5OREYB+emZWVFVgsFtG2I5lFHQUAQC45RQ9TqZTQXIFzTa+VlRUMBgNsb2/LQCrK88y6Pv74Y4xGI2xubsqkSw70Ozg4mOoVYr1gOBzi+PgYx8fHcDgc2Nvbk/PHjJ+K06TFMlgjVESHxkI9IRk6U9ZGh8Oh6AomEgnYbDahzLPDnNl6JpORWi7PAqnypIaTxENdN5fLdakA8Wtf+5qgD6VSCY1GA6lUCnq9XvpcaLM4hI9ClCQwkQ6fTCaxtLQk1HfCi2xVUBuk6aioyUZhSZ47Eqh4TtUzToXl4XAo01yZcTKLI/u2+lfjlhnEzM/Po9/v4+joSBqsGaBdZL1WQX80GuHx48fY39+fYpXs7e2Jl6OBUVWGKToZj8fh8/lw/fp1xONxHB4eysWhc2F9hNE08LIrmxvDdJMwXafTgc/nE6cSCASg1+uRz+dxdnYGv98v408fPXqE09NTaUAajUZIpVKCl5IyTYE2QnJq1/Qs68MPPxSqcLlcFghsPB7jz/7sz7C/v49oNIpEIiE02+FwiGw2i1qtBp/Ph3q9DrfbjbfeeksohHwNMr0ASEZCIgCVkJ89e4ZcLidOikXkarWKpaUlvPPOO3C5XFhYWBC4gmkzhUsfPXqEk5MTWK1WuP9qpverSrMulwvLy8sYjUa4f/++ZJuv24SlLgpXcjTxaDQSI72/vy+DpdgsydoSeymoGUciSSAQAACp+/EyezweLCwsoFQqCdTIs0LaOEUUVWza6/VibW0NVqtVYJBKpYKzszPJtIFzdWNOJOQzPDo6mlI44GA93gcKvl6m5gcAv/zLvyx3cnd3F/V6XQrM9+/fx+npqcAjdLpkgObzebmngUAAf+fv/B2srq6KKGixWJRxC6ynqE2a3F9+9ft9mTSbTqdRLpcRCoWwsLAAm80mwpVPnz7F1taWkH90Oh2++93vYnd3d6o5kqQg7o/H48Hi4qKcE06EfN0uc3V98MEHGAwG+PGPfyzG+OjoCKPR+cCufD4Pv9+PUCgkzoLZIO9uPB6H3+/HL/3SLyGZTMoYCmr7qXtFewq8lJGh1BHtJaE4yjxRNJWBy+HhIQ4ODmSYHwA8fvxYgiOyxjKZjECOXq9X9N76/T4ODw9RLBZhMBhEuuoi68LOpVAoTElcqIVM4olqMbLdbmM8HotYGxkkpAyzF4LRHymRVDtWtWyIX7J4RcybzZek2vKw8VKazWahivJyUlNM7ZTlvzH95mvyoXLUL6OuWRblWWhUOP6Wn5nCmKz5MBLX6XTy75wTwuKnRqMR2I4UY1Xz61UePSNRskP4u9g9X6/XRUaHDp7PnDRo/j6SOPjFTHY0OhfuOzk5AQARDNTpdDIrfpZFORVmrMBLUgkvCdV4u92uqGyzYMx/J1xKLJvwC8cMcO84W0jtjueZZM2K9GsGVJRJYSMp+0cYLLzat8Kf42cgFNxqtaYyGcLOl+lxASB3jgVw1kAnk4lAeazvsSmw1+tJlktokYaL95N3LRQKSQ8cgClYmwaTGRFrmMzE2QLAe8fnR+dOSIj3kSOSSdShLWL2TqPOn2cd8ueN773oyuVywh5kwMsAlcQIQqoM7phRGI1GEQclLE/mHWu5pP6yXswMiH/H2hP3j2eQpCjeD+ClogrPHJmytIGBQECgV95fnn3u0dnZmdwTvkf2X11kXdi5/OAHPwBwbrzYGEecMRwOw+12y4Xioex2uwgEAnC5XAJL6HQ6Scv4eixa6nQ6odKqr0MGFb+Wl5dx+/ZtmR1DfJ8d2Sx0+Xw+3Lx5U1J04Ly/Ix6PC3UZeDn7gFEunQCzlWg0Kvj8rBf8s88+A3BeQ3n//fcRCARkZseNGzcQiUQkMiwWi3jy5Anq9TpWVlYQjUYRi8Vw69YtMTKvOp61tbUp9lSr1RKD3Gg0pG+DcMSdO3fgdrulC7tYLOLp06ciRMpRxp1OR5QQKJZHGjMvh6pMTXIAxRn9fj/eeecdbG9v4+nTp1OyMa+znjx5IjUUGi9eOL/fL3Usv9+PQqGA3d1dVCoVEfzj7ApmNnSkDodDGit5iZlx7O3tAQBCoRAsFgsqlQqq1Srcbjfu3bsHm82GJ0+eIJ1Oo1KpSEbMYXeE7VQIj535JycnODg4AADBxsmIy2Qy+Mu//EsJetiTRAM869rZ2ZHu7ps3b0rzMGFgjvl2OBzI5/PY2dlBvV7HnTt3sLS0JNkqmy8JRVFahN31dFosUtNIqr1THDvNfi8Gb6lUSiROGPyEw2GYzWakUikpkFNIlWeag9oYYDLz1Ov1WFxcxOrqqhAGZm2E/su//EsA506TCg7xeBzAueNm1udyuYS+3Wg0sLGxgUQiIaQmSuCk02lMJhPEYjEMBgOEQiHpbwEgJCY6bGYp9XodgUAAb775ppQLCKtTFJS2S6fTSasAbQb34+zsDOl0GgDElnOIm0ajwdbWlvRcLS8vo1arIZ1OX/gOX9i5EI6i4SYsBUD+nzRANSNhwZ9FSQCiLcSIUqXAMSsCXlI7WcRmZsHoi4aUuC6jWmYy9NLMahihqdPXaBwZxZLWR6Oq/o7LLOKbJEOo6aXFYpF+CMJVdKQq3ZF1ApXOzPfIn1dTfn4fAPlc6j7TmbE5lKKXqjL0q/UbdT9Uiiypj/z7crkskvt834RRZ1mEPEixVqMn/m5mJ2Qt8QxwT9WzpRZcKTNOQgQjbkbRjI55hoCXhVeeGZ4nBkWEKnU63dT/08AwSGA2aDAYBK8fDoeiEMG+ImaOl8le2Pek1+uFTaQ2oVI12G63o9FoyO+jDh6dCyFx3kvusXoGVeos6y38MyNmPjfaDQYnvV5PFHvZlMl633A4hN/vl6ZJPh+1yZhZlUoOYC8R7ccsi1I4tIG0g8BLSjeL6aoSBLNC3lUVtua55fePRiMp3jNLIvxFWjrvNM8gzzaVO2gDudR90uv1Yo9ZkphMJvL71R4sNvRSoYHn/Ct3LgAkS1lZWUGv15PZLQBEniUUCglTptlsTnWtUtWXD5r6VK1WC6lUaqroR0oznRANLjfuk08+kYFBPp8PpVIJh4eH8vCNRiNisRgikQiazaZMF0wmkyJZEQgEhHrJYi7pimyEYx+K3W6XsZ+zLBqL+fl5LC8vS3TF1B6ADAQzGo1YXV2VuSn8vna7DavVKp+B0iPcr8lkInIuzFxYzCacRfmIH//4x1PGMZPJSNTIbIiTF1utFk5PT6HVavHGG28gFouhWCwik8lM9S2Ew2GMx2NUKhUcHByg0+kgnU6jVCpBp9PhrbfemmnvuDeM/CkRwmI9I2hCr+wEZyDBi8dmMk6w5KpUKjJsirAFZcxVB04H32w28f3vf1/gBpfLJWwxrVaL4+Nj0dJLJBJoNptTmHYkEhGjqvaAkGnH4jgJLKw9Xla4kjN9rl+/jqWlJdRqNZH4YBDjdDpF/WB1dRXVahW1Wg1ffvmljCqwWCxYWFiAy+WSXjZVjocwLCEcQoKEhLmXn332mdRkAAhrlMEiWZpzc3Nyh/V6PW7evImlpSVUKhVYrdapKbQq5ZljmqkaYbPZ8MYbb8zsoBnsJZNJaeIlVMbGXcLuWq0W6+vrYgP5DGnI4/G4oCNshmRXPR29CnNxL+hwqtUq/vzP/1zsUzKZRDabxcHBATQajUzU5Vh6QtUkFthsNszNzcHhcAiky+zJYDAgl8tJQzL17sxms4xnvsh6befidrsxNzeHYrEoYzy5SQaDQfBYps/0iN3u+bQ1bqbKICN0o8qOUxqCkQtfh5DQ1taW4PmcOnlyciIRIpsUOWCLMgiJREJSTGqc8YFxsFU6ncbR0ZGwtohRRyKRSzUB0sBHIhEZrKY2ZbFGpNFoEIlEBIsmrl+pVOBwOOD3++WAUBjx9PRUMjr2SqiT5SaTiTiObreLra0t6aNhtzOp3Jx4Fw6HsbS0hJOTE7x48QLAOZOJfRlqhM8iLqNwaj2VSiVUq1VhF81aTGWGS8fH/eDF4HPkaAR1oigjaRqjSCQi0SGzLhJDmHWrz5kOhrWdbreLZ8+eQavVYnV1Vc4FGWrci2g0KuSSQqEAAFNzObh/ZEpx/6hLRbiHF/t1mDo/b+VyORgMBrzzzjtYWVlBOp3G8fEx+v2+9DJQSn40GslE0nQ6jXQ6LcaThWNmKUajcSpjYwbLLIxZCmnNXq8X7XZbYLpIJCLS8aVSSWwE6z1er1eoyAxOQ6GQOGf1GbO+yxoEIaN6vQ6v14t4PD7zHjLT9Pv9WF5elgFezOq5f9Sam5ubE7iOZ6vX60l9Cng5xp2OmQE27wmzMdam2LjcarXw5MkTGI1G3Lx5E7FYTFhx/MwGgwErKyuIRCIyGkGluJNdptZrOBVUrRmxx81ut2Nubu6r73OhIeMHpkEcDoci0Eack132lMVgbYNpNlO3bDaLVquFRqMhxVBGIKPRCIFAQGh7drsdxWJROOSEyyhXbzab8cYbbwB42dVuMpmQSqXQ6/UEU+SFZdGeKSDwUnyODpMRLIkD5PPPsjwejxhewkOkch8fH6NWq+Hs7Ez6XEwmk8iyUyaGda5cLif1JbPZLHz48fhcN8pkMqHRaAgMGY/HJZtkHYuGgGQHt9uN9957DyaTCclkUiRRDg4OREBTo9FIpEtZH/Yy8XVYIOcBpPEmbHRZ52Kz2QRSVOnolUoFe3t70kvFy0A5HRaiB4MBzs7OpC8IgPR2DAYD6c0YjUYCvczNzcHtdksNijUERojsqF5ZWZE+IzqK09NTEcfUaDTI5XLo9/uS+XHvVYVxtbbFWgSAmeEcLt4nUuxJfe33+0in0xgMBgKLARBnUC6XpabAzPrk5EQyUma/hE64CL8SHmVhXiUusO9qOByK6CMJJ1QcpqwTA9disYjNzU2Uy2WcnZ1hNBpJRsvfxyyMdkLtyZr1DvOZEjanU6HMFVswmGUTjiNtmU7TaDTK+eM9VdUzCNePx2Mhc9ABAxBHxMGCDMSdTidu374tATkzSOqvkYZNSRh1xg0AsXe0ndR3JKw9GJzPzfnKMxeHwyGHSBVXHAwG2N/fl27OwWCAeDyO3/qt34LX68Xp6SkODg6koA+8FMLLZrMCqfACMoux2WxIJpNwu9342te+hmAwiC+//BJffvmlcL1J4ZtMJlhbW8PHH38sUed4PMYnn3yCL774AjabTQrm7Bo+OTkRY7S0tCSNgcxiVF0tcsmJ5c+yEomEsGrYj8Fo7/79+zg6OoLb7RZV1/fee086xGkcA4EAxuOxdOM6HA45yIwYU6mUwARserp58yaCwSCePXsml4BNV4SMlpaWcO/ePYloAOCLL77AgwcPJFLUarV48eIFPvvsM8G5PR4PPvjgA2GfAJjSEGN9hD1Ps15stYOddRwaDup6lctloV1eu3YNNpsN6XQa+/v70vw5mUywv78vRoECk2dnZwDOJ00S7w+Hw7Db7VhfX5dsg0OpCCNwDHAoFMLGxoYQSfR6PZ49e4bNzU0YDAa52Pv7+9je3ka5XEY2m4Xb7cYHH3wg0TZ7Ndhsp9FopqLey9RcFhcX5ayk02m5Q91uF0+fPkUul5OMKhwO41vf+pZ0cjebTRlX3e/38fz5c5TL5SmGGfXjGFDwc5tMJty4cUOaG7PZrOjo9ft9YUHGYjGsr6+LQSNF+vHjx7BYLEgmkwI7cg8LhQJ8Ph++9a1vIRQKoVwuo/pX46YDgYDcMzIICY9f5gyORiPpr+M52t3dRTabFWZlKBTCxx9/LArD+XxehHe1Wq20ItA5q6xVnrHBYCBKBWtra8IOYxB+eno61XsYDodx584dkfEBgIcPH+LZs2fCRmPjZqPREOdss9lw69YtEQRVGagqVNztdoUAcJF1YeeiGjGyWtjoRy/NLEDlagMvdaf4xQh+PB5LLwYLtersDxbGGF292ijI4h0jJBab6GCYKWk0GsHL1bkipIqyyEjcnFAEMVZGWmpB93UXo7rBYCC8dFUjiHAgANlHQiUUR6ShZueyisGr9RMWsrl/KgWUz4xRGNlBZrN5SsMIwFR3NKMgHlwWFvn8tVqtGGr1s5FAoNJxZ1k8f9xDlUyg6kmprEIAclF4PlVaJ0kgzHJYF+Br8pkQGuD7Z2GejBxq4fGzco/U96PStrkf3EOeKRpAwigqmYX35jJLVc1VB4MxMyLMBLwcNcwzxLHQfKZWq1U6/VW6u0oJ5vepbEK1SZifSSWrEOYiuYLGmlk6M1bC3zyzXL1eTz6bCsupDdKzLvUO0waqz4fvh38meYB2jUV5ABLAqT/P7Jxni4tkB44i5mfi69GequoFdFivEqDUZ6TaPp5b2tlmszlFvuD+8WxcZF3YuSwtLWEyOZcff/HihfDgiZlGIhExXlarFdlsVihtHJDDAzI/Pw+Hw/Ezki0qW0r9EA8fPgQAeU0yGEwmExKJhEhNPHr0CEajEfF4XCIfj8cjTZGkq1qtVjSbTWxtbYnBYkZwdHQkEBQ59cyELiO5z6iZRTfuh91ux927d6UDnQejUCigVqshFovhxo0bQhHUarW4d+8erFarzOzm5VehPDrYyWSC3d1dbG9v4/T0FJlMRgpzjIjm5uZQrVbx9OlTgXV0Op1kkNxLvV6PjY0NmEwmHB0dYWtrSy48ABweHmJvb0+cJwAppFIddtZ1/fp1AOcCoAcHBxJwTCYTxONxKeQSTiJ7iAqzNDpWqxVvvPEGgsGgUFP1er2QHvg6ZC71+3389Kc/FSdEBuLKyorsBzFt0q/VyJvRLi8vac1Go1EKzZ1OB9VqFTs7O9jf359y8AyeKMFyGeNI6nGtVkMmk0Gz2UQ+n8d4PEYgEJA6ANfR0dEUCaXRaMiclq9//etwuVyijs2ZQ2rfhcViEfLK/v6+KAOTlk1NupWVFSQSCVQqFdy/f18yVIPBIJpvhOioDqDRaHB0dCRsNrYQbG9v4/DwUIreJAaoUkizLjbCEjplhgacz7IiNExjT2dAqRjC7haLBXfu3IHf70cul0M2m4XZfD5Wmo4YgAQZ/X4fDx48EIkc1kAINc7NzWFubg5nZ2f49NNPpaXDYDBIdz7lYqgWQWo37TXP/ebmJg4ODmT/AEw1xKpEmL9uXdi5uFwuoUiWy2UMh+czA3jwjUajMJ+0Wq1MN1MbcLjxZFTwApvNZgQCAfkQLAYyeqM8gjpUiA1MPp8PkUhEioEsvnMxsiRExKZORhK8rOPxWOAyYubAxb30X7fIdms2mygWi9JARh46+4QIEzKiZPGP2CkZU6SEttvtKSoyDSBxV9bCONKAc8YpsR2JRBAOh6XpDIAoxxI2Y8RMQofb7Ua1WhUiB7MAGi1mRz+PZjvrYpMt63PMAiaTiRhwFr2Bl1mX3W6f6lFhkyiLrfl8Xi62qjKrsp+oX8fOZbWRlDNe8vm8MIfYTwBAMiq+Lgc6UeyQdUDCtfl8Xj4zSS+MODk3ZdbF7I29Ye12W2pH7BXi++x0OiKdtLKyIpAsGUehUEj6Wpjh8P6ylsKGUaptUO6oVqtNtSiQmk/WHvefjhd4qbBusVgky6lWq5KVEjIsl8sC+bKJmFnCZReze6IbLLIDkPdBFILBz3A4lM/Imud4PIbb7ZaAvFKpiHMmdE8YFIDUyMgapVwWzxEp0ISImUURygIgf2YtisEpa0C0HY1GQ5QpmB2pKArbNi503i66sXzBer0+Ja5IZpia5hGmopPp9XrCtJlMJjg8PEQqlRKjyAvHiJ14JiMPXlRCLiqWu7u7ixcvXsBsNmNxcRHj8Vhmd5DSy0OqqvvyYPJy0yCwoEnvziiTuPBlYB2mwJTGYZaists8Ho8YGlJRKb9wcHAgjsPlcknUxu570pXZXc/mSbKnSLtWIaSDgwOZV3P9+nVpxGIjpRot63Q66SEiC6bZbOLo6AhWq1UkMUj3JXyk053P27jM/hGqLJVKYoD5GQiTEEJkoVQtvNJIcaYOmY4MVJjlUaep0WigWCxiMpkIVk5ogkOiyIrb3t4WuQw62WKxiNFoJNNRaSj4+nT0LFjz/RHfJgzIFQqFMD8/fynnQnkRZrCEOhgA0GjzfvG+ajQaFAoFkULqdDr48ssvsb29PZUtM4CgAGUmkxFdPtZQj46OhOBDmPrw8FCo2hzSR7JLKBRCIpEQyIj1SgASKAEv+8gqlYqwKpeXl8XuEIW4jLYYZXGobUbnqWam3EcGPmS3srWBDv758+c4Pj7+GaidpJxqtYpmsykqA6xtMdOhEzMajXKH9Xq9nEHaOo47Z9BAG0FolPDezs6OZNOEQvnZCH0SAfrK2WJ8IGQacDPJAGFkTudCCQNG4dz48XiMo6MjtFotLC8vY2VlReiNWq0Wh4eHMk0wn89Dp9OJ5D3ZDfTWBoMBz58/x9HREd544w384i/+IjqdDn7yk5+gVCrh5s2bWF1dFaYXoxlmXapz4fu22+3yfuip9frzKXhLS0szU5Ep+UGHQaPH5jOz+XzWO4todHgUmCsUCtLH0+124XA4EA6HEY1GAbxscszn8wJL1Wo14bMTOsxmsxKl0Lk0m03cunUL9+7dE1HGarWKQCCAZDIpdF8SL5hxMsLilD86l2AwKCk+9zsajWJtbW3mXg1iwJVKZcq58NKQrcSMmBdILbpynzY3N6HTTcvx88JQeZvMR4vFgjfeeAM+nw+pVArlclko4zqdDp9++ikODg7w7rvv4t1330W/38f9+/dRKpVEuZlZNVUk+DlYFyiXy8LaofoF9eBY6wkGgyKoOetiX1Amk8Hx8bEEd7y/arMugKmx14RpGbwwq1lfX8e1a9eE1TYej0WQNpvNYmdnB3a7Hb/0S78kdFkaVAZuh4eHqFarWF5ext27dyVD4iCxpaUlYWQxUCCyweZWStuQ+u50OrG0tCS0YBa0g8HgzM6FUvRUWTebzWInyG5j9sx60mQyEWYdIeLR6Fw8dDA4n0TJOwycOxeePao+WCwW3L17V8RriQzQqR8cHKBcLmN9fR3vvfcehsMhdnd30Ww2EYvFsLy8LH0uagBKYhUJCgCkt89ut8sZ5F3niOqLnsEL3/R8Pi8HgqKO7DCld2bnr1rY5wYw7SM0xIJ6NpuV7IUQi1rcJ9aqFvap3cOo9ed9UY6es2POzs4wGAwEznA4HPKgudnMJAiRGY1GGQnabreRSqWg0Whw48aN1zyWkEhRr9dLJKHCcmohjvAiNYTIQOJDZeGe1FlGZaQ+Auf4OllLTOVZg1L3mng/vygFXywWpVZB+GgymSAYDApzjd3XzJp4oWh8ePnoWDkXfJZFlo9erxdRR+6ZqhTBLJCLjoMwAs8M97hYLAptnj/PGhbwUjePBVFmzKqzIhuJ47q5f5RK6nQ60rdit9vleQIv4R5ST/v9PlqtlqiJE06mgvFlMhciDg6HQyatMqhiTerVpkgSI3jGwuGwfEay21TDyT2jcWIAytEWarc8nx8RiWazKUEMWwxYt6jX6zg+PpZmZxpwo9E41dDNbnidTidOm/W0TqdzKcYi5VrMZrOIQPL50LHwvNAm0glwDAhtICFtBpukvvMMOhyOqaCJNpGwFiFSPic+C8LplUoF9Xpd2HPshWONnO9lYWFhqmeMaABnFPG5c/ZTOp2GVqvFrVu3/tr9urBzefLkCXQ6HdbW1vDOO++gXC7j8PBQUuFKpYJEIiGaP9vb2+h0OgiHw9IHweYco9EoafPW1pb0H3BD2eXPC0jsMpPJTGln0eOSessDXyqVBHt1OBwoFAp48OABRqMR7t27B6/XC6/Xi1AohHq9js8//1x48NzE7e1tmEwmUQlNpVL45JNPMB6PZYTv66wf/ehHsn/f+MY3xKjzojIyJ1WZmDjn3nu9XqGBPnjwQOT2C4UC3G63KNSyR4FqCd1uF48ePZLu+5WVFYEtaVwPDw+lE7per+PJkyfIZDJS06LWGQChfFISvVwu44c//CHy+bwEEe12G1988QXMZjO+9a1vIRaLIZfLYXNzE+PxGL/5m7/52vt3//596c6+deuWODw1zVclPrh4EdXghnTtQqGAg4MDaUqlLIvb7UYsFhMlABoJajQB54oLzOja7TZKpZI03j558kSybo/Hg0KhgBcvXmA0GuHu3bvw+/2Yn5+Hz+dDu93G9va2nF82uqXTaRgMBiwuLsLr9QoRBAB+/dd//bX3j3toMBjwN//m38TXvvY1ZLNZPH78WAKwcrmMcDgsNG9mW4SE+d9Op4OHDx/i7OxMaK0ul0uoyFRK4OwdKis3Gg1RfNZqtSLKWK1WUalUpuoV6XQa3W5XYOp0Oo3vfe97GI/H+LVf+zUsLi4K5FWtVvHpp5+i3W6Lygbp0nq9Huvr6zJG+fj4GJPJZKYz+L3vfQ96vR5f+9rX8PHHH8uwLfXsUd+u1WoJsYDP2+VyIRqNYjAYYGtrS5733t6ejKMggSaZTAoxh8w9Zg8LCwtTEjFU46AqQbvdltdn+SKfz+PRo0fQaDT41re+hUgkgkAggLffflvuMGvbbDjmGfz6178uWefu7u6FbeCFnQvHiVJehTLgpAsyk2B0zcibXppMA+KOhKPYlc9aCmEoFk1J2QReRgnAy0ZOvj4x2p9H4WREyGiX9FkacrXuwQhS7fAFIBglI7nXXWyiIlVabeZiQZewGf/M98xoiRALIUf2KKiUSH4WRouMbCgWyAIkP9twOJyKvFUcltE594+HWY1A2XGsduczU1LPBHuSZt0/QqusEag9SPwCXo50Vc8kAGGEkZb5atFebQxmtMgeFkaF/NzMoFXiAuFftUGX5wyAnDuVLs+6Cus+fB0WbUnN5bNmvWvWRS0p3mF1PhGfNx2p2lXODEan0wlxhHtImIiQt1ojZbbIn1e17tTzxy8+B74m3xP/TYU4ubcMBlWVENLvqaLMFgZm4bPuIbXKAAhRgfAyzx3PDwChXvPcUKONRBmVYMHPygyZ5ACiK2yY5Gvxd/A8cT9Zk1Jfk8+VbR/cZ54DFSHheaPTonMjyYqEhIusCzsX9q7s7+9LxyklmbnIQW+32zg6OpKU2Ww2Y2VlRVSAT05OcHp6CgDSJEQ8n93VzWYTp6en6Pf7MsqXh5DGEziHfxYWFoQeq+obzc3N4datWwgGg6IqW6vV8OzZM8kWNBoNwuEwfD6fzLgAIHRQYsc6nQ7r6+szG0cW+Vi85OXlgWDfCh8qdZGMxpcy4deuXZNiOplzdBwcmUujQVXbVquFx48fo1wui7TDqweTRXB2kzOCCofDWFxclM5gMs8+++wzOBwOGVscj8cRj8extbUlhUwWUWu1GnK5nAQRs+4fcenT01NpwmOdgpeN8ES9Xkc6nUar1UKpVJK6E0djs65CEgglbxqNhlz6ZrMp7/vLL79EqVSCy+USPS0+K5vNJiMFCoUCOp2ORLBsCnT/1UheFXL0eDxCCmCxltkf95C/o9vtShZ5mcVi9sOHD+VZk8KrKlM4HA60222cnp6KQS6VSlhYWMDq6qoEEFRIYABIUgydaKPRwPHxMXq9Ho6Pj2XfSaYhpZh3jXIkaoM293I8HuPtt99Gt3s+7rhYLCIajcrMlmAwCIfDgRcvXiCbzQrEQwfIAIHw9yyLEOvu7q70CLERlQ5mbm5O4Or9/X1Rbna73VhfX8fNmzeFIZZOp0U9hEacjFzg5RyrTqeD58+fy8gKQpe8lwCkTsYaHYvx0WgUyWRS0KNer4dsNotUKoVgMCiMv7m5OUQiEWxvb+Pg4AA63bnSNcsRbFYnkegi67WcC9OrQqEgG8tNYORPJ1EqlaborQ6HQ16nUqnIdEVKNqgRCTFm4q6pVEoE4F6VkyalkXQ9RqCkzTK9PD09RbVaxfHxsejvkEpIsTZ1hgbw0ntXq1Upss6K15LVok6PVCMd1itYsOchYRGTopAA5MIz01Fxb2YnLOizVsTmPGZ6NArsA+Bz4RhYFnvJjefvTKVSYhwoL37z5k3Y7XZhcjFiJKWV0j6XEV50u91SHM3lcvL3ZMOptFcaQ+L11HuiESAFl+KcfM6sRzAa1mg00n9yenqKZDKJRCIhUSgA6RvQarXyzJh1e71eOTPhcFjOX7lcRq1WQ7PZhMvlwvXr14XJxEhYvU/9fl+exWVqLiaTCePxGMfHx9jd3Z3q5Gb2y+yV1HVG3tTeY9bMrI9LzUBISGGthPg9x3Hzc1N3jYvZMO8YAy6ez4WFBbRaLezu7oouHyVKnE4nHA4H9vf35T2T7KHSgi8jocNsuVAoiAPgXjBTNxgMQtXP5/OCdrRaLUSjUdk/nlG14ZafmZkFM7FGo4H9/X2RlrHb7dJ/x/3jcyTiwroq+/xYN2w2m/jiiy/kHHa7XbhcLly7dg1Wq1XqMmwhYXZFh88JmBdZr9WhzzdPiIJej1ROLmKLakcx57Kz94GpH6PAV8UpGemzGMeD5HQ6RRuLzAZVPgHAFH12b29PojOtVise3Gg0SvTPlFod4RyPx+VgsjimGrXXXczOSIu22WwS+fNgESq0Wq146623JIpkAxSd+mQyEclsZmksNLNgTIdPocDxeCyQAQ8w021GxoygWcy2Wq1Cl2TnsN1ul8NHA5xOp2EymXB6eipTKRcWFgTmocOh5Pssi7ADYRMadaPRCJ/PJ+eHU0Pv3bsHADJLiGeHz5u01lqtJjUoZj68QOyTuHXrloz05T2ggyY0o0qfr6ysyPdwTDFwfjGDwaDsIV//7OxMNOOoDcfiLr/v5OREBrD97u/+7kx7yCZJGnibzQafzyfqCsPhEIFAQGp3ZFZxgB9/ngaaZ5dUXMJWDJbI6hyPxzIJlDRlwo4ajQaBQEBqsuPxuYLCzZs3MRgMBHVg1jEej4WZZTQapalTjdxpn+isySBToatZFgM8Gn8W6gmxApDI3m634969e4IMUJGcNoYZFM8es1RC87RJhC6vX7+O+fl5OWdczHBVu8b2EEKumUxGiEvD4VAaedmRTwaw0fhy7Ller5dgplarCaT9Ovt3YedCSIvcdSqDqvIXFF4MBAL45V/+ZZHuZpTDnhcyKuixyc5hhMyOUioEc3Z2IBBAMBhEoVDAw4cPpQGMm8jXpLhevV7Hl19+KQeC/RY8lOSGsw7EiCQQCGBtbQ06nQ6pVEqiLs45mWWxO5pRM/Wv2JQ0mUyQz+eRyWTg9/vxK7/yKwiFQlLLyOfzko7z9XhgyC5hk6jVej6Sl6MFVlZW4HQ6ZdwrnTOJGMRWyXhZXFyEzWZDJpPB8+fPBcKgijWFMUmnpfHc399HOp1GIBDAjRs3oNVqsbe3h3w+LwPJZt0/Ysq8DKxB8dI6nU7pbwoEAvjwww9Fp83lckmDbKVSEedCNpLdbpcR2Wy6bDabqFarsFgs+OY3vwmXyyWd2ZT/ICym1gRZjLVarTg5OcFPf/pTiazZTKfRnAtYEjpmYHR0dIR0Oo1QKCQ9GuzKzmazOD4+vpRxXFpawmg0QqFQQKlUQjAYxPLysjCphsOXM5Y8Hg9u3bolNHmTyTSVUQPTwpQMzjqdjmTPdF4kejAKpwJ6Pp9Hv98XVINwm9Vqxe3bt+FwOKa+n1H53NwcTCYTSqUSjo+PhVGq1WpFZJNS8zyXpJCrAqGvuxYWFgQ+zufzcLlcogbCpmhmZx6PBx999JHcQQaV7GEhJK5KCRFZ4J0nsuJyubC0tCT7w36sk5MT9Pt96U8ivGi327GxsQGHw4Ht7W3s7u6KjdTpzoeFmc1mITiotcNMJoNKpQK/3y+D0FTdOcJ/F1mvhVPwEjAVY+MXI0gyuQjvkGnD4nSr1ZqKbthlT5odAOll4b+p2C5VAph6E68kT58H+FXdJnUz+ADU6IDvlXAGKYXMqtTobNY+A6aVKizFvaDiNH8vIwrWP5htsEjHL0qRqEKRjED5mVSCAA8GX0ulX5PCSfo3jTnrMtxHFq2Zeqv7yoY6VRWZkRjT/1mNI98HAMH1KcHOGpxK7ebnVvWsWq2WkBUY5DDTY/TJ/qPRaCROiNIvDI5Y51IhFp5/Qk8qmYAkET4P7iXPPQMMZo80VPz9fI3L9Li8uocMqkjU4bPj3eY54X2jM65UKjKCWC2q8/kyAmftiYvPRYV/2TPFrJPsL2rn0XbwLvN9qYrEhNH4mjzHvMfs9Kd8CdGTWRYDWZWIQ5YnpWlU/TxG+ryPhJYJafM5EGkg2sB9B17WUmizaIPYyvGqyC4zG7Wmy39TyU9EctQ+IAASCPCZEppkFv3/SubCaIX88l6vhydPnsBsNuO9994T+GE0Op+pkcvlUK1WkU6nUSgUBApjBqPRaODz+bC0tDTV65FOp5HJZBAIBDA/P4/BYCB6VcvLy1hcXESxWMTu7i663S5isRi8Xi9cLhfW1tbQ6/Wwvb2Ner0Ol8slsz/YZEUJEL1eL7MdCMfNzc1JzwPTeUZEbrf7Z7SXXmelUikAkN9NLTRGaaFQCD6fTzBZUm8XFhYQDoeFr95oNETRNpFISM8NDSlrSny/3HNVbLJer+Po6AiDwUBmqfv9fqysrGA4HOLk5ETIFXSuvOwHBwdIpVJYXl7GrVu3RHKDtRqv1wuNRiNYM+V4bDabqGLPsoijEwLsdrt4/vw57HY7FhcXRd6HWduLFy8kQGFRlOl9KpVCsVjE22+/jXfffRedTgenp6dot9sSuUWjUWxsbGA4HOKzzz4TaX2LxYJWqyVSLxzLHQqFEI/HpUmRl55UXNaCKIHi9/uxvr4u0AfPBrNu9uTQiPt8vtfCu3/eYk2RBpDZsNlsxvvvv494PC5Mt0qlghcvXojBp9zK6empDO5qNpvSAa6yO9PpNIrFIiKRiASe6mTEyWSCarWKra0tdLtdrK+vi6R8KBTCYDDA4eGh1MvMZrO85+FwiL29PZTLZWxsbODtt9+W88a9Ih1ZDcoIE12mZsVgkHeYZB/OnIlGoxJED4dDHBwcTDFgVefCGh+zZp6DyWSCg4MDnJ2diV7ZcDiUUQ1+vx8+nw+VSgWpVEqCVtooUp3ZCkLUgWoag8FACEVerxcbGxsYj8eSkS4uLiIYDMpeTSYTUSF/3XVh58Joi7g0G2/UEaxq/YXRRbFYlIY6SqDQK6t0T1WSoFwuy+uSeUGWCdNkdqoyKmBBlxERRRcZsTClI17KWoZKYeXlZUbDFJWX/zKLl4sHjR2y/AyM6EgN5HApt9stvQVkwlG9WaM5nyrHpjN2gKs/q0aqjLoItQwGA5mNwohPHQWgHjDSQQkXEXZjsZJRJCmLvGC85Go9bZbF7ImRPvcPgETQ/OJ+8DyyZsfMmU2zJpNJep04VZP7p9Y8KI/u9Xplqh+lVBglM4Ln86nX69KAy2ySjYq1Wk2cOs8aAJH+4V1SMXg1G5x1qTpdjHzz+bw4ZGZ+w+FQHIAaWVMdgXvI6JewjMViERpzo9EQFiKDGgYHhIBYH+HnJAzE+1utVkUJgRnfeHyuAJDP57G0tCQ6gozsGeDyrLFxlX++jHPmvgDn94mEJZWIpGr7qWPU+ZnZLsHPw3oRswPuHyntPPf8s9V6PmqaDD82BNPh0QlwxlE0Gp3SWiS1vtPpSG8X63qs5bJXjNkhySuvm/Fd2LmoPSd8kFqtVjxyLpeTy0togIKA8XhcvDa54QCEcks2CSEMduQzcn7zzTcBnCuPUrSRBzMej0sT5rNnzySVJr6rwhjcPNY/1G5dQhavpr5MPXkpZk2pmWHwgPOgkWVE/J1QD3tHVFE59fBqNBrUajWkUik5HIQQWJwGIJI2jLotFotkb4PBAD6fD3a7Hd3u+UwPGhwaIr5fznFwu9148803YTKZREVZzTxJKfX5fBiNRjg8PJSazGUW03fgHCpgXYIR5MOHD1Eul1EqlWCxWBCPxyXg4Ex4nj2fzyc9Ti9evBBpjE7nfOgcp5VS1Xt1dRVLS0tCeKhUKgI9RCIRydYODw8lQhwOz4fosRhdqVSkuEuFga2tLej1etHV4wAptbtblcW/DI1W3UMGGqwZaLVaNJtNPH/+fAoeAV6qWnOCKaElwj1kPbGuOhqNhCHKGT5UaiAETmN67949dLtdKTBXq1Vpb+A9oNFTJYii0Sii0Si0Wi2+//3vT91ZBmmsBzFgoC6cyvJ63cUgkwX6QCAgiu/FYhEPHz4UyJozedjbQhowNdB4Zxms8c/9fl9kehiMGI1GJBIJCcapsE7BWSI3nU4Hm5ubAnux7kzKPoNYDo1rt9v4/PPPAbyEr0lOoRwVzzORq9exfxd2LvSINCBk6wDnh4h9GXQuxJBv3ryJ+fn5KW0senZ2NjcaDRwcHKDX6wm8RjiHg4a8Xq9EAA6HQ5hegUAATqcT+XxeRvcyWm02m1O9JKSt0tiQQcKNpSF/1WDysDADmmWtrq4CeCkXwkxgOByKUaQEhs1mm2KGqHixeomoA8bDyguvRsPEVckCYybEyIRd6YRIWCtQay6M0PR6Pd5++20kEgmkUim8ePFC5FiIk/NsxGIxgdhmOZivLkpqUFCP/SXD4VCk6gk9ka3Iz04WUrFYFPiAl31nZ0cUgEej8yFZzPiYQa+ursLtdgtEw07mbrcrhIFyuYxUKiXOATiXZifdk/sXj8cRi8Wwv78/tX+MDtVmOLVJll+XWayR8Zw7HA6BoZ48eYLDw8Mp0VZmDAxQyCLieVORBqIUDG6YLVarVSGCsDjNgj8b+njeSqUSdnZ2oNFohALPBkAWw7Xa89n0wWAQu7u7+OSTT6DTnSuLk1Xp8XikAZGMUmZadPKzLDoX9qQQjRkOhzg6OsLh4aEEgKSO0155PB5pglWfMbNc2lAiK7yfbH5mEE3bpDoXj8cDh8OBs7MzHB0dSQZnNBqlv4qoiMlkEoWSZ8+e4cGDB9BqtZJlc6geA4J+vy/9g/+vZy7d7vkcF6fTiWg0OsVTJ1xDKhyx1kwmg3q9LilwNBoVtVjCJ4QX+MGIv9Kp0XGNx+dyEfTyVBim5pDKz+aFrFarSKVSU93+9Mhq1zEdCYUreYnYkKVSq1930TDQ4fEzajQaOJ1OiQI59pQGm3o+rJtQkE8dyMVMiNniZDIRGQoWVRk18aLSeBEiAiDsPHWYGiOpQqEgfRB07CqUZ7FYhAnDjnym+CyeX0b6XM34VFUAo/F8Vj2hw1arJRg4pWiYPajd8Gp3PvDSebHwylnyZPnQaZIpR+iKGTSpqcDLGSw0BBwJzUiU9G8+Pza/8plotVqBqorFotDjLysdz+BIVcwmbLm4uIhwOCzfS+kj3ouTkxMRe2Udhu+VAQ8hKcJobDolkYN1PErnsA5K56LTvZxDosrQDAbnYzfovDnDaDQawePxCG2WQSVVN8xms5yXWq0GrVZ7qbopFx0AGzy5j/x8vV4PDodDHB7PpVrcX1xclL4hIkBUomaQ5vf7xQ6wXsL9ZiuGWi9hbc5gMEj9lvJYlJRioENbTjIQ7S4hOMKUAMQ2kRl84fN20W+kUGE2m0U6ncbNmzfx/vvv/4yUfLVaFXbQZDLB0dGRjNlkMfa9996D3+/HF198gU8//RQmk0nUaRmpRyIRrK2tAYAMFeOgIfLl2ThJeuLq6qrQKJkSj8djbG1t4fHjx+h0OohGo7KBuVxOCl52ux3Hx8fIZrOIRCIiXU3JA7JOZo2++T75ORYWFnDr1i3RUCMswLnkdOYPHjzA7u4ugsEgVldXYbPZ8NZbb0kPytHRkTgOlVPPeRHj8blEOBWRCXdx8WL7fD7RJ5ubm5NO90ajgZ2dHTx79kwCBbL/GB1StTqdTgvRIpFIAIBQM81m86WaAHnGVAfMAj61lniJ9Xq9QAePHz/G/v4+nE6nPGfOLjk+PpbBbXNzc8Lpr9VqcLlcWF1dxWg0wu7urowqUHuqSFWvVCqiZsCgQaV2b21t4f79+yI+yeZM4uTUNmORnBF4v9/H9vY2crkcgsGgZGOzLtZEOGp4aWkJGxsb8Hg8uHfvHtxuNzKZDFKpFKxWq6gwf//738fjx4+l/cBut0s29/z5czx58gSj0UiQDGbDNLBsMmStSj3jDOAmkwl8Ph/u3bsn8vw2mw21Wg3VahUvXrzA97//fXHsnIGysrIiEbfJZEI2mxWlA5fLJd3wR0dHSCaTuHHjxqXYYqQBs7F6cXFR2gDYMsCBfHxen3zyCTY3N2V+kt1uxy/+4i/C7XZjd3dX4FEOI+N+zM3N4dq1a0KeYtMlM0oG6yTUxONx3LhxA3a7XbT/KFp5cHCAP/3TP5V6mcPhwGAwEAfHBk+O3wYw1XiZzWYxNzcn484vsi7sXAgXAS+LsmqxlpEgU0dVg6lerwtzhwVAFjNp3MiqADBF4yT+rKocs0jI9HIwOB9CRRiJhbdXD5FKqVWpyOpnUmsw/BlV+2vWxd/Nz8vPR0o2YRo1kuGeMjUmhGe32wUK5GvwGbDWwmgKwBSNmb1BjKwJ46gFSe4pX4/vh02ezMLUhi6V/87XU5ca4c6y+LMqFZPZEc8WAImm+Tm4fzyXzMxIP2YxWWXFMRNR624qe44ECJWuy+Is9wh42TWtLlWri4EU94/vW4VA1T27bEFaPRt8PdYoCYPUarWprJAZLNmXLLo7nU4ZbsVnz741lTLNM08UodVqCf2Z36vePWaWwDR1Wr07zA7U5lV+Jn6Puk9qZz73dpalPodX7zGzT0oIqYEI94+Fco1GI03U6t8RGWG2xmfF12CNlntG+0f7pNZMyDQk/Zj7qb4OCQDcv1ft+6tn7XXP3oWdC4vEfr9fIJnPP/8cVqsV0Wh0Sv6DaRYjFmJ+pKSykE+ZEI1GIzAXZx8Eg0EcHR0JH//VvgtuPh8QmUv5fB4/+tGPUCgU4PF4hIpMqQ+9Xo92uw2fz4dQKIR+v49CoSAKyrdv3xYNLBXr5p9njRzZUMp9MJvN2N7ehtlsluFG6pAzqgxQIJSaQI1GQ+CHTCaDg4MDGI1GBAIB6HQ6UaqlMutkMhFZFzoSMqcIo5lMJqHJtlotPHv2TJpJfT6fFF1ZoByNRiJtQtpor9eDwWDA3bt3BeMejUawWCzy3lggn3X/+LwJVZIqu7a2Bq/Xi9PTU5ycnMBkMsksCqpd82KxeE1KdqPRmBJizOVyojLAv6OuEh0mIVXWBmKxmPRFVatV/PCHP0T1r+baBAIBtNtthMNhwen7/f5UYZ8d1G63G3NzcwIh9fv9qeLrZZso6ew2NjawtraGbreLBw8eiJQSp6SSsk06OdV1iTwYjUZRE9jZ2cHOzg7MZjNisRg0Gg1OTk7QaDREAkeFbqjywD4vMh4ZHLCo/93vfheNRkOcB5mpJGmwJ4csvNPTU3lmhGUpI0/FA6oFz3oG6fR4f4fDIT755BOpy3k8HuRyOZyensJkMsnnY22Xxl+n00mrRiqVEjYtAx7+XS6Xk0yNDpmBH88zAHFUbNAtFAr49re/jWKxKFkVhYEpnFmr1RAOh5FMJjEYDFAoFISynUwmBeZmk+v8/Dx0Op2QNS6yLuxcGC0ScgEgYoncdMJivJTEr9UeGbJ0CDnx+xiFnp2dSR8HhRv5QBgRqNmH2vzHlPXLL7/E/v6+iLGR2UEPTQpuNBpFvV4XvSy/3y+Xmw9RVV+mQ5tlEeYins4CHimI7XYbZ2dncjABCGWZ77n6V9Mp2aFO2iw/CxlyJycnIiPDugBpwRqNRmigKjWU9YBCoYAf//jHSKfTwpKiWgJpxsTVA4GAjFeoVquYn5+X/SMuzQI86ZWzLpXpxMu5v78PjUaDYDAoKT0hHbWvCnhJS2XUy7NJaIHfR+l5o9GITCYj5w14yShUGzjJYKTzabfbePHiBU5PTzE3N4doNDq1fzR8hOlarZaoXlCrjQ2fg8FAMvzT01OZSjjrIvrgdrsFBt7c3ITBYMDa2hqsVqsMsptMJiLKyOfGLFun0wnmT61Bh8OBSCQiPVxnZ2ewWq1SxCaMHQqFxMCRns/XJTusXC7j/v37yGazwg4djUaSSalZARs2M5mMOHGfzyeEIQrhUpH97Oxs5v1jxsPz1el0cHh4KIw61shKpZIQgHQ6nTDe+N5ZM2k0GqIowCxIo9GgXC4jnU6LzBGzSGbWtJUsspOwwwCn1Wrhs88+w97eHubm5mRwH+FKVSDY6/Wi3W7j4OBAlAUYEJAlZjKZ4PF4BHa+aAZzYeeys7MjRSCylZieMeLVarUSoTPa53AqOgim4mozEkUStVrtlHoyoxsO+kokEkgkElPUQxb7dDqdNPssLS3BbDYL5k1WDLWnqCdlsViETUE5CuDl9EwaHLKL2Eczy+JFUnnvdCJqxzELk06nE3q9HrFYTJrCXmXhABCdJb4vFreBlwqpmUwGnU4Ha2trWFlZkUIeSQBqL4zD4cD169cRDocRDocFk+VrkqbcaDRQKpWEXs66D1NyOmXuL1lbs2Z+jOAYtbLmwkvA2eHJZFIyWdZSaNjpyAFMfWYaK4PBgGvXrkmthQaQkjmJRAKxWGyKOEFpEo6SttvtIv8SCASmnqdWqxWDp0JqhH05kI2ZpQr/Ui7oMqvT6UhARnhrZWVFngmDFxIHyOpcXl5GJBKZ6inhv3s8HhlDzMxiaWkJiURC+lFY96AAaygUEoo1nTVp1rzbnHdD+If6cAy01ECBigtslqaaAO+U2od1mUmUhINJL+YkTDaVc3wzBTnpSNjozc53OikiGWpHvF6vx9LSkmTqJBmxL437R6YeYVZSvgndJpNJIVaxp49sMxb4GYyqivNnZ2dSl6Vt4O9hvfKi+3dh5/LgwQNoNBppJCNmBwAnJycYj8eYn5/HysqKSO73ej3EYjEEAgExSMQCecGIVbIzmWyOTCYjPQibm5uixLuxsSEXYzw+V3gtFotyIex2O27evIl4PC7FQJfLhWQyCZ1Oh83NTZlvrtPpxNmwIE6aKY0Z4R8yN74K48imM6bWhBH8fr8U1jhNz+/3A3h5yAiZMJokbEJnz9Gux8fHePLkCarVKp4/f45arYaFhQVsbGyg2+3C/VcTErPZrJAwjMbzca3vvvuuNNXxi86oUCgI/dRgMMjBpxI2jQSNBplBbrf7UjPgK5WKUItNJpNM5GNGx6bF9fV1YWlpNBrZH0I+jLpUnJtZDkcaR6NRbG1t4Uc/+hEqlYrsH88WM+3BYCDnb35+XrrM19fXEYvFhDLNyHY8HiOXy4lT52uQZUk1CwZWdAR6vV7k0S9T0G82m1OMObvdjjt37gA4dzz5fF6oyKqYJ0da8F4w6uX55J7Tga+srMDn8+HJkyfY39+XSbD9fh+3b99GIpFA9a+GW7G+RUfD2hMdaSaTEQX11dVVaLXnenXFYlE+F+8D5WnYj1MoFASaZ7a4uLg48x4SouagwW63OzXNlnc4FotNMVNXV1dht9sFHVChLUJVzHQo2sk7/PjxY9RqNezu7qLRaOAb3/gGbt68KfeTDdeEIfv9c/Xxa9euIR6Pi4NgZkl4mpAde7HIVEylUuj1evKZqVtI0gR1Hi+yLuxcmHIBmNKkUpfaWapGE+wIZYqsQjTsaSETgweMBU/OeDAajZJBMB1Wi3Sqh1UNBy83/16lz9JJqmQF2RhFc4wXnUXWWRYjZdagCJWoBUjKhKhwFX8nL/arRXbuB7MFCnRy/8g8IotOhefUL9KSAcjn5fNghsgeBlK1vV6vKDwzpWc/EZ8vSRvM1mbdP/4sL6fajKsWPavV6lQvEB05HTP3mQVoZoX8vJQ+4eszC2J/DIkVnF2ikgtIWSZbUi2c06mpjZ3sjlYLwGphVf0vyTOX0RcjrMQRDbwbfL6EYPn+GYBptVpBI9gOoPZcsd6pnhV+n5pt9Pt9eDwemUX/6nngGSOT7NWzogYNdJJkhqoqHFx83+qfL3OHaQO73a4EAbRXdBgcM6AuZiUcI0Knws9AiSmeTd4hfh+/x2A4l/N3uVxTklYMkGgDmVnyGarkJO4fHZnNZpPZRfweOni1eZv7ryYVf926sHO5ceOG0Fo5AIyHnoWoZrOJFy9eYDAYCD7MQjRZCsQI2cxz7dq1KXXeYrGIer0u0Vo4HMb6+jq0Wi0SiYTIVu/t7UlaGggEMBgMZJQsN52y4QAkajUYDAgEAlhdXcWbb76JQqGA/f19GWbF2R+EBMhQY7Y16+Ume2l7exupVAqhUEiyMOLJpDiSSqtCNhy6pdfrZYAXaczMQJge0zmEw2FEo1Hcvn0bBoMB6+vrIrEOYMrZEuYiXKg6Vx5GZgLRaBSJRALr6+sCz+XzeZTLZWkCJe3YaDQK718VYnzdxUFfL168wOHhoShXq7IouVwOjx49EkIJex3Y/0ChSNb6fD4fksmk7F+n08H9+/cl8qUDIJRy584doYZyPjtHa5PYAEAyE0aDbLrT6/VCmXW73QgEAqhUKjg9PZ1SYqDDZ8BAI3+Z/QPOJeOHwyF2d3eRSqUQiURw69YtGAwGqXGyEZLKATx/rBWxXsp7EI1GsbCwIE2U/X4fx8fHotZ969YtuUej0Qjvvvsurl27hnQ6ja2tLYxGIzFWnJ1ER04Ym/VZVajUYrFgfn4eN2/eRLFYxMnJifTYkQXF2oFa9+V5nmUlEgmMRiM8ffoUe3t7oo1IqHo8Ph+EuL+/L4GLwWBAsVgUBYZsNgu9Xo/l5WW43W74fD4kEglpiCbZif0wnHnFjIFkDA63AyBEKao+APiZc0Iby783GAxCzSaRSGVVWq1WucPsoeG6aN3vws6F0QnnaqspLB84oxMWwtUmSaa+jHboRclk4EXiASPVkXx1QjZms1mGGXU6HSlSqSmnKnJIOIfMF15SdgtTvVW91DycKmOM0e6rFNuLLh5ocv1ZWFMjKzpgRmGMLijlTbl4HmRCWXz4vPyDwUAYJJShsFgskqkBL+mOzGL4rHj51GxOrbER6mHmQpIHA4x+vy+dwGwsoxO7zOL74eVTKdt8n51OB4VCQQwh94owqhr58xwwsqYxr1arKJfL8Hg8UqDm+WCXPvAyk6IxIzSiGi6eFZ5//hyb0dQx0dw/nkNGoqy5MPu5DBWZTD9CiXa7XVAINpTyvKvKECrFmpAJ7zGp4PxsdALlchlut1sw+ldrsHx+r1KGSZOl4gP3jQ5GpS4zc2EWBEyrL5P1SXtz2T0kKYAQIs873zszB7LcmHXwfVMjkZk0nbjVahUmJ20VdcS8Xq/YKzJNKZ7Kz8q7wcyScCrvHLNyElkYpLBQz4ZQNSskEUer1cqYCeDijgV4DefCF49EIlJwp8Elq4AH0WQyTQ3C4genpyXzgXM+1AIwo0A6HjIrRqORRNaVSgVbW1sYDAZYXFyUMbNut1v0erjRlHrhyGQuddLeZDKB2+2WAmQ4HMby8jIAoFAooFwuC0Y9q5EkhLeysoJ4PC51pslkIuw4VeCR0arf7xcZidPTU6ljsN+EGRdlcOr1uhSYGXFTLLFUKmFrawulUgmPHz9Gt9sVbTHWMKgtRgND+iONCmfgnJycCFHg4OBAxB85dCgajUKj0WBzcxP7+/tYWVkRhzPLqtVqmEwmohLNwiSbHrkXvIjBYFCiV+piMaPlTBpmrWq9gI2AxJdHo5FElGSC0bgMh0PBygl3kUFFCqfdbp8alEaNtnA4jEQiIeeVGlhk7HD2ytbWFrLZrMwSuoyTpuFYXFyUTm7uG2fzEAah4yWs6nQ6kcvlBJmgU9/e3sbh4aHovTFbtNlsUqim0+52u3jx4oU06j19+hTtdhuJRAI+n0+ozmwMZBHe4/FIQ/ZoNJL3yoya9UfOfzk7O0MikcD169cBAFtbW1JPqtfrM59BEi4SicRUYVuduMmgjY6FWTznDQGYYmKdnJxIJsj+K9amSQ6ZTCYoFotS2zw4OEC1WsXe3h76/b5I6+j1etFZVKnFvNdsQKeiCYN0NrgyeCuXy7BarZifnwcAfPe73xXdPLfb/dXDYow+/X4/HA6HROCspVCFmFIqwWBQIB9Gdcx2GAmVy2Xx5GRi8QGREz6ZnAtMqoq21WpVIAgSDNiYSSOsqgizw1QtGlIum3UZp9MpVGBKqDPiIZmgVqvNnFJz/5LJpGhXkeZZq9Xk97K/hRGC2+1GLBaTSIVGqN/vI5fLIZPJiDgo+1+Gw6HoOVG7rF6vT3VJP3nyBMPhEHfu3BH2i9/vR7PZxMHBAUqlkrD8KNVBJzMcDpHJZJDP52UvKT6ay+VE3mcyOR+A9vz5c+j1eplGOssiC4gEkbOzM2xubqJer+P09BT1el0YfXTcHE3t9XolkAEgENnx8fGUbD8xaJ3uXNxybm4O3W4X+/v7KJVKODo6EvZbPp+HRqPBrVu3kEgk5BzRWBPa5f5Rf4uDoijmSoIGDWoul4NGo5HI/ezsDDs7OxiPxwJXXmYRXjYazyexptNpdLtdGYnNPVRFEhOJhPTpPHnyZIoldXJygnK5jFAoJE2VqjoBI3few/39fRweHiKfz2NnZ0dkm5hVU0WalOhEIiHNnbzXlJICIPVFZtC8w+xxYw2oVCrB6/UKdDbLKpfLcgZDoZD0+VBahQV/ZmTch2AwiEgkIqgLJbSq1aqojng8Hty8eVPYZGQkRiIRDIdD6YthoEOIbTKZYHV1VUgpbrcbrVYL9XodtVpNyg/tdlsIFAzGWP9lrZFsxkqlgng8jrm5OYxGIyEUUHrqojJYF97lTCYj0AHTLBp1ct49Hg8CgYBsLtNsYtAs3DPq4eFTC6Pk9atDbChDQL0ng8Eg8ByhK5V9Q2quGkUyS1AVgxkFqtnL6uoqAoGAZFlkmnm9XmlSmmWVSqUpKIERHqEQ0gZpgIlzq/NbyJCjBhHH9pIlwmmCwHQXMfeR8FC32xU9M0JwLPJSJYDaaiwqBgIBKThS6oNNbEypFxcXkUwmMTc3J+y7cDiM69evIx6Py7O+zP4xk2JWqtefa8ix6MkGN8II/Fy8+DQ23W5XNJion0W4hJAGa1cOh0PgNdbl+P2sH5KWzKhVHZ1Ao0kK8Gg0EqYbg6/J5HxuhiosOhwOBW+fm5uTuzXrovQMsy3gPHhhz1Wr1RI4kFkmgztCabzDfOZEL9jnQeYRNfpU468SE7jHwEuIkhAtoSLCPa8O5DIajeh2u+K4+dxYj0wmk9KDxXtNavNlSCVkfFI/r9frCUxF2v+rZ1Cv1wtBhNNfJ5PJ1DAz4BxyUxudub/qwDT+PfAS2WDQyn1mUM2zylrYZDKRuiVtAMeZ03YOh0NpP5ibm5M+p0AggPX1dYTD4dfavws7ly+++AJ6vR5ra2sYDM4HzSwuLgpH3Wg0IplMiqji4eGhRHCEadipzUsOvJQUoOFlfYWHX6vVTg2v0WjOR8TydQEI5EBDSMHGw8NDpFIp+Hw+XL9+HXa7HeFwGA6HA6enp9jb2xPmx3A4xNraGhYWFkRDazweI5FIYHl5WS7ArGtvb0+of6xXkJrLCCcej+Ott96SaKHf7yObzeLFixfSU6DX60UyXu2HIV+djlylOwIQyIEzbpj9kA5Nlh+LqX6/X6YOskNX/fwMHHjoJ5MJbt++jbW1NZRKJWxvb2MwGOD27dt48803Z3bK6v4x22U9jtAbnSwjRAByUTkTnPus0WikXme1WmXAHGXOCQWxX4fECOpUEV4j/k7Ig1p1AERW/uTkBNlsFsFgELdu3RItNBIoKpXKVO3r2rVrSCaTAjH2+31sbGxgdXUVPp/vUj0aAPD48WMAL+tFyWQSb7/9NgaDAZ4/f45SqYT19XXcuXMHk8lEjCEJLwBEbJXQNrNtOnmKRLbbbTidTtlz3nkaXQ4CoyNhKwFtCTMl9rmpWmfs0yDDUc1c3n77bdy8eRPZbBYPHz6ULHF+fv7SZ5BZJW0GC/qEmAaDARYWFnDz5k2pcfT7fRn1TehUrR97vV5pmFUbm8kCJQTOuqpahyGJh3A62WpELkwmkxCBQqEQ3njjDZjNZslcqDjNnxsMBrh79y5u3Lgh4zyGwyGuXbuGmzdvihO76Hqtmgs3jB/gVdokI0vWNtRsgp6RB41LLa4xq6ERo7qpSplUIy8afEbQatTO11ML+Hwd4qEcIqSmsYzAaJx4GPh5Zl2qdAgxT14K7iP11cbjsRR0CScw8qVhUOm+ry5GlIzcAEzVv/gaZPoR5yYNlK/PCJNYMKNuNRtiFjCZTMTZ0fGrdQdVgXjW/WPBk/unFr+ZQbFo3Wq1xAFSZoj7pb5/ZuNqcVllJwEvC6Yq5ZlRvdFoFHIGzx8LpqxBqueUX3zWzDAZGLEfghkNM4hXaaWzLL4/lTL86lniXSExhj9H+RGVSKEGitwf9YuRtNoyQNRDJY0wG3yVLKN+Vhag2fGukkT4vHgGHQ6HiDn2+304nU6J4tUejtdd6r7xGalBMJ2uqjvHe6WOBlfPn/r5aK/4ReYrv1+lq/P71XvK4Iffrz5b1sJpO/lz3EO+HtEhtpMMBgMhYfDuXXRd2LkwShyPz5V9NRoNQqEQJpOJYIcUVKQzUbMTSpPrdDrhppfLZZydnQl/m0aCkXWxWJR+EKfTObV5PFxzc3OIx+PI5/OivZTJZKDRaODxeESplt3Fx8fH6HQ68Pl8uHPnjmhPkQJJtocqB840nEZ0lsUaDh0EDSMdCTMI1nV40HixAYgmE7H6QqGAXC4nNSKySNgtvLm5CaPRiOXlZSn0MbNhwfTDDz/EnTt3sLe3h/v3708xzjwej4xgJRzFrDGZTOLmzZtoNBr49NNPUa1Wkclk4HQ6kU6nsbe3J+fA7XYLi3DWNTc3JwaJRorPg3g3SRetVgu7u7tS5yPVm1R4XqpqtTqlbmsymVCpVFAqlWSMrNVqxerqqmRyhBorlQpGoxFsNpsoQGcyGXE4Wq0WS0tLuHbtmkCgwHn02+l0EAqFcP36ddTrdXz22WfSyMuaDjv0maEWCgVsbm5iPB7jH/2jfzTTHlJSn1Era2eEWqPRqBRsqWxBlQUSGAgnMthot9tIp9MSxbNmwxrpZ599JmQbj8cjtQI28ur1eszPz2N5eVmaSFXyBdW9GeAAL1llwWAQ8XgcrVYLm5ubIn1ktVqRz+cFpqRjJgFk1jtMR8K7OxgMBDpiuwIL5DToNNjst2LGxYCGZ9DpdGJ5eVmyjXa7jUKhgJ2dHRiNRszPz8Pr9YrmGzMN4HyI4srKimiRESIfj8eIxWKC5JC9mUqlkM/nsbKygjfffFPOXLVaFcoya0E8J9RKUwPWv3a/LrqxlP8YjUZoNpuw2+1CpWWjJH85o0x1UdKCjWnkvtMoEMNnJNfpdFAul6XQz8KgWkfQas+n6QUCAcly2Gw4Hp/L8DMdZsTBzmDKXzcaDXGIjEp7vZ4YWB4qFslmPZhqlqTilirNl/UjNXt4Fd5SWXqdTke03FhP4cGlSoLZbBZ9MNZQ+MyIwy4vL4vUOyPN0WgkxUiVzcfu/GQyKZI6fF6EesrlsuD0hPIY7c26eP7UrJTRKrMTRltsCuMUPwYthBx4sTmGgE7CbrdLwZ2BjNPpxPr6ukRzNDCMnimxT3KDej5VcU86ffYyBQIBBIPBqZoXsztG3MxsqSTBeSazLk5gBSBOl425DPDYC8S6p5pFqw2/fF/9/vmESNKrKSxKqPbk5GTqtSmKSYICi9B+v196tBjpU9mBdVY2SzMAMpvP5x5xuiPJLhxrweyCzaGse8yKQDBLUzMmQsMM3HjO6YC5T0ReuO98jqS+q31VqoJ5KpWCzWbD0tKSwL/MIHiOOb+IdWLe1/F4LJA2HfJwOBRx0OXlZUSjUVGfoAwMbTnRB7aZqAMWL7Iu7FxCoRBGoxH29vaQSqVkZodOpxOdIF4KPtDRaIRAIIBwOCzsEBbomR4zVSNuSC+vDiuifMfZ2ZnISMRiMWi1WknhDQaDsCK4SaSk8rCqHcfFYhGPHj2Smk4gEJBDx4iEHcY0bJfJXMi5z2azKBaLSCaTiEQiU9Ad3ydrMHq9Hqurq4LDE9Pn52UGoxZkefkDgQDeffddUQimGjWjE9axut2uDIIiRk7qt8/nw+Li4pTyQj6fF2rz48ePodVqcevWLSnqWq1WKbry+ZAiSoWGWZbL5cJoNBKWWiAQmKKGE2oldEGKdTgchsfjQalUwsHBASaTidT1KGnBS8vXIZmBQc14PBZBS9K0mQWQNML6y6uBTyQSQb/fF/rs2dmZ9Ittbm4K24djlGmcmK2azecjo8vlssCXsy7+fDabxenpKcbjMRYWFsTokfxweHgo83fY+Gm325HP57G/vy/iknTmJpNJmjPVZ+9wOKRRmHNgSH+lYzCbzeh0Ojg6OkKr1RKaOPvSwuEwrl27JkxF1gkNBgMKhQLu378Pvf5ccoYQOkVdWcsgA5A2Z9YzuLi4iPF4jFQqhYODA0SjUWlKJqTOjFqFvUOhELxer1DfaVcYELKn7eTkRGBWt9stz95kMskzIOOLe8oskzTyQCAggQwJB4lEQuqKzWZTWKC8wwAQj8dF3Z6OkM6ITEDeg6+8iTIWi6Hf7+Ozzz7Dl19+iX6/jxs3bsBoNE7RhJnNkMWRTCYRjUbx+PFjfPbZZxgMBtK4NplMJO0nhZHTKF0ulzi0fD4vlNPd3V3Rb+JBZlGLMvO8wA6HA9FoVArdxOl1Oh3y+TxSqRS8Xi8++ugj+P1+MVz07jxQVFnlgZ9lEbPMZDJ4/Pgx+v2+0IAZ2bBniPUVg8GAmzdvIhwOy9ArwoKE6pjBZDIZqXnw4i4tLQl2S6NSKpUkXWZGRmIDxxPwGVKrizBbs9nE6empZC9nZ2eIRCL423/7byMajUqfCy/4cDgUpV/CAbNebNKqnz9/js3NTSwsLCAej8tFoJMhDh4IBAAAt27dwuLiIh48eIAnT56g1+vJz9hsNoFmCGuoNFqyA0kT5iAovV4v+zccDnF6egqtVotwOCzU9fF4LKQN1nxITya8WCgUEAgE8M1vfhN+vx+np6cCm1GpgQFSqVQSFtmsizAXqaVqDWg0OpfUoWowadU2m016i54+fYrd3V05H6x/kLX17Nkz6HQ6zM/PC/NtZWUFFotFqLhHR0cyiTUejwvbtFAowGw2IxgMiojncDhEPB7H3bt3pZ2g1WrBarWiXq8jm83iwYMHiEaj+J3f+R0kk0mZhsr/ku1EtOAyzmV9fR39fh/Pnz/H/fv3cePGDdy8eVMgO/blkdZLSI70+SdPnuDLL7/EYDAQu0eSTb/fx8HBAQDg2rVrMoBPbXxmpkKm5PLyshAkCMVFIhHR0WMfG5EJ9tK4XC7YbDaUSiV88skn8Pv9+PDDDxEIBCSzZM8LIVNqqZHUcJF1YeeiFu9Z1P2/db2qf1a7jmmY1X9nhKj+P42F2n2tFj65ya8WtPkeWRtSi4yv/g6m3/+31+LvfPU9XmbxfalpMf/+5+0d8FK1lwVk7sOr3/8qJENogz/38/5dPbSEOl59HipEp1IQuX902MR0X/15/leFEmZZfIavUqx/3lKL72pRnT+rPld+LnVfXz03hBJZpFX3hPvHM0Q6Lf+rEinU71fPKZ/xq3ukPhP1DM+6+PM8g+rrq+fo1futFvC5+BnUxeBB3Ue1QK32gHDxz3w/r35OtSD96r8RIiPcqSowqHZD/fNlFj8DgJ97h3+e/VD3j8/71bOrPhf173iH+XOvkp9UQoVqb9V7+irZQn2fKgVZrRG9ul79uYsuzWTW2361rtbVulpX62r9X9blBJ+u1tW6Wlfral2tn7OunMvVulpX62pdra98XTmXq3W1rtbVulpf+bpyLlfral2tq3W1vvJ15Vyu1tW6Wlfran3l68q5XK2rdbWu1tX6yteVc7laV+tqXa2r9ZWvK+dyta7W1bpaV+srX1fO5Wpdrat1ta7WV76unMvVulpX62pdra98XTmXq3W1rtbVulpf+bpyLlfral2tq3W1vvJ15Vyu1tW6Wlfran3l68KS+7/xG78BnU6HpaUlxONxHB8f46c//Sl0Oh0+/vhjLCwsIBKJIB6Po91uI5VKodVq4eTkBIVCQYaF6XQ6rKyswOPxTM1md7lc0Gq1ODs7Q61WQywWw40bN9BqtfDd734XJycnMn7YYrHIvIO1tTWEw2GRjO71ekin0+h0Opifn0c8Hpdpjr1eD5ubm8jlcjJ/gb/baDTCbrfLTAZO3+MQLnX+9r/4F//itTf6d3/3d6HVauF0OmG325HJZPDo0SNYLBb89m//Nq5duyaTPCnLPRgM8OjRI+zv7wN4KX3NqXyhUAihUGhKyp3T4zgLot1u49GjRyiVSjLpzuVyYWFhQYY8cQaK0WiU6YQcfuXxeGSqXrfbxQ9+8APs7e3B4/EgGAzCYrEgGo3CbDajVquh1WrJdEaOnK7X61NS4P/u3/27196/f/AP/gF0Oh2uX7+OxcVFbG9v40//9E+h1WrxK7/yK1heXpaJnABkquj3vvc9PHr0SEYgG41GBINBWK1WGQTHgWvqCIlAIIClpSXUajX87//9v3F0dCRDlvj5DAYDQqEQHA6HSMOPRiO0220ZCMUZKhyox/PndDploNn8/DzsdrvI2nMuz2AwwPPnz5HP56fk5v/5P//nr71/APBv/s2/gUajgd1uh8ViwdOnT/GHf/iHMBgM+J3f+R3cvn37ZyTzuYcPHz6UeUsWiwVLS0twuVwyh4njDThNtd/vw+/3Ix6Po1ar4Tvf+Q6Ojo7g8XjgdrthtVoRCATkNU0mk4w2B87nyXBGk8/nk2FhrVYLn3zyCQ4PD7G2toY33nhDpPbVu8GRzIPBAIVCAa1WC3a7HQ6HAxqNBv/0n/7T196/v//3/77M7fH5fDg6OsKPf/xjWK1W/M7v/A7u3LkDi8UCm82GWq2GZ8+eoVaroVqtotFoIJfLYXt7GxqNBsvLy3KGuAeRSAQ6nQ7pdBqlUglerxexWAydTgcPHjxAoVAQmX2bzYZwOAyLxYK5uTm5b8PhEP1+H/l8Hr1eD7FYDNFoVAY4ttttfPLJJzg4OIDb7YbP54PD4cDCwgJsNptI8FPSn1NmOWKAZ+Mi+3dh52KxWOSDcZrf7du3odPp4PV6odPpsLW1hZ/85CdwuVy4fv26TFHzeDwyCVGn0yGZTMLj8aBWq6FSqcBiscj0v06ng0qlAgAy5wEA3G63DNcBIDOkT09P0Wq15CHxcuj1ehwdHWF/fx8WiwV+v1+m4xmNRpTLZRwfHwOAjMLd2NiA2+1Gs9lEKpVCp9ORudScFzHr4gPjw3E6nbh+/boYKq1Wi0KhgN3dXXi9Xrzzzjvi6DweD/r9vgwKowE0mUzodrswm83wer3QarUyKbHX66FSqcjALs6FAIBms4nt7e2p92e322U4Fvdwd3cXzWYTDodDhmNx+l6tVhNDQOPncDhgtVrR7XaRz+cxGo1Qr9fR6/VgtVplUt8sKxQKyf4Vi0VYLBZ89NFH0Ov1CIfD0Gq1SKfTODo6gt/vxwcffACn04ler4d4PC6jXbVaLbxer0xlrNVqMJlM8Pl80Ol0KBQKMnUSOJ9KGggEZMw2nyOHn1UqFZliyQtJJ3Z2doatrS1YrVZ5/cXFRcTjcTSbTVSrVZnqqNfrkUgkEIvF5O84JbRUKomDv8yq1WoyfdRgMMDhcODXf/3XxUkOBgMUi0Xk83k4HA6sr6/D4/Hg3Xffxfz8PMrlMo6OjqZGdbfbbVQqFVitVoRCIfl7nU43FejZbDbMzc3B4XDA4XAAOD+HdGAcfW6322UPOZ3x0aNHcLlcSCaTMp2VUyzr9To6nQ4ODw/R6XSwsLCAubk5Gcs7GAxQKpXQ7XbhcrkwHA6n5p28zuIAOoPBgH6/D4fDgTfffBNms1nGE+/v7+Pw8FCGecViMZTLZdTrdbjdbpmhk0gk4HA4pkbDc98GgwHa7fbUzB+XywWLxYJWqyUTNovFIvR6vUyX5PvgRNter4etrS1sbm7CZrMhEAjIZExOBa1Wq2g2m+h0OjCZTAgGgzJ0sVwuo9/vyx3mlMyLrgs7F05M5MxvRn0c56rT6ZBKpfDJJ59gYWEB9+7dw9zcHAwGg8yPpxGi5+e8cwDiELrdLmq1GgaDAbrdrkS8DocDJpNJjFepVJKxu3QufI8Oh0MOJqdNcnIl501zfjrnsNNwct57Op1Go9HA6ekp6vU6bDabGN9Z1mAwmBrq43Q6xWEy8q1Wq9jZ2cHi4iLC4TAikYhMreMl5jja0Wgks8RpKAwGgzhmZlqTyUQyMnU2diaTkcFXHO07HA5hMBhgMpmg0WiQTqext7cHv9+P0WgEp9OJRCIBj8eDra0tHBwcoNfrSaTOi82R1IyC6FDNZvPMF9vr9QI4Dziq1SqcTifu3bsn53E8HiOXy+H+/ftYWlrC3/gbfwPRaBRGoxHz8/M4Pj7GF198IYGR3W5HpVIRg+t0OmEymVAul2X2eqfTEefu8/lQrVZRrVYlCuQzVbMeZh18re3tbfh8PthsNtjtdszNzcFqteLg4AD5fF6mLo7HY7ncvV4P1WpVzjcDMLvdfqmhV+12G8DLgVJ+vx+3b98WYzkcDlEul7G3t4dwOIzbt2/D6/XKuOLt7W0Ui0UZJc2Rvpy8OTc3J2OhgfOx4AxwrFYrDAaDjMLmvzEapuHi99G2PHv2DPfv30c8HkckEoHJZEIikYBWq5XpoPl8Hvfv35fJkxaLBd1uF/V6HYPBQJw4bcysZ9Dlcsn/D4dDsSXMPAaDAfb29vDd734X8/PzuHv3LmKxGJxOJ+r1OkwmE1qtFgAgEonAbrcjl8vJSHXeRd5xohfcD71ej7OzM0EniKRUq1XodDq43W6Ew2FMJhOZvpvNZnF2dga/34/r16/DZrPB6/UiEong8PAQJycnMmmVWXMwGMRgMEAul5uytUQ9vvJJlDT0NFCMXji9TK/Xw2KxyLz5Fy9eIJvNyuz0RqMhRovztw0GA9bX1+VnJ5OJwDn0whqNBoPBQKAbQlaMdBiheL1eeDwe2VhOxeOs6lqthm63KxvTarUEgmJWpk4CpLHg7+KkwFkvNyORdrsNk8kkn5njUHlQzGYz+v0+nj59ilQqhVwuN3UJB4OBfBaXywW/3y+jnrlP6qTEyWQixpKRNUerMrPg86TxHwwGEkXOz8/DZDKh1+tJRM+InREX4Ry3241IJCJGW820Lrs6nY48G+DcQDabTTFK/Fx+vx8GgwE7OzsoFovodDro9/uoVquwWq3iNBjBBgIBmEwmudAMhn7e/o3HY8kemEEzozSbzVNBAgD0ej2Z316r1cTZ0/C1Wi2MRiMZtUy4SJ1WyhnphJwu61xU6IgGnogAx40bDAaB8Ox2OzweD+x2u4wOZ+A3HA5lpDTP7Xg8FkcF4Geyfd7fyWQCi8Uijprn3263YzQayajyfr8vhpVZIqeeFgoFQS7C4TD8fj9isRiCwSBqtRrq9br8HqPRCLPZfKn9KxQK0Gg0sFgsYssIYQ+HQwkEg8EgjEYjtra2kM1m0el00Ov1xN5MJhOUSiXUajUYjUYsLi7K++P7JcJitVplGipRHAbSDKwIuTK4YRmANtbr9cJkMskZpBMfjUZotVqYTCYCbep0OlgsFnlunLI6i1O+sHOpVqtigDQajWwGPyThr7m5OfR6PXznO9+Rw6fVauF2uxGLxTCZTCSFff/99/Hhhx+i3W7j+PgYrVZLIDZuLL0qI3S+B4/Hg/F4jEePHiGTycDj8SCRSKDdbuPBgwcol8vyd51OB+l0GsB5xOH1elGpVATDZEqpjmFlxK1mbJeBxUqlkjhhzm+nEaPjBiB1kj/4gz+Q+dUWi0Wcbr/fRzqdRqVSwZtvvonl5WX0+30UCgUxgsw+uH+VSgW9Xk8+h8PhwPz8PADg4cOHqNVqkvGNx2N5rXA4jI2NDdRqNRwdHYkTtNlsSKVSKBQKUvux2+1YXFzErVu3cHJygnw+D2DaGVxmVSoVgUlVR2CxWBAMBgXa4n782Z/9mVxUBiperxfj8Viiv8XFRSwvL2M4HEqUazKZEAqFxOj1+31xUg6HA263G0ajUWo1e3t7KJfLsNvtiMfj6Ha7ePbsmTgzv9+P4XCIk5MTaLVa1Go12Gw2ZDIZFAoFWK1WLC8vw+VyIRaLyXvk76YRe3Ws7qx7qNFopG5SrVYloLt27Rr8fj/y+bzMqP/2t7+N8XiMd999FxsbGxgMBohEIlJTbTabWF1dxcrKCobDoWQOXLyrjMg5U57G3mAwYDAY4Pj4GOVyWWpdvV4POzs7qNfrMBgMmJubAwAcHx9Dq9XKz6dSKezs7MBut+Pu3bvw+XySPZ+cnCCdTmMymUh997JBzs7ODjQaDWKxGPx+v4wwVqFGl8uFjY0N1Ot1fOc730Gn0xFnxDoTz02328XXv/51fPjhhxgMBsjn8+h0OmLbWBceDodyZgGI4yHMtre3h3q9Dr/fD4fDIbWper0Op9OJUCiEdruNk5MT6PV6uFwueL1eDAYDQTqIytCO0+nQnjAoeR3nfGHnwmieHpoOxWg0iuEwGo1SMCP2bzabJVKhp+Ub5GswUuYF4jxtzqsmFsmHxGiVs5/VOeXqrHRuyHA4lEIvozaLxQKPxyP47qtRO50JvTjf36xrMBhAq9VORQIkM6j7RyyUqS8dAtNmvi/1S41o1RnonJ2t1ov0ej2sViv0+vNHz0PPZ6POfqeTUp8zgwW1zsPnwueg1+ulvqLVatHv9+UCzrr6/f5URsnPwvfNQMbhcAiGzGhYq9VKRkc4h++Ne/vqlzpfnr+HAY86T16d8a7+PX+eF5K1Gn4PMx2z2SzZAs+Jir+bTCbZu36/P/P+AZDMnVk/8HIuPCFbZhbMDInfszjOO2Y0Gqe+uNSaIM8qz6K6l1qtVsgkaqatBng88yrOzz01Go0S4ROuYW2Re807zT3u9XqSAc+yGKARFeHvUJEN3mEiCZ1OR84nz4IaaNEW8f7SoBNSVveV8CH3lc+Rz4AFeD5HPiv1bPL50g4Q7eFrcO/5WRgc0Pa9zhm8sHPhxhAPZsGKadh4PEYgEIDT6US5XBa4ioabNROtVouFhQWJKrPZLFqtFkqlEprNJo6Pj5HP5yXV1ul0cDqdmEwmiMfjSCaTqNVqUmwmpOBwOFCtVjEYDAROY1HQ5/Nhfn5eMF+TyYRYLIZf+qVfQrfbRSaTEUdIp+j3+8URaLVanJyc4PDwUC7l6y6SGcxmM0KhEAKBAFZXVwXvHo1GiMVi8Pl8UswlM85gMMhB4IHu9/sSBWk0Golmzs7OhI3Ey8r/J1Ot0+kgm83Ka/h8Poli1BqaXq9Hu92G2WzGrVu3oNVqhWF39+5dWCwWNJtNbG1todlsotfrSXR59+5djMdj1Ot1dLtd7Ozs4MmTJzM76HK5LJAEM1dCqmQj6vV6LCwsoFKp4OzsTPBqBjj8TKwhWa1WIYbwQpOtaLfb5QwmEgkA51ml2+1Gq9XC6ekper0enE4nrFarsMI0Gg3C4TBcLpcYWbfbLfAlYVrCaf1+Xwqn2WwW5XJZ6jwAhKmTzWZRKBQuFX3ncjkxMGTNXb9+XYx3qVTCZDIR8ovFYkG73Uar1ZL97PV60Gq1WF9fh9lsFmhXZYs1Gg3J9AhpmUwmYdAxkm61WhgOh3C73bBYLMJcMpvNSCaTUssbj8ewWq0CNxE+JDMKgNigSqWCVCoFo9GIa9euyR4OBgOkUikcHBzMfIdpfMkIdLlcsg90GDyjDocDrVYLjUZDoGdCt7QDo9EILpdLSg1kwx4dHeH4+BgejwfxeFyg2fF4jEQigZWVFTSbTaTTaXS7XcRiMWGaFYtFgS8tFgsACBS2uroKk8kkpJz33nsP9+7dkztMyJ4Z7vLystzXyWSC3d1dPH369ML7d2HnwuiGlECNRgOPxwOz2SwFM5vNBo/HA71eL6wFu90uaTi9JxkhBoMBzWYTrVYLnU4HnU5HcH1iz/w+4uOJRALZbBYvXryQTWOETRyYUAL/a7FYEA6Hp6Jr0iQbjQYePnwoRUkW3Bh582eKxaK8/iyLxAGj0SjkANYHuH8qJdtqtaLf70vUwSyKGRxfiw+aTLnhcIhmsymQAz+DwWCAz+dDIBBAsVjEwcEBOp2O0GHL5TKy2Sz0ej08Hg8sFgsGg4EweXixCYMGAgHMzc2hXC6jUCiIcWYqPjc3JzBQp9PBwcEBisXizPvHqJsBh9lsFgbW2dkZWq0WPB4PPB6PZDE8t2ptkA6SkTUZYMz4Wq2WOFn+PGmxdC7Ay1oL6xXqs2BARdae1WoVdhNptypzr9lsCrmFAVkoFJL3zqhXJUfMsjqdjrCzGPH6/X6YTCYUi0WBXaxWK9rtttxXwiyMps1mM/x+v0Arg8EAAGR/SQNmlse/p1OzWCwS/U8mE4HXuY8kmKh7aLfbhfpOtp/JZJLiPVsfzs7OpIA9Pz8PvV6PUqkkjqpSqcy8h/wsrH0ycLVYLMIe5JkBzkkoDB5Z72KWw9odkRvWnTqdjjAxNRoNfD6f1J3JGovH4yiVSshkMtBoNBJgt1ot1Go1eV2z2Yxer4dutyv7pmbMrNlWKhWhget0uikii/p5UqmUMPAutF8X3diNjQ1MJhNxBM1mE1988QXMZrNQDNViHqMVsqIIA43HYzSbTdlQ0u5YF5ifn8fS0pKQA0g3ZnFKr9cjn88jm81K9MBiY6vVgl6vF5YaD3S/30cqlQIA+P1+YQoBEGOi9mLwvdKwGI1GYVjMGnm/9957Unti5Fuv12GxWLCwsACfz4dmsym0P5Vh5XQ6xaGoXzTcvMw8fLdu3ZIaAzFtvnaz2UStVkOtVpOoUQ0aDAYD5ufn4ff70Wg0BBLhQWZfB1lA1WoV+Xwe5XJZ6kPsb2EKbjAYEA6HcevWrZmdy5tvvgkAEhVXq1U8ffpUsuFQKAQAYqgJT7hcLunVIWTA/5J1xyx7PB4jHo9jaWkJAGRfTk5O0O/3EQ6HpxiOhBZMJhM6nQ7Ozs5gMpkwPz8Pm82GYrGIcrmM8XiMVCol+8B6DaP8arUqTpmOic6Hxtbn8yGZTF4Kmn3vvfekAFyv15HNZvH8+XOhiTOjYgDEDIOBG+FOZjo0mqS9NhoNISgEAgGBU1qtFg4ODoQSzEyRn89utwtslc1mYTQakUwmYbVahSrbbrexubkJ4JxpxcjcZrOh3+/j7OxM7oLb7YZOp5NsFoCgFcyuZllvvPGGfG6y0D799FNYrVasrKwITMzv4WcKBoPweDzwer2CiKTT6SnYUa37zc/PIxKJSADa6XTw8OFDlEolHB0dweFwCNu13+9L31a73cZoNJL9Y72G8FypVEK9XpesiXU9kkvo3LhnhNXolHw+n/TMXGRd2LnQMJyenuLs7AyNRgN7e3uwWq341V/9VUQiEXE8jLTYwxEMBuXN9no9+fler4fBYIBWqyU9E++88w6WlpbQarVQKBRQrValEZOrXC7j5OQEg8FAsNZGoyFwRjKZhNfrlfoNufLdbhcbGxsAIBTKTqeDQqGATqcjUQULhoQxSM/j5Zllffzxx2J0i8UicrkcCoWCRPmBQEBYOIRCCAeoBUkV0+Y+sElPp9Ph7t27WFxclM9RLpfx6aef4vDwUJq5yFZiDY3RWLfbhcPhwPLyMubn58U4np6eYnNzE/1+X5wF961arSKbzaJWqyESicghz2az0Gq1iMVicLlcksnMCuu8//77GI1GeP78Ofb391Eul3H//n3YbDa8+eabiEQiKJfLUnxncMBGMV4mdf949obDoVCSr127hpWVFRQKBRweHqJWq+Hw8FACEBpGMglpmBkweL1e6WU5ODjA0dERSqUStre3p2pjDK4ajYZAwuwBYYTMSFej0cDv91+6z+XDDz/EaDTCF198gc3NTTE8DocDt2/fRigUkr+z2WyIRCIStBCZYA/PZDJBv99Hs9kUGLzZbEKr1SIajSIajU59tp2dHekdY5Ov3++XHjS32y0Fep/Ph48++gjxeBxnZ2fS//W9730PrVZL6PBEAEihpmPxeDwYDAbS1xQIBITEsrKyMvP+vffeexiNRvh/2Huz38az7M7zy0WiRImLRFKiJGqXQrFHRm6VtbmqXV1uL+i90e4B5mUAY4CZh35rDDAP8zxP8w80MFtv6DHGDXTP2HDbrnJVpbNyi8jI2EOhfaUoUiIpcd/mQf4cXYbL7Qgp5y0uEKisCInL/d17lu/5nu/Z3NzU3t6ejo6O9PXXX1ummUqlDCKs1+vq6+uzZmTq0bFYzALa3d1dHR8fa39/v6uOtbS0pPHxcUNtMpmMPv74Y+3s7CgYDMrr9apUKhlhATo09SCaXEdHR+28b25uGokA54LNBJKrVqsqlUpdvW69vb1KJpNGc56ZmfnmnQsXE68fCASM4lYul60LFuoxkBYHEGfj9XqtGE8Uwd9JMmjHjW44QDClGo2GRdwUw0i5cRDACRjEqakpKwpns1nreSEdBeqT1FUUxFnW6/W/Uox7k0U2wvfFcQWDQesLIbIgAmHfgTNepT9CPHCfC3ANxovO5EQiYawlIDJoty50JMkOG1FQOBzW5OSkarWa1QYoKFIgpeh8fHxsDViSDIJqNBqWfV1klctlKzRSUwMOrdVqRj3lkkgyOAFIgr97lZzhfiYyGaLTTqdjtG3ODhk5e+ZG4cCR4PzQQ5PJpGWH6XS6S02A8w6E4Xac877ASJdZBFsEfbAkgW6A5ahdSucNgxBs3I58l1zxauAjyYIX6QwigqDC2cAxs4cuDI2h43MEg0HNzs5a1pjP5+XxeCwLZP8qlYplTNxh7JFbH7rIgkoMkQh4sL+/X5VKxaBzslu+O+fAra+CzFBTdQ068CPPpFQqKRqNanx8XJ1OR7u7u/J6vYrFYua0sHlurwzfH4YgzFkYoYODg10ZPOcMyjzPk5IFzMJvvOaSyWTsg/h8Po2Ojuru3bv2ZV++fGkpMkXknp4eHR0dKZfLWXGqt7f3r1A9wS4ldRXYeZhLS0tqtVq6f/++Pv74Y01PT+vv/t2/q0gkYh26ZBvBYFDBYNC68DOZjGKxmP6r/+q/UqPR0P/9f//f+uKLLzQxMaG5uTkjKJTLZasPSedwRKFQsA2+zOVeX1+3/6a2sri4KI/Ho83NTauBlMtlc3adTsekWDCoNK7BtIlEItaz02q1lMvlunpnfD6frl27plu3bumnP/2p/vN//s+6fv26/tv/9r9VIpHQ0dGRSqWS1cW8Xq9lOYlEQsPDw4pGo7p165ZOT0/17/7dv9O9e/c0MjKiyclJu2j9/f06ODhQNps17Nvr9apYLFoPUjwev/DF3tjYkHRm7Kanpw264aKAuWN8qK0dHR3p+PhYoVBIIyMjBpO6jYD8vHTWxb63t2dwTKfTMZhsdXVVX331laanp/Xuu+8qFAppZ2fHGtBGR0fV19enXC5nhfpKpaLh4WG9++67ajab+n/+n/9HT5480ezsrG7dumWfp1KpmNEFD5dk9QLkai6zDg4OJMmeKZGxx+MxmZJcLqdMJmMBCDBnq9UyuvertSoMNgaKgM2NhD/66CO12209ffpUT58+1ZUrV/S3//bf1vDwsGXUwK69vb22rxjM6elpvfPOOyqXy/o3/+bf6N69e1pcXNTMzIw8Ho89+9PTU2P2UTfd2NhQu91WPB43NYeLrCdPnkiSBYfDw8O6e/euPB6PstmswaeQDMjUCXgIiD0ej8bHxzUyMmJGnCyaPja/369CoaB0Oi2v16tbt27pvffe089//nP9yZ/8iZaWlvTf/Df/jRKJhMlTuRl7oVDo6skZHR3V7/7u76pcLuv3f//39eDBA42MjGhqakrt9rn8kdszg0NMp9PWlDk6OvradvCNmigl2aWEtdFqtbS2tmaMF3B7eNNEgfR0kPLzAfGuRHGk19RuKMBSD6E5j5QYg0wkC6XTpfT5fD4r9Eoymi+Ly/NqBMtr8O+X6dVg/1wCAlEXmLt7Od33fbWQy9+zbxTueR8cErgvHfo+n88KcvRsUGvgtWiUpYCN4+C/YZW50TxUcyJ26juwzei34dlfZPGM0cWikM73BGblzGA0yYAhlMCgwyhK5x3r7B8Bi+s4qeHx9xSTMaoucQKnDv2cveRMuw29biTNHvK7sIRqtVpXdH/RRXYOvRxMndoPkT9nlX1x2WAuNZU7QabvfgeyZxAMOrshitA/4WZvMNQgEbh9SkDT5XLZzrwkQyjcbJTzzP+HdMD+X3QPT05Ouqj39IR0Oh2l02lls9kuOr97BsmEQRvI6MlSgLow9K6zJDsBMuUOU1Pk9d1WAVe9A/oyPVqdTkenp6cKh8NmZ1hu9gndGrvebrf//5F/OTk5kSRLB4l2ms2mXbipqSnNzs6qWq1qd3fXPCBGATowzgNJEjqoa7WaMRKGhoY0NjZmm+P1erWwsGBMqo2NDe3u7toBYmOh2RKFJ5NJFYtF/W//2/9m0N6HH36oRCKhycnJLrpgLBYzh8nhjcVihlFeBprgoAF3YOQkGUtufHzcdLC+/PJLVatVJZNJjY6OKhaLGSUW2RBJxho7Pj42WZfNzU1NTk7q5s2bdjE9Ho+uXr1qGC3d/0SIfX19JpfisnwoRv/RH/2RFfjn5ua0uLioO3fuGNSG5lGpVDID0tPTo6WlJYuOLlrMl6RisWgGDtjIrZ0g0jczM9Ml3EcxeGhoSDMzM10BCou6As17RJljY2MGFUIVp/j87NkzM8x8Lp4pMAOaYqVSSX/yJ3+iWq2m/v5+ffjhh1aEhZpPIyp7h+4WhW00qC6TPQPtEgxgAIHrSqWSxsfHdffuXdtDoKyBgQFFIhElEgn5/X6DgKBWw3g8PT3V06dP9eDBAyUSCc3OznZ1d9Os2dfXp/X1dW1vbxtKAN0YpIDaDy0Cn3/+uWq1mkKhkH784x8rkUhoZGREpVLJYN5YLKahoSETipTOpVa4bxddrmHFgUJO2tvbUyaT0dLSkm7evKl8Pq979+7p5OREsVhMIyMjGhsb07Vr1+Tz+SxLAdKGZAOdH9o2jDccwuzsrP7e3/t76uvr02effdZVCuh0OtZGwJnm/u/v7+snP/mJ3dGlpSWNjY1pdnZWtVpNGxsbKpVKFiDhrHn2r1K/X2e9tnNxI0eiDTaIiHF0dFTvvfee0VPxxGB+pLxo1dTrdRNjI3I/ODjQ3t6eZmZmjPVFajwxMWEw0N7enokyghuz8vm8SqWSRkZGNDw8rEwmoz/+4z9WrVbTj370Iy0tLRkN7+TkRHt7e5LO4IJYLKZyuaxcLifprN4TiUS6musustymO1JjjFO1WrUIf3Z21i5Fo9Gwrl5gKLIpV6STiKJer2t3d1eHh4caGhoytWKeE4VQ2DX1el07Ozs6Pj7W1NSUpqamLCLjc3Y6HWUyGf3kJz9RsVg0Tv309LSuXr1qjYrFYlH5fN4ifOR+YF8dHR3p4ODgUjUXr9dr1F6iLZxLo9FQPB7X3bt3DRojK3P7K4CCXGmaUqmkfD5v+7e9va3FxUVNTk52yWDE43GNj4+rWCxqbW1N9Xrd2HNu4ABsOTw8rNHRUa2urur+/fuqVCq6ceOGpqam7NITAFEADgQCBk8BtY2Pj5vMyWWcC1H7qwGZdF6ri8Vieu+997okfHim6FJ5vV6rgVFAx1nQq7azs6M7d+7o1q1bXdIw09PTmp2dVaFQsD0cGxszYUYENPf29syQ4bx+8YtfqFar6Xvf+55u3rzZ1eSHGCZkgr29PWOIDg8Pa3x83GpKF91D9oo7CFuuXq/r+PhY2WxW77zzjq5fv67t7W397Gc/UyaTMRiSVgrqTi7UTmDSarWUyWSUz+e1tLRkYqA8i7GxMY2NjSmTyRhJaXx8XNFoVKFQyBrDXdiyp6dHuVxO//k//2ednp7qzp07SqVSSiaTGh8fNxibM8j9Iot2A1S3pvY37tfrbuzS0pKxndbW1hQKhYyNwAdAKgMmEgeZv19eXpbX6zWNIIwmkVCj0TDpA5rSiALxoIlEwhxRrVZTPB7XwMBAF98eSjSe2O/36+rVq2q1WhYxdjodMyhIhyNYiYyD1+tVLpczmRO3E/lN1+LiolqtllZWVrSzs6NEImGpsSSLTtz0GRp2tVq1HhGv12tZHrL3vb292tvbU6fTUTKZtCgT/DSdTttezc3Nmdoz0AxOFfiHzABab6lUMkbb+Pi4GQJEDKHkwgzq7e3VjRs3zIivr69bdnhRGihU+Fwup7W1NaMXk7nRELmxsWH1C4gFYNgUPnEqyOpA4e7p6dHIyIja7bb1a7kd2WQiqPE2Gg3FYjGjzENu4NmdnJxYgX9sbMyYQxhCnjMGkjPbbrc1MjIij8djGm4Ed5eBZhcXF9Vut7Wzs6OdnR2Fw2GNjY2ZsQSmoYBLDRWIy42MoRXDDIV0AgQI6QajBOyG8UdJAYo3+03Q6X4GgoWJiQm1Wi3rzaKnC/2x3t5eVatVbW5uql6vWzB2enqqjY0Ng6MvumgqfPr0qdbW1hSLxbqg897eXoM96ROCpo4cElkaLEXoya4uI+SDvr4+a2jk5xOJhBKJhILBoEGm4XDYiBGuYoV0FvTRfHv9+nU1Gg2lUinTb3QzRIKGw8NDs7XULff29rpIP6+zXvsnf/SjH6lWq+lf/+t/rc8++8z6CtgsIK719fUu7BtoYmNjw4TkMOq//uu/rnfffVf5fF7pdNqgB76UW9j2eM40fe7cuWMS5BzWaDRqTUUcTPBy2DG/8Ru/YWwXv9+vYrFoGwbt7969e3ry5Immpqb03e9+V5L0i1/8QhsbG0Zpvejl/t73vqdaraZHjx7p448/1uzsrM2RIbqgoEY0VK1W9ejRI1UqFY2NjWl7e9saznp6zmTSl5aWlMlkbEYNBz4YDFqn/7Nnz1QsFvU7v/M7+t73vqd8Pq/Hjx+rXC5renpakiybAuKRZAX63t5e3bp1y3Bv1BA2NjaM7tvf36/19XUdHBxocXFRv/mbvymv16uPP/5Yjx8/7mK0XWT9xm/8hmq1mv6v/+v/0qeffqrJyUnruaCxs1Ao6N69e6rX6yoUCsZso0i9t7envr4+g0kmJiZMl4yMg8Y14C+Px2POJRaLaXFx0VRs6TEIh8PK5/M6PDw0SKvZbJp8v8/n082bN63PCeeE6gAXe21tTXt7e0okErp27Zra7bY+//xz7ezsKBaLXaoYLUk//OEPVa1W9b//7/+7fvrTnyqVSumDDz4wFhNZNOrPZFB7e3vK5XLa3d01R03QNz8/b8aSes7Y2JiGhoaUSqWsYTKTyahQKGhhYUF3795VLpezAHF6elrxeNyK4ozdQHMPphojPrjzh4eHptmXTCYlnRXdV1ZWlEql9K1vfUuS9Mknn2hra0uzs7O6evXqheGx733ve6pUKvrss8/0Z3/2Z5qcnDQ9OmBQenXy+bx16h8fHyuTyWhzc9P0ycgG33vvPc3MzKjT6VgWDLpAfx7BiiTNzs7q9u3bqlarmp6etvosThSmH5mLqzjxm7/5m8YuJWOn6XJkZEStVkuPHj3S6uqqKdt3Oh19/fXXRhFn9MXrrDeCxSjqgNVCS3QLpBT6XEPFRrpFasQHodrhkCigSufFJTbW1duB1sxrE/Xz716v1x6Km87x/hRuXfIBn9fVWgL2c/sbLrKQR3H1mdgbpDHcBi8yCIwJNQtSVYq95XLZdLSg+1LAY7/cfceIvNozwWtx8CnkgdPjHIiegQLo9Xi1puQGFzAM3yTqeXWdnJxYVueyvLxer30X93y4VG0aHV3dKvaCqBwpFrJwsgn3XJFpUJjmrFCPI6jhnPDMCI6IKvkMFPypD2L02GM+p0vLv8zinnHXPB6PfVeeGY3O3FH2EA0tNwiRzgk4ZByQHVztK54LRo8siPdlX1DeJiNyz7xLYmGPcE7Qb4E83efs3nv3/19kkcm7d5j9w76RvUB2gIjhkg04M5wtSBTcN7c1w73D7Df7Q1DF+fB4PH/FVrmUchAgbEqr1bLmcVc1hXPtkqKwG+45/ZvWa9/2f/2v/7WkMyfz7rvvKplM6ubNm/L7/VbU4sNJMgiJi+OqHIdCIVWrVR0eHuqP/uiPbLBVq9XS2NhYF2WPZqhqtaqNjQ3rj4F9Uq/XlU6ntb+/r/X1dXm9XotMaS48Pj7W8+fPrZMbCuna2prBeYODg4pGozb8B3ofWQUCjxdlmvwf/8f/YbTE27dva2pqyii17AcaYMitkClQWwIq4TAiK5/P5/X8+XM1Gg3dvXvXpoEWCgW1Wi0NDQ0pGAxa7YTu6+HhYbswBwcHRrUEIuIi0CBIoXBkZETLy8v66quv1N/frxs3blizKU1qP/vZz9RqtUzrKBqNdk3NfNP1L//lv5R0drmWlpYMjkKTCgkOOsUx9iMjI2YAgB3cYUtkd0B8ZC04JCJR5nFQPGVwFDXCTCZjmRwTAglQcrmcdnZ25PF49N577ymVSun09NSyQpwzKrcQNGBUIceDY7vo+lf/6l+p3T5ThU6lUlpYWNAHH3xgciBIfyCBJMmo7LALx8fHJcmaVWu1mkkxQdufmpqyDn0UzTFy29vb+uUvf2n9U7Ck8vm8VldXde/ePXk8HnturVbLAtCDg4Mug04DJ6yt3t5ey2jb7bNhdwRSc3NzJgp7mTsMu/PWrVtaXFzUD37wAyNc4LAx7kjdhMNh+Xw+6zeTZDazWCzqq6++0unpqdbX19VoNDQ+Pm5NotTjtre3VSqVtLKyomw2q0gkYuMwcCTFYlErKyuSznTwgCvL5bLy+bypRMzPzysej2tvb0/37t1TX1+fbty4oVAoZJAbdHASCqj8s7Oz37xzef78uaWfo6OjGhkZMc47abJLw6MgzAel+EYE0tPTY4VzojOyDdhhOBg8cLFYVDqdNkcARgv9lfkIGGiiHrr9ubjSGRaZy+XU19dnDzwUCpnkucuMICq6DJX22bNn8ng8VtgbHh62XiB6CIhWiGaJHDudjrFmJBkkcXx8bGJ3fD+P50zEkmip0+lY1I5UeiKRMMiCxkiawIhW+DzUoujBoAufzmImDBLR0HuEggJRomtMLrIePXpk0j6jo6O2d7wuDhoWGLUOZDcCgYDV8YgEUUNAuoVLRPTm9/utaFssFo3Rg4YehiSfz5s6AAGBm/1CoHCxc2o0LlxIb4akLmjZnd1xmfX8+XNJZwVp7tDo6Kii0ajVLPb29qzuw12GuUmAw/1AKDWXy9k9A02IRCKWDWOgPB6PTk9Ptbe3p0gkYgaQelwul9PBwYH1vYGIsFdovtFzQTDBd5JkYrXoc1FPINMkE7/IevbsmZ0temYmJyeNlMRZoT+PzIWCeCQSsX4+YNhG42wM88nJidVVYeShA+aOG+EcjoyMKJVKddWQYN2SiZA5QiUGqaHGBZkpFAqpUqlYUytQJvU22g1cR/k6640K+tJ5YxDNhx6PR/v7+9aFTxE3m83aBYGtMzY2Zs1HPT091rhFBOIWWt3aCekzWQyNmjgoDhjRPsONKPihsiqdTzL0eDwaGxsziIdGSg4BeOrg4KBlY+7clTddH374oUWx9LUgFJdOp1UqlRQKhRSJREw3CCio3W6bgUSlt6+vT4eHhzbxkc9FhoVGEPADB4TodGVlxWi5QGtEJTjuXC6nXC4nv9+vhYUFO1QoR3OAYXIR1QcCAc3PzxvmS9GV4uRF1t/5O3/HmGtMbkTNmeFcBC5Qsqkf4ICSyaR6enosCueMulAPTrLZbBp+HYvFLEhCMogzR9PowMCAja2emZlRMBjU/v6+0um0PB6Pbty4Yc2tGxsbRiuu1+tW+yM4Y+hZu32uKs2zv0zN5dd//dfVbDYNQ89kMjo4OFCxWLSJrq4hAkZDpgRxyWAwqJmZmS49NxywGxC5vRJolzWbTdt3elqY59Jut/X+++/bjJvBwUGtrq5aRjg3N2ckm3w+b/YjEAhob2+vSxATGnez2bRpj/TGXXTRTOvCf5BmVldXDSbmTnCvmKyL0wgEAkZ2yOfzlqXilPr6+qwGwntBOjo5ObH+l/X1dfX29naVGUBDJiYm1N/fr1wuZ60GsBqPjo4sKIXBS50QCDEUCpmqyd7enp3F7e3tb965UGDkwWKQm82mNjc3dXx8rMHBQYsgMUA4D75EJBLR1NSUUYRp+HEFGzkkyDbg+dko+mtc5o/ffza0Cq2i/v5+FYtF09pJpVKSzjq9SaVhnxQKBUuXiTbg278q1HfR9Z3vfEeNRkOffvqpFUbRS9vY2FChUDA+fD6fN2FLIIVarWZGf2ZmRslkUl9//bVlCC4GjKQMuCmsNAx7uVzWixcvbN8rlYqSyaTm5+ctwqfhMpvN2niA3t5era2t6eDgwJRqgc3oW6Lhcnp62ggKREBkPxdZv/3bv616va4/+qM/sgic4GBzc1MnJyeGFdPlTCQJM3F+ft6gT+RwUDRgEbRARKHAz+viyHBw1BoSiYT1pDCO9+joSEdHRxoeHtaNGzfk8/m0vLxs8h3g5QxCC4VCGhgYUCgUUjKZVLvdtrPidpxfdEGK2Nzc1MHBgUZGRqwD/Be/+IW2t7cVDoet4RhiCfcdxxuPx3X9+nUtLCzYXScDczNmDBWRdLt9Jlp7eHiocrlsdbqVlRWl02ktLS3pW9/6liKRiObm5tTf32/jFBKJhDnoL7/80ob/USME8SDAGRoa0uzsrJrNpun5tdvtS0HbV65cUafTMZ25QCBgEOvjx4+1vb1t/Sz0DaHBVygULAiJRqOamZlRLBbTxsaGicAymZQBeDh92Iw0PRKcrqysWP1Gkn3nYDCoVCplGS91KcoSiIj29fXZWGRaCXhu/f39piP24MEDY8Gx56+zXtu5MCnO1ftBKwplUiJvIjQKuXSXvjoeFPYWeF6j0TBlVmoGfFHXW6Jr1tvbaxRHt2gG7EGxkGKldK7CiuHjIvCZeMgILyJlI13OuSDPIp1rKg0ODko6w0fpI8BA8t44FBopSZNx7DTiUayj/4XVbrftmeE8id75d/czNhqNrmI/+46+FAVyd2GcgRKhLwPJMY+Hc3ORxTwRPh+sP6BXF4ag7kLDLQ4PBW23AVM6o4EPDw8bpNjX12cO3YV6+W8yIY/HY7AujX908XO+qQu5EGUoFLJ9ks7rk2TnrhQMRXdJXbWQiywcLkYFJXNJNumUzATnSnAH3IQuGbbAJeHA2EIun3vokhKAYekuxxFgK2DiYfxgY5FNAhNyptjnV0k9Pp/PoE7qWdBqL7N/vIfU3SeE7BT7x8/xjMlYaJSlJuhS6RFYRfGA33cJOTh8+t+Q2ufnCKi5f5Ah2B9J9jyBf12iBAV8ggDOPgod/780Ud6/f18ej6crMoDC22yeq5HGYjHt7e3p/v37ymazVtxDsh7ngqRFNBrtGkHr9/uNmryysiKPx6OJiQkzIIjF3blzR/39/Xr+/LmlvcyBGR4elqQuwwPtk5oHg4O8Xq85KiKN7e1tky8ZGhrSwsKCMpmMdnd3L4x7r6ys2INKpVIaHR01Gicy/FxCIIN2+0xXbWJiwlRJO52OaWlJZ01jHDzwcbfZs9FomFYYsNjk5KTu3r2rgYEBra+v2yyPlZWVrlED7J/X69XBwYFdgkgkYoeQgjfwJPM3IF6A7edyOaXT6Qvv35/+6Z8aHJtMJhWLxbq4/a7jIuWXzqDSaDSq4eFhaxIlgAGyHRwctKyN2hay/u7rInYajUb1zjvvqLe3V48ePdLOzo41vwH94ADpLaFXY3h4WIlEQtvb21ZfGBsbMxIJWeDJyYlloiMjIzo6OtLW1tal6i4PHjywXpUf/vCHNq++0+lobm5OqVTK4MFCoWAZ6vz8vMbHxw3apk64vb1tvTyhUMjo6kCIrVZLe3t7Vnsh4KxWq5b9MOQuHo+rVCrp0aNH6u3tVTqdtlHMzJyB1s2wPbIDKNQEUjjhlZUV9fT0mEr18+fP9eDBgwtT4h8/fiyv12t9JdwTSVb/oG+FbOX4+NjQlGQyaZA28i7NZtMINzilcDhsjeXo1LnnAgWTDz74QOFwWMvLy0qn08rn83rx4oUFI+Fw2EaZYFshNY2MjFgQ6ErAgDSAiPj9Z5Myl5aWrCb2umfwtZ0LEAEFT7w2zYVgwlxOogqoqqRoeHoKfHxht3DvUjuBzfjykAV4LSJ96Vy/C/l8GvzQ3sG5uMUuqXugFFkAWD16PLzHRS+3K58DfISxZ79cLSpoyv39/YpEIl2YNZkdmSD7SbbD3lMMdSMg4B2eGcYWRk6r1eqq17jBAEw/2DjS2WHMZrNd6syt1tkMD+ovLj30oheb4ICoy6UWk8VIsiwVA8iZdOe2s19AKrB62A+XOu/SgBl7wHtC+eZnoUpjNHjWGFdJ9lmoI/K83T0Cf+du8Uzde3CRRa0RB8Azdpv2yM6oL7JHwK1oBLrFdHTWqAtwn7i7EBhc+SSXiu9CufTRsG88Q6Jm9tSt9fGM3ECADBD6NPbHRTjedEFYoFVCOrcHPCtmzBSLRUmyO8c548yQhfP8CeR4LensjJLpQT92zyOsOc41zpX7x/eFXMLvcReoN7vv6SoFFAoFI2e4d+wbdy5cBrzewMCARfIUA4kkSbuBoKAMg1Nykbmo5XJZm5ubajabmp6e1ujoqF2uV1e73VYmk9Ef/uEfGjlgaGjIGr5oJgoEApqenjatLjDa2dlZpVIpg5AwyjgsiAbb29tWDKRRiwLmRdbLly/l8/l048YNzc7OqtVqmVorhh95iEgkYkXUSqWira0tO7yk+EAQGH5qARQCC4WCVlZWDIJw53q3Wi2trq5agZDa2O7urhkc6LipVMoGDfn9fi0uLmpqasouKSn56empGc6joyMtLy/bv/O8Z2ZmLrx/GGv013BkbtBBzW9wcNAK0l6v1yBJnCoqDUSTpVLJzt/U1JRGR0fN6GFIgV8gkTx69Eher9cozPl83hhhu7u76u3t1cLCguH+wDFE3X6/v6uzn+efSqXMYcMIPDo6Uk/PmRr0ZWoua2tr8vnOZv4sLS1ZIzHFabfvKhAIGIuJrLa3t1crKyvq7+/XwsKCotGoJiYmTJ+Kovzo6KghBtQNMUhAb729vfrkk0/k8/msrpjJZLS2ttYltAjDqlQq2Zhmsiwi+3K5rO3tbVUqFQsGod5ConE1yS5zBoFaYZguLy/beyD3D7wFIxNjLp1RsclwsI2SLJNpt9uamZkxmSGX8Qbbtt0+0yL76U9/2gVhkxW2Wi2bscTzQW7H4/Fofn5ek5OTSqfT2tra6mIuTk9Pmw3c2dnpgvXa7bZNp3yd9drOhWgO+iIXhiInTUBEddG/HAeLU6LG4VIciR7pVUGyIRKJdBXeXr1Q+XzejPVHH31kXaMYysPDQ3k8HuOKoykkyWTDKYCTBbRaLdPn2dvbs3SeIhdSKxdl6zDD486dOxobG7OOZzIq2Gt0YaN2CtTEoQL2Q2KDzAStJ9hl9AV0Oh1NTEzYPgAjpNPprgipVCpZcRtDPT8/r1gspqOjI2OJcLEw1kjMu6KB7fb5HHVJNub3MvtHEDA8PKyZmRmbgeM27Pb395uMCPIw9ARxgYiSvV5vlw7VgwcPdHp6ar1E1AMlWb0OSjpCf+6CYkuNEMon+mE8HyJBZPVLpZJWV1dVqVQUiURMgh6iBc23IyMjl9o/6fwMBoNBzc/P2zl3HSfZiXQG4SH1QiQObIMcEDAfvTyMGCBIoUbgKnmMjIyoUqkYqQQ5IRw0dG4oybFYzM4od2N6etrYWUic0KeE1hlOBQc5PT2tK1euXHgPOWv0pgEJuxmF1+u1f4Ou7qIr2Wy2a+SwdH62CTJ6e3utb4eeLWp3NFpWq1U9efJEXq9XExMTGhoaMsSHoKRarRokyBmUzgv/UJvr9boF+9iW3d1dg8bc7AvG2eus13YupMMUSF0NrKOjI4uc+fIwwxBlBE4h0yEqL5VKXTME3Ml2sHQYo0wzJbQ7+gagGd66dcseMM4F3Bxnd3x8rNXVVYt6MKREqRgSuubddJQLdpHl9k9wmKhrUBMBFqDTfmRkxLBbDCcMlXQ6bZ+LPeYy02k/NDRkh4/9ozDv8uEZZkXRFtozdYRarWaaUvl8Xuvr6xYkQCog8qWZjKDCLXACy1xkwa8n1adpD9wdmjq9NIwZQJjThQGQZXHnlXO2stmsTZYkW5yamrKaHO+Fk3ad8XvvvWfFbTL4jY0NVatnEz45X0irYBCBxXBE0rnCABkiBfbLOJd4PG5wIaxP+nzS6bSdO+oIPFeCHOjmUH9R/I3FYvY6MBDpq+rr61N/f7/Gx8ft/nN/j4+PLSDtdM7kdb73ve+Z4ClKvFtbW2as/X6/Dg8P9eTJEx0fH+vw8NCosxhgF6oESqSOBDvuIot+LgRxISGUy2W9fPnSslPsBrAyowyAsMh0oHq7fTySTK6oXq/bDKTx8XGDzbCX3KfoXw5+GxwcNNVl+pY8Ho+2traMst3pdCxboYbi8/nMmQUCAbOB2AMXRnwTUs5rOxeiGBquMGKtVsuE8HZ2dvTs2TOFw2FduXJF0WhUy8vL2tnZsebLVqul9fV165w/Pj7uwlGBX+hUDQaDun79ujFU6OugTyCXy5kez/Xr142VAUWVzmiK4fv7+9ra2rJmp1AopHfeeccyAVJ4d2Nd+OeixpFIjIeHEZekp0+f6tmzZ4rH4xoZGVEymdR3v/tdDQ4OGiwyNjam8fFxeb1ea2Ck/oLxgW0Dk2liYkJ9fX22f2iqMYZYkqampjQwMKArV65ocXHRivYej0cff/yxPv/8cwWDQY2Pj6unp0f7+/u2pxjVK1euaHBwUNlsVsfHx2o0GsYO5OCTnV60ZhWPxw2fhg2TyWR0enpqBAw+08TEhH7nd35H0WhUBwcHOjo6sjpbs9k06ifsHkYZE0UDtcF0++53v6tEIqHPP/9cX3zxhU5PT7W/v29MJr/fr1u3bumHP/yhiWF6PB798pe/1L179xQKhTQ9Pd3V8b+1taUXL15oYGDAzh9GUVKXY4EWTN3pomt6etqM7vb2ttH6C4WCHj58qIODA8Pxx8fH9aMf/UjRaNSMIwFjs9nU06dPVS6XjSxBf1hPT48579PTU4NkP/roI1N2ePnype0hTqvdbuvKlSv68MMPrZ7V6XT08ccf6+uvv9bQ0JCWlpbU09OjjY0NPXz40GCj4eFh/fCHP1QikTBiyas1M2zHZe4wumRTU1M2ApoG2s3NTT19+tT0wwYHB63B8uTkREdHR4pGo4pGo2q3z8ZYQO91lZp7enq0vb1tjemzs7Pq6enpcrbZbNYyd8hUfX19mpyctJYBlFGWl5f14MEDC2Y7nY4ePXqkL7/80uptQ0NDmpubUywWs+fm9Z5NuoRMAEJCne111htnLmD8sG3IFIBYXJ0bitU4DreAhWQC8APS+RSQScNI57xer0UDZFAU1yjCYlzcDn9SOtJS0nMyINcrA0O4DAq3EewyF5veEVf/xz1QbuFbOtcUgvrpDkxjb4jIiJYpCCNDAdbbbDYNtnSZZBQ63V4e6Zw0AcnC/fNqAZvXhBGFKjb7ygEmOruocyGzhPLL92k0GkZ84P/zh33gbHBWyarc8wEtl4I/+8q5e5XODQ2avUPuxf094GCXOMAzdhmTnDXegxHTPAv3bl0mc3GzN7dJEuILRW+MPcYE6RIyb4/HY5Ru6pacDfaarI47zXlxtc24+zQ38nM8NzJj7gpOhz+QN4i0Ke4DyXJvXZLLmxjHVxc2kD2kBoNNe5VYwl2ls90lOrHP2DiIFtgnt3WCYBsUBagNYg1Nwe65dolSBEuvninuiHtXYUlyNrhTZIBvcv7eqImy0zmbIY5mD94sHo8b9AG1E4M+Pz+v2dlZnZycmKovTWw7Ozva3NxUKBTS/Py88doxhnzBn//8513DsQYHB/XBBx+or69PCwsLGhkZ0cnJiXZ2duTz+ZRIJCxKdJlTvb29mpmZUTQa1crKir766is7kOVyWc+ePdPy8rIZK0nmCGhuu6iDuX79uiRZ1Ojyyq9evWqSJmimZTIZo3LfuXPHHnq7fSbHjmzGyclJF6vN4zmTlaARtNls6uXLlwYBAe2FQiHrpJ+dnVU+n9ejR4/U09NjtEoaI73es07+QCCghYUFJRIJ7e3taX193eCNcrmse/fumVYRM+aBDaBWXtS5kHmik0TE7fF4dO3aNQ0MDNjws0AgYEPQOp2OxsbGLAIbGBjQhx9+qNHRUR0cHFjt6e7du8aScVmErVZLf/7nf27wDczHYDBoUSwF3PX1dZMGwanT/BYKhaxeBeEAhiAacMvLy9ra2jJMnhoX/WSX6bOSZDPTs9mstra2jIjh8Xh0/fp1U9egML26umrn6MaNG6pWq9bQeevWLctWM5mM1TJ7enrsGdM70+l0jOBxcHBg8vNkc3fu3NHk5KSy2az+4i/+wqCenp4eZbNZI1cAddKT9OLFCyMJAUWtra1peXm5C94GdkR54KJrYmLCGg6h5pMhLC4u2rOmJwRnjTYbGQ706Egk0qVoDgkKB05AUq/X9eLFC+v493q9isfjmpycVCAQ0M2bNzU+Pq7j42MbGTI2NmYQIdkn8jlzc3OKx+Pa3d3VysqKITM+n89QFJy8G4i+qQ18bedCwYgaAG/a6XRsE4ki3MyBegYNQJKML8+FD4fD1lF6dHRk7B4ik729PR0fHysSiVjqzSUdHh5WJBIxgTayEkldWQkbBNMKdQB+Drhkd3fXBOPc7leitItGjhS6kV4gw2q1WlaAHBwcVDgcVq1Ws2I1zA4gJ/abRixwci42QpREd51Oxwwx3eREqURU0WjU+oQoOAMl8BoY14GBAcViMXN0BALt9vkse6IoHLckIyZc1LlgYE9OTkxRoVarmWNNJBKq1+smqUNDqKQurFo6my6aSqWs/tHf36+pqSn19JwNVWKeuySTv0DPCZYQRmB0dFSjo6PKZrPa29szowK+zX9jKIjSXeVvCrTZbFYbGxuKxWJW4yITcOGdiy7qLa6mH+dhaGhIkUjE6n6MLZDUpUUFxXxsbMzqAczwgcjgIhpunatUKtl8Gjcjp6s9n88rk8mY08XZvdryABKSTqct0ifYLRQKymQylhVx1tGau8we0hdEvQrjDclBkhlgnq3H4zF71263tb6+rlarZfcImStIL1CsgfZAMqhrE7AxOmJgYMCIQFDeaSQme8FWQOWmad2VTSKrZHaLJMuweU+QkG/cuZA+u5RL3pwF00A6T1HRHarVaqb+urGxoXw+r1arZbAWhqBYLOr4+Fj5fN7qAjMzM1pYWDBNHeAcn8+nly9f6tGjR8aAkGQqq4FAwPRxGO60t7dnkQebShRSq9UMJkIYkcUsg4s6F2A4GDpkVF6v1yABSZZ+AkFAScUxtFotG4Pq9o5AToAZAwwFf56aEppgiURC/f392tvbM6cyNzdnz7parSoSiej27dsGNfDdT05OrCBNt3pfX59liv39/ZqenrbeCb/fbxDaRRcZBdAbe0G9CTkRaluvip/C8Onp6dH6+rqOjo5Ur9fN6LsZLuQDOpTpJodAAgXe5/PZ5EoCJJhy1A6np6fNADHvCJbO5OSkPXOgRJrWCDhYGNbLwGJANWQgwFYEORi0UCikTqdjRtLv99szh5YvnRlSl62HgQcaJfihwByPx4095jKoXrx4oc3NTXm9Xi0tLVktolqtmiyRO1/HJVbQzMjcnp2dHR0cHNhgPH6Huqt7py+6cM4w1egLks4VQFxZn4ODA1NdAE7b2trS0dGRMXBxpDh1iva8PmcbSJhAr6+vT2tra1pdXVV/f7817WJHXZUPPiMMX3TNyGqwGdQjIVQBiSeTSavbvc56Y+fiRgbgx65k+OLiohUtSbEprFFQ2tzc1ObmppLJpCYmJsy5cKiOjo6M8z4wMKAf/OAHGhsb0/Lysg3boVlreXlZGxsb+uijj/TRRx+p0WjoyZMnyufzGh0dVTwe78KX8co4N/pmuHQUZGFbEP3QXXsZ50LfzMuXLy1aDQQCunXrlsGKOBdSfUZGw5TiNZgbjngjGVb+LwU4ycKCwaA++OADxeNxo4zjXAKBgDY2NpTNZnXt2jWbVPfy5UudnJxoZmZGU1NTXew06XykcS6XUyAQUDweNzIEDXlTU1MKhUIWPV3GKErnTpciLgvmEREbmQXvx2fGWXc6HWO7MdWPv+c80EewvLysQCCgu3fvKhaL6fDwUEdHRwqHw8ZKe/r0qXZ3d3Xnzh298847XUKPU1NTmpiY6AqyKMYCP5IxE3z09vZaVE+2BkU0kUhcqu5HzYpCdDAYNIeL2gKZARErWRMZYy6XU7N5NvwL+vz4+HhXjeTw8NDuP/1PnEEYi25j8osXL5TP53Xz5k398Ic/VK1W04MHD3RycqLFxUWbIssdIlhtNBqmlwXbbXd3V+l0WqFQyBhqGHQypMucRaBZmF3sK5lsT0+PDU4kmMPhurVWnCljn1Gf4Dycnp4ql8tpa2vLbMTQ0JCpaQBT+f1+PX78WHt7e7p7967u3r2rarWqTz/9VLlcTqOjo0omk5bNYItxLvm/nGoLQ5daFa0FwHLtdlvJZFJzc3PffOYCHx7mgis5QjrsFpWJKil0YXRIeYFUDg8PDccGr4WFBNuJbmIMLGmwdK5nRTG+Xq8rk8l0KYFSv6GhkMizv7/f6i0U5zDgYL38XLFY1P7+/oUvNyN+YQ4RlXAgKfLBCGF/3KI/vS8UfFutMy0hvic9GO322bx3HCQ0XrqokTdx5SRw6kBFMFyoD9Bsx+8zI4NiL0EGLDuwYbeoeJnucuonMJm4CDgvCr6MG4DJCDzoFsaJztrttl0ufo6MaHBwUAsLC+rt7TVNN+i2rtyMq35Lxnd6emoBDY1tXF5Jdt7pQgdm5jPW63Xt7u5a7QWVaxCDiy76nlAJd0kzGG0yuXa73aWRRkYzNzenRuNMJp5Im14M7j+ZMgtHQi2H2ol03oXOPtKrdnR0ZGxSshiaNJFfGR4etqwep4XtaLfPxjkjFNnX16dyudw1V+dN187OjqENyWTSHLJ0ToJx6bzA7QTCZIlkeNSJkA1yJ6vCApPUZVsJPshEvN6zeTiMLSDryWQyZltjsZgFFK1Wy95jeHhYV65cMYfoqp5I5/dEkvUR7uzsfPOZy8cffyyfz6dbt27p3XffNWEzomw6jt30rl6va2hoyPotYMbgBHZ3d7W8vKzoX8pPo6dFb8GdO3e6qMXIVhBpsQHQNLe2tlQqlXT//n2j6THuF+c4PDzcNU60WCzqiy++0NHRkT045KzpqB8ZGVE2m9WTJ0/U6XT0D//hP3ztA8laX1+Xx+PRwsKCvvOd76hQKFgTJRFNX1+fRkdH7ZJw6TqdjqLRqBYWFszh0Am/sbGhRCKhubk5i0KhDl+7ds0IBKenp6bRRGG10Whoa2vL+kDC4bCazaY2NjZMZ40M5enTp2q3z7TOqDN88MEH1l9SKpU0MjKiyclJDQ4OGn9eOmeh0IF8kfXkyRP5fGeDqxiNvbW1ZVBSs9ns6nBfWVnpaj5jBgsFWdSBnz59anNewKZbrZYmJyf1ox/9yBptYZWxOMO5XE6Hh4c6PDy0AVrb29vKZDJW18rn81pbW1On09G1a9c0OjpqRg8Nr0KhYAbo6OjIBtn9+q//usLhsA4ODrS/v692u63f+q3futAefvHFF/L7/Xr//ff1/e9/X4VCwQr7BF/Qs+l9QVGaxsWrV6+qVqvpT//0T7W5uWmGDYmi/v5+Ox/Utmq1s/Heh4eH6unp0ezsrEF0ZHXHx8dKp9PWpvDs2TPlcjlzTEdHR3r+/Ll8Pp9+8zd/U/Pz81Zgz2Qy+uM//mOdnJxYLaJareonP/mJgsGg/vbf/tuKx+Pa3Nw0MtI/+Af/4I337yc/+Yl8Pp9u376t7373uzo5OTFKOpknNUyC6EqlYnXnwcFBxeNxy7SoQa2vrysWi+mjjz4yKBKFEWq1KAAQyHm9XgtY9vf3tbu7q6GhIS0vL+vk5ET37t2znh6y7ufPnxvMS+sGmeLW1pZOTk7srtC24fV6LcDe2NjQs2fP1G639bu/+7t/4369tnNB0pzsxaXNuti2JCsAk07BfCCFJT1DP6yvr88Kd8A7UO1c2p/bIImR5ec5pPxx1ZsldUEe0CbJEogo3CiYBikiXLcL/iKL16NexAAg0mH2gz/QAMkQ6QUiGwSGcOnUfC96VYaGhtRoNLpk+XlPt6uYovzJyYlFUwhQuioBQBNETMiX5P9Skp1z4fF4LErlTPB9Lrt/krqeFc8VuMGl0rI3nU7HImocHc8V8gMifdBXiebc88e/cR7cRmIyYJcm7RJKXMo29UqyVv6Xv5PUJWSKoSIbu+hCZJKA0KXouvpVkuxMuOOL6Zgvl8smZ8I54gxDAqF2BMRGhiGdK264Z96tnRHYkA266ARZFkEFRAIQDTIDzrML1xK9XzTAYdgW7/1qzZm95NzBpnVtGpk1tSueqwvfuQoR3LHDw0M7Q2QO0Lr5ewhSNKZTe+WzuZ8LKjgBaSAQMBvMHhPkuijRm9jAN+pz8Xg8evnypTUAUSAiTZuamtLMzIxF5bBLMpmMUqmUbt++rWazqbW1NWUyGbVaLRvwxVRFLiCHol6va21tzbwq0xN3d3dto+PxuFFua7VaF0NjYWFBh4eHRpfd2dnR1taWRkdHrTiVSqU0Njam58+fG5MlHo/L7/ebRPbAwICNeL3IonnryZMnevnypaWunc7ZyAKYSi9evLCImGg8EoloYmLCRp7CLALz7unp0dramtW9kHp59OiRKpWKdTNjvLj4pMZcSqAnIKaxsTFdv37dMhucCkqvrjYS0KebSfr9Z4q/jFwACrnIYoLf7u6u9vf3Te+MwjNQAoZpd3dX1WpVOzs76nTOVH9HR0etgY3LGo/HTUUAaBa22ccff6x6vW6qzy7Mx6Vza05Pnz41Iwgl/urVqza/hGmfx8fHGh4etpktKDdj7MnMgd8YssaMoYsuHOPTp09tmBoimzD++G7sr1sHQM2XTIffwWhxxmElHR8f6/Hjx3ZfKebjyOnTAL4EjuZ1oXXPzs4a/k+wlMlkjCUInX9mZkZra2va2dkxOApaf09Pj53JizoXaLgrKyva2dlRvV43Ziv1KTLR09NTywoJGKJ/OSa6VqtpeXnZzi+ZzoMHD7ruMKtcLuv+/fs6PDy0plVsJHtH7RC4EkWIVCqlqakp9ff3G2SG5NDh4aF2d3fV09OjcDjctccoQkCAoL0A0tTrrDcSriSdQzoEz03kgAFGyuD4+Fjt9pmmGHphpIrUROgmRyabDIiI6PT01FLk2dlZzczM2N/DVAFjhb7L50UHjQcoyabekTkMDg7aLOrd3V1JMg0d+PVkAq4xfdNF5IvsDZAT+C3zvdH6cQ092QaUa3BuRsVC9eRZRKNRq+mUSiWDvvgOQDIuPk2zqtvkhTAhmD96ZdRpmAFPzY2MlUzH7/crHo9bhDQ2Nnbh/aPJkXoaUS5RltsLUq/XTVoE9hxwA30ee3t7JnSJRLz7vA8PD7W+vm6ilqVSqQviJXLnuzWbTQt4aHYMh8PGMCTYymQyNmGUyBtyACxJSRal04MA7HzZ1W6fDSB7Vb7fvTdE0W6TJeeV6JrI1v19nAYIQzab1fb2dhdshJOllsV3BCVgb8hCgZIQwiyXy1pbW1M2m7W6B7NkYLXBYsSoU9vE+bnw5psshCMzmYzVyajVcgeYQ0XRH1tF1szdbDabJrDL/ByeydzcnH12esw2Nze1u7urmZkZa8akJkZGBFuUckBPT4+N+W632yYInMvlrJaVzWYViUR08+ZNq7vwLMn4JJk9QCnjddYbOxeK6fQX0DxFsxcG/vbt28bIYbodEJCrAEothuyHQ0ETpt/v1507d1Sr1cwwou1EWs3r4PCgozYaDT18+FDVatUK4rOzs8ZuwZBzMOCvA+GBt1N3ADK4yOIigyEzF8Xn89nlOTk5MdHA+fl5+f1+pVIpxeNxDQ8PW22DIU1kMdAZXUaZJLucS0tL9j2J8IFvcGhw2ImCgE0ODw+tp6Tdbpv8T19fXxc3HqKBmzXyHCnSkm1dZAF/8Z5kDDSfUScA5lpaWrILKkmJRMIgLs4W0TbRLBlbMBhUtVq1CBLJDjJn4AEXYqAQToZBZrOysmKBENAm+4K8PAYK6Y1Wq2VRMsbpsn1C0tnMEWpOpVLJRFBx0O1227Jo6nZu304ymeyiLANBEeSxOIcEMPwd8JgLz1CDrdVqGhgYUCQSkSSTRmLOi8sQ4/PRwwWC4vN1i2xOTk6azYHteBk6PFmdq9IAI5K5NARnzK/y+/0aHx83QU3YnDxz4DqPx2OBGPRqqPeS9M477+jatWtWEyNrQvMQRyOd2ZiJiQmDztfX143MBEGKe0Smv7W1ZfJO+XzeCDtA3TwDAvBvtOZCCsuF7e/v19jYmLFqhoaGtLm5qdXVVSUSCf3oRz9SIpHQyMiIIpGIjo+PtbW1pdPTU9Pjcdlm9Hq480JI+d555x0Fg0Ebc4xBBeOFaYPRZtTn6uqqfvKTnygcDltnPkOhVldX9ejRI3Mgfr9fOzs7lnrioGCwZDIZIwVcZOEAYb6Bp8KLDwQCZugHBgZsDjvMGHokaIh0MWgaqSA+uFExYnYcWJ/vbELfp59+agyxo6MjxWIxK37Pz88rEomoXq9re3vb6k0ez9nYAbIsqM27u7sqlUrmPIaGhnTt2jV5vV6tr6+b04b3f5FFbYOMZWhoSLdv37ZZ3+FwWC9evNCjR48UCoX00UcfKRaLKfqXStf0TdF3gSGg8RaHTOYnyfYxlUpZvavVaunk5ESbm5tWfwKCwUGPjIyot7dX2WxWX375pb2f3++3KBK42Ov1mpbT4eGhXWyMPlnsZYfVSWdjelutlnZ3d5XJZJRMJnXz5k1jyRF0QHP/4IMPTBsOWBRDRs3SjW5ZOFqYkdBa3dkj+b9UNkfjDydPrWt+fl6hUMh61qj/oOcWjUatqZuI3ev1Kp1O6/DwULFYTFevXlWn09HXX3+tdDp9KaaddF4rIpBlCBgS+n19fca8jMfj+uijj2x4WCQSUTab1fr6ugW1PT09ZuRDoZAmJyetf49nX61WNTAwoB/96EeKx+OWdVSrVSvyo/zMc+jr69PU1JSCwaCy2ay+/vprRSIRQ2hwkNvb21peXlaxWLQAcW1tTYeHh5qdndWdO3cUCAQM+eAMtlot/c//8//8N+7XazsX6bxgzAd08USiMTYe54DoHawSMg56VTCwLsWY4q0bYRLlQNHF+7v8clRcpW4dHf4/kBwFMLqkKXa5URqFVlej6jL8eH4X2AQoEEYTcjVcPv5I53RrinQYNZgpbr0AXJt9AAN39cswbkiY0ySYSCQssqZ4TVSPMSaShnUCiw+2G/vHs2M2CJTXizpnnj1GDWorz8g9U3xHOtDZN4gewC5uxzdEBIq+BDBogBEFcj55DjxbjCl7BwzKa/DscVDsqfvvnGPqPkTHrhTIZejcKBQQ6JA1sGegE66YpEuKoBkZth1F4VfrVUCTIAKuBhjngvqYO4qAqBqNLKBxV9uK/a9UKl0UXZfsQXMhz4K77NJsL7J4f9cOcQYoC/B33Bu+N8V9IHH2iACQwASFEYrpLIIqCAJu1uHuH6gC9TvpvNTAWSMgarVaFuxyNtxx15w9SWYPXiUx/JfWa+80FxIqXKlU0rNnzxQMBjU2NmY05OHhYfX09Ghzc9PmR/DzDPahE35qakrvvPOO9VZQyC6VSorH40qlUpLOBm3hcLxer3K5nB4/fqx6va7Z2VnF43GFQiHNzMyo1WpZUdDr9WpmZsb6GVqtlsmMx2IxLS0tqd1uG847MjJiBpLolQdEF+1FFw8biIj+BqISFKOJrGE0HR8f22FiLg2NYlevXtUPf/hDw19rtZrW19dNgoWhV9RGksmkksmk0um0nj9/rmKxqKWlJS0tLWlubk5379616CWbzSqRSJisBPAD/7a0tKQPP/xQ9fqZ/tjJyYkODg6UzWYNm5bOZG8Y4AVufpEFPDA0NKTR0VGVSiUrgFYqFY2OjqrRaCiVSqmnp8dqM+wLNQQygVqtZiqyriFdXV01qSFo4ffv37fJn/Q8ra6uqtls2iyNaDRq8CN0UOBBIMNGo6F0Oq1isaiRkRFNT09LOm9QjsVidqEJ0uhfAka9TOby5MkTCxiAgXd2dtTf368PP/xQ4+PjXc2kDO6iLpXL5bS5uWnwyOnpqcbGxqwRGkhrdXVVBwcHikQi1hXPtFKCj0wmo88//1zVatXucDwet5rq9va2Sc0AHRIsrK+va39/Xzdv3tS7775rgRpBoyud02g0bNQAdOCLZjA4QoK7Uqmk/f1900ZEz4tACpLN8PCwwuGwtW+cnJwonU7r6OhI7733nj788ENrtKxUKlpbW9Pu7q7Gxsa0tLSkTqejL774Qq1Wy+zT8fGxXrx4oVqtpng8boMGb926pXa7bYoFPt/ZWGg00KrVqh49eqS9vT2lUildvXpV7XbbxlfEYjHNz893FfYJvOm5et312s4F+InIkb4FUmkob+DO7rAoqKnFYtGYIDRTMQsC6jApHpeKRkGKYuCFRE80MZFOk0qenp4qHA5b6g6ui7YXxVwKphTD+Q5E6lxyVzX4IsulX/J5YOMAD7qd7MA04Mx8L5cmDAQDVRFaI+yicDhsERKGitdhT3t7zwYTJRIJjY2N2eHm2fG9aQwjSGg2myZzQaEZBhERIzWMnp4z0UB3POybLjITGkYp2sNKAnJB04xIDIVXDJNLwe7v7ze2EY2pQKDUTlqtlhXaYb0VCgULVuiaJwJ1YQowbvc7cG+os0nqgjPcCN3NxDD4l3EujCWArEIDH4rSbt2SQAiGGeoZQDFE0dxjnABFewgp/BtZJ9E60HitVtPExIQhIjSrco5h8vH9ua8U1Dl73Bdqlm6GSEaGIsFl6n5kr24WT2ZAlk4vWbFYtGyBZ8/dJfuilkXPS7t9rkJBkb7T6ejo6EilUsnYYuxxo9EwyDEUCml4eFj1et2mSLpZHKjJ0dGR0um0hoeHjZVGCQI7yH3BrnPGIbK8znpt5+KybZCjoBmKKAf9IeTH6TDmQmJI+TIoLFerVZv8KMnUkQ8ODuT3+022AdVg5jJUq1WlUilj8NDPASOLFBU11E6nY6NHG42Gnj9/3tX7Qk2ESJaHgdO7rGQ8lwGmzOzsrKWky8vLdugoIvNzRMvsRyKRsM+2tram09NTra6u6vT01Ci4NFoODAzYJErgzFAopGvXrqlcLtv44+3tbZOqYH/RP3Ipq6FQSFevXtXJyYn+4A/+QFI35MeFAMLJZrPmdFzFgTddRPnAoPF43DB1iuNkfq5KdDwe1/T0tGmScR6IQDOZjKrVqs0WqVQqxn7E4M7Pz0uS6eC5op2Tk5MmObO6umrO3O/3m2ODtcb+UAcCXgQeBTZymU4u+46el4suomAXYgTOyufz1nhK9kyRmnuBA+c5wniimZr7DcVWkj2foaEhg60hluCgJiYmFI1GdXJyos8++8wcmStTQuDEHaYO9ujRI4Ms+UxE+NFo1BhoQKMEHRdZKHMPDQ0ZksM+oiqONFIgELDaG02LIDgw/8gY7t+/b2cQmA2SFEEk0ySjfzkTBhmYarVqiur1et1Gm2cyGdtfIEwYe8FgUNeuXVO9Xtef/umfGv2ZTA+yAfA29pCz8brrjZ0LuNvg4KDBBg8fPtTm5qbBNqFQyFJTZMY9Ho/RQ4lA6E6tVComLzI6OmrFukwmYxsBpQ49LfBaag50y9brdTuYHEhgid7eXl27dk2Tk5N68eKFnj59KkmmtOxCNxxSDBaRxkUXHp9CIPsHNfTg4MB+lsvb09Nj3c5MpvN4PCbxXq/XjVr94MGDvyInDga7sLCg4eFhKzZCwuAgo5awsrJiEQrsJb7/6emp/P4z+fBkMqmvv/5aH3/8sXVco1AdjUYN1oHRggLvZQzj1NSU4f7U2sLhcFdmSz0AWvLg4KDm5uY0MzNjAqBI/9OoitbX2tqaqtWqjcamdtDf36+5uTmLwIF4cBowgfL5vDY2NrqafWFluVI18/PzSiQSXbJD6O+5kBVd0vTIcOkvs4fz8/MWBReLRQWDQcXjcctSgFEIDkAOOLM4FwwrmSy6WZlMxvpzXLqvz+czRXO0+2hQbTQaBiVtb2/bnURsEQPKWfL7zwazMZ762bNnlqVTl6K+CFWZO1KpVLoGc73pIoiQuuvPjUbD9BKpLUPbxa5g07xer/0dzD0gfrJh5KlgZPr9fk1MTFhwTQsCzDP6vBqNhtbX1y3AJvPA/u3u7srj8ejmzZsaGxvT119/rV/84hfq7+/X7du3FYlELNMiS6HGQqZGy8jrrNd2Lm5RDx4/KSC9ELCPkNEeGBiwRjYUevv6+jQxMWEsC4xuPB63yI7eCQ6MO7gG/B9oA/l1CrT8LhETlxwohx4NipZcHCTSKXIDiwEhEb1ddLkwF7RAMi5YI8CDHJ6BgYEuhhwXF3zX5/PZs4DtBTyBJHowGDRjSlRNzwLqCBgDdMEikYh6e3stjSdrwjBheMmGqKt4vWc6RxA1SOnr9bpJoVx0UcfJ5XLKZrM2xx3DwgWCbZVIJExDDTabdAbvIU1CdkKkC/MOSixzWSBF4AyIPiUZAQB6tDu4Dtg2n89rdXW1K3vj83LWPB6PRdbg6tBooZlexrGwqM/l83lFo1Gjy5Kpu4Vm7miz2bSmSxwE7DF3AV8BxQwNDRldHLpzPp9XNpvtatyEXNDT02OjLmjoowDO6F8MMhk3zjgSiSgQCFjwQIblqg9I57DZRRZROzYQCSnpjOY9PDxsasRkqDQ08xxxMIxK5ox4vV5jEgLbhcNhDQ8Pq7e3V6enp79SE4+sGOYotSao3OiI0bZBMEaQQEAN5EuWB3oiyWwANuJ112s7F6CW/f19ZbNZXb16Ve+99541x0lnwngI7k1OTsrv9+vLL7/Uy5cvFQ6HbS7E0tKS+vv7dXh4qIODA3m9Xkv7qDGgjVWpVPTJJ58onU7bzAn6E+joPTk5UTKZ1MLCgoLBoBWwgBrW19f19OlTg98kWY9BIBAw+fn9/X0dHh52NfwdHR3ZmObLqCIDaRSLRZ2cnFjncSQSsah4d3dXGxsbRqf2+/36yU9+ogcPHmh0dFRXrlxROBzWhx9+qKGhId2/f1+fffaZenp69M4771jTFAeGBsv19XUb6cyAJ2ig4+PjGhoaMkl0ov2BgQFlMhnlcjmtr6/r4ODAeju4BOPj4wqFQjbmeGtrS3t7ezbIiMNMwydiiRdZfJft7W19/vnnunv3rn7t137NhpJ5PB6bReLCcsvLy3r48KFCoZDRqK9evaqBgQGTKqcvwev1mkbW6OioFhYW1G63lU6nVSgUTEOMyDMQCJhuHQQK+r5g7Ph8ZwOY7t+/r0qlotnZWWNpHRwcGPW7v79fq6urpuiLc4HCTSB2GcYiUCrP9J133tH777+vaDRqEv8HBwfa29szJyxJv/zlL/X06VMlk0ldu3bNRgIEAgG9fPlSz58/V61Ws1oNJIdwOKyRkRFJ5xqAm5ub2t7eNhovTooggVENyWTSgoNyuayHDx/qL/7iL1QoFBQKhcwgU1edm5tTf3+/Hjx4oI2NDTUaDc3MzNidOzo6Ml3Bi9ZcSqWS2u22qYlMTU3p+vXrGhgYsNn1uVzO5sww7+bJkyfa2NjoagjlLm9sbNhQNgIyHMn4+LiWlpZUq9X09ddfK5fLaWRkxIYjwmrEFg4PD2t8fLxr/1z69IMHD+wZ5HI5s7PhcNhUzJ88eaLt7W2zd9Q0t7a2lEqlNDEx8c03UUrn9RawRlIuIl7wW1djikiPL4r0yODgoGHXRO+wGYDOXF0q2BkUi19txJLO6dDAWhRK3c8MHEKxmYI1P8OiSMffu1S+iywu3qvUVGojwWDQjAisNGiXMI94HdJsMh5JVsyGjeNSYt29I2Ih6gF/h+766v6+GjED50AbdXWdiBJ/VbOpS6u96P6534nP7NYoqLcQvXFG0YTic7DfZH6S7PxJMqdINE/UyR+aDSnU0oPDmYFqDmb91y2XJu8+h1drCNRi+P4XXS6d3jUQPp/P6nMnJyd2L8ioQAtoiiQzBSrjtUEhoPzy3cnAoHBjpDnTIAgubZhMG/tAbZf9Irvi2XNmXRvF/ydqd6m5F1nsGc9I6iZjQHQisOA5Qht2pWdcEV63KfPVZtNX9w9nS8bjUp3d88Pvu+cJJAcbiC2hzvzq2XLt5q86Q3/Tem3nwgGYnJy0AUhff/21ent7lUqlFAqFtLGxoZcvX1oXvTsqF/hFkskj7O3tWWcoEBGzMPb29iwNRjTzVeZFp3M2wha6JE1MP/3pT83LI7SH4YVjPzQ0pFQqpUqlYvTK4eFhzczMmIFoNBpKJBKG5cIMucianp62YiCyJT/72c8UCoX0/vvva3x8XEdHRzaKGOotBWVogH6/34rXW1tbWltbs0MaCAS0t7dnMhzuoCT2ncyJyNvl40PXJcLh/Vuts4mYbt+Dm7Hu7e1ZDQ0mXDqdNmcKRfXo6OjC+4djmpubU6dzJqPx5MkT9fX1GemB2Tco41JALZVKNkWw2WxaExujBShedzodk3yJRqNaW1szpiNwBsb06OhIkow8AKkAin6xWDRlBc4WsBsw5tDQkCqVilZWVlSpVBQOh036Awwd58a+XmYBF9N0GggE9LOf/czqmvF4XEdHRzYIi/fb29tTLpezZlTqAn19fdZcDBTj8/mUzWYNwYhEIl1UV+DrTudMhoc9pXbB3BtmClHHA50YGRmxCB92WbPZ1IMHD4y9NjMzo3A4bBE9jr5UKmljY+PCZxAV5vHxcbszL168UCAQ6FJPX1tbMxidvpLoX8r+E+wxOIwGY5/PZ4QmuuRdtYFqtWosNPq1kHoh2IQsVCqV9NVXX6lYLNrsoXa7bdMwcdpDQ0MaHx9Xq9WyLv5AIKDr169bFtZsNq125PF4dHh4+Nr79drOBY8KjJPP57W9vW2RIxBVOp22egKUNreJTpJh+YVCwUQRiXIymYwxHagx0CvzanFJkuGeRDzValVfffWVNjY2ND8/r5mZGYtkMVDQUJPJpPL5vB4+fKhcLmc0P6jOzWazq7j7Ksb8Jmt4eNguVrlcVrFY1Nramvr7++0yoLsELkrGRB8PsAg/c3x8bDAeIojoHpENwlrp7+/v6vkg4nOjPtg/jx8/1uHhocLhsFG2JyYm5PP5bAw1tRYKua48B1RcSV0GmS7/iyzODjM8ms2zoWkEC8B96XS6a5KoG925TZAuNZQsB9LJwcGBOXpwbJg6kUjEmnjJfhkVgWbe/fv3tb+/r4mJCet9wLjg8N1s9fDwULlcTteuXVMsFuuK0N2M+zLyQ5LMqMNEKhaLevnypTWSUjQvFAq2J5Ks+Zniut/vt+wDkgijh+kxot+JQAhVCfbQlTZxqb1Mefz5z3+ug4MDTU9PK5VKWR8Njc5E+jilnZ0dnZycaHZ2VqOjo9anQWbv9/stA73oIkjiex4cHOj58+fy+/2amZmx/XNnD3FuafZ0m8AlWSOky1Clrogzpv2Du0oWwzmGhELwXKvV9Pz5c+3t7Vl9MRqNdsFc1WrVSEWnp6d6+fKlCoWCCbziANEpCwQCVlN/3V61N6q58EBDoZAajYYxqzhoPT1no3JhKfX29mp0dFSRSMSiMbeACWuErlrYSMwtwVgxZW5ubs70d2DP0JQIW8nj8WhmZsbmSsA64b1RnCUShPWDYaXRE4YTxpAaxkWNYy6XkySLuIjqfL6zUbmI+aVSKeuFwRASkVEALZfL1iuEE8cAMhmQSZRgsz6fz2ZtQ2t1O58pmPf09Gh6etqiUFJnIu9W63wULxcHkgCvCYOIVJvvSnZ6kfXixQvDz4EYXP03ejiIsti3eDxuhtzNXHEmkDl4FjMzMzbdk05qBAgXFhYsk+V7dDpnEjI0Ofr9fl29etXUDgYHBzU4OGjNhLXa2ZRWoGH6ayBDoM1H1N1ut23AHY7poouoE4dFrYIAzlUjJvDgPlHghc4ONMUMIheiGh8fVzweNxFJdzZMJBKxCZywEd2Cfn9/v2KxmN555x0VCgVDHCAJUQdFV4u9InCioM+dcxUlGDB20QVb030GkHwYZdxsNo02754R6RxSAuKUzuFe7pTPdzZDSpJJT1UqFWPiLS0taWZmpqt3SzprMsZ5+f1+a6CmTj0wMGA9PsjtuHuH3iPQPFCoG+AwYfYbh8WgAfKB8bCwYfL5vEZGRixTAMZCuh5jDmPM6z2THXGnJcIki8Vi2tjY0FdffaVSqaS1tTUdHx+bh3a7dZHSTyQShvleu3bNCuIutVOSQSLlcln5fN6aMeHU0wCKjhODnSgIX7QgzRTLeDxuLAzw+rW1Nb148ULvvvuubty4YUVwF7rBiMFKIqvDmOIIpqenlUgk9OTJEz1//tyaAmu1mn70ox/p7t27Bj2AgUO5heJ79epVe+YQAVD3lWSdzuwFl8DtDUJRIRwO2+9fhhDx5ZdfWs0ORhsCkbD/hoeHNTIyYn0SkA7i8bhlU0TIOBcGXMVisa4i9u7urp48edIV1UEPxeG6NGhIANwNgh4gkfn5eXk8Hj169Ej7+/umG0dm5fV6jQHkZn6hUMjIFu4zuMiCikqUyygHn8/XJWfjZrUEfLdv3zaHK53T5QcGBjQ1NWU1O4KYwcFBPX/+XMvLy9ZDUyqVdOvWLV25cqWrtwhj59oExguQBSE6K0nZbNZEXOlbgpFFzQhkxK1nwY676B4CW1GLoGes0TgbutdoNDQ7O6vr169LOtfDcxtAyT6BmdxaNdD+lStXND4+rqdPn+rP//zPVSgU9OzZM52cnGh6elpzc3NmSwlIyDaBxKenpw2x4A92hxHNZFA0pRYKBbMtBIk4K6/3TL5/bm7um3cueFVGilI3oKiMF2SiHgeNFJIU1S1eIfhGPYeo3O/3G3XZvchEgS5EhYFzOdhkR1K3nhMPU5JdbiJrjCGL6MSV4iA7uMgCGqpWz9SBiWZ4XbDQfD5vlGiMNIcUh+JKbZNh0IMAbbNSqVhUVS6XFQgETMMIqBI4gsPDHri6QjwXLr8ki7LIRNg3d5+AMHE2kAguun88N5wDxU7+TlJXtksUTlRGduU29/n9foNU+X2yhWazaRg5kkYwk6BXsyCugIEDG3APpHPDxHchii6Xy9rf3zcI9K8jjnCXLpO5uP1HzWbTshUo2a6eFc/crcm5ASIZDgaWewYJgbtO0X5kZMRqT4zZ4Gcx1PQh+Xy+rnqhS7TgZznPiUTC5uTAyOTnent7zS6xv5dh3LH3GGPOoHvua7WaDQJjuYVxfofghv1zSQsugsJeMKrcFfblfHJXeQ9IEO4ddN8bR0PgRwsIz5/z29NzPnbefb3XPYOv7VwWFhbUarW0vLysn/3sZ4rFYlpcXLQH2Gq1rAkK6AyvTCREbYWmqeHhYc3Pz1sTGzOagT38/jPZ7rt370o6k51eWFgwxwZmjjHZ2NiwaJn6C6wIHgLRweTkpBYXF3V0dKRsNqv9/X07eBxcHsSrU/susubn59VsNnX//n0tLy8rHo9rcXHRHCx4/89+9jNJ+iuHkwvu8/lMtiUUCumDDz7oMuBQCcPhsHWwY/Ru3LihiYkJi1JcccbT01Pt7Oyop6dHqVTKIE+3gEhBur+/X9PT0/rggw+UTqf11VdfKZPJ2MF3nRKFR4zVRTM/5OIZ/Eadw3X+LiaMoWHgEXtIcdfvP1M7vnXrlsrlsra3t7tGDiM575IIZmZmlEqldHp6qu3tbRO0RM7EJTFIMjHVVutMs4x/SyaTmp+f1507d3R4eKi9vT0bhjc8PGzUXCAjol0Xw7/Iiv7lUKq9vT1T/2aq5KuBE98Lx4mRpt+BjD6ZTGpxcdEG8VWrVRsx7vV69f7771vQ2Gq19N5772lhYUE7Ozt6+PChCoWCQWrFYlGbm5vy+/1GpeX+ImnCPkxMTOjatWv64IMPrKmVNgNUFtDrQ8VCkjGjLrLoF3n+/LlevnzZpcMFZH5wcGBEJyBU1yhz37ApKF6gFlEul/X555+brhr9J0CCd+7csTre8fGxqQNQwyGoIogiE3bluVKplJEA4vG48vm8zXYByUAWivNHMMGZf531RpL7pMX7+/sWSbqRTrlctj4AGCWNRsMKy3hUDA+du0QVFP5Ig91pkEAhrrfmtbxerxWS+Xk+k9v8iXHB6TEzHs0yHIdLq3w1IrjoQhONPgP6GMjO/H6/FUcl2eHDyQKhcUBp4qLvh0yPNBnnQ8QLw8vF08l43E5ot9mKQ4phISPkTzgctkZA97vwuYGNgN9c3v2bLpyJS291sxBJfyU7kc6bV1kECewDRVrqXIwSQF2CvaKgTwBCJsb3rVQqKhQKXYaDPaa+0OmcT80kcwHGcPF47gvPgkj8TaLGX7Xo/eG8wCzCmHCXpPNsjH3ld9gbgggiaJABggjYb66BgkyAc6cwTeDJPkF6IQvBNrjSLZw/YEwo8SAAUKuxOW7Wc9EAx82ujo6OrPGac+/1ei0TBepy1aJdBwM1mGyYPW+1WhbwkuW5d5ag3WXPus/NhQGl88CUAFySZUL0vUGIIVAn4MAR43BADb5xWGx7e1vSGaV2cnLSDEer1bJmHopMwWBQqVTKZpH09/d3CQLSqf3y5Us9ePDAshn6JpCluHLliiRZbWdlZUXb29umoUVBkS5UJGoYRAZdErG2VutMzwzGBB3RxWLRfiafzysSiWhqakrtdtvGkU5MTJiW2kVWOp2WdJbB0IgEnx+YEUNFdzOFcNh5SOTAda9Wq0qn09Y4SjROREQAIJ052oODA+v7WF1dVaPRMGqn33+uWUYE7jLwIDgwP+Po6EgHBwdd6gfb29uqVCqamJjQhx9+aOdmd3fXIvaLRo1E8xMTE0aFx4Gh0sDlpWObf3cdhwtH7u/vd9W2uEA4TyAttK2Y9lksFrW+vq5Wq6WZmRklEgmFQiGr7ezs7KhQKBhJgIZJOso9Ho+JQBJpRiIRg1uY7QE1GiHDy0TdkswYTk5OWqOnK7XEiG8cBwaRWtLu7q5114MerK6uand316DSvr4+00oDemw2m8pkMnZuNzY2lE6n9fjxY1UqFWvCRYap2WxaMR77QYHZhS6haTPzhTpwsVjU/Py8IR4oDsdiMcu8LrLIjFKplN03ahQ7OztdQ8/oeh8YGFAikVA0GtXR0ZE2NzetVkXT6vr6ukGlyGXB8qTOBM1/ZWVFmUxG+Xxez58/V7Va7RovwP5Q88OxUTbwer1GNWfUdq1WswmzNEJPTU1paWlJkvTo0SNtbGxocnJS8/Pz37xzyWQy8vv9unHjhubn561T2h3mw0Xu7e3V2NiYSZIEg0Ht7Oxoe3u7C1ra2NjQkydPFIvF9OGHH5qcSG9vr3V0EykgpJjJZFQqlcxYX7lyRclk0uClWq1mjiMWixkPnmIp3tllm1DfyOVy2t7e1tzcnMbGxtRqtfTJJ59Ydz+R7EVWLpeT13vWszI1NaWjoyOtr6+b/DYzwSkaRyIR6yWJxWJ2sckQ6/W6CTHG43EjO9CFLp1HQqxsNmuKBpubm+aAgUWAZJieSC8GEicuAeDg4MDGslL4S6fT2t3dNcFNMOiDgwOTW7no/lGvoUu4VCrp8PDQ5C9QRuYZ0UEO9VqSFfmlM+fCxXYZjBhE13mdnJwYRReCxebmpiQZ7R6q58nJidbX15V3JppSE4DBhvFMp9NmlEOhkGnMQcrwer12RgiULpu58JmJfAkeNjY2DCqjlkJdJhaLmRQ+0SuZbCaTUbFYVDQa1e3bty1wdDMF6awv6Pj42FCPo6MjYwCiisx8Inc0N6wnGFNA3QRZxWLRCBTtdtt6bOiPIcuHvAOr6iKLwGp+fl6Tk5MqFosGae7s7NiYAe4iNeJUKqXx8XGtra1peXm5q27EwK5oNKpbt25pYGDARD6TyaSmp6fNmddqNYNvj4+Ptby8rGazaXp/oAw4EndMBBkJMHetVtPIyIgFMUhs7e/va21tzVCRTqejra0t3bt3z2RhXnf/XvumE1kzn9pVP0ZFlTSQCISsBkyPNA79L2RCSF+BtYBv6OeQzguapJBMBuSLQkfl8nY6HdPPks77TDiYEANQEGAuAqqjPAjYR6jfXjRyhMt+fHxsBAcKeURnw8PDNkEOVhKwEo2PLixD+h8MBruos6SuLt0Rlh5Rzu7uru0T0AM/586jx6Hh7AggiJRI73t7ezUzM6Px8XGNj48b2wlpCVRhL0PlBkagXwOSBHW9oaEh06RyIzkgURg6dKC/2ukPPd4dIEbdD6cFrIrku8fjMdVt9LcgoeCEm82mYrFYF5TnqlgAdyLtEQqFDBaix4iJhpfJXLa3t+XxeIzYgQEEzmIsAnOUgFFKpZLR2mk2RWPMvbcU8SGguFliMBi0OgyNhUDcnU7HMjhejwZEIF1gSVeVAwaodE74mJ2d1eTkpCYmJpTP5yWdkQlu3LihsbGxS9WtCHCKxaIxMMmU0bdj+i6Bjs/ns8wXKE06JyK5ageQJty6IME4/0sgBKoBOQdI0B2GKMnQGQJ27ne9XjfEgjvdarWUTCY1ODioiYkJG7lNfX1iYuKvICL/pfXazoWO5Gq1qs3NTQ0MDCgWi0mS6QONjo52ac/Qo0Jntst8AEscGxuzlJdCHEYUVhVQBZtB2s3GUrilmEudZXd3V7lcTqlUSt///vdt/gjZCtE4TJP333/fiqzPnj1To9GwgUQU1i5qHNmDSqWinZ0dJRIJXb16Vc1mU/v7+2q1Wrpy5Yql8jjB7e1ta/BEqBEn6rLgoBS6dGVgNqJJhoXt7OxoY2PD4EOwdbBb9Mm2tra0u7ureDyumzdvWipPo9z29rZlPz6fT7du3TKSxMuXL1Wv15VKpWzULcb5Iuvly5fGaMvn84rH45qbm1MoFDLF4+npVytAigABAABJREFUaV29elWNRsMuP45ZkhFJGH7l1gIJYghsiPjI6Dwej2mLUVvBiSOzDqGEiHV9fV3b29tKJBK6c+eO/X0gELBCPrT4drutDz/8ULdu3dL+/r4ePHhg2k9XrlyxxtDLZC6ffvqpPB6PiZqmUinNz89bwRe69be+9S01Gg3t7++rXC5bs2Bvb69Rl2kKBfaifuNqXbGnUOZxTNJZVh2NRrvEPclEgGh5TYyjS4PFITGLCYjqO9/5jq5evWp3uNls6vr16/adgD4vsmCjbm5u6uDgQMFg0BpSEa6cnp428g5Q6/r6ujWLkzUSWBB8YRsw+hCJoAWznzgy1ykQzHM3qNV5PB5ls1kdHR1pYmLCdNBc2SfqqWT477zzjmZnZw1Rqdfrunr1qpaWlrp6ZV5nvZEqssfjseiE6NAtZsGygiVEKkaPDI16rhaOdC7jTyRISg7Dg/fjcPB+OB0E7txCFr/H6xEpupEjD490ks+P6nK9XjeRQujCF11EHW7kxWcEgnG7vYk+MI58ViJsXovIGwfB9+N9yGDcQqZ7ONyeJPaCZ0E26uqW8dyJ7iFS4GTC4bA9ezBzCr4wVi66f5LMGEPtdYvcFIbZA/esSeoiHri/9+prEJkRkeNQifaRyeBcElxRnCa641n5/X4jjbgjhaF8kyEAkUHvf/X5Xeb8Seejv12Ku/v9OVdkxwQlRMSv3iW+36vECs4NvVnsrQunuPeRs4XRcz8L55MziDN7lbThMurC4bBJTJEtkY1DS77M/v2qO+wSMcgMKKTT2Mld4FmSkbxKhiG7A1XhOwBXghy4NhDoy83GXXjX/QMs51Kk+V8aisn46/W6gsGgBZBvcgZf27m4EAR/OBzIHmCgYUyAi6NATPTaaDRMC+ro6EhDQ0O6ceOG+vr6lE6ndXx8bJnFwMCA3nvvPSUSCZNOx3lJZ8W1xcVF7e/v6+XLl/bgfT6fFhYWdOvWLWuqAr6oVqsaGxvTe++9Z1gsU/GYdQE+jgwMB6TT6ej3fu/3XnuDWcAPkBwCgYB1Y/Pv1ChwrPQNUS+Cok2XNKrS4XBYi4uLZgzQhUqn0+rr69PVq1cVjUZVLBb15MkTk/CXZON2Dw8PrdjIIZ6fn9fVq1dNQUE6w51LpZJGR0f1wx/+UPl8Xr/4xS90dHSk/f19RSIR65B2GX38+0Uv9tTUlP330dGRenp6rBkMeRKK5M3m+ZA45FUwVFxEalcUpjGoXFAkWfr6+nTnzh3FYjHLqH0+n9bX1+Xz+TQ7O6vp6Wnt7+9rZWVF0jlDbWJiQuPj40b7hKp6enqqZDKpjz76yLTcUFJ49uyZ1cUgUJyentpFl6Tf+q3futAeXrt2zWomzL/J5XLWrT8yMiK/329jsUdGRtRun0kK7e/v2z3AuUJzR2Ke0Rv0j+VyOX3yySfy+XwGqWA4e3p6jBp9584dLS4uanNzU48ePVK9XjcUYmRkxGT4YdAxlZGawcnJib788ksVCgVlMhltbm5qd3fXNO8CgYApDWM/LrI4yzR6YqghjCBsSkC4ubmpk5MTm37rQlSJRELBYFD7+/va2dlRLBbTBx98oIGBAVOhwHYGAgEtLCyYXBVZHs/u6tWrunLliqkdS+dj2Wk0BoqnBaHRaFhNp1AoaHt72xrKYfuBbDBSAx25192/N9IWk7oVT30+n6VmFPuIek9OTqyAVqlUuiiqXObDw0Ol02nDT8PhsMko5PN57e7uGv0zGo1acxIRgSSbU46wG1E0tMdkMtlVwCei4eK/KmjJ4aAeAwbKaNCLHkw3GmRQEA6ZhkiiFbIBV0nWpVoz4wGBz3q9biwON7rBOUNLhuHFPHePx2OUWPYFJgtsEnoF2BPGHNOtC4OKw8jrSN0KqjDOLrp/GCIuHppM0vmMHPaKjIXPjfApUEKtVrPsgD2loM/ZKRaL2t3d1cDAgE1wRILl9PTUnBXifzBzXLgBHS2yH1g8h4eHGhsbs6Lw6uqqPWsMCueYyBWa+kWds3Q2M0k6DxAwInw3AiACN2o87t6gdwWFmkzSpd5yzw8PD7W1tSW/369YLGYsNKJ0ovhkMqnZ2VnVajWtra1JkkFKjOlwo3mXbpxKpWzGEPecGi/9XcCYsNUuuod8dgIUtw2DSJ/gBKiPzwFU2Gw2TXCT9oNcLmekDuq9kBA2NzcVCoV0/fp1o67zfNz7mkgkrHTh1lehGzcaDdsPXt/rPRNQdZEQl/7OXhOU1et1HR4edpGE/kvrtZ3LxMSEWq2WdnZ29Pz5c2vkIS3GM1LHYPM5GEdHR9rY2LDiHg4DCqKrlwX9lvegmYqDg2YUBhmmSCQS6RJcg3GGYcPbw0bB4IMpAj1hqNrttnWzksVc1DiSlmezWe3s7CgUChn1lwtKJInh6u/v19WrV7WwsKBsNqv19XXrHEcWBAwXqiKpdyKRsOgKOiyyLz7fmYYWuC9Ub7eoyP8fHx/vIj1A+S0UCvqLv/gLtVotLS4uam5uTuPj4xoZGdHBwYGNnAY+IuK76P4NDQ2p2Wxqa2tLq6urarVaun79uhk0shEMMCoGyWTSGsV2d3eNQv9qJ/Or4qiTk5M2phbV42w2a53TSGk0m01jggFNANEmk0lT0uVcATPmcjndv39fXq/XSBA4cODndrttml4Yx8tAY9zR4+NjbWxsGNWagE+S1VhgBaEPGAwGbQ4M/T04c0lGXoB4Ajz1rW99Sz09PUbcSafTNhYZ5QNYSgiiuooUSOe42TyBIArg1Pvu3LljsJJrLN0g51VI7U3PYKfTsRk+4XBYqVTKPqsbGOI03fHOUJEl2ZmA2NTf329NjGQMDBujJ44m4Ww2q0qlYrXAdrtt0lXYaexyKBTS+Pi4OaVaraaNjQ0LnqjNXLlyRVeuXDG2KqQh7ggweDQa/eYzl+npaTUaDT148ECffvqpFhYWzPhLZ5E50gd4UwT7otGonj17pufPn1tE1+l0TJKcaAnpByjMpHR4W4xvb2+v0Y8lGccdOQ2cy9DQkK5cuWJd2hie09NTra+va3d3V2NjY/on/+SfaHx8XCsrK9rc3LRmPEkWFdTr9S7JhzdddGqvra1pfX1dqVTK+iA4UMfHxwaZRSIRBYNBzczMaHR0VA8ePDCjGgwGNTQ0ZD05QGS9vb0mp55IJCzrIBpmDHU0GtWVK1dMhpzCHawzoCXeH8dK2u/z+bSzs6NPP/1UIyMj+sf/+B9bfw3ZLIVYGDNuw+xFViwWM4nyBw8eWJaAY8GQEL2BK8Pye/HihdbW1tRsNk0VFlYemYv7v+hQYdTpc3n8+LF1f1MHTKfT5tjL5bI5m76+Ps3MzBhphHvS29trNOhEIqHf+q3f0ujoqNbW1rSzs2MEDUk2ZK/VOlPBvuj5k84bSCnQQ1l34Ut6yGgqZsxzMpnUw4cP9ezZMwu8AoGA3ZNqtard3V2DYtB+e++996wWIZ2x/nZ3dzU4OKjp6Wn19fVZmwFzn4iYm80zufdr167ZiI6TkxMjU2xtbenx48eanJzU7/3e72l6elrPnz83yNItbBNIXca5xONxNZtnY5OXl5dNv4usiaCMuvDk5KR8Pp8xrR4+fNildgwciagpKt88D0gXkgzyPTw87NIphE2HUOzc3Jx1+6NCPTMz09Uft729bdqKz58/VzKZ1D/6R//IGHZk+rVazRi5BAvxePybz1x4WHhctxjlLrdI7xa63BTy1UK+1K0cSqThFpr5GbcA5jJH3N/l7/gZUmr3vYDWyJZeVbp99TXd4u9lFu/NA3KLar9qT92o2v1er34utzDn7p/7eV99XbfA6vYkvLrH/L3bEQw0AsmA/eMz8YxdSupl9o7fZe9+FXHD/Y58B/bhV3X2vxqBuc+Y78T3dt/71Wj41f169f//quflQnfs8a+iyL76GpehIruL7/Hqcs+i2xPE83XvoPtsf9UZpqjsnl8XenT3y/27V7+/W+R2nzPZAgaQepj7XX7Vumj2x/vz3tjDv27xTN2g5Ve95qvnyL0v1HX4d86+uyf8G+/nUv7dv3OzOtcGunf4r9s/92687hn0dC4D4r5db9fb9Xa9XW/Xr1jfTBj0dr1db9fb9Xa9Xc5661zerrfr7Xq73q5vfL11Lm/X2/V2vV1v1ze+3jqXt+vterverrfrG19vncvb9Xa9XW/X2/WNr7fO5e16u96ut+vt+sbXW+fydr1db9fb9XZ94+utc3m73q636+16u77x9da5vF1v19v1dr1d3/h661zerrfr7Xq73q5vfL11Lm/X2/V2vV1v1ze+3jqXt+vterverrfrG1+vrYr8z//5P5d0rpR5cHCgZ8+eKRgM6nd/93d148YN5fN5kzxH3nt7e1uHh4fa3t7WgwcP5Pf79e6772pkZMRk+QOBgGKxmEnHF4tFG8JUKpX02Wef6eDgwNQ4h4eHTTKeGQ8oljJTpt1u6/r161paWrIJk+VyWV9//bX29vZsfjjzWvx+vwqFgs3wZlYNKqSucuv/8D/8D2+80f/9f//fSzqT7Y5Go9rY2NAnn3yinp4e/b2/9/d05cqVLkVUJnw+fPhQKysrqlQqOj4+Vk9Pj5aWljQ0NKREIqGRkZEulVZ3GNr169dVLBb1B3/wB1pbWzPV00gkovn5eRs7zVhUFF9RjZ2enlYqlVK9Xlc+n1e5XNann36qjY0NJRIJjY2NKRQKaX5+XgMDAybrPzg4aHNgvv76a+3v79v8bUn6n/6n/+mN9++3f/u35fP5ND4+rkQioXQ6rUePHqm3t1d/5+/8HS0sLNhsoFKppI2NDZVKJe3s7Ojw8FAnJyfKZDKSzuT7+/r6NDQ0pKGhIVPUlWQjlBneVK/Xtba2Zt/t9PRUsVhMN2/eVDAYtM/X19dnYxUKhYKNfGAkAhLmn3zyiT0LxkLfvHnTJngy0yQcDncpkZfLZZtb9L/8L//LG++fJP13/91/Z9NQBwcHtbu7q/v376u/v1//7J/9M924ccPGezPDp1qt6quvvtLy8rKNvujr69ONGzcUi8VM9di9H4wrHhwc1PDwsCqVih49eqRsNmtnkHEcDLJj0F+5XO4aPjg+Pq7R0VF7/Uqlos8//1ybm5s2iXJgYEATExM2E4XJmIxMSKfTNiywXq+r0+lc6Az+j//j/yhJNp9lZ2dH9+7dU29vr/7pP/2nNl+IefaHh4eqVqva29tTLpfT1taW7t27J0laWlqy2SnBYFChUEhzc3Py+/169uyZdnZ2FI1GNTExoZOTE/3pn/6pdnd3NTo6qpGREYXDYU1NTdlYbBTQUZFnVPvCwoJmZmZsblSpVNJPf/pTvXz5UslkUjMzMzYEj3vA+JRisWhjCxhHjV38F//iX/yN+/XazoXlSjkz3Q+jhCS0JDtwruQz0ueuDD7rVXFmvpQ7p1pS19xuVwLdfV0cmyspzeu7s+T5vEj6u1Lc/DfjBX7VZ3zT9ap0OvvH3yPDjsw4/86QJ3fWw183HsD9/K6ku/t7vJcrkf7q77uv4Y48eHU8AfuHMXAl91+VYP9VkuoX2Ts+K8/SlcTHMLr750ruu2MD+E7ud3el493/776nuzcsNwjh99gb5M4ZvOTOn+e1cCLu5+A1f9WYgcssdw9dw8R3dc+NO8Ne0l+Rev9Ve+h+B/e5851fPbu85686i+4+82/uPXD359W7yn9jI159Rhdd7p3jPrB/2Ct3nIF7VpHdf1W2/q+7F27w9+oIDfffeV7uvxMcM1qE7+7em181AuTVO/vqOIXXXa/tXBiLy/jMQCCg4eFhBQIBDQ4Oqlqt6uDgQKurq4pEIrp7966NNe3v77cxmUxoY7qfe1ldo8vs6WazaeM4iQp8Pp/y+bw6nY4NsQqHw4rFYhYJtVot7e7uamtrS8Fg0MZ5MvWt2WxqbW2ta+7H6OioYrGYjShlOFW5XFYoFLLBZhdZXAbGHE9OTprhI4Lb2NjQ8vKy4vG4vve97ykcDtvnOjo60tbWljwej5LJpAYHB23CJxEwUzk7nY5F661Wy+a/M9bX6/WqWCzav0tnkffAwECX893Z2bGJnQMDA5LOsplkMqlSqaR8Pq9isaijoyP5/X5NTk5qbGzMJkZyJo6OjtRqtX7l5XjdRSRPpDY0NKQbN27I7/fbhMuVlRXt7OwoHo/rO9/5jkKhkFZXV7W/v6/9/X37rkxWZHxwf3+/vX42m1U2m1UwGPwrwVIgELCLyCRHzk8oFFI8Hu8KtLa2tlSpVDQwMGADoebn52089M7Ojtrttr1WLBZTJBKxqY7uzPpvYpYLgYvf79fAwICN+e7p6VEwGLRMb319XfF4XN/97ndtTO7MzIyy2axWV1fl8XgMcWC0MGfQ6/XaRM1Go2Hfo6+vT7FYTNK5Ic1ms2ZTmAqLI2bIXCaT0fr6uoLBoEZHR+Xz+TQ/P6+ZmRkVCgXLVLLZrJ2FYDCoSqWi1dVVNRoN7e/vq1gsmm256OJecI8CgYBu3Lhhd6fZbGp7e1vb29vq6+uz/R0aGjIHxPhqsmcy2J6eHjtbjMWuVqs24G5sbMzQHZ5lJpPpOhNkipLMTm5ubmplZUXhcFiTk5PyeDyKRqOanJyU1+u10eM48LGxMSUSCZXLZR0fH6ter+v09NQGj/EMX2e99k67E91IC5kDzRhixnhOTEzYNEQibp/PZ/PoR0ZGFAwGLcqUziM1Dj9jaT0ej4aHhxUOh82xVatVFYvFLrjG5/PZ4fP7/Wo2m1pdXdXa2ppGR0d1+/ZtBYNBRSIRRSIR7e3taWNjw9I/SXr//fc1NjbWNQ55c3NT+Xxe4+Pjf+1Ap9dZRG2BQED9/f02zdDn8ykUCqmnp0e5XE6PHz/WzMyMfud3fkcTExPq6elRIpHQwcGBGS4O5snJiU5OTmwyJcOSOp2zUazHx8fq7e3V7OysQqGQTk5OVCwWVa1Wlc/nuwYehUIh9fX1SZINyUqn00qn010pOI5tbW1N+/v7BtcxlnVpaUnHx8cGRRwdHalYLJrBuOj+4TxJ38PhsI1xZhLlzs6OfvnLX+rq1av63d/9XU1PT9s57e3tVTqdVrvdVjweVzAYtM/GnHhmwrM37IMkyyDJhg8ODroiPPdSM+I7nU5rd3fXxvmGQiEtLCwoHo/r+fPnNrFyf3/fRhqnUikdHx/r6OhIlUrF4NzBwUGbcX/R5Wax/f39GhgY0NjYmHw+nwKBgEE4jx490uLiopLJpCYnJxUMBjUxMWFQI84C+KdSqXQ5CenMgRCAdDodO/dkEJzBVqtl2ROBF/e8t7dXW1tbWl5etuCSszg0NKQnT55odXVV9Xpd9XpdkjQ/P69QKKRqtap0Oq1KpaLd3V0VCgUFg8EuKPNNF5F+rVZTo9FQMBjU4uKiAoGABSt7e3u6f/++YrGYEomEwcGM+34VacE2+v3+rgA7EAiY8/T5fEomk+rv77c73263dXR01AWJJxIJBYPBrmx9c3NT6+vrGh8fVyQSseeeTCaVz+eVzWZt0izQF2PnT05ObGx8qVRSq9WyIOB11ms7l0KhYMatXq9rYGBAfr9fgUBAfX19tkEcOHDDarVqWCcbeHR0pHw+r+HhYcXjcUndU/7a7bbNgZdkX4g/vb296u/vl9/vt5nuOD0+a61Ws2iwr69PpVLJHJ3H41E+nzevHQwG1dvbq2AwaAedB88oWLDGi17uSqVimQYXiiicjGFwcFAjIyPq6+vTs2fPtL+/bw749PTUnCZ1rf7+fjNc7XbboiKyRRw1l9kdWTo0NGQz58vlsvx+vxn/RqNhPzs4OKienh5VKhU1m00b7cs41FarpXA4rJ6eHg0ODloU5hoxDu1lnDNOwIW3yBx4rp1OR36/X5VKRffu3dP29rZyuZzVMjBu7iz2iYkJ9fb22uu40W8gEFCn0zGDGQgE5PV6bRR1p9PR8fGxyuWyBgYGzMFQN8AJ9vT0KJ/Pq1arKRwOq9VqKZPJKJvNWnDFmeP8SeewFYbchdIussrlsrxer05OThQIBAx1cA0c+Hu1WtX9+/e1tbXVNVWUOlS5XFapVLIMCNgPw9toNOT1em3mOnUYF7qm5lcul1Wv19Xb22ujv5kjz3v29PSoXC5bVk5WfHh4KEmKRCL2fRjXDYQTDAa7AruLrlwuZ8/F6/V22SvgJ86PJK2vr1u2yx4A0zNCeHx83PaPqZM8B7Ih7A77x8ho4Od8Pt91vyXp9PTUfpfMiZoX2VG9Xjd7JMmQgXA4bBAjthjbzmu+znpt57K9vS3pLPXq7+/X0NCQXbRwOGyHMhgM6vT0VP/v//v/qtPpaHp6WqOjo2aYqtWq1tfXdXp6qu9+97u6cuWKyuWyNjc3u9LpUCik8fFxtVot5XI51Wq1LgydlLxYLFqRcWhoyNJg4I7Z2Vmbfy6dO6rd3V2tra1pYGBAd+/e1fDwsGKxmILBoBkesobh4WH7vYte7nw+L0kWxYfDYY2Pj1vW4fP5lEgkdP36dZVKJf3hH/6hGo2GxsfHFY/HrdjW6XS0urqqYrGoO3fuWBH26OhItVrNMP7BwUGDB4+Ojgy6omA3ODioTqejFy9emLHhOTFju6enx+aGE4GWy2UrZu7v7ysYDOr69esaGhoyuKlSqdgzisViBjm5mcCbrnQ6La/Xa0XfQCCggYEBc9JkEcFgUMfHx/o//8//U36/X/F43DKcaDSqRqOh3d1dlUol3bx5U++++65F7My9TyQSdpbJVIjMJSkUCml6elper1dPnjzR7u6uEomEZmZmVKvV9OTJE+XzeQUCAY2Pj9t8eY/Ho2q1qmg0qrW1Nb18+dJgUYw9EDJGmACE+3WZlcvl7HWr1aqhARgOvnM4HFaxWNS/+Tf/Rj6fT3fv3tXi4qJarZaSyaTK5bKePHmiXC6nDz74QO+8846RKKrVqt1joEIi+lKpZBF1MBjUyMiIJGl5eVnpdNoyt1qtpufPn6tQKCgQCCiZTKrdbptxLxQK6u3t1fLysp4/f67BwUFNTEwoHo/bfaXO2ul0jLjhBj4XWUCC0WhUkUikqxZaq9XsjiaTSRUKBf3sZz9TqVSybIwApNVqaXt7W5VKRZOTk7p9+7bq9bqdQYJnsohWq9UVHHPuXQIJ/47zwAZGo1HNzs6qWq1qeXlZHo9HqVRK0WhU5XJZ6+vrVqqA3DQ+Pt4V7EejUfX29lrw8Lp1lzeCxUgLJVkG4c7WBiJrNpsW6WLwiH4wMoFAwKAIoh6Kx41Gw6I1t/iEwSLKJNIjqnu16MT7eDweO2y8ZygUUiwWszSRTIj6C5G2i7PXarU3PY+2qDdJ52QBPjuQoNfrNedWLpdVqVQ0NDSker3eVXh1C/0uVutGURTfpXOMmyiY3wf6YU9eJQe4mQKOgecFowmID8NHhOpGVzzXy+xfo9GQJHuOGHuw7Ha7rd7eXkWjUdVqNRUKBYu6MMx8dr4b++dCszwLd/94RkT4GHwyC6A6XkM6J464f9wFxPOrCvwue42IVeouEl9k8b24J9xFEAUCEyDUbDardrutUqlkkbZ79gKBQNcd5Tu4bC+yMDczctlJLknEJfywyHDciJl/p84D8kD2x+9x91+dNX/RfcTmuIQPF+lwUZVKpWJ7Wq1WJanrnPT29tr9w8bw2UB6eE2XreoytrAH7OmrZ1A6h3Ox33xmgrOhoSGroYFAsX/AuyAS5XLZSgivs17bufCgiPDHxsZ08+ZN+f1+M4YDAwOan59XoVAwLJZLIskyne985zvq6+tTNBq1n6tWq6rVajo9PVW5XJYki665xIlEQqlUSoVCQSsrKxZ9gTOSXfn9foXDYYsGh4eHrUDIQfzoo48sEt7d3bUDUCgU5Pf7dePGDaM2NxoNPX36VI8fP+5iCL3Jqlar8nq9RkVOJpO6evWqenp6dHp6qmw2q1arpVAopGazadG4y3zjMN66dcuK2tKZ0aDIeHJyYrRL11ECocViMZ2cnGh7e1u1Ws2iOq/Xa8YEgwyWOzQ0pHg8bsbY6/Xq6tWrFtWD20Ii6O3t1djYmCTZaywvL+vFixcXvtinp6d2OYhm79y5I5/Pp/39fZ2enmp2dlbXr19XLpfTZ599pkKhoFarZXAKl3tmZsYgm2Kx2FUXzOVy2tnZ0ejoqEG/0WjUKLyhUEi1Wk25XE71el19fX1KpVLyer1dkS1nu9FoKBKJaGRkxM7w4OCg5ubm9L3vfU/lclkbGxuW7XFnyBR4jXQ63QVRXWTxu8FgUIlEQvF43Aq71MiCwaA++OADZbNZw/dLpZKy2aw5wt7eXt2+fVvSmZHc3t5Wp9MxuLBYLKpQKBhEzt4NDAwoEokoHA6rXC5rd3fX4PKxsTEjFTSbTUWjUQta+ANkxpqdndW3v/1tI2ZwD4rFonp6enT9+nV1Oh1Vq1U1m03t7OxoZWXlwmwxl1XXaDTU29ur8fFxC7Bw0gQOFMOxb+FwWKOjo/Z9O52OJiYmVK/XVa1WVSqVdHJyos3NTe3v71uBvtPpqFQqqd1ua2FhQdevX1ehULD7lEqlNDY2ZmgOhIFoNGpBEIQkMuVwOKzp6Wn9+Mc/tsy6Wq0qGAzq8PBQfr9f77//vrH8JOnp06d6/vz5a9/h13YuLtspFAopGo0aXJNOpw1GweD19fVZVOJGw729vZqYmFAsFrOIlroCHvvVbIfIAwiJCB1jC8Z6cnJi2CrREf8ej8cNDgoEAgbj5PN5ffzxxwabwQJJJBKGSzabTb18+VLZbNYi6DddRI3UNgYHBxWLxQxfpihKFOLSvKVzimBPT49GR0eNLeZSCdlDUnSiddJoDli73TanHo/HNTg4qFKpZHU19o8aDvuBcSbDIsKtVCpqNBoql8s6PT3V0NCQksmk1XsgahwdHVnh9U0X0BR7SDGaOtbJyYmGhoaUSqU0MDCgR48emVMh88PZEnj09PTYWSPCrVQqKhQK1pPjUsZhyxwfH2t3d1eVSsWKz7BrgBKB0MjiYrGYBToDAwNmaF3GHfUuv99v94i9pcB/2exFOicdUGymHlAsFjU2NmbOEsPEsyU67u3tVSKRUF9fn9UuOV+cSYrszWazC3GA1dnpdKxgTAbMfaNGBzJC/WFkZMSCHs5lf3+/Tk9P9fTp0y4H47LTyLz29vZ0cnJy4QDRrRkS+FHjwT7CMoSZ2tfXZ3UNsgXul8/nM9gL21ev1y1rbLVaxtLkO8M0BRZst9tW13PRFZi6LmIDNDg0NGT2Z2xsTCcnJ/L7/UYQgEAC4Qgbs7KyYoHr66zXdi5EKrz51taW8vm8+vv7NTc3Z80+xWLRLhy8fuk8ve3p6VGpVJJ0Fo2enJyoXq+rUqmo0+koEokoGo1qcHBQ4XBY1WpVmUxG+XzenAzReb1e19DQkEU85XJZ/f39mp+fN0onxfBnz56p0+lodHTUjCKMFQq/kUhEoVDIIjU33Y3FYnrvvfcufLnfe+89SbI0eW9vzxzZyMiIRkZGVKlUDJem0Ars5aa8ZEFAZ27D0/DwsNFe+/r6VK/Xtbu7awVYskzSXqJC9q+vr0/T09Ndhq/RaOj58+fyer0WeWOUT05OdHx8rHw+b1EpxVcX4kgkErp79+6F929xcdGygp6eHh0fH+uTTz4xx3f16lVJMmp6X1+fBgcHFY1G7fKzh5VKpQt2gE7barU0MTGhsbExDQ4OWr0A1hF7RISJ4SRixYmNj48rGo0ql8vZheU9+/r6uujK+XxehUJBJycnXTRP9gnnFo1GNTU1danMZW5uTpJs/4iYMd7z8/Pyer1G8gDiAf/ne7gFYLKrUqmkw8NDM2QzMzPq7++Xz+ezOih7ABGH+ipwEnAmv889xaBtbW3J6/UqEomY8/Z4PCqXy3ZWgX2ByfnMlUpFkUhEt27duvD+3bp1y+xfrVbT8fGxfvnLXyoYDOr27dsaGRkxJ4qTbLfb5jixawRaIDUgPQRfMzMzxtKLRqPWSH54eGj3z2V68XyApAngqcm0220Vi0Xt7Ox0wb3c33K5rGw2q1KppGAwaK0a29vb8vl8ikajdp8mJydf2zm/tnN5//331Wq1tLq6qp2dHe3t7Wl3d1eRSES/93u/p6mpKR0cHKjRaKhSqVgxFCwfNpHX67VO50wmo0wmY4bO7/crkUgYQWBgYEDHx8fa39/X1taWQSwufZgCV61WsyLitWvXNDExoVwup+PjY62srOjrr79WpVIxKujx8bFOTk5UKBS0vr6u4+NjTU5OGv4JVEKUS1fsRVPq733ve2q1Wnr27JnW19eVzWb14MEDDQ4O6h/+w3+o8fFxHR4eGquMPQBWdJvzuODsH/9Gr0kqlbK/Oz4+1r1797Szs2MQBxAQkR+QJ4Xy+fl5TUxMaH9/X5lMRltbW3r8+LHq9bquX7+uZDJpEXWxWFQ2m1WxWLTAQDqHsbjs9BBddN28edMw6VarpWw2q4cPH2pwcFD/9X/9X+vmzZva2dkxuizF0JGREQ0NDalWqxmdslwudzUmEi16vV7dvXtXc3Nzdo6LxaIymYwODg6sSx+jABSEIatWqxoYGNDk5KQmJia0u7trlPG9vT2LtqXzXol8Pm9/6vW6XXzXuXi9XoM0LtMAuLS0pE6no2w2q1wup8PDQ62trWlwcFC/8Ru/obm5OaXTaTsr3EGMF06EaJjMFIe7t7enTqejO3fuaHp62r4j0B99LaFQyIg4LgPq9PRUBwcHGh4e1szMjFKplNbX17W5ualCoaDNzU1JsjuM8S6VSsZAhbIMm6vdPuvqPz091fDwsObm5i5Mynn33XfVbre1urqqvb09ZbNZffHFF0ZESKVSVguBvUX20dPTo+HhYYVCITUaDdv/UCikgYEBozj7fD7dvHnTCCN+v1/7+/v6kz/5E62tramvr89s4PHxsbV24GwbjYYGBga0tLSkRCJhiMbKyoo+//xzK1/09PTo6OjIYNfj42OD44PBoAXdHo9Hi4uLVt+anZ197QDntZ1LvV43miv040gkooGBAZ2eniqdTiubzVrvAAfQ7bInFXQLpjCgcA7QYElvYSsApxwcHJjRh0AALgjLhsMErDMwMKCFhQWr5eRyOaPrUniTZP0zRGxcdOCpy1CRq9WqZSCkrI1Gwz4DfSlEjW5UJ50TIXw+XxcThmKdm6pS4AZ/hbyAYUGeBWjIrc0AFZXLZavbBINBTU9PW1E3k8lYis3nhJ76arOaSz+9TBMg349oFAiWrPXg4MCcLTAjn8ktfOKcyaopmJJlkR3DjGk2m1YHa7fb2tvbU19fn1HA2TMXxiQjcCG8ZDJpRiGTyRgsRhADG4ffcwu8LuHjm1hAxZwhGH5HR0fK5XLK5XJGZaW+UKlUJMno+mQsFIrdvXx1QRLgTlOjobEZejC1VfawXC7b6weDQY2NjdkewS5jD7EBOGzgNNhUnANgpossnBULAkl/f7+q1apyuZzZLmokr/4+Z8qVvYF1hu3j/BAAnZycKBwOm5xNJpOR3+83xhrPhPvK3adhGiRkZmamywbyWUFToOmTWboISSAQ6CIlvc56beeSTqclySCiWCym+fl5SdLKyopWVlYMcwdDJCqUZMwEePb1et2gn9PTU8tMBgYGrCmTHpb33ntPnU5Hn3/+uT755BPNzMzo7//9v28FWb48XPetra0uHaOJiQl9+9vfVqVS0f/6v/6v+vTTTzU5OSlJlr56vWfdqhjfRCIhn89nkdrw8LBGRkYufME3Njbs8szMzJjjbbfb1mx3enpqjhkDCPYMw83j8Zjj9Pl8isfjKpfLSqfThtm2Wi1VKhVrUrty5YoWFhb0+PFjPXz4ULOzs/roo48UjUaVzWatwxo47eDgwGAfoKKPPvpItVpN/+7f/Tt99tlnWlxctP6XUqlk3d35fN5qXGSpGGgK4xdZ6IK56hA3b96Ux+PRxsaGnj9/rkwmY534GMbT01P19PRoZGRECwsLkmR4Ntg3gROLzHh/f1+SdPXqVfl8Pv35n/+5fv7zn+vatWv68Y9/rHg8bhkNgQLECC4usN3k5KRqtZr+/b//97p3754mJyd19epVixaB5zKZjJ196oi1Wk1jY2Oampq6lIPhLobD4S7nKJ2pMaytrenw8FCZTMYYUR6PR8fHx2o0GorH45qfn7c7S70tEAio1WoZWoFzYE/7+/t1+/ZtNZtN3b9/Xz//+c915coV/bN/9s8UjUa1u7tr1G1o/3t7e6bR1tvbq3g8rm9/+9uq1+v6gz/4A3399deam5vTzZs3raetv7/faPcupEzfWzKZtLt+kQXESV1sZGREMzMzRgRxqd5kbdJ5D1+5XLbgOB6Pa2RkxP4NJAfaNk6FWvCtW7d0+/ZtPXz4UF9++aVmZmb0d//u37XeKklmc2u1mg4PD1Wr1Yw2PT09rYWFBZ2enuo//sf/qHv37nXR7XlehULBEgDYg9xrgvXXXa/tXGBTuRROmtJg6xDFUtByNxbqKJ5QUld3P4X9Wq1mfSZEg3ho6jXNZtNqMkAd0jnVD8MMfsjhBHIiqnWbBV+NwvHSbhPoZfBuGtig/JEFAS1RA+IBYhyJlsgYcS5QbwOBgP2sG7Gwp5LMKZGuc2H5HESHZGs4XKL53t5exWIxi6qp3RD5UgwnquQ1MJjUGvgeF1lEpy4FNBqNqtPpmDDg8fGxSqWS7QV7jJPk+4LJQ9N0iSdcNM4CUR+wrXv+qEu5VFwMS7VatfeBSELBmmftkjzYS84/zoV7dVEihLsgLrgSToODg2o2m8YO49lKsuzTpZHTaFssFu2sYlCByTiH0jml3W2iRSWCgCOTyZiNoIjP+7l7GA6HrUkzn89bnVY6p/a6e8Uz5S64FN+L7h9nhHsxNDSkTqdjSgpA2a76BX+whewHDcnU6iQZjIdNODk5seBoYGBAvb291uaB6CUBpXRO0+b84Txcua52u22wLtm8S5J6lUhFTdyt/b7Oem3nQlc42QDMIw5esVjUxMSEpqenVSqVtLa2ZgaVn0+lUvbF2VC60xOJhCqVig4PD5VOp5VKpXTz5s0uKvPMzIx+8IMfaGhoyCK6zc1NHR8fm4qy1+u1z4TUy/7+vv7sz/7MCrJ3797V+Pi4YevQSznExWJRe3t71nAUiUS6jPFFFgeelBlYkb6AZrOpqakpTU1N6fT0VM+fP1epVDLIJZFI6MqVK/J4PJblcFnZX5QRnjx5otHRUS0sLHQdhqmpKUln3czpdNoM8unpqSKRiEZHRw2rlmSNmPl8Xv/23/5bc+TvvvuuJiYm/kpzLAtJGK/Xq/HxceuwvkwTpdvjw3ciOKDAnkql9K1vfUuFQkH379+3AuXAwIDJcXg8Z/pObqOiW3vZ2Ngw6Iu6F3WpO3fuGFtyfX1dOzs71qHfarXsnPDZgCxyuZyePXtmP7e0tGTPGqcJ7MTCEVy5csU6vt09vsjK5/PmcN1ubIrA0tkde++990w2hWAB+IqaGtkZ8B00f2jT6XTaMjZII16vV7dv31YoFNLQ0JA1/21sbGh/f9+aLt26E88vn8/rP/yH/2CsynfffVfz8/NaXFw0kgBQFBkrkkl37tyxfrHL7qGkriZH+sWoY01PT5sNPD4+VqVSsZ+NxWJaWloyWNENViGikMGsr69rdHRU165d6+rXW1xcNKLRF198Ib/fr+HhYQtax8fHzdmhQOL3+7W6uqonT56oVCqZrYYx22q1jOBBkASEB6ONHpg3ucOv7VyKxWIXTZV+EaLvUqmkUCikq1ev6ujoSDs7O+ZcXDpwp9PR7u6uFfHwnAhZbmxs6ODgwCJDmncajYaSyaRJvFQqFaPsZbNZDQwM2MFH8BKq4PLysv7Df/gPOj091a/92q9pYWHBJOOhM0MGGBgY0ObmpolaxuNxMwJE9BdZRHJkdhgjovFms6mRkRG9++67ymazBgNxkCKRiAnPNRqNrsYrsrRWq2WaX3fu3NH169eN+95qtYxp0mq1bI9gvhAsSDI4AtWDvb09/eQnP1GpVNI777xjBVXosuFw2NJxdLe2t7ftc09MTJgDvejCwLm1ERcvLpfLisfj+ta3vqW9vT29ePGiy4m7ZAPOspupAOUSkY+Pj5sGHud0bm5OY2NjOj091fb2tgVJQFvQ3IE8IU2k02n98pe/VKVS0djYmCYmJmx0AL0QZDw4ds4lP5vNZk2D7KIL0gIMMI/HYxIjGPRkMqnbt28b1EevENEvxWfpvP4lyaJxWhPy+bz8fr8WFhasz8rn82lubs7qT1CE0+m09vf35fV6lUqlLGPCMA4MDCidTuvjjz9WpVLRrVu3TEqejn4gec4I8J7f79f8/LxmZ2cN+rvMHkrniAtwdbN5JnGfyWSUSqWsxQB4GwSmv79fk5OT6unpMagOY45EUE9PjzY2NrS+vq6BgQFNTU2pt7fX9mpiYsKCw88++0zValWLi4saHR01cct6va7V1VWjFEciEW1sbOg//af/pFKppDt37mh8fFzJZFJTU1PmnGEOUr+B1UttCJWBb1z+ZWlpSe1221Q/kbGQ1MVxL5VKXVEYzLC+vj7dv3/fGrbK5bKp9VJUhLMN4wF8E6peJBIxOQ1oe7OzsxofHzcD5/4hCuh0Orp+/brq9bqmpqaMow88B9e/XC6bYb1y5YokWU2EFPGii6Y42HYo4BKNE/VBu8YhACH4/f6uvph6vW5Gs6enx0gK6LExR0Q675pHcoYMkaxNUpeeEE6iUChIOnOI8/PzqtfrGh8ftzkUFAwx+MfHx8Y6mZ2dlXQWBGxvb9sFu+iiTrW9va2NjQ1rcsSYoGywtbVleDP7R3aA0OrJyYkajYbC4bAikYiRAkqlkmVh1CLoj5BkkR7sROAWcHwXGoPFhAOcnp5Ws9k08UC/3281MYwy/Tp+v1/T09NGu19bW7NncpkFWwzaMJkB2QwQy97ent1bGgChvK6urhq0LJ2ds8HBQVUqFaNsI+LodnwfHx/bGUQcFqZoKpWy3gsySvaReoTX6zWkYXx8XLFYzOwR0OLg4KCRYmgu9PvP5jS9fPnyr9Dj33RFo1G1Wi0TvY1EIkqlUuZ8McygDQSROIbd3V09fvzY4ENIDfF4vAsaDYfDSiaTRpby+/2WWSAIHAqFrOjO/g0MDBgxANi3Uqkom81KOmNcNptNTU5OKhqNWmBB4ADknsvlrNEW2vTR0ZH1Rn3jzuVv/a2/pXq9rn/7b/+tHjx4oFQq1aVUTMMNBWKiAySx9/f3tbq6qp6eHiu8RyIRay6jAa3ZbFqzJFFlOp3WycmJ5ubm9Gu/9mvKZrP68ssvValUdPv2bQ0NDSmbzWp7e9siSeiqR0dH6unp0W/8xm8Y17y/v98URwOBgKnnfvnll3ry5IkmJib0wx/+UJJ07949vXjxwmo8F3Uw3//+91Wr1bSysqIHDx6YsqurAFupVOwScCC3t7eVTqe1t7dncA0GLh6Pa25uzjj+qBAwRIwDSy1nfn5et27d0vHxsR4/fmzQIWwXiBb8b6lUUiaTUW9vr77zne90NWRSFwCSo5lxeXlZExMT+uCDDyRJn332mba3t63p9qL799FHH6larerx48f6sz/7My0uLtqzpP4CHIZhpL8CqCaXy5kyRF9fn8bGxnTlyhXrEYJQAV0TQ7y6uqrT01P9rb/1t7S0tGQDvXCuGFvUajE2x8fHqtVqGhgY0Pvvv28FZvpbtra2jObe29trPS+oeLfbbX3yySfa3NxUJBK51MgHSfrBD36gZrOpP//zP9fjx49NKgeYZ3h4WKenp3Y2UG3O5/NWwIeiPDQ0ZEoJV65c0fHxsbGLgLxRo261zhSrT09P9cEHH+jatWs6OjpSoVBQp9PR7du3bVgahhAYrV6vGznn29/+tqERgUBA+/v7+uqrrxQIBOw8bG1t6cWLFxofH9f7778vSbp//77S6bRBo29SN3BXKpVStVrVH//xH+sP//AP7T2onZChcZ9BJAgGs9msNjY2rI7c19en27dva2pqythh7XZbIyMj1jOGU0Z37Pvf/76+/e1vq1AoKJFIdDWhokJOrbCvr0/FYlHFYlHhcFi/8zu/Y5+LWhTZCUSq3d1dra6uan5+Xh9++KE8Ho/W19e1urpqzuV1nfMbFfQx3C6NGMhAkh0kF0+keZJGM7dXwS3iQ0VGGRX5E34Oh+EWdFutc60j2BWojroZjHSewrtFXjBaogiKki6lks/Iz1x0USOq1+tmINBaIivC+PCHfYbuynI78REKxIEgPQG9k+Iq+wLsQv2IKIuGKpcSyQK6o0jOsySjoiZAxMkCdnK/z0WNIyQMioqvFuXZQ54RDCZ3H4G+OH+NRsP2jf35L+03Z7XVatm/c54ohLtFT96DP2RZ9MVQg+F9KRK7mmcuJf+yi0IwxXN3/9xz4N4znjdqD+59cu+ne8Y409iDv055A7vhwuOgCbwvrwv9nPMDPExXvvv8oPfys9QPLkvK4Q5zBvgOrpw+584t5kNqcM++C8mSNWNjeU3usHuPuPNkna5eINmy+yz4PfTZ3MZwgliXbOW2EbBfvJ7bE/c667Wdy+///u+r3T5TJp2cnLQoGDoxLBA8JxeWMaT9/f2KRCJdEV02m9WTJ09ULBb18uVLNRoN3bhxQ1NTU+YAMMYej0f7+/v68ssvJcmYYIVCQblcTmtra/rqq6/k9Z4N13KltYvFop4/fy6fz6cbN24omUxqf39fKysrNuMhHA4rGo3qzp07qtfrevDggTUXfRN9Lv/yX/5LdTodFQoF68CdmZnpEs3E0HFQW62Wrl69qoGBAcvmOp2ORYnr6+sW7T579kz1el3Xrl2zQWREJ0dHRzo9PdXKyooVb4mC6fTd2NjQkydP5PF4NDY2ZrCQJMtIfD6fbt26pbGxMR0fH2t9fd0YK8hJENXwXj6fz2bAXGYeyX/6T//JAoDvf//7SqVSmpubU29vr8GmGMl6va5gMGgXsVarqa+vzzIsnOXm5qYODg6seN1qtTQ5OWnQIrg59ayDgwN9+umn1ucSDAatJ+ng4ECPHj2S3+/X3NycDTAjgyZivXbtmkZGRlQsFrW1tdWVrff19Wlpackk7zkLrkDnZdbv//7vS5LR4UdHR03fjkzZZWsRjScSCctuIpGIOp2Odc5vbm6aMsfa2ppB1dBs0WBjnzKZjFZWVuT1eo0aXK+fSb9vbGzo/v378ng81qEuyc4xNNnFxUUlEgkbuEbjH0jIyMiIPS+3JtZqtQw+vsj6j//xP6rdPut2n52d1eLiot577z1rpMWJ0BSLEyJYDoVCGhkZ6er1Oz4+1qeffqrT01NtbGyo1Wrp2rVrSqVSlvm4bRsbGxs6OjoyJejBwUGT59nf39fjx48t6MZBo7qwsbGhQOBswNnY2JgymYwePXqkQCCgubk5DQwMGCpC6wfPhvrf9evXXxvefm3n8vLlS0myBkZgDnBs8NGjoyO7VK1Wyz4wB5MiF1Ej3d2IJgITADMQIVBr2N/f75L8J1XP5XI6ODgwiISCtyTrA/F6vYY3MsgIuidZxMDAgA4PDw23d7OVyziXx48fSzrD7aFgIubHzBRgGeix7XZbQ0NDJkrHQUKyAQinUCgonU6r1Wrp+vXrhg0T8dZqNet7yWQy1ueAnhDUx3Q6rZ6e8xk4fIZq9WweuMfj0dzcnD1Dir5usyXRJ5g+9ZDLGsi1tTV5PB7FYjFjqiFkSAACow86KuwgIja3i5l6TC6XsxqUdAZ9UP+Dog1bhwscDodtTALFeyDEvr4+66GSzqml6XRaPp9P09PTZlBPTk7sPjWbza46HNkABoJ9u0yfC/WS6elpjY2NmVaaiyrwmaVzJWyapV3qMv1s9DGdnJx0Df8aGhoyQVZo3WRrR0dHBut6PB6b9looFHRwcGCwkRv1n56e6vDw0ILHUChkRXze3+v1amxsTPF4XIVCwYIwjC1n+aJrfX3dnjcwJZ+FbK1QKJi0i1uLQYookUgYjIrtYTAhYzmwYWQ1vEaz2VSxWDQZGIYJkpWVSiVrjoT6zp9qtWrDA6enp+1ZHB4eqr+/XxMTExYoMraCYYrAncFg0DQDX2e9Uc2l3T4byYohIwWjAEj6Sz2Dgubh4aFpNdEzMTY2Zk2L9A5I57LnMHfAD/v7+1Uul7W9vW3/7fF4lE6nTV79zp07tnnBYNBkasAxcUZE/MApFMvc7GR+fl7N5tm43kKh8Feoom+6fvzjH6vdPuvwRuYF57W5udklSYKzBTaBpjk6OmpKrHNzcyZLAm3V6/V2OQSeCTAZrBO49l6vV/v7+yoUCvJ6vbp165b6+vq0sLCgwcFBbW5umr7Q0tKSNZU+f/7ceP2t1tlsCjLWZrOpQCCgmZkZtVotbW1tWRPeZWAxtMNwDG5DWqFQMJwfXTN3PhBNnAgJjo+Pa2BgQNls1gZPIXIZDAY1Pj5uDWxcbKAkaPcrKyt2afne8/Pz6uvr08TEhEKhkAVI0hkNHPgWx5tIJLoIFKgHMJYbOjRwp3Ru+C+yPvzwQ0myLnZqnXR9Uyvlbu/s7Bj1V5Kpeff19WlkZET9/f1G4nCnTsISfBWWAeY6PDy09/J6vTo8PLRJiDMzM+rr69PVq1dtTPXGxobpZQHdoVVGnZHPQAHb7/ebYjps08vuH/Ivu7u75uhwEDs7Ozaryefz2aTcZrNpNatarWZMPfYPjUaCcc642/MH1Mj5o0Vhc3PTVKiBxufn57vUmg8PD03mhUXTaqFQ6JLT59nBCr5165bq9bqePHliChjPnz+X3++3mvR/ab22c/nxj3+ser2uP/uzPzODxgG5d++ednd3LZspFAp2gFB7jUajGhsb09DQkAldPnr0yPphiBJ5+FwAmCBQ9fL5vPr6ziZLer1eM2wzMzN65513TM2TAilidslkUpKMXAAmjHNxO9LHxsZMZBFacKvVulTU89u//duq1+v64z/+Y21sbBgFuFar6dGjR9rf3ze6H0yaWq1mex2PxzU7O6tYLKZbt25pcnJSX331lba3ty3CZf/o84HtBaMMh+MqKUDAGB0d1Z07d0wOvr+/X5lMRul0WslkUtevX5fP59NXX32l3d1dM6j1et3gHeogyWRSMzMzFowQTV2GcXfjxg1zZAcHByb5Qr2DIISLvby83PVMiRhhfKGoTLRIhAjcsL+/b6OMXX03skC3i73dPhvxvLCwoGAwqFQqpf7+fu3s7KhQKCgSiWhmZsZkNQ4ODtRqtTQyMmKwA1lWIBBQPB43aXZUc6krXGZ95zvfUavV0oMHD7SysqKenh6T0idApG5WKBS0vb1t+nulUkmjo6NaWlpSPB7X9evXNT09rWfPntnvvhp5EzTCiJNkECI1VRxboVBQX1+f5ubmFAqFdPPmTYVCIW1tbWlra8tGfPT29mp/f98yIrS6stms9Xcw+I6xGcjZcDcuuj788EP7fRAG6hxfffWVsRhhtFJjcgMvZPSB509OTrSysmIIgNvdj3J5p9OxXiEYha1WSxsbG+ZYy+WyksmkFhcXFYlEdPXqVYXDYT18+FDPnj1TrVazJt7t7W0bYkYLCI6ZewyppF6va3193dAfl7b+N603GnNMdAXDiVoLXOpQKGTMIwyJW9OA9gkDpdPpGGuCLAJYA467K4XCBgQCAVPHpS/B5/NZwxcPiaIlsAYPjs0hcgKD54KTemIIBwcHu/SiLrLI9hqNhsFEwB00QPJZcagunXNoaMgisWq1as8DKA/aoEvnlGTQBZ229XrdeoI8Ho8pK0uyA4ih9fl8piqMIYDrjmMhA3LrREAfFNKZROlGwW+6jo+PLcqXZH1SvK/7nDFmOF2P52zUazQaNZ0wjA0U8EQiYZkVsKMLr3H2JRktXJLRQdk/6jQ4U/T03OwSBWAaa+mlISggCwB2c9UjLrMQPOVZusVx6hs8T+ot9NtEo1EznOFwWJJMDQHqMU3SZI908APRttvtriAEIVsy51fPElkwNFtQDc48xAhX6oUAAJiNu442lvsc33Tl83kLgrF3fHfgbe41gR4ZL5AtNpJGYwITgj9JxoAEznUhbpwWsCIZDfAXQTf/69LlsQvsO+8jyZymS0ohKMTm8++vu17buTx8+NDgqmQyaQVNr9er+fl5G4ZEBz9FyenpaaVSKYPFJJmWVjAYtI5Tt/sdmMON4kkz6/UzmX0iG6AD0lUK/TCYOAAIXdL4BxRCEx61DFJYpL9RPN3d3b1UE9tPfvITSWcpL7gww6iuXLmiVCplEQu4rdfrtb6ccDhsxUAEGsvlsmG/CwsL6unpsbG+wHyNxplUOWrIHo9Hs7OzunnzZpeuUKvVUjqdNqoizJAbN24Ys0SSjS0m++FC01cE64XIbmBgQIuLizo8PNTu7u6FL/bDhw8ldcuBMHOnVCqZ0wyFQjo6OjKNOOoFw8PDmp6etsyGsc8jIyOmG8ezffnypYrFoikVo/eG4Usmk3r//fcVCAT0/Plz0zPLZrMGafFZqc1QXwmFQhocHDShUr//bHhTb2+vtra2tLe3Z0YQJXF6Gl6tAb7p2t7etiDNbUbt7T0f7sbr8xlPT09t/lIsFrNBa8ViURsbG2o2mxofH9fExIRpvfl8Pm1vb9u+0SjJ/CDmEc3NzZmdICCVzlUsJGl4eFi3b982B00dMhaLWRDoGsydnR0dHBxYoEADdywWM/rzRddXX31ljnhhYUHj4+M2in12dtbsGJL1EBno4RkbG7Ofo1emv79fS0tLqlarNhhsbGzM7BX2CSTo8PBQx8fHGhkZ0YcffqhoNKqXL19a4+r6+roRhMLhsI07pgWE7N1l4SKnU6udDcHL5/NKJBIWbHY6HY2MjFiN5nXP4BtlLtLZ4YNnziJaJIIA33eZRETrpKZMPWPWBkyicrls3pP3w6mwGUT2vEd/f79Ju1BQhmCAs+Ow4a3ZNNJRN4uh45aOZAwaxvkiC2wbOQt3HgV7yeeifgBDh2gHeMZVLCbrgxRAhgYtl4I+mRFMFX4WdhAFPpeSzLPmNaRz6iX1HTeq4vV5DZwLNNbLLNSWycxcSiWUWoT4gJdgjQ0ODtrn4IwBo7mfjTP3Kj2ZM+s+f6iinC/ONK/PmePZujRu+iD43O5gLKJxaMNkFG6WcdHlyqPw/sB6vDcZDfWBdrttA74go7TbbcucufNQuClWu9p2krruGcYJB0fUTbEc9hPfl6yFKJp7QWZPFA75gtciU8PYuu9zkYWyA4PyqPcAnfIc3fPJe7p/7/P5LLtye0dgJXIvISPgoKm/cJY4g/xxxxhgr8mO3bsCSgTE62axrn1mKq+bPb/Jeu0bv7e3J5/PZx3xFNXcwn4ikVAikVBPT49u3Lihk5MTw0QR64M9BERGkY8RrgzUyeVyymQyJkmABhLFrs8++8ycmnRmcPf29qyGAkZJoxhU0HfeeUcTExM2QAhKdK1WM22tfD6vzc1No/GWy2VFo1H94Ac/uPDl5iImk0lNT09L6lZZbbVaNgZ1cHBQh4eHVrhDeRjGUTwe76JP890xgBTuwaVfNe7ValVffPGFFXR7e3t1dHSk/f19I0kEAgFNTU1pYmLC9gOlA+Q7oJzznFKplHp7e41pQj0BjS+asi6yCBiSyaQmJiasniN1S+QwabO/v9+ovBhDhAWRyZDOh69tbW2pXq9rbm5O8XjcDBwZBJcLxdlPP/3Ung3QYyaTMdIIZ49OcpxZMpnU0NCQMY1gjVUqFY2PjyuVShmsiMN3RSMvsxi2RQRdr9et/khjKWq9fX192t7eNpiWugtng+dAjwaMOzrMgU6BXSYmJgwaJKMhiAIaZnaQdMYOJGii85z7MD09bfI5yWRS9XrdSDnojVGTa7VaxswaGBjQ9evXL3wGc7mcSdgAAb548aKrbhaLxTQ5OWkyLEDS0tm9W1tbM4ISMBqQGI4BGHJ/f19ffPFFFxxPsd7r9dqgMv4NPTNsAHD5nTt3bG5Vp9PRlStXNDIy0tUvx8yjhYUFs+noxxHYIhfzuuu1nQtaQf39/UqlUsrlckqn0xbhtdttkyWA8usqurbbbevuhYZL5NJsngm/UfCCButSG+mCJXt58eKFGWsmViLUdnh4aIeAOSRcfK/3bPASNRQgMdLSSCRiRUQoprVaTSMjI7px48aFu3vBXhmEhMEmE4Nmi3AfVGE3yqFYySx3pDRyuZxevnypSqWiWCxm2QSFP7I7otR6va6VlRX5fD5TWq3X68aOYmwtXdjtdttkdG7fvm39LB6Pp2tuChDT9vZ21/5VKhUNDw+bXPtFFvUMBADz+bzVsdA+kmRSJESwYN/lctkiRdQR3Ia4TCajRqOh2dlZhUIh5XI5+zecs0thpvjtKhxwXjFCN2/eNF01NKago0JnhkqPtE4ikTB6NGw39xlehoqcyWTU09Ojubk5TU5OGlRJUEKNDHiG+hRZAHTXwcFBkxwBDiVIc5v73GyI51MsFq0vCVbXzMyMEomEKSoQIcPanJmZsToZ2SlkCFQFCHBHR0dtFALjhUE9kGu56B4izQP8jMoC6hbUqdCkY8IoaAxKEb29vZqcnOzSJwPCJggZGBhQtVrVy5cvrRQAEgRdnd4zaOU4M+l8lDViwtvb23rw4IEx9+gFYn+gNKMwsL29rd3dXdVqNTv/LpX6ddYbYRVARhx60tjd3V2dnJyYYCWek94NIBJgnYODA5NeofAKLOU+KCI1JGKgz0F3lmQ1lOHhYRthStrXbrdNwoImJAQhSbPBZUlFSdtJIYFToARfNOoBMpLOU89Go2ERH6NGmZtD2p3NZpXP5y31Br+nWEiPCvtCLaFer/9/7L3Zj+NZduf35RIMMrgzGCtj33Otyqyqru4uTbkXDaSRxhgNNNCMAQ8MGLDfDBt+MPzoJ/8PfjZsD2wMLK8jWZbVkrq7uroqq3KNXGLfySAjgkEyGEEySPoh9Dl5md1jRTLLb3mBRC0ZC3/3d+9Zvud7vkeJREJ+v9/mytO/A82bfWDWDpItrEAgYMw2DjQ9Gzh5in8oH7tChjwzbJTd3d2uLzbQBu8W+SAyCTJRaM9Ef9Vq1YIa4FyiXJxLsVi0M3d0dGTBCnI/DEZj74AJecZQKGS6b16v16DUQCBg/VWc/YODA6PYU/AmOicTcuEHAgKy7HdZwDiQLjCG9XrdZogcHh5aRtjT06OBgQEdHh7q5OTE6puIcSLRT80L2IpgiKgXQgpML0mWGXLfyNzR9GNcNk6F/wcLdGNjw2AdiBnAlBhyCBTAc0ipdLuGhoYsmwLuwigfHh6aM+M91et1q5swrIzAGSISs2dAZGhsRraI4IRskn3GBno8Hms1iMfj+uCDDwy6Y/9evXpl9b1Wq2UsSM4vdTJIEtg/IEcUD+iz+c479Lk4tVrN0nj6KZaXly2dla5S4H/0j/6RUqmURShE281mU6urqwaZkanAmIC+CM0wFAppYWHBlD03Nzd1cnJisAFdvuPj4xodHTU5BEn64osv9NVXX1mXsdfr1erqqpaXl+3yx+Nx3bt3zzy/24+BgcLYvHz5suuCPhGKpA7HUiwW9ejRIx0cHFgNamxsTH/wB3+gRCKh4+NjZbNZm6ft9XrNQUJfbjQaptMEK8vv91th8LPPPtPAwIAePHigb775RicnJx1ZU7vd1uzsrO7du9fRnf3VV1/ZKGZ6DJgzAekhEono9u3bHeMDJNnFg6GCEkC3+wdlEmPV19enoaEhlUolff3111bIDIfDGhwc1Geffab+/n49e/ZMW1tbGhkZ0fj4uNFuXbonNMt2u21zxnt6emwmOooFLmWT4AYNrWQyqfn5efv6QCCgr776St9++62Nm2g2m1pZWTEsnXrGnTt3bDYM0utuXYAiPOysbhdzfRqNhtFjI5GIKpWKHj16ZD1h7XZbExMT+pM/+RP19/drZ2dH6+vrGhsbs4L+ysqKEQNgLGGkkBRBigg4KpFI6OnTp5bRUlfhPgwMDJhqxezsrEKhkP76r/9av/zlLxWNRk15Yn9/32Dr8/NzxWIxffjhh4rH45YtUP+CIUrR+l361ebn5+Xz+WyUMjWParWqjY0Nra6uamNjQ8vLy0omk7p165YpRaD9FwwGTT2Abn8G7E1OTlpvCnW/xcVFg8LC4bD29va0t7dnlO7Ly0tzLsPDw/rhD39oAcTl5aWePHmiX/ziF+Ys/P4r+f1Xr15ZPTcajWp+ft5YqzBqKWmggA9C8Z0X9Il6SJGBDLiIFOspNvFwGAQGeVFUJz0DvsD4AmW4hUI30ifLIc2mQE5Rmt9LwVmSsdfYYOn1LHqykna7bXNByuVyR3cwWRDZWjcL4wSeScGWYipRAlEczyq9dkw4ePcys9+o27pzF1z5bKI5951RCKVIjmPASEivZ7kzXIrnp1+GZ3LPBUKQ7KF72LvdP5xXT8/rWRg4xjcL8/x/nK2rvURRHaIIURrjb9lbirHuWcYxuj+T8+dmai7pgc9Khse7Iet0s+VqtWrSSC6hhT9uMbybhXMhUnazT+4gyIRLBIFK60KafK1LIea+umQL4FOcOIELcLf0mgHI+YaM4v7hM6BBBlwM5ZafiSrAm2OGXYJLt3sIOxYo0A0CXILHm5G9m/FBKnFJBy7Rwx2vju104V3sIO/MPYPsDWea7+P5XaUHziP7xvmFHQnMCK3epZRfd13budy4cUPSVaoHBRFW19LSkmZmZiTJHoq0O5lMKpPJ2AP6fFcSGGhAgaXjfNgQ10siq72/v6/d3V0Fg0EtLCwoHA7r1q1bymQyymazevLkiTGcKKxCEGAKG/MlVldX9fjxYyswejwePXr0SC9evLAXgcPiz7s0YFEALJfLevr0qT1fq9XSjRs3tLi4aDBNMBjU1taWFfBnZmbsYrgKsEdHR8rn8+rt7bVoymV+SFfG6de//rV1hiNzQnTN/h0dHekXv/iFFZ3pcWBOOTgyNYZHjx7p1atXVkvzer169uyZ4cC8S6AoLne369NPP+1oYsSwUIRkfzFCQDWDg4M2EKlYLBreHYlErEnU5/Npbm7O6JswkXAqRPTAk26j5NTUlNLptAqFgnZ3d023TZI5LQIhv99v6hHr6+uWgZJF0PAWjUY1MjJigZUL377LHt65c8cgGQIc6kSzs7Oam5szGDEYDGpjY0N7e3vy+Xy6ceOGAoGA1T3m5uYUDod1enpq9VigZ5wMq1qt6ptvvtHl5aXR6EENenuvxkAnk0krwpPp+v1+5XI5BQIB09bjDDLC4/nz5zo7O9P+/r7Ozs5M2TwSiZhUiQtJv8s5BCXJ5/Pa3t42h8D+jI6OmgMESvJ6vTbwDYo+dd/e3l6zaZFIRNPT01bzAN6jEZgx5pzZQCCg2dlZ9fX16cMPP9T4+LiOjo60vLwsn89nWXdfX5/Gx8ctOPH5fBoaGlIsFjNUhIC1p6dHu7u7evHiharVqk1ZhbWIs/nOMxdEE+k5wdhJMriGyAM8Fb0keNXwpgcGBmxWAWwKok6yG7eREGIAjBWKzWhkMSoVqAy1XjBlou5QKKR0Oq1IJKJsNvsbMgsIDNLl73r5d7nU0uuZMScnJ1bvAPdEC43MSZIVAsPhsPWtUKhOJpPG9iiXywYFkbq69FnwYGAIBB5xEgj9FYtF03Wi/4UMkYiK5kvG/rJ//BO8HpYKUShO+l3oyPShIFPCfrRaLZtrQ9QmyZwDU/qA8iTZRMWzszOLJmlII5OmbgAZgOyP2lcqlbL9iEajxoACduLfXUNLkytMIOouvJOTkxPt7+/bOwEpcJs33+UccodpECWb8Hg8JlhYqVQMWWC/oCDjbFEOSCaT1pyLc3GjY76+0WhYXxZkCIIOoCK024CtyIpgmJJZoStITZKmPjKYXC6nzc1NDQwMdNTBXNp1t4t7wSAyt6cpmUxa1uFmsZIsOHPPCI2hqGZwz9/MVGiiJBigJOHz+ayRM5VKWd8PzbexWMwCfbTrsIvJZNIYkdR4eWc4eGwHgT6Z/9sE2Ne+7URzxWLR6HQULkkHYShQ/OHrKWZR1ISCS42B9FmSGUdodV6vV+l0WvF43HpFwANDoZBWVlb0/Plz+f1+E1WkiM8UREnm9NxiKtAF4o3uXGm0fzgwjGztdkGlRqNHkhkfLhd9IXxeCBREO0Suq6ur2trasowP4315eWlji+lQlmS0ZaA2GGe9vb3a2tqyyaBLS0sG1zD6GKdFynx0dGS0Xor4QCfAeIiPukoOg4OD7zQPh2IsLBaMPQVNepJwxETk4Ox8tnq9rpWVFW1tbVlvgetUoIaXy2WTl0Gl4E1Y1ufzaWtry2ZdzM3Nqd1umxRKT0+PZmdnO+BaxBTJ9ogMgehciJgggH4mV6m6mwVtent7W6urqx09LhTL6QtiH4h4z87ODH5st9t6+vTpb73DnAN6LTBeZMAUt1GWDgaDVo+D4gxk2Ww2NTw8bIV0AkyMZKlUsrlFQIk4PybfYqPcLvZuF3cYp8fv45k5F+64C1o2ELOkHkVA0W63lUwmO2qdqD4waVdSx2wcJqwyOXdtbU3r6+umC9hsXo0tzuVy1kDMHWBvXSHbUqlkyuvZbNayU4aYEQjE4/H/f9hiMBVgakQiEUu98NAwNrj40hWF+eLiwh7y8vJKDLJcLmtyctIKhERpGC4UUinckgoDe7DZz58/1+bmpm7duqXPP/9ctVrNtMIoQFarVR0eHlqkD6yC0YQthN4W3d9EKu321bhjCsLdrHg8bvtyeHhoTpLeAkkdUe6b2C4OgaLw+fm57R/OhaJlPp9XsVi04WIU3GGZQaH1+/1aXV1VLpfTzZs39dlnn+ni4kIPHjzQ8fGx7t69qxs3bhjNm4OPJE80GpXP57PmLvDYQCBgIpFg3AMDA+9ERXadC3L+RHatVkvRaNT6XGCNufNz3FoHRfWpqSlNT093NDCS8ZTLZe3v7xtjioI7WQnfs7q6qoODA925c0f37t1TrVbTt99+q+PjY/X392tmZkZnZ2eWqZycnNh5c9lM7J1LoSbw8Puv5GbcbLqbhYHZ2dnRkydPFAwGrcEZ2BMIGSNEsIYB6u29GpL27NkzHR0daWlpSTdv3uxwLjxPoVDQixcvFAgEdOfOHVN24LlSqZQCgYBevnypbDZr70OS9Wgh2wOrkggeQszg4KAkWSaGcwmFQoaQcM9RbOh2D6Fmk61Rn+C9kSlwxmHTok7gQtbA0/Q2SbLG052dHRME3dvbUygU0t27d62H6+zszJQn+vr69PTpU+3t7enevXv6h//wH+r8/FwbGxvK5/OanZ1VJpMx9RFqx2RB+XzenG8wGFQul+twLtQyKWe8TTvGtZ0L8y5QHXb1fdxCHpEN6TCF5Wg0qoGBAet+l2Q9AbDFOBT8TDdFpDaDU4GyCcfdbYpkvgSGmSi03W5bRpJIJDQxMWFcbxq+IC6QnpPmlkol7ezsdH0wYYcEg0EbecszSbJuYyAJmEHUUWCLoS+EoUQymwsEaQH2HdkQe0vzKkaUgUFAZjChwNJRm4WqymWNRqMaHR01mIa6AFDm4eGhTTfs6+uzcccej8co42+z6JWKxWIaHx+3pjqX4MC5cWmoXAwgGJwwVNlCoWCXFOcCnAo7ib/DGAeDQWPVAEXwB/mecrls+4zcOTUssqyJiQkjcZyfn3dkUpLMEAANY8C6XYz/TSQSpjJNsPZm5kkG6xprsifQBIwSUjuu3hdMtIWFBYNmXIaV3+/vuMNk225PHOc8EAhYqwOOnfNOKwNQKQxPYGao9j09PfYzu100EksyWPpNkg/wMYgDpCb6+ggE6W3ibFC/Ya8g27hnj8yI0dKS7Hxxj7GHMGpHRkbMmaAe39/fbxn53NycvXPOAjYcVXUC0Uqloo2NDXm9Xn3wwQd/735d27n87Gc/k9fr1eLiou7evdshnkgKi/FCAoOu43Q6rXQ6bXPY/X6/FfaePn2qdDqt+/fvm44Skg/Qgzc2NnR0dKRAIKCxsTH5fD7rOchms1aopt9hZ2dHR0dHJiaXy+Wsgejf+Xf+HWUyGaXTad2+fVulUklPnz5VsVg0bDIQCFjDGUXEtbU1c1D/8l/+y7c6lNLVuF+//2pY1Pe+972OLnZeJHt0dnamly9f2gUNBoOKx+MaHR01A4vM97fffms1Ly4R+mKDg4PWjEojKNkPzB3w43Q6bZHh7u6uFV2BNl+9eiWPx6NPPvlEk5OTNsvn7OxMy8vLVoAFt//666/V19en3/3d39Xo6Kg2Njb0y1/+Uu12W//4H//jt94/oMG5uTl99NFHOj091e7urmWDBD50LHMZEYVElZsaTblcVjab1aNHjzQwMGBRNNDF0NCQPv30U0kySCOVSlmGzbyfzc1N07QbGhpSo9HQ5uamya/39fUpn8/bMLypqSn19/drdHRU09PTOjs70+PHjzt0xjDgwMPAe/v7+2+9b+5iJs7i4qJ+9KMfWXaGkyyXyzZiFz2ri4sLc6rcb0kGP25sbOjx48emzgE1/vz8XBMTE/pH/+gfqdW6mnWPA4D9lc/nrU8ul8spEolYdsgQMoxlsVjU6uqqqUSk02kzvuVyWQ8ePFC5XLY6BJRzKOX87KOjI7Xbbf2Tf/JP3nr//s2/+Tfy+a4GDt6/f1/n5+dGxiBrSqfTGh4etibps7Mzzc/PmwR+NBpVrVbT8vKyCoWCkXJisZjm5+fV19en6enpjmC9VqtpfX1dp6enVutDKoa9oUduc3NT5XJZr169Ui6XM8HRfD6v9fV1tdttDQ8Pa3BwUEtLS/r+97+vs7MzraysmII3bM+dnR0FAgHdvHlTfX192tra0i9/+Us1m03903/6T//e/XorbTEwaSJAFtE/GC6UNYT2SPExfmDK4Lqu5hCFsN7eXpuJ4WoNcbl5mZAK8OBElERAkuz3EFFRd6CO5NKgXf0u8EbICAg1drPo7sXwEYW6eC14rtSpxURGQFbjUmTPz88teiPKJJoPh8OGv4K3Qo+l7sR7Awsn+yNi5mtd5V80u5ju5zJyeD+oA/B+yDSIjt92wb2nqYt35r5j9pDP7Oow4fioMbh0ZFe3jv3AMfAzwdjJzNwz1mq1zCmxV9QAIKgQhPF7aFrj80mv6aI4Frd+wXO+CywGddzr9drQL5fa7f4uMmu3X4QaIdAXn8XVYXMp036/vwNK4n1AUnDPmPs7ue9kTmR3OCY+J20NZCw8G2Qj6PeQTmAadkuKIIBi34BcJXU8l3tmXJVhGHKu9pxrj5BqogaLU8f2kZFTimAf3OZVUAhXfYLP5BJ9ms2mQYWgHWSKZFd8dqB0gpDrNqJe27nQU7Gzs2OsD6ASukGZpFgul7W9vW0YItLSCwsLBkWgkEuDWj6f1+npqRECXGjr0aNHNuWPnhkmUaZSKduQ7e1tNRoNS0MzmYwWFhaUTCYtNcxms8rlcjbXgxQfSRh0sogkXWOdyWS6Pphc0qdPnxptErkM16DAEmPYFTL7MzMzmpubs6iOojZNaq7jlGQKp7VazaJGlwMPJx4piHa7rY2NDbvAqNZ++umnyufz6unpMRWBQqFgOkPsXyKRsImgroFwGz3fZf8gc0DyIOputVoGg+zt7Vmz4dramqnwktZTD8zn8zo4ODCadyAQMLmQSCRimeGjR490fn5umRkNZ8AbHo9Hk5OTNmm1UCiYEZNkkkHRaFS7u7umAgDOjeMZGhpSIpHQ8vKyZcwuicPr9Wp0dNTqk90umIgPHz7Uy5cvTbIG4+H1XqkKS1esodXVVZPMQTYGKZZHjx4pm83K7/db4yMN0O12W6FQSEdHR/rZz36mWq2m7e1tU+uoVqsdjbnJZNJgIcYio649PDysTz75RAcHB7q4uDA20/7+vkZHR41EwYyotbU1bW1tdbBTCYJ6eno0Pj7etYNGfgemKdkvDlC6Up4Oh8M2OhuItVwua2FhQXfv3lWtVtODBw86mlDr9brW1tYs04KkwrCz7e1tFQoFgwS9Xq/Z1WazaU58a2tL9XpdoVDIpHCo1WQyGYNtV1ZWtLu7a0PvmBicz+ctg8e5Eyz19fVpYmLiu6ci80JgI52cnFg3M4UzIkYwP2S06/W6Td2jSA0MlUgkJMkKnCgGU0Oh1sF4WS44KsDUADwej1GRwa6TyaSGh4fV09NjctsrKyvK5/NKp9OmAjAzM2O8fiAjDADzK8Deu10Y/f39fSvuIivuNoHyIjnAqEcjL395eWkyO+iLwTpxO+5hnHAwYScR+VDjAuOVZBMSJVn/AbO1keJeW1vrEMQEDiLLwxjyc05PT01rC+pqN4ueJ4yTKxQpXREmoA1XKhXt7e1Z5AXryMW7C4WChoaGfqMOSG2BscWlUknPnz9XoVDQ2NiYMplMx/4xJpjaHtG4dAUdMTiKc040i7gqhedEImEDzmAjcemh4I6OjnZNiOB3t9ttg/kwHD6fz4QrET4EdiUzhqQBNp/NZrW2tqaJiQnrWyOoIABELPH8/Fy5XM6yEXT8YIFx/gkq3eJ8IpHQ9PS0enp6tL6+Lp/PZzC533811AoFDkk2CIuMxe/3W/tCPB63ekM3i6ZPgt5yuWw2kDoSCyQA+jzBVSKR6EABqDHDJJVe9+K4MO3x8bGOj4+NnedmSa1WyxwoRAEIJ5FIRJFIRLVazYgR1GcIKGKxmG7dumXQJ8gImY+bXUG9vs66tnNxZ1RQ+MHYUoTkssD/9nq96u/vN8EzFzoA2mITuax4ZeCzWCym27dvmzQCVF3SPQwwRVKfz6dMJmMOZ21tzZrtPJ6rWRz8LlgfNG4dHh5a4xDMJhq6eJHdLhg4wEqMOkU+BJohdYLR0VEz2MFg0LIssg16Cur1uhUCXbl9yBRAcBwOsgiYcfwJBAKG9dMf4PF4tLGxYWOeKQZT0CdShQVD4BEIBGwsMmw8N6LvZrlEEUkd8Orw8LCNbOA8MtY6kUgoHA6rv7/fAhbOMXUF18C5Eh1Eqnfu3NHFxYXS6bT6+/vNcAD/4khx1hjgi4sLvXjxwi48fVZ05QPhAnegwB2LxUxdHCOSz+f19ddfy+Px6A/+4A+62sP+/n4LPNyoGScJhVa6ctaoWOMshoaGJL0eLMX9KZVKdjc5Y2hokVG7IpjAi1CrgWo4g729vRofHzdCA3t4enqqWq2mkZERUw93STutVsvaCnCGvJNG40o37vj4uKu9cxf3tKenx+bgkInyd4FAQENDQxaAUa+C6Qm5AjgNViLB0snJiTWl+v1+zc/P26hsnsfVwwNq474TTPX19Rma4IraQmICKtvf35ff79fBwYGKfzdRdHp62gIdUKq3gbWv7VxGR0ft33EIOBe3ZgJMcevWLeNFo/mzt7dnAovQPSkijY6OdnhkDGMkEtHExESHTMzR0ZGePHliLDE4+PRz3L59W7FYTFtbW/rmm2+M6kwvTF9fn05OTgwC29jYMLgpl8tpdHRU9+/fl9/v18bGhjWAAS11syjGk0Gl02nNz88bcy0YDOrg4EA7OztKpVL6wQ9+YGQCinr8/kgkomQyaVEwzh0jwOHDoc7Pz1svAw2nDx48MDVbOnDpHRobG7NC6aNHjwziohjY29tr2We5XLb0nIM5PDxsA542NjYMckLFuJvFTA8gPZddQ6c3z5xMJnXv3j1j3fh8PstWkPahi//4+NiK/dFo1JwR5zoajerWrVsdczMKhYIeP35szw7MAymAf1YqFf3yl7+0oCQcDmtxcVEDAwPa3t7WixcvOmo++/v7VpSemJhQb2+vjo6OdHZ2pq2tLf3qV79Su93Wf/Vf/Vdd7eHY2Jja7baOjo4sGAOWpony4OBA+/v7SqVS+vTTT63ZLxgM2rAqaNNer9cowuyhO23RVXJmvAZ7WCwW9fLlyw4twXA4bJna5OSkZR1ffPGFoQler9dGBB8eHtqYb7ImhEHT6bR1zFNHRMm92yCRu09wHA6HLZvE/lFrHh4e1k9/+lOT3ofS/fXXX6tSqejo6MiMe7t9NfdnbGxMfv+Vdhoq8QTrH3/8sWl9ERwCA5Pp9fb2GilqcXFRsVjMlK9RlfD7/cbKOzs7MwFN6Pn7+/vK5XIaGhrSnTt35PV69fLly459vu66tnPBKJCGuYUeog2iYIpVLm2WQhPFJopwHEDqDq76K5EUxACiaX4u3cUUrzEMrjaR9Fp2BriGQhwFfQ4bF4OmIRwS/yQt7ma5Xf4UN6FKurRhl+zAcwJfUIfCIUDthGoMZZuMEGNM4ZnDTOEU5wPtm9oFPTawelx+PpGo9Dqb4LncTAl4jM9IZvsuF5s9cSUoKOQiV+MW5N33DRzA+Wo0GmbsYBdBAecCc+bdeRpEcmjQgbe79G8yTAr0PDOwJkVl99w3Gg2bpOmOy3UVK961w9x9p0TIZHKcFVdNgK8jeITqSq8TRftwONwBp1BId4v7ZDv8fn4ebDiXxPOmqgGfizoXwQ7UfnePCXpxYhAWeHfvgkC8aQOxQShuBwIBgzOxhxA73oSxgGvJmt1xCgSSoVCog/zgjqnGOTDniGd2fxbfy9nlrLnSWsBykJW4D9TReV7e59s0oV77K6HwYZTo8AwGg/rRj36ksbExi6SBU97ENknJDw4OdHh4qMXFRS0tLXUwoQ4ODpTL5ZROp+0QICUDhe7g4ECvXr1StVrV5OSkDeC6ffu2fVYKlTRZcaCRt6eewGcicspkMh24JtTqd73YpJrogzELoq+vTz/+8Y8tQ2GOCx347rAooMTt7W2dnJxoYWFBS0tL5hxarZY19UWjUet2JlscHBzUwMCACoWC1tfXVa/XlclklEqlNDExoVu3blkHezabNbVfnHG9fjWUibkxaBZR+KvX63a5gS2JfCFQvAshotVqGWEEOAbpG4rwqD/kcjkbbsVZAM6iY/revXv6+OOPDVqAcl0sFpVMJo26vLKyYlTugYEBo7ZfXFxofHzcZtV89NFHqtfrevr0qY6OjqyuQJDQbDa1u7urV69eKZVKaXFx0YxUo9FQKpXS+Pi4SXpIsmdFU+tdzuDR0ZEkGVutVCppe3vbaiqulEur1TK4hcwTg0jGB1T44YcfWmDRarUs24/FYkqn02bQ2u22+vv7lUqldHBwoKdPn6parSqTydh+3759W5eXl1pbW1OlUrEpmOfn5zYAbnNzU8vLyxofH9fCwoJarZY1zVIPA1qE9edG/N3uocvagqi0tbWlSCSin/zkJ5qamjKH02q19PTpU3k8HpNaury8NPgWx4N6MvtKwy1jD6amptRoNPTkyRNDGCBLPH36VLVaTePj45qZmVEikdDw8LAkGbkKeNythaIZNzMzozt37tjnoikVpiyqHDjHt61ZXdu5kD24jYro64AxutExmD4vgggWFggePpFImPHm8uO0SL/B7F04yMWNYfikUinrfQGDhFpM9ETUSXMfy4WRwDWJLMDQ34UGSuQmvcaqC4WCQqGQRSRkEdJrZg+jS4ne0LyCCZNKpSzqpiENyQimIJZKJUube3t7rSiO0yDzS6VSpqPF9EiK4NRyiHrQUpJea6QBrbl77io6v4v0hkujJHIFZ+f8SbLMjUJ1qVTS0dGRRcA0iyIQOjw8bMw9oBP6maiTAU2RiRWLRetvoMAfiUSUTqdNjRddJhop+WwYZgqt7D/wGJ3S3Cf2nbP8Ls6FIIWfh6JDIBCw8+BG52Rs9FC4ZwCjEwwGjagBcsFs+1arZX1rbqYRCl2NJaeWh4gqdQkCCe4j54xIHtYi/StE9rBEIRWg6OEiLO+yh3wfz4kdJFOGSejxeIzE4MLA3G/uAXYxFovZz+J+Qcjh92EHYrGY3WnO4NTUVAfRCUfF++a9ERxAyKL2C+PXbRkh43czLrLU71z+BRyauRrVatWK9ggjsoEwjbh0cKgRvARHJGKs1+uG5RaLRTPk4OoUvlOplOnw3Lx505o04/G4KpWKHjx4oEbjSiSvXq8bG4IN4iIPDw+rUqnoiy++sH4DoDyKaIHA68mXXIx3udgQImBgcJkoeL98+dIywkAgYMOVMpmMRRXM+jg+PrbDwrMWi0XLLNg74CimW8bjccNhgdeoiVWrVT1+/Njkcy4uLpTNZnV0dNTR50GB8vLyagjRmx3yQEMYAhozXViwm0WgQd0IB9jTczVga3Nz01hsbn/Q8PCw+vv7LahA2gcnns1mjdXkilu6Hf9LS0vyeK4mhUJQoXBM02GpVNKvf/3rDqFQnDzsMAwNc46ePXvWEbRAS2+1Xs+oL/7dgDwIGe+yhzwXki8U1D0ej8rlsrUZAA0SwAwNDSmVSpkBhOLtUmKr1aqxy9weJxwKjEyMfrvd1tLSki4uLkzeqVqt6tGjR5YVICaLoTw9PbXonVHraJwhYkrN0IWUCYhhr3a7pqam7N8JVtmj09NTPXv2zNhw2K5QKGRnlv0DYpKusklqbwQ4Ho/H5HjOzs4UCoU0OzvbAZ0jxkr2g/Dn+vq6MV5dx+bzvR6UGA6HtbCwoGq1qn/zb/6N9Y5Rt8bhuKw1SC7Y5+ust5rnQooHtW1wcFAXFxfa3d014TQkP8bHx004sr+/X0dHR1pfXzfeNz0HRIWrq6u6uLjokDKB7TA/P2/aYhhMmDXQ546OjvTq1SsrnmFc3PoLQoLpdFqvXr3Sw4cP1dvbazLoqVTKog+3UfFN7axuFlEwhw84B0NCtzJFPLDkkZERTU1N6fj42CjFiBm2WleTNiuVinZ2dqy+5Xb3RiIRTU5O2ihg/l+hULAAIRKJGOXbZZNwwe2w+P02IjiXy5nsON3SrrSHq5pcLpftfXa7CBboqXFxa4ghyInw/hEc7evrsw53sj3qWqhpb25umrMi+kSCY2xszAql9BXt7e2pUqmov79f0WhU5XLZ+iuI6nEUQB2SbP+AJj2e11MDY7GYIpGIwTeuc6G/4btYkA+I7Kn/AaNwzqHKDgwMKBKJ6PT0VPv7+0ZaAMPn/H777beqVCoGheJcODf0W/Bu5ufndX5+bs/PPpFpSK9rQmSrOPlwOKxisajl5WVJryefzs7OamRkxPrwqF9Q56UW181ifjyZODXARqOhXC5nI6Pr9boikYh13KN7h6SS29BM0EFgCEuxv79fwWDQoL7JyUlDImCUotsYj8cVCARM2dx1KnxGmLV+v1+zs7MaHx/X48eP9fOf/1yBQEBzc3NGrAJ+BRGhjtpsNo2yf5311n0uRC6h0NXkMx4UYTbpKrtBmr1UKlnE7T4c2KB05VXBpmGm0PwGS4WD4fP5TDeHwrbbNU7tAnyx1brqq0Gd9fT0VD09PablFQwG7fso+jILwsVG+ZzdLmilGItEImHzvN2iPYqxAwMDCgaD1lBJ9OX1ejU+Pq6RkRGj1rr7Bh0UyXFgAL623W6b03iTkgwZgsIpjpCGRUn2fS4RAqdFUx5GkvMALER63s0ibacnJRwOG56PICrjniF20NiLMjIwD0GE22U9PDzc4UjT6bRl38AM7BcyQzhOLjCZAOrPyHQA8WAgMRoY3mg0at+LMXUdMRc9FAq9EzQLvISx7e3t1ejoaAeBg/6NWCxmEvBAi7zzQOBqMiK9JZzLoaEhJZNJE1VMpVKm5Qd1lgyCgIBgAEeM4aZnioXEidu07Z4rV439+PjYCEPSFbTMe6aW2s3CDvBPhoBJr6nt6PORsYRCIYMcedaenh5rviXLhnEGlAhBBDozJArQGEZMc2a529Tq3lQOcO9wqVRST0+PfS/wLSMMkH7iHWCbIJxcd13buQAvZbNZHR8f6+bNm/rJT35icBkfulgsGife6/XqV7/6lZaXlxWLxTQyMqJIJKLf//3fVyKR0DfffKOvvvpK4XDY0mY60mFB1et108vhBZ2fn9tBw5gmk0mNjo4qEolobGzMoLjz83Otra3p2bNnVoeB5ZNOp9XX16fh4WGFQiE9f/5c6+vrmp6e1vz8vBkNlAMwvt0sIjkaEe/fv68f/OAHisfjFkkdHx+rUChYEbLdbtuYXjez+vzzzzUwMKCf//zn+qu/+iu77EjdM9+EAjr9O664YvHvJOlp2hsYGLAMDlo4l+XFixd68uSJ1VowjkRfRPPLy8va2NjQxMSEpqambK9cmZRuF+SEbDar3d1dzc3N6ebNm9bv4/VezfLY3d21fhK/36+nT59qY2PDsqpQKKTFxUXrmt/e3lYgENC9e/eMNXN+fq5MJqNbt26p1Wppc3PT4D0YjzTGwRZKpVJ2jhg34GbA7hyTdrttFFwyo1gspp2dHeVyOfv8LpEikUi8UwOgdOUwm82m1tbWtLe3p9u3b+vHP/6xRb70Oezs7CgUCimTycjn8+mLL77Q8vKyUqmUpqamFIlErNXg2bNnevz4sQKBgD7++GOr33GXBwcH1Ww2dXh4qKOjI+s1QWkbggv1VxqyZ2dnDUXwer168eKFvvrqK4M2OVfAsuz56empDg8PTbW92WyajDzEkm738OTkpIPUNDY2pqWlJTPMwGM0ouLMV1ZWjA7c39+vvr4+/fSnP7XG2RcvXlgW7vF4NDAwYGSaTCaji4sLPX36tKNWVywWTW2ZNTMzow8//NCQH7cOtrm5qadPn9oIdFSSQTIY2La9va2DgwNrJ4DBe3x8rHg8rsnJye8eFnNppKRZ0utRnDQQIalNlA/OiNyI1+u1jYNdIskuPtAXP6/RaFhGgbFz6bZudMMFcRfwhmvoGLbDJeCZoLn+24zguxT1qeG42Y/X6zVsFmaGq/RLusykTKC+UChkRtVt6GLf3Kil2Wx2dOUSAfG87vt8M93/bfsAdCepQ4fIpQe7i8/g7mE3Cwbam+/XjVrJSl0qN3UsSRb5UzeCZgtkB5HD1aiCKAGRAmVd9syFwd6kDZMR8Ny8e96jW9wlwnRps28+K3XDbhdZGFEyv4dMIRAIqFQqWeGb5wFacmcNMTuHnipgWPd7eX63dcCF31ySBs/HO3hzL96k8bKnfD3f78K6BG38v3edh8Peu/Re/j+2i1qgewfpQ+GuSDL2n/uZqGGx76694fyB3mAHXajeJdC4NtqllUPl5k5QY+Heu6Qst53BpcVfl5hzbeeCLlg8Htfx8bF6enr013/91xYJ9vf36+DgQHt7e5Y1cPDw7DT7wbBg8JTbbYraMU6Ah4Hd4hbEpddyHfQQFAoFi3BwHpeXl5qYmDA89PT0VOPj45qfn1etVtPGxobBFWhBIe9NZO4a7W4W1Orp6Wm7EH/1V39lxTXqUoeHh5a5SOpQNADuQ5H3+Pi4o8u30WhoeXm5I0pz8WW3HiHJeguIsIlQ/vIv/1KlUskkJBqNhsGYvD8a8Gq1mra2tqwD+LPPPrPMxmW2wfLqFpKgCZUswefz6csvv1QoFNKNGzfU399vrCaK/LDryDq5SJLszB0eHlqzHlktUTXKDQQdQDntdtvqFW6NC/LHo0ePdHZ2ZvAwjB4II9BlgeWeP3+uer1u1F1XlBPYFnj0XVY6nTYDND09LY/Ho7/9279VOBzWvXv3NDw8bHUB3j1BDRAyz4uBAjLDqQDhECHjaDCchUJB+Xze5rmQ2Xk8Hht+1Wg09LOf/czuZCgUUqVSsb+nfshe1mo17e3tqVarGV22t/dqtDTkgFwuZ++v23tMzQXSSCAQ0M7Ojilb0KC8srJiRpmvZww59xT7wpjjQCBgyhivXr0ylXR+J+cTeBw4W3otH0XJ4Pz8XI8ePTJKPaM6GKaINmR/f7/u3LljdV8yrqmpKQWDQVMmyWQyisVihhxcd13buVB8JlM5Pj420TOYTeCibzYwUYzk0oAP0tRG8590BQ25Mwn8fr/Gx8cNVsKYgj3S3EiUVKlU9OTJE5ORZ8zt6OioPB6P9vf3bTYGlwk4an5+XiMjI/J6vdb5CjX0XVckElGr1eqQD1lZWbH5DKTUSLVjhN+UFwG6eZPFRoRIYRFaJ3ADl9tdZEgYABg533zzjfb29qyInUgkNDs7a9kXDJWhoSFjyRSLRSMfkMG6arlknt06F7BtnOzp6am2trZMZgN6a6lUssjK57uaz8K0Tv7pMn0qlYplMFBmcYoU0uPxuGHUUJxd2Itos9W60jZ79eqVaZdBl0WOA0NKobdYLNrIh8XFRQ0NDXUQCsiqXLZlt4vMgzpQLpfTs2fPrGDsak/RTsBZZO/cjATpJSA+agu5XM4ME+gCkvPUCsD5QURw2DQirq6uWq+VO4+IgAiyTywWs1ob8DU1GT6nq/v2NvIlb65kMinp9Qjti4sLHR8fq7e31yB/anJAXCA1ZMpkV2Q3OHO0ED2eq/k4qDWASuCECdLIniUZfdiFsJaXl3VwcKCxsTH7bKisQAwKh8Oam5szMdDT01MNDg4a8YLsJpFIKB6PK5/Pv9XYh2s7l42NDUmvYYhYLGZaQ3CmPR6PzVvhUFJTYHPhz/OCiIgoCuMMCoWC0WtpyOSyup2vOBQK1z09PZqamrJucwTr0JrCsTWbTZNPwGnS4InT4gDBkX8X4cqnT59Kku0T0avP57MhPmg8kUrjjCjUg+uSDrfb7Y7OXL/fb/g9BhJ5m2azqYmJid9QhaUozaRL6Qq7dVlzsP+QpoBzTx2Bc8GMGpft1G63rTj8LjRQ1Hr5XRhdMjmgD96zC5eC6UvqaGgEUiBThKZMAMRU1MPDQzWbTeslcKEBnD+GkUZcmGWQG9Czw8gRWUuvO6CZvopR5rMicYNx63Yxk4ez1G63rdGQ+ketVlM0GjWnKcnEOYHVIG7gWFwjh7gh8+FxMrw/DCHUVjJctMW4B6OjozZ0iyI+LQkYWXpCgNvcgJTgE+IOkkYM2ep2kXm4793r9Wpvb8/aKqanp43EIcnOBsGc6yhjsZiGh4eN7tvT06MbN25oYWHB+vloHG40GpqZmdHs7KzV+tCnQy08Go2q2Wxa+wGBJRC29FofknvK7yBjxQm6cKV0hVq8jTL3tZ3L8vKyvF6vdcSzGSj4np2daXFxUbdv31ar1bLJe/39/Zb1cFAwSBTk4dwjQQI2vb29bbpKZ2dn+vGPf6z79+8bMwhueLlcNvirt7fXZsHTt9Df32/y8EBtjUbDutRhcFDwdmmzYLccgm4N5BdffCGv12vD03DQNOnlcjlNTU1pbm7O6N1oFEWjUctMiI5hmcBIATOnKXV3d1fLy8s2zItudjS/gHt2d3d1cnJi6XM4HNadO3dsVvnFxYUGBwe1sLAgj+dKXPHw8ND0kchGKKi7hAGowAwWg0XVzXr16pX9PCTaiXr39/eVz+dNqYE9gtbJe8QgQDnGuZDd9fX1mWLB1taWHj58qHK5rCdPnujk5ET3799XJpOxn8cZo7kNOvb8/LxlONQzUIpwx1aTxQC7YZwgCkjqYA4NDAy8EzSLzt7ExIQpWWcyGbVaV8oYGxsbGhkZ0djYmH0uSRoZGdH4+Lg1gF5eXppqONMWyVA4136/34aN0WpQKpW0tLRkWnc8N068t7fX7uLs7KxpheVyOUWjURvpzShelCGY/MmYAiAjGKbDw8MmbvouZ5CFU8NJNJtNra+vmw28c+eONT66jDb2h+DV4/EYScL9msXFRY2OjurJkyf6i7/4Cx0fH+vly5eqVCqamprShx9+qHK5rJ6eq9EMKysrpqhMm0ImkzE2H+gLd8GVHEIfMJ/Pm4PCzhDAck4nJyc1Nzd3bdbsWxX0Ke4hVMgfNotUmuyEw0ME4XbcUsgGUiMiaLfb9uFdCRYom319ffZzwLyBrRCwdOEKMGO63ElXiWLAjSmAuX/cAh4vqduDSTEZ40aE4PbhgGO7ark0aUFu4MUT4QHZEP3yWcHJcfBkSuwp2SMwAzRUAgDeKe8GUgG0UdhrlUqlo6AKxMHlcbMwMo1ulkttZn/cngkIIFCzaeTDkbrnT3otgULtgzMHXHF+ft4hnkrm4opaEsVzB9zL6PZT8G7YD7fbuVarGezhEiTYP86z9DrQ6XZhWLnHQFEuxEzE7UauLpztjv+G6QXdmKwCAgQZh/u76flwiQ/UT6HlEzm70KDr7CBpkEk2m80OQgbnDNvDO3jXBlTeXbVa1fHxsWUf/H/uFawy92xgexqNhiEhfDbIKtggVEooGVBnJMhAYZqz4cq7APu9WXTn3ZK5NptN+1nSFfTFveW9u9m+9JrIcF3W57Wdy+LioprNplZWVvTNN9+Y3IUrGnl2dqZf//rXVpfhEEMhPjs7U29vr2ZnZ01FdWpqSmdnZ9rZ2THeOy8EEgH6Ojdu3NDo6KjVdlqtlpLJpNLptCqVitbW1oyWy6Gm+/jFixd2QPx+v6anp/XRRx/p5OREf/7nf25qqRgrMhfqGjAounUuFM62t7e1urpq2l8cDOoIz58/7zDIpVLJfj+RGAcNZWX2j0MJnkoxkHnpU1NTmpiYULFYtOFLsFYuL68GQLkOAkZdtVrVl19+af8vFotpbm5On332mfL5vA3C4mIjyc/nPzk5UU9Pj9WzulkffPCB7R/NirCUyIqq1apevHhhcAzd3EAwUFeBTKPRqD755BOL4Gq1mh4/fmy9OsxZQY12dnZWs7OzFiCgyQSLhw5oFo663W5btz49W5FIRHNzc6awXK/XlU6nlUwmravcZaC1Wq13lov//PPPLdND+wsDyfhi1MFdJ/Mmy8jn8xlcOz4+rtu3bxvBBO27w8ND9ff3mxIz1OrJyUmNj49bP0Wj0TC0otFoaHd312B0nCrBI/qGe3t7KhaLunv3rj744AMdHR1pY2NDl5eXNm6ZehoZP/1IUveMRWzA+vq6Xr16pYGBAS0sLBjsGolEtL+/r83NTfX09FjgAtyFHqPP57M2CIZ0IT1Ur9f16NEj6ycDlbh586aCwaA+/vhju0fAXaiW+Hy+DpkiNzuGYeb3+zU3N2fB4dDQkNXWTk5OdHBwoHw+r76+PusjI0PkDH7nsBj4J/heq9Uy/BJIBo+OYYbdAPMLmiP1EoqlLuWTTcVgSK8plC4fH0cAFEEPgiugiIe9vLw04UgOgjv4xi20Sq/TUw6jO1Kg2xWLxSySIirmv4kQ6MtxDz/OmSIehUyiNKIQInPgAb6OQ+YSL/gMFxcXpnAArkv0QsRIURxMPplM2vckk0mLvN3PTMGbhjbIEe+6f2SdNH/xfnFoPAPOhXdGVgjtmEyNQiVnE2cIS4wmV6JOMj9+FhGoJCu08vw4BDIA4EPeJbVLFCkIMthL6pNcardG1O2iz4UeMVfJgHcO5ONSrF3nQoBTq9VsL9PptNXgJJkRdQvZZL00V7tUWyjMSBJhDLkX2BMyAWossO+479Rt+Xqcu6siTgbZzSK7oB6HDJKbpSJZAwvTVVWoVqsmz8QZdEdkkM1BMqKRkYZ1yDUuKoAdRbgWmwJJR1LH/ksy8gBqKx6PxzIXpqlKssCD0sHbqpRc27nAEhgYGDDxND4sl9pV8OUB2ZTDw0O9evXKNq9er2tra8teDikfzX2uPhVOY39/X8ViUaVSSevr6wb5QMWbm5tTvV7XwcGBarWaIpGIOUXX2LDAg3d2dnR8fGw1mkwmo48++kjtdlvb29va2dmxLKnbLn2EKDOZjBEhKNpSu3C1g4h6KIRXKhXDVam5VKtVG6VK74Akg7NwJK7u2NbWlk5OTvT8+XPbew7nxMSEEQCg0sZiMWu4gsZN0ECkSkZ6enqqSqWi4eFhzczMqNVq2Ywc2FHd7t/6+rrBOGhSQQvm7KEC0dNzNc6WLC8ajZpBcI1lLpczQUYuOfRYZHHY73q9brXF8/PzjiI/dPhYLKaLiwurEQ4ODlrEzsCmg4MD20MULCiO7+zs2Dyf2dlZtdttra6uqlAoWJT7LosziGgrPRnQk4lu6W53J0USgCAvAhoBRdp1iEjGuIP9oNDu7OyY5BNSL8PDw4rH4/L5fBbFb29vq1qtamhoSENDQ9Y4jeZdsVjUysqK0um0BbA+n0/ZbFZ7e3s2E6fVulK1Pjo6smCy2+x5b29PrVZLo6Oj1rSJVApq6wQtwGXNZlOpVEojIyPa3d01hIRAemNjQy9evFAwGNTIyIipe19eXlpjLuSos7MzPX/+XFtbW8rn8zaGm7oc6BCBAE4PpwXyAgsSxiefo1wua3NzU7u7u+rp6bH64vLystbX1zU3N2dtGddZ13YuDOqhUFQsFrW7u2tSDlBO6/W6edZAIKCxsTGNj49rfX3dtH6QhDk6OlI+n1d/f7/u379vfH6X7uk2+jHcCyl1IAfS4fHxcZVKJZtFPj09bXi52+EPbRKxzEKhYEOPjo+PFY1GrQBbLpe1vb2tWCymmZmZazcQvblIV9k/LurZ2ZmKxaJOTk4sBUbaxK2TUHDDIEDfJtV150EAT7F/pVLJYJxm87VKQLvdNmFHYKDT01M9fvzYpidCgyUjwNEfHR1ZdzuZK2Nf3QI22QtNd91e7K2tLdOoGh4eNkPJeXJrMAQ1GLlEImH7jVNG4DSbzSoSiWhmZsacOhRX4DAyDs4rIo+tVktzc3MaGhpSX1+f/Z5CoaBCoWACkew5GnDMQo/H45ZtAiudnp5qdnZWd+/eNUOwu7trPUvvUozG8KAhVSgUtLKyYj0bZKmIZBK4pdNpxWIxg7HcwMJVHpiYmLBARXpNfQZiI0ME9svn8x31uWQyabbl8PBQuVxOyWTSephoUygUCjo9PdXOzo6i0ai9H5/Pp1wup8PDQ01NTenmzZvyeDzGAoVd2e0ZzOVy8vl8mpub0/j4uDlXUIDT01NFIhGDGLlviURC4+PjHTppfN69vT3t7OxoaGjIFEaoqaTTaeuPgtlKcIJzbbVaNnQQJ06mjnNxa46832azqf7+fo2MjFjgRLCazWY1Ojpqqhj5fF5Pnz5VOBw2EdfrrGtbSmRCwH0RoKQB7eLioqOOAHRDtOGmyTwcxTicCvCBK3joFpCgLXu93g4ZdUnW+Far1QxO8/l8BocNDAyo3W53QHKuaoDP59PIyIhGR0c1OjpqFOX+/n7NzMwonU5LUkfm8zaL5i0McbPZVCwWUyAQsOfncrlZB0OpYBhRuATaAoLhn24zG/uD6Ki7l5FIxA4/0Wu7fSWsCdSGcSNac0kDbl0KmApRSXBcqK6Li4tGMe/2YsMEQu+o2Wx2NNHBDAPfpsvbHdGMEYPZRK2Jc+x+NrJKjDGXF5IAQqM4Kxw8ulLxeNzYTpxxzhu9BHRZQ0yhLwvHDJllaGhI/f3978RWlK7QB3p5otGo6vW66bIRPCC79CbtmEAGlIAgEmLObxtuBvQmyWSdgFdcrTCIK24/CqxH5J+ozbgQPPL6QF+NRsNqLii2cwbb7bapWr9LzYX74vbxSK+hUHeOEs6kVCppbW1NhULBCu+cUfYbKj8BnFtnhRGHKjSQIdCzm0lwx7nnMCR7enrs/rFnQGk8g9fr1cjIiAYHBzU8PGwU/3Q6rRs3bmhgYMCC/eusazuXg4MDiwJyuZwSiYR1ve/u7ur4+FgTExP63ve+p1arZQfyxYsXNjZzYWGhYxPD4bAGBgY6MH1eoCS73BgymCZEhrApJFn0T6+H3++3qGBgYEAffvhhx+TJSqWi09NT8+xer1cffvihFhcXramo0Whofn5eCwsLdlneZnPdtbOzY7ABasQQFZDNn5yc1M2bNy3SrdVqNvI0Go0qnU53OO6zszNjReE0Mb4QKtzeGWooZEE4corNkuzrh4aGtLu7q93dXQ0ODur+/fsdncCMT61Wq9rf31ej0dD3vvc9ozGjsHzz5k3dv3+/Q7Knm7W1tWXZWrFYVCqVsmFvFByHh4eVyWTMeNXrdR0eHur09NR6dTCE4PWDg4O/cSGBM2q1mgKBgEXk1EvYP+AyFKZxsqlUSolEQoVCwWAuNKju3r2r3t5e5XI5M5oEAGNjY6bJx+eANjwwMKBMJvNOmcvXX39txfhEIqHBwUEtLS2p1Wrp0aNHOjo60vj4uEXLwI0MCqO3DRgNurRb23LvB6xRSDYYw3a7rf39fW1vb1ud0S2+0/LQbre1vr6uZ8+eaXh4WN/73vesAbTVulL42N/ft8y61Wrp448/1p07d2zmy+XlpW7cuKGlpSUz5N0uIH8o1ijAS6/VLkZGRvTBBx+YMgAw6YMHDyyQpK8Km4YDXltbs7NADwuQ6dbWlo6Pj61l4PLy0uqQb4qcSjJWKZllOp3W7OysoRkEirB6QZo+/PBDzc3N6ejoSM+ePdPl5aUWFxf1wQcfGJR33fVWGI/b2cwhcCMpvClRIhEJKqvg3dJvqnYSZfP3ZBk4Frw1X8c/3X4bDqgbGfB91DLYeL4P9hif3Z1TTVSL4u+7FFS5ELwgmil5ZhwBs+DZBw6AO8vD5cmzXDop81VQq2UPSJNd2iZ/eFfUedy/A+qgwEcxmoZC4BQgMvB1onycuhvpdbuH7Af4Mb+fZ+QdE/lhvPge6XX2SdTs7h/7xVnHaLhwiruX/BPqKWfyzbvhfj7OFFk4gQGSJi4BgFoQBJV3cS5u/wL7wdkj2+B9uQVm7gN9KJI63jvv4s2zJsngGc42tHoieN4dBhLqPdm2JDs7LjWe+pt7h7mvqGHwh+I6dZBu99BtbXBbF1ybxHO6+4ANhLkIQcQ9T2/+PEhLLhnGfVfuvwOBU07gfPM91HKxg7w/zhf/Lb1WeiawuLy81NDQkNXD32aS57WdiyuR7/YbtFoto7X5/X5rkOSSw36pVqsWvZOdgHmnUil9+OGHVuCk6xbGxNDQkFFN8/l8R3o4PT2tqakp7ezsaHl52fpwgD2I9ungRf5/aGhIN2/eNKosBX8Ktnh09LxoNOrWOCYSCUmyaFqSySwASfD5OLzS6yiaZ4fFFgqFDJuGCcYhCwSu5t1ks1kFAgEtLCwYBERKzMHLZDLKZDI6PDzs6K73+/0aHh62xjUiWeboZDIZ/fCHPzSG0MnJiSTZfBR6h1AgYPpdt/tHcZHPwnum/wFjBp5P0Zh6BnUmN/NbW1vT+vq6UqmU7t+/b/U5ejgKhYJJZKTTaSsk4zg9Ho9GRkaUSqUM5gEaYf8ymYw5kHr99TC8VCqlH/7whyqXy3rw4IHBphhzyApAyeDe7XZb/+F/+B++0x5igBj5zH2moRn4lRolMHU+n9fh4aGxnbxer1HDk8mkPvjgA4XDYRNk5MyitA1bi/ofVOipqSmTYuJugEpEo1HdunXL5tzQcAl09r3vfU9nZ2d69uyZZS8Ma3NhdRo+ycK6WUBqqC7gPHDK2DzeNbYMW8LQM8gc7Af6i8PDw7avHs+VkvazZ88MrpqdnbV3gkQWsNXs7Ky1FwCntVotU+wAJoZph5rF7OysyuWyjo6OTPoHghaOBNSjVqtZC8h11rWdC8wZInrp9ehZon7+3o2i2SjYSkQQ0hWUtbe3Zx3SOKhAIGAbRB2BfgvqD2RHSO1j5ChqNRoNK1JjnLnclUrF5qETlVN3cPWwcIIUJF2u/Nsud15HtVq1OguRJJkDvQUu1EDEXqlUrMbg9/ttP4DA3Ojk8vJSh4eHhqtSp3DhH6/Xa7LoLsRBJE2Rkd/NOzw5OVEmkzECxatXr6wWw6GneMj3IYzX7f5RR+PMQcoAaiQKBFp1LxHvn4iZ/Tg8PNTq6qoymYw+/PBD2zsMPP0rOCR6MXhWjF86nVaj0bCaBoEPsi9otpH1NxoN9ff3a3x8XMViUc+ePbPz655hSWaoz87OrJej2wXdFOdIXZPMC0o0NUGMJdE6jDuv12uNuYVCQRsbG7q4uNDdu3c7qO/UD1hE41D7qY8lEglj1WEUyaqgzRLdc6aYhjk2NqZKpaLd3V27M7Ql8Hsg4ZyenhpDrZtFNoXkkos68O9kvNxnjD1n6uLiwoIIl6YMs9GF7k9OTnR4eKhgMKiFhQWl02kV/27EtiQ7h/SkIPSJPaFemMlkOiSZcHiQedwmZOwuf9zeIO7Rd+5caIpjFsTIyIgxWPhQaOGQ1nk8Hs3NzWlmZsYmKcJ1DwaDNn42FAppe3tbR0dHCofDVrSD+huNRq0QxTjl8fFxS61PT0/l9/s1OTlpUev5+bmxgIgakDOpVqs6OjrSt99+K7/fr8XFRcNk6ZeADgg26nLTu1kokx4cHGh7e1vNZlNLS0sdDpiXh4Fqt9uamJjQ2NiYjo+PTX0Y1pUbsYMHE3Uid9HT02ODx5ht3mg0rIcDSBGGFVF+tVrV1NSUBgYGrJkLoT727+uvv7bsZ2RkxGpSRJj0xQA1ugb0bRdzUKA2M2HS5/OZA6Pb2O0/GR4eVjAY1PHxsWXOsLj6+/s1PT1txV+36M+MoEAgYNj5zs6OMSRdjTGcFoEMhiSdTmthYcGYURcXFyZImM1m9ctf/lLSFRGCOR9EwjgA1IVxZN0aRvcMvnr1Spubm5qYmNDIyIhFtRgesnhkVJLJpAYHB03eB+PJXo6NjSmZTNr3060PVZemWijs0JmRs4GR6PV6TUWa7GZyctJo7Thm9vjk5MQkbSjWA6FTtwQBcKVPul1keDC3YIFJr7vXYaZJMvQE5t/e3p6ePn3a0Zvi9uLs7OwYFE1wvrS0ZA6f/XXnUfF1tDJA2wb6jMViHc6lVqsZIeHw8FDPnz+Xx+PR4uKiqdvHYjGjK/MuOBMEKNdZ195pXvrh4aEePHigGzduaHFx0T4AjZJw+NmQDz74QLOzs/rmm29szPHw8LAddKLB1dVV+Xw+3blzR4ODgyYZTx8IOH6pVFI0GrXilM/ns8bN+fl5M6C8/Bs3bujy8tJgMebCHxwcaH19XSMjI/rn//yfK5PJaHd3V7lcTh6PR8W/G0cai8UMJ6UQ3M3i8hUKBT169KhDRM5tUnNnQdBNOzo6qsePH+vFixfG7JFe49mS7DLSfT44OGj9NO5hOzg4UCQS0fT0tD0XTLTx8XEzfGgXjYyMqNFoGAaLrlMul9PW1pYGBgb0+7//+xoaGtL6+rp2d3eNftxutzU7O2uUW3cm0NuuVCqlRuNKqvzp06eamJjQ4OCgent7rfkumUxaRhGJRBQMXs1uHx4e1vPnz7W8vKx2u62RkRHrqXAZiPTIUGPhjEIZ39/f18HBgYLBoIkocv5DoZCNIICgMTw8rPv37+vs7MxUDDiH29vbevDggfr7+/UP/+E/NIVpoB0yaYyG1+u1huNuF9lBLpfT119/bSQMMhXgFjrhibIzmYyRZJj3DsstGo0ajZs+i0QiYY75TYHOSqWivb09GxBIwEZQlU6nO6jvo6Oj+v73v2/7jwTN5eWVvtnjx4+VTCb1k5/8xCJ7er6YnklwSI2h2z3Eaa2trWl1ddUCE7JhSebQaHxkpEYmk9GXX36pFy9eqFarWW2IgBclaKDQYDCo0dFRffDBBwbLsy9ogI2MjFg9hcbsTCajSqVi8GIikdD09LQ5F7QaLy4ujHY8ODioP/iDP9DIyIiVBRCx5J1Rq4LAcJ311mOOiU7/bek5Htyl6L2pKfXbClNvGh23aO0W4NyiNobV/V38P6ASFxN1+wRIX3Fwrr6U+7veJVJ883lciua/jXVGQe/NfeA53mwE/W17437fm1/32/aKv3f3h8PkFrrf3D+iSLfDm79zz4Dbjf0uBWl3/1zY8P+LKPDm+XPPD0Vp92zy+Tg7LpToFnJd+vebe8j+Sa+L//xx9xf41SUGuOu37eO7rDehm992Bl0o9s279ts+n7uH7md1yRHufrh3iq9hT/l/b+4p0bx7h91iP2f1zTv+5l151/XbbMdv+/kuSckt8v+2+/jm9wEJ8kxvEnf4OheO4zNJ6vj/LtmA8+d+PZ+fmgo28M276n7Nm2fg/3O/2t/l7r9f79f79X69X++XpO47st6v9+v9er/er/fr37LeO5f36/16v96v9+s7X++dy/v1fr1f79f79Z2v987l/Xq/3q/36/36ztd75/J+vV/v1/v1fn3n671zeb/er/fr/Xq/vvP13rm8X+/X+/V+vV/f+XrvXN6v9+v9er/er+98vXcu79f79X69X+/Xd77eO5f36/16v96v9+s7X++dy/v1fr1f79f79Z2v987l/Xq/3q/36/36zte1VZH/i//iv7DhM5FIRDs7O/rqq6/U09Oj3//939fs7Kyp/bojUH/+85/r6dOnHaOEkWFHLtpV8GWKW39/v8bGxlStVvXLX/5Sh4eHNqSnt7fXpv2h4ukqNfMzw+GwwuGwDUW6uLjQ9va2Tk5O1N/fb7M+UqlUx1S4cDhsszlevnypfD6veDyuVColj8ej//g//o/feqP/o//oP7J5FdFoVNvb2/ryyy8VCAT0x3/8x1paWlKlUrGBPgzcevnypXZ2dmxoEnO3GYnLjA8GfLkjjHt7e1WpVPTgwQPl83mbeeGOOk6n0zapjiFjJycnqtfr9nMikYiGhoZUq9X0f/6f/6eeP3+uqakp3bhxQ319fRoZGVFvb6+y2awKhYLJfHu9XpPod8dM/yf/yX/y1vv3n//n/7kkmbpsoVDQy5cvFQwG9ZOf/ERTU1MmBS/JZuK8fPlS29vbNseip6dHs7OzSiQSdn6YPcK/M7AuHA6rXC7r5z//ubLZrOLxuGKxmAKBgOLxeIeqNGq20mu1XwbSMQfn4uJCm5ubOj4+Vjwet4FbyNOjwMysmVarpf39fZ2entqsIUn6T//T//St90+S/tk/+2cm1d7f36/9/X09evRIvb29+sM//EPNz8+rr6/PpOCZT5/P51UsFrW/v68nT57I4/Hoxo0bSqVSdsd6e3sVi8Xk8Xi0v7+v4+NjjY6OamlpSWdnZ/p//p//R3t7e6YmHI1GNTExoWAwqKGhIZv5wzvM5XKq1+u6c+eOlpaWbB7Q+fm5Hj58qL29PZszw+92pe+ZV99qtVQoFGwkBWOt/+v/+r9+6/37L//L/1Ltdts+4/HxsVZXVxWJRPQf/Af/ge7evau9vT1tbW3ZAESPx6Pl5WVtb2/bTCufz6e5uTklEgkbjfHmDJ96vW6D/LADxWLRzgGzYhiZcXl5aaPHG42GTaW8deuWFhcXbYBetVrVr3/9a21ubmpqakq3b982W+Lz+UxynzvEkDh3XLUk/Wf/2X/29+7XtZ0Lk80k2QjX3/md37EJaowX5aV/8sknNjaWiYX5fF4ej8dmsTP/IRAIaGBgwCbVNZtNm23RbDZtTCqXliltrpQ+Y0Zd6Wim5Llz4aenpzU9Pa1qtaqTkxM1m01tbm5KkkZGRjQwMKDz83Pt7OyoXq9rb2/Phmcxc6KbFQ6HTf660WjYiNbe3l5zWtlsVsvLy0qn0/rss88UjUY1MjKivb09G+LEDA3mZDCSOBKJyOPx2HhSBjb5fD719/ebs5FkkyHdf+/r61M8Hu+Q/N7f39fJyYni8bjOzs7k8/mUyWRsL5mqub+/L+lqoFw4HNbl5aXW19dtVPDZ2Zni8bgSicRbSXa/uQgYGDMbi8Xk8/mUTCbl8Xh0eHio9fV1pdNpff7554rFYgqHwxocHNTJyYl2d3clvR6VjOS8z+f7jemJ7ANTP5kSyBAyppIy4TQcDtvz4XT29/e1tbVlw7K8Xq/Gx8c1OjqqSqViEwUZVT04OGhTLXd3d1Wv17W9va1isWjjg99Fdp9pnoFAQB6PR8lk0qZHEoQdHBzo8PBQ4XBYs7Oz6u/vVzAYtMF9R0dH8nq9Gh0dVSqVUq1WU7VaVbvdNmPH1Nbd3V2bGhsKhTQ2NmYBHEbx4uJC9Xrd5ugwOZVxy7u7u9rf37dR6h6Px5xyuVy2u0tQMDk5qUwmo7OzMzOwzHcKBoM2QbKbhYA8vysYDGp4eFh9fX2KRqM2B+Xg4EDJZFKLi4tmtAcHB7W/v29S+PF43MZtE5Dzc6UrG1ur1bS+vi7palheJBIx++jxeHR+fm7jx8/Pz+1eejweG0ufzWa1urqqcDisoaEh+Xw+jY6OKp1Oq91u2wRPRiYzLOzi4sLsI9Ncmax63TN4befC3AlJZrAmJydts1qtlo6OjrSysqKJiQklEgkNDw8rEAhobGxM+/v7evbsmS4vLxUIBOT1em04EfOoe3t7dX5+Lo/HY5fP6/UqnU7bDHhmpJdKJftMXq/XvDZZU09Pj4rFojY2NpRIJBQKhdTX12dR0vr6unZ2dmwyHoOiiBROT09tquXp6aldgm4XRomhYNFoVKOjoxYFS9LR0ZGeP3+u+fl5TU9Pa3x8XPF4XKOjo7Z/rVbLjBzGPRQKmcNmWBJRB0OmGHNM9HZycmIGFMfCwWSuRKFQsBnzGKB0Oq2JiQmdnJwom82qWq1qd3dXtVpNN2/eVH9/v6rVqrLZrGq1mo6Ojmzv3LGu3S4yuEQioaGhIRvi5vF4dHx8rFevXqnVaml0dFSjo6PyeDyKRCLKZrMW4TGojbkbZNA9PT02UAlnzjuLRqM2/OrNsc9nZ2caHBw058I9yefz2t/fVzKZ1MLCgkKhkIaGhhQKhbS+vm4ZFeO8w+GwRkZGbPZ8tVrVzs6Ojo+PlUqlOu5gt3uHEWMWPKPFmYq4s7Ojhw8fKpPJ6NatWxocHFQgENDZ2Zk5Pa/Xq4GBAaVSKctq3DkiTEw8Pz9XoVCQ3+/X0NCQDY1jhC7BI8PvotGohoaGbBKoJO3s7Gh/f1/9/f26c+eOQqGQYrGY4vG41tfXtb+/b+OMvV6vUqmUTV3d2dmxwVlnZ2dKpVIaHBzs2kG/OQspGo2ajcM5M2ytt7e3YzpmOp1WOBzWycmJLi8vFYlE1Nvb2zGmm3PJHJeTkxPt7e2pp6dHExMTisViducZmUxGx5BBBo3xezc3N/XVV19paGhI9+/ftz0Oh8Pa3d3V6uqqKpWKBdNLS0uamZnR6emp/T+yvXQ6bWfnOuvazoWpdKenp2q1WgqHw7YhjGd1PduzZ8+0u7tr3piMxY10fD6fzQhnlrx74RlbS0rnDt9hSqALB/X19cnr9ers7Mw8fDgcVk9Pj8ElhUJBlUrFLgWjO/1+v5LJpMLhcMdBcp/zXUakVioVSa+H+TDbm88pXUE+iURCkvTo0SNtb29bmkrmQMRXr9ftAPt8PnMIrrEl4nCHD3E4hoaGOoYT8RmazaaN9W2320okEgoEAuZguQzFYtGmdeLcksmkwW65XE6Xl5cdGdO7ZH6Mzy4UCmo0GpbKA+fx38lkUq1WSw8ePND6+rqNxm232wqHwzbbvFqtKhqNmuPl/EmvM5loNGqjp4EJ+ftIJGL7hqHm3eF4yLT8fr+q1arBXj09PTo6OtLJyYmkq4yit7dX4XBYfX19NuJauopY+Wdvb+87ZS7VatUgaDIs3g2DpZjC2Ww2tbKyomw2awamWCxakHR0dKSzszP19fVpbm7OkANG+GIT3M+ME5Bkd5izdH5+rng8bvevXC4bWhKNRtXT02NnkKyGyYxkOr9t2JXX67UJqAS13e4h2T7wUKvVskmm7jRTxnw/efLEoEJgWsaFM1EzGo0qnU53ZA+cq2AwqJGREQtYarWaTdPEHjGZ1h0WBrLDIqC+uLiQJAve8/m8CoWCOTuPx2OwPfYSW8w7e5v9u7a1ZGOBYZLJpCRZug4+WC6XVS6X9b/8L/+Lms2mfvCDH+jmzZtWr6lWq1pbW9Pp6ammpqY0NjZmk92Iai4vLxUMBm20MhEyly8UCllaB6aPY2s0Gtra2jJ8fWBgwD4343lbrZay2ay2t7cVDof14YcfKpVKaWJiQul0WtLryXkYSyKFblcul5MkcxDBYNCyBrDrWCymiYkJnZ+f63/8H/9HNZtNjY2N2WfCCZ+cnKhWq2lubk6zs7Oq1WoqFApmAGOxmNrttuHM7Glvb69httFoVO12W9vb2zo6OjLnU6vVtLW1pdPTUyWTSfs8QEr1el2JREKHh4fa2dmxzJTRybOzs9ra2tLy8rIuLi4UCARsPLR74LvZP7ITIsH5+XmFw2GFQiGrC01NTen09FT/7X/736rZbOr+/fuan59Xu91WOp3W+fm5VlZWVCwWtbCwoMHBQcOVmaRIFhOJRAzi4dxT88Po44SGh4c1NjZmWHypVJLf77fzRxaEQwcyi0QimpyctBpgKpUyR+/xeAwqo/71Luvk5MTqk2Tq4XBYgUDAgr1QKKT+/n5dXFzoL//yLw2WBrICQVhfX9fZ2Zl++tOf6kc/+pGq1ao2NzdVqVQsu+SfzWbTsgcMUzAY7DCq+Xxew8PDNop5f39fpVLJoCc3axobG1MymVSpVNL+/r7B3Tgh9g4nwMjrUCj0Wyc7Xnft7e1Jkr0LshXOhMfjsWxif39fm5ub8nq9unXrlqamplSr1RSPxxUIBLS1taVKpaKpqSktLi6qXC7r1atXqtVqhtDE43HNzc3p8vJSu7u7KpVKVhNzHRb3lyC42WxqY2NDFxcXCoVCWlpa0uXlpZ1BRiDncjltb28rFAppYWFB8XhcExMTGhkZ6ZgcijMLBoO/MVX4/2td+7SSurvjMzGURL/AU+fn56pUKlZEZcP4fiJNClNuMZTLJ8kOCmkohVb3gPCi+cPFbLfbFtWy8O7NZtMuCxcHHJrPwX/zu/lc3Q7uBO4LBoP2HMBb7CGXnfnl9XrdcGm3IM4+8nzu2FN3L98c2Ut0zM9yDembY6iBFon6cBB8PTPA3Xfpng2+nminVqtZobCbRWrujnbls1A/8fl8CofDuri4MGiL84fxBCvnvXMZJVkWScbF3gKH9fb2WuGfkcvupXtzuREun5PR0IFAQJFIxIw7joPn5OtdI/IusKwky7IwXuwftUqv12vBAFh7rVazv+vt7bV6EntAZkpWAqnHrWexyIwCgYD9TvdnMMrbHbXMOZReR84QMQjMcCBAw679AHpyn73bxbtxMz/X6XMPe3t7rTDfbrd1fn7+GzaQM+XuPZkt7wd0g/3gGd4cl8xzctbcP24gy8/HLgAxhkIhC9zJ/rBF3Bf+PwjWddZbZS4ej0cTExMaGhrSwMCApqam5PV6VSwWdXh4KJ/Pp+HhYTsA1WpVx8fH2tnZ6WCSLS0t2Uvh8mDggCF4gRT78eSxWKwDIwyFQhoYGFAgELCXR1GKA0A05r6U8/NzS6l58YeHhyoWiwoEAhofH7dI/vLyUmdnZ8rlcr917vh1Vjablc/n0/z8vMbHxzU0NKSbN2/K5/NZfScWi+nmzZsGPVarVQWDQTvUGMOhoSFJsgzF5/MpFosZy2Z/f7+j5oXzGh8f19jYmM7OzrS3t6eLiwslEgmDMDCqCwsLHQYiFotpZmZGPT09Bh1y+S8uLrS7u6uLiwuLoFqtlpaWljqM6fr6ujY2NrrePyCdRCKhdDqtsbExzc/Py+/3K5/P6/DwUF6vVzMzMwqHw1pbW7P3nMvlDBcPhUK6f/++GbRgMGgw2eXlpUqlksrlsuLxuAYHB9XT06PJyUldXl4qkUgokUioUqloa2vLIEFqGfv7+/Z8ZNhAJslk0uqMGA6gOODFw8NDe07qRQQzKysrWl5e7nr/pNfBBg6UiJVzxd1pt9sqlUqWrUejUfX19VkwGAgEdOPGDXk8HqVSKR0eHqpSqahQKOj09FT7+/s6PDy0wrvH4zEHOj09rampKRWLRb169Urn5+caHBzU4OCg/H6/stmsOd9EImGfLRqNanp6uiPb+tGPfqSf/vSnqtVqVryH4SdJo6Ojarfbdgc2Njb04sWLrvcQxlQqldLw8LCSyaTGx8fNjrXbbaVSKS0tLRnZAFi2UChYxuj3+3X37l319vYqnU6rWCyqXC6rVqupVqsZKw5orNVqmQ0IBoNWcM9ms2o0Gkqn05bx8eypVMoCef5MTU0ZfImD9vv99vlAPrBFn332mQU4kvTq1Ss9evTo2vv3VjUXl5oKXi1dpVknJydKJBKKx+OqVCoWxV5cXKhYLHZERul0WpFIpIOBxdfjofGwXq9XfX19arfbhmtTg6nVakaFlF5nJlAQ+Xl9fX1Kp9MdUQKRYLVaNRjt7OxMlUpFqVTKCtxQmCUZzNTNOjs7sxcaj8fNQHq9XlWrVVUqFfX29trvTSQSHRENl9/n81n03Nvba8/sMsHAxl3mkiRzOMfHx8YSIYPj4FMU9fv9VtyORCIaHR01CAiD2dfXp9PTU4Ppzs/PrR43MDDQUR+C5tjt/hE4YFwoRns8Hu3t7en09NSM//n5uYLBoBU+gWqAL4aHh80ZQ//kApFtEwXjuCUZkQA6KsYsFAqp0WgY9u1Cn0B2GE9+H7WNcrmshw8fGksNsgfFU/cc5/P5d4q8pdcOhowsmUxaZEvtAlYa9UaiWjdjTiaTdnaoCZItlstlg7Rg21E3SKVSmpycVE9Pj549e6aLiwsLWKrVqkqlkmUsGD/OPOQCMp6hoSFNTEyoVCrp22+/Ndi1VqtZrcbr9VqGfXBwoHK53PUeuvYklUoZQcDn85lzIFDr6ekxdiyBIj/DJTjA+nLhMIIdzrB0FRBwtoLBoJ2/RqNhsDpOyuv1GgGF9+3aQJik3KFKpaJHjx7p9PTUbGMoFLJ6D4Hm+vq6Dg8PzdH9fevazuWTTz6xf8/n88Z9JpKBhQEjh8wBnJMo1mUjXVxcGOurXq+r3W4b64sUGb79+fm5hoeHOzaeiCYajer09FSHh4cKBoOam5tTNBpVoVCw/oK1tTU7aHhuvPTx8bEqlYoVswKBgEUcGMd4PK6bN292DYvdu3fPHGWhULBnp8+BvhoOH4eAy4UxwglfXl5axE4tQLqK1sC7Yeesr69blgZkRCQ1MDCgaDSqYrGo4+NjhUIh4+AfHx+rWCyqVqtpY2PDagA4GJzLzs6OisWixsbG7MKUSqUOivjw8LBu3brVddR4584dSTIntbe3p1/96ldG5BgeHpbP57MzBnWW9wk0J105ekkqlUo6PT01BmKr1VJ/f7/S6bRlHeDnZ2dndv6gtQLDhcNhHR8f6+TkRKFQSLdu3VIikdDJyYnR2FdWViTJYNHe3l5jJWazWR0fH1vNLxQKWSQMnNHf36+PPvronTKXW7duSZKxtSqVir744guFQiEtLi6qv7/faMFuD5kLu4RCIctsqJeUSiVj19VqNY2OjmpsbEzRaFQDAwOq1+t69eqVOXlqZ9xNKOVAuzgSyAM4c2jH/f39BtlIV1ltoVAwhwYU5hb1/X6/4vG4xsbGut7D+fl5SbJs2bU5s7OzGhwc1OnpqUG0kuwzSK9hOvbS3QdYnJBFaFGg/vXq1SsdHR0ZOYWAFFuKIwamnZ6etvoYaNDW1paazaZisZj6+voUi8V0dnamcrmsra0tFYtFC6yBRF1yRF9fn+7cuWOw49+3ru1cPvvsMzWbTT19+lSrq6vy+/3GP//00081PDxsl7XZbBr9l0PAgZZkbBi41ESXXq9X8/PzGhkZ0fn5ubFD1tfXrV+CByOyBCo7OjrSzs6OUqmUfvzjH2t8fFwvXrywKGpvb0/NZlPpdFrRaNQIABjaUqlk2RgRJnhpvV634na3xcAf/vCHarVa2tnZUTab1c7Ojr7++mtFo1H90R/9kaanp1WpVFQul+X3+9XX1yfpNRTmNoUR4R4dHSmfz1uU0dfXZwaK/T4+PlYul9Pe3p71GjWbTctE6Vc4Ozsz6HNyclJjY2PKZrPK5/Pa3t7W119/rYuLC83MzFjvQ19fn4rFovVi9Pf3WxQPPRUa88jIiMF43ayPP/7YepKy2ayKxaJevnypSCSin/zkJxobG1OlUlGpVJJ0ZYD6+vqswY93CfQFDJXNZjvo61NTU+boIZhsbW0pl8sZm0eSPX80GlUoFNLR0ZEKhYIGBwd19+5dzczM6Ntvv9XTp091cnKizc1NXV5eWtYEc5LGupOTE4Na3FomMNrAwID1LnS77t+/r1arpYODAxUKBeVyOX355ZfWA5HJZFSr1Qz+ItvAYJG51ut1HR4eqlQqGVOQjNnj8ej27dsaHx+37KNYLOrXv/61dnZ2DGKGbo0DxaGR8U1PTyuVSqnRaBhF+sGDB6rVakbEAAYC+oRuTI0GB4Phpbm3W+dy8+ZNtVot7e7u6uDgwMge8Xhc09PTGhkZkcfjUbVa/a2Fb7IFtyG2UCjo+fPn6u3t1cDAQEdzZCqV0sDAgE5OTnRwcKCNjQ3LGsiUySzcmnQsFtPCwoKGh4d1cXFhAeYvfvELVSoVCxDj8bjBwJCsms2m1W5AC8gWI5GIPv7442vv17WdC6kRkTbRANFdpVLR6empjo+P7RKTrQArkY5R7HIbM91CvsuZh/1EVH90dGRsMdI+ItJQKKRAIGD1FDKrSCSi4eFhiw5oXqPJU5JRd0ulknWqS7J0F3igW+dCcQ9KNpkIRubk5MQK0NBWccCk20RybiMVGZzbfdzT02MNqjhGUvpcLmdMHb73TaICMAcHLRKJKJPJGD25WCwqFosZ5ZkisPRaYYHiPcoHZGTdLqBSDFyj0bDfS72nXC7r9PTUeiyAZPgcBCQ4Di4lmDZ7RP2JbJrmUumKgsv+UeSkcEpdgl4HsoBoNKpMJmOG8ujoyFhDrmGAwkpmA+OP2iJ9XN2ui4sLe1bqGvSFnJ+fm8MoFos6OzuzvWC/iMYpWnPfcCJvRutuX1UsFjOGZzablSRjd5GR8zO4/9T16I2bnJy0u358fGwqHXT2QzPns/L91C+AfbtdLpuQbFi6sjvlctkUKo6Pjw0pcBeQFmQaMg6yuWq1ajAsMDhECTJAsiZqUiAcfD72i73gzNErA8Hl9PRUPT09Rgfn2bi7/LckSwqAeL/zgn4+n5d0FRFSUOYAFItF5fN55fN5OzhEIcAC6XRak5OTBpkcHx8b7gszRXqNLeJYIpGI7ty5o3q9rpWVFT18+FATExP66KOPFIvFtL+/r0KhYGSDnp4e7ezsGN0uEoloZGREY2Njqtfr+p//5/9Zjx8/1vT0tFFNSSePjo6sXoFBJmPKZDIdB+pt18bGhiQpHo9rfHxc0WhUg4ODkq6il4ODA3vJwDSXl5d2UAcGBuzFXlxcGN7v1qBIgX0+nyqVikGBH3/8sUKhkP7iL/5C//f//X9rfn5eP/nJT9Tf369KpWKOHsr11taWyuWyFbwnJyc1Nzeni4sL/dmf/ZlevHhhET5UUfj8h4eHFlG2Wi3l83n5/X6j2na7f8fHx0ZnHxgYsIt7eXmpvb09ra2tWYDD5aK3BdLH1NSUPB6PTk5OjDQB/5/zzTkk0JCku3fvyuv16vHjx3rw4IGmpqb08ccf2/k7OTlRb2+vpqam5Pf7tby8rLW1NQuMRkdH9fnnn6tWq+l/+p/+Jz18+FDj4+MKBAKq1+vmNOgdgdVHD8jFxYXGxsY0MzPTUUN727W9vW3QKEHH1NSUpCvCyebmpgU41FzcZt1kMmkQ1sDAgPUUQYoh20fKxCXNLC4uan5+Xl999ZX+9m//VhMTE/rDP/xD+xlQXqENX15e6uLiwloIUqmU/uW//Jeq1+v61//6X+vRo0caGxtTIBCwehW9ZDTsYrRdNYpuM2dJFiQHg0HLMgiq1tbWDPoDMiSYxOBTq8Ihnp+fG4X/9PRUa2trajQaWlpasvYDzv3nn3+udrutv/mbv9HPf/5zzczM6E/+5E+USqWMEETgUK1Wrc+MoCyRSOjf+/f+PV1cXOhf/at/pQcPHqjZbBoVnyy1UqlYUAmZ4OjoSOfn5xoZGdHExMR3T0UGf0NSQ5Jh3BSSqtWqLi4uOqIYIgZJhiUXi0VrMnM7msl0gALc5kUemCiEyImDDCboFpHBzeHnE3nTFCe97oYlo+KzEnkTEfHPbo0jVGSaRiORiPr7+9VsNnVwcGCkB7exks9DMyTZnMuw6+vrs2Yy9+u57KTJRMpEr+FwWNFo1JwSURTOyyUgBINB61GiduHSRDmERFr8fi4YEey7LKjwwDDsBQw5V6LHzezAsTkf4NyuVhIQFDAUf3DU6In5/VfyMPQMETFyZoAyKW5DcOH8udRUvocsgP25uLjooNMTSLgNiN0ufj8/C/Zfq3Ul3XR8fGzvjujazUCazWYHYsEZdWmz7D3nj6zfraugn0fPBuSc39be4AZMyWTS9o07/CZ1mT98Low7f/8umQtoDNk6mmbNZtP6cmq1mjkh7o/bugHl2j1ffX19ZrMo7LufmfdEpo4jQQIJlME9Hy56IF3Z6kQiYY3Q3M832xp4TkmW4bqfy81o/r51bedSKBQkySJmGBOSzIBMTEzogw8+UL1eN1gAowxbgaK/m0IDKdTrdb18+VLPnz/X8PCwdf5ySIj2EomE0fUoxkejUaNR4oD4naenp/rf/rf/zfpFPvnkE2UyGdM68vl8HS+iWq2ahtLi4qIVuFAW6Ga5zA0iay45L29iYkIzMzM6OTnR119/rVKppEQiodHRUQ0MDGh8fNyYILVazSiGp6enhjl//fXXevjwoWKxmEZGRtTT02Nd/tPT0/oX/+JfKBwOG8PPNXRQR/mswWBQ0WhU+Xxef/M3f2MqAffu3VMmk9Ho6Khh526vDWfC7/dramrKCsWnp6dd7x/ZKQV1pGg4Q+1222jyFxcX2tnZsYvk8Vx1HlMzo96EEQJaIDteW1uzTMelyBO1gVVXq1UdHBwon88b7CPJIniy00KhoP/hf/gfDO68e/euJicndePGDdMlcxUYkCzxer366KOPbP+44N0uzjhBm8sE4uePjY2Z9h6NkkBW8XhcMzMz8vv9VozHEeJQEYfd2NhQPB7X8PBwR9vB5OSkfvjDHyoajWpvb0/5fN6MGFCxJGNpItl0cnKi/+a/+W8sS6E2m06ndXFxYfp4yWTSiCxknvRv4BC6Xbu7uxbgUIMKh8MW1BHdo6X4+PFjlctlxWIxRaNRJRIJs1H0AWL7oHx7vV7t7e2pUChoaGhIc3NzBi1fXl5qcnJSv/d7v6dEImEQ8O7urk5OTtTX16dMJmOEhnq9rkgkor6+Ph0eHuov/uIvTMbn7t27Gh8fN7ibe4VDLJVK2t3dVbvdNj1BWKLXXW/d5+JyrrlMeNjBwUHdvn1bZ2dnevnypWHgYOVAJ7wQ93uJhDY2NpTNZnX79m3bWAzS4OCg0U+5qGRMsMbcvhWovYeHh/ryyy9VrVb14YcfWkc0/TNEiFzuw8NDHRwcyOfzaXx8XNPT09ra2tLKykrXxUAXS+ZCu/gouPT8/Lz29vb0i1/8QuVyWaOjo8pkMurv7zcYrbe31yJ5onOgtO3tbZ2enur27dtaWlpST0+PRaTDw8NaWFiwPg33Z4C/4rD4f8Fg0FhF1WpV3/ve9zQ9PW3c+nK5bNGU1MmOgTAwPj6u3d1dbWxsdB19c/4whGScLo19YGBAH374oRXs+efl5aUVraUr6jw1FZw00iW7u7vK5/O6c+eOKcZSnxkYGDCJF0gVsMSAECV1yHckEgltb2/rr/7qr1Qul/XJJ59oZmZGExMTmpiY6IjEMcLZbLajL2phYUGbm5t6+fLlO7HF2De3aRMHSxCYTqd179495XI5bW5u6uLiwphxKGCDJLwJ0QHzHR4e6ujoSNPT05qcnOwIrIaGhiyDRnqEM5FKpQz6xdBBvNnZ2dH/8X/8H6pUKvrss880PT2t/v5+YwMi4zMwMKD+/n6TJ6LPhYAYWnk3K5/PW6GdZ0eTDQQlmUzq9u3b2t/f18OHD42ohPAkNkq6ygxwUiAsEHUINm7cuNHRpAqFudlsWgaYy+V0dHSksbExC4iwC+zhq1ev9L/+r/+rKpWKfvKTn1jBn8AFp+3aKBcWHh8ff2uVkms7l/n5ebVaLasPNBoNYzVw8C4vL41mS6oLDp7L5bS+vm79E0ifQLsDF02n0/J6vcY8on4AHZgsAnHGoaEho2/iqHBG9Ni0Wi1lMhk1m00NDQ1ZiknkRQEVvZ92u21ZwtnZmTY3N1UqlQwq6GbNzMwYU2d7e1uDg4MWpXFRiYQPDw8NF8/lcibZjgHiM9Dp7PVeybvDzIOlB6RSKBR0fn6uRCKhkZER20/3oJBB4Wg55DityclJNRoNU1SFOEFfBnAndNC5uTn5/X6VSiW9fPlS9Xrd4LNuFjRQmkQvLy+N/k7gIl1JnJTL5Y6eC6LCp0+fqqenx7B5jA2ZLu9fkunNuX0ISKRT/OY8cVYJvggezs7ObA+p+Y2NjdmoB/piYLS5BpGsnf0rFosdmmPdrLm5OTWbTW1vb2tvb6+DvUehGpkQDA3kkIuLCx0cHGh5eVk+n8/aEYaHh02xnDpRPB63GgpnhFoqiMf5+bmy2awFgZAjcHpuQyHOEFRkbGzMFICBKYmsyZw8Ho8RCCqViorFotXXuiVF3Lt3z+qI+/v7qtVqBo0SNEPThoTD/aHJEzj++PjYAptwOGw9e8B6OEQII2SKg4ODGh0dtTphvV7X9PS0xsbGLLhhr4GAscXz8/N2h7Hd1Ic4g6enpzo9PZXP59PS0pI9+9HRkQVy113Xdi6ff/656vW6/vf//X/X8+fPNTIyYsVSol646LBeLi4ulMvlTPKa/hQu4+DgoDVBUUCmJ2J0dNSEA2nmm5yc1AcffKCTkxM9e/bMNjaRSJhKgCuRUSqV7DDdv39fPp/PHBHy2C5+WigUlM1mlUqldP/+fbXbbT179kzLy8uW0na7Pv30U9Xrdf13/91/p7/8y7/U7OysMcBggRwfH+vZs2dmIKvVqhnmeDyukZERYyphGDkkc3NzarVaSqVSOj4+th6U8/NzK3bfvHlTt27dMkl+alDtdtvojlB1W62WHbLe3l59/PHH6u3tNRG8crlsktxE9FCdZ2dn9dlnn8nj8ejP//zPtbq6agXpbjHvH/3oR2o0GvrTP/1TPXnyRFNTUxoeHjYGC3XAvb09Y2u5AqXQ5MPhsDKZjKLRqDXBVatV9fb2GoWUZlMEHBn/gFIwme3l5aUWFxdN0h+6O7UCFKEbjYbu3bsnn89nVG6gr0AgoKGhIWu629zc1OjoqD777DNJ0q9+9St99dVXCofDb8XU+W3rs88+U61W08rKir744guDEAmaMM77+/sWyASDQVOuoAvfRQ5+/OMf69NPP7W+MpwDTC6gUGp9H3/8se7fv69SqaTV1VXV63XrtSoUCqb2UCqVTMgWI/5Hf/RH8vl8hkzQruDz+Uwh++HDh3r+/LnGxsb0gx/8QJL013/919rY2HhnVeQ/+qM/Ur1e17/6V/9Ky8vLSqVSuri4MLsF5JXL5YzE1NfXp6OjI+3u7nZ0xycSCctsYd8CSyOwirIxen8nJycGKx4fH+vhw4eq1+vKZDJKJpM6ODjQ2tpaRy2KYL+np0c/+tGPrH4TCoVsLEFvb68RlhgZMDg4qJ/+9KeSpIcPH2ptbU3xeNzGW1xnXdu5UEBz9XEo3Lu6UnhNojeXfucW7l1IiNoMlDk6+d2iHtEPRShkJfiZ8L7dWoZbNHVTePB2MHk450BCrsYRvxuo412oyK5Cr/u5oARDKqBeAU2Yoh7kBmoM7md0i9gcYH4PBg8GT6PRMOyZn+/2gfB9bpZxeXnZodsEK4Uoi31z4T++711rBW/un9vY5Z6FN4u67CMBEM/kFqg5q1CoIUCgqebCZ5xBSYZr8z6g47tkAIIGzjCLLmhXKdk9D9wlzjCf67so6APx8btcOI+iM+edc0D/BHfIvd+gE0TH0P/p7gdCczM69hCb4J5pfjefh9/BneW+83cI1NK0zc9zfybv0WVwdbPcdwtNm/oLkjRA1hCSyMZclQL3c7n0aT4jkkKgMe6+uS0b3GGXOOBqmEkye+gSG9g/bCZ3QZLtn0vldu/L25Airu1c/vv//r+XJCv6ZTIZjY+PG7efFBUoAirczMyMbRTQBY4KlpQbxczNzWlsbEwez5W8Oj0gZ2dn2t3dtQE76AYdHh5qf39fOzs7lrIT0WKQq9WqdbLfv39fwWBQxWJRu7u7Bi1ROCRl39jYsEOCvDrKxt2sP/3TP7W+haWlJdNYguFGsZqDMDIyYhLk9BaxL2hR0QtRLBb19OlTXVxcaGBgwPBnjAby5Gtra/qzP/szUz9lCBh7/OzZM0nSwMCAQZIUmFdWVgyayGQypqgaCAQ0OjpqUdjExIT6+vpMR4yoE3ip28yF8wcxgTqU22uBlLmrHLGwsGDaWCh5MygOA0UUeHFxoRs3bhg9F8IDpBEmDPJzpSt4AxLAt99+K0nWQ4QRgmZKg6DP5zPqL4EXmcni4qLq9bq++eYbo+PCtHL7wrpZ//pf/2u1Wldd9Tdv3tT4+LgNrHONGw7VxfnHxsYUDodtQibR+eHhof78z//cGhmbzaYmJydtMBUN1Lu7uxYpP3jwwLKiQCBgYxTy+XzHvBhgtaOjIx0eHurly5fyer2anJxUIpFQPp/X2tqatTNEIpGOyapMVIXlmkgkTJaom/Wnf/qnajabyufzVmz/8Y9/bPRpn8+n/f19bW9vm7NttVp2P6BaN5tNHR0dmbLAo0ePzL61Wi3dvXvXJqsC1XJGisWinj17Zs8EXZ1GaTT1sAGcuUqlotXVVXm9Xt25c0cjIyM6ODjQy5cvzT5jb+bn53V+fm5nEEVwSR2O6+9b13Yur169ksfjMQiEDk8uN1652WxaCtxqtUyKH0aOGyXCqS+VSh2y0eDg4OWwGRggBjPH4/Fod3dXx8fHyufzOjg46CjusQm8ROoafAbqA27EwLQ3YD0yszepfW+7mChH4xo9A6gUY8SRhEGjKJVKGYQzNjZm+4q8iiSDMmBR0eVNxISTQExveHjYeoL4GXSLs/9kc1C3c7mcfD6fXexyuWw9QQiHUvugVkCkz8F8Fyo35y+dTtv5g5bsZmromBGFMwoX+jcZA4FQT0+PXc5a7WrgWSqVUrVaNVgRemmpVLIxzqOjo/L5fEbhzefz2tvbs2gWumcwGDRJeTBu+jdOT0+tJ4j6BrI74Ok4M0nvnLmsrKwYJRtCCyOqKQ6jEkHE2mq1DIINh8M2dRZqPY6a55CkqakpYz6hdkEmUalUlM1mbTAaTM1SqfQb8LhbN8TJcCdg2B0fH5sGF1lqMpk0eRuaLpFeIdDpZq2trVl2Re1ofHzcmh55vy7S0Ww27U5iwBuNhjXHQkFGV43a1fDwsMHjoAbUiVHlAKKiP4/+LRwKpBz6auj9g8EJfIzSAAgEvXME92RdZDLfuXP53d/9XbVaV3NQjo6OjB/vai+xmeVy2Qp+1WpV29vb9jLA7UdGRnR4eGgFazfd83g8JhPRaDQ6RvYi5EazJrMzQqGQzXRfXFxUNBrV1taWRULT09NGJnj58qWOj4+NOrm1tWWRB/AJHf0UxKDmdrs+/PBDNZtN7ezsKJfLKR6PWyd0Npu1OkhfX5/h8e6FSqfTHbISkUjECpWQFrh4KDoDU42MjNhlJxJfXV01w8q7+/TTT9XT02Nqyjs7O9rb21MgENBHH31kh4zZEuDh+/v76unpsYJlPB7X0NCQms2mTd4jQ+h2/d7v/V7H+aMLu9VqdVBmueAoDON46SsC9kKwjyZIyB3AUGhlueePIKNUKmlra0uSrIm3r69Pn3zyiXp7ezU9Pa2+vj7lcjnLdm/dumX7l81mdXp6arAtM+ddhYDx8XFrYHPnoLzLYq4N95QGQ4/nSvwT5yCpY2wGGSd9EojPDg8Pm+wNsCrPwF7xnChlYOSAfAhEqI2OjIzYxE4K3dCMCRgrlYplBwi8co6pY4bDYY2OjqpevxpVThZYLpe73svvf//7ajavBByZvooUEZkIenzn5+dGs4a8gJOhrjwxMWH6gC7khB0CzYCwwPwYMl5IUATYgUBAN2/eNFWInp4eY+41Gg1rPi4Wi1pZWdHx8bEFZczFAsmRpIWFBTUaDROGdUsN11nXdi6///u/r0ajoT/7sz/T2tqayUM0Gg2tr69b1uDCUMwiuby8tHG9/f39Wlxc1MTEhGq1mtEdXUwauKJSqajdblskiHEEp2y32zaGOJFIaHJyUtFoVEtLS1YgzOVySqfTJm+/sbGhzc3NDrYUURgR8MDAgG7evClJBvOBT3d7MO/fv2/9P2RfqLh++eWX2t/f1+TkpGZmZmxMMJkdNOJaraZIJKKZmRlzTgjocTD7+/s1Pj5uzxcIBDQyMmK/m/4j0lsgH4rwNExyYY+PjzU5Oanvfe97CgQC+uabb7Szs2P4LZAH9Q2KlcPDw/J4PBY8INHSLdvpD//wD9VoNPR//V//l7a3t60/qd1u22Wn4Agsi+OWrhSNM5mMEomEvv/972toaEgvXrzQ7u6uqRS4TaA4FxhOBDfg4+gw5XI5lUolDQ0N6fbt29ZxHQqF9Jd/+Zd68uSJ0um07t69q0AgYDRjAqdGo6GdnZ2OOtro6Kju378vr9drGdSbdcNu1sLCgt0Z2JZo+718+VL5fN4QCTfyZ4wuximRSGhqakqDg4N2f9kzoECibAIfIGocLrJRwOnNZrODSAGUVCwW7VzBpsIRhkIhJf5uIi1BDCQj+rCazaYePXpkzoXn7mb9zu/8jtFxGVlB8PDkyRMjaADn5fP5jq9ByBNZ/vHxcT1+/Fh7e3tmtKHYY+AJvLmTh4eH2t7etr2RpK2tLR0dHWlpaUm3b982CE6SoUI9PVcj3Nvtto6PjzsGn7XbbWu9oC8mnU6b0Cz6hKBH113Xdi6oF0uvRSNpAqKfBAdA3wqOQZLROMEJkV9HpHFwcNBSQqAccGYEK0nJ/H6/jUDGOLqdxBhWlFDRBKNhiYMGXAOMQnEc40EtBC7723C8/237B1uDojF7A10WmI50FpguFovZi8eoSq8HMPX395uDZA8wYBgJInn2HDychW4bEI0kS6/5ukAgYNpesM3Ye0lG6QUGkmQNsmDQ3SyouC7pg/MQiUSUSqU62HdAsCjQJpNJG/UArCO9Vo3AGXJuOWfAaLCpgOEYN0G/iyvOShTOeWMP2U/eHXCsC03Cgjo5OTEoAkP8LudPuqoh8ewu+QMoD9WGeDyucrlssA330h1bAPxNFg1rsNlsdtCXcTjAYjwj2Xhvb68x+0ArYJdRhHZJDpwnFowyMnXeQV9fn/b39yVd3RHYa8Bk3SzXBlILdftdGLtNDQhoERVizmk0Gu14Vjd4YZ+4qy6tnawN9hdUZcREgdYJHLFrBM0Ex8xwIovlrLLfZK2Hh4e25+FwuEO/8Drr2s7l6dOnlhahwItHHB4etuiYiIesZXBwUPF4XIlEwuaXQK1jKA11CAwXnpfmoe3tbZVKJY2NjWl0dNSid3otODDgndlsVn19fQaR0YjZarU0MjKiTCZjmDcHgMJ4uVy2pkOc09DQkLLZrPb397uOvJeXlyVdGZc7d+4onU5bM9bt27etuM+hxSEmEgk7lMzBgG0kyQwnNRTGD0ALrtVqRonlT29vryYnJxUOh5XP5w3r/uqrrxQIBGx8ME110FFRR4D6XSgUOjBY+ksQQOzp6TFNsbOzM6Mud7O+/fZbtVot63iGpBAIBDQ7O6uJiQk7/IFAwBQcUMHu7++3DvtKpaK9vT0rtrqyHEixEMVVq1Wtrq6qXC4rnU6rv79fIyMjWlpaMmdDvwZQq+u8OacUytPptEFBR0dHHUwcvr9QKOjhw4fGgkqn08rlcuYcul2PHj2SJNMM83g81pR8dnamWCxmtZj9/X19++23KhQKGh8ft+bEsbEx9fb2GhHE7/drYmJCFxdXc1nIHk5PT1UoFGyAGqMGMI6jo6P6/ve/r0gkoq+//lobGxsG2cLAIoMiiofQwGwconhJNqYjn88bVMeQuGg0qrm5OZ2cnJiaRDfr+fPnZuxHRkaUSqUsGJucnDSdrmazqUKhoNXVVV1eXiqTydgQO+48mmn8PQEdjnRnZ8dqcrVazcYZUBMLBoOampoyMgHPtbKyYn8HWQiIjH/OzMxY4zOyUTiyQqFgNZzt7W1TaR4bG9Pp6anVxq+z3ipzYUG742XjDMg4iBj5WuQPyGIo0EsyKiTNlHTzunRWoiDgHKIZt2BNkV6SzTmgQU163VgUjUbNg7vSF0RcpInUNyhQu5pH3SzScXoymNXi9XptX5BXwGjSeEjE+CYVGWwWthuHk9oB++xSvd3sDxiT5jmKo2DvRM1EfO122ww7LBIXznQpjIwOgFzwrjUD8GUiPSiunDUooDDuqI8hi8+eE2TAIiITdFl7LPf8uVTbVqtlVHH2kQyHfeG8UcuD2ovjIRN2teN4F9Lr4XKRSKQjon0XbSyIA2hUufeMgjfnDYMuvVaUhjJPrYsskq8luoU2zDO6pA73DAIh8dwU7qXXigV8L/cUpIQ+Lkkdhpl3BkEF20KG9i5NqG/aQFdKxqX2N5vNjvvKZ+AeS+ooBRDYBINBe7+w9VwbBSRLVsQZpMbE2AzOItkemQvvOxwO21BH3gm/kz2EpowNdMdTf+fOBZhjfHzc8H8anThAUBXxrsAJRNIHBwcm0cClDwQCdhCazaZJQLCJHo/HRBcxAKVSSd988418Pp/BV6gA8FkDgYDpDBEN+nw+ffDBBxoeHlaj0dDg4KDhp+fn5xofHzctLopsRFrRaFSffvpp10Zyf39fXq9XExMTBmERyUN5RUOMjInfBUOEZj9UlVEnYOzz5eWlZmdnlU6njZnl8/nMuQMthsNhbWxsyO/3WyH06OhI+/v7picGI2t6etqgycvLS01PT9s0S/b24ODAurVDoZDpEkG5LJVK8vv9VsfqZkFsGBkZMcFPjAuXk7oeJAeM6cXFhWmpsR9kHTTU0hQJdEszKY4eaKO3t1flcllffPGFwTDQU+kMh6Ld39+vZDJpuLvP5zMxS6ZT0vl+cXFhE0BLpZK9T6j68Xhc3//+99/JueD8BwYGNDo6qp6eHsssDg4ObBoq2er09LRN3ySYzOfzNs0TaIUGaajInHFmrVCnIQj1+Xw6Pj7WX/zFXxjMNjIyYgoWtVpNL1++NLgXHa1cLmc2aGJiwowkjly6kohC+gclB0g5ZLndroODA3m9Xk1NTWl0dLSDfs3vpykSBKFSqSgYDJq6OVL32DnXiUCuIBsBokIainNbKpXUbDb15MkTC0gZ71woFOzM8/+Hhobsnvp8PmUyGcu6OP84dZqds9msHj16ZHVfSh9IKF3rvF33C5kzgcHBaFBcp+jEsB4KUBcXF1aUZoIfhxV89+TkRFtbWx3drm6EA12XaIuucyh3dLGiVYQhmpubM+ofzgXWCxEsdLzLy0v19/crlUrZLHCYMq3W1YTChYWFrouqMDOQCZdkES6XUJKprAJLUTSnGIm+E+ybYDCoXC6np0+fWg9IJBKxTIlIhQgVXPVN53l8fGyzSk5OTtRut5VIJDQ0NKRSqWSOkNk49Cicnp6aXD0FWYq2PFu73bY+nW6NI1pLsVhMs7OzOjo60vr6uskIBQIBDQwMmHN2nSlRGAZmfn7eMki3V+Di4sJqh61Wy/qxyCaIfqkptVotm/rJ7Phms2mR4s2bN60OwfkjmybrRiqe3o5UKmUz6N1saGho6J3OnyTLwGkPoLZDn1O1WtXAwIBJwSBRxL1pNpvGzKTWB/x9dnbWwVrkjoMmADni4Mrlsh4/fqyenh7du3dP4+PjBkfz3NSCRkdHjRnp1hjJYKgrXl5emrPa29szGSWc3+joqHXyd7MITkKhkMbHx3VwcKDNzU3VajV7NqBggkBKBGQJZDLM0aHO22w2LRinpk1TpCQ742SE7XZbW1tbCgQCdueRnuHs9vT0aHZ21koWDPDDgbnZN3uChiHZkot6QLT4zpsogXEwSBScXKOezWat0QyvuLe3Z8UoUkXmA1Bj4IJdXl4aMwsKKEqfXESXFw5+32pdzeW4ceOGORw2gMmL6XTamClooxExYCjf1L5ys5RSqWSR6e/8zu9cd9tsjY6Oyu/3K5VKKRaLWYf7xcWVgq+rIg0WHovFdHBwoKOjIwUCAYMOGchGXYn/Jm3GIQIXgbWWy2XrHaJegpEbHBzU4OCgXQqkT+jP4d3hlNzepGQyaXPQ3S5gdw9dPbhulgvHuPNnWq2Wtre37b1ubm4adJJOp1UoFOxSAaeBZWMoOc8YKcgAiFROTExYr4D73prNpv3MVCqljz76SNLrznNox/wsv9+vcrms7e1t+3s0uFzHxbO5MG2j0bDIudtFXYKAjN9DvfH4+Nj2mD+BQMAgQQaWSTKKNO0G3EkcNQEbNQb0wMh0qM3yPuLxuHp7e43RBowTiUSMmOL+bhir9Ia4jYySDFIEjpOuoDKXaPK2i3dGJg9j0ePxWPZ+cHCgV69eGfyJfSOwpghPAOt2xxMMAmtzP30+nzl6l0XGrJehoSGjKy8tLdl+AHeDzBBk5vN5vXjxwmyFJBPWRB+N/avX60bmcHtlrrOu7VyI6EgzSfnOzs6MM41hGR8f1z/7Z/9MqVTK+hJisZiGhobUbrdNDh2cF4ND0xVFvGg0qlgsZrLjz54907Nnz0zrCQ0dopu5uTkzpj6fT1988YW+/vprJRIJzc3NKRAIWPMfL7yvr09LS0uWKZAtvCljQk+OJP37//6/f+0NZt26dUter9dkwtG6qlQqevLkidbX17WysqLl5WWNj4/r3/13/10rnB8dHVnzoMfj0c7OjgndMc+BiAVIksJqIBDQ+Pi4IpGIVldX7d0xMhUII5PJaGFhwfbd6/XqwYMHevz4sfr7+3Xr1i0FAgFtbm5qeXnZ8N1EIqHPPvvMlGhpwHOZg5LMCHW7ML6uzArBzuPHj7W9vW2R2MTEhP74j/9Y/f39Ngo6Ho8rk8lIkuktuZ8Rp07WxhC0cDispaUlJRIJvXr1yoq0FLQxaBMTE7ZHaHX9/Oc/15dffmnnD/26vb09y5zj8bju3LmjeDxu59pt3oXAcX5+rpcvX3a9f9JVVApRAQUBnAmd5blcTmtra4rFYlb4LRQKyufzltkD/dFc6rLY/H5/x+C1sbEx9fX16datW9Ybxxlkr/P5vGkOLiwsdNiFjY0NbW9vG7JAr9jOzo5NTI3FYvrwww87gpve3l7T/iLy5sx2W3ch86PATuf8xcWFXrx40fGZJicn9S/+xb/Q4OCgstmsTk5OjNHYbrdtMBt1UzQDgR8JEKl3TU1NKZVKWd9ZNpvV8vKyaYul02kNDg7q5s2bltn5/X797Gc/0y9/+Uub3ks7BpqFwLH/4B/8A6XTaQtSge4oVQBNMtTwOuvazgUtJVI1CsVEP2wK2QDFOTbITb3e1AXj+3Eu1Aow7q7+GB6dJiMolOhwUeySZAeNbCYYDBoVkv4VSeZQzs7OjPHkau1A2XN1wd52MaiKyAec1lUGIOOCigkN1P07CBQcSj4nUjBEPpI6Il9gRuk1RAGNMZFIdEA1OFRScGpffH4MMmeAKJfeELq9XWYYrKhulxuVvklSAGrgM0qyM8Pz4njcvWL/yWrcc+ieP94/FG8ies4fZArOn0vLBtp12Y+wsyqVijlMsnZqa7xL3smbRrybReQqqUOhF9qqq2rhLtQ1oGa7BXSe06W84hBxkHx+RobzbFCKycBhdfL37v7zOfh77gg2h0X9ACTEzcJY3WbPMMOwgdgit8cLggMkDorkUNj5/UBc3CkcF3/4eWS1blEfMgBkCDILsmtsAJ8Vaj133i3gc644q8Cb2EZ3r/gM17WB13YuAwMDkmRdwy4tbWpqymjB4NovX7601JsZEBy2yclJw6lPT0+t+E4kyqZzCb/66itJMpqc3+/X8PCwenp6rDGuWCxqeXnZqHcUq0nl+/v7Tb+JZsCnT5+qUqloaGhI5+fnevbsmV69emV1BV6uJBN17HYx+wYlV1LSnp4eff/739dHH31kxsTj8ejhw4dGRf7000+NedPT06O7d+8qGo1aNuX2GZHKwu1vtVod9Q/kHejkvXnzpjKZjBk2fgaHkOwHpg400O3tbRUKBdXrdWuYffz4sV69emXnBIPl9j10u9D7giQACaHZbNoIXUnGjqFu0W63rfiLTAfjljl/RM0uQwooqlwu6/nz5/L5fNrd3dXu7q78fr/NKRkdHVUymVSpVLJ3RiBQLBYNbgBymJiYUDAYtL06PT3V8PCwyuWyvv76az179sw02qgpEB2XSqV3YjtNT08bBPbixQtzyqjiUq9w9dqkK1hwbm7O6O29vb26d++eBgcHlcvllM1m7Q5jXGEYkmV++eWXVv84Pz9XMBjURx99pFAopKWlJQ0PD6tQKJiGnastxjnC4A4MDCgcDmt9fd0aCXlfL168sPdFMCHJWJmMh+hmoSfHnWLAFggAmQdGnECLUe0EqH6/39REgKphLPr9V6OxXUHMZrOpvb09bW1taXt7W7u7uwoGg7p165b6+vr00UcfaXp6WhsbG/rmm2/k9XqVyWSM+ZlMJk2hgjPV09OjlZUVK1EgN/To0SPTcCML/21s3eusazsXd1YB0QHQAoV5orFms2kvHZYNHhp6aiKRMJgNYcaenh5Ly4i2KdDTBFitVi3SoUMXKQ+gISCTer1uESMUy3g8bt9LEyDpKbz5gYEBpdPpDt65i093s0KhkPVpAFsRBaK9RnTMdLlGo2Ey4a5EBgJ8dL1zcdxshghIUgeN1qVyBoNBDQ0NaXh42Jg6rgSFm3USoXHgyRSogXg8HpNMh11FJEf01G2Pi3RVL4B5yDlAlsdtjiTbctUdoCET6RFguDpRGAYyWy4UTbXt9tVYgkqlYo4KSaNEImE6V+yR1+s1eBd4CwMM64fPSAZzeHhokvvj4+MdGRfU+Xfpc4G8UCgUdHJyYnsCJRs6NFkiRphxugQ4MDiR+IGIMzg4aOfPjeipdVD74rnoQUqn00omkwYTk9WQBXIH2UsYWUzrJAOFebm3t6dgMGhS9qAhZJrdOhfm1OA03EwWujtno16vq1AomERNMpk0HTZ+FnU4MgscOmeFAJteNchHhULBIEpGgSSTSevUl2TsWmrXbuAACQUCCo279A5tbm4qEoloZGRE0mt69duevWs7F6AQDIjbxUxW4mpvuXUU0m6MFNGt6+U5QEQ7bKTH4+kYBOSqBPT29urg4EB7e3vyeDymxwRtNp1Oa2xszDrsy+WysTbOz881MTFhfSHUcCQZ281lyrjT57pZpJ7ZbFa7u7tXm/93+0YxE4HKQCBgz46ECeKHHEZ6Jdy9Bqri+SigU9B/syMc/Jp+gPn5edVqNW1vbxs7i/3jZ0ivZ8a7sBsHD8MAo439c/shulnUCI6OjkzXi/PH4WfxGXhWMjnOUDab7Qg8cKREltDsob66w8AwAolEQr29vTo8PLRZHVNTU0YfrtfrSqfTNnYWI0EN8uzszOi5XG7gNj6X2ztBE+O7LAwJApyBQEBnZ2eSZF37MD4lGeyDMa1UKuboVlZWbFomzhNmHs2g3GG61GOxmIrFohWyYUQ9ffrUsuTZ2Vnrk6KmMTQ0ZEV0aPk4c/q50Gs7Pz+3JmQXDZGuaMpTU1MdRf63WQRTKILT4+SyVglicWoERFDWgWufPn1q55SGac6pS0FHMolMxu1N4+c/efLEmrRv3rxpHf3Uo6APsxecNdAISFoEZ8FgULFYTMPDwxaQYU8nJyev7ZyvvcscBFJXePoYSOAc/psLRdTMIazValpdXdXp6ammpqZsgJTrXMrlsg4PD7W+vq5AIKBbt24pEomYg3OZZ2tra8rn85qYmNDt27d1eXlpcvk4F2jQDAgjY5mYmLBaASwdXgJyK0Q90Wj0rQblvLlc57K2tmZYKS+OugvRDIwl0m7qGRxur9drWYcky6jA7xk8BfTlTkqUZIcKna5bt27p3r17BgMdHBwok8kYpOlGfFAhOeBSp2IvwoMYTqjIAwMDXe8f9YqjoyO9evVK4XDYfh6OAePPeQQb5xLx7ysrKyqVSpqYmNDMzMxvOBdom1tbW9bZjMEggkZ5G3HU2dlZ3bt3r0Ohwj1/TCeEvl+pVOxd41wkdahTYLhwLsB53S6CCyBFoBu3hoLKNU6CvSDwol61srKidrutyclJM9g4L0gUp6enymazCgaDun37tqnt5vN5y9pbrZaWl5e1s7OjTz75RPfu3VOj0dDDhw91cnKiTCajoaEhIw9xBo6Pj825tNttZbNZQz7IzEFDyEaHhoa0uLjYdZDokntevnypcDhsGa/LOOWuUFehhMDfX15e2giCubk5LS4uSpJl+MBPZBGBwJUgZeLvxpC7NRmccy6X0507d/SjH/1I9Xpdjx8/Vrlc1tDQkCYnJ3V+fm6sXlefkWeizkwNmD46N5tPp9NvtX/Xdi7FYtGolxMTEwoEAh3G0aXaSZ2jNt/sIkeXqd1u2wFh4yjmxeNxzczMmBEmSgByoAOViIpeG2Al/r/bx0GK7cJ0UCjpNsaJIZmSSCSMrvoukvtEBrFYTFNTUwb7YeSBXlzygwtNAOW1Wi0rZMLccxtSYWRxsYDMpKtMg4ieP/QAwFRC+rxUKimVStkhZP5JPB639zw1NWURmovFAktRzOR98TO6WZw/RAmZjeF2ftMJTc+AC6ngvDlrGOnj42ODfXAykqw+gsGFQQhcAXxDwyYkBs4TfTUQMzh/OA1qZNwR+mmod0HrJYiChfcuC/kiGunION2iMjUel8RANuXCnO7zumwvDB9nDmdM7Y53BO3fhSDZt1qtZqMM3G5yxClpACST4zl4FtAIRC/57GdnZyYSev/+/bfeP2rM4XDYghJ+NrAl++uec4KFUChkdwo9REkmlQRNmf13IT32k3EJnHMK/G6pgiCGc8mIB9oyqGclk0nLFF04HRv75vDAcrmsvb09eb1e3b179+/dr2s7F4o8Y2Nj+vDDD+3C0A3LCM6RkRHVajXt7u6afAlsBqhtPp9PZ2dnyuVyev78uYm5gZv7/X7Nzs5qdnbWilnlctl47tQHkIM+Ojoy8Ue6ocEeqRPRo3L37l3rOeHSUsxCprvZbOrp06cKBAL68MMP1dvbq93dXW1tbanZbOqP//iPr7tttlzpf8aUrq+v6+LiomNuA8KLroMBn56ZmVG73db29rbK5bL29/e1ubmpkZERLS4uKh6PGyQxMzOj2dlZ1et1LS8v6+TkxKAC5tucn59rf39fR0dH6uvr0/j4uM18yWazNuANiW7panQAg+I+//xzVSoVPXz40PoapCtHurGxoUAgYPTLcrlscGA3i3kuw8PDWlhYsAzXhQBSqZSmpqZUqVS0tram8/NzO1dEYpyvcrmsg4MDPXv2TP39/VZj48yMj48bkQLlZJc4sbOzo3q9rrW1Ne3u7ioajVpdDOgLKKNYLGp9fV3tdlu3b9/W4OCgMpmMwuGwKpWKHj9+bD03IyMj8nq9FokzLoF30mq19Cd/8idd7eHf/M3fyOfz6e7du/rwww9NIt6tkaRSKcXj8Y7aKmrmnB86+lHv/vbbb5VIJPTBBx8YzIMjYUAgsBDEICSEXBg8n89rY2NDlUpF3377rfVUhUIhFQoFPX/+XNLVyPCBgQFNTk4qEomoXC7rm2++sT4dgqxcLie/36+FhQWl02nt7e3p+fPnarfb+qf/9J++9f49efLEmrN/8IMf2BnCORIg0gTOQh9wYGBAMzMzajSuBv3lcjmdn59rdXVViURCt27dsrqNK4tVq9WM/EE9GHirXq+bAsrx8bGpqW9sbOjo6MhqQLlcTo8ePVKz2dQPf/hDpdNp3bhxQ5988okpngCPAyeyf8D229vb9g7+4A/+4O/dr2s7F7SOwK6BISiKuvUQ8DwUeIkuiaTdIjFQBQVuSZbtoFUkqYPi6Ubv4MIupAGzwaUkk9a7TX5uvcilTsJVh+4KBQ915m4W0CD4LJAHn4ln4Q8ijODuaPzQHMnsDPbPpU4TLUajUYPjIF9Q92A/2XciR6Jtvs+lRpOyQwyg6MpzEDW6jY4w1ohQu11kqm5nM4QQ9sp9N2/SpCEy4Fzc8+dqOHE+iOL5ue4eu7RkIAMyPJeiz8+RXtPd+R3QU4HsyB4gdmA4+Gzvev4kGSuJPhDqHkT8kuxd8q6hnlJoJmLu7e01tIDz4qoZ8CwEjG8aX7ILNzImoiebdhma7B0ZP0EqbCpqA9goziDvmbPyLntI0yeMSmB093zz2fjnmwgOxX7ICTTvupk/KA0EJLJY2KLsMRJZ/A76Y3gXfB4yO94Xv8/r9XbowWE7OCPY70gkIukqQEBx4zrr2s4Fo/fq1SttbW1ZxAFOKMkkXEhricD9/ivlVOYJMDBLknWiszkc9FwuZ8N2GDxGCujSDBHE9Hq9vzGnZWxsTB999JHhy0QzuVxOqVTKIlkKq3Ses/mSjKpKo1y3C3zzyZMnevbsmdVQXIPGbIxqtWqyEiMjIzZZD4waDSEiTZ/Pp5WVFWNGUWhG7fiLL75QPp83eRT3gkLb7unpsdG1XNbR0VHduXPH9g+Yi4yVYiNwHxpmUHjJuJDwoVDczUI0kHGtpP6k9FCngTP39/dVr9dtdsj09LRGR0fVaFypbKOzNDo6qmg02jHsjroW0ihbW1vGDnKhVUkaGhoyCfO1tTUzEkAn3/ve94wKjjI0HemMDKbPaGtry0gn+Xzefg8MNOjW3S76XHZ2dozAAtwGlAOsWiwWdXh42CH1zryhy8tLnZycWNTe399v6g0Ea5wX+scePHigQqGgZDKpVColr9drhr6392qAINFyvV63Rt6ZmRndunXLFL6r1ar29va0t7enVCrV0ZKQyWT05MkTG0qHscR5p1KpdzqDaH+trq7aVFwkiFyHWa9fjSrATsLMa7fbunXrlp3jQqFghBufz2fNlkNDQ5Y9co+/+uorHRwcGArU19dn+m6JRMLeIfsH7DU4OGjkGggPSHcBOUqypmG3CZtmSpilOPPrrms7Fzwg43/xgNAYe3p6bNxpo9EwfJSF92u1rjp0Dw4OlEwm1d/fb5Go6+XRrCKacdVjwazBdrkYTFwjokgmkyZ1fXh4aEXa4+Njk7PgAqPRRaRLlEpDljszpZvF/h0dHVln8uXlpWWCfr9fhULBMGcgEPoj2Gv3M2HEgFF8vqsJhr29vSYeWSqVtLKyYobiTVzVVbp1Nc58vit9KPofqCHQaEqBkH2hSZVJmgQBnAEgpW73j88FY4jgxs1muMgUoamjUecjEKJLfnh4WKOjo8bld0kBQG21Wk17e3tmdCnUSq+zSYyKK+fe29trMEhvb6+2trZULBaVzWZt+JZrBDAM4OjMc6lUKmZAMMrdLrJgpOcxhDwL5yLxd2OsCU6AeeiTYH+Qx3d1rSTZmSK7LJVKevXqlXZ3dzU/P281T0kWHAA3wiTjZwAh9vT02NTHFy9eKJ/PK51OW1307t27ikQi2tzctOclG+SdUpt8lzNI4As9eHNzs6MOhC2izotDpL8K+8YdBkaUXus3UmcDjTk5OdHGxoYNxIO+PTIyYhkO75EBd36/3+bz4HwGBwdNlBdBzUgkYgon1HzIwM/OzqxXkZ/pKkH/fevazgWxRxc+otAOxopRpmBIwaunp0fpdNoK0m+yeaAxSp3d+xS7gTfIgoBxSEebzaa9FKJ36Spy2d7etv4E1EVhk9An4abRpKxjY2OWKtJD8y5NlBTpKNiyfD6fjQFwef2Tk5Py+/0aHR21meGoUJOqUrQj6uDyEO2S9n766acGUSGMCeSAAeX52+22xsbGDL5ALZcolKgJOIrIVJJJl3i93o7GWeRpoBB3s6i3cfY4Q+7+AQP4fD5NT093dEbTxIoeFIoSFI15LxhZagZ8fa1WM1IFEJjbNU2Eh4HmUq6urnYEDVxmMm+yAAI32E6Li4sGPULcoHes20X07CpncIcJEAkkKNp6PB4NDAwYRRmIlSAOY8rzU3x2qbKBQEB37tzR9PS0ZQ+cQe4u7w2bgUJ0o9HQs2fPrL+mr69PMzMzZqihKOdyORWLRcs4qVfxM5CkeZc1MjLS0Y8Sj8c1NzdnewsMSJ1pcHBQkkxNG/khAkUgSXf4F7Co2yFP0yqzqTijnD1sBu/P5/OZ/IvP59P+/n4H6Qm1eAJ2HAlDErEpOPV6vW7aaf+/TKIE0kKfK5lManp62iTaEVTM5/OKRCI2cAppaTqMSSFxKOCYwGG8CHo+JJmRR6785OREz58/N5iBiw8LZXBw0ArjfB00Xpycq8clyeCmarWqdDptCrQHBwfGCELssZtFDxCHBwad63jRW0okErp3757i8bjJs+dyOb18+dIOYjKZ1MnJiQ4PD3+joYqGw5OTE8Xjcf3oRz9Sf3+/HSQMPbAEuH61WlUoFNKNGzesaRaox23gZP8Y9Xt8fGzcfCi2MMnQkdrd3dX29nbXjZT9/f3m3Gq1mmKxmMbGxjqa/k5OTlQoFBSPx3X79m1Fo1FzttDbcc7BYNAuSzKZtCgQI+Fiz8jBDw4OamBgwM4fpIpisWiFcNhsNOk+ePBA1WrV+j2GhoasFobgI4SSfD6vSqWigYEB3b17V36/X/v7+yqXyzo6OtLh4eE71Vyof1EnQuUW4kUoFLI9TKfT+vzzz5VKpcy5MDaD7JGAo9lsmoOm/wyH0Whczdb58Y9/bHsCu4nnBorkn319fVpYWFAkEtH29rb+9m//1nqnEn83zjwYDJrOXaNxNWqdYDKbzWpkZMQYXQcHB4ZcQGDoZs3NzVkwxRgOtNBYGH/YlGQmBCpkBThk4CecErUslE4gRP3e7/2eYrGYlQYKhYK++eYbg7F7enosaAaSjUQi2t/f18rKSscd5gzSrwNd2uv1qlAoKJvNamJiwmjHKysryufzdja+85qL26HJpXPpklA03YZIn89nRSZohsABZDBAUhT7gdXIXiQZfOQWVGGyEIHBzeZzUMfgM5MKU4ymYY2vc18QxTaogK5mULeL5kbpdbGUTIWD5vYMkc4TmVHgZHocNRjmrnDAiQbd0dBIzXDZKQ6fnZ0ZNEaKzHvgc7EHOEe3+A1nn/cCLIaBIQqlhkOxtZsF1AmsQHRHZuzy/zl/0usxuDCS6LuiiOlqg7mQAGeK7Brjx9mB/ACsA3SFo3PpsRTE36Sdo9dHoAXlF8KH+zycwXelI7sNt26Bm71gSBcFcFfXD6ILThEHxfRYGixdA8p7IMvhvNC7xTkmWySLgkjiLvaUZkNJRtHlv8keoFSTWfGz3qQJv83inOMQgAeBR98U4X2TyMIzkyVQwwQNINgslUoW6AFJugrG3CMCFGwU7DzOLWffrTuxr7xzWi+wm8jE0HLAe3GVTq57Bq/tXCjA88uKxaI1+Ny6dcsar7hADKECX3Y3CBrs8PCw5ubmjLPu8Xi0vr6ubDarSCRiUAa1gsHBQZvtjDIvmj5jY2NaWlpSo9HQ5uam8vm8FZipa9RqtY7BVlNTU/aS3EOAsabfpre3t6PTtZsFDRcjc3FxodPT0w4JG14itRn2DscCbLKxsaFyuazFxUX97u/+bscFevHihQqFgsLhsBKJhGq1mr788ksrqiPR//z5czUaDc3Pz2tmZkYTExO6ceOGKpWKfvGLX2h/f7+jiRIY6eHDh9rb29Pk5KSWlpYkyZxdT0+Pda7TdcxhBCrp1jhCLWf/Dg4OjC7+0UcfaXh42LJiSdbEx5Aw6TXLEOx+aWlJN2/eNNy63W5rdXVV2WzWZtO0WleqFBiDnp4e7e3tmS7dyMiIneOPPvpIl5eXWltbsyIuUjP0shwfH6tSqdhQJgw0Q8mQEWGfMJYua6fbRYCIw0PtIBqNamxszMgXBH5IxzP8CgSAYnSlUtHU1JQ++OADc7j1et1GSAwMDJie2cuXL63OGQqFdHx8rFevXpn2YCKRUDqdtmFejNr1eDwGR+Ho9vf3LXOYn5+3QLfZbGpubs6GnQHDu02O71LQZ8w0MjXU/cLhsH73d39X4+Pj5jyq1arW1tY6HJskIzLs7Ozo8PBQ8/PzWlxctDIDaMHm5qbR42mvgCI/MTGhUqlkLRqZTEaRSESjo6P6+OOP1Wg09PLlS52enpodrdVqZpshjcTjcd2/f78jmw0EAh3q8sDk9Bq9jb7dtZ0LKZWLJxcKBesVoc5B0ZQPe3JyYqwoUjNwQjSoiGpJOWlW4jJB16NABSQDK4zUMR6PGwWW+QUYIyIoZFGAonj5YMWksHh6CpMU2LpdFITJUGCLEQFKsvoPNED2jyIncAIwndfrNQNIjwVd0TRaQY64vLy0Dmn6kqAjAkEysIkDSDZHZM7vPzo6sg586XVUymF0G0CJZkn734XKLb1W52a6ZE9Pj3VuE6W5lOmjoyObAsm5pWbAzBf3e5DZkV7rmUFQIOvB0Z+dnWlkZER9fX02f55aINIl7AWOFYOEKgNGWXo9JhgH6dYnXVXod12cM3okcDhk59CUKdDzuWnGA324vHytC0hm02q1DK4mwAByxqAR0FFDBPLs7e21MwpzEcfgUmhLpZIVpDHIZEOwH9l36bUEFdl0t4uMk8yMQDcajRp5xKWesx/YPjIMHBCkF0ghrkjk6elph8QTagn0GVH7wgaSeaJzh53AqZI9u6gJOnfSVYDYaDSsn4nFOeVevw2h5NrOBYYHsBEMBDYSh9BqtUzUECZRJpMxeiWXFBgHI3d6etrRucofv9+v8fFxk2ThwtNIB354fn6u58+fm7xBu902vB9JDvcyNJtNKzADufh8PpPY4FK4fTPvouo7OjoqSXaB6/W6hoaG5PP5VCqV9PLlS4MhXF2koaEhm8QHJp9MJiVdvXjGwjJ1r1QqmUFyazoQL4CtYNbhYLPZrP76r//aHLcka4zkIPP5xsbGdHFxoV/96lcdzD2X0QYbjtk57zLLhX2j5kN0T0aAVAY1JZ4xFAqZPAnGjz9ExblczrIZGjPf7DshuxkaGtLg4KDq9bomJiZ0dnamgYEBC3geP36sev1KsBBWHRAEFGXYbdQJcEQ4coIFDCmfF2jqXRakCPcONBpXKr2lUskkQ6DfU7tMJBKKxWLmZOl3wTGura2pVquZSnaj0bBsi6+fmpqyACSRSCiXy9nPo0mz3W5rfX1djUbD3osbcAHVxmIxpdNpVatVUwGGkAHcAySLE3yz566bBVNqaGhIQ0NDVp+F6QdEhaNI/N00TuqmBM6S7HOUy2XLSgh6EEAlOCMI8vuv1OBpGL9165aq1aoGBwcVjUZVrVb1i1/8QvV63ewB1HxUMyTZ3chmszbuHDkj9luSwc/VatWCV/rdrrPeyrmwwUSzRBT1et2cBJ6OFH9sbExjY2NGK6b2ggeEnfDixQtdXFzYDHP3hdKL4NYlZmZmVK/XrYhfqVR0cHBglDlJNjvbxcthTF1cXE2AZBN9Pp/NpCc65ZLz32dnZ9fe2DcXGmA4ZzK8er2ubDarbDbbgatj+OnIRRcIlgp7ncvlLM2u1Wq/gdGjOoAxxuFw+FzngoAgRgz9JsQzPR6PyaMfHBzoxYsXCoVCWlxctKzENQaXl5dWCHzbqOfNBc7MiN5YLGYNdCgOEF0DYQaDQY2Pj2toaMggskqlYnPMJZlC8JMnT1StVo0QwXMEg0EtLi4qmUxax329fjUE6+zszKK/arWq5eVlc8StVsvEB3FUBC/xeFy1Wq2DNgvDbnBw0J4Ho0imwM/tdoEExGIxC9ygua+vr2t7e9ucGSQHOryBk+iC52ddXFxoY2PDqLkU5JGPx6hPTk4qHo9bP1Q8Htf+/r7Ozs7MYJZKJRtiB5Tu9oFBKMK4P3/+XI8fP1Zvb6+N+uV8u9pbnGl+TreLmgo1HVcrDh0wl1SDusL09LSN/yZIcJuNCYzITmgzcJvJp6amTMCXnrylpSW7w4HA1QCxZ8+eWaAClMiANBq5Occ7Ozt69OiRgsGgbty4YWK9JAfU3bDZ2MLrrreaRAmX/fj4WLFYzGRUSLO43Ijfwchh1DHw0sjIiF1CIlqmzHHQiE6AA1wKJCklD06UR9rLwYaVAzuKrMpVm6Vzm2IuEvYYaAy9C7l0s4CQ6A+IRqMmhQGThD4fIL5gMGhNY2Refr9fY2NjGhgYsBTc7/cbnAChAmadW2CmbkBx383M2u22FUeBtIhgDg8PtbOzY4YcfBtcm0yBGhF1Ahceg4nV7QLiQ+MtHA5reHjYCsiQPM7Ozqze1NfX1+F4oaOn02kLMBjIxqhYmiLj8bgGBwfN+br7RITO+XMNAVi1JMuoYZURTLiFcrfPiXfMO5VeK/HyO97FQQPrAllzzzDAqVTK+ltisZjNAaGxjn32+6/GYqdSqQ4CROLvxkJj4LnD9MAxuTQejxtTjOwW4++SS9xmX9fh4gAhisCSot+D/pFYLNYBeUJO6XZx992ZNASNQIMuWwymInUqase9vb2am5vT4OCgvU+yOppq2+22BgYGzGHibN0+LBwb9H9XNw/dR0l2b3AysDwvLy+NAEA/HShSX1+f3QnEbaXXduw669o7PTk5qUajoZ2dHT158kQfffSRvv/971vfBLh/sVg04yZJz58/17fffmtzBMLhsI11/fbbb/XgwQP5/X4tLi4qFAppfHzcmrWIhknJ9vf3rbkQQwz33zUGIyMj1rXv9/u1vLysr7/+uqNpiUiIoj3R/MbGhgm6SeqA6t4Fr02lUrq8vNTW1pZWVla0sLBg+5BMJk2D6uTkxAqPHo9Hz5490+bmpuHL4XBYn332mRKJhFZXV/Xq1SsTxOMzAh9lMhlLbXHK/EHehQ5tYBDmcmDw/H6/nj59ql//+temDICzAp9Np9MKh8M6OjrS/v6+0um0RkdHrbMc2GJwcLBrpk4mk9Hl5aWePHmi1dVV3b9/Xz/+8Y8tCqc2QiMakfXTp0+NeAJVFoXZp0+f6tGjR+rt7bXBVZOTkxoYGDBYEdUGOtYPDw8tYoWVhyGYmJhQKBSy/aPe9/z5cyOguEEDEvbJZFKBQEC7u7vKZrNGRfZ4PKY0AEzS7f5JMliXICAYDGp0dNRGfXu9XuVyOe3t7amvr09jY2Py+Xz69a9/rRcvXigWi1mNaWFhQdFoVGtra3YGR0dHra7VarVM8+78/Fw///nPlc1mlUqllEwmDYJ0I/ZMJqP5+XkFg50jf1FVIEigs71Wq5kBxxBvbm5ag+z09LQ5J5pBsQvdrmazaT01S0tL+gf/4B9YFo0NyWaz6u3tNZ24b775RisrK4rH4xodHVUkEtE//sf/WLFYTN9++62+/vprBQIBm+s0MDBg5xqnkc1mLVBxERQXThsZGbEm1ZGREQta6/W6NjY29PTpU7v/BNnT09MKh8MaHx9XKBSyDHZ6etrIGJxd5nZd9wxe27lwWTAskjoohJI6sE3+HxfRpehROIfnTecnhX1ePoUrV/kT3BBD76bMbuMlBTb3ULhfCyxAeupSJPl7vo809l2iHmiRrnYTv4ceHRyAS9kl4sYB0OsRi8WMSg2dlUyLKJf35OpTuVpkPC+Noy505WZoLlWaPeEdk6K7Olj8fvf7eVfdXmyKm6TqROHURXiPMBbdAjpSF2RORGqQNHgHLi2ejME9f7BlXDq2+4flNhO/KUHC3vIZIYxwZmlMdet+/L93gXQkddxdakEEae48EijBfAYcAeeNbMuNjiXZ9/Es/C5QB2i7IBH8bjI5YC/eHX8vqWPviNY5F0TT7pnga/lv1668y/6xJ+79RRYF9XTsCp8BAgh7BapCUIldgkwBfA2cx70F6cGeAq+7GnB8L7/7zTPDneB9vbl/3C3KC8CwrnrKdde1rSUpGxlGKBTSz372M4ti+vv7bY4D0Yskm7zo8riBwoAkXHbU48ePzYjwMmEIwRIBN3S58TCIUPik0xlxuHQ6bY1iGOj+/n5TcL64uFAqldLc/9vemwS3naZpfg8WrgBIgABILNwpktqVykxlZmV1rdE1S0z0zPS0jzMT4duELz7ZZ199dYTDF0/Mxe6wo/vgsX2YsN3dVV3Z2VlZqZSU2iiR4k6QBAgCIEFiB3xg/159UFW7JSh94xehqCwtIP7f//ve5Xmf93mvXOliQRWLRRv/+z6ZSzweV6vVMtq21+vVixcvTAJ/fHzcBonBIPF4PCoWi3aZYPZQFDw+PrZuZPYql8vp5ORE4XDYhouxOGyk6MBoOCSe+f79+1aI5ZCja0VGMzo6qlgspkqlogcPHnTJSfj9fsuIYDzl83mrifWy5ufnzYkxBZLmuitXrtg0UsQZgVXQpKPW5orwvdk31Wq19PjxY/s5jNh1x2YzNoB9JRL2+S7kc46Pj/XNN98YbEKNZmpqStLrekc8HtfY2JgVxMvlssbGxnT37l37TGqZzO95X7YYMGwgELC79+2332pgYEDT09MKhULa3t7W2tqa1WJ4/+D97BeaY4xnwDB6vV5lMhkdHR1Z8yIOBITArX94PBdNfX19fYrH49ag+6tf/Ur5fL6rmxwSEQSMsbEx3b59W/V6XXt7e6pWq4pGo7p165a8Xq8KhYL9O9SI36XD/M1FJB+JRMwOffHFFxoeHtYHH3ygRCKhTCaj7e1tYzF6vV6rMWPMBwYGrIaRzWatdSAej6vdbmttbc0EZBFsJRvGUeJUJFmwiaBtqVTSb37zG8tQUCPhHRKkh/9uQmar1dLKyorVbNGKOzw8tMyRRACW6tust3Yu0CZhOJVKJa2trRmEwwOQ6hP9kbIR7VLbkLob46ib7O/vW18CNRpqL0TZRFjS645Y0sfT01OtrKx0SZ4PDg5qbGzMjCXcd4qITMcbGxszrj8ZEKno++K1QHHJZFLBYFCFQsHgmqmpKQ0PDxtFmGYzj8djRo9npyF1cHDQsN9Go2FsvuPjY2WzWXPgQFt8fxw/+Dn8d/68XC5rZWXF4Dne79WrV617uNlsGn8+n89rd3dX2WxWs7OzmpyclNfrtc8n0j0/P3+vDnNqckhonJyc2DA5jBYpP+fMbSQjO3ENJN8F49fpdAzyqFarKhaLZngDgYDtt5uRcKYIbhi2htw5YwtmZ2e7ovxgMKh0Oq1CoaBHjx7p6OhIiURCk5OTXVkz1Hne3fssmJbQVsvlsnZ2dozq3Gq1LEB0jVG73TYiD/uFIaK1gIjY4/GYY3GVkqnPuXtN4IGSAtl4oVDQ06dPtbGxYYKUjKImyKxWq4rH40qlUjo5ObGxEuPj40qlUjo/P7e6Dk2ZdOj3egZhaQLZI1zZ399v35E7zF5h795sFMUuEuhxXjudjnK5nMFgjGJwBXpddAZUgTozNvDp06fK5XKm3AEsjHNxdSER9D05OVEqldL4+LixWMmm3WzzbddbW8uHDx+aE8ApoLbJXBCYYhh6SVbQQ54deAEGFk5naGhIfr/fVICRvGg0Lma2EDG4TXquvg5MB4/Ho+npaYt2iLogH8C354C5PRJIhGB06YVAIsPtwH3XtbOzY/tHxEGTKC+20+lY7YTogIMB3k4kCZFBkhkHtMgikYhlXfQFtFotLS0taWlpyfad4jHvgA5z2HlucRUGFc2d9EW4g47c+hjOhWJmX1+fOYZe1m9/+1vbP0lWI8LYNJtNi9Loju50OjbXnbNBwdKlV7oXn0CJZkfwfo/HYxRoivZer9eiQHB3mD2xWMzuSigUsmgwn8/b4DT2j2cqFotW+Cd78vv9isfjxtp6n5oLqr7A0j6fz5TN0YfzeDyanJy0ZySjIOJGi4w77va+YTiXl5c1OztrhBH2sFaraWpqSpOTk+aMYExBliCzTKVS8nq9Nh+eyZLUEHFOnC+3r2lra6trQBuLHrZe19HRkaTXjeTBYNBIJfl83gKZdDptmYoka5cIBAIGX0mvGZDUjcj0R0dHTc4IROfZs2dGVU8kEmo0GnavsVUuQ3R2dtYCapw7zhHyDlJeBKJkWa7NIBhwB5597zWXX/3qV/J4PIpGo8YkmZubk9frNU2xSCSiWCxmB6fT6ViRDpYUnpBOVYwCUR7F1J2dHeuR2NzcVLlc1p07d2wKIZcbSWrqFjQAVSoVk+1HHdnr9erp06cqFouWAYBXclDh7h8dHcnrvRiONjExYTh9r5f7xYsXdhFxVEjAb25uqlQqaX5+XteuXbPLjioBlEKgjHq9bmk1EA1ROXz4zc1Nffvtt5ZholmVTqcN8oIdVy6XTdyR93N+fm7Gkp4BhO12dnaMcUbTH2xCCBZEVzS7TkxMdEXl77r+03/6T/L7/SadHwwGNTY2pna7bQOS5ubmNDExYRE/F31+ft7gAgwQrC+UlQlwXJYbag4MHrt+/bqRRqDmojDs813I9/MZrVbLYKFIJKJUKmUGg4CmVCoZlk5flpupShe4eCqVUjwet071XhejE6Bq49xopiyVSopEIrpy5Yq9c6jvbt3Mpfd6vV6Tz8H4XLt2TbFYTLu7u3r69Kny+bxevHihbDarkZERffzxx2q1WhZkcoel19nB3NycEUyAk1zxUWoy9BTRC7S/v2/MNvq1gMOxT73WXhj4B6TJmWk0Gtrf39fa2pqWlpZ0/fp1g2RbrZbC4XBX7QoyDU4aJ0BQwbtG6aBUKtlAuX/6T/+p7t69a59NtlytVruGjF2/ft2agrnLMNvoa+LM4fD8fr+Oj4/tsxib0Wq1rEHzXfbvnZso3ZQMJ4HH5VJQWCV9Bt7hElHY7e/vN7l2vDifK8mohOG/mzXuzrV300IKW0Rfnc7r4UYuZMF3ly4i32g0agJ6FAh5RmA9IkiX/dPLgv5M5gKVl8IvUQ57RFTnRomu4B3P6OqpEdnzjNQd6ACm14WDRLpL4c6daSK91p/CoNCJTxSN5DkH1CU9EJ1BAsH49Fo3YLQA9TkK8WSgnEO3Q96NvODq8+zU8shU+PecPfaP3hrO38jIiO0/sC3/no5rt5GOTB7sHEiIRkZECLlLnD8+3yVnACP1usi8OfNuxOrW3KgnvElKcAvE/DfwsgvXAOdw5/r6+qw3C4QBOSieibuG1hn/7k37Isl036Dse71ek3fiGehrc4kA0mt1gl4W/R+MRKCYz10EVcBRutpeQMP0fHEGoWxjV7Cd7h2WLhAM7rurLu/zvR6fAeUY6rxLiOD+cpY8Ho9lomdnZzo6OrI7xTvH2bn9Qe+izfbWzuWjjz5Su32hs1QsFq2z9M1uWFQzMUoHBwf23y7OR7fpnTt3jI7oRjHBYFA3btxQq9XS7OysarWapqenTVeHrmCovJVKRc+ePbPIDAYammWbm5tqt9sWqc7MzOjzzz/vwpiBgMCHoTDm83lNTk5aBNLLmpubs8LZ1taWXTaoh2hjbWxsdF1i9rdSqVg9Znx83DI1onckJRC9o8jYaDQsW7lx44ZisZh18fMugHeePXsm6TUzBxKB9FpCg5HAS0tL+vDDD5XP5y3iBj5zmUiSzLhEIpGenfPHH39s2cbOzo4ZGIw72cLOzo51I2PIXSo2PRqBQEDpdFrXrl1TvV63OguRMM2h7XZbk5OTqtVqWlxc1JUrV1Qul7W9va16va6xsTGNj4+rUqlod3dXfv/FgDQuLoXQlZUVg4k4fz/4wQ9sHMTBwYF1cmMkMcAEImRVvS5k6ldXV7Wzs2PUYreWc3R0pLW1NfX19RmUh3Eno4PtRHA4Pz+vcrmszc1Ng5bpfQkEAopGo/rRj36kTqejq1evanZ21vqDiKrJhIAgMdZufRCjHAwGjWo/Pz9vElPMWWGPybgInvgZvd7hxcVFtVoXI9DX19c1OjpqSEokEjEprC+++MJUDAjiQEYymYxR3ycmJhSPx+38uHNi6Be8fv26WoLGQksAAJo9SURBVK2WpqenVavVdOPGDU1MTNjztlotm2dULpftDuOYCVbcHiqgtvn5eX344YfK5XJGwkAdhGAQAlC9Xre68ffuXGAVMGcArI+DzwsEDuNAwnqQXivawlAC40Zni8jTbYJi1et1m9hHFlStVo3OB/aNo5Ne01QpcpGFQOvFMJOluEVaIqlCoWCMozcptu+yiNY6nY5pJpGJUN+ADcd3JzL3+XxdDX8UUyn0IdFN1AhzC3YNDYBIZPBsRCrUzU5PT+3/vxkh89wUeUdGRowBRySP8SE65M9c1YBejWMkElG73bYRC7yLdrttRpzzhhIEWTBGhbG3iJGSubhTQYEZ0L3jLHP+oIyTgQIdssc0FXOWuPTUhdgDMmdJRsEnEnWL9y50y+f2uoaGhqwJERYXUIkbUBwfH3dRYn+fc4EZhqMh86GmBWPRzfp8Pp8ikYgGBga6pILc7JkzTsZHoErGwN2lcXJ0dNRgGwJcHBGZGmgKlOf3yZ75DDKXaDRqmTmCnPl83t4f2Qy2s1gs2nhratSuvQK1ODs7swF73K16vW7kFTeDIPCA0AIBA/vnvkPekWt/gWBdJMhtOyExcFs53ma9k+Q+BWcXInNpxO4F4eE4XIi8uen+3t6edYu6GL570Dqdjk0+rNUuJjSWSiVtbW1Z5I9BnJ+fN2rx+fm5NWw1Gg1jjriUZyCCWq2mwcFB8+CxWEzLy8vqdDrG2iDq6PVggvNTnHVVUIlUcLwYZ7KwYDBoEyybzaY1n1FH4JIDw+A0KLzj1Kljwcap1+umSOvz+Uz6BqYPWmT0L7VaLZP6yGQyNt3y4ODAdJOq1arS6bQ++ugjeTwem7zoUsZ7WcjbIwcOLEpAAiTlCmVKrycsouTLWaZzn+iP5wOywphh3JrNpvb29lQoFHR6emoTCBuNhhnMxcVFVatVbW5u2vmDIk19BUMDiwhj3mw2tbOzo/Pzc8XjcV29elWdTkePHz9WqVTqUj3odTFplRoO2SU6aPRUuaMYgsGgqSKfnJzo4OCgC2J5+fKl3SW36NtqtRSNRjUzM2Pnv1KpaG1tzcY57+zsqF6vW3HZJYZQH6NG2Wq1lM1mJV0oRvh8Phugdn5+btkzxp2mVkm6f/++MpmMZmdntbi42DPrk2ePxWL66KOP7PfJOjwejwWx1ImGhoY0OjqqQCBgyiY8H7CkCy8iaYSDAMbirOzu7hrlfnd31xwDjLTJyUlVKhXt7Ozo7OzMWjCo03LWCc5weiQNiOImEgmr/x4eHiqTyVij7NvawLfeZb4Ms7/pvaAY6CqY4vkoEo+MjOjw8NAuEZ+XzWa1tbVlfSvUXPjyZEYU7NyxoQcHB5Jkmk/I7pdKJT18+NCUcPHMhULBpEu44HD1MSgHBwfG1rl3755lD/TP4Mh6WQglRqNRzc3NWTRQqVS0ubmpo6Mj03DCuXi9XmMakc6T+ZDhUVClQAt1FPxVel2D2t/f1+rqqo6OjvT06VM1m0199NFHRpAIh8NmCI+Pj01ixi0a7u7uWhEbCBRx0K2tLbuAP/vZzyyjwVhJ6nn/KpWLEbNjY2MaGRkxh1+v17tgTbIYWE105ZPxkLEh6gdUhoIvdZQ3I95ms2liilA3pdd9PxMTE5qZmdHx8bG++uor7e/va2Fhwbrx2T+K2EBwboaayWS0u7urmzdv6qc//am8Xq+ePHmi09NTow6/T0EfdYWZmRml02nlcjmtrKwYbReGECQbnMvU1JQSiYR2d3d1dHTU1ZS7ubmptbU1RSIR3b5924glyMtAWmH/Ga6Gcex0OiaFQibuqi9Ho1GTdTk+Pu6SSaKFAMgJ+vjh4aHdG97b06dPJclaKXrdP4/nQv1iamrKyC006nJO3EbT4eFhpdNpJRIJHR0dye/36+zsTHt7e11ikOPj40okEgoEAiboSb2YvebeZ7NZG12C7aK2mkgkdHJyoufPn+vo6MgQDM4bZw+4kXcOa5CZR9Fo1CbS0o8Tj8eNWv42662dSyaTseImFzcUCtkPJtKlQVCSZQYYUiJOt9AGa4KilM/ns9SVdJCmOaABjB8eHlYE0QsFRpciGIvFuogIFLb5961Wy7x8PB63SABWEAXEXi83kY0kg+IwTOwDUJ0kK/CCTddqNdMPIwMgPcWIk/qS8iI26hZEoTrCqiILJUKXXhcPofmCX9NMSM0HmI/sYH5+XlNTU0qn01bAxvFDAuh1ofnm9rAwVliSnS/mzLswjysx7pIUXCiUKJHAg/92syB0tE5OTmyMQat1oXvFqINKpWLfgcZLMla3QEqG70aSTHxMJpM2gjscDhu1/n2pyAQjSLFXKhXbQwItYEycstfrNUosZ4G/g55YKpWyZlEyZQweJBHX4I6OjkqSRemcH7JylwUJMcO9i5xnFBcwvo1Gw9isUMGbzaZSqZSazaampqbeK/vLZrNGroF4g6wT2f7IyIi1S0DScRuhsXVkd9Q2+vv7zdm4zoW6JffZJVVx50GDIK40m01Fo1EL9gkyqbmB3uC8OOcej8c0IePxuLVshEIhpdNpu79v2yf01s7lm2++kcfj0ezsrBKJhGKxmObm5lSv1/Xy5UuVSiXNzs7q+vXrpoXjMonw4LwcjCkH1S0sUwyE2ZNOpw27bDabOjg4sEZBCrVcer/fb/LeGxsbevnypaLRqK5fv269NF7vhYbS1taWFXPb7bbu3bun27dv6/T0VHt7e2q326Z15EpO9LKePHliFzsejysajWphYcGMBf04dKITlefzeZ2enmpkZETT09PmfHHYyJ0QkXORIQrwZ1xGcGrgBzJGoEnpQkeu1WppfX1dW1tbisfjWlpaMkPk8Xi0v79v5ANgjRs3bmhxcVGFQkEbGxuq1y/mT7iD0Ho1jqurq1ZvqtfrCoVCSiQSpi7M4LiFhQU1Ghezhjh/RGLz8/PyeDxdFGD3nXLxyBK54Ohvcf5QemaIG9BCLpdTf3+/Zmdn1d/fr42NDW1ubmp8fFx37twxdtPQ0JAymYw2NjZsAFe9XtetW7e0vLzc1XDKM72PU2ER4NBpDaWaIA75dowQdQGGn3F2cD7g+YlEwqChZrPZNfCM5yBgxPGSoVC3onOfBmqf70KAFtXqZDKpTz/9tGuQWrlctr1DOfr69etaWFjo6nP5+OOPde/ePWso7nUvnz9/bg4/FAoplUrpzp07ajabpri9sLCge/fuqdVqGUy8sbGhk5MTRSIR6yFCQcQlv+zu7lqwgoIxjhYlZoIhr9ervb09u9uSjI7t8/m0uLgor9er3d1dZTIZxeNx3blzx+o90LjJwKWLIPXWrVumtpzNZtVoXIzYQPdMei2z8w+td6q54Bg4dG8uCkjSax0eCv+uTo3UrRXE4abOwAFgY10s3Y2uaBAi+qc50Y2uiIAwrHwv/r9LJ4Th8yY27ur/vG0x683lFtPYvzfpkWRu7v5Q73DHueJ43e5Z9oDPYf+4UJKs4EnmBDZMBOPqckHjdv+b/+/uH5Ab+0RhkSyT5juixV73j73HydMM50ah7APnifPnZi9vwnP8HvvuFpe5uG4Bm/PkFt9dGrkk+/vuOaX/ANUIGG7sn1vjoJbTarWMust+vs/i/QKJAF+7zz0wMGDfgXuALhhGDkKOS3VlX/gs9t6dz+Q2A/NzsRncMe6Ze3fJAtlPfi5ZgEu0AeJ1EQkIM27/UC+Ln8Mdxj7wHK6t4e7hICqVihEq+Ptka66DcG2BJLvf/HL/Ds/MeyODo12AjNA9gxT3sXcEl9wb2JeQYjgzNHm+yxl8a+eytLRkD0aGsLu7ayk+EY0rK02UCE2WmSVQ52i+dBsLMWKlUskmXQKZAUsQHQ0PD2tmZkYTExM6OTmxeRJwyUdGRnTnzh0rrJEZoTfEELNnz56pXC6r1WoZFoo2FoVIJhq+bUr45rpy5YrBAmCWkBioOTWbTYu2aG6jTkBdY2BgwMaaHh4ean193bJCDH4wGNT5+blWVlbU39+v5eVlo2XCOkFR4eOPP9bc3JwODw+1sbFh8AOyNIlEwhyKW3yORCL6wz/8Q52fn+vFixddExwpEIIDo/gMRtzLmp+fl3QRQBwcHKjRaBibC504iCPSa6HVo6MjnZ+fa39/3xS76VUhcgsEApqcnOwSwITW7fb9wOIB6vX7/VpYWFAqlTJFaIq1lUrFmuGgo8IGhCF49+5dK6TSPX98fGzKt5IM2snlcqby0Otyo3a3f4FAhbNGYMLewUCiTuU2WEIQGR0dNYkgiuzu4DGUqPP5vI6OjrrUfScmJrSwsGBohwudz8/P6+bNm0bKcOX/JycndefOHdM3g6rPd6V/iOcDTu91D1GYcNmUEHVgXiFD5J5BMvtarabt7W17tk6no0wmo62tLcViMf3gBz9QMBhUNpu1FoBisai+vj4jjdAUCXNwcPBiZtHs7KwODg706tUre34yzFu3btn3Yu4VUi8ffvihEaZoeM7lcsrn89rY2DC4NhgMqlQqmY19q/P2thsbi8WMucUDsgEYTQ6l9HoehSRjaaEYSgTjNra50Qj/liI6UQJZE3TETqdjXbcU+KBa8p3ppOUziSIoyp2enurg4MCatZAjd6UpgKneVxtLeh2BE4W7dGCotGR7blTjzspB2hzYrF6vG5SB82JyJXpOLqxIgICzisfjFgTglMHTcXoEDZAiEomEFhYWdHJyou3tbaNBSrK0nrOB5hEzyHtZwDeHh4c6PT3V4OCgNekRLXo8Hrt0GFLgHRrfMAwUTguFQtfZw2gQhJDVSq/p95xxYJ50Oq1Wq9XFPGs2mzb8C6kO/i3BEbpY9GBRo+Rn8zPb7W5pol7Xm02F7i8yET4fB4uaAAYacgb7nMvljMWFyCSd6ChdBINBG2EMjMUvsqGJiQlVKpUuhIL3nkwmrYBdq9XMeaXTaRuvMTw8bDUlYDgib7It7kSvy60Zsm+uhp8rfeVmXW7GRRDhCrxmMhlTuYCAhIMgyCXDc0dMu/Ix8Xjc7rRLuabIz7ujj4ZR5alUyiBS5I6YRku5gPky1WrV7svbrLd2LhQf9/f3tbm5aSKFpFN8KRSEuZAcuFwup1evXkl63flNIRXjwwsaGhoy5gQXeGhoyKYJUnjCaWCQgScoagUCAU1PT9v3I3okEuSiJJNJpVIpu/yuIUTNme/2PrAYGHShUND09LRmZmbs8GHUeHEU4+PxuPr6+pTL5WwELLpsLvuJ741+Ujwet+iSgi2H6uTkxIw12CvZHIe60bgYqjUzM6N6vW4Hl3dWKBT0N3/zN/J6vYbTYxCgIEvqMtrvQ6OlGfHo6MgaaGdnZ63oWy6XjQqLc5Gk8fFxm+TpGnG3N4EmVUnWREvjJ5EnEE8ul1Or1VIymbQInhohlE8yl5mZGSWTSXPi1BSazaby+bxReBOJhMbHx80oSLLgxu0rA9LodU1PTxsrbXNzU4lEwmSUCHTcHiF38mF/f7/y+by2t7cNrXADkdHRURWLRfve7OPY2JidQ9hO0MbJ6lziSDKZNANIdspYbbefrVgsan9/X9988428Xq/NHwEeAj6lthsOh1Wr1Yz+38tiyOHGxob29vZM5BFmZrFYtBn2riNPp9OampqyO0zWC72c5uJXr14pl8sZ+5NghvoTWRn9aDMzM2Y7yKCwY5yzaDSqpaUlY9tBfIK+/dVXX8nv92tpaUlXr161u4o8DPeF7wu8+DbrrZ0LG7W9va1vvvlG7XZbn3/+uUXcGG734lJcTyQSWl1d1ebmZhdji4wH2KBer5sHh5EkyYw+VMZwOKzl5WUrtKNRRoEM+GxkZESLi4tW3IPO2mg0TK4+Go3qF7/4heLxuDY2NrS7u2v0VjjtFC/dZrF3XTgBhoV5PB79/Oc/N9jPdS5u9/nCwoISiYQeP35sRhXaLQYBXJyDho7S4uKiQXtkaNvb2/L5fOacoWo2m03FYjF79mbzQvl4aWnJIAYyhcHBQW1sbOjp06eKx+P6kz/5E01OThrFlB4cYBcXM+61mAqUuL+/r0ePHqndbuvjjz82dWgkN/h51IkWFxeVTqf14sULm0bKn0NdxvkS5VI8DYfDarVadnZKpZL29/cVCoW0sLBgcAfNmfF43GjKYOxTU1Oq1WoaGhqy5t9KpaKDgwM9f/5cY2Nj+tnPfqZ4PK7t7W3t7+9Leg2Z0ptAz8f7wGKLi4tqNBp68eKFvvnmGy0uLmp6errrLNHrQuGa3olYLKanT5/q5cuX9jz9/f2KRCIWWEB1DgaDRhphaCC9NDiYvr4+Iz7ASPP5fJqentbZ2ZkKhYI1ri4sLBgT6/T01Ig4m5ub2t3d1cTEhP7Fv/gXSiQS2t7eViaTsXsiqWu8Bs2yvaypqSk1Gg09fvxYT58+VaPR0PXr1+Xz+UzJAzq/W4O5efOm5ubmrLMf50IzMpppz5490+DgoD799FNTF8ehuBN3i8WiIpGI2UBKDv39/ZqZmbHMo9FoaGJiQh988EEX/fng4MAUVp4+fap0Oq3//D//zzU9Pa3d3V1TBncbWGktoc76NuutQ0miThzJ73tBb6baFFbfxqi8WSx3aacuRonBcouwbz4sn+UWyd1Um8+Bkvr3fcffV8B/X9YO2cI/dMDd707Nw33W3/fd3OIq++e+N7cIy2ezF+6zuRELhXHeg9uXQQr+5h7zrvg+75OxuPvh7p+7Dzwbz+n+mQuRuXv05me7/+7N535zX3gmNzqVunWX3L/nfh7LJQy4+/v3wVbud+t18TMwGuyjuydv/iy+25v0d3fv3O/NuXbPIPvy5rO4e/L7fo/P4Xv/vj1ydcSA1N7ctzcL4L3u4e+zQ79v3978X/bvTXv15vchUHT3wQ3K3jzDv88Gur/HZ7t2lGfgzLv7R83R/Vnu5/y+3///Wp7O+4RCl+tyXa7Ldbku1+9Z7x9SXq7Ldbku1+W6XG+sS+dyuS7X5bpcl+t7X5fO5XJdrst1uS7X974uncvlulyX63Jdru99XTqXy3W5Ltflulzf+7p0Lpfrcl2uy3W5vvd16Vwu1+W6XJfrcn3v69K5XK7Ldbku1+X63telc7lcl+tyXa7L9b2vS+dyuS7X5bpcl+t7X5fO5XJdrst1uS7X974uncvlulyX63Jdru99XTqXy3W5Ltflulzf+3rreS7/7t/9O5ugNjw8rGw2q5WVFQ0ODupf/st/aXM/KpWKyU+3Wi29evVKmUxGx8fH2traUl9fn65fv654PN41x166kCFnzOvExITm5+dVq9X08OFDHR0d2TyM4eFhjY+P27AdhhEx7Y0ZGEyqc4cHPXv2TAcHBwoEAgqFQgqFQlpeXlYwGFQ+n1epVLLP5fswWZH5EP/tf/vfvvNG/zf/zX9zseF/J3+9sbGhX//61xocHNS//bf/Vrdv37Zpk8ix1+t1ffnll3r27JlJZw8ODmp+ft6mRDLsikFpjCyNx+OamZnR+fm5/uZv/sbmPfBs6XTa5rr39/fbsCMmeXY6Hc3Pz9uwsFKppLOzM/3yl7/U2tqalpeX9dFHH2loaMgGRpXLZZ2dndmcina7bTMkmOEtSf/Vf/VfvfP+/fEf/7EN1gqHw9rb29P9+/c1MDCgP/7jP9bVq1dtYJo7UmF1dVW7u7s6Pj7W7u6uPB6PpqamNDIyovHxcSWTSTurDEqr1WoaGxvT1NSUzs7O9Ld/+7c2gpcppouLi13D41wpcmTnJyYmFIvFTA6+0Wjo2bNnymazJn/OzJxgMGhTXpkd1Gq1tLu7q5OTky6J9//hf/gf3nn/JOm//q//a3k8HkUiEQWDQWUyGT18+FBer1f37t1TKpVSLBZTIpGw89doNLSxsaGDgwPt7u7q0aNH8nq9unHjhqLRqEKhkEZGRuxsMuW0UqkomUxqcXFRJycn+vM//3NtbGzYLKdoNKrr168rEAhodHRUQ0NDdu7dFY1GFQ6H7QxWq1Wtrq4ql8tpYGDARphPTk7aQC13AmSj0dDm5qYKhYJGRkY0MjIir9er/+K/+C/eef/+1b/6VzYcb2xsTJlMRo8ePVJ/f7/+6I/+SEtLS10D36SLybcPHjzQ2tpa19yl6elpjYyMaGxsTLFYTM1m00atM79qdHRUyWRS5+fn+uabb2wSabvdViAQUDqdtmFuzLKSZNNXGSEdi8Vs2m21WtWXX36pjY0NBQIBjYyMKBQK6erVqwqFQioWizo5OVEwGFQ8Hpd0McML28BIgP/uv/vv/sH9emvnwuCuUChkBn10dFR9fX0KBAKq1+va39/X1taWIpGIPv74Y4VCIY2Ojmp2dtYG/DCEKBQKyePx2LhODiZDccrlslZWVtTpdNTX12eT+jh8DAXjMzloXq9XgUBAXq/X5sIHg0Gbejc9Pa1EIqGjoyMdHByoWCzaFMNIJKKRkRFVKhVtbm7a5MBKpWJzFXpd1WrV5iH4fD4lEgn94he/UH9/v6LRqBqNhnZ3d7WxsaHR0VF9+OGHGh4eVr1e18TEhMrlso6Ojmz6H+OHC4WCBgYGbJwz8xpKpZJWVlZsiFoikTCD1mw2tbm5KUkaHR21gW0MoxoYGFC73dbu7q7W1tY0ODioSCQij8ejubk5xWIx+Xw+7ezs2CCjdrutVCqleDxuI3kbjYYODg5ULpcVCoVscFQvq9lsyufzaXBwULFYzN43Q7o8Ho+y2aw2NjYUi8X04x//WCMjIwoEAhobG1M2m7WBY/F4XIFAQENDQ6rX6zbgSpKNlyaoaLVaNg2VoImpigQd9XrdBmS5c0fYv2AwqPHxcfX19dno7Ww2q93dXdu7wcFBC9zOzs6UyWRUr9dtjv3g4GBXINbLcmeytFotjYyM6M6dO/L7/ZqamjKn/fXXXyscDuvu3bsaGRnRzMyMotGoRkZGVK1WJUmTk5MaHR21EdzuvSsUCja5NJ/Pq9lsanR0VMvLy+a8+/r6bBb8+fm5vVvuMLNFdnd39eLFC5smKV04nKGhIZ2enqpYLNpsd5/PpytXrtiANiZj5nI5FYtFVSoVnZ+f97yHo6Oj8ng8Gh0d7ZrA2dfXp0Qiob6+PmUyGa2urioej+vnP/+5DU2bnp62AFu6sKODg4M2WdLn8ykUCkmSjo+PbcQx02ZHR0c1PDys09NTG0Z2fHzcNcnW7/dboD00NCS/3282eWhoyO7t/Py8pqamdHx8rIODA52cnOjFixfq6+szG1iv17W2tqZ6vW53mM9/2/17a+fChw4PD9tFmpqasgfhIqyurmpmZkaxWEzJZFKjo6Mql8vq6+uzSYBceuZoE3lzqPr6+mxymt/vVyKR0MjIiBlnJkvy75vNpkU+HML+/n7t7OzoxYsXmpiYUDgcVjAYVCKR0ODgoJrNphnfw8ND+Xw+3bp1S/F4XOVyWZlMRufn5yoWi6pWqzahsNfBV/V6XZLU398vj8ejWCympaUli+gbjYay2ayePXumqakp/eQnP9HExIS8Xq8mJiZ0eHioly9fqtPp2CjjUqmkk5MTDQ0NaWxsrGvAULlcVqlUktfrtQMuXThl5rYzfTIYDNr+MIO80+loa2tLKysrGhsb082bNzU8PKxUKqX+/n7t7e1pfX1d5XJZ29vbqtVq+uSTTxSNRs04Mvf87OxM0Wj0vSZRtlotm1zK5cZhcjaOj4/14sULtdttTU5OanJyUq1WSwMDAwoEAjo7O1O73VYkEtHg4KCk106L+efHx8eWveVyOcsYMSZ9fX2q1Wo6Pj5Wo9GwTLHZbGp4eNjep9fr1dHRkba2tjQ2NiaPx6NAIKBUKqXR0VGdn5/b9+Hizs3NKRQKWXCDgalWq4pEIu+1f5JsmBbPHQgENDExob6+PsuEHz9+rF//+teamprS7du3zQkzPfHo6EidTkfj4+MKBAI6PT3VycmJZcGMQz8/P7fAzO/3K51Oa3x8XGdnZzY5tlqtGhogybIKMmwChs3NTY2Njenq1auWFY+MjKjZbGp3d9emZ3Y6HUWjUc3NzalSqahYLNo435OTE5tQ2+se4jwDgYDdmdnZWXMMfX19Oj4+1tOnT7W8vKx0Oq3p6Wn19/drfHxcOzs7v3NW2u22ZfvhcFg+n0+lUsmcTr1el9/vt3HRfr/fBvWdnJzYoC/uRiAQ0MDAgCEaR0dH2tvbs0AgGAxqbm5O0WhUz58/VyaTMdTC4/Ho2rVrSiQSqlQq2t7e1vn5ufL5vCqVitn97925YKgkWTTMheMC8kPL5bKePHmiTCZj0R4XpNFo6OTkROfn5xobG1MikZAkg66YHsjmM9Gu0WjYZLv+/n7FYjG1Wi3lcjmdnZ1paGhI0WhUXq+3C57jO5ZKJdXrddVqNfX391s0I11EQqSWb2YoRPUcqF4PJiOgmZ7XbrftEhGlATFJ0vPnz7W3tyfp9fTF/v5+g/2AT4iYPB6PpcxkexwEd5Ilz0QmiHEbGBiwlLdSqVhqjyHmcnY6HYsa8/m8Wq2WGb7x8XGFw2H7+a1WyyJRDnuv+0cQUSwWbZwul82drNnX16dKpaJHjx5pd3dXe3t7Ojo60unpqYaHh9VsNlUqlVQoFBSLxRSPxy2bY68xIIw55tmJEv1+v0ZHR7vmzfv9foXDYfn9F1eKIIpgBlgWeKFQKOj4+NiyIjLHQCCgcrls34Xn7O/vf6eo8fets7MzeTwe1et1G6WNI5RksHcymdTQ0JBWV1ct8MLoYdww2MPDw3YG3bG42AP+bavVsqxnYGDAMk/2t1KpWCAkybIaxjt7vV6Vy2Uztl6v18Yhc5dw/tgc7gJz398HeZBkGUN/f7/dAzJ6IClsRbPZ1KNHjwwWPjs7U6VS0fDwsBqNhiqVik5PTxWNRi0wZNS7JHsWMupGo6F6va5Wq2VQWDgcVrvdNic6MDBg48u5F/39/QoEAvL7/To9PVWj0dDw8LCq1aoODw9VKBTU6XQ0PDysgYEBc5qMNGesOXf4/5fMJZPJGNwyPDxs0eLQ0JDC4XDXRc9ms/rf/rf/TX6/X5OTkxofH5fX69XMzIwqlYoeP36sQqGgH//4x7p165bK5bJevnxpDsHn82l0dFRjY2NqNBqWRWD8ibikC6dUqVQ0OjpqNZoXL16oVCrJ4/EomUyq3W7bbHIM7cbGhra2tjQ8PKypqSlFo1GD+7hAXq9XoVDIjM27eO3ft3/SRWodDAZtZvvQ0JBBjaOjo5qcnNTZ2Zn+z//z/1S73db169c1Nzener2uQCCgWq2mnZ0dnZ2d6caNG7px44YajYby+bwdvna7bRkmkZE7jhgYrdls6uXLlzo8PJTf7zeH7e739PS0arWaDg4O5PF4VKvVFAqFdHBwYPv3wQcfaGxsTIuLi5qamlJ/f7+y2awZFxwjsFQv6/T0VF6vV5lMRtVqVaFQyAy3JMt+BwcHVSwW9Wd/9meSLjJFLnwsFlOlUtHDhw+Vz+f1gx/8wGpKh4eHqtVqarfb6uvrUzQa1eTkpKrVqu7fv2/BAYY+Go2q1Wrp6OhI1WpVAwMDNve8WCyqXq8rmUxqfHzcnEqlUrFIfmNjQzs7OwZX4MxisZjOz8/NOBJ8BAIBc9S9rqOjI0mvR+FS62CRJd++fVulUkn/9//9f+vs7EzhcNhqlKlUSq1WS5ubmyqXy/rkk090/fp1NRoNq4sSRfv9/q7ovFKpaGhoSMFgsKuutLKyoqOjI6XTaaVSKVUqFW1tben4+Fj9/f2KRCKSZLWqUCikgYEB5XI5bW1taXBwUMvLywqHwzbjnZpbp9NRMBg0tILf62Xx88/OzpTP57syYEZtDw8PKxaLqVqt6n/9X/9XeTwepVIpy9z5s+fPn6tQKCgajWp+fl7ValW7u7tmA6kljYyMqFar6eXLlyqVSlYnAUXodDp69OiRyuWyRkdHtbS0pE6no3w+b/XpRCKharWqbDZrzmhwcFA7Ozu2f0tLSxodHdX4+LjS6bSazabBbQSM3K+3XW/tXIAl3BnsGAyicbwbNRNJGhsbU7VatUtC5sF/uzO0mSFNZE8USMRLdIeR6nQ69nlESu48dLw/WZH0eg72wMCAHcahoSGD5dzMieI7EfE/NPf+/2tVq1X5fL6u2ergpEQ+4M7ABRT42Q93LjnwC4V8lxThviP3/blFdfaP5+PZ3Xn0OCIOlnThnPv7+zU8PKxIJKLh4WEzfDgSgg7+Pg6vVqv1vH88P++WiIrDTmSKAy6Xy2o2m4Ztcx6ATvnV399vz8w8cQwQESDniOyB7MXj8XRlnu7+sbecYb4DZ5k6Ft+D7JOgZmhoqCuQ8fl8Vl98nz10F9+fM8EehUIhg5AqlUpXUMeZcu8F+9pqtewXP4s/c6GbUChkZ473RtDnEiRcmJfnJojA4Y6Njdl/U7clI3f33+/3m3PvdfFcPCOfy7nHBhI8kqVSBgA6dO8uZwc4GqcIOgRJiX0G8gKC5G4ODQ39TvCGzSTT4g6zz6Abrj3GlpPxce84P2RWb7Pe2rnw8sfGxhSNRjUxMaGrV69a4TyfzysYDOoHP/iBisWivvvuO8OU6/W6vRSfz6cPPvjAoIXDw0MzpETgx8fHqtVqVsDkhYyPj1vBeH19XbVaTT6fT1NTUxoYGND+/r5FD64jI4X0er0W3d+4cUP/5J/8EzWbTZ2cnFhkf3Z2poGBAd28edMOVKfTsWJ7rw6GiHVgYECxWEyxWExXrlxRX1+fms2mzs/PLWLm0nPIKpWK7Z/f79f169fNCFSrVYsyOBilUskOZKfTMegmHo8rnU7r5OREr169UqVSUSgU0vDwsBlpr9ercDhsUA/F7pmZGfX19WlsbEzDw8O6deuW/sW/+Beq1Wra399XtVpVoVDQ6empRZIQNOr1ul6+fKnvvvuui0nzLot0PBwOa2JiQqlUSnfu3LFs5ujoSKFQSB999JGKxaKePHmis7MzDQ8PW+QN7PSzn/1MHo/H4NB6va5qtaqzszPlcjmdnp4aq0qSMdSi0agikYiq1aqOjo7UbDatHjg4OKiNjQ0zFJxb2Hmzs7N2/prNpm7evKk/+ZM/UbVaNSy+Wq1qe3tbHo9HH3/8saTXEfHq6qoeP378XgGOa1y4y9euXdPAwIDOz89VrVY1NDRkTMJEImH7FwqFzEDCFoO9x94Vi0WDqorFotXGPB6PsQfn5+c1Ozur4+NjPXv2TOfn5woEApqZmdHQ0JAODg7U6XQUj8dtr8mWZ2dnzeBSvP/5z3+uWq2mfD5v9ZRcLifpIrB118bGhjGuelk498HBQY2NjWliYkKTk5Py+/3KZDI6PT2V3+/XtWvXDDYE6jo7O5Mkq2F98MEH5ogajYYV7pvNphGN4vG4ZYDz8/NGthkYGLCaIMy7aDSqTqej7e1teb1e+3sE3OFwWNevX5fP57Mg6tatWwoEAqpWq9ra2lKlUtHBwYERLLjDOJsXL17o0aNHBiH/Q+utnQuXBhhnZGTEHoiNjUQiisViltHgIcFi2ZyJiQmNjo5ahEmRi0JguVy2CNSNjkKhkDGrCoWCzs/P7eLX63XLlogyiTBDoZCxxYCjwuGw4vG4zs7O9PTpU4M96vW6HR5qPe4L79U48kL8fr/tYTwel8/nUy6XU71eN/jt/PzcImMiGYwM9aZQKGR/RlGPCAqiA4eCZ6Bwy2GuVCpmMIhOuDxuxDI8PKyJiQljCII1J5NJlUolffnll8rlcqpWq6pWq4rH44pGo0ZPBr/N5/M97x+RMg5idHTU6nX7+/tWcIzFYpZx4KSpp5H5TkxM/A7zij3BUOIU/X6/gsGgRcljY2M6OTnR0dGR2u22Gd1araaTkxN7h0TM3Jnx8XH5/X773GQyqbm5OZVKpS5DUSwWFQ6H7bwSLW9ubiqXy/W8f+wh/8v3ikaj6u/vN+NGAFSr1RQMBtVsNu35qZtRXyLroh6Ag+QXmY5b6+DZyGTPz88NwvV4PCqXy/L5fIYcEP1zBsmIQRdCoZDK5bK+++47u59Aum6GBEQLRNzLIgPjDg8PD2t0dNSovycnJ4pGo0bh5QyQ1bjZDq0Ybi2FzBcHTX2G/SZg5mzv7u6qXq8rHo8rFAqpUChof3/fIG6ycsgb6XTa7mStVtPExISmpqZ0cnJie8fZj0QiSqVS6uvrs++3trZmQdXbrLd2LpOTkwZ3NJtN5XI5/fa3v7XLNzc3Z5vcbDbtUoPbATtgsImwod3BvgF3hsbcaDS0s7NjHHAwQ/cB2cBaraaBgQGl02kNDw930UXX1tYMrx0cHNTZ2Zk6nY7hp6enp0YFpbYAOYAi2MLCQs947b179+y/s9msqtWqOTL6BShY4gRIV10yAxcVNgnOkv6YwcFBy+SGh4ctGoG26PP5rLBHdB6JRHRycqJ8Pq+BgQHNz88buwooYXV1VZKUTCY1MjJiTuPk5ESZTEaFQsGMDTUuN02PxWL66KOPfgeaedt1/fp1Y1w1Gg3t7+/rr//6r40KD/20XC6rXC6bQ+VS84tiqnRBUoHaCW2VaHRkZMSClp2dHZ2cnCiZTKper+v09NQCAjIizvTQ0JD1MGAs6vW6nj9/Luk1BRXndHJyov39fRUKBXNUnHGcod/v18TEhO7evftemcvy8rKki/rV+fm5SqWSfvnLX1qWQhSNA6PeCMaPg5Yu6LJAJ4ODg6pUKiqVSmo2m5qentbVq1cNcqvValpdXdXJyYkZSHqfcFr0pJA9pVIphUIh5fN5u+/Pnj2zPhMibt45mQI1CSAjCu99fX3Wd9PrHl6/fl2SjPySy+X09ddfq6+vT8PDw5qenrZ3WqlUrM5DBuvxeFStVrtIItio8/NzCx4SiYSmpqaMvt9qtbS9vW2kqHA4bLbCLSUQhMI8jEQiyuVyyufzki4yN4KK/v5+nZ6eKpPJqFQqmY2AYDAwMGCIE7+i0ahu37791vv31s5ldnZWkswoHh8f6+HDhxoeHtY/+2f/TFeuXFE2m1Umk1Gj0dDAwIAVcv1+v0XSZAe1Wk2FQkG7u7tW8JSkmzdvampqyozpycmJDg4OdHBwYAefF0RkzwWuVCrWoAT1j4v76tUrdTodo9pBMz47O9Ph4aFFNESzRNu8xGAwqBs3brztdv3O+vzzz9Vut/XkyROtra3p8PBQm5ubCoVC+tnPfmbNntC2KfzhXNxsTJJFOAcHB3ZIPR6P5ufnNTEx0YWT7u7uamtrq4tFQ0QUi8WUTqe1tbWlra0tS4eTyaSy2axRQZ89e6ZqtaqFhQXFYjGNjo5ajxDGN51O22XIZDLG/hkcHFQikTASRi/r7t27arfb1kOxu7ur+/fvKxAI6I/+6I80Pz+v7e1tHR4eGoUThwI0gdGsVCpqtVra29szSjZZ8tzcnFHsiZx3dnasJ6XVatm+t1otw79h2AUCAc3PzyuVSllD2t7enh49eqR6va6rV68a1TObzapcLmt3d1enp6eGgTebTeXzefX19Skej6uvr0+pVMqK1b0uDMPOzo4ODg6Uy+X01VdfaWhoSP/yX/5L66ci8IKeTEGc4KTRaBhLE/iFJkC/36+7d+/q6tWr5nDoKdve3pb0usnUrSPQyFuv1zU0NKSpqSlNTEwol8vp6OhIu7u7+uKLL1Sr1XT79m0lk0mdnZ3Z9z06OlK5XFYwGFQkErFmRIrjgUDAAuReA5w7d+6o0+kol8upUCjo4OBAjx8/1tDQkP7xP/7Hmp+f1/7+vp0V9gzHTBsF8F1fX5+KxaK1O8Ae/OijjzQ/P2/BUKlU0qtXr3RwcKCZmRlNT08bOsFddh1Mf3+/FhcXNTk5qbW1NUkXwcDLly/VbrftDp+cnFjWsre3p1KppEgkYr07JArU2cbHx7uaNf+h9dbOhaKzyzgKhULq7+83rBpj5HpV4AaiTuoA/Pmb1F+civS63jEyMmIRKNRIGtZ4WL6XCw1xiMCR+f1MJmNR1Zuen4wFiI0UcnBw8HeKrO+y+P7UMMC9+/v7rW+HhjAomxT5cC5EQJIMDuNFc2HdYiPOZHR0tIsJhsIBMAeQJYVTms0IBgKBgPUOSLJIKBgM2gWWZFE9P5sLBNxC9NbLqlarRvrgczF6p6enOjw8NENERzs/i/0AIuF5KfpyfjjjRIDsJcZKkg4ODiSp6/xJsiyDBlSaMckmZ2dn7cyjljA4OGi1jlqtZj0g7B9nxG3mfJ/l1u4gREQiEYPFjo+PdXZ2Zr07NIjy76AvS7LzCPTs7iH3DFIAxIpoNKp2u61sNmvQM0QGYCscDc7BhdOnpqbM4FFj83q99j2BenGO/CLYoAbcq3NxWyVQZ4C5xh0+Pj42BiEBB/tE4R0iA+8C8gKkIvaRoJkmSs6g20zNuZNe204QF5clOjQ0pGQyaf1F+/v7ZtMIvAjcz87OuggkEFSwEW+73tq5AEOxSSMjI5qcnFS73dbW1pZevnypbDZrl4+LTFErGo1qenpaPp9P1WpVpVLJaIL8PZehQ+dup9PR9evX1Ww29e233+pXv/qV5ufn9cd//McaHR01SMbtjaEJiQatVCqln/70p6rX6/rzP/9zPXjwQHNzc0ahhJ1FVnB6eqqjoyNLX6vVqhXwejWOu7u7ki4c3ZUrV7qw6L29Pe3t7VlDmkvlxDkHg0GlUinDjTk4fAYHv1wua3h4uIt1cvPmTS0uLurRo0f65S9/qeXlZf3whz+0mlOhUFC9XjfG1/b2to6Pj+1dzMzM6N69ezo/P9ef/umf6ptvvtH8/Lz1jdD/QRSGEQKC4yLQTNjL2tzctAvo9/sVjUY1NTWlTqej9fV1PXv2TLlczgrCXFicsyRj2JC5SLJmPKIzOrtxPl6vV5988om8Xq9+/etf69e//rWmp6f1z/7ZP9Po6KhFzEA59AQRWDUaDaVSKf3kJz9RrVbTv//3/15ffvmlUqmUZmdnjQiBQeT9Y2D4BVz3PmwxusOpJYG5S7JubbJgl4jD3oTDYTuDY2NjXX/m1vjI9mgCbbVaWlpa0vz8vF68eKGvvvpKMzMzunr1qkZGRrpUCHDQpVKpqwaQSCR079491et1/cf/+B/19ddfa3p6WktLS6pUKjo5OdHp6akODg6M4UbPTCaTUa1W64KVe1mHh4fyeDwGV7XbbU1PT1vAsL29rYODAyMWEeDQ4zMxMWH1mGw2a/uMg8Yx4DDPzs50fHwsj8ejO3fuyOfz6euvv9ZXX32l2dlZ/fN//s81MjKi/f19FYtFo3f7/X6TDYKlmkql9PHHH6tWq+nP/uzP9ODBA83OzuratWtW9z4/P9fh4aG9V2rmZ2dnqtfrSiQSmp6efms6fE/OhSiUgl82mzUIAK8HLdCl6FHgo44hyTaVugzRKb9o7HKjOOAHCnZEIrwccHUitP7+fo2OjloqSc+Be4nfjFz5+cCAZDe9Hk6axLhAGORWq6Xj42MrhiKNIb3OFt1IE+fCMxPxSbLv7tItXaaOS2gAKqB2AlnA7/db5kSmOTAwYJIbZDZoF7lZ45u4rxtt8/vvk7lIsn2j1tdqtbS/v6/j42PL+nDO7r64kSEMO0nGFnPppK5ECEYKZ089JxgMamRkRMVisYtOC/uPTAvKJ5R8mmDJBlyIwXWE7vuTZFnk+/S5vHku+vv7zUgWCgVrSORdkTVAPyWY4c66309SV/c4dT3+LQV7GJnAzq4kjfvZvAccFntIpsxnuI3DfEf3fXJ2cF7vgz5wtkBscPyUCUqlktV43bvhFvPdPhGXkUl2T6aALQC1CIVCVishsITQQP+K2zDN/kqv6dtIW2EDXTvCHX6Tbtxut43WTybzvTdR7uzsyOPxWBOg9JqeDBx17do1/fSnP1W5XNbq6qq9UCAMMHc8JWmwJGMx7e7uKpPJaGxszNgNOKrl5WX5fD5FIhGTxTg4OFA2m9Xo6Kh1p+K8QqGQxsbGVCqV9Kd/+qcW8S8sLGhubs4a6Dwej87OzhQIBBQIBFQsFrW5uSmPx6MrV64oEAh0RZG9LIwDvH/6bOgYb7VampqaUiqV0vn5udbX13V+fm7wCQ1OkA3a7bZJtriRB1nk9PS0bt682bUfd+7cUTweVzgctmg5m83q5OREo6OjmpmZ6eovoCchl8vpyy+/tMDh888/VzqdtuYvmHp08KIt5vF4rLD4JmvoXRf0YLcL3K0hSdL8/LxlY+vr61YcDgQCikajmp2dVafT0atXr1StVu35yuWyNZ2tra2p1boQPb1+/bqdz3q9runpaf385z9XOBw2+itwnJuZcTmheedyOf33//1/b5Twzz77TKlUSouLi6rX61ZfGxkZUTAYVKlU0tbWljwejxYXF60BD4Pe63IDEs4xEA1wUjqdtoxqb2/PmF/1et0aZVFBoP8KCIt92t3d1crKimKxmFHYefczMzMGc62srFhAA1wMEaJQKJgm2ejoqAqFgv7sz/7MzjK1q1gsZkFjpVKxPSTrkS6o5G/2g/WyaMymMM+54l739fXp6tWr+oM/+AOdnJwYHX50dFShUEiRSEQTExPWHuDaT/a/Vqvp6dOnarVaJj5LvabZbGpmZkZ/+Id/qEAgYC0gLqGGNgwCFX52Pp/X//K//C+Whdy8eVOzs7MG1/b39xtzj+x7b29PXq9Xt2/fNiWC/1+cSy6XM6PjsljYHK/Xq+npaX366afKZrPK5/NdKZ8rPPemZIf0Gr/f2dnR8fGxrly5opmZmS5ZlsnJSRN3IxWGUz88PGywDlE1PTmHh4f6q7/6K52enmpxcVGpVErJZFITExMWnWGIoEDiXFKplBKJhDGKei2oYhDdBjtkIojcxsfH9cEHH+jo6Ejb29ummebSbz0ej3H6cep+v9+EIjc3N3V4eGgd3670zcLCgubn500Tq16vW18HdRjooBQGh4aGVCwW9Rd/8Rc6Pz/XZ599Zoq4FFWz2ayk1wq2+/v7FoyMjIwolUp1qUr3stxMU5LVNtyVTCZ19+5dHR0dKZfLqdVqWePayMiIJiYm1G63tb29bWeTLnGiRSjnbiGbuhx0bC46+lWujAt/hsEJh8Pa3NzUf/yP/1Hlclk//elPde3aNaVSKVNeQI4jHA5rZGREe3t7VtdaWloyyjIMrV6X26DoGgjOP8Z5eXm5iw0oXTimYDCoyclJ9fX1qVAoWAboZmrn5+d6+fKl1tbWtLS0pKWlpS6qOwEgRJB2u62JiQlzCtBv6X+DBn1wcKC//uu/VqVS0fXr1zU9Pa2xsTEjQFDnwaFTrJZen0syqV738OzszBAOgkXUR1wb+NFHH+ng4ECZTEbtdtvsiiveyrt04SeQkr29PR0fH+vGjRu6fv16FwqUSCQUjUaNAICmY7lcNqq8K8WDIO/u7q5++ctf6vT01BxLOp3WxMSEEVNoh/B4PDo8PNTu7q68Xq/m5uY0Nzeno6MjHR4efv9ssTt37lgNAqkMl0FCQ9/GxobJX0iy1HZ4eNiohFAW0XYql8sWqQHhIBHh8XgssncLy1y+dDptKrdvSjHwAjqdjhYWFlSr1ZRKpYzmy2fQJYvDqtVqxsXnEriF8l7W9evX1W63lclkTMyQaIrvwCXn0tJUSspL9ABTh+YpIg+XbRQMBruaKiuVihKJhDHl3HdYr9eNdst3gP2DMccpsX9e74X6baPR0MjIiFEX9/f31Wg0NDc3Z1nWzs5OVyd4L+vGjRtqty8k/BEr5HtQWOeiuTAj4ok0rEmy80f/CY6+1WoZ/BcKhbrqWBSlFxcXjelFsx8Gze0DAf6RZAwdcGt6IxDGhI4LLbnRaCiZTMrj8ahYLOrFixc6OzuzumSvC1LLxsaG9vb2rJdLkmkFdjodU4SmqE8tMJPJ6OnTpybe2W5fiIBGo1H7u8A1qF+4MJskI5ecnJwYHDQ+Pm6FcbdHCweOk4BBxRmEpQak1Ol0VCqVlM1m5ff7NT4+LkkWhHJWel1v3mFkiAiQIWhsb29bHQlWLDU11IqB2BHEHRoaMu027jM1IzJLCvvRaNTQChxcNBo19QiCTiD0g4MD1et1zc7OqlaraXp6WvF43Jywx/Na1gh4r16vm5wRNVnYed87W+yP/uiPVK/X9X/8H/+HvvnmG42NjRltcGxsTCMjIyqVSvrqq6+sSC7JWFDFYlGHh4ema4XmzaeffqpcLmeGrNVqmT6P29NwcnKiH/zgB7p3756Ojo70zTffGGwViUSM644DaDabOj09ValUks/n0w9/+ENrzurv7zdl4P7+fk1PT2tgYEDPnz/X+vq6IpGIrl27pna7rYcPH+rg4EAjIyMG7/Sy/vE//seq1Wr6n/6n/0n37983RV8cDP0NKB3DgKH7HEo1tQzp4jDTuUuvBVEgzBx3/65cuaJ79+6pWCzq6dOnBsWQBtPkCHxDhuP1em3/kHzJ5/Pa3d1VX1+fKes+fPhQz58/19TUlH7wgx9Ikr7++mutrKwYjPa++/enf/qnevjwoaanp62Rj/4r1IRh3Z2entqZ2Nvb09bWlsGRZDMLCwsKhULa2dlRX9+F5DgMO5p70TP78Y9/rB/96Efa29uzzGhxcVHhcNio7dLr2h9nXrqgovt8PtOwK5VKWl9f1/DwsK5evarh4WH91V/9lX7zm99oZmZGP/rRj+T1evXgwQMrSLvMvF7WrVu3VKvV9PXXX+sv/uIvNDs7K7/fb/W3QCBgXd61Ws1qWNlsVrlcTqVSSblczvo6+vv79cknn+jOnTsGOeNwgbRwLAQu165d07Vr11QsFhWNRlWr1RSLxTQyMmL0Xrf+CFowMDCgH/3oR11yRbDD+HO/36+trS29evVKc3NzpsTwl3/5l1pfX7fMoVdo7Be/+IXq9br+9E//VA8ePNDk5KRJIRGQFAoFQwNg3+VyOQuytre3FQwGde3aNVM6mZmZsUzw5OREIyMjFjwCs9KkjDIKs6doWwAeLxQKkmROJp/PW9f+xx9/bArNbtPl4OCg2UDaDhKJhO7cuSNJ+u1vf6u9vb3fkY/6h9ZbOxciE+AEWGPUBEirgBiAz6iZEFm4tDaKRBSugGIwum9q7bjFJ/7c1eVx03S3MM9/828x0Kenp9YlCyXS7eiVXnfXul3yvSzwVJwGRUqMIzDKmxTjN/XU3AUcASZOfxGHALYSjsLtBsap0afAd+TvkfXA4KMQyi8ka3gP7J1boAWPdwkSvS72z6U1A3m5MCvPJ3WTHajRcJ7cjnzOX6vVMrq3S1N3f/HZUFHZ706n06Wd5u7BmzAUBgNWGY2zbxIeeAcUrt/HsUivafXcBc6cq6gBNZuzzn672lVAOHw3ek1wCn19fRa0EEywd+4eQrqACECdhH0ks6GQ7sKN1BL5M76/WzN0zyD1ofdZ1Csgv3DPiPr5Trwrl7QjqWv/OINkau5ZhKwCmsEZcclF7B/EDIrxLnzsSr1wj13iBH+fn+Huj1vgp6bGz/reay7/4T/8BzPMzD1ZXFw0B0MBGDySy+kWvICtMBLr6+s6OTmxwVb1et2aACVZeoYTKRQKWltbU7vdVjwet3SxWCxqf39fq6ur8vkupN8RCoSSfHBwIJ/Pp5s3byqZTCqXy+nVq1fGwADzvXHjhur1uqWS7Xbb5DzeR3rj3//7f692u62dnR2TNb99+7bBV+6F5edQIETuf3x83OiqFNG//fZbnZ6eWjPg1atXbY4JGm04s62tLf3617/W0NCQETNwEvv7+3r06JE8notZM0NDQ129JTBwaMA6OjrSzs6OFRFRdb5+/bo6nY6ePXtmwQMd08BEvaz/8B/+g6SLi/npp59qampKd+/etUIk8B8S4jhDWDbI7dArlc/ntbKyYizHjY0NNRoN3b59W9PT0wbHsHcej0d7e3v66quv1NfXZxkjtZD9/X29evVKXq/XNKEQGeT9SK+75Pf39/Xs2TOr8Y2OjmpgYEC3b99Wf//FvBwuNQ6PgX29rj//8z83g3Lr1i1NTk5qbm7OmJc0MgK/Yfj4O8zFgV1WqVS0sbGho6Mj1esXg/UgpkxNTZmRw5Gen59rdXXVxkVQPEbKaX9/X5ubm/L5fJqYmLDZNrlcTu12Wy9fvlR/f79u3LihiYkJnZ6eamNjw7rvmUhJrZE7IV0oRCBP1Wvm8j/+j/+jpAun9+mnnyqVSumDDz6wM4g9QlqfjA0bg8CmJJuXAn06n8/r22+/VbVa1c2bN63bH7kgnPfOzo4RoSDgHB0dKZ/Pa29vTy9fvpTX6zV4F3bq6empXr16ZY4FCGx7e9tIL8C7V65cUX9/v0m9+Hw+y/bfZezIWzuXlZUV+Xw+LS4uKpFIKB6PW8cmnhFNH6IMDDMRCl6cQ8iBA9Ii4xkdHTWOvHu5qaFAg5ZkkBvMHYq0Lg0V5+L1em2qHt3DHHx+bigUsvQfaI+oCGp0L+vZs2dmqIEVmO5HNlcqlYzaKl1ElmNjY6ZDBG1Uks2DyOfzJhooyYQxgYWgGUsy3DwcDpvEA5TRcrmsXC5nOkZEzfyCKQaOXKlUrBaB0B1R/MnJSZcOFlkSzLxe948OegZPoZ/ExD4ya6IzeP+McmWEw+HhoZ0lvj/7B+X1+PjYGEu8i3K5rIODAxvvQB8Pe1EoFKx+4zKIWq2WisWiqSoQGDCEiUuMbhz1LqJtqP2IQPa6MDyhUEixWMzOH+QPgkPIF2SbzKUhQITq32w27V1jWHlHsVisS2oHNhe1D0aM0/cGMef4+FgDAwNKpVIGdZKhAAPNz89Lkum5AfV0Oh2D9/j71H5BV95nmidncHFxUdPT09a34hIcpNfECWwfw/rc/aOvDcQF1le9Xtf169fNsRLgkOUgPRSJRIxNy6gD7AF3EZSJDLBQKFgrAVnnycmJ3X8cD3YGZh7Ufn59787ls88+s/9GFyiXy8nnuxgixIGEZXJ4eGgvll4VVGgTiYQCgYAZUww8F9kVdIPxgGT27u5uV7Ern8/bAbt69ap18g4NDWlnZ0c7OzuSLiiQbDJMFKJGNxMglWfeCY6TDe0VmvjRj36kVqulZ8+eaWNjw/aq2WxqZ2dHpVLJPp8CaqVS0atXr7S9va1QKGRd9el0Wul02uY/vKlw4LJXyMoCgYAZQ0kmcMcgrWq1anPhr1y5omAwqNXVVa2vr2twcFDpdNrkUAqFghUsm82mjUplj5DgaTabNn8bx/w+eDf9DcViUQMDA4YlHxwcdHVlo9TM3x0eHrYaYV9fn6ampjQzM2OZDlM7JVkww4WjQA28Q5QNHHN8fGz1QiaLIgaZz+e1sbGhTqejmZkZg21g+VC3gEVHhIu4KwVtDD3Gq9f1ySefqN2+0C2juRGHvLe3Z/AgdxmIanNzUwcHB5b99ff3K5lMamBgwJh5rqrD+fm5GS0MI3et3W7b38fwUfAeGhqyM0gtTLqgoVMv8Xq9pgV4dnZmn1H8u4FZ9MkMDAxodnZWzWZTL168sLMKI6qX9Yd/+IeWTRweHsrr9Wp/f18+n8+GgvHzy+WyTRPlO+KkcYaTk5N2n8rlssGiZAi8C5rQGSrHueTv53I5m0j74YcfGrEHx8M9WV5eNtgahpnX67U7jPMG7kPVg/7Fd11v7Vx+/OMfq9m8GA28vr4uSZam44UxHuVyWa9evbIDWq1WTWI+Fovpxo0bmpmZ0atXr4yJACNMurhkRHjQSb3eC0mWbDZrpAAu6tnZmWKxmHWNJ5NJ9ff3Ww9MOBw2eftCoWAFUlJUN2r1+Xw2gphncfn8va6f/exnqtcvZoo/f/7cZDbOzs6saItYJ1prRF/lclmRSERTU1OKx+O6efOm0VgPDg7swJD5uRRl6bX0OD+TplaPx2PU7/HxcS0vL2tkZMSguMPDQxWLRY2Pj5veFtP1wIAx5G4zbCKRMELEzs5Ol9Borxf7n/7Tf6pms6kvvvjC4Du0tlZXV1UsFjUxMaFkMqlaraa9vT1zLFzmdrutsbExffbZZ5qYmNDjx4+1t7f3O85FkpEZYOO4pIdOp2OKC5zRiYkJXbt2zaAP6Jzr6+uKxWK6deuW+vv7DZKr1+vWVPzm1EWcS6fTsSF334dz+fTTT9VqtfTw4UML5mgwfPLkiQ4PDy06JXuq1+sWjI2PjxuB5vr160omk3r16pWdJ2iqzLanxiLJoF2EFAly/H6/ZX9jY2OanZ1VMBjU/Py8Maj29vaMKi/JBtwFAgEbi0AhG6gtEAhoYWFBrVZLu7u79t2IxHtZ/+Sf/BM1Gg396le/0vr6ujqdjmKxmKQLZCefz5vwbqlU0sbGhmXVkG2uXr2qaDSqpaUlJRIJPXnyRBsbGybMS3nB7V/zer2KxWIaHBw0sgqai0BvjUZD09PTdgap7xwfH2tzc1PJZFIffPCBjSbJZrM2mRSFAUlG72aqJYGHy7T73tliQFng8G6NhXGlGDVJVlBmpsP4+LjRMCWZtAuNbNAkoSNS4ELvi3SdnxOJRCyboQCIA6A4RdRO5ElU4HbF8iySLJJz588DsfDnvRYFXZ2heDxu3eXtdtv2gKFbrqwGkA4jAmi8JNviPcC3fxOXJ9p38WAKhn6/39J5IC+XKk6BG2iHdw1tmeid/QGSAuqRXsNMwJq9LqAjCpD0kEiy8dbUV6gD0UgbDAY1NjZmTadkJTQFQ/+UXmfNnI1Wq2VEB5wAigVer9cyTL/fb+eQGh3FcgqrFERhQboBmSSDIfx+v9HkOcf8+fss4CsILGRJ9GIwiXVwcNDgVMgfnBlEGMn0+XPk+1utloLBoBEUXFhbkgVqQID8PQI3zpVbmHbnyLTbbTuDPp/PnJcLF6OOnsvlzBByrwgielnMgqHoDpnJ6/UavM27J3vizksyG4gmGk4ZvbZkMmn32SU+cAbd2gvabNDVyX55b9g7Sgjox0mviRz8otjP/tLg6Z5BShvs99ust3YuDx48sB4IDsfExEQXn5qiFeJtSHlHIhGNj49rcXHRHAIKqYlEQuPj44ajDgwMmAAcMy5wMkRVgUBAd+7cMXl3OOMcdjR7RkdHtbi4aIfU4/FYOs9Fg8ZKissIAC4gRUzXifWytre31el0FI1G9emnnyoUClkNgjGoHFayK/DddDpts0q8Xq/BZqVSyeoKN27csP13IwtUD05PTw02Gh4e1vz8vMnqMJ5gZ2fHDAe/Bx8eA5pMJi07oP5CQRejTIGSQms6ndb29rZ1v/eyvvjiC+vcli4UHW7evGlOplgsdkVX6XTaxkbHYjGNjY2ZNlehUFA2mzUoVXottInCMXARHefu956ZmdHnn3+uQCCgly9f6uDgwGSQIEv4/X6DkWhkxdEmEgnT8eJzO52O1c/o+nebj4FP3ocx9utf/9p6GghYcJLM8MApolh+fn5u5zMcDhvOTz8EPVWcT0nmpJDBd1mKOIFwOKyPP/5YgUBA3377rba2tmwPITCQ2aFhSAAwOTmpyclJU0vGHtFgzB4WCgUzoIlEQplMRuvr6z2fwV/+8pcGu0L3Z+YJPS6QIDwej/VAUdtKp9O6deuW/P6LuT75fF5er9ecyo0bN+T3+xWJRAyShFixtbXVJcuSSqX04YcfamhoSM+fP7eGzb29PcvU6V1aWFiQ1+u1Mgb121arZbWWYDBo1OXDw0MdHx8rm82ausr4+Pg791q9tXMhjXUppxhtjDBFM7c5LxgMKhwOW7Hc4/GYUaIA7HZek0pjqNyDSZQjqUvLiRSQDIdIXbqIRImMkF0JhUI6OzuziIKoyKXRkmlw2XjOXi83+4eBcZ+F6JZIklSYQq7bpNdut40B1m63zQDRyMhnujRMskAcrEtHxCExU6LRaBhkQuaC6kG73bafU61WLVDAyLgZHhLyFGbfRxFZeg1dosfEmYN1BE2VgiVzh1wWDAxC+jdcCMslgHBW3P3j+dyGOeRuaOYjqKEOBlUZ6rFL60ZRwqW58/MpVLvZj0uP73UhX8L8IM4dDge6MfIu7CcBFn9O1F2v1y1C57vz93lu/h4UXbfBj2ARajGBJM3LnGFsCVkrygmQTN5sjoTdWCqVTBsOG/E+6EOxWOxivrJ/LlUfG1Kv1+28waTkHNJgixMCTXGHq4HAcB4hrLiqJthcYDAafjnXBM8ogfDz3JHLnH+XFi7Jsnv6oN5s0Xib9dbOBbmRdDqtWCymTudi7KX0esb9yMiI1TuSyaQZRC706uqqFZvoLOfiApPxAthAIlNYJefn59rb29N/+k//yYwL1NjNzU21Wi199913hpXHYjHTgfL7/Va3oPkTGAwa79LSkrGC+F71el2RSMSKsr2sJ0+eyO/36+rVq9blDRvJzSiAChhHfHp6ahpMQD4MUoLl0263bRgYxft6va5sNqtarWZQBs6rr69PDx48MDgIfbO9vT07XNCL0era3t6W3+/XD3/4Q83Pz+vk5MSK2ch0I9WBNpYbjQ8NDemHP/xhzwYSCDCVShn+/PLlSwtWms2mwQ7BYFBbW1vmwIt/N2UP5hXNtAQVDFRD4gWlZM4FhhfYr1Ao6C/+4i+6OqJLpZJevnypTqejlZUVi0DRISsWi8akgqkHvIjSAaOQmT8E/IIq9vT09Hs7GPYQpACoBzFEIESf72J8OEP0JBnrkmeDCcXwuPX1daMuQ1mFDs8Z535XKhV99dVXxvajpopSR6lUMiLJxMSEdb53Oh3duHFDkUjE4Mlms2nff2ZmRpK67hfwTigU0ueff97z3gGBTUxMWMaHTBRBZzQa1eLiog05I6Ou1WpWu6IPqK+vz2jAkJWazabS6bQikYg520ajYdAkDuf09FTffPONDWMj66AWCAkKvULYjB6Px2bloLdXr9eNWOWSJl6+fGnBI3YE+vPbrLd2Lq58w/T0tHK5nFZWVtRqtTQ2NmZYI8YOqRI8KtIBg4MXMyToUmYDUWTlBRI1UV8ZGhrS4eGhFVUPDw/l9/t1584dTU1NKZvN2rhbPveDDz4waqfL5KAOE4lE7KVWKhWF/25W+P7+vo6OjrqanBKJhCYnJ7uYWe+ytre31d/fr5s3byqdTuvo6Mh+Bpkbaay7f8fHxzbDxhUAJVJyjWOr1bL30Gq1bB+gQeLs6/W6FSQZW4z0PmlztVo1IcFarWYwzfDwsA2ugo2GthjO/PDw0Oi+p6enOj091cLCgq5evdrz/pGxjI2NaX5+Xqenp9rf37domCyMoi8zgKD/cin7+/s1NjZm0SJZBXI4RJnAq/TMABfidB4/fiy//2K2OZAB3eUwf+7du6dUKmWfxfekdoFSMk6e6HZjY0Orq6uWAeE4oT+/z/J4LuapT05OqlQqaXd393ca7ZCBicViZqQkWQYMWxMnTa2F1oKZmRmrI7gKyARm4P+rq6tWK6POg6IBwqKM9mi1Wjo6OjIjDhQ3Pj5u55P3Nzw8rGw2a+QVambRaNTEb3tZZJDAYaenp9rZ2bEzAksSscmRkRELiprNixHWuVxO/f39unLliknYkGUzByYcDhts5aI20mvV50qlorW1NUNCGI8OnZmsJRQKaWlpyQJ5SV3ZHHDe2tqaweCRSEQbGxt68eKFSf8jfxSNRt9aQPWtnQtFcPjPFAFrtZpNiczlchZ50HgD7gq8I13MRQCaQAKaNPj09NSMI9itK1gJQ4lhXryAkZER059yvzPjk3n5XCiowBT0GTpG+k7nOYf59PRU6+vr8ng8PUU/NHYRxeC0KH4TFRJ5YARduXD0l7g4QFpuFzN/v9VqmdbV1NSURYtE+XSHA03EYjF98MEH8vsv5nsDsUEbZTZ9NpvVkydPdHp6ajUAlGspHHJW3Et8dnam/f39njM/HIWb7fL7W1tbOjs7UyaT0dramhnJaDRq41sx3GQynMmhoSHrXKfITv8L1M90Oq2hoSHl83ljelEHBMadmJjQD3/4QzuPBEpEhC6mLb0Wj4Smj/EFPqN2NjIyYgEBUXKvKxwOG4zqds5XKhUdHh5avxk9ORBiGB0NTIfmHbU/pn8Cpx4fHxsxAmdPpuGqRriEBp71zp07VgclGISNSgZVrVbNEDMeASgOOJI9dmEk2Jq9nkECBLf2QWYJ7Tifz5vDAb7LZDJWS2LeCoQcEAlYocjusH+gNjj6w8ND7e/vG12e4Jzz/sknn5hNg4Czs7NjdVRqtnt7e1177/P57Lu5CgqUEggI0MN7m/XWzgWjQQpKc9Xp6akePHhgG0qH7n/2n/1nNmp4dXVVExMTRoldX183LwpDATwQCRQ6nSlWIztOBgRrrV6vG03y5s2bGhwcNK2rv/zLv9QXX3xhxrOvr88UmxmOFAqFdOfOHWNhEeVwuME+8/m8Njc31el09G//7b996wPJYsgSPHUiupOTEz18+FB7e3saGhrS0NCQEomEfvKTnygcDlsRDXVhV9mARjSXEeLSC2ne+uijjzQ+Pq6VlRVTQkBFGTYaERc1DI/Ho2+//VbfffedAoGA9QltbGzo2bNntu9jY2P6/PPPDX6EHQP2zIIy3qtxhNGGg+T81Go1/fa3v9WrV6/M+E1PT+tP/uRPlEwmtb29ra2tLaXTads/GmTZb/DlTqdjDWn9/f1Kp9MKBAK6efOmwuGwnj17ZpEcWSHPPD8/r+vXrxv+3W639ctf/lJffvmlhoaGFIvFrB/C/a5jY2O6d++ewuGwQSkwooB8g8Gg9cy8Dx0+mUxa8ZbaIsbsu+++097enqLRqEWvd+/eVSAQ0MrKinK5nEHJ7faFsjSOle9EULG3t2eGeGFhQUNDQ7p+/bpGR0f17NkzPXv2zIIpt9aUTCZNg416y8rKip49e2Z9FxTDt7e3rSs9FArpww8/NBaW9Lo2TEMh2eP29nbPZxD0g+BBuoDtz8/P9ejRI4NiBwYGNDc3p3/zb/6NYrGYtre39erVK2s+9/l8ymazajabVuM6Pz83AhO0aZQ8QqGQyd7/9re/tQFqDFwkWJidndXt27c1MDBgrNG/+qu/0hdffKFQKKSpqSnrfYFQUqlUFAwGdfv2bRNUBU0BBcEWugrob7Pe2rnw4ijmUYR0u6Hdg/amjAmpFPQ46XXR2S2mk3oStXi9r0d2Uv+g85SMg3/jFsHcRfGQi08kwwXgWYjQiEpdLTMcZ68FfaIGfg4dznDbITa4citgqRga9o+Iwi2Sc7ElWXMVNQE6pel2phALU8zVMaKQ7fF47L+l7imOREt8R87B+fm5RbAwoTgzGLJeF2OFkeFxVQyAFlxiCBg/xU0yUb4PkJgkM7jSa6wa448xwaG5zWucZc4flxLjyC/p9R1wR0uTubvnj6bWNyneGPL3YYtRMH7zDJLpuR367v5StOe8kVmQ6VNHYBIsGQT7yDsjY6eojhPGyXMG3fYA3iXnnv12C+dktZxBlJzdO8zdep8mSmrBEBVcvUEyELfoDTEJ++PqA2K/pNf3lfYE11Zxr0E52D+3RcLV2HMJC2/aLd4NP5NzDWxH7Q3H5d4nqXuE+tust3Yut27dstoJUTeYJlIILBoY8/m8hoeHjSbLQV1cXDS5Z+i0kUiki43lMsV++9vfqtW6mDi4v79v0f3w8LAVp/L5vB4/fiyfz2ewTj6ft6I3BAN6TL7++ms9efJEkqyg+O2332plZcUiBpg64Plg0b2syclJdToXumBkDTix+fl5o1tiADc3Nw2iun79ujVW9vf36+OPPzbI8ejoyJgmLouP+gpNczRcomo7PT2toaEh3b59W5OTk8rlcnr27Jlh8n6/397N8PCwTWOcnJyU3+/XixcvdP/+fYP1Go2Gnj59qtXVVXtv9JGQUpNt9rJ+9rOfGYuPmgZR271793Tjxg07/MiGHB0dKZVKWQMlF31iYsLgRP4+tHoyEb5ns9nUN998o0ajYdMaXUNHp3WpVNJf/uVfyuv1GhX54ODAHB/vw43gv/rqK7XbbR0eHlqB+8GDB/Z9BgYGTA2g0WiYrlevi7HQaEoRdLTbbV29elVXrlyxxuf+/n4LHmKxmI0gYITw0tKSwuGwjo6ODPJhX2EW8a7Ozs709ddfW72KuSiTk5MaGBjQ8vKyEomECoWCXrx4Ia/XayMpgMtCoZCSyaT1d9DxDwmFHhCUzd1Ale+Ec+l1ffjhh5IuHNXR0ZE5sU6no7t375qNxEHQvBkIBHT37l1DFHw+n2ZmZhQMBk3yJhwOd7UTuHWNSqWiv/3bv1Wj0dDR0ZFJ6AC1z83NaXx8XOfn5/r222/l9/tNGgliBPJHgUDARpQ8ePBAGxsbVu+p1Wr67rvv9OLFC/t7BADciXepV721cyEddpV9MRbQPYkKoWNWKhVjk7AwOAy+AoLiQVyFXxwM80uo39B4FAwGjTXFprNgUcCQQlacDlToq9Q+wEs3NjY0Pj7eRUiQ9NZFrL9v0U2OdIq70Fhy5TKoKQEnUjvCecKNh7ZMtEiERnROH4o7WC0UCimVStkYgUgkYlg7kSMZj0uHHRoaMnJFJpNRp9PpwnwPDw9NeJAoVnrdlf8+kXcqlTIev0uL93q9pitFpCjJaoPMyjg7O1M+nzdnMjw8bO+eoGNgYEDFYtH6pYiIqS9g6IkUcRzUYzKZjLHXOMvAHgQosVhMiUTCcHAmEHq9FzI2GxsbisfjSiQSBkNjsNzIt5cVDAbVbrdNuYJ3g6Fya5TUV+kvGxoasucH35+YmOi6wzhE7m673bYAlI5wFgaPMzU2NtbVvEx2Lr2OzHHQ1Pc4YxjtRqNhjpN36jaySr3LN0kylqxbHyGIYp4KAQuOlGI/7Fi01oLBoCKRiElfBQIBJRKJrtYJYFegMmSaaONgX1D2YM4V75QAwWWKAm1CqqJ9w73Dr169MnIO9pzs6l2yvre2mKRjNCJJr3FNjCOXFifEJhFxc6EfP35suDIzJGA3EOGWSiUdHBxYdIrWV7VaNSmJwcFBbW9vm0GbnZ01owLrgmFQGOydnR2TNYHvTXro8/lsABdREmkuzqxXvJYLB04MDRHYAGyYbngOIR3z9B00Gg09efJEq6ur9u/4fZ6RAwhLBwffbrcNN4aGu76+3jVxjj6XcrlsTXNuc6Yr2w6dkiCDTBSZEFhWLjzS6+LS5nI5ra6uSpJleSjAsoek/G4tDwir0+loZ2dHzebrKZ/SBZ4+MDBghgNWoiTr1SJzCQQCmp6etgx9d3dXw8PDWlhY6KKlUozFSCNYWCwWjfoMRZViOIycVCqlgYEBU1CIRCLWJ9brot+h0WgYNRqYmHczODho7QRAzfR8Eb3WajVtbGwol8tJkhkv9ptghud0afbIl9CSMDg4qK2tLdOwm5ubM6ZjsVg0KRhYfS6UQxbu8XiMUUkdAgflQkYEZb3uIe8WFWwyF0gfFMT9fr+dARftYb87nY7W1tZ+p2cQO4gThyxBtgOsCTKB89zd3dXm5qZGR0e1vLxsP9M9N9iVcrmsjY0N7e7u6uDgoIsUROM4tVx62oBJYdN+7wV9Dtf+/r5WVlaM405WQLRKhgPkc3R0ZNFyIBBQrVbTs2fPdHx8rKWlJdOgcp0LHnh9fd26qNHcYtY9EhPPnj3TwcGBlpeX9dlnn6nZbBqtDsji/Pxc2WxW5+fnpr6McyG6d2mqsVhMExMTpmDabrcVi8VsMlsvi4wELjqXbWBgwJhEGDGXkddoXEjJIxWBc6lWq5qbm9PCwoK9H3e/OZjBYFA//vGPlUqlrJeFGhkF+mKxqKWlJX366aeq1Wp69OiRTk9PNTk5qStXrpjTwtBA6CBbJZtlOFsikTDhQfYPufNe9w8Dnc1mrcuayyBdRJX0rsCAQrKFoWjj4+Oq1+va2dlRoVCwyZxer9fET0ulknV4r62taWhoSJ9++qkVYuv1i5n3c3Nz8vl8+uKLL7S2tqbbt2/rzp078nq9JkwZj8dNZwoSC2xAnEun0zE1b+SSxsbGlEql7NJ3Ohcju9PpdM/7J8maNnEuboDDPpId4JAxSLCyMPKwQlFswLnAMAQWZyzDrVu3LDs5Pz/XyMiI2Y8HDx5oe3tbt27d0o0bN1StXoz6LRQKGhsb09zcnLEBmR/DmWOPDg8PrV/LdS78wgF8+OGHPVORcQDFYlE7OzsWBJPVu/VRt17GGQwEAkbb3tjY0MnJSdd4Avfvox324sUL+f1+LSwsGAIEEy0ej8vj8ej+/fva3NzUJ598oj/4gz9Qs9nU06dPVS6XTZ2iVqvZmATGiaAwj+MhY8W5QBYieI3FYu/U6/fWzoWJfowadg2U3++3bnEOMJRXGoYwnAi4EdHS6MSUR7D0UCik+fn5rgiHOdSDg4OWdgNp0YNQr9fNyEUiESsyM2WRQ0AaShGbTIHCOUVpCoeMtu016jk8PLRDceXKFaNIulgw0TUGwC0QkxlSq+GFHx0dWbTBIec5aXTr7+83iIZJkhQjiaqI1t3eFH5xIHESvAfYVzhOejg8Ho9RmLlscOV7Xdls1oq/NH6hgkuQQHbs7hHZDTBEo9GwaZMej8fqbfTRsEKhkObm5qw73VUFAEaQ1EWSwFnk8/muMQSoL9frdTPmoVBIk5OTkl4zJrlLrdaFPDq1Kij60Ed7Xdvb23ZPp6en7fchdtD3QIaDcjJ3EKiV8woFnpoLe+0SJCTZ+XRhRBfLx5iivovUfKFQsNERUMSBeQhWQUlwLi5TKp/PWyMmjYr01rg14rdd1PoCgYDS6bSdb7eVgb0i2ONcSLJ7QxZAxgIcTf2LDNG1tSjKc6b9fr8hBpw/gm+CBxAjanfo85H9BIPBroAFtAnbwvgDFkH69565PH/+XF7vxTyUTz75ROfn512KxjRXTUxMqFwua39/X+fn50aHpahOc9bZ2Zk2Nze1srKiaDTahe91Oh1NT09bERd6qPS6kQnnVSgUTOeIqGhzc1NHR0d2GY6Pj/Xs2TO1221TIw2Hw1peXtbJyYkePXpkTZzAR+vr66ZJFAqFtLe3Z4oEv/jFL95222zdv39ffX19+uSTT/SP/tE/0vHxsTY2Ngy+KpfLpkGEc4Tqi/ji+Pi4detSP3n06JGi0ajRRoHBksmklpeXLdM5Pj7W8PCw/R7yE8ycJ+uEs39ycmJF01wup4cPH0q6KKyD2V67dk2np6d6+PChdein02lJ0jfffKPh4WHdvn1biURCe3t72tvbU7vd1r/6V//qnffv4cOH8nq9WlhY0L1791Qul82gwGBB3NPVZKK3JR6P68qVKyYTQ41kc3NTsVhM6XTaok2/36+5uTnr9mauENCo1+s1Ugb0YaDEarWqR48e6fj4WIuLi6Yhxfm7cuWK4vG4ZmdndffuXZ2fn+vFixcWAdNMSMRKLW1jY8MUmf/L//K/fOf9k6T/6//6v+Tz+XTjxg394R/+oX03l2VJ5lQqlbS9va1KpaKFhYUuDS1qAGR4z58/VzAY1OzsrLEPiXBx2ASDkUjEFMnJzg8ODrS9va2xsTHrQVtbW1Mul7PgqFgsam1tTZL08ccfGyw5NDSkYrFomSoTMIvFoh4/fmwjOJLJpDY2NvT//D//j9rttn70ox+98/4BH6dSKd28edOouZAJ+PnMqkdVZHBwULVazZpXJdm8lt3dXb18+dJqwTjBRqOhyclJG3eNQjVBR7vdNk0/bAWahNVqVa9evTJ1DOYV0Ti9sLCgaDSqRCJh6gfPnz/vmn+DMgj6kKFQSJlMRq9evZIk/et//a//wf16a+fCDBfwPqIpt5EMnNHNKIhkoWFKsgNKio2Xd6mDUEhxNi79FO/uGhbwaxguNEOSyrrfs9FoWPpPxO3SR9HygULp0vZ6XcyekC4iGIqbbiGa70hECEuISAU1XTJGYCouqfRac43CJ3RTisxES+wFv3hfwA3UVfh+OHd+nzoU0JTbJU9TLPRTngdorZeFwJ4kgytdvSiMo/sO36TT0gntUuPfpJRyhvv7LwRBOedvnjf2laiUPYJt5VLa3b12M1IibByK+27A8vlzPv992GLU2ygyE8XyTG7zIc7ZVdnt6+uzrIb7QuYB047vTKZHRsMeSrL3yNng3dFDdH5+buea/XXrZ+5ZJzKnduC+QyJ7WE4Y4l7PoDs7CeICkf3Z2VkXdR9ExLWLZLIQhVzb4tpBt4fGld5583xj66D8k20iKosNdAk1nEF+H1vuUvM5E5zVWq3WhZq8LSninWAxMFdkLvL5/O84BKCGly9fWgYzNDSk5eVlzc/PW00E7DmVSpl0gWsg6EKvVCp6+fKl6UMB+VCoh0zQ19dnA48kWdH1ww8/1OHhodUNCoWCDg8PlUgkjPO+vLysZvNiqNDGxkYXd5/O4v7+fiUSiZ5hCTjn1IhIMX8fD79cLmt1ddUcDNRQpFjOzs5M7gLI5vj42AqdNLIdHx+rUqno+fPnlpm1220jSBAZ08NCdAnTJB6Pa2FhoasOVCgUdP/+fcXjcaNXR6NRBYNBw4lhwAAlEsFB3uhlYVgePHigp0+fGt7Nu+7v71cul9Pe3p5h9gioAnUyghkSiNd7oUgbDAa7elnISFZXV62+AGxDhhEOh83BplIp1et1ffvtt5YV0gS8tLTU1U2OInMkElEul7PIemZmxjIC+l+Ab5A6uXHjRk97xwLCQSWbzANnQ83p9PTU7goyI0dHR5qdnVUqlTLIZG9vzyBt/r3X6+1S9AW24mcCM6PwwPe6evWqhoeHTVMNWGhhYUE/+MEPTN7o7OzMhgCOjY1pfHxcHo9HiURCsVhMu7u72t/f18DAgLU3cNf6+/ut4N3L4vuWSiVrqIWKTIC1urpqd5P/hb0FXNhqtayg3mq1LGshaOb+FYtFo8Hv7++b1h12i2ZnaleSrBUAAtDs7Kw+/fRTk9VBoHZ9fd1qV37/hdo5NUneO3qMEBWAGN92vVPmgkdDlp7NpkEIjJO50HQyQ8HEgEFZZbhTX1+feWDYFnxGuVzW8+fPjWLHZsL0cWUfoFFKF16fAhSMikKhoOfPn5uEQTgcViAQsJR/d3fXDDpyF+CZgUDgvcbM4jwymYzpOeEM3mzuxHmQUns8F7L8bpPb6empRW4ej8fSZmociEqSegPtNBoXkhLUuFy2Cs6HPgWmX1IzKZfL2t7eNjiUvacPgcyUoiQyF0ToLn77rgvHd3BwYMPHiPbHx8c1PDxsQ6owQNVq1c5KIpGw7wbbJx6Pm04bESTRIxe5Vqtpe3vbYFdEODljCKs2GhcyNJBTCHzon8lmszY+253iGYlEdOXKFYVCIb148cKMMQq8zN2hxvU+BX32Hzr82dmZ0eLD4XBXLQ4jhNTK6empwuGwnTeo3SAAQKgQPIB2iKJfvXpldVCCFe4qWlq1Ws3gxk7nQlF6fHxcCwsLGhgY0ObmpgqFgjY2NnR8fKx4PK5m82JSaDqdNnYdlFl6v6jD+v3+9woQmXbqNqBC5Y3FYkbXBipDkJQAh3Ef1EQymYxGR0cVDoetKZUaF0oeBI17e3umcAFZgTMIVbzZbJrDojgfjUZ15coVDQ8Pa3d3V8ViUVtbW2a7yY5mZ2c1MDCgjY0Nq6Fjnwh2KG987wV9LieGhzkTFEsxkNJFJPnJJ59IktFREX3ESHCJzs/PTQ6dlJEov9G4GPa0vLxsOjxuF68ky3Y4TJJs4yuVih4/fmyGodm8UByFwkcBW1JX9O/3+5VKpeyyUHDc29vrOeqJx+OSXmujIUBJ966bRcAEkS4yO5hWGFSyC/YR2Iz94fMgU1BEJC3mZ5LFUMwlIgIvHx4eVj6fN4ir0+ko/Hez1pn34jZHUnvr6+szuRj6RIi4el0UTMl+KK4jocLzQDqJRqOSZD0RyWTS9o9fFFvpFsdwut3lXu+FrAaQAIVsl2oP0xDWn6uosLa2pmKxqHw+r1qtpvHxcUWj0S7mVSaT0eDgYJf0DIVcGIKQBN6noC/JsmNUGpgwyh2WZCOI79y5YxArASIZGJAt8Ar3lu8svYbGaLqEDUcGDpkHWBrozePxaHJy0v775cuXZgypAYyMjBjLD5iboCqfz8vj8RjDr1qtGiHlfWBFF6YHasXuMbodhQqfz2fvkHNKcODeV/6/9HqMA7C3G6TR4uGeCdAeF0Yjm+Ec1+t1C85BE8iUYMpKF4QZv99vE3AHBwdtGi8jD5iR87brrZ3LwsKCyStQS6HxjLT44OBAmUzGBmLREYrAJYwhNgRoAwfFDAI2C32d5eVlDQ0NGT0ul8vp/v37VvMBR6djlcL28fGx/uqv/sqckd/v15UrVzQ2NqadnR2TSGfD9vb2rE9jcXFRfX19xsvPZrPa3d3t2blMT08bR/7k5ESjo6PWQ+LOTIEEcf369a5BQ0SKMFY4YK7TdRvNuOxkcBhfqJSrq6tG65ZklzAYDOrOnTsaHR21iMltmHUzGfBrov1sNmvEBHoTtre3tbe3Z93ave4f2Q9QVDgc1vT0tFG5ITmgyjA3N2dNs6FQyMROgXzK5bIZOS40LCZXtoYOaDfryuVy+u6776yG1GxeSNW7qhHch/v373ed86tXryqZTOrw8FA7OzsGO3U6HTt/qVRKH3zwgXw+n9bX102JAZrt+y4y34mJCS0vLxtzk87zg4MDJZNJ/eIXv1A8Hu8qqu/u7ppOnJtZU7x3HYV7765evWp11FAopJOTE7169cqo7WShwC8MsysWi/r666/tuXn3fr/fCBnurCSII7FYTNevX5fX69Xe3p4ymYzVxHrdQ6jAbuDGO5+dndXIyIi2tra0tramcDisDz/80HrByAZwyDAbkQKSZDYQJIjAliCA9guaHb/++mtj9NE3mEgkulSPT05O9Dd/8zdd2fDs7KwikYiOjo5MB46aKnd4YmLCqPWcQUoKb7ve2rngDVkUiVutlk2wcw+WJMtOiPS42BSyiIqgB0uyqJLowOPxdFH6uMwU/Ph7RI4uxENG4xb53J4aomGeCwODgSZydSOBXouBFPb4eTRLkda7VE4gNNJkMFTmuzApEeovURsEBFJr4EIcMM9BRESajVNCucCFyNg39pHMC1owe8l+vpmFko19Hx3mkuxdsX8w/Igg2T8WmDf7h0OEPgqllWjR7ULnGdzRyjyD2539pkQOhhXI03VWfHcIGrxjolL2zyVIDAwMWIb9PpkL0bDbzMezkZGCJFAc5+7x7tkfzqr7zt2GXgwoelucfwgfQM+QFIjw3xxpTABFpsDdcYkXbjEa5wRiwr0lq/q+ziB7SaOyew941/ziGYDRKLrX63XrsAfC83g8ZlfZG+woNhI75GagLonH3Sf2hPvPvnImGWgmyQIBeoO4E24jqptp/UPrrZ0LhpyDwzyXwcFBff755/bSwA7phC8UCiqXyxYFUtRsNpuKRqO6ffu2XaJms6lXr15pZ2fH6iX1el0vX75UvV43SYJsNmvzLhKJhEZHRxWLxXT16lXV63U9e/ZMpVLJ1H7BjdvttrLZrI0/XVhYsF6PZvNi0BBpO9AF0SljiHuNehjrzMrlctak9/nnn1uTKD03W1tbZrQGBgasWH56eqqtrS3l83ktLi5qeXm5S/dsa2tLuVxO4XDY1KHRIuLQZDIZPX78WNVqVQsLC9YIB1V3d3e3C093HcvLly+VzWZ19epV3bt3zzI/Ih++L9nT5OSkzTuh+NnL4kDjKA8ODrS6uqpAIKCf/vSn1g0P7AORAHo6FwpZoqGhIU1OTurDDz+0i9lqtbS2tqatrS2Fw2HD5xmlOz4+romJCYvuK5WKDXaampoyfbPd3V3lcjmbpUHGAXX+/PxipPCtW7fUaDSM4DE1NWW1Kww7mVc+nzeD3+sCWuEs1Ot1PXjwQMPDw/rJT36iiYkJDQ+/nk+/vb1t43MlWQ9UpVIx/ax4PK75+XlzqNRU8/m8JicnDY58+fJlV80ll8vpwYMHqtVqWlxc1Pj4uFG02+229vf3rX7g9gDxZ+VyWYFAwIaeEYxNTk4qEAhYhiS9VkrAzvS6cPCSLCvY3t62e8XfceHgcrmsTCZjag99fX12vwuFgtLptO7evWsOol6va2VlxdSesUMMdWOfstmsZWOTk5MaGxvT1NSUbt++rVqtpidPnqhUKmliYkKpVMrGE6OCzQiDhYUFU1FpNBpKJpNGucdJocdI9v69s8VI3Vza4PHxsQYHB7vUVTFEpLq5XE7Hx8eGB1I0pWBHcxaX6eTkxFg0HBgMBAVkMiCMMd41FArZqN7z83Obesf3cim+FDC59BRPoYgiI0Khne/T6+UGLyetRfOLpr839xrqLbBXqVSyIj0Rn8/nM4igr6/PsknID5FIpCsDob5QqVRMpwiYaWRkRLFYzJSnIQy4Sq+dzoXEC/x6IDWyA7j7ZLHuXrq6Z70ul4qJMCWFY/fPqa14PB7TTGMRHNFIC7EBw+gOTWNEBAoJTPikzkQ0yWUkQOD80TwMZZXgjEI+w6RoDnQhSt4ZGRmswfdxLmQr3AdIOdTC0MbCEQPB8nvsK38fQkkwGFSn0zHqMKq61DY7nY7tK9FzsVi0czQ7O2tUcQr7sCbfrOPwc05PTzU0NGR7Bu3WJY8QDJL9kaH3mv25qAXZQ6FQ0ODgoDV/utRpMvxCoaCDgwOr67lUYb//Yqqn+wzFYlH7+/tqNpsaHR2VJJsLRKbIv6dOStY3OjpqPWzAW9DHgXypG+KEeWewBlutVpdKA/e3XC6bzXyb9U7yLx6PxzptocBCK9zY2DD8NBQKmfLm8PCw5ubmzLDhybmEKOpS8ESWQpLJO8zPz8vvv5iQxxhfRm8mk0kbF3v//n3Txmq326bXBN7e6XQMz4RZ5G6U3+83iin/FifJpe6VrROLxSS9JkRg0KkNcbDcQ4DS7Pj4uLLZrB0woAAyMqi/GCoOHVEqLB9X6BPjCKZeKBT0zTffqF6vG1MNJ+f2B8RiMXuWv/7rvzbjin4bzoTmxUwmYxMKYdv0sjjopOdMQPT7/XZ26IQfHh62c0LwwjlAkQB2GKOgoTAj6AjpASVonokAZGZmxqaXUoN6+fKlarWaMpmMXfBCodB1/mAGnZyc6Ouvv7aAp92+GMo0NjZmTXnAyVx+F6bsZYXDYUmvpYjYH5/Pp9PTU0MD0MEiSIjH4wqHwyqXy8rlcl0Q88nJibEfGbLWbrftHuXzefl8Pi0tLWlxcdE0q2iArdVqmp2dVTweV6fTsVHJZHgulAzMNDIyong8rkbjQhDThXUIWsmeMaawJWF39bLcwjltCuwTs2JQunBVnGdnZzU1NdUFcVerVTPgTEHl3qG9xi+XbQuy0tfXp4ODA1WrVctuz87O9N1335kdhSyCDWNWEJ/JO8dhA4sRlHIGCdibzab1fr3NeifnAoOIh4H+BiceDJAHQHIDY0ZxnIIeB7JcLuvVq1fW5U/Ui6eemZlR+O9GggIVwdEeGxtTMBhUNpvVd999p3a7bVghvQluzcGlTR8cHJjD7OvrUzQatcZDnocI4U0s/10X7CUWMGGz2dTe3p52dna6lE5xsMFg0OT4t7a2bI+gNEIQoD+HTIteAZwLkTWaTtC/OTRQI90aFNkWnHe6u5PJpFZXV/Xll19qcHBQCwsLVmwkOhwbGzN6LiwyVxX3XZdbFwMPhgWXyWSMesxlwwElk0lFIhGLdovFouk6YcSOj4/14MEDnZ2dmXOk5hIMBnXt2jVFIpEuskk6ndb5+bnBBXRB45zB1mGgSa/rAaOjo9ra2tLKyookWc0I5QhEM3FKvMte630somDeORR3omVk1zlHjAOfm5vT1NSUUZJdFINx05VKRZlMRq1WS+l0WmNjYxY4BQIB20POx/j4uFFcGQpYKBS0vb3d1YRL0x8ZeH9/v27fvq1kMqnd3V2trq6aYyYg4A4xwbPRaFidw30f77qoU7j0Xwwx2ZpLGiBDJgDGcSBlQw0ll8t12UBqQzh33sHIyIg5M6/Xq0QioWq1agrHTHt1HQKTK6XXKuIQn5DYkWQ2EwJRpVKx1g4cs8vIfZv11s6FdBP6KawYClBAAaenp6bEiQwD0Q7duFNTU0Zj5oVBtcW5jI2NGfMB2iIGnsI2joyDQ1EMnS1WqVTSzs6OpXsudg08AgyG1D1wRrFYtEsNtNPLAnqhf4CaCC+MVJWLAsPr7OxMq6urKpVKlr1BzZZkhWZ6LXgWBOvASYExMfRorblRiNsYCJwBdkzdgb4VopjBwUGDf6BhSuoiQ1DABgPvZQHHQmaYmJgwKjcwAT+fvolAIGDzMljIahBBk/bTQAZcGovFND4+bo4D2LfdvhA9hWFDPwHZPPvBu+l0Ljr8M5mMJNkeuKrXFMSBgFutiymiOBfgk/epF0gyogY9S6OjoybGCqOOzAXCATUCmG3SBeQ0NzfXRdbp7++3RkDGHLh9UhSngXCLxaLBX5zJVqtlkbE7FRE0IpPJmLPhz+jF4M5DGYdpis3hvrv6ce+63DHL9P2AqhCoId0EQoARJwvAYY6Pj9sIhHq9bs8MuxYRXc4gP9c9UxCcaKlwYWzuMk4ZxAj7Qj8SxCACNu54p3Ohgwh5CojvXTLnt97peDyuVutixO7e3p7u3r2rP/qjP9LIyIhFFtlsVgcHBwYl+Hw+/c3f/I2ePn2qcDisVCqlYDCoH/3oR4pEInr8+LEePXqkvr4+G5RDyhaJRDQ5OWkFLvSDuND0rXCQUqmUlpaWFAgEbGY8afTLly/16NEjlctl89BIXzCHIhAImJcPh8Mm/U3RzKVr9rIQ6oP+d+3aNet+j0ajGh4eVjab1f7+vvr6+kzx9KuvvtLz588ViUQ0MzOj8fFxXb16VZFIRN9++62+/vpryx58votZL8yLj8Vi1jRILevo6Miggk6nY8ygkZERzc3NaWhoSOl0WsPDw3b4nj17pi+++MKKqGQ0U1NTRvsdHBzUw4cP9fLlS83OzurmzZtdbD8gzV5hRYwTRJHPPvtMH3zwgUGidLczLhoc/6//+q/16NEjK3gGg0H98Ic/VDgc1u7urnZ2dtTX16cPP/xQXq/XiqM4C3S+UANAgQJIAghydnZW6XRa4XDYxiJT73nx4oUePnxo0ThRLI6FHgm63kdHRzUzM6NGo2HqwJFIxGYgvc/qdDo6ODjQ1taWbt++rVu3bikUCllwg9R9p9OxusLq6qoePnxozmJkZESfffaZIpGInjx5okePHqnT6Vj9iuwvnU7r2rVrajQaphKBs3BrEkC7k5OTunr1qgYHBxWJRLpEXFdXV7W6utrV0lAul5XNZu19h0Ihk5OPxWLm7HhPZE29nsFEIqFms6knT57o1atX+uSTT/TZZ58Z3CjJ2jEIBL1er1ZWVrSzs2M1vuHhYd28eVMjIyN6/vy5njx5or6+Ps3PzxsERtvF2NiYWq2LQYlohQFzMZkSOG16elrXr19XMBi0u4lzefHihZ4+fWqkGpQkaEdAZcNtJ1lcXLSAB3v7LjW/t3YuFPsk2eGA2w6Ec3Z21tUxTzc5cubQ9ej0JFvg8/l3bsSLAwGzJwLgQaFKgrXifdGecou1FCf5HsBPLvUXWMj9fRq9+PNelts/Ib3WHpJk2DekBbdZFDiRugaOAFkatNH4dzRsuc9NAfHs7MyiEvbAdZiu5hZRCs/L3yEyBH4gmnYz09+3Ty7NupcFU8iNxvhedMyXy2Wrk7AHRP/oc7HfMJbYB3ceDO/e1VxzIT13RLVrLF3Iwn1u3jXnlvol39XNiF1c3913/vt9OvSBYfg+wKY8tyTLkthzvi8SRNwNFH45p1CyecdvagGyh9ByOSNE7m57gt/vt73Fyb25p64Sh5tlu3vmnpM397KXRRnAJVywfwStZK+cBdiL5XLZIHgK58iq8JluA7R7f9kzMktIN9w1/g53jPfs3uE3f3GX3Dv/5p+5No+7zR16m/XWzoUouNW60MIZGhrSr371KxuShFbS4eGhccwp8rpYczAYNJYKcIPH41GpVJLP51Mul+uakeAeKjrtMbBALZ1Op0t+4X//3/93FYtFi+CRLqDh6+zsTOFw2DqvmQo4OjpqQ5pcGRhE994H8x4fHzcMFrWDX//61xZJp9NpZTIZm7dyfHysTqfTxXTC4aJVtbu7q0wmYwVs6KNnZ2fW6Q8e7IoGujABh4eUPp/P62//9m9NaJOUn4IkdEl+ZqvV0nfffWe9CPPz84pEIqa2SyrvQma9LOb+oA49NDSkX/7ylwoGg5qbmzNngcIz+0HhlTk9iH9S14DFQ8H00aNHdi5dnBkaPTRc6Lywj4B58/m8/uf/+X+2LIVzg/I39RVUFxqNi0mruVzONPP6+/uNSMEZJxB7n4I+d5hMc2hoSPfv37dMYXBwUPv7+9re3tbAwICSyaQZGAIXIJVMJqOjoyNrqqTW5/F4jMSRyWSs4A7R5E1mI3AQPRqwKL/88kvlcjmlUiklEgmjbwPxbG5uKhAI6Be/+IUqlYo2NjZsiudHH31kdgOoHUjr9PS0ZyfDNFQkgIaGhvSXf/mXNkZjbGxM2WxWR0dH5mwIUiQZI45AnezDnXwqSd99912XDaSfze/3W4DN59FbiG2t1y/Gmf/2t7/tEtPsdDp2BkEraHKHGIENXFhYUH9/vzkxVA/edb21c8FQwS5CXBE6MReCjlE6S90MBywfHA/vK73mkO/v73d1gfb39yuVSml4eNgyGH6f+gwd/lB2Hz9+rO3tbRvWNDAwYFx3SUYUSCQSOjk5sZSdojcHwlUIJmrs9WBC1/T7/RodHTWp8oGBAS0uLmpkZMQgCTpz3X1hQeukCA9cI104H7poiS7J7sBQwfxd5yLJMpxSqaTvvvtO2WzWGjSRT4GOiNGlJrS7u6uzszOTNoc9hXGV9N7d0RMTExbcoCi7trZmBt7n85miLj+P7IWJpwQYXGxUBjBs7XbbBAXB1QcHB3Xjxg2DsjBOnDukc3AyZ2dn+uabb5TJZCyKRD/MbUyjN4bpqMVi0RrqiHZdPNyNLntd3GEG+rVaLe3s7FjzLSyuvb0909JzNaz4RTDo8XgMriaylS5EbhnOR02K84ZhIyuXZPeTd1MqlfTVV19pY2ND169f19LSkvUigYY0Gg3Nzc1peXlZ+XzezmwymdTk5KTVaan3kWEjd9LL4oxwFqvVqp1Bgl0EQcn4sDmSrKkWiNzNSMjWJBlc6zZHzs/PW6uFKwmDbZVk6NDp6akeP35sUyyli8Di2rVr9m88Ho9GRkaUTCZ1cnKizc1NFYtFg+nJKLm3QOHvkjm/tXNBx59o1qUjM9uh07mYmMfm0SgpybqRiRrpmCbdpl8DLa2zszObGrmzs2PGkfHG0usu7WbzYkgQ8BVzJbjMgUDAir+uJlKhULCeGWYz8Lmk6l6v14pv7yNcube3J+n1zPKhoSHT30IQslarGaOHhkAmYrr9QFzm/v5+a3wD3pqYmDC5mOPjYyvkNxoNLS8va2Jiwt6B2zUPCyYQCGhmZsYGakmyjM7n82l3d9dYgcyRIMtjLIPP5zMiBA6FPppe929nZ8fezejoqOr1up1F1H29Xq+mp6fNCHq9XhtMR2AjyZwQ50+SQTKoEMOcgqW3v7/fpTwgyfp+KFRD0aYZkuVK/bhKEwzBAtM+PDy03g63Ex1K/7swdX7f2traMsflKk/gLFBzZlYK0AwQLLUUft9lhTKbHUeLYyE4w2EvLi6aijROB7aaJAsSEZyNxWJmYGko5N7m83nt7++bWCmICBIm+/v7ZsBxahCTellPnjyRdAENv8kCpFfJ778QUmWPaIR1NQTpfaH4z1lmP5GUgYHYaDT06tUro2G7Wbnr4GGxSdLs7KzC4bA5fWretGFQK3QFSulLlF6POADCJdD4/4Ut9vjxY3m9F6KG8LcjkYiazaZ2dnaMr07HLKlgKpXS9PS0FeLon/B4PKaXFAgEDLOdn5/X0NCQMpmMXrx4oWKxqFevXqlQKOj27dtGFCC7OD4+toYqekCWl5c1PT1tG0eB1O/3G+0PAgL01FKpZMVv6hw+n8/GkI6NjVmRvZfFzOxoNGpMpvHxcTNQuVzOxivjhFutlqanp63OgFHiMAwODpqDYk8oWqN0cHp6qlevXun8/Fzz8/OmWAC8xWe6URVFWIZgRaNRmw9fKpWM3QM8RwMZzsytuWCE0ALrtWbw8uVLK7jjICnyF4tFFQoFLSwsaHl52RiErVZLMzMzWlhYsPPXaLweG82gL4wAkuJDQ0NaW1szRYSVlRVVq1VduXJFi4uLkl7LCCEo6fdfKO7S0+G+r2AwaKKFOBD+LeePX9LrmTxAYqFQyIZ4vU/d4Pnz5/J4PMbmlF7XAt2i8NWrVw1+oiucnhFqnWD8ZB1ktzSUDg8Pa2NjQ/fv37cJkPl8XhMTE0YOgpHJwDqv16toNKqBgQEtLy/bWA2QiWQyKUk6OjpSoVAwSIjekvPzc5vMWigUTLNtenpa4XDY2Fe9nsEvv/zSbALw+fDwsFqtlg4ODtRoNLS4uGijRSAwJBKJLhvYbDaVy+Xs2RnvAcozOztrOmkU4Z8/f67T01MjYUB84vwfHh4aQ43xDJCf0L5j/9bX101pAeYtcNve3p5B2gQh9BUB5b7tGXxr50LUDvXYLfSCyxJVEx1Jrztl2Vh+D0+Ooi0v3B0ghKeE2onXlmSFWHBJ+jEwbGQIGF3SQ6Ju93OJtt1/Q+TLcov9vSzSciJ+olHptaEikuD5+DMcqduJTspMdy/fDaMrybKdWCymcrlsRoD3yPujDsP7IWLmz4EAIDhAUyXD3N/f74LvXNICRkiSOcFeFhETcCDfjZ/DdyRIIKNwzx9BBc9GIybnB/IIF5L3Az09FApZNAhMQPZOI50LH1EIpRmX3i0+G5YRWadLBsA5gZnz632cCz8HtiVFZDcYALJ22VzcKxdipW4HDR5DB8zjZkicUxwb1Ps3h++5/S1QzN0iPecfiJ3R6S6d391jsn/OLWe9V+cSCoXs37qNpsBFsFB5BujCBC9k9+5+Dw8PKx6Pd8ksAfvROtFqtSxboTmYrEWSwXJAw9g793tRe3XvJPRx6XVzN8/EnkvdyhjvYgPf2rn88Ic/VKvVskFLPBDQjN/vV6VS0crKihlLDBGbTtoYj8dtBsOVK1e6Buvs7u7q5OTEJOnRc2o2m5qcnNTU1JTNdK/X60qlUvYdt7a2ujYDuKLVahnElsvldHp6qhs3bujjjz9WPp/X1taWms2mwuGwRkZGujpRfT6fyaBjhHpZ8/PzarVaevXqlVZWViwqowYlydRvXb460S97Cqef3ozl5WWdn59rd3dXlUrFdJeGh4d1584dtVotLS0tqdls6u7du5qbm1M2m9X29rYx6vz+i9kRe3t7dlF5n0Boa2tr9n3QzProo4+sGI0IH0wtLgVzfd6UuHnXdfv2bbVaLT19+lTffvutzalwLzfqt1xQCtEu+6ivr0+Tk5Omq7SwsGBSMicnJ8pmszo5OdHQ0JCmp6fVbrcVjUZVr9d148YN3bp1y/YD+iwd99vb2+rr6zMqPI2UhULBziY1l+npaX322Wc6OjqyrnTOH5AOAYcku0fvs5LJpNrttvb29qymRi0NY062iiFmYVTYa54jFotpfn5e1WrVggwXeu7v77fBcn6/X0tLS5qZmbExBMAu1EsZUEUdDOfc6XS0v78vj8djWdz8/Lxu3bpl5CC0yFBDYGwFjKz3IeRI0ueff652u62NjQ2tra0ZuQQHS0/QgwcPzMm0222DUzkPfX19mp6etnEit27dMkiqWq3q8PDQ0BiGc3EWQVKwge12W9PT05qfnzd5fUkWsAN/VioVGzOOPYnFYvrkk0+Uy+X08uVLk+MfGxuzRnKCWpeY9b07l2g0qmazadItYIrS665pxAldCiAe0b3crkx8NBpVuVxWPp83JgbCkhhYxDDpxncPOv0nMLtwCCyiFiQ2YPxAC6S4DyRE9OhGEWCPREa9LDR8gGyABFxqLd3RbiTrUl3pzSGyAC6QXkelREfUaaAb4jyh2nJpydDc6JqfgdMjCnP3lEZDDIiL4ZOVEmCQCbh00XddOH3weajFLl0S5o3UTekF5+a78lwoYIPfYxDy+bzi8bhSqZRFnRh/VAFwWJBAeHdu0x5nHqKEJOvoB8euVquWyVMbotZHhsD547z0ungnLuEGiNpFDtCKo77iQqfu3SDjd5sBgVrOz8/NLtDUS0e722sG3ZjMhAZOWFIsVy+OXpFQKGS1wVAoZIQipni6OmI4u17PnyTrOdne3rYaBwxQSAMYZUgjLpUYCNltyyCD5Qy2WhfiqsDy7AOlAzI/94zRfPkmq4uM2uv1ql6vWx2U98a741nc5yDrJ7jmXb2LDXxr57K/v2/Fvbt373bp9YCXkg4SrVD0Hxoa0unpqY31hSlWKBS0urpqqbMrrUDvR6dzMfKYLlFYKEhNxGIxu7DJZFLValXr6+s6OzuzzIeIHprj2dmZVlZWFAgEjA3h9XqVy+W0s7Oj8fFxG4n76NEjHRwcGCGg15QaxwdhgbSWgjtQBKkw1FDG8B4eHlpW2Ol0rG9lfX29q08BxhEHBIddrVYN987n83ry5IlqtVpX0+DU1JRRGavVqhEo6vW6GV/3glKUhhzAv0un05qcnJR0gfMfHh5qZGSkS/LiXRfF6GQy+TtsFs4TFyAQCPwOqYOpi61Wy+iiOD2YN+DVPDskFGoPPN/Z2ZmdP+m1Ei4DsQjA+NnUr6B8UrNA2gWYb2trS8+fP1csFtOdO3fUbrd1//597e3taXJy0px4r4ufk0qlLCLGgRUKha4OcArzROUwRCn4QiLJZDKWLXI+kFuizsbPLhaLJtN0cnKi9fV1NRoNaxp0SQuuUgDBI8b3+PjYmFmu4gT3O5vNamJiQrdu3ZIkY0658ki9LGRU4vG4xsbGuoQ8d3Z2LIAiY4bEwc9ERaLdvlC9OD4+Nno3Z4LzSJc+wScknlqtZnI7ZC405vb19WlxcdFYbOVyWWNjY4pEIvbuqHkTzPLeQXb29/eVyWQsM5QuqNH0hL0LY/atnQsS5kioHx0dmVCf29hIYRSjPzY2ppGREYO9oBM3Gg3TdRoZGdHi4mJXhz5NRkSNwAtEAEdHR10ZDNglMzuYU06X9dHRkWmgET0QHVIvoO8BmrIk/eY3vzFa6ft2mHs8HutwxtgR1TJGmpeHw0gmk8avf/jwocEkFPyQO7l+/bpx6Dudjv0v/QRklTs7O8rn81pbW7NCH78ikYiJ2eXzees4Pz8/73p/vBOYelwYLjY9NjQxUnCnl6mXRf8PsMr+/r6+++47nZ2dmaYXTg+o1pUhArqrVCrK5XLWUFosFjU2NqYPPvhAw8PDRr2mKE2ETic0Io1keWSF4+PjmpmZsfnqh4eHSqfT1tXtMiQ5z1DGOYuZTEYbGxv68MMPtbS0JOmiF2p9fd0o+e8DjZ2ensrr9Wp+fl7pdNqUBjB6iMZi1IC/kMk/PDw0GRv+fH9/X3t7exYIkdG12xfzflKplBqNi7ECEChgd2WzWXk8HlMJ4M5jrM/Pz602iQF0GzCB0SRZZlcoFGx8MAXsv/3bv9Xm5qZRwHvdw1wuJ5/Pp9nZWaVSKR0dHZnYJ+QPzs/AwIAxD7nP5+fnGhoastHjbt/X4OCgotGoZQ8u/Zx6Yr1eNxKNO/yL95VMJjU7O6tisaj79+8rk8lYXRDCDdI/OOTt7W2rvXk8F9L+x8fHunr1qqampiRJDx8+tOme7xLgvJNzAS7B6yG9gRoqdRjocERndHW7lFkOCRspyVJMcD0KUDQQuTpDRNL0owCnVSoVDQ8PKxKJqF6va29vzyjRo6Oj9vukzKSv9XpdY2NjCv/dHA++Xzgc1uTkpBKJhInx9bKQG2fvgOX6+/tNXhtGGsJ7Ho/HaMQ4EfaZYmWn0zG4w23aI8PBAHJY6REBfnF7fzCAQG0ej8eKktFo1AKIVqvVJS3BuZiZmdHMzIzi8bhR06mNMHK21/2jOAwmX6lUTLIC2NAdetbpdKwwipOjlkSmQXOdOxHQhR2JRCmg8vzAL0Su/f39Zpj5/xT+aSJMJBJmJCCroCxAJDkxMWFquoVCwVh28/PzJlH0PpkLYxTo7QFlaLfbBtsibEq7gdfrNaiJ5lwgM4Q9odqSBQFVU2AGfnVZoaenp6b0TGTeaDS6fs/v9xsk2GpdNG9jM3B8QO7UecbHxxWJRBSPx42IQKDoFs573T+v12uwPa0DDFmjHoQ+HeeWxVlEFBRqvPR6uiV/7vbxAYeRrXNXYT2STbsjUKhZS9Lh4aHa7baSyWTXHXap6CzYfBMTE0a4GBkZ0eTkpLHFvnfn8vTpU4OOEPWDsgjWDU4tySRHisWiRcjIaiNaR8ENvJ+LicGj85deBYwnXcT8DJQAgLdonsxkMlpfX1cikdBHH31kzs3r9Vp3sQtZfPDBB0bDdamsqVTKHFOvB3N9fd0yrMHBQaVSKd25c0e1Wk2rq6s6Pz/XtWvX9IMf/MDohbVaTevr6yoWiwoGg0blxakA43i9XkupkWin3kHkgiElqgK6IWIpl8s6OjqS1+tVMpmU1+vVwcGB9vb2FA6Htbi42DVjh0iXgGBoaEj37t3TzZs3Dfqgt+aDDz4w49Trov/j1atX2tzcVCKR0M2bNw2jbjQaSqVSmpubszpBoVBQsVg0eGBmZkaSjNkFAYEaBGk/NRHYX8wlwWDu7e1pfX3dZGXa7baJo/p8PmtE297e1vr6ulKplD799FMLkrzeC7Vg3gHB2c2bN7W0tGQq181m0+j9zC55n5rLwcFBF9uJO0lPxeDgoKanp7WwsKB6vW7wy97eno6OjjQyMqKJiQlTyOCuUnOCegvV3uPxWEM0TaySrGMfw0hLAUEid35wcND02SKRiJaWliy7GRgY0PHxsfb3962e0Gg0dO/ePSvyr6+vq9Vq6cMPP1QwGLQMrddGVAgvRP1jY2M23Aynw3AuiAVoclGng0lIHRnjTqCC8admBLQKI4+1s7NjtR/uYbFY1N7envr7+5VMJjU9Pa2XL1/q+fPnSiaT+uyzzwzu7e/vN1Vpl+EHMoASOoQBWhzepdfvnYaFYcTcAU0u7RQjAzboUhPdArH0muJKncGlNLOAq2h+4v+7hT63+9btHIeCzAtEvoLf5zOBPYi4AoGAsZvAP12doF4LgtBI2TcKqXwfMgwUh4FboGe6rCj2+/c5OldXiG5kPpufRXTOYcdx09jm0mJ5diA3omyKz6T7ROMoDVD/4N+SXfS6fzwrAQZUU54HcgcZFTAZRI/BwUErVLv7RJZHkfpNMoekru5w9oRFhA/kxtlkvzEmb2ruURuj4VSSZQLAHo1Go2t08rvoOv2+xd4DTeMcuLtuzdPdc57tzWFiZHZuoZ/PIhMkSyT7Y0EsoQF6cHDQMhT2n892zylsRKJ7hldx1wmizs7OrK0Bu9SLsq+7qLG5lPU3oWz2D6ICd9hlq/FM7BF3isVn8rP4XDJdSV1NnC71ncyPO4x9xP5BsODz3Am4zeZrqRxqOY1Gw4JyUKvv3bkkk0m7wJK6ujkpBPISXUyaaOH09FS5XM4up9fr1e7urnZ3dw3zZggYw3SOj48VDAY1Pz+vaDSqw8NDa3JkU+fm5jQ3N6d8Pm9UOxgN0WjUIiBYX8fHxzo/P1cymdRHH31k7KJSqWSwy9nZmRWwMKAnJyf2d//1v/7Xb7tttsjSMLBg+LA36G4mvaaYCtPDlbJn/gzR78jIiMmLcNCLxaJWV1fl8/mUTqcVCARMRJRnRb16dnbWRhuTyfl8PuvroDObfSqXy0omk7p+/bpOT0/1m9/8xqTtt7e3u4rldCCfnJyYXlovy5Wx5yIib0Hth73pdDo2rIt6EVFdX9/F3J7BwUGtr69rZ2fHSCqwt4AZcrmczYQZHR3V8fFxV+2IWS/z8/Pa2trSkydPLBqXLujnV69eNXjILUBPTU3p448/Nt06Cqv7+/s6OTn5HUMITf192E6oZVAfc/tqcCDMGqnX613TFdlTZEmY3+MyBOkDgfpaLBZNJf2TTz5RPB43SBFHPTAwoGvXrml6etqQBoxao9FQPB7X4uJiF6RLtjIxMaGPP/7YbIa7h9ls1kYDezwem0XDyOleFn1JQInYQOo/p6enpiLgsj9RP2C5XfhbW1va3t5WIBDQ9PR01ywhKPKBQECxWMzIIchm4UDm5+c1MzOjbDarzc1Nsy0oUy8uLhqTlMbyer2udDqtn/zkJzo7O9O3335rDcXUgIt/N1wMR3hwcGA2/9/9u3/3D+7XWzsXV84Ceim4Ol7arclwaMFD8YQUxvv6+pTNZrW6uqqpqSl99NFHVuwiPXQbvcBKwWAlWYGOouHOzo79GVRPJDmoSVBUHB8fVzqd1snJiWG5OEN3aiI/nx6IXi+3OwuCiMoVoEPzhzoIeDKYMo7BLbgiYUJUgcSJ1+tVqVQyAT1YKxg4KJ00UcViMRUKhd95l/F43IqM0CfR1yJVLhQKXbpNXCQiXNJtJFd63T+iaaJmSQY5cNkgQeC83QZGzh9QGGoNL1++VCqV0t27d+1ikyVwuXDE7XbbiqFE5xTyITVIsig1HA4rnU4bu6xSqSibzapUKimZTCqdTqtUKhlkAxzrCo1iCM/Pz9/r/EkyKAY6vjuV0aVN82cuhZw6aa12Mdq5VqtZJub2pVB3AqbO5XIWDFGsZ+FgYrGYZmdnrcbo9lgEAgFNTk6a06b+yAhfdAfJViCYsI+0PQC5vQ8sxhkkc4Usg6MBkmaxp5QNOBcuzFUsFrW1taVIJKJkMmmQLFkN+4CRd2uqIBJjY2NKp9O2t3yvRqOhZDKpubk562PDIZ6eniqZTGp+fl4nJydGTKBWSZBFRiPJ5hK97Rl8a+eCKu7Kyoo2NjY0NTVlRVqwfr4Qm+H1XkxLg122sbFhL4lmQKRVgC+gINMgieEiMkY2YXZ21nBJagdMZuOFxONxLS8vGy5PDwjMiW+++UZe74XkBBx2fkEdhmdOWtnrwcTpZrNZ7e3taXZ21i4UhwE2G3poXq9XCwsLmpycVD6f1+bmpqXROGr2BzYcLL1IJGIyEZOTkxoeHu4SdpycnLRU+ujoyAgFKAjUajWNjIxofn7eDBDYdq1WUz6f129+8xt5PB5dvXpV165ds3SbKI5aG31E7EEvi/ezsbGhvb09xeNxc9gYOL679Hoe+dTUlGKxmAUybh8K5w+WHBTcWCymaDSqmZkZeyb053BU8XjcsvDz83MNDw9reXnZjDMElmQyabVAsgB6B548eWL0dNSQXcgXhwis8j6wrCRTsd7d3TVq940bN4zhxT1B5QCkYnZ21ppv3cmPGDy3859/B7sNggpD13K5nLa3t9VsNo04wB5SR3RZjgMDAzbSuFwuGzOrXC5rd3fXiDkLCwtWbwMZwRYRdEBg6PUOI1i5sbGhTCajdDqtWCxmkD/2D4IQezE+Pq5EImE2EMcLdEqNCkNOTSQSiVhgODg4aGhOPp9XuVxWIpGwM0uvSjqdtvoX5QhUKKiPt9ttQ2O+/vprSTJZKrcB/e/rC3rb/Xtr50In/ZdffqmvvvpK5+fnunPnjuHN1WrVirZ8Qa/Xq3Q6rUgkopWVFb148UKNRsMwvdHR0a6D1263NT8/r0QiYSkfTYcI0u3v71uHOPghHfSTk5OWdeC17969a70kiAPSc/Pq1StFo1H9/Oc/1/j4uPb29my2N/IhCOdRY+j1YHK49/b29ODBA0nSH/zBHxjNFUrt0dGR4ftDQ0O6ceOGUqmUvvvuO21tbRlbhKwGVkomk7FDSKGWDnaceSaTsQmE8/PzdmCBl5LJpLFO6NZF6p73e3R0ZBH4o0ePlEwm9W/+zb/R1NSUdnZ2rGhM3QUdOox0r/uHPP0333yjhw8f6sqVK/Z8ZMz0TgFLeL1eXblyRbFYTI8fP7YCL7+IHr1erwUdjBoeHR21MQmcGUQmfb6LsQnULMrlsoLBoG7fvq1yuWyD6RABhcFIHcDnu5hZ//XXXysSieizzz6zZmI3uyNjxXD3unes8N9NK83lcnrw4IH8fr/JxxO0nJ+fWz8S52lubk6JREIPHjyw8QoITBI9gyrA9qTXbXZ2Vp1Oxwzi/v6+1tbWbJKtW7drt9u/05AJxZnAAfYp5+v4+FgTExP6R//oHykej2t3d1f7+/vmwAnCeMb32cd0Oq1Go6Hf/va3+s1vfqM7d+7o448/ttoRPXPuvB+Px2NOaGVlRc+ePbMMGMeMnhpZ+MTEhMnho2DNnQT66u/vN5HWgYEBlctlDQxcjISnp6VUKqmvr8+mrMIkw+EeHx9rbW1NkUhEP/nJTxSNRm1MAo6OveqFSPLWzsUtdLpsJKnbk7m/5xaP+bfu4s9dBhQYLhsPBAL+zOcToVDIc7+j+52BL9yiI59HisnfYQP5Ob/vEL4PW4fPdveOz+P53iw4Usz7+7j57nd2/y17+Puejb1xIRH+jUsYID3n77v/BgiN6NVl+fHnb+6f+67edXEugLp+X2HWpUa7Ac7fJ53CM/l8vi6yAb9PRO4+Dz/zTVq1Syx48/fcn/Pmvrsd3vzZ+56xv2/x2W5B/s3FOeLZOAP84u+4n/nmv+fnQBAggnejYtc+uJ/pPr/7d97cG+6Ru4c4ud+3f7/v/bzr4t+7NvDv24PfZ6s4l79vD9/8DJdMw89h71yyA3ebd+b+nDfPKt//9z2HSy568zl6XZ7O+4ZDl+tyXa7Ldbku1xur946sy3W5LtflulyX6+9Zl87lcl2uy3W5Ltf3vi6dy+W6XJfrcl2u731dOpfLdbku1+W6XN/7unQul+tyXa7Ldbm+93XpXC7X5bpcl+tyfe/r0rlcrst1uS7X5fre16VzuVyX63Jdrsv1va9L53K5LtflulyX63tf/y8fbWwy/qiBOQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 32%|███▏ | 64/200 [05:42<12:21, 5.45s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 32%|███▎ | 65/200 [05:47<12:08, 5.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 33%|███▎ | 66/200 [05:53<11:57, 5.36s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 34%|███▎ | 67/200 [05:58<11:49, 5.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 34%|███▍ | 68/200 [06:03<11:42, 5.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 34%|███▍ | 69/200 [06:08<11:34, 5.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 70/200 [06:14<11:27, 5.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 36%|███▌ | 71/200 [06:19<11:21, 5.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 36%|███▌ | 72/200 [06:24<11:16, 5.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 36%|███▋ | 73/200 [06:30<11:15, 5.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 37%|███▋ | 74/200 [06:35<11:08, 5.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", + "Step 74: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 38%|███▊ | 75/200 [06:41<11:24, 5.48s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 38%|███▊ | 76/200 [06:46<11:10, 5.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 38%|███▊ | 77/200 [06:51<10:58, 5.36s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 39%|███▉ | 78/200 [06:57<10:50, 5.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|███▉ | 79/200 [07:02<10:44, 5.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 80/200 [07:07<10:36, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 81/200 [07:12<10:29, 5.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 41%|████ | 82/200 [07:18<10:22, 5.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 42%|████▏ | 83/200 [07:23<10:18, 5.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 42%|████▏ | 84/200 [07:28<10:16, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 42%|████▎ | 85/200 [07:34<10:11, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", + "Step 85: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 43%|████▎ | 86/200 [07:40<10:24, 5.48s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 44%|████▎ | 87/200 [07:45<10:13, 5.43s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 44%|████▍ | 88/200 [07:50<10:01, 5.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 44%|████▍ | 89/200 [07:55<09:51, 5.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 90/200 [08:01<09:43, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 46%|████▌ | 91/200 [08:06<09:38, 5.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 46%|████▌ | 92/200 [08:12<09:55, 5.51s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 46%|████▋ | 93/200 [08:17<09:48, 5.50s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 47%|████▋ | 94/200 [08:23<09:42, 5.50s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 48%|████▊ | 95/200 [08:28<09:36, 5.49s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", + "Step 95: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 48%|████▊ | 96/200 [08:35<10:05, 5.82s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 48%|████▊ | 96/200 [08:39<09:22, 5.41s/it]\n" ] }, { @@ -874,7 +2015,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[679], line 32\u001b[0m\n\u001b[1;32m 29\u001b[0m gen_opt\u001b[38;5;241m.\u001b[39mupdate(gen, G_grads)\n\u001b[1;32m 31\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[0;32m---> 32\u001b[0m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgen_opt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m \n\u001b[1;32m 34\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (cur_step \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m) \u001b[38;5;241m%\u001b[39m display_step \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mStep \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: Generator loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mG_loss\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, discriminator loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mD_loss\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", + "Cell \u001b[0;32mIn[721], line 23\u001b[0m\n\u001b[1;32m 20\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n\u001b[1;32m 22\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[0;32m---> 23\u001b[0m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdisc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc_opt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# TODO Train Generator\u001b[39;00m\n\u001b[1;32m 26\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m G_loss_grad(gen, disc, batch_size, z_dim)\n", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } From ba5244738550066f32e0966d14affc7de0df384d Mon Sep 17 00:00:00 2001 From: Shubbair Date: Tue, 30 Jul 2024 13:21:38 +0300 Subject: [PATCH 25/38] Updating GAN Code... --- gan/playground.ipynb | 1676 +++--------------------------------------- 1 file changed, 82 insertions(+), 1594 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index e9538d8a..28051188 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 701, + "execution_count": 517, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 702, + "execution_count": 518, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 703, + "execution_count": 519, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 704, + "execution_count": 520, "metadata": {}, "outputs": [], "source": [ @@ -71,15 +71,15 @@ }, { "cell_type": "code", - "execution_count": 705, + "execution_count": 521, "metadata": {}, "outputs": [], "source": [ "class Generator(nn.Module):\n", "\n", - " def __init__(self, z_dim:int = 10, im_dim:int = 784, hidden_dim: int = 256):\n", + " def __init__(self, z_dim:int = 10, im_dim:int = 784, hidden_dim: int = 64):\n", " super(Generator, self).__init__()\n", - " # Build the neural network\n", + "\n", " self.gen = nn.Sequential(\n", " GenBlock(z_dim, hidden_dim),\n", " GenBlock(hidden_dim, hidden_dim * 2),\n", @@ -95,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 706, + "execution_count": 522, "metadata": {}, "outputs": [ { @@ -104,26 +104,26 @@ "Generator(\n", " (gen): Sequential(\n", " (layers.0): Sequential(\n", - " (layers.0): Linear(input_dims=100, output_dims=256, bias=True)\n", - " (layers.1): BatchNorm(256, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.0): Linear(input_dims=100, output_dims=64, bias=True)\n", + " (layers.1): BatchNorm(64, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", " (layers.2): LeakyReLU()\n", " )\n", " (layers.1): Sequential(\n", - " (layers.0): Linear(input_dims=256, output_dims=512, bias=True)\n", - " (layers.1): BatchNorm(512, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.0): Linear(input_dims=64, output_dims=128, bias=True)\n", + " (layers.1): BatchNorm(128, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", " (layers.2): LeakyReLU()\n", " )\n", " (layers.2): Sequential(\n", - " (layers.0): Linear(input_dims=512, output_dims=1024, bias=True)\n", - " (layers.1): BatchNorm(1024, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.0): Linear(input_dims=128, output_dims=256, bias=True)\n", + " (layers.1): BatchNorm(256, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", " (layers.2): LeakyReLU()\n", " )\n", - " (layers.3): Linear(input_dims=1024, output_dims=784, bias=True)\n", + " (layers.3): Linear(input_dims=256, output_dims=784, bias=True)\n", " )\n", ")" ] }, - "execution_count": 706, + "execution_count": 522, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 707, + "execution_count": 523, "metadata": {}, "outputs": [], "source": [ @@ -146,12 +146,12 @@ }, { "cell_type": "code", - "execution_count": 708, + "execution_count": 524, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -176,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 709, + "execution_count": 525, "metadata": {}, "outputs": [], "source": [ @@ -184,18 +184,19 @@ " return nn.Sequential(\n", " nn.Linear(in_dim,out_dim),\n", " nn.LeakyReLU(negative_slope=0.2),\n", + " nn.Dropout(0.3),\n", " )" ] }, { "cell_type": "code", - "execution_count": 710, + "execution_count": 526, "metadata": {}, "outputs": [], "source": [ "class Discriminator(nn.Module):\n", "\n", - " def __init__(self,im_dim:int = 784, hidden_dim:int = 256):\n", + " def __init__(self,im_dim:int = 784, hidden_dim:int = 64):\n", " super(Discriminator, self).__init__()\n", "\n", " self.disc = nn.Sequential(\n", @@ -203,21 +204,18 @@ " DisBlock(hidden_dim * 4, hidden_dim * 2),\n", " DisBlock(hidden_dim * 2, hidden_dim),\n", " \n", - " nn.Dropout(0.3),\n", " nn.Linear(hidden_dim,1),\n", - " # nn.Sigmoid()\n", + " nn.Sigmoid()\n", " )\n", " \n", + " \n", " def __call__(self, noise):\n", - " x = noise + 1.0\n", - " x = self.disc(noise)\n", - " out = mx.log(mx.softmax(x)) \n", - " return out" + " return self.disc(noise)" ] }, { "cell_type": "code", - "execution_count": 711, + "execution_count": 527, "metadata": {}, "outputs": [ { @@ -226,24 +224,27 @@ "Discriminator(\n", " (disc): Sequential(\n", " (layers.0): Sequential(\n", - " (layers.0): Linear(input_dims=784, output_dims=1024, bias=True)\n", + " (layers.0): Linear(input_dims=784, output_dims=256, bias=True)\n", " (layers.1): LeakyReLU()\n", + " (layers.2): Dropout(p=0.30000000000000004)\n", " )\n", " (layers.1): Sequential(\n", - " (layers.0): Linear(input_dims=1024, output_dims=512, bias=True)\n", + " (layers.0): Linear(input_dims=256, output_dims=128, bias=True)\n", " (layers.1): LeakyReLU()\n", + " (layers.2): Dropout(p=0.30000000000000004)\n", " )\n", " (layers.2): Sequential(\n", - " (layers.0): Linear(input_dims=512, output_dims=256, bias=True)\n", + " (layers.0): Linear(input_dims=128, output_dims=64, bias=True)\n", " (layers.1): LeakyReLU()\n", + " (layers.2): Dropout(p=0.30000000000000004)\n", " )\n", - " (layers.3): Dropout(p=0.30000000000000004)\n", - " (layers.4): Linear(input_dims=256, output_dims=1, bias=True)\n", + " (layers.3): Linear(input_dims=64, output_dims=1, bias=True)\n", + " (layers.4): Sigmoid()\n", " )\n", ")" ] }, - "execution_count": 711, + "execution_count": 527, "metadata": {}, "output_type": "execute_result" } @@ -276,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 712, + "execution_count": 528, "metadata": {}, "outputs": [], "source": [ @@ -288,15 +289,15 @@ " fake_disc = disc(fake_images)\n", " \n", " fake_labels = mx.zeros((fake_images.shape[0],1))\n", + " \n", + " fake_loss = mx.mean(nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True))\n", " \n", - " fake_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels)\n", - " \n", - " real_disc = disc(real)\n", + " real_disc = mx.array(disc(real))\n", " real_labels = mx.ones((real.shape[0],1))\n", - "\n", - " real_loss = nn.losses.binary_cross_entropy(real_disc,real_labels)\n", - "\n", - " disc_loss = (fake_loss + real_loss) / 2\n", + " \n", + " real_loss = mx.mean(nn.losses.binary_cross_entropy(real_disc,real_labels,with_logits=True))\n", + " \n", + " disc_loss = (fake_loss + real_loss)\n", "\n", " return disc_loss" ] @@ -310,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 713, + "execution_count": 529, "metadata": {}, "outputs": [], "source": [ @@ -319,28 +320,28 @@ " noise = mx.array(get_noise(num_images, z_dim))\n", " \n", " fake_images = gen(noise)\n", - " fake_disc = disc(fake_images)\n", + " fake_disc = mx.array(disc(fake_images))\n", "\n", " fake_labels = mx.ones((fake_images.shape[0],1))\n", " \n", - " gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels)\n", - "\n", - " return gen_loss" + " gen_loss = nn.losses.binary_cross_entropy(fake_disc,fake_labels,with_logits=True)\n", + " \n", + " return mx.mean(gen_loss)" ] }, { "cell_type": "code", - "execution_count": 714, + "execution_count": 530, "metadata": {}, "outputs": [], "source": [ "# Get only the training images\n", - "train_images,*_ = map(np.array, mnist.mnist())" + "train_images,train_labels,*_ = map(np.array, mnist.mnist())" ] }, { "cell_type": "code", - "execution_count": 715, + "execution_count": 531, "metadata": {}, "outputs": [], "source": [ @@ -350,16 +351,16 @@ }, { "cell_type": "code", - "execution_count": 716, + "execution_count": 532, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 716, + "execution_count": 532, "metadata": {}, "output_type": "execute_result" }, @@ -380,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 717, + "execution_count": 533, "metadata": {}, "outputs": [], "source": [ @@ -393,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 718, + "execution_count": 534, "metadata": {}, "outputs": [], "source": [ @@ -417,12 +418,12 @@ }, { "cell_type": "code", - "execution_count": 719, + "execution_count": 535, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADWZUlEQVR4nOz915PcV3rfj7865xynpycnDgaJIAiGXZKbg2RLWrnkKgW7LN/4wv+M73xhl8t2OciutWRJ1mq/u8vd5YI5gMjA5Ng559z9u8DvHPYAAxIgJvQ0Pq+qKe5ienr6c+ac85zzhPej6vV6PRQUFBQUFA4R9Ul/AAUFBQWF4UMxLgoKCgoKh45iXBQUFBQUDh3FuCgoKCgoHDqKcVFQUFBQOHQU46KgoKCgcOgoxkVBQUFB4dBRjIuCgoKCwqGjGBcFBQUFhUNH+6QvVKlUR/k5ThVfR9RAGb8vUMbv2fi6ohrKGH6BMgefjScZP+XmoqCgoKBw6CjGRUFBQUHh0FGMi4KCgoLCoaMYFwUFBQWFQ+eJA/oKCgoPUKlUaLVa1Go1NpsNk8lEr9ej2+3S6XQolUo0m0263S7dbvekP66CwomgGBcFhafEaDQSCARwOp388R//MS+99BLNZpN6vU4ikeCv//qv2d7eJp/PUygUTvrjKiicCIpxUVB4SrRaLVarFa/Xy5UrV/jhD39IvV6nUqmwubnJhx9+SDabpVqtnvRHVVA4MZSYi4LCM/Bwvr9KpZL1EEpdhMLzjGJcFBSegV6vJ7/ggUFRq9VoNBrFuCg81yhusSFHpVJhNBrRarX4fD68Xu+Bm16lUqFQKNDpdGi1WnQ6HWq1GrVaDY1Gg8lkQq1WYzAY0Gg08uc6nQ7lcpl2u02n03kuAtidTod6vU65XKZYLJLP5wHkOI2Pj9NsNun1epRKJdrtNq1W62tX1isonEYU4zLk6HQ6QqEQDoeDP/zDP+QP/uAPUKsfXFj7XTj37t3j/fffp1wuk06nqdVqrK6usrGxgcViYXx8HIvFwsjICHa7HUBunrdu3aJQKFCpVKjVaif2rMdFo9EgGo1SqVS4f/8+IyMj+P1+JiYmCIVC/PN//s/J5/P8zd/8DdVqlUqlQiqVot1un/RHV1A4NhTjMsSIlFmbzYbL5WJiYoKzZ88eaFw6nQ67u7uUSiU0Gg2VSoV4PI5Op8NkMuH1erFarYyMjOB0OoEHxiWfz7O7u0u73abZbA6lcREuLvEl3F5qtZp2u02tVqPVaqFWqzEajYyMjOBwOPD5fFgsFtrttuIiU/hS1Go1er1+X7xOrKnTimJchhS9Xo/ZbMbj8fDWW28xPT3N/Pz8vtf0u2lCoRDf+ta3qFarJBIJKpUKLpcLm83GxMQE3/72t3E4HLhcLkwmEwDdbpdSqcT4+DipVIqrV6/y6aefHutzHjUGg4GxsTGsVitOp1OOwdzcHHa7nfPnzxMOh7FardJdaLPZ0Ov1BAIBxsfHSSQSJBIJWq3WCT+NwqAyMjLCD37wA9xuN2q1GrVaze3bt3n77bep1+sn/fG+FopxGVK0Wi0WiwWPx8OFCxdYWloiFAqhUqn2BZ/F//Z4PLjdbprNJolEgnK5TKPRoNFoMD8/z3e/+13cbreM38AXbjGbzUYqlWJzc3PojItWqyUYDOLz+RgdHWVkZITR0VHeeOMNHA4HBoMBnU4nNwR4UAej0+lwOp14vV4ajYb8noLCQbhcLr797W8zPj6ORqNBq9ViMBj43e9+pxiXfsQVT6fTMTMzw+joKOVymUwmQ71eJxaLUalUjuJXP/fodDo0Gg2hUIhz584RCoUIh8O43W5543gcwuVjNpvRaDRMT08DD05VZrNZVqX3v77X68mAdafTOdJnOwk0Gg02mw2n00k4HGZ+fh63243FYkGv1wM8ciMxGo2oVCr8fj+Li4uo1Wp0Ot1JfPxjRbgLfT4fNpsNh8OB3+9Hq9VKAyxoNptUq1UajQZbW1tkMhlardap3UifFeG+djqd0v1qMpnkeu52u6cuIeRIjItWq8XhcGCz2fhn/+yf8f3vf5+dnR0+++wzkskkb7/9tmJcjgAxIU0mExcuXOAv/uIv8Hq9zM/P43A4nuj0rNVqcblc9Ho9PB4Ply9fRqPRYDAYUKvVj8QOer0e9XqdWq02lAFrrVaL1+tlbGyMF198kddee01ulgC1Wo1ms0m73abRaKDVauX3Z2ZmpDzMP/zDP5zwkxwtKpUKnU6HwWBgaWmJ+fl55ufn+eY3v4nZbMZqtWIwGORri8Ui29vbZLNZfvrTn/LJJ59QLBalbM7zhsFgwO/3MzIyImWD7HY7RqORer1OvV5XjAvsP+15PB4CgQDNZpPR0VG0Wi1ut5tisShPvN1ul3a7vW/wVCqVDKQ+fGI+aLMTi7vb7cr3fJ60ncR4WSwW7HY7brcbr9eLx+PZ58oSCC2sgwr+xFiLcX745+DBplqtVsnn86TTaZlhdtoRc8poNGKz2faNo81mw2AwSIPa6XTI5XJUq1U574xGI3a7Hb1eL9/DarViNBrR6/W02+2hm5MqlQqDwYDb7cZsNhMKhaQL0e/3YzKZsNls6HQ6Oc/EpqnT6QgEAgSDQbRaLZVKZd8NWKS4DyvCnarT6eSX2MfEPDltRkVwJMbFZrNx4cIFRkZGmJ2dxev1yjTWbDaLVqtlY2ODeDxOJBKhUqkQi8X2ZUYYjUbp0/b5fJjNZvk9t9vN0tLSPldNNBplfX2dUqnE7u4ulUqFUqlEuVw+ikccKET9idFo5MyZM0xNTXHp0iWmp6exWCwYjcZ9r+90OjQajX2xF61WK908X0ar1aLdbnP37l0+/PBD0uk0165dI5PJsL29fSTPd1yoVCo5XmfPnuUHP/gBHo+HpaUl6QoT82p7e5tSqcSdO3eIRqNyA/V6vfz4xz/GbDZjNBpl3GViYgKtVksikaBUKp30ox4aIj4QDof5p//0nxIKhTh//jwTExNYLBbcbjcajUYmO/R6PWm8w+GwHK+lpSVu377Nb3/7W5rNJmq1mm63SyqVIpPJnPBTHh1ms1keYoQbLJfLUSgUyOfz8mb8tAeSg7wUx32oORLjotPp8Pl8BAIBHA6HdNW43W7cbjezs7NywtVqNbRaLel0ep9bRa/XyxNfIBDAarXK742MjHDhwgXsdjtarRaNRsPGxgbtdpt8Pi8Xb6PRkCel02r9nwRx8jEYDHi9XsbHxwkGg9jt9gPjLL1eT8ZI+sdHq9V+acqs+Ll2u00ymeTevXukUinu378vT/CnGZVKhV6vx2QyEQqFeOmll3C73YyPj2O1WqnX6zQaDYrFIvF4nFwux/LyMhsbG9jtdnw+H41Gg1qtJsfTaDRiNptxOByUy2Wy2exJP+ahotFoZPLCmTNnmJiY4IUXXmB0dHTf68RNWaBWq+X6np6exm63U6lUuHXr1r51W6lUyOVy+1QQhgmdTofFYpGGRa1W02q1qFQqNBqNr3Vz6/f6CB5WkjgOjsS4VKtVlpeXyefzXLp0SW5iItC/tLTEyMgICwsLpNNpqtUqyWRyX2BUuBT0er107QhsNhvj4+OyWlycOL1eL7VajZdeekkWuK2urpLP59nc3KTRaBzF4544IiXW4/HwjW98gzNnzhAIBB4JInc6HdrtNtFolPfee2/fCVrUZXxZXKbfDXTnzh2uX79OqVQil8ud6piLRqPBaDRiMBiYnZ0lFApx5swZmWKsUqmo1+vcvn2bu3fvkslkuH//PqVSib29PbLZLFarVRaSrq2t0ev1ZNzR7/fzxhtvyMLLYTAw4nB4/vx5Ll++zOjoKEtLS3i9Xmw2GwD1ep1SqUStVmN3d3dfBqLP5+Oll17CZDLhdDrR6/Xy/7daLTQaDZ1Oh/v377OysiIPMcMW8LfZbASDQbxer6xzSSQSrK2tEYvFnsqwiAOm2+3mzTffJBgMSjfvzs4Ov/nNbygWizQajWNxNR6JcREbeywW44c//CHtdlsWnZlMJs6dOwc88KeKr1qttu+BRVBULHyNRrPP6j68CY6Pj3PhwgW63S7NZpNms8nvfvc7PvzwQzY2NqTbbRhPP3a7ncuXLxMOh3nzzTdZWloCHhVObLfb1Ot1dnZ2+Ju/+RtisZj8XjAYZHp6ep+0y8O02225mcZiMdbX1x+JlZ1GRIzQYrGwsLDA4uIiS0tLjI2NodfrKZfL1Go1bty4wd/93d+RyWRYWVmRN5Rer4fZbCadTlMul1lZWaHT6TA3N4fL5SIQCPCtb32LeDzO9evXuX///kk/8jPR70a9fPkyf/mXf4nD4WBsbAyDwSDnXa1WI5lMks1muXr1KolEgkKhQLFY5OzZs8zOzmIymXC5XLjdbkZGRnjxxRcBpHH55JNP+Pzzz7l//z7b29tDZVxUKhU2m43R0VH8fr/MMozFYty9e5doNPrUxkUcvP/Fv/gXXLhwQXp23n33Xe7du0en05FfR82RGJdut0u9Xkev11MoFMhms5hMJux2u/SlimCyTqej1+vJBxYGRVjcXq+3L1D8uI2s368r4jB+v5/p6WkajQYmk4lqtTpU+lfima1Wq0w5ttls+/zbAjGOuVyOXC5HPp+XmljwhWvty24u7XabVCpFuVymXC7T6XROtWHpH79AIIDNZmNsbIzx8XFcLhfwwLWaTqcplUqk02kymQyFQoFms7lvgQpNNnF766/qPyjL7jSj0WhkDMrr9eJwOLBYLHLeiRvK3t4ed+7cIZ/Ps7W1RTqdplKpUC6XCQaD5PN5zGYzFotFeiFE3E8Euvv3gmFErF2v14tWq5XJIuVy+akNqcPhYGZmhqmpKZxOp9QD1Gq1mEwmHA4HxWKRWq12LF6cIzEu7XZbZoNtbGxw8+ZNRkZGWFxcBB5Mvlarhclkwmw20+l0yGQyNJtN3G43Vqt132LNZrNyMB63mZlMJqxW6z432vnz55mbm8Pn8/HrX/+aer1OtVo91ZIK/QjX4djYGG+88YYM4D8uzpRIJFhZWeHevXtsbm6SSCTk9yKRCPfv3//KmIvwAQ9D1pMYv0AgwOuvv47f7+fb3/62vPkJt87nn39OLBbj2rVrLC8vyyzHfkSSRKvVkpI5er1eGmtxqDnNxlhgNBo5d+4co6OjnD17ltHRUXQ6HVqtlk6nw/b2NpFIhE8++YT/83/+D6VSiVKpJON83W4XjUbD/fv3qVarTE1N4fP55I1IIMZqWLM+VSoVk5OTfOtb38Ln82EymaTrWXgInua5Z2Zm+NM//VOCwaCME4rf43A4mJiYQK1WSwN/1BxZhb4wDrVaTVph4UIQXftEkE/47ZvNpnR/iZaxrVbrkTTXgxaozWaj1+vJa7YIGFosFhwOh7weDgsi40bIkrhcLlwu1z7j0F/k2Ol0KBaLpFIpstnsI6eXYY1HfRk6nU5m6/j9foLBoFQqEGnWQnQykUjIeNNB869/zvYbkX5NMrF56nQ6+drTiEajwel04vf7cTgcGI1GaUS73S6FQoFkMkk0GmVnZ0fecvs3SiFy+rA7vB8xf8V4DoNhfhiR6dmfqdmvTP4kzyxueQ6Hg9HRUTweD2q1mmazKeuuxK3wYVXzo+TY5V+azSa7u7uk02l2d3fl5Nvb26PVauF0OrFYLPK00mq1yOVyX3lzGR8f58yZM/j9fmw2277U5WFC1BTodDrOnz/Pq6++ytTUlDSu/fR6ParVKmtra9Lv/d5770nX1vOMSqVidHSUc+fOMTExwbe+9S28Xi+hUAiAbDbLnTt3iMfj/PrXv2Zzc5N4PP7Y+Sdcu81mk3Q6TSQSwefzAQ+MmMPhoN1us7CwQLFYJJlMsrOzcypP5CJV+8UXX2RychKVSiXXaqVS4bPPPuPq1atsb29Tq9XodrsyWC28Ef3p84/b7Hq9Ho1Gg1Kp9Fijfprp9Xqsrq7y93//98zMzBAIBKSL0G63k81mv9IdqNFoCAQC2O125ubmWFhYQKVSce3aNarVKouLi8zNzdFsNqU7+7g07o7duHQ6Hbn4Pv30Uz744APK5TKJRIJ2uy3TZ4VxabfbFAqFrxyQF154QWpdvfLKK8f0NMePiFMZjUYmJyd57bXX8Hq9Mpvu4QXYarXY29tjb2+P69ev8/7779NqtRQRRZAClFNTUywtLeHxeOT3yuUyOzs77O7ucvPmTdbX17/y/cR8FT1eRMBfo9FgNptpNpuEQiGmp6fpdDrs7e2dSuOi0+kYHx9ncXFRypWIZ6/Vaqyvr/PJJ59QqVSkC1qcnsXrxDx+kjifqPUYRuMSi8X49NNP5eYvCp5FndRXGReVSoXT6SQQCBAKhQiFQlQqFTY2NohGozgcDqanp6W0Tr1eP7Y5d6TGpdvtyswHgKWlJVQqFS6Xi1arhcFgkC4zcW0W1aniGvy0/tZ+F0T/vw0LarUai8Uig6mhUEjW+/TTbDapVCqk02kZY4nFYjJWMmwL9UlRq9XYbDaMRiMTExPMzc0RDAbR6/X0ej1ZXxCJRFheXiYejz+R8oBwc9VqNba2tmg2m8zOzgJfpDqbTCZUKpV0dwzT36BSqbC6uko6nZbagaJQt18gVdDpdKhWq1Sr1cemsPd6PcrlMslkknw+f2rdiF9GtVollUqRy+VkQzmr1Yrf7yeVSj3RzWV0dJT5+Xn8fj+NRkPqOCaTSSqVirxVH7dM05EaF5GnXiwW6Xa7fOtb38JsNsuGU++99x6FQkEWC3W73QM1x550EfZLmRw0oYcBjUYjZd/Hx8dZWFhAr9c/4lqoVqvEYjF2d3e5evWqbOg1jCfAp0Gn08meNOfOneP111+XRWzdbpdMJkMmk+HevXt88MEHZLNZCoXCV76viG0Vi0WuXbvG+vo658+fl8WUNpuNTqeDRqMZimSIh8nlcly9epW9vT1WV1f3FT4elGAiPBL5fP5LE2yy2Sybm5tkMplTW0f1ZeTzeYrFIiMjI9KF6PP5mJmZIZVKfWV8RKfTsbi4yBtvvIHf76darZLNZtnd3WVra4tcLif7wojEiqEwLiL9VaS9ZrNZOp2OrHcRhXui++FhbXzDvnmKCtz+WqDHvUan08mgv/j/wjc+TBlMT4parcZut8sUWrPZjE6nk6nFiUSCSCRCPB6nWCw+onX1VYjbi0ajkSfzJ0nzHiZE2YFAuAX7k3VGRkZkbPTLNlDhRjvtae+PQ9wqhNuq0WjINStuuo9DpBkL+RidTkexWKRcLu/TZBS/Q2QzDo1bLJPJUCwWcblc/OpXvyIYDPLSSy/h8/l47bXXANja2uLv//7vSafTzzSJ+iUOhs3t8LRYLBZGR0ex2Wz85Cc/4bXXXpMnxXg8zgcffECxWKRUKj1XmWIijXZ+fp6FhQUcDoeUfS8Wi/z0pz/lo48+IpvNsre399TdAMXtW6Tk3r59G6fTydjYGDBcLtp+TCYTExMTMv11fHxcfk9klxmNRikE6vP5uHjxIjabTVb0H0R/vcuwjh088DTs7OwAD9bumTNn2NjYeOyBRIjKWq1WGf/a3d3l008/pVKpSKFVEYIQh/xsNjs8AX0RRMpkMuzu7tLtdrl48aLUDHvhhRcA9lXhfx3fqpiE/Vfw/riN+LfnBa1Wi9VqRa1WMz09jdvtlsWTRqORe/fuSSVp4esd9vERQWQRqxKyI/1+6o2NDW7cuCHH5mkR+mtqtVpqiYlAtmAYbjD9KcLwYLOz2+3yVtJ/G9HpdLLRXDgcZnR0FLvdzsjIyL5aoMcxDOP1VQhdRIfDQSgUwuVyye6mB7n4+1sciJvL3t4eyWSSZrMp6/4MBsMjN6Pj4tiyxVKpFB999BGhUEgKV2q1Wubn5+l2u8zMzKDX66VExNPidrs5e/YsIyMjWCwWer2erKje2dmhVCrJxIHnCSFpLjJKGo0Gk5OTjI6OUiqVuHfvHrFYTMq5iEyyYTM0LpeLiYkJgsEgZ8+e5cyZM7hcLur1OsVikVgsRjKZlHGpZ3UdiENSf0KKqNbv71p5Gmk0GqysrGA0GnnhhRekOO3U1BT1ep2RkZF9IqZqtVp257Tb7VIzULi8xKFQjI9AGGqxKQ7bnOynUCjw/vvvs7Gxwe/93u8xOTlJKBRiaWlJHsz749EiZhgMBgkGg2g0Gur1OolEAq1WK7UGtVoty8vLstTjODk245JOp/n4448ZGRnhypUrWK1WwuEwU1NTdLtdpqamUKlUVCqVZzIuQt4fHhi09fV1KZp3nGl4g4JWq2VkZATYf3N78803qdfrvPPOOywvL3Pt2jVisZgsahs2I+xyuWRV+dLSEgsLC3LjKpVKxONxGWd51kXYfwsUp/v+ZJN+aZjTSKPRYHV1lVarhdVqZXFxEaPRyNTUlHzNQSdt8V+RMVev16VxeZzRbbfbVKvVoTzw9JPL5Xj//ffxeDy8+uqr8ma3tLRELBYjm83uMy4Oh4OXXnqJcDhMIBBAq9XSaDSIx+M4nU6mp6eZmppidXWV9fV16eI9To7NuIiTXK1WY2dnR/bNGBsbk0Ep0VDo6yCCW/3XSDExhVEZhsnZ7XapVqtotVpWVlZ49913sVgseDwe2aBKtJh+OCD4cEMwvV4v0xer1arUzVpbW6NUKg2VkdHr9bhcLun712g0NBoNaVwikYhULX5W+g1Hv0YefJGyfJrdkO12m3g8LtV2t7a29lV/i7XdX2ler9dlMFnsA8lkkm63i9frxWq1SveOSAkXf5t6vT70WY7dbpdarSZv0ULFfXp6GpvNRiQSQaVSUa1WqVQqUqrfYrHIMgSn08n8/Lxswd1qtUgkEty7d2+4by6igjefz/P2229z/fp1AC5cuIDRaGR0dJRut8vq6urXen+RHdFf7yH86ELnbBgmZ7vdli6cXC7Hr3/9a0KhEN/5znfweDzSX+vxeBgfH//STBydTse5c+d44YUXOHfuHFeuXGF3d5f/9J/+E+vr61QqlVPfo0Vgt9uZmZkhFAphs9nQarW0Wi1pWN599122t7cPpTGVcO/odDpp6OGLNSBS708r9Xqdzz//nDt37siYndlsxuPxYDKZmJ+fl8V8ophUeA8qlQqVSoVEIsFHH31Eq9Xim9/8JvPz88zOznLp0iVarRY7Ozv7NLaOSyb+pGi1WlKW6YMPPqDRaDAxMcEf/MEfUCwWAVhbW2N9fZ319XXMZjNer1eqKQPMzc3xZ3/2Z1IUuFgs8tFHH/FXf/VX1Gq1Y28tf6wV+uI2kc/npQaROJV8XXdVf5tQcXPpLxoS+lDDYFjgCz+00FwTgoCRSER28BMuBHETFGmwQgW4378tZHLExtdut6UPfViyyEQTMLvdjtVqlQeQZrNJsVikUCjI7n/PKmoq3F7iS6SDPuwCO83uWZERV61WSafTRKNRzGYzjUYDs9ksEyVEo69qtUo8Hpd1FqIGa3t7m3a7LfsBibEXNxeh4PuwAvUwIvbGRqNBNpslGo3K7pS9Xg+fzyfHJJfLyV5BohsvPLidO51OGo0GmUxGKnknk8kTUYM/dvkXoRdULpfZ2NjgvffeIxaL8cEHH5BMJkmn00/8Xmq1WjYnCoVCsh2yEB28fv06P//5z8lkMkNzAu9HuBmi0Si//OUvZf92cV0WCtNC2kRk6ogrdf+tRnRf7PV6LC4uolarWVlZkaem04q4OXi9Xubn5/F6veh0Otnw7J133pFZNpVK5WvfKIRREa5Gq9XKyMiInJ/iEGQwGDCZTBgMhkN+0uOn1+uxtrZGsViUXTe1Wi1OpxOz2Uyr1ZKGQWhaiQOMaBBoNBpxuVzMzMzIZnVCf1D8XfpVO4addrvNvXv3SCQSJJNJ4IEo7+XLl/nGN75BMpkkmUzidrs5d+4cVqtV1hQVi0U2NjZIpVJcvXqVWCzGjRs3TqxG6ESMi+g0l0qlWF1dJRaLsbGxIU/iT4pQPvZ4PLhcLpmFksvlKJfLbG9vc/PmTZrN5lBqaYlMpP7eLELUUsRcREbU2NgYarVa9nkQNxYx6fR6PXq9nmq1ysjICOVyeV8zsdOKVquV6ZrBYFD2aWk2m0QiEa5fv04qlaJYLD7TraXfFSaKVkVmlDhdirigUFQ4rQH9fsRm93URXWR9Ph92ux2VSiXbbCQSiaFyaT8JQjIrmUyiVqsJBoOMjo5y+fJlJicnKZfLlEoleRPvV3sXBnt3d5cPPviAzc1NqY5yEhy7cenXD9vc3ESr1ZLP58lkMlQqlacyAuIqKYyHyDwRV8Cnla4eBoT7oD8F9vbt28RiMVKpFNvb2zgcDqamprBYLITDYZxOp/x5g8FAOBym2+2yvr5+qmV0VCoVJpNpXyW4SqWSnUpLpZKMyT2r28VoNOJwOPB4PHz729+WWWni1lKtVikUCuzu7rK6uiqD2c8roh2vKKoUh55hMLjPinDrZzIZbt26RTQaRafTEQwGZXsNm82G1Wql2+2ytbVFJpNhdXWVTz75hEwmQyKRkFl2J8WJ3FyEi+rGjRvcuXNH5rs/bQaNuAXVajUZuxEnH9HQ6TBqFk4T4tnhweYq/K5qtRqPx4PX6yUYDPLqq6/i9Xr5zne+s8+4GI1GFhYW8Hq93Lx584Se4nBQqVRYrVYp9SJiT41Gg1qtRiaTIRqNfql44pNisVik4vGf//mfs7S0JOV5arWa9H3fv3+fzz77bGgbYD0pFotFysyPjY3h8/n2dZ08zanaz4qYF5FIhEQigcFg4PPPP8dms/Haa6/x2muvEQwGCYfDtNttrl27xvXr17l79y5Xr16Ve+FJH6qP3bjAF66Y/o3w6yACtSaTCZ1Od2AR1vNMf3M2eJA9J4LMIgHg4ViU6BcjJL+NRuOBnRdPA6Khms1mky1fH05seBZfvshQFGKiIqYlNMvEzVn0KxJuntM4loeNVquVAqwiNby/a6eod3uex6rb7crDsUg2EdphoiC81+uRy+WIxWKyjfRx6od9GSdiXA4LjUYjW3r2948XYm0K+xEy6EJfzOPx8PLLL3Pp0iX5GhGQ1Wq1BINBxsbGpOz5aUufVavVhEIhzp49y8TEhAyki3bY/aKVT3NK7s8I83g8WK1WXnvtNX7yk5/g8Xjw+Xyy82e5XObevXv87//9v4nH46ytrR3hE58ebDYbZ8+eJRwO4/F49sWgarUa9+7d4+bNm8Rised+LYvWx6VSiWg0yu7urrwRq1Qq7ty5w29/+1uZNDEIhgVOuXFRqVQy9VFkP4ngVr+mmMIDxE1RFKc1Go1Hct/7NYtMJhMmk+mpN99BQcyPfp0mEXQXUvgP33af9H1FcN5qteJyuRgZGWFubg673Y7BYJBFcaLl78rKilQAUHhQY+VyuaTmmJhf/fVwD7c3f14R3gfROE2EAcStLpfLEY/HTyTd+Ms41cZFtPicmZnB7/ej0WhotVqkUilSqdRQ1bccJmazmVAoJGMR/XS7XcrlMsVikXQ6TTweP7WabCKgL+p24IvnE/UTwq31cCX9495PGCzRTvv73/8+Z86cYWJiQsYNxAnyN7/5jUy1397e3teZ8XlHo9HIrEVRp1EsFkmlUmxubsoiYcW47MflcjE5OYnNZmNvb496vS57tgySYYFTblzUajU+n4+pqSk8Hg9qtZp2u006nSaRSDxVWvPzhNlsliKOD8ud9/u7s9ksqVRq4Cbt0yBqf0TMRXRALJVKNJtNedt9WFH7IMSNxWQyMTIygt/v5wc/+AHf+c535PcbjYYsyLx69Sr/+T//5xMPrA4i/d05hXEplUpsb2+zs7MjpYhO89w7bFQqFQ6Hg4mJCQCi0agsAh5El/WpNS79rgm9Xi8nqKgePoxq60FEq9Xi9XplwZpWq6VWqxGLxb7yecWYWSwWxsbGGBkZwWq1fummepo3xW63SyQS4fbt22g0Gl588UWMRiMGg4Fer8fMzAxvvPEGhUKBnZ0d2QL2cRuaqJlxu90sLi7i9XqlFpbQYSsWiywvL5NIJKSr4jSP4WEjDIpIQXa73bKgVLTmEN0plXF7FJGQ0mq1pGEZ1H3uVBqX/k6MZrNZ9kQXNQzxeJzt7e2vpa486JhMJl5++WXC4TAWiwWr1cr29jZ/93d/95W6WMIQBwIBvvGNbxAOhwkGg195Yj+ttFotPv74Y27cuEEul+PNN9/E4/HILKXf//3f51vf+hbpdJpPPvlEyo08LkPJarXKgr9Lly5htVoxGo0yHb5SqbC7u8tPf/pTVlZW2N7eHroxfVY8Hg8jIyMsLCxw5swZRkdHpXHJ5/OsrKywt7dHtVpVbi0HIFQgarUakUhE1gcOIqfWuIigs/jqFwesVCrS7TFsi1ukvQqfv+ikKDSFHg7qiXRt0bnOYDDg8XjweDz7To3itb1ej3q9LuMGpx0hlJjL5SgWixgMBmlkHQ4HDocDvV5POBzep3V3EMK4eDweAoEAJpNJqtSKgkxxY4nH4wO76E8KEQMTBl6ku4uECpG2Xa1WT2WM76jpb10uNAQHWdDzVBoXk8lEOBzG5/MxOzvL3NycnKT1ep3l5WWuX79OPB4/6Y966Oj1eqampjh37hw+nw+fz8fk5KRMZEgkElIKBh4Uq507dw632y3bGni9Xs6fP4/VasVqtUoD3Ov1KJfLfPDBB1J9dViIRqOyzfaVK1dkF0S9Xo/NZuPcuXNSzeHL3GJCQ0tImi8vLxOJRLh//z4ffPAB+Xye1dXVZ5aTGUZUKhUzMzN873vfky2R+2NdQtAykUgoY/cQ4kDkcrkYGxuTnptBZrA/3WMQg+z1euWXQPQw2N3dHcpME1FbEQqFCAaDhEIhLBaLLKLa2NggkUjI1zudTl555RUp8yL6mQhdItjvDqvX62xubnLv3j3S6fTQ3PwKhQLLy8sUi0Xm5+dxu90yLdlgMBAKhZ7q/UR6aDKZZGNjg2vXrvHzn/98aJSkjwKVSoXP5+OFF17A5/Oh1+v3pbg3m00KhQKlUmkgA9QnhYiVajQamVpfLpcHvjzg1BqXQCBAMBh8RI9ILPrT3jPjcTSbTTY3N+Vzj46OYrFYZA+NUCgks+R6vR4mk4mZmRlcLhdms1lm5zxc29HfZ7tarQ6NW0xQKBS4d+8e0WiURqOBz+djZGSEcDiM3W5ncnJSjk2/WnS325UdE0Xb7E6nIyVkrl69yurqKpubmwPrnjhpRBKJ0WiURc+iHUS325Vy/BsbG0QiERnQV/gCkQYvJIUOWsODxqk0LiaTibGxMUZHRx9JpRXCmMMosQ8PWszeuXOHfD6Py+Xi0qVLOBwOLl68CHwh+SJuHAe11T3oxCNk0EXPCFFkOSyk02lyuRwqlYrf/va3qNVqXnzxRS5fvixdNB6P55FWBN1ul2KxSLVa5datW9y+fZtGo0GhUKBSqfDBBx+wsbExVF07DxutVovL5cJutzMxMcHCwoIsYG02m2xtbbG1tcWtW7dYX18/ccHFQaRfddtoNEq5q0HmVBoX+KJJWH9lr9DAGuYsE1H5XS6Xpbq0SMk+aLL1u7X6VQvEf8XPFAoFYrEYkUhEZk0N081PKGjDA9epSqWSTZlUKhV3797F5XJhMpnQ6/Xy50Qzq3q9LnuRi35E4oannLK/HI1GI1OPhTtWnLqFkK1o6tdut5X07QMQa1d4F0RDwEHm1BoXgRjgWq1GPp8nm80O9amn0+mQz+dRqVT76gGe5CQj3IWdTkeqUIuf+fzzz/nFL35BIpHgzp07p1JL7Gno9XpsbW2RSqUwGAz88pe/lC6xh92sYsOr1WpUq9V9dS1KRthXI7TX5ubmmJub2ze+nU6HWCwm5XFEUoXCF4j51mq1yOVyRKNR0un0wK/PU2tc+m8uYgMQujvDPDlFJ89arUaj0aBerwN8aeaIkHcXWmIiZiCMi0qlIpFIsL6+TiqVkim5w061WpXu0729vRP+NMOJWq2W3TmFuKxAnMb7by7D7HV4FsQabrVaVKtV6vW6cnM5ChwOB2fPnmV8fBy32w180eJzZ2dnqDdGEVgul8t8+umnOBwOQqEQr7322iM6YfDgRre6ukoul5O+bREzaLfb8hQZiURYWVmRongKCs+KyGwaGxtjcXGRc+fO4fV6HxGp3N3d5e7du6TT6aE+GD4LwhBXKhWy2SylUmngx+pUGheLxcLc3BxTU1NyQy2VSuzs7BCNRod6cxRtjVUqFbdv30alUrG4uMj58+cPNC6NRoPV1VV2d3f57LPPuHbtGpVKhWQyuc99OOinIIXTh8lkkll5MzMzzM/P71ODEMYlmUyyvr7+3DX2exrEeNXrdZlMMuhjdSqNC3yhsTPoGRNHRa/Xo1gsEolEAPjlL38pb3H96r6lUombN2+STqfZ3d2VWWBK0FThqLHZbMzPzzM+Po7ZbN63VqvVKnt7e6RSKRknHfQYwknT6/XIZrOsr6/T6/UwGo2y3YjRaJRxmUHhVBoXkZJ3GnK9j5JoNEoqleLzzz/nN7/5zYFjIeRcxMQT2XSDfupROP2Mj4/z4x//mEAgsK/QGSCVSvGrX/2KaDTKxsbG0JYOHCa9Xo+1tTW63S4jIyO8+uqr+Hw+/H4/kUhEtuselEPjqTQugoOyep6n00//8yrtBRQGDVFRbjab0Wg0Mhml2WySy+WkDpvSd+nJ6PV61Go1stksJpOJUqmEVqsd2D3vVBuXfiqVCrFYjGQyqdQdKCgMAMKIGAwGWZdx584drl+/zvb2Nr/4xS/IZDIkk8mT/qinBtFATTSgU6lUxGIxCoXCwLm6T61xEVXo3W5XSr6USiWZaqugoHCyiMZs/X1y4vE4t2/fZmdnh9XVVQqFwkBtiIOOKLcQ9S6DzKk0Lnt7e/yv//W/8Hg8slHY1tYWN27ckFIdCgoKJ0ssFuN3v/sddrud5eVlbDYb9+/fZ3l5mWw2K2s1FOMynKh6T/iXHaSsLBHQ79fK6td2Ouqby9dZDIM0fieNMn7PxtfdjI97DPszOkWySbfble6bk0wqUebgs/Ek43cqjctJo0zMZ0MZv2fjtBiXQUaZg8/GoRoXBQUFBQWFJ+X5LRJRUFBQUDgyFOOioKCgoHDoKMZFQUFBQeHQUYyLgoKCgsKhoxgXBQUFBYVDRzEuCgoKCgqHjmJcFBQUFBQOHcW4KCgoKCgcOopxUVBQUFA4dBTjoqCgoKBw6CjGRUFBQUHh0FGMi4KCgoLCoaMYFwUFBQWFQ+eJm4UpctNfoMh1PxvK+D0biuT+s6PMwWfjScZPubkoKCgoKBw6inFRUFBQUDh0FOOioKCgoHDoKMZFQUFBQeHQeeKAvoKCgoLC6UStVqPVatFoNJjNZnQ6Ha1Wi0ajQafTodFo0O12D/V3KsZFQUFBYYhRqVRYrVbC4TB2u50333yT2dlZNjc3uXv3Lrlcjhs3blAoFA719yrGRUFB4ch4OH3366ZRK3w9VCoVarUag8GA2+3G5/Nx6dIlXnzxRVwuF9VqFaPRyP379w/9dyvGRUFB4UgYGxvj7NmzmM1m7HY7Op2OO3fucOfOHVqtFrVa7dBdMQoPXGB6vR6NRsPc3BxTU1P4fD7OnDmD3W5nbGwMtVpNpVJhZ2eHTCZDo9E49M+hGBcFBYUjYWpqij/5kz/B4/EwMTGByWTiv//3/048HqdSqRyJn/95R6VSodFoMJlMGI1GXn75ZX7wgx8QCAQ4f/48BoOBXC5HrVajWCyyublJPp9XjIuCgsLpodPpUK/XaTQaaDQaDAYDOp0OjUaDWq0kqh4WarVaxlWcTidGoxGfz4fFYmF8fBy73Y5WqyWXywGws7NDNptle3ubcrl8ZEZeMS4KCgpHQqFQYHl5mWKxyOTkJA6HA41Gg16vR6vVKnIqh4QYzxdeeIE33ngDt9vNuXPncLvdGI1GjEYj2WyWd955h1wux+9+9ztWV1cpFAqkUik6nQ7tdvvQP9epMS4iMCVOPRqNZt/kbLfbtFoter2ectVWUBgAms0mxWIRq9VKp9NBpVKh0+kwGo3U63XFuBwCarUao9GIyWTC7XYzNjaG2+1mcnISt9tNtVqlVqtRq9WIxWIkk0k2NjZYW1uj0+nQarWO7LMNvHFRqVQYDAa0Wi2Tk5NMTk7i8XhYXFzEZDLR7Xbp9XrcunWLq1evUqlUyGQyNJvNk/7oCgrPNeVymd3dXQA0Gg0Oh4MXX3yRVqvF6uoqf/u3f0s2mz3hT3k6ERlgFouFH/3oR5w7d45QKMTs7CwAsViMra0tbt++zfLyMqVSiVgsRrVaZW9vTx7Ej5JTYVx0Oh0Gg4GxsTEuX77MxMQE3/ve93A6nbTbbbrdLj/72c9YXV0lnU5TLBYV46KgcMLU63WSySRWqxW1Wo3FYmFmZkbeXv6//+//O+mPeGoRGWFWq5VXXnmFH/3oRxiNRqxWK8VikQ8++IBYLMbvfvc7rl69SrvdptFoHGsq+MAaF4vFgsvlwmq1Mj8/j8vlYmFhgfn5ebxeLyaTCY1GI18/Pj7OG2+8Ia1zs9mk0+k8ly4y4W4Qt77R0VGsVqv8vlqtlq5Ft9uNxWIhHo+ztbVFvV5/7oyzcC1otVr8fj9OpxObzYbT6ZSxga9y4XS7XdrtNtVqVfqzhUtC4Qsedm+r1ernco0+K06nk4sXL+Lz+QgGg2g0GqLRKDs7OxQKBW7fvk02myUWi9Fut+l0OsdeYzRwxkUsYq/XK696f/Inf8Ls7CwWi0UaFZ1Ot2/RX7x4kfHxcdbW1tjY2KBQKMhMlecJMSZiAbtcLt566y3Gx8fl98T4GY1GLl68yMTEBO+88w5/9Vd/RTqdZnl5+ViuzYOCTqeTB5k333yTM2fOMDExwYULF9Dr9eh0OpndJObbw2PTaDRoNBrs7e3xH/7Df2B5eZlIJKIYl4cQMiT9ciSAYmCektHRUf70T/+UcDhMKBRCp9Nx69Yt/uN//I/k83lSqRT1ep1Wq3Via3lgjEt/Op3JZCIYDMqBCwQCeDwedDodWq2WZrNJOp2m2+1isVgwGAyo1WqcTiculwuLxYLZbJaaOc8LKpVKjoe4IrtcLkZHRwmFQo8YF4PBQDAYxOfzMTIywtjYGHq9Xm6K4sQzrOj1eum3HhkZweFwyLES4yKMy1fdXFqtFvV6nWazyejoKJVKhWKxSCwWO6anGXxUKhVarRaDwSDrMERwXzEuT4ZYw6Li3u1202g0SCQSJJNJUqkUxWKRYrF4pMH6J2EgjIso+jGZTLz11lv7To5Wq5WRkRGMRiONRoNKpcL29jY/+9nPqFarvPrqq0xPT+NwOPD5fDidTubm5mg2m6yvr1Mul0/68Y4F4YO9ePEis7OzTE1NcfnyZaxWKz6fD5PJtM9dJr6cTic6nY5z587h8XjY2dmhXq+zsrJCNpuVufHDyPj4OHNzc4yOjvLWW2/h8XgYHR3F7XbLza+/HkO4WYWB7jc4Yg6Lm3Y2m+U//+f/zOrq6nNzA3wSXC4XZrOZXC7H1NQUGo2GSCRCPp8/6Y92KtBqtej1ehwOB+Pj4/h8Pv7v//2/fP7556yvr5NIJGg2m0eSWvzUn/WkP4BYqOIEOTk5yYULFxgfH+fcuXPodDrggRui0+lQq9VIpVLcvHmTUqlEKBTC5XLJXG+DwYDL5cLr9RKLxVCpVEO/uIUbTKfTEQwGmZmZ4dy5c3zrW9/CaDTue53g4THxer14vV5sNhuBQIBYLDbUhlmtVuNwOBgbG2NqaopLly7JwjMxZmKMRHq7SN0Urpx+t6yYxxaLhYWFBWq1GoFAALVaPdS3v6dF3FacTicOhwObzYZerz/pj3Vq6L/5Wa1WjEYj0WiUzz//nEwmQ7VaHZhb4IkaF4/Hg8/nw+v1cvnyZTweDxcvXmRychKn04larabRaLC7u0upVOL+/fssLy8Ti8W4d+8erVaLjz/+mFQqxaVLlxgfH8dsNnP+/Hk8Hg/lcpmtra19NTDDiNPp5Pz587jdbt58802WlpYIBoNotQ/+vN1ul263KwPMIoDdH0cQJyKdToff7yccDlMul0kkEif5aIeOVqvF6/ViNpu5dOkSP/zhD/F4PHg8HoxGI51Oh3K5TLlcJpPJUK/XSSQS++oFtFotFosFnU6H3W7HbDYTCASYnJyURr7b7UrZk0qlQjqdfu6NjFLX8myoVCqWlpa4dOkS4XCYaDRKLBZje3tbztFB2uNOzLioVCp8Ph+Li4vMz8/zF3/xF4yMjGA2mzEYDPJ19Xqd1dVVotEov/zlL/nVr35Fs9mUm2S73WZ5eRmdTsd3vvMduWnMzs6ytrbGRx99RKPRoN1uD9TAHyZut5u33nqLsbExXn31VV544QV5qhY3vk6nQ6FQIJ1Oy2u1CKyqVCqMRiM6nU7efkRe/LDd/LRarYynXLlyhd/7vd+TMZVer0exWJQFZysrK+TzeT7//HOZ4l4oFDAajbjdbgwGA+Pj43g8Hs6dO8fY2JisQFepVAQCAaanp0mn0xQKhefeuCg8G2q1mgsXLvBnf/ZnNJtN9vb2yOVybG5uEo/HB26dHrtxUavVWK1WWbcyPz/PxMQENpsNg8EgbxmiGDKfz3P//n1isRiJRIJ6vS5rW3q9HtVqFa1WK4XwRLDLarVK11omk2F1dZV6vT5wf4BnwWKxyJjUyMgIwWAQi8UCQK1Wo1Qq0Wg0yGQy1Go10uk06XQarVaL1Wrdlw46MjLC7Ows7XYbj8dDvV5na2sLp9NJs9kcuFPR10Xc2oRLQaQaC5fXxsYGkUiEdDrN1tYWpVKJaDRKPp+nUqlQLpfR6/W02235Plqt9pG5JeqzTCaTNDYKCl8Hcdu2WCwEg0FcLhfpdJqdnR1SqRSlUmkg1+axGxeDwcD8/Dw+n4/vfve7/PCHP8Rms+H3+9FoNMTjcXK5HMvLy1y9epVMJsPNmzdJp9NUKhW5iMVXOp0ml8sRi8XI5XKyRsHlcvHDH/6QhYUFrl+/zr//9/+eZDJ5IvneR4FKpZKS5nNzc7z++usEg0GMRiOtVou9vT1u3LhBJpPho48+Ih6Pk8lkyGQywBfZeWJz/f73v89f/uVfYjKZuHjxIktLS1K+I5fLsb6+PhSZdxqNBp/Px+joKHa7HXgQqK9WqxSLRf73//7f/PznP6der1Mul2Xxmbj99Qf0hZGpVqtMTU09cjMRkhzValURauRB7Eoxsk+PSJGfmJjg9ddfZ3p6mkwmwz/+4z+ytbU1sEk3J3JzsdlseL1eAoEAIyMj8mTXbrcpFouk02kpX5DNZolGowcOYH/NgQi4drtd6d5xOp0EAgGcTucj2T3DgMViwev14na7pVFtNBqUy2Xy+TzxeJxEIsHGxgbxeJxsNvuI3Ia4vZw9e5ZKpSLjCPAgs8dut8sb4TCgVqtlMNRgMOxzHbZaLam9JFrAfhnCPSvqCfoRSRbiS+EBD9/ulLF5PGJ8jEajjIPa7XY0Gg2tVot0Ok0ymRyIzLCDOHbjYjQaOXv2LIuLi0xPT2M2m2VVcz6f55133uHu3bukUilZMV6pVPa9hwia6vV65ubmCAQCnDt3DqfTidlsRqPR0O12ZcxleXmZSqUyNLcWgdvtlqm0Op2ORqPBu+++y8rKCltbW3z++eeUy2Xi8TjVavXAzVK4F+v1OqVSCb1ej8/nw2AwEAgEmJiYAJDJAacdvV7P9PQ0586dIxgMPpJBJ+pVnnWe9Ho9yuUyqVSKXC43MBk8g4JGo8FqtWKz2WRGqMJ+hEcnHA7z2muvsbi4SL1e56OPPuLOnTtUKpWBjiUf+46h0+kIh8MsLCwQCAQwGAwUi0V2d3eJx+N88MEHfPTRRzSbTer1+oHv0a+uKmoVRKaYKKjsdDrE43Fu3LhBLBYbukItUXA6MjKC1+uVp5mVlRXeeecddnZ2ZMe/L0O4F0VnwGaziV6vx2Kx4HQ68Xq95PP5oTlhComX8fFxnE4nsD/l+DDlxxuNhkwQGKa5dxhoNBqZltwv46TwBf3F5PPz8ywuLnLjxg3W1tbY3d0d+D3t2IxLfz2Lw+HA4/FgNpuBB8Hnra0tmf0gdMHEz4msJrvdjs1mw263Mzk5ic1m4/z584TDYSYnJ6VMh9gkCoUC8Xh86NJANRoNWq0Wm80mbxmxWIxGo8H29jY7OzvKafkxCEMqMgjh66fIajQa/H4/s7OzMmbY//75fJ5kMkmpVBqq+XcYmEwmJicn0Wq1rK2tnfTHGUg8Hg8XLlyQN+x8Ps/6+joff/wxe3t7jz18DwrHZlyEYTGZTAQCAcLhsKwaLxaLXLt2TWbq9A+aSqXCZDKh0+mYmppiampKqiJ7PB4p26HVatHpdPR6PZlxFo/HuX//PrVa7cSlEA4LlUqFXq9Hr9fLOopqtcry8jKZTIYbN25w584dGYNS2I+o9ymXyzSbzUdUC54GrVbL7Owsr7zyClNTU2i1Wnq9HrVajUqlQjweZ2NjQ2Y3KnyBkN8fGRnh2rVrJ/1xBpJwOMyPfvQjnE4nKpWKWCzGxx9/zP/5P/+HRqMx8Lp1x+oWE7cXUbAnrsMihmI0GqUasni9TqeTKsgTExOMjY0RCoXw+Xy4XC5sNhsmk0n+jm63S6VSoVKpUK1WZbB1UP2ST4uQLjebzTIoXa/XqdVqlMvlA4PLX4b4O5jNZkwmk3QrDiti8xdp2iKDSQRPRbD/yyTKxXw1m83Y7XYZ64Mv5p/4WzzPhqXb7dJsNuVG2Gg0pFhlf9x0mOfb10GojQjXtMVikZmyxWJRxloGfV4dq1tMKPWKzmliUtlsNnn9m5mZoVgs7nP9XL58Gb/fLwOAZrMZv98vJ2c/tVqN27dvk0wm2dzcHLpAvtFo5MyZMwSDQWZnZ3E4HFSrVbLZLMlk8qmuyhqNhlAohNvt5oUXXmBhYQGbzbZPMmbYaDabbG5uAl8ob8ODW4jRaGR6epqXX36ZRCLB6urqgQFTs9lMOBzG6/WysLDAwsICFosFtVpNpVJhfX2dZDJJMpkcmnn3dajX62QyGSwWC7u7u3g8HikzpHAwYk16vV7m5+cJh8N0Oh0+/fRTdnd3T9VN+NhvLv0pmsINodfr8Xq9slK8UqlIDR2n08mLL77I6OjoPqnuxxWmtVotMpkMsVhMKoMO0wIXMvrBYBCHwyFPfuJ0+DTBaJGx05/ObLFY0Gq1cvKKgP+wIGJxmUyGSqUi61bgwXg4nU5CoRDNZlPKuIiMOoFOp8PhcOByueSXqBdqt9vy/QfdJ37UCC1AcZMrlUrYbLaT/lgDjUjU8Xg80jNTrVZl/LhSqcg9tD8RZRDX6LEZF3FFrlQqRKNRtre35QK1Wq2cPXtW1gw0m819txyv14tOpyMSiRCNRrFarUxOTspsExFr6Xa7lMtlbt26xcrKCpFIZCAH/Vno78wpEhieNlag1+vluL/++uucOXOGxcVF6SITtR+pVEpK7wxqLv3T0m63icfjtFottra22NnZwWQySY2wK1euMDIywvLyMna7XcprFItF+R6BQIDXX3+dUCjE6Oio4tp5DJ1OR2Z9Cl22YZlHh42ISZvNZi5evMjFixdZXFzEYDCg0WjkATscDvPCCy/sa/GwublJOp2WZRuDsucdu3ERQoDb29syHdRqtbK0tCRf21/J26+NFYvF+OijjwgEAlitVux2+z6hwHa7Tblc5vbt21y/fp10On1cj3es9BsX4b9+GgNjMBikYOirr77K66+/jsPh2Cdm2ev1yGazrK+vk8/nhyYhQhiXYrHI9vY2u7u7sljUbDbz0ksvcenSJW7evIlarZbq0P3B/2AwyGuvvSbjf0qdxsGINS+KTUVizaBsfoOEWq3GbDbjdDq5cOEC3/ve93C5XNJFffHiRRqNBvPz80SjUer1Ovl8nnK5zG9/+1t6vZ7sfjoo43usbrFer0ej0WBzcxO9Xk+j0ZAyGsJnLRB6Vq1Wi1wuR7VaZW1tjWQyKTfB/qSAarUqK/sLhQKVSmVoNsSD6DcmoulXr9eT/TLa7fYjrYpF0N7n87G0tCRVEiwWC71ej1wuJ11lgMw4G6asM7Hhieyb27dv4/f7ZXBexJxEurvoSS6KSVUqFTMzM/j9fumWfPj9q9UqpVLpuXeLKTw5Yg0LhW673b6v9YNwhZnNZrxeL81mE4vFQr1e5/z58zidTra2tmRH1EGogTk24yL8goVCgf/3//4f77zzDq+88gqvv/66bPDVn/UlZDjy+Tw3btyQbTvFoOl0un3VveJWs7Ozw9bWltQRex5wOp289tprUgNsb29PCn+KCaZSqfD7/UxNTTE7O8sf//Ef4/f7GR0dxeVyyQC2wWBgYWEBk8kkb4MnPUkPk263S6lUolwu8/7777O2tsbk5CTlcplgMMjS0hJjY2OEw2HcbjetVovvfe97Ut1ApMYHAgEpM9SPSIHf3t7e50pTUPgyHA4HL7/8snR7hUIh4IsGdSIpyePx4Pf7Zdig1+tx5coVGo0Gv/zlL6lWq+RyOaLR6ImnKh97hX673SaTyVAul4lGo/KKJ9wSgkQiIfWwdnZ2pFS80IPSaDT79MKq1SrJZJJ0Oj1UdS0HIeJL4vorAswqlQqv14vf76dYLMo2xSJo7fF4CAaDjIyMyIwUs9mMSqWi2WySy+UwmUz7/OL9IqHDgjh0FItFut0uBoOBaDSKSqUiHA7j8XjQarU4HA56vR4Wi2VfUa9IWT7IFdnpdKjX6/LWPUzjpnB0aDQabDYbVqtVxpCFaoZw9wslblH3J9QNxL4ZCASw2Ww0m82BUD04duPS7XZlLcatW7dIJBLo9XopLikQrgXhFmu327z11lu88cYbhMNh+Xph1Xd3d3nnnXdIJpND3TJV1FEUCgWpgSUmptFo5Cc/+QmvvPIK2WyWvb09ms2mrBAXgXvRK16v11OtVsnn86ysrPDRRx/hcrmYm5t7LrJ66vU6nU6HjY0N/vZv/xan08ne3h6Li4uEw2HOnj0rbyei5wt8ecFlp9OR7tlh7uSpcLiIfbFcLrOyskKlUmF3d5e7d+9SqVSk58bhcGC32wkGg1y5cgWn0yl7Cvl8Pi5dukQ0GiWZTJ74/DsRNcJ2u0273WZvb4+9vb0vfa3IjhLFlGJARZ2M0ILKZrPcv3+ffD5/4tfBo6TX68kAqbidCeVUo9HIpUuXuHjxIplMhu3tber1Oul0mmazydmzZzl79qzcGNvtNvl8nnw+L9WTfT7fcxMrEPOwXq+Ty+VkfxZR2zI/P49Wq93XVK2fg24lnU6HUqlEPp8fihYFCsdDv2xQPB6nXq9z9+5dfvOb31AsFolGo1SrVdxuN263m5mZGVmSIGqH7HY7ExMTsqfVSTPwUrdarVZe90TASygft9ttNjY2SKVSrK+vy6roYYoRPIzo1VKpVBgfH2dsbAyHw8H4+DhGo3Gf28bv99NqtbDZbLTbbdxut3SBZbNZqtUqn376KVtbW7RaLRYWFvB6vej1elqtlqyuHvb0UeFmFOnJnU6HRCJBNBrFYrHg8/n2deoU9VdCgsdqtUqDn8/nSaVSJJPJR9S8FRQeR6VSYWVlhWg0isPhwGw2E41GZaM/sQaFGGokEuH999/H7/fjcrlwOp0YDAZmZ2fR6XS4XC5SqRStVuvEQgQDb1wMBgNTU1MEAgFmZmYIhUKyYK1Wq3Hjxg2uX7/OjRs35GlxmP3cjUaD+/fvy4pytVrN5OQkXq93Xyqx3W6XWV8iZiJiVNVqlc3NTVKpFH/zN3/Dhx9+yJtvvsmf/umf4nK5MJlMMnmi0Wg8F7GDbrdLo9Hg9u3b3Lt3TxbrWiwWzp49i9vtlrI7brdbuhfPnTuH1WqVN8R4PM7Ozg7b29tDfchROFwKhQIff/yxdLmqVCqZUAPIuVStVqnVauRyOba2tnC5XExOThIOhzGbzbz88stSczGRSMjQwkkw8MZFVKSL20t/kZ+ohhatPodJ5uXLEEF60RDMaDTKmh6hDwbICdpqteTm2Ww2yWQyMklC9IYXFelarVY2zmo2m7RarYHuGXHYCFdZ//9PpVK0221MJhNGo5F2u00oFEKtVsuFK+qxhjF9W+HoEW6xJ3md+BLJKKKGSKiaGI1GDAYDBoOBarV6DJ/+YAbeuIjCtrNnzzI1NbXPotdqNdkQLJ/PP1cLutfrsbm5SalUYmJiAp1OJ1Npx8fH5euazaYMLm9vb7O9vU0qleLmzZuykFDUZIgNslQqAch4zLClIz8NjUaDjY2NfYKL4XAYq9VKMBjkzJkzwP6eMAoKR01/76FcLkcymUStVhMMBjGZTDidTpxOJ7VajUKhcCKfceCNi1arxev1EgqFsNls+07jzWZT6jgNUmXqcVEul2m1Wmg0Gra3t2m1WoyMjODxeORrGo0GmUyGYrHIzs4Oq6urUtZF1HuIlGVxIhLGRFRXP6+GBb6oi+nHaDRKnaznwWV4GIgDoTJWh4vYC4UCt6h/EaK+J5mSPLDGRYhTCgl+j8cjiyyLxSL3798nmUyyu7sr/YrP28QVizWZTPL+++9jtVq5efMmbrd732sKhQKNRoN0Ok02m6VSqcimbA8H6/uNy8OCjQoKXweR+VSr1TCbzczOzp70Rxoa+tuViHhqqVQimUwSj8dPNB15oI2L6FnicDhk+jE8OLHfvXuXaDT6XNcTCN9+Op0mk8nIf/+ylNknMRbKKVPhMKnX66ysrJDL5Zifn1fm1SEhAv8iziKSnEqlEul0mmQyeaLF5ANrXET/6GAwiMVi2XfFq9frxGIx9vb2hrqm5Wl4WgMiEPUbIsVWo9FIdWqlTkPhMBBtDtRqNblcjlwuJ9sdPE8YjUZsNts+cVjR2PDrvJeoefF4PDidTjqdDtFolEQiIQuET9KQD6xx8Xg8XL58mbGxMfx+PxaLRZ7I8/k8n3zyCZubmySTyRP+pKcbUSRosVhwOBxoNBqi0Si5XO6RWIOCwteh1Wqxu7tLMplkZWWF1dXVJ86OGiZcLhdLS0v7WoRsbGywvr7+1EbA6XRy5coVgsEg586dY2Zmhvv37/Pxxx+zs7NDJpM58fEdWONiNBplcVB/vwwREyiXyzKgrfD1EQFAEeMC9gUIFRSeFZEcIiRO6vX6vjkn9LLa7fZQr2eDwYDb7Zb6iL1ej0wmg06ne+L0dVHIa7fbCQQCBAIBTCYTvV5P6isOgmGBATYubreb8+fPEwwGpc6VyGp6HusvjoJ+d5jFYpEqwPV6XSYBKCgcBp1OB5VKJdNnzWYzwWCQRqPBlStX6Ha77O3tsby8PLSHGtE/yel04vF40Ov1/OIXv5AH5a+KkahUKubm5lhcXGR8fJwf/ehHOJ1O2u02n3zyCe+//z4/+9nPyOfz5HK5Y3yygxlY42I2mwmFQvj9flkUKNLuRKGbKFpT+Pr0py2azWZ5YxHiogoKh4FwA4kvrVaL2+2m2+0yMTEh9e9WV1dP+qMeGTabjcnJSXw+H2NjY5jNZjY2NvB4PKhUqq+8cYi2GYuLi0xPT3PhwgUsFguff/4529vbrK+vc/fuXarV6kDU/A2scREaWf2CgblcjkQiwe7uLsVikWq1OrSnnONCZIYJg1KpVEgkEuzt7VEqlZSb4QH0u3fEiVzIxQhDLVwdyuHn8ahUKvR6vewfpFarpSKwqL8aJkqlEjs7OzSbTUZGRjCZTCwtLfFHf/RHJJNJrl+/TrFYlBqJoiGi0WhkdHQUu93O0tISS0tLWK1WUqkU8Xic69evs7y8zNramlTjGAQG1riIxdpvXBKJBDdv3mRlZUUWBiqb37Mh3BRCeFFU7a+trQ3E1XoQ6XQ6MstHnBBFvYEwLkajUcrtKDyKMMhGo5GXXnqJixcvAvDJJ5/IW8wwGpf79+9TKpW4ePEiFouFV199lUuXLhGJRPjlL39JKpVib2+PbDa7z139rW99i9HRUdmePJ1Oc/v2bVKpFL/5zW/4/PPPKZVKA6WtOLDGRdAfyK9Wq2QyGQqFghJvOSSEW0wE9lUqlQysDsoJaBB5uJZIbJYiUC2kYhT2I5SjtVot+Xyeer0uDYmQIRpWuaFarUYikUClUnH//n2p4N7r9UgkEiSTSXK5HMVikUqlsk8dIxqN0ul0KBaLshh6bW2NbDZLJpORrx8kBt64wBdibZFIhGvXrhGNRpVg8yGgUqlk73in04nFYpGuRiVb7PGITqhCnRuQLgyDwYDJZMJsNivj9xC9Xo+9vT0++ugj3G43hUIBvV5PJpOhVCrxySefsLOzQ7VaHbiN8jBIJBK8++676HQ6rl69itFoBL4QrRSHZmFs++fZe++9h16vl6UD/d0pc7kc1Wp14BQ1Bta4iIESlrvX61Gr1Uin0xQKhYEIWJ12hM/bZDLJiSv6cp90AdYgo1Kp5CIXKaXi3/tbcCs3l/2IosFkMin7C+n1euLxOMVikUQiQaVSGdqDY6PRIJVKAQ9uIk9DLBY7io90pAyscanVakQiETqdjlT6FCmy5XJ5KK/Nx41GoyEcDjM1NcXo6OhjW/cq7MdisTA3N0c4HMbhcAAP+mzEYjFisRjpdFrpRHkAvV6PaDRKq9XCaDRy7949NBqNdOkIo6MwHAy0cUkmk2g0GnlFFl3YarWaYlwOAY1GQyAQYG5ujkAgcKIKqqcJk8nExMQEExMTsgZLzNdUKkU+n1fUDR5DKpWSp3eF4WZg7+2FQoG1tTXZs0QJMB8N/S4c5ebyZGg0GoxGI0ajURrkTCbDrVu3uH///ok2aFJQGBQG9uYSjUb55S9/ydTUFN/4xjfw+/3KlfmQEbGDk+77cNrQarVSqVsU+K6trfFXf/VXZDIZ5WSuoMAAG5dms0mxWCSXyxGPx/H5fDKbQgnmHw4iS0Wkg/Z/KeP8eEThaavVku1li8Ui2WxWzlEFheedgTUuIjVvY2ODf/fv/h0ul4udnR0ikcgjfc4Vvh7tdputrS06nQ5qtZqxsTGi0Si7u7tEIhGlncFjqFarrKysUCgUsNvtGI1G7t+/T6FQ2FdYqaDwPDOwxkWohDYaDT788MOT/jhDSa/XI5fLyayxTCZDLpcjn89TKBSUVOTH0J9Sms/n0ev1JJNJqcemjJuCwgAbF4Wjp9vtSjfO9evXZZV0f1dLhUcpFAp8+umnWCwWdDodGo2GjY0NWVGtGBcFBVD1nnAlKJlEX/B1No9BHb/+CnNRQHnU0jqnffxEoWT/Z+p2u8fmDvu6f5tBGsOT5rTPwZPmScZPMS5fA2ViPhvK+D0binF5dpQ5+GwcqnFRUFBQUFB4Uga2iFJBQUFB4fSiGBcFBQUFhUNHMS4KCgoKCoeOYlwUFBQUFA4dxbgoKCgoKBw6inFRUFBQUDh0FOOioKCgoHDoKMZFQUFBQeHQUYyLgoKCgsKhoxgXBQUFBYVDRzEuCgoKCgqHjmJcFBQUFBQOnSfu56Iogn6Boqj6bCjj92woqsjPjjIHn40nGT/l5qKgoKCgcOgoxkVBQUFB4dBRjIuCgoKCwqGjGBcFBQUFhUNHMS4KCgoKCoeOYlwUFBQUFA4dxbgoKCgoKBw6T1znchh83Tzxr5vXr7Cfg8ZfGVsFBYWj4NiMy8TEBFeuXMFsNuNwONDr9Y+8ptPpEI/Hyefz9Ho9Op0O7XabUqkk/1ssFul2u7RaLbrdLvV6nXa7fVyPMfBotVrUajUul4uRkRG0Wq38N5vNhs1mAx4YlUajwY0bN9jd3T3hT310aLVaNBqNnDNPik6nw2Qy0e12qdVqdDqdI/yUCgrDx7EZl9nZWf7lv/yXBINBxsfHsdvt+76vUqloNptcu3aNjY0N2u02jUaDRqNBJBKhWq2ys7NDJBKh2WxSrVZpt9t0u13FuPSh0+nQ6XSMjIxw5coVTCYTRqMRrVZLOBwmHA4DDwy5MNbDbFx0Oh0Gg4Fms0m73X7im5per8fhcEijpBgXBYWn49iMi06nw+FwYLfbMZvNGAyGfd9XqVRoNBrcbje1Wo12u02z2aTVamEwGKjValitVjweD61Wi3K5TLvdJpPJUK1W5S2n2WySSqVoNBrPpcun1+vR6/UwGo0EAgEsFgs2mw29Xo/f78fn80mDrNPpCAaDjI6OUq1W5Y3xtOJ2u/H5fPvcf1arFYPBQKPRkHOmVqvJeWUwGFCr1ahUqn0/Z7fb8fv9tNtt9vb2qFar1Go1arXavpuz+K9arUarfbCcWq3WqR5HBYXD4NiMi8lkIhgM4vP5DnSJ9Xo91Go1U1NThMNhuUmKjVAYj1arRaPRoFKp0Gq1SKfTlMtlyuUy+XyeRCLB3/3d37Gzs0O326Xb7R7XIw4E4oTt8Xh4+eWX8Xg8jIyMYDab5a2m3W5TqVSoVqu88cYbeDwe7t27x3vvvfdUrqNBQqVScfnyZf7wD/8QrVYr55PD4cBsNlOr1cjn81SrVe7fv082m2V0dJSxsTE0Gg16vX6fcfF6vUxMTFCv17l9+zbpdJqNjQ02NzepVqtkMhmazSbZbJZKpYLRaMThcNDpdMjn8zSbzRMcDQWFk+fIjYtarUatVqPX6/edFB93sjObzV/5nuLm0mq1cDqdVCoVSqUSmUxG+so1Gs1zeXoUBlmtVmMwGDAajdjtdqxWKxqNBo1GQ7vdRqVSoVarCQQClEol0uk0ZrOZer0uT+OnDafTyfT0NHq9nl6vh0qlwul0YrFYqNVq5HI5yuUypVIJo9HI+Pg4U1NTaDQaOS8FXq+XyclJGo0G1WoVq9VKs9mkUqlQqVRkvE8YY6vVisPhoN1uU6/XZczwNI7jSaHRaGR8UNwm2+22dGcqrsmD6b91P3wDf/iArVKpZBxSjLMY216vJw/yh8GRGhe1Ws34+Dh+v5/p6WlMJpOcPM+CRqPBbDbT6XTQ6XS0Wi2azSb1eh2n04nf7ycej0tXxvOE2NCWl5f5b//tv+F2u7lw4QI+n4+ZmRlmZmYAZBzm4sWLTE5OMjY2ht/vJ5VK8f7775NMJul0OqdqQbvdbubn56VxATAYDPK25vV6aTabBINB6vU6NpsNu90uXbL9i9JoNGI0GtHpdLzwwgtMTEwwOzvLa6+9RrPZJJ/P02q1KBaL1Ot1jEYjVquVYrHIRx99RDKZZGtri93d3VN7yBEb1XEZyJmZGV555RXsdjtTU1OYzWY++eQTbty4QaFQYGdn59TerI8KlUqFw+HAZDJhMBiwWq1otVoMBgMqlYpYLEYikZB/S6PRyOXLl+V6D4fD8jafz+e5desWKysrh/LZjty4+P1+5ubmCIVC6PV6NBrNobyviNkcdNMRrpBWq/XcGRfhTtzd3aVUKuFwOKhWq4yOjmIymZicnJQndYPBwPT0NL1eD7fbjdVqZXt7m+XlZbLZ7Kk7LVqtVkZHRzEYDHIcDmJycvKJ31On08kkCEG73ZZxPhG/0el0GI1GUqkUnU6Hra0tKpUKkUiEbrd7Kg2MOASqVKpj+fyhUIg333yTYDDIq6++itPpxGazUSqViMVixGIxxbg8hFqtxmKxyLHyer3odDosFgtqtZp2u00ul5OeCpvNxoULF3jxxReZnZ3lwoUL5PN5fv3rX7O3t0cmkzkdxgUevaYdNSaTibNnz6LVarl9+zbFYvHYfvcgITY+tVrN2toauVyOXq9HJpPBZrMRDocxmUz4fD6sVqvcmDUaDVeuXCEQCLCxscH29jbdbvdUGJlOp0Oz2UStVh/KIeZxiOC9uO202200Gg06nQ6bzcYLL7yAx+NBq9Vit9tptVrShbazszPQiRNWq1Um3YgDYT6fl+7EeDx+6HNB7A9iPrrdbrRaLSqVCr/fz+LiIjqdjrt371Kv1587V6NGo8HlcslbuF6vR6/X43Q6MZlMhMNh3G43JpNp380FHsRex8bGpAvMbDaztLTE2NgYbrdbHtTD4bD8r9/vp9FoUCqVnmmsj8W49J+Ajhqn08nv/d7v8fLLL/Pf/tt/Y3l5eWAX8lEiUm9FLEqtVvPee+9ht9sZHx/ne9/7HsFgkNdeew273Y7X65UxC5vNRjqd5q//+q9JJpNycxz0cRSJCr1eD7PZ/Mzu18ehVqsxmUzA/iJUlUqFyWTiu9/9Lp1Oh4sXL7K5uUmtViObzZLP5/nbv/1bCoXCIz87KHi9Xubn5xkZGeE73/kODoeD1dVVIpGIvNEetjdA7BFOp5OpqSncbjdGoxGVSsXc3Bwmkwmn08m7775LuVwGeK4MjPAwuN1uHA4HDocDj8fD2bNnsdvtzM7OyizJhw/ziUSCVColD1xarZbR0VEcDoc8HJnNZi5cuECtVmNtbY3NzU0ymQy1Wu2ZElOOLVvsoIXeaDRkEaRI8XwcKpVKJgU8/O/9waxarSYzhZ63znEqlQqbzYbRaJTB+16vJ104YqxNJhPRaFSm2RoMBsxmM3a7HZ1Oh8fjQa1Wy8lcrVZpNpsDf3splUpEIhEsFot8Fp1Oh1arpdPpyBThLwu0i0Cn2PBEAPSguaRWq9HpdPtuSSIeKFyNIn1ZJFdYLBZ0Op3Mfhw0DAYDdrsdl8uF3+/H6XTKE2w6ncZoNO4Lsj8rIg6g1+uxWCwydiD2C2FYREKKWq0e+Hn4NIj9qz+pRK/Xy9i0RqPBYrHIm4bdbsfhcOByuQgGg9hsNjweDy6XS75n/9+l2WzK3yFu3CI9X9AfZjCZTPL3PyvHKv/ST6/XY319ndu3b5NKpbh27RqlUunA14rBmZ2dZW5ubp8x0ev16HQ6OXCNRoO9vT15hX+e0Ov1fPvb3+bFF1/EZrPh8/moVqt88sknJJNJdnd32dvbIx6P84//+I/o9XreeecdXC4Xr7zyCn/0R3+EyWRiZGSEQCDASy+9RDabJRaL8fHHH1OtVk/6ER9Lr9fjww8/lIH68fFxLBaLTCjJ5/NEIhHq9TqZTIZ6vf7Ie4jsMlGHZTab0ev1eL1ejEbjvtcJ5YOJiQk8Hs+B7+X3+7Hb7dKwZbNZPvzwQxkPG0T3mMvlYm5ujrGxMWZnZ3G73fj9fsrlMjabjfv375NOp0kmk4cyH7RaLdPT04RCIRYWFvB4PFgsFmnQxd9jY2MDvV4/NIdG8Qwi9ul0OllYWMButzM5OYnf78dqteJyuTAajXi9XllOoNVq0ev12Gw2tFrtl2bY2u12eQvs/50PIwyZyC6tVCrPfPM/MeMCkM/n2d7eZnt7m3fffZdcLvfIa/qtrrgSCzQaDSaTSQ64Tqej2WwSj8dl7cvzhEajYWxsjPPnz+N2uxkbG5NV+EajUZ7sa7UamUwGgEgkgsFgwGaz8Z3vfAeNRoPD4ZAFlmNjY7RarUM5yRw18XicTz75BJvNRj6fx263y1TMRCLB+vo6lUqFaDRKpVJ55Of7DYLJZMJut8sCTIvFIl8nDjIGgwG/3y9vQf2HHniQbNK/8I1Go9wsB7EORrj13G43brcbp9OJy+WSyTFbW1s4nU5Z33MYCHdYMBiUG2l/HZzYfIXBGSbjolKpZOmEzWZjdHQUr9fL0tIS4+Pjclx0Oh1WqxWdTnfg+3wZ4vb+uNeLw03/DUrsp8/Kie4YosJZ+PQf58sVD76+vk61Wt23iPsDq1qtVsYZWq0W8Xh84E6GR0mn02F1dRWdTidTv9VqNRcuXGBhYYGZmRmWlpZIpVJcv36dSqVCrVajUqmwvr7Ob37zG0ZGRnjrrbfwer2nbuzq9Tq5XE4qPBiNRqLRqKyFSqfTNJtNSqUSjUbjkZ/XaDSkUimZpi1S5+12+yOFv+LmItwVwWCQmZkZ6cI46DSp0WgIBALMzMywvb0tM8sGnX7fvNvtptlsHrjRfR263S7FYpFkMkmhUKDRaMixfTg1fHx8HJVKxd7enoxbnUYMBgMzMzO4XC5mZmaYm5uTxsVsNhMIBHA6ndKoHlWCSr8KSqFQoFwus7OzQzQaJZPJPHNc68SNi6i6r9VqX3nNXl1dZW1t7ZF/f5w1Pm2b47PSbrdZXl4mnU5TqVSYnJzE4/Hw0ksvYbfbiUajRKNRVlZWKJVKJBIJtre3KZVKbGxs8Itf/IKZmRkuXLiA1+sF+NKU3kGjXq9Tr9dlfv/Dwc0nnRcPz6eD/r/IvhE1Bi+++CLf//73CQQCuN3uxxqXYDDI7Ows1WqV5eXlU2FcxClWyC81m80DVTa+Dt1ul0KhgFqtJpfLUa/XpZu7f0O1Wq1MTk6i1WrJ5/On2rgYjUaWlpaYmprijTfekB6D/oD8cdzOREp9tVple3ubQqHA9va2lDt61rl5pMal1+tRLpdJpVIUi0UZBHycMeinP8us/3XPq+F4Enq9HrVajUKhQCwW4969ezKt0+120+l0ZJHp9PQ0ZrNZLlRRyyAqdQEpmVIul09Vds6zzpEn+TkxP4ViciqVYnNzU4qqHjTP4QvFikFDPI9w3VkslkdOy2L9HfaBo1/i6XHvrdFosFqt2Gy2Q7s1HTciOcHtdjM5OcnU1JSsS/myjNrDHmuR2JNKpYhEIpTLZba2tigWi8Tjcer1Os1m85l/75Eal263y87ODul0mnA4TL1el77Tr/xgfVWmAjEBFSXkg+l2u2QyGfL5PNlsljt37uB0OvnGN77ByMgIr776Kq+88opseSCCstls9pEgX6/XI5lMcvfuXTKZjFK89hDCEJfLZdRqNXfv3iWZTDIzM8Orr75KKBSS2U2nAZGm6vf7eeGFF6RbBpBFoELXr9FoHNphQ0iOCPf44zL5TCYTo6OjwJNJRA0igUCA1157jVAoxD/9p/+U2dnZI02ZP4hOp0MsFiOXy3Ht2jV++9vfks/n2drakrVM4nA00G6xXq9HvV6n0+lIifxOpyOvgGJCGwwGTCYTZrN5X0aDxWLZZ1yEf7DT6cgJ3n/aOU2n66NCpImKmg/hR2232ywuLtLtdqVCskajkQFmk8m0Lw201+tJLa3nsXDtSREJA0JMVdxkHncCH8SCVHFrEdlCNpsNq9UqNz2xtkQ6+2EaFzj45vLw2PVr5Z0Wg/0wRqMRv98v1cm9Xu8jSSAC4Ul4eDzEfOuXLBJJDv3B+YcR3+t0OhQKBZLJJLFYjO3tbfL5PLu7u4eeDXrkMRfRc6VarVIoFDAYDPLkHAgEuHjxIuFwGLvdLk+BarUar9crRQUF2WyWbDZLsViUfsFIJCJdN5lMRnGX/f8RC7ZUKnHjxg3W19fpdruUSiWZkWK327ly5YosrBKpoG63+6Q//qljZmaG7373u4TDYYLB4IG1MSJ4nUqlKJVKAzNXRZaYyBQLBoMy7VW4Wuv1OpFIhLt375JKpQ4tE1O8v/ivODwOytgcJiLdOBgMSuN9kCEQ/9btdmV9mVCBTyaTpFIpqb8m/m5C1ftx4yYOQPl8np/97Gd88MEHpFIpdnd3aTabR5K9eOTGRVjaZrMpC8osFotsxjQxMYHX68Vut9NoNKQrYXx8nAsXLuzzr4qAdDqd5vbt2+TzeZlZAkg9LIUv3Da1Wo2trS2Z7aNWq1lcXOTy5ctYrVZmZ2dptVpMTExw5swZKQWj8HQEg0Fef/11WXh40OlabKClUmmgFA9UKpW8FVitVpxOpwzY999gc7kcu7u7h5aGLBAu10ajcerEUp8Gk8lEKBQiEAjs89L087CisXAXijmzu7vLxsYGfr9f3nz6XdqPMzDCrVmpVPjss8/4+c9/fjQP2cexZYvl83nu3r1LLpeTLjARPBQS+e12W1pzUSXej8lkwuPxYDAYZPtZn89HNptld3eXO3fuUC6XZefK0yoYeFSIYLM4KWo0GsLhMGq1Go/Hg9PpRKPR7OtVIjSxlHF8FLGwdTqdrAlxOBwHxhRFbCGbzRKNRikUCgMzplqtVm56DzdbE983Go24XC7Gx8exWq3Szf0sv1OcuMfGxnC5XJw/f14qTJxW19dX8VXJJq1Wi+XlZaLRqFyvzWaTdDpNrVaj0WjQbDZlYaROpzswI1L870KhQLFYJJfLsba2RiqVOrbi8mMzLvF4nHfeeYdwOMzY2JgUTLRYLPR6PcbGxva9/qDcbqfTid1up9frMT8/Lyuf2+02d+/e5erVq0SjUX7xi18QiUSU9rQPIepASqWSbFdw5swZXnjhBTne5XKZO3fukE6nZSW5MEYK+1GpVLJXTiAQYHR0dN+pXyBukY1Gg93dXe7duyfdxYOAwWBgaWmJhYUFpqam9m3sQp5Fo9EwMjLCxYsXpYF8FteYxWJhZGQEm83GG2+8IZXTheDnMBRKPo4vW0uNRoO3336bt99+m3q9Trlcpl6vE4/HqdVqzM7OMjs7Kw2wUC046H17vR7RaJT19XXW1tb4h3/4BzKZDDs7O0f6fIJjMy6tVot8Po/NZpMnnv587icpEhJBLPgi915kl3g8HkKhEAAjIyP0ej1yuZw8IT5vm2O/cq+QMfH7/Xg8HilaB0i3Y6vVolqtUiwWiUajxONx2VHxsHSkhoX+Smafzye/RP+Xhxe7EK5MJpOyyd2gGBb44nke12tJfN9qtRIOh6U21bMEgE0mE4FAAKvVKjvU2my2R/rqDBMPB+gfl/AhmvcJ4yIOIqJSX2j+CV27fleYSL5oNBq0Wi1SqRQ7OztEIhFSqdSxdkk9NuNSKpXY3NyUwf3Doj9GY7fbKRaLTExMkEql+NWvfsXVq1dpt9s0Go3naoM0m814vV4cDgdXrlwhGAwyNTXF1NQULpcLm8227/XJZJKVlRUikQg//elP2draIpVKUSgUnst20V+GXq+XLrCf/OQnvPzyy4TDYVmzIAy3SLFdX1/n7//+74lGo6yurg5cwFqsSdH47GHEIWVhYQGXyyUDwM/iFRCtpbVarcxY7DfMw4iIe3yZm1kciiORiMxAtFgsvPTSSwSDQa5cucLLL7+MzWbD7XbvGzOR0VetVllfXyeXy/GP//iP/OY3v6FcLpNIJOTvPw6O9eYi/H9P+nBPWsymUqlkIFr4KDOZDLdv35bBrsMoCjoNiJiVEKDzer3Mzs4yPj7OxMQEY2Nj0s0h2iHDA5dZKpWSFfxra2uKUXkMWq1WNmgSigZC0ffhgGy73Safz7O8vCwzGwdtHvbXsBx0SxVrTMi9K3w9RL+hL3OJiticqCdqNBqYzWZ5OJybm2NxcVHeNB+Ot4i/YyaTkd1Q79+/L8sTjpNjNS7lcpl8Pk8ikSAajWKz2R45QYtrXS6XIxqNHng6Ep3WdDrdI1IbQnDRZrPx4osvksvlSCaT3L59W0oaDNriflZ0Oh0OhwOj0cjc3BzBYFBqWNlsNmZmZnA4HDSbTXZ3d+Xk1Wq1MjWyvzsloCRDHIDRaMRkMjE2Nsb3v/99gsEgi4uLMoj/8EKPx+MyfXd1dZVEInGgYOZJI25XhUKBubk55e9+RMRiMX71q18xMjIi+wE9LG5qMBj47ne/i8/nI5fLEYvFsFqtvPnmm4RCISYmJh4bk0qn06yvr5NOp3n77beJRCInGt87VuMiZMZFAU+v18NqtT5y2hOV5rdv3z7QPyj8tf3S6AJhXDqdDhcuXKDVarGyssLm5ua+fh7DhF6vl7GUN954g0uXLjE6OsrS0pLMfwe4c+cOq6urUh1ZuCSEcelXpFVuLI9iMplwOBzMzMzwB3/wB9IVdlDqdq/XI5FIcPv2be7evcva2trApso3m002NjbY29vjm9/8pvK3PyKEcRFr0+l0AvsVB/R6Pd/5znf45je/SSwW4/79+xgMBqn3J1yUB5FOp7l58ya7u7v87Gc/Y2tr60TjzccqXCkCTVtbW1LXSnQOFEHOYrFIrVYjFouxvLx8oAtNr9cTjUYxGAyUSiUCgYB0AQm5aJVKhcvlYmJigm63y7lz58hms2xvb8tFftoXUX/h2+LiokwVFWncon+78KWvra2xtrZGo9GgUChgMpmkj10EbU+TZMlxIHoGCQXkmZkZFhYWZJzg4bTjfjmTeDzOysoKe3t7A++WFc3LCoUCe3t72Gw2XC7XqdXxGkSEwkGxWCQSieB0OmXZRX+lvkgvttlsBAIBKct/ULJDt9ulUqnQaDSIRqOsra0Rj8dlKcZJcmzGRbhZRJDpgw8+YGpqiunpaemXrtfrrK6uEo1GpVLyQQuyv5/G0tIS4XBYqtL2dyGcmZkhHA6TTqeZmZkhmUzyP//n/+Szzz6TvsnTjM/nkwJ4f/iHf0ggEJBy3ULlOJvN8tlnn5FMJslms+RyOVnA6vV6+dGPfgQ82nhNSMAM8oZ4HIj+5RaLhe9///v8wR/8gWzHazAYHjlFisVerVb5+OOP+V//6389keL3SSIMYq/XY21tjV//+teMjIzwzW9+U56uFZ6dZrNJPp+n0+nwzjvvsLm5yQ9/+ENmZmb2zSPRgyUYDOJ2u+XaPOjG0m632d7eJh6P8+677/L3f//3lMvlQy90/Toc681FTGLRCdBgMKDX62m1WlJue2tri0gk8pU3CzHgoiFUIBAgnU7TarVkAzGj0YjRaKTX6xEOh2WMpj/wfxo3z/4kBp/Ph9/vJxQK4ff7ZcfEarVKLBaTQb1EIkGpVKJcLstTkNlslkE+cWvpb8h0GsfmWelvcSwympxOJw6Hg2AwSDgclu7Yg4olReZVpVIhn8+TTqdPRdW5WG+VSoVYLCYl8MU49OtYHUS/VPyTxuv6X9fr9WTDv2Glv95JHPKy2Szlclm2cBfzT9xgHjce/XqK+XyeeDwuD5DPWuB6WBx7P5dOpyO1wCqVCru7u9JdJkTVnmRyCleaUF1OpVKsrq4SDof5i7/4C2ZnZ+WiMJvNTE5O4na7+d73vkc4HObmzZu89957A/FHeBqEDpRer+fChQv80R/9ER6Ph7GxMXQ6Hffu3WNvb49bt27xq1/9ilKpRCqVkrpNj0O0Us3n89I4n0SGyUki2upaLBYcDgehUAin08lLL72E3+9ncXHxK/3etVqNu3fvEovFiEQij1X5HTTExre6ukq1WsXtdrO8vIzD4ZCxJYvFgtvtPtDAiBoMUYh7UEpzP2KDFXOs0+kwMTHB2bNnT0XX02eh2Wyyvr5OLBaTXUlDoRCvv/66lA4SBuartMKKxSJvv/02v/71r0mlUlQqlYEp0D32v6LQV4IHtS+xWOxrv1e325Vilul0mo2NDebn5/nxj3/M5OSkjCOIgLfFYmFpaQmr1UqhUODDDz88dZunqMo1mUxMTk7y8ssvYzabcTgc0s9/69Ytbt++ze3bt79ykQvE5iCy8DQazcCftg8bob/mcrkYGRlhfn4en8/H66+/ztjYGA6H4yt115rNJnt7ezK2d1qy7sRnTCQSpFIpbDYbmUwGu93OmTNnGB8fx+VyEQ6HD9z8hYdAyAd9VfW+aDct0m3b7TZarZYzZ84cyfMNEqL/jzjMGAwG5ubmuHjxIna7/RGFhMdphYlmX3fv3uXdd989zkd4IobmiCCCZclkkrfffputrS0WFxeZm5vbFxALBAJoNBq2traYmZmRKrWnJf5iMpm4fPkyo6OjUmiy0Whw8+ZNisUi165d4+bNm0QikacynCK9WxSzDXOltECkFlutVkZHR7FYLExNTcm4VSgUwmazEQwGv7IPUblclmnvu7u77O7uYjAYmJ+fp1qtkslk5Cm92+3K2KBKpZK3m3K5/NhW38dFf4V3Op2WRiKRSEjDe9DNxWg04na70Wg05HK5rzQu9XqdfD4PPJB1slqtAyXmeRz0ej0ymQwrKyt0Oh1u3bpFJpNhbGxsXyfYx/2suPEZDAbsdjvNZvOJD5PHwdAYF6Extru7y3/5L/8Fm83Gn//5n+NwOKQKs06nY2pqivHxcXK5HCsrK7L24LQYF5vNxu/93u/x8ssvMzo6itvtZmtri9/85jfs7u7y7rvvcu/evaduqCbGR/SLfx6yxqxWK36/n3A4zPe+9z38fj9nzpxhbGwMvV4v9ZvEWHyZsc3lcty7d494PM7du3eJRqO4XC5efvllUqkUN2/elP1eut2uLMBUqVSyM+De3t5AGJder0e1WmV3dxeVSsXm5qZ00zxuTohWGqIN8VclMIjfo9freemll5iYmBioNgTHRTQaJZFIkEwmZUzv29/+Nl6v90vHQigmdzodLBYLXq+XYrE4UEokQ2Nc4AtrLoQZc7kcuVyOXq+Hx+ORMRiNRoPdbmdkZERq9pwW1Gq1jAkIV0Sj0SCVSsmg/dfRDmo0GrLItdlsnhp3zpPSn2otDhuhUIhwOMzIyAgjIyN4vV5cLhdWq/VLg6n99De5Eg3uAoEAarUal8slE0jq9bpsvNZutwkGg0xOTkrXbr1eJ51OH8NIPDnCb/8k7tFWqyWzDJ8k5iLoL0N4HrMTRV1f/6324XE4aExUKpVMgBCty1UqFfl8fmBc/UNlXOAL4TdR1/HJJ59IFeb+U+jU1BQ//vGPWV1dlam6pwG1Wo3dbsfj8aDT6ahUKiQSCT766CM2NzfJ5XJf6313dnb4+OOP2d3dJRaLSTWDYUGv18sOi1euXCEUCrG0tMS5c+eku0d0RBVy5l+FKPYV2T5nzpyh0+mwuLhIq9VCp9NhMBhkk6b+zqkmkwmLxUKhUODTTz+VDcS2t7ePYTQOn3a7TbFYBJ7MGCnsR6vVSnmdh1W1H/d6m82GVqvl1VdfxeFwcO3aNeLxuHRtnrShPjHj0p+62G+pn3VA+nP2RTzFbrc/oplks9kIh8OUSqUn+mMOCiIFW8i0iHqgdDpNMpl8ooUt3Bv9Lo5yucze3p7shTMsSsjiMCFuFU6nk7GxMSYnJ3nhhRc4f/78l2Z/fRmikVa1WsVgMMhMH5/PB3yR1ixOpv3zXNyiMpmMTGo5rb3h4YsbiMLTI27VomHbQXOxfy32pyr3ej18Ph+VSoWdnR10Ot3AqG4fu3ERfdtF8yGfz0etViOZTNJoNGT9iagYflIr3N9TWnSnFKnNpVJp39UbkPEFkT456PT7vMX/rlQqsmDqadrDWiwWqUEmWiBEo1E++ugjkskkxWLxVBsWkVGn1+tZXFxkYmICn8/HzMwMVquVqakpHA4HgUDgsTLzT/p7xFwWm0L/jae/6lrMMTGu/QKj4+PjmEwmWbF9msde4emwWCxYLBZCoRALCwtMTEw8UrgqagOFiKXJZEKtVss5Nz4+jtPpJJVKMT4+LiW2Tjq4fyLGxeVyYbfbmZmZYXZ2lmKxyO3btymVSrKoqN1uU6/Xn1iZt7/YS3QHFHIWwsXT/z56vV6m3p4W4/KwEqrIQsrn8091WjGbzUxPTxMKhbBYLLTbbZLJJNeuXZOSPKcZsfDMZjMXL17k1VdfZXJyksuXL+9zeT1rNpyQ6HhYfPWg1z1ujhkMBkZHR2V7YYXnCyHfFAwGmZ6eZnJyUhZCC1qtFul0mmKxiNvtxu12S++F6CYLsLm5yejoKHq9XiqenCTHblx0Op0Mok5PTzM7O0u1WsVsNsv+4rVajVqtRrFYlH3gv8rdI1qxCoVgg8Egf8/4+PiBJ8vThJBsEW2hRbD5aZp5iQnp8XiYmppiZGQEgEwmIzNNhqGlsUajwWazYbfbCQQChMNhGaM6iQy4ZrNJoVDY1zm10WhQq9Vke4hKpUI6nT71Y39U1Ot1otHoQGTUHSb9grGiBEDMUVHNn8/nZSaiiMsIPUGhFiESVYLBIPDA0Jw0x25cLBYL3/zmN7lw4YLUxYIv+q2Im0o2m5WCf/l8/itThUXdgNlsZmxsTBYDiowKi8Xylemkg4zD4WBhYYGxsTHcbjcmk4ler0epVHpikToh7rmwsMB3v/td/H4/sViMe/fusbOzI7OZTvsGZzQaGR0dxe/3c+HCBV555ZUTlRYpFArcvn1bZuNVq1USiQQ7Ozu0Wi0qlQqtVot79+6dyOc7DWSzWT788EN2dnZOTfLNkyA8KGazWbpX+3ssZbNZdnZ2+Ku/+itu3rwpxWrPnj3Lv/k3/4ZQKCS177xeLy+++CI7OzvcvXuXTCZzos927MZFrVZLxVWn0yn9zA9jsVhQqVQ0Gg1ZKPhl9BuXcDiMxWI5qkc4EfrdYuJ087Du00H+ehH402g0UqxSdKi0Wq3UajWZwjwsvW5E0oOoVTnKuSDGqz8TTKSUivRS0WJCFFpWq1Xi8Th7e3u0Wi2Znnza3ZFHiSgxKJVKA5NqexiIdtni9iEMi9j7crmcbPyVSCQwmUyYzWZyuZyMs4rXi0P0oLj6BzYV2WKxMDY2Jl0JT+IWEzcVkUn1ZfTfkgYhs+KrEEbAYDBQLpdpNps4nU4WFhaoVCo4HA6y2ax0kwljZDKZmJ6exul0cuHCBS5cuIDP50Ov11MoFHj33Xf54IMP5Cl6GOiXvRexNmF8D/v31Go1ufGl02kqlQpbW1uUy2U2NzfZ2dmhWq3KpAshdSLqXoRROuz238OGcI+L8R4GhPjs6OiorMMT/w6wtbXF3/7t3xKJRGTbY7vdjt1ul8Xhou2DMC7iBjQIBdADa1zEyfMoOU09XVqtFsViUcZG2u02JpNJxlCE31YsPJFZptfrZWfKpaUlrly5Ik9J1WqVtbU1rl27RqVSGZr6BCHCKDZt0c75KFyiwi9eKBSIx+Pk83lu375NOp3m888/59atW/IzDMOt8KTodrs0m82hiAn2YzQaZf3Vwx0mM5kM169fJ5lMypidEOIV671fil+s95OKLT7MsRsXUeSYy+Xw+XxHuvAPQrgsNjc3uXPnDhsbG7L4a5Bpt9tSSbrRaMhxE8bj93//90kkEtTrdZrN5j5F6Pn5eVwuF6FQCHggVXL79m0Z16pUKqe2/cBBNJtNORa3bt3C7XbjdDpl24WH+7AIY9TfrE68rtfrUa/XpXad+MrlcvuC8blcjkQiQbVaJRKJUC6XSaVSz23lucKTUavVyOVyFItFmZgj9kK/388rr7xCPp9nZmaGarXKyMgIwWBQph/3GxJRhBuJRE48UwxOSHI/l8sRj8dlO+KjcFkchCh6a7fb3Llzh//xP/4HqVTqxANfT4I4tQl5lna7jdFoxGAwMD09zb/+1/+aZrMpbzUiJqPX6/H5fBiNRvL5vBRX/PnPf048Hmd5efnU17U8TL1eZ2dnB4PBwPvvv0+1WmV2dhaj0Sjrmh42LmJ8o9EoqVRKFlx2u13ZayiTyUgV7uXlZdkuOpfLUalUZLsIYVBOi8tV4WTo9XqUy2Xi8Th+v196DoSBGR0d5Uc/+hH1el26A30+Hz6fD4PBgMvlkrcd0YhRZJUNQkbdsRuXdrstJb19Ph/BYFA29jroKidO32IQn8YIidOoCJq2Wi0ymQzVapXt7W1SqdRAafF8FaIKWijvut1uXC4XvV4Pi8WCyWSSBaj9Vfgi/TUejxOJRGTzsHQ6PRTZYQch/u65XI5IJCI7+wldtv64nHBtif5AmUxGtjEQxkWkhObzeQqFghQ8FadOcaMZxrFUODr6i8Qf1hMTzRBFzVan05EK0v3Fv2KfE6Ucok7wpDl241Iul/ntb3/LRx99xJ07d7h79y5Wq5WRkZFHiofgQcHfmTNnZOHQ08RhqtWqdMGtrKxIHafd3V2i0SgbGxtSPuW0UC6X+cUvfsHKygoXLlzg0qVLWCwW/H4/er1+3yRVqVSUy2Vu3LhBKpXi008/5bPPPqNYLLK7uytPRMNKp9Ph7t27bG5u4nA4+PWvf43BYJCHFYEw2u12m3Q6LSWBLBaLPF2K26KI5YjaK/FzSkxF4bARlfv9sWGRXSYOj2J+1ut1YrEYGxsbUgj1pDkRt1gymZTVzSL7odvtHmhcbDYbo6OjGAyGp+qwJlq2iqr/aDQqeyesr69TKpUoFAqnbkMQrptOp4PX62VycpJOp4PL5Xok/VBsmul0mkgkwubmJsvLy/sKVIcZoS9XLBbJ5/Nks1lZbPuwW0wYDqFQIHoACfn5YR8rhZOlX1tReGeE1+arpPdrtRrlcplSqUSxWJRZiCfNiWWL9Xo94vG4jB3cuXPnwNxsg8HA1atXMZlMTy0w2Gg05OlctPqNRCKyKPO0GRZgX2vnbDbLrVu3ZLOgg5pZ1et19vb2KJfLRCIRmXUyCJPvOBF1JGq1mmq1us8F2++aEO0KRAAfeO7GSuH4EGnpIhGn1Wo9kd6duD1XKhV+9atfcffuXe7du0c6nR6YdO0TTUVOp9NP1MPiMIL9p9GQHES73ZYquuvr6080NsPy7M+CWIxPikh9VVA4SkS8r9lsStfrw4rlj/s5UT/1/vvv8/bbb1MsFmVr7UFgYOtc+lE2x8ejjI3Caabb7VKv1ykWi7LVg6jnAOSpXgSphy22JWqkUqkUW1tbdLtdRkdHcblc+14nYqmFQoFisSjTjkXCioi7DNLYnArjoqCgMJwIHUF44MkQLkuTyYRKpZLSJ7FYTGZCDtIG+qwUi0XK5TJarZZ33nlHtjnuNy4iJthut9nY2ODevXtEIhHef/99MpkMW1tbpFKpgaunUoyLgoLCidJsNmUxYSwWw2q1ytYIsViMRCJBJpMZypuLqIWqVqskk0nUajWxWAy32y1fIxJzOp0O0WiUSCRCLBYjFotRKBQGVl1D1XvCv9RpVRM+Cr7O5FbG7wuU8Xs2vu7mOohjKBqmiTqkqakpGdBWqVRSTyyfz7O+vn5orp9Bm4Mmk4lAIIDRaCQQCOBwOOT3xI2k3y0mejn1C58eJ08yfopx+RoM2sQ8bSjj92wMk3E5KZQ5+Gw8yfidvLqZgoKCgsLQoRgXBQUFBYVDRzEuCgoKCgqHzhPHXBQUFBQUFJ4U5eaioKCgoHDoKMZFQUFBQeHQUYyLgoKCgsKhoxgXBQUFBYVDRzEuCgoKCgqHjmJcFBQUFBQOHcW4KCgoKCgcOopxUVBQUFA4dBTjoqCgoKBw6CjGRUFBQUHh0FGMi4KCgoLCoaMYFwUFBQWFQ+eJ2xwrjXK+QGk09Gwo4/dsKM3Cnh1lDj4bSrMwBQUFBYUTQTEuCgoKCgqHzhO7xRSGB6vVSjgcxmg0YrFY0Ov1xGIxVldX6XQ6J/3xFBQUhgDFuDyHBAIB/sk/+ScEAgHGx8fxeDz8wz/8Azs7O1Sr1ZP+eAoKCkOAYlyeI3Q6HTqdDpvNRjAYJBAI4Pf7cTqd2Gw2JWCpoKBwaCjG5TlBpVIxNjbGxMQEZ86c4c0338Tr9VKpVGi32yf98RQUFIYMJaD/HGG32xkbG2N8fJzx8XHC4TBWq5Ver/e101uHGZVKdShfCgpHwaDPNeXmMuSoVCoMBgN6vZ75+XneeustRkdHMZlMdDodYrEYOzs7JBIJut3uSX/cE0WlUmEymTAYDLjdbsLhMFqtFp1Ot2/hajQatFotWq0Wr9eL1WqV32u32+RyORqNBpVKhXK5TC6XY319nXq9TrvdVgy5wtfG5XLhcrlwu92cO3cOs9lMuVym0WgQjUZZWVmh0WhQKpVO3COhGJchR61WY7FYMJvNnD17lh/96EeYTCbMZjP1ep1IJMKdO3eIRqOKcVGpsNls2Gw2FhYW+MY3viHHSqPRSAOj1Woxm80YDAaWlpYIhULyPWq1Guvr6xQKBWKxGIlEgrW1NdLpNN1ul16vd+KLXuF0olKp8Hg8zM7Osri4yL/6V/8Kt9tNPB4nn8/z4YcfUq1WyefzNBqNE59nA2tc9Ho9FosFrVYr/2s2mzGZTE/8Ho1Gg2azSbVaJZVK0Wq1aLfbz9UmKoyL3W7HYrFgNBpRq9VUKhU5LrFYjHw+/9yMi0ajQa1WS8Oh1+txOp3o9XrcbjcWi4XJyUnGxsYwGAwYjcZ9xkWj0WA0GtHr9VitVgwGw773dzqdaLVaer0eOp2OVqvF7Ows2WyWvb098vm84opUeGK0Wi1OpxOj0cjMzAyLi4tMT0/jcDiwWq1yvoXDYRYWFkilUuRyuRPP/BxY4+LxeHjhhRdwOp0sLS3h8XiYnp5mamoKlUolF2a/u6J/sfZ6PWKxGMlkkpWVFf7v//2/ZLNZcrkctVrt2J/npNDr9YyPjxMMBhkZGcFsNlOr1djd3SWTyfDRRx/x7rvvUiwWT/ykcxyo1WppUGZnZ5mbm2NkZIRvfOMbOJ1O6RYzm804HA7UajVq9YPQpJhr/T5uo9G47/11Oh2jo6N0Oh0mJydpt9vE43HC4TCpVIqf/vSnXL9+nXa7TbPZPPbnVzhdqFQqrFYrr7/+OqOjo3zzm9/ktddew2w2S6NiNBrpdru4XC5mZ2fZ2NggEomQyWRO9LMPnHHRarWo1WpsNht+vx+3283ExAR+v19uBg/Tb2z6/7/dbsfhcNBoNPB6vbTbbarVKvV6/bk4NapUKrRaLQ6HQ57INRoN3W6XcrlMsVgkm82SyWRoNBrP1Zjo9XpsNhs+n4+RkRFmZmbweDwYjUZ0Oh0ajQadTgcg3Vni53u9nvy3ZrMpjYRard73/v0Hn8nJSWmwdDrd0I21SqWSzy/GZtie8bgRBxidTofP5yMcDjM2Nsbk5OQjMUB4cCBXq9U0Gg3p7en/Oxz332SgjItWq+Xs2bOMjY0xPz/P66+/jsViwe12YzAYqNVqfPbZZ48MUL9x0Wg0mM1mdDodBoOBiYkJzGYzZrOZVCrF3/zN33Djxg0ajcZQ32DE6TsQCPDqq68yPz/P9PQ0KpWKSqXC2toasViMVCpFtVp9rlxiLpcLm80m/6vT6SiVSvJQYzab5UJsNBpsbW1RqVSAB3OtXq+TzWZpNpsUCgVqtRpGoxGz2Yzdbuf8+fO43W4cDgc2mw2LxSLdGJOTk/JUGYvFTv24q9VqNBoNVquV0dFR9Ho9qVSKYrFIs9l8bg5yR4FWq8VkMuHxeLhw4QLnzp1jbGzssVlher0eu92O1+tlfn5ejn+r1aLRaEjvRKPROBYljoEzLpOTk7z44oucOXOGt956C4PBQLPZpN1us7a2xtra2pdOVp1Oh9vtxmg0Mjk5SSAQwOPxMDExQTqd5saNG6yvrwMM9cTXarVYrVY8Hg+Li4tcuHABl8slN8doNCr9/8+Te0atVmO1WnG5XFitVkwmE1qtlmq1Kk+JWq2WTqdDq9WiVCqxurpKKpWSi7pUKkk1g1gsRrFYxGaz4Xa78fv92O12ut2uLFg1GAwEg0GMRiMjIyMEAgGazSbxePyER+PZUavVMi46OTkpXTTCxVqv10/4E55ehHFxOBzMzMxw5swZzGbzY1+v0+lQq9U4HA7C4TDlcplKpSK/hCu23W4/P8ZFpVKh0WgwGAyEw2HOnDmDzWZja2uLVqvFzs4OpVKJaDRKLBb70vfSaDTYbDb0ej1TU1NMTEzgcDiYmJiQG0e/H33YEBugz+fjxRdfJBQKEQgEsFqt6PV6AKrVKuvr63Jcnyc6nQ75fJ52uy0NrdlsZm9vD6PRiNVqlRtkp9OhVquxublJoVCQ71Gv16UrsVAoSFdrrVaTMRaDwYDdbj/BJz0eNBqNTIQ4d+6cVHuIRCJEo1Hu37//xLE8i8WC0+mk0+nIm+HziHCHeb1ezpw5IyWahMsWoNVqUalU6HQ6MtlEeGvMZjNLS0u43W6Z1JROp7l79y6lUomtrS2y2eyRP8dAGBe1Wo3RaMRms3HhwgV+8IMfsLa2xocffkg8HucXv/gFu7u7cqC+7LYhDJVGo2F2dpbJyUkuXLjAv/7X/1pm+AgLP4wI3/fs7Cx/8id/QiAQYH5+HrfbLSdtLpfjgw8+YH19nVarddIf+VhptVpEIhHUajUbGxvyoCEWaH8xmnCNPVyb0uv16HQ6+2IvYtyTySTz8/M0Gg08Ho9MQBlWdDodFouFsbEx/vAP/5BQKMT169fZ3Nzkk08+YX19/YmNi8fjYWlpiXq9zvXr159b4yKyGWdmZvjjP/5jgsEgExMT+ySa6vU6u7u7NJtNuac5HA4CgQBut5vf//3fp9Vqyfm9vr7OP/7jPxKLxSiXy8+PcYEvrLUY2GazSSqVIplMkk6nSafTdDqdJ7rOiQHNZDKYzWYKhQK9Xk8GHAexmvUwUKlUsv7C5XLh8/lkvKrfmIrNsT9Q/Twh5tFhGlYR9xPzTK/X70tfFoao3zUxDGMv1powMjabDavVisViwWAwPNE6E4c9u91OMBikWq3Knx2GMXoaVCoVer0eg8GAw+GQSU39YykSSUQ9i81mw2g0yr1Ro9FgsVjkXNRoNDJt2WQyHdvBeiCMi9js2u02mUyGaDTKvXv3uHr1KplMhnQ6/VSLUWyauVyObrfLxMQE7XZbZlUMK1qtlqWlJaanp7ly5QoLCwtyQvVjNBoJh8O0Wi2SyeRz5xo7CvR6PWazGZ/Px9mzZ1laWiIQCKBSqeh0OvvqrSKRiDzwnHZEzEVk2D3txqXRaAgEAjidTl577TV+8pOfkEwmWV1dle7L5yFFXqDRaBgfH2dkZISLFy9y8eJF7Ha7VIFotVpy3X788cdUKhUWFxcZGRnZZ1BERmJ/xpnVasVut0v3+FEzEMYFvjAw1WqVQqFAOp2WAedarfbUWTW9Xo96vY5arX5usqHUajVer5fJyUlCoRAul0salv6NTGT32Gw2crncSX3coUIEX61WKz6fT8a54MHYt1otaWCEXMcwIIxLv1sRvripfRWijsPtdhMKhZibm5OKEhqN5rnrL6RSqbDb7fj9fvx+/yPyQuKgUqlUSCQSlMtlwuGwLLXof5/+tHmRIq/Vao/NazMQxkUsvmq1ynvvvUcmk2F9fZ1sNkutVvtaE0z8kXw+n8z/HlbEycRisTAzM8NLL73E+Pg4Wu3+P2+hUKBQKLC3t0c0GiWRSAx1OvZRI+RijEYjc3NzXL58mZGRESYnJ3E4HLJyv1AocO/ePRKJhPR5t1qtU39zUalUBINBzp49y8LCAhaLBZVKRbFYfGLVB51Ox+LiIufOnWN2dlZuniKj6bSP0dOi0WgYHR1laWmJ0dHRfWu41+tx8+ZNPvvsM9RqNUtLS+j1eqanp/H5fDIm0+12qVartNttNjc32d7eZm9vjw8//JBMJkMqlTqWZxkY49Jut6lUKvzud7/jgw8+kLnZzzK57HY7o6OjeDwemWUxjIiECIvFwtzcHFeuXMFsNj8yMfP5PLu7u2xvbxOJRIjH48/d4j1MRNqny+XipZde4s/+7M9wOp2EQiEsFot8XT6f5/PPPycajRKJRCiXyyf4qQ+XUCjE5cuXGR8fx2KxoFarKRQKRKNRKXPzZeh0Os6ePct3v/tdKaYqBD5FXPB5Qq1WEw6HOXfuHOFweJ8rv9vtcv36df7rf/2vLC4u8m//7b8lFArhcDj2ub7FXlqr1fj000/53e9+Rzwe5/r161Sr1WO7NQ+EcREII9Ptdp8p2Cyufx6PR9a6aLXaoZ2oJpOJsbExPB6PrPHRaDTSP5tIJKhUKmxvb7Ozs8PGxsZzU5F/FIj6FaPRyMLCAqFQiJmZGRwOh3TniNNjtVolHo+zu7tLLBaTxZjDgijys9ls8jaWy+VIpVKUSqWvXHMiiUcoT/ffWJ7H+SmyDoWrER64wkTKe7PZxG63Y7fbMZvNGI1G6eoql8vk83mq1apMn19ZWSEWi8nU+eO8MQ+UcQFk/cHXHQCRKWE0GnnxxRf5J//kn+Dz+TCZTEO3sAVer5cf//jHjI2NcebMGSl5UywWSaVS/PVf/zXr6+tsb2+zvb1NvV4nn8+f9Mc+tYgqfK/Xyx/90R/9/9o7z944z+z8X9Of6b2THFaRIlUtyZJrvFrv2o5fLBbZLJCOAAkS5CvkawTIyyRAsot9kcRxsuuq/a+9alaXKIpi5/Th9N7L/4VwjocUJcsSRQ6Hzw8gZJMUNXPzeZ5z3+dc5zp45ZVXuGGV0q+NRgPr6+tYW1vD3NwcPv30U6RSqb5ad+rFmJmZgVqtRrFYRKVSwcOHD3Hjxg0Ui8WnprRJyaRQKKBUKjcF5F5w9d0ryD6IgkalUsHdu3exsbGBWq2GmZkZjI+Pw2q1wmAw8DUXCoVw5coVRKNRfPLJJ4hEImxQSyfC3QzaPRdcALzQm+9OEZnNZjidThgMBs5F9tOuiHY5Go0GbrcbHo8Her0eMpkMnU4HlUoFhUIBoVAIq6urCIVCCIVCfDLc7udR4a+7X4hot9sH8qbvlsnL5XL2JHO5XDzdk75GD8h6vY50Oo1YLIZ4PI5UKoV0Ot1XfUU0K4h8rGiGTaFQQC6Xe2pPGl27FGDkcjm7lu90Eb+7uN3r9z2tS7fyrtVqIZ/PI5PJsGjHZDKxhLter6PVaiGTyXDz6vr6OkKh0J6+l54MLs8L9XkcP34cLpeLi2KdTodv7kKhwDf/fsdgMMBsNmNsbAwnTpyAz+eD1WoFACSTSdy5cwfhcBjz8/NYXl7mjt7toIeERqPB8PAw9Ho9hoeH4fP5OF1ZLBbxf//3f5ibm9vNt7mnkLJOpVJhfHwcY2NjcLvdeO2112A2mzEyMsKuD8Cj4v1vf/tbRCIRzM3NYWFhAel0Grlcrm96W4BvU88KhQIKhQLVahWrq6vcSkAKzSe9X9oEknx7YGAA2WwW8Xh8R18n+cWpVCpW6vUi3R32Op2OU6y0Ka5UKigWi3xP6nQ6SCQS5HI5XLt2DWtra1hYWMA333yDXC7XEyrQvgouANhTbHh4GAMDA7BYLCiXy8hkMsjlciiVShzp9/uNrtFoYLPZ4HQ62eoGeHTyKxQKWFlZQTgcRigU+k4fq24d/MTEBBwOB06fPo0TJ06wgWMqlcKtW7cOVHChDQsp8c6dOwev14vXX38dBoPhsd6OcrmM27dv4+HDh3jw4AEWFhb28NW/HLpPcfRBzgfxeJxPLU+DejHIbNFisaDRaOy4TLb799dut1EqlXryvqeMgUKh4MwLOWvT/UeuD8eOHWOFbT6fx4MHD3Dt2jWsrq7izp07aDQaPVFf7pvgQrJjt9uN6elpjIyMQK/XI5vNIhQK4fe//z2i0SjbyOzn1A6lE0ZHR/Haa69hbGyMG6jISHFubg53795FIpF4bLfWnfIio0Wv18tNlyMjIzAYDBgaGoJer0en02E1ypEjR1AoFBCLxRAIBHriIn4ZdHc2nz17Fl6vF1NTU5icnITZbOaha+T6QCgUCrhcLpRKJSQSCcRiMTQaDVQqlZ58qD0PNMeGHoJarRb5fB7ZbBaJROK5zSqpkK3T6TA5Ocm1B3rgmkym790ITcPyFAoFZmdncfXq1Z7snekWNgiCALVazc2OSqUSY2NjMJlMcLvdkMlkSKfTuH//PlKpFObm5rC2tsYuJr1ynfVNcKGd9tDQEH74wx9ieHgY2WwWsVgMN27cwD/90z8hGo3u+znm3Tuc06dP42//9m/Z5bfVamF5eZkLqp988glKpdJjeX6yJ1Gr1Th27BjGxsbwyiuv4L333mP1CQDuuqaHp8lkwvnz5zE0NIRLly4hEon0RXpxO2japNPpxM9//nOcOnUKRqORB4g9qRlNpVJhdHQUarUamUwG8XgcxWKRezf6AXKWprEFZrMZyWQSkUgEfr//uR0fuk0w33jjDRw+fJiVUTQ8cOtwNgCP/R62+sBRLeff//3fcePGjZ4MLnRPUnqa5v5IJBJotVq8+uqraLfbfFJMJBL46KOPEAwGMTs7i1Ao9Mz2WLvFvg8uKpWKbfbdbjccDgc/IKmLNZlMIpvN9oXNiUQigVqthiAIPAxNEARIJBI0Gg1ks1lsbGwgnU4/pmmnYqEgCLBardDpdPB4PBgYGGALju2sIboL/SaTCQ6Hg+eg9NoF/aJQQKXxsS6XC1arFSaTiX3bngaddur1OjweD4aHh5FKpVAoFFCtVvuid4Ocx0n2Tu4DhUIBhUJhW9ECBQDaGKlUKlitVthsNl5TckZXq9WwWCwsViHDWfJm2ypI2dog3T3IrdVqsQS3WCz2/KaSRAfd74/8xoBHhpWlUgmZTAapVAqpVIpT/b3Gvg4ucrkcIyMjcDgcOHPmDD788EPodDpIpVIkEglcv34d33zzDfx+f990oqtUKkxMTMBut2N4eJiVOnTRzc7O4ssvv0Q8Hn9sp0zz4AcGBvDOO+/A4XDg7NmzGB0dhV6vf6yjn+gexDY4OAiDwYDV1VXY7XYUCgXk8/m+UEFJpVIOsuPj43j11Vd5AqrRaHymlIxarcbMzAzq9TomJibwwQcf4N69e/i3f/u3TUF/PyMIAk6cOMH3XiKRQDAYxOLiItbW1h7bxFGxWiaTwW63s2vGzMwMbDYbhoaGAIBVjyaTifs2qFYaiUTw4MEDTjF+14Ymm80iEAiwkzqNQujV67TdbqNer6NWq6FYLCKXy/Hgum5LHSrcLy4u8pyhXm2x2LfBhXKURqMRLpcLXq8XPp8PSqWSf0HxeBwrKytIJBI9e1F9X2iSIkmsaUdDOnbyZCsWi4/tkBUKBdRqNUwmE0ZHR7n5b3h4mL9nu50dFRXJB4rWXRAE1Gq1vnGYpvy81WqF1+vF4cOHYbVaOUUBYNOabrdWUqkUZrMZAGA2m3kMstlsRqlUQj6f35038xKRy+Ww2+0YGhqCIAgsP85ms2z5QtcEnZZJVUaTEl0uF0ZHR2Gz2aDX6wF8e3IBwGKJYrGIZrOJQqGAtbU13kR91049kUhgcXER1Wp11yYvvijUKkEnwa2bw06ng1wuh2AwiFgshmw2y1ZCvci+DC5qtRp2ux0GgwGvv/46jh49CpfLhVarhVQqxYXsa9euYWlpiX12+gGFQoGBgQFMTk7CbrdDIpEgm83i3r17iMfjWFtb4+mSFBAorXDy5EmcPHkSbrcbp0+fhslkgslk2vTzqU+j1WpBEIRNaSBSrXT3MhQKhX1x4z4NyvPrdDr86Ec/wokTJ+B0OjE2NsaF+3K5zN5gT0OtVmNiYoL7jZRKJex2O86cOQOPx4OLFy/u2wBDQUKv12NsbAxHjhzhE0EqlUK73Wb1l0aj4bSiWq1mSxy73Q6bzQatVguHw8GjoQFw/SCbzeLBgwfIZDLI5/NsZZJOp9FsNtFoNL7zmiuXyzy8bb+nIbuJxWK4ffs2YrEY8vl8Tz/b9mVwodSOw+HA66+/jnPnzqHRaPBs88uXL2NlZQXLy8vw+/09n2f9PigUCvh8PkxNTcFqtbJR4K1btxAKhTi4EDKZDBqNBmq1GqdOncIf//Efw2g0YmhoaNv6QavV4p0hNckRFFyoX4Acq/c7KpUKTqcTdrsd58+fxwcffMBqMeoxqFarWF9fx927d5/ajGe1WuF0Ojm4UNPbqVOn4PF48ODBA6yuru7yO9wZ6GSh0+kwNjaGmZkZLC0tYWFhAalUCp1OBwqFgh19h4aGcPz4cZhMJhw5coRtYvR6PaeBOp0OF+lDoRC+/PJLRKNRXLx4EfF4/LHi/LPST/c8QWrQu3fvIpfL9fyI8n0RXKhJzWazwWazwWq1Ynp6GmazGRqNBuVymdNB8Xgc4XAYyWSyr+SfgiBwCtBqtcJqtbI5Yq1WQzgcRiAQYNkxKZpobjvtImloEKmdqMBcKBSQTCbR6XR4vWnt6M9ms4mNjQ1EIhEkk8m+2RG2221Uq1Xuh9rY2ODgUq/XEYlEUCwWMT8/j8XFxcfWpRuXy4V8Pg+r1brJH4pky/vZnVsul0Or1XJTaffIXaVSiampKZRKJQwPD3OAGRgYgFqtRqfTQalUQi6X49RPpVKBVCrlvioSBVCqZ7+fiL8PUqkUarWapd00bG0r1NsGAJFIZLdf5vei54MLLbpKpcLbb7+NH/7wh+xnpFKpEIvFsL6+jps3b+LTTz9lS/lyudyzucjnwW6345VXXoHH48GJEydYlimRSJBOp3Hp0iXOMQOPUj00J+Ott97C0NAQTp06hYGBAS6u0kmk0WjgwYMH+N3vfgdBEHD27Fk4HA6+ubs79K9fv45bt27h4cOHfXPz1+t1NvabnZ3laX1yuRz5fB5ff/01wuEwotEop8WetGkZHR3FmTNnoNfrYTAYuJ5ACqD9HJA1Gg08Hg/cbjcbd3Y6HZTLZdhsNvzFX/wFVCoVBxeqi9ZqNfj9fmxsbGBubg5zc3OoVqvI5XLQ6XT4+7//ezgcDjb5TCQSPb0jfxkolUrePLvdbrhcrsc2IxKJBG63GydPnsT6+jpWV1d7OnPQs8Gl29TOYDBArVbD5XJhaGgIZrMZJpMJUqkUlUoFyWQSGxsbbGdeKBT67uJUqVSwWCycWtBoNAAenVoqlQry+fymXD6tm8lkgtPphMvlgslk4hoCsFn2SPN06PPdg58osOTzeV7rfD7fN6dCkq3WajWk02lEo1EOLjSmgE7DqVRq259B1yvlwLdan+wHX6vvQiaTQa1WQ6PRsK8VNTpS4NFoNHA4HCxmqFQqPJI3k8lwLwwZqxoMhk3quX5Yp+eBmkfJPv9JI0Lo5EJrR6NJerHu0rPBxWQycSA5e/Ys3G43Dh8+jMOHDyOVSuGTTz5BJpPB7du34ff7kUgkEI/HuWGq3zCZTDh69CinuORyOfx+P9bX1zE7O/uYvNXn8+FHP/oR16VcLhcsFssmZRdJRCUSCUZHR/HBBx9AoVDwbI7uXPinn36KeDyOr7/+GisrK9uq0fYrrVYLlUoFjUYDly9fxsOHDzm41ut1RKNRlMvlp3aeW61WDA0NYWxsDB6PB1arle07Wq0WisUiK5/2K+TeQKkuiUQCn8/HcniamBgKhXD//n3+s1QqIRgMolQqsccfAE4ZUoZBr9djZGQEgiAgEAjszZvcI0wmE958800MDAzA4/Hw57cG2tHRUeh0OkQiEVitViQSCfzud7/rSZuhng0uWq2WnX5ff/11jIyMsEY+m81idnYWwWAQ169fx/r6et/veLRaLbxeL1wuFzQaDaRSKbLZLJaWlhAMBh87qdlsNpw8eRIul4uL/9tBHfh2u527z2kmCZHJZHDjxg0EAgEsLCx8p0/ZfoO6uBuNBpaXl5/rZ2i1WgwODsLr9cJsNm8acUw1HXKH2K8IgsA1T5LAU/2PqNfruH//PhYWFjA/P4//9//+H1vhdAdn8rITBIHTq2q1GjabDdVqta+H+20HqQyHh4cfU3B21/hIbedwOCCVSjnVKAaXJ0CKJqVSyTtzn8/HShPqG1haWuJgMjc3x53P/R5YiK2nDtLF080plUrhcrlgNptx6NAhDA8Psw/W1l4U+n9KkXXfzM1mE/V6nW27FxYWsLKygmQyue8bAHcSEpnodDocPXoUb7/9NlwuF0trK5UKKpUKotEoFhYWEIlE9rVLBEm2LRYLn8qojyeTyWB2dpY9rwKBAKLRKHK5HDsTdEOpWOqcJ7NLjUbz2Oamn+lO/dvtdjidTk5553I5RKNRNBoNlEolNJtNDAwMwOv1QqPRYGBgAIIgYHBwEG63G+VyuafS1T0RXJRKJQ++eeONNzA9PY3h4WG88sorkMlkbJ1x/fp1XLhwAclkEgsLC5zf7pXF3A26ayEk56Q1kMvlOHToEKampnDmzBkcPXqUR88+6WeQ8SJd5CRFrtVquHLlCj7//HPEYjHcvXuXbdRFHiGXyzE8PIyhoSG8+eab+PnPf85jC9rtNvL5PFKpFFZXV3HlyhXEYjEkk8m9ftnPDZ3O3G43G5nWajUUCgXMz8/jn//5n7G+vo5EIsGqsCfNT6I6V7VaZQ+27imLByW4UL3KbDbD5/NheHiYT73xeBzXrl1DPp9HJBJBtVrFe++9xy4Zk5OTcLvdmJyc5MbK7xrQtpvsWnChwp9UKoVKpdp08eh0Ovh8Pnbi7baAoJx3LpdDOBzmYnK1Wt3VkZ29SLe7MRVXSXJsNpuhVCq/8yalG7/ZbLKtN+2wg8Eg4vE46+l75aLdbSg401qTqaVarWZnCKfTyfJRktomEgkEAgFeT2pO3a9QKossSWhAVSgUQjAYRCKR4K7x73JG7haT0EmZTBo1Gs0TrYj6DZ1OB4fDAZvNxtkbcsQol8v87ItGo6jVakgkEshkMlCpVCysIHdqlUrVU24ZL/03SDtjk8kEr9cLrVYLn88Ho9HI32O323H69Gnu4zAajWz3EI/H8Z//+Z9YXl5GIpFAIpHgi/GgBRa6Iel9k9xYp9NxL8HRo0dx/vx5OByO7/QKo6DSarX4QbixsYH//d//5bTGxsYG6vV6X8m6vw/USEoFa61WC4vFwtb7b7/9Ng4dOgSTyQS1Ws0P3HK5jC+++AKfffYZUqkUgsHgvq+56HQ6tmyRSCQoFAr4+uuv8fHHHyORSGB5efmZRQt07VHzc6lUYhkzAFY19nPKWyKRYHp6GufPn4fP54PD4eD7uNFowO/347PPPkMmk2F3AuqBsdvtOHHiBKRSKVvxFwqFgxdcSMJosVhgMBjg8/lgsVj4e5xOJ6anp2EymTgCNxoNbuxbXFzEgwcPOL97ENnaJ9HpdLhjmgwpO50OrFYrPB4PT6p7mldYp9NBq9VCs9nkoms4HMb9+/exsrKCSqWyyVW5n6FU4dabk04pSqWSe1fsdjtP/RwdHcXY2Bifbmgt8/k8gsEg5ufnUS6XnzoFdL9A1i80O6hWq3FB+XkMTLtl8I1Gg0dIdzf59mtgAcCb7pGREbjdbnZzp1Q3pcNSqRTy+TyazSai0SjC4TBkMhlarRY/W2na5oEJLjKZDMPDw3C5XJiYmMCbb74JvV4Pq9XKOVsAvBvsniVSr9fZu4oaKanGcBDJ5/NYXFxEsVjk4Ox0OnH8+HFueKxWqzhy5AinxJ50oVFgaTQaWF9fRzKZxP379/H1118jlUohHA6zL9NBgGoJWq2WfbFoUyQIAqdsaYaJRqOB0+nkMb3pdJpH9ObzeczOziKVSuHmzZvIZrM9MxnwRaH1kMvlCIfDyOfz3P+zXdH+WWi1WojH41hdXYXX68XAwADK5TIryfr91Ex+bd2OGeTVFgqFNvmHdTod+P1+XLx4EdPT0yx4mpqagtFohFwux/z8PIrF4jM5R79sXmpwkUqlGBwcxLFjx3DixAn89Kc/5WJVN9s9BOnkUiqVIJfLoVarD2xgAYBCoYDl5WVUq1WcO3cOAFiaPTAwwDNERkdHN6Uct4NOLPV6HcFgECsrK7h8+TI+/vjjvrLMeVY0Gg0OHToEs9kMj8cDm83GAge9Xo+TJ0+yyWL3pogeBNlslvuNqBeIjAV7dWb780AnZalUilQqhVgshlgsximb56HdbiOZTMLv98NsNsNms6FYLLLFDNWv+hW6zii4tNttxONxrK+vcwDvVmiGQiEUCgW0221ks1no9XqMj49jfHwciUQCRqNx0yybveSlBhcackP2LdRTQd3LpVKJB/jQ/Gyj0cjzo51OJ5RKJV555RUMDAzwxVypVNhGvx+GLz0LlUoFGxsbbElSLpfZxlyhUMBsNqPRaGx6+G2FdoHlcpknJM7NzWFlZQXhcLgvlXfk70WCEkoj0IA5i8UCs9mMw4cP86naYDDwyYVce+mhSsOn0uk0KpUKlpeX2S15ZWWFbef78eTXXYCPx+MIBoPIZrMvdM3Qc6B7zk0vpXZ2C6pBAUA0GsXi4iI2NjZYBdr9TLTb7SxHpllOpLyj+TW98Ex86TUXktmRySItYrPZRCAQwPLyMssZpVIpDyHS6/U4ffo0ms0mzp07h1qthvn5eczPzyMQCODChQvIZrMol8sH4kSTTqdx+/ZtxONxBAIBHmpFhWSfz8cX4pMoFotIp9MIh8P4+uuvWeq4trbGHmP9BE3tVKvV7LOm0WgwNDQEo9GIs2fP4o033mDFDQUUqp9QDYYCCzlCx2IxXLt2DYlEAr///e9ZFl8oFNBsNjlF1G+Bmk68xWIRs7OzuHv3LgKBwAs9yOj0p1AoMDo62hMPxb2A0tqdTgc3btzA559/zuawGo0GIyMjMJvNmJqawqFDhzA4OAibzQa1Wo1UKoVMJoNkMolcLtczcuRd0/vRjo92KvV6HfF4nOew5/N5bgKkiEwFKporYrPZ4PF40Gg04HQ6IZfLkclkuFjabw/HbqhQTB5f+XweKpWKu+qpY7pbSUcnRBICpNNpxONxxGIxhMNhVt+RHcd+hRSJ3b07dGKxWCxcJLbb7eyBZTQaMTg4CJ/P95hcu1smS9319FClU18kEmEH7mg0yj5a/Uy1WkUikeBUFt17Lwqdpntlx71XUPCmYWHUWiAIAruhu1wu/m+ybqK/Q5v2XtnYvNTg0ul0UCwWkUgkNjXp3b17l2/QcDi8KTD87ne/Yy09mbh5vV7odDoMDg7izJkzmJmZwcmTJ5HP53Hx4kUsLS1hY2MDa2trfTcciKDgnMvlcOvWLZRKJZw+fRpOp3PT94TDYaRSKZTLZe5PyWazqFarWFlZwdraGiuZqIFtP0OTOanQTJLhkZERGI1GTE9P88REUiHpdDoe4tU9ZRP4VqZNqZp8Po+bN28ikUggGo0iFouhVCqx83YikTgwzaW3b9/GP/7jP6LdbmN1dRXZbBalUumFHmTtdptnwh9k9wfy+RMEAceOHUO73YZCoYBKpYJWq8XExARMJhOMRiP0ej3UajV7/1FQoqDSK9fiSz+50MjhZDIJlUqFcrmMy5cvw+/3I5VKIZFIbPv3uvPfhw8fZnXU0NAQpFIppqenWfJJ0r1AIIBWq9WXEka6gKrVKkKhEKRSKUZGRniXTbWsbDbLjVcbGxuoVCqIRCIolUp48OABFhYW2Em1H9ZIIpFAo9FAr9fzzWixWDAzMwOr1Ypz585hamqKZ9tsJzcGNhsEUkE0l8shkUjg7t27WF9fx/r6OgKBAOr1+oEJKN2EQiGEQqEd/ZndA+gOYu8a0T0O2u12o1KpwGAwwOFwQKvVYnx8nG2FuqHNdHeWold4qcGl3W4jEolw3pBy+36/H5lM5qlpBBocRGaCZGMSj8dhNBrh8/kgl8sxNDTEvTNmsxm5XA7r6+tsGdNvfRr1eh1+v5/tNYLB4CY7mFgsxmtLfQf5fJ67eyn1sN9vYgoWBoMBb7/9NkZGRqBUKtlOY2hoCDqdDk6nk2smW4MK7fbInaDRaCAUCnH6cGVlBblcDnfv3mU3336tp+wlVKei+7VfNj7fRafTQaFQQCgU4s2jXC6Hx+OBUqmEIAjcv0Jp7620223kcjnEYjHkcrmeWreXGlxarRZWV1exvr6+acdICq+nLQSpHiQSCWKxGKRSKebn5/HFF1/A5/Phgw8+gN1ux6lTpzA4OIj19XVMTk4iGo3i17/+NYLBINLpdN8FFxI2SCQSXL9+/bECPq3r1g/6Wi/tbF4EhUIBo9EIt9uNn/70p3jzzTdZOUeFebLH6Z5f0033Q41SiV999RXm5ubYLr7bzbjXdob9AJ1cJBIJSqUSjzbohYL0bpBKpbC0tMSKWblcjpGREYyMjDxWR9yObil3KpXqqevzpafFXuSB1v1gpJkbpLEPBAKoVCpc2C8Wi1CpVOxPplKpuJO1Xq+jVCr11MK/CHTj0Y77INI9qIp8vhQKxWM7PJLO0gml1WrxiZgGy5G0uFwuswVOKpXicbsH3cPuZUO/m2KxiFgshng8jmazuWlj0K+QQESv1yMWi6HdbsNkMm3qB2y325uG0NFHs9lk/zHqq+ql63RfucORHUmpVEI8HocgCLhx4wa8Xi88Hg8OHToEt9uNP/uzPwMAXL9+Hffu3UM0GsWtW7cOdMGw3yADVPL92u5B1Ol0UKlUUK1WUS6XkcvlkM/ncePGDcRiMUQiEYRCIa6vNJtNFAoFnp5IDaW9dMP2G/Q7ohP5Rx99hEqlgmKxCEEQ+nrz1Ol02EV6ZWUFMpkMHo8H77zzDqanp/n7arUalpeXkcvleIwDTeAtlUq4evUqlpeXkclkeqq3al8FF8qR066T1BVk2DYyMsLqMkEQEI/HudlSEIQD1XR5EOgew1ytVlktRrTbbbbCKBaLSKVSyGazWFtbQzAYRCAQwPr6Ol9P4nWxN9BOPJvNIhAIsBR3uzpZv1Eul7kh2u/3o9FocG2v+3vS6TRSqRRKpRJ/bGxsoFgsIhQKIRaLcZ9MryDpPOOr6cVfslQqhcVigVarhcvlwujoKI8Dpo71RqOBbDaL1dVV5HI5XLt2DYFAgDXhz8Pz/AJ7cf32ip1Yv25H6DNnzsDj8Wz7MKL54o1Gg3fIwWCQfevy+TxvWHrpxnwaz/s6e/0aNJvNcLvdaLVaXC+l7vOdptfuYZ1OxyKUsbExuFwu/hqNb6C1oOuZHKipmE+f3w2eZf32dXDphmw6aBa10+nEoUOHMDo6ygOwstks/vVf/xXffPMN2yU8D712Ye43dnr9vs/a7pcA8jT6NbjsJr18Dz/NcLZXeJbXsq/SYk+DUiPFYhF+vx/5fB6lUgmxWIwbEKmhs18bLQ8qvXTTiYi8KP1yPffNyYVke2SFQmaFZO1BMtKdaNbq5V3PfkBcvxdDPLm8OOI1+GIcqJPL1rGpIiIiIiJ7R3+LyEVERERE9gQxuIiIiIiI7DhicBERERER2XHE4CIiIiIisuOIwUVEREREZMd5ZimyiIiIiIjIsyKeXEREREREdhwxuIiIiIiI7DhicBERERER2XHE4CIiIiIisuOIwUVEREREZMcRg4uIiIiIyI4jBhcRERERkR1HDC4iIiIiIjuOGFxERERERHYcMbiIiIiIiOw4YnAREREREdlxxOAiIiIiIrLjiMFFRERERGTHkT/rN0okkpf5OvYVz2MkLa7ft4jr92I8r5G5uIbfIl6DL8azrJ94chERERER2XHE4CIiIiIisuOIwUVEREREZMcRg4uIiIiIyI4jBhcRERERkR1HDC4iIiIiIjvOM0uRRUQOCi8iOX1emXC/8X3XUFy3zUgkkn2/JmJwETnwKBQKGAwGqFQqeDwemM1m/ppSqYTD4YBGo4FcLodCoeCvdTodNBoNtFot5HI5JBIJlEolBAIBFItFlMtlVKvVvXhLLwWpVAqZTAaJRMIfBK2hQqGAxWKBTqfj75fJZDAajVAqldDr9dDpdGg2myiXy6jValhfX0cikeA1bLVaaLfb+/7h+jzI5XLMzMxgYGAAGxsbWFlZQb1eR7VaRavV2uuX970Qg4vIgUepVMJut8NoNOLs2bOYmJjgr+l0Opw4cQI2mw0ajQYajQbAo8DS6XRQKpX4ATk3N4d4PI7f/va3iEQiSCaTfRdclErlpiBD6HQ6DA4OQqfTYWJiAi6XCwqFAkqlEoIgwOfzQa/Xw+v1wuPxoFqtIh6PI5/P4/PPP8f9+/cRCARQKBRQr9dRr9cPZHBRKBQ4ffo03nrrLdy5cwfZbBbFYnFfBtyeDy7dux65XM4fKpUKMpkMSqUSMpkMjUaDI3wqlUK1WkWj0UCz2dzrtyDSo9C1ZDabcejQIVgsFgwPD8Pr9fL3qNVqGI1GaLVaCIIAlUoF4Nvg0m63ebfu8XigUqlw+PBhWK1WLCwsoFKpoNVqodFo7KsHw3bodDp4vV6oVCro9XoolUr+mlqthsvlglqtxtDQEOx2O2QyGQcYCs46nQ4qlQoSiQR6vR5SqRRDQ0NoNBrQaDRotVooFosIBoMolUpot9tot9t7+K53F4lEAqVSCa1WC7fbjRMnTqBQKCAcDqNcLiObzSKbzfL118tIOs/4CvfK+sBgMODs2bNwOp0wmUwwGo0wGAwYGhqCRqOB3W6HXq9HOp1GJBJBLBbDxx9/DL/fj3Q6jWw2u+OvSbSOeDF6Zf1MJhNMJhMOHz6Mv/u7v8PAwAAsFgv0ej3/m1KpFIIgQCaT8Y6dXj/d4J1OB7VaDbVaDY1GA5lMBuVyGb/85S/x3//93yiVSkilUju20dkr+5cTJ07gj/7oj+BwODiAElKpFAqFAlKpFCqVCnK5fFP6TKlU8p8KhQLtdhvNZhPtdhuFQgG1Wg3JZBKhUAjBYBD/8i//guXlZVQqFdRqtRd63dvRK9fgVrRaLf7hH/4B7733HjQaDfR6PcrlMm7cuIFYLIaLFy/i8uXLaLVae7pxfpb167mTi0Kh2JTX1el0cDgc8Hq9sFgssFgsMBqNGBsbg1arhcvlgtFoRDKZhE6ng0ajgdVqRSaTQalU2uu3I9KD0LWlUqlgMBhgtVoxODgIn88HjUbDp5Nn/TkSiQQymQwajQbtdhtGoxG1Wg12ux2CIKDRaLzkd7Q7aDQaeDweuN1uTExMwOFwPPF7uwNw95/tdhvVapXXTCaTwWq1QiKR8OlQLpdz3abVar2U4NLLtNtttFotaLVajI+Po1KpIJVKQaVSYX5+Hkqlkmt9vXx66ZngQimuU6dOYXx8HIIgQK/XQ6/X4/jx47BYLFCr1VCpVFCpVDAajZDL5RAEAZ1OBxqNBgMDA1Cr1Th//jwmJiZw6dIlZLPZPY/yIr2DVCqFVquFUqnEkSNHcOrUKQwPD8Nut3PRnqCdKt3A9P/dSp6tn6MdfKfTgVKp5LTtQTq5lstlTlNTWrBWq6HVaiGRSCCRSMBgMGB4eBgajQZGoxEajYbFE3K5HD/72c8QCoXw29/+FpcuXerph+hO0mg08M033yCdTuP06dOw2+1QKBSYmJjgIn8oFEI2m8Xa2lpPB96eCC6UflAqlZiensYbb7wBg8EAm80GrVaL0dFRTlVsR6fTgSAIEAQBarUaJ06cgNfrxfr6Oj8sej3Ki+wOUqkUarUaGo0Gw8PDOH36NBwOB0wmEwRBAPDoeuoOBtsFhqd9TiaTbaoPUoroINDpdFCv11Eul1Eul5HL5dBsNlEsFlGr1bC6uorV1VU4HA4olUqYTCauyyiVSmg0GqjVarz11lvIZDLw+/24dOnSXr+tXaPZbOLhw4cIhUIQBAHvvvsuzGYzBgYGIJVKMT8/j5GREUSjUYRCITG4PAm1Wg21Wg29Xo/BwUGYzWYcOXIEw8PDUKvVLA+VyWTP/DPp2F0ul9Fqtfb9TU1pF71eD7vdzg8rmUyGUqnEu0R6v1uhnbpCoYBGo4FWq93231EoFBAEAQqFAiaTaVOxtlKpIB6Po1qtwu/3I5PJvLT3+7JRKBRccB4bG8PAwACfgrspFApIJpOo1+vIZDIsBd26xlRnMJlMcDqdLLeVSCQwGAzwer2Qy+UIh8O7+TZfCsViEevr6yiXy3A4HNsW2pvNJpaWlhCJRFAqlZBOp9FqtfgEs7GxgXg8jlgshnK5DKPRiDNnzmB4eBg6nQ5msxlSqRQajQbNZpNrNQdlY0j1O4lEgkqlgnq9jmazyRseu92O6elpqFQq3L17d69f7lPZ0+BiNBrh8Xjg8/nw4Ycfwul0YmpqCl6vl08z9OezQmqTXC7Hv6T9HGCoiOx2u/Hmm29Cq9VCo9FAoVAgHA4jFAqhUCggGAxuu4tRqVQYHByEXq/HwMAABgYGtr1ZjUYj7HY7DAYDDh8+DKPRyGsXiURw9epVxGIx/Nd//de+Di5qtRqnT5/G1NQUTpw4gaNHj0KhUHBwoXXZ2NjAjRs3kEqlcP/+faRSKVQqFVSrVX6oymQyaLVaqFQqzMzM4O233+Z6oFqthtvtxvHjx7G0tIT5+XlUKpU9e987QTKZxLVr1zijsJ1YplKp4Ne//jVu3LiBQqGARCLBEtpOp8OSWolEAoVCAb1ej7/+67/GW2+9BbfbzYHebDZDpVI9cTPUr3Q6HRSLRZRKJX6GUUpRqVRiYmICer0e169fxxdffNHT9+KeBJfu3R7p3p1OJ5xOJ59Wui9EemhKpVL+2LrT7DdInWQwGFiW6PV6odVqoVaroVAo+OFfLBYhlUq37akQBAFer3dTj8F2wcVgMMBut0On03GQoZ/faDTgdDrRbreh1+shCAKazea+rGNRIZ9OzSqVClKplNVLxWIRlUoFkUgEoVAImUwG0WgU6XQa1Wp1U4CgIrRKpYLZbEYgEIDNZsPAwADLbu12OxKJxPfaIPUq9Xod2WwWUqkU4XB4201btVpFLBZDMplEqVRCNpt9qpS41Wohm80ik8nAZDJx3YpkzIIgQKvVotFooFarHYgTDAXier2OYrEItVrNaygIAoxGIzejajQaPt30Grv+hFYoFHA6ndDpdPjxj3+M999/HyaTCT6fD4IgcJNapVJhiSKlZHQ6He/cHQ7Hpm5pglQ7lArab41HwKP+C4PBALVajXfeeQfHjx+H1+vF0aNHOU0okUhQq9VQrVbRbDZRqVS2vYlJSiuXy6FWq7musN2/Sb1EarUawLe7eL1ej5mZGbhcLty5c4dTRtFodN/3IEgkEjSbTRQKBZTLZVy4cAH37t1DJBLBgwcPUK1WUSwWUa/XWcXTjVwuh1QqRSAQwPXr1zE2Ngav1wur1YrJyUm4XC5otVr8z//8T0/vMp+FfD6PxcVFKBQKrK2tbXsttdtt7rYnqfHTaDabWFtbg1qthlQqxZEjR9gJod1uY2hoCKdPn0YikcDS0lJP1xh2mlQqhdu3b8PtdvMmk/qEhoeHcfLkSdhsNiwtLSEej+/1y32MXQ8uUqkUOp2OA8qJEycgCAJ0Ot2m2kqz2eSaQjweR7lchslkQqPRQLvdhtls3iRZJui4Tb0J+xHqFdBqtRgZGcHJkyfhcDgwMTHBAXW7XeN3BdGtf+dp3085XlI92Ww2yGQy2Gw2WCwWlpPuZ7bKY4vFIpaWlnDjxg3E43Gsrq4+844wlUpxPaJUKkEikcBiscBsNmNhYaEvTtrUOQ9gxx5mnU4H2WwWGxsbyOfz/Duh7IRer4fL5UKr1dq39/PzQrVOuVzOcnaFQgGFQgGj0QiHw4FarYZQKLTHr3R7dv2Kl8vlnOIhzyZK8XQ6HeTzeVQqFSwuLuLy5csoFouIxWKoVCp8atFoNHC73dBqtTh27BhLkMnbaHBwECaTCceOHcPGxgaSyeS+2vWQck6tVsPhcMDn8z0WfJ+HarWKer0OmUwGtVrNKS86+eTzeVZTyeVyaDQaCILAr0er1WJychLtdhu3bt3C6urqvvM7arfbyOfzSKVSSKVSSCaTyGazuHPnDpLJJObm5jZ1hz/vvwGIZowvQreClJwR9vtm5vvSaDSQzWah1+sf2+RQdsNoNG6bwekF9iQtNjg4iPHxcbjdbmg0Gn5oNptNZLNZpFIp3Lx5E7/4xS+Qy+WQTqdRq9W48Eo5bpPJhL/8y7+EVCqFzWaDTqeDUqnE0NAQms0mF7tXVlYQCAT2VXChuoDT6cTIyMiO3Fi1Wg25XA6CIHD/Ra1WQ71eRyqVQigU4qY2QRAgkUg4uNDNPT09DbPZjGw2i6+++mrfNQhSjj+RSCCZTCKZTCIYDOKrr75CNBrFvXv3EAgEXjgwdP99Mcg8H9TRT42tBy241Go15PN55PP5pwaXbmVnL7HrwYUuGJK9SiQS1Ot1pNNpVCoVLCwsIBwOY2VlhfPg1I0KgGso1H2/tLQEQRAwOjoKg8HAP1smk0Gv18PpdCKTyUAQBFQqFZb19TIkYqBjcSgUYo8rEjQ8KS1WrVZRq9Ueqw90Oh2Ew2GEw2GoVCqYTCbIZDKUy2Ve/0gkAkEQMDExAZPJBJ1Ox3+f/j1KV+zXAnWr1UIqleLUaafTQTweRzgcZkXYTlwf3aIJlUoFh8OBarWKfD7fV2aWIi+PWq2GdDoNnU7HtVW6/4HNDhG9yK4HF3roU8c9AGQyGVy8eBEbGxv44osvcO/ePW7AIsUYAP7vZrPJD8Rf/epX+Pjjj/H+++/DYrFwv4FKpcLAwACARw/Er776itVAlDfuVRqNBlKpFMrlMq5fvw4AGB4expkzZ7gov93Dvd1uIxKJIB6Po1aroVgs8tq1221cunQJV65c4Vy2TCbjizafzyOZTMJut+NnP/sZRkZGoNFo4HK5dvW9v2wqlQpu3boFhUKBr7/+mpVvhUIBzWZzR0+3FGAsFgvOnDkDj8eDW7du9WyOXKS3yGQyuH//Pku6S6XSJvPUXmdXgwtJDKmTXiaT8VyHjY0NhMNhBINB+P3+J/6Mbjda4NvCYiQSQTqdhlQqhdVqhUqlgiAIMJvNMBgMfLTeD70G7XYbjUYDUqmUTxRqtRqZTAa1Wo1rIt07lk6ng2aziVQqhUQiwWq77sAcDofh9/u5P6O75lIoFJDJZPj30X1a7IYewL0ofXwW2u02isXirv6btN5b7WVERJ5Go9FAoVDgDXH3Rns/sGtXuiAIMBgMcLvdmJqawrFjxwA8SmstLS3hyy+/RCgUeu5d3dLSEn75y19iaGgIf/Inf4KRkRG2BR8cHMTY2BgEQcDS0lLPBxgaQtVut3Hv3j2EQiFYrVZcunSJ1SLdR2P6O+12G8lkknO03e+z0+kgGo0il8txbwwAtjQnS3ilUgmfz4fDhw/DZrNtel2NRgMLCwuYnZ3dl8X83YbSYvl8HvPz8wgGgy/FpVukP6GNHmUX9puF1a4FF5pUZzab4fV6MTw8jGAwiGAwiPX1ddy9exehUOi5IzPZUU9MTOCDDz5Ap9NhDymr1QqXy4Vms4lgMLjD7+zlQA/9QCCAQCDAaq2tNZfu3H6n02HLiO2sSp4FuVzOLtTdNRfg0cUeDoexsLCAjY2NfbWL2m26fyfVapXdFMrl8h6/MpH9Qrvd3jSFcj/McOlm14KLUqmE0WiEyWTiRsBsNovFxUVWcr3I4tXrdeTzeWQyGWxsbCAWi8FgMECv10Oj0cDn80Eul2N+fn6H39nuQBdadwFvu76V72vFTT+PJM8jIyOw2WzceEmCi0KhgFQqhUgkgmAwiEwms68u9N2Ggr5EIuE+GhJaiHwLpbE9Hg9MJtOmk3ir1UI+n0csFmOPsoNIt3yevAL3A7uaFnM4HHA4HNw9H4lEcPnyZcRisRfqKwDAvk8qlQqrq6tQq9XspmwymXDy5Ek4nU5cu3ZtB9/V7kHH4u/i+z7wyWbm0KFD+MlPfgK3280jaemEVK1WEQqFEIvF8PDhQ8zOzh64CYHPAwWYbjNVMSBvRiaTwePxYHp6Gh6PB1KplOuHjUYD8XgcCwsLLLg4iDSbTcTjcQSDQSiVyk1D2nqZXU2LmUwmGAwGyOXyTd455XL5hR9U3YV+8r2in0kzNva7Vn6nH0zkZkAGgna7HRaLhZ1oiUajgWKxuEka3k9QxzO5TZNPWz6f5+vpedaeJlOSI7AYWL49KctkMh7WRhNBNRoNn/TI6YC83g6Kr9h20HqQHRbw7TVbLpfZ367X5lbtWnCxWq04ceIEz9mmBiHyITqoR969hJpPzWYzJiYmMDMzs2muCfUU5fN5LC0tIRwO77rSajdwuVz4wz/8Q9jtdpjNZuh0OszOzuKLL77gdOD3lSiTLDwYDGJ5ebnn5e+7BfmGmUwmTExMwGaz4eTJkzh69Ci0Wi2Pkpifn0cikcDi4iJisdgT1YsHgXq9Dr/fD6lUCrvdDuDR8/Sdd95BKpVCMBhELpfj5uBeySjsWnBRqVTsSyWXy9FqtXhSXbeNucjuQPYaWq0WJpMJZrOZ58fTJEVqxKxWq0in08hms33XAEjOxuPj4xgYGIDD4eAxxdevX0en0+GUzNadc3fRntaz27q/WCwikUggk8kc2AfjViiLQD1UDoeDT8y0diSpj8ViyGazBz6dSDUXmitEwxHJAstms0Gv1/ecA8muBRfyCaLjW7VaRS6XQyKReOKgK5GXgyAIsNlsMBgM+MEPfoCpqSkcOnSIHQ4o772ysoK1tTWsrKzgq6++QiKRQCqV2uuXv2O4XC54PB5MTk7i2LFj8Hg87Kd25swZCILATsC5XI6tzSmd22g0kE6nUSqV4Ha7MTo6Cp/Px7vLRCKBhw8fIhwO910q8XmgYVcejwfDw8N4//33WUhCc+FzuRxisRhu3LiBlZUVBIPBAx1YgG9T/vRBqUXq5bPZbBgcHGTLq17ZqO9acCErd6VSyTO1qfNUvPF2F0EQMDAwALvdjvPnz+ONN97guRlUa2m1WlhdXcVXX32FtbU1fP3115tca/c7EokELpcLx48fx9TUFI4cObLJjcDpdOL06dMoFou4ffs2N6bS+F4SoayuriKRSOD48eM4f/487HY7rFYrOp0OG6YGg8GeyoXvJTabDZOTk5iensZ7770Hu93OPVu04YzFYrh58ybm5ub2/ZiCnYIyCd11ZJlMxo7lXq+XZ+30CrveLtxut3kRCoXCjj+sqPjVj4XnF4V2PFqtFkNDQ3A6nZuk4aRuqlarrNTx+/2IRqPcZNlPaLVaOJ1OmM1m9rkDwAOrgEcSeovFwiafNENHp9OhVqvBYDAgm81ifHwcHo/nMZfaXtlF7hWUsXC5XNDpdDh8+DAOHTqEoaEhHtTWaDTQaDQQi8UwPz+PUCjE9kfiPfwoTUgD5/L5PI9v3+ox1mvsenCp1WoIh8OoVCqIRqM7/sBqNptIp9OIRqMYHBzsuwfii0A1AZfLhR/+8IfsXNB9YqF8d6FQwO3bt/H5559zbayfoJPLiRMn2IsOeLyOolKpMDY2tmnoXLeCrF6vs7MBDbwiQ8yDfu1RfcVms+EnP/kJxsfHMTExgfHxcZ7USfWEUqmEK1eu4D/+4z+QTCaxvr6+yRvvIFOpVHDnzh0IgoCTJ0+iWq1CqVSyG3KvXmu7HlyoOeplNZR19xSIqYjN0KRPk8kEu90Ou93OD0SCTCzT6TQX8Xvxwt0JlEolN9lSnYmCCO0MJRIJT0cFNjsiPO1zrVYLKpUKOp2OR9ICYPeEXn0g7CRKpZIHA3o8HgwNDcHtdnMqjEQ9+XyeB4aFQiHkcjnx/u2CsjG0yds6XZdGQveab92uvxqVSoXR0VFIJBLMzs7u+HGuXq8jHA4DAGZmZnb0Z+9npFIpTp48iddffx0+n4/nsmy1eMlms/if//kfLC4u4s6dO339AFQoFNBqtRxgSXZdLpeh0Wh4xAGtwXaWO0/6nEwmw8mTJ2G327GxsYGZmRmk02lcv34dgUAAlUqFx0b0G7Qm4+PjePfdd+F0OvHWW2/B4/FAr9dDEAQUCgWsr68jn8/j6tWrWFlZwcrKCmKx2L42Rt1tZDIZvF4v2/Mf6JqLTCaDw+GAIAgwGo07/vNbrRbS6TQUCoXo49SFRCLB8PAw3nrrLdjtdni9Xh550E2pVMKtW7dw69atvjdZpEa+biNQap4EwNfnk04rW9k6btvn88Hn82FjYwNarRbxeBzRaBSpVIp3o/0avKVSKVwuF1577TU4nU4cOnQIZrOZv95oNHg8xLVr13Dnzh0Ui0Xkcrm+XZOXgVQq5bHjJpPpYAeX7mFhNHulXC5zoUpkZ6C0Ds21MRgMmJycxODgIPR6PfuGUWoyFothbW0N6+vr2NjY2Bdzb54HGuNMA9NMJhPUajWKxSJarRauXr2KhYUFGI1GOJ1OKBQKqNVqKBQKuFwuOJ1OVj5uHdq29TRDnxMEgY1A/+AP/gA+nw/RaBRra2soFot8ktnPkMuDIAiYnp7G4OAgDh8+jJGREeh0Oh7wF41GEYvFEIvFcPXqVWQyGa6v9FsP1W5AvWoWi4UdDnqFXQ8uVPDUarWw2+0YGRnhKZRicNk5qHhvNBpx9uxZDA0N4dy5czh8+DArw4BvJY7Ly8v46KOPEI1Gsbq6inQ63Zc7SJlMxulAp9MJh8OBdrvNHc4ff/wxfvOb38BoNMLhcECtVsPhcECv1+O1117D2bNn2RtPqVRyfWbrWOPuz+n1ekxOTqLdbmNsbAyVSgVzc3O4cuUKIpEIcrncvg8uKpUKHo8HVqsVf/VXf4V3330XKpUKGo0G7XYbhUIB2WwWN2/exKVLlxAOh3H16lXk83meKQSII6G/LxKJBGazmTdLBzK4dOu0KSdNY4gBIBAI7Mi/I5VK2axyv0xsexnQTtJoNMLlcsHr9bJMtttQkRwS0uk0YrEYEolE3/s4yWQyyOVy/iBT0EajwR5OnU4HMpkMarUaJpOJJbH0d7qDM406KJVKHFiARwIKQRAgkUjYT0+n00GpVMJsNsNut6NarW76nexHSFVns9ngcDhgsVhgNBpZIksy42w2i2AwiEgkgmQyyb5h+/V99wLdo457KSUG7GJwIYUY2cYrFApMTk7iww8/xMLCAlZXVzkH/SIXm0ajwbFjx3Do0CEMDAz0VCTfTaxWK6anp+H1evHjH/+YO/CBbx+IjUYDq6uriEQiuHbtGq5cuYJCoYBCobDHr/7lQdeeIAgs5yQX3nq9zh+kWDKZTDh8+DDsdjscDgfcbjcHGAA8N2d1dRU3btzgICSTyTA5OclD6gwGAwcrlUoFn88HALBYLLhw4QLi8fgzO1/3ErQWTqcTP/jBDzAwMIDh4WEoFAoe1RCLxfCLX/wCCwsLPMOJlE9iYOlfdi240DwS6guQSCQwGo0YHBxELpfj+SHP60BLyOVy3hWShHRrd2s/Q7sYtVoNm80Gp9MJr9eLgYEBAN+mHahXgySgGxsbiMfjByLvTQPXyAFZKpXy9UEfJJlvNBpQKpXQaDT8sXXmSLPZRC6Xg9/vR61W49+B2WyG0+lEu93eNOhNKpVCp9PB4XAgk8lAqVRCJpPtu8ACgLvEdTodPB4P1/RIalwul5HL5bC8vIz79++zxP1Z2Lox3DrLqHsjehDubaJ7zHsvs2vBJRKJ4PPPP4fH44HL5YLRaIRer8fY2BgajQZOnjwJm82GtbU1JBKJF/q36MEBPNpZZrNZzM7OIhKJ9LUCSiqVwu12w2w2Y2pqCq+//jrXC7opl8tIJpPI5XK4fPky7t69i9XV1QMj/6Qbk/7cbjPjdDoxPj4Op9OJt99+Gz6fD0NDQ/x1Ou2Ew2Gk02ncvn0bv//977l2IpPJsLa2hitXrsDr9eK1116DyWSCy+WCwWCAIAiwWq2w2Wyw2+2w2WzIZDL76tQokUgwMTGB48ePY3h4GEeOHOHrjep4n332GWKxGBYWFri2+l1QrZCaBIFHbgoej4d7k1QqFYrFIrLZLIrFIpaXl/vSsXsr1WoVmUwGWq2WNyW9yq4Fl1gsht/97ncYHBzEj370I4yNjUGn08FqtaLRaODIkSMwGAxsZvm8UD2nO7jkcjk2EMzlcjv1lnoOmUwGl8uFoaEhHDlyBGfOnIHRaOR0GFGv11kGev36dVy8eJFHqR4UnhZYgEceWGfOnIHH48Grr77KqZ7uv9NqtRCLxbC+vo7Z2Vl88803mx6e1EMzMzMDvV4Pl8sFrVbLD0eVSgWLxQKr1cpy0v0WXMbGxvDjH/8YbrcbU1NTMBgMfPJbW1vDRx99hGQyiWg0+sytASS66D4lOhwOHDt2jOu0Op0OiUQCwWCQJd79HlzImomeYSaTSQwuANgJuVwuIxqNIhAIcNpGo9FgeHgYgiBw7pmO01sHfz0JmhNBHehmsxntdhvpdBqJRILlj/tdlfM0JBIJLBYLhoaGeIes1Wof69ytVquIxWLY2NhALpfjprWDkv/uTpOSwESn06HVamF6ehqZTAbj4+OYmppi92hS2LXbbRSLRYRCIRQKBdy5cwd+v5/NKbvXsNFoQCqVIplMYnZ2FrFYDEqlEuVymZVUmUwGpVIJ1Wp135wcKe1Kvmvkz0aihVwuh1KpxLOaSqUSvzdKC8rlcgiCsKnXiFSk9DzQ6XQcXEwmE0ZHRyEIAstu2+02UqnUY8Pt+pl0Oo3l5WUeV0A9WvT8U6vV7NW216mzXQsuzWaTXZBv3LiBUqmEU6dO8SyH8+fPo1gswmQyYWxsDH6/H3fu3OEg8109F3TRud1ujI2NYXx8HJFIBAsLC5ibm8PNmzexsbHRl70bhFwux6FDh/DWW29hYGAAAwMD2x6d8/k8bt++jVAohHA4zCqngwAJGbqL90qlEm63Gw6HA3/+53+Od999F1arFYODg9yTRTWRRqMBv9+PX/3qV4hGo7hz5w6CwSBPneymXq+j0WhgaWkJkUgEer0efr8fk5OTcDgcGBgYQCgUwsbGBtLp9L6pd8nlcjgcDphMJhw6dAgzMzPQaDRQqVRoNptYW1uD3+/HgwcPEIvFuIcIAEu4dTodvF4vBEGA0+mEwWCAy+XC+Pg4jEYjJicnYTKZNv2bFESoViYIApLJJEqlUs9Zn7wM2u02FhYW8Jvf/AbT09OYnJyERqNh9aNGo4HFYoFUKkUmk9nzZ92uSpHJ6C+TySAajW4aPqXX66FUKuF0Onk3bbPZuJmPiqdbo3F3AZtSDFqtFoIgcEqMjPH69dRCuz+9Xg+DwcBDv5RK5abhVZVKBZVKBclkEqlUih9oe73D2U26i/D00b17ttlsUCqVMBgMMJvNLO/sdDqo1WooFotIp9OIRCIIh8OIx+NPnHFD1zy5KZNZq06nQ7PZhFwu53lGvbDTfFa6Z4mo1Woes0vCCArC1ODXfaoQBIHHG1PWwul0wmg0siDAYDCwdL6bbpUj/Q5pbffL2r0oxWIR8XgcbrebAzYFXLVaDavVColEwt5se+lht+vhvlKp4MaNG1haWgLw6LhrMBj4ojp16hQmJiaQTCZx7tw5JJNJXLhwAaFQCPF4HPF4nH9W9/H8xIkT+PDDD3kAlEwmQzwex71797C2trbnUfxlQDsWm83Gp8BXX32VXWe7TyztdhtffvklfvOb3yCdTmNhYYEflAcJsgcqlUqIxWKIRqPc/6NQKGAwGLgjf2uj6e3bt3H16lUEAgF88803yGaz36uGV6/XcefOHaysrEAQBOh0OpTLZfj9/k2po16nuxGahqtR7w/V/bpPJ3SiI3eObnWZSqXi9Var1TAYDJze7obUprVaDQsLC4jH47h58yYuXLiAXC7X17VUotPpYGNjA+VymUc+0JrK5XIcP34cf/M3f4NwOIyPPvoIfr+fx4/sBbseXBqNBgKBABQKBSYmJhAOh9FsNjE0NMRDrIBHEXpoaAiRSASrq6u8a9xqEEi5Wq/Xi7Nnz8JiscBgMEAikaBQKCASiSCVSvVlsZpUcdQBTs6zNpttUxc+8O2R+te//jXvommHeZCgE1ytVkM+n0exWIRcLuedL+2stzZJtttthEIhXLt2DRsbGwgGg9/beLLVarGp6n6G7julUgmFQrFJQCORSLhGRSIGWtvuv6fVauFyuTbNvnka7XYbjUYDlUoF4XAY6+vrePjwIebm5vj0chCgPrRkMsmbEap1eb1eKJVKrK+v4/Lly0gmk3t6f++Z5T4AvllHRkYwPDzMRSmykKaL8+zZsxgcHEQgEIDf7+f6jVQqhc/ng81mw/Hjx+FwOCCTybC+vo5KpYL79+/j4cOHSKVSffkQpTwrNUx2Bxbg2/EDfr8f+XyedzJU8DsItu/fB9q4SCQSTrlUKhUsLi4im83y6N1CodCX19Oz0mq1+OHm9/uxsrLCfTt0AiQnAoVC8Zg9PNVPtnaU12o1vj7z+Tzq9Tqn2XK5HNbW1lAoFPDw4UPEYjHuKzpIYhSCRmwbjUbodDqoVCoolUoYjUaYzWaWuFND8F6wJ1Uw6mpeXFxEPp/H0aNHcfbsWajVauh0Os6BU+77/fffR7VaRTgcRiQSQaFQ4B3guXPnMDo6Cp1OB7PZjGw2i2+++QahUAhXrlzBtWvX+naHTukFt9uNc+fOYWRkhIudlJMuFAq4efMm/H4/Hj58iEKh0JenuBeh20IDANcGSRb/6aefYnl5GXNzc3j48OGBach9Eo1Gg0UIDx8+xN27d7luQimt7qFrW+luhOymUqkgHo+jWCxyICHRhd/vx1dffYVsNot0Oo1yuczPkYMIKT7JmJbSi4IgoFqtwuv1Ip/PI5/PIxqN7slr3FOJBQ0KolnjlUoFQ0NDPEyITjFqtZq1781mc1OR0Gq1wmAwQC6X87GZdO/ZbJYLpf24syHzRavVCkEQNqUYaPdHxedQKIR8Pn+gH4pbKZfLXMPzer08z6VSqSCbzSIajSKRSHDhvlgs7pu6yMuG1iGdTmNtbQ3VahVutxtGo5FrMJQCA8D3IIlKiO5BWOQWUS6XEQgEUCqVWNlH9zP9fvqxhvp9oI0jGX8Cm1O4z9rC8TLZ0+BCNtvFYhGJRAIWiwV/+qd/irfeegt6vR5Wq5Ut0skE0OVy8QQ7mgcvCAKKxSJisRgCgQAuXbrER2ea+tdvUHf0+fPnMTw8DK1Wu+nryWQSDx48QDgcxmeffYbFxUU2ZBR5dCMuLy/jk08+wcTEBDdJ3r17F0tLS1hZWcH169f5lCxawn8LuRO0Wi3cvHkT6+vr8Hq9CIVCcDgc8Pl8cDgcMJvN8Hq9kEgkqFQqaDQaWFhYwNLSEl+H9Xods7OzCIVCKBaLyGQyaDabKBaLnLqlYj6N5RAD/KONEW3IHQ4HHA4Hp3ILhQLi8TjLwPeKPQ0uFF3r9TrK5TIMBgN30VNhkFQoUqn0MQUJ8O2OiHbq3V5ZxWKxLx+m1IhG3mwOh4OLegRNpksmk6yKEvkWavYLhUIwGAwoFotQqVSIx+MIBAJYXV3FgwcPUC6XxRPLNtAuOZPJcH2EanrUF0SDrCQSCUqlEur1OpLJJAKBAF+rtVoNDx8+xMrKCiqVCgcQqreIbA+d9DQaDbtLNxoNlEollEollMvlPVcg9kTnEeW4C4UCLly4AL/fD5/Ph1deeYXljDqdDhqNBlqtlncyjUaDvZ3W1tZw+/ZtJJNJLmD349FZqVTy8K/jx4/j5MmTPKSpm1qtxhJN8cG4PalUCvPz84jH48hkMhAEAX6/H8lkEul0mlMO4kPuyZBAJ51O49q1a9BoNLhz5w70ej2PigbAwSIej2+yd2o2m4hGo8jlcpwC69c09k6SyWRw8eJF6HQ6zM3NwWq18qmOvBSTyeSeTuPtmeBCp5irV6/i5s2bmJmZQb1eh81mg0Qigc1m46YsCi6VSgWrq6sIBoO4c+cOLly4gFKphHQ63ZeBBXikEPN4PPB4PJiamsLhw4c3NUoSlJMVd91PJpPJIJPJcAoMEIdVfV/oBJPP53Hv3j3+/NPsWMQ1fnFyuRxu3boFYPu17oU17ong0g2pPzKZDBYXFxGLxThlZjAYoNfrN82GWVlZQSKR4Ea0fu84pxoUKXJKpRL3+pCElpygg8EgotHogekBeBF64WbsJ8T13D16da17LrjQyFMaYkWqse5ZGMBmK4hms4lGo8ETFPs9uJDsmlx5tVot111IjeP3+3H16lW21hcRERHZTXouuADfmgv2Y2/Ki0IpRFLZZTIZtFotWCwWyGQynnFBsk3qBxARERHZTXoyuIg8mWq1yn5psVgM4XAYw8PDcDgckEqluHbtGu7cuYP79+8jHo+jUqmINRcREZFdRwwu+4xms4mNjQ0kk0n2dJJKpajVahAEAcFgEHfv3t3UhCYiIiKy24jBZZ9BabF2u82Sznw+z061165dw+rqKrLZbF/XnkRERHobSecZpQYHZdLbs/A86oyXsX7UXCqRSFiOTH5LvWxK2Svrt1953t+ruIbfIl6DL8azrJ94ctnHdDtMi3UVERGRXuKZTy4iIiIiIiLPivS7v0VEREREROT7IQYXEREREZEdRwwuIiIiIiI7jhhcRERERER2HDG4iIiIiIjsOGJwERERERHZccTgIiIiIiKy44jBRURERERkxxGDi4iIiIjIjvP/AUZaVyxgoaxUAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -447,12 +448,12 @@ }, { "cell_type": "code", - "execution_count": 720, + "execution_count": 536, "metadata": {}, "outputs": [], "source": [ - "lr = 1e-6\n", - "z_dim = 8\n", + "lr = 2e-6\n", + "z_dim = 128\n", "\n", "gen = Generator(z_dim)\n", "mx.eval(gen.parameters())\n", @@ -465,163 +466,26 @@ }, { "cell_type": "code", - "execution_count": 721, + "execution_count": 537, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 1/200 [00:05<18:14, 5.50s/it]" + " 0%| | 0/50 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -633,1396 +497,13 @@ "name": "stderr", "output_type": "stream", "text": [ - " 6%|▌ | 11/200 [00:58<17:02, 5.41s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▌ | 12/200 [01:03<16:49, 5.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 6%|▋ | 13/200 [01:08<16:36, 5.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 7%|▋ | 14/200 [01:14<16:27, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 15/200 [01:20<17:14, 5.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 16/200 [01:25<17:00, 5.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 17/200 [01:31<16:39, 5.46s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 9%|▉ | 18/200 [01:36<16:20, 5.39s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|▉ | 19/200 [01:41<16:08, 5.35s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 20/200 [01:46<15:56, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 21/200 [01:52<15:48, 5.30s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n", - "Step 21: Generator loss: array(4.85982, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 11%|█ | 22/200 [01:58<16:17, 5.49s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 23/200 [02:03<15:57, 5.41s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 24/200 [02:08<15:44, 5.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▎ | 25/200 [02:13<15:31, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 13%|█▎ | 26/200 [02:19<15:24, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 14%|█▎ | 27/200 [02:24<15:17, 5.30s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 14%|█▍ | 28/200 [02:29<15:13, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 14%|█▍ | 29/200 [02:34<15:03, 5.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85982, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 30/200 [02:40<14:57, 5.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 31/200 [02:45<14:50, 5.27s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", - "Step 31: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 32/200 [02:51<15:13, 5.43s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▋ | 33/200 [02:56<15:01, 5.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 17%|█▋ | 34/200 [03:01<14:50, 5.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 18%|█▊ | 35/200 [03:07<14:40, 5.34s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 18%|█▊ | 36/200 [03:12<14:35, 5.34s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 18%|█▊ | 37/200 [03:17<14:27, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 19%|█▉ | 38/200 [03:23<14:23, 5.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|█▉ | 39/200 [03:28<14:16, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 40/200 [03:33<14:09, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 41/200 [03:38<14:00, 5.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 21%|██ | 42/200 [03:44<13:57, 5.30s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", - "Step 42: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 22%|██▏ | 43/200 [03:50<14:19, 5.47s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 22%|██▏ | 44/200 [03:55<14:07, 5.43s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 22%|██▎ | 45/200 [04:00<13:56, 5.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 23%|██▎ | 46/200 [04:06<13:45, 5.36s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▎ | 47/200 [04:11<13:36, 5.34s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 48/200 [04:16<13:30, 5.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 49/200 [04:21<13:23, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 50/200 [04:27<13:17, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 26%|██▌ | 51/200 [04:32<13:10, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 26%|██▌ | 52/200 [04:37<13:03, 5.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 26%|██▋ | 53/200 [04:43<12:57, 5.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", - "Step 53: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 27%|██▋ | 54/200 [04:48<13:18, 5.47s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 55/200 [04:54<13:04, 5.41s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 56/200 [04:59<12:53, 5.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 57/200 [05:05<13:03, 5.48s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 29%|██▉ | 58/200 [05:10<12:50, 5.43s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|██▉ | 59/200 [05:15<12:36, 5.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 60/200 [05:20<12:23, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 61/200 [05:26<12:20, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 31%|███ | 62/200 [05:31<12:12, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 63/200 [05:36<12:04, 5.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", - "Step 63: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9R4ykWXYdfMJ77yPDpDflu7raTU9P9zSHpEQKJEiKGwkQJS60IAQIECRoJwHSStBGW2khCZIgQgJBgRoNSdCMn+7p7urylZXeRGRGRIb33vyL5Ln1omYEZkX2jx/4kQ9IdFdVZmTE+9675txzz9VMJpMJrtbVulpX62pdra9waf+/fgNX62pdrat1tf7/t66cy9W6Wlfral2tr3xdOZerdbWu1tW6Wl/5unIuV+tqXa2rdbW+8nXlXK7W1bpaV+tqfeXryrlcrat1ta7W1frK15VzuVpX62pdrav1la8r53K1rtbVulpX6ytfV87lal2tq3W1rtZXvvQX/cbf+73fg06ng8/ng9vtxsnJCb788kvo9Xp885vfxPz8PMxmMywWCzQaDbRaLUajER4+fIi9vT00m00UCgUYDAYsLy/D7XYjEAggEAhgNBqh3W5jMBigWq2i1WohGAxicXERjUYDf/7nf46TkxPo9XrodDpYrVb4/X4YjUZYLBYYDAZYrVa4XC4AQKfTwXg8RiAQgM/nQ7/fR71eR7vdxosXL5DL5WA0GmE2m2G1WjE/Pw+bzSaf1Wq1wuPxYDgcYnd3F8ViESaTCSaTCRqNBv/yX/7L197of/yP/zG0Wi2i0SgCgQA2Nzfx7W9/G0ajEX/37/5d3LhxA+PxGJPJBIPBAPV6Hb1eD/v7+8hkMmi1WigWizAYDFhfX4fb7Zb9MBqNcDgc0Gq1yGQyKJfLiEajWF9fR6PRwHe+8x0cHx/D5/PB6/VCr9fDbDZDr9cjEonA7Xaj2+2i3W6Dgg0ajQbBYBB+vx9msxlOpxPdbhff/va38ezZMywuLuLGjRswGo2w2WzQ6XTyWfv9PprNJsbjMTQaDTQaDcbjMUajEQDgn/2zf/ba+/crv/Ir0Ol0mJ+fRyQSQSaTwePHj2E2m/Hbv/3b2NjYgEajgU6nQ6/XQ7FYRLfbxdHREQqFAmq1Gk5PT6HVahEMBmG1WmGz2WC326HVaqHXn1+FdruNbrcLl8uFYDCITqeDx48fo1QqYTQaYTwew2AwwOFwwGKx4Pr164hGo5hMJhiPx+h0Otjf30er1cLS0hLm5+cxGo3Q6XTQ6XTw5ZdfIpVKye83m80Ih8OwWCxwOp3yfgwGAyaTiZyDRqOBarWKyWSCf/tv/+1r7x8A/Ot//a9lj3Q6HY6OjvCTn/wERqMRv/Vbv4WNjQ1YLBZYrVb0+30Ui0W0Wi384Ac/kL12uVwwm81IJpNwOp0YDAbo9/uwWq0IBoPQ6/Uol8totVrw+/1IJpNot9v46U9/ikKhAJvNBqvVCpPJBIfDAYPBAI/HA7vdjna7jUajgX6/j3K5jMFggGQyiXg8jvF4jH6/j3a7jR//+Mc4PDzE0tISbt68CYPBAKPRCL1eD61WC61Wi8lkgtFohOFwiLOzMzQaDbnzAPCv/tW/eu39+yf/5J8AAMxmM4xGI3K5HJ4/fw6DwYAPP/wQ8/Pz0Gq1U3dhNBphZ2cHJycnKJVKODg4gF6vFxvocDjgcDhgNBrhdrsBAAcHBygUCpibm8PGxgZardaUDdTr9bBarQgEAjAajfD5fLDZbPJ5e70eCoUC+v0+bty4gbW1NYzHY/R6PfR6Pezt7aFQKMBkMsFiscBoNMLj8UztoU6ng8FgQL/fx8HBAcrl8tQd/q//9b/+tft1Yeficrmg0WjkzUQiEXz961+HTqfD3NwcbDYbMpkM0uk0PB4P3nrrLdjtdty6dQuxWAzZbBbPnz8HAHi9XjidTkwmE5TLZRgMBjHunU4H7XYblUoFz549w2QywdzcHEKhEFqtFprNJjQaDfr9PgaDAbrdLrRarWyuTqeD2WyGwWBAOp3G8+fPYbPZEAqFYDAYsLq6ioWFBRSLRZycnKBWq2F7extGoxGJRAKRSATD4RAnJydywRqNBgCI45xlmUwmAECr1cJoNILZbMYv/MIvwGAwwOfzYTgcolAoIJvNwmq1IhaLwePxwGazYXl5GZlMBk+ePJHParVa5WFPJhO5VEajUYxDKpVCr9eD0+nE/Pw8rFYrrFbr1MVrNBqyb0ajUQIDADg9PcXW1hZcLhcWFhag1Wrh8XjECNVqNfT7fTnIiUQC4XAY7XYb+Xwew+EQ/X4fk8kEJpMJZrN55v1bXFyERqOByWRCs9mEzWbDW2+9JU6/VqshlUrh4OAALpcLd+7cgc/ng9FoRDAYxMnJCcrlMgDA5/PB5XKJEzSbzXC73dDpdKjX66hWqxiPx9DpdJhMJggGg3C5XKhUKqhUKgDOnVCv18PR0RFqtRr0ej1MJhMGg4H87P7+Pra3t2Gz2RAOh6HT6eSMlUolZDIZNBoNlEol6HQ6rK2tYWFhAfV6Xfa00Wig1+vNvG/q4jnmslqt+Oijj2A0GuH1euVZlstlWCwWxGIxBAIBvP/++1hfX0e5XMbx8bG8l+FwiE6ng0ajIcGcTqeD3W6H0WgEAGQyGQyHQ7hcLgnOAGAwGCCdTkOj0aDX68HtdktwZTQaEY/HodFoxG64XC4sLi5Cp9NhfX0d8XgcOp1OgoFUKoVOp4NoNIpQKITRaITBYIDhcIh6vY5utwuLxYLhcDjz/nW7XQDAeDzGYDCAxWLBzZs3xTFMJhPkcjlks1k4nU5cu3YNTqcTGxsbSCQSOD4+xmAwwGQygdfrhd1ux3g8RrVahc1mg8/nk8DPZDKhXq/j2bNnGI1GCAQCskfcJzrcWq0m7w2ABLE6nQ75fB6Hh4dwOp1IJpPQ6/Ww2+3Q6XTy7IbDIQ4ODjAajTA/P494PI5qtSpnkK9vNpvFOV9kXdi50Pgz4mVUQmOu0+lQKpXw6NEjxONxvPfeexKRDIdD8Zaj0QhOpxNWqxW9Xg+1Wg02mw1+vx96vR7FYhHA+UU4PT2FyWTC6uoqXC4Xstks8vm8ZCL0opPJBMPhUIyP1WqFwWBALpfD1tYWwuEwPB4PHA4HEokErFYrNjc3kUql0O12USgUAAAejwfz8/Po9XrI5/PodruoVqvodrtyMWa95IyMu90uWq0WXC4X7t27B6PRCJPJhNFohFKphL29Pfj9fiwvL8Pr9YpRslqtODk5wWg0gsVigclkQq/Xw3A4xHg8BnCebRgMBpjNZgyHQ+RyOUwmE4mIGbEOBgNxcu12G8PhEDabDRaLBTqdTiK/fD6PnZ0diZAYXTscDrTbbTHET58+RaPRwGQygcPhQK1WQ6FQQK/Xk9d3Op3weDwz79/c3BwmkwkajQba7TbcbjdWV1cl2mo2m9jd3cX3v/99LCws4O2330YgEIDZbBbDSYPncrng8/lQKpVQq9Uk89Xr9RgOh2g2mwAAg8EgkTUdDZ1xp9MBAGSzWVSrVVgsFsk66KCPjo5wdHSEUCgEnU4Hh8OBaDQKp9OJzc1N7O3todvtisPy+XxIJpNoNps4PDxEu91Gs9lEr9eDzWaDw+G4lJNpt9sAzqPp0WgEv9+PW7duwWQyyR3K5XLY3t5GIBBAMpmE2+1GMBiETqfDixcvUCwWxUCPRiM5z3q9HpPJRAJQk8mEdrst99lms8HpdKLX66Hb7aLb7eLs7Ayj0UiCGr1eD4PBAJPJhGAwCJPJhM3NTfzkJz9BMpkUA5tIJGAymVAoFHB6eopCoYBHjx6hUqng5s2b0Gq14vhGo5Hck9FodKn96/f7AF7aG7vdjkQiAYPBAIvFAgAolUpic27dugWXywWv1wutVguTyYSTkxO5D1arFfV6HY1GQ7IFo9EoX+12G9lsFkajEfPz83A4HFP7VyqVMBgM0Gw2JcjWarWS1ZjNZvz0pz/F/fv3EY1GJVNikJnP5+WMHR4eigMJhUKo1WrY39+XwIYZr91uv/AeXti5MOrr9/uwWCyymbyAWq0WFosFbrcbWq0WW1tbyGazMJlMMBgMaDQacDgcUw/bZDLB4/HAYDBIykYnYTAYYLfbodfrxSvzIDItnEwmqFaraLfbAg0RFun1etBqtXC73RIFMJIxm80oFosSoTLTYbpOAzwYDCQi5eWZdXW7XYk2xuMxTCaTfC673S6QotFoxGAwwO7uLqxWq8AvNGA0ft1uF16vF8FgEADktfV6vRhRZiiEc5jq0smMx2O0Wi1x1Ha7fQqiHA6HsFqt0Gq1KJfLElExws9ms+j1enJg/X4/PB4PxuOxGFkVqrjM5T49PZX/12g04vj53Hkh6Qi2t7eRz+flczQaDXg8HkwmE3Q6HRSLRRiNRiwuLgqsApwbQbfbLQZSo9GIs+n3+/K9vGQ0YszMJpOJZHQajUbghlqthsFgAIfDAb1ej3a7jU6ng36/L4GHur88w7wLOp3u0tkLnQtfazgcyh7a7XYYDAYA5/es2WxiZ2cHDodDkAY+636/j/F4jG63OwXv8e8mk4mcR6PRKP/P52+xWDCZTBAIBOT5lEolOBwO+Hw+TCYTZLNZsRVerxcGgwGFQgHtdhsejwcWiwX5fF4gY5fLJRn/3NwcGo2GBGM0jAyQZl29Xg8A5J71ej20Wi159jzrwDkCc3BwgFKpBKPRCJ1OJ2UBjUaDer2OVqsFu92OhYUFcfC9Xk+CRZ5BBjbtdlvus06ng8vlkrNdr9fhcDjgcrmg0+lQq9XQaDSg0WgQCARgt9vRbDYlMBiPxygWi8hmsxJ4mUwmOJ1O2Gw2QYjUpdPpprLPv25d2LkcHR0BOE+licEziqZxZurVarXwx3/8xxgOh4jFYggGg7BYLAiHwxgMBkilUmg0GlheXpZM4ezsbOpCsYZC3JnwmcVigc1mQyQSAQA8e/YMp6ensFqtCIfDGI1GOD09Rbvdhl6vRzwex2g0Qi6Xk8xGr9fj6OgI6XQaZrMZGxsbcLvd8Pl88hAYHRCn5cOfddE5c2k0GlSrVdjtdszNzcHr9cLtdsNut6PRaOAv/uIv0Ov1EI/HBW5wu92yf61WCx988AHefPNNtFot7O3tod1ui6PX6XTQ6/UYDAbitOmUeUgGgwEePXqE4+NjJJNJgeeOjo7QbDYlghwOh0ilUtBqtQiHw7Db7VM1D+4faww6nQ4HBwfQaDSw2WwS+VwGknj48CG0Wi1CoRB8Pp9EzYRQmJ0lk0n0ej386Z/+KUajkUCIPJvj8RjpdBqtVgtvvfUW3nvvvalM1e/3w2QyiUMkVMR6FDPjUCgEANjf30c+n4fD4YDb7Uav18Ph4aE820QigX6/j9PTU4E8CAczqmdwYbfb4XQ6BYptt9sSZdLwX2ZVq1WJbC0WC5rNJo6OjmA2m7G0tASLxSJZa7FYxNHRETQaDa5fv47FxUX0+334/X7Zk06ng6WlJaysrMgecp8mk4kEiKPRCJVKBf1+H06nEy6XSzJg7lc6nUYymUQ0GkW328Xjx49RqVRgNpsxPz+PwWCAra0taLVazM3Nwel0IpVKYWtrCyaTCUtLS3C5XLh16xbW1tZwdHQksDADApvNJlnELIuwIgNcnmeLxQKPxyO2hXv9ox/9SFAHOh+LxYLBYICTkxO5wx988AE6nY7c6+FwKJluMBgUm9ZoNCQwZK1lNBrh2bNnODs7g9lsRiAQkPvKoJs1l0KhIM8GOLfpz58/h9lsxurqKtxuN8LhMAKBADqdzlTtiJ+btd2LrAs7F2YUjLyB86yFEf1oNIJer4fNZpPUjUVMGgFuPDeID50pK6MYvr5er5+KdmkUGWXyPdD4/zxPy6iFEBojakZrLM4xNWcNQ03R+TqMXGZZzFLUgp/6ewHI+1IjV9agiHey+Mz9ozMBIGSAwWAg+83XJpZNY6/VaiXD4J78vP3jM+P38YLQ+ZvNZilK0gETAuCZYI1MxYVfd/H8vZqFcb/4Owkd9ft99Ho9+Qz8GS7+2WQyyZkeDodyBtWiOv+d0R2DKQBTxWR1qYVzPie+T61WC7PZLMaB50zda+4fzyehmMuswWAAjUYjtS++F/X50wEyg6UTHwwGchd5N5j1MxPRaDTyPkej0dTrcn9ZF2RG9ur38f+Z6eh0OthsNgn2uD80sLzDdFa0AzynAKayZ2aUsyx+fhpnnhH1nnH/WA/mfVBtETMf7iNhbH7xDk8mE8laAMgZ5PnjfvGMq89SRTL4PHu9nrzWZDKZImhw/1Sby0BIRSH6/f5X71z45l0uF9xuN0KhENbX16HX61Gr1VCv12EwGBCPx2GxWJDJZABAYDHCIow8xuMxgsEgjEYjut2u4PO1Wg3tdht2ux1Wq1UMMAA4HA7JLLa3twW7vHbtGgBM4f42m22K+RONRuV1NBoNVlZW8O6772IwGKBWq0l6eXx8jNFohLm5ualM5/DwEFtbWzNnL9lsFhqNRiAku92O69evw2q1YjAYSGbDyLnVaqHT6cjBU2E67rvP50O5XJ5Kl9PpNHK5HPx+PxYWFqT4OBqNEA6HsbGxgUajIXiqWpcgSSCRSKDX6wkTiLUqkh48Hg9u3bqFX/u1X0O/30e1WhWo5OTkBIPBAEtLSxIlTSYT7OzsYGtra2YD6Xa7p9hgfr8fd+7cmSIJaDQa2O121Ot1AOcwEKEF7ul4PIbNZpNzSZJIoVBAo9HA7u4ucrkcvF6vnAEGTfF4XNhPhBMikYjUxVqtFgaDAfx+P5xOJ4bDISaTiUAfjCztdjtCoRC+/vWvo9ls4sWLF0Is4D3a2NiQbBM4L4zv7+9fKnsuFovQ6XSSoTidTsTjcXHKOp1OiC/5fF6yOQBiUBiQLCwsSCRLA8Rib6lUQr1eh8vlgt1uF4fDoMfj8aDZbKJUKgm8a7fbpwra8XhcziSJNHz+TqcTFosFa2tr+MVf/EUpbI9GI/T7fWxvbwMAbt++DeA8sBsOh8hkMnj06JEEr6+7uPdkC/p8PiwtLYmhp625du0ams0mjo+Phazg8/nkdUwmE9bX16HRaBAKhaRu1Wg00Gg0cHZ2JmxHNZA2mUyIxWKIxWJTdRISVKxWqzg0j8cDp9MpwQ2fMTPTyWSCu3fvwmq1CgxKMsrBwQHG4zFWV1cFRTIYDEilUtjc3Lzw/r22cyEswM3VarVCl2Rk3Ov1JMNglM1ohOkeIxIeWnrtfr8vRhWAbI5WqxXYoNfroVwuo9frwefzIRAICFUTgBSmGXUR3qEH5+cxGo1otVrY2tpCvV4XogCxR7Xecnh4iEqlMrNxbLVakpnQsNGw53I5ucQ08Iwi1CiOl5jUQ4vFIg6U0XW9Xkc+n5faDfDyUqisJUaSNLQ2m00idUKeZAExyrZYLAiFQnJwPR4PWq0Wnj17hlqthlarhVqtJgaE2RGfe7VanXn/GIWyWGsymRCJRATeIeTCM8eLxb3WaDSyHwxYGMmShk3mVjabBXDu6BkZarVaeL1exGIxlMtlZDIZjEYjqYl1Oh1xXoSK2+022u02TCYTAoGAUJ9NJhO8Xi+i0agw0IrFosCYOp0Ofr9fqNwAkM/nhd496+p2u3IvSMTxer2yF4QxWXNUDREXzyCZjGoUy2h8OBxKPYaL95tOiFAt63oMHJkdO51OQSR4By0WizgfnrFgMIh+vy8wU7lcRrVahdPpRCwWk/pgr9dDJpMRFuMsi+eYGYfVahVqPynUZrMZfr8fBoMBp6enGAwGAnnS+bFeYjabYbPZJIgj4tNsNtFoNGC1WtFutyV7oQ0MhUJyD/r9vtxd7jMAQTl4fqxWqzhvPtNwOIxkMolut4u9vT1xbLVaDRaLRc4Gn8XZ2RlKpdKF9+/CzmV1dVU2uNPp4PT0VAxJMBiEz+eT6JoXjIeYm9pqtaYON5laNEq9Xg/BYBDJZBIWiwUOh2OqxkBH0m63JQNgek7apslkQiKRgN1ux9nZmRjnw8PDqaiHzqXZbKLZbKLVak1hsrxYvAButxvr6+szX+63334bAISAkM/n8dOf/hQ2m00KlIx0NRoNnE6nGEVG5HTmjLZVWJHMmPn5eWEkBYNBtFotYfm43W6YzWY0m00pOrPXBwDq9TrMZjOi0ahgw8xM9vf3hSvPPhGHwyFngYaVjpBRN38n+27o3F93ra2tSTGezuDJkyfi8EhFZ3RLKIoZMJ83KdrNZhNarVbOLLOvhYUFJJNJ2O12BAIBiYQbjYYY3nq9jrOzMymEcq94H+bm5uR58qtUKqFSqSASicDlcknPCp0yYVAWdGksaBy8Xi8SicTM+wcAGxsb8v/FYlGyKovFgkAgIJEv4V+fzyewYalUmoJh+F86km63i2KxKMaOEJVWq5V6Al9Dr9dPUZh9Ph88Hg96vR4qlQoMBoP0zfV6PaGMp1IpjEYjMcysS5HGz2zbaDRKnZWIyXg8hsfjwd27d2e+w+vr6wAgnzeXywlkHYvF4HQ6AUCgI+4T3z+zRrUGSZovg+Nut4twOCx3OBKJoNfr4dmzZ6hUKvJ5Go0GKpUKBoMB7HY77Ha7OCiyedXaIeuyo9FIiEtEktgXxnqPmokxIBgMBjCZTNK3dZF1Yedy/fp1jEYjnJyc4OzsDLlcDqenp7DZbPiN3/gNLCwsoFwuo1AoYDwew2q1TtU7mLbyz3q9HvV6XSApFpDW19exsLAA4DxKqlQqyOVyODk5QTQanfL8xF2JJ9ZqNbhcLoRCoSnvXqvVsLOzg8lkgvn5eWGf0LmQuRGLxeD3++X90GkxzXQ4HK97HmV9+OGHGAwGePDgAXZ2dpDJZFAqleB0OvHRRx/B6/UCeFkTUvsC+OdoNCq0bhZneeFpTJeXlxGJRMTIE97Y39+HTqcT+IqRqdvthsvlkqhdq9UikUjI/ul0Ojx69Ah//Md/LM+K9F2z2Sy9QGQRsu5CZl8gEIDH40EikRAsfpbFJtPT01OJ4r/44gtYrVZ84xvfELIDLxPfn8vlgsvlkj83m008ffoUJycn0k9FA24wGHDt2jXEYjH5veVyGQ8ePMDJyYkwdjqdDs7OzqRfgYV8RszhcFjouzqdDicnJ/jkk0/Q6/Uk6ibbjYECDRazC2brzF5ZSL9M5nL79m2MRiPs7u4KZMO+BxbZ6cDJ5nI4HBiPxzg7O5PmYn4uQpSdTkcc7mAwwMrKCsLhsDQ9shk4lUrJPo9GI6EwswXg5OQE6XQaTqdTzvHZ2RkKhQK63S729/fR6XTg9/vFoFYqFYzHY2FCMZjo9XoolUqYTCbSaO33+7G0tDRzzeXGjRsYjUbY29tDOp1GsVhEqVSC3W7Hr/7qryIWiwnEpNa0er2esLmIqhA5IPLQ6XTk/a6vryMWiwl5ieQPQtnM1An/RqNROBwONJtNsaPhcFhsJHuuCL9GIhE4nU50Oh2pMbKnhfeE54DBOWs9S0tLF96vCzsXtdDNqIw032aziVwuh1qtJt25LAIaDIYpOIIem41ALLaquLma8g0GA4nuSbGz2WxSrwEgxS8WTcmQYhprs9kQjUbFqObzedjtdunCZ8TIiJ7fx0idHn5WlglwHu3Q4KqQjc1mE3oxDQ0LbyzMqVRO9UG/+nxUCI0Xu9PpiMPVarUoFovSNMiGS9KiVYiSTpzveXFxUS5NuVyWvhnu9auNfnz/rVZLIDo6wFlWq9USp0V4lrAl+ynI2WcWB0CeK9k6NDbEqFVnqNYVePlHoxE8Ho/0OJydnYlTZvMvsyK1+M7zw0hwbm5Oal+kQTPj4d+rmb9a/OU5oFGedTEbJ3xN6ASAZHKE6eh4VMKD2iBJqIb3h++b+8czSzjH7XZLlpHJZIRhRRSBe8Cz0+l0pA7A3zs/Py9nularSeZECjSjbPXZTSYTcdqsnc3qXFTSAQMAZn7sVyqXy2IDgZflBP6saud+3utz0QZxb51OJ/x+v/SfMSgwGo1yLl6FMAGIzTCZTFhYWJBnQKSG6ESj0ZByhJrxaLVadLtd9Pt9CW4uWve7sHMh15+HcjKZYHFxEcPhEIeHh3j+/LlcDkb+k8lEoBen0wmv1wuNRjOFT3q9XnFE6oa0Wi2R3FhZWcHi4iL29vawu7uLRCKBt99+G3a7HcfHxyiVSpL2ms1mwfZJxQuFQlhdXUW/38f//J//Ew8fPhTpCEaQzASq1aoUwMbjMcrlsuDHl2liOz4+BgApRJpMJsGYm82mZCN8H0yfuZ9sFCT2z0idB5ByGYRmKpUKstksxuMxrl+/jhs3bmBzcxMPHz5EMpnEG2+8IQ6bLKxqtQqNRiPRIC+S1+vF7/3e76HdbuMP//AP8fjxY0QiEaGnVqtVdDodqTUwc9DpziVGMpmMFH9n3b+dnR0AkGfDTG48HiOVSuH58+dSP1H5+MTYXS4XIpEINBqNZGbE89XGSWYgJJhoNBrcvn0bGo0GP/jBD/CjH/0ICwsL+K3f+i2BgkmmGA6HMBqN8hp09F6vF7/5m7+J4XCIP/qjP8KDBw9k/15lBLJuwedP48D+rMsswq5er1dqona7HcA5pZrwYLVaFVkam80mEKrNZsPCwgIMBoMY73a7LXeEAQXlavj5zWYz7ty5g5WVFbx48QLf//73sba2hr/39/4eAoEAut2uvAZh7uPj46neqsXFRdy7dw+tVgv/7b/9N3z++eeCQpAQo1Lx6UABSH2WNmnWM0jjSnjL4XAgHo9Dq9Uil8shl8uhVCqhUChAq9VKXVStPQOQYIH3i8+cwQ8zHTWw3NjYwNLSEr788kt8/vnnSCQS+NVf/dUp6SYGpXRMvA/sFfqH//Afot/v4/d///fx4MEDgc9arRYODg5Qq9Wkz4WKAVqtVvbvdQPsCzsXRm6M0LgxlF4oFotTtEN6UrJEVBwZeMk6IazFSIhRN/FDAFI4ZEMlLzElVYhxMnIkDkwqH40RoblGoyFFcNUL8wDyEr4a9ZDKOctSC/aksxKGoHFmiky4j3vC98kDqXY0q82dzLRarZYUk0kA4CXt9/uyfwwSgJe0Y+KrfB/si6DOFpvHVHhGzapUhhjfD3n7xHJnWTT0wEttJ4fDIYFMpVIRA682ivIcWSwWMQxq3wHplTQ8PDs8g3q9Xpo09Xq94NIkl/As8Zyp55jvhzU0GmQ2dDIjUPeL36/+l//+Kt35dRczAzXjInLATEE9gyrsyjPC4jFlQ9TzqVKRu93uFMOLjakGg0GiZ7ImeccYRNGu8Gf5vL1er6iBqPVJ1iHUv6Md4udmkPY6VNpXlxoA83mTLVepVKb2kI5b3Uf+HAM6ZnUqnZg1OipA8HsIybNzn0QBQoBqxqvaYO6LTqeTYIg2V23zoCNirVy9z7ThapPoRdaFT2smkxFaGr0xox6uZDKJ5eVlKR5RYoQbEY1G5bKqB1in00m38v7+PnZ2doRNwwsAAIFAAMvLy7Db7djf34fBYJBCLKEf4KXmEeG0druN//W//pcY+Nu3b4scgt1ux507d6QngjhyvV6HRqPB8vKybPhl+gzUDIFRAI10qVRCs9lEMBjE2toaWq0WDg8P0el04HQ6hcqYSCSg0+kELlDVB8hWOjo6wubmplBpWVvSarW4ceMGotEoAGB3dxcHBwfwer2w2WyCsdO5NBoNkYsol8v44osvhHn3/vvvw+Vywe/3S9bZ6XTgdrvhdDqn8GAaBFX4c5alGjjVIA4GA3GkCwsLWFlZEao6CQrcv3A4LJGxStZg5Nfv91EqlVAsFuXsMJvl/nzzm9+EzWbDwcEBTk9P5f282h9DuIdU/f/4H/+jGNHl5WWpGxgMBoEo2S9EliOp6yy+XrbPpVAoyGuSMMLMjRnz4uKiNDKenp5KTYpROPs6aBS9Xi8cDofQ29vtNtLpNA4ODhAOh7G8vCwOfTQa4Wtf+xrm5+elWZSZEkk6c3NzU+xSfu6joyP88Ic/FBThF37hFxAKhUQuh/eVagLtdlsIBLFYTGi4l3HQbK8YDoeSpbNE0O12Ua/XEYlE8NZbb8n+EVanFlk8Hhd2GZ0hACEndDodZDIZHB4eIhAIYH5+XuBznU4nDZEWi0Wkbxg02+12EfSlLAz/rlKp4N//+38vjunWrVsIh8NIJBLye3nnCWESOaKdYX/bRdeFd5oPitEXO4fVFQwGcefOHVQqFcFESfGlQCMxQkYqjAZIANjf30cul8Pq6qpsLCM3p9MpUEgmk5nKOshaI0uE/HK3241yuYyf/OQnaLfbWF9fx+LiItxut/xORh+MVmu1GqrVKnQ6HSKRyBTVeVbMmymxGgnQuPG1k8kkVldXUSwWhaHENJW9RYx4aMz54E9PT9Hv94X8cO3aNdy+fVtgmvF4jGQyiY2NDWSzWfz4xz9Gp9NBMpmE3+8XfTdma/1+Hx6PRzTNeLHfe+89rKysiGEiR7/T6SAQCMDr9crFASAOSsWbZ12vNompGS5T/zt37iCbzWJrawvtdlvov4Rl1eyZTb4AJGokXh4Oh0UFgpCN2+3G7du3pc+FF09V1KbxJSzDnq8/+ZM/QafTwbvvvov5+Xlp/iN8wroCGVIqdZ36fKwtzrroQOx2u2QuJGXQeUciEbz99tvI5/NIpVJCkiF9mw6Tz4Hsy1KphNPTU2GNFQoF6PV6XLt2baoXyev1Yn19He12G5lMRog41LXy+/3QaDRTfRfD4bnm2V/8xV+g3+/j448/xsrKimjEVatVHBwcSI9RMBhEPp/H6ekpNJpzde+5uTmpyc26h0RnWBpQG7pZ4/T5fLh37x7K5bLUrugkaaMIkbHOyaCWPW2lUkmYrisrK0JZZh+hyrRlVkKEgUV82hYybE9PT/F//s//QavVwje/+U2srq7C5/MhGAwKoaDdbsPr9cLlcglhazQaIRqNSi+S0+m88D1+LSryeDxGLpeTiJe9B+R7D4dDpNNpgQpY96hWq8hms9jd3f0ZBlQkEplSfnW73dIcqXarE7v2+/3odDqysTabTS4gIR/WIlqtlvRuUEKCDBiVB07nxUsNQAwLmTwqTDfLSiaTGI1GEvES0gEwxaIj1RaA1KfULmn14jG6ZbGbjXEqrZSR/WQyERl54FxlmCqybFBk4MCCuKpCHYvFMBwOpa5FfH40GklE22w2RauKWWStVkM+nxfjPiskQRr4wcEB9vf3RYOKhsJsNqPb7eLk5ATValWkbijfDkACG15GRmIq9ZvZB/u3JpOJ7Lff7xcqPPeA/R7MHLVarRjLbrcrBeSNjQ30+32EQqEp1WCNRjMF7xKCpcouDQ2d+WXWG2+8gfH4XFNqZ2dH2F+Etghb0jCpUTWJGcfHx9DpzkVqe70eotGowNaE+fi6rCmynjccDhGNRhGJRFCr1dDpdKQhlk6WBXreZUKTer1eRhuQ3k5DzECLkDh7kJLJJDQaDdrtNo6Pj6U/ZdYgZ3l5GePxGNlsFkdHR7Db7QgGgwLx0x4y2GIASfuVzWbx4sUL6HQ6NBoNDAYDRCIRzM3NCSTIszgej+Fyuab2Dzi3tevr66jX64IyMAikbaXdJXkEOIf01tfX0e/3p3r+CCerOnqVSkWaW8nEa7fbwjD7yp3LRx99hF6vh//+3/87fvKTn2BxcVEa6zweD1wuF7rdLh48eCAFUsIMuVxODBU7nV0uF5LJJO7evYtSqSS0UDamhUKhqf6Lfr+PjY0NrK+vo1gs4ssvv0S/30csFoPX60W9XpcDzyJWuVwWjax33nlHDDhrMWpD0WQyQavVQqFQgMfjkZ4M0lAZPcx6MO/du4der4fnz5/js88+kx4Ko9EoF3swGKBSqYiGEQvShNEeP34sOLRWq8Xy8rI4RdK7g8HglOLqZPJSyZc6UMFgUMRCmcEx8iQkyAIyIYq7d+8CgGDnhUIBuVxOioJ6vR6PHj3C1tYW1tbW8Lf+1t8CAPzRH/0Rtra2sLKyIrpms6yPP/5YNKf+5E/+BPPz89LgCZyrN1SrVTx+/FiKyDrdueQ45cOz2awUyw2G87k4HBfB+hAhrcFgINkJ63fr6+t4++230Wq1kE6nhTFJhdmjoyP0ej3kcjn5Nzqtjz/+eIo1pNZXGCBls1kUCgUEg0EsLCxgNBrhBz/4AY6OjuD3+xGJRC7FWPzN3/xN9Ho9/Kf/9J/wgx/8AF6vF4uLixKB0zjy/hB7p9YZ+zA0Gg3Ozs4kk6U6Op2Rx+MRKJJ1r+PjY9TrdczPz+PevXtCX+92u0gkEggEAjg7O8Ph4aHArCoD0mQy4fbt29BqtYjFYnC5XCiXy0in09DpdNIwyTOYSCTw/vvvQ6PR4LPPPkM6ncbc3JyMjphlffDBB+j1evgf/+N/4PPPP4ff75csnnUlAILccB/Zy1SpVKS8wM/2jW98A3fv3pUaKmnEoVBInAsZrv1+H++88w7eeustYX12u12sra0hHA7j7OxMziA7/FutluiO8QzSibXbbZkRQzjxyZMnoop97do1jMdjPHjwQFQrgsHghffvws6l1WpJNAG81E4iBMA3q6bujMpepT0Sg1T1x9RCIr0w8BJGIlODv5cSFjzUxBj5HllUZSTKCEiVoqEXprHm6/FA0wDw86iFudddfG8qtZm4LfeR3fkq0UDt21CjLkYorFWxqMfX4f7QQJBVRsICC9rcj1f3j8aWl1ylxHK/WbgE8DOFS8KHaqGV+zvLIr1dzSwYzbOOwuK8ynTjZ+Rz5ZlSabTqFwMP7j/PHveRr08qNF8bgGTMfG7E4kkf5z6pz477QjiNBuZVGFUtVM+6yChS2ZnM3gh5Ea/n86PRUxU3+PkASDBCosNkMpFnwsKxeofUSJ60bVV1nO9NZXWplGY+V+4vm4lZH1PPNG2VCkHzjsy6f6oNpB3iXWKRn7+LhAISdGjU+fzH47GMruDdIxKgEqd4XtVCOwDJNlT6Nds31PqSSrrg4ntgRvoqueAyQQzXhXf5v/yX/4LJ5LyjeHl5GclkUqiKKoOExbmTkxOBA2gEqDPEDX327BlOTk5Qr9exvb2Nfr+P5eVlzM3NSYrb7/dRqVQkWuRG+P1+jEYj1Go1mfNyeHgIrVaLQCAgzmk8HiOfz+Phw4fQ6XSCeafTaezs7MBkMglJgFMXSSxgqsos6nVmGby6fv/3f19gxbm5OayuruKDDz4Q3Ji4NZvzeBjC4bAUYEOhkPDcyQQ7OzuT/R6Px5ifn5eiHvF71gx2d3fRarVEHp/8fBIB7t+/L5GhzWYT1hl58DqdTjLWYrGIdDoNm80m+81eGqvVip2dHTFQrMUQD55l/ef//J/F+Lz77rtIJpN48803Rd2ZLCyODyDUSNhBFe3k3rbbbTx9+lSaIkkMYTYeCoXkLHC+EPsDOG+ETolRt15/rsRts9lQrVYl4uTzWlpags/nk5oGFWnJLCJNmAEBs/hgMCiEi1nXf/gP/wGTyQTHx8fweDxYWlrCL//yL4swJB0B5dqBcyiRk1p9Ph/m5+cxHJ4Pl2Ix/rvf/a6QQAAI1ZvQKWFuq9WKYrGIH/7wh9KrRAmjXq+HdDotd5hwG41xt9tFNpuV++12u9FoNHB4eChsMg4FdLvd6HQ6uH//vjgz0u5Z+J9l/cEf/AHG4/PhXouLi1hYWMAHH3wg9o+N4eycZ9AQj8cF+fB6vej1etJ6sL29LYrRlUpFiCOsLTO7JUGkUCjg888/F3KV2WzG8fExtre3BdLS6XSi0sygtF6v4/HjxwAgFO5KpYLDw0OZRcSatsvlwmAwQKFQkDNoNBolG/3KM5cXL15Aqz0XrqS2FIv6TqdTGm9oUBh9sSeD0Q8zlsFggFKphFKphFarJT0Zi4uLUgBmpMgImpIHbESk46hWq1JEpOYQU3waJDJ7yFwjXstsgQU14LxOwPkb1BDi3IpZD+b29rZcFGLSLJRFIhHY7Xbs7u5OORcAciA5SIqRC8c2s0hJ6IsEBUZLXMRXh8OhvB4Lf+ywpiYZp9ixYM4GMZ1OJzUD0i6Bl/0TrL2RXs0ITx3LMGvUuLm5CY1GI/sWiUTEwDOjIT7MvXu1+Mr6CiNEyg61Wi3phyE8ZDKZ4PP5RJOK56/ZbE7BA4zC+RxIM3c4HFMsPvY+EO7g2GqeddYNGXXzDKiZ/2UmoXIPmXWaTCa43W6RuuG0RjYBMovjneeIbI4lZw2gWCwin88LAsDGXJ/PJ/eImZvRaBQpGIfDgVgsJoQTarvV63WJ8ulk+UU6OjMb9tPQeRPy9Hg8yGazMsaDcjEAfqbZ93XW7u6uGHoaWnbH0/6xc19FWaiAwACWtUEyEcmsBCAtFi6Xa+qOEbVot9vI5XKwWCzw+/0AIHeXcCLPO+0A64Bkf3GyKptR2RNDij0h5nK5LGQsns/XsYEXvukffPABJpOJpMBMOylbwAI6iz9kbJXLZeHHk60TCAQQj8dRq9XEy5PuC7xMY5niqXMhOFKWODiNrMPhwPXr10U5lFS9XC4njYQajQalUgmff/65FHlZAGTjINPxubk5wZv5eS9Dpf3ggw8wGo2wtbUlc92pxHv//n2BHVVa7Gg0ks/g8/nQbDbl8obDYeTzedH0UjukmR0QwuEkznq9LiKZLCqTBj0ej/HWW2/BarVidXUVDocDh4eHOD4+FhE7rfZcJ+rw8BCNRkNkVQqFghinfr8Pt9stDbbFYnGqqD9r5L26ujqV1pPZpdVqZd4KswgVjiqXy1LHo1AoszbCaerl4qRDnU4nUxfZ7NtqteTr5OREYB+emZWVFVgsFtG2I5lFHQUAQC45RQ9TqZTQXIFzTa+VlRUMBgNsb2/LQCrK88y6Pv74Y4xGI2xubsqkSw70Ozg4mOoVYr1gOBzi+PgYx8fHcDgc2Nvbk/PHjJ+K06TFMlgjVESHxkI9IRk6U9ZGh8Oh6AomEgnYbDahzLPDnNl6JpORWi7PAqnypIaTxENdN5fLdakA8Wtf+5qgD6VSCY1GA6lUCnq9XvpcaLM4hI9ClCQwkQ6fTCaxtLQk1HfCi2xVUBuk6aioyUZhSZ47Eqh4TtUzToXl4XAo01yZcTKLI/u2+lfjlhnEzM/Po9/v4+joSBqsGaBdZL1WQX80GuHx48fY39+fYpXs7e2Jl6OBUVWGKToZj8fh8/lw/fp1xONxHB4eysWhc2F9hNE08LIrmxvDdJMwXafTgc/nE6cSCASg1+uRz+dxdnYGv98v408fPXqE09NTaUAajUZIpVKCl5IyTYE2QnJq1/Qs68MPPxSqcLlcFghsPB7jz/7sz7C/v49oNIpEIiE02+FwiGw2i1qtBp/Ph3q9DrfbjbfeeksohHwNMr0ASEZCIgCVkJ89e4ZcLidOikXkarWKpaUlvPPOO3C5XFhYWBC4gmkzhUsfPXqEk5MTWK1WuP9qpverSrMulwvLy8sYjUa4f/++ZJuv24SlLgpXcjTxaDQSI72/vy+DpdgsydoSeymoGUciSSAQAACp+/EyezweLCwsoFQqCdTIs0LaOEUUVWza6/VibW0NVqtVYJBKpYKzszPJtIFzdWNOJOQzPDo6mlI44GA93gcKvl6m5gcAv/zLvyx3cnd3F/V6XQrM9+/fx+npqcAjdLpkgObzebmngUAAf+fv/B2srq6KKGixWJRxC6ynqE2a3F9+9ft9mTSbTqdRLpcRCoWwsLAAm80mwpVPnz7F1taWkH90Oh2++93vYnd3d6o5kqQg7o/H48Hi4qKcE06EfN0uc3V98MEHGAwG+PGPfyzG+OjoCKPR+cCufD4Pv9+PUCgkzoLZIO9uPB6H3+/HL/3SLyGZTMoYCmr7qXtFewq8lJGh1BHtJaE4yjxRNJWBy+HhIQ4ODmSYHwA8fvxYgiOyxjKZjECOXq9X9N76/T4ODw9RLBZhMBhEuuoi68LOpVAoTElcqIVM4olqMbLdbmM8HotYGxkkpAyzF4LRHymRVDtWtWyIX7J4RcybzZek2vKw8VKazWahivJyUlNM7ZTlvzH95mvyoXLUL6OuWRblWWhUOP6Wn5nCmKz5MBLX6XTy75wTwuKnRqMR2I4UY1Xz61UePSNRskP4u9g9X6/XRUaHDp7PnDRo/j6SOPjFTHY0OhfuOzk5AQARDNTpdDIrfpZFORVmrMBLUgkvCdV4u92uqGyzYMx/J1xKLJvwC8cMcO84W0jtjueZZM2K9GsGVJRJYSMp+0cYLLzat8Kf42cgFNxqtaYyGcLOl+lxASB3jgVw1kAnk4lAeazvsSmw1+tJlktokYaL95N3LRQKSQ8cgClYmwaTGRFrmMzE2QLAe8fnR+dOSIj3kSOSSdShLWL2TqPOn2cd8ueN773oyuVywh5kwMsAlcQIQqoM7phRGI1GEQclLE/mHWu5pP6yXswMiH/H2hP3j2eQpCjeD+ClogrPHJmytIGBQECgV95fnn3u0dnZmdwTvkf2X11kXdi5/OAHPwBwbrzYGEecMRwOw+12y4Xioex2uwgEAnC5XAJL6HQ6Scv4eixa6nQ6odKqr0MGFb+Wl5dx+/ZtmR1DfJ8d2Sx0+Xw+3Lx5U1J04Ly/Ix6PC3UZeDn7gFEunQCzlWg0Kvj8rBf8s88+A3BeQ3n//fcRCARkZseNGzcQiUQkMiwWi3jy5Anq9TpWVlYQjUYRi8Vw69YtMTKvOp61tbUp9lSr1RKD3Gg0pG+DcMSdO3fgdrulC7tYLOLp06ciRMpRxp1OR5QQKJZHGjMvh6pMTXIAxRn9fj/eeecdbG9v4+nTp1OyMa+znjx5IjUUGi9eOL/fL3Usv9+PQqGA3d1dVCoVEfzj7ApmNnSkDodDGit5iZlx7O3tAQBCoRAsFgsqlQqq1Srcbjfu3bsHm82GJ0+eIJ1Oo1KpSEbMYXeE7VQIj535JycnODg4AADBxsmIy2Qy+Mu//EsJetiTRAM869rZ2ZHu7ps3b0rzMGFgjvl2OBzI5/PY2dlBvV7HnTt3sLS0JNkqmy8JRVFahN31dFosUtNIqr1THDvNfi8Gb6lUSiROGPyEw2GYzWakUikpkFNIlWeag9oYYDLz1Ov1WFxcxOrqqhAGZm2E/su//EsA506TCg7xeBzAueNm1udyuYS+3Wg0sLGxgUQiIaQmSuCk02lMJhPEYjEMBgOEQiHpbwEgJCY6bGYp9XodgUAAb775ppQLCKtTFJS2S6fTSasAbQb34+zsDOl0GgDElnOIm0ajwdbWlvRcLS8vo1arIZ1OX/gOX9i5EI6i4SYsBUD+nzRANSNhwZ9FSQCiLcSIUqXAMSsCXlI7WcRmZsHoi4aUuC6jWmYy9NLMahihqdPXaBwZxZLWR6Oq/o7LLOKbJEOo6aXFYpF+CMJVdKQq3ZF1ApXOzPfIn1dTfn4fAPlc6j7TmbE5lKKXqjL0q/UbdT9Uiiypj/z7crkskvt834RRZ1mEPEixVqMn/m5mJ2Qt8QxwT9WzpRZcKTNOQgQjbkbRjI55hoCXhVeeGZ4nBkWEKnU63dT/08AwSGA2aDAYBK8fDoeiEMG+ImaOl8le2Pek1+uFTaQ2oVI12G63o9FoyO+jDh6dCyFx3kvusXoGVeos6y38MyNmPjfaDQYnvV5PFHvZlMl633A4hN/vl6ZJPh+1yZhZlUoOYC8R7ccsi1I4tIG0g8BLSjeL6aoSBLNC3lUVtua55fePRiMp3jNLIvxFWjrvNM8gzzaVO2gDudR90uv1Yo9ZkphMJvL71R4sNvRSoYHn/Ct3LgAkS1lZWUGv15PZLQBEniUUCglTptlsTnWtUtWXD5r6VK1WC6lUaqroR0oznRANLjfuk08+kYFBPp8PpVIJh4eH8vCNRiNisRgikQiazaZMF0wmkyJZEQgEhHrJYi7pimyEYx+K3W6XsZ+zLBqL+fl5LC8vS3TF1B6ADAQzGo1YXV2VuSn8vna7DavVKp+B0iPcr8lkInIuzFxYzCacRfmIH//4x1PGMZPJSNTIbIiTF1utFk5PT6HVavHGG28gFouhWCwik8lM9S2Ew2GMx2NUKhUcHByg0+kgnU6jVCpBp9PhrbfemmnvuDeM/CkRwmI9I2hCr+wEZyDBi8dmMk6w5KpUKjJsirAFZcxVB04H32w28f3vf1/gBpfLJWwxrVaL4+Nj0dJLJBJoNptTmHYkEhGjqvaAkGnH4jgJLKw9Xla4kjN9rl+/jqWlJdRqNZH4YBDjdDpF/WB1dRXVahW1Wg1ffvmljCqwWCxYWFiAy+WSXjZVjocwLCEcQoKEhLmXn332mdRkAAhrlMEiWZpzc3Nyh/V6PW7evImlpSVUKhVYrdapKbQq5ZljmqkaYbPZ8MYbb8zsoBnsJZNJaeIlVMbGXcLuWq0W6+vrYgP5DGnI4/G4oCNshmRXPR29CnNxL+hwqtUq/vzP/1zsUzKZRDabxcHBATQajUzU5Vh6QtUkFthsNszNzcHhcAiky+zJYDAgl8tJQzL17sxms4xnvsh6befidrsxNzeHYrEoYzy5SQaDQfBYps/0iN3u+bQ1bqbKICN0o8qOUxqCkQtfh5DQ1taW4PmcOnlyciIRIpsUOWCLMgiJREJSTGqc8YFxsFU6ncbR0ZGwtohRRyKRSzUB0sBHIhEZrKY2ZbFGpNFoEIlEBIsmrl+pVOBwOOD3++WAUBjx9PRUMjr2SqiT5SaTiTiObreLra0t6aNhtzOp3Jx4Fw6HsbS0hJOTE7x48QLAOZOJfRlqhM8iLqNwaj2VSiVUq1VhF81aTGWGS8fH/eDF4HPkaAR1oigjaRqjSCQi0SGzLhJDmHWrz5kOhrWdbreLZ8+eQavVYnV1Vc4FGWrci2g0KuSSQqEAAFNzObh/ZEpx/6hLRbiHF/t1mDo/b+VyORgMBrzzzjtYWVlBOp3G8fEx+v2+9DJQSn40GslE0nQ6jXQ6LcaThWNmKUajcSpjYwbLLIxZCmnNXq8X7XZbYLpIJCLS8aVSSWwE6z1er1eoyAxOQ6GQOGf1GbO+yxoEIaN6vQ6v14t4PD7zHjLT9Pv9WF5elgFezOq5f9Sam5ubE7iOZ6vX60l9Cng5xp2OmQE27wmzMdam2LjcarXw5MkTGI1G3Lx5E7FYTFhx/MwGgwErKyuIRCIyGkGluJNdptZrOBVUrRmxx81ut2Nubu6r73OhIeMHpkEcDoci0Eack132lMVgbYNpNlO3bDaLVquFRqMhxVBGIKPRCIFAQGh7drsdxWJROOSEyyhXbzab8cYbbwB42dVuMpmQSqXQ6/UEU+SFZdGeKSDwUnyODpMRLIkD5PPPsjwejxhewkOkch8fH6NWq+Hs7Ez6XEwmk8iyUyaGda5cLif1JbPZLHz48fhcN8pkMqHRaAgMGY/HJZtkHYuGgGQHt9uN9957DyaTCclkUiRRDg4OREBTo9FIpEtZH/Yy8XVYIOcBpPEmbHRZ52Kz2QRSVOnolUoFe3t70kvFy0A5HRaiB4MBzs7OpC8IgPR2DAYD6c0YjUYCvczNzcHtdksNijUERojsqF5ZWZE+IzqK09NTEcfUaDTI5XLo9/uS+XHvVYVxtbbFWgSAmeEcLt4nUuxJfe33+0in0xgMBgKLARBnUC6XpabAzPrk5EQyUma/hE64CL8SHmVhXiUusO9qOByK6CMJJ1QcpqwTA9disYjNzU2Uy2WcnZ1hNBpJRsvfxyyMdkLtyZr1DvOZEjanU6HMFVswmGUTjiNtmU7TaDTK+eM9VdUzCNePx2Mhc9ABAxBHxMGCDMSdTidu374tATkzSOqvkYZNSRh1xg0AsXe0ndR3JKw9GJzPzfnKMxeHwyGHSBVXHAwG2N/fl27OwWCAeDyO3/qt34LX68Xp6SkODg6koA+8FMLLZrMCqfACMoux2WxIJpNwu9342te+hmAwiC+//BJffvmlcL1J4ZtMJlhbW8PHH38sUed4PMYnn3yCL774AjabTQrm7Bo+OTkRY7S0tCSNgcxiVF0tcsmJ5c+yEomEsGrYj8Fo7/79+zg6OoLb7RZV1/fee086xGkcA4EAxuOxdOM6HA45yIwYU6mUwARserp58yaCwSCePXsml4BNV4SMlpaWcO/ePYloAOCLL77AgwcPJFLUarV48eIFPvvsM8G5PR4PPvjgA2GfAJjSEGN9hD1Ps15stYOddRwaDup6lctloV1eu3YNNpsN6XQa+/v70vw5mUywv78vRoECk2dnZwDOJ00S7w+Hw7Db7VhfX5dsg0OpCCNwDHAoFMLGxoYQSfR6PZ49e4bNzU0YDAa52Pv7+9je3ka5XEY2m4Xb7cYHH3wg0TZ7Ndhsp9FopqLey9RcFhcX5ayk02m5Q91uF0+fPkUul5OMKhwO41vf+pZ0cjebTRlX3e/38fz5c5TL5SmGGfXjGFDwc5tMJty4cUOaG7PZrOjo9ft9YUHGYjGsr6+LQSNF+vHjx7BYLEgmkwI7cg8LhQJ8Ph++9a1vIRQKoVwuo/pX46YDgYDcMzIICY9f5gyORiPpr+M52t3dRTabFWZlKBTCxx9/LArD+XxehHe1Wq20ItA5q6xVnrHBYCBKBWtra8IOYxB+eno61XsYDodx584dkfEBgIcPH+LZs2fCRmPjZqPREOdss9lw69YtEQRVGagqVNztdoUAcJF1YeeiGjGyWtjoRy/NLEDlagMvdaf4xQh+PB5LLwYLtersDxbGGF292ijI4h0jJBab6GCYKWk0GsHL1bkipIqyyEjcnFAEMVZGWmpB93UXo7rBYCC8dFUjiHAgANlHQiUUR6ShZueyisGr9RMWsrl/KgWUz4xRGNlBZrN5SsMIwFR3NKMgHlwWFvn8tVqtGGr1s5FAoNJxZ1k8f9xDlUyg6kmprEIAclF4PlVaJ0kgzHJYF+Br8pkQGuD7Z2GejBxq4fGzco/U96PStrkf3EOeKRpAwigqmYX35jJLVc1VB4MxMyLMBLwcNcwzxLHQfKZWq1U6/VW6u0oJ5vepbEK1SZifSSWrEOYiuYLGmlk6M1bC3zyzXL1eTz6bCsupDdKzLvUO0waqz4fvh38meYB2jUV5ABLAqT/P7Jxni4tkB44i5mfi69GequoFdFivEqDUZ6TaPp5b2tlmszlFvuD+8WxcZF3YuSwtLWEyOZcff/HihfDgiZlGIhExXlarFdlsVihtHJDDAzI/Pw+Hw/Ezki0qW0r9EA8fPgQAeU0yGEwmExKJhEhNPHr0CEajEfF4XCIfj8cjTZGkq1qtVjSbTWxtbYnBYkZwdHQkEBQ59cyELiO5z6iZRTfuh91ux927d6UDnQejUCigVqshFovhxo0bQhHUarW4d+8erFarzOzm5VehPDrYyWSC3d1dbG9v4/T0FJlMRgpzjIjm5uZQrVbx9OlTgXV0Op1kkNxLvV6PjY0NmEwmHB0dYWtrSy48ABweHmJvb0+cJwAppFIddtZ1/fp1AOcCoAcHBxJwTCYTxONxKeQSTiJ7iAqzNDpWqxVvvPEGgsGgUFP1er2QHvg6ZC71+3389Kc/FSdEBuLKyorsBzFt0q/VyJvRLi8vac1Go1EKzZ1OB9VqFTs7O9jf359y8AyeKMFyGeNI6nGtVkMmk0Gz2UQ+n8d4PEYgEJA6ANfR0dEUCaXRaMiclq9//etwuVyijs2ZQ2rfhcViEfLK/v6+KAOTlk1NupWVFSQSCVQqFdy/f18yVIPBIJpvhOioDqDRaHB0dCRsNrYQbG9v4/DwUIreJAaoUkizLjbCEjplhgacz7IiNExjT2dAqRjC7haLBXfu3IHf70cul0M2m4XZfD5Wmo4YgAQZ/X4fDx48EIkc1kAINc7NzWFubg5nZ2f49NNPpaXDYDBIdz7lYqgWQWo37TXP/ebmJg4ODmT/AEw1xKpEmL9uXdi5uFwuoUiWy2UMh+czA3jwjUajMJ+0Wq1MN1MbcLjxZFTwApvNZgQCAfkQLAYyeqM8gjpUiA1MPp8PkUhEioEsvnMxsiRExKZORhK8rOPxWOAyYubAxb30X7fIdms2mygWi9JARh46+4QIEzKiZPGP2CkZU6SEttvtKSoyDSBxV9bCONKAc8YpsR2JRBAOh6XpDIAoxxI2Y8RMQofb7Ua1WhUiB7MAGi1mRz+PZjvrYpMt63PMAiaTiRhwFr2Bl1mX3W6f6lFhkyiLrfl8Xi62qjKrsp+oX8fOZbWRlDNe8vm8MIfYTwBAMiq+Lgc6UeyQdUDCtfl8Xj4zSS+MODk3ZdbF7I29Ye12W2pH7BXi++x0OiKdtLKyIpAsGUehUEj6Wpjh8P6ylsKGUaptUO6oVqtNtSiQmk/WHvefjhd4qbBusVgky6lWq5KVEjIsl8sC+bKJmFnCZReze6IbLLIDkPdBFILBz3A4lM/Imud4PIbb7ZaAvFKpiHMmdE8YFIDUyMgapVwWzxEp0ISImUURygIgf2YtisEpa0C0HY1GQ5QpmB2pKArbNi503i66sXzBer0+Ja5IZpia5hGmopPp9XrCtJlMJjg8PEQqlRKjyAvHiJ14JiMPXlRCLiqWu7u7ixcvXsBsNmNxcRHj8Vhmd5DSy0OqqvvyYPJy0yCwoEnvziiTuPBlYB2mwJTGYZaists8Ho8YGlJRKb9wcHAgjsPlcknUxu570pXZXc/mSbKnSLtWIaSDgwOZV3P9+nVpxGIjpRot63Q66SEiC6bZbOLo6AhWq1UkMUj3JXyk053P27jM/hGqLJVKYoD5GQiTEEJkoVQtvNJIcaYOmY4MVJjlUaep0WigWCxiMpkIVk5ogkOiyIrb3t4WuQw62WKxiNFoJNNRaSj4+nT0LFjz/RHfJgzIFQqFMD8/fynnQnkRZrCEOhgA0GjzfvG+ajQaFAoFkULqdDr48ssvsb29PZUtM4CgAGUmkxFdPtZQj46OhOBDmPrw8FCo2hzSR7JLKBRCIpEQyIj1SgASKAEv+8gqlYqwKpeXl8XuEIW4jLYYZXGobUbnqWam3EcGPmS3srWBDv758+c4Pj7+GaidpJxqtYpmsykqA6xtMdOhEzMajXKH9Xq9nEHaOo47Z9BAG0FolPDezs6OZNOEQvnZCH0SAfrK2WJ8IGQacDPJAGFkTudCCQNG4dz48XiMo6MjtFotLC8vY2VlReiNWq0Wh4eHMk0wn89Dp9OJ5D3ZDfTWBoMBz58/x9HREd544w384i/+IjqdDn7yk5+gVCrh5s2bWF1dFaYXoxlmXapz4fu22+3yfuip9frzKXhLS0szU5Ep+UGHQaPH5jOz+XzWO4todHgUmCsUCtLH0+124XA4EA6HEY1GAbxscszn8wJL1Wo14bMTOsxmsxKl0Lk0m03cunUL9+7dE1HGarWKQCCAZDIpdF8SL5hxMsLilD86l2AwKCk+9zsajWJtbW3mXg1iwJVKZcq58NKQrcSMmBdILbpynzY3N6HTTcvx88JQeZvMR4vFgjfeeAM+nw+pVArlclko4zqdDp9++ikODg7w7rvv4t1330W/38f9+/dRKpVEuZlZNVUk+DlYFyiXy8LaofoF9eBY6wkGgyKoOetiX1Amk8Hx8bEEd7y/arMugKmx14RpGbwwq1lfX8e1a9eE1TYej0WQNpvNYmdnB3a7Hb/0S78kdFkaVAZuh4eHqFarWF5ext27dyVD4iCxpaUlYWQxUCCyweZWStuQ+u50OrG0tCS0YBa0g8HgzM6FUvRUWTebzWInyG5j9sx60mQyEWYdIeLR6Fw8dDA4n0TJOwycOxeePao+WCwW3L17V8RriQzQqR8cHKBcLmN9fR3vvfcehsMhdnd30Ww2EYvFsLy8LH0uagBKYhUJCgCkt89ut8sZ5F3niOqLnsEL3/R8Pi8HgqKO7DCld2bnr1rY5wYw7SM0xIJ6NpuV7IUQi1rcJ9aqFvap3cOo9ed9UY6es2POzs4wGAwEznA4HPKgudnMJAiRGY1GGQnabreRSqWg0Whw48aN1zyWkEhRr9dLJKHCcmohjvAiNYTIQOJDZeGe1FlGZaQ+Auf4OllLTOVZg1L3mng/vygFXywWpVZB+GgymSAYDApzjd3XzJp4oWh8ePnoWDkXfJZFlo9erxdRR+6ZqhTBLJCLjoMwAs8M97hYLAptnj/PGhbwUjePBVFmzKqzIhuJ47q5f5RK6nQ60rdit9vleQIv4R5ST/v9PlqtlqiJE06mgvFlMhciDg6HQyatMqhiTerVpkgSI3jGwuGwfEay21TDyT2jcWIAytEWarc8nx8RiWazKUEMWwxYt6jX6zg+PpZmZxpwo9E41dDNbnidTidOm/W0TqdzKcYi5VrMZrOIQPL50LHwvNAm0glwDAhtICFtBpukvvMMOhyOqaCJNpGwFiFSPic+C8LplUoF9Xpd2HPshWONnO9lYWFhqmeMaABnFPG5c/ZTOp2GVqvFrVu3/tr9urBzefLkCXQ6HdbW1vDOO++gXC7j8PBQUuFKpYJEIiGaP9vb2+h0OgiHw9IHweYco9EoafPW1pb0H3BD2eXPC0jsMpPJTGln0eOSessDXyqVBHt1OBwoFAp48OABRqMR7t27B6/XC6/Xi1AohHq9js8//1x48NzE7e1tmEwmUQlNpVL45JNPMB6PZYTv66wf/ehHsn/f+MY3xKjzojIyJ1WZmDjn3nu9XqGBPnjwQOT2C4UC3G63KNSyR4FqCd1uF48ePZLu+5WVFYEtaVwPDw+lE7per+PJkyfIZDJS06LWGQChfFISvVwu44c//CHy+bwEEe12G1988QXMZjO+9a1vIRaLIZfLYXNzE+PxGL/5m7/52vt3//596c6+deuWODw1zVclPrh4EdXghnTtQqGAg4MDaUqlLIvb7UYsFhMlABoJajQB54oLzOja7TZKpZI03j558kSybo/Hg0KhgBcvXmA0GuHu3bvw+/2Yn5+Hz+dDu93G9va2nF82uqXTaRgMBiwuLsLr9QoRBAB+/dd//bX3j3toMBjwN//m38TXvvY1ZLNZPH78WAKwcrmMcDgsNG9mW4SE+d9Op4OHDx/i7OxMaK0ul0uoyFRK4OwdKis3Gg1RfNZqtSLKWK1WUalUpuoV6XQa3W5XYOp0Oo3vfe97GI/H+LVf+zUsLi4K5FWtVvHpp5+i3W6Lygbp0nq9Huvr6zJG+fj4GJPJZKYz+L3vfQ96vR5f+9rX8PHHH8uwLfXsUd+u1WoJsYDP2+VyIRqNYjAYYGtrS5733t6ejKMggSaZTAoxh8w9Zg8LCwtTEjFU46AqQbvdltdn+SKfz+PRo0fQaDT41re+hUgkgkAggLffflvuMGvbbDjmGfz6178uWefu7u6FbeCFnQvHiVJehTLgpAsyk2B0zcibXppMA+KOhKPYlc9aCmEoFk1J2QReRgnAy0ZOvj4x2p9H4WREyGiX9FkacrXuwQhS7fAFIBglI7nXXWyiIlVabeZiQZewGf/M98xoiRALIUf2KKiUSH4WRouMbCgWyAIkP9twOJyKvFUcltE594+HWY1A2XGsduczU1LPBHuSZt0/QqusEag9SPwCXo50Vc8kAGGEkZb5atFebQxmtMgeFkaF/NzMoFXiAuFftUGX5wyAnDuVLs+6Cus+fB0WbUnN5bNmvWvWRS0p3mF1PhGfNx2p2lXODEan0wlxhHtImIiQt1ojZbbIn1e17tTzxy8+B74m3xP/TYU4ubcMBlWVENLvqaLMFgZm4bPuIbXKAAhRgfAyzx3PDwChXvPcUKONRBmVYMHPygyZ5ACiK2yY5Gvxd/A8cT9Zk1Jfk8+VbR/cZ54DFSHheaPTonMjyYqEhIusCzsX9q7s7+9LxyklmbnIQW+32zg6OpKU2Ww2Y2VlRVSAT05OcHp6CgDSJEQ8n93VzWYTp6en6Pf7MsqXh5DGEziHfxYWFoQeq+obzc3N4datWwgGg6IqW6vV8OzZM8kWNBoNwuEwfD6fzLgAIHRQYsc6nQ7r6+szG0cW+Vi85OXlgWDfCh8qdZGMxpcy4deuXZNiOplzdBwcmUujQVXbVquFx48fo1wui7TDqweTRXB2kzOCCofDWFxclM5gMs8+++wzOBwOGVscj8cRj8extbUlhUwWUWu1GnK5nAQRs+4fcenT01NpwmOdgpeN8ES9Xkc6nUar1UKpVJK6E0djs65CEgglbxqNhlz6ZrMp7/vLL79EqVSCy+USPS0+K5vNJiMFCoUCOp2ORLBsCnT/1UheFXL0eDxCCmCxltkf95C/o9vtShZ5mcVi9sOHD+VZk8KrKlM4HA60222cnp6KQS6VSlhYWMDq6qoEEFRIYABIUgydaKPRwPHxMXq9Ho6Pj2XfSaYhpZh3jXIkaoM293I8HuPtt99Gt3s+7rhYLCIajcrMlmAwCIfDgRcvXiCbzQrEQwfIAIHw9yyLEOvu7q70CLERlQ5mbm5O4Or9/X1Rbna73VhfX8fNmzeFIZZOp0U9hEacjFzg5RyrTqeD58+fy8gKQpe8lwCkTsYaHYvx0WgUyWRS0KNer4dsNotUKoVgMCiMv7m5OUQiEWxvb+Pg4AA63bnSNcsRbFYnkegi67WcC9OrQqEgG8tNYORPJ1EqlaborQ6HQ16nUqnIdEVKNqgRCTFm4q6pVEoE4F6VkyalkXQ9RqCkzTK9PD09RbVaxfHxsejvkEpIsTZ1hgbw0ntXq1Upss6K15LVok6PVCMd1itYsOchYRGTopAA5MIz01Fxb2YnLOizVsTmPGZ6NArsA+Bz4RhYFnvJjefvTKVSYhwoL37z5k3Y7XZhcjFiJKWV0j6XEV50u91SHM3lcvL3ZMOptFcaQ+L11HuiESAFl+KcfM6sRzAa1mg00n9yenqKZDKJRCIhUSgA6RvQarXyzJh1e71eOTPhcFjOX7lcRq1WQ7PZhMvlwvXr14XJxEhYvU/9fl+exWVqLiaTCePxGMfHx9jd3Z3q5Gb2y+yV1HVG3tTeY9bMrI9LzUBISGGthPg9x3Hzc1N3jYvZMO8YAy6ez4WFBbRaLezu7oouHyVKnE4nHA4H9vf35T2T7KHSgi8jocNsuVAoiAPgXjBTNxgMQtXP5/OCdrRaLUSjUdk/nlG14ZafmZkFM7FGo4H9/X2RlrHb7dJ/x/3jcyTiwroq+/xYN2w2m/jiiy/kHHa7XbhcLly7dg1Wq1XqMmwhYXZFh88JmBdZr9WhzzdPiIJej1ROLmKLakcx57Kz94GpH6PAV8UpGemzGMeD5HQ6RRuLzAZVPgHAFH12b29PojOtVise3Gg0SvTPlFod4RyPx+VgsjimGrXXXczOSIu22WwS+fNgESq0Wq146623JIpkAxSd+mQyEclsZmksNLNgTIdPocDxeCyQAQ8w021GxoygWcy2Wq1Cl2TnsN1ul8NHA5xOp2EymXB6eipTKRcWFgTmocOh5Pssi7ADYRMadaPRCJ/PJ+eHU0Pv3bsHADJLiGeHz5u01lqtJjUoZj68QOyTuHXrloz05T2ggyY0o0qfr6ysyPdwTDFwfjGDwaDsIV//7OxMNOOoDcfiLr/v5OREBrD97u/+7kx7yCZJGnibzQafzyfqCsPhEIFAQGp3ZFZxgB9/ngaaZ5dUXMJWDJbI6hyPxzIJlDRlwo4ajQaBQEBqsuPxuYLCzZs3MRgMBHVg1jEej4WZZTQapalTjdxpn+isySBToatZFgM8Gn8W6gmxApDI3m634969e4IMUJGcNoYZFM8es1RC87RJhC6vX7+O+fl5OWdczHBVu8b2EEKumUxGiEvD4VAaedmRTwaw0fhy7Ller5dgplarCaT9Ovt3YedCSIvcdSqDqvIXFF4MBAL45V/+ZZHuZpTDnhcyKuixyc5hhMyOUioEc3Z2IBBAMBhEoVDAw4cPpQGMm8jXpLhevV7Hl19+KQeC/RY8lOSGsw7EiCQQCGBtbQ06nQ6pVEqiLs45mWWxO5pRM/Wv2JQ0mUyQz+eRyWTg9/vxK7/yKwiFQlLLyOfzko7z9XhgyC5hk6jVej6Sl6MFVlZW4HQ6ZdwrnTOJGMRWyXhZXFyEzWZDJpPB8+fPBcKgijWFMUmnpfHc399HOp1GIBDAjRs3oNVqsbe3h3w+LwPJZt0/Ysq8DKxB8dI6nU7pbwoEAvjwww9Fp83lckmDbKVSEedCNpLdbpcR2Wy6bDabqFarsFgs+OY3vwmXyyWd2ZT/ICym1gRZjLVarTg5OcFPf/pTiazZTKfRnAtYEjpmYHR0dIR0Oo1QKCQ9GuzKzmazOD4+vpRxXFpawmg0QqFQQKlUQjAYxPLysjCphsOXM5Y8Hg9u3bolNHmTyTSVUQPTwpQMzjqdjmTPdF4kejAKpwJ6Pp9Hv98XVINwm9Vqxe3bt+FwOKa+n1H53NwcTCYTSqUSjo+PhVGq1WpFZJNS8zyXpJCrAqGvuxYWFgQ+zufzcLlcogbCpmhmZx6PBx999JHcQQaV7GEhJK5KCRFZ4J0nsuJyubC0tCT7w36sk5MT9Pt96U8ivGi327GxsQGHw4Ht7W3s7u6KjdTpzoeFmc1mITiotcNMJoNKpQK/3y+D0FTdOcJ/F1mvhVPwEjAVY+MXI0gyuQjvkGnD4nSr1ZqKbthlT5odAOll4b+p2C5VAph6E68kT58H+FXdJnUz+ADU6IDvlXAGKYXMqtTobNY+A6aVKizFvaDiNH8vIwrWP5htsEjHL0qRqEKRjED5mVSCAA8GX0ulX5PCSfo3jTnrMtxHFq2Zeqv7yoY6VRWZkRjT/1mNI98HAMH1KcHOGpxK7ebnVvWsWq2WkBUY5DDTY/TJ/qPRaCROiNIvDI5Y51IhFp5/Qk8qmYAkET4P7iXPPQMMZo80VPz9fI3L9Li8uocMqkjU4bPj3eY54X2jM65UKjKCWC2q8/kyAmftiYvPRYV/2TPFrJPsL2rn0XbwLvN9qYrEhNH4mjzHvMfs9Kd8CdGTWRYDWZWIQ5YnpWlU/TxG+ryPhJYJafM5EGkg2sB9B17WUmizaIPYyvGqyC4zG7Wmy39TyU9EctQ+IAASCPCZEppkFv3/SubCaIX88l6vhydPnsBsNuO9994T+GE0Op+pkcvlUK1WkU6nUSgUBApjBqPRaODz+bC0tDTV65FOp5HJZBAIBDA/P4/BYCB6VcvLy1hcXESxWMTu7i663S5isRi8Xi9cLhfW1tbQ6/Wwvb2Ner0Ol8slsz/YZEUJEL1eL7MdCMfNzc1JzwPTeUZEbrf7Z7SXXmelUikAkN9NLTRGaaFQCD6fTzBZUm8XFhYQDoeFr95oNETRNpFISM8NDSlrSny/3HNVbLJer+Po6AiDwUBmqfv9fqysrGA4HOLk5ETIFXSuvOwHBwdIpVJYXl7GrVu3RHKDtRqv1wuNRiNYM+V4bDabqGLPsoijEwLsdrt4/vw57HY7FhcXRd6HWduLFy8kQGFRlOl9KpVCsVjE22+/jXfffRedTgenp6dot9sSuUWjUWxsbGA4HOKzzz4TaX2LxYJWqyVSLxzLHQqFEI/HpUmRl55UXNaCKIHi9/uxvr4u0AfPBrNu9uTQiPt8vtfCu3/eYk2RBpDZsNlsxvvvv494PC5Mt0qlghcvXojBp9zK6empDO5qNpvSAa6yO9PpNIrFIiKRiASe6mTEyWSCarWKra0tdLtdrK+vi6R8KBTCYDDA4eGh1MvMZrO85+FwiL29PZTLZWxsbODtt9+W88a9Ih1ZDcoIE12mZsVgkHeYZB/OnIlGoxJED4dDHBwcTDFgVefCGh+zZp6DyWSCg4MDnJ2diV7ZcDiUUQ1+vx8+nw+VSgWpVEqCVtooUp3ZCkLUgWoag8FACEVerxcbGxsYj8eSkS4uLiIYDMpeTSYTUSF/3XVh58Joi7g0G2/UEaxq/YXRRbFYlIY6SqDQK6t0T1WSoFwuy+uSeUGWCdNkdqoyKmBBlxERRRcZsTClI17KWoZKYeXlZUbDFJWX/zKLl4sHjR2y/AyM6EgN5HApt9stvQVkwlG9WaM5nyrHpjN2gKs/q0aqjLoItQwGA5mNwohPHQWgHjDSQQkXEXZjsZJRJCmLvGC85Go9bZbF7ImRPvcPgETQ/OJ+8DyyZsfMmU2zJpNJep04VZP7p9Y8KI/u9Xplqh+lVBglM4Ln86nX69KAy2ySjYq1Wk2cOs8aAJH+4V1SMXg1G5x1qTpdjHzz+bw4ZGZ+w+FQHIAaWVMdgXvI6JewjMViERpzo9EQFiKDGgYHhIBYH+HnJAzE+1utVkUJgRnfeHyuAJDP57G0tCQ6gozsGeDyrLFxlX++jHPmvgDn94mEJZWIpGr7qWPU+ZnZLsHPw3oRswPuHyntPPf8s9V6PmqaDD82BNPh0QlwxlE0Gp3SWiS1vtPpSG8X63qs5bJXjNkhySuvm/Fd2LmoPSd8kFqtVjxyLpeTy0togIKA8XhcvDa54QCEcks2CSEMduQzcn7zzTcBnCuPUrSRBzMej0sT5rNnzySVJr6rwhjcPNY/1G5dQhavpr5MPXkpZk2pmWHwgPOgkWVE/J1QD3tHVFE59fBqNBrUajWkUik5HIQQWJwGIJI2jLotFotkb4PBAD6fD3a7Hd3u+UwPGhwaIr5fznFwu9148803YTKZREVZzTxJKfX5fBiNRjg8PJSazGUW03fgHCpgXYIR5MOHD1Eul1EqlWCxWBCPxyXg4Ex4nj2fzyc9Ti9evBBpjE7nfOgcp5VS1Xt1dRVLS0tCeKhUKgI9RCIRydYODw8lQhwOz4fosRhdqVSkuEuFga2tLej1etHV4wAptbtblcW/DI1W3UMGGqwZaLVaNJtNPH/+fAoeAV6qWnOCKaElwj1kPbGuOhqNhCHKGT5UaiAETmN67949dLtdKTBXq1Vpb+A9oNFTJYii0Sii0Si0Wi2+//3vT91ZBmmsBzFgoC6cyvJ63cUgkwX6QCAgiu/FYhEPHz4UyJozedjbQhowNdB4Zxms8c/9fl9kehiMGI1GJBIJCcapsE7BWSI3nU4Hm5ubAnux7kzKPoNYDo1rt9v4/PPPAbyEr0lOoRwVzzORq9exfxd2LvSINCBk6wDnh4h9GXQuxJBv3ryJ+fn5KW0senZ2NjcaDRwcHKDX6wm8RjiHg4a8Xq9EAA6HQ5hegUAATqcT+XxeRvcyWm02m1O9JKSt0tiQQcKNpSF/1WDysDADmmWtrq4CeCkXwkxgOByKUaQEhs1mm2KGqHixeomoA8bDyguvRsPEVckCYybEyIRd6YRIWCtQay6M0PR6Pd5++20kEgmkUim8ePFC5FiIk/NsxGIxgdhmOZivLkpqUFCP/SXD4VCk6gk9ka3Iz04WUrFYFPiAl31nZ0cUgEej8yFZzPiYQa+ursLtdgtEw07mbrcrhIFyuYxUKiXOATiXZifdk/sXj8cRi8Wwv78/tX+MDtVmOLVJll+XWayR8Zw7HA6BoZ48eYLDw8Mp0VZmDAxQyCLieVORBqIUDG6YLVarVSGCsDjNgj8b+njeSqUSdnZ2oNFohALPBkAWw7Xa89n0wWAQu7u7+OSTT6DTnSuLk1Xp8XikAZGMUmZadPKzLDoX9qQQjRkOhzg6OsLh4aEEgKSO0155PB5pglWfMbNc2lAiK7yfbH5mEE3bpDoXj8cDh8OBs7MzHB0dSQZnNBqlv4qoiMlkEoWSZ8+e4cGDB9BqtZJlc6geA4J+vy/9g/+vZy7d7vkcF6fTiWg0OsVTJ1xDKhyx1kwmg3q9LilwNBoVtVjCJ4QX+MGIv9Kp0XGNx+dyEfTyVBim5pDKz+aFrFarSKVSU93+9Mhq1zEdCYUreYnYkKVSq1930TDQ4fEzajQaOJ1OiQI59pQGm3o+rJtQkE8dyMVMiNniZDIRGQoWVRk18aLSeBEiAiDsPHWYGiOpQqEgfRB07CqUZ7FYhAnDjnym+CyeX0b6XM34VFUAo/F8Vj2hw1arJRg4pWiYPajd8Gp3PvDSebHwylnyZPnQaZIpR+iKGTSpqcDLGSw0BBwJzUiU9G8+Pza/8plotVqBqorFotDjLysdz+BIVcwmbLm4uIhwOCzfS+kj3ouTkxMRe2Udhu+VAQ8hKcJobDolkYN1PErnsA5K56LTvZxDosrQDAbnYzfovDnDaDQawePxCG2WQSVVN8xms5yXWq0GrVZ7qbopFx0AGzy5j/x8vV4PDodDHB7PpVrcX1xclL4hIkBUomaQ5vf7xQ6wXsL9ZiuGWi9hbc5gMEj9lvJYlJRioENbTjIQ7S4hOMKUAMQ2kRl84fN20W+kUGE2m0U6ncbNmzfx/vvv/4yUfLVaFXbQZDLB0dGRjNlkMfa9996D3+/HF198gU8//RQmk0nUaRmpRyIRrK2tAYAMFeOgIfLl2ThJeuLq6qrQKJkSj8djbG1t4fHjx+h0OohGo7KBuVxOCl52ux3Hx8fIZrOIRCIiXU3JA7JOZo2++T75ORYWFnDr1i3RUCMswLnkdOYPHjzA7u4ugsEgVldXYbPZ8NZbb0kPytHRkTgOlVPPeRHj8blEOBWRCXdx8WL7fD7RJ5ubm5NO90ajgZ2dHTx79kwCBbL/GB1StTqdTgvRIpFIAIBQM81m86WaAHnGVAfMAj61lniJ9Xq9QAePHz/G/v4+nE6nPGfOLjk+PpbBbXNzc8Lpr9VqcLlcWF1dxWg0wu7urowqUHuqSFWvVCqiZsCgQaV2b21t4f79+yI+yeZM4uTUNmORnBF4v9/H9vY2crkcgsGgZGOzLtZEOGp4aWkJGxsb8Hg8uHfvHtxuNzKZDFKpFKxWq6gwf//738fjx4+l/cBut0s29/z5czx58gSj0UiQDGbDNLBsMmStSj3jDOAmkwl8Ph/u3bsn8vw2mw21Wg3VahUvXrzA97//fXHsnIGysrIiEbfJZEI2mxWlA5fLJd3wR0dHSCaTuHHjxqXYYqQBs7F6cXFR2gDYMsCBfHxen3zyCTY3N2V+kt1uxy/+4i/C7XZjd3dX4FEOI+N+zM3N4dq1a0KeYtMlM0oG6yTUxONx3LhxA3a7XbT/KFp5cHCAP/3TP5V6mcPhwGAwEAfHBk+O3wYw1XiZzWYxNzcn484vsi7sXAgXAS+LsmqxlpEgU0dVg6lerwtzhwVAFjNp3MiqADBF4yT+rKocs0jI9HIwOB9CRRiJhbdXD5FKqVWpyOpnUmsw/BlV+2vWxd/Nz8vPR0o2YRo1kuGeMjUmhGe32wUK5GvwGbDWwmgKwBSNmb1BjKwJ46gFSe4pX4/vh02ezMLUhi6V/87XU5ca4c6y+LMqFZPZEc8WAImm+Tm4fzyXzMxIP2YxWWXFMRNR624qe44ECJWuy+Is9wh42TWtLlWri4EU94/vW4VA1T27bEFaPRt8PdYoCYPUarWprJAZLNmXLLo7nU4ZbsVnz741lTLNM08UodVqCf2Z36vePWaWwDR1Wr07zA7U5lV+Jn6Puk9qZz73dpalPodX7zGzT0oIqYEI94+Fco1GI03U6t8RGWG2xmfF12CNlntG+0f7pNZMyDQk/Zj7qb4OCQDcv1ft+6tn7XXP3oWdC4vEfr9fIJnPP/8cVqsV0Wh0Sv6DaRYjFmJ+pKSykE+ZEI1GIzAXZx8Eg0EcHR0JH//VvgtuPh8QmUv5fB4/+tGPUCgU4PF4hIpMqQ+9Xo92uw2fz4dQKIR+v49CoSAKyrdv3xYNLBXr5p9njRzZUMp9MJvN2N7ehtlsluFG6pAzqgxQIJSaQI1GQ+CHTCaDg4MDGI1GBAIB6HQ6UaqlMutkMhFZFzoSMqcIo5lMJqHJtlotPHv2TJpJfT6fFF1ZoByNRiJtQtpor9eDwWDA3bt3BeMejUawWCzy3lggn3X/+LwJVZIqu7a2Bq/Xi9PTU5ycnMBkMsksCqpd82KxeE1KdqPRmBJizOVyojLAv6OuEh0mIVXWBmKxmPRFVatV/PCHP0T1r+baBAIBtNtthMNhwen7/f5UYZ8d1G63G3NzcwIh9fv9qeLrZZso6ew2NjawtraGbreLBw8eiJQSp6SSsk06OdV1iTwYjUZRE9jZ2cHOzg7MZjNisRg0Gg1OTk7QaDREAkeFbqjywD4vMh4ZHLCo/93vfheNRkOcB5mpJGmwJ4csvNPTU3lmhGUpI0/FA6oFz3oG6fR4f4fDIT755BOpy3k8HuRyOZyensJkMsnnY22Xxl+n00mrRiqVEjYtAx7+XS6Xk0yNDpmBH88zAHFUbNAtFAr49re/jWKxKFkVhYEpnFmr1RAOh5FMJjEYDFAoFISynUwmBeZmk+v8/Dx0Op2QNS6yLuxcGC0ScgEgYoncdMJivJTEr9UeGbJ0CDnx+xiFnp2dSR8HhRv5QBgRqNmH2vzHlPXLL7/E/v6+iLGR2UEPTQpuNBpFvV4XvSy/3y+Xmw9RVV+mQ5tlEeYins4CHimI7XYbZ2dncjABCGWZ77n6V9Mp2aFO2iw/CxlyJycnIiPDugBpwRqNRmigKjWU9YBCoYAf//jHSKfTwpKiWgJpxsTVA4GAjFeoVquYn5+X/SMuzQI86ZWzLpXpxMu5v78PjUaDYDAoKT0hHbWvCnhJS2XUy7NJaIHfR+l5o9GITCYj5w14yShUGzjJYKTzabfbePHiBU5PTzE3N4doNDq1fzR8hOlarZaoXlCrjQ2fg8FAMvzT01OZSjjrIvrgdrsFBt7c3ITBYMDa2hqsVqsMsptMJiLKyOfGLFun0wnmT61Bh8OBSCQiPVxnZ2ewWq1SxCaMHQqFxMCRns/XJTusXC7j/v37yGazwg4djUaSSalZARs2M5mMOHGfzyeEIQrhUpH97Oxs5v1jxsPz1el0cHh4KIw61shKpZIQgHQ6nTDe+N5ZM2k0GqIowCxIo9GgXC4jnU6LzBGzSGbWtJUsspOwwwCn1Wrhs88+w97eHubm5mRwH+FKVSDY6/Wi3W7j4OBAlAUYEJAlZjKZ4PF4BHa+aAZzYeeys7MjRSCylZieMeLVarUSoTPa53AqOgim4mozEkUStVrtlHoyoxsO+kokEkgkElPUQxb7dDqdNPssLS3BbDYL5k1WDLWnqCdlsViETUE5CuDl9EwaHLKL2Eczy+JFUnnvdCJqxzELk06nE3q9HrFYTJrCXmXhABCdJb4vFreBlwqpmUwGnU4Ha2trWFlZkUIeSQBqL4zD4cD169cRDocRDocFk+VrkqbcaDRQKpWEXs66D1NyOmXuL1lbs2Z+jOAYtbLmwkvA2eHJZFIyWdZSaNjpyAFMfWYaK4PBgGvXrkmthQaQkjmJRAKxWGyKOEFpEo6SttvtIv8SCASmnqdWqxWDp0JqhH05kI2ZpQr/Ui7oMqvT6UhARnhrZWVFngmDFxIHyOpcXl5GJBKZ6inhv3s8HhlDzMxiaWkJiURC+lFY96AAaygUEoo1nTVp1rzbnHdD+If6cAy01ECBigtslqaaAO+U2od1mUmUhINJL+YkTDaVc3wzBTnpSNjozc53OikiGWpHvF6vx9LSkmTqJBmxL437R6YeYVZSvgndJpNJIVaxp49sMxb4GYyqivNnZ2dSl6Vt4O9hvfKi+3dh5/LgwQNoNBppJCNmBwAnJycYj8eYn5/HysqKSO73ej3EYjEEAgExSMQCecGIVbIzmWyOTCYjPQibm5uixLuxsSEXYzw+V3gtFotyIex2O27evIl4PC7FQJfLhWQyCZ1Oh83NTZlvrtPpxNmwIE6aKY0Z4R8yN74K48imM6bWhBH8fr8U1jhNz+/3A3h5yAiZMJokbEJnz9Gux8fHePLkCarVKp4/f45arYaFhQVsbGyg2+3C/VcTErPZrJAwjMbzca3vvvuuNNXxi86oUCgI/dRgMMjBpxI2jQSNBplBbrf7UjPgK5WKUItNJpNM5GNGx6bF9fV1YWlpNBrZH0I+jLpUnJtZDkcaR6NRbG1t4Uc/+hEqlYrsH88WM+3BYCDnb35+XrrM19fXEYvFhDLNyHY8HiOXy4lT52uQZUk1CwZWdAR6vV7k0S9T0G82m1OMObvdjjt37gA4dzz5fF6oyKqYJ0da8F4w6uX55J7Tga+srMDn8+HJkyfY39+XSbD9fh+3b99GIpFA9a+GW7G+RUfD2hMdaSaTEQX11dVVaLXnenXFYlE+F+8D5WnYj1MoFASaZ7a4uLg48x4SouagwW63OzXNlnc4FotNMVNXV1dht9sFHVChLUJVzHQo2sk7/PjxY9RqNezu7qLRaOAb3/gGbt68KfeTDdeEIfv9c/Xxa9euIR6Pi4NgZkl4mpAde7HIVEylUuj1evKZqVtI0gR1Hi+yLuxcmHIBmNKkUpfaWapGE+wIZYqsQjTsaSETgweMBU/OeDAajZJBMB1Wi3Sqh1UNBy83/16lz9JJqmQF2RhFc4wXnUXWWRYjZdagCJWoBUjKhKhwFX8nL/arRXbuB7MFCnRy/8g8IotOhefUL9KSAcjn5fNghsgeBlK1vV6vKDwzpWc/EZ8vSRvM1mbdP/4sL6fajKsWPavV6lQvEB05HTP3mQVoZoX8vJQ+4eszC2J/DIkVnF2ikgtIWSZbUi2c06mpjZ3sjlYLwGphVf0vyTOX0RcjrMQRDbwbfL6EYPn+GYBptVpBI9gOoPZcsd6pnhV+n5pt9Pt9eDwemUX/6nngGSOT7NWzogYNdJJkhqoqHFx83+qfL3OHaQO73a4EAbRXdBgcM6AuZiUcI0Knws9AiSmeTd4hfh+/x2A4l/N3uVxTklYMkGgDmVnyGarkJO4fHZnNZpPZRfweOni1eZv7ryYVf926sHO5ceOG0Fo5AIyHnoWoZrOJFy9eYDAYCD7MQjRZCsQI2cxz7dq1KXXeYrGIer0u0Vo4HMb6+jq0Wi0SiYTIVu/t7UlaGggEMBgMZJQsN52y4QAkajUYDAgEAlhdXcWbb76JQqGA/f19GWbF2R+EBMhQY7Y16+Ume2l7exupVAqhUEiyMOLJpDiSSqtCNhy6pdfrZYAXaczMQJge0zmEw2FEo1Hcvn0bBoMB6+vrIrEOYMrZEuYiXKg6Vx5GZgLRaBSJRALr6+sCz+XzeZTLZWkCJe3YaDQK718VYnzdxUFfL168wOHhoShXq7IouVwOjx49EkIJex3Y/0ChSNb6fD4fksmk7F+n08H9+/cl8qUDIJRy584doYZyPjtHa5PYAEAyE0aDbLrT6/VCmXW73QgEAqhUKjg9PZ1SYqDDZ8BAI3+Z/QPOJeOHwyF2d3eRSqUQiURw69YtGAwGqXGyEZLKATx/rBWxXsp7EI1GsbCwIE2U/X4fx8fHotZ969YtuUej0Qjvvvsurl27hnQ6ja2tLYxGIzFWnJ1ER04Ym/VZVajUYrFgfn4eN2/eRLFYxMnJifTYkQXF2oFa9+V5nmUlEgmMRiM8ffoUe3t7oo1IqHo8Ph+EuL+/L4GLwWBAsVgUBYZsNgu9Xo/l5WW43W74fD4kEglpiCbZif0wnHnFjIFkDA63AyBEKao+APiZc0Iby783GAxCzSaRSGVVWq1WucPsoeG6aN3vws6F0QnnaqspLB84oxMWwtUmSaa+jHboRclk4EXiASPVkXx1QjZms1mGGXU6HSlSqSmnKnJIOIfMF15SdgtTvVW91DycKmOM0e6rFNuLLh5ocv1ZWFMjKzpgRmGMLijlTbl4HmRCWXz4vPyDwUAYJJShsFgskqkBL+mOzGL4rHj51GxOrbER6mHmQpIHA4x+vy+dwGwsoxO7zOL74eVTKdt8n51OB4VCQQwh94owqhr58xwwsqYxr1arKJfL8Hg8UqDm+WCXPvAyk6IxIzSiGi6eFZ5//hyb0dQx0dw/nkNGoqy5MPu5DBWZTD9CiXa7XVAINpTyvKvKECrFmpAJ7zGp4PxsdALlchlut1sw+ldrsHx+r1KGSZOl4gP3jQ5GpS4zc2EWBEyrL5P1SXtz2T0kKYAQIs873zszB7LcmHXwfVMjkZk0nbjVahUmJ20VdcS8Xq/YKzJNKZ7Kz8q7wcyScCrvHLNyElkYpLBQz4ZQNSskEUer1cqYCeDijgV4DefCF49EIlJwp8Elq4AH0WQyTQ3C4genpyXzgXM+1AIwo0A6HjIrRqORRNaVSgVbW1sYDAZYXFyUMbNut1v0erjRlHrhyGQuddLeZDKB2+2WAmQ4HMby8jIAoFAooFwuC0Y9q5EkhLeysoJ4PC51pslkIuw4VeCR0arf7xcZidPTU6ljsN+EGRdlcOr1uhSYGXFTLLFUKmFrawulUgmPHz9Gt9sVbTHWMKgtRgND+iONCmfgnJycCFHg4OBAxB85dCgajUKj0WBzcxP7+/tYWVkRhzPLqtVqmEwmohLNwiSbHrkXvIjBYFCiV+piMaPlTBpmrWq9gI2AxJdHo5FElGSC0bgMh0PBygl3kUFFCqfdbp8alEaNtnA4jEQiIeeVGlhk7HD2ytbWFrLZrMwSuoyTpuFYXFyUTm7uG2fzEAah4yWs6nQ6kcvlBJmgU9/e3sbh4aHovTFbtNlsUqim0+52u3jx4oU06j19+hTtdhuJRAI+n0+ozmwMZBHe4/FIQ/ZoNJL3yoya9UfOfzk7O0MikcD169cBAFtbW1JPqtfrM59BEi4SicRUYVuduMmgjY6FWTznDQGYYmKdnJxIJsj+K9amSQ6ZTCYoFotS2zw4OEC1WsXe3h76/b5I6+j1etFZVKnFvNdsQKeiCYN0NrgyeCuXy7BarZifnwcAfPe73xXdPLfb/dXDYow+/X4/HA6HROCspVCFmFIqwWBQIB9Gdcx2GAmVy2Xx5GRi8QGREz6ZnAtMqoq21WpVIAgSDNiYSSOsqgizw1QtGlIum3UZp9MpVGBKqDPiIZmgVqvNnFJz/5LJpGhXkeZZq9Xk97K/hRGC2+1GLBaTSIVGqN/vI5fLIZPJiDgo+1+Gw6HoOVG7rF6vT3VJP3nyBMPhEHfu3BH2i9/vR7PZxMHBAUqlkrD8KNVBJzMcDpHJZJDP52UvKT6ay+VE3mcyOR+A9vz5c+j1eplGOssiC4gEkbOzM2xubqJer+P09BT1el0YfXTcHE3t9XolkAEgENnx8fGUbD8xaJ3uXNxybm4O3W4X+/v7KJVKODo6EvZbPp+HRqPBrVu3kEgk5BzRWBPa5f5Rf4uDoijmSoIGDWoul4NGo5HI/ezsDDs7OxiPxwJXXmYRXjYazyexptNpdLtdGYnNPVRFEhOJhPTpPHnyZIoldXJygnK5jFAoJE2VqjoBI3few/39fRweHiKfz2NnZ0dkm5hVU0WalOhEIiHNnbzXlJICIPVFZtC8w+xxYw2oVCrB6/UKdDbLKpfLcgZDoZD0+VBahQV/ZmTch2AwiEgkIqgLJbSq1aqojng8Hty8eVPYZGQkRiIRDIdD6YthoEOIbTKZYHV1VUgpbrcbrVYL9XodtVpNyg/tdlsIFAzGWP9lrZFsxkqlgng8jrm5OYxGIyEUUHrqojJYF97lTCYj0AHTLBp1ct49Hg8CgYBsLtNsYtAs3DPq4eFTC6Pk9atDbChDQL0ng8Eg8ByhK5V9Q2quGkUyS1AVgxkFqtnL6uoqAoGAZFlkmnm9XmlSmmWVSqUpKIERHqEQ0gZpgIlzq/NbyJCjBhHH9pIlwmmCwHQXMfeR8FC32xU9M0JwLPJSJYDaaiwqBgIBKThS6oNNbEypFxcXkUwmMTc3J+y7cDiM69evIx6Py7O+zP4xk2JWqtefa8ix6MkGN8II/Fy8+DQ23W5XNJion0W4hJAGa1cOh0PgNdbl+P2sH5KWzKhVHZ1Ao0kK8Gg0EqYbg6/J5HxuhiosOhwOBW+fm5uTuzXrovQMsy3gPHhhz1Wr1RI4kFkmgztCabzDfOZEL9jnQeYRNfpU468SE7jHwEuIkhAtoSLCPa8O5DIajeh2u+K4+dxYj0wmk9KDxXtNavNlSCVkfFI/r9frCUxF2v+rZ1Cv1wtBhNNfJ5PJ1DAz4BxyUxudub/qwDT+PfAS2WDQyn1mUM2zylrYZDKRuiVtAMeZ03YOh0NpP5ibm5M+p0AggPX1dYTD4dfavws7ly+++AJ6vR5ra2sYDM4HzSwuLgpH3Wg0IplMiqji4eGhRHCEadipzUsOvJQUoOFlfYWHX6vVTg2v0WjOR8TydQEI5EBDSMHGw8NDpFIp+Hw+XL9+HXa7HeFwGA6HA6enp9jb2xPmx3A4xNraGhYWFkRDazweI5FIYHl5WS7ArGtvb0+of6xXkJrLCCcej+Ott96SaKHf7yObzeLFixfSU6DX60UyXu2HIV+djlylOwIQyIEzbpj9kA5Nlh+LqX6/X6YOskNX/fwMHHjoJ5MJbt++jbW1NZRKJWxvb2MwGOD27dt48803Z3bK6v4x22U9jtAbnSwjRAByUTkTnPus0WikXme1WmXAHGXOCQWxX4fECOpUEV4j/k7Ig1p1AERW/uTkBNlsFsFgELdu3RItNBIoKpXKVO3r2rVrSCaTAjH2+31sbGxgdXUVPp/vUj0aAPD48WMAL+tFyWQSb7/9NgaDAZ4/f45SqYT19XXcuXMHk8lEjCEJLwBEbJXQNrNtOnmKRLbbbTidTtlz3nkaXQ4CoyNhKwFtCTMl9rmpWmfs0yDDUc1c3n77bdy8eRPZbBYPHz6ULHF+fv7SZ5BZJW0GC/qEmAaDARYWFnDz5k2pcfT7fRn1TehUrR97vV5pmFUbm8kCJQTOuqpahyGJh3A62WpELkwmkxCBQqEQ3njjDZjNZslcqDjNnxsMBrh79y5u3Lgh4zyGwyGuXbuGmzdvihO76Hqtmgs3jB/gVdokI0vWNtRsgp6RB41LLa4xq6ERo7qpSplUIy8afEbQatTO11ML+Hwd4qEcIqSmsYzAaJx4GPh5Zl2qdAgxT14K7iP11cbjsRR0CScw8qVhUOm+ry5GlIzcAEzVv/gaZPoR5yYNlK/PCJNYMKNuNRtiFjCZTMTZ0fGrdQdVgXjW/WPBk/unFr+ZQbFo3Wq1xAFSZoj7pb5/ZuNqcVllJwEvC6Yq5ZlRvdFoFHIGzx8LpqxBqueUX3zWzDAZGLEfghkNM4hXaaWzLL4/lTL86lniXSExhj9H+RGVSKEGitwf9YuRtNoyQNRDJY0wG3yVLKN+Vhag2fGukkT4vHgGHQ6HiDn2+304nU6J4tUejtdd6r7xGalBMJ2uqjvHe6WOBlfPn/r5aK/4ReYrv1+lq/P71XvK4Iffrz5b1sJpO/lz3EO+HtEhtpMMBgMhYfDuXXRd2LkwShyPz5V9NRoNQqEQJpOJYIcUVKQzUbMTSpPrdDrhppfLZZydnQl/m0aCkXWxWJR+EKfTObV5PFxzc3OIx+PI5/OivZTJZKDRaODxeESplt3Fx8fH6HQ68Pl8uHPnjmhPkQJJtocqB840nEZ0lsUaDh0EDSMdCTMI1nV40HixAYgmE7H6QqGAXC4nNSKySNgtvLm5CaPRiOXlZSn0MbNhwfTDDz/EnTt3sLe3h/v3708xzjwej4xgJRzFrDGZTOLmzZtoNBr49NNPUa1Wkclk4HQ6kU6nsbe3J+fA7XYLi3DWNTc3JwaJRorPg3g3SRetVgu7u7tS5yPVm1R4XqpqtTqlbmsymVCpVFAqlWSMrNVqxerqqmRyhBorlQpGoxFsNpsoQGcyGXE4Wq0WS0tLuHbtmkCgwHn02+l0EAqFcP36ddTrdXz22WfSyMuaDjv0maEWCgVsbm5iPB7jH/2jfzTTHlJSn1Era2eEWqPRqBRsqWxBlQUSGAgnMthot9tIp9MSxbNmwxrpZ599JmQbj8cjtQI28ur1eszPz2N5eVmaSFXyBdW9GeAAL1llwWAQ8XgcrVYLm5ubIn1ktVqRz+cFpqRjJgFk1jtMR8K7OxgMBDpiuwIL5DToNNjst2LGxYCGZ9DpdGJ5eVmyjXa7jUKhgJ2dHRiNRszPz8Pr9YrmGzMN4HyI4srKimiRESIfj8eIxWKC5JC9mUqlkM/nsbKygjfffFPOXLVaFcoya0E8J9RKUwPWv3a/LrqxlP8YjUZoNpuw2+1CpWWjJH85o0x1UdKCjWnkvtMoEMNnJNfpdFAul6XQz8KgWkfQas+n6QUCAcly2Gw4Hp/L8DMdZsTBzmDKXzcaDXGIjEp7vZ4YWB4qFslmPZhqlqTilirNl/UjNXt4Fd5SWXqdTke03FhP4cGlSoLZbBZ9MNZQ+MyIwy4vL4vUOyPN0WgkxUiVzcfu/GQyKZI6fF6EesrlsuD0hPIY7c26eP7UrJTRKrMTRltsCuMUPwYthBx4sTmGgE7CbrdLwZ2BjNPpxPr6ukRzNDCMnimxT3KDej5VcU86ffYyBQIBBIPBqZoXsztG3MxsqSTBeSazLk5gBSBOl425DPDYC8S6p5pFqw2/fF/9/vmESNKrKSxKqPbk5GTqtSmKSYICi9B+v196tBjpU9mBdVY2SzMAMpvP5x5xuiPJLhxrweyCzaGse8yKQDBLUzMmQsMM3HjO6YC5T0ReuO98jqS+q31VqoJ5KpWCzWbD0tKSwL/MIHiOOb+IdWLe1/F4LJA2HfJwOBRx0OXlZUSjUVGfoAwMbTnRB7aZqAMWL7Iu7FxCoRBGoxH29vaQSqVkZodOpxOdIF4KPtDRaIRAIIBwOCzsEBbomR4zVSNuSC+vDiuifMfZ2ZnISMRiMWi1WknhDQaDsCK4SaSk8rCqHcfFYhGPHj2Smk4gEJBDx4iEHcY0bJfJXMi5z2azKBaLSCaTiEQiU9Ad3ydrMHq9Hqurq4LDE9Pn52UGoxZkefkDgQDeffddUQimGjWjE9axut2uDIIiRk7qt8/nw+Li4pTyQj6fF2rz48ePodVqcevWLSnqWq1WKbry+ZAiSoWGWZbL5cJoNBKWWiAQmKKGE2oldEGKdTgchsfjQalUwsHBASaTidT1KGnBS8vXIZmBQc14PBZBS9K0mQWQNML6y6uBTyQSQb/fF/rs2dmZ9Ittbm4K24djlGmcmK2azecjo8vlssCXsy7+fDabxenpKcbjMRYWFsTokfxweHgo83fY+Gm325HP57G/vy/iknTmJpNJmjPVZ+9wOKRRmHNgSH+lYzCbzeh0Ojg6OkKr1RKaOPvSwuEwrl27JkxF1gkNBgMKhQLu378Pvf5ccoYQOkVdWcsgA5A2Z9YzuLi4iPF4jFQqhYODA0SjUWlKJqTOjFqFvUOhELxer1DfaVcYELKn7eTkRGBWt9stz95kMskzIOOLe8oskzTyQCAggQwJB4lEQuqKzWZTWKC8wwAQj8dF3Z6OkM6ITEDeg6+8iTIWi6Hf7+Ozzz7Dl19+iX6/jxs3bsBoNE7RhJnNkMWRTCYRjUbx+PFjfPbZZxgMBtK4NplMJO0nhZHTKF0ulzi0fD4vlNPd3V3Rb+JBZlGLMvO8wA6HA9FoVArdxOl1Oh3y+TxSqRS8Xi8++ugj+P1+MVz07jxQVFnlgZ9lEbPMZDJ4/Pgx+v2+0IAZ2bBniPUVg8GAmzdvIhwOy9ArwoKE6pjBZDIZqXnw4i4tLQl2S6NSKpUkXWZGRmIDxxPwGVKrizBbs9nE6empZC9nZ2eIRCL423/7byMajUqfCy/4cDgUpV/CAbNebNKqnz9/js3NTSwsLCAej8tFoJMhDh4IBAAAt27dwuLiIh48eIAnT56g1+vJz9hsNoFmCGuoNFqyA0kT5iAovV4v+zccDnF6egqtVotwOCzU9fF4LKQN1nxITya8WCgUEAgE8M1vfhN+vx+np6cCm1GpgQFSqVQSFtmsizAXqaVqDWg0OpfUoWowadU2m016i54+fYrd3V05H6x/kLX17Nkz6HQ6zM/PC/NtZWUFFotFqLhHR0cyiTUejwvbtFAowGw2IxgMiojncDhEPB7H3bt3pZ2g1WrBarWiXq8jm83iwYMHiEaj+J3f+R0kk0mZhsr/ku1EtOAyzmV9fR39fh/Pnz/H/fv3cePGDdy8eVMgO/blkdZLSI70+SdPnuDLL7/EYDAQu0eSTb/fx8HBAQDg2rVrMoBPbXxmpkKm5PLyshAkCMVFIhHR0WMfG5EJ9tK4XC7YbDaUSiV88skn8Pv9+PDDDxEIBCSzZM8LIVNqqZHUcJF1YeeiFu9Z1P2/db2qf1a7jmmY1X9nhKj+P42F2n2tFj65ya8WtPkeWRtSi4yv/g6m3/+31+LvfPU9XmbxfalpMf/+5+0d8FK1lwVk7sOr3/8qJENogz/38/5dPbSEOl59HipEp1IQuX902MR0X/15/leFEmZZfIavUqx/3lKL72pRnT+rPld+LnVfXz03hBJZpFX3hPvHM0Q6Lf+rEinU71fPKZ/xq3ukPhP1DM+6+PM8g+rrq+fo1futFvC5+BnUxeBB3Ue1QK32gHDxz3w/r35OtSD96r8RIiPcqSowqHZD/fNlFj8DgJ97h3+e/VD3j8/71bOrPhf173iH+XOvkp9UQoVqb9V7+irZQn2fKgVZrRG9ul79uYsuzWTW2361rtbVulpX62r9X9blBJ+u1tW6Wlfral2tn7OunMvVulpX62pdra98XTmXq3W1rtbVulpf+bpyLlfral2tq3W1vvJ15Vyu1tW6Wlfran3l68q5XK2rdbWu1tX6yteVc7laV+tqXa2r9ZWvK+dyta7W1bpaV+srX1fO5Wpdrat1ta7WV76unMvVulpX62pdra98XTmXq3W1rtbVulpf+bpyLlfral2tq3W1vvJ15Vyu1tW6Wlfran3l68KS+7/xG78BnU6HpaUlxONxHB8f46c//Sl0Oh0+/vhjLCwsIBKJIB6Po91uI5VKodVq4eTkBIVCQYaF6XQ6rKyswOPxTM1md7lc0Gq1ODs7Q61WQywWw40bN9BqtfDd734XJycnMn7YYrHIvIO1tTWEw2GRjO71ekin0+h0Opifn0c8Hpdpjr1eD5ubm8jlcjJ/gb/baDTCbrfLTAZO3+MQLnX+9r/4F//itTf6d3/3d6HVauF0OmG325HJZPDo0SNYLBb89m//Nq5duyaTPCnLPRgM8OjRI+zv7wN4KX3NqXyhUAihUGhKyp3T4zgLot1u49GjRyiVSjLpzuVyYWFhQYY8cQaK0WiU6YQcfuXxeGSqXrfbxQ9+8APs7e3B4/EgGAzCYrEgGo3CbDajVquh1WrJdEaOnK7X61NS4P/u3/27196/f/AP/gF0Oh2uX7+OxcVFbG9v40//9E+h1WrxK7/yK1heXpaJnABkquj3vvc9PHr0SEYgG41GBINBWK1WGQTHgWvqCIlAIIClpSXUajX87//9v3F0dCRDlvj5DAYDQqEQHA6HSMOPRiO0220ZCMUZKhyox/PndDploNn8/DzsdrvI2nMuz2AwwPPnz5HP56fk5v/5P//nr71/APBv/s2/gUajgd1uh8ViwdOnT/GHf/iHMBgM+J3f+R3cvn37ZyTzuYcPHz6UeUsWiwVLS0twuVwyh4njDThNtd/vw+/3Ix6Po1ar4Tvf+Q6Ojo7g8XjgdrthtVoRCATkNU0mk4w2B87nyXBGk8/nk2FhrVYLn3zyCQ4PD7G2toY33nhDpPbVu8GRzIPBAIVCAa1WC3a7HQ6HAxqNBv/0n/7T196/v//3/77M7fH5fDg6OsKPf/xjWK1W/M7v/A7u3LkDi8UCm82GWq2GZ8+eoVaroVqtotFoIJfLYXt7GxqNBsvLy3KGuAeRSAQ6nQ7pdBqlUglerxexWAydTgcPHjxAoVAQmX2bzYZwOAyLxYK5uTm5b8PhEP1+H/l8Hr1eD7FYDNFoVAY4ttttfPLJJzg4OIDb7YbP54PD4cDCwgJsNptI8FPSn1NmOWKAZ+Mi+3dh52KxWOSDcZrf7du3odPp4PV6odPpsLW1hZ/85CdwuVy4fv26TFHzeDwyCVGn0yGZTMLj8aBWq6FSqcBiscj0v06ng0qlAgAy5wEA3G63DNcBIDOkT09P0Wq15CHxcuj1ehwdHWF/fx8WiwV+v1+m4xmNRpTLZRwfHwOAjMLd2NiA2+1Gs9lEKpVCp9ORudScFzHr4gPjw3E6nbh+/boYKq1Wi0KhgN3dXXi9Xrzzzjvi6DweD/r9vgwKowE0mUzodrswm83wer3QarUyKbHX66FSqcjALs6FAIBms4nt7e2p92e322U4Fvdwd3cXzWYTDodDhmNx+l6tVhNDQOPncDhgtVrR7XaRz+cxGo1Qr9fR6/VgtVplUt8sKxQKyf4Vi0VYLBZ89NFH0Ov1CIfD0Gq1SKfTODo6gt/vxwcffACn04ler4d4PC6jXbVaLbxer0xlrNVqMJlM8Pl80Ol0KBQKMnUSOJ9KGggEZMw2nyOHn1UqFZliyQtJJ3Z2doatrS1YrVZ5/cXFRcTjcTSbTVSrVZnqqNfrkUgkEIvF5O84JbRUKomDv8yq1WoyfdRgMMDhcODXf/3XxUkOBgMUi0Xk83k4HA6sr6/D4/Hg3Xffxfz8PMrlMo6OjqZGdbfbbVQqFVitVoRCIfl7nU43FejZbDbMzc3B4XDA4XAAOD+HdGAcfW6322UPOZ3x0aNHcLlcSCaTMp2VUyzr9To6nQ4ODw/R6XSwsLCAubk5Gcs7GAxQKpXQ7XbhcrkwHA6n5p28zuIAOoPBgH6/D4fDgTfffBNms1nGE+/v7+Pw8FCGecViMZTLZdTrdbjdbpmhk0gk4HA4pkbDc98GgwHa7fbUzB+XywWLxYJWqyUTNovFIvR6vUyX5PvgRNter4etrS1sbm7CZrMhEAjIZExOBa1Wq2g2m+h0OjCZTAgGgzJ0sVwuo9/vyx3mlMyLrgs7F05M5MxvRn0c56rT6ZBKpfDJJ59gYWEB9+7dw9zcHAwGg8yPpxGi5+e8cwDiELrdLmq1GgaDAbrdrkS8DocDJpNJjFepVJKxu3QufI8Oh0MOJqdNcnIl501zfjrnsNNwct57Op1Go9HA6ekp6vU6bDabGN9Z1mAwmBrq43Q6xWEy8q1Wq9jZ2cHi4iLC4TAikYhMreMl5jja0Wgks8RpKAwGgzhmZlqTyUQyMnU2diaTkcFXHO07HA5hMBhgMpmg0WiQTqext7cHv9+P0WgEp9OJRCIBj8eDra0tHBwcoNfrSaTOi82R1IyC6FDNZvPMF9vr9QI4Dziq1SqcTifu3bsn53E8HiOXy+H+/ftYWlrC3/gbfwPRaBRGoxHz8/M4Pj7GF198IYGR3W5HpVIRg+t0OmEymVAul2X2eqfTEefu8/lQrVZRrVYlCuQzVbMeZh18re3tbfh8PthsNtjtdszNzcFqteLg4AD5fF6mLo7HY7ncvV4P1WpVzjcDMLvdfqmhV+12G8DLgVJ+vx+3b98WYzkcDlEul7G3t4dwOIzbt2/D6/XKuOLt7W0Ui0UZJc2Rvpy8OTc3J2OhgfOx4AxwrFYrDAaDjMLmvzEapuHi99G2PHv2DPfv30c8HkckEoHJZEIikYBWq5XpoPl8Hvfv35fJkxaLBd1uF/V6HYPBQJw4bcysZ9Dlcsn/D4dDsSXMPAaDAfb29vDd734X8/PzuHv3LmKxGJxOJ+r1OkwmE1qtFgAgEonAbrcjl8vJSHXeRd5xohfcD71ej7OzM0EniKRUq1XodDq43W6Ew2FMJhOZvpvNZnF2dga/34/r16/DZrPB6/UiEong8PAQJycnMmmVWXMwGMRgMEAul5uytUQ9vvJJlDT0NFCMXji9TK/Xw2KxyLz5Fy9eIJvNyuz0RqMhRovztw0GA9bX1+VnJ5OJwDn0whqNBoPBQKAbQlaMdBiheL1eeDwe2VhOxeOs6lqthm63KxvTarUEgmJWpk4CpLHg7+KkwFkvNyORdrsNk8kkn5njUHlQzGYz+v0+nj59ilQqhVwuN3UJB4OBfBaXywW/3y+jnrlP6qTEyWQixpKRNUerMrPg86TxHwwGEkXOz8/DZDKh1+tJRM+InREX4Ry3241IJCJGW820Lrs6nY48G+DcQDabTTFK/Fx+vx8GgwE7OzsoFovodDro9/uoVquwWq3iNBjBBgIBmEwmudAMhn7e/o3HY8kemEEzozSbzVNBAgD0ej2Z316r1cTZ0/C1Wi2MRiMZtUy4SJ1WyhnphJwu61xU6IgGnogAx40bDAaB8Ox2OzweD+x2u4wOZ+A3HA5lpDTP7Xg8FkcF4Geyfd7fyWQCi8Uijprn3263YzQayajyfr8vhpVZIqeeFgoFQS7C4TD8fj9isRiCwSBqtRrq9br8HqPRCLPZfKn9KxQK0Gg0sFgsYssIYQ+HQwkEg8EgjEYjtra2kM1m0el00Ov1xN5MJhOUSiXUajUYjUYsLi7K++P7JcJitVplGipRHAbSDKwIuTK4YRmANtbr9cJkMskZpBMfjUZotVqYTCYCbep0OlgsFnlunLI6i1O+sHOpVqtigDQajWwGPyThr7m5OfR6PXznO9+Rw6fVauF2uxGLxTCZTCSFff/99/Hhhx+i3W7j+PgYrVZLIDZuLL0qI3S+B4/Hg/F4jEePHiGTycDj8SCRSKDdbuPBgwcol8vyd51OB+l0GsB5xOH1elGpVATDZEqpjmFlxK1mbJeBxUqlkjhhzm+nEaPjBiB1kj/4gz+Q+dUWi0Wcbr/fRzqdRqVSwZtvvonl5WX0+30UCgUxgsw+uH+VSgW9Xk8+h8PhwPz8PADg4cOHqNVqkvGNx2N5rXA4jI2NDdRqNRwdHYkTtNlsSKVSKBQKUvux2+1YXFzErVu3cHJygnw+D2DaGVxmVSoVgUlVR2CxWBAMBgXa4n782Z/9mVxUBiperxfj8Viiv8XFRSwvL2M4HEqUazKZEAqFxOj1+31xUg6HA263G0ajUWo1e3t7KJfLsNvtiMfj6Ha7ePbsmTgzv9+P4XCIk5MTaLVa1Go12Gw2ZDIZFAoFWK1WLC8vw+VyIRaLyXvk76YRe3Ws7qx7qNFopG5SrVYloLt27Rr8fj/y+bzMqP/2t7+N8XiMd999FxsbGxgMBohEIlJTbTabWF1dxcrKCobDoWQOXLyrjMg5U57G3mAwYDAY4Pj4GOVyWWpdvV4POzs7qNfrMBgMmJubAwAcHx9Dq9XKz6dSKezs7MBut+Pu3bvw+XySPZ+cnCCdTmMymUh997JBzs7ODjQaDWKxGPx+v4wwVqFGl8uFjY0N1Ot1fOc730Gn0xFnxDoTz02328XXv/51fPjhhxgMBsjn8+h0OmLbWBceDodyZgGI4yHMtre3h3q9Dr/fD4fDIbWper0Op9OJUCiEdruNk5MT6PV6uFwueL1eDAYDQTqIytCO0+nQnjAoeR3nfGHnwmieHpoOxWg0iuEwGo1SMCP2bzabJVKhp+Ub5GswUuYF4jxtzqsmFsmHxGiVs5/VOeXqrHRuyHA4lEIvozaLxQKPxyP47qtRO50JvTjf36xrMBhAq9VORQIkM6j7RyyUqS8dAtNmvi/1S41o1RnonJ2t1ov0ej2sViv0+vNHz0PPZ6POfqeTUp8zgwW1zsPnwueg1+ulvqLVatHv9+UCzrr6/f5URsnPwvfNQMbhcAiGzGhYq9VKRkc4h++Ne/vqlzpfnr+HAY86T16d8a7+PX+eF5K1Gn4PMx2z2SzZAs+Jir+bTCbZu36/P/P+AZDMnVk/8HIuPCFbZhbMDInfszjOO2Y0Gqe+uNSaIM8qz6K6l1qtVsgkaqatBng88yrOzz01Go0S4ROuYW2Re807zT3u9XqSAc+yGKARFeHvUJEN3mEiCZ1OR84nz4IaaNEW8f7SoBNSVveV8CH3lc+Rz4AFeD5HPiv1bPL50g4Q7eFrcO/5WRgc0Pa9zhm8sHPhxhAPZsGKadh4PEYgEIDT6US5XBa4ioabNROtVouFhQWJKrPZLFqtFkqlEprNJo6Pj5HP5yXV1ul0cDqdmEwmiMfjSCaTqNVqUmwmpOBwOFCtVjEYDAROY1HQ5/Nhfn5eMF+TyYRYLIZf+qVfQrfbRSaTEUdIp+j3+8URaLVanJyc4PDwUC7l6y6SGcxmM0KhEAKBAFZXVwXvHo1GiMVi8Pl8UswlM85gMMhB4IHu9/sSBWk0Golmzs7OhI3Ey8r/J1Ot0+kgm83Ka/h8Poli1BqaXq9Hu92G2WzGrVu3oNVqhWF39+5dWCwWNJtNbG1todlsotfrSXR59+5djMdj1Ot1dLtd7Ozs4MmTJzM76HK5LJAEM1dCqmQj6vV6LCwsoFKp4OzsTPBqBjj8TKwhWa1WIYbwQpOtaLfb5QwmEgkA51ml2+1Gq9XC6ekper0enE4nrFarsMI0Gg3C4TBcLpcYWbfbLfAlYVrCaf1+Xwqn2WwW5XJZ6jwAhKmTzWZRKBQuFX3ncjkxMGTNXb9+XYx3qVTCZDIR8ovFYkG73Uar1ZL97PV60Gq1WF9fh9lsFmhXZYs1Gg3J9AhpmUwmYdAxkm61WhgOh3C73bBYLMJcMpvNSCaTUssbj8ewWq0CNxE+JDMKgNigSqWCVCoFo9GIa9euyR4OBgOkUikcHBzMfIdpfMkIdLlcsg90GDyjDocDrVYLjUZDoGdCt7QDo9EILpdLSg1kwx4dHeH4+BgejwfxeFyg2fF4jEQigZWVFTSbTaTTaXS7XcRiMWGaFYtFgS8tFgsACBS2uroKk8kkpJz33nsP9+7dkztMyJ4Z7vLystzXyWSC3d1dPH369ML7d2HnwuiGlECNRgOPxwOz2SwFM5vNBo/HA71eL6wFu90uaTi9JxkhBoMBzWYTrVYLnU4HnU5HcH1iz/w+4uOJRALZbBYvXryQTWOETRyYUAL/a7FYEA6Hp6Jr0iQbjQYePnwoRUkW3Bh582eKxaK8/iyLxAGj0SjkANYHuH8qJdtqtaLf70vUwSyKGRxfiw+aTLnhcIhmsymQAz+DwWCAz+dDIBBAsVjEwcEBOp2O0GHL5TKy2Sz0ej08Hg8sFgsGg4EweXixCYMGAgHMzc2hXC6jUCiIcWYqPjc3JzBQp9PBwcEBisXizPvHqJsBh9lsFgbW2dkZWq0WPB4PPB6PZDE8t2ptkA6SkTUZYMz4Wq2WOFn+PGmxdC7Ay1oL6xXqs2BARdae1WoVdhNptypzr9lsCrmFAVkoFJL3zqhXJUfMsjqdjrCzGPH6/X6YTCYUi0WBXaxWK9rtttxXwiyMps1mM/x+v0Arg8EAAGR/SQNmlse/p1OzWCwS/U8mE4HXuY8kmKh7aLfbhfpOtp/JZJLiPVsfzs7OpIA9Pz8PvV6PUqkkjqpSqcy8h/wsrH0ycLVYLMIe5JkBzkkoDB5Z72KWw9odkRvWnTqdjjAxNRoNfD6f1J3JGovH4yiVSshkMtBoNBJgt1ot1Go1eV2z2Yxer4dutyv7pmbMrNlWKhWhget0uikii/p5UqmUMPAutF8X3diNjQ1MJhNxBM1mE1988QXMZrNQDNViHqMVsqIIA43HYzSbTdlQ0u5YF5ifn8fS0pKQA0g3ZnFKr9cjn88jm81K9MBiY6vVgl6vF5YaD3S/30cqlQIA+P1+YQoBEGOi9mLwvdKwGI1GYVjMGnm/9957Unti5Fuv12GxWLCwsACfz4dmsym0P5Vh5XQ6xaGoXzTcvMw8fLdu3ZIaAzFtvnaz2UStVkOtVpOoUQ0aDAYD5ufn4ff70Wg0BBLhQWZfB1lA1WoV+Xwe5XJZ6kPsb2EKbjAYEA6HcevWrZmdy5tvvgkAEhVXq1U8ffpUsuFQKAQAYqgJT7hcLunVIWTA/5J1xyx7PB4jHo9jaWkJAGRfTk5O0O/3EQ6HpxiOhBZMJhM6nQ7Ozs5gMpkwPz8Pm82GYrGIcrmM8XiMVCol+8B6DaP8arUqTpmOic6Hxtbn8yGZTF4Kmn3vvfekAFyv15HNZvH8+XOhiTOjYgDEDIOBG+FOZjo0mqS9NhoNISgEAgGBU1qtFg4ODoQSzEyRn89utwtslc1mYTQakUwmYbVahSrbbrexubkJ4JxpxcjcZrOh3+/j7OxM7oLb7YZOp5NsFoCgFcyuZllvvPGGfG6y0D799FNYrVasrKwITMzv4WcKBoPweDzwer2CiKTT6SnYUa37zc/PIxKJSADa6XTw8OFDlEolHB0dweFwCNu13+9L31a73cZoNJL9Y72G8FypVEK9XpesiXU9kkvo3LhnhNXolHw+n/TMXGRd2LnQMJyenuLs7AyNRgN7e3uwWq341V/9VUQiEXE8jLTYwxEMBuXN9no9+fler4fBYIBWqyU9E++88w6WlpbQarVQKBRQrValEZOrXC7j5OQEg8FAsNZGoyFwRjKZhNfrlfoNufLdbhcbGxsAIBTKTqeDQqGATqcjUQULhoQxSM/j5Zllffzxx2J0i8UicrkcCoWCRPmBQEBYOIRCCAeoBUkV0+Y+sElPp9Ph7t27WFxclM9RLpfx6aef4vDwUJq5yFZiDY3RWLfbhcPhwPLyMubn58U4np6eYnNzE/1+X5wF961arSKbzaJWqyESicghz2az0Gq1iMVicLlcksnMCuu8//77GI1GeP78Ofb391Eul3H//n3YbDa8+eabiEQiKJfLUnxncMBGMV4mdf949obDoVCSr127hpWVFRQKBRweHqJWq+Hw8FACEBpGMglpmBkweL1e6WU5ODjA0dERSqUStre3p2pjDK4ajYZAwuwBYYTMSFej0cDv91+6z+XDDz/EaDTCF198gc3NTTE8DocDt2/fRigUkr+z2WyIRCIStBCZYA/PZDJBv99Hs9kUGLzZbEKr1SIajSIajU59tp2dHekdY5Ov3++XHjS32y0Fep/Ph48++gjxeBxnZ2fS//W9730PrVZL6PBEAEihpmPxeDwYDAbS1xQIBITEsrKyMvP+vffeexiNRvh/2Huz38az7M7zy0WiRImLRFKiJGqXQrFHRm6VtbmqXV1uL+i90e4B5mUAY4CZh35rDDAP8zxP8w80MFtv6DHGDXTP2HDbrnJVpbNyi8jI2EOhfaUoUiIpcd/mQf4cXYbL7Qgp5y0uEKisCInL/d17lu/5nu/Z3NzU3t6ejo6O9PXXX1ummUqlDCKs1+vq6+uzZmTq0bFYzALa3d1dHR8fa39/v6uOtbS0pPHxcUNtMpmMPv74Y+3s7CgYDMrr9apUKhlhATo09SCaXEdHR+28b25uGokA54LNBJKrVqsqlUpdvW69vb1KJpNGc56ZmfnmnQsXE68fCASM4lYul60LFuoxkBYHEGfj9XqtGE8Uwd9JMmjHjW44QDClGo2GRdwUw0i5cRDACRjEqakpKwpns1nreSEdBeqT1FUUxFnW6/W/Uox7k0U2wvfFcQWDQesLIbIgAmHfgTNepT9CPHCfC3ANxovO5EQiYawlIDJoty50JMkOG1FQOBzW5OSkarWa1QYoKFIgpeh8fHxsDViSDIJqNBqWfV1klctlKzRSUwMOrdVqRj3lkkgyOAFIgr97lZzhfiYyGaLTTqdjtG3ODhk5e+ZG4cCR4PzQQ5PJpGWH6XS6S02A8w6E4Xac877ASJdZBFsEfbAkgW6A5ahdSucNgxBs3I58l1zxauAjyYIX6QwigqDC2cAxs4cuDI2h43MEg0HNzs5a1pjP5+XxeCwLZP8qlYplTNxh7JFbH7rIgkoMkQh4sL+/X5VKxaBzslu+O+fAra+CzFBTdQ068CPPpFQqKRqNanx8XJ1OR7u7u/J6vYrFYua0sHlurwzfH4YgzFkYoYODg10ZPOcMyjzPk5IFzMJvvOaSyWTsg/h8Po2Ojuru3bv2ZV++fGkpMkXknp4eHR0dKZfLWXGqt7f3r1A9wS4ldRXYeZhLS0tqtVq6f/++Pv74Y01PT+vv/t2/q0gkYh26ZBvBYFDBYNC68DOZjGKxmP6r/+q/UqPR0P/9f//f+uKLLzQxMaG5uTkjKJTLZasPSedwRKFQsA2+zOVeX1+3/6a2sri4KI/Ho83NTauBlMtlc3adTsekWDCoNK7BtIlEItaz02q1lMvlunpnfD6frl27plu3bumnP/2p/vN//s+6fv26/tv/9r9VIpHQ0dGRSqWS1cW8Xq9lOYlEQsPDw4pGo7p165ZOT0/17/7dv9O9e/c0MjKiyclJu2j9/f06ODhQNps17Nvr9apYLFoPUjwev/DF3tjYkHRm7Kanpw264aKAuWN8qK0dHR3p+PhYoVBIIyMjBpO6jYD8vHTWxb63t2dwTKfTMZhsdXVVX331laanp/Xuu+8qFAppZ2fHGtBGR0fV19enXC5nhfpKpaLh4WG9++67ajab+n/+n/9HT5480ezsrG7dumWfp1KpmNEFD5dk9QLkai6zDg4OJMmeKZGxx+MxmZJcLqdMJmMBCDBnq9UyuvertSoMNgaKgM2NhD/66CO12209ffpUT58+1ZUrV/S3//bf1vDwsGXUwK69vb22rxjM6elpvfPOOyqXy/o3/+bf6N69e1pcXNTMzIw8Ho89+9PTU2P2UTfd2NhQu91WPB43NYeLrCdPnkiSBYfDw8O6e/euPB6PstmswaeQDMjUCXgIiD0ej8bHxzUyMmJGnCyaPja/369CoaB0Oi2v16tbt27pvffe089//nP9yZ/8iZaWlvTf/Df/jRKJhMlTuRl7oVDo6skZHR3V7/7u76pcLuv3f//39eDBA42MjGhqakrt9rn8kdszg0NMp9PWlDk6OvradvCNmigl2aWEtdFqtbS2tmaMF3B7eNNEgfR0kPLzAfGuRHGk19RuKMBSD6E5j5QYg0wkC6XTpfT5fD4r9Eoymi+Ly/NqBMtr8O+X6dVg/1wCAlEXmLt7Od33fbWQy9+zbxTueR8cErgvHfo+n88KcvRsUGvgtWiUpYCN4+C/YZW50TxUcyJ26juwzei34dlfZPGM0cWikM73BGblzGA0yYAhlMCgwyhK5x3r7B8Bi+s4qeHx9xSTMaoucQKnDv2cveRMuw29biTNHvK7sIRqtVpXdH/RRXYOvRxMndoPkT9nlX1x2WAuNZU7QabvfgeyZxAMOrshitA/4WZvMNQgEbh9SkDT5XLZzrwkQyjcbJTzzP+HdMD+X3QPT05Ouqj39IR0Oh2l02lls9kuOr97BsmEQRvI6MlSgLow9K6zJDsBMuUOU1Pk9d1WAVe9A/oyPVqdTkenp6cKh8NmZ1hu9gndGrvebrf//5F/OTk5kSRLB4l2ms2mXbipqSnNzs6qWq1qd3fXPCBGATowzgNJEjqoa7WaMRKGhoY0NjZmm+P1erWwsGBMqo2NDe3u7toBYmOh2RKFJ5NJFYtF/W//2/9m0N6HH36oRCKhycnJLrpgLBYzh8nhjcVihlFeBprgoAF3YOQkGUtufHzcdLC+/PJLVatVJZNJjY6OKhaLGSUW2RBJxho7Pj42WZfNzU1NTk7q5s2bdjE9Ho+uXr1qGC3d/0SIfX19JpfisnwoRv/RH/2RFfjn5ua0uLioO3fuGNSG5lGpVDID0tPTo6WlJYuOLlrMl6RisWgGDtjIrZ0g0jczM9Ml3EcxeGhoSDMzM10BCou6As17RJljY2MGFUIVp/j87NkzM8x8Lp4pMAOaYqVSSX/yJ3+iWq2m/v5+ffjhh1aEhZpPIyp7h+4WhW00qC6TPQPtEgxgAIHrSqWSxsfHdffuXdtDoKyBgQFFIhElEgn5/X6DgKBWw3g8PT3V06dP9eDBAyUSCc3OznZ1d9Os2dfXp/X1dW1vbxtKAN0YpIDaDy0Cn3/+uWq1mkKhkH784x8rkUhoZGREpVLJYN5YLKahoSETipTOpVa4bxddrmHFgUJO2tvbUyaT0dLSkm7evKl8Pq979+7p5OREsVhMIyMjGhsb07Vr1+Tz+SxLAdKGZAOdH9o2jDccwuzsrP7e3/t76uvr02effdZVCuh0OtZGwJnm/u/v7+snP/mJ3dGlpSWNjY1pdnZWtVpNGxsbKpVKFiDhrHn2r1K/X2e9tnNxI0eiDTaIiHF0dFTvvfee0VPxxGB+pLxo1dTrdRNjI3I/ODjQ3t6eZmZmjPVFajwxMWEw0N7enokyghuz8vm8SqWSRkZGNDw8rEwmoz/+4z9WrVbTj370Iy0tLRkN7+TkRHt7e5LO4IJYLKZyuaxcLifprN4TiUS6musustymO1JjjFO1WrUIf3Z21i5Fo9Gwrl5gKLIpV6STiKJer2t3d1eHh4caGhoytWKeE4VQ2DX1el07Ozs6Pj7W1NSUpqamLCLjc3Y6HWUyGf3kJz9RsVg0Tv309LSuXr1qjYrFYlH5fN4ifOR+YF8dHR3p4ODgUjUXr9dr1F6iLZxLo9FQPB7X3bt3DRojK3P7K4CCXGmaUqmkfD5v+7e9va3FxUVNTk52yWDE43GNj4+rWCxqbW1N9Xrd2HNu4ABsOTw8rNHRUa2urur+/fuqVCq6ceOGpqam7NITAFEADgQCBk8BtY2Pj5vMyWWcC1H7qwGZdF6ri8Vieu+997okfHim6FJ5vV6rgVFAx1nQq7azs6M7d+7o1q1bXdIw09PTmp2dVaFQsD0cGxszYUYENPf29syQ4bx+8YtfqFar6Xvf+55u3rzZ1eSHGCZkgr29PWOIDg8Pa3x83GpKF91D9oo7CFuuXq/r+PhY2WxW77zzjq5fv67t7W397Gc/UyaTMRiSVgrqTi7UTmDSarWUyWSUz+e1tLRkYqA8i7GxMY2NjSmTyRhJaXx8XNFoVKFQyBrDXdiyp6dHuVxO//k//2ednp7qzp07SqVSSiaTGh8fNxibM8j9Iot2A1S3pvY37tfrbuzS0pKxndbW1hQKhYyNwAdAKgMmEgeZv19eXpbX6zWNIIwmkVCj0TDpA5rSiALxoIlEwhxRrVZTPB7XwMBAF98eSjSe2O/36+rVq2q1WhYxdjodMyhIhyNYiYyD1+tVLpczmRO3E/lN1+LiolqtllZWVrSzs6NEImGpsSSLTtz0GRp2tVq1HhGv12tZHrL3vb292tvbU6fTUTKZtCgT/DSdTttezc3Nmdoz0AxOFfiHzABab6lUMkbb+Pi4GQJEDKHkwgzq7e3VjRs3zIivr69bdnhRGihU+Fwup7W1NaMXk7nRELmxsWH1C4gFYNgUPnEqyOpA4e7p6dHIyIja7bb1a7kd2WQiqPE2Gg3FYjGjzENu4NmdnJxYgX9sbMyYQxhCnjMGkjPbbrc1MjIij8djGm4Ed5eBZhcXF9Vut7Wzs6OdnR2Fw2GNjY2ZsQSmoYBLDRWIy42MoRXDDIV0AgQI6QajBOyG8UdJAYo3+03Q6X4GgoWJiQm1Wi3rzaKnC/2x3t5eVatVbW5uql6vWzB2enqqjY0Ng6MvumgqfPr0qdbW1hSLxbqg897eXoM96ROCpo4cElkaLEXoya4uI+SDvr4+a2jk5xOJhBKJhILBoEGm4XDYiBGuYoV0FvTRfHv9+nU1Gg2lUinTb3QzRIKGw8NDs7XULff29rpIP6+zXvsnf/SjH6lWq+lf/+t/rc8++8z6CtgsIK719fUu7BtoYmNjw4TkMOq//uu/rnfffVf5fF7pdNqgB76UW9j2eM40fe7cuWMS5BzWaDRqTUUcTPBy2DG/8Ru/YWwXv9+vYrFoGwbt7969e3ry5Immpqb03e9+V5L0i1/8QhsbG0Zpvejl/t73vqdaraZHjx7p448/1uzsrM2RIbqgoEY0VK1W9ejRI1UqFY2NjWl7e9saznp6zmTSl5aWlMlkbEYNBz4YDFqn/7Nnz1QsFvU7v/M7+t73vqd8Pq/Hjx+rXC5renpakiybAuKRZAX63t5e3bp1y3Bv1BA2NjaM7tvf36/19XUdHBxocXFRv/mbvymv16uPP/5Yjx8/7mK0XWT9xm/8hmq1mv6v/+v/0qeffqrJyUnruaCxs1Ao6N69e6rX6yoUCsZso0i9t7envr4+g0kmJiZMl4yMg8Y14C+Px2POJRaLaXFx0VRs6TEIh8PK5/M6PDw0SKvZbJp8v8/n082bN63PCeeE6gAXe21tTXt7e0okErp27Zra7bY+//xz7ezsKBaLXaoYLUk//OEPVa1W9b//7/+7fvrTnyqVSumDDz4wFhNZNOrPZFB7e3vK5XLa3d01R03QNz8/b8aSes7Y2JiGhoaUSqWsYTKTyahQKGhhYUF3795VLpezAHF6elrxeNyK4ozdQHMPphojPrjzh4eHptmXTCYlnRXdV1ZWlEql9K1vfUuS9Mknn2hra0uzs7O6evXqheGx733ve6pUKvrss8/0Z3/2Z5qcnDQ9OmBQenXy+bx16h8fHyuTyWhzc9P0ycgG33vvPc3MzKjT6VgWDLpAfx7BiiTNzs7q9u3bqlarmp6etvosThSmH5mLqzjxm7/5m8YuJWOn6XJkZEStVkuPHj3S6uqqKdt3Oh19/fXXRhFn9MXrrDeCxSjqgNVCS3QLpBT6XEPFRrpFasQHodrhkCigSufFJTbW1duB1sxrE/Xz716v1x6Km87x/hRuXfIBn9fVWgL2c/sbLrKQR3H1mdgbpDHcBi8yCIwJNQtSVYq95XLZdLSg+1LAY7/cfceIvNozwWtx8CnkgdPjHIiegQLo9Xi1puQGFzAM3yTqeXWdnJxYVueyvLxer30X93y4VG0aHV3dKvaCqBwpFrJwsgn3XJFpUJjmrFCPI6jhnPDMCI6IKvkMFPypD2L02GM+p0vLv8zinnHXPB6PfVeeGY3O3FH2EA0tNwiRzgk4ZByQHVztK54LRo8siPdlX1DeJiNyz7xLYmGPcE7Qb4E83efs3nv3/19kkcm7d5j9w76RvUB2gIjhkg04M5wtSBTcN7c1w73D7Df7Q1DF+fB4PH/FVrmUchAgbEqr1bLmcVc1hXPtkqKwG+45/ZvWa9/2f/2v/7WkMyfz7rvvKplM6ubNm/L7/VbU4sNJMgiJi+OqHIdCIVWrVR0eHuqP/uiPbLBVq9XS2NhYF2WPZqhqtaqNjQ3rj4F9Uq/XlU6ntb+/r/X1dXm9XotMaS48Pj7W8+fPrZMbCuna2prBeYODg4pGozb8B3ofWQUCjxdlmvwf/8f/YbTE27dva2pqyii17AcaYMitkClQWwIq4TAiK5/P5/X8+XM1Gg3dvXvXpoEWCgW1Wi0NDQ0pGAxa7YTu6+HhYbswBwcHRrUEIuIi0CBIoXBkZETLy8v66quv1N/frxs3blizKU1qP/vZz9RqtUzrKBqNdk3NfNP1L//lv5R0drmWlpYMjkKTCgkOOsUx9iMjI2YAgB3cYUtkd0B8ZC04JCJR5nFQPGVwFDXCTCZjmRwTAglQcrmcdnZ25PF49N577ymVSun09NSyQpwzKrcQNGBUIceDY7vo+lf/6l+p3T5ThU6lUlpYWNAHH3xgciBIfyCBJMmo7LALx8fHJcmaVWu1mkkxQdufmpqyDn0UzTFy29vb+uUvf2n9U7Ck8vm8VldXde/ePXk8HnturVbLAtCDg4Mug04DJ6yt3t5ey2jb7bNhdwRSc3NzJgp7mTsMu/PWrVtaXFzUD37wAyNc4LAx7kjdhMNh+Xw+6zeTZDazWCzqq6++0unpqdbX19VoNDQ+Pm5NotTjtre3VSqVtLKyomw2q0gkYuMwcCTFYlErKyuSznTwgCvL5bLy+bypRMzPzysej2tvb0/37t1TX1+fbty4oVAoZJAbdHASCqj8s7Oz37xzef78uaWfo6OjGhkZMc47abJLw6MgzAel+EYE0tPTY4VzojOyDdhhOBg8cLFYVDqdNkcARgv9lfkIGGiiHrr9ubjSGRaZy+XU19dnDzwUCpnkucuMICq6DJX22bNn8ng8VtgbHh62XiB6CIhWiGaJHDudjrFmJBkkcXx8bGJ3fD+P50zEkmip0+lY1I5UeiKRMMiCxkiawIhW+DzUoujBoAufzmImDBLR0HuEggJRomtMLrIePXpk0j6jo6O2d7wuDhoWGLUOZDcCgYDV8YgEUUNAuoVLRPTm9/utaFssFo3Rg4YehiSfz5s6AAGBm/1CoHCxc2o0LlxIb4akLmjZnd1xmfX8+XNJZwVp7tDo6Kii0ajVLPb29qzuw12GuUmAw/1AKDWXy9k9A02IRCKWDWOgPB6PTk9Ptbe3p0gkYgaQelwul9PBwYH1vYGIsFdovtFzQTDBd5JkYrXoc1FPINMkE7/IevbsmZ0temYmJyeNlMRZoT+PzIWCeCQSsX4+YNhG42wM88nJidVVYeShA+aOG+EcjoyMKJVKddWQYN2SiZA5QiUGqaHGBZkpFAqpUqlYUytQJvU22g1cR/k6640K+tJ5YxDNhx6PR/v7+9aFTxE3m83aBYGtMzY2Zs1HPT091rhFBOIWWt3aCekzWQyNmjgoDhjRPsONKPihsiqdTzL0eDwaGxsziIdGSg4BeOrg4KBlY+7clTddH374oUWx9LUgFJdOp1UqlRQKhRSJREw3CCio3W6bgUSlt6+vT4eHhzbxkc9FhoVGEPADB4TodGVlxWi5QGtEJTjuXC6nXC4nv9+vhYUFO1QoR3OAYXIR1QcCAc3PzxvmS9GV4uRF1t/5O3/HmGtMbkTNmeFcBC5Qsqkf4ICSyaR6enosCueMulAPTrLZbBp+HYvFLEhCMogzR9PowMCAja2emZlRMBjU/v6+0um0PB6Pbty4Yc2tGxsbRiuu1+tW+yM4Y+hZu32uKs2zv0zN5dd//dfVbDYNQ89kMjo4OFCxWLSJrq4hAkZDpgRxyWAwqJmZmS49NxywGxC5vRJolzWbTdt3elqY59Jut/X+++/bjJvBwUGtrq5aRjg3N2ckm3w+b/YjEAhob2+vSxATGnez2bRpj/TGXXTRTOvCf5BmVldXDSbmTnCvmKyL0wgEAkZ2yOfzlqXilPr6+qwGwntBOjo5ObH+l/X1dfX29naVGUBDJiYm1N/fr1wuZ60GsBqPjo4sKIXBS50QCDEUCpmqyd7enp3F7e3tb965UGDkwWKQm82mNjc3dXx8rMHBQYsgMUA4D75EJBLR1NSUUYRp+HEFGzkkyDbg+dko+mtc5o/ffza0Cq2i/v5+FYtF09pJpVKSzjq9SaVhnxQKBUuXiTbg278q1HfR9Z3vfEeNRkOffvqpFUbRS9vY2FChUDA+fD6fN2FLIIVarWZGf2ZmRslkUl9//bVlCC4GjKQMuCmsNAx7uVzWixcvbN8rlYqSyaTm5+ctwqfhMpvN2niA3t5era2t6eDgwJRqgc3oW6Lhcnp62ggKREBkPxdZv/3bv616va4/+qM/sgic4GBzc1MnJyeGFdPlTCQJM3F+ft6gT+RwUDRgEbRARKHAz+viyHBw1BoSiYT1pDCO9+joSEdHRxoeHtaNGzfk8/m0vLxs8h3g5QxCC4VCGhgYUCgUUjKZVLvdtrPidpxfdEGK2Nzc1MHBgUZGRqwD/Be/+IW2t7cVDoet4RhiCfcdxxuPx3X9+nUtLCzYXScDczNmDBWRdLt9Jlp7eHiocrlsdbqVlRWl02ktLS3pW9/6liKRiObm5tTf32/jFBKJhDnoL7/80ob/USME8SDAGRoa0uzsrJrNpun5tdvtS0HbV65cUafTMZ25QCBgEOvjx4+1vb1t/Sz0DaHBVygULAiJRqOamZlRLBbTxsaGicAymZQBeDh92Iw0PRKcrqysWP1Gkn3nYDCoVCplGS91KcoSiIj29fXZWGRaCXhu/f39piP24MEDY8Gx56+zXtu5MCnO1ftBKwplUiJvIjQKuXSXvjoeFPYWeF6j0TBlVmoGfFHXW6Jr1tvbaxRHt2gG7EGxkGKldK7CiuHjIvCZeMgILyJlI13OuSDPIp1rKg0ODko6w0fpI8BA8t44FBopSZNx7DTiUayj/4XVbrftmeE8id75d/czNhqNrmI/+46+FAVyd2GcgRKhLwPJMY+Hc3ORxTwRPh+sP6BXF4ag7kLDLQ4PBW23AVM6o4EPDw8bpNjX12cO3YV6+W8yIY/HY7AujX908XO+qQu5EGUoFLJ9ks7rk2TnrhQMRXdJXbWQiywcLkYFJXNJNumUzATnSnAH3IQuGbbAJeHA2EIun3vokhKAYekuxxFgK2DiYfxgY5FNAhNyptjnV0k9Pp/PoE7qWdBqL7N/vIfU3SeE7BT7x8/xjMlYaJSlJuhS6RFYRfGA33cJOTh8+t+Q2ufnCKi5f5Ah2B9J9jyBf12iBAV8ggDOPgod/780Ud6/f18ej6crMoDC22yeq5HGYjHt7e3p/v37ymazVtxDsh7ngqRFNBrtGkHr9/uNmryysiKPx6OJiQkzIIjF3blzR/39/Xr+/LmlvcyBGR4elqQuwwPtk5oHg4O8Xq85KiKN7e1tky8ZGhrSwsKCMpmMdnd3L4x7r6ys2INKpVIaHR01Gicy/FxCIIN2+0xXbWJiwlRJO52OaWlJZ01jHDzwcbfZs9FomFYYsNjk5KTu3r2rgYEBra+v2yyPlZWVrlED7J/X69XBwYFdgkgkYoeQgjfwJPM3IF6A7edyOaXT6Qvv35/+6Z8aHJtMJhWLxbq4/a7jIuWXzqDSaDSq4eFhaxIlgAGyHRwctKyN2hay/u7rInYajUb1zjvvqLe3V48ePdLOzo41vwH94ADpLaFXY3h4WIlEQtvb21ZfGBsbMxIJWeDJyYlloiMjIzo6OtLW1tal6i4PHjywXpUf/vCHNq++0+lobm5OqVTK4MFCoWAZ6vz8vMbHxw3apk64vb1tvTyhUMjo6kCIrVZLe3t7Vnsh4KxWq5b9MOQuHo+rVCrp0aNH6u3tVTqdtlHMzJyB1s2wPbIDKNQEUjjhlZUV9fT0mEr18+fP9eDBgwtT4h8/fiyv12t9JdwTSVb/oG+FbOX4+NjQlGQyaZA28i7NZtMINzilcDhsjeXo1LnnAgWTDz74QOFwWMvLy0qn08rn83rx4oUFI+Fw2EaZYFshNY2MjFgQ6ErAgDSAiPj9Z5Myl5aWrCb2umfwtZ0LEAEFT7w2zYVgwlxOogqoqqRoeHoKfHxht3DvUjuBzfjykAV4LSJ96Vy/C/l8GvzQ3sG5uMUuqXugFFkAWD16PLzHRS+3K58DfISxZ79cLSpoyv39/YpEIl2YNZkdmSD7SbbD3lMMdSMg4B2eGcYWRk6r1eqq17jBAEw/2DjS2WHMZrNd6syt1tkMD+ovLj30oheb4ICoy6UWk8VIsiwVA8iZdOe2s19AKrB62A+XOu/SgBl7wHtC+eZnoUpjNHjWGFdJ9lmoI/K83T0Cf+du8Uzde3CRRa0RB8Azdpv2yM6oL7JHwK1oBLrFdHTWqAtwn7i7EBhc+SSXiu9CufTRsG88Q6Jm9tSt9fGM3ECADBD6NPbHRTjedEFYoFVCOrcHPCtmzBSLRUmyO8c548yQhfP8CeR4LensjJLpQT92zyOsOc41zpX7x/eFXMLvcReoN7vv6SoFFAoFI2e4d+wbdy5cBrzewMCARfIUA4kkSbuBoKAMg1Nykbmo5XJZm5ubajabmp6e1ujoqF2uV1e73VYmk9Ef/uEfGjlgaGjIGr5oJgoEApqenjatLjDa2dlZpVIpg5AwyjgsiAbb29tWDKRRiwLmRdbLly/l8/l048YNzc7OqtVqmVorhh95iEgkYkXUSqWira0tO7yk+EAQGH5qARQCC4WCVlZWDIJw53q3Wi2trq5agZDa2O7urhkc6LipVMoGDfn9fi0uLmpqasouKSn56empGc6joyMtLy/bv/O8Z2ZmLrx/GGv013BkbtBBzW9wcNAK0l6v1yBJnCoqDUSTpVLJzt/U1JRGR0fN6GFIgV8gkTx69Eher9cozPl83hhhu7u76u3t1cLCguH+wDFE3X6/v6uzn+efSqXMYcMIPDo6Uk/PmRr0ZWoua2tr8vnOZv4sLS1ZIzHFabfvKhAIGIuJrLa3t1crKyvq7+/XwsKCotGoJiYmTJ+Kovzo6KghBtQNMUhAb729vfrkk0/k8/msrpjJZLS2ttYltAjDqlQq2Zhmsiwi+3K5rO3tbVUqFQsGod5ConE1yS5zBoFaYZguLy/beyD3D7wFIxNjLp1RsclwsI2SLJNpt9uamZkxmSGX8Qbbtt0+0yL76U9/2gVhkxW2Wi2bscTzQW7H4/Fofn5ek5OTSqfT2tra6mIuTk9Pmw3c2dnpgvXa7bZNp3yd9drOhWgO+iIXhiInTUBEddG/HAeLU6LG4VIciR7pVUGyIRKJdBXeXr1Q+XzejPVHH31kXaMYysPDQ3k8HuOKoykkyWTDKYCTBbRaLdPn2dvbs3SeIhdSKxdl6zDD486dOxobG7OOZzIq2Gt0YaN2CtTEoQL2Q2KDzAStJ9hl9AV0Oh1NTEzYPgAjpNPprgipVCpZcRtDPT8/r1gspqOjI2OJcLEw1kjMu6KB7fb5HHVJNub3MvtHEDA8PKyZmRmbgeM27Pb395uMCPIw9ARxgYiSvV5vlw7VgwcPdHp6ar1E1AMlWb0OSjpCf+6CYkuNEMon+mE8HyJBZPVLpZJWV1dVqVQUiURMgh6iBc23IyMjl9o/6fwMBoNBzc/P2zl3HSfZiXQG4SH1QiQObIMcEDAfvTyMGCBIoUbgKnmMjIyoUqkYqQQ5IRw0dG4oybFYzM4od2N6etrYWUic0KeE1hlOBQc5PT2tK1euXHgPOWv0pgEJuxmF1+u1f4Ou7qIr2Wy2a+SwdH62CTJ6e3utb4eeLWp3NFpWq1U9efJEXq9XExMTGhoaMsSHoKRarRokyBmUzgv/UJvr9boF+9iW3d1dg8bc7AvG2eus13YupMMUSF0NrKOjI4uc+fIwwxBlBE4h0yEqL5VKXTME3Ml2sHQYo0wzJbQ7+gagGd66dcseMM4F3Bxnd3x8rNXVVYt6MKREqRgSuubddJQLdpHl9k9wmKhrUBMBFqDTfmRkxLBbDCcMlXQ6bZ+LPeYy02k/NDRkh4/9ozDv8uEZZkXRFtozdYRarWaaUvl8Xuvr6xYkQCog8qWZjKDCLXACy1xkwa8n1adpD9wdmjq9NIwZQJjThQGQZXHnlXO2stmsTZYkW5yamrKaHO+Fk3ad8XvvvWfFbTL4jY0NVatnEz45X0irYBCBxXBE0rnCABkiBfbLOJd4PG5wIaxP+nzS6bSdO+oIPFeCHOjmUH9R/I3FYvY6MBDpq+rr61N/f7/Gx8ft/nN/j4+PLSDtdM7kdb73ve+Z4ClKvFtbW2as/X6/Dg8P9eTJEx0fH+vw8NCosxhgF6oESqSOBDvuIot+LgRxISGUy2W9fPnSslPsBrAyowyAsMh0oHq7fTySTK6oXq/bDKTx8XGDzbCX3KfoXw5+GxwcNNVl+pY8Ho+2traMst3pdCxboYbi8/nMmQUCAbOB2AMXRnwTUs5rOxeiGBquMGKtVsuE8HZ2dvTs2TOFw2FduXJF0WhUy8vL2tnZsebLVqul9fV165w/Pj7uwlGBX+hUDQaDun79ujFU6OugTyCXy5kez/Xr142VAUWVzmiK4fv7+9ra2rJmp1AopHfeeccyAVJ4d2Nd+OeixpFIjIeHEZekp0+f6tmzZ4rH4xoZGVEymdR3v/tdDQ4OGiwyNjam8fFxeb1ea2Ck/oLxgW0Dk2liYkJ9fX22f2iqMYZYkqampjQwMKArV65ocXHRivYej0cff/yxPv/8cwWDQY2Pj6unp0f7+/u2pxjVK1euaHBwUNlsVsfHx2o0GsYO5OCTnV60ZhWPxw2fhg2TyWR0enpqBAw+08TEhH7nd35H0WhUBwcHOjo6sjpbs9k06ifsHkYZE0UDtcF0++53v6tEIqHPP/9cX3zxhU5PT7W/v29MJr/fr1u3bumHP/yhiWF6PB798pe/1L179xQKhTQ9Pd3V8b+1taUXL15oYGDAzh9GUVKXY4EWTN3pomt6etqM7vb2ttH6C4WCHj58qIODA8Pxx8fH9aMf/UjRaNSMIwFjs9nU06dPVS6XjSxBf1hPT48579PTU4NkP/roI1N2ePnype0hTqvdbuvKlSv68MMPrZ7V6XT08ccf6+uvv9bQ0JCWlpbU09OjjY0NPXz40GCj4eFh/fCHP1QikTBiyas1M2zHZe4wumRTU1M2ApoG2s3NTT19+tT0wwYHB63B8uTkREdHR4pGo4pGo2q3z8ZYQO91lZp7enq0vb1tjemzs7Pq6enpcrbZbNYyd8hUfX19mpyctJYBlFGWl5f14MEDC2Y7nY4ePXqkL7/80uptQ0NDmpubUywWs+fm9Z5NuoRMAEJCne111htnLmD8sG3IFIBYXJ0bitU4DreAhWQC8APS+RSQScNI57xer0UDZFAU1yjCYlzcDn9SOtJS0nMyINcrA0O4DAq3EewyF5veEVf/xz1QbuFbOtcUgvrpDkxjb4jIiJYpCCNDAdbbbDYNtnSZZBQ63V4e6Zw0AcnC/fNqAZvXhBGFKjb7ygEmOruocyGzhPLL92k0GkZ84P/zh33gbHBWyarc8wEtl4I/+8q5e5XODQ2avUPuxf094GCXOMAzdhmTnDXegxHTPAv3bl0mc3GzN7dJEuILRW+MPcYE6RIyb4/HY5Ru6pacDfaarI47zXlxtc24+zQ38nM8NzJj7gpOhz+QN4i0Ke4DyXJvXZLLmxjHVxc2kD2kBoNNe5VYwl2ls90lOrHP2DiIFtgnt3WCYBsUBagNYg1Nwe65dolSBEuvninuiHtXYUlyNrhTZIBvcv7eqImy0zmbIY5mD94sHo8b9AG1E4M+Pz+v2dlZnZycmKovTWw7Ozva3NxUKBTS/Py88doxhnzBn//8513DsQYHB/XBBx+or69PCwsLGhkZ0cnJiXZ2duTz+ZRIJCxKdJlTvb29mpmZUTQa1crKir766is7kOVyWc+ePdPy8rIZK0nmCGhuu6iDuX79uiRZ1Ojyyq9evWqSJmimZTIZo3LfuXPHHnq7fSbHjmzGyclJF6vN4zmTlaARtNls6uXLlwYBAe2FQiHrpJ+dnVU+n9ejR4/U09NjtEoaI73es07+QCCghYUFJRIJ7e3taX193eCNcrmse/fumVYRM+aBDaBWXtS5kHmik0TE7fF4dO3aNQ0MDNjws0AgYEPQOp2OxsbGLAIbGBjQhx9+qNHRUR0cHFjt6e7du8aScVmErVZLf/7nf27wDczHYDBoUSwF3PX1dZMGwanT/BYKhaxeBeEAhiAacMvLy9ra2jJMnhoX/WSX6bOSZDPTs9mstra2jIjh8Xh0/fp1U9egML26umrn6MaNG6pWq9bQeevWLctWM5mM1TJ7enrsGdM70+l0jOBxcHBg8vNkc3fu3NHk5KSy2az+4i/+wqCenp4eZbNZI1cAddKT9OLFCyMJAUWtra1peXm5C94GdkR54KJrYmLCGg6h5pMhLC4u2rOmJwRnjTYbGQ706Egk0qVoDgkKB05AUq/X9eLFC+v493q9isfjmpycVCAQ0M2bNzU+Pq7j42MbGTI2NmYQIdkn8jlzc3OKx+Pa3d3VysqKITM+n89QFJy8G4i+qQ18bedCwYgaAG/a6XRsE4ki3MyBegYNQJKML8+FD4fD1lF6dHRk7B4ik729PR0fHysSiVjqzSUdHh5WJBIxgTayEkldWQkbBNMKdQB+Drhkd3fXBOPc7leitItGjhS6kV4gw2q1WlaAHBwcVDgcVq1Ws2I1zA4gJ/abRixwci42QpREd51Oxwwx3eREqURU0WjU+oQoOAMl8BoY14GBAcViMXN0BALt9vkse6IoHLckIyZc1LlgYE9OTkxRoVarmWNNJBKq1+smqUNDqKQurFo6my6aSqWs/tHf36+pqSn19JwNVWKeuySTv0DPCZYQRmB0dFSjo6PKZrPa29szowK+zX9jKIjSXeVvCrTZbFYbGxuKxWJW4yITcOGdiy7qLa6mH+dhaGhIkUjE6n6MLZDUpUUFxXxsbMzqAczwgcjgIhpunatUKtl8Gjcjp6s9n88rk8mY08XZvdryABKSTqct0ifYLRQKymQylhVx1tGau8we0hdEvQrjDclBkhlgnq3H4zF71263tb6+rlarZfcImStIL1CsgfZAMqhrE7AxOmJgYMCIQFDeaSQme8FWQOWmad2VTSKrZHaLJMuweU+QkG/cuZA+u5RL3pwF00A6T1HRHarVaqb+urGxoXw+r1arZbAWhqBYLOr4+Fj5fN7qAjMzM1pYWDBNHeAcn8+nly9f6tGjR8aAkGQqq4FAwPRxGO60t7dnkQebShRSq9UMJkIYkcUsg4s6F2A4GDpkVF6v1yABSZZ+AkFAScUxtFotG4Pq9o5AToAZAwwFf56aEppgiURC/f392tvbM6cyNzdnz7parSoSiej27dsGNfDdT05OrCBNt3pfX59liv39/ZqenrbeCb/fbxDaRRcZBdAbe0G9CTkRaluvip/C8Onp6dH6+rqOjo5Ur9fN6LsZLuQDOpTpJodAAgXe5/PZ5EoCJJhy1A6np6fNADHvCJbO5OSkPXOgRJrWCDhYGNbLwGJANWQgwFYEORi0UCikTqdjRtLv99szh5YvnRlSl62HgQcaJfihwByPx4095jKoXrx4oc3NTXm9Xi0tLVktolqtmiyRO1/HJVbQzMjcnp2dHR0cHNhgPH6Huqt7py+6cM4w1egLks4VQFxZn4ODA1NdAE7b2trS0dGRMXBxpDh1iva8PmcbSJhAr6+vT2tra1pdXVV/f7817WJHXZUPPiMMX3TNyGqwGdQjIVQBiSeTSavbvc56Y+fiRgbgx65k+OLiohUtSbEprFFQ2tzc1ObmppLJpCYmJsy5cKiOjo6M8z4wMKAf/OAHGhsb0/Lysg3boVlreXlZGxsb+uijj/TRRx+p0WjoyZMnyufzGh0dVTwe78KX8co4N/pmuHQUZGFbEP3QXXsZ50LfzMuXLy1aDQQCunXrlsGKOBdSfUZGw5TiNZgbjngjGVb+LwU4ycKCwaA++OADxeNxo4zjXAKBgDY2NpTNZnXt2jWbVPfy5UudnJxoZmZGU1NTXew06XykcS6XUyAQUDweNzIEDXlTU1MKhUIWPV3GKErnTpciLgvmEREbmQXvx2fGWXc6HWO7MdWPv+c80EewvLysQCCgu3fvKhaL6fDwUEdHRwqHw8ZKe/r0qXZ3d3Xnzh298847XUKPU1NTmpiY6AqyKMYCP5IxE3z09vZaVE+2BkU0kUhcqu5HzYpCdDAYNIeL2gKZARErWRMZYy6XU7N5NvwL+vz4+HhXjeTw8NDuP/1PnEEYi25j8osXL5TP53Xz5k398Ic/VK1W04MHD3RycqLFxUWbIssdIlhtNBqmlwXbbXd3V+l0WqFQyBhqGHQypMucRaBZmF3sK5lsT0+PDU4kmMPhurVWnCljn1Gf4Dycnp4ql8tpa2vLbMTQ0JCpaQBT+f1+PX78WHt7e7p7967u3r2rarWqTz/9VLlcTqOjo0omk5bNYItxLvm/nGoLQ5daFa0FwHLtdlvJZFJzc3PffOYCHx7mgis5QjrsFpWJKil0YXRIeYFUDg8PDccGr4WFBNuJbmIMLGmwdK5nRTG+Xq8rk8l0KYFSv6GhkMizv7/f6i0U5zDgYL38XLFY1P7+/oUvNyN+YQ4RlXAgKfLBCGF/3KI/vS8UfFutMy0hvic9GO322bx3HCQ0XrqokTdx5SRw6kBFMFyoD9Bsx+8zI4NiL0EGLDuwYbeoeJnucuonMJm4CDgvCr6MG4DJCDzoFsaJztrttl0ufo6MaHBwUAsLC+rt7TVNN+i2rtyMq35Lxnd6emoBDY1tXF5Jdt7pQgdm5jPW63Xt7u5a7QWVaxCDiy76nlAJd0kzGG0yuXa73aWRRkYzNzenRuNMJp5Im14M7j+ZMgtHQi2H2ol03oXOPtKrdnR0ZGxSshiaNJFfGR4etqwep4XtaLfPxjkjFNnX16dyudw1V+dN187OjqENyWTSHLJ0ToJx6bzA7QTCZIlkeNSJkA1yJ6vCApPUZVsJPshEvN6zeTiMLSDryWQyZltjsZgFFK1Wy95jeHhYV65cMYfoqp5I5/dEkvUR7uzsfPOZy8cffyyfz6dbt27p3XffNWEzomw6jt30rl6va2hoyPotYMbgBHZ3d7W8vKzoX8pPo6dFb8GdO3e6qMXIVhBpsQHQNLe2tlQqlXT//n2j6THuF+c4PDzcNU60WCzqiy++0NHRkT045KzpqB8ZGVE2m9WTJ0/U6XT0D//hP3ztA8laX1+Xx+PRwsKCvvOd76hQKFgTJRFNX1+fRkdH7ZJw6TqdjqLRqBYWFszh0Am/sbGhRCKhubk5i0KhDl+7ds0IBKenp6bRRGG10Whoa2vL+kDC4bCazaY2NjZMZ40M5enTp2q3z7TOqDN88MEH1l9SKpU0MjKiyclJDQ4OGn9eOmeh0IF8kfXkyRP5fGeDqxiNvbW1ZVBSs9ns6nBfWVnpaj5jBgsFWdSBnz59anNewKZbrZYmJyf1ox/9yBptYZWxOMO5XE6Hh4c6PDy0AVrb29vKZDJW18rn81pbW1On09G1a9c0OjpqRg8Nr0KhYAbo6OjIBtn9+q//usLhsA4ODrS/v692u63f+q3futAefvHFF/L7/Xr//ff1/e9/X4VCwQr7BF/Qs+l9QVGaxsWrV6+qVqvpT//0T7W5uWmGDYmi/v5+Ox/Utmq1s/Heh4eH6unp0ezsrEF0ZHXHx8dKp9PWpvDs2TPlcjlzTEdHR3r+/Ll8Pp9+8zd/U/Pz81Zgz2Qy+uM//mOdnJxYLaJareonP/mJgsGg/vbf/tuKx+Pa3Nw0MtI/+Af/4I337yc/+Yl8Pp9u376t7373uzo5OTFKOpknNUyC6EqlYnXnwcFBxeNxy7SoQa2vrysWi+mjjz4yKBKFEWq1KAAQyHm9XgtY9vf3tbu7q6GhIS0vL+vk5ET37t2znh6y7ufPnxvMS+sGmeLW1pZOTk7srtC24fV6LcDe2NjQs2fP1G639bu/+7t/4369tnNB0pzsxaXNuti2JCsAk07BfCCFJT1DP6yvr88Kd8A7UO1c2p/bIImR5ec5pPxx1ZsldUEe0CbJEogo3CiYBikiXLcL/iKL16NexAAg0mH2gz/QAMkQ6QUiGwSGcOnUfC96VYaGhtRoNLpk+XlPt6uYovzJyYlFUwhQuioBQBNETMiX5P9Skp1z4fF4LErlTPB9Lrt/krqeFc8VuMGl0rI3nU7HImocHc8V8gMifdBXiebc88e/cR7cRmIyYJcm7RJKXMo29UqyVv6Xv5PUJWSKoSIbu+hCZJKA0KXouvpVkuxMuOOL6Zgvl8smZ8I54gxDAqF2BMRGhiGdK264Z96tnRHYkA266ARZFkEFRAIQDTIDzrML1xK9XzTAYdgW7/1qzZm95NzBpnVtGpk1tSueqwvfuQoR3LHDw0M7Q2QO0Lr5ewhSNKZTe+WzuZ8LKjgBaSAQMBvMHhPkuijRm9jAN+pz8Xg8evnypTUAUSAiTZuamtLMzIxF5bBLMpmMUqmUbt++rWazqbW1NWUyGbVaLRvwxVRFLiCHol6va21tzbwq0xN3d3dto+PxuFFua7VaF0NjYWFBh4eHRpfd2dnR1taWRkdHrTiVSqU0Njam58+fG5MlHo/L7/ebRPbAwICNeL3IonnryZMnevnypaWunc7ZyAKYSi9evLCImGg8EoloYmLCRp7CLALz7unp0dramtW9kHp59OiRKpWKdTNjvLj4pMZcSqAnIKaxsTFdv37dMhucCkqvrjYS0KebSfr9Z4q/jFwACrnIYoLf7u6u9vf3Te+MwjNQAoZpd3dX1WpVOzs76nTOVH9HR0etgY3LGo/HTUUAaBa22ccff6x6vW6qzy7Mx6Vza05Pnz41Iwgl/urVqza/hGmfx8fHGh4etpktKDdj7MnMgd8YssaMoYsuHOPTp09tmBoimzD++G7sr1sHQM2XTIffwWhxxmElHR8f6/Hjx3ZfKebjyOnTAL4EjuZ1oXXPzs4a/k+wlMlkjCUInX9mZkZra2va2dkxOApaf09Pj53JizoXaLgrKyva2dlRvV43Ziv1KTLR09NTywoJGKJ/OSa6VqtpeXnZzi+ZzoMHD7ruMKtcLuv+/fs6PDy0plVsJHtH7RC4EkWIVCqlqakp9ff3G2SG5NDh4aF2d3fV09OjcDjctccoQkCAoL0A0tTrrDcSriSdQzoEz03kgAFGyuD4+Fjt9pmmGHphpIrUROgmRyabDIiI6PT01FLk2dlZzczM2N/DVAFjhb7L50UHjQcoyabekTkMDg7aLOrd3V1JMg0d+PVkAq4xfdNF5IvsDZAT+C3zvdH6cQ092QaUa3BuRsVC9eRZRKNRq+mUSiWDvvgOQDIuPk2zqtvkhTAhmD96ZdRpmAFPzY2MlUzH7/crHo9bhDQ2Nnbh/aPJkXoaUS5RltsLUq/XTVoE9hxwA30ee3t7JnSJRLz7vA8PD7W+vm6ilqVSqQviJXLnuzWbTQt4aHYMh8PGMCTYymQyNmGUyBtyACxJSRal04MA7HzZ1W6fDSB7Vb7fvTdE0W6TJeeV6JrI1v19nAYIQzab1fb2dhdshJOllsV3BCVgb8hCgZIQwiyXy1pbW1M2m7W6B7NkYLXBYsSoU9vE+bnw5psshCMzmYzVyajVcgeYQ0XRH1tF1szdbDabJrDL/ByeydzcnH12esw2Nze1u7urmZkZa8akJkZGBFuUckBPT4+N+W632yYInMvlrJaVzWYViUR08+ZNq7vwLMn4JJk9QCnjddYbOxeK6fQX0DxFsxcG/vbt28bIYbodEJCrAEothuyHQ0ETpt/v1507d1Sr1cwwou1EWs3r4PCgozYaDT18+FDVatUK4rOzs8ZuwZBzMOCvA+GBt1N3ADK4yOIigyEzF8Xn89nlOTk5MdHA+fl5+f1+pVIpxeNxDQ8PW22DIU1kMdAZXUaZJLucS0tL9j2J8IFvcGhw2ImCgE0ODw+tp6Tdbpv8T19fXxc3HqKBmzXyHCnSkm1dZAF/8Z5kDDSfUScA5lpaWrILKkmJRMIgLs4W0TbRLBlbMBhUtVq1CBLJDjJn4AEXYqAQToZBZrOysmKBENAm+4K8PAYK6Y1Wq2VRMsbpsn1C0tnMEWpOpVLJRFBx0O1227Jo6nZu304ymeyiLANBEeSxOIcEMPwd8JgLz1CDrdVqGhgYUCQSkSSTRmLOi8sQ4/PRwwWC4vN1i2xOTk6azYHteBk6PFmdq9IAI5K5NARnzK/y+/0aHx83QU3YnDxz4DqPx2OBGPRqqPeS9M477+jatWtWEyNrQvMQRyOd2ZiJiQmDztfX143MBEGKe0Smv7W1ZfJO+XzeCDtA3TwDAvBvtOZCCsuF7e/v19jYmLFqhoaGtLm5qdXVVSUSCf3oRz9SIpHQyMiIIpGIjo+PtbW1pdPTU9Pjcdlm9Hq480JI+d555x0Fg0Ebc4xBBeOFaYPRZtTn6uqqfvKTnygcDltnPkOhVldX9ejRI3Mgfr9fOzs7lnrioGCwZDIZIwVcZOEAYb6Bp8KLDwQCZugHBgZsDjvMGHokaIh0MWgaqSA+uFExYnYcWJ/vbELfp59+agyxo6MjxWIxK37Pz88rEomoXq9re3vb6k0ez9nYAbIsqM27u7sqlUrmPIaGhnTt2jV5vV6tr6+b04b3f5FFbYOMZWhoSLdv37ZZ3+FwWC9evNCjR48UCoX00UcfKRaLKfqXStf0TdF3gSGg8RaHTOYnyfYxlUpZvavVaunk5ESbm5tWfwKCwUGPjIyot7dX2WxWX375pb2f3++3KBK42Ov1mpbT4eGhXWyMPlnsZYfVSWdjelutlnZ3d5XJZJRMJnXz5k1jyRF0QHP/4IMPTBsOWBRDRs3SjW5ZOFqYkdBa3dkj+b9UNkfjDydPrWt+fl6hUMh61qj/oOcWjUatqZuI3ev1Kp1O6/DwULFYTFevXlWn09HXX3+tdDp9KaaddF4rIpBlCBgS+n19fca8jMfj+uijj2x4WCQSUTab1fr6ugW1PT09ZuRDoZAmJyetf49nX61WNTAwoB/96EeKx+OWdVSrVSvyo/zMc+jr69PU1JSCwaCy2ay+/vprRSIRQ2hwkNvb21peXlaxWLQAcW1tTYeHh5qdndWdO3cUCAQM+eAMtlot/c//8//8N+7XazsX6bxgzAd08USiMTYe54DoHawSMg56VTCwLsWY4q0bYRLlQNHF+7v8clRcpW4dHf4/kBwFMLqkKXa5URqFVlej6jL8eH4X2AQoEEYTcjVcPv5I53RrinQYNZgpbr0AXJt9AAN39cswbkiY0ySYSCQssqZ4TVSPMSaShnUCiw+2G/vHs2M2CJTXizpnnj1GDWorz8g9U3xHOtDZN4gewC5uxzdEBIq+BDBogBEFcj55DjxbjCl7BwzKa/DscVDsqfvvnGPqPkTHrhTIZejcKBQQ6JA1sGegE66YpEuKoBkZth1F4VfrVUCTIAKuBhjngvqYO4qAqBqNLKBxV9uK/a9UKl0UXZfsQXMhz4K77NJsL7J4f9cOcQYoC/B33Bu+N8V9IHH2iACQwASFEYrpLIIqCAJu1uHuH6gC9TvpvNTAWSMgarVaFuxyNtxx15w9SWYPXiUx/JfWa+80FxIqXKlU0rNnzxQMBjU2NmY05OHhYfX09Ghzc9PmR/DzDPahE35qakrvvPOO9VZQyC6VSorH40qlUpLOBm3hcLxer3K5nB4/fqx6va7Z2VnF43GFQiHNzMyo1WpZUdDr9WpmZsb6GVqtlsmMx2IxLS0tqd1uG847MjJiBpLolQdEF+1FFw8biIj+BqISFKOJrGE0HR8f22FiLg2NYlevXtUPf/hDw19rtZrW19dNgoWhV9RGksmkksmk0um0nj9/rmKxqKWlJS0tLWlubk5379616CWbzSqRSJisBPAD/7a0tKQPP/xQ9fqZ/tjJyYkODg6UzWYNm5bOZG8Y4AVufpEFPDA0NKTR0VGVSiUrgFYqFY2OjqrRaCiVSqmnp8dqM+wLNQQygVqtZiqyriFdXV01qSFo4ffv37fJn/Q8ra6uqtls2iyNaDRq8CN0UOBBIMNGo6F0Oq1isaiRkRFNT09LOm9QjsVidqEJ0uhfAka9TOby5MkTCxiAgXd2dtTf368PP/xQ4+PjXc2kDO6iLpXL5bS5uWnwyOnpqcbGxqwRGkhrdXVVBwcHikQi1hXPtFKCj0wmo88//1zVatXucDwet5rq9va2Sc0AHRIsrK+va39/Xzdv3tS7775rgRpBoyud02g0bNQAdOCLZjA4QoK7Uqmk/f1900ZEz4tACpLN8PCwwuGwtW+cnJwonU7r6OhI7733nj788ENrtKxUKlpbW9Pu7q7Gxsa0tLSkTqejL774Qq1Wy+zT8fGxXrx4oVqtpng8boMGb926pXa7bYoFPt/ZWGg00KrVqh49eqS9vT2lUildvXpV7XbbxlfEYjHNz893FfYJvOm5et312s4F+InIkb4FUmkob+DO7rAoqKnFYtGYIDRTMQsC6jApHpeKRkGKYuCFRE80MZFOk0qenp4qHA5b6g6ui7YXxVwKphTD+Q5E6lxyVzX4IsulX/J5YOMAD7qd7MA04Mx8L5cmDAQDVRFaI+yicDhsERKGitdhT3t7zwYTJRIJjY2N2eHm2fG9aQwjSGg2myZzQaEZBhERIzWMnp4z0UB3POybLjITGkYp2sNKAnJB04xIDIVXDJNLwe7v7ze2EY2pQKDUTlqtlhXaYb0VCgULVuiaJwJ1YQowbvc7cG+os0nqgjPcCN3NxDD4l3EujCWArEIDH4rSbt2SQAiGGeoZQDFE0dxjnABFewgp/BtZJ9E60HitVtPExIQhIjSrco5h8vH9ua8U1Dl73Bdqlm6GSEaGIsFl6n5kr24WT2ZAlk4vWbFYtGyBZ8/dJfuilkXPS7t9rkJBkb7T6ejo6EilUsnYYuxxo9EwyDEUCml4eFj1et2mSLpZHKjJ0dGR0um0hoeHjZVGCQI7yH3BrnPGIbK8znpt5+KybZCjoBmKKAf9IeTH6TDmQmJI+TIoLFerVZv8KMnUkQ8ODuT3+022AdVg5jJUq1WlUilj8NDPASOLFBU11E6nY6NHG42Gnj9/3tX7Qk2ESJaHgdO7rGQ8lwGmzOzsrKWky8vLdugoIvNzRMvsRyKRsM+2tram09NTra6u6vT01Ci4NFoODAzYJErgzFAopGvXrqlcLtv44+3tbZOqYH/RP3Ipq6FQSFevXtXJyYn+4A/+QFI35MeFAMLJZrPmdFzFgTddRPnAoPF43DB1iuNkfq5KdDwe1/T0tGmScR6IQDOZjKrVqs0WqVQqxn7E4M7Pz0uS6eC5op2Tk5MmObO6umrO3O/3m2ODtcb+UAcCXgQeBTZymU4u+46el4suomAXYgTOyufz1nhK9kyRmnuBA+c5wniimZr7DcVWkj2foaEhg60hluCgJiYmFI1GdXJyos8++8wcmStTQuDEHaYO9ujRI4Ms+UxE+NFo1BhoQKMEHRdZKHMPDQ0ZksM+oiqONFIgELDaG02LIDgw/8gY7t+/b2cQmA2SFEEk0ySjfzkTBhmYarVqiur1et1Gm2cyGdtfIEwYe8FgUNeuXVO9Xtef/umfGv2ZTA+yAfA29pCz8brrjZ0LuNvg4KDBBg8fPtTm5qbBNqFQyFJTZMY9Ho/RQ4lA6E6tVComLzI6OmrFukwmYxsBpQ49LfBaag50y9brdTuYHEhgid7eXl27dk2Tk5N68eKFnj59KkmmtOxCNxxSDBaRxkUXHp9CIPsHNfTg4MB+lsvb09Nj3c5MpvN4PCbxXq/XjVr94MGDvyInDga7sLCg4eFhKzZCwuAgo5awsrJiEQrsJb7/6emp/P4z+fBkMqmvv/5aH3/8sXVco1AdjUYN1oHRggLvZQzj1NSU4f7U2sLhcFdmSz0AWvLg4KDm5uY0MzNjAqBI/9OoitbX2tqaqtWqjcamdtDf36+5uTmLwIF4cBowgfL5vDY2NrqafWFluVI18/PzSiQSXbJD6O+5kBVd0vTIcOkvs4fz8/MWBReLRQWDQcXjcctSgFEIDkAOOLM4FwwrmSy6WZlMxvpzXLqvz+czRXO0+2hQbTQaBiVtb2/bnURsEQPKWfL7zwazMZ762bNnlqVTl6K+CFWZO1KpVLoGc73pIoiQuuvPjUbD9BKpLUPbxa5g07xer/0dzD0gfrJh5KlgZPr9fk1MTFhwTQsCzDP6vBqNhtbX1y3AJvPA/u3u7srj8ejmzZsaGxvT119/rV/84hfq7+/X7du3FYlELNMiS6HGQqZGy8jrrNd2Lm5RDx4/KSC9ELCPkNEeGBiwRjYUevv6+jQxMWEsC4xuPB63yI7eCQ6MO7gG/B9oA/l1CrT8LhETlxwohx4NipZcHCTSKXIDiwEhEb1ddLkwF7RAMi5YI8CDHJ6BgYEuhhwXF3zX5/PZs4DtBTyBJHowGDRjSlRNzwLqCBgDdMEikYh6e3stjSdrwjBheMmGqKt4vWc6RxA1SOnr9bpJoVx0UcfJ5XLKZrM2xx3DwgWCbZVIJExDDTabdAbvIU1CdkKkC/MOSixzWSBF4AyIPiUZAQB6tDu4Dtg2n89rdXW1K3vj83LWPB6PRdbg6tBooZlexrGwqM/l83lFo1Gjy5Kpu4Vm7miz2bSmSxwE7DF3AV8BxQwNDRldHLpzPp9XNpvtatyEXNDT02OjLmjoowDO6F8MMhk3zjgSiSgQCFjwQIblqg9I57DZRRZROzYQCSnpjOY9PDxsasRkqDQ08xxxMIxK5ox4vV5jEgLbhcNhDQ8Pq7e3V6enp79SE4+sGOYotSao3OiI0bZBMEaQQEAN5EuWB3oiyWwANuJ112s7F6CW/f19ZbNZXb16Ve+99541x0lnwngI7k1OTsrv9+vLL7/Uy5cvFQ6HbS7E0tKS+vv7dXh4qIODA3m9Xkv7qDGgjVWpVPTJJ58onU7bzAn6E+joPTk5UTKZ1MLCgoLBoBWwgBrW19f19OlTg98kWY9BIBAw+fn9/X0dHh52NfwdHR3ZmObLqCIDaRSLRZ2cnFjncSQSsah4d3dXGxsbRqf2+/36yU9+ogcPHmh0dFRXrlxROBzWhx9+qKGhId2/f1+fffaZenp69M4771jTFAeGBsv19XUb6cyAJ2ig4+PjGhoaMkl0ov2BgQFlMhnlcjmtr6/r4ODAeju4BOPj4wqFQjbmeGtrS3t7ezbIiMNMwydiiRdZfJft7W19/vnnunv3rn7t137NhpJ5PB6bReLCcsvLy3r48KFCoZDRqK9evaqBgQGTKqcvwev1mkbW6OioFhYW1G63lU6nVSgUTEOMyDMQCJhuHQQK+r5g7Ph8ZwOY7t+/r0qlotnZWWNpHRwcGPW7v79fq6urpuiLc4HCTSB2GcYiUCrP9J133tH777+vaDRqEv8HBwfa29szJyxJv/zlL/X06VMlk0ldu3bNRgIEAgG9fPlSz58/V61Ws1oNJIdwOKyRkRFJ5xqAm5ub2t7eNhovTooggVENyWTSgoNyuayHDx/qL/7iL1QoFBQKhcwgU1edm5tTf3+/Hjx4oI2NDTUaDc3MzNidOzo6Ml3Bi9ZcSqWS2u22qYlMTU3p+vXrGhgYsNn1uVzO5sww7+bJkyfa2NjoagjlLm9sbNhQNgIyHMn4+LiWlpZUq9X09ddfK5fLaWRkxIYjwmrEFg4PD2t8fLxr/1z69IMHD+wZ5HI5s7PhcNhUzJ88eaLt7W2zd9Q0t7a2lEqlNDEx8c03UUrn9RawRlIuIl7wW1djikiPL4r0yODgoGHXRO+wGYDOXF0q2BkUi19txJLO6dDAWhRK3c8MHEKxmYI1P8OiSMffu1S+iywu3qvUVGojwWDQjAisNGiXMI94HdJsMh5JVsyGjeNSYt29I2Ih6gF/h+766v6+GjED50AbdXWdiBJ/VbOpS6u96P6534nP7NYoqLcQvXFG0YTic7DfZH6S7PxJMqdINE/UyR+aDSnU0oPDmYFqDmb91y2XJu8+h1drCNRi+P4XXS6d3jUQPp/P6nMnJyd2L8ioQAtoiiQzBSrjtUEhoPzy3cnAoHBjpDnTIAgubZhMG/tAbZf9Irvi2XNmXRvF/ydqd6m5F1nsGc9I6iZjQHQisOA5Qht2pWdcEV63KfPVZtNX9w9nS8bjUp3d88Pvu+cJJAcbiC2hzvzq2XLt5q86Q3/Tem3nwgGYnJy0AUhff/21ent7lUqlFAqFtLGxoZcvX1oXvTsqF/hFkskj7O3tWWcoEBGzMPb29iwNRjTzVeZFp3M2wha6JE1MP/3pT83LI7SH4YVjPzQ0pFQqpUqlYvTK4eFhzczMmIFoNBpKJBKG5cIMucianp62YiCyJT/72c8UCoX0/vvva3x8XEdHRzaKGOotBWVogH6/34rXW1tbWltbs0MaCAS0t7dnMhzuoCT2ncyJyNvl40PXJcLh/Vuts4mYbt+Dm7Hu7e1ZDQ0mXDqdNmcKRfXo6OjC+4djmpubU6dzJqPx5MkT9fX1GemB2Tco41JALZVKNkWw2WxaExujBShedzodk3yJRqNaW1szpiNwBsb06OhIkow8AKkAin6xWDRlBc4WsBsw5tDQkCqVilZWVlSpVBQOh036Awwd58a+XmYBF9N0GggE9LOf/czqmvF4XEdHRzYIi/fb29tTLpezZlTqAn19fdZcDBTj8/mUzWYNwYhEIl1UV+DrTudMhoc9pXbB3BtmClHHA50YGRmxCB92WbPZ1IMHD4y9NjMzo3A4bBE9jr5UKmljY+PCZxAV5vHxcbszL168UCAQ6FJPX1tbMxidvpLoX8r+E+wxOIwGY5/PZ4QmuuRdtYFqtWosNPq1kHoh2IQsVCqV9NVXX6lYLNrsoXa7bdMwcdpDQ0MaHx9Xq9WyLv5AIKDr169bFtZsNq125PF4dHh4+Nr79drOBY8KjJPP57W9vW2RIxBVOp22egKUNreJTpJh+YVCwUQRiXIymYwxHagx0CvzanFJkuGeRDzValVfffWVNjY2ND8/r5mZGYtkMVDQUJPJpPL5vB4+fKhcLmc0P6jOzWazq7j7Ksb8Jmt4eNguVrlcVrFY1Nramvr7++0yoLsELkrGRB8PsAg/c3x8bDAeIojoHpENwlrp7+/v6vkg4nOjPtg/jx8/1uHhocLhsFG2JyYm5PP5bAw1tRYKua48B1RcSV0GmS7/iyzODjM8ms2zoWkEC8B96XS6a5KoG925TZAuNZQsB9LJwcGBOXpwbJg6kUjEmnjJfhkVgWbe/fv3tb+/r4mJCet9wLjg8N1s9fDwULlcTteuXVMsFuuK0N2M+zLyQ5LMqMNEKhaLevnypTWSUjQvFAq2J5Ks+Zniut/vt+wDkgijh+kxot+JQAhVCfbQlTZxqb1Mefz5z3+ug4MDTU9PK5VKWR8Njc5E+jilnZ0dnZycaHZ2VqOjo9anQWbv9/stA73oIkjiex4cHOj58+fy+/2amZmx/XNnD3FuafZ0m8AlWSOky1Clrogzpv2Du0oWwzmGhELwXKvV9Pz5c+3t7Vl9MRqNdsFc1WrVSEWnp6d6+fKlCoWCCbziANEpCwQCVlN/3V61N6q58EBDoZAajYYxqzhoPT1no3JhKfX29mp0dFSRSMSiMbeACWuErlrYSMwtwVgxZW5ubs70d2DP0JQIW8nj8WhmZsbmSsA64b1RnCUShPWDYaXRE4YTxpAaxkWNYy6XkySLuIjqfL6zUbmI+aVSKeuFwRASkVEALZfL1iuEE8cAMhmQSZRgsz6fz2ZtQ2t1O58pmPf09Gh6etqiUFJnIu9W63wULxcHkgCvCYOIVJvvSnZ6kfXixQvDz4EYXP03ejiIsti3eDxuhtzNXHEmkDl4FjMzMzbdk05qBAgXFhYsk+V7dDpnEjI0Ofr9fl29etXUDgYHBzU4OGjNhLXa2ZRWoGH6ayBDoM1H1N1ut23AHY7poouoE4dFrYIAzlUjJvDgPlHghc4ONMUMIheiGh8fVzweNxFJdzZMJBKxCZywEd2Cfn9/v2KxmN555x0VCgVDHCAJUQdFV4u9InCioM+dcxUlGDB20QVb030GkHwYZdxsNo02754R6RxSAuKUzuFe7pTPdzZDSpJJT1UqFWPiLS0taWZmpqt3SzprMsZ5+f1+a6CmTj0wMGA9PsjtuHuH3iPQPFCoG+AwYfYbh8WgAfKB8bCwYfL5vEZGRixTAMZCuh5jDmPM6z2THXGnJcIki8Vi2tjY0FdffaVSqaS1tTUdHx+bh3a7dZHSTyQShvleu3bNCuIutVOSQSLlcln5fN6aMeHU0wCKjhODnSgIX7QgzRTLeDxuLAzw+rW1Nb148ULvvvuubty4YUVwF7rBiMFKIqvDmOIIpqenlUgk9OTJEz1//tyaAmu1mn70ox/p7t27Bj2AgUO5heJ79epVe+YQAVD3lWSdzuwFl8DtDUJRIRwO2+9fhhDx5ZdfWs0ORhsCkbD/hoeHNTIyYn0SkA7i8bhlU0TIOBcGXMVisa4i9u7urp48edIV1UEPxeG6NGhIANwNgh4gkfn5eXk8Hj169Ej7+/umG0dm5fV6jQHkZn6hUMjIFu4zuMiCikqUyygHn8/XJWfjZrUEfLdv3zaHK53T5QcGBjQ1NWU1O4KYwcFBPX/+XMvLy9ZDUyqVdOvWLV25cqWrtwhj59oExguQBSE6K0nZbNZEXOlbgpFFzQhkxK1nwY676B4CW1GLoGes0TgbutdoNDQ7O6vr169LOtfDcxtAyT6BmdxaNdD+lStXND4+rqdPn+rP//zPVSgU9OzZM52cnGh6elpzc3NmSwlIyDaBxKenpw2x4A92hxHNZFA0pRYKBbMtBIk4K6/3TL5/bm7um3cueFVGilI3oKiMF2SiHgeNFJIU1S1eIfhGPYeo3O/3G3XZvchEgS5EhYFzOdhkR1K3nhMPU5JdbiJrjCGL6MSV4iA7uMgCGqpWz9SBiWZ4XbDQfD5vlGiMNIcUh+JKbZNh0IMAbbNSqVhUVS6XFQgETMMIqBI4gsPDHri6QjwXLr8ki7LIRNg3d5+AMHE2kAguun88N5wDxU7+TlJXtksUTlRGduU29/n9foNU+X2yhWazaRg5kkYwk6BXsyCugIEDG3APpHPDxHchii6Xy9rf3zcI9K8jjnCXLpO5uP1HzWbTshUo2a6eFc/crcm5ASIZDgaWewYJgbtO0X5kZMRqT4zZ4Gcx1PQh+Xy+rnqhS7TgZznPiUTC5uTAyOTnent7zS6xv5dh3LH3GGPOoHvua7WaDQJjuYVxfofghv1zSQsugsJeMKrcFfblfHJXeQ9IEO4ddN8bR0PgRwsIz5/z29NzPnbefb3XPYOv7VwWFhbUarW0vLysn/3sZ4rFYlpcXLQH2Gq1rAkK6AyvTCREbYWmqeHhYc3Pz1sTGzOagT38/jPZ7rt370o6k51eWFgwxwZmjjHZ2NiwaJn6C6wIHgLRweTkpBYXF3V0dKRsNqv9/X07eBxcHsSrU/susubn59VsNnX//n0tLy8rHo9rcXHRHCx4/89+9jNJ+iuHkwvu8/lMtiUUCumDDz7oMuBQCcPhsHWwY/Ru3LihiYkJi1JcccbT01Pt7Oyop6dHqVTKIE+3gEhBur+/X9PT0/rggw+UTqf11VdfKZPJ2MF3nRKFR4zVRTM/5OIZ/Eadw3X+LiaMoWHgEXtIcdfvP1M7vnXrlsrlsra3t7tGDiM575IIZmZmlEqldHp6qu3tbRO0RM7EJTFIMjHVVutMs4x/SyaTmp+f1507d3R4eKi9vT0bhjc8PGzUXCAjol0Xw7/Iiv7lUKq9vT1T/2aq5KuBE98Lx4mRpt+BjD6ZTGpxcdEG8VWrVRsx7vV69f7771vQ2Gq19N5772lhYUE7Ozt6+PChCoWCQWrFYlGbm5vy+/1GpeX+ImnCPkxMTOjatWv64IMPrKmVNgNUFtDrQ8VCkjGjLrLoF3n+/LlevnzZpcMFZH5wcGBEJyBU1yhz37ApKF6gFlEul/X555+brhr9J0CCd+7csTre8fGxqQNQwyGoIogiE3bluVKplJEA4vG48vm8zXYByUAWivNHMMGZf531RpL7pMX7+/sWSbqRTrlctj4AGCWNRsMKy3hUDA+du0QVFP5Ig91pkEAhrrfmtbxerxWS+Xk+k9v8iXHB6TEzHs0yHIdLq3w1IrjoQhONPgP6GMjO/H6/FUcl2eHDyQKhcUBp4qLvh0yPNBnnQ8QLw8vF08l43E5ot9mKQ4phISPkTzgctkZA97vwuYGNgN9c3v2bLpyJS291sxBJfyU7kc6bV1kECewDRVrqXIwSQF2CvaKgTwBCJsb3rVQqKhQKXYaDPaa+0OmcT80kcwHGcPF47gvPgkj8TaLGX7Xo/eG8wCzCmHCXpPNsjH3ld9gbgggiaJABggjYb66BgkyAc6cwTeDJPkF6IQvBNrjSLZw/YEwo8SAAUKuxOW7Wc9EAx82ujo6OrPGac+/1ei0TBepy1aJdBwM1mGyYPW+1WhbwkuW5d5ag3WXPus/NhQGl88CUAFySZUL0vUGIIVAn4MAR43BADb5xWGx7e1vSGaV2cnLSDEer1bJmHopMwWBQqVTKZpH09/d3CQLSqf3y5Us9ePDAshn6JpCluHLliiRZbWdlZUXb29umoUVBkS5UJGoYRAZdErG2VutMzwzGBB3RxWLRfiafzysSiWhqakrtdtvGkU5MTJiW2kVWOp2WdJbB0IgEnx+YEUNFdzOFcNh5SOTAda9Wq0qn09Y4SjROREQAIJ052oODA+v7WF1dVaPRMGqn33+uWUYE7jLwIDgwP+Po6EgHBwdd6gfb29uqVCqamJjQhx9+aOdmd3fXIvaLRo1E8xMTE0aFx4Gh0sDlpWObf3cdhwtH7u/vd9W2uEA4TyAttK2Y9lksFrW+vq5Wq6WZmRklEgmFQiGr7ezs7KhQKBhJgIZJOso9Ho+JQBJpRiIRg1uY7QE1GiHDy0TdkswYTk5OWqOnK7XEiG8cBwaRWtLu7q5114MerK6uand316DSvr4+00oDemw2m8pkMnZuNzY2lE6n9fjxY1UqFWvCRYap2WxaMR77QYHZhS6haTPzhTpwsVjU/Py8IR4oDsdiMcu8LrLIjFKplN03ahQ7OztdQ8/oeh8YGFAikVA0GtXR0ZE2NzetVkXT6vr6ukGlyGXB8qTOBM1/ZWVFmUxG+Xxez58/V7Va7RovwP5Q88OxUTbwer1GNWfUdq1WswmzNEJPTU1paWlJkvTo0SNtbGxocnJS8/Pz37xzyWQy8vv9unHjhubn561T2h3mw0Xu7e3V2NiYSZIEg0Ht7Oxoe3u7C1ra2NjQkydPFIvF9OGHH5qcSG9vr3V0EykgpJjJZFQqlcxYX7lyRclk0uClWq1mjiMWixkPnmIp3tllm1DfyOVy2t7e1tzcnMbGxtRqtfTJJ59Ydz+R7EVWLpeT13vWszI1NaWjoyOtr6+b/DYzwSkaRyIR6yWJxWJ2sckQ6/W6CTHG43EjO9CFLp1HQqxsNmuKBpubm+aAgUWAZJieSC8GEicuAeDg4MDGslL4S6fT2t3dNcFNMOiDgwOTW7no/lGvoUu4VCrp8PDQ5C9QRuYZ0UEO9VqSFfmlM+fCxXYZjBhE13mdnJwYRReCxebmpiQZ7R6q58nJidbX15V3JppSE4DBhvFMp9NmlEOhkGnMQcrwer12RgiULpu58JmJfAkeNjY2DCqjlkJdJhaLmRQ+0SuZbCaTUbFYVDQa1e3bty1wdDMF6awv6Pj42FCPo6MjYwCiisx8Inc0N6wnGFNA3QRZxWLRCBTtdtt6bOiPIcuHvAOr6iKLwGp+fl6Tk5MqFosGae7s7NiYAe4iNeJUKqXx8XGtra1peXm5q27EwK5oNKpbt25pYGDARD6TyaSmp6fNmddqNYNvj4+Ptby8rGazaXp/oAw4EndMBBkJMHetVtPIyIgFMUhs7e/va21tzVCRTqejra0t3bt3z2RhXnf/XvumE1kzn9pVP0ZFlTSQCISsBkyPNA79L2RCSF+BtYBv6OeQzguapJBMBuSLQkfl8nY6HdPPks77TDiYEANQEGAuAqqjPAjYR6jfXjRyhMt+fHxsBAcKeURnw8PDNkEOVhKwEo2PLixD+h8MBruos6SuLt0Rlh5Rzu7uru0T0AM/586jx6Hh7AggiJRI73t7ezUzM6Px8XGNj48b2wlpCVRhL0PlBkagXwOSBHW9oaEh06RyIzkgURg6dKC/2ukPPd4dIEbdD6cFrIrku8fjMdVt9LcgoeCEm82mYrFYF5TnqlgAdyLtEQqFDBaix4iJhpfJXLa3t+XxeIzYgQEEzmIsAnOUgFFKpZLR2mk2RWPMvbcU8SGguFliMBi0OgyNhUDcnU7HMjhejwZEIF1gSVeVAwaodE74mJ2d1eTkpCYmJpTP5yWdkQlu3LihsbGxS9WtCHCKxaIxMMmU0bdj+i6Bjs/ns8wXKE06JyK5ageQJty6IME4/0sgBKoBOQdI0B2GKMnQGQJ27ne9XjfEgjvdarWUTCY1ODioiYkJG7lNfX1iYuKvICL/pfXazoWO5Gq1qs3NTQ0MDCgWi0mS6QONjo52ac/Qo0Jntst8AEscGxuzlJdCHEYUVhVQBZtB2s3GUrilmEudZXd3V7lcTqlUSt///vdt/gjZCtE4TJP333/fiqzPnj1To9GwgUQU1i5qHNmDSqWinZ0dJRIJXb16Vc1mU/v7+2q1Wrpy5Yql8jjB7e1ta/BEqBEn6rLgoBS6dGVgNqJJhoXt7OxoY2PD4EOwdbBb9Mm2tra0u7ureDyumzdvWipPo9z29rZlPz6fT7du3TKSxMuXL1Wv15VKpWzULcb5Iuvly5fGaMvn84rH45qbm1MoFDLF4+npVytAigABAABJREFUaV29elWNRsMuP45ZkhFJGH7l1gIJYghsiPjI6Dwej2mLUVvBiSOzDqGEiHV9fV3b29tKJBK6c+eO/X0gELBCPrT4drutDz/8ULdu3dL+/r4ePHhg2k9XrlyxxtDLZC6ffvqpPB6PiZqmUinNz89bwRe69be+9S01Gg3t7++rXC5bs2Bvb69Rl2kKBfaifuNqXbGnUOZxTNJZVh2NRrvEPclEgGh5TYyjS4PFITGLCYjqO9/5jq5evWp3uNls6vr16/adgD4vsmCjbm5u6uDgQMFg0BpSEa6cnp428g5Q6/r6ujWLkzUSWBB8YRsw+hCJoAWznzgy1ykQzHM3qNV5PB5ls1kdHR1pYmLCdNBc2SfqqWT477zzjmZnZw1Rqdfrunr1qpaWlrp6ZV5nvZEqssfjseiE6NAtZsGygiVEKkaPDI16rhaOdC7jTyRISg7Dg/fjcPB+OB0E7txCFr/H6xEpupEjD490ks+P6nK9XjeRQujCF11EHW7kxWcEgnG7vYk+MI58ViJsXovIGwfB9+N9yGDcQqZ7ONyeJPaCZ0E26uqW8dyJ7iFS4GTC4bA9ezBzCr4wVi66f5LMGEPtdYvcFIbZA/esSeoiHri/9+prEJkRkeNQifaRyeBcElxRnCa641n5/X4jjbgjhaF8kyEAkUHvf/X5Xeb8Seejv12Ku/v9OVdkxwQlRMSv3iW+36vECs4NvVnsrQunuPeRs4XRcz8L55MziDN7lbThMurC4bBJTJEtkY1DS77M/v2qO+wSMcgMKKTT2Mld4FmSkbxKhiG7A1XhOwBXghy4NhDoy83GXXjX/QMs51Kk+V8aisn46/W6gsGgBZBvcgZf27m4EAR/OBzIHmCgYUyAi6NATPTaaDRMC+ro6EhDQ0O6ceOG+vr6lE6ndXx8bJnFwMCA3nvvPSUSCZNOx3lJZ8W1xcVF7e/v6+XLl/bgfT6fFhYWdOvWLWuqAr6oVqsaGxvTe++9Z1gsU/GYdQE+jgwMB6TT6ej3fu/3XnuDWcAPkBwCgYB1Y/Pv1ChwrPQNUS+Cok2XNKrS4XBYi4uLZgzQhUqn0+rr69PVq1cVjUZVLBb15MkTk/CXZON2Dw8PrdjIIZ6fn9fVq1dNQUE6w51LpZJGR0f1wx/+UPl8Xr/4xS90dHSk/f19RSIR65B2GX38+0Uv9tTUlP330dGRenp6rBkMeRKK5M3m+ZA45FUwVFxEalcUpjGoXFAkWfr6+nTnzh3FYjHLqH0+n9bX1+Xz+TQ7O6vp6Wnt7+9rZWVF0jlDbWJiQuPj40b7hKp6enqqZDKpjz76yLTcUFJ49uyZ1cUgUJyentpFl6Tf+q3futAeXrt2zWomzL/J5XLWrT8yMiK/329jsUdGRtRun0kK7e/v2z3AuUJzR2Ke0Rv0j+VyOX3yySfy+XwGqWA4e3p6jBp9584dLS4uanNzU48ePVK9XjcUYmRkxGT4YdAxlZGawcnJib788ksVCgVlMhltbm5qd3fXNO8CgYApDWM/LrI4yzR6YqghjCBsSkC4ubmpk5MTm37rQlSJRELBYFD7+/va2dlRLBbTBx98oIGBAVOhwHYGAgEtLCyYXBVZHs/u6tWrunLliqkdS+dj2Wk0BoqnBaHRaFhNp1AoaHt72xrKYfuBbDBSAx25192/N9IWk7oVT30+n6VmFPuIek9OTqyAVqlUuiiqXObDw0Ol02nDT8PhsMko5PN57e7uGv0zGo1acxIRgSSbU46wG1E0tMdkMtlVwCei4eK/KmjJ4aAeAwbKaNCLHkw3GmRQEA6ZhkiiFbIBV0nWpVoz4wGBz3q9biwON7rBOUNLhuHFPHePx2OUWPYFJgtsEnoF2BPGHNOtC4OKw8jrSN0KqjDOLrp/GCIuHppM0vmMHPaKjIXPjfApUEKtVrPsgD2loM/ZKRaL2t3d1cDAgE1wRILl9PTUnBXifzBzXLgBHS2yH1g8h4eHGhsbs6Lw6uqqPWsMCueYyBWa+kWds3Q2M0k6DxAwInw3AiACN2o87t6gdwWFmkzSpd5yzw8PD7W1tSW/369YLGYsNKJ0ovhkMqnZ2VnVajWtra1JkkFKjOlwo3mXbpxKpWzGEPecGi/9XcCYsNUuuod8dgIUtw2DSJ/gBKiPzwFU2Gw2TXCT9oNcLmekDuq9kBA2NzcVCoV0/fp1o67zfNz7mkgkrHTh1lehGzcaDdsPXt/rPRNQdZEQl/7OXhOU1et1HR4edpGE/kvrtZ3LxMSEWq2WdnZ29Pz5c2vkIS3GM1LHYPM5GEdHR9rY2LDiHg4DCqKrlwX9lvegmYqDg2YUBhmmSCQS6RJcg3GGYcPbw0bB4IMpAj1hqNrttnWzksVc1DiSlmezWe3s7CgUChn1lwtKJInh6u/v19WrV7WwsKBsNqv19XXrHEcWBAwXqiKpdyKRsOgKOiyyLz7fmYYWuC9Ub7eoyP8fHx/vIj1A+S0UCvqLv/gLtVotLS4uam5uTuPj4xoZGdHBwYGNnAY+IuK76P4NDQ2p2Wxqa2tLq6urarVaun79uhk0shEMMCoGyWTSGsV2d3eNQv9qJ/Or4qiTk5M2phbV42w2a53TSGk0m01jggFNANEmk0lT0uVcATPmcjndv39fXq/XSBA4cODndrttml4Yx8tAY9zR4+NjbWxsGNWagE+S1VhgBaEPGAwGbQ4M/T04c0lGXoB4Ajz1rW99Sz09PUbcSafTNhYZ5QNYSgiiuooUSOe42TyBIArg1Pvu3LljsJJrLN0g51VI7U3PYKfTsRk+4XBYqVTKPqsbGOI03fHOUJEl2ZmA2NTf329NjGQMDBujJ44m4Ww2q0qlYrXAdrtt0lXYaexyKBTS+Pi4OaVaraaNjQ0LnqjNXLlyRVeuXDG2KqQh7ggweDQa/eYzl+npaTUaDT148ECffvqpFhYWzPhLZ5E50gd4UwT7otGonj17pufPn1tE1+l0TJKcaAnpByjMpHR4W4xvb2+v0Y8lGccdOQ2cy9DQkK5cuWJd2hie09NTra+va3d3V2NjY/on/+SfaHx8XCsrK9rc3LRmPEkWFdTr9S7JhzdddGqvra1pfX1dqVTK+iA4UMfHxwaZRSIRBYNBzczMaHR0VA8ePDCjGgwGNTQ0ZD05QGS9vb0mp55IJCzrIBpmDHU0GtWVK1dMhpzCHawzoCXeH8dK2u/z+bSzs6NPP/1UIyMj+sf/+B9bfw3ZLIVYGDNuw+xFViwWM4nyBw8eWJaAY8GQEL2BK8Pye/HihdbW1tRsNk0VFlYemYv7v+hQYdTpc3n8+LF1f1MHTKfT5tjL5bI5m76+Ps3MzBhphHvS29trNOhEIqHf+q3f0ujoqNbW1rSzs2MEDUk2ZK/VOlPBvuj5k84bSCnQQ1l34Ut6yGgqZsxzMpnUw4cP9ezZMwu8AoGA3ZNqtard3V2DYtB+e++996wWIZ2x/nZ3dzU4OKjp6Wn19fVZmwFzn4iYm80zufdr167ZiI6TkxMjU2xtbenx48eanJzU7/3e72l6elrPnz83yNItbBNIXca5xONxNZtnY5OXl5dNv4usiaCMuvDk5KR8Pp8xrR4+fNildgwciagpKt88D0gXkgzyPTw87NIphE2HUOzc3Jx1+6NCPTMz09Uft729bdqKz58/VzKZ1D/6R//IGHZk+rVazRi5BAvxePybz1x4WHhctxjlLrdI7xa63BTy1UK+1K0cSqThFpr5GbcA5jJH3N/l7/gZUmr3vYDWyJZeVbp99TXd4u9lFu/NA3KLar9qT92o2v1er34utzDn7p/7eV99XbfA6vYkvLrH/L3bEQw0AsmA/eMz8YxdSupl9o7fZe9+FXHD/Y58B/bhV3X2vxqBuc+Y78T3dt/71Wj41f169f//quflQnfs8a+iyL76GpehIruL7/Hqcs+i2xPE83XvoPtsf9UZpqjsnl8XenT3y/27V7+/W+R2nzPZAgaQepj7XX7Vumj2x/vz3tjDv27xTN2g5Ve95qvnyL0v1HX4d86+uyf8G+/nUv7dv3OzOtcGunf4r9s/92687hn0dC4D4r5db9fb9Xa9XW/Xr1jfTBj0dr1db9fb9Xa9Xc5661zerrfr7Xq73q5vfL11Lm/X2/V2vV1v1ze+3jqXt+vterverrfrG19vncvb9Xa9XW/X2/WNr7fO5e16u96ut+vt+sbXW+fydr1db9fb9XZ94+utc3m73q636+16u77x9da5vF1v19v1dr1d3/h661zerrfr7Xq73q5vfL11Lm/X2/V2vV1v1ze+3jqXt+vterverrfrG1+vrYr8z//5P5d0rpR5cHCgZ8+eKRgM6nd/93d148YN5fN5kzxH3nt7e1uHh4fa3t7WgwcP5Pf79e6772pkZMRk+QOBgGKxmEnHF4tFG8JUKpX02Wef6eDgwNQ4h4eHTTKeGQ8oljJTpt1u6/r161paWrIJk+VyWV9//bX29vZsfjjzWvx+vwqFgs3wZlYNKqSucuv/8D/8D2+80f/9f//fSzqT7Y5Go9rY2NAnn3yinp4e/b2/9/d05cqVLkVUJnw+fPhQKysrqlQqOj4+Vk9Pj5aWljQ0NKREIqGRkZEulVZ3GNr169dVLBb1B3/wB1pbWzPV00gkovn5eRs7zVhUFF9RjZ2enlYqlVK9Xlc+n1e5XNann36qjY0NJRIJjY2NKRQKaX5+XgMDAybrPzg4aHNgvv76a+3v79v8bUn6n/6n/+mN9++3f/u35fP5ND4+rkQioXQ6rUePHqm3t1d/5+/8HS0sLNhsoFKppI2NDZVKJe3s7Ojw8FAnJyfKZDKSzuT7+/r6NDQ0pKGhIVPUlWQjlBneVK/Xtba2Zt/t9PRUsVhMN2/eVDAYtM/X19dnYxUKhYKNfGAkAhLmn3zyiT0LxkLfvHnTJngy0yQcDncpkZfLZZtb9L/8L//LG++fJP13/91/Z9NQBwcHtbu7q/v376u/v1//7J/9M924ccPGezPDp1qt6quvvtLy8rKNvujr69ONGzcUi8VM9di9H4wrHhwc1PDwsCqVih49eqRsNmtnkHEcDLJj0F+5XO4aPjg+Pq7R0VF7/Uqlos8//1ybm5s2iXJgYEATExM2E4XJmIxMSKfTNiywXq+r0+lc6Az+j//j/yhJNp9lZ2dH9+7dU29vr/7pP/2nNl+IefaHh4eqVqva29tTLpfT1taW7t27J0laWlqy2SnBYFChUEhzc3Py+/169uyZdnZ2FI1GNTExoZOTE/3pn/6pdnd3NTo6qpGREYXDYU1NTdlYbBTQUZFnVPvCwoJmZmZsblSpVNJPf/pTvXz5UslkUjMzMzYEj3vA+JRisWhjCxhHjV38F//iX/yN+/XazoXlSjkz3Q+jhCS0JDtwruQz0ueuDD7rVXFmvpQ7p1pS19xuVwLdfV0cmyspzeu7s+T5vEj6u1Lc/DfjBX7VZ3zT9ap0OvvH3yPDjsw4/86QJ3fWw183HsD9/K6ku/t7vJcrkf7q77uv4Y48eHU8AfuHMXAl91+VYP9VkuoX2Ts+K8/SlcTHMLr750ruu2MD+E7ud3el493/776nuzcsNwjh99gb5M4ZvOTOn+e1cCLu5+A1f9WYgcssdw9dw8R3dc+NO8Ne0l+Rev9Ve+h+B/e5851fPbu85686i+4+82/uPXD359W7yn9jI159Rhdd7p3jPrB/2Ct3nIF7VpHdf1W2/q+7F27w9+oIDfffeV7uvxMcM1qE7+7em181AuTVO/vqOIXXXa/tXBiLy/jMQCCg4eFhBQIBDQ4Oqlqt6uDgQKurq4pEIrp7966NNe3v77cxmUxoY7qfe1ldo8vs6WazaeM4iQp8Pp/y+bw6nY4NsQqHw4rFYhYJtVot7e7uamtrS8Fg0MZ5MvWt2WxqbW2ta+7H6OioYrGYjShlOFW5XFYoFLLBZhdZXAbGHE9OTprhI4Lb2NjQ8vKy4vG4vve97ykcDtvnOjo60tbWljwej5LJpAYHB23CJxEwUzk7nY5F661Wy+a/M9bX6/WqWCzav0tnkffAwECX893Z2bGJnQMDA5LOsplkMqlSqaR8Pq9isaijoyP5/X5NTk5qbGzMJkZyJo6OjtRqtX7l5XjdRSRPpDY0NKQbN27I7/fbhMuVlRXt7OwoHo/rO9/5jkKhkFZXV7W/v6/9/X37rkxWZHxwf3+/vX42m1U2m1UwGPwrwVIgELCLyCRHzk8oFFI8Hu8KtLa2tlSpVDQwMGADoebn52089M7Ojtrttr1WLBZTJBKxqY7uzPpvYpYLgYvf79fAwICN+e7p6VEwGLRMb319XfF4XN/97ndtTO7MzIyy2axWV1fl8XgMcWC0MGfQ6/XaRM1Go2Hfo6+vT7FYTNK5Ic1ms2ZTmAqLI2bIXCaT0fr6uoLBoEZHR+Xz+TQ/P6+ZmRkVCgXLVLLZrJ2FYDCoSqWi1dVVNRoN7e/vq1gsmm256OJecI8CgYBu3Lhhd6fZbGp7e1vb29vq6+uz/R0aGjIHxPhqsmcy2J6eHjtbjMWuVqs24G5sbMzQHZ5lJpPpOhNkipLMTm5ubmplZUXhcFiTk5PyeDyKRqOanJyU1+u10eM48LGxMSUSCZXLZR0fH6ter+v09NQGj/EMX2e99k67E91IC5kDzRhixnhOTEzYNEQibp/PZ/PoR0ZGFAwGLcqUziM1Dj9jaT0ej4aHhxUOh82xVatVFYvFLrjG5/PZ4fP7/Wo2m1pdXdXa2ppGR0d1+/ZtBYNBRSIRRSIR7e3taWNjw9I/SXr//fc1NjbWNQ55c3NT+Xxe4+Pjf+1Ap9dZRG2BQED9/f02zdDn8ykUCqmnp0e5XE6PHz/WzMyMfud3fkcTExPq6elRIpHQwcGBGS4O5snJiU5OTmwyJcOSOp2zUazHx8fq7e3V7OysQqGQTk5OVCwWVa1Wlc/nuwYehUIh9fX1SZINyUqn00qn010pOI5tbW1N+/v7BtcxlnVpaUnHx8cGRRwdHalYLJrBuOj+4TxJ38PhsI1xZhLlzs6OfvnLX+rq1av63d/9XU1PT9s57e3tVTqdVrvdVjweVzAYtM/GnHhmwrM37IMkyyDJhg8ODroiPPdSM+I7nU5rd3fXxvmGQiEtLCwoHo/r+fPnNrFyf3/fRhqnUikdHx/r6OhIlUrF4NzBwUGbcX/R5Wax/f39GhgY0NjYmHw+nwKBgEE4jx490uLiopLJpCYnJxUMBjUxMWFQI84C+KdSqXQ5CenMgRCAdDodO/dkEJzBVqtl2ROBF/e8t7dXW1tbWl5etuCSszg0NKQnT55odXVV9Xpd9XpdkjQ/P69QKKRqtap0Oq1KpaLd3V0VCgUFg8EuKPNNF5F+rVZTo9FQMBjU4uKiAoGABSt7e3u6f/++YrGYEomEwcGM+34VacE2+v3+rgA7EAiY8/T5fEomk+rv77c73263dXR01AWJJxIJBYPBrmx9c3NT6+vrGh8fVyQSseeeTCaVz+eVzWZt0izQF2PnT05ObGx8qVRSq9WyIOB11ms7l0KhYMatXq9rYGBAfr9fgUBAfX19tkEcOHDDarVqWCcbeHR0pHw+r+HhYcXjcUndU/7a7bbNgZdkX4g/vb296u/vl9/vt5nuOD0+a61Ws2iwr69PpVLJHJ3H41E+nzevHQwG1dvbq2AwaAedB88oWLDGi17uSqVimQYXiiicjGFwcFAjIyPq6+vTs2fPtL+/bw749PTUnCZ1rf7+fjNc7XbboiKyRRw1l9kdWTo0NGQz58vlsvx+vxn/RqNhPzs4OKienh5VKhU1m00b7cs41FarpXA4rJ6eHg0ODloU5hoxDu1lnDNOwIW3yBx4rp1OR36/X5VKRffu3dP29rZyuZzVMjBu7iz2iYkJ9fb22uu40W8gEFCn0zGDGQgE5PV6bRR1p9PR8fGxyuWyBgYGzMFQN8AJ9vT0KJ/Pq1arKRwOq9VqKZPJKJvNWnDFmeP8SeewFYbchdIussrlsrxer05OThQIBAx1cA0c+Hu1WtX9+/e1tbXVNVWUOlS5XFapVLIMCNgPw9toNOT1em3mOnUYF7qm5lcul1Wv19Xb22ujv5kjz3v29PSoXC5bVk5WfHh4KEmKRCL2fRjXDYQTDAa7AruLrlwuZ8/F6/V22SvgJ86PJK2vr1u2yx4A0zNCeHx83PaPqZM8B7Ih7A77x8ho4Od8Pt91vyXp9PTUfpfMiZoX2VG9Xjd7JMmQgXA4bBAjthjbzmu+znpt57K9vS3pLPXq7+/X0NCQXbRwOGyHMhgM6vT0VP/v//v/qtPpaHp6WqOjo2aYqtWq1tfXdXp6qu9+97u6cuWKyuWyNjc3u9LpUCik8fFxtVot5XI51Wq1LgydlLxYLFqRcWhoyNJg4I7Z2Vmbfy6dO6rd3V2tra1pYGBAd+/e1fDwsGKxmILBoBkesobh4WH7vYte7nw+L0kWxYfDYY2Pj1vW4fP5lEgkdP36dZVKJf3hH/6hGo2GxsfHFY/HrdjW6XS0urqqYrGoO3fuWBH26OhItVrNMP7BwUGDB4+Ojgy6omA3ODioTqejFy9emLHhOTFju6enx+aGE4GWy2UrZu7v7ysYDOr69esaGhoyuKlSqdgzisViBjm5mcCbrnQ6La/Xa0XfQCCggYEBc9JkEcFgUMfHx/o//8//U36/X/F43DKcaDSqRqOh3d1dlUol3bx5U++++65F7My9TyQSdpbJVIjMJSkUCml6elper1dPnjzR7u6uEomEZmZmVKvV9OTJE+XzeQUCAY2Pj9t8eY/Ho2q1qmg0qrW1Nb18+dJgUYw9EDJGmACE+3WZlcvl7HWr1aqhARgOvnM4HFaxWNS/+Tf/Rj6fT3fv3tXi4qJarZaSyaTK5bKePHmiXC6nDz74QO+8846RKKrVqt1joEIi+lKpZBF1MBjUyMiIJGl5eVnpdNoyt1qtpufPn6tQKCgQCCiZTKrdbptxLxQK6u3t1fLysp4/f67BwUFNTEwoHo/bfaXO2ul0jLjhBj4XWUCC0WhUkUikqxZaq9XsjiaTSRUKBf3sZz9TqVSybIwApNVqaXt7W5VKRZOTk7p9+7bq9bqdQYJnsohWq9UVHHPuXQIJ/47zwAZGo1HNzs6qWq1qeXlZHo9HqVRK0WhU5XJZ6+vrVqqA3DQ+Pt4V7EejUfX29lrw8Lp1lzeCxUgLJVkG4c7WBiJrNpsW6WLwiH4wMoFAwKAIoh6Kx41Gw6I1t/iEwSLKJNIjqnu16MT7eDweO2y8ZygUUiwWszSRTIj6C5G2i7PXarU3PY+2qDdJ52QBPjuQoNfrNedWLpdVqVQ0NDSker3eVXh1C/0uVutGURTfpXOMmyiY3wf6YU9eJQe4mQKOgecFowmID8NHhOpGVzzXy+xfo9GQJHuOGHuw7Ha7rd7eXkWjUdVqNRUKBYu6MMx8dr4b++dCszwLd/94RkT4GHwyC6A6XkM6J464f9wFxPOrCvwue42IVeouEl9k8b24J9xFEAUCEyDUbDardrutUqlkkbZ79gKBQNcd5Tu4bC+yMDczctlJLknEJfywyHDciJl/p84D8kD2x+9x91+dNX/RfcTmuIQPF+lwUZVKpWJ7Wq1WJanrnPT29tr9w8bw2UB6eE2XreoytrAH7OmrZ1A6h3Ox33xmgrOhoSGroYFAsX/AuyAS5XLZSgivs17bufCgiPDHxsZ08+ZN+f1+M4YDAwOan59XoVAwLJZLIskyne985zvq6+tTNBq1n6tWq6rVajo9PVW5XJYki665xIlEQqlUSoVCQSsrKxZ9gTOSXfn9foXDYYsGh4eHrUDIQfzoo48sEt7d3bUDUCgU5Pf7dePGDaM2NxoNPX36VI8fP+5iCL3Jqlar8nq9RkVOJpO6evWqenp6dHp6qmw2q1arpVAopGazadG4y3zjMN66dcuK2tKZ0aDIeHJyYrRL11ECocViMZ2cnGh7e1u1Ws2iOq/Xa8YEgwyWOzQ0pHg8bsbY6/Xq6tWrFtWD20Ii6O3t1djYmCTZaywvL+vFixcXvtinp6d2OYhm79y5I5/Pp/39fZ2enmp2dlbXr19XLpfTZ599pkKhoFarZXAKl3tmZsYgm2Kx2FUXzOVy2tnZ0ejoqEG/0WjUKLyhUEi1Wk25XE71el19fX1KpVLyer1dkS1nu9FoKBKJaGRkxM7w4OCg5ubm9L3vfU/lclkbGxuW7XFnyBR4jXQ63QVRXWTxu8FgUIlEQvF43Aq71MiCwaA++OADZbNZw/dLpZKy2aw5wt7eXt2+fVvSmZHc3t5Wp9MxuLBYLKpQKBhEzt4NDAwoEokoHA6rXC5rd3fX4PKxsTEjFTSbTUWjUQta+ANkxpqdndW3v/1tI2ZwD4rFonp6enT9+nV1Oh1Vq1U1m03t7OxoZWXlwmwxl1XXaDTU29ur8fFxC7Bw0gQOFMOxb+FwWKOjo/Z9O52OJiYmVK/XVa1WVSqVdHJyos3NTe3v71uBvtPpqFQqqd1ua2FhQdevX1ehULD7lEqlNDY2ZmgOhIFoNGpBEIQkMuVwOKzp6Wn9+Mc/tsy6Wq0qGAzq8PBQfr9f77//vrH8JOnp06d6/vz5a9/h13YuLtspFAopGo0aXJNOpw1GweD19fVZVOJGw729vZqYmFAsFrOIlroCHvvVbIfIAwiJCB1jC8Z6cnJi2CrREf8ej8cNDgoEAgbj5PN5ffzxxwabwQJJJBKGSzabTb18+VLZbNYi6DddRI3UNgYHBxWLxQxfpihKFOLSvKVzimBPT49GR0eNLeZSCdlDUnSiddJoDli73TanHo/HNTg4qFKpZHU19o8aDvuBcSbDIsKtVCpqNBoql8s6PT3V0NCQksmk1XsgahwdHVnh9U0X0BR7SDGaOtbJyYmGhoaUSqU0MDCgR48emVMh88PZEnj09PTYWSPCrVQqKhQK1pPjUsZhyxwfH2t3d1eVSsWKz7BrgBKB0MjiYrGYBToDAwNmaF3GHfUuv99v94i9pcB/2exFOicdUGymHlAsFjU2NmbOEsPEsyU67u3tVSKRUF9fn9UuOV+cSYrszWazC3GA1dnpdKxgTAbMfaNGBzJC/WFkZMSCHs5lf3+/Tk9P9fTp0y4H47LTyLz29vZ0cnJy4QDRrRkS+FHjwT7CMoSZ2tfXZ3UNsgXul8/nM9gL21ev1y1rbLVaxtLkO8M0BRZst9tW13PRFZi6LmIDNDg0NGT2Z2xsTCcnJ/L7/UYQgEAC4Qgbs7KyYoHr66zXdi5EKrz51taW8vm8+vv7NTc3Z80+xWLRLhy8fuk8ve3p6VGpVJJ0Fo2enJyoXq+rUqmo0+koEokoGo1qcHBQ4XBY1WpVmUxG+XzenAzReb1e19DQkEU85XJZ/f39mp+fN0onxfBnz56p0+lodHTUjCKMFQq/kUhEoVDIIjU33Y3FYnrvvfcufLnfe+89SbI0eW9vzxzZyMiIRkZGVKlUDJem0Ars5aa8ZEFAZ27D0/DwsNFe+/r6VK/Xtbu7awVYskzSXqJC9q+vr0/T09Ndhq/RaOj58+fyer0WeWOUT05OdHx8rHw+b1EpxVcX4kgkErp79+6F929xcdGygp6eHh0fH+uTTz4xx3f16lVJMmp6X1+fBgcHFY1G7fKzh5VKpQt2gE7barU0MTGhsbExDQ4OWr0A1hF7RISJ4SRixYmNj48rGo0ql8vZheU9+/r6uujK+XxehUJBJycnXTRP9gnnFo1GNTU1danMZW5uTpJs/4iYMd7z8/Pyer1G8gDiAf/ne7gFYLKrUqmkw8NDM2QzMzPq7++Xz+ezOih7ABGH+ipwEnAmv889xaBtbW3J6/UqEomY8/Z4PCqXy3ZWgX2ByfnMlUpFkUhEt27duvD+3bp1y+xfrVbT8fGxfvnLXyoYDOr27dsaGRkxJ4qTbLfb5jixawRaIDUgPQRfMzMzxtKLRqPWSH54eGj3z2V68XyApAngqcm0220Vi0Xt7Ox0wb3c33K5rGw2q1KppGAwaK0a29vb8vl8ikajdp8mJydf2zm/tnN5//331Wq1tLq6qp2dHe3t7Wl3d1eRSES/93u/p6mpKR0cHKjRaKhSqVgxFCwfNpHX67VO50wmo0wmY4bO7/crkUgYQWBgYEDHx8fa39/X1taWQSwufZgCV61WsyLitWvXNDExoVwup+PjY62srOjrr79WpVIxKujx8bFOTk5UKBS0vr6u4+NjTU5OGv4JVEKUS1fsRVPq733ve2q1Wnr27JnW19eVzWb14MEDDQ4O6h/+w3+o8fFxHR4eGquMPQBWdJvzuODsH/9Gr0kqlbK/Oz4+1r1797Szs2MQBxAQkR+QJ4Xy+fl5TUxMaH9/X5lMRltbW3r8+LHq9bquX7+uZDJpEXWxWFQ2m1WxWLTAQDqHsbjs9BBddN28edMw6VarpWw2q4cPH2pwcFD/9X/9X+vmzZva2dkxuizF0JGREQ0NDalWqxmdslwudzUmEi16vV7dvXtXc3Nzdo6LxaIymYwODg6sSx+jABSEIatWqxoYGNDk5KQmJia0u7trlPG9vT2LtqXzXol8Pm9/6vW6XXzXuXi9XoM0LtMAuLS0pE6no2w2q1wup8PDQ62trWlwcFC/8Ru/obm5OaXTaTsr3EGMF06EaJjMFIe7t7enTqejO3fuaHp62r4j0B99LaFQyIg4LgPq9PRUBwcHGh4e1szMjFKplNbX17W5ualCoaDNzU1JsjuM8S6VSsZAhbIMm6vdPuvqPz091fDwsObm5i5Mynn33XfVbre1urqqvb09ZbNZffHFF0ZESKVSVguBvUX20dPTo+HhYYVCITUaDdv/UCikgYEBozj7fD7dvHnTCCN+v1/7+/v6kz/5E62tramvr89s4PHxsbV24GwbjYYGBga0tLSkRCJhiMbKyoo+//xzK1/09PTo6OjIYNfj42OD44PBoAXdHo9Hi4uLVt+anZ197QDntZ1LvV43miv040gkooGBAZ2eniqdTiubzVrvAAfQ7bInFXQLpjCgcA7QYElvYSsApxwcHJjRh0AALgjLhsMErDMwMKCFhQWr5eRyOaPrUniTZP0zRGxcdOCpy1CRq9WqZSCkrI1Gwz4DfSlEjW5UJ50TIXw+XxcThmKdm6pS4AZ/hbyAYUGeBWjIrc0AFZXLZavbBINBTU9PW1E3k8lYis3nhJ76arOaSz+9TBMg349oFAiWrPXg4MCcLTAjn8ktfOKcyaopmJJlkR3DjGk2m1YHa7fb2tvbU19fn1HA2TMXxiQjcCG8ZDJpRiGTyRgsRhADG4ffcwu8LuHjm1hAxZwhGH5HR0fK5XLK5XJGZaW+UKlUJMno+mQsFIrdvXx1QRLgTlOjobEZejC1VfawXC7b6weDQY2NjdkewS5jD7EBOGzgNNhUnANgpossnBULAkl/f7+q1apyuZzZLmokr/4+Z8qVvYF1hu3j/BAAnZycKBwOm5xNJpOR3+83xhrPhPvK3adhGiRkZmamywbyWUFToOmTWboISSAQ6CIlvc56beeSTqclySCiWCym+fl5SdLKyopWVlYMcwdDJCqUZMwEePb1et2gn9PTU8tMBgYGrCmTHpb33ntPnU5Hn3/+uT755BPNzMzo7//9v28FWb48XPetra0uHaOJiQl9+9vfVqVS0f/6v/6v+vTTTzU5OSlJlr56vWfdqhjfRCIhn89nkdrw8LBGRkYufME3Njbs8szMzJjjbbfb1mx3enpqjhkDCPYMw83j8Zjj9Pl8isfjKpfLSqfThtm2Wi1VKhVrUrty5YoWFhb0+PFjPXz4ULOzs/roo48UjUaVzWatwxo47eDgwGAfoKKPPvpItVpN/+7f/Tt99tlnWlxctP6XUqlk3d35fN5qXGSpGGgK4xdZ6IK56hA3b96Ux+PRxsaGnj9/rkwmY534GMbT01P19PRoZGRECwsLkmR4Ntg3gROLzHh/f1+SdPXqVfl8Pv35n/+5fv7zn+vatWv68Y9/rHg8bhkNgQLECC4usN3k5KRqtZr+/b//97p3754mJyd19epVixaB5zKZjJ196oi1Wk1jY2Oampq6lIPhLobD4S7nKJ2pMaytrenw8FCZTMYYUR6PR8fHx2o0GorH45qfn7c7S70tEAio1WoZWoFzYE/7+/t1+/ZtNZtN3b9/Xz//+c915coV/bN/9s8UjUa1u7tr1G1o/3t7e6bR1tvbq3g8rm9/+9uq1+v6gz/4A3399deam5vTzZs3raetv7/faPcupEzfWzKZtLt+kQXESV1sZGREMzMzRgRxqd5kbdJ5D1+5XLbgOB6Pa2RkxP4NJAfaNk6FWvCtW7d0+/ZtPXz4UF9++aVmZmb0d//u37XeKklmc2u1mg4PD1Wr1Yw2PT09rYWFBZ2enuo//sf/qHv37nXR7XlehULBEgDYg9xrgvXXXa/tXGBTuRROmtJg6xDFUtByNxbqKJ5QUld3P4X9Wq1mfSZEg3ho6jXNZtNqMkAd0jnVD8MMfsjhBHIiqnWbBV+NwvHSbhPoZfBuGtig/JEFAS1RA+IBYhyJlsgYcS5QbwOBgP2sG7Gwp5LMKZGuc2H5HESHZGs4XKL53t5exWIxi6qp3RD5UgwnquQ1MJjUGvgeF1lEpy4FNBqNqtPpmDDg8fGxSqWS7QV7jJPk+4LJQ9N0iSdcNM4CUR+wrXv+qEu5VFwMS7VatfeBSELBmmftkjzYS84/zoV7dVEihLsgLrgSToODg2o2m8YO49lKsuzTpZHTaFssFu2sYlCByTiH0jml3W2iRSWCgCOTyZiNoIjP+7l7GA6HrUkzn89bnVY6p/a6e8Uz5S64FN+L7h9nhHsxNDSkTqdjSgpA2a76BX+whewHDcnU6iQZjIdNODk5seBoYGBAvb291uaB6CUBpXRO0+b84Txcua52u22wLtm8S5J6lUhFTdyt/b7Oem3nQlc42QDMIw5esVjUxMSEpqenVSqVtLa2ZgaVn0+lUvbF2VC60xOJhCqVig4PD5VOp5VKpXTz5s0uKvPMzIx+8IMfaGhoyCK6zc1NHR8fm4qy1+u1z4TUy/7+vv7sz/7MCrJ3797V+Pi4YevQSznExWJRe3t71nAUiUS6jPFFFgeelBlYkb6AZrOpqakpTU1N6fT0VM+fP1epVDLIJZFI6MqVK/J4PJblcFnZX5QRnjx5otHRUS0sLHQdhqmpKUln3czpdNoM8unpqSKRiEZHRw2rlmSNmPl8Xv/23/5bc+TvvvuuJiYm/kpzLAtJGK/Xq/HxceuwvkwTpdvjw3ciOKDAnkql9K1vfUuFQkH379+3AuXAwIDJcXg8Z/pObqOiW3vZ2Ngw6Iu6F3WpO3fuGFtyfX1dOzs71qHfarXsnPDZgCxyuZyePXtmP7e0tGTPGqcJ7MTCEVy5csU6vt09vsjK5/PmcN1ubIrA0tkde++990w2hWAB+IqaGtkZ8B00f2jT6XTaMjZII16vV7dv31YoFNLQ0JA1/21sbGh/f9+aLt26E88vn8/rP/yH/2CsynfffVfz8/NaXFw0kgBQFBkrkkl37tyxfrHL7qGkriZH+sWoY01PT5sNPD4+VqVSsZ+NxWJaWloyWNENViGikMGsr69rdHRU165d6+rXW1xcNKLRF198Ib/fr+HhYQtax8fHzdmhQOL3+7W6uqonT56oVCqZrYYx22q1jOBBkASEB6ONHpg3ucOv7VyKxWIXTZV+EaLvUqmkUCikq1ev6ujoSDs7O+ZcXDpwp9PR7u6uFfHwnAhZbmxs6ODgwCJDmncajYaSyaRJvFQqFaPsZbNZDQwM2MFH8BKq4PLysv7Df/gPOj091a/92q9pYWHBJOOhM0MGGBgY0ObmpolaxuNxMwJE9BdZRHJkdhgjovFms6mRkRG9++67ymazBgNxkCKRiAnPNRqNrsYrsrRWq2WaX3fu3NH169eN+95qtYxp0mq1bI9gvhAsSDI4AtWDvb09/eQnP1GpVNI777xjBVXosuFw2NJxdLe2t7ftc09MTJgDvejCwLm1ERcvLpfLisfj+ta3vqW9vT29ePGiy4m7ZAPOspupAOUSkY+Pj5sGHud0bm5OY2NjOj091fb2tgVJQFvQ3IE8IU2k02n98pe/VKVS0djYmCYmJmx0AL0QZDw4ds4lP5vNZk2D7KIL0gIMMI/HYxIjGPRkMqnbt28b1EevENEvxWfpvP4lyaJxWhPy+bz8fr8WFhasz8rn82lubs7qT1CE0+m09vf35fV6lUqlLGPCMA4MDCidTuvjjz9WpVLRrVu3TEqejn4gec4I8J7f79f8/LxmZ2cN+rvMHkrniAtwdbN5JnGfyWSUSqWsxQB4GwSmv79fk5OT6unpMagOY45EUE9PjzY2NrS+vq6BgQFNTU2pt7fX9mpiYsKCw88++0zValWLi4saHR01cct6va7V1VWjFEciEW1sbOg//af/pFKppDt37mh8fFzJZFJTU1PmnGEOUr+B1UttCJWBb1z+ZWlpSe1221Q/kbGQ1MVxL5VKXVEYzLC+vj7dv3/fGrbK5bKp9VJUhLMN4wF8E6peJBIxOQ1oe7OzsxofHzcD5/4hCuh0Orp+/brq9bqmpqaMow88B9e/XC6bYb1y5YokWU2EFPGii6Y42HYo4BKNE/VBu8YhACH4/f6uvph6vW5Gs6enx0gK6LExR0Q675pHcoYMkaxNUpeeEE6iUChIOnOI8/PzqtfrGh8ftzkUFAwx+MfHx8Y6mZ2dlXQWBGxvb9sFu+iiTrW9va2NjQ1rcsSYoGywtbVleDP7R3aA0OrJyYkajYbC4bAikYiRAkqlkmVh1CLoj5BkkR7sROAWcHwXGoPFhAOcnp5Ws9k08UC/3281MYwy/Tp+v1/T09NGu19bW7NncpkFWwzaMJkB2QwQy97ent1bGgChvK6urhq0LJ2ds8HBQVUqFaNsI+LodnwfHx/bGUQcFqZoKpWy3gsySvaReoTX6zWkYXx8XLFYzOwR0OLg4KCRYmgu9PvP5jS9fPnyr9Dj33RFo1G1Wi0TvY1EIkqlUuZ8McygDQSROIbd3V09fvzY4ENIDfF4vAsaDYfDSiaTRpby+/2WWSAIHAqFrOjO/g0MDBgxANi3Uqkom81KOmNcNptNTU5OKhqNWmBB4ADknsvlrNEW2vTR0ZH1Rn3jzuVv/a2/pXq9rn/7b/+tHjx4oFQq1aVUTMMNBWKiAySx9/f3tbq6qp6eHiu8RyIRay6jAa3ZbFqzJFFlOp3WycmJ5ubm9Gu/9mvKZrP68ssvValUdPv2bQ0NDSmbzWp7e9siSeiqR0dH6unp0W/8xm8Y17y/v98URwOBgKnnfvnll3ry5IkmJib0wx/+UJJ07949vXjxwmo8F3Uw3//+91Wr1bSysqIHDx6YsqurAFupVOwScCC3t7eVTqe1t7dncA0GLh6Pa25uzjj+qBAwRIwDSy1nfn5et27d0vHxsR4/fmzQIWwXiBb8b6lUUiaTUW9vr77zne90NWRSFwCSo5lxeXlZExMT+uCDDyRJn332mba3t63p9qL799FHH6larerx48f6sz/7My0uLtqzpP4CHIZhpL8CqCaXy5kyRF9fn8bGxnTlyhXrEYJQAV0TQ7y6uqrT01P9rb/1t7S0tGQDvXCuGFvUajE2x8fHqtVqGhgY0Pvvv28FZvpbtra2jObe29trPS+oeLfbbX3yySfa3NxUJBK51MgHSfrBD36gZrOpP//zP9fjx49NKgeYZ3h4WKenp3Y2UG3O5/NWwIeiPDQ0ZEoJV65c0fHxsbGLgLxRo261zhSrT09P9cEHH+jatWs6OjpSoVBQp9PR7du3bVgahhAYrV6vGznn29/+tqERgUBA+/v7+uqrrxQIBOw8bG1t6cWLFxofH9f7778vSbp//77S6bRBo29SN3BXKpVStVrVH//xH+sP//AP7T2onZChcZ9BJAgGs9msNjY2rI7c19en27dva2pqythh7XZbIyMj1jOGU0Z37Pvf/76+/e1vq1AoKJFIdDWhokJOrbCvr0/FYlHFYlHhcFi/8zu/Y5+LWhTZCUSq3d1dra6uan5+Xh9++KE8Ho/W19e1urpqzuV1nfMbFfQx3C6NGMhAkh0kF0+keZJGM7dXwS3iQ0VGGRX5E34Oh+EWdFutc60j2BWojroZjHSewrtFXjBaogiKki6lks/Iz1x0USOq1+tmINBaIivC+PCHfYbuynI78REKxIEgPQG9k+Iq+wLsQv2IKIuGKpcSyQK6o0jOsySjoiZAxMkCdnK/z0WNIyQMioqvFuXZQ54RDCZ3H4G+OH+NRsP2jf35L+03Z7XVatm/c54ohLtFT96DP2RZ9MVQg+F9KRK7mmcuJf+yi0IwxXN3/9xz4N4znjdqD+59cu+ne8Y409iDv055A7vhwuOgCbwvrwv9nPMDPExXvvv8oPfys9QPLkvK4Q5zBvgOrpw+584t5kNqcM++C8mSNWNjeU3usHuPuPNkna5eINmy+yz4PfTZ3MZwgliXbOW2EbBfvJ7bE/c667Wdy+///u+r3T5TJp2cnLQoGDoxLBA8JxeWMaT9/f2KRCJdEV02m9WTJ09ULBb18uVLNRoN3bhxQ1NTU+YAMMYej0f7+/v68ssvJcmYYIVCQblcTmtra/rqq6/k9Z4N13KltYvFop4/fy6fz6cbN24omUxqf39fKysrNuMhHA4rGo3qzp07qtfrevDggTUXfRN9Lv/yX/5LdTodFQoF68CdmZnpEs3E0HFQW62Wrl69qoGBAcvmOp2ORYnr6+sW7T579kz1el3Xrl2zQWREJ0dHRzo9PdXKyooVb4mC6fTd2NjQkydP5PF4NDY2ZrCQJMtIfD6fbt26pbGxMR0fH2t9fd0YK8hJENXwXj6fz2bAXGYeyX/6T//JAoDvf//7SqVSmpubU29vr8GmGMl6va5gMGgXsVarqa+vzzIsnOXm5qYODg6seN1qtTQ5OWnQIrg59ayDgwN9+umn1ucSDAatJ+ng4ECPHj2S3+/X3NycDTAjgyZivXbtmkZGRlQsFrW1tdWVrff19Wlpackk7zkLrkDnZdbv//7vS5LR4UdHR03fjkzZZWsRjScSCctuIpGIOp2Odc5vbm6aMsfa2ppB1dBs0WBjnzKZjFZWVuT1eo0aXK+fSb9vbGzo/v378ng81qEuyc4xNNnFxUUlEgkbuEbjH0jIyMiIPS+3JtZqtQw+vsj6j//xP6rdPut2n52d1eLiot577z1rpMWJ0BSLEyJYDoVCGhkZ6er1Oz4+1qeffqrT01NtbGyo1Wrp2rVrSqVSlvm4bRsbGxs6OjoyJejBwUGT59nf39fjx48t6MZBo7qwsbGhQOBswNnY2JgymYwePXqkQCCgubk5DQwMGCpC6wfPhvrf9evXXxvefm3n8vLlS0myBkZgDnBs8NGjoyO7VK1Wyz4wB5MiF1Ej3d2IJgITADMQIVBr2N/f75L8J1XP5XI6ODgwiISCtyTrA/F6vYY3MsgIuidZxMDAgA4PDw23d7OVyziXx48fSzrD7aFgIubHzBRgGeix7XZbQ0NDJkrHQUKyAQinUCgonU6r1Wrp+vXrhg0T8dZqNet7yWQy1ueAnhDUx3Q6rZ6e8xk4fIZq9WweuMfj0dzcnD1Dir5usyXRJ5g+9ZDLGsi1tTV5PB7FYjFjqiFkSAACow86KuwgIja3i5l6TC6XsxqUdAZ9UP+Dog1bhwscDodtTALFeyDEvr4+66GSzqml6XRaPp9P09PTZlBPTk7sPjWbza46HNkABoJ9u0yfC/WS6elpjY2NmVaaiyrwmaVzJWyapV3qMv1s9DGdnJx0Df8aGhoyQVZo3WRrR0dHBut6PB6b9looFHRwcGCwkRv1n56e6vDw0ILHUChkRXze3+v1amxsTPF4XIVCwYIwjC1n+aJrfX3dnjcwJZ+FbK1QKJi0i1uLQYookUgYjIrtYTAhYzmwYWQ1vEaz2VSxWDQZGIYJkpWVSiVrjoT6zp9qtWrDA6enp+1ZHB4eqr+/XxMTExYoMraCYYrAncFg0DQDX2e9Uc2l3T4byYohIwWjAEj6Sz2Dgubh4aFpNdEzMTY2Zk2L9A5I57LnMHfAD/v7+1Uul7W9vW3/7fF4lE6nTV79zp07tnnBYNBkasAxcUZE/MApFMvc7GR+fl7N5tm43kKh8Feoom+6fvzjH6vdPuvwRuYF57W5udklSYKzBTaBpjk6OmpKrHNzcyZLAm3V6/V2OQSeCTAZrBO49l6vV/v7+yoUCvJ6vbp165b6+vq0sLCgwcFBbW5umr7Q0tKSNZU+f/7ceP2t1tlsCjLWZrOpQCCgmZkZtVotbW1tWRPeZWAxtMNwDG5DWqFQMJwfXTN3PhBNnAgJjo+Pa2BgQNls1gZPIXIZDAY1Pj5uDWxcbKAkaPcrKyt2afne8/Pz6uvr08TEhEKhkAVI0hkNHPgWx5tIJLoIFKgHMJYbOjRwp3Ru+C+yPvzwQ0myLnZqnXR9Uyvlbu/s7Bj1V5Kpeff19WlkZET9/f1G4nCnTsISfBWWAeY6PDy09/J6vTo8PLRJiDMzM+rr69PVq1dtTPXGxobpZQHdoVVGnZHPQAHb7/ebYjps08vuH/Ivu7u75uhwEDs7Ozaryefz2aTcZrNpNatarWZMPfYPjUaCcc642/MH1Mj5o0Vhc3PTVKiBxufn57vUmg8PD03mhUXTaqFQ6JLT59nBCr5165bq9bqePHliChjPnz+X3++3mvR/ab22c/nxj3+ser2uP/uzPzODxgG5d++ednd3LZspFAp2gFB7jUajGhsb09DQkAldPnr0yPphiBJ5+FwAmCBQ9fL5vPr6ziZLer1eM2wzMzN65513TM2TAilidslkUpKMXAAmjHNxO9LHxsZMZBFacKvVulTU89u//duq1+v64z/+Y21sbBgFuFar6dGjR9rf3ze6H0yaWq1mex2PxzU7O6tYLKZbt25pcnJSX331lba3ty3CZf/o84HtBaMMh+MqKUDAGB0d1Z07d0wOvr+/X5lMRul0WslkUtevX5fP59NXX32l3d1dM6j1et3gHeogyWRSMzMzFowQTV2GcXfjxg1zZAcHByb5Qr2DIISLvby83PVMiRhhfKGoTLRIhAjcsL+/b6OMXX03skC3i73dPhvxvLCwoGAwqFQqpf7+fu3s7KhQKCgSiWhmZsZkNQ4ODtRqtTQyMmKwA1lWIBBQPB43aXZUc6krXGZ95zvfUavV0oMHD7SysqKenh6T0idApG5WKBS0vb1t+nulUkmjo6NaWlpSPB7X9evXNT09rWfPntnvvhp5EzTCiJNkECI1VRxboVBQX1+f5ubmFAqFdPPmTYVCIW1tbWlra8tGfPT29mp/f98yIrS6stms9Xcw+I6xGcjZcDcuuj788EP7fRAG6hxfffWVsRhhtFJjcgMvZPSB509OTrSysmIIgNvdj3J5p9OxXiEYha1WSxsbG+ZYy+WyksmkFhcXFYlEdPXqVYXDYT18+FDPnj1TrVazJt7t7W0bYkYLCI6ZewyppF6va3193dAfl7b+N603GnNMdAXDiVoLXOpQKGTMIwyJW9OA9gkDpdPpGGuCLAJYA467K4XCBgQCAVPHpS/B5/NZwxcPiaIlsAYPjs0hcgKD54KTemIIBwcHu/SiLrLI9hqNhsFEwB00QPJZcagunXNoaMgisWq1as8DKA/aoEvnlGTQBZ229XrdeoI8Ho8pK0uyA4ih9fl8piqMIYDrjmMhA3LrREAfFNKZROlGwW+6jo+PLcqXZH1SvK/7nDFmOF2P52zUazQaNZ0wjA0U8EQiYZkVsKMLr3H2JRktXJLRQdk/6jQ4U/T03OwSBWAaa+mlISggCwB2c9UjLrMQPOVZusVx6hs8T+ot9NtEo1EznOFwWJJMDQHqMU3SZI908APRttvtriAEIVsy51fPElkwNFtQDc48xAhX6oUAAJiNu442lvsc33Tl83kLgrF3fHfgbe41gR4ZL5AtNpJGYwITgj9JxoAEznUhbpwWsCIZDfAXQTf/69LlsQvsO+8jyZymS0ohKMTm8++vu17buTx8+NDgqmQyaQVNr9er+fl5G4ZEBz9FyenpaaVSKYPFJJmWVjAYtI5Tt/sdmMON4kkz6/UzmX0iG6AD0lUK/TCYOAAIXdL4BxRCEx61DFJYpL9RPN3d3b1UE9tPfvITSWcpL7gww6iuXLmiVCplEQu4rdfrtb6ccDhsxUAEGsvlsmG/CwsL6unpsbG+wHyNxplUOWrIHo9Hs7OzunnzZpeuUKvVUjqdNqoizJAbN24Ys0SSjS0m++FC01cE64XIbmBgQIuLizo8PNTu7u6FL/bDhw8ldcuBMHOnVCqZ0wyFQjo6OjKNOOoFw8PDmp6etsyGsc8jIyOmG8ezffnypYrFoikVo/eG4Usmk3r//fcVCAT0/Plz0zPLZrMGafFZqc1QXwmFQhocHDShUr//bHhTb2+vtra2tLe3Z0YQJXF6Gl6tAb7p2t7etiDNbUbt7T0f7sbr8xlPT09t/lIsFrNBa8ViURsbG2o2mxofH9fExIRpvfl8Pm1vb9u+0SjJ/CDmEc3NzZmdICCVzlUsJGl4eFi3b982B00dMhaLWRDoGsydnR0dHBxYoEADdywWM/rzRddXX31ljnhhYUHj4+M2in12dtbsGJL1EBno4RkbG7Ofo1emv79fS0tLqlarNhhsbGzM7BX2CSTo8PBQx8fHGhkZ0YcffqhoNKqXL19a4+r6+roRhMLhsI07pgWE7N1l4SKnU6udDcHL5/NKJBIWbHY6HY2MjFiN5nXP4BtlLtLZ4YNnziJaJIIA33eZRETrpKZMPWPWBkyicrls3pP3w6mwGUT2vEd/f79Ju1BQhmCAs+Ow4a3ZNNJRN4uh45aOZAwaxvkiC2wbOQt3HgV7yeeifgBDh2gHeMZVLCbrgxRAhgYtl4I+mRFMFX4WdhAFPpeSzLPmNaRz6iX1HTeq4vV5DZwLNNbLLNSWycxcSiWUWoT4gJdgjQ0ODtrn4IwBo7mfjTP3Kj2ZM+s+f6iinC/ONK/PmePZujRu+iD43O5gLKJxaMNkFG6WcdHlyqPw/sB6vDcZDfWBdrttA74go7TbbcucufNQuClWu9p2krruGcYJB0fUTbEc9hPfl6yFKJp7QWZPFA75gtciU8PYuu9zkYWyA4PyqPcAnfIc3fPJe7p/7/P5LLtye0dgJXIvISPgoKm/cJY4g/xxxxhgr8mO3bsCSgTE62axrn1mKq+bPb/Jeu0bv7e3J5/PZx3xFNXcwn4ikVAikVBPT49u3Lihk5MTw0QR64M9BERGkY8RrgzUyeVyymQyJkmABhLFrs8++8ycmnRmcPf29qyGAkZJoxhU0HfeeUcTExM2QAhKdK1WM22tfD6vzc1No/GWy2VFo1H94Ac/uPDl5iImk0lNT09L6lZZbbVaNgZ1cHBQh4eHVrhDeRjGUTwe76JP890xgBTuwaVfNe7ValVffPGFFXR7e3t1dHSk/f19I0kEAgFNTU1pYmLC9gOlA+Q7oJzznFKplHp7e41pQj0BjS+asi6yCBiSyaQmJiasniN1S+QwabO/v9+ovBhDhAWRyZDOh69tbW2pXq9rbm5O8XjcDBwZBJcLxdlPP/3Ung3QYyaTMdIIZ49OcpxZMpnU0NCQMY1gjVUqFY2PjyuVShmsiMN3RSMvsxi2RQRdr9et/khjKWq9fX192t7eNpiWugtng+dAjwaMOzrMgU6BXSYmJgwaJKMhiAIaZnaQdMYOJGii85z7MD09bfI5yWRS9XrdSDnojVGTa7VaxswaGBjQ9evXL3wGc7mcSdgAAb548aKrbhaLxTQ5OWkyLEDS0tm9W1tbM4ISMBqQGI4BGHJ/f19ffPFFFxxPsd7r9dqgMv4NPTNsAHD5nTt3bG5Vp9PRlStXNDIy0tUvx8yjhYUFs+noxxHYIhfzuuu1nQtaQf39/UqlUsrlckqn0xbhtdttkyWA8usqurbbbevuhYZL5NJsngm/UfCCButSG+mCJXt58eKFGWsmViLUdnh4aIeAOSRcfK/3bPASNRQgMdLSSCRiRUQoprVaTSMjI7px48aFu3vBXhmEhMEmE4Nmi3AfVGE3yqFYySx3pDRyuZxevnypSqWiWCxm2QSFP7I7otR6va6VlRX5fD5TWq3X68aOYmwtXdjtdttkdG7fvm39LB6Pp2tuChDT9vZ21/5VKhUNDw+bXPtFFvUMBADz+bzVsdA+kmRSJESwYN/lctkiRdQR3Ia4TCajRqOh2dlZhUIh5XI5+zecs0thpvjtKhxwXjFCN2/eNF01NKago0JnhkqPtE4ikTB6NGw39xlehoqcyWTU09Ojubk5TU5OGlRJUEKNDHiG+hRZAHTXwcFBkxwBDiVIc5v73GyI51MsFq0vCVbXzMyMEomEKSoQIcPanJmZsToZ2SlkCFQFCHBHR0dtFALjhUE9kGu56B4izQP8jMoC6hbUqdCkY8IoaAxKEb29vZqcnOzSJwPCJggZGBhQtVrVy5cvrRQAEgRdnd4zaOU4M+l8lDViwtvb23rw4IEx9+gFYn+gNKMwsL29rd3dXdVqNTv/LpX6ddYbYRVARhx60tjd3V2dnJyYYCWek94NIBJgnYODA5NeofAKLOU+KCI1JGKgz0F3lmQ1lOHhYRthStrXbrdNwoImJAQhSbPBZUlFSdtJIYFToARfNOoBMpLOU89Go2ERH6NGmZtD2p3NZpXP5y31Br+nWEiPCvtCLaFer/9/7L3Zj+NZduf35RIMMrgzGCtj33Otyqyqru4uTbkXDaSRxhgNNNCMAQ8MGLDfDBt+MPzoJ/8PfjZsD2wMLK8jWZbVkrq7uroqq3KNXGLfySAjgkEyGEEySPoh9Dl5md1jRTLLb3mBRC0ZC3/3d+9Zvud7vkeJREJ+v9/mytO/A82bfWDWDpItrEAgYMw2DjQ9Gzh5in8oH7tChjwzbJTd3d2uLzbQBu8W+SAyCTJRaM9Ef9Vq1YIa4FyiXJxLsVi0M3d0dGTBCnI/DEZj74AJecZQKGS6b16v16DUQCBg/VWc/YODA6PYU/AmOicTcuEHAgKy7HdZwDiQLjCG9XrdZogcHh5aRtjT06OBgQEdHh7q5OTE6puIcSLRT80L2IpgiKgXQgpML0mWGXLfyNzR9GNcNk6F/wcLdGNjw2AdiBnAlBhyCBTAc0ipdLuGhoYsmwLuwigfHh6aM+M91et1q5swrIzAGSISs2dAZGhsRraI4IRskn3GBno8Hms1iMfj+uCDDwy6Y/9evXpl9b1Wq2UsSM4vdTJIEtg/IEcUD+iz+c479Lk4tVrN0nj6KZaXly2dla5S4H/0j/6RUqmURShE281mU6urqwaZkanAmIC+CM0wFAppYWHBlD03Nzd1cnJisAFdvuPj4xodHTU5BEn64osv9NVXX1mXsdfr1erqqpaXl+3yx+Nx3bt3zzy/24+BgcLYvHz5suuCPhGKpA7HUiwW9ejRIx0cHFgNamxsTH/wB3+gRCKh4+NjZbNZm6ft9XrNQUJfbjQaptMEK8vv91th8LPPPtPAwIAePHigb775RicnJx1ZU7vd1uzsrO7du9fRnf3VV1/ZKGZ6DJgzAekhEono9u3bHeMDJNnFg6GCEkC3+wdlEmPV19enoaEhlUolff3111bIDIfDGhwc1Geffab+/n49e/ZMW1tbGhkZ0fj4uNFuXbonNMt2u21zxnt6emwmOooFLmWT4AYNrWQyqfn5efv6QCCgr776St9++62Nm2g2m1pZWTEsnXrGnTt3bDYM0utuXYAiPOysbhdzfRqNhtFjI5GIKpWKHj16ZD1h7XZbExMT+pM/+RP19/drZ2dH6+vrGhsbs4L+ysqKEQNgLGGkkBRBigg4KpFI6OnTp5bRUlfhPgwMDJhqxezsrEKhkP76r/9av/zlLxWNRk15Yn9/32Dr8/NzxWIxffjhh4rH45YtUP+CIUrR+l361ebn5+Xz+WyUMjWParWqjY0Nra6uamNjQ8vLy0omk7p165YpRaD9FwwGTT2Abn8G7E1OTlpvCnW/xcVFg8LC4bD29va0t7dnlO7Ly0tzLsPDw/rhD39oAcTl5aWePHmiX/ziF+Ys/P4r+f1Xr15ZPTcajWp+ft5YqzBqKWmggA9C8Z0X9Il6SJGBDLiIFOspNvFwGAQGeVFUJz0DvsD4AmW4hUI30ifLIc2mQE5Rmt9LwVmSsdfYYOn1LHqykna7bXNByuVyR3cwWRDZWjcL4wSeScGWYipRAlEczyq9dkw4ePcys9+o27pzF1z5bKI5951RCKVIjmPASEivZ7kzXIrnp1+GZ3LPBUKQ7KF72LvdP5xXT8/rWRg4xjcL8/x/nK2rvURRHaIIURrjb9lbirHuWcYxuj+T8+dmai7pgc9Khse7Iet0s+VqtWrSSC6hhT9uMbybhXMhUnazT+4gyIRLBIFK60KafK1LIea+umQL4FOcOIELcLf0mgHI+YaM4v7hM6BBBlwM5ZafiSrAm2OGXYJLt3sIOxYo0A0CXILHm5G9m/FBKnFJBy7Rwx2vju104V3sIO/MPYPsDWea7+P5XaUHziP7xvmFHQnMCK3epZRfd13budy4cUPSVaoHBRFW19LSkmZmZiTJHoq0O5lMKpPJ2AP6fFcSGGhAgaXjfNgQ10siq72/v6/d3V0Fg0EtLCwoHA7r1q1bymQyymazevLkiTGcKKxCEGAKG/MlVldX9fjxYyswejwePXr0SC9evLAXgcPiz7s0YFEALJfLevr0qT1fq9XSjRs3tLi4aDBNMBjU1taWFfBnZmbsYrgKsEdHR8rn8+rt7bVoymV+SFfG6de//rV1hiNzQnTN/h0dHekXv/iFFZ3pcWBOOTgyNYZHjx7p1atXVkvzer169uyZ4cC8S6AoLne369NPP+1oYsSwUIRkfzFCQDWDg4M2EKlYLBreHYlErEnU5/Npbm7O6JswkXAqRPTAk26j5NTUlNLptAqFgnZ3d023TZI5LQIhv99v6hHr6+uWgZJF0PAWjUY1MjJigZUL377LHt65c8cgGQIc6kSzs7Oam5szGDEYDGpjY0N7e3vy+Xy6ceOGAoGA1T3m5uYUDod1enpq9VigZ5wMq1qt6ptvvtHl5aXR6EENenuvxkAnk0krwpPp+v1+5XI5BQIB09bjDDLC4/nz5zo7O9P+/r7Ozs5M2TwSiZhUiQtJv8s5BCXJ5/Pa3t42h8D+jI6OmgMESvJ6vTbwDYo+dd/e3l6zaZFIRNPT01bzAN6jEZgx5pzZQCCg2dlZ9fX16cMPP9T4+LiOjo60vLwsn89nWXdfX5/Gx8ctOPH5fBoaGlIsFjNUhIC1p6dHu7u7evHiharVqk1ZhbWIs/nOMxdEE+k5wdhJMriGyAM8Fb0keNXwpgcGBmxWAWwKok6yG7eREGIAjBWKzWhkMSoVqAy1XjBlou5QKKR0Oq1IJKJsNvsbMgsIDNLl73r5d7nU0uuZMScnJ1bvAPdEC43MSZIVAsPhsPWtUKhOJpPG9iiXywYFkbq69FnwYGAIBB5xEgj9FYtF03Wi/4UMkYiK5kvG/rJ//BO8HpYKUShO+l3oyPShIFPCfrRaLZtrQ9QmyZwDU/qA8iTZRMWzszOLJmlII5OmbgAZgOyP2lcqlbL9iEajxoACduLfXUNLkytMIOouvJOTkxPt7+/bOwEpcJs33+UccodpECWb8Hg8JlhYqVQMWWC/oCDjbFEOSCaT1pyLc3GjY76+0WhYXxZkCIIOoCK024CtyIpgmJJZoStITZKmPjKYXC6nzc1NDQwMdNTBXNp1t4t7wSAyt6cpmUxa1uFmsZIsOHPPCI2hqGZwz9/MVGiiJBigJOHz+ayRM5VKWd8PzbexWMwCfbTrsIvJZNIYkdR4eWc4eGwHgT6Z/9sE2Ne+7URzxWLR6HQULkkHYShQ/OHrKWZR1ISCS42B9FmSGUdodV6vV+l0WvF43HpFwANDoZBWVlb0/Plz+f1+E1WkiM8UREnm9NxiKtAF4o3uXGm0fzgwjGztdkGlRqNHkhkfLhd9IXxeCBREO0Suq6ur2trasowP4315eWlji+lQlmS0ZaA2GGe9vb3a2tqyyaBLS0sG1zD6GKdFynx0dGS0Xor4QCfAeIiPukoOg4OD7zQPh2IsLBaMPQVNepJwxETk4Ox8tnq9rpWVFW1tbVlvgetUoIaXy2WTl0Gl4E1Y1ufzaWtry2ZdzM3Nqd1umxRKT0+PZmdnO+BaxBTJ9ogMgehciJgggH4mV6m6mwVtent7W6urqx09LhTL6QtiH4h4z87ODH5st9t6+vTpb73DnAN6LTBeZMAUt1GWDgaDVo+D4gxk2Ww2NTw8bIV0AkyMZKlUsrlFQIk4PybfYqPcLvZuF3cYp8fv45k5F+64C1o2ELOkHkVA0W63lUwmO2qdqD4waVdSx2wcJqwyOXdtbU3r6+umC9hsXo0tzuVy1kDMHWBvXSHbUqlkyuvZbNayU4aYEQjE4/H/f9hiMBVgakQiEUu98NAwNrj40hWF+eLiwh7y8vJKDLJcLmtyctIKhERpGC4UUinckgoDe7DZz58/1+bmpm7duqXPP/9ctVrNtMIoQFarVR0eHlqkD6yC0YQthN4W3d9EKu321bhjCsLdrHg8bvtyeHhoTpLeAkkdUe6b2C4OgaLw+fm57R/OhaJlPp9XsVi04WIU3GGZQaH1+/1aXV1VLpfTzZs39dlnn+ni4kIPHjzQ8fGx7t69qxs3bhjNm4OPJE80GpXP57PmLvDYQCBgIpFg3AMDA+9ERXadC3L+RHatVkvRaNT6XGCNufNz3FoHRfWpqSlNT093NDCS8ZTLZe3v7xtjioI7WQnfs7q6qoODA925c0f37t1TrVbTt99+q+PjY/X392tmZkZnZ2eWqZycnNh5c9lM7J1LoSbw8Puv5GbcbLqbhYHZ2dnRkydPFAwGrcEZ2BMIGSNEsIYB6u29GpL27NkzHR0daWlpSTdv3uxwLjxPoVDQixcvFAgEdOfOHVN24LlSqZQCgYBevnypbDZr70OS9Wgh2wOrkggeQszg4KAkWSaGcwmFQoaQcM9RbOh2D6Fmk61Rn+C9kSlwxmHTok7gQtbA0/Q2SbLG052dHRME3dvbUygU0t27d62H6+zszJQn+vr69PTpU+3t7enevXv6h//wH+r8/FwbGxvK5/OanZ1VJpMx9RFqx2RB+XzenG8wGFQul+twLtQyKWe8TTvGtZ0L8y5QHXb1fdxCHpEN6TCF5Wg0qoGBAet+l2Q9AbDFOBT8TDdFpDaDU4GyCcfdbYpkvgSGmSi03W5bRpJIJDQxMWFcbxq+IC6QnpPmlkol7ezsdH0wYYcEg0EbecszSbJuYyAJmEHUUWCLoS+EoUQymwsEaQH2HdkQe0vzKkaUgUFAZjChwNJRm4WqymWNRqMaHR01mIa6AFDm4eGhTTfs6+uzcccej8co42+z6JWKxWIaHx+3pjqX4MC5cWmoXAwgGJwwVNlCoWCXFOcCnAo7ib/DGAeDQWPVAEXwB/mecrls+4zcOTUssqyJiQkjcZyfn3dkUpLMEAANY8C6XYz/TSQSpjJNsPZm5kkG6xprsifQBIwSUjuu3hdMtIWFBYNmXIaV3+/vuMNk225PHOc8EAhYqwOOnfNOKwNQKQxPYGao9j09PfYzu100EksyWPpNkg/wMYgDpCb6+ggE6W3ibFC/Ya8g27hnj8yI0dKS7Hxxj7GHMGpHRkbMmaAe39/fbxn53NycvXPOAjYcVXUC0Uqloo2NDXm9Xn3wwQd/735d27n87Gc/k9fr1eLiou7evdshnkgKi/FCAoOu43Q6rXQ6bXPY/X6/FfaePn2qdDqt+/fvm44Skg/Qgzc2NnR0dKRAIKCxsTH5fD7rOchms1aopt9hZ2dHR0dHJiaXy+Wsgejf+Xf+HWUyGaXTad2+fVulUklPnz5VsVg0bDIQCFjDGUXEtbU1c1D/8l/+y7c6lNLVuF+//2pY1Pe+972OLnZeJHt0dnamly9f2gUNBoOKx+MaHR01A4vM97fffms1Ly4R+mKDg4PWjEojKNkPzB3w43Q6bZHh7u6uFV2BNl+9eiWPx6NPPvlEk5OTNsvn7OxMy8vLVoAFt//666/V19en3/3d39Xo6Kg2Njb0y1/+Uu12W//4H//jt94/oMG5uTl99NFHOj091e7urmWDBD50LHMZEYVElZsaTblcVjab1aNHjzQwMGBRNNDF0NCQPv30U0kySCOVSlmGzbyfzc1N07QbGhpSo9HQ5uamya/39fUpn8/bMLypqSn19/drdHRU09PTOjs70+PHjzt0xjDgwMPAe/v7+2+9b+5iJs7i4qJ+9KMfWXaGkyyXyzZiFz2ri4sLc6rcb0kGP25sbOjx48emzgE1/vz8XBMTE/pH/+gfqdW6mnWPA4D9lc/nrU8ul8spEolYdsgQMoxlsVjU6uqqqUSk02kzvuVyWQ8ePFC5XLY6BJRzKOX87KOjI7Xbbf2Tf/JP3nr//s2/+Tfy+a4GDt6/f1/n5+dGxiBrSqfTGh4etibps7Mzzc/PmwR+NBpVrVbT8vKyCoWCkXJisZjm5+fV19en6enpjmC9VqtpfX1dp6enVutDKoa9oUduc3NT5XJZr169Ui6XM8HRfD6v9fV1tdttDQ8Pa3BwUEtLS/r+97+vs7MzraysmII3bM+dnR0FAgHdvHlTfX192tra0i9/+Us1m03903/6T//e/XorbTEwaSJAFtE/GC6UNYT2SPExfmDK4Lqu5hCFsN7eXpuJ4WoNcbl5mZAK8OBElERAkuz3EFFRd6CO5NKgXf0u8EbICAg1drPo7sXwEYW6eC14rtSpxURGQFbjUmTPz88teiPKJJoPh8OGv4K3Qo+l7sR7Awsn+yNi5mtd5V80u5ju5zJyeD+oA/B+yDSIjt92wb2nqYt35r5j9pDP7Oow4fioMbh0ZFe3jv3AMfAzwdjJzNwz1mq1zCmxV9QAIKgQhPF7aFrj80mv6aI4Frd+wXO+CywGddzr9drQL5fa7f4uMmu3X4QaIdAXn8XVYXMp036/vwNK4n1AUnDPmPs7ue9kTmR3OCY+J20NZCw8G2Qj6PeQTmAadkuKIIBi34BcJXU8l3tmXJVhGHKu9pxrj5BqogaLU8f2kZFTimAf3OZVUAhXfYLP5BJ9ms2mQYWgHWSKZFd8dqB0gpDrNqJe27nQU7Gzs2OsD6ASukGZpFgul7W9vW0YItLSCwsLBkWgkEuDWj6f1+npqRECXGjr0aNHNuWPnhkmUaZSKduQ7e1tNRoNS0MzmYwWFhaUTCYtNcxms8rlcjbXgxQfSRh0sogkXWOdyWS6Pphc0qdPnxptErkM16DAEmPYFTL7MzMzmpubs6iOojZNaq7jlGQKp7VazaJGlwMPJx4piHa7rY2NDbvAqNZ++umnyufz6unpMRWBQqFgOkPsXyKRsImgroFwGz3fZf8gc0DyIOputVoGg+zt7Vmz4dramqnwktZTD8zn8zo4ODCadyAQMLmQSCRimeGjR490fn5umRkNZ8AbHo9Hk5OTNmm1UCiYEZNkkkHRaFS7u7umAgDOjeMZGhpSIpHQ8vKyZcwuicPr9Wp0dNTqk90umIgPHz7Uy5cvTbIG4+H1XqkKS1esodXVVZPMQTYGKZZHjx4pm83K7/db4yMN0O12W6FQSEdHR/rZz36mWq2m7e1tU+uoVqsdjbnJZNJgIcYio649PDysTz75RAcHB7q4uDA20/7+vkZHR41EwYyotbU1bW1tdbBTCYJ6eno0Pj7etYNGfgemKdkvDlC6Up4Oh8M2OhuItVwua2FhQXfv3lWtVtODBw86mlDr9brW1tYs04KkwrCz7e1tFQoFgwS9Xq/Z1WazaU58a2tL9XpdoVDIpHCo1WQyGYNtV1ZWtLu7a0PvmBicz+ctg8e5Eyz19fVpYmLiu6ci80JgI52cnFg3M4UzIkYwP2S06/W6Td2jSA0MlUgkJMkKnCgGU0Oh1sF4WS44KsDUADwej1GRwa6TyaSGh4fV09NjctsrKyvK5/NKp9OmAjAzM2O8fiAjDADzK8Deu10Y/f39fSvuIivuNoHyIjnAqEcjL395eWkyO+iLwTpxO+5hnHAwYScR+VDjAuOVZBMSJVn/AbO1keJeW1vrEMQEDiLLwxjyc05PT01rC+pqN4ueJ4yTKxQpXREmoA1XKhXt7e1Z5AXryMW7C4WChoaGfqMOSG2BscWlUknPnz9XoVDQ2NiYMplMx/4xJpjaHtG4dAUdMTiKc040i7gqhedEImEDzmAjcemh4I6OjnZNiOB3t9ttg/kwHD6fz4QrET4EdiUzhqQBNp/NZrW2tqaJiQnrWyOoIABELPH8/Fy5XM6yEXT8YIFx/gkq3eJ8IpHQ9PS0enp6tL6+Lp/PZzC533811AoFDkk2CIuMxe/3W/tCPB63ekM3i6ZPgt5yuWw2kDoSCyQA+jzBVSKR6EABqDHDJJVe9+K4MO3x8bGOj4+NnedmSa1WyxwoRAEIJ5FIRJFIRLVazYgR1GcIKGKxmG7dumXQJ8gImY+bXUG9vs66tnNxZ1RQ+MHYUoTkssD/9nq96u/vN8EzFzoA2mITuax4ZeCzWCym27dvmzQCVF3SPQwwRVKfz6dMJmMOZ21tzZrtPJ6rWRz8LlgfNG4dHh5a4xDMJhq6eJHdLhg4wEqMOkU+BJohdYLR0VEz2MFg0LIssg16Cur1uhUCXbl9yBRAcBwOsgiYcfwJBAKG9dMf4PF4tLGxYWOeKQZT0CdShQVD4BEIBGwsMmw8N6LvZrlEEUkd8Orw8LCNbOA8MtY6kUgoHA6rv7/fAhbOMXUF18C5Eh1Eqnfu3NHFxYXS6bT6+/vNcAD/4khx1hjgi4sLvXjxwi48fVZ05QPhAnegwB2LxUxdHCOSz+f19ddfy+Px6A/+4A+62sP+/n4LPNyoGScJhVa6ctaoWOMshoaGJL0eLMX9KZVKdjc5Y2hokVG7IpjAi1CrgWo4g729vRofHzdCA3t4enqqWq2mkZERUw93STutVsvaCnCGvJNG40o37vj4uKu9cxf3tKenx+bgkInyd4FAQENDQxaAUa+C6Qm5AjgNViLB0snJiTWl+v1+zc/P26hsnsfVwwNq474TTPX19Rma4IraQmICKtvf35ff79fBwYGKfzdRdHp62gIdUKq3gbWv7VxGR0ft33EIOBe3ZgJMcevWLeNFo/mzt7dnAovQPSkijY6OdnhkDGMkEtHExESHTMzR0ZGePHliLDE4+PRz3L59W7FYTFtbW/rmm2+M6kwvTF9fn05OTgwC29jYMLgpl8tpdHRU9+/fl9/v18bGhjWAAS11syjGk0Gl02nNz88bcy0YDOrg4EA7OztKpVL6wQ9+YGQCinr8/kgkomQyaVEwzh0jwOHDoc7Pz1svAw2nDx48MDVbOnDpHRobG7NC6aNHjwziohjY29tr2We5XLb0nIM5PDxsA542NjYMckLFuJvFTA8gPZddQ6c3z5xMJnXv3j1j3fh8PstWkPahi//4+NiK/dFo1JwR5zoajerWrVsdczMKhYIeP35szw7MAymAf1YqFf3yl7+0oCQcDmtxcVEDAwPa3t7WixcvOmo++/v7VpSemJhQb2+vjo6OdHZ2pq2tLf3qV79Su93Wf/Vf/Vdd7eHY2Jja7baOjo4sGAOWpony4OBA+/v7SqVS+vTTT63ZLxgM2rAqaNNer9cowuyhO23RVXJmvAZ7WCwW9fLlyw4twXA4bJna5OSkZR1ffPGFoQler9dGBB8eHtqYb7ImhEHT6bR1zFNHRMm92yCRu09wHA6HLZvE/lFrHh4e1k9/+lOT3ofS/fXXX6tSqejo6MiMe7t9NfdnbGxMfv+Vdhoq8QTrH3/8sWl9ERwCA5Pp9fb2GilqcXFRsVjMlK9RlfD7/cbKOzs7MwFN6Pn7+/vK5XIaGhrSnTt35PV69fLly459vu66tnPBKJCGuYUeog2iYIpVLm2WQhPFJopwHEDqDq76K5EUxACiaX4u3cUUrzEMrjaR9Fp2BriGQhwFfQ4bF4OmIRwS/yQt7ma5Xf4UN6FKurRhl+zAcwJfUIfCIUDthGoMZZuMEGNM4ZnDTOEU5wPtm9oFPTawelx+PpGo9Dqb4LncTAl4jM9IZvsuF5s9cSUoKOQiV+MW5N33DRzA+Wo0GmbsYBdBAecCc+bdeRpEcmjQgbe79G8yTAr0PDOwJkVl99w3Gg2bpOmOy3UVK961w9x9p0TIZHKcFVdNgK8jeITqSq8TRftwONwBp1BId4v7ZDv8fn4ebDiXxPOmqgGfizoXwQ7UfnePCXpxYhAWeHfvgkC8aQOxQShuBwIBgzOxhxA73oSxgGvJmt1xCgSSoVCog/zgjqnGOTDniGd2fxbfy9nlrLnSWsBykJW4D9TReV7e59s0oV77K6HwYZTo8AwGg/rRj36ksbExi6SBU97ENknJDw4OdHh4qMXFRS0tLXUwoQ4ODpTL5ZROp+0QICUDhe7g4ECvXr1StVrV5OSkDeC6ffu2fVYKlTRZcaCRt6eewGcicspkMh24JtTqd73YpJrogzELoq+vTz/+8Y8tQ2GOCx347rAooMTt7W2dnJxoYWFBS0tL5hxarZY19UWjUet2JlscHBzUwMCACoWC1tfXVa/XlclklEqlNDExoVu3blkHezabNbVfnHG9fjWUibkxaBZR+KvX63a5gS2JfCFQvAshotVqGWEEOAbpG4rwqD/kcjkbbsVZAM6iY/revXv6+OOPDVqAcl0sFpVMJo26vLKyYlTugYEBo7ZfXFxofHzcZtV89NFHqtfrevr0qY6OjqyuQJDQbDa1u7urV69eKZVKaXFx0YxUo9FQKpXS+Pi4SXpIsmdFU+tdzuDR0ZEkGVutVCppe3vbaiqulEur1TK4hcwTg0jGB1T44YcfWmDRarUs24/FYkqn02bQ2u22+vv7lUqldHBwoKdPn6parSqTydh+3759W5eXl1pbW1OlUrEpmOfn5zYAbnNzU8vLyxofH9fCwoJarZY1zVIPA1qE9edG/N3uocvagqi0tbWlSCSin/zkJ5qamjKH02q19PTpU3k8HpNaury8NPgWx4N6MvtKwy1jD6amptRoNPTkyRNDGCBLPH36VLVaTePj45qZmVEikdDw8LAkGbkKeNythaIZNzMzozt37tjnoikVpiyqHDjHt61ZXdu5kD24jYro64AxutExmD4vgggWFggePpFImPHm8uO0SL/B7F04yMWNYfikUinrfQGDhFpM9ETUSXMfy4WRwDWJLMDQ34UGSuQmvcaqC4WCQqGQRSRkEdJrZg+jS4ne0LyCCZNKpSzqpiENyQimIJZKJUube3t7rSiO0yDzS6VSpqPF9EiK4NRyiHrQUpJea6QBrbl77io6v4v0hkujJHIFZ+f8SbLMjUJ1qVTS0dGRRcA0iyIQOjw8bMw9oBP6maiTAU2RiRWLRetvoMAfiUSUTqdNjRddJhop+WwYZgqt7D/wGJ3S3Cf2nbP8Ls6FIIWfh6JDIBCw8+BG52Rs9FC4ZwCjEwwGjagBcsFs+1arZX1rbqYRCl2NJaeWh4gqdQkCCe4j54xIHtYi/StE9rBEIRWg6OEiLO+yh3wfz4kdJFOGSejxeIzE4MLA3G/uAXYxFovZz+J+Qcjh92EHYrGY3WnO4NTUVAfRCUfF++a9ERxAyKL2C+PXbRkh43czLrLU71z+BRyauRrVatWK9ggjsoEwjbh0cKgRvARHJGKs1+uG5RaLRTPk4OoUvlOplOnw3Lx505o04/G4KpWKHjx4oEbjSiSvXq8bG4IN4iIPDw+rUqnoiy++sH4DoDyKaIHA68mXXIx3udgQImBgcJkoeL98+dIywkAgYMOVMpmMRRXM+jg+PrbDwrMWi0XLLNg74CimW8bjccNhgdeoiVWrVT1+/Njkcy4uLpTNZnV0dNTR50GB8vLyagjRmx3yQEMYAhozXViwm0WgQd0IB9jTczVga3Nz01hsbn/Q8PCw+vv7LahA2gcnns1mjdXkilu6Hf9LS0vyeK4mhUJQoXBM02GpVNKvf/3rDqFQnDzsMAwNc46ePXvWEbRAS2+1Xs+oL/7dgDwIGe+yhzwXki8U1D0ej8rlsrUZAA0SwAwNDSmVSpkBhOLtUmKr1aqxy9weJxwKjEyMfrvd1tLSki4uLkzeqVqt6tGjR5YVICaLoTw9PbXonVHraJwhYkrN0IWUCYhhr3a7pqam7N8JVtmj09NTPXv2zNhw2K5QKGRnlv0DYpKusklqbwQ4Ho/H5HjOzs4UCoU0OzvbAZ0jxkr2g/Dn+vq6MV5dx+bzvR6UGA6HtbCwoGq1qn/zb/6N9Y5Rt8bhuKw1SC7Y5+ust5rnQooHtW1wcFAXFxfa3d014TQkP8bHx004sr+/X0dHR1pfXzfeNz0HRIWrq6u6uLjokDKB7TA/P2/aYhhMmDXQ546OjvTq1SsrnmFc3PoLQoLpdFqvXr3Sw4cP1dvbazLoqVTKog+3UfFN7axuFlEwhw84B0NCtzJFPLDkkZERTU1N6fj42CjFiBm2WleTNiuVinZ2dqy+5Xb3RiIRTU5O2ihg/l+hULAAIRKJGOXbZZNwwe2w+P02IjiXy5nsON3SrrSHq5pcLpftfXa7CBboqXFxa4ghyInw/hEc7evrsw53sj3qWqhpb25umrMi+kSCY2xszAql9BXt7e2pUqmov79f0WhU5XLZ+iuI6nEUQB2SbP+AJj2e11MDY7GYIpGIwTeuc6G/4btYkA+I7Kn/AaNwzqHKDgwMKBKJ6PT0VPv7+0ZaAMPn/H777beqVCoGheJcODf0W/Bu5ufndX5+bs/PPpFpSK9rQmSrOPlwOKxisajl5WVJryefzs7OamRkxPrwqF9Q56UW181ifjyZODXARqOhXC5nI6Pr9boikYh13KN7h6SS29BM0EFgCEuxv79fwWDQoL7JyUlDImCUotsYj8cVCARM2dx1KnxGmLV+v1+zs7MaHx/X48eP9fOf/1yBQEBzc3NGrAJ+BRGhjtpsNo2yf5311n0uRC6h0NXkMx4UYTbpKrtBmr1UKlnE7T4c2KB05VXBpmGm0PwGS4WD4fP5TDeHwrbbNU7tAnyx1brqq0Gd9fT0VD09PablFQwG7fso+jILwsVG+ZzdLmilGItEImHzvN2iPYqxAwMDCgaD1lBJ9OX1ejU+Pq6RkRGj1rr7Bh0UyXFgAL623W6b03iTkgwZgsIpjpCGRUn2fS4RAqdFUx5GkvMALER63s0ibacnJRwOG56PICrjniF20NiLMjIwD0GE22U9PDzc4UjT6bRl38AM7BcyQzhOLjCZAOrPyHQA8WAgMRoY3mg0at+LMXUdMRc9FAq9EzQLvISx7e3t1ejoaAeBg/6NWCxmEvBAi7zzQOBqMiK9JZzLoaEhJZNJE1VMpVKm5Qd1lgyCgIBgAEeM4aZnioXEidu07Z4rV439+PjYCEPSFbTMe6aW2s3CDvBPhoBJr6nt6PORsYRCIYMcedaenh5rviXLhnEGlAhBBDozJArQGEZMc2a529Tq3lQOcO9wqVRST0+PfS/wLSMMkH7iHWCbIJxcd13buQAvZbNZHR8f6+bNm/rJT35icBkfulgsGife6/XqV7/6lZaXlxWLxTQyMqJIJKLf//3fVyKR0DfffKOvvvpK4XDY0mY60mFB1et108vhBZ2fn9tBw5gmk0mNjo4qEolobGzMoLjz83Otra3p2bNnVoeB5ZNOp9XX16fh4WGFQiE9f/5c6+vrmp6e1vz8vBkNlAMwvt0sIjkaEe/fv68f/OAHisfjFkkdHx+rUChYEbLdbtuYXjez+vzzzzUwMKCf//zn+qu/+iu77EjdM9+EAjr9O664YvHvJOlp2hsYGLAMDlo4l+XFixd68uSJ1VowjkRfRPPLy8va2NjQxMSEpqambK9cmZRuF+SEbDar3d1dzc3N6ebNm9bv4/VezfLY3d21fhK/36+nT59qY2PDsqpQKKTFxUXrmt/e3lYgENC9e/eMNXN+fq5MJqNbt26p1Wppc3PT4D0YjzTGwRZKpVJ2jhg34GbA7hyTdrttFFwyo1gspp2dHeVyOfv8LpEikUi8UwOgdOUwm82m1tbWtLe3p9u3b+vHP/6xRb70Oezs7CgUCimTycjn8+mLL77Q8vKyUqmUpqamFIlErNXg2bNnevz4sQKBgD7++GOr33GXBwcH1Ww2dXh4qKOjI+s1QWkbggv1VxqyZ2dnDUXwer168eKFvvrqK4M2OVfAsuz56empDg8PTbW92WyajDzEkm738OTkpIPUNDY2pqWlJTPMwGM0ouLMV1ZWjA7c39+vvr4+/fSnP7XG2RcvXlgW7vF4NDAwYGSaTCaji4sLPX36tKNWVywWTW2ZNTMzow8//NCQH7cOtrm5qadPn9oIdFSSQTIY2La9va2DgwNrJ4DBe3x8rHg8rsnJye8eFnNppKRZ0utRnDQQIalNlA/OiNyI1+u1jYNdIskuPtAXP6/RaFhGgbFz6bZudMMFcRfwhmvoGLbDJeCZoLn+24zguxT1qeG42Y/X6zVsFmaGq/RLusykTKC+UChkRtVt6GLf3Kil2Wx2dOUSAfG87vt8M93/bfsAdCepQ4fIpQe7i8/g7mE3Cwbam+/XjVrJSl0qN3UsSRb5UzeCZgtkB5HD1aiCKAGRAmVd9syFwd6kDZMR8Ny8e96jW9wlwnRps28+K3XDbhdZGFEyv4dMIRAIqFQqWeGb5wFacmcNMTuHnipgWPd7eX63dcCF31ySBs/HO3hzL96k8bKnfD3f78K6BG38v3edh8Peu/Re/j+2i1qgewfpQ+GuSDL2n/uZqGGx76694fyB3mAHXajeJdC4NtqllUPl5k5QY+Heu6Qst53BpcVfl5hzbeeCLlg8Htfx8bF6enr013/91xYJ9vf36+DgQHt7e5Y1cPDw7DT7wbBg8JTbbYraMU6Ah4Hd4hbEpddyHfQQFAoFi3BwHpeXl5qYmDA89PT0VOPj45qfn1etVtPGxobBFWhBIe9NZO4a7W4W1Orp6Wm7EH/1V39lxTXqUoeHh5a5SOpQNADuQ5H3+Pi4o8u30WhoeXm5I0pz8WW3HiHJeguIsIlQ/vIv/1KlUskkJBqNhsGYvD8a8Gq1mra2tqwD+LPPPrPMxmW2wfLqFpKgCZUswefz6csvv1QoFNKNGzfU399vrCaK/LDryDq5SJLszB0eHlqzHlktUTXKDQQdQDntdtvqFW6NC/LHo0ePdHZ2ZvAwjB4II9BlgeWeP3+uer1u1F1XlBPYFnj0XVY6nTYDND09LY/Ho7/9279VOBzWvXv3NDw8bHUB3j1BDRAyz4uBAjLDqQDhECHjaDCchUJB+Xze5rmQ2Xk8Hht+1Wg09LOf/czuZCgUUqVSsb+nfshe1mo17e3tqVarGV22t/dqtDTkgFwuZ++v23tMzQXSSCAQ0M7Ojilb0KC8srJiRpmvZww59xT7wpjjQCBgyhivXr0ylXR+J+cTeBw4W3otH0XJ4Pz8XI8ePTJKPaM6GKaINmR/f7/u3LljdV8yrqmpKQWDQVMmyWQyisVihhxcd13buVB8JlM5Pj420TOYTeCibzYwUYzk0oAP0tRG8590BQ25Mwn8fr/Gx8cNVsKYgj3S3EiUVKlU9OTJE5ORZ8zt6OioPB6P9vf3bTYGlwk4an5+XiMjI/J6vdb5CjX0XVckElGr1eqQD1lZWbH5DKTUSLVjhN+UFwG6eZPFRoRIYRFaJ3ADl9tdZEgYABg533zzjfb29qyInUgkNDs7a9kXDJWhoSFjyRSLRSMfkMG6arlknt06F7BtnOzp6am2trZMZgN6a6lUssjK57uaz8K0Tv7pMn0qlYplMFBmcYoU0uPxuGHUUJxd2Itos9W60jZ79eqVaZdBl0WOA0NKobdYLNrIh8XFRQ0NDXUQCsiqXLZlt4vMgzpQLpfTs2fPrGDsak/RTsBZZO/cjATpJSA+agu5XM4ME+gCkvPUCsD5QURw2DQirq6uWq+VO4+IgAiyTywWs1ob8DU1GT6nq/v2NvIlb65kMinp9Qjti4sLHR8fq7e31yB/anJAXCA1ZMpkV2Q3OHO0ED2eq/k4qDWASuCECdLIniUZfdiFsJaXl3VwcKCxsTH7bKisQAwKh8Oam5szMdDT01MNDg4a8YLsJpFIKB6PK5/Pv9XYh2s7l42NDUmvYYhYLGZaQ3CmPR6PzVvhUFJTYHPhz/OCiIgoCuMMCoWC0WtpyOSyup2vOBQK1z09PZqamrJucwTr0JrCsTWbTZNPwGnS4InT4gDBkX8X4cqnT59Kku0T0avP57MhPmg8kUrjjCjUg+uSDrfb7Y7OXL/fb/g9BhJ5m2azqYmJid9QhaUozaRL6Qq7dVlzsP+QpoBzTx2Bc8GMGpft1G63rTj8LjRQ1Hr5XRhdMjmgD96zC5eC6UvqaGgEUiBThKZMAMRU1MPDQzWbTeslcKEBnD+GkUZcmGWQG9Czw8gRWUuvO6CZvopR5rMicYNx63Yxk4ez1G63rdGQ+ketVlM0GjWnKcnEOYHVIG7gWFwjh7gh8+FxMrw/DCHUVjJctMW4B6OjozZ0iyI+LQkYWXpCgNvcgJTgE+IOkkYM2ep2kXm4793r9Wpvb8/aKqanp43EIcnOBsGc6yhjsZiGh4eN7tvT06MbN25oYWHB+vloHG40GpqZmdHs7KzV+tCnQy08Go2q2Wxa+wGBJRC29FofknvK7yBjxQm6cKV0hVq8jTL3tZ3L8vKyvF6vdcSzGSj4np2daXFxUbdv31ar1bLJe/39/Zb1cFAwSBTk4dwjQQI2vb29bbpKZ2dn+vGPf6z79+8bMwhueLlcNvirt7fXZsHTt9Df32/y8EBtjUbDutRhcFDwdmmzYLccgm4N5BdffCGv12vD03DQNOnlcjlNTU1pbm7O6N1oFEWjUctMiI5hmcBIATOnKXV3d1fLy8s2zItudjS/gHt2d3d1cnJi6XM4HNadO3dsVvnFxYUGBwe1sLAgj+dKXPHw8ND0kchGKKi7hAGowAwWg0XVzXr16pX9PCTaiXr39/eVz+dNqYE9gtbJe8QgQDnGuZDd9fX1mWLB1taWHj58qHK5rCdPnujk5ET3799XJpOxn8cZo7kNOvb8/LxlONQzUIpwx1aTxQC7YZwgCkjqYA4NDAy8EzSLzt7ExIQpWWcyGbVaV8oYGxsbGhkZ0djYmH0uSRoZGdH4+Lg1gF5eXppqONMWyVA4136/34aN0WpQKpW0tLRkWnc8N068t7fX7uLs7KxpheVyOUWjURvpzShelCGY/MmYAiAjGKbDw8MmbvouZ5CFU8NJNJtNra+vmw28c+eONT66jDb2h+DV4/EYScL9msXFRY2OjurJkyf6i7/4Cx0fH+vly5eqVCqamprShx9+qHK5rJ6eq9EMKysrpqhMm0ImkzE2H+gLd8GVHEIfMJ/Pm4PCzhDAck4nJyc1Nzd3bdbsWxX0Ke4hVMgfNotUmuyEw0ME4XbcUsgGUiMiaLfb9uFdCRYom319ffZzwLyBrRCwdOEKMGO63ElXiWLAjSmAuX/cAh4vqduDSTEZ40aE4PbhgGO7ark0aUFu4MUT4QHZEP3yWcHJcfBkSuwp2SMwAzRUAgDeKe8GUgG0UdhrlUqlo6AKxMHlcbMwMo1ulkttZn/cngkIIFCzaeTDkbrnT3otgULtgzMHXHF+ft4hnkrm4opaEsVzB9zL6PZT8G7YD7fbuVarGezhEiTYP86z9DrQ6XZhWLnHQFEuxEzE7UauLpztjv+G6QXdmKwCAgQZh/u76flwiQ/UT6HlEzm70KDr7CBpkEk2m80OQgbnDNvDO3jXBlTeXbVa1fHxsWUf/H/uFawy92xgexqNhiEhfDbIKtggVEooGVBnJMhAYZqz4cq7APu9WXTn3ZK5NptN+1nSFfTFveW9u9m+9JrIcF3W57Wdy+LioprNplZWVvTNN9+Y3IUrGnl2dqZf//rXVpfhEEMhPjs7U29vr2ZnZ01FdWpqSmdnZ9rZ2THeOy8EEgH6Ojdu3NDo6KjVdlqtlpLJpNLptCqVitbW1oyWy6Gm+/jFixd2QPx+v6anp/XRRx/p5OREf/7nf25qqRgrMhfqGjAounUuFM62t7e1urpq2l8cDOoIz58/7zDIpVLJfj+RGAcNZWX2j0MJnkoxkHnpU1NTmpiYULFYtOFLsFYuL68GQLkOAkZdtVrVl19+af8vFotpbm5On332mfL5vA3C4mIjyc/nPzk5UU9Pj9WzulkffPCB7R/NirCUyIqq1apevHhhcAzd3EAwUFeBTKPRqD755BOL4Gq1mh4/fmy9OsxZQY12dnZWs7OzFiCgyQSLhw5oFo663W5btz49W5FIRHNzc6awXK/XlU6nlUwmravcZaC1Wq13lov//PPPLdND+wsDyfhi1MFdJ/Mmy8jn8xlcOz4+rtu3bxvBBO27w8ND9ff3mxIz1OrJyUmNj49bP0Wj0TC0otFoaHd312B0nCrBI/qGe3t7KhaLunv3rj744AMdHR1pY2NDl5eXNm6ZehoZP/1IUveMRWzA+vq6Xr16pYGBAS0sLBjsGolEtL+/r83NTfX09FjgAtyFHqPP57M2CIZ0IT1Ur9f16NEj6ycDlbh586aCwaA+/vhju0fAXaiW+Hy+DpkiNzuGYeb3+zU3N2fB4dDQkNXWTk5OdHBwoHw+r76+PusjI0PkDH7nsBj4J/heq9Uy/BJIBo+OYYbdAPMLmiP1EoqlLuWTTcVgSK8plC4fH0cAFEEPgiugiIe9vLw04UgOgjv4xi20Sq/TUw6jO1Kg2xWLxSySIirmv4kQ6MtxDz/OmSIehUyiNKIQInPgAb6OQ+YSL/gMFxcXpnAArkv0QsRIURxMPplM2vckk0mLvN3PTMGbhjbIEe+6f2SdNH/xfnFoPAPOhXdGVgjtmEyNQiVnE2cIS4wmV6JOMj9+FhGoJCu08vw4BDIA4EPeJbVLFCkIMthL6pNcardG1O2iz4UeMVfJgHcO5ONSrF3nQoBTq9VsL9PptNXgJJkRdQvZZL00V7tUWyjMSBJhDLkX2BMyAWossO+479Rt+Xqcu6siTgbZzSK7oB6HDJKbpSJZAwvTVVWoVqsmz8QZdEdkkM1BMqKRkYZ1yDUuKoAdRbgWmwJJR1LH/ksy8gBqKx6PxzIXpqlKssCD0sHbqpRc27nAEhgYGDDxND4sl9pV8OUB2ZTDw0O9evXKNq9er2tra8teDikfzX2uPhVOY39/X8ViUaVSSevr6wb5QMWbm5tTvV7XwcGBarWaIpGIOUXX2LDAg3d2dnR8fGw1mkwmo48++kjtdlvb29va2dmxLKnbLn2EKDOZjBEhKNpSu3C1g4h6KIRXKhXDVam5VKtVG6VK74Akg7NwJK7u2NbWlk5OTvT8+XPbew7nxMSEEQCg0sZiMWu4gsZN0ECkSkZ6enqqSqWi4eFhzczMqNVq2Ywc2FHd7t/6+rrBOGhSQQvm7KEC0dNzNc6WLC8ajZpBcI1lLpczQUYuOfRYZHHY73q9brXF8/PzjiI/dPhYLKaLiwurEQ4ODlrEzsCmg4MD20MULCiO7+zs2Dyf2dlZtdttra6uqlAoWJT7LosziGgrPRnQk4lu6W53J0USgCAvAhoBRdp1iEjGuIP9oNDu7OyY5BNSL8PDw4rH4/L5fBbFb29vq1qtamhoSENDQ9Y4jeZdsVjUysqK0um0BbA+n0/ZbFZ7e3s2E6fVulK1Pjo6smCy2+x5b29PrVZLo6Oj1rSJVApq6wQtwGXNZlOpVEojIyPa3d01hIRAemNjQy9evFAwGNTIyIipe19eXlpjLuSos7MzPX/+XFtbW8rn8zaGm7oc6BCBAE4PpwXyAgsSxiefo1wua3NzU7u7u+rp6bH64vLystbX1zU3N2dtGddZ13YuDOqhUFQsFrW7u2tSDlBO6/W6edZAIKCxsTGNj49rfX3dtH6QhDk6OlI+n1d/f7/u379vfH6X7uk2+jHcCyl1IAfS4fHxcZVKJZtFPj09bXi52+EPbRKxzEKhYEOPjo+PFY1GrQBbLpe1vb2tWCymmZmZazcQvblIV9k/LurZ2ZmKxaJOTk4sBUbaxK2TUHDDIEDfJtV150EAT7F/pVLJYJxm87VKQLvdNmFHYKDT01M9fvzYpidCgyUjwNEfHR1ZdzuZK2Nf3QI22QtNd91e7K2tLdOoGh4eNkPJeXJrMAQ1GLlEImH7jVNG4DSbzSoSiWhmZsacOhRX4DAyDs4rIo+tVktzc3MaGhpSX1+f/Z5CoaBCoWACkew5GnDMQo/H45ZtAiudnp5qdnZWd+/eNUOwu7trPUvvUozG8KAhVSgUtLKyYj0bZKmIZBK4pdNpxWIxg7HcwMJVHpiYmLBARXpNfQZiI0ME9svn8x31uWQyabbl8PBQuVxOyWTSephoUygUCjo9PdXOzo6i0ai9H5/Pp1wup8PDQ01NTenmzZvyeDzGAoVd2e0ZzOVy8vl8mpub0/j4uDlXUIDT01NFIhGDGLlviURC4+PjHTppfN69vT3t7OxoaGjIFEaoqaTTaeuPgtlKcIJzbbVaNnQQJ06mjnNxa46832azqf7+fo2MjFjgRLCazWY1Ojpqqhj5fF5Pnz5VOBw2EdfrrGtbSmRCwH0RoKQB7eLioqOOAHRDtOGmyTwcxTicCvCBK3joFpCgLXu93g4ZdUnW+Far1QxO8/l8BocNDAyo3W53QHKuaoDP59PIyIhGR0c1OjpqFOX+/n7NzMwonU5LUkfm8zaL5i0McbPZVCwWUyAQsOfncrlZB0OpYBhRuATaAoLhn24zG/uD6Ki7l5FIxA4/0Wu7fSWsCdSGcSNac0kDbl0KmApRSXBcqK6Li4tGMe/2YsMEQu+o2Wx2NNHBDAPfpsvbHdGMEYPZRK2Jc+x+NrJKjDGXF5IAQqM4Kxw8ulLxeNzYTpxxzhu9BHRZQ0yhLwvHDJllaGhI/f3978RWlK7QB3p5otGo6vW66bIRPCC79CbtmEAGlIAgEmLObxtuBvQmyWSdgFdcrTCIK24/CqxH5J+ozbgQPPL6QF+NRsNqLii2cwbb7bapWr9LzYX74vbxSK+hUHeOEs6kVCppbW1NhULBCu+cUfYbKj8BnFtnhRGHKjSQIdCzm0lwx7nnMCR7enrs/rFnQGk8g9fr1cjIiAYHBzU8PGwU/3Q6rRs3bmhgYMCC/eusazuXg4MDiwJyuZwSiYR1ve/u7ur4+FgTExP63ve+p1arZQfyxYsXNjZzYWGhYxPD4bAGBgY6MH1eoCS73BgymCZEhrApJFn0T6+H3++3qGBgYEAffvhhx+TJSqWi09NT8+xer1cffvihFhcXramo0Whofn5eCwsLdlneZnPdtbOzY7ABasQQFZDNn5yc1M2bNy3SrdVqNvI0Go0qnU53OO6zszNjReE0Mb4QKtzeGWooZEE4corNkuzrh4aGtLu7q93dXQ0ODur+/fsdncCMT61Wq9rf31ej0dD3vvc9ozGjsHzz5k3dv3+/Q7Knm7W1tWXZWrFYVCqVsmFvFByHh4eVyWTMeNXrdR0eHur09NR6dTCE4PWDg4O/cSGBM2q1mgKBgEXk1EvYP+AyFKZxsqlUSolEQoVCwWAuNKju3r2r3t5e5XI5M5oEAGNjY6bJx+eANjwwMKBMJvNOmcvXX39txfhEIqHBwUEtLS2p1Wrp0aNHOjo60vj4uEXLwI0MCqO3DRgNurRb23LvB6xRSDYYw3a7rf39fW1vb1ud0S2+0/LQbre1vr6uZ8+eaXh4WN/73vesAbTVulL42N/ft8y61Wrp448/1p07d2zmy+XlpW7cuKGlpSUz5N0uIH8o1ijAS6/VLkZGRvTBBx+YMgAw6YMHDyyQpK8Km4YDXltbs7NADwuQ6dbWlo6Pj61l4PLy0uqQb4qcSjJWKZllOp3W7OysoRkEirB6QZo+/PBDzc3N6ejoSM+ePdPl5aUWFxf1wQcfGJR33fVWGI/b2cwhcCMpvClRIhEJKqvg3dJvqnYSZfP3ZBk4Frw1X8c/3X4bDqgbGfB91DLYeL4P9hif3Z1TTVSL4u+7FFS5ELwgmil5ZhwBs+DZBw6AO8vD5cmzXDop81VQq2UPSJNd2iZ/eFfUedy/A+qgwEcxmoZC4BQgMvB1onycuhvpdbuH7Af4Mb+fZ+QdE/lhvPge6XX2SdTs7h/7xVnHaLhwiruX/BPqKWfyzbvhfj7OFFk4gQGSJi4BgFoQBJV3cS5u/wL7wdkj2+B9uQVm7gN9KJI63jvv4s2zJsngGc42tHoieN4dBhLqPdm2JDs7LjWe+pt7h7mvqGHwh+I6dZBu99BtbXBbF1ybxHO6+4ANhLkIQcQ9T2/+PEhLLhnGfVfuvwOBU07gfPM91HKxg7w/zhf/Lb1WeiawuLy81NDQkNXD32aS57WdiyuR7/YbtFoto7X5/X5rkOSSw36pVqsWvZOdgHmnUil9+OGHVuCk6xbGxNDQkFFN8/l8R3o4PT2tqakp7ezsaHl52fpwgD2I9ungRf5/aGhIN2/eNKosBX8Ktnh09LxoNOrWOCYSCUmyaFqSySwASfD5OLzS6yiaZ4fFFgqFDJuGCcYhCwSu5t1ks1kFAgEtLCwYBERKzMHLZDLKZDI6PDzs6K73+/0aHh62xjUiWeboZDIZ/fCHPzSG0MnJiSTZfBR6h1AgYPpdt/tHcZHPwnum/wFjBp5P0Zh6BnUmN/NbW1vT+vq6UqmU7t+/b/U5ejgKhYJJZKTTaSsk4zg9Ho9GRkaUSqUM5gEaYf8ymYw5kHr99TC8VCqlH/7whyqXy3rw4IHBphhzyApAyeDe7XZb/+F/+B++0x5igBj5zH2moRn4lRolMHU+n9fh4aGxnbxer1HDk8mkPvjgA4XDYRNk5MyitA1bi/ofVOipqSmTYuJugEpEo1HdunXL5tzQcAl09r3vfU9nZ2d69uyZZS8Ma3NhdRo+ycK6WUBqqC7gPHDK2DzeNbYMW8LQM8gc7Af6i8PDw7avHs+VkvazZ88MrpqdnbV3gkQWsNXs7Ky1FwCntVotU+wAJoZph5rF7OysyuWyjo6OTPoHghaOBNSjVqtZC8h11rWdC8wZInrp9ehZon7+3o2i2SjYSkQQ0hWUtbe3Zx3SOKhAIGAbRB2BfgvqD2RHSO1j5ChqNRoNK1JjnLnclUrF5qETlVN3cPWwcIIUJF2u/Nsud15HtVq1OguRJJkDvQUu1EDEXqlUrMbg9/ttP4DA3Ojk8vJSh4eHhqtSp3DhH6/Xa7LoLsRBJE2Rkd/NOzw5OVEmkzECxatXr6wWw6GneMj3IYzX7f5RR+PMQcoAaiQKBFp1LxHvn4iZ/Tg8PNTq6qoymYw+/PBD2zsMPP0rOCR6MXhWjF86nVaj0bCaBoEPsi9otpH1NxoN9ff3a3x8XMViUc+ePbPz655hSWaoz87OrJej2wXdFOdIXZPMC0o0NUGMJdE6jDuv12uNuYVCQRsbG7q4uNDdu3c7qO/UD1hE41D7qY8lEglj1WEUyaqgzRLdc6aYhjk2NqZKpaLd3V27M7Ql8Hsg4ZyenhpDrZtFNoXkkos68O9kvNxnjD1n6uLiwoIIl6YMs9GF7k9OTnR4eKhgMKiFhQWl02kV/27EtiQ7h/SkIPSJPaFemMlkOiSZcHiQedwmZOwuf9zeIO7Rd+5caIpjFsTIyIgxWPhQaOGQ1nk8Hs3NzWlmZsYmKcJ1DwaDNn42FAppe3tbR0dHCofDVrSD+huNRq0QxTjl8fFxS61PT0/l9/s1OTlpUev5+bmxgIgakDOpVqs6OjrSt99+K7/fr8XFRcNk6ZeADgg26nLTu1kokx4cHGh7e1vNZlNLS0sdDpiXh4Fqt9uamJjQ2NiYjo+PTX0Y1pUbsYMHE3Uid9HT02ODx5ht3mg0rIcDSBGGFVF+tVrV1NSUBgYGrJkLoT727+uvv7bsZ2RkxGpSRJj0xQA1ugb0bRdzUKA2M2HS5/OZA6Pb2O0/GR4eVjAY1PHxsWXOsLj6+/s1PT1txV+36M+MoEAgYNj5zs6OMSRdjTGcFoEMhiSdTmthYcGYURcXFyZImM1m9ctf/lLSFRGCOR9EwjgA1IVxZN0aRvcMvnr1Spubm5qYmNDIyIhFtRgesnhkVJLJpAYHB03eB+PJXo6NjSmZTNr3060PVZemWijs0JmRs4GR6PV6TUWa7GZyctJo7Thm9vjk5MQkbSjWA6FTtwQBcKVPul1keDC3YIFJr7vXYaZJMvQE5t/e3p6ePn3a0Zvi9uLs7OwYFE1wvrS0ZA6f/XXnUfF1tDJA2wb6jMViHc6lVqsZIeHw8FDPnz+Xx+PR4uKiqdvHYjGjK/MuOBMEKNdZ195pXvrh4aEePHigGzduaHFx0T4AjZJw+NmQDz74QLOzs/rmm29szPHw8LAddKLB1dVV+Xw+3blzR4ODgyYZTx8IOH6pVFI0GrXilM/ns8bN+fl5M6C8/Bs3bujy8tJgMebCHxwcaH19XSMjI/rn//yfK5PJaHd3V7lcTh6PR8W/G0cai8UMJ6UQ3M3i8hUKBT169KhDRM5tUnNnQdBNOzo6qsePH+vFixfG7JFe49mS7DLSfT44OGj9NO5hOzg4UCQS0fT0tD0XTLTx8XEzfGgXjYyMqNFoGAaLrlMul9PW1pYGBgb0+7//+xoaGtL6+rp2d3eNftxutzU7O2uUW3cm0NuuVCqlRuNKqvzp06eamJjQ4OCgent7rfkumUxaRhGJRBQMXs1uHx4e1vPnz7W8vKx2u62RkRHrqXAZiPTIUGPhjEIZ39/f18HBgYLBoIkocv5DoZCNIICgMTw8rPv37+vs7MxUDDiH29vbevDggfr7+/UP/+E/NIVpoB0yaYyG1+u1huNuF9lBLpfT119/bSQMMhXgFjrhibIzmYyRZJj3DsstGo0ajZs+i0QiYY75TYHOSqWivb09GxBIwEZQlU6nO6jvo6Oj+v73v2/7jwTN5eWVvtnjx4+VTCb1k5/8xCJ7er6YnklwSI2h2z3Eaa2trWl1ddUCE7JhSebQaHxkpEYmk9GXX36pFy9eqFarWW2IgBclaKDQYDCo0dFRffDBBwbLsy9ogI2MjFg9hcbsTCajSqVi8GIikdD09LQ5F7QaLy4ujHY8ODioP/iDP9DIyIiVBRCx5J1Rq4LAcJ311mOOiU7/bek5Htyl6L2pKfXbClNvGh23aO0W4NyiNobV/V38P6ASFxN1+wRIX3Fwrr6U+7veJVJ883lciua/jXVGQe/NfeA53mwE/W17437fm1/32/aKv3f3h8PkFrrf3D+iSLfDm79zz4Dbjf0uBWl3/1zY8P+LKPDm+XPPD0Vp92zy+Tg7LpToFnJd+vebe8j+Sa+L//xx9xf41SUGuOu37eO7rDehm992Bl0o9s279ts+n7uH7md1yRHufrh3iq9hT/l/b+4p0bx7h91iP2f1zTv+5l151/XbbMdv+/kuSckt8v+2+/jm9wEJ8kxvEnf4OheO4zNJ6vj/LtmA8+d+PZ+fmgo28M276n7Nm2fg/3O/2t/l7r9f79f79X69X++XpO47st6v9+v9er/er/fr37LeO5f36/16v96v9+s7X++dy/v1fr1f79f79Z2v987l/Xq/3q/36/36ztd75/J+vV/v1/v1fn3n671zeb/er/fr/Xq/vvP13rm8X+/X+/V+vV/f+XrvXN6v9+v9er/er+98vXcu79f79X69X+/Xd77eO5f36/16v96v9+s7X++dy/v1fr1f79f79Z2v987l/Xq/3q/36/36zte1VZH/i//iv7DhM5FIRDs7O/rqq6/U09Oj3//939fs7Kyp/bojUH/+85/r6dOnHaOEkWFHLtpV8GWKW39/v8bGxlStVvXLX/5Sh4eHNqSnt7fXpv2h4ukqNfMzw+GwwuGwDUW6uLjQ9va2Tk5O1N/fb7M+UqlUx1S4cDhsszlevnypfD6veDyuVColj8ej//g//o/feqP/o//oP7J5FdFoVNvb2/ryyy8VCAT0x3/8x1paWlKlUrGBPgzcevnypXZ2dmxoEnO3GYnLjA8GfLkjjHt7e1WpVPTgwQPl83mbeeGOOk6n0zapjiFjJycnqtfr9nMikYiGhoZUq9X0f/6f/6eeP3+uqakp3bhxQ319fRoZGVFvb6+y2awKhYLJfHu9XpPod8dM/yf/yX/y1vv3n//n/7kkmbpsoVDQy5cvFQwG9ZOf/ERTU1MmBS/JZuK8fPlS29vbNseip6dHs7OzSiQSdn6YPcK/M7AuHA6rXC7r5z//ubLZrOLxuGKxmAKBgOLxeIeqNGq20mu1XwbSMQfn4uJCm5ubOj4+Vjwet4FbyNOjwMysmVarpf39fZ2entqsIUn6T//T//St90+S/tk/+2cm1d7f36/9/X09evRIvb29+sM//EPNz8+rr6/PpOCZT5/P51UsFrW/v68nT57I4/Hoxo0bSqVSdsd6e3sVi8Xk8Xi0v7+v4+NjjY6OamlpSWdnZ/p//p//R3t7e6YmHI1GNTExoWAwqKGhIZv5wzvM5XKq1+u6c+eOlpaWbB7Q+fm5Hj58qL29PZszw+92pe+ZV99qtVQoFGwkBWOt/+v/+r9+6/37L//L/1Ltdts+4/HxsVZXVxWJRPQf/Af/ge7evau9vT1tbW3ZAESPx6Pl5WVtb2/bTCufz6e5uTklEgkbjfHmDJ96vW6D/LADxWLRzgGzYhiZcXl5aaPHG42GTaW8deuWFhcXbYBetVrVr3/9a21ubmpqakq3b982W+Lz+UxynzvEkDh3XLUk/Wf/2X/29+7XtZ0Lk80k2QjX3/md37EJaowX5aV/8sknNjaWiYX5fF4ej8dmsTP/IRAIaGBgwCbVNZtNm23RbDZtTCqXliltrpQ+Y0Zd6Wim5Llz4aenpzU9Pa1qtaqTkxM1m01tbm5KkkZGRjQwMKDz83Pt7OyoXq9rb2/Phmcxc6KbFQ6HTf660WjYiNbe3l5zWtlsVsvLy0qn0/rss88UjUY1MjKivb09G+LEDA3mZDCSOBKJyOPx2HhSBjb5fD719/ebs5FkkyHdf+/r61M8Hu+Q/N7f39fJyYni8bjOzs7k8/mUyWRsL5mqub+/L+lqoFw4HNbl5aXW19dtVPDZ2Zni8bgSicRbSXa/uQgYGDMbi8Xk8/mUTCbl8Xh0eHio9fV1pdNpff7554rFYgqHwxocHNTJyYl2d3clvR6VjOS8z+f7jemJ7ANTP5kSyBAyppIy4TQcDtvz4XT29/e1tbVlw7K8Xq/Gx8c1OjqqSqViEwUZVT04OGhTLXd3d1Wv17W9va1isWjjg99Fdp9pnoFAQB6PR8lk0qZHEoQdHBzo8PBQ4XBYs7Oz6u/vVzAYtMF9R0dH8nq9Gh0dVSqVUq1WU7VaVbvdNmPH1Nbd3V2bGhsKhTQ2NmYBHEbx4uJC9Xrd5ugwOZVxy7u7u9rf37dR6h6Px5xyuVy2u0tQMDk5qUwmo7OzMzOwzHcKBoM2QbKbhYA8vysYDGp4eFh9fX2KRqM2B+Xg4EDJZFKLi4tmtAcHB7W/v29S+PF43MZtE5Dzc6UrG1ur1bS+vi7palheJBIx++jxeHR+fm7jx8/Pz+1eejweG0ufzWa1urqqcDisoaEh+Xw+jY6OKp1Oq91u2wRPRiYzLOzi4sLsI9Ncmax63TN4befC3AlJZrAmJydts1qtlo6OjrSysqKJiQklEgkNDw8rEAhobGxM+/v7evbsmS4vLxUIBOT1em04EfOoe3t7dX5+Lo/HY5fP6/UqnU7bDHhmpJdKJftMXq/XvDZZU09Pj4rFojY2NpRIJBQKhdTX12dR0vr6unZ2dmwyHoOiiBROT09tquXp6aldgm4XRomhYNFoVKOjoxYFS9LR0ZGeP3+u+fl5TU9Pa3x8XPF4XKOjo7Z/rVbLjBzGPRQKmcNmWBJRB0OmGHNM9HZycmIGFMfCwWSuRKFQsBnzGKB0Oq2JiQmdnJwom82qWq1qd3dXtVpNN2/eVH9/v6rVqrLZrGq1mo6Ojmzv3LGu3S4yuEQioaGhIRvi5vF4dHx8rFevXqnVaml0dFSjo6PyeDyKRCLKZrMW4TGojbkbZNA9PT02UAlnzjuLRqM2/OrNsc9nZ2caHBw058I9yefz2t/fVzKZ1MLCgkKhkIaGhhQKhbS+vm4ZFeO8w+GwRkZGbPZ8tVrVzs6Ojo+PlUqlOu5gt3uHEWMWPKPFmYq4s7Ojhw8fKpPJ6NatWxocHFQgENDZ2Zk5Pa/Xq4GBAaVSKctq3DkiTEw8Pz9XoVCQ3+/X0NCQDY1jhC7BI8PvotGohoaGbBKoJO3s7Gh/f1/9/f26c+eOQqGQYrGY4vG41tfXtb+/b+OMvV6vUqmUTV3d2dmxwVlnZ2dKpVIaHBzs2kG/OQspGo2ajcM5M2ytt7e3YzpmOp1WOBzWycmJLi8vFYlE1Nvb2zGmm3PJHJeTkxPt7e2pp6dHExMTisViducZmUxGx5BBBo3xezc3N/XVV19paGhI9+/ftz0Oh8Pa3d3V6uqqKpWKBdNLS0uamZnR6emp/T+yvXQ6bWfnOuvazoWpdKenp2q1WgqHw7YhjGd1PduzZ8+0u7tr3piMxY10fD6fzQhnlrx74RlbS0rnDt9hSqALB/X19cnr9ers7Mw8fDgcVk9Pj8ElhUJBlUrFLgWjO/1+v5LJpMLhcMdBcp/zXUakVioVSa+H+TDbm88pXUE+iURCkvTo0SNtb29bmkrmQMRXr9ftAPt8PnMIrrEl4nCHD3E4hoaGOoYT8RmazaaN9W2320okEgoEAuZguQzFYtGmdeLcksmkwW65XE6Xl5cdGdO7ZH6Mzy4UCmo0GpbKA+fx38lkUq1WSw8ePND6+rqNxm232wqHwzbbvFqtKhqNmuPl/EmvM5loNGqjp4EJ+ftIJGL7hqHm3eF4yLT8fr+q1arBXj09PTo6OtLJyYmkq4yit7dX4XBYfX19NuJauopY+Wdvb+87ZS7VatUgaDIs3g2DpZjC2Ww2tbKyomw2awamWCxakHR0dKSzszP19fVpbm7OkANG+GIT3M+ME5Bkd5izdH5+rng8bvevXC4bWhKNRtXT02NnkKyGyYxkOr9t2JXX67UJqAS13e4h2T7wUKvVskmm7jRTxnw/efLEoEJgWsaFM1EzGo0qnU53ZA+cq2AwqJGREQtYarWaTdPEHjGZ1h0WBrLDIqC+uLiQJAve8/m8CoWCOTuPx2OwPfYSW8w7e5v9u7a1ZGOBYZLJpCRZug4+WC6XVS6X9b/8L/+Lms2mfvCDH+jmzZtWr6lWq1pbW9Pp6ammpqY0NjZmk92Iai4vLxUMBm20MhEyly8UCllaB6aPY2s0Gtra2jJ8fWBgwD4343lbrZay2ay2t7cVDof14YcfKpVKaWJiQul0WtLryXkYSyKFblcul5MkcxDBYNCyBrDrWCymiYkJnZ+f63/8H/9HNZtNjY2N2WfCCZ+cnKhWq2lubk6zs7Oq1WoqFApmAGOxmNrttuHM7Glvb69httFoVO12W9vb2zo6OjLnU6vVtLW1pdPTUyWTSfs8QEr1el2JREKHh4fa2dmxzJTRybOzs9ra2tLy8rIuLi4UCARsPLR74LvZP7ITIsH5+XmFw2GFQiGrC01NTen09FT/7X/736rZbOr+/fuan59Xu91WOp3W+fm5VlZWVCwWtbCwoMHBQcOVmaRIFhOJRAzi4dxT88Po44SGh4c1NjZmWHypVJLf77fzRxaEQwcyi0QimpyctBpgKpUyR+/xeAwqo/71Luvk5MTqk2Tq4XBYgUDAgr1QKKT+/n5dXFzoL//yLw2WBrICQVhfX9fZ2Zl++tOf6kc/+pGq1ao2NzdVqVQsu+SfzWbTsgcMUzAY7DCq+Xxew8PDNop5f39fpVLJoCc3axobG1MymVSpVNL+/r7B3Tgh9g4nwMjrUCj0Wyc7Xnft7e1Jkr0LshXOhMfjsWxif39fm5ub8nq9unXrlqamplSr1RSPxxUIBLS1taVKpaKpqSktLi6qXC7r1atXqtVqhtDE43HNzc3p8vJSu7u7KpVKVhNzHRb3lyC42WxqY2NDFxcXCoVCWlpa0uXlpZ1BRiDncjltb28rFAppYWFB8XhcExMTGhkZ6ZgcijMLBoO/MVX4/2td+7SSurvjMzGURL/AU+fn56pUKlZEZcP4fiJNClNuMZTLJ8kOCmkohVb3gPCi+cPFbLfbFtWy8O7NZtMuCxcHHJrPwX/zu/lc3Q7uBO4LBoP2HMBb7CGXnfnl9XrdcGm3IM4+8nzu2FN3L98c2Ut0zM9yDembY6iBFon6cBB8PTPA3Xfpng2+nminVqtZobCbRWrujnbls1A/8fl8CofDuri4MGiL84fxBCvnvXMZJVkWScbF3gKH9fb2WuGfkcvupXtzuREun5PR0IFAQJFIxIw7joPn5OtdI/IusKwky7IwXuwftUqv12vBAFh7rVazv+vt7bV6EntAZkpWAqnHrWexyIwCgYD9TvdnMMrbHbXMOZReR84QMQjMcCBAw679AHpyn73bxbtxMz/X6XMPe3t7rTDfbrd1fn7+GzaQM+XuPZkt7wd0g/3gGd4cl8xzctbcP24gy8/HLgAxhkIhC9zJ/rBF3Bf+PwjWddZbZS4ej0cTExMaGhrSwMCApqam5PV6VSwWdXh4KJ/Pp+HhYTsA1WpVx8fH2tnZ6WCSLS0t2Uvh8mDggCF4gRT78eSxWKwDIwyFQhoYGFAgELCXR1GKA0A05r6U8/NzS6l58YeHhyoWiwoEAhofH7dI/vLyUmdnZ8rlcr917vh1Vjablc/n0/z8vMbHxzU0NKSbN2/K5/NZfScWi+nmzZsGPVarVQWDQTvUGMOhoSFJsgzF5/MpFosZy2Z/f7+j5oXzGh8f19jYmM7OzrS3t6eLiwslEgmDMDCqCwsLHQYiFotpZmZGPT09Bh1y+S8uLrS7u6uLiwuLoFqtlpaWljqM6fr6ujY2NrrePyCdRCKhdDqtsbExzc/Py+/3K5/P6/DwUF6vVzMzMwqHw1pbW7P3nMvlDBcPhUK6f/++GbRgMGgw2eXlpUqlksrlsuLxuAYHB9XT06PJyUldXl4qkUgokUioUqloa2vLIEFqGfv7+/Z8ZNhAJslk0uqMGA6gOODFw8NDe07qRQQzKysrWl5e7nr/pNfBBg6UiJVzxd1pt9sqlUqWrUejUfX19VkwGAgEdOPGDXk8HqVSKR0eHqpSqahQKOj09FT7+/s6PDy0wrvH4zEHOj09rampKRWLRb169Urn5+caHBzU4OCg/H6/stmsOd9EImGfLRqNanp6uiPb+tGPfqSf/vSnqtVqVryH4SdJo6Ojarfbdgc2Njb04sWLrvcQxlQqldLw8LCSyaTGx8fNjrXbbaVSKS0tLRnZAFi2UChYxuj3+3X37l319vYqnU6rWCyqXC6rVqupVqsZKw5orNVqmQ0IBoNWcM9ms2o0Gkqn05bx8eypVMoCef5MTU0ZfImD9vv99vlAPrBFn332mQU4kvTq1Ss9evTo2vv3VjUXl5oKXi1dpVknJydKJBKKx+OqVCoWxV5cXKhYLHZERul0WpFIpIOBxdfjofGwXq9XfX19arfbhmtTg6nVakaFlF5nJlAQ+Xl9fX1Kp9MdUQKRYLVaNRjt7OxMlUpFqVTKCtxQmCUZzNTNOjs7sxcaj8fNQHq9XlWrVVUqFfX29trvTSQSHRENl9/n81n03Nvba8/sMsHAxl3mkiRzOMfHx8YSIYPj4FMU9fv9VtyORCIaHR01CAiD2dfXp9PTU4Ppzs/PrR43MDDQUR+C5tjt/hE4YFwoRns8Hu3t7en09NSM//n5uYLBoBU+gWqAL4aHh80ZQ//kApFtEwXjuCUZkQA6KsYsFAqp0WgY9u1Cn0B2GE9+H7WNcrmshw8fGksNsgfFU/cc5/P5d4q8pdcOhowsmUxaZEvtAlYa9UaiWjdjTiaTdnaoCZItlstlg7Rg21E3SKVSmpycVE9Pj549e6aLiwsLWKrVqkqlkmUsGD/OPOQCMp6hoSFNTEyoVCrp22+/Ndi1VqtZrcbr9VqGfXBwoHK53PUeuvYklUoZQcDn85lzIFDr6ekxdiyBIj/DJTjA+nLhMIIdzrB0FRBwtoLBoJ2/RqNhsDpOyuv1GgGF9+3aQJik3KFKpaJHjx7p9PTUbGMoFLJ6D4Hm+vq6Dg8PzdH9fevazuWTTz6xf8/n88Z9JpKBhQEjh8wBnJMo1mUjXVxcGOurXq+r3W4b64sUGb79+fm5hoeHOzaeiCYajer09FSHh4cKBoOam5tTNBpVoVCw/oK1tTU7aHhuvPTx8bEqlYoVswKBgEUcGMd4PK6bN292DYvdu3fPHGWhULBnp8+BvhoOH4eAy4UxwglfXl5axE4tQLqK1sC7Yeesr69blgZkRCQ1MDCgaDSqYrGo4+NjhUIh4+AfHx+rWCyqVqtpY2PDagA4GJzLzs6OisWixsbG7MKUSqUOivjw8LBu3brVddR4584dSTIntbe3p1/96ldG5BgeHpbP57MzBnWW9wk0J105ekkqlUo6PT01BmKr1VJ/f7/S6bRlHeDnZ2dndv6gtQLDhcNhHR8f6+TkRKFQSLdu3VIikdDJyYnR2FdWViTJYNHe3l5jJWazWR0fH1vNLxQKWSQMnNHf36+PPvronTKXW7duSZKxtSqVir744guFQiEtLi6qv7/faMFuD5kLu4RCIctsqJeUSiVj19VqNY2OjmpsbEzRaFQDAwOq1+t69eqVOXlqZ9xNKOVAuzgSyAM4c2jH/f39BtlIV1ltoVAwhwYU5hb1/X6/4vG4xsbGut7D+fl5SbJs2bU5s7OzGhwc1OnpqUG0kuwzSK9hOvbS3QdYnJBFaFGg/vXq1SsdHR0ZOYWAFFuKIwamnZ6etvoYaNDW1paazaZisZj6+voUi8V0dnamcrmsra0tFYtFC6yBRF1yRF9fn+7cuWOw49+3ru1cPvvsMzWbTT19+lSrq6vy+/3GP//00081PDxsl7XZbBr9l0PAgZZkbBi41ESXXq9X8/PzGhkZ0fn5ubFD1tfXrV+CByOyBCo7OjrSzs6OUqmUfvzjH2t8fFwvXrywKGpvb0/NZlPpdFrRaNQIABjaUqlk2RgRJnhpvV634na3xcAf/vCHarVa2tnZUTab1c7Ojr7++mtFo1H90R/9kaanp1WpVFQul+X3+9XX1yfpNRTmNoUR4R4dHSmfz1uU0dfXZwaK/T4+PlYul9Pe3p71GjWbTctE6Vc4Ozsz6HNyclJjY2PKZrPK5/Pa3t7W119/rYuLC83MzFjvQ19fn4rFovVi9Pf3WxQPPRUa88jIiMF43ayPP/7YepKy2ayKxaJevnypSCSin/zkJxobG1OlUlGpVJJ0ZYD6+vqswY93CfQFDJXNZjvo61NTU+boIZhsbW0pl8sZm0eSPX80GlUoFNLR0ZEKhYIGBwd19+5dzczM6Ntvv9XTp091cnKizc1NXV5eWtYEc5LGupOTE4Na3FomMNrAwID1LnS77t+/r1arpYODAxUKBeVyOX355ZfWA5HJZFSr1Qz+ItvAYJG51ut1HR4eqlQqGVOQjNnj8ej27dsaHx+37KNYLOrXv/61dnZ2DGKGbo0DxaGR8U1PTyuVSqnRaBhF+sGDB6rVakbEAAYC+oRuTI0GB4Phpbm3W+dy8+ZNtVot7e7u6uDgwMge8Xhc09PTGhkZkcfjUbVa/a2Fb7IFtyG2UCjo+fPn6u3t1cDAQEdzZCqV0sDAgE5OTnRwcKCNjQ3LGsiUySzcmnQsFtPCwoKGh4d1cXFhAeYvfvELVSoVCxDj8bjBwJCsms2m1W5AC8gWI5GIPv7442vv17WdC6kRkTbRANFdpVLR6empjo+P7RKTrQArkY5R7HIbM91CvsuZh/1EVH90dGRsMdI+ItJQKKRAIGD1FDKrSCSi4eFhiw5oXqPJU5JRd0ulknWqS7J0F3igW+dCcQ9KNpkIRubk5MQK0NBWccCk20RybiMVGZzbfdzT02MNqjhGUvpcLmdMHb73TaICMAcHLRKJKJPJGD25WCwqFosZ5ZkisPRaYYHiPcoHZGTdLqBSDFyj0bDfS72nXC7r9PTUeiyAZPgcBCQ4Di4lmDZ7RP2JbJrmUumKgsv+UeSkcEpdgl4HsoBoNKpMJmOG8ujoyFhDrmGAwkpmA+OP2iJ9XN2ui4sLe1bqGvSFnJ+fm8MoFos6OzuzvWC/iMYpWnPfcCJvRutuX1UsFjOGZzablSRjd5GR8zO4/9T16I2bnJy0u358fGwqHXT2QzPns/L91C+AfbtdLpuQbFi6sjvlctkUKo6Pjw0pcBeQFmQaMg6yuWq1ajAsMDhECTJAsiZqUiAcfD72i73gzNErA8Hl9PRUPT09Rgfn2bi7/LckSwqAeL/zgn4+n5d0FRFSUOYAFItF5fN55fN5OzhEIcAC6XRak5OTBpkcHx8b7gszRXqNLeJYIpGI7ty5o3q9rpWVFT18+FATExP66KOPFIvFtL+/r0KhYGSDnp4e7ezsGN0uEoloZGREY2Njqtfr+p//5/9Zjx8/1vT0tFFNSSePjo6sXoFBJmPKZDIdB+pt18bGhiQpHo9rfHxc0WhUg4ODkq6il4ODA3vJwDSXl5d2UAcGBuzFXlxcGN7v1qBIgX0+nyqVikGBH3/8sUKhkP7iL/5C//f//X9rfn5eP/nJT9Tf369KpWKOHsr11taWyuWyFbwnJyc1Nzeni4sL/dmf/ZlevHhhET5UUfj8h4eHFlG2Wi3l83n5/X6j2na7f8fHx0ZnHxgYsIt7eXmpvb09ra2tWYDD5aK3BdLH1NSUPB6PTk5OjDQB/5/zzTkk0JCku3fvyuv16vHjx3rw4IGmpqb08ccf2/k7OTlRb2+vpqam5Pf7tby8rLW1NQuMRkdH9fnnn6tWq+l/+p/+Jz18+FDj4+MKBAKq1+vmNOgdgdVHD8jFxYXGxsY0MzPTUUN727W9vW3QKEHH1NSUpCvCyebmpgU41FzcZt1kMmkQ1sDAgPUUQYoh20fKxCXNLC4uan5+Xl999ZX+9m//VhMTE/rDP/xD+xlQXqENX15e6uLiwloIUqmU/uW//Jeq1+v61//6X+vRo0caGxtTIBCwehW9ZDTsYrRdNYpuM2dJFiQHg0HLMgiq1tbWDPoDMiSYxOBTq8Ihnp+fG4X/9PRUa2trajQaWlpasvYDzv3nn3+udrutv/mbv9HPf/5zzczM6E/+5E+USqWMEETgUK1Wrc+MoCyRSOjf+/f+PV1cXOhf/at/pQcPHqjZbBoVnyy1UqlYUAmZ4OjoSOfn5xoZGdHExMR3T0UGf0NSQ5Jh3BSSqtWqLi4uOqIYIgZJhiUXi0VrMnM7msl0gALc5kUemCiEyImDDCboFpHBzeHnE3nTFCe97oYlo+KzEnkTEfHPbo0jVGSaRiORiPr7+9VsNnVwcGCkB7exks9DMyTZnMuw6+vrs2Yy9+u57KTJRMpEr+FwWNFo1JwSURTOyyUgBINB61GiduHSRDmERFr8fi4YEey7LKjwwDDsBQw5V6LHzezAsTkf4NyuVhIQFDAUf3DU6In5/VfyMPQMETFyZoAyKW5DcOH8udRUvocsgP25uLjooNMTSLgNiN0ufj8/C/Zfq3Ul3XR8fGzvjujazUCazWYHYsEZdWmz7D3nj6zfraugn0fPBuSc39be4AZMyWTS9o07/CZ1mT98Low7f/8umQtoDNk6mmbNZtP6cmq1mjkh7o/bugHl2j1ffX19ZrMo7LufmfdEpo4jQQIJlME9Hy56IF3Z6kQiYY3Q3M832xp4TkmW4bqfy81o/r51bedSKBQkySJmGBOSzIBMTEzogw8+UL1eN1gAowxbgaK/m0IDKdTrdb18+VLPnz/X8PCwdf5ySIj2EomE0fUoxkejUaNR4oD4naenp/rf/rf/zfpFPvnkE2UyGdM68vl8HS+iWq2ahtLi4qIVuFAW6Ga5zA0iay45L29iYkIzMzM6OTnR119/rVKppEQiodHRUQ0MDGh8fNyYILVazSiGp6enhjl//fXXevjwoWKxmEZGRtTT02Nd/tPT0/oX/+JfKBwOG8PPNXRQR/mswWBQ0WhU+Xxef/M3f2MqAffu3VMmk9Ho6Khh526vDWfC7/dramrKCsWnp6dd7x/ZKQV1pGg4Q+1222jyFxcX2tnZsYvk8Vx1HlMzo96EEQJaIDteW1uzTMelyBO1gVVXq1UdHBwon88b7CPJIniy00KhoP/hf/gfDO68e/euJicndePGDdMlcxUYkCzxer366KOPbP+44N0uzjhBm8sE4uePjY2Z9h6NkkBW8XhcMzMz8vv9VozHEeJQEYfd2NhQPB7X8PBwR9vB5OSkfvjDHyoajWpvb0/5fN6MGFCxJGNpItl0cnKi/+a/+W8sS6E2m06ndXFxYfp4yWTSiCxknvRv4BC6Xbu7uxbgUIMKh8MW1BHdo6X4+PFjlctlxWIxRaNRJRIJs1H0AWL7oHx7vV7t7e2pUChoaGhIc3NzBi1fXl5qcnJSv/d7v6dEImEQ8O7urk5OTtTX16dMJmOEhnq9rkgkor6+Ph0eHuov/uIvTMbn7t27Gh8fN7ibe4VDLJVK2t3dVbvdNj1BWKLXXW/d5+JyrrlMeNjBwUHdvn1bZ2dnevnypWHgYOVAJ7wQ93uJhDY2NpTNZnX79m3bWAzS4OCg0U+5qGRMsMbcvhWovYeHh/ryyy9VrVb14YcfWkc0/TNEiFzuw8NDHRwcyOfzaXx8XNPT09ra2tLKykrXxUAXS+ZCu/gouPT8/Lz29vb0i1/8QuVyWaOjo8pkMurv7zcYrbe31yJ5onOgtO3tbZ2enur27dtaWlpST0+PRaTDw8NaWFiwPg33Z4C/4rD4f8Fg0FhF1WpV3/ve9zQ9PW3c+nK5bNGU1MmOgTAwPj6u3d1dbWxsdB19c/4whGScLo19YGBAH374oRXs+efl5aUVraUr6jw1FZw00iW7u7vK5/O6c+eOKcZSnxkYGDCJF0gVsMSAECV1yHckEgltb2/rr/7qr1Qul/XJJ59oZmZGExMTmpiY6IjEMcLZbLajL2phYUGbm5t6+fLlO7HF2De3aRMHSxCYTqd179495XI5bW5u6uLiwphxKGCDJLwJ0QHzHR4e6ujoSNPT05qcnOwIrIaGhiyDRnqEM5FKpQz6xdBBvNnZ2dH/8X/8H6pUKvrss880PT2t/v5+YwMi4zMwMKD+/n6TJ6LPhYAYWnk3K5/PW6GdZ0eTDQQlmUzq9u3b2t/f18OHD42ohPAkNkq6ygxwUiAsEHUINm7cuNHRpAqFudlsWgaYy+V0dHSksbExC4iwC+zhq1ev9L/+r/+rKpWKfvKTn1jBn8AFp+3aKBcWHh8ff2uVkms7l/n5ebVaLasPNBoNYzVw8C4vL41mS6oLDp7L5bS+vm79E0ifQLsDF02n0/J6vcY8on4AHZgsAnHGoaEho2/iqHBG9Ni0Wi1lMhk1m00NDQ1ZiknkRQEVvZ92u21ZwtnZmTY3N1UqlQwq6GbNzMwYU2d7e1uDg4MWpXFRiYQPDw8NF8/lcibZjgHiM9Dp7PVeybvDzIOlB6RSKBR0fn6uRCKhkZER20/3oJBB4Wg55DityclJNRoNU1SFOEFfBnAndNC5uTn5/X6VSiW9fPlS9Xrd4LNuFjRQmkQvLy+N/k7gIl1JnJTL5Y6eC6LCp0+fqqenx7B5jA2ZLu9fkunNuX0ISKRT/OY8cVYJvggezs7ObA+p+Y2NjdmoB/piYLS5BpGsnf0rFosdmmPdrLm5OTWbTW1vb2tvb6+DvUehGpkQDA3kkIuLCx0cHGh5eVk+n8/aEYaHh02xnDpRPB63GgpnhFoqiMf5+bmy2awFgZAjcHpuQyHOEFRkbGzMFICBKYmsyZw8Ho8RCCqViorFotXXuiVF3Lt3z+qI+/v7qtVqBo0SNEPThoTD/aHJEzj++PjYAptwOGw9e8B6OEQII2SKg4ODGh0dtTphvV7X9PS0xsbGLLhhr4GAscXz8/N2h7Hd1Ic4g6enpzo9PZXP59PS0pI9+9HRkQVy113Xdi6ff/656vW6/vf//X/X8+fPNTIyYsVSol646LBeLi4ulMvlTPKa/hQu4+DgoDVBUUCmJ2J0dNSEA2nmm5yc1AcffKCTkxM9e/bMNjaRSJhKgCuRUSqV7DDdv39fPp/PHBHy2C5+WigUlM1mlUqldP/+fbXbbT179kzLy8uW0na7Pv30U9Xrdf13/91/p7/8y7/U7OysMcBggRwfH+vZs2dmIKvVqhnmeDyukZERYyphGDkkc3NzarVaSqVSOj4+th6U8/NzK3bfvHlTt27dMkl+alDtdtvojlB1W62WHbLe3l59/PHH6u3tNRG8crlsktxE9FCdZ2dn9dlnn8nj8ejP//zPtbq6agXpbjHvH/3oR2o0GvrTP/1TPXnyRFNTUxoeHjYGC3XAvb09Y2u5AqXQ5MPhsDKZjKLRqDXBVatV9fb2GoWUZlMEHBn/gFIwme3l5aUWFxdN0h+6O7UCFKEbjYbu3bsnn89nVG6gr0AgoKGhIWu629zc1OjoqD777DNJ0q9+9St99dVXCofDb8XU+W3rs88+U61W08rKir744guDEAmaMM77+/sWyASDQVOuoAvfRQ5+/OMf69NPP7W+MpwDTC6gUGp9H3/8se7fv69SqaTV1VXV63XrtSoUCqb2UCqVTMgWI/5Hf/RH8vl8hkzQruDz+Uwh++HDh3r+/LnGxsb0gx/8QJL013/919rY2HhnVeQ/+qM/Ur1e17/6V/9Ky8vLSqVSuri4MLsF5JXL5YzE1NfXp6OjI+3u7nZ0xycSCctsYd8CSyOwirIxen8nJycGKx4fH+vhw4eq1+vKZDJKJpM6ODjQ2tpaRy2KYL+np0c/+tGPrH4TCoVsLEFvb68RlhgZMDg4qJ/+9KeSpIcPH2ptbU3xeNzGW1xnXdu5UEBz9XEo3Lu6UnhNojeXfucW7l1IiNoMlDk6+d2iHtEPRShkJfiZ8L7dWoZbNHVTePB2MHk450BCrsYRvxuo412oyK5Cr/u5oARDKqBeAU2Yoh7kBmoM7md0i9gcYH4PBg8GT6PRMOyZn+/2gfB9bpZxeXnZodsEK4Uoi31z4T++711rBW/un9vY5Z6FN4u67CMBEM/kFqg5q1CoIUCgqebCZ5xBSYZr8z6g47tkAIIGzjCLLmhXKdk9D9wlzjCf67so6APx8btcOI+iM+edc0D/BHfIvd+gE0TH0P/p7gdCczM69hCb4J5pfjefh9/BneW+83cI1NK0zc9zfybv0WVwdbPcdwtNm/oLkjRA1hCSyMZclQL3c7n0aT4jkkKgMe6+uS0b3GGXOOBqmEkye+gSG9g/bCZ3QZLtn0vldu/L25Airu1c/vv//r+XJCv6ZTIZjY+PG7efFBUoAirczMyMbRTQBY4KlpQbxczNzWlsbEwez5W8Oj0gZ2dn2t3dtQE76AYdHh5qf39fOzs7lrIT0WKQq9WqdbLfv39fwWBQxWJRu7u7Bi1ROCRl39jYsEOCvDrKxt2sP/3TP7W+haWlJdNYguFGsZqDMDIyYhLk9BaxL2hR0QtRLBb19OlTXVxcaGBgwPBnjAby5Gtra/qzP/szUz9lCBh7/OzZM0nSwMCAQZIUmFdWVgyayGQypqgaCAQ0OjpqUdjExIT6+vpMR4yoE3ip28yF8wcxgTqU22uBlLmrHLGwsGDaWCh5MygOA0UUeHFxoRs3bhg9F8IDpBEmDPJzpSt4AxLAt99+K0nWQ4QRgmZKg6DP5zPqL4EXmcni4qLq9bq++eYbo+PCtHL7wrpZ//pf/2u1Wldd9Tdv3tT4+LgNrHONGw7VxfnHxsYUDodtQibR+eHhof78z//cGhmbzaYmJydtMBUN1Lu7uxYpP3jwwLKiQCBgYxTy+XzHvBhgtaOjIx0eHurly5fyer2anJxUIpFQPp/X2tqatTNEIpGOyapMVIXlmkgkTJaom/Wnf/qnajabyufzVmz/8Y9/bPRpn8+n/f19bW9vm7NttVp2P6BaN5tNHR0dmbLAo0ePzL61Wi3dvXvXJqsC1XJGisWinj17Zs8EXZ1GaTT1sAGcuUqlotXVVXm9Xt25c0cjIyM6ODjQy5cvzT5jb+bn53V+fm5nEEVwSR2O6+9b13Yur169ksfjMQiEDk8uN1652WxaCtxqtUyKH0aOGyXCqS+VSh2y0eDg4OWwGRggBjPH4/Fod3dXx8fHyufzOjg46CjusQm8ROoafAbqA27EwLQ3YD0yszepfW+7mChH4xo9A6gUY8SRhEGjKJVKGYQzNjZm+4q8iiSDMmBR0eVNxISTQExveHjYeoL4GXSLs/9kc1C3c7mcfD6fXexyuWw9QQiHUvugVkCkz8F8Fyo35y+dTtv5g5bsZmromBGFMwoX+jcZA4FQT0+PXc5a7WrgWSqVUrVaNVgRemmpVLIxzqOjo/L5fEbhzefz2tvbs2gWumcwGDRJeTBu+jdOT0+tJ4j6BrI74Ok4M0nvnLmsrKwYJRtCCyOqKQ6jEkHE2mq1DIINh8M2dRZqPY6a55CkqakpYz6hdkEmUalUlM1mbTAaTM1SqfQb8LhbN8TJcCdg2B0fH5sGF1lqMpk0eRuaLpFeIdDpZq2trVl2Re1ofHzcmh55vy7S0Ww27U5iwBuNhjXHQkFGV43a1fDwsMHjoAbUiVHlAKKiP4/+LRwKpBz6auj9g8EJfIzSAAgEvXME92RdZDLfuXP53d/9XbVaV3NQjo6OjB/vai+xmeVy2Qp+1WpV29vb9jLA7UdGRnR4eGgFazfd83g8JhPRaDQ6RvYi5EazJrMzQqGQzXRfXFxUNBrV1taWRULT09NGJnj58qWOj4+NOrm1tWWRB/AJHf0UxKDmdrs+/PBDNZtN7ezsKJfLKR6PWyd0Npu1OkhfX5/h8e6FSqfTHbISkUjECpWQFrh4KDoDU42MjNhlJxJfXV01w8q7+/TTT9XT02Nqyjs7O9rb21MgENBHH31kh4zZEuDh+/v76unpsYJlPB7X0NCQms2mTd4jQ+h2/d7v/V7H+aMLu9VqdVBmueAoDON46SsC9kKwjyZIyB3AUGhlueePIKNUKmlra0uSrIm3r69Pn3zyiXp7ezU9Pa2+vj7lcjnLdm/dumX7l81mdXp6arAtM+ddhYDx8XFrYHPnoLzLYq4N95QGQ4/nSvwT5yCpY2wGGSd9EojPDg8Pm+wNsCrPwF7xnChlYOSAfAhEqI2OjIzYxE4K3dCMCRgrlYplBwi8co6pY4bDYY2OjqpevxpVThZYLpe73svvf//7ajavBByZvooUEZkIenzn5+dGs4a8gJOhrjwxMWH6gC7khB0CzYCwwPwYMl5IUATYgUBAN2/eNFWInp4eY+41Gg1rPi4Wi1pZWdHx8bEFZczFAsmRpIWFBTUaDROGdUsN11nXdi6///u/r0ajoT/7sz/T2tqayUM0Gg2tr69b1uDCUMwiuby8tHG9/f39Wlxc1MTEhGq1mtEdXUwauKJSqajdblskiHEEp2y32zaGOJFIaHJyUtFoVEtLS1YgzOVySqfTJm+/sbGhzc3NDrYUURgR8MDAgG7evClJBvOBT3d7MO/fv2/9P2RfqLh++eWX2t/f1+TkpGZmZmxMMJkdNOJaraZIJKKZmRlzTgjocTD7+/s1Pj5uzxcIBDQyMmK/m/4j0lsgH4rwNExyYY+PjzU5Oanvfe97CgQC+uabb7Szs2P4LZAH9Q2KlcPDw/J4PBY8INHSLdvpD//wD9VoNPR//V//l7a3t60/qd1u22Wn4Agsi+OWrhSNM5mMEomEvv/972toaEgvXrzQ7u6uqRS4TaA4FxhOBDfg4+gw5XI5lUolDQ0N6fbt29ZxHQqF9Jd/+Zd68uSJ0um07t69q0AgYDRjAqdGo6GdnZ2OOtro6Kju378vr9drGdSbdcNu1sLCgt0Z2JZo+718+VL5fN4QCTfyZ4wuximRSGhqakqDg4N2f9kzoECibAIfIGocLrJRwOnNZrODSAGUVCwW7VzBpsIRhkIhJf5uIi1BDCQj+rCazaYePXpkzoXn7mb9zu/8jtFxGVlB8PDkyRMjaADn5fP5jq9ByBNZ/vHxcT1+/Fh7e3tmtKHYY+AJvLmTh4eH2t7etr2RpK2tLR0dHWlpaUm3b982CE6SoUI9PVcj3Nvtto6PjzsGn7XbbWu9oC8mnU6b0Cz6hKBH113Xdi6oF0uvRSNpAqKfBAdA3wqOQZLROMEJkV9HpHFwcNBSQqAccGYEK0nJ/H6/jUDGOLqdxBhWlFDRBKNhiYMGXAOMQnEc40EtBC7723C8/237B1uDojF7A10WmI50FpguFovZi8eoSq8HMPX395uDZA8wYBgJInn2HDychW4bEI0kS6/5ukAgYNpesM3Ye0lG6QUGkmQNsmDQ3SyouC7pg/MQiUSUSqU62HdAsCjQJpNJG/UArCO9Vo3AGXJuOWfAaLCpgOEYN0G/iyvOShTOeWMP2U/eHXCsC03Cgjo5OTEoAkP8LudPuqoh8ewu+QMoD9WGeDyucrlssA330h1bAPxNFg1rsNlsdtCXcTjAYjwj2Xhvb68x+0ArYJdRhHZJDpwnFowyMnXeQV9fn/b39yVd3RHYa8Bk3SzXBlILdftdGLtNDQhoERVizmk0Gu14Vjd4YZ+4qy6tnawN9hdUZcREgdYJHLFrBM0Ex8xwIovlrLLfZK2Hh4e25+FwuEO/8Drr2s7l6dOnlhahwItHHB4etuiYiIesZXBwUPF4XIlEwuaXQK1jKA11CAwXnpfmoe3tbZVKJY2NjWl0dNSid3otODDgndlsVn19fQaR0YjZarU0MjKiTCZjmDcHgMJ4uVy2pkOc09DQkLLZrPb397uOvJeXlyVdGZc7d+4onU5bM9bt27etuM+hxSEmEgk7lMzBgG0kyQwnNRTGD0ALrtVqRonlT29vryYnJxUOh5XP5w3r/uqrrxQIBGx8ME110FFRR4D6XSgUOjBY+ksQQOzp6TFNsbOzM6Mud7O+/fZbtVot63iGpBAIBDQ7O6uJiQk7/IFAwBQcUMHu7++3DvtKpaK9vT0rtrqyHEixEMVVq1Wtrq6qXC4rnU6rv79fIyMjWlpaMmdDvwZQq+u8OacUytPptEFBR0dHHUwcvr9QKOjhw4fGgkqn08rlcuYcul2PHj2SJNMM83g81pR8dnamWCxmtZj9/X19++23KhQKGh8ft+bEsbEx9fb2GhHE7/drYmJCFxdXc1nIHk5PT1UoFGyAGqMGMI6jo6P6/ve/r0gkoq+//lobGxsG2cLAIoMiiofQwGwconhJNqYjn88bVMeQuGg0qrm5OZ2cnJiaRDfr+fPnZuxHRkaUSqUsGJucnDSdrmazqUKhoNXVVV1eXiqTydgQO+48mmn8PQEdjnRnZ8dqcrVazcYZUBMLBoOampoyMgHPtbKyYn8HWQiIjH/OzMxY4zOyUTiyQqFgNZzt7W1TaR4bG9Pp6anVxq+z3ipzYUG742XjDMg4iBj5WuQPyGIo0EsyKiTNlHTzunRWoiDgHKIZt2BNkV6SzTmgQU163VgUjUbNg7vSF0RcpInUNyhQu5pH3SzScXoymNXi9XptX5BXwGjSeEjE+CYVGWwWthuHk9oB++xSvd3sDxiT5jmKo2DvRM1EfO122ww7LBIXznQpjIwOgFzwrjUD8GUiPSiunDUooDDuqI8hi8+eE2TAIiITdFl7LPf8uVTbVqtlVHH2kQyHfeG8UcuD2ovjIRN2teN4F9Lr4XKRSKQjon0XbSyIA2hUufeMgjfnDYMuvVaUhjJPrYsskq8luoU2zDO6pA73DAIh8dwU7qXXigV8L/cUpIQ+Lkkdhpl3BkEF20KG9i5NqG/aQFdKxqX2N5vNjvvKZ+AeS+ooBRDYBINBe7+w9VwbBSRLVsQZpMbE2AzOItkemQvvOxwO21BH3gm/kz2EpowNdMdTf+fOBZhjfHzc8H8anThAUBXxrsAJRNIHBwcm0cClDwQCdhCazaZJQLCJHo/HRBcxAKVSSd988418Pp/BV6gA8FkDgYDpDBEN+nw+ffDBBxoeHlaj0dDg4KDhp+fn5xofHzctLopsRFrRaFSffvpp10Zyf39fXq9XExMTBmERyUN5RUOMjInfBUOEZj9UlVEnYOzz5eWlZmdnlU6njZnl8/nMuQMthsNhbWxsyO/3WyH06OhI+/v7picGI2t6etqgycvLS01PT9s0S/b24ODAurVDoZDpEkG5LJVK8vv9VsfqZkFsGBkZMcFPjAuXk7oeJAeM6cXFhWmpsR9kHTTU0hQJdEszKY4eaKO3t1flcllffPGFwTDQU+kMh6Ld39+vZDJpuLvP5zMxS6ZT0vl+cXFhE0BLpZK9T6j68Xhc3//+99/JueD8BwYGNDo6qp6eHsssDg4ObBoq2er09LRN3ySYzOfzNs0TaIUGaajInHFmrVCnIQj1+Xw6Pj7WX/zFXxjMNjIyYgoWtVpNL1++NLgXHa1cLmc2aGJiwowkjly6kohC+gclB0g5ZLndroODA3m9Xk1NTWl0dLSDfs3vpykSBKFSqSgYDJq6OVL32DnXiUCuIBsBokIainNbKpXUbDb15MkTC0gZ71woFOzM8/+Hhobsnvp8PmUyGcu6OP84dZqds9msHj16ZHVfSh9IKF3rvF33C5kzgcHBaFBcp+jEsB4KUBcXF1aUZoIfhxV89+TkRFtbWx3drm6EA12XaIuucyh3dLGiVYQhmpubM+ofzgXWCxEsdLzLy0v19/crlUrZLHCYMq3W1YTChYWFrouqMDOQCZdkES6XUJKprAJLUTSnGIm+E+ybYDCoXC6np0+fWg9IJBKxTIlIhQgVXPVN53l8fGyzSk5OTtRut5VIJDQ0NKRSqWSOkNk49Cicnp6aXD0FWYq2PFu73bY+nW6NI1pLsVhMs7OzOjo60vr6uskIBQIBDQwMmHN2nSlRGAZmfn7eMki3V+Di4sJqh61Wy/qxyCaIfqkptVotm/rJ7Phms2mR4s2bN60OwfkjmybrRiqe3o5UKmUz6N1saGho6J3OnyTLwGkPoLZDn1O1WtXAwIBJwSBRxL1pNpvGzKTWB/x9dnbWwVrkjoMmADni4Mrlsh4/fqyenh7du3dP4+PjBkfz3NSCRkdHjRnp1hjJYKgrXl5emrPa29szGSWc3+joqHXyd7MITkKhkMbHx3VwcKDNzU3VajV7NqBggkBKBGQJZDLM0aHO22w2LRinpk1TpCQ742SE7XZbW1tbCgQCdueRnuHs9vT0aHZ21koWDPDDgbnZN3uChiHZkot6QLT4zpsogXEwSBScXKOezWat0QyvuLe3Z8UoUkXmA1Bj4IJdXl4aMwsKKEqfXESXFw5+32pdzeW4ceOGORw2gMmL6XTamClooxExYCjf1L5ys5RSqWSR6e/8zu9cd9tsjY6Oyu/3K5VKKRaLWYf7xcWVgq+rIg0WHovFdHBwoKOjIwUCAYMOGchGXYn/Jm3GIQIXgbWWy2XrHaJegpEbHBzU4OCgXQqkT+jP4d3hlNzepGQyaXPQ3S5gdw9dPbhulgvHuPNnWq2Wtre37b1ubm4adJJOp1UoFOxSAaeBZWMoOc8YKcgAiFROTExYr4D73prNpv3MVCqljz76SNLrznNox/wsv9+vcrms7e1t+3s0uFzHxbO5MG2j0bDIudtFXYKAjN9DvfH4+Nj2mD+BQMAgQQaWSTKKNO0G3EkcNQEbNQb0wMh0qM3yPuLxuHp7e43RBowTiUSMmOL+bhir9Ia4jYySDFIEjpOuoDKXaPK2i3dGJg9j0ePxWPZ+cHCgV69eGfyJfSOwpghPAOt2xxMMAmtzP30+nzl6l0XGrJehoSGjKy8tLdl+AHeDzBBk5vN5vXjxwmyFJBPWRB+N/avX60bmcHtlrrOu7VyI6EgzSfnOzs6MM41hGR8f1z/7Z/9MqVTK+hJisZiGhobUbrdNDh2cF4ND0xVFvGg0qlgsZrLjz54907Nnz0zrCQ0dopu5uTkzpj6fT1988YW+/vprJRIJzc3NKRAIWPMfL7yvr09LS0uWKZAtvCljQk+OJP37//6/f+0NZt26dUter9dkwtG6qlQqevLkidbX17WysqLl5WWNj4/r3/13/10rnB8dHVnzoMfj0c7OjgndMc+BiAVIksJqIBDQ+Pi4IpGIVldX7d0xMhUII5PJaGFhwfbd6/XqwYMHevz4sfr7+3Xr1i0FAgFtbm5qeXnZ8N1EIqHPPvvMlGhpwHOZg5LMCHW7ML6uzArBzuPHj7W9vW2R2MTEhP74j/9Y/f39Ngo6Ho8rk8lIkuktuZ8Rp07WxhC0cDispaUlJRIJvXr1yoq0FLQxaBMTE7ZHaHX9/Oc/15dffmnnD/26vb09y5zj8bju3LmjeDxu59pt3oXAcX5+rpcvX3a9f9JVVApRAQUBnAmd5blcTmtra4rFYlb4LRQKyufzltkD/dFc6rLY/H5/x+C1sbEx9fX16datW9Ybxxlkr/P5vGkOLiwsdNiFjY0NbW9vG7JAr9jOzo5NTI3FYvrwww87gpve3l7T/iLy5sx2W3ch86PATuf8xcWFXrx40fGZJicn9S/+xb/Q4OCgstmsTk5OjNHYbrdtMBt1UzQDgR8JEKl3TU1NKZVKWd9ZNpvV8vKyaYul02kNDg7q5s2bltn5/X797Gc/0y9/+Uub3ks7BpqFwLH/4B/8A6XTaQtSge4oVQBNMtTwOuvazgUtJVI1CsVEP2wK2QDFOTbITb3e1AXj+3Eu1Aow7q7+GB6dJiMolOhwUeySZAeNbCYYDBoVkv4VSeZQzs7OjPHkau1A2XN1wd52MaiKyAec1lUGIOOCigkN1P07CBQcSj4nUjBEPpI6Il9gRuk1RAGNMZFIdEA1OFRScGpffH4MMmeAKJfeELq9XWYYrKhulxuVvklSAGrgM0qyM8Pz4njcvWL/yWrcc+ieP94/FG8ies4fZArOn0vLBtp12Y+wsyqVijlMsnZqa7xL3smbRrybReQqqUOhF9qqq2rhLtQ1oGa7BXSe06W84hBxkHx+RobzbFCKycBhdfL37v7zOfh77gg2h0X9ACTEzcJY3WbPMMOwgdgit8cLggMkDorkUNj5/UBc3CkcF3/4eWS1blEfMgBkCDILsmtsAJ8Vaj133i3gc644q8Cb2EZ3r/gM17WB13YuAwMDkmRdwy4tbWpqymjB4NovX7601JsZEBy2yclJw6lPT0+t+E4kyqZzCb/66itJMpqc3+/X8PCwenp6rDGuWCxqeXnZqHcUq0nl+/v7Tb+JZsCnT5+qUqloaGhI5+fnevbsmV69emV1BV6uJBN17HYx+wYlV1LSnp4eff/739dHH31kxsTj8ejhw4dGRf7000+NedPT06O7d+8qGo1aNuX2GZHKwu1vtVod9Q/kHejkvXnzpjKZjBk2fgaHkOwHpg400O3tbRUKBdXrdWuYffz4sV69emXnBIPl9j10u9D7giQACaHZbNoIXUnGjqFu0W63rfiLTAfjljl/RM0uQwooqlwu6/nz5/L5fNrd3dXu7q78fr/NKRkdHVUymVSpVLJ3RiBQLBYNbgBymJiYUDAYtL06PT3V8PCwyuWyvv76az179sw02qgpEB2XSqV3YjtNT08bBPbixQtzyqjiUq9w9dqkK1hwbm7O6O29vb26d++eBgcHlcvllM1m7Q5jXGEYkmV++eWXVv84Pz9XMBjURx99pFAopKWlJQ0PD6tQKJiGnastxjnC4A4MDCgcDmt9fd0aCXlfL168sPdFMCHJWJmMh+hmoSfHnWLAFggAmQdGnECLUe0EqH6/39REgKphLPr9V6OxXUHMZrOpvb09bW1taXt7W7u7uwoGg7p165b6+vr00UcfaXp6WhsbG/rmm2/k9XqVyWSM+ZlMJk2hgjPV09OjlZUVK1EgN/To0SPTcCML/21s3eusazsXd1YB0QHQAoV5orFms2kvHZYNHhp6aiKRMJgNYcaenh5Ly4i2KdDTBFitVi3SoUMXKQ+gISCTer1uESMUy3g8bt9LEyDpKbz5gYEBpdPpDt65i093s0KhkPVpAFsRBaK9RnTMdLlGo2Ey4a5EBgJ8dL1zcdxshghIUgeN1qVyBoNBDQ0NaXh42Jg6rgSFm3USoXHgyRSogXg8HpNMh11FJEf01G2Pi3RVL4B5yDlAlsdtjiTbctUdoCET6RFguDpRGAYyWy4UTbXt9tVYgkqlYo4KSaNEImE6V+yR1+s1eBd4CwMM64fPSAZzeHhokvvj4+MdGRfU+Xfpc4G8UCgUdHJyYnsCJRs6NFkiRphxugQ4MDiR+IGIMzg4aOfPjeipdVD74rnoQUqn00omkwYTk9WQBXIH2UsYWUzrJAOFebm3t6dgMGhS9qAhZJrdOhfm1OA03EwWujtno16vq1AomERNMpk0HTZ+FnU4MgscOmeFAJteNchHhULBIEpGgSSTSevUl2TsWmrXbuAACQUCCo279A5tbm4qEoloZGRE0mt69duevWs7F6AQDIjbxUxW4mpvuXUU0m6MFNGt6+U5QEQ7bKTH4+kYBOSqBPT29urg4EB7e3vyeDymxwRtNp1Oa2xszDrsy+WysTbOz881MTFhfSHUcCQZ281lyrjT57pZpJ7ZbFa7u7tXm/93+0YxE4HKQCBgz46ECeKHHEZ6Jdy9Bqri+SigU9B/syMc/Jp+gPn5edVqNW1vbxs7i/3jZ0ivZ8a7sBsHD8MAo439c/shulnUCI6OjkzXi/PH4WfxGXhWMjnOUDab7Qg8cKREltDsob66w8AwAolEQr29vTo8PLRZHVNTU0YfrtfrSqfTNnYWI0EN8uzszOi5XG7gNj6X2ztBE+O7LAwJApyBQEBnZ2eSZF37MD4lGeyDMa1UKuboVlZWbFomzhNmHs2g3GG61GOxmIrFohWyYUQ9ffrUsuTZ2Vnrk6KmMTQ0ZEV0aPk4c/q50Gs7Pz+3JmQXDZGuaMpTU1MdRf63WQRTKILT4+SyVglicWoERFDWgWufPn1q55SGac6pS0FHMolMxu1N4+c/efLEmrRv3rxpHf3Uo6APsxecNdAISFoEZ8FgULFYTMPDwxaQYU8nJyev7ZyvvcscBFJXePoYSOAc/psLRdTMIazValpdXdXp6ammpqZsgJTrXMrlsg4PD7W+vq5AIKBbt24pEomYg3OZZ2tra8rn85qYmNDt27d1eXlpcvk4F2jQDAgjY5mYmLBaASwdXgJyK0Q90Wj0rQblvLlc57K2tmZYKS+OugvRDIwl0m7qGRxur9drWYcky6jA7xk8BfTlTkqUZIcKna5bt27p3r17BgMdHBwok8kYpOlGfFAhOeBSp2IvwoMYTqjIAwMDXe8f9YqjoyO9evVK4XDYfh6OAePPeQQb5xLx7ysrKyqVSpqYmNDMzMxvOBdom1tbW9bZjMEggkZ5G3HU2dlZ3bt3r0Ohwj1/TCeEvl+pVOxd41wkdahTYLhwLsB53S6CCyBFoBu3hoLKNU6CvSDwol61srKidrutyclJM9g4L0gUp6enymazCgaDun37tqnt5vN5y9pbrZaWl5e1s7OjTz75RPfu3VOj0dDDhw91cnKiTCajoaEhIw9xBo6Pj825tNttZbNZQz7IzEFDyEaHhoa0uLjYdZDokntevnypcDhsGa/LOOWuUFehhMDfX15e2giCubk5LS4uSpJl+MBPZBGBwJUgZeLvxpC7NRmccy6X0507d/SjH/1I9Xpdjx8/Vrlc1tDQkCYnJ3V+fm6sXlefkWeizkwNmD46N5tPp9NvtX/Xdi7FYtGolxMTEwoEAh3G0aXaSZ2jNt/sIkeXqd1u2wFh4yjmxeNxzczMmBEmSgByoAOViIpeG2Al/r/bx0GK7cJ0UCjpNsaJIZmSSCSMrvoukvtEBrFYTFNTUwb7YeSBXlzygwtNAOW1Wi0rZMLccxtSYWRxsYDMpKtMg4ieP/QAwFRC+rxUKimVStkhZP5JPB639zw1NWURmovFAktRzOR98TO6WZw/RAmZjeF2ftMJTc+AC6ngvDlrGOnj42ODfXAykqw+gsGFQQhcAXxDwyYkBs4TfTUQMzh/OA1qZNwR+mmod0HrJYiChfcuC/kiGunION2iMjUel8RANuXCnO7zumwvDB9nDmdM7Y53BO3fhSDZt1qtZqMM3G5yxClpACST4zl4FtAIRC/57GdnZyYSev/+/bfeP2rM4XDYghJ+NrAl++uec4KFUChkdwo9REkmlQRNmf13IT32k3EJnHMK/G6pgiCGc8mIB9oyqGclk0nLFF04HRv75vDAcrmsvb09eb1e3b179+/dr2s7F4o8Y2Nj+vDDD+3C0A3LCM6RkRHVajXt7u6afAlsBqhtPp9PZ2dnyuVyev78uYm5gZv7/X7Nzs5qdnbWilnlctl47tQHkIM+Ojoy8Ue6ocEeqRPRo3L37l3rOeHSUsxCprvZbOrp06cKBAL68MMP1dvbq93dXW1tbanZbOqP//iPr7tttlzpf8aUrq+v6+LiomNuA8KLroMBn56ZmVG73db29rbK5bL29/e1ubmpkZERLS4uKh6PGyQxMzOj2dlZ1et1LS8v6+TkxKAC5tucn59rf39fR0dH6uvr0/j4uM18yWazNuANiW7panQAg+I+//xzVSoVPXz40PoapCtHurGxoUAgYPTLcrlscGA3i3kuw8PDWlhYsAzXhQBSqZSmpqZUqVS0tram8/NzO1dEYpyvcrmsg4MDPXv2TP39/VZj48yMj48bkQLlZJc4sbOzo3q9rrW1Ne3u7ioajVpdDOgLKKNYLGp9fV3tdlu3b9/W4OCgMpmMwuGwKpWKHj9+bD03IyMj8nq9FokzLoF30mq19Cd/8idd7eHf/M3fyOfz6e7du/rwww9NIt6tkaRSKcXj8Y7aKmrmnB86+lHv/vbbb5VIJPTBBx8YzIMjYUAgsBDEICSEXBg8n89rY2NDlUpF3377rfVUhUIhFQoFPX/+XNLVyPCBgQFNTk4qEomoXC7rm2++sT4dgqxcLie/36+FhQWl02nt7e3p+fPnarfb+qf/9J++9f49efLEmrN/8IMf2BnCORIg0gTOQh9wYGBAMzMzajSuBv3lcjmdn59rdXVViURCt27dsrqNK4tVq9WM/EE9GHirXq+bAsrx8bGpqW9sbOjo6MhqQLlcTo8ePVKz2dQPf/hDpdNp3bhxQ5988okpngCPAyeyf8D229vb9g7+4A/+4O/dr2s7F7SOwK6BISiKuvUQ8DwUeIkuiaTdIjFQBQVuSZbtoFUkqYPi6Ubv4MIupAGzwaUkk9a7TX5uvcilTsJVh+4KBQ915m4W0CD4LJAHn4ln4Q8ijODuaPzQHMnsDPbPpU4TLUajUYPjIF9Q92A/2XciR6Jtvs+lRpOyQwyg6MpzEDW6jY4w1ohQu11kqm5nM4QQ9sp9N2/SpCEy4Fzc8+dqOHE+iOL5ue4eu7RkIAMyPJeiz8+RXtPd+R3QU4HsyB4gdmA4+Gzvev4kGSuJPhDqHkT8kuxd8q6hnlJoJmLu7e01tIDz4qoZ8CwEjG8aX7ILNzImoiebdhma7B0ZP0EqbCpqA9goziDvmbPyLntI0yeMSmB093zz2fjnmwgOxX7ICTTvupk/KA0EJLJY2KLsMRJZ/A76Y3gXfB4yO94Xv8/r9XbowWE7OCPY70gkIukqQEBx4zrr2s4Fo/fq1SttbW1ZxAFOKMkkXEhricD9/ivlVOYJMDBLknWiszkc9FwuZ8N2GDxGCujSDBHE9Hq9vzGnZWxsTB999JHhy0QzuVxOqVTKIlkKq3Ses/mSjKpKo1y3C3zzyZMnevbsmdVQXIPGbIxqtWqyEiMjIzZZD4waDSEiTZ/Pp5WVFWNGUWhG7fiLL75QPp83eRT3gkLb7unpsdG1XNbR0VHduXPH9g+Yi4yVYiNwHxpmUHjJuJDwoVDczUI0kHGtpP6k9FCngTP39/dVr9dtdsj09LRGR0fVaFypbKOzNDo6qmg02jHsjroW0ihbW1vGDnKhVUkaGhoyCfO1tTUzEkAn3/ve94wKjjI0HemMDKbPaGtry0gn+Xzefg8MNOjW3S76XHZ2dozAAtwGlAOsWiwWdXh42CH1zryhy8tLnZycWNTe399v6g0Ea5wX+scePHigQqGgZDKpVColr9drhr6392qAINFyvV63Rt6ZmRndunXLFL6r1ar29va0t7enVCrV0ZKQyWT05MkTG0qHscR5p1KpdzqDaH+trq7aVFwkiFyHWa9fjSrATsLMa7fbunXrlp3jQqFghBufz2fNlkNDQ5Y9co+/+uorHRwcGArU19dn+m6JRMLeIfsH7DU4OGjkGggPSHcBOUqypmG3CZtmSpilOPPrrms7Fzwg43/xgNAYe3p6bNxpo9EwfJSF92u1rjp0Dw4OlEwm1d/fb5Go6+XRrCKacdVjwazBdrkYTFwjokgmkyZ1fXh4aEXa4+Njk7PgAqPRRaRLlEpDljszpZvF/h0dHVln8uXlpWWCfr9fhULBMGcgEPoj2Gv3M2HEgFF8vqsJhr29vSYeWSqVtLKyYobiTVzVVbp1Nc58vit9KPofqCHQaEqBkH2hSZVJmgQBnAEgpW73j88FY4jgxs1muMgUoamjUecjEKJLfnh4WKOjo8bld0kBQG21Wk17e3tmdCnUSq+zSYyKK+fe29trMEhvb6+2trZULBaVzWZt+JZrBDAM4OjMc6lUKmZAMMrdLrJgpOcxhDwL5yLxd2OsCU6AeeiTYH+Qx3d1rSTZmSK7LJVKevXqlXZ3dzU/P281T0kWHAA3wiTjZwAh9vT02NTHFy9eKJ/PK51OW1307t27ikQi2tzctOclG+SdUpt8lzNI4As9eHNzs6MOhC2izotDpL8K+8YdBkaUXus3UmcDjTk5OdHGxoYNxIO+PTIyYhkO75EBd36/3+bz4HwGBwdNlBdBzUgkYgon1HzIwM/OzqxXkZ/pKkH/fevazgWxRxc+otAOxopRpmBIwaunp0fpdNoK0m+yeaAxSp3d+xS7gTfIgoBxSEebzaa9FKJ36Spy2d7etv4E1EVhk9An4abRpKxjY2OWKtJD8y5NlBTpKNiyfD6fjQFwef2Tk5Py+/0aHR21meGoUJOqUrQj6uDyEO2S9n766acGUSGMCeSAAeX52+22xsbGDL5ALZcolKgJOIrIVJJJl3i93o7GWeRpoBB3s6i3cfY4Q+7+AQP4fD5NT093dEbTxIoeFIoSFI15LxhZagZ8fa1WM1IFEJjbNU2Eh4HmUq6urnYEDVxmMm+yAAI32E6Li4sGPULcoHes20X07CpncIcJEAkkKNp6PB4NDAwYRRmIlSAOY8rzU3x2qbKBQEB37tzR9PS0ZQ+cQe4u7w2bgUJ0o9HQs2fPrL+mr69PMzMzZqihKOdyORWLRcs4qVfxM5CkeZc1MjLS0Y8Sj8c1NzdnewsMSJ1pcHBQkkxNG/khAkUgSXf4F7Co2yFP0yqzqTijnD1sBu/P5/OZ/IvP59P+/n4H6Qm1eAJ2HAlDErEpOPV6vW7aaf+/TKIE0kKfK5lManp62iTaEVTM5/OKRCI2cAppaTqMSSFxKOCYwGG8CHo+JJmRR6785OREz58/N5iBiw8LZXBw0ArjfB00Xpycq8clyeCmarWqdDptCrQHBwfGCELssZtFDxCHBwad63jRW0okErp3757i8bjJs+dyOb18+dIOYjKZ1MnJiQ4PD3+joYqGw5OTE8Xjcf3oRz9Sf3+/HSQMPbAEuH61WlUoFNKNGzesaRaox23gZP8Y9Xt8fGzcfCi2MMnQkdrd3dX29nbXjZT9/f3m3Gq1mmKxmMbGxjqa/k5OTlQoFBSPx3X79m1Fo1FzttDbcc7BYNAuSzKZtCgQI+Fiz8jBDw4OamBgwM4fpIpisWiFcNhsNOk+ePBA1WrV+j2GhoasFobgI4SSfD6vSqWigYEB3b17V36/X/v7+yqXyzo6OtLh4eE71Vyof1EnQuUW4kUoFLI9TKfT+vzzz5VKpcy5MDaD7JGAo9lsmoOm/wyH0Whczdb58Y9/bHsCu4nnBorkn319fVpYWFAkEtH29rb+9m//1nqnEn83zjwYDJrOXaNxNWqdYDKbzWpkZMQYXQcHB4ZcQGDoZs3NzVkwxRgOtNBYGH/YlGQmBCpkBThk4CecErUslE4gRP3e7/2eYrGYlQYKhYK++eYbg7F7enosaAaSjUQi2t/f18rKSscd5gzSrwNd2uv1qlAoKJvNamJiwmjHKysryufzdja+85qL26HJpXPpklA03YZIn89nRSZohsABZDBAUhT7gdXIXiQZfOQWVGGyEIHBzeZzUMfgM5MKU4ymYY2vc18QxTaogK5mULeL5kbpdbGUTIWD5vYMkc4TmVHgZHocNRjmrnDAiQbd0dBIzXDZKQ6fnZ0ZNEaKzHvgc7EHOEe3+A1nn/cCLIaBIQqlhkOxtZsF1AmsQHRHZuzy/zl/0usxuDCS6LuiiOlqg7mQAGeK7Brjx9mB/ACsA3SFo3PpsRTE36Sdo9dHoAXlF8KH+zycwXelI7sNt26Bm71gSBcFcFfXD6ILThEHxfRYGixdA8p7IMvhvNC7xTkmWySLgkjiLvaUZkNJRtHlv8keoFSTWfGz3qQJv83inOMQgAeBR98U4X2TyMIzkyVQwwQNINgslUoW6AFJugrG3CMCFGwU7DzOLWffrTuxr7xzWi+wm8jE0HLAe3GVTq57Bq/tXCjA88uKxaI1+Ny6dcsar7hADKECX3Y3CBrs8PCw5ubmjLPu8Xi0vr6ubDarSCRiUAa1gsHBQZvtjDIvmj5jY2NaWlpSo9HQ5uam8vm8FZipa9RqtY7BVlNTU/aS3EOAsabfpre3t6PTtZsFDRcjc3FxodPT0w4JG14itRn2DscCbLKxsaFyuazFxUX97u/+bscFevHihQqFgsLhsBKJhGq1mr788ksrqiPR//z5czUaDc3Pz2tmZkYTExO6ceOGKpWKfvGLX2h/f7+jiRIY6eHDh9rb29Pk5KSWlpYkyZxdT0+Pda7TdcxhBCrp1jhCLWf/Dg4OjC7+0UcfaXh42LJiSdbEx5Aw6TXLEOx+aWlJN2/eNNy63W5rdXVV2WzWZtO0WleqFBiDnp4e7e3tmS7dyMiIneOPPvpIl5eXWltbsyIuUjP0shwfH6tSqdhQJgw0Q8mQEWGfMJYua6fbRYCIw0PtIBqNamxszMgXBH5IxzP8CgSAYnSlUtHU1JQ++OADc7j1et1GSAwMDJie2cuXL63OGQqFdHx8rFevXpn2YCKRUDqdtmFejNr1eDwGR+Ho9vf3LXOYn5+3QLfZbGpubs6GnQHDu02O71LQZ8w0MjXU/cLhsH73d39X4+Pj5jyq1arW1tY6HJskIzLs7Ozo8PBQ8/PzWlxctDIDaMHm5qbR42mvgCI/MTGhUqlkLRqZTEaRSESjo6P6+OOP1Wg09PLlS52enpodrdVqZpshjcTjcd2/f78jmw0EAh3q8sDk9Bq9jb7dtZ0LKZWLJxcKBesVoc5B0ZQPe3JyYqwoUjNwQjSoiGpJOWlW4jJB16NABSQDK4zUMR6PGwWW+QUYIyIoZFGAonj5YMWksHh6CpMU2LpdFITJUGCLEQFKsvoPNED2jyIncAIwndfrNQNIjwVd0TRaQY64vLy0Dmn6kqAjAkEysIkDSDZHZM7vPzo6sg586XVUymF0G0CJZkn734XKLb1W52a6ZE9Pj3VuE6W5lOmjoyObAsm5pWbAzBf3e5DZkV7rmUFQIOvB0Z+dnWlkZER9fX02f55aINIl7AWOFYOEKgNGWXo9JhgH6dYnXVXod12cM3okcDhk59CUKdDzuWnGA324vHytC0hm02q1DK4mwAByxqAR0FFDBPLs7e21MwpzEcfgUmhLpZIVpDHIZEOwH9l36bUEFdl0t4uMk8yMQDcajRp5xKWesx/YPjIMHBCkF0ghrkjk6elph8QTagn0GVH7wgaSeaJzh53AqZI9u6gJOnfSVYDYaDSsn4nFOeVevw2h5NrOBYYHsBEMBDYSh9BqtUzUECZRJpMxeiWXFBgHI3d6etrRucofv9+v8fFxk2ThwtNIB354fn6u58+fm7xBu902vB9JDvcyNJtNKzADufh8PpPY4FK4fTPvouo7OjoqSXaB6/W6hoaG5PP5VCqV9PLlS4MhXF2koaEhm8QHJp9MJiVdvXjGwjJ1r1QqmUFyazoQL4CtYNbhYLPZrP76r//aHLcka4zkIPP5xsbGdHFxoV/96lcdzD2X0QYbjtk57zLLhX2j5kN0T0aAVAY1JZ4xFAqZPAnGjz9ExblczrIZGjPf7DshuxkaGtLg4KDq9bomJiZ0dnamgYEBC3geP36sev1KsBBWHRAEFGXYbdQJcEQ4coIFDCmfF2jqXRakCPcONBpXKr2lUskkQ6DfU7tMJBKKxWLmZOl3wTGura2pVquZSnaj0bBsi6+fmpqyACSRSCiXy9nPo0mz3W5rfX1djUbD3osbcAHVxmIxpdNpVatVUwGGkAHcAySLE3yz566bBVNqaGhIQ0NDVp+F6QdEhaNI/N00TuqmBM6S7HOUy2XLSgh6EEAlOCMI8vuv1OBpGL9165aq1aoGBwcVjUZVrVb1i1/8QvV63ewB1HxUMyTZ3chmszbuHDkj9luSwc/VatWCV/rdrrPeyrmwwUSzRBT1et2cBJ6OFH9sbExjY2NGK6b2ggeEnfDixQtdXFzYDHP3hdKL4NYlZmZmVK/XrYhfqVR0cHBglDlJNjvbxcthTF1cXE2AZBN9Pp/NpCc65ZLz32dnZ9fe2DcXGmA4ZzK8er2ubDarbDbbgatj+OnIRRcIlgp7ncvlLM2u1Wq/gdGjOoAxxuFw+FzngoAgRgz9JsQzPR6PyaMfHBzoxYsXCoVCWlxctKzENQaXl5dWCHzbqOfNBc7MiN5YLGYNdCgOEF0DYQaDQY2Pj2toaMggskqlYnPMJZlC8JMnT1StVo0QwXMEg0EtLi4qmUxax329fjUE6+zszKK/arWq5eVlc8StVsvEB3FUBC/xeFy1Wq2DNgvDbnBw0J4Ho0imwM/tdoEExGIxC9ygua+vr2t7e9ucGSQHOryBk+iC52ddXFxoY2PDqLkU5JGPx6hPTk4qHo9bP1Q8Htf+/r7Ozs7MYJZKJRtiB5Tu9oFBKMK4P3/+XI8fP1Zvb6+N+uV8u9pbnGl+TreLmgo1HVcrDh0wl1SDusL09LSN/yZIcJuNCYzITmgzcJvJp6amTMCXnrylpSW7w4HA1QCxZ8+eWaAClMiANBq5Occ7Ozt69OiRgsGgbty4YWK9JAfU3bDZ2MLrrreaRAmX/fj4WLFYzGRUSLO43Ijfwchh1DHw0sjIiF1CIlqmzHHQiE6AA1wKJCklD06UR9rLwYaVAzuKrMpVm6Vzm2IuEvYYaAy9C7l0s4CQ6A+IRqMmhQGThD4fIL5gMGhNY2Refr9fY2NjGhgYsBTc7/cbnAChAmadW2CmbkBx383M2u22FUeBtIhgDg8PtbOzY4YcfBtcm0yBGhF1Ahceg4nV7QLiQ+MtHA5reHjYCsiQPM7Ozqze1NfX1+F4oaOn02kLMBjIxqhYmiLj8bgGBwfN+br7RITO+XMNAVi1JMuoYZURTLiFcrfPiXfMO5VeK/HyO97FQQPrAllzzzDAqVTK+ltisZjNAaGxjn32+6/GYqdSqQ4CROLvxkJj4LnD9MAxuTQejxtTjOwW4++SS9xmX9fh4gAhisCSot+D/pFYLNYBeUJO6XZx992ZNASNQIMuWwymInUqase9vb2am5vT4OCgvU+yOppq2+22BgYGzGHibN0+LBwb9H9XNw/dR0l2b3AysDwvLy+NAEA/HShSX1+f3QnEbaXXduw669o7PTk5qUajoZ2dHT158kQfffSRvv/971vfBLh/sVg04yZJz58/17fffmtzBMLhsI11/fbbb/XgwQP5/X4tLi4qFAppfHzcmrWIhknJ9vf3rbkQQwz33zUGIyMj1rXv9/u1vLysr7/+uqNpiUiIoj3R/MbGhgm6SeqA6t4Fr02lUrq8vNTW1pZWVla0sLBg+5BMJk2D6uTkxAqPHo9Hz5490+bmpuHL4XBYn332mRKJhFZXV/Xq1SsTxOMzAh9lMhlLbXHK/EHehQ5tYBDmcmDw/H6/nj59ql//+temDICzAp9Np9MKh8M6OjrS/v6+0um0RkdHrbMc2GJwcLBrpk4mk9Hl5aWePHmi1dVV3b9/Xz/+8Y8tCqc2QiMakfXTp0+NeAJVFoXZp0+f6tGjR+rt7bXBVZOTkxoYGDBYEdUGOtYPDw8tYoWVhyGYmJhQKBSy/aPe9/z5cyOguEEDEvbJZFKBQEC7u7vKZrNGRfZ4PKY0AEzS7f5JMliXICAYDGp0dNRGfXu9XuVyOe3t7amvr09jY2Py+Xz69a9/rRcvXigWi1mNaWFhQdFoVGtra3YGR0dHra7VarVM8+78/Fw///nPlc1mlUqllEwmDYJ0I/ZMJqP5+XkFg50jf1FVIEigs71Wq5kBxxBvbm5ag+z09LQ5J5pBsQvdrmazaT01S0tL+gf/4B9YFo0NyWaz6u3tNZ24b775RisrK4rH4xodHVUkEtE//sf/WLFYTN9++62+/vprBQIBm+s0MDBg5xqnkc1mLVBxERQXThsZGbEm1ZGREQta6/W6NjY29PTpU7v/BNnT09MKh8MaHx9XKBSyDHZ6etrIGJxd5nZd9wxe27lwWTAskjoohJI6sE3+HxfRpehROIfnTecnhX1ePoUrV/kT3BBD76bMbuMlBTb3ULhfCyxAeupSJPl7vo809l2iHmiRrnYTv4ceHRyAS9kl4sYB0OsRi8WMSg2dlUyLKJf35OpTuVpkPC+Noy505WZoLlWaPeEdk6K7Olj8fvf7eVfdXmyKm6TqROHURXiPMBbdAjpSF2RORGqQNHgHLi2ejME9f7BlXDq2+4flNhO/KUHC3vIZIYxwZmlMdet+/L93gXQkddxdakEEae48EijBfAYcAeeNbMuNjiXZ9/Es/C5QB2i7IBH8bjI5YC/eHX8vqWPviNY5F0TT7pnga/lv1668y/6xJ+79RRYF9XTsCp8BAgh7BapCUIldgkwBfA2cx70F6cGeAq+7GnB8L7/7zTPDneB9vbl/3C3KC8CwrnrKdde1rSUpGxlGKBTSz372M4ti+vv7bY4D0Yskm7zo8riBwoAkXHbU48ePzYjwMmEIwRIBN3S58TCIUPik0xlxuHQ6bY1iGOj+/n5TcL64uFAqldLc/9vemwS3naZpfg8WrgBIgABILNwpktqVykxlZmV1rdE1S0z0zPS0jzMT4duELz7ZZ199dYTDF0/Mxe6wo/vgsX2YsN3dVV3Z2VlZqZSU2iiR4k6QBAgCIEFiB3xg/159UFW7JSh94xehqCwtIP7f//ve5Xmf93mvXOliQRWLRRv/+z6ZSzweV6vVMtq21+vVixcvTAJ/fHzcBonBIPF4PCoWi3aZYPZQFDw+PrZuZPYql8vp5ORE4XDYhouxOGyk6MBoOCSe+f79+1aI5ZCja0VGMzo6qlgspkqlogcPHnTJSfj9fsuIYDzl83mrifWy5ufnzYkxBZLmuitXrtg0UsQZgVXQpKPW5orwvdk31Wq19PjxY/s5jNh1x2YzNoB9JRL2+S7kc46Pj/XNN98YbEKNZmpqStLrekc8HtfY2JgVxMvlssbGxnT37l37TGqZzO95X7YYMGwgELC79+2332pgYEDT09MKhULa3t7W2tqa1WJ4/+D97BeaY4xnwDB6vV5lMhkdHR1Z8yIOBITArX94PBdNfX19fYrH49ag+6tf/Ur5fL6rmxwSEQSMsbEx3b59W/V6XXt7e6pWq4pGo7p165a8Xq8KhYL9O9SI36XD/M1FJB+JRMwOffHFFxoeHtYHH3ygRCKhTCaj7e1tYzF6vV6rMWPMBwYGrIaRzWatdSAej6vdbmttbc0EZBFsJRvGUeJUJFmwiaBtqVTSb37zG8tQUCPhHRKkh/9uQmar1dLKyorVbNGKOzw8tMyRRACW6tust3Yu0CZhOJVKJa2trRmEwwOQ6hP9kbIR7VLbkLob46ib7O/vW18CNRpqL0TZRFjS645Y0sfT01OtrKx0SZ4PDg5qbGzMjCXcd4qITMcbGxszrj8ZEKno++K1QHHJZFLBYFCFQsHgmqmpKQ0PDxtFmGYzj8djRo9npyF1cHDQsN9Go2FsvuPjY2WzWXPgQFt8fxw/+Dn8d/68XC5rZWXF4Dne79WrV617uNlsGn8+n89rd3dX2WxWs7OzmpyclNfrtc8n0j0/P3+vDnNqckhonJyc2DA5jBYpP+fMbSQjO3ENJN8F49fpdAzyqFarKhaLZngDgYDtt5uRcKYIbhi2htw5YwtmZ2e7ovxgMKh0Oq1CoaBHjx7p6OhIiURCk5OTXVkz1Hne3fssmJbQVsvlsnZ2dozq3Gq1LEB0jVG73TYiD/uFIaK1gIjY4/GYY3GVkqnPuXtN4IGSAtl4oVDQ06dPtbGxYYKUjKImyKxWq4rH40qlUjo5ObGxEuPj40qlUjo/P7e6Dk2ZdOj3egZhaQLZI1zZ399v35E7zF5h795sFMUuEuhxXjudjnK5nMFgjGJwBXpddAZUgTozNvDp06fK5XKm3AEsjHNxdSER9D05OVEqldL4+LixWMmm3WzzbddbW8uHDx+aE8ApoLbJXBCYYhh6SVbQQ54deAEGFk5naGhIfr/fVICRvGg0Lma2EDG4TXquvg5MB4/Ho+npaYt2iLogH8C354C5PRJIhGB06YVAIsPtwH3XtbOzY/tHxEGTKC+20+lY7YTogIMB3k4kCZFBkhkHtMgikYhlXfQFtFotLS0taWlpyfad4jHvgA5z2HlucRUGFc2d9EW4g47c+hjOhWJmX1+fOYZe1m9/+1vbP0lWI8LYNJtNi9Loju50OjbXnbNBwdKlV7oXn0CJZkfwfo/HYxRoivZer9eiQHB3mD2xWMzuSigUsmgwn8/b4DT2j2cqFotW+Cd78vv9isfjxtp6n5oLqr7A0j6fz5TN0YfzeDyanJy0ZySjIOJGi4w77va+YTiXl5c1OztrhBH2sFaraWpqSpOTk+aMYExBliCzTKVS8nq9Nh+eyZLUEHFOnC+3r2lra6trQBuLHrZe19HRkaTXjeTBYNBIJfl83gKZdDptmYoka5cIBAIGX0mvGZDUjcj0R0dHTc4IROfZs2dGVU8kEmo0GnavsVUuQ3R2dtYCapw7zhHyDlJeBKJkWa7NIBhwB5597zWXX/3qV/J4PIpGo8YkmZubk9frNU2xSCSiWCxmB6fT6ViRDpYUnpBOVYwCUR7F1J2dHeuR2NzcVLlc1p07d2wKIZcbSWrqFjQAVSoVk+1HHdnr9erp06cqFouWAYBXclDh7h8dHcnrvRiONjExYTh9r5f7xYsXdhFxVEjAb25uqlQqaX5+XteuXbPLjioBlEKgjHq9bmk1EA1ROXz4zc1Nffvtt5ZholmVTqcN8oIdVy6XTdyR93N+fm7Gkp4BhO12dnaMcUbTH2xCCBZEVzS7TkxMdEXl77r+03/6T/L7/SadHwwGNTY2pna7bQOS5ubmNDExYRE/F31+ft7gAgwQrC+UlQlwXJYbag4MHrt+/bqRRqDmojDs813I9/MZrVbLYKFIJKJUKmUGg4CmVCoZlk5flpupShe4eCqVUjwet071XhejE6Bq49xopiyVSopEIrpy5Yq9c6jvbt3Mpfd6vV6Tz8H4XLt2TbFYTLu7u3r69Kny+bxevHihbDarkZERffzxx2q1WhZkcoel19nB3NycEUyAk1zxUWoy9BTRC7S/v2/MNvq1gMOxT73WXhj4B6TJmWk0Gtrf39fa2pqWlpZ0/fp1g2RbrZbC4XBX7QoyDU4aJ0BQwbtG6aBUKtlAuX/6T/+p7t69a59NtlytVruGjF2/ft2agrnLMNvoa+LM4fD8fr+Oj4/tsxib0Wq1rEHzXfbvnZso3ZQMJ4HH5VJQWCV9Bt7hElHY7e/vN7l2vDifK8mohOG/mzXuzrV300IKW0Rfnc7r4UYuZMF3ly4i32g0agJ6FAh5RmA9IkiX/dPLgv5M5gKVl8IvUQ57RFTnRomu4B3P6OqpEdnzjNQd6ACm14WDRLpL4c6daSK91p/CoNCJTxSN5DkH1CU9EJ1BAsH49Fo3YLQA9TkK8WSgnEO3Q96NvODq8+zU8shU+PecPfaP3hrO38jIiO0/sC3/no5rt5GOTB7sHEiIRkZECLlLnD8+3yVnACP1usi8OfNuxOrW3KgnvElKcAvE/DfwsgvXAOdw5/r6+qw3C4QBOSieibuG1hn/7k37Isl036Dse71ek3fiGehrc4kA0mt1gl4W/R+MRKCYz10EVcBRutpeQMP0fHEGoWxjV7Cd7h2WLhAM7rurLu/zvR6fAeUY6rxLiOD+cpY8Ho9lomdnZzo6OrI7xTvH2bn9Qe+izfbWzuWjjz5Su32hs1QsFq2z9M1uWFQzMUoHBwf23y7OR7fpnTt3jI7oRjHBYFA3btxQq9XS7OysarWapqenTVeHrmCovJVKRc+ePbPIDAYammWbm5tqt9sWqc7MzOjzzz/vwpiBgMCHoTDm83lNTk5aBNLLmpubs8LZ1taWXTaoh2hjbWxsdF1i9rdSqVg9Znx83DI1onckJRC9o8jYaDQsW7lx44ZisZh18fMugHeePXsm6TUzBxKB9FpCg5HAS0tL+vDDD5XP5y3iBj5zmUiSzLhEIpGenfPHH39s2cbOzo4ZGIw72cLOzo51I2PIXSo2PRqBQEDpdFrXrl1TvV63OguRMM2h7XZbk5OTqtVqWlxc1JUrV1Qul7W9va16va6xsTGNj4+rUqlod3dXfv/FgDQuLoXQlZUVg4k4fz/4wQ9sHMTBwYF1cmMkMcAEImRVvS5k6ldXV7Wzs2PUYreWc3R0pLW1NfX19RmUh3Eno4PtRHA4Pz+vcrmszc1Ng5bpfQkEAopGo/rRj36kTqejq1evanZ21vqDiKrJhIAgMdZufRCjHAwGjWo/Pz9vElPMWWGPybgInvgZvd7hxcVFtVoXI9DX19c1OjpqSEokEjEprC+++MJUDAjiQEYymYxR3ycmJhSPx+38uHNi6Be8fv26WoLGQksAAJo9SURBVK2WpqenVavVdOPGDU1MTNjztlotm2dULpftDuOYCVbcHiqgtvn5eX344YfK5XJGwkAdhGAQAlC9Xre68ffuXGAVMGcArI+DzwsEDuNAwnqQXivawlAC40Zni8jTbYJi1et1m9hHFlStVo3OB/aNo5Ne01QpcpGFQOvFMJOluEVaIqlCoWCMozcptu+yiNY6nY5pJpGJUN+ADcd3JzL3+XxdDX8UUyn0IdFN1AhzC3YNDYBIZPBsRCrUzU5PT+3/vxkh89wUeUdGRowBRySP8SE65M9c1YBejWMkElG73bYRC7yLdrttRpzzhhIEWTBGhbG3iJGSubhTQYEZ0L3jLHP+oIyTgQIdssc0FXOWuPTUhdgDMmdJRsEnEnWL9y50y+f2uoaGhqwJERYXUIkbUBwfH3dRYn+fc4EZhqMh86GmBWPRzfp8Pp8ikYgGBga6pILc7JkzTsZHoErGwN2lcXJ0dNRgGwJcHBGZGmgKlOf3yZ75DDKXaDRqmTmCnPl83t4f2Qy2s1gs2nhratSuvQK1ODs7swF73K16vW7kFTeDIPCA0AIBA/vnvkPekWt/gWBdJMhtOyExcFs53ma9k+Q+BWcXInNpxO4F4eE4XIi8uen+3t6edYu6GL570Dqdjk0+rNUuJjSWSiVtbW1Z5I9BnJ+fN2rx+fm5NWw1Gg1jjriUZyCCWq2mwcFB8+CxWEzLy8vqdDrG2iDq6PVggvNTnHVVUIlUcLwYZ7KwYDBoEyybzaY1n1FH4JIDw+A0KLzj1Kljwcap1+umSOvz+Uz6BqYPWmT0L7VaLZP6yGQyNt3y4ODAdJOq1arS6bQ++ugjeTwem7zoUsZ7WcjbIwcOLEpAAiTlCmVKrycsouTLWaZzn+iP5wOywphh3JrNpvb29lQoFHR6emoTCBuNhhnMxcVFVatVbW5u2vmDIk19BUMDiwhj3mw2tbOzo/Pzc8XjcV29elWdTkePHz9WqVTqUj3odTFplRoO2SU6aPRUuaMYgsGgqSKfnJzo4OCgC2J5+fKl3SW36NtqtRSNRjUzM2Pnv1KpaG1tzcY57+zsqF6vW3HZJYZQH6NG2Wq1lM1mJV0oRvh8Phugdn5+btkzxp2mVkm6f/++MpmMZmdntbi42DPrk2ePxWL66KOP7PfJOjwejwWx1ImGhoY0OjqqQCBgyiY8H7CkCy8iaYSDAMbirOzu7hrlfnd31xwDjLTJyUlVKhXt7Ozo7OzMWjCo03LWCc5weiQNiOImEgmr/x4eHiqTyVij7NvawLfeZb4Ms7/pvaAY6CqY4vkoEo+MjOjw8NAuEZ+XzWa1tbVlfSvUXPjyZEYU7NyxoQcHB5Jkmk/I7pdKJT18+NCUcPHMhULBpEu44HD1MSgHBwfG1rl3755lD/TP4Mh6WQglRqNRzc3NWTRQqVS0ubmpo6Mj03DCuXi9XmMakc6T+ZDhUVClQAt1FPxVel2D2t/f1+rqqo6OjvT06VM1m0199NFHRpAIh8NmCI+Pj01ixi0a7u7uWhEbCBRx0K2tLbuAP/vZzyyjwVhJ6nn/KpWLEbNjY2MaGRkxh1+v17tgTbIYWE105ZPxkLEh6gdUhoIvdZQ3I95ms2liilA3pdd9PxMTE5qZmdHx8bG++uor7e/va2Fhwbrx2T+K2EBwboaayWS0u7urmzdv6qc//am8Xq+ePHmi09NTow6/T0EfdYWZmRml02nlcjmtrKwYbReGECQbnMvU1JQSiYR2d3d1dHTU1ZS7ubmptbU1RSIR3b5924glyMtAWmH/Ga6Gcex0OiaFQibuqi9Ho1GTdTk+Pu6SSaKFAMgJ+vjh4aHdG97b06dPJclaKXrdP4/nQv1iamrKyC006nJO3EbT4eFhpdNpJRIJHR0dye/36+zsTHt7e11ikOPj40okEgoEAiboSb2YvebeZ7NZG12C7aK2mkgkdHJyoufPn+vo6MgQDM4bZw+4kXcOa5CZR9Fo1CbS0o8Tj8eNWv42662dSyaTseImFzcUCtkPJtKlQVCSZQYYUiJOt9AGa4KilM/ns9SVdJCmOaABjB8eHlYE0QsFRpciGIvFuogIFLb5961Wy7x8PB63SABWEAXEXi83kY0kg+IwTOwDUJ0kK/CCTddqNdMPIwMgPcWIk/qS8iI26hZEoTrCqiILJUKXXhcPofmCX9NMSM0HmI/sYH5+XlNTU0qn01bAxvFDAuh1ofnm9rAwVliSnS/mzLswjysx7pIUXCiUKJHAg/92syB0tE5OTmyMQat1oXvFqINKpWLfgcZLMla3QEqG70aSTHxMJpM2gjscDhu1/n2pyAQjSLFXKhXbQwItYEycstfrNUosZ4G/g55YKpWyZlEyZQweJBHX4I6OjkqSRemcH7JylwUJMcO9i5xnFBcwvo1Gw9isUMGbzaZSqZSazaampqbeK/vLZrNGroF4g6wT2f7IyIi1S0DScRuhsXVkd9Q2+vv7zdm4zoW6JffZJVVx50GDIK40m01Fo1EL9gkyqbmB3uC8OOcej8c0IePxuLVshEIhpdNpu79v2yf01s7lm2++kcfj0ezsrBKJhGKxmObm5lSv1/Xy5UuVSiXNzs7q+vXrpoXjMonw4LwcjCkH1S0sUwyE2ZNOpw27bDabOjg4sEZBCrVcer/fb/LeGxsbevnypaLRqK5fv269NF7vhYbS1taWFXPb7bbu3bun27dv6/T0VHt7e2q326Z15EpO9LKePHliFzsejysajWphYcGMBf04dKITlefzeZ2enmpkZETT09PmfHHYyJ0QkXORIQrwZ1xGcGrgBzJGoEnpQkeu1WppfX1dW1tbisfjWlpaMkPk8Xi0v79v5ANgjRs3bmhxcVGFQkEbGxuq1y/mT7iD0Ho1jqurq1ZvqtfrCoVCSiQSpi7M4LiFhQU1Ghezhjh/RGLz8/PyeDxdFGD3nXLxyBK54Ohvcf5QemaIG9BCLpdTf3+/Zmdn1d/fr42NDW1ubmp8fFx37twxdtPQ0JAymYw2NjZsAFe9XtetW7e0vLzc1XDKM72PU2ER4NBpDaWaIA75dowQdQGGn3F2cD7g+YlEwqChZrPZNfCM5yBgxPGSoVC3onOfBmqf70KAFtXqZDKpTz/9tGuQWrlctr1DOfr69etaWFjo6nP5+OOPde/ePWso7nUvnz9/bg4/FAoplUrpzp07ajabpri9sLCge/fuqdVqGUy8sbGhk5MTRSIR6yFCQcQlv+zu7lqwgoIxjhYlZoIhr9ervb09u9uSjI7t8/m0uLgor9er3d1dZTIZxeNx3blzx+o90LjJwKWLIPXWrVumtpzNZtVoXIzYQPdMei2z8w+td6q54Bg4dG8uCkjSax0eCv+uTo3UrRXE4abOwAFgY10s3Y2uaBAi+qc50Y2uiIAwrHwv/r9LJ4Th8yY27ur/vG0x683lFtPYvzfpkWRu7v5Q73DHueJ43e5Z9oDPYf+4UJKs4EnmBDZMBOPqckHjdv+b/+/uH5Ab+0RhkSyT5juixV73j73HydMM50ah7APnifPnZi9vwnP8HvvuFpe5uG4Bm/PkFt9dGrkk+/vuOaX/ANUIGG7sn1vjoJbTarWMust+vs/i/QKJAF+7zz0wMGDfgXuALhhGDkKOS3VlX/gs9t6dz+Q2A/NzsRncMe6Ze3fJAtlPfi5ZgEu0AeJ1EQkIM27/UC+Ln8Mdxj7wHK6t4e7hICqVihEq+Ptka66DcG2BJLvf/HL/Ds/MeyODo12AjNA9gxT3sXcEl9wb2JeQYjgzNHm+yxl8a+eytLRkD0aGsLu7ayk+EY0rK02UCE2WmSVQ52i+dBsLMWKlUskmXQKZAUsQHQ0PD2tmZkYTExM6OTmxeRJwyUdGRnTnzh0rrJEZoTfEELNnz56pXC6r1WoZFoo2FoVIJhq+bUr45rpy5YrBAmCWkBioOTWbTYu2aG6jTkBdY2BgwMaaHh4ean193bJCDH4wGNT5+blWVlbU39+v5eVlo2XCOkFR4eOPP9bc3JwODw+1sbFh8AOyNIlEwhyKW3yORCL6wz/8Q52fn+vFixddExwpEIIDo/gMRtzLmp+fl3QRQBwcHKjRaBibC504iCPSa6HVo6MjnZ+fa39/3xS76VUhcgsEApqcnOwSwITW7fb9wOIB6vX7/VpYWFAqlTJFaIq1lUrFmuGgo8IGhCF49+5dK6TSPX98fGzKt5IM2snlcqby0Otyo3a3f4FAhbNGYMLewUCiTuU2WEIQGR0dNYkgiuzu4DGUqPP5vI6OjrrUfScmJrSwsGBohwudz8/P6+bNm0bKcOX/JycndefOHdM3g6rPd6V/iOcDTu91D1GYcNmUEHVgXiFD5J5BMvtarabt7W17tk6no0wmo62tLcViMf3gBz9QMBhUNpu1FoBisai+vj4jjdAUCXNwcPBiZtHs7KwODg706tUre34yzFu3btn3Yu4VUi8ffvihEaZoeM7lcsrn89rY2DC4NhgMqlQqmY19q/P2thsbi8WMucUDsgEYTQ6l9HoehSRjaaEYSgTjNra50Qj/liI6UQJZE3TETqdjXbcU+KBa8p3ppOUziSIoyp2enurg4MCatZAjd6UpgKneVxtLeh2BE4W7dGCotGR7blTjzspB2hzYrF6vG5SB82JyJXpOLqxIgICzisfjFgTglMHTcXoEDZAiEomEFhYWdHJyou3tbaNBSrK0nrOB5hEzyHtZwDeHh4c6PT3V4OCgNekRLXo8Hrt0GFLgHRrfMAwUTguFQtfZw2gQhJDVSq/p95xxYJ50Oq1Wq9XFPGs2mzb8C6kO/i3BEbpY9GBRo+Rn8zPb7W5pol7Xm02F7i8yET4fB4uaAAYacgb7nMvljMWFyCSd6ChdBINBG2EMjMUvsqGJiQlVKpUuhIL3nkwmrYBdq9XMeaXTaRuvMTw8bDUlYDgib7It7kSvy60Zsm+uhp8rfeVmXW7GRRDhCrxmMhlTuYCAhIMgyCXDc0dMu/Ix8Xjc7rRLuabIz7ujj4ZR5alUyiBS5I6YRku5gPky1WrV7svbrLd2LhQf9/f3tbm5aSKFpFN8KRSEuZAcuFwup1evXkl63flNIRXjwwsaGhoy5gQXeGhoyKYJUnjCaWCQgScoagUCAU1PT9v3I3okEuSiJJNJpVIpu/yuIUTNme/2PrAYGHShUND09LRmZmbs8GHUeHEU4+PxuPr6+pTL5WwELLpsLvuJ741+Ujwet+iSgi2H6uTkxIw12CvZHIe60bgYqjUzM6N6vW4Hl3dWKBT0N3/zN/J6vYbTYxCgIEvqMtrvQ6OlGfHo6MgaaGdnZ63oWy6XjQqLc5Gk8fFxm+TpGnG3N4EmVUnWREvjJ5EnEE8ul1Or1VIymbQInhohlE8yl5mZGSWTSXPi1BSazaby+bxReBOJhMbHx80oSLLgxu0rA9LodU1PTxsrbXNzU4lEwmSUCHTcHiF38mF/f7/y+by2t7cNrXADkdHRURWLRfve7OPY2JidQ9hO0MbJ6lziSDKZNANIdspYbbefrVgsan9/X9988428Xq/NHwEeAj6lthsOh1Wr1Yz+38tiyOHGxob29vZM5BFmZrFYtBn2riNPp9OampqyO0zWC72c5uJXr14pl8sZ+5NghvoTWRn9aDMzM2Y7yKCwY5yzaDSqpaUlY9tBfIK+/dVXX8nv92tpaUlXr161u4o8DPeF7wu8+DbrrZ0LG7W9va1vvvlG7XZbn3/+uUXcGG734lJcTyQSWl1d1ebmZhdji4wH2KBer5sHh5EkyYw+VMZwOKzl5WUrtKNRRoEM+GxkZESLi4tW3IPO2mg0TK4+Go3qF7/4heLxuDY2NrS7u2v0VjjtFC/dZrF3XTgBhoV5PB79/Oc/N9jPdS5u9/nCwoISiYQeP35sRhXaLQYBXJyDho7S4uKiQXtkaNvb2/L5fOacoWo2m03FYjF79mbzQvl4aWnJIAYyhcHBQW1sbOjp06eKx+P6kz/5E01OThrFlB4cYBcXM+61mAqUuL+/r0ePHqndbuvjjz82dWgkN/h51IkWFxeVTqf14sULm0bKn0NdxvkS5VI8DYfDarVadnZKpZL29/cVCoW0sLBgcAfNmfF43GjKYOxTU1Oq1WoaGhqy5t9KpaKDgwM9f/5cY2Nj+tnPfqZ4PK7t7W3t7+9Leg2Z0ptAz8f7wGKLi4tqNBp68eKFvvnmGy0uLmp6errrLNHrQuGa3olYLKanT5/q5cuX9jz9/f2KRCIWWEB1DgaDRhphaCC9NDiYvr4+Iz7ASPP5fJqentbZ2ZkKhYI1ri4sLBgT6/T01Ig4m5ub2t3d1cTEhP7Fv/gXSiQS2t7eViaTsXsiqWu8Bs2yvaypqSk1Gg09fvxYT58+VaPR0PXr1+Xz+UzJAzq/W4O5efOm5ubmrLMf50IzMpppz5490+DgoD799FNTF8ehuBN3i8WiIpGI2UBKDv39/ZqZmbHMo9FoaGJiQh988EEX/fng4MAUVp4+fap0Oq3//D//zzU9Pa3d3V1TBncbWGktoc76NuutQ0miThzJ73tBb6baFFbfxqi8WSx3aacuRonBcouwbz4sn+UWyd1Um8+Bkvr3fcffV8B/X9YO2cI/dMDd707Nw33W3/fd3OIq++e+N7cIy2ezF+6zuRELhXHeg9uXQQr+5h7zrvg+75OxuPvh7p+7Dzwbz+n+mQuRuXv05me7/+7N535zX3gmNzqVunWX3L/nfh7LJQy4+/v3wVbud+t18TMwGuyjuydv/iy+25v0d3fv3O/NuXbPIPvy5rO4e/L7fo/P4Xv/vj1ydcSA1N7ctzcL4L3u4e+zQ79v3978X/bvTXv15vchUHT3wQ3K3jzDv88Gur/HZ7t2lGfgzLv7R83R/Vnu5/y+3///Wp7O+4RCl+tyXa7Ldbku1+9Z7x9SXq7Ldbku1+W6XG+sS+dyuS7X5bpcl+t7X5fO5XJdrst1uS7X974uncvlulyX63Jdru99XTqXy3W5Ltflulzf+7p0Lpfrcl2uy3W5vvd16Vwu1+W6XJfrcn3v69K5XK7Ldbku1+X63telc7lcl+tyXa7L9b2vS+dyuS7X5bpcl+t7X5fO5XJdrst1uS7X974uncvlulyX63Jdru99XTqXy3W5Ltflulzf+3rreS7/7t/9O5ugNjw8rGw2q5WVFQ0ODupf/st/aXM/KpWKyU+3Wi29evVKmUxGx8fH2traUl9fn65fv654PN41x166kCFnzOvExITm5+dVq9X08OFDHR0d2TyM4eFhjY+P27AdhhEx7Y0ZGEyqc4cHPXv2TAcHBwoEAgqFQgqFQlpeXlYwGFQ+n1epVLLP5fswWZH5EP/tf/vfvvNG/zf/zX9zseF/J3+9sbGhX//61xocHNS//bf/Vrdv37Zpk8ix1+t1ffnll3r27JlJZw8ODmp+ft6mRDLsikFpjCyNx+OamZnR+fm5/uZv/sbmPfBs6XTa5rr39/fbsCMmeXY6Hc3Pz9uwsFKppLOzM/3yl7/U2tqalpeX9dFHH2loaMgGRpXLZZ2dndmcina7bTMkmOEtSf/Vf/VfvfP+/fEf/7EN1gqHw9rb29P9+/c1MDCgP/7jP9bVq1dtYJo7UmF1dVW7u7s6Pj7W7u6uPB6PpqamNDIyovHxcSWTSTurDEqr1WoaGxvT1NSUzs7O9Ld/+7c2gpcppouLi13D41wpcmTnJyYmFIvFTA6+0Wjo2bNnymazJn/OzJxgMGhTXpkd1Gq1tLu7q5OTky6J9//hf/gf3nn/JOm//q//a3k8HkUiEQWDQWUyGT18+FBer1f37t1TKpVSLBZTIpGw89doNLSxsaGDgwPt7u7q0aNH8nq9unHjhqLRqEKhkEZGRuxsMuW0UqkomUxqcXFRJycn+vM//3NtbGzYLKdoNKrr168rEAhodHRUQ0NDdu7dFY1GFQ6H7QxWq1Wtrq4ql8tpYGDARphPTk7aQC13AmSj0dDm5qYKhYJGRkY0MjIir9er/+K/+C/eef/+1b/6VzYcb2xsTJlMRo8ePVJ/f7/+6I/+SEtLS10D36SLybcPHjzQ2tpa19yl6elpjYyMaGxsTLFYTM1m00atM79qdHRUyWRS5+fn+uabb2wSabvdViAQUDqdtmFuzLKSZNNXGSEdi8Vs2m21WtWXX36pjY0NBQIBjYyMKBQK6erVqwqFQioWizo5OVEwGFQ8Hpd0McML28BIgP/uv/vv/sH9emvnwuCuUChkBn10dFR9fX0KBAKq1+va39/X1taWIpGIPv74Y4VCIY2Ojmp2dtYG/DCEKBQKyePx2LhODiZDccrlslZWVtTpdNTX12eT+jh8DAXjMzloXq9XgUBAXq/X5sIHg0Gbejc9Pa1EIqGjoyMdHByoWCzaFMNIJKKRkRFVKhVtbm7a5MBKpWJzFXpd1WrV5iH4fD4lEgn94he/UH9/v6LRqBqNhnZ3d7WxsaHR0VF9+OGHGh4eVr1e18TEhMrlso6Ojmz6H+OHC4WCBgYGbJwz8xpKpZJWVlZsiFoikTCD1mw2tbm5KUkaHR21gW0MoxoYGFC73dbu7q7W1tY0ODioSCQij8ejubk5xWIx+Xw+7ezs2CCjdrutVCqleDxuI3kbjYYODg5ULpcVCoVscFQvq9lsyufzaXBwULFYzN43Q7o8Ho+y2aw2NjYUi8X04x//WCMjIwoEAhobG1M2m7WBY/F4XIFAQENDQ6rX6zbgSpKNlyaoaLVaNg2VoImpigQd9XrdBmS5c0fYv2AwqPHxcfX19dno7Ww2q93dXdu7wcFBC9zOzs6UyWRUr9dtjv3g4GBXINbLcmeytFotjYyM6M6dO/L7/ZqamjKn/fXXXyscDuvu3bsaGRnRzMyMotGoRkZGVK1WJUmTk5MaHR21EdzuvSsUCja5NJ/Pq9lsanR0VMvLy+a8+/r6bBb8+fm5vVvuMLNFdnd39eLFC5smKV04nKGhIZ2enqpYLNpsd5/PpytXrtiANiZj5nI5FYtFVSoVnZ+f97yHo6Oj8ng8Gh0d7ZrA2dfXp0Qiob6+PmUyGa2urioej+vnP/+5DU2bnp62AFu6sKODg4M2WdLn8ykUCkmSjo+PbcQx02ZHR0c1PDys09NTG0Z2fHzcNcnW7/dboD00NCS/3282eWhoyO7t/Py8pqamdHx8rIODA52cnOjFixfq6+szG1iv17W2tqZ6vW53mM9/2/17a+fChw4PD9tFmpqasgfhIqyurmpmZkaxWEzJZFKjo6Mql8vq6+uzSYBceuZoE3lzqPr6+mxymt/vVyKR0MjIiBlnJkvy75vNpkU+HML+/n7t7OzoxYsXmpiYUDgcVjAYVCKR0ODgoJrNphnfw8ND+Xw+3bp1S/F4XOVyWZlMRufn5yoWi6pWqzahsNfBV/V6XZLU398vj8ejWCympaUli+gbjYay2ayePXumqakp/eQnP9HExIS8Xq8mJiZ0eHioly9fqtPp2CjjUqmkk5MTDQ0NaWxsrGvAULlcVqlUktfrtQMuXThl5rYzfTIYDNr+MIO80+loa2tLKysrGhsb082bNzU8PKxUKqX+/n7t7e1pfX1d5XJZ29vbqtVq+uSTTxSNRs04Mvf87OxM0Wj0vSZRtlotm1zK5cZhcjaOj4/14sULtdttTU5OanJyUq1WSwMDAwoEAjo7O1O73VYkEtHg4KCk106L+efHx8eWveVyOcsYMSZ9fX2q1Wo6Pj5Wo9GwTLHZbGp4eNjep9fr1dHRkba2tjQ2NiaPx6NAIKBUKqXR0VGdn5/b9+Hizs3NKRQKWXCDgalWq4pEIu+1f5JsmBbPHQgENDExob6+PsuEHz9+rF//+teamprS7du3zQkzPfHo6EidTkfj4+MKBAI6PT3VycmJZcGMQz8/P7fAzO/3K51Oa3x8XGdnZzY5tlqtGhogybIKMmwChs3NTY2Njenq1auWFY+MjKjZbGp3d9emZ3Y6HUWjUc3NzalSqahYLNo435OTE5tQ2+se4jwDgYDdmdnZWXMMfX19Oj4+1tOnT7W8vKx0Oq3p6Wn19/drfHxcOzs7v3NW2u22ZfvhcFg+n0+lUsmcTr1el9/vt3HRfr/fBvWdnJzYoC/uRiAQ0MDAgCEaR0dH2tvbs0AgGAxqbm5O0WhUz58/VyaTMdTC4/Ho2rVrSiQSqlQq2t7e1vn5ufL5vCqVitn97925YKgkWTTMheMC8kPL5bKePHmiTCZj0R4XpNFo6OTkROfn5xobG1MikZAkg66YHsjmM9Gu0WjYZLv+/n7FYjG1Wi3lcjmdnZ1paGhI0WhUXq+3C57jO5ZKJdXrddVqNfX391s0I11EQqSWb2YoRPUcqF4PJiOgmZ7XbrftEhGlATFJ0vPnz7W3tyfp9fTF/v5+g/2AT4iYPB6PpcxkexwEd5Ilz0QmiHEbGBiwlLdSqVhqjyHmcnY6HYsa8/m8Wq2WGb7x8XGFw2H7+a1WyyJRDnuv+0cQUSwWbZwul82drNnX16dKpaJHjx5pd3dXe3t7Ojo60unpqYaHh9VsNlUqlVQoFBSLxRSPxy2bY68xIIw55tmJEv1+v0ZHR7vmzfv9foXDYfn9F1eKIIpgBlgWeKFQKOj4+NiyIjLHQCCgcrls34Xn7O/vf6eo8fets7MzeTwe1et1G6WNI5RksHcymdTQ0JBWV1ct8MLoYdww2MPDw3YG3bG42AP+bavVsqxnYGDAMk/2t1KpWCAkybIaxjt7vV6Vy2Uztl6v18Yhc5dw/tgc7gJz398HeZBkGUN/f7/dAzJ6IClsRbPZ1KNHjwwWPjs7U6VS0fDwsBqNhiqVik5PTxWNRi0wZNS7JHsWMupGo6F6va5Wq2VQWDgcVrvdNic6MDBg48u5F/39/QoEAvL7/To9PVWj0dDw8LCq1aoODw9VKBTU6XQ0PDysgYEBc5qMNGesOXf4/5fMJZPJGNwyPDxs0eLQ0JDC4XDXRc9ms/rf/rf/TX6/X5OTkxofH5fX69XMzIwqlYoeP36sQqGgH//4x7p165bK5bJevnxpDsHn82l0dFRjY2NqNBqWRWD8ibikC6dUqVQ0OjpqNZoXL16oVCrJ4/EomUyq3W7bbHIM7cbGhra2tjQ8PKypqSlFo1GD+7hAXq9XoVDIjM27eO3ft3/SRWodDAZtZvvQ0JBBjaOjo5qcnNTZ2Zn+z//z/1S73db169c1Nzener2uQCCgWq2mnZ0dnZ2d6caNG7px44YajYby+bwdvna7bRkmkZE7jhgYrdls6uXLlzo8PJTf7zeH7e739PS0arWaDg4O5PF4VKvVFAqFdHBwYPv3wQcfaGxsTIuLi5qamlJ/f7+y2awZFxwjsFQv6/T0VF6vV5lMRtVqVaFQyAy3JMt+BwcHVSwW9Wd/9meSLjJFLnwsFlOlUtHDhw+Vz+f1gx/8wGpKh4eHqtVqarfb6uvrUzQa1eTkpKrVqu7fv2/BAYY+Go2q1Wrp6OhI1WpVAwMDNve8WCyqXq8rmUxqfHzcnEqlUrFIfmNjQzs7OwZX4MxisZjOz8/NOBJ8BAIBc9S9rqOjI0mvR+FS62CRJd++fVulUkn/9//9f+vs7EzhcNhqlKlUSq1WS5ubmyqXy/rkk090/fp1NRoNq4sSRfv9/q7ovFKpaGhoSMFgsKuutLKyoqOjI6XTaaVSKVUqFW1tben4+Fj9/f2KRCKSZLWqUCikgYEB5XI5bW1taXBwUMvLywqHwzbjnZpbp9NRMBg0tILf62Xx88/OzpTP57syYEZtDw8PKxaLqVqt6n/9X/9XeTwepVIpy9z5s+fPn6tQKCgajWp+fl7ValW7u7tmA6kljYyMqFar6eXLlyqVSlYnAUXodDp69OiRyuWyRkdHtbS0pE6no3w+b/XpRCKharWqbDZrzmhwcFA7Ozu2f0tLSxodHdX4+LjS6bSazabBbQSM3K+3XW/tXIAl3BnsGAyicbwbNRNJGhsbU7VatUtC5sF/uzO0mSFNZE8USMRLdIeR6nQ69nlESu48dLw/WZH0eg72wMCAHcahoSGD5dzMieI7EfE/NPf+/2tVq1X5fL6u2ergpEQ+4M7ABRT42Q93LjnwC4V8lxThviP3/blFdfaP5+PZ3Xn0OCIOlnThnPv7+zU8PKxIJKLh4WEzfDgSgg7+Pg6vVqv1vH88P++WiIrDTmSKAy6Xy2o2m4Ztcx6ATvnV399vz8w8cQwQESDniOyB7MXj8XRlnu7+sbecYb4DZ5k6Ft+D7JOgZmhoqCuQ8fl8Vl98nz10F9+fM8EehUIhg5AqlUpXUMeZcu8F+9pqtewXP4s/c6GbUChkZ473RtDnEiRcmJfnJojA4Y6Njdl/U7clI3f33+/3m3PvdfFcPCOfy7nHBhI8kqVSBgA6dO8uZwc4GqcIOgRJiX0G8gKC5G4ODQ39TvCGzSTT4g6zz6Abrj3GlpPxce84P2RWb7Pe2rnw8sfGxhSNRjUxMaGrV69a4TyfzysYDOoHP/iBisWivvvuO8OU6/W6vRSfz6cPPvjAoIXDw0MzpETgx8fHqtVqVsDkhYyPj1vBeH19XbVaTT6fT1NTUxoYGND+/r5FD64jI4X0er0W3d+4cUP/5J/8EzWbTZ2cnFhkf3Z2poGBAd28edMOVKfTsWJ7rw6GiHVgYECxWEyxWExXrlxRX1+fms2mzs/PLWLm0nPIKpWK7Z/f79f169fNCFSrVYsyOBilUskOZKfTMegmHo8rnU7r5OREr169UqVSUSgU0vDwsBlpr9ercDhsUA/F7pmZGfX19WlsbEzDw8O6deuW/sW/+Beq1Wra399XtVpVoVDQ6empRZIQNOr1ul6+fKnvvvuui0nzLot0PBwOa2JiQqlUSnfu3LFs5ujoSKFQSB999JGKxaKePHmis7MzDQ8PW+QN7PSzn/1MHo/H4NB6va5qtaqzszPlcjmdnp4aq0qSMdSi0agikYiq1aqOjo7UbDatHjg4OKiNjQ0zFJxb2Hmzs7N2/prNpm7evKk/+ZM/UbVaNSy+Wq1qe3tbHo9HH3/8saTXEfHq6qoeP378XgGOa1y4y9euXdPAwIDOz89VrVY1NDRkTMJEImH7FwqFzEDCFoO9x94Vi0WDqorFotXGPB6PsQfn5+c1Ozur4+NjPXv2TOfn5woEApqZmdHQ0JAODg7U6XQUj8dtr8mWZ2dnzeBSvP/5z3+uWq2mfD5v9ZRcLifpIrB118bGhjGuelk498HBQY2NjWliYkKTk5Py+/3KZDI6PT2V3+/XtWvXDDYE6jo7O5Mkq2F98MEH5ogajYYV7pvNphGN4vG4ZYDz8/NGthkYGLCaIMy7aDSqTqej7e1teb1e+3sE3OFwWNevX5fP57Mg6tatWwoEAqpWq9ra2lKlUtHBwYERLLjDOJsXL17o0aNHBiH/Q+utnQuXBhhnZGTEHoiNjUQiisViltHgIcFi2ZyJiQmNjo5ahEmRi0JguVy2CNSNjkKhkDGrCoWCzs/P7eLX63XLlogyiTBDoZCxxYCjwuGw4vG4zs7O9PTpU4M96vW6HR5qPe4L79U48kL8fr/tYTwel8/nUy6XU71eN/jt/PzcImMiGYwM9aZQKGR/RlGPCAqiA4eCZ6Bwy2GuVCpmMIhOuDxuxDI8PKyJiQljCII1J5NJlUolffnll8rlcqpWq6pWq4rH44pGo0ZPBr/N5/M97x+RMg5idHTU6nX7+/tWcIzFYpZx4KSpp5H5TkxM/A7zij3BUOIU/X6/gsGgRcljY2M6OTnR0dGR2u22Gd1araaTkxN7h0TM3Jnx8XH5/X773GQyqbm5OZVKpS5DUSwWFQ6H7bwSLW9ubiqXy/W8f+wh/8v3ikaj6u/vN+NGAFSr1RQMBtVsNu35qZtRXyLroh6Ag+QXmY5b6+DZyGTPz88NwvV4PCqXy/L5fIYcEP1zBsmIQRdCoZDK5bK+++47u59Aum6GBEQLRNzLIgPjDg8PD2t0dNSovycnJ4pGo0bh5QyQ1bjZDq0Ybi2FzBcHTX2G/SZg5mzv7u6qXq8rHo8rFAqpUChof3/fIG6ycsgb6XTa7mStVtPExISmpqZ0cnJie8fZj0QiSqVS6uvrs++3trZmQdXbrLd2LpOTkwZ3NJtN5XI5/fa3v7XLNzc3Z5vcbDbtUoPbATtgsImwod3BvgF3hsbcaDS0s7NjHHAwQ/cB2cBaraaBgQGl02kNDw930UXX1tYMrx0cHNTZ2Zk6nY7hp6enp0YFpbYAOYAi2MLCQs947b179+y/s9msqtWqOTL6BShY4gRIV10yAxcVNgnOkv6YwcFBy+SGh4ctGoG26PP5rLBHdB6JRHRycqJ8Pq+BgQHNz88buwooYXV1VZKUTCY1MjJiTuPk5ESZTEaFQsGMDTUuN02PxWL66KOPfgeaedt1/fp1Y1w1Gg3t7+/rr//6r40KD/20XC6rXC6bQ+VS84tiqnRBUoHaCW2VaHRkZMSClp2dHZ2cnCiZTKper+v09NQCAjIizvTQ0JD1MGAs6vW6nj9/Luk1BRXndHJyov39fRUKBXNUnHGcod/v18TEhO7evftemcvy8rKki/rV+fm5SqWSfvnLX1qWQhSNA6PeCMaPg5Yu6LJAJ4ODg6pUKiqVSmo2m5qentbVq1cNcqvValpdXdXJyYkZSHqfcFr0pJA9pVIphUIh5fN5u+/Pnj2zPhMibt45mQI1CSAjCu99fX3Wd9PrHl6/fl2SjPySy+X09ddfq6+vT8PDw5qenrZ3WqlUrM5DBuvxeFStVrtIItio8/NzCx4SiYSmpqaMvt9qtbS9vW2kqHA4bLbCLSUQhMI8jEQiyuVyyufzki4yN4KK/v5+nZ6eKpPJqFQqmY2AYDAwMGCIE7+i0ahu37791vv31s5ldnZWkswoHh8f6+HDhxoeHtY/+2f/TFeuXFE2m1Umk1Gj0dDAwIAVcv1+v0XSZAe1Wk2FQkG7u7tW8JSkmzdvampqyozpycmJDg4OdHBwYAefF0RkzwWuVCrWoAT1j4v76tUrdTodo9pBMz47O9Ph4aFFNESzRNu8xGAwqBs3brztdv3O+vzzz9Vut/XkyROtra3p8PBQm5ubCoVC+tnPfmbNntC2KfzhXNxsTJJFOAcHB3ZIPR6P5ufnNTEx0YWT7u7uamtrq4tFQ0QUi8WUTqe1tbWlra0tS4eTyaSy2axRQZ89e6ZqtaqFhQXFYjGNjo5ajxDGN51O22XIZDLG/hkcHFQikTASRi/r7t27arfb1kOxu7ur+/fvKxAI6I/+6I80Pz+v7e1tHR4eGoUThwI0gdGsVCpqtVra29szSjZZ8tzcnFHsiZx3dnasJ6XVatm+t1otw79h2AUCAc3PzyuVSllD2t7enh49eqR6va6rV68a1TObzapcLmt3d1enp6eGgTebTeXzefX19Skej6uvr0+pVMqK1b0uDMPOzo4ODg6Uy+X01VdfaWhoSP/yX/5L66ci8IKeTEGc4KTRaBhLE/iFJkC/36+7d+/q6tWr5nDoKdve3pb0usnUrSPQyFuv1zU0NKSpqSlNTEwol8vp6OhIu7u7+uKLL1Sr1XT79m0lk0mdnZ3Z9z06OlK5XFYwGFQkErFmRIrjgUDAAuReA5w7d+6o0+kol8upUCjo4OBAjx8/1tDQkP7xP/7Hmp+f1/7+vp0V9gzHTBsF8F1fX5+KxaK1O8Ae/OijjzQ/P2/BUKlU0qtXr3RwcKCZmRlNT08bOsFddh1Mf3+/FhcXNTk5qbW1NUkXwcDLly/VbrftDp+cnFjWsre3p1KppEgkYr07JArU2cbHx7uaNf+h9dbOhaKzyzgKhULq7+83rBpj5HpV4AaiTuoA/Pmb1F+civS63jEyMmIRKNRIGtZ4WL6XCw1xiMCR+f1MJmNR1Zuen4wFiI0UcnBw8HeKrO+y+P7UMMC9+/v7rW+HhjAomxT5cC5EQJIMDuNFc2HdYiPOZHR0tIsJhsIBMAeQJYVTms0IBgKBgPUOSLJIKBgM2gWWZFE9P5sLBNxC9NbLqlarRvrgczF6p6enOjw8NENERzs/i/0AIuF5KfpyfjjjRIDsJcZKkg4ODiSp6/xJsiyDBlSaMckmZ2dn7cyjljA4OGi1jlqtZj0g7B9nxG3mfJ/l1u4gREQiEYPFjo+PdXZ2Zr07NIjy76AvS7LzCPTs7iH3DFIAxIpoNKp2u61sNmvQM0QGYCscDc7BhdOnpqbM4FFj83q99j2BenGO/CLYoAbcq3NxWyVQZ4C5xh0+Pj42BiEBB/tE4R0iA+8C8gKkIvaRoJkmSs6g20zNuZNe204QF5clOjQ0pGQyaf1F+/v7ZtMIvAjcz87OuggkEFSwEW+73tq5AEOxSSMjI5qcnFS73dbW1pZevnypbDZrl4+LTFErGo1qenpaPp9P1WpVpVLJaIL8PZehQ+dup9PR9evX1Ww29e233+pXv/qV5ufn9cd//McaHR01SMbtjaEJiQatVCqln/70p6rX6/rzP/9zPXjwQHNzc0ahhJ1FVnB6eqqjoyNLX6vVqhXwejWOu7u7ki4c3ZUrV7qw6L29Pe3t7VlDmkvlxDkHg0GlUinDjTk4fAYHv1wua3h4uIt1cvPmTS0uLurRo0f65S9/qeXlZf3whz+0mlOhUFC9XjfG1/b2to6Pj+1dzMzM6N69ezo/P9ef/umf6ptvvtH8/Lz1jdD/QRSGEQKC4yLQTNjL2tzctAvo9/sVjUY1NTWlTqej9fV1PXv2TLlczgrCXFicsyRj2JC5SLJmPKIzOrtxPl6vV5988om8Xq9+/etf69e//rWmp6f1z/7ZP9Po6KhFzEA59AQRWDUaDaVSKf3kJz9RrVbTv//3/15ffvmlUqmUZmdnjQiBQeT9Y2D4BVz3PmwxusOpJYG5S7JubbJgl4jD3oTDYTuDY2NjXX/m1vjI9mgCbbVaWlpa0vz8vF68eKGvvvpKMzMzunr1qkZGRrpUCHDQpVKpqwaQSCR079491et1/cf/+B/19ddfa3p6WktLS6pUKjo5OdHp6akODg6M4UbPTCaTUa1W64KVe1mHh4fyeDwGV7XbbU1PT1vAsL29rYODAyMWEeDQ4zMxMWH1mGw2a/uMg8Yx4DDPzs50fHwsj8ejO3fuyOfz6euvv9ZXX32l2dlZ/fN//s81MjKi/f19FYtFo3f7/X6TDYKlmkql9PHHH6tWq+nP/uzP9ODBA83OzuratWtW9z4/P9fh4aG9V2rmZ2dnqtfrSiQSmp6efms6fE/OhSiUgl82mzUIAK8HLdCl6FHgo44hyTaVugzRKb9o7HKjOOAHCnZEIrwccHUitP7+fo2OjloqSc+Be4nfjFz5+cCAZDe9Hk6axLhAGORWq6Xj42MrhiKNIb3OFt1IE+fCMxPxSbLv7tItXaaOS2gAKqB2AlnA7/db5kSmOTAwYJIbZDZoF7lZ45u4rxtt8/vvk7lIsn2j1tdqtbS/v6/j42PL+nDO7r64kSEMO0nGFnPppK5ECEYKZ089JxgMamRkRMVisYtOC/uPTAvKJ5R8mmDJBlyIwXWE7vuTZFnk+/S5vHku+vv7zUgWCgVrSORdkTVAPyWY4c66309SV/c4dT3+LQV7GJnAzq4kjfvZvAccFntIpsxnuI3DfEf3fXJ2cF7vgz5wtkBscPyUCUqlktV43bvhFvPdPhGXkUl2T6aALQC1CIVCVishsITQQP+K2zDN/kqv6dtIW2EDXTvCHX6Tbtxut43WTybzvTdR7uzsyOPxWBOg9JqeDBx17do1/fSnP1W5XNbq6qq9UCAMMHc8JWmwJGMx7e7uKpPJaGxszNgNOKrl5WX5fD5FIhGTxTg4OFA2m9Xo6Kh1p+K8QqGQxsbGVCqV9Kd/+qcW8S8sLGhubs4a6Dwej87OzhQIBBQIBFQsFrW5uSmPx6MrV64oEAh0RZG9LIwDvH/6bOgYb7VampqaUiqV0vn5udbX13V+fm7wCQ1OkA3a7bZJtriRB1nk9PS0bt682bUfd+7cUTweVzgctmg5m83q5OREo6OjmpmZ6eovoCchl8vpyy+/tMDh888/VzqdtuYvmHp08KIt5vF4rLD4JmvoXRf0YLcL3K0hSdL8/LxlY+vr61YcDgQCikajmp2dVafT0atXr1StVu35yuWyNZ2tra2p1boQPb1+/bqdz3q9runpaf385z9XOBw2+itwnJuZcTmheedyOf33//1/b5Twzz77TKlUSouLi6rX61ZfGxkZUTAYVKlU0tbWljwejxYXF60BD4Pe63IDEs4xEA1wUjqdtoxqb2/PmF/1et0aZVFBoP8KCIt92t3d1crKimKxmFHYefczMzMGc62srFhAA1wMEaJQKJgm2ejoqAqFgv7sz/7MzjK1q1gsZkFjpVKxPSTrkS6o5G/2g/WyaMymMM+54l739fXp6tWr+oM/+AOdnJwYHX50dFShUEiRSEQTExPWHuDaT/a/Vqvp6dOnarVaJj5LvabZbGpmZkZ/+Id/qEAgYC0gLqGGNgwCFX52Pp/X//K//C+Whdy8eVOzs7MG1/b39xtzj+x7b29PXq9Xt2/fNiWC/1+cSy6XM6PjsljYHK/Xq+npaX366afKZrPK5/NdKZ8rPPemZIf0Gr/f2dnR8fGxrly5opmZmS5ZlsnJSRN3IxWGUz88PGywDlE1PTmHh4f6q7/6K52enmpxcVGpVErJZFITExMWnWGIoEDiXFKplBKJhDGKei2oYhDdBjtkIojcxsfH9cEHH+jo6Ejb29ummebSbz0ej3H6cep+v9+EIjc3N3V4eGgd3670zcLCgubn500Tq16vW18HdRjooBQGh4aGVCwW9Rd/8Rc6Pz/XZ599Zoq4FFWz2ayk1wq2+/v7FoyMjIwolUp1qUr3stxMU5LVNtyVTCZ19+5dHR0dKZfLqdVqWePayMiIJiYm1G63tb29bWeTLnGiRSjnbiGbuhx0bC46+lWujAt/hsEJh8Pa3NzUf/yP/1Hlclk//elPde3aNaVSKVNeQI4jHA5rZGREe3t7VtdaWloyyjIMrV6X26DoGgjOP8Z5eXm5iw0oXTimYDCoyclJ9fX1qVAoWAboZmrn5+d6+fKl1tbWtLS0pKWlpS6qOwEgRJB2u62JiQlzCtBv6X+DBn1wcKC//uu/VqVS0fXr1zU9Pa2xsTEjQFDnwaFTrJZen0syqV738OzszBAOgkXUR1wb+NFHH+ng4ECZTEbtdtvsiiveyrt04SeQkr29PR0fH+vGjRu6fv16FwqUSCQUjUaNAICmY7lcNqq8K8WDIO/u7q5++ctf6vT01BxLOp3WxMSEEVNoh/B4PDo8PNTu7q68Xq/m5uY0Nzeno6MjHR4efv9ssTt37lgNAqkMl0FCQ9/GxobJX0iy1HZ4eNiohFAW0XYql8sWqQHhIBHh8XgssncLy1y+dDptKrdvSjHwAjqdjhYWFlSr1ZRKpYzmy2fQJYvDqtVqxsXnEriF8l7W9evX1W63lclkTMyQaIrvwCXn0tJUSspL9ABTh+YpIg+XbRQMBruaKiuVihKJhDHl3HdYr9eNdst3gP2DMccpsX9e74X6baPR0MjIiFEX9/f31Wg0NDc3Z1nWzs5OVyd4L+vGjRtqty8k/BEr5HtQWOeiuTAj4ok0rEmy80f/CY6+1WoZ/BcKhbrqWBSlFxcXjelFsx8Gze0DAf6RZAwdcGt6IxDGhI4LLbnRaCiZTMrj8ahYLOrFixc6OzuzumSvC1LLxsaG9vb2rJdLkmkFdjodU4SmqE8tMJPJ6OnTpybe2W5fiIBGo1H7u8A1qF+4MJskI5ecnJwYHDQ+Pm6FcbdHCweOk4BBxRmEpQak1Ol0VCqVlM1m5ff7NT4+LkkWhHJWel1v3mFkiAiQIWhsb29bHQlWLDU11IqB2BHEHRoaMu027jM1IzJLCvvRaNTQChxcNBo19QiCTiD0g4MD1et1zc7OqlaraXp6WvF43Jywx/Na1gh4r16vm5wRNVnYed87W+yP/uiPVK/X9X/8H/+HvvnmG42NjRltcGxsTCMjIyqVSvrqq6+sSC7JWFDFYlGHh4ema4XmzaeffqpcLmeGrNVqmT6P29NwcnKiH/zgB7p3756Ojo70zTffGGwViUSM644DaDabOj09ValUks/n0w9/+ENrzurv7zdl4P7+fk1PT2tgYEDPnz/X+vq6IpGIrl27pna7rYcPH+rg4EAjIyMG7/Sy/vE//seq1Wr6n/6n/0n37983RV8cDP0NKB3DgKH7HEo1tQzp4jDTuUuvBVEgzBx3/65cuaJ79+6pWCzq6dOnBsWQBtPkCHxDhuP1em3/kHzJ5/Pa3d1VX1+fKes+fPhQz58/19TUlH7wgx9Ikr7++mutrKwYjPa++/enf/qnevjwoaanp62Rj/4r1IRh3Z2entqZ2Nvb09bWlsGRZDMLCwsKhULa2dlRX9+F5DgMO5p70TP78Y9/rB/96Efa29uzzGhxcVHhcNio7dLr2h9nXrqgovt8PtOwK5VKWl9f1/DwsK5evarh4WH91V/9lX7zm99oZmZGP/rRj+T1evXgwQMrSLvMvF7WrVu3VKvV9PXXX+sv/uIvNDs7K7/fb/W3QCBgXd61Ws1qWNlsVrlcTqVSSblczvo6+vv79cknn+jOnTsGOeNwgbRwLAQu165d07Vr11QsFhWNRlWr1RSLxTQyMmL0Xrf+CFowMDCgH/3oR11yRbDD+HO/36+trS29evVKc3NzpsTwl3/5l1pfX7fMoVdo7Be/+IXq9br+9E//VA8ePNDk5KRJIRGQFAoFQwNg3+VyOQuytre3FQwGde3aNVM6mZmZsUzw5OREIyMjFjwCs9KkjDIKs6doWwAeLxQKkmROJp/PW9f+xx9/bArNbtPl4OCg2UDaDhKJhO7cuSNJ+u1vf6u9vb3fkY/6h9ZbOxciE+AEWGPUBEirgBiAz6iZEFm4tDaKRBSugGIwum9q7bjFJ/7c1eVx03S3MM9/828x0Kenp9YlCyXS7eiVXnfXul3yvSzwVJwGRUqMIzDKmxTjN/XU3AUcASZOfxGHALYSjsLtBsap0afAd+TvkfXA4KMQyi8ka3gP7J1boAWPdwkSvS72z6U1A3m5MCvPJ3WTHajRcJ7cjnzOX6vVMrq3S1N3f/HZUFHZ706n06Wd5u7BmzAUBgNWGY2zbxIeeAcUrt/HsUivafXcBc6cq6gBNZuzzn672lVAOHw3ek1wCn19fRa0EEywd+4eQrqACECdhH0ks6GQ7sKN1BL5M76/WzN0zyD1ofdZ1Csgv3DPiPr5Trwrl7QjqWv/OINkau5ZhKwCmsEZcclF7B/EDIrxLnzsSr1wj13iBH+fn+Huj1vgp6bGz/reay7/4T/8BzPMzD1ZXFw0B0MBGDySy+kWvICtMBLr6+s6OTmxwVb1et2aACVZeoYTKRQKWltbU7vdVjwet3SxWCxqf39fq6ur8vkupN8RCoSSfHBwIJ/Pp5s3byqZTCqXy+nVq1fGwADzvXHjhur1uqWS7Xbb5DzeR3rj3//7f692u62dnR2TNb99+7bBV+6F5edQIETuf3x83OiqFNG//fZbnZ6eWjPg1atXbY4JGm04s62tLf3617/W0NCQETNwEvv7+3r06JE8notZM0NDQ129JTBwaMA6OjrSzs6OFRFRdb5+/bo6nY6ePXtmwQMd08BEvaz/8B/+g6SLi/npp59qampKd+/etUIk8B8S4jhDWDbI7dArlc/ntbKyYizHjY0NNRoN3b59W9PT0wbHsHcej0d7e3v66quv1NfXZxkjtZD9/X29evVKXq/XNKEQGeT9SK+75Pf39/Xs2TOr8Y2OjmpgYEC3b99Wf//FvBwuNQ6PgX29rj//8z83g3Lr1i1NTk5qbm7OmJc0MgK/Yfj4O8zFgV1WqVS0sbGho6Mj1esXg/UgpkxNTZmRw5Gen59rdXXVxkVQPEbKaX9/X5ubm/L5fJqYmLDZNrlcTu12Wy9fvlR/f79u3LihiYkJnZ6eamNjw7rvmUhJrZE7IV0oRCBP1Wvm8j/+j/+jpAun9+mnnyqVSumDDz6wM4g9QlqfjA0bg8CmJJuXAn06n8/r22+/VbVa1c2bN63bH7kgnPfOzo4RoSDgHB0dKZ/Pa29vTy9fvpTX6zV4F3bq6empXr16ZY4FCGx7e9tIL8C7V65cUX9/v0m9+Hw+y/bfZezIWzuXlZUV+Xw+LS4uKpFIKB6PW8cmnhFNH6IMDDMRCl6cQ8iBA9Ii4xkdHTWOvHu5qaFAg5ZkkBvMHYq0Lg0V5+L1em2qHt3DHHx+bigUsvQfaI+oCGp0L+vZs2dmqIEVmO5HNlcqlYzaKl1ElmNjY6ZDBG1Uks2DyOfzJhooyYQxgYWgGUsy3DwcDpvEA5TRcrmsXC5nOkZEzfyCKQaOXKlUrBaB0B1R/MnJSZcOFlkSzLxe948OegZPoZ/ExD4ya6IzeP+McmWEw+HhoZ0lvj/7B+X1+PjYGEu8i3K5rIODAxvvQB8Pe1EoFKx+4zKIWq2WisWiqSoQGDCEiUuMbhz1LqJtqP2IQPa6MDyhUEixWMzOH+QPgkPIF2SbzKUhQITq32w27V1jWHlHsVisS2oHNhe1D0aM0/cGMef4+FgDAwNKpVIGdZKhAAPNz89Lkum5AfV0Oh2D9/j71H5BV95nmidncHFxUdPT09a34hIcpNfECWwfw/rc/aOvDcQF1le9Xtf169fNsRLgkOUgPRSJRIxNy6gD7AF3EZSJDLBQKFgrAVnnycmJ3X8cD3YGZh7Ufn59787ls88+s/9GFyiXy8nnuxgixIGEZXJ4eGgvll4VVGgTiYQCgYAZUww8F9kVdIPxgGT27u5uV7Ern8/bAbt69ap18g4NDWlnZ0c7OzuSLiiQbDJMFKJGNxMglWfeCY6TDe0VmvjRj36kVqulZ8+eaWNjw/aq2WxqZ2dHpVLJPp8CaqVS0atXr7S9va1QKGRd9el0Wul02uY/vKlw4LJXyMoCgYAZQ0kmcMcgrWq1anPhr1y5omAwqNXVVa2vr2twcFDpdNrkUAqFghUsm82mjUplj5DgaTabNn8bx/w+eDf9DcViUQMDA4YlHxwcdHVlo9TM3x0eHrYaYV9fn6ampjQzM2OZDlM7JVkww4WjQA28Q5QNHHN8fGz1QiaLIgaZz+e1sbGhTqejmZkZg21g+VC3gEVHhIu4KwVtDD3Gq9f1ySefqN2+0C2juRGHvLe3Z/AgdxmIanNzUwcHB5b99ff3K5lMamBgwJh5rqrD+fm5GS0MI3et3W7b38fwUfAeGhqyM0gtTLqgoVMv8Xq9pgV4dnZmn1H8u4FZ9MkMDAxodnZWzWZTL168sLMKI6qX9Yd/+IeWTRweHsrr9Wp/f18+n8+GgvHzy+WyTRPlO+KkcYaTk5N2n8rlssGiZAi8C5rQGSrHueTv53I5m0j74YcfGrEHx8M9WV5eNtgahpnX67U7jPMG7kPVg/7Fd11v7Vx+/OMfq9m8GA28vr4uSZam44UxHuVyWa9evbIDWq1WTWI+Fovpxo0bmpmZ0atXr4yJACNMurhkRHjQSb3eC0mWbDZrpAAu6tnZmWKxmHWNJ5NJ9ff3Ww9MOBw2eftCoWAFUlJUN2r1+Xw2gphncfn8va6f/exnqtcvZoo/f/7cZDbOzs6saItYJ1prRF/lclmRSERTU1OKx+O6efOm0VgPDg7swJD5uRRl6bX0OD+TplaPx2PU7/HxcS0vL2tkZMSguMPDQxWLRY2Pj5veFtP1wIAx5G4zbCKRMELEzs5Ol9Borxf7n/7Tf6pms6kvvvjC4Du0tlZXV1UsFjUxMaFkMqlaraa9vT1zLFzmdrutsbExffbZZ5qYmNDjx4+1t7f3O85FkpEZYOO4pIdOp2OKC5zRiYkJXbt2zaAP6Jzr6+uKxWK6deuW+vv7DZKr1+vWVPzm1EWcS6fTsSF334dz+fTTT9VqtfTw4UML5mgwfPLkiQ4PDy06JXuq1+sWjI2PjxuB5vr160omk3r16pWdJ2iqzLanxiLJoF2EFAly/H6/ZX9jY2OanZ1VMBjU/Py8Maj29vaMKi/JBtwFAgEbi0AhG6gtEAhoYWFBrVZLu7u79t2IxHtZ/+Sf/BM1Gg396le/0vr6ujqdjmKxmKQLZCefz5vwbqlU0sbGhmXVkG2uXr2qaDSqpaUlJRIJPXnyRBsbGybMS3nB7V/zer2KxWIaHBw0sgqai0BvjUZD09PTdgap7xwfH2tzc1PJZFIffPCBjSbJZrM2mRSFAUlG72aqJYGHy7T73tliQFng8G6NhXGlGDVJVlBmpsP4+LjRMCWZtAuNbNAkoSNS4ELvi3SdnxOJRCyboQCIA6A4RdRO5ElU4HbF8iySLJJz588DsfDnvRYFXZ2heDxu3eXtdtv2gKFbrqwGkA4jAmi8JNviPcC3fxOXJ9p38WAKhn6/39J5IC+XKk6BG2iHdw1tmeid/QGSAuqRXsNMwJq9LqAjCpD0kEiy8dbUV6gD0UgbDAY1NjZmTadkJTQFQ/+UXmfNnI1Wq2VEB5wAigVer9cyTL/fb+eQGh3FcgqrFERhQboBmSSDIfx+v9HkOcf8+fss4CsILGRJ9GIwiXVwcNDgVMgfnBlEGMn0+XPk+1utloLBoBEUXFhbkgVqQID8PQI3zpVbmHbnyLTbbTuDPp/PnJcLF6OOnsvlzBByrwgielnMgqHoDpnJ6/UavM27J3vizksyG4gmGk4ZvbZkMmn32SU+cAbd2gvabNDVyX55b9g7Sgjox0mviRz8otjP/tLg6Z5BShvs99ust3YuDx48sB4IDsfExEQXn5qiFeJtSHlHIhGNj49rcXHRHAIKqYlEQuPj44ajDgwMmAAcMy5wMkRVgUBAd+7cMXl3OOMcdjR7RkdHtbi4aIfU4/FYOs9Fg8ZKissIAC4gRUzXifWytre31el0FI1G9emnnyoUClkNgjGoHFayK/DddDpts0q8Xq/BZqVSyeoKN27csP13IwtUD05PTw02Gh4e1vz8vMnqMJ5gZ2fHDAe/Bx8eA5pMJi07oP5CQRejTIGSQms6ndb29rZ1v/eyvvjiC+vcli4UHW7evGlOplgsdkVX6XTaxkbHYjGNjY2ZNlehUFA2mzUoVXottInCMXARHefu956ZmdHnn3+uQCCgly9f6uDgwGSQIEv4/X6DkWhkxdEmEgnT8eJzO52O1c/o+nebj4FP3ocx9utf/9p6GghYcJLM8MApolh+fn5u5zMcDhvOTz8EPVWcT0nmpJDBd1mKOIFwOKyPP/5YgUBA3377rba2tmwPITCQ2aFhSAAwOTmpyclJU0vGHtFgzB4WCgUzoIlEQplMRuvr6z2fwV/+8pcGu0L3Z+YJPS6QIDwej/VAUdtKp9O6deuW/P6LuT75fF5er9ecyo0bN+T3+xWJRAyShFixtbXVJcuSSqX04YcfamhoSM+fP7eGzb29PcvU6V1aWFiQ1+u1Mgb121arZbWWYDBo1OXDw0MdHx8rm82ausr4+Pg791q9tXMhjXUppxhtjDBFM7c5LxgMKhwOW7Hc4/GYUaIA7HZek0pjqNyDSZQjqUvLiRSQDIdIXbqIRImMkF0JhUI6OzuziIKoyKXRkmlw2XjOXi83+4eBcZ+F6JZIklSYQq7bpNdut40B1m63zQDRyMhnujRMskAcrEtHxCExU6LRaBhkQuaC6kG73bafU61WLVDAyLgZHhLyFGbfRxFZeg1dosfEmYN1BE2VgiVzh1wWDAxC+jdcCMslgHBW3P3j+dyGOeRuaOYjqKEOBlUZ6rFL60ZRwqW58/MpVLvZj0uP73UhX8L8IM4dDge6MfIu7CcBFn9O1F2v1y1C57vz93lu/h4UXbfBj2ARajGBJM3LnGFsCVkrygmQTN5sjoTdWCqVTBsOG/E+6EOxWOxivrJ/LlUfG1Kv1+28waTkHNJgixMCTXGHq4HAcB4hrLiqJthcYDAafjnXBM8ogfDz3JHLnH+XFi7Jsnv6oN5s0Xib9dbOBbmRdDqtWCymTudi7KX0esb9yMiI1TuSyaQZRC706uqqFZvoLOfiApPxAthAIlNYJefn59rb29N/+k//yYwL1NjNzU21Wi199913hpXHYjHTgfL7/Va3oPkTGAwa79LSkrGC+F71el2RSMSKsr2sJ0+eyO/36+rVq9blDRvJzSiAChhHfHp6ahpMQD4MUoLl0263bRgYxft6va5sNqtarWZQBs6rr69PDx48MDgIfbO9vT07XNCL0era3t6W3+/XD3/4Q83Pz+vk5MSK2ch0I9WBNpYbjQ8NDemHP/xhzwYSCDCVShn+/PLlSwtWms2mwQ7BYFBbW1vmwIt/N2UP5hXNtAQVDFRD4gWlZM4FhhfYr1Ao6C/+4i+6OqJLpZJevnypTqejlZUVi0DRISsWi8akgqkHvIjSAaOQmT8E/IIq9vT09Hs7GPYQpACoBzFEIESf72J8OEP0JBnrkmeDCcXwuPX1daMuQ1mFDs8Z535XKhV99dVXxvajpopSR6lUMiLJxMSEdb53Oh3duHFDkUjE4Mlms2nff2ZmRpK67hfwTigU0ueff97z3gGBTUxMWMaHTBRBZzQa1eLiog05I6Ou1WpWu6IPqK+vz2jAkJWazabS6bQikYg520ajYdAkDuf09FTffPONDWMj66AWCAkKvULYjB6Px2bloLdXr9eNWOWSJl6+fGnBI3YE+vPbrLd2Lq58w/T0tHK5nFZWVtRqtTQ2NmZYI8YOqRI8KtIBg4MXMyToUmYDUWTlBRI1UV8ZGhrS4eGhFVUPDw/l9/t1584dTU1NKZvN2rhbPveDDz4waqfL5KAOE4lE7KVWKhWF/25W+P7+vo6OjrqanBKJhCYnJ7uYWe+ytre31d/fr5s3byqdTuvo6Mh+Bpkbaay7f8fHxzbDxhUAJVJyjWOr1bL30Gq1bB+gQeLs6/W6FSQZW4z0PmlztVo1IcFarWYwzfDwsA2ugo2GthjO/PDw0Oi+p6enOj091cLCgq5evdrz/pGxjI2NaX5+Xqenp9rf37domCyMoi8zgKD/cin7+/s1NjZm0SJZBXI4RJnAq/TMABfidB4/fiy//2K2OZAB3eUwf+7du6dUKmWfxfekdoFSMk6e6HZjY0Orq6uWAeE4oT+/z/J4LuapT05OqlQqaXd393ca7ZCBicViZqQkWQYMWxMnTa2F1oKZmRmrI7gKyARm4P+rq6tWK6POg6IBwqKM9mi1Wjo6OjIjDhQ3Pj5u55P3Nzw8rGw2a+QVambRaNTEb3tZZJDAYaenp9rZ2bEzAksSscmRkRELiprNixHWuVxO/f39unLliknYkGUzByYcDhts5aI20mvV50qlorW1NUNCGI8OnZmsJRQKaWlpyQJ5SV3ZHHDe2tqaweCRSEQbGxt68eKFSf8jfxSNRt9aQPWtnQtFcPjPFAFrtZpNiczlchZ50HgD7gq8I13MRQCaQAKaNPj09NSMI9itK1gJQ4lhXryAkZER059yvzPjk3n5XCiowBT0GTpG+k7nOYf59PRU6+vr8ng8PUU/NHYRxeC0KH4TFRJ5YARduXD0l7g4QFpuFzN/v9VqmdbV1NSURYtE+XSHA03EYjF98MEH8vsv5nsDsUEbZTZ9NpvVkydPdHp6ajUAlGspHHJW3Et8dnam/f39njM/HIWb7fL7W1tbOjs7UyaT0dramhnJaDRq41sx3GQynMmhoSHrXKfITv8L1M90Oq2hoSHl83ljelEHBMadmJjQD3/4QzuPBEpEhC6mLb0Wj4Smj/EFPqN2NjIyYgEBUXKvKxwOG4zqds5XKhUdHh5avxk9ORBiGB0NTIfmHbU/pn8Cpx4fHxsxAmdPpuGqRriEBp71zp07VgclGISNSgZVrVbNEDMeASgOOJI9dmEk2Jq9nkECBLf2QWYJ7Tifz5vDAb7LZDJWS2LeCoQcEAlYocjusH+gNjj6w8ND7e/vG12e4Jzz/sknn5hNg4Czs7NjdVRqtnt7e1177/P57Lu5CgqUEggI0MN7m/XWzgWjQQpKc9Xp6akePHhgG0qH7n/2n/1nNmp4dXVVExMTRoldX183LwpDATwQCRQ6nSlWIztOBgRrrV6vG03y5s2bGhwcNK2rv/zLv9QXX3xhxrOvr88UmxmOFAqFdOfOHWNhEeVwuME+8/m8Njc31el09G//7b996wPJYsgSPHUiupOTEz18+FB7e3saGhrS0NCQEomEfvKTnygcDlsRDXVhV9mARjSXEeLSC2ne+uijjzQ+Pq6VlRVTQkBFGTYaERc1DI/Ho2+//VbfffedAoGA9QltbGzo2bNntu9jY2P6/PPPDX6EHQP2zIIy3qtxhNGGg+T81Go1/fa3v9WrV6/M+E1PT+tP/uRPlEwmtb29ra2tLaXTads/GmTZb/DlTqdjDWn9/f1Kp9MKBAK6efOmwuGwnj17ZpEcWSHPPD8/r+vXrxv+3W639ctf/lJffvmlhoaGFIvFrB/C/a5jY2O6d++ewuGwQSkwooB8g8Gg9cy8Dx0+mUxa8ZbaIsbsu+++097enqLRqEWvd+/eVSAQ0MrKinK5nEHJ7faFsjSOle9EULG3t2eGeGFhQUNDQ7p+/bpGR0f17NkzPXv2zIIpt9aUTCZNg416y8rKip49e2Z9FxTDt7e3rSs9FArpww8/NBaW9Lo2TEMh2eP29nbPZxD0g+BBuoDtz8/P9ejRI4NiBwYGNDc3p3/zb/6NYrGYtre39erVK2s+9/l8ymazajabVuM6Pz83AhO0aZQ8QqGQyd7/9re/tQFqDFwkWJidndXt27c1MDBgrNG/+qu/0hdffKFQKKSpqSnrfYFQUqlUFAwGdfv2bRNUBU0BBcEWugrob7Pe2rnw4ijmUYR0u6Hdg/amjAmpFPQ46XXR2S2mk3oStXi9r0d2Uv+g85SMg3/jFsHcRfGQi08kwwXgWYjQiEpdLTMcZ68FfaIGfg4dznDbITa4citgqRga9o+Iwi2Sc7ElWXMVNQE6pel2phALU8zVMaKQ7fF47L+l7imOREt8R87B+fm5RbAwoTgzGLJeF2OFkeFxVQyAFlxiCBg/xU0yUb4PkJgkM7jSa6wa448xwaG5zWucZc4flxLjyC/p9R1wR0uTubvnj6bWNyneGPL3YYtRMH7zDJLpuR367v5StOe8kVmQ6VNHYBIsGQT7yDsjY6eojhPGyXMG3fYA3iXnnv12C+dktZxBlJzdO8zdep8mSmrBEBVcvUEyELfoDTEJ++PqA2K/pNf3lfYE11Zxr0E52D+3RcLV2HMJC2/aLd4NP5NzDWxH7Q3H5d4nqXuE+tust3Yut27dstoJUTeYJlIILBoY8/m8hoeHjSbLQV1cXDS5Z+i0kUiki43lMsV++9vfqtW6mDi4v79v0f3w8LAVp/L5vB4/fiyfz2ewTj6ft6I3BAN6TL7++ms9efJEkqyg+O2332plZcUiBpg64Plg0b2syclJdToXumBkDTix+fl5o1tiADc3Nw2iun79ujVW9vf36+OPPzbI8ejoyJgmLouP+gpNczRcomo7PT2toaEh3b59W5OTk8rlcnr27Jlh8n6/397N8PCwTWOcnJyU3+/XixcvdP/+fYP1Go2Gnj59qtXVVXtv9JGQUpNt9rJ+9rOfGYuPmgZR271793Tjxg07/MiGHB0dKZVKWQMlF31iYsLgRP4+tHoyEb5ns9nUN998o0ajYdMaXUNHp3WpVNJf/uVfyuv1GhX54ODAHB/vw43gv/rqK7XbbR0eHlqB+8GDB/Z9BgYGTA2g0WiYrlevi7HQaEoRdLTbbV29elVXrlyxxuf+/n4LHmKxmI0gYITw0tKSwuGwjo6ODPJhX2EW8a7Ozs709ddfW72KuSiTk5MaGBjQ8vKyEomECoWCXrx4Ia/XayMpgMtCoZCSyaT1d9DxDwmFHhCUzd1Ale+Ec+l1ffjhh5IuHNXR0ZE5sU6no7t375qNxEHQvBkIBHT37l1DFHw+n2ZmZhQMBk3yJhwOd7UTuHWNSqWiv/3bv1Wj0dDR0ZFJ6AC1z83NaXx8XOfn5/r222/l9/tNGgliBPJHgUDARpQ8ePBAGxsbVu+p1Wr67rvv9OLFC/t7BADciXepV721cyEddpV9MRbQPYkKoWNWKhVjk7AwOAy+AoLiQVyFXxwM80uo39B4FAwGjTXFprNgUcCQQlacDlToq9Q+wEs3NjY0Pj7eRUiQ9NZFrL9v0U2OdIq70Fhy5TKoKQEnUjvCecKNh7ZMtEiERnROH4o7WC0UCimVStkYgUgkYlg7kSMZj0uHHRoaMnJFJpNRp9PpwnwPDw9NeJAoVnrdlf8+kXcqlTIev0uL93q9pitFpCjJaoPMyjg7O1M+nzdnMjw8bO+eoGNgYEDFYtH6pYiIqS9g6IkUcRzUYzKZjLHXOMvAHgQosVhMiUTCcHAmEHq9FzI2GxsbisfjSiQSBkNjsNzIt5cVDAbVbrdNuYJ3g6Fya5TUV+kvGxoasucH35+YmOi6wzhE7m673bYAlI5wFgaPMzU2NtbVvEx2Lr2OzHHQ1Pc4YxjtRqNhjpN36jaySr3LN0kylqxbHyGIYp4KAQuOlGI/7Fi01oLBoCKRiElfBQIBJRKJrtYJYFegMmSaaONgX1D2YM4V75QAwWWKAm1CqqJ9w73Dr169MnIO9pzs6l2yvre2mKRjNCJJr3FNjCOXFifEJhFxc6EfP35suDIzJGA3EOGWSiUdHBxYdIrWV7VaNSmJwcFBbW9vm0GbnZ01owLrgmFQGOydnR2TNYHvTXro8/lsABdREmkuzqxXvJYLB04MDRHYAGyYbngOIR3z9B00Gg09efJEq6ur9u/4fZ6RAwhLBwffbrcNN4aGu76+3jVxjj6XcrlsTXNuc6Yr2w6dkiCDTBSZEFhWLjzS6+LS5nI5ra6uSpJleSjAsoek/G4tDwir0+loZ2dHzebrKZ/SBZ4+MDBghgNWoiTr1SJzCQQCmp6etgx9d3dXw8PDWlhY6KKlUozFSCNYWCwWjfoMRZViOIycVCqlgYEBU1CIRCLWJ9brot+h0WgYNRqYmHczODho7QRAzfR8Eb3WajVtbGwol8tJkhkv9ptghud0afbIl9CSMDg4qK2tLdOwm5ubM6ZjsVg0KRhYfS6UQxbu8XiMUUkdAgflQkYEZb3uIe8WFWwyF0gfFMT9fr+dARftYb87nY7W1tZ+p2cQO4gThyxBtgOsCTKB89zd3dXm5qZGR0e1vLxsP9M9N9iVcrmsjY0N7e7u6uDgoIsUROM4tVx62oBJYdN+7wV9Dtf+/r5WVlaM405WQLRKhgPkc3R0ZNFyIBBQrVbTs2fPdHx8rKWlJdOgcp0LHnh9fd26qNHcYtY9EhPPnj3TwcGBlpeX9dlnn6nZbBqtDsji/Pxc2WxW5+fnpr6McyG6d2mqsVhMExMTpmDabrcVi8VsMlsvi4wELjqXbWBgwJhEGDGXkddoXEjJIxWBc6lWq5qbm9PCwoK9H3e/OZjBYFA//vGPlUqlrJeFGhkF+mKxqKWlJX366aeq1Wp69OiRTk9PNTk5qStXrpjTwtBA6CBbJZtlOFsikTDhQfYPufNe9w8Dnc1mrcuayyBdRJX0rsCAQrKFoWjj4+Oq1+va2dlRoVCwyZxer9fET0ulknV4r62taWhoSJ9++qkVYuv1i5n3c3Nz8vl8+uKLL7S2tqbbt2/rzp078nq9JkwZj8dNZwoSC2xAnEun0zE1b+SSxsbGlEql7NJ3Ohcju9PpdM/7J8maNnEuboDDPpId4JAxSLCyMPKwQlFswLnAMAQWZyzDrVu3LDs5Pz/XyMiI2Y8HDx5oe3tbt27d0o0bN1StXoz6LRQKGhsb09zcnLEBmR/DmWOPDg8PrV/LdS78wgF8+OGHPVORcQDFYlE7OzsWBJPVu/VRt17GGQwEAkbb3tjY0MnJSdd4Avfvox324sUL+f1+LSwsGAIEEy0ej8vj8ej+/fva3NzUJ598oj/4gz9Qs9nU06dPVS6XTZ2iVqvZmATGiaAwj+MhY8W5QBYieI3FYu/U6/fWzoWJfowadg2U3++3bnEOMJRXGoYwnAi4EdHS6MSUR7D0UCik+fn5rgiHOdSDg4OWdgNp0YNQr9fNyEUiESsyM2WRQ0AaShGbTIHCOUVpCoeMtu016jk8PLRDceXKFaNIulgw0TUGwC0QkxlSq+GFHx0dWbTBIec5aXTr7+83iIZJkhQjiaqI1t3eFH5xIHESvAfYVzhOejg8Ho9RmLlscOV7Xdls1oq/NH6hgkuQQHbs7hHZDTBEo9GwaZMej8fqbfTRsEKhkObm5qw73VUFAEaQ1EWSwFnk8/muMQSoL9frdTPmoVBIk5OTkl4zJrlLrdaFPDq1Kij60Ed7Xdvb23ZPp6en7fchdtD3QIaDcjJ3EKiV8woFnpoLe+0SJCTZ+XRhRBfLx5iivovUfKFQsNERUMSBeQhWQUlwLi5TKp/PWyMmjYr01rg14rdd1PoCgYDS6bSdb7eVgb0i2ONcSLJ7QxZAxgIcTf2LDNG1tSjKc6b9fr8hBpw/gm+CBxAjanfo85H9BIPBroAFtAnbwvgDFkH69565PH/+XF7vxTyUTz75ROfn512KxjRXTUxMqFwua39/X+fn50aHpahOc9bZ2Zk2Nze1srKiaDTahe91Oh1NT09bERd6qPS6kQnnVSgUTOeIqGhzc1NHR0d2GY6Pj/Xs2TO1221TIw2Hw1peXtbJyYkePXpkTZzAR+vr66ZJFAqFtLe3Z4oEv/jFL95222zdv39ffX19+uSTT/SP/tE/0vHxsTY2Ngy+KpfLpkGEc4Tqi/ji+Pi4detSP3n06JGi0ajRRoHBksmklpeXLdM5Pj7W8PCw/R7yE8ycJ+uEs39ycmJF01wup4cPH0q6KKyD2V67dk2np6d6+PChdein02lJ0jfffKPh4WHdvn1biURCe3t72tvbU7vd1r/6V//qnffv4cOH8nq9WlhY0L1791Qul82gwGBB3NPVZKK3JR6P68qVKyYTQ41kc3NTsVhM6XTaok2/36+5uTnr9mauENCo1+s1Ugb0YaDEarWqR48e6fj4WIuLi6Yhxfm7cuWK4vG4ZmdndffuXZ2fn+vFixcWAdNMSMRKLW1jY8MUmf/L//K/fOf9k6T/6//6v+Tz+XTjxg394R/+oX03l2VJ5lQqlbS9va1KpaKFhYUuDS1qAGR4z58/VzAY1OzsrLEPiXBx2ASDkUjEFMnJzg8ODrS9va2xsTHrQVtbW1Mul7PgqFgsam1tTZL08ccfGyw5NDSkYrFomSoTMIvFoh4/fmwjOJLJpDY2NvT//D//j9rttn70ox+98/4BH6dSKd28edOouZAJ+PnMqkdVZHBwULVazZpXJdm8lt3dXb18+dJqwTjBRqOhyclJG3eNQjVBR7vdNk0/bAWahNVqVa9evTJ1DOYV0Ti9sLCgaDSqRCJh6gfPnz/vmn+DMgj6kKFQSJlMRq9evZIk/et//a//wf16a+fCDBfwPqIpt5EMnNHNKIhkoWFKsgNKio2Xd6mDUEhxNi79FO/uGhbwaxguNEOSyrrfs9FoWPpPxO3SR9HygULp0vZ6XcyekC4iGIqbbiGa70hECEuISAU1XTJGYCouqfRac43CJ3RTisxES+wFv3hfwA3UVfh+OHd+nzoU0JTbJU9TLPRTngdorZeFwJ4kgytdvSiMo/sO36TT0gntUuPfpJRyhvv7LwRBOedvnjf2laiUPYJt5VLa3b12M1IibByK+27A8vlzPv992GLU2ygyE8XyTG7zIc7ZVdnt6+uzrIb7QuYB047vTKZHRsMeSrL3yNng3dFDdH5+buea/XXrZ+5ZJzKnduC+QyJ7WE4Y4l7PoDs7CeICkf3Z2VkXdR9ExLWLZLIQhVzb4tpBt4fGld5583xj66D8k20iKosNdAk1nEF+H1vuUvM5E5zVWq3WhZq8LSninWAxMFdkLvL5/O84BKCGly9fWgYzNDSk5eVlzc/PW00E7DmVSpl0gWsg6EKvVCp6+fKl6UMB+VCoh0zQ19dnA48kWdH1ww8/1OHhodUNCoWCDg8PlUgkjPO+vLysZvNiqNDGxkYXd5/O4v7+fiUSiZ5hCTjn1IhIMX8fD79cLmt1ddUcDNRQpFjOzs5M7gLI5vj42AqdNLIdHx+rUqno+fPnlpm1220jSBAZ08NCdAnTJB6Pa2FhoasOVCgUdP/+fcXjcaNXR6NRBYNBw4lhwAAlEsFB3uhlYVgePHigp0+fGt7Nu+7v71cul9Pe3p5h9gioAnUyghkSiNd7oUgbDAa7elnISFZXV62+AGxDhhEOh83BplIp1et1ffvtt5YV0gS8tLTU1U2OInMkElEul7PIemZmxjIC+l+Ab5A6uXHjRk97xwLCQSWbzANnQ83p9PTU7goyI0dHR5qdnVUqlTLIZG9vzyBt/r3X6+1S9AW24mcCM6PwwPe6evWqhoeHTVMNWGhhYUE/+MEPTN7o7OzMhgCOjY1pfHxcHo9HiURCsVhMu7u72t/f18DAgLU3cNf6+/ut4N3L4vuWSiVrqIWKTIC1urpqd5P/hb0FXNhqtayg3mq1LGshaOb+FYtFo8Hv7++b1h12i2ZnaleSrBUAAtDs7Kw+/fRTk9VBoHZ9fd1qV37/hdo5NUneO3qMEBWAGN92vVPmgkdDlp7NpkEIjJO50HQyQ8HEgEFZZbhTX1+feWDYFnxGuVzW8+fPjWLHZsL0cWUfoFFKF16fAhSMikKhoOfPn5uEQTgcViAQsJR/d3fXDDpyF+CZgUDgvcbM4jwymYzpOeEM3mzuxHmQUns8F7L8bpPb6empRW4ej8fSZmociEqSegPtNBoXkhLUuFy2Cs6HPgWmX1IzKZfL2t7eNjiUvacPgcyUoiQyF0ToLn77rgvHd3BwYMPHiPbHx8c1PDxsQ6owQNVq1c5KIpGw7wbbJx6Pm04bESTRIxe5Vqtpe3vbYFdEODljCKs2GhcyNJBTCHzon8lmszY+253iGYlEdOXKFYVCIb148cKMMQq8zN2hxvU+BX32Hzr82dmZ0eLD4XBXLQ4jhNTK6empwuGwnTeo3SAAQKgQPIB2iKJfvXpldVCCFe4qWlq1Ws3gxk7nQlF6fHxcCwsLGhgY0ObmpgqFgjY2NnR8fKx4PK5m82JSaDqdNnYdlFl6v6jD+v3+9woQmXbqNqBC5Y3FYkbXBipDkJQAh3Ef1EQymYxGR0cVDoetKZUaF0oeBI17e3umcAFZgTMIVbzZbJrDojgfjUZ15coVDQ8Pa3d3V8ViUVtbW2a7yY5mZ2c1MDCgjY0Nq6Fjnwh2KG987wV9LieGhzkTFEsxkNJFJPnJJ59IktFREX3ESHCJzs/PTQ6dlJEov9G4GPa0vLxsOjxuF68ky3Y4TJJs4yuVih4/fmyGodm8UByFwkcBW1JX9O/3+5VKpeyyUHDc29vrOeqJx+OSXmujIUBJ966bRcAEkS4yO5hWGFSyC/YR2Iz94fMgU1BEJC3mZ5LFUMwlIgIvHx4eVj6fN4ir0+ko/Hez1pn34jZHUnvr6+szuRj6RIi4el0UTMl+KK4jocLzQDqJRqOSZD0RyWTS9o9fFFvpFsdwut3lXu+FrAaQAIVsl2oP0xDWn6uosLa2pmKxqHw+r1qtpvHxcUWj0S7mVSaT0eDgYJf0DIVcGIKQBN6noC/JsmNUGpgwyh2WZCOI79y5YxArASIZGJAt8Ar3lu8svYbGaLqEDUcGDpkHWBrozePxaHJy0v775cuXZgypAYyMjBjLD5iboCqfz8vj8RjDr1qtGiHlfWBFF6YHasXuMbodhQqfz2fvkHNKcODeV/6/9HqMA7C3G6TR4uGeCdAeF0Yjm+Ec1+t1C85BE8iUYMpKF4QZv99vE3AHBwdtGi8jD5iR87brrZ3LwsKCyStQS6HxjLT44OBAmUzGBmLREYrAJYwhNgRoAwfFDAI2C32d5eVlDQ0NGT0ul8vp/v37VvMBR6djlcL28fGx/uqv/sqckd/v15UrVzQ2NqadnR2TSGfD9vb2rE9jcXFRfX19xsvPZrPa3d3t2blMT08bR/7k5ESjo6PWQ+LOTIEEcf369a5BQ0SKMFY4YK7TdRvNuOxkcBhfqJSrq6tG65ZklzAYDOrOnTsaHR21iMltmHUzGfBrov1sNmvEBHoTtre3tbe3Z93ave4f2Q9QVDgc1vT0tFG5ITmgyjA3N2dNs6FQyMROgXzK5bIZOS40LCZXtoYOaDfryuVy+u6776yG1GxeSNW7qhHch/v373ed86tXryqZTOrw8FA7OzsGO3U6HTt/qVRKH3zwgXw+n9bX102JAZrt+y4y34mJCS0vLxtzk87zg4MDJZNJ/eIXv1A8Hu8qqu/u7ppOnJtZU7x3HYV7765evWp11FAopJOTE7169cqo7WShwC8MsysWi/r666/tuXn3fr/fCBnurCSII7FYTNevX5fX69Xe3p4ymYzVxHrdQ6jAbuDGO5+dndXIyIi2tra0tramcDisDz/80HrByAZwyDAbkQKSZDYQJIjAliCA9guaHb/++mtj9NE3mEgkulSPT05O9Dd/8zdd2fDs7KwikYiOjo5MB46aKnd4YmLCqPWcQUoKb7ve2rngDVkUiVutlk2wcw+WJMtOiPS42BSyiIqgB0uyqJLowOPxdFH6uMwU/Ph7RI4uxENG4xb53J4aomGeCwODgSZydSOBXouBFPb4eTRLkda7VE4gNNJkMFTmuzApEeovURsEBFJr4EIcMM9BRESajVNCucCFyNg39pHMC1owe8l+vpmFko19Hx3mkuxdsX8w/Igg2T8WmDf7h0OEPgqllWjR7ULnGdzRyjyD2539pkQOhhXI03VWfHcIGrxjolL2zyVIDAwMWIb9PpkL0bDbzMezkZGCJFAc5+7x7tkfzqr7zt2GXgwoelucfwgfQM+QFIjw3xxpTABFpsDdcYkXbjEa5wRiwr0lq/q+ziB7SaOyew941/ziGYDRKLrX63XrsAfC83g8ZlfZG+woNhI75GagLonH3Sf2hPvPvnImGWgmyQIBeoO4E24jqptp/UPrrZ0LhpyDwzyXwcFBff755/bSwA7phC8UCiqXyxYFUtRsNpuKRqO6ffu2XaJms6lXr15pZ2fH6iX1el0vX75UvV43SYJsNmvzLhKJhEZHRxWLxXT16lXV63U9e/ZMpVLJ1H7BjdvttrLZrI0/XVhYsF6PZvNi0BBpO9AF0SljiHuNehjrzMrlctak9/nnn1uTKD03W1tbZrQGBgasWH56eqqtrS3l83ktLi5qeXm5S/dsa2tLuVxO4XDY1KHRIuLQZDIZPX78WNVqVQsLC9YIB1V3d3e3C093HcvLly+VzWZ19epV3bt3zzI/Ih++L9nT5OSkzTuh+NnL4kDjKA8ODrS6uqpAIKCf/vSn1g0P7AORAHo6FwpZoqGhIU1OTurDDz+0i9lqtbS2tqatrS2Fw2HD5xmlOz4+romJCYvuK5WKDXaampoyfbPd3V3lcjmbpUHGAXX+/PxipPCtW7fUaDSM4DE1NWW1Kww7mVc+nzeD3+sCWuEs1Ot1PXjwQMPDw/rJT36iiYkJDQ+/nk+/vb1t43MlWQ9UpVIx/ax4PK75+XlzqNRU8/m8JicnDY58+fJlV80ll8vpwYMHqtVqWlxc1Pj4uFG02+229vf3rX7g9gDxZ+VyWYFAwIaeEYxNTk4qEAhYhiS9VkrAzvS6cPCSLCvY3t62e8XfceHgcrmsTCZjag99fX12vwuFgtLptO7evWsOol6va2VlxdSesUMMdWOfstmsZWOTk5MaGxvT1NSUbt++rVqtpidPnqhUKmliYkKpVMrGE6OCzQiDhYUFU1FpNBpKJpNGucdJocdI9v69s8VI3Vza4PHxsQYHB7vUVTFEpLq5XE7Hx8eGB1I0pWBHcxaX6eTkxFg0HBgMBAVkMiCMMd41FArZqN7z83Obesf3cim+FDC59BRPoYgiI0Khne/T6+UGLyetRfOLpr839xrqLbBXqVSyIj0Rn8/nM4igr6/PsknID5FIpCsDob5QqVRMpwiYaWRkRLFYzJSnIQy4Sq+dzoXEC/x6IDWyA7j7ZLHuXrq6Z70ul4qJMCWFY/fPqa14PB7TTGMRHNFIC7EBw+gOTWNEBAoJTPikzkQ0yWUkQOD80TwMZZXgjEI+w6RoDnQhSt4ZGRmswfdxLmQr3AdIOdTC0MbCEQPB8nvsK38fQkkwGFSn0zHqMKq61DY7nY7tK9FzsVi0czQ7O2tUcQr7sCbfrOPwc05PTzU0NGR7Bu3WJY8QDJL9kaH3mv25qAXZQ6FQ0ODgoDV/utRpMvxCoaCDgwOr67lUYb//Yqqn+wzFYlH7+/tqNpsaHR2VJJsLRKbIv6dOStY3OjpqPWzAW9DHgXypG+KEeWewBlutVpdKA/e3XC6bzXyb9U7yLx6PxzptocBCK9zY2DD8NBQKmfLm8PCw5ubmzLDhybmEKOpS8ESWQpLJO8zPz8vvv5iQxxhfRm8mk0kbF3v//n3Txmq326bXBN7e6XQMz4RZ5G6U3+83iin/FifJpe6VrROLxSS9JkRg0KkNcbDcQ4DS7Pj4uLLZrB0woAAyMqi/GCoOHVEqLB9X6BPjCKZeKBT0zTffqF6vG1MNJ+f2B8RiMXuWv/7rvzbjin4bzoTmxUwmYxMKYdv0sjjopOdMQPT7/XZ26IQfHh62c0LwwjlAkQB2GKOgoTAj6AjpASVonokAZGZmxqaXUoN6+fKlarWaMpmMXfBCodB1/mAGnZyc6Ouvv7aAp92+GMo0NjZmTXnAyVx+F6bsZYXDYUmvpYjYH5/Pp9PTU0MD0MEiSIjH4wqHwyqXy8rlcl0Q88nJibEfGbLWbrftHuXzefl8Pi0tLWlxcdE0q2iArdVqmp2dVTweV6fTsVHJZHgulAzMNDIyong8rkbjQhDThXUIWsmeMaawJWF39bLcwjltCuwTs2JQunBVnGdnZzU1NdUFcVerVTPgTEHl3qG9xi+XbQuy0tfXp4ODA1WrVctuz87O9N1335kdhSyCDWNWEJ/JO8dhA4sRlHIGCdibzab1fr3NeifnAoOIh4H+BiceDJAHQHIDY0ZxnIIeB7JcLuvVq1fW5U/Ui6eemZlR+O9GggIVwdEeGxtTMBhUNpvVd999p3a7bVghvQluzcGlTR8cHJjD7OvrUzQatcZDnocI4U0s/10X7CUWMGGz2dTe3p52dna6lE5xsMFg0OT4t7a2bI+gNEIQoD+HTIteAZwLkTWaTtC/OTRQI90aFNkWnHe6u5PJpFZXV/Xll19qcHBQCwsLVmwkOhwbGzN6LiwyVxX3XZdbFwMPhgWXyWSMesxlwwElk0lFIhGLdovFouk6YcSOj4/14MEDnZ2dmXOk5hIMBnXt2jVFIpEuskk6ndb5+bnBBXRB45zB1mGgSa/rAaOjo9ra2tLKyookWc0I5QhEM3FKvMte630somDeORR3omVk1zlHjAOfm5vT1NSUUZJdFINx05VKRZlMRq1WS+l0WmNjYxY4BQIB20POx/j4uFFcGQpYKBS0vb3d1YRL0x8ZeH9/v27fvq1kMqnd3V2trq6aYyYg4A4xwbPRaFidw30f77qoU7j0Xwwx2ZpLGiBDJgDGcSBlQw0ll8t12UBqQzh33sHIyIg5M6/Xq0QioWq1agrHTHt1HQKTK6XXKuIQn5DYkWQ2EwJRpVKx1g4cs8vIfZv11s6FdBP6KawYClBAAaenp6bEiQwD0Q7duFNTU0Zj5oVBtcW5jI2NGfMB2iIGnsI2joyDQ1EMnS1WqVTSzs6OpXsudg08AgyG1D1wRrFYtEsNtNPLAnqhf4CaCC+MVJWLAsPr7OxMq6urKpVKlr1BzZZkhWZ6LXgWBOvASYExMfRorblRiNsYCJwBdkzdgb4VopjBwUGDf6BhSuoiQ1DABgPvZQHHQmaYmJgwKjcwAT+fvolAIGDzMljIahBBk/bTQAZcGovFND4+bo4D2LfdvhA9hWFDPwHZPPvBu+l0Ljr8M5mMJNkeuKrXFMSBgFutiymiOBfgk/epF0gyogY9S6OjoybGCqOOzAXCATUCmG3SBeQ0NzfXRdbp7++3RkDGHLh9UhSngXCLxaLBX5zJVqtlkbE7FRE0IpPJmLPhz+jF4M5DGYdpis3hvrv6ce+63DHL9P2AqhCoId0EQoARJwvAYY6Pj9sIhHq9bs8MuxYRXc4gP9c9UxCcaKlwYWzuMk4ZxAj7Qj8SxCACNu54p3Ohgwh5CojvXTLnt97peDyuVutixO7e3p7u3r2rP/qjP9LIyIhFFtlsVgcHBwYl+Hw+/c3f/I2ePn2qcDisVCqlYDCoH/3oR4pEInr8+LEePXqkvr4+G5RDyhaJRDQ5OWkFLvSDuND0rXCQUqmUlpaWFAgEbGY8afTLly/16NEjlctl89BIXzCHIhAImJcPh8Mm/U3RzKVr9rIQ6oP+d+3aNet+j0ajGh4eVjab1f7+vvr6+kzx9KuvvtLz588ViUQ0MzOj8fFxXb16VZFIRN9++62+/vpryx58votZL8yLj8Vi1jRILevo6Miggk6nY8ygkZERzc3NaWhoSOl0WsPDw3b4nj17pi+++MKKqGQ0U1NTRvsdHBzUw4cP9fLlS83OzurmzZtdbD8gzV5hRYwTRJHPPvtMH3zwgUGidLczLhoc/6//+q/16NEjK3gGg0H98Ic/VDgc1u7urnZ2dtTX16cPP/xQXq/XiqM4C3S+UANAgQJIAghydnZW6XRa4XDYxiJT73nx4oUePnxo0ThRLI6FHgm63kdHRzUzM6NGo2HqwJFIxGYgvc/qdDo6ODjQ1taWbt++rVu3bikUCllwg9R9p9OxusLq6qoePnxozmJkZESfffaZIpGInjx5okePHqnT6Vj9iuwvnU7r2rVrajQaphKBs3BrEkC7k5OTunr1qgYHBxWJRLpEXFdXV7W6utrV0lAul5XNZu19h0Ihk5OPxWLm7HhPZE29nsFEIqFms6knT57o1atX+uSTT/TZZ58Z3CjJ2jEIBL1er1ZWVrSzs2M1vuHhYd28eVMjIyN6/vy5njx5or6+Ps3PzxsERtvF2NiYWq2LQYlohQFzMZkSOG16elrXr19XMBi0u4lzefHihZ4+fWqkGpQkaEdAZcNtJ1lcXLSAB3v7LjW/t3YuFPsk2eGA2w6Ec3Z21tUxTzc5cubQ9ej0JFvg8/l3bsSLAwGzJwLgQaFKgrXifdGecou1FCf5HsBPLvUXWMj9fRq9+PNelts/Ib3WHpJk2DekBbdZFDiRugaOAFkatNH4dzRsuc9NAfHs7MyiEvbAdZiu5hZRCs/L3yEyBH4gmnYz09+3Ty7NupcFU8iNxvhedMyXy2Wrk7AHRP/oc7HfMJbYB3ceDO/e1VxzIT13RLVrLF3Iwn1u3jXnlvol39XNiF1c3913/vt9OvSBYfg+wKY8tyTLkthzvi8SRNwNFH45p1CyecdvagGyh9ByOSNE7m57gt/vt73Fyb25p64Sh5tlu3vmnpM397KXRRnAJVywfwStZK+cBdiL5XLZIHgK58iq8JluA7R7f9kzMktIN9w1/g53jPfs3uE3f3GX3Dv/5p+5No+7zR16m/XWzoUouNW60MIZGhrSr371KxuShFbS4eGhccwp8rpYczAYNJYKcIPH41GpVJLP51Mul+uakeAeKjrtMbBALZ1Op0t+4X//3/93FYtFi+CRLqDh6+zsTOFw2DqvmQo4OjpqQ5pcGRhE994H8x4fHzcMFrWDX//61xZJp9NpZTIZm7dyfHysTqfTxXTC4aJVtbu7q0wmYwVs6KNnZ2fW6Q8e7IoGujABh4eUPp/P62//9m9NaJOUn4IkdEl+ZqvV0nfffWe9CPPz84pEIqa2SyrvQma9LOb+oA49NDSkX/7ylwoGg5qbmzNngcIz+0HhlTk9iH9S14DFQ8H00aNHdi5dnBkaPTRc6Lywj4B58/m8/uf/+X+2LIVzg/I39RVUFxqNi0mruVzONPP6+/uNSMEZJxB7n4I+d5hMc2hoSPfv37dMYXBwUPv7+9re3tbAwICSyaQZGAIXIJVMJqOjoyNrqqTW5/F4jMSRyWSs4A7R5E1mI3AQPRqwKL/88kvlcjmlUiklEgmjbwPxbG5uKhAI6Be/+IUqlYo2NjZsiudHH31kdgOoHUjr9PS0ZyfDNFQkgIaGhvSXf/mXNkZjbGxM2WxWR0dH5mwIUiQZI45AnezDnXwqSd99912XDaSfze/3W4DN59FbiG2t1y/Gmf/2t7/tEtPsdDp2BkEraHKHGIENXFhYUH9/vzkxVA/edb21c8FQwS5CXBE6MReCjlE6S90MBywfHA/vK73mkO/v73d1gfb39yuVSml4eNgyGH6f+gwd/lB2Hz9+rO3tbRvWNDAwYFx3SUYUSCQSOjk5sZSdojcHwlUIJmrs9WBC1/T7/RodHTWp8oGBAS0uLmpkZMQgCTpz3X1hQeukCA9cI104H7poiS7J7sBQwfxd5yLJMpxSqaTvvvtO2WzWGjSRT4GOiNGlJrS7u6uzszOTNoc9hXGV9N7d0RMTExbcoCi7trZmBt7n85miLj+P7IWJpwQYXGxUBjBs7XbbBAXB1QcHB3Xjxg2DsjBOnDukc3AyZ2dn+uabb5TJZCyKRD/MbUyjN4bpqMVi0RrqiHZdPNyNLntd3GEG+rVaLe3s7FjzLSyuvb0909JzNaz4RTDo8XgMriaylS5EbhnOR02K84ZhIyuXZPeTd1MqlfTVV19pY2ND169f19LSkvUigYY0Gg3Nzc1peXlZ+XzezmwymdTk5KTVaan3kWEjd9LL4oxwFqvVqp1Bgl0EQcn4sDmSrKkWiNzNSMjWJBlc6zZHzs/PW6uFKwmDbZVk6NDp6akeP35sUyyli8Di2rVr9m88Ho9GRkaUTCZ1cnKizc1NFYtFg+nJKLm3QOHvkjm/tXNBx59o1qUjM9uh07mYmMfm0SgpybqRiRrpmCbdpl8DLa2zszObGrmzs2PGkfHG0usu7WbzYkgQ8BVzJbjMgUDAir+uJlKhULCeGWYz8Lmk6l6v14pv7yNcube3J+n1zPKhoSHT30IQslarGaOHhkAmYrr9QFzm/v5+a3wD3pqYmDC5mOPjYyvkNxoNLS8va2Jiwt6B2zUPCyYQCGhmZsYGakmyjM7n82l3d9dYgcyRIMtjLIPP5zMiBA6FPppe929nZ8fezejoqOr1up1F1H29Xq+mp6fNCHq9XhtMR2AjyZwQ50+SQTKoEMOcgqW3v7/fpTwgyfp+KFRD0aYZkuVK/bhKEwzBAtM+PDy03g63Ex1K/7swdX7f2traMsflKk/gLFBzZlYK0AwQLLUUft9lhTKbHUeLYyE4w2EvLi6aijROB7aaJAsSEZyNxWJmYGko5N7m83nt7++bWCmICBIm+/v7ZsBxahCTellPnjyRdAENv8kCpFfJ778QUmWPaIR1NQTpfaH4z1lmP5GUgYHYaDT06tUro2G7Wbnr4GGxSdLs7KzC4bA5fWretGFQK3QFSulLlF6POADCJdD4/4Ut9vjxY3m9F6KG8LcjkYiazaZ2dnaMr07HLKlgKpXS9PS0FeLon/B4PKaXFAgEDLOdn5/X0NCQMpmMXrx4oWKxqFevXqlQKOj27dtGFCC7OD4+toYqekCWl5c1PT1tG0eB1O/3G+0PAgL01FKpZMVv6hw+n8/GkI6NjVmRvZfFzOxoNGpMpvHxcTNQuVzOxivjhFutlqanp63OgFHiMAwODpqDYk8oWqN0cHp6qlevXun8/Fzz8/OmWAC8xWe6URVFWIZgRaNRmw9fKpWM3QM8RwMZzsytuWCE0ALrtWbw8uVLK7jjICnyF4tFFQoFLSwsaHl52RiErVZLMzMzWlhYsPPXaLweG82gL4wAkuJDQ0NaW1szRYSVlRVVq1VduXJFi4uLkl7LCCEo6fdfKO7S0+G+r2AwaKKFOBD+LeePX9LrmTxAYqFQyIZ4vU/d4Pnz5/J4PMbmlF7XAt2i8NWrVw1+oiucnhFqnWD8ZB1ktzSUDg8Pa2NjQ/fv37cJkPl8XhMTE0YOgpHJwDqv16toNKqBgQEtLy/bWA2QiWQyKUk6OjpSoVAwSIjekvPzc5vMWigUTLNtenpa4XDY2Fe9nsEvv/zSbALw+fDwsFqtlg4ODtRoNLS4uGijRSAwJBKJLhvYbDaVy+Xs2RnvAcozOztrOmkU4Z8/f67T01MjYUB84vwfHh4aQ43xDJCf0L5j/9bX101pAeYtcNve3p5B2gQh9BUB5b7tGXxr50LUDvXYLfSCyxJVEx1Jrztl2Vh+D0+Ooi0v3B0ghKeE2onXlmSFWHBJ+jEwbGQIGF3SQ6Ju93OJtt1/Q+TLcov9vSzSciJ+olHptaEikuD5+DMcqduJTspMdy/fDaMrybKdWCymcrlsRoD3yPujDsP7IWLmz4EAIDhAUyXD3N/f74LvXNICRkiSOcFeFhETcCDfjZ/DdyRIIKNwzx9BBc9GIybnB/IIF5L3Az09FApZNAhMQPZOI50LH1EIpRmX3i0+G5YRWadLBsA5gZnz632cCz8HtiVFZDcYALJ22VzcKxdipW4HDR5DB8zjZkicUxwb1Ps3h++5/S1QzN0iPecfiJ3R6S6d391jsn/OLWe9V+cSCoXs37qNpsBFsFB5BujCBC9k9+5+Dw8PKx6Pd8ksAfvROtFqtSxboTmYrEWSwXJAw9g793tRe3XvJPRx6XVzN8/EnkvdyhjvYgPf2rn88Ic/VKvVskFLPBDQjN/vV6VS0crKihlLDBGbTtoYj8dtBsOVK1e6Buvs7u7q5OTEJOnRc2o2m5qcnNTU1JTNdK/X60qlUvYdt7a2ujYDuKLVahnElsvldHp6qhs3bujjjz9WPp/X1taWms2mwuGwRkZGujpRfT6fyaBjhHpZ8/PzarVaevXqlVZWViwqowYlydRvXb460S97Cqef3ozl5WWdn59rd3dXlUrFdJeGh4d1584dtVotLS0tqdls6u7du5qbm1M2m9X29rYx6vz+i9kRe3t7dlF5n0Boa2tr9n3QzProo4+sGI0IH0wtLgVzfd6UuHnXdfv2bbVaLT19+lTffvutzalwLzfqt1xQCtEu+6ivr0+Tk5Omq7SwsGBSMicnJ8pmszo5OdHQ0JCmp6fVbrcVjUZVr9d148YN3bp1y/YD+iwd99vb2+rr6zMqPI2UhULBziY1l+npaX322Wc6OjqyrnTOH5AOAYcku0fvs5LJpNrttvb29qymRi0NY062iiFmYVTYa54jFotpfn5e1WrVggwXeu7v77fBcn6/X0tLS5qZmbExBMAu1EsZUEUdDOfc6XS0v78vj8djWdz8/Lxu3bpl5CC0yFBDYGwFjKz3IeRI0ueff652u62NjQ2tra0ZuQQHS0/QgwcPzMm0222DUzkPfX19mp6etnEit27dMkiqWq3q8PDQ0BiGc3EWQVKwge12W9PT05qfnzd5fUkWsAN/VioVGzOOPYnFYvrkk0+Uy+X08uVLk+MfGxuzRnKCWpeY9b07l2g0qmazadItYIrS665pxAldCiAe0b3crkx8NBpVuVxWPp83JgbCkhhYxDDpxncPOv0nMLtwCCyiFiQ2YPxAC6S4DyRE9OhGEWCPREa9LDR8gGyABFxqLd3RbiTrUl3pzSGyAC6QXkelREfUaaAb4jyh2nJpydDc6JqfgdMjCnP3lEZDDIiL4ZOVEmCQCbh00XddOH3weajFLl0S5o3UTekF5+a78lwoYIPfYxDy+bzi8bhSqZRFnRh/VAFwWJBAeHdu0x5nHqKEJOvoB8euVquWyVMbotZHhsD547z0ungnLuEGiNpFDtCKo77iQqfu3SDjd5sBgVrOz8/NLtDUS0e722sG3ZjMhAZOWFIsVy+OXpFQKGS1wVAoZIQipni6OmI4u17PnyTrOdne3rYaBwxQSAMYZUgjLpUYCNltyyCD5Qy2WhfiqsDy7AOlAzI/94zRfPkmq4uM2uv1ql6vWx2U98a741nc5yDrJ7jmXb2LDXxr57K/v2/Fvbt373bp9YCXkg4SrVD0Hxoa0unpqY31hSlWKBS0urpqqbMrrUDvR6dzMfKYLlFYKEhNxGIxu7DJZFLValXr6+s6OzuzzIeIHprj2dmZVlZWFAgEjA3h9XqVy+W0s7Oj8fFxG4n76NEjHRwcGCGg15QaxwdhgbSWgjtQBKkw1FDG8B4eHlpW2Ol0rG9lfX29q08BxhEHBIddrVYN987n83ry5IlqtVpX0+DU1JRRGavVqhEo6vW6GV/3glKUhhzAv0un05qcnJR0gfMfHh5qZGSkS/LiXRfF6GQy+TtsFs4TFyAQCPwOqYOpi61Wy+iiOD2YN+DVPDskFGoPPN/Z2ZmdP+m1Ei4DsQjA+NnUr6B8UrNA2gWYb2trS8+fP1csFtOdO3fUbrd1//597e3taXJy0px4r4ufk0qlLCLGgRUKha4OcArzROUwRCn4QiLJZDKWLXI+kFuizsbPLhaLJtN0cnKi9fV1NRoNaxp0SQuuUgDBI8b3+PjYmFmu4gT3O5vNamJiQrdu3ZIkY0658ki9LGRU4vG4xsbGuoQ8d3Z2LIAiY4bEwc9ERaLdvlC9OD4+Nno3Z4LzSJc+wScknlqtZnI7ZC405vb19WlxcdFYbOVyWWNjY4pEIvbuqHkTzPLeQXb29/eVyWQsM5QuqNH0hL0LY/atnQsS5kioHx0dmVCf29hIYRSjPzY2ppGREYO9oBM3Gg3TdRoZGdHi4mJXhz5NRkSNwAtEAEdHR10ZDNglMzuYU06X9dHRkWmgET0QHVIvoO8BmrIk/eY3vzFa6ft2mHs8HutwxtgR1TJGmpeHw0gmk8avf/jwocEkFPyQO7l+/bpx6Dudjv0v/QRklTs7O8rn81pbW7NCH78ikYiJ2eXzees4Pz8/73p/vBOYelwYLjY9NjQxUnCnl6mXRf8PsMr+/r6+++47nZ2dmaYXTg+o1pUhArqrVCrK5XLWUFosFjU2NqYPPvhAw8PDRr2mKE2ETic0Io1keWSF4+PjmpmZsfnqh4eHSqfT1tXtMiQ5z1DGOYuZTEYbGxv68MMPtbS0JOmiF2p9fd0o+e8DjZ2ensrr9Wp+fl7pdNqUBjB6iMZi1IC/kMk/PDw0GRv+fH9/X3t7exYIkdG12xfzflKplBqNi7ECEChgd2WzWXk8HlMJ4M5jrM/Pz602iQF0GzCB0SRZZlcoFGx8MAXsv/3bv9Xm5qZRwHvdw1wuJ5/Pp9nZWaVSKR0dHZnYJ+QPzs/AwIAxD7nP5+fnGhoastHjbt/X4OCgotGoZQ8u/Zx6Yr1eNxKNO/yL95VMJjU7O6tisaj79+8rk8lYXRDCDdI/OOTt7W2rvXk8F9L+x8fHunr1qqampiRJDx8+tOme7xLgvJNzAS7B6yG9gRoqdRjocERndHW7lFkOCRspyVJMcD0KUDQQuTpDRNL0owCnVSoVDQ8PKxKJqF6va29vzyjRo6Oj9vukzKSv9XpdY2NjCv/dHA++Xzgc1uTkpBKJhInx9bKQG2fvgOX6+/tNXhtGGsJ7Ho/HaMQ4EfaZYmWn0zG4w23aI8PBAHJY6REBfnF7fzCAQG0ej8eKktFo1AKIVqvVJS3BuZiZmdHMzIzi8bhR06mNMHK21/2jOAwmX6lUTLIC2NAdetbpdKwwipOjlkSmQXOdOxHQhR2JRCmg8vzAL0Su/f39Zpj5/xT+aSJMJBJmJCCroCxAJDkxMWFquoVCwVh28/PzJlH0PpkLYxTo7QFlaLfbBtsibEq7gdfrNaiJ5lwgM4Q9odqSBQFVU2AGfnVZoaenp6b0TGTeaDS6fs/v9xsk2GpdNG9jM3B8QO7UecbHxxWJRBSPx42IQKDoFs573T+v12uwPa0DDFmjHoQ+HeeWxVlEFBRqvPR6uiV/7vbxAYeRrXNXYT2STbsjUKhZS9Lh4aHa7baSyWTXHXap6CzYfBMTE0a4GBkZ0eTkpLHFvnfn8vTpU4OOEPWDsgjWDU4tySRHisWiRcjIaiNaR8ENvJ+LicGj85deBYwnXcT8DJQAgLdonsxkMlpfX1cikdBHH31kzs3r9Vp3sQtZfPDBB0bDdamsqVTKHFOvB3N9fd0yrMHBQaVSKd25c0e1Wk2rq6s6Pz/XtWvX9IMf/MDohbVaTevr6yoWiwoGg0blxakA43i9XkupkWin3kHkgiElqgK6IWIpl8s6OjqS1+tVMpmU1+vVwcGB9vb2FA6Htbi42DVjh0iXgGBoaEj37t3TzZs3Dfqgt+aDDz4w49Trov/j1atX2tzcVCKR0M2bNw2jbjQaSqVSmpubszpBoVBQsVg0eGBmZkaSjNkFAYEaBGk/NRHYX8wlwWDu7e1pfX3dZGXa7baJo/p8PmtE297e1vr6ulKplD799FMLkrzeC7Vg3gHB2c2bN7W0tGQq181m0+j9zC55n5rLwcFBF9uJO0lPxeDgoKanp7WwsKB6vW7wy97eno6OjjQyMqKJiQlTyOCuUnOCegvV3uPxWEM0TaySrGMfw0hLAUEid35wcND02SKRiJaWliy7GRgY0PHxsfb3962e0Gg0dO/ePSvyr6+vq9Vq6cMPP1QwGLQMrddGVAgvRP1jY2M23Aynw3AuiAVoclGng0lIHRnjTqCC8admBLQKI4+1s7NjtR/uYbFY1N7envr7+5VMJjU9Pa2XL1/q+fPnSiaT+uyzzwzu7e/vN1Vpl+EHMoASOoQBWhzepdfvnYaFYcTcAU0u7RQjAzboUhPdArH0muJKncGlNLOAq2h+4v+7hT63+9btHIeCzAtEvoLf5zOBPYi4AoGAsZvAP12doF4LgtBI2TcKqXwfMgwUh4FboGe6rCj2+/c5OldXiG5kPpufRXTOYcdx09jm0mJ5diA3omyKz6T7ROMoDVD/4N+SXfS6fzwrAQZUU54HcgcZFTAZRI/BwUErVLv7RJZHkfpNMoekru5w9oRFhA/kxtlkvzEmb2ruURuj4VSSZQLAHo1Go2t08rvoOv2+xd4DTeMcuLtuzdPdc57tzWFiZHZuoZ/PIhMkSyT7Y0EsoQF6cHDQMhT2n892zylsRKJ7hldx1wmizs7OrK0Bu9SLsq+7qLG5lPU3oWz2D6ICd9hlq/FM7BF3isVn8rP4XDJdSV1NnC71ncyPO4x9xP5BsODz3Am4zeZrqRxqOY1Gw4JyUKvv3bkkk0m7wJK6ujkpBPISXUyaaOH09FS5XM4up9fr1e7urnZ3dw3zZggYw3SOj48VDAY1Pz+vaDSqw8NDa3JkU+fm5jQ3N6d8Pm9UOxgN0WjUIiBYX8fHxzo/P1cymdRHH31k7KJSqWSwy9nZmRWwMKAnJyf2d//1v/7Xb7tttsjSMLBg+LA36G4mvaaYCtPDlbJn/gzR78jIiMmLcNCLxaJWV1fl8/mUTqcVCARMRJRnRb16dnbWRhuTyfl8PuvroDObfSqXy0omk7p+/bpOT0/1m9/8xqTtt7e3u4rldCCfnJyYXlovy5Wx5yIib0Hth73pdDo2rIt6EVFdX9/F3J7BwUGtr69rZ2fHSCqwt4AZcrmczYQZHR3V8fFxV+2IWS/z8/Pa2trSkydPLBqXLujnV69eNXjILUBPTU3p448/Nt06Cqv7+/s6OTn5HUMITf192E6oZVAfc/tqcCDMGqnX613TFdlTZEmY3+MyBOkDgfpaLBZNJf2TTz5RPB43SBFHPTAwoGvXrml6etqQBoxao9FQPB7X4uJiF6RLtjIxMaGPP/7YbIa7h9ls1kYDezwem0XDyOleFn1JQInYQOo/p6enpiLgsj9RP2C5XfhbW1va3t5WIBDQ9PR01ywhKPKBQECxWMzIIchm4UDm5+c1MzOjbDarzc1Nsy0oUy8uLhqTlMbyer2udDqtn/zkJzo7O9O3335rDcXUgIt/N1wMR3hwcGA2/9/9u3/3D+7XWzsXV84Ceim4Ol7arclwaMFD8YQUxvv6+pTNZrW6uqqpqSl99NFHVuwiPXQbvcBKwWAlWYGOouHOzo79GVRPJDmoSVBUHB8fVzqd1snJiWG5OEN3aiI/nx6IXi+3OwuCiMoVoEPzhzoIeDKYMo7BLbgiYUJUgcSJ1+tVqVQyAT1YKxg4KJ00UcViMRUKhd95l/F43IqM0CfR1yJVLhQKXbpNXCQiXNJtJFd63T+iaaJmSQY5cNkgQeC83QZGzh9QGGoNL1++VCqV0t27d+1ikyVwuXDE7XbbiqFE5xTyITVIsig1HA4rnU4bu6xSqSibzapUKimZTCqdTqtUKhlkAxzrCo1iCM/Pz9/r/EkyKAY6vjuV0aVN82cuhZw6aa12Mdq5VqtZJub2pVB3AqbO5XIWDFGsZ+FgYrGYZmdnrcbo9lgEAgFNTk6a06b+yAhfdAfJViCYsI+0PQC5vQ8sxhkkc4Usg6MBkmaxp5QNOBcuzFUsFrW1taVIJKJkMmmQLFkN+4CRd2uqIBJjY2NKp9O2t3yvRqOhZDKpubk562PDIZ6eniqZTGp+fl4nJydGTKBWSZBFRiPJ5hK97Rl8a+eCKu7Kyoo2NjY0NTVlRVqwfr4Qm+H1XkxLg122sbFhL4lmQKRVgC+gINMgieEiMkY2YXZ21nBJagdMZuOFxONxLS8vGy5PDwjMiW+++UZe74XkBBx2fkEdhmdOWtnrwcTpZrNZ7e3taXZ21i4UhwE2G3poXq9XCwsLmpycVD6f1+bmpqXROGr2BzYcLL1IJGIyEZOTkxoeHu4SdpycnLRU+ujoyAgFKAjUajWNjIxofn7eDBDYdq1WUz6f129+8xt5PB5dvXpV165ds3SbKI5aG31E7EEvi/ezsbGhvb09xeNxc9gYOL679Hoe+dTUlGKxmAUybh8K5w+WHBTcWCymaDSqmZkZeyb053BU8XjcsvDz83MNDw9reXnZjDMElmQyabVAsgB6B548eWL0dNSQXcgXhwis8j6wrCRTsd7d3TVq940bN4zhxT1B5QCkYnZ21ppv3cmPGDy3859/B7sNggpD13K5nLa3t9VsNo04wB5SR3RZjgMDAzbSuFwuGzOrXC5rd3fXiDkLCwtWbwMZwRYRdEBg6PUOI1i5sbGhTCajdDqtWCxmkD/2D4IQezE+Pq5EImE2EMcLdEqNCkNOTSQSiVhgODg4aGhOPp9XuVxWIpGwM0uvSjqdtvoX5QhUKKiPt9ttQ2O+/vprSTJZKrcB/e/rC3rb/Xtr50In/ZdffqmvvvpK5+fnunPnjuHN1WrVirZ8Qa/Xq3Q6rUgkopWVFb148UKNRsMwvdHR0a6D1263NT8/r0QiYSkfTYcI0u3v71uHOPghHfSTk5OWdeC17969a70kiAPSc/Pq1StFo1H9/Oc/1/j4uPb29my2N/IhCOdRY+j1YHK49/b29ODBA0nSH/zBHxjNFUrt0dGR4ftDQ0O6ceOGUqmUvvvuO21tbRlbhKwGVkomk7FDSKGWDnaceSaTsQmE8/PzdmCBl5LJpLFO6NZF6p73e3R0ZBH4o0ePlEwm9W/+zb/R1NSUdnZ2rGhM3QUdOox0r/uHPP0333yjhw8f6sqVK/Z8ZMz0TgFLeL1eXblyRbFYTI8fP7YCL7+IHr1erwUdjBoeHR21MQmcGUQmfb6LsQnULMrlsoLBoG7fvq1yuWyD6RABhcFIHcDnu5hZ//XXXysSieizzz6zZmI3uyNjxXD3unes8N9NK83lcnrw4IH8fr/JxxO0nJ+fWz8S52lubk6JREIPHjyw8QoITBI9gyrA9qTXbXZ2Vp1Oxwzi/v6+1tbWbJKtW7drt9u/05AJxZnAAfYp5+v4+FgTExP6R//oHykej2t3d1f7+/vmwAnCeMb32cd0Oq1Go6Hf/va3+s1vfqM7d+7o448/ttoRPXPuvB+Px2NOaGVlRc+ePbMMGMeMnhpZ+MTEhMnho2DNnQT66u/vN5HWgYEBlctlDQxcjISnp6VUKqmvr8+mrMIkw+EeHx9rbW1NkUhEP/nJTxSNRm1MAo6OveqFSPLWzsUtdLpsJKnbk7m/5xaP+bfu4s9dBhQYLhsPBAL+zOcToVDIc7+j+52BL9yiI59HisnfYQP5Ob/vEL4PW4fPdveOz+P53iw4Usz7+7j57nd2/y17+Puejb1xIRH+jUsYID3n77v/BgiN6NVl+fHnb+6f+67edXEugLp+X2HWpUa7Ac7fJ53CM/l8vi6yAb9PRO4+Dz/zTVq1Syx48/fcn/Pmvrsd3vzZ+56xv2/x2W5B/s3FOeLZOAP84u+4n/nmv+fnQBAggnejYtc+uJ/pPr/7d97cG+6Ru4c4ud+3f7/v/bzr4t+7NvDv24PfZ6s4l79vD9/8DJdMw89h71yyA3ebd+b+nDfPKt//9z2HSy568zl6XZ7O+4ZDl+tyXa7Ldbku1xur946sy3W5LtflulyX6+9Zl87lcl2uy3W5Ltf3vi6dy+W6XJfrcl2u731dOpfLdbku1+W6XN/7unQul+tyXa7Ldbm+93XpXC7X5bpcl+tyfe/r0rlcrst1uS7X5fre16VzuVyX63Jdrsv1va9L53K5LtflulyX63tf/y8fbWwy/qiBOQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 64/200 [05:42<12:21, 5.45s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▎ | 65/200 [05:47<12:08, 5.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 33%|███▎ | 66/200 [05:53<11:57, 5.36s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 34%|███▎ | 67/200 [05:58<11:49, 5.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 34%|███▍ | 68/200 [06:03<11:42, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 34%|███▍ | 69/200 [06:08<11:34, 5.30s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 70/200 [06:14<11:27, 5.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 71/200 [06:19<11:21, 5.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 72/200 [06:24<11:16, 5.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▋ | 73/200 [06:30<11:15, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 37%|███▋ | 74/200 [06:35<11:08, 5.30s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", - "Step 74: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 38%|███▊ | 75/200 [06:41<11:24, 5.48s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 38%|███▊ | 76/200 [06:46<11:10, 5.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 38%|███▊ | 77/200 [06:51<10:58, 5.36s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 39%|███▉ | 78/200 [06:57<10:50, 5.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|███▉ | 79/200 [07:02<10:44, 5.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 80/200 [07:07<10:36, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 81/200 [07:12<10:29, 5.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 41%|████ | 82/200 [07:18<10:22, 5.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 42%|████▏ | 83/200 [07:23<10:18, 5.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 42%|████▏ | 84/200 [07:28<10:16, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 42%|████▎ | 85/200 [07:34<10:11, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", - "Step 85: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz916/lWXoWjj8755zTyalOnepKXd3T0d0zg8NgjLABG2EMSAgBQnCBBIg/AAlxzRXiwtjAV76wkQwS9ozNzHh6prtyPjnucHY4O+f8uzh+3lq7ZvzzqV391U/66Syp1NV1wt57fdZ6w/M87/tqxuPxGJfrcl2uy3W5LtfXuLT/v34Dl+tyXa7Ldbn+/29dOpfLdbku1+W6XF/7unQul+tyXa7Ldbm+9nXpXC7X5bpcl+tyfe3r0rlcrst1uS7X5fra16VzuVyX63Jdrsv1ta9L53K5LtflulyX62tfl87lcl2uy3W5LtfXvi6dy+W6XJfrcl2ur33pL/qN/+7f/TsAgNlshtFoxNHREb744guYzWb85m/+Jq5du4ZGo4FqtQoA0Gg0GAwGuHv3Lra2tmAwGGAymWA0GhEIBGCxWOD1euHz+aDRaCZeazwew2q1wul0ol6v4/vf/z5OT0/h8Xjg8/lgt9sRiUSg1+vR7XYxGAzQbrfRbDah0WhgNBqh1+sRj8cRiUQwHA7R6/XQbDbxgx/8APv7+5idncWVK1dgMBhgNpuh1WrR7/cxGAzgcDgQDocBALu7uyiVSrBYLLBardBoNPiX//JfvvFGf+c734FOp8Pi4iJisRh2d3fx3e9+F0ajEb/xG7+Bq1evwmq1wmazodFoYG9vD41GA6lUCoVCAZ1OB/V6HQaDAdFoFHa7HSaTSd67wWAAAPkMHo8H0WgUrVYLX331FfL5vOyz1WpFMBiEyWSC1+uF3W5Hv9+f2MvBYACn0wm73Q673Y5wOIzBYIAvv/wSBwcH8Pl8CIVCMBqNsNvt0Ov16PV6GAwGcLvdWFhYgEajQSqVQq1Ww2g0wmg0AgD8q3/1r954//7BP/gH0Gq1iMViCAaDOD4+xk9+8hMYDAb84i/+IhYXF6HX66HX6zEajdDr9dDv97G3t4dMJoNSqYSTkxPo9XosLy/D4/EgEAggGAxiNBqh0+lgOByi0Wig2+0iHo9jfX0dlUoFv/d7v4e9vT1otVpotVp4PB6sr6/DbDbL62i1Wuh0uon3PDs7i1gsBgAYDofodDp48OABkskkLBYLnE4nzGYzotEoLBYLxuMxxuOx3I1+v4+nT58im83CZDLBYrFAo9Hg3//7f//G+wcA//Sf/lNoNBpEo1EEg0EcHBzgBz/4AUwmE37zN38TGxsbGAwGGAwGGA6HaLfb6Ha7+PLLL/HixQvo9XoYjUYYjUbE43E4HA6YzWaYzWYAkOer0+mg0+lgNptht9vRaDTwxRdfIJfLiQ1wuVyYn5+XnzcYDOj3++h0OgDObQDPKr9utVrR7Xbxwx/+EHt7e5iZmcHKygoMBoM8Gy6n04loNIrxeIx0Oo1qtQqNRiPf88/+2T974/37rd/6LWg0GthsNthsNhQKBWxvb8NiseA73/kOlpeXxQ5ptVqYTCYAQC6XQ6lUQiqVwuPHjzEajeDxeGCxWBCPx5FIJCbucLlcRqPRgMPhgN/vR6vVwv3795HP52GxWGAymWCz2RCPx6HVauX73W43AoEAhsMh8vk8ut0uFhcXMTs7C4PBAIvFgl6vhwcPHuD4+FiepcVikTPY7XbR6/VgMpngcrkwHo9RqVTkuXBd5Axe2LkAkAeo1+sRjUbxrW99CwaDAR6PB91uFycnJ9ja2oLP58Mnn3wCh8OB8XiMYDCIVquFcrksl9NqtQIAzs7OYDQa4Xa7odPp0O/3MRwOUalUcHZ2hl6vB5fLJRuh1+vR6XSws7OD0Wgkh8VsNsNms0Gn00Gv10Oj0eD4+Bg7Ozswm83wer3QarVi3Hu9HrLZLPr9Pur1OkajERKJBCKRCFqtFvb399Hr9XB4eIhKpQK32w2/3z9xgN9kBQIBaLVauFwu2O12zMzM4PPPP4dOp4PT6US73cbx8TFOT0/h9Xrx3nvvwW63Y2dnB8lkEtVqFZlMRgys3W5Hq9VCo9GQw6bX61EqldBsNgGcO/herweNRgOLxSL7NxqNUCwWodFo0Gw25WsWiwWj0Ugc1PHxMVqtlhgCg8EAm82GlZUVdDodFAoFjEYjDAYDaDQaxONxBINBdDod3L9/H71eD/l8Hs1mE0ajUS7bNMtqtUKn04mxicVi+PTTTyWIsNlsODg4wN7enpw/p9MJi8WCQCCAQqEAk8kErVaLRCIBp9MJ4Pwi09hptVoMBgN0Oh3kcjnU63X0+334/X5YrVZ0Oh10u10YjUbUajW0Wi1xqHSyWq0WRqMRWq0WqVQKx8fHsFqtcnaCwaAETeVyGc1mU+7F3NwcYrEYut0udnd30el0kE6nUalU4HQ6xYhOuzweD7RarTipUCiEn/u5n4Ner4fVakW1WkU6ncbR0RG8Xi++8Y1vwG63Q6PRIJFIoFgs4ujoCFqtFna7HU6nE91uV/bQ6XRCp9Oh1+uh0+mg3W6jWCyi3+/Lne/3+3LHj46OoNPpJFDS6/UwGAzQ6/VwOBzQ6/XIZDLI5/NwuVyYm5uT4CAej6PX66FYLGIwGKDRaGA4HErw0Wq1cHBwgH6/j5OTE1QqFTgcDrjd7p8KZi+6+FxdLhdcLhesVitcLhcMBgMcDgf6/T7Ozs6QSqXgdrtx48YN2O12cYw8b8PhEF6vF2azGU6nU+yqVquVAGM0GqHRaKDT6WAwGMDlcsFsNsvdHI1GqFarGI/HOD09RaVSQbfblQDYYrHAbDbj5OQE29vb8Pl8WFtbg8FgkL1sNBoolUpim3U6HcLhMAKBADqdDnZ3d9Hv99FsNtHv9+F2u39mMvAXrQs7Fx5qGu9gMIiFhQUYDAYYjUb0+33kcjk8f/4cCwsL8Pl8ErV5vV7k83ns7e1hPB7D7XbDYrGgUqmgXC7DZrPB7XZDr9ej3+9jNBqhXq+jWCwCgHydG9toNJBMJtHr9WA0GqHT6RAMBuH1esWxcNMPDw/h9XqxsrICm82GWCwGl8uFvb09PHnyBI1GAycnJ/JgEokEGo0GTk9P0el0kEwmUalU0O/35XBNs9xut1xKi8WCSCQCn8+H8XgMnU6HTqeDw8ND3Lt3D+vr6/iN3/gNzM3NwWQywWq1Ip/Po9/vQ6PRIBgMwm634/T0FGdnZxIl0XG0222MRiMMh0OMx2NoNBqJEE0mE9rtNrLZrGQpjFIMBgPG4zGGwyH6/T6y2SxSqRS8Xi8AwG63IxgMIhAIIJ1OI51Oo9PpoFKpyHNdWFhALpfDy5cv0Ww2UalU0G635SJOe7FtNhu0Wq18BovFglgsBp1OB4fDAYPBgGKxiK+++gorKyv4lV/5FczMzIihcjgcEn1x/6rVKsrlsmRndM7AuRE4ODgQ5xWNRlGtVlGr1WTfmCENh0PY7XaJsBm5n56eIpPJwOPxADh3kIxYGUh0Oh2USiWMRiP4fD5YLBY0m00kk0k0m02cnZ2h0WhAr9fD6XTibVoBulwuABAnyztKw9ZoNHB8fIx79+5hcXERv/ALv4BEIgGz2Yx4PI6dnR1ks1n5LDabTTJqq9UKr9cLg8GAbreLfr+PdruNarUqAZTBYECtVkOtVkOn00E2m8VwOBRDzTPCs2o0GlGpVPDy5Utxyk6nE4lEAg6HA/v7+3jy5AmazaYEilarFeFwGJ1OB+VyGe12G0dHR6hUKggGg9DpdFOfQYPBIJmLy+WC2+1GNBoVhz0YDFAul3FycoLhcAin0ymZBG1bPp/HaDQS56LT6WT/+b7oXDqdDjqdDrRarThGnkEAaDQaGAwGyOfzKBaL0Ov1CIVCE2jMwcEBtra2kEgk4Pf74XA4YLfb4XA4kEql5AzS6fFe1Wo1nJycSEDFAPJNAuwLO5dSqQStVotutysGT6PRSKSh1+slndfpdHj27BlSqZS8uX6/D4PBIB652WxCp9PB7/fLvzMKHA6H0Ol0sFgs8vr8cIwCgsGgRJn8GqPoVquFwWAA4Nyom81mdDodjMdjlEol9Ho9FAoFnJ2dYTAYiFMKBoPweDzQaDRy4R0Oh7yX0Wg09eUuFArQ6XQwGo3QaDTQaDRysGiUbDabQFQPHjzAycmJQDrNZlP2qVwuo16vQ6PRYGZmRn7fYDCQ32M0GmGz2TAYDKDX6zEYDOQAm81mgQtbrRba7TacTiesVqtkjZ1OB0ajET6fD2azWQ4yM6RGo4FKpSKvSRjEZDKJo6Oj12g00Ov1b3WxCTXwEjBTYEbEfQwEAtDpdHj58iWy2SwqlQoajQbq9Tq0Wi1GoxFKpRIqlQqsVqtcRsJbzIYtFosYk/F4LM6En4t7VSgU0Gq1YLfbxXkSYqTjMxqNaLVaGA6Hkk1WKhXZP4vFAr1eL+dArz+/lsyCrFarBDZvk7kQsu71emi1WjCZTJIh0NCZTCbJcJ4/f450Oo3hcIjRaIRutwubzYbRaIRWqyX7EY/HxaEymOF7dzgcACD302AwSIDlcDjk9/K+mkwmaDQaZLNZMbBOp1OyxcFgAJ1Oh263O3GHeS7dbjfsdrsESaPRSDJKs9mMbrc79R42Gg2xDbRRRAP4OweDAfr9PiqVCp4+fSpZaqvVQrPZhM1mw3A4RK1WQ6VSQTQaRSgUQr/fR61WQ6/XmwiiuEd8ZgxQ9Xo9TCYThsMhyuUyOp0OrFYrTCaTwGuj0QgulwuJRAIejwfNZlMCTuDcJmWzWYzHY7HfRAa0Wi16vR56vZ7AoQaDAcPh8ML7dWHnkkwmxUgwtWKkQBzQ4/FgYWEBrVYLf/AHf4DBYIDl5WXEYjGMRiPYbDZ0u11kMhm0Wi0sLS1hfn4eg8FADBoPhMFgEK/PlI/RjM1mQyQSwWg0wuHhIQqFAoBzj08oodVqwel0Ih6PYzgcysUib3FwcICdnR04HA68//77CAQCWF1dxezsLMxmMwqFAjQaDWKxGIbDoWDR0zqX3d1d6HQ6ieYZxdIgEl8lrPQ7v/M7ACC8B/FrwgnNZhO3b9/GnTt30Gw2cXh4iE6nI3tEJ9Pr9VCtVtHr9aDT6QR7DYVCGI1GePz4MXK5HAKBALxeL7rdrkR6NpsNPp9PIDDyWePxGPl8HslkEnq9XmAmt9sNh8MhUNtgMJALwHMzrXMhjFer1SSKj0QicvYYHS8tLaHT6eAP//AP5fUZkLjdbozHY+zt7aHVauHOnTt499130el0JBAixOV2u+HxeNDv95FKpVCpVORCM4giHl2v1xEOhxGNRjEYDHB4eIhGowGDwYBwOCwBAc+f0WhEMpnEyckJTCYTlpeX4XQ64fV6BaKkI6YhpgOadv8A4PT0FMArTsRmsyEQCMBsNsPn8wnPOTc3h3a7jT/4gz/AcDjEwsICIpEI+v0+vF4vBoOBBGkbGxu4du0aut0ustksut2uBE6Ei4bDoUArhIIsFgv8fj9GoxGePn2KZDIphrPT6eDp06cCR/MOnp6eQqvVolarwWazYW9vD7u7u7Barbh+/Tp8Ph9mZmYQCAQk0BwMBpKxNJtNtFqtqe9wLpeTZ6gafwY3AAQOrNfrODw8BACBqLxeL2ZnZ9Hr9fDo0SPk83mEw2Hh9h49eoRWqyXnmw640+ng5cuXsh/qMxuNRuI0PB4PHA6HBDDD4RDxeBzxeFwc3mAwkGA/mUwKZ3TlyhV4PB65wyaTCa1WC51OB4FAADabDSaTSSC5i6wLO5dutysbxUNOI8aN1ev1sNlsgtN1u125sAAkoqGhIY/CrwGQQ8HfOx6PJ7gei8UyQZ7Sq/6si8fIgg4LgESGZrNZ0nEeFJ1OJ9ElSUo126rX61MfTD6Ufr+PXq8nBoOfZzweC/bPrIDZnpod8nMRnjQajcKrABBHyEyBl5xRKV+T0Q2fBY0Z/5BgNJvNGI/HElHyey0WC1wulzwTZmTcZx5EEtWMNqeNGvlc+v2+wAbcG36d54/QYKfTEXjw9YyR+8L3ORgMJHtRMxj1D7MyZmY8p6ozUM8g90s9f3wuZrNZCHGeQY1Gg263K5+NmcxwOIRWq/0pUvVNF+8w9wJ4dR/47JhtMDtR7zAjXH4ONWjge2Smx/9nVK/T6TAajeQMqgaZZ5l7o0JEfE5arVZ+J7/fZDKJ82UQwefA9zUej2UfSVZf1Di+vpj9D4dDieD5/HmH+Ww7nQ6azaagKhqNRvaL+8z3zfNEOJrnjXZN/UN+lYGaRqOB1WoVh8Bzy6/xd3S7XXn+tMcqTMt91Ov1YnNpm+x2O2w2GzQaDVqt1oX368LOpVqtChnPKO3GjRswGAxoNptiMGOxGMxms0QifBgAZFPX19cn1C9arRZWqxW9Xk8UZ4w0uQmM8AOBAKrVKvb29tDpdGCxWDA7OyuOiqQUDTMfiM/nm4CM3nnnHXz729+W9JoZFSPOmZkZABCo7unTp9ja2pIH86ZLNVLkTT766CMYDAYcHx8LafnBBx+gXC7j2bNnEiHxgvFArq6uAgD8fj/q9To6nY4cvpOTE+RyOUQiEVitVsFrjUYjIpEIIpGIZDPdbldgQJfLJRGQ1+uF1WqVy+p0OjE7Owu9Xg+fzwebzYaFhQV89tln6HQ6gs0yyh+NRpibm8NgMBB8/ejoCDs7O2+UVr++f8Cry+z3+3H16lWYTCZReJlMJvnc1WpVuB6eNTqTjY0N6PV6xGIxgRObzSYajQaKxSIajQacTqdcVPIBkUgE4XAY9XodR0dH6HQ6CAaDcLvdovIbDocCK9BY2O12LCwsyPnUarVYXl7GZ599hn6/j3K5LM+EmfXs7OyEI97c3MTDhw+n3j/gPPvTarXC94VCIayvr0Ov1wu04nQ64ff7cXZ2JmIMBg90kiaTCXNzczAYDHA6nQJVMtghB+ByucQoUS0YCATg9/tRrVaxv78vZ3dubk5gcKPRiOXlZXEEfE2e41AoJFnq7du30e12USwWBTpqNBrQarWYnZ2dcCTVahX5fH7qPaQTIfcTCoVEcdput9Hv9xGNRmG1WtFqtYST5J2nvbPZbPjoo48AADMzMxiPx+j3+2L7SOSHQiEJOiKRCPx+PzweDzwej/z+fr+PcDiMmZkZ1Ot1gd+JhnD/HA6HiIoI71MERSFCt9uFXq9HsViEyWSS90jI8eXLl/jqq6/+38lc1FTX4/EgFApBr9fLJvJrhLBIQKtvhh/c6XQKPslIg1EmfxcvNyMru90Oj8cjsuJ2uy2bqEbdTMUZ4VKtQ2iJUY7JZEKlUsFXX32FdruNRqOBXq8nn81gMExwOoQCplmqY9FqtRNSwmQyiVarJa9LwpcRBH+el5cKFHIFxGlJyhaLRdhsNsG/eSncbjeCwaAolQaDgaTrfF6UwqoQltVqRSAQkNemAMDr9YoRJw5dq9UkK9RoNDCZTOh2u0ilUvKa0yw16yDn4ff7YTQa0el0BE4gdEiOjJEh98BkMkmaT4KcGWW320Wr1UK9XhcYhZCa0WiEx+MRCTzVXDabDR6PR3Bx8hDMQpjdkLvi5yAM1mw28fLlSyFqG42GvA6dEQBsb28jl8uh3+9PtX/AOWTDrI1SaBqcer0uwgS3243hcCjqLgZpzNp1Oh3cbrcooNrttpw1Kj6bzaYEN9x38h8ej0dI5FarJXeYn1Wn04nYhfysxWKRPaRz8fv9iMfjqFarePjwodxVRv8UMJDHZeT9NgEO0RAGv9FoFHq9HtlsFo1GQzKAer0uNur1rI9wqc1mg9VqlUyPKjueA3X/7XY7gHMO2eVyCdTY6/VEZEOoVUUqmIkbjcYJwRPVglSNPX78WO4ng7JQKCQ2X6PRYHNzE9ls9sI28MLO5b333pO/U7nU6/XE8Ph8PrRaLbRarYnN4CVTsxj+4YXi//PwMbugrv3g4ADNZlP+NBoNAJgwcuVyGaenp7BYLFhbW4PT6USxWBRifn9/H1qtFl6vVx6q3W5HpVLB6ekpSqUSZmZm4Ha7YTQaxcDQwEajUXz44YdTp9TXr18H8Ar2S6VS+OM//mOJqhOJBADIgaQTcjgcsFgsYgw1Gg3q9brwCWazWRR0g8EAKysrWFxclGibcuBarSYOqlarIZ1OS7bJ78vlcjCbzZidnRW+hoZib28PABCPx4VvI1eWTCZRKpXg9XrFqTAKotRyaWkJ7XZ76ou9sbGB8Xgsl7ZQKODP/uzPYLFYEA6H4fP50Gg0UKvVJqAvPj9VUUfoqdVq4ezsTPZ8NBphZmZGRAJ2ux29Xk+cPx0Q30O/35ezSkmxyWSS/Ws0GvJzu7u70Gq18Pv94gC5t3w+dPSsNxiNRgJVBINB3Lhx460yl/X1dQDnd/Ls7EwMD/H7eDwuUTShRErAGfgxOFChRBpvvme32y2KULvdjm63i+PjYwneKKMl/0flGdVxZrMZS0tLsNvtQuwD56Iiwmwkt3U6nUTs5XIZHo9HnCAhOv6/z+fD+vr61Hd4eXlZztJoNEKhUMBPfvITEcj4/X4h6rk33BPuD20hM5pisSh2jUEHnWIgEJCyCXIufr8ffr8flUoF+Xxe6tE0Gg3a7bagG4FAAG63WwQ7vV4PR0dHACCBAYUqjUYD+/v7aDQacLlckvFQIm82m0V1efXq1QufwQs7l08++QTD4RBPnz7F3t4ecrkcdnZ24HK58Cu/8isIBAIolUrodrtC+PMgMGIyGo1yEAmZpFIpiXoMBgPi8bhELaPRCJVKRWSvVNhw8TKGw2HR6Pv9fqysrGB+fh6bm5sYj8coFArY3NxEv98XKTIjn1KphGQyiWKxiGg0KsVrlPvReCQSCSmsnGa99957GI1GODg4kPqHFy9ewOVy4W/8jb+B+fl55PN5ZLNZqVMhscyL6nQ6RSJcrVaFP2HUrNfrsbGxgdnZWVSrVSneymQyyOVy4rAovx4Oh5ifn4fdbkc+n0cmk4HX68XHH3+MRCKBer0uBZ1bW1siuIhGo2i322i32yK9PDs7E96IzwaAyB9ZzzDtxb558yZGoxG2t7dxfHyMXC6HZ8+eweFw4Nd+7dcwPz8PAKIKI+au4vrE+dvttpCVdHjMzOfm5jA7Oyvnr1QqSeEjDQdVdvy9ZrMZlUoFhUIBbrcbc3NziEajKJfLqFarODk5wYMHD9Dr9XD16lWEw2HJkBqNhkS9MzMz8Pv9AM6zDErtWThLDmHadf36dQwGAxwcHCCZTCKfz+Pg4AButxt/7a/9NczNzaFYLIrR4jNUg8LXuUOqoFgvptFosLa2hlgsNuF8kskkMpmMRL3M6BiIOhwOucNutxsfffQRYrGYZC/tdluEO6r0m5LybDaLYrEoPwNg4r+E5Ai1T7PW1tbEnlQqFWQyGTx8+BB2ux2/+qu/ilAohMFgILU3PF90cMywgfNsDwAODw+xv78PvV4vhHowGJR6OJ/Ph1KphHQ6jf39fYTDYYTDYTSbTZyenopQijaA0D/rVSqVCmq1GnK5HPb29tDr9bC4uCi/l+Kgw8NDtNttLC8vw+fzodfr4ezsDACEz3G5XLh169aFz+CFnQsPlwp5EI9mBFitVkX6yUPIdJRQBrFbprAqNk2PSHKLcJTX6xUyr1AoSIU+eQF+jZFpp9NBo9EQXNHlcmFmZkYicdbPOJ1ODIdDgch6vZ6khoQf+v3+RHHXtIQ0IzaKBQg/UUFXKpVQLpdRqVTEuWi1WqkXIGSgQkOEHF+/RIywmTbzQo3HY2QyGQCvCuooKefv1Gq1E4oSwoqzs7MCKeTzeXg8HqlvYurM5wpAYBDKR5nJTGscuX8kGkejkShqeP6KxaIUJvK905nxvPLz8WuqkEStM1D3QIWPCoWCKJ7I56kSebPZLM+A0KzVasXc3Jw4Z55hj8cjjo2Gh86RWRc/S6fTeSulGD8XALkTdMJ2ux3NZhO5XA6VSmWiEBeAyPtJHvO98b7qdDoJGtW9VKFCBkaj0Qinp6ciXiGHpgaYFEsw6mfxLJ877zfLDCg4IWej7tV4PEa32xUb8TZSbsLG/Mw8B5Tq5/N5OYfkAVWpvsoLq7aRcGmv15M7TLvIQl2v1yvZTqVSkbooohssUGbGqULwJOXn5+eF1GcWyICFwQLPIQMHPk/SFgAufA7fqM4FOC+IZMEjo9RMJiMEJ0lh6uDpQBwOB2ZmZmRzqtWqSJlZyQtA4B5CbBqNRqL+n/zkJ/jyyy+xsrKCX/iFX4DP5xPMX6/XIxwOw2w2I51OyyX1er2IxWL45JNP0G638d//+3/Hw4cPsbi4CLfbLe1KWLD16NEjuXTAqwsZDAal4GyaRaOu7uHc3ByA8y4FrMJnKsqDWKvVUC6XpQaHB4WH73UDWq/Xkc/nUSgUpJr61q1bsFgs+OEPf4jvfve7WFpawq//+q/D4/GgUCiIcIDpMvkTrnA4jL/39/4e2u02fu/3fg93797F0tKSQEwOh0PeTz6fl7YoOp0OuVxOnBirvadZqVQKwPmljkQiGI/HmJubw2g0QiqVwsnJCWq1GkqlkmDY/H7VcBE+UDsXdLtdIeObzaZU37M49OrVq7h69SoePXqEx48fY25uDu+99x5cLhcqlYrUuSQSCZhMJoG6mH1EIhF84xvfQKfTwf/4H/8DX3zxBRYXF3H9+nV0u10JyghFUOpM2ISX+22k3MCrOo1gMIhIJCKw1Gg0wtHREV6+fCnRNgNCvV6ParWKUqmEYDCIpaUlgaJoxMm98CwyOGu1WigWixiPx3jnnXcwHo9x7949/Mmf/AkWFxfxd/7O35EzWKvVJrgp7n232xW+5cqVK+j3+/jd3/1dPHjwQOBvAAiFQnIv1M4R5AG73e4bV5i/vvL5vPydWVMikcB4PBbBSqlUktfnGWQ3A2Zo5KVIA8zPz6Ner+Pk5ETskcfjEfRBo9Hg/fffh1arxY9+9CN88cUXiMVi+Pa3vy1Om+16WNBKB8bnOD8/j29/+9vo9Xr4b//tv+HBgweIRqNYWFiQrgq0wxS5kC+iWMfr9SIYDF7YBl7YuTCdpWyXUkkW8dBZqBEjvTAA0dVrNBqR2QIQUppYLn8Ho0sSc/T8lJfSWFH1xENOEp6kObkHj8cjUSaVHSTMGf2oxDCjeL5/6sanjbwZ0dNI2Gw2eL1ejEYjZDIZibhJzvO9MrJllKMqxxjpqFEao7pms4lOpwOTySQ4rk6nQ6PRkGicBxh4VbCn1+vloHEfDAaD9DgCIFEZ94bZKCM1RtoqeUiIatqLTRhBla8zwiWUyIgLeCUA4N8preZnVXkZtQiXERthMyokCU8x46aEmK2DmJmrGRyNC8nUbrcrMI/6PrkYrdP48NJT0s33P+3i5+SdoKy11+shlUqhWCwKQqHeAT5bZmFarRbNZlPuDxVwr38OvneqESk1ZrEg1Up8XQpAmBETUqKtYbuZ4XAoiiq1AwXfD+0HX59Onnd42jNIZ8rsirLtwWCAs7MzQW3U96WKAF4v3eA+a7VauTt8n9w/8ihq2QTvPav2VcUoX4POjXvCOkRmLiw0Z2bDZ8ism5kMn0Ov15OC2K8dFuPlVo0FK8B5MWOxmDRL3N/fF9JNo9HA4/GI9JO8DH+f0WgUKeTLly+xubmJcDiMlZUV6HQ6yYLYz4ztZNhvq1KpwOVyYXFxUfTmhLvIJ/zpn/6pZFU3b97E3Nwc5ubm5MDxwjMCqFQq0Ol0WFhYkPYd0yqdgFfOhQ+fsBVfu9FoIBqNYmZmBu12W+S9vJThcBjxeBwA5HLzELCFSKfTwebmJjqdDhwOB7xer8B9tVoNS0tL+LVf+zWRjzYaDclcRqORFGDykLPtTrlcxu///u+j1WrBbDbjk08+QTQaxdzc3MRlZybFnweAlZUV+P1+uTTTOmc6NsKU3EfgVcV5PB7H3Nwcms0mDg4O5P0yIl5aWpLIllwLi9BY07G9vY3nz59LQR6hVp1Oh3g8jtu3b8Nms2F/f39Cgsr9Zi3OcDiUVhuVSgW/8zu/I+f49u3biMfj8Pv9AlnSkWm1WlFDDodDUbapHQ+mXUQC1Noj1kwQrpmdncXs7KycQSqH2DuMcBoVSGpdEw3fwcEBDg4O4HK5RFHK559IJPDzP//zcLlcyGazKJVKAiPxOel0uol99Xg8aDQa+J//839K54j33nsPiUQCPp9PsiR+PkJMFHewFx/fw7Tr7OxMVKskxAmzUhQSi8Xw/vvvo1qt4unTpxKs8i6Fw2ERJKikP23qYDDA3t4eDg8PEQgEsLCwINkws68bN27AarXi6OhI5MiqAIMZL9VrLpcLmUwG3/ve92Sf2GORxbHccxUxyWaz0Gg0Iq82Go3Cw11kvZEUWfXaAES+CkAwwI2NDZTLZSF46VxYgQ5AIhV+jfxDv9/H4eEhstksbt68iWvXrkkdTafTgd/vRyAQkMrowWAgTdtYh8BDwAjQbDajWq3iu9/9LprNJt577z2srKxIzUKn00G1Wp0QG/D9A+eQ0OzsLEqlEvL5/FtlLmqtC50CnVm73YbH48H169fltdjSwW63w+/3w+fzybPQ6/USXeh0OpFJJ5NJZLNZ6YbKKJBEPHFXfj/rUNTIitEL6xjS6TR+9KMfodVq4fbt21hYWIDf70coFBJSn5zQeDwWWIgQlipWmJbQZ8Q1HA7ltWw2GwAIxxQIBPDuu++iWCyiUqlMFJG5XC7pRcYMjtEhI9/BYIB0Oo1UKoUrV65gcXFR6ow0Go2c33a7LW1ReIaZBZAnGY1GAn+m02n88R//MVqtlpw/fm08HktLEJ6/UqkkhtHlciEQCEyo3qZdPIOUxjKiZVZnMBgQiURw69YtMfrMpGm42ByW0BnfN53NcDhEOp1GsVjEwsICYrGYIA7D4RDBYFCI71KpJIaZ3CBhLqqc3G43vF4vSqUSvvjiC7TbbWxsbEhFudPplKiaWShRCWbfPp8PkUgEhUIB6XR66jNIkQ/RAzVTYtGuz+fDu+++i0wmg+3tbekLx/NBaJvPQ+36weyBAfP6+rrUBDKLsdvt0oUil8tNFGmqak2eHyr2dnZ28Pu///uo1+v4+OOPsbCwgFAoJOiJ2hST2V0+n4dWq0U0GkUgEBB7c9F1YeeyurqK0WiEk5MTpFIpBAIBwVoBiLFjYzoVWmC0ycZ27DbL1tXj8Viky36/XzaKToxtrFWHUKlURCFFKSpTehqNer0uRNTS0hL6/T5mZmakloQyUXpjkukGg0Gi3FarhaOjozdqe/Cz1pUrVzAajXB8fCz8FDu0MvVvt9viLGu1mlT4sv0NcG5cCAWymItGlLgo6xDoJBqNhshso9Go/F7CZiq/QiNGmWy5XJassd/vIxKJiP6dZD1JTcpB+UyYkdKREuaYZi0vL2M4PG99k0qlJKNTxSJsDMhmmZQNM+NklE5DR6dtNBqF26BSkcWl5A/VOqtWq4VMJiMRH3uIAZB6BaohXz9/VCSygahKMrOR63g8RigUAnBu0FhYqVbWT7PW1tZEQvvy5Utxlsz0WdtzcnKCer0ucAgbKKqZDp+jWjGuNthUFV0AJDOk2okthQaDgew5IViS+NxP3snFxUU5g16vV5wWAyzWVNGpEMmgGoqCpGnX8vKytD7a29uTURTcB95lnkEAwk+x5RVtFuEwi8Ui6EChUMB4PJYmnYFAQH4vg0C2PWIhL8tBmKETMgYgP0e498qVK+h2u4hGo9LBmlAfgzBSHKPRSIJ1FmzyLFx0Xdi5fP755+h2u/gv/+W/4Pvf/z4WFhakoI4pWafTEePI5oDZbBblclnkxHa7HbOzs4L5swq1XC4LDhwOhxGLxaQIiBLQa9eu4cMPP0S1WsXLly+lwpyKNRphOrXBYCCdBdienTADe3wBEPiiXC6jVCohEong9u3bGI/H+Oqrr/D8+fM3JrNeX9/85jelb9eDBw8wNzcHl8slqipmWC9evJDIn1AdD9D29vZEu5uNjQ2srKzAYrFIt1rKaHlJe72e9HxaWlrCxsaGZH10LmzNQmfL1y2VSkLqXb16VS6s3+9HLpeT3mIsOC0Wizg9PUUkEsE777wDAHj58iUKhYLAG9Max08//RTdbhd7e3v46quvEI/HBYoxGAxwu91ot9vY3d1Fs9mUSmfyWcfHxzg4OJBODzabDRsbG5ibm5PzSjw8HA7L5SMhPBwOcf36dVy/fh3VahXb29uyfxQ2MAKnEeHP6nQ6fPzxx9LtwGKxSIsfnU4n0WahUMDW1hZisRjeffddjMdjfPHFFzg+PhZS+G3Wt771LXS7Xfz2b/82/uiP/giJREK4D9Y8EU7p9/sSxOTzeSGq0+k0LBYL5ubmpA8Vx1RQVcb6HI4qYBeCarWK1dVVvPfee6jX6yKN5R1mrRqzZkKErAH68MMPJdtiLRqDH96JUqmEUqmEeDwuQqDvfe972NvbQyKREAJ7mvVzP/dz6PV6+H/+n/8HX3zxhRhfNpwl+rG/v49arSbQI2X+er1euLrV1VX4fD6BvvL5PE5PT6HX6xGJRIQjYa1fLpdDuVzG559/js8++wz5fB56vR7tdhuJREJq/ZjNABBHd3BwAIvFgp//+Z+f4EFZb8QGtTqdDtlsFul0WmYWjUbn/QfpXP5faf9CxQUxdm4cN4x/p6abf9QeSTTMJPwZ5f2s6Ih4LtNcte/TcDiUdJ5QDh0JZZ2s0mVkSy6GRK4akbKdu9rfiGIEZkMqcT7NYuRGKIWpNfePckUWpwGvqvpVwlRVoaj7xmyNl+z1n+Ee8j1Q/kmsnREfX597rxL3wKveZawkJlmt9nTi6/P7qfh5mxqNer0uGYHaZ4lFY4SmeLb4R+VnuB/MpJhNEdLo9XriLNhXSSU4uS+qfJT7zAhbldSrRYcUp3BRjcPiNJ5R7iPvj6oGfBtBBICJYIXPgq+p1rQAk6Qt77DKP6mfT5WxskhQ7bfGzIhni1AQ7zCzP+6hKmtWpfgMhPgzlCUDkNd73d7wHKu/c9rFO6baP6IvbE3D90S6gJ9LhcQBCMylig34rNl1nlnL6wIpwn4mk0kyPtq314VHKtTF7JTPkOefNoV7y/vFc6DaBP77RdaFv/M//af/JCl1NBqVKIDV3bx0JOx56dfW1gT3C4VCooxgRF0ul1EsFvHgwQN0Oh2sra0hGo1OkPwky/b29sQZqNDM2dkZtre3pe8NU2YSb2xPotfrcePGDWi1WuRyOezu7sJkMmFhYUGqWtnI8NmzZ3IYw+EwrFbrG23s6+t3f/d3RSl08+ZNJBIJrKysiOxaNf6DwUAiIZLsalffYrEomCsrbA8PD9Hv94XkVBvq8TClUimZHkq8mlE2C8I0Go3AhirhWC6XodFoRGTAIUQcokU58tzcHKxWq0BxqoHn+5lm/ef//J9Fmnr9+nVEo1Gsr68LJMAo7vV6kMXFRSlADQaDGA6HSCaTqNfr2N7eFmEDB0txEBUvGBWEzWYT+/v7GAxeDQazWCyi8kulUjKtkgQojTAzHY1Gg6WlJQQCAZyenuLo6EiUW+QkabRSqZTAOLFY7K0zZwD47d/+beEUV1ZWMDs7i+Xl5YnRFhQ5UPWk0WiwuLgodSSqAGEwGEhWU6/Xsb+/L9wXoVI6Hxq3dDqNBw8eSK8wKu5KpRL29/fx8OFD6HQ6zMzMCMJATo1y5Zs3byIej6NeryOVSknxNXsbEu47OjoSlZvb7RboeVoH/Yd/+IfCKS4vL2N5eRkffvih3FWdToeTkxPpewicO2Y2h7TZbNIJulgs4vDwEPV6Haenp/LfwWAgPcQMBoOob8lJn56e4osvvpAAhzU2tVoNhUIByWRyggukyq7RaODevXvQarW4ceMGYrEYyuUyDg8PxRkzO2ZfN865Yt8+ClC+dinykydPhCBiGkjttlq1SyKdHlIdTcyNZfsYNpnjXIFer4fl5WUhahld0huzgjcQCIiSh5eblfaMmhwOh+CbLLLTaDQSvRFGI5HFttisw6HogO0pGEVMu7a2tqTGgOQ8nSD5Ehafqtipw+GQ6Mjj8QgBysiXfBSbB7L3FfdfPWjsiOD1esWRUtrNAWkkv5ni8zmwIzT36+zsDGdnZ7BYLGK0tVqtFBeqEaqagU27h8+fP4dW+2rMMfeQxpn1GKPRaEKyS+yazqXb7Qr0wlEEPIPMTtlzjIaeGRwrwama4v5S/p3P56V5pqrsYrUzuRSO/iUfRQPCjhM0pIwmedfeBlYEgBcvXkjNmdfrlYrw1+cm8f3wuXEwFs/gcDgUQ8jAiFXgrNNQu4zTYTG4yuVycLlcYkD5DEqlkhRYhkIhCVyo5svn8zAYDFheXhbIl5NYec5om9hKRi3qpZJv2j1k+xTaNb/fj0gkArvdLoEE90BFH9hBnM0ue71XLZkAiAFXi6eZSXLvKGdmIMO2WzqdDtVqFa1WS/hufj8hRCI7VH9duXJF7ijvgKoUMxqNUmNDfpJZmiou+cvWhZ3LN7/5TYxG5z26ON+COOvR0RGq1apg4GyFQYktC/QSiYQYo3g8jtPTU8Hy1P41LpdrYrMJG/AQkWRnhMdZGbdv34bZbMbc3BxsNhtOTk6QTqdhNBplQ3u989HFuVxOLsbx8bFE6oTcFhcXpZq4VCoJBDPtwXzvvfcwHo+Fi6K+X6c7n1jYaDQmDtDZ2ZlcKEq52feKBZ1U9FBOOx6PZVIfC6rG4zH8fj9cLpcU6VHZQxKWKiIqUxKJhEy/LBaLMBqNInBgJM8CVTpjtR8aZ06Mx2OZIcJGhdOuzz77TFSClUpF+AEW+FEqD0CKKfl82daGMF4ikRAFIPdPlVGrEm8KFpiJ1Go1IfKpqGFEff36dZjN51MbrVYr0uk0stkstFotVldXxbgdHx+LdFyj0ciMd74Ps9mM+fl59Pt97OzsiEiC3RSmXe+//76gD7y/3KNisTjxDOksmfUzAo/H41LhHwgEkM/npdMwHTI78PK5s/SA0ChnqqRSKWi12olpm+vr6zJfxOl0YmtrC+l0GmazWToQN5tNvHjxQhRRo9EI2WxWxBPM/DkQj0WqhHKn3cM7d+5gNBpJTctwOEQul5voIM09HI1G0g6LwQJFNgaDAXNzc1hYWBCeV6UFWJtGXpjnjftHWTJFPuTJHA4Hrl27JvtO2qFarYpSD4DMmlFVnrxDDLLZmbvX62F3d3dCIHPRdWHn8ou/+Ivo9c4n6D1+/FgKhrRarQz7YRvver2OXC4nEuJer4dQKCRy4itXriCRSKDVamFnZ0eIUbXgjyqZ0WgkzRtZKKWqP9LpNMrlMhKJBD744AOpeDWbzajVanj48CHi8bgYzs3NTSSTSWkqSBiPPAtw3gb75s2bACDQnSrBnmZ9+OGHGAwG+PGPf4yTkxOYzWaRO+/s7KBYLCIQCCAcDkskzT1ot9tCHnIgWygUwt7enhCaxE7ZHp8EIJ0LnRjHClBhQ3zY7XbjnXfeEcLbYDCI4Q6Hw1hdXYVer8fm5iYqlYo4F5LWqiSSveX4d76/t6kx+Ct/5a+g3+/jhz/8oQzZOjs7E8Ixl8tJH7ZOpyPQYSaTEZVSt9uV3mmRSATPnj1DoVAQPoBtMJhVUwzCLIUqPspkgfNL2Wg0kEgkZP9YC5LJZJDJZBAKhXDjxg3odDrpU0ZucDgcIpVKCc7OAVELCwvo9/vY3t6WEbasYZh2ffDBBxgMBvjyyy9xenoqcJ9Wez4Ol61tOI/k9PRUYNdOpyMqL6/Xi5mZGRltwXHF5IYcDgeCwaB06H7dudAu0Mkw8na73bh27ZrIbRkglstlgUGNRiOePXsmQSMFRZlMBqPRSGDexcVF3Lp1C8D5oD5mmDyn06xvfOMbGAwGeP78uXCXmUwGg8FgYvhXIpHAcDgUo88OxzTybrcbH374ISKRCB49eoRMJiP3g0G0y+WSgIwcKR0rRROcwpnL5VCr1XDz5k1cv35d6lw6nQ6Oj49lFDpbGFWrVemcQJ787OwMOp1O5MzsqELInGNJ3sQ5X9haEvtkF1pGwmxh4PV6BWdV+3GRtCNexzG+VKRotdqJFE9t082LRPiHhCvHHBPqYa0CuyVTfkr5KPX3VKG83q6Ci+QVm+QximOLBbW30JsutlThQaEz5e/nPprN5oko3GazwWKxwOPxSDM7tmcAIPg/W6Lo9Xo5gOyvNhgMpBiVUI8605wSYR5a7iedA58/RQeEK7gfKnk6Go2EoyEUxspq9XO96SLcQNEC228A511eu92u7J/K/7FOiBXO5NQIl/D7idOzT5NKyrJDNlWIbCjICno6Te6jSnxTUakWurEmQyX5SQQzc2Y2QDUZJbVvS+gTvuTnJEzEQj8S9wAE8+e+8vwxy6cABDiHnRgZq/eL94bEslrpz47ZFOsAr2q4mE3z86ut6Xkf1A4gau8rvjcaVfK0fD/TLkLlfG8sJB8Oh+IMmOGqijTyHoTG2BWBWYDD4RDoShWdcF/U2hPea7PZLDaQtk6v10sxKoVC3BdVGMQMmAGO+jV2FyC3SN7ZYrH81Jn9y9aFncv+/j7G4zECgQA++eQTKV7S6XRYWlrC3NycXGiz2YzT01MYDAYkEgnRbYfDYcEIiQ+yNcva2poM9VJbnDCCUqGp2dlZfPTRRzJ68/T0FJ1OB/v7+xJ1sX5mfn5e5rbwoLpcron5LXRQrL9hl1q1sjudTuPg4GDqWpd79+4BOMff2TY7GAyKE1bbraiYKbtE+/1+GThFeAuADA+an58Xvun4+Fhko6pKhoeCsIPFYsHR0REKhQKazabAgzSA5B8A4Pj4WKLneDwusB2/h86d2O/z58+Fv5mbm8PJyQlOT0+nVuz86Z/+KQCIYCMUCmF+fl7gKTYcJY5MTiAejyMQCMBut8tMGlU15fV6ZfysTqeTjrTsnEyORoV9XC4X3n33XdhsNty9excABOahY2LwwPeoPi+Xy4VSqSTzy5k1E14kB0khx9raGorFokTn067d3V0A54Z4aWlJ9kKj0cicEGYuzFpZM8UAMpFIwGAwyN6oPfxU4p+QDCEcFq1yUdBitVrx4sULMWi5XE66fdOpLS8vy3ulVDcej8sZByCKQdbA5fN53L17VyL+mZkZFItF5HK5qQNEPmsGEzabTfolDodDhMNhURCqbaQikQhmZ2dlZLNWq5VCaZ1Oh5WVFbTbbSkypo1kGydy2aPRSGa9LC4u4uOPP4bD4cCjR49wfHwMs9mMo6MjmM1mGT2eTqfFwdIhhsNhOBwOlEol2Q+q+tiAmFQG7xdHzpOPu8i6sHOhlzUajQKbMHIg18KHRnJoMBiIEoZ9l9iagSIA/qw6xIvRGS8zFUtcjOhYVWw0GsWjE2Pk7+ehI/TldDolslS9N9vFsDeUqv/m+5pWHw+cK4Yol1XnvjMN5qEk5sqDSZiE8mxKiBmtqFEKq4XV/kQqsc7vZZRDhQuNGzMXOjpKlXlp6ZwdDgeazaZ8D+FCOj46GvZEUuXd015sqtWoAKSKjkSj2g+JMAwLZBlt86KoGSj3jXJO9QyqfdJUaTv3hcEOz4w6kVUt3KQcG4D0CFPl2eq+8LxXKpUJSSqjxrdxLmyJz2wOeDU+mtknzyczRNZYMYPmsyRBD7yaDko5Lu8JOSRmbWoJwnD4akQyAymePUJnXOx8wMCEZ4Czo/ge+Dl4R1h8+vodnvYMkoCnneB9opSbAa1615hl8w+zQjpb9j8EXo0G5/1m1qKWYKgICsVG/MPPzAyfe6OWJdAG2e12CYJ4pri/zOwrlYoUxbIW6k0yvws7l83NTeh0Oly/fl08LavkqeaiCsloNMo42G63OzHy2GQ6H5HKN0wFD7FFkv6tVkswXw4z4oPQarX46quvBAJiodfx8TF0Op2kjX6/H16vF+12W6KEUCiEeDwuRohEODsAmEwmVKtVJJNJjEYjyWYcDgfef//9C2/s64vQCsl4g8EgXVYJL7A1Bgv5aEB7vVejABiV0Bk7HA7Zq8FgIHMcCGfwsBJSYHuRr776SvgQZkLpdFoqis3m84l/5MZyuRwMBoP0FGOVOaPX0WgkPZy4f4xEqariSNdpFiO6SCQi0fPJyYnsLTs+sACyXC7L56AaplAowGg0Ih6Pi6ooFArJfBvCvnRWDFZYwQxAos7vfe97kqUwM0kmk9BoNMIJJRIJRKNR6dM0Ho+xtraGUCgEj8eDaDQqz5bG3GAwiCyXZ6Zer8NkMuHq1atvBYsdHR1Br9fj5s2bWF1dld58alsPNlTV6/UyvVWnO2+kWSgUUCgUYLFYcPXqVVGBBgIBtNttZDIZDIdDxONxEXvQEJIkZkDa6XTw5ZdfCo9ANR7PC+8w2+RQ4anX6zE7O4tgMCjGtdvtSgH1wsICFhcXpa0THRZJ/qtXr069f2yFE4/Hpas0s0kKSKgiYwDWaDREUq0qENV7wBoV9lOjEWfmp9IM7DPXbrfxR3/0R+KsNBqNqBk1Gg0ODg4EOZidnUWn0xHFIn8P3wtFEOxQ0ev1UCgUsLOzM6EaVCmFi6wLO5dUKgWj0Yhbt24hGo2K6onkZ7/fh8/nEx08W5vUajWRu7E1OXva0FlUKhWkUil0u13BbdVLxyiBlfS9Xg97e3tibI1Go6TCjEx58GKxmHhhRhh+v1+iAE6xG41GCIVC8Pl8yGazKBQKQjqy4R4hjmkWu5ZardaJFjaq9DMUCsmUR2LKbKvDfSYs9XptAtUwkUgETqdTDKsqveQlazQa2NnZEQLPbreLNHs0Oh/QRlLe7/dL5fRwOJSGjsR/yeP0euet5WOxmHRjINlPoQFb+0yzeBmpOuSQLRVmU8UIrPVRC2bL5TKMRqN0yDaZTKJqqtfraLVaCIfDEjlSjELsGji/xM1mE8+ePZMggDBaOp0WzoXFpaz5YQt5vV4vd0Oj0UiBYKfTEWnw0dERdnd3BXZstVqYnZ1FIpF4q+yZztVoNEqfNRLSaqGw3W4X1RfwSp7MgJITCXkfWQnOlv1+v18yQRotOme1eJowHbkePiMAkvlSlkwukGgEn6/qnChe8Xg8IiRQs3eORZ72DNLIu1wuOYP5fF4k0STkGXjF43FRkFFwQ4OuIjnMhln/R4fMrJkKM6IazHyfPHkitWXsWp7L5SaQnnfffRcLCwui4KXyjEXADPyYIKgFmQ8fPhQRDJ8Rs8iLrAs7Fw724YVgdWer1cLx8bG00MjlckJkkriiuoiQFNuuMFVkrQaNAOd583AzglLrXlgTwkXHxgenFg4yq9Lrz0f8Hh4eygMgkc5aEjWFVBcbNE57MEmgq9ACsdqTkxPpK0Uil5Ace4wRHjMajdIaBngVsRSLRandYD0MHSxbxp+ensrhI8xJB+/xeCQy5v5RTsusgEViVLEw8/J4PAJPvV4JTShJraaeZhFmoEHh3rGYlBeLc3MYdHAA2+v1PlSIURXGDgCUOXe7XSHSY7EYbDabDIJiRAlA4EG3240PPvgAwCsYwmw2y4hkwlCcIPh6HRD5Q0J0VEGRA+v3+yiVSm+VuZDjY+0XFU/MSjhut1AoiAEym83CQQKQjJnniGQw+/KRX6Fkm90vCE1Vq1WZwcQ7D0Ag9PX19Z+6w4zG6bRZr0WDOR6Pf6pKXn0OzM55RqbdQ9URMNghXMf3k8/ncXJyIvvHtkh0yoTsCLGRoySRTuEG1VksTg4EAsKF0X5yeB+zHI/Hg5s3b050dzCbzaKYJCx8dnYm1ITqMCluIe3gcDiEe3G73XIGL7ou7FwI1zBNZ6RXLpfx5MkTIYPZO+zXf/3X4fP5UCwWcXR0BIfDIZPT2L+G+Cg/kFarFe31YDCQHlA3btyA3+/H1tYWtra2pOCK0QoALCws4N133xUeYDgc4u7du3j06BH8fj82NjZgNBpRKBSklXi9XofH48E3vvEN+Hw+iTD4EFTuhw5v2oNJMYPT6RQ+inDDkydPsLu7K4qSSCSCzz//HA6HA1tbWyiVSggEAtL6//DwUKJarfZ8bG8ul5PXYXbHA7O+vg6Xy4XHjx+LeIESXFbqE26iKkiv1+PRo0d49uwZ7Ha7jEt49uyZYPcsJrtz5w68Xq9ITOn0+T3AufF4E43864vZAw0Mo+J6vS69j+x2uzQT/Pzzz+F0OoU4J87M2hTgfIAbYUdmFryIwPmZdzqd+MY3voFQKIT79+/jwYMHqNfrIr+momZlZQXvvfeeRIL9fh/37t3D48ePYbFYpPU86xoImdjtdmxsbEjwxlonu90uDp5YPAemTbtU0YfaGLXdbmN/f18Mr0ajQSKRwK/+6q/C6/WiUCjg7OxMWuhrNBpBDsgpdDrnYx8IEfFeu1wu2Gw2vPPOO/B4PNKOv1gsIpVKSf0Em8WyVo3w97179/DkyRO4XC4RIeRyOZyenuLs7AzpdBoulwsffPCBBGN0hIR9yfewOeS0Sw06mYUQ+tve3sb+/r78ezQaxS/90i/JuIB0Og2fzydNPQnjqR00yAuyPxoFTlarFSsrK3C5XNIlgiIWqjPb7Tbm5uZw7do1uSPj8Rg//OEP8ZOf/EQgRq1Wi8PDQ+lyT0HOjRs3BL4j1MuGomwMnEwmkUqlvn5Cn8Q4iUtKg0mEM8ICXg2tYpGYSmaRuH49uuUGE48kxkf1FLkdQkgkq9gQ0Wq1SoSiRhjcCMIgqoSWfI7a8oK1DIQJGO0yyp128bLwddX+TiTu+ZnoHJlCk+Cn0SZRyOibUIZaV0LDTsiF8Br3n/vF+iFVPqs+B/I06nNSm2Lyc5C3KpVKoudXDyGzl2kXDS+zBkJ8PAt0ODwDzKBUkl7NKNQgRN0/EvwMpLhvhEfVljYqOU4BgbpPAASi5YXnc2VxIY0AEQHVcanRMT/T2yyeQRbdqi3feaZUY6zKrNmzjnvDKJcGl04LgEB36j6SZObrkccaj8eiClOhXv4sgzl+P+XTfPbtdltIaYpS1AJaVUhAKfS0SxWF8LPweXL/VEKf752tsNSzpXZR5j1XzyUA2RNW6/P9E+rja6hZG+XMapcK2kNVMET6QIXhuH8ssFWfLRfPx0XWhZ0Li/jq9TpevHiBfr8vcyuuXbuG9fV1idiMRiM2NzfFEK2trckHJtHpcDiQy+WQzWaFT+EDUltnjMdjvHjxAsPhUKqBASAej8NoNOL69euYmZlBNpvF48ePRVZpMBhEd846B7YvAM4FCgcHBwAgWOSDBw/w8uXLiQfN91Sv1yW6nWbF43FxLPv7+3LpdDodbty4gaWlJQCvLhELy2w2G1ZWVjAcDnF2dibybpvNhkKhgFwuB6vVimg0KrAKDxKj8rt37wqcSP6D3EQsFpOWHqxN4cFqt9sCQfESr66uwuFwYH9/X3gH1vDcvXsXz549E2dJQ0Zj8jZFqJxlw7b+rFkYj8dYXV2VokOqtWhg7HY7VlZWBL82mUxYWVmR8bqUvkYikQnjoJKcP/nJT6SKndAoYYr19XXE43EUi0X84Ac/kD21WCwSvNjtdgSDQRkYZbFY8PLlS2Sz2Yn6j+fPn0vBn+oY1UDnbRx0NBqVLJxFdrzDS0tLWFhYELjKYrEglUoJ7BSNRuVeWiwWrK6uytC+XC4nFeAajUbqUtS1vb0tr00ebmZmBjqdTjiDZrMpohKOUqf03OfzCYlP20D4DYCMt3748CGeP38Ok8kkMLlaO0JF5DRrbW1NzjFtBuGs5eVlaVnDbJOS7JmZGcn8GXhEo1EYDAbZD/KFDEJUGzgajQSePjg4wP7+vtx5u92OGzduYGZmBqenp/jxj38sMBpVtIFAAHq9XoKghYUF2Gw2HB8f4+XLlxgOh6IQ3dzcxObmpmTPZrNZoE61M8VF1oVvO6VujExVKMvr9cqboBEjORyLxaThIjHAQCAAr9crsmFWpDIipjGid+VFIK7Lg0MIJBaLTcxPZxSlFiwyfSfnQbKbreYNBgNyuRz29/elhQojNR5yknLTLBZxMTtiDYNGoxG+SK0UZ0TBnk71el323Wq1CoxXKpXkoFksFqkgV7M3GmTWDxgM52OL2dabyhZmZnRQJPj4d9Z4BINB5PP5CakuuaCDg4OJ/VMj/bdZanV3q9US56nVasWIkK9jYEHOgrJVFtF6PB4Eg0E5p1SZkVRmRE+VGSug1c7TNKCsQapUKgKz8Vlz/3j2qMSiUo13gt/LZoaE8JhJMKBRC4vf5gyyhQ6DQToEtgPivjJDpINUuYxAICDtVdheXq1zUyNw1h4RNSAMRuMVCoUQDoeRyWRwenoqBpy/g/eWUTzvJQsP+ZzYteHk5ET43dcbpk5bZwVARDYU+nD/xuOxjFIgkkJCnveV9oYoAr+fqAibq7I0Q4X0CHtxxADHOPBn6HgLhYIE3wCkcSjvPM8ia7vIn9Du8D6k02kZ3EY1Gfm5NxGUXPjG01hXq1XpCURylXJFVn8ShuDhYodc4Fw19fjxYzFa9IQ0Xo1GQwQDbDXAlI8/TyWT2WzG/v4+Tk5OoNFoJMInnqw2luODpLqJBKLJZBKBANVPNKDU9xuNRvj9fiwvL194Y39qo/8ciz87O8Pu7i7MZrNU5rJampeHD5l4uOrYer0ejo+PpfiJF1StEmdESmfL5qEkkcmNkWzM5XLweDyYnZ0VqTJn5bCIkk5bbRRKqIlVvjSmnOXBzInKI7aEmWaxpcbu7q70ZCOMR/WXVquVJoL8f852ofEbDM7nbZD4Z80Es4JGoyEEP1tkkAMgFk4JvclkQjKZFOnxjRs35Fnlcjnp9UTjxoJgnU4ng7LYxJBtfuicOGyNmSO7Ir8NoU8oJ5fLSW8+VShBTpDGkWeKwgmuer0uPCEr+9VFCJkNVXmHWT9DA0uhSSaTQSqVgsViwfz8vHASdBjMBAnD09ANh0OZ+0QVJOFSSqkZXBBCUqG2N10WiwWj0UgQF3WptVyErdTmo6pQQ6PR4Pj4GMBkzQwdYLVaFWSILZwI/VIqz/5tNpsN29vb2N7ehsFgwMbGhtjpZrMpajsqwtTzls1mRcDCybQajUa6rVCExJ8jN/u1Zy58OPV6Xfr6UDmiRgnUXTPTocflGxoMBtjd3UWn08HMzIxU9vOwMKoqlUpIpVIwm8145513hCOggoLE+M7ODnK5HNbX1/Hxxx+j2+3i8ePHUrcyPz8/kV4Sa6aShbI+4o00lGrbcF6Et5HS0tkWCgVxLoRI5ubm5OAQHmAhKPkZRkFsfDgcno8tZm0ODQex/GKxKB0Lbt68KZJiDmWjiieTyeDs7AwbGxvSS4ijDgKBgOjeKQQol8uicPlZLSNIQnu93gmDEAgEEIvFpto74BxW7Pf72NvbE9WU2smBzkYtimSmw4aVbD1EUpQNLNWeXeyHVSgUcHR0BJPJhOvXr0umXS6XRcKs1+vx5MkTnJyc4NatW3j//ffR6XTw1VdfoVQqYWVlRUbSlstltNttUZtR/t7tdlEoFCTbYkTPAWzMotiT722kyDR6hUJBWq0zSGMkzbqVfr8vdWzM2piZcHhVv9/H2toarly5MsFxUg12dnaGg4MDGAwGrK+vi2KOHTQIXz9//hypVAobGxvY2NhAr9eTNv7sgE1npzqewWAgZ4rGnI6HcnSHwyHBm9PpFFJ7mkWYq9FoSO0ez6DP55NCcvIiNNjkfegQxuOxKLbYbYDZGABR1DELY+NY2gubzSZlAnq9Hvfv38fh4SHu3LmD73znO+j1erh//z4qlQpCoZDIlNmNntnN6emp3Gu+VwCCZlCpxjKHYDCIjY2NC5/BCzsXNgm02WxYWFiQg0RvzXoAencqUUgyk/RntKZG8pRh8vtMpvPZASwYIn5Lo8XCKWKo6h+2h+cDUqOA8Xgs0aDT6cTMzAwACFFMueNoNBIjwPfBHlwajQbXr1+/+In880Vc2m63T2RAPFQkR0nKMeXnvjB6ZlRIh1MsFkUlRRhqMBjAZrOJ0yL8xsgNgMBvbP3Oz9ftdkVyyyiakzFJFjJTpVEmYcuMAXg13IsOSO3wPM1i3YzFYhF+pdlsTmQpzAYpeyYMy6+pXWn5dWZpapGf0WiE2+3G3NycnBXCWjTCdPSU47OZJQnRs7MzBINBiSCz2azUZRGaU/kd/p0BGRVu7IjQ7XYlQ9/Y2JhqDwlVOxwOLC0tybNQYV91lADrq1Qyn1/jnel2uxIEEp7kZ6JylA6TNoDBqIpQ1Ot1aXdCuLxarUqHDxZKEuqmCMXhcIjBpzSagRMDNEJs5A0AYH19/Y33j1yfyXQ+VoGwFQMd4FW7fNoSVZCgdgsnEkHIcDg8708GQDhfqkPVziLsa8dAieUbhIsppGKQ7nA4hNPjftDeer1eLCwsCApF9AiA8DAUIRH1yWQyF3bObzTPRa/X4+rVq/j0009RKpVwcHAgWUCtVoPX65WRp4zU2OmV7bppYGu1GvL5PF68eIFAICAEKbHfSCSC5eVl9Pt9bG5uolwuIxAIIBQKSVTFqK9YLCKfzyOdTqPdbuPo6EjwxH7/fMTqzs4OtFotPvjgA8zPz2N+fh43b96UFJ/DxLxeLwaDAZ48eQKr1Ypbt27BYDDg+PgYJycnGA6H+OVf/uWLbpssDuq5cuUKPv30UxQKBWxvb4sjYbTFy83mhoT02ApkMBjg9PRU2vIfHR3JvlCF1263EY1G8dlnnwEA8vm88DCM6FnVfnJygsPDQ7jdbkmXnzx5It0RdDodisUiXr58idFohHfeeQexWEywXna2rlarMBgMYsAZsbKPUSaTEVL3H/7Df/jG+/enf/qn0Ol0uHXrFj766CPZPw4y0ul0wr81Gg0ZocvgQB0Wxs7QuVwOL168gMPhEFUXIZxYLCZdZJk9sBhQr9cLVMDxvyS2WaDKVvvj8RjlclkKBm/fvi0Er9vtRr1ex9OnT0XGOxgMZEa71WrFz//8z2NmZgbHx8e4d+/e1OcPOCfVdTod1tbW8M1vflOGRXEeTalUkgJAqkIZsTLLoGNlNJtMJvH06VOEQiF8+OGH4txZqf/Zn49KYC86nu3R6HyuE39HJpOBx+NBJpNBp9PBwcGBZKhmsxmFQgFPnz7FeDzGBx98gLm5ORHqVKtV3L9/H7VaDSaTSebab29vw2w2Y2NjA3q9Hul0WgQK3/rWt954/9ilhLaJc6IYZBBq9/v9ws8x6DabzdJdnE6ZTqZarQrHwUCRfcvY1JbBGiF64FULGQaD7EnXarWkyzV5VXZ9GAwGWF1dlZKHYDCIVquFly9fipMDzrNL1juRMzo9PZVz/Pf//t//S/frws6FjRwpv1R7/xDL5wUkLkqil5ffarVK5EEjRxiHqSMzHUahfAgkY1kbovbOYpRFr83X5vthhgNAYCb261JJKrXuhsaXv4cZ0bSEPovtqLZhtA286u9EcleV0qqyYhYp8jkQC2cWx0gGgFxiknU8/Py6+jOMbFhExz/kS1ScW30/lKOqElXVwfH9EDIjfDbNYteA8fhVBTxfj8+Ekk5yKyRbiXVzP/izNKB6vV6KzAixkQtTpeM8K8zUVTmqun8UtfBrqgSW+82iU0bCqkKI9Tvcb7Wm520IaQohGN2rclNVKkx8nvCO+sxfRyb4rFVpOAC5x7xjvIcUAfE8MDhV94n/TlEGITdmm4SIqaxUCXs+Qxp8PhtVvDPtGVT3izynCvern199Df4M94MIDe8wUQjuAXkwZsuEAnkf1cxShd0o02cGw2enllPw/PEMqn3NaF/5/lmHQym0uqcXWRd2LrwwL168QDabRa1Wk0pjtdUDCd9kMoler4dwOCyEKy9PuVwWGSa/xqiZldUcVNVut7G9vS3tW0icUTZK5Y5Od95JlNiw2WzGzMwMbt26NYFpVyoVPHnyBOFwWBQflEFTCFCr1ZDJZKSilxtOGG2axQf07NkzvHjxQir+AUjKy8X32Gg0ZGxrJBJBJBKRTIytT9gGY39/X3r/WCwW1Ot1PHr0CO12G8+ePUOpVBIclYsw0+zsLIDzaY98ziaTCaFQCEtLS3C5XDLTo9ls4uDgQDoqM9tyu90oFAriVMgf8EKwQHTaRaNCjoNVzMz4CIOwOHF/f1/alXA+CCXJp6en0mmAZ5JBETk3lXs6PDwUySsAcVaEf9hu/cWLF1JYGAgEsLS0hHfffVciQJ6n09NThEIhzMzMwGA4H9Ebi8WEN6ABIUfHUeIcqzDtYjDx7NkzHB4eotlsyrA07gOJao51JmzlcrkQjUYls+eQLApprFarcB5ssdNsNnH37l20Wi3s7e2JSpIwFetaCHVzQJbayj8UCuHatWvSv4wQY6FQQDAYRCKREHk9a2BUJ8wsi5BeIpGYev8IiyeTSemoQTvHM1ir1VAulyWjIFTH93Lt2jVoNBrhVQGI7SwWi9KfjD36OBOGd5hZDekC1qqxR+OjR4+Ev7ZarQiFQlhcXITdbkexWBTFGad+JpNJmM1mRKNRzMzM4MWLF6Ls474RSmVW9rUT+iR7MpmMzG6nkoFqLj5YtZEiIyW10y5xaWL6NOztdltavXAmdKvVwsnJibT21mq1spl0NjykNGyMmnw+H2ZnZ4UzYdsINpujRI8Flk6nEw6HQ1rbaDQawX2Jdb4NoT8ajZBMJifkguQrqBSjcuP4+FimUwKQ0cPcv3K5LCk0IQatViuttlkxXa/XsbW1hUKhgEQiIfU2vLwUEgAQLT0DBo5JoMCBg4/UZ8GqbeK4jKZarZbAKwAkE512MYNKJpM4ODiQiA+AGCtG1+R3GBU3Gg2EQiFx8JVKRUY6M+p9nfsg5NBoNPDy5UuRclN5RIUUz1Gv1xMFGn9vOBzG7OwszGaztADZ2dmR96bTnXeZXltbE2fNpq00SFStscXM26jFyLOlUimJlhmdejweaS8yGp23SmF/PWZN5Ng0Go3A2sFgEMFgUO44oUiq61KplJxBKpOo0AsGg2IDiCQwc+GzcDqdQnhnMhlUKhUcHh5KeQL3mm2MCEeqIh7CcT6fT7qETLOYqagTUFmVT9GAWo7B3ojM8GKxmAQHvCPkgKlUHAwGIlNnqUGlUsHW1hZyuZyM6rBYLPB6vRNZttrFgRkx7+doNJKhgZzeW61WUS6XRQnr9XqRTCYFfXh93gzHNH/tnIva0I/EpN/vlxRbbcKm0WiwvLwMnU4Hv98vRXtMA0mAMZJiO2+mgaxpYERC8ook3mDwao68CgUReiDmqtfrkc/npXEmHSGNA+E2pnokEfV6PVZWVuSz8AHTeEyz2PaBnQyMRqNEW+FwWJwssf/bt29jPB7LPBxCOjzgxP0rf94WW1XuOZ1O+UwajQa3b99Gr9eTC8geZNw/kraEMO12uxjcnZ0dKbQzGAzwer0AMIEbsxCWihMWEqoKQwokpl2EqEjKMirT68/7Iqkwo91ux+3btyfw4kgkIvUQhFMItwCvquqZGTPi1Ov1WF1dRbfblQI5BlEUDPA+sP8aFYaUTrM7OAAxvGyZAgAnJydSZ1Wr1aDX62Ws9Gh0PnGQkMnbLKquKpWKOAueRzoXOlebzYZ4PC49pqxWK9xutwheKF9mhE5eVZXKDgYDuN1u+bwc6MaIm85OhYS4J/F4XAQkx8fHcl51uvPO5lROqdAncJ5xsZs0h5GR8KeKctrF4ITv3WQySdbPuiQVppubmwPwCjLj2GBCzAAE2qUjoBiAUB5h9CtXrmBmZkYGjjHLJoxGG8zXZhA0Ho9xeHgoY4zH4zGCwaC0duH7YL/CbDYrUymp5GVGTW79a89c5ubmhJzkPOjZ2VlRbuj1elHLuFwuXLt2TTaLkBTTVV5aqmxIXFNiTAfDy0q9NRuoZbNZfPnll4JDEutsNpuwWq1SgarX66WPGA2hz+cTA0KoheQkiw39fj/eeecdaDQabG1tIZPJSIX+tMvr9YqhKJfLMuDLZrNhdnYWLpcL2WwWqVQKbrcbH3/8sUQdHo9HUnC21DEYDAIBMaJwOBzwer3w+/3CGblcLnz00UdwOp2SvdXrdSSTSZHGqm16LBYLZmZmYLVaUSgUcPfu3QnnRQiDTfoGgwEODg4Ebmq327DZbFhaWhKHwwiWo6mnWT6fTy51q9WC0+nE2tqa9D1zOBxIJpM4PDyEx+PBRx99NPGsiUcz62LbHxpsRsCsG2JUrNVqpacVDWOpVMLz588FVmUtDPeIBZmFQgH37t2bCLo4LqBSqQjkQQTg8PAQhUIB4XAY165dg1arxfb2NtLpNGq12lt1iABe1QoB54GYz+fD4uKiRMFms1mGWPn9fnz00UciKTeZTKjX6yJnpSFjFs0RAg6HQ+4p7xiLLlkIyT3c3NyUomIWuTabTZjNZsnmut0uXr58KRmxXq/H/Py8nMFCoTARSROWImFNuJSV8G+zh8woCBHz7qrV7wzYnE4nVldXJRtjdTuHFPLcMRhhQS4/s6q2dTgc+PjjjyfqCYvFIp4+fYp+vy9iHxZxUjxgsVhQLpfx+PHjicFuc3NzcLvdAo2pdTd7e3tIJpNIJBLY2NiAVqvFs2fPZCAjHdRF1oWdC6MMVarGWQNqqxReZgCi4yehTEiFxp5RES80IyG+lvo71HYcNDBs5UCugUoXNYsCXkWlKqnFQ67K8FjIqPbzodKDD3Hag8nWK2rUTKmfSrq9vphZ0XGrhDEdrrp/7HhMqSOJPtUJ83lw7DBVQCxq4z4BkAhVNdLkJxi1M+1XD7lKjLPzKrOht1mUUxPuUMlSQgw0aioJT76IQgVyNYyyyQlS5UOnwciaQgLuHwlnlXxlVsznxsJTdfGZMFpl9Mjom9k5n4NaWa0OdppmkQin8IF3eDQawe12C9TJZ83zyJ9jBwR2P6bBpKKRz5jdjlXCm1AXAHkelB4z4KRalAXT6vvlXgCvxhgzc1RbC/EOM8vU6XQSWJJPm3YPiaZQ/KDTnc+OImLA7IzPnc9WFTxR0svPxuxavTPcZ94fQmREPphhMgsiPaBKvtWq+tftCp8xyxT4frmfhCi5t3RotFFfe+aSTCYnNjmXy0kx4HvvvSfFTIRrOKyGh5APpNFo4PDwEGdnZ1hbW8P6+rrgr8A54X18fCxV8jTCw+F5j554PI5kMolnz56h0WggHo/D4/FgaWkJt27dkkK7Wq0mxBgNR6fTEexybW0NS0tLYjQYvfOQ8IAnEgkEAgGpnZnWODIyIPbZbDbx5MkTgVMIiVGtlk6nRWrMOhGOPk0mkyiXy7h27RreeecdIQSHw1ft+ym/1el0ePLkiejujUYjisWiyHhjsRiCwSBmZ2dx5coVdLtdbG5uirR8YWFB3ne/35cUOxaLYXl5GaPRSAhMSrlVaMDn80nhmpqGv+lSW9PYbDY0Gg18+eWXIkelg2DX3s3NTbkQvDisCchmsyiXy1hbW8PVq1fFuQ6HQ7x8+RKZTAZutxvRaBSj0QhHR0fodrsIhUIIBoMiw+/1enL+OIZ6MBjg6OgIjUYDDocD0Wh0osagWCxiMBjA6XRifn5eMm7WX7CSnfeM0azaRHLaxXkzbL9SqVSE0P3ggw+kVIBnMJVK4ezsTFoKkSdoNps4OTmRPVxfX5+QKTPSDQaDmJ+fx2AwwObmJprNpvQJY/bHPfR6vZiZmcE777wjs0oqlYoM/ON+0LacnZ0hFothcXFRoK/hcIj5+Xm5U7Qfbrdb+AtC7tMsQuvkWxhk2O12fOtb3xLuiYHN4eGhOFtmXUajUfjQVquFRCKBpaWliV5ke3t72NnZQTQaxdraGvr9867LzWYTi4uLWFhYkPKLVquFUCgktVlLS0vo9XrY2dlBrVaD3++Hz+cTFRmpDU7BJGfLM7i2toZoNCojSIbDoQRglJBfdF3YuTDKZVTDGhOz2fxTMsThcCjqGkZ4/FDMYCgBZTpOLoVtCQaDgRDALISk4ogprloYSfKZjSF5ECgdZcpK9Qs14wDEQxMnVpvdWa1WMZQqRv+mi9Jt9g6iKo2pJjM2Kpd4IGkUCRmohVIs5qJUkdAjm+rxsDJq5AFhZEQegIVqfr9fitHq9boMEqOck8/n7OxMepPxGbP1Chf3i4VkFEVMGzXy55hpsvst9497xyJUavbVZwm8ao9DRRwJXhouigG0Wq20zWC0TjKaz4HPh+oxcl18DhQ58L3T6HQ6HTidTokaGblTmswsm4EPAIHx3mapXb3JeZ6dnUlPNX4eGkiewWKxKJ2aKXHlPBgKZ8inDgYDlEolIYYJxZVKJZk2S3idjjYcDovUnmeQQgzW1wCvModWq4VisShQG+0RDSG5H3a65tmgQX2bM8jMhcQ9ofl+vz8R2XP/KMDhXhFyVSXprGnjz1EsoY6iJu8bCAQmxBi0c8zseD4JNzITpIpW3Ue1PITBDYNrZsz8PrWI9mvPXBg9cBOI72m1WtTrdezv70uXX8qDWUTHaXyFQkFUGzT6dCQk3U9PT2XjqcQh5s0mgePx+bjYdrstkWO73cb9+/flwrC/E+XJ6vwNtjm5e/fuRLo3Ho8FV+WlZ3diXqhpFyd00lmpI5v7/T7S6bQ4TaakBoNB2tDU63XkcjlpPMdo7fT0FN1uF9lsFp1OR4aGcf8MhvPRxOQM6GAoG41EIjJGdmtrS4x2vV6XmRI0uKzuXVlZgU6nkw7SqoyaikAaEcIXxKmnvdh+vx+j0UgcKzFqvf58Rsrz588F6mMUxzYtbrdbMOdmswmXyyUXikVwnFzIeUI0lkajEVevXpUeZiw25fdHIhGput7f3xeFGVu88O+UGJNXHAzO2yAR0uGFJcSsQhuNRmOiCnzaRSPNYI5nkI6G5QHkEwh3kccj70eZK50Q1W/ZbFYq6fl1FuIuLi4K/OZyuVAqlYRHicfj8Pv9aLfbuHfvnkBmlOyy1Qy5Cq1WK0HV3t6ewEcajUYEAaPRSPgBNft6G1EEAxWWTwCvaquq1ap0bx+NzptVzs7OivOjKpTozdHRkaAy7N5B0QFLMohYGI3nE4C1Wi2CwSACgQB0Oh3i8Tja7TZmZ2flLuzs7IgEn50e1G4AGo1GhC3ZbBbFYlECQyYOfG4U6KjB+JucwTd2Llz0YtS8Z7NZOaz8Q+MYjUZF1siHQ+eSz+dFoslGdUzLgXOpLAko4o3U1rfbbekazNoQNbprNBpS5EXib25uDuFwGPl8XhpokrT0eDxwuVySYTFqZRNJlQt600XnQsfhdrsRDAbR7/eFWONreTweRCIRieTi8TjOzs4EX/V4POIMqfI4OjqaaC5ImEyj0SAYDAp0RJ08azj8fr+MOd7b25M+WMzwCJ/s7+8DAG7cuCGjjHd2dmAwnI8AYDEWORaV26FjfpsiSgoims2m8CvMhCiEoLFihks5cDwelzn2jO7U9i+NRgMHBweiJFOjSIPBgNXVVVFTkVdKpVLSzjwQCKBcLuPo6EgKdl8vXCU/4/f7EQgEkMlkcHh4KIpKFhoTwqW0n4ZW7ds37aIB5jkYDoeyr71eT+oymJ1Qjccu5lRuMQhjVlYoFFCtVvHy5Uu0222Bo8kv0NBSOm+1WqWGrdvtyqjoXC6HnZ2diUJh8hOEM4FzNWggEJCaK8q0mbXy/Kstkt5kguJftGhY6SDJTwwGA5ycnCCZTEqBJINCDghjGyW2VeLzpm1qt9syqI5V/XQ+JpMJGxsbos5lMByJRNDpdBCPxxEIBKSrOx0UAxy+JgN+2hHSC2azGUtLS3IuKCpgsFCv1ydqwr52KTKxSsoYPR6P1ECwkp6yOrVrbLvdFmUS07DZ2VmBeailJjHNuSs+nw+hUEiIwtFoJMaX74GpJjMNh8Mh0IiKs5+dnUnERbIWwAQJRlybc8bVSlpVpjrt4sFkusq6GdY6EE5goRT7B9XrdZk8SYI0HA7LZWfa6vV6JbUFztVValNL9mUitEUDwo7VTNEtFovo8XnYaLT5s4TzAAj0xRoJEpEsliuXy6jX61LLM+3ioabT8/l8Mt2TzoJwAM+P1WpFvV4Xo08YkDwaSV5KiQlv0QlQ9cXPTQEBe0zxeQKQ+gTg3BGqctJqtSq8jdpRgXAYjQ0hNWLchCLIJ/wscvZNFuWn3W5XYBc24OQibM3miEQduO90fqyxoDNiVkIy2Gq1wuVyiciGn4P7SESBdoDOnDPaOeaYIg1OnVS7PhDeAV5lYzyDqmCHUBXv8bRLtSmE4Fhiwd5lvEuE5ljDx0yNAQd5DQorNBqNOF6+X/YiM5vNEihzEelRkZrBYACXyyWFver30wZw0fmqUmgKTMifxmIxeb7kayiwuMi68E6zZfvBwQG2t7dx/fp1XLlyBW63Wy4mDY9aD3H//n1sb28LYef1ejE/Pw+Hw4Gf/OQn+LM/+zPodDosLy/DZDJhZmZGWmWzopsbkc1mpXdOLpcT/JVKsZmZmQnVE3Cetj5//hw/+tGPUK/XZQzweDyWDCsSicBisWBnZwdHR0eIRqO4c+cONBqNdA5lseW0iwWFx8fHSKfTWF1dxe3bt+FyuYS0TafTSKVSMBqNQg4+efIE+/v7MgvEarXi9u3bcLvd2N/fx+7uLkwmE5aXl8UJj0YjRCIRrKysoNfr4enTpyiXy1IDQ3ECJY8MEHw+nzS8ZGRLhRt5mnQ6PaHBZxZmt9uRy+WQTCbh9XqxuLiI4XCIzc1NJJNJeDweIdunWbyE5XIZJycncLvduHHjhsy5B861+qenp9IYUqPR4MmTJzg4OIDb7UYsFoPdbscnn3wCt9uNhw8f4v79+wAgRbmBQECM7szMjIgkmHmTr2FrkpOTEwwGAxE42Gw2RCIR4THa7TZ2dnbw4sULtFotCbpIoJJrsNvtMoKbvws4N2hUIL2JUudnrdXVVQwGA9y/fx8vX77E+vo6Pv30U3EKZrNZJNIsouX9YYEng78rV67A4/Hg/v37uHv3LgyG86GAzDgASHU4i5FZlU6YhQWbVD5SAKHKuSmu2d7exsOHD1Gv1xEKhcTQkSPinJyzszNkMhkRDqiiDkrtp91DOioqVYPBIK5cuTIBpbO/F22SXq/Hs2fPpMM2yyzef/99OJ1ObG1t4fnz59DpdNLkk2gMHXS328Xe3p7wiHSu5EHZU5EdIaxWq9hAIi67u7v4n//zf6JeryMSicDpdKJarU7U2LhcLpFrh8NhXL9+XUo1WGuldhz4y9aFnQvTuNcxN41GM1H4SK9H2IsRD+VzLPBhZEYijGoJtQMrH5ga4agem7g5YRimbYzQX5cjU6LK1JlRGP+Nf2hQuYk8yG9DqHLfGKGp+0eym0ohtfcQsWZGfuS7KDlk9MufodFXK5SJsfJ7VAWfKkNUFwUYPMw/a/9I+qkZoSpX5+vzdVR565sungdVVEEIixFiq9WSv7ObAY0Y5xEBEL6QakZmpcxS1ctD3oOwnipeoYJOPX/cIzrm1/eDgRIAicq51zx3rzsRVQL7NouNT3lP1IiekX6n0xG8n5+FnCWjae45cXpKkpmBqdkF95AOmS1c+HnJz/G58lnwDnMf1fPJ/WDGQD6DpL5aGKu+h7fN/pj1qOeD+0Q+gjNUyD2qvBnl+oQVyd0QfeB54L3inlBQ83q/PuDV6GPWXPFn1YxNJfIprSfBT9vNPVIdNjNO/j517y+0XxfdWI/Hg9FohPX1dXi9XhgMBvz4xz+G3W7Hu+++i0gkIqkroRKSfTxQhGaI7ZbLZdl0Oopnz55JN2VGpdwU1ikAmFAw8GuZTAa9Xg9HR0dSjEUVGscEGAwGieJjsRg6nQ4ePXokxZ+zs7NScDgYnPdKYwdmKuamWVS+ra2tYWZmBnq9Hi9evJALHwwGJ3r9UOmk0WgkxSYhS2fD98Z/1+v1wiEcHx9jb28PAKSgkntGrJu1Kip5WKlU8OjRownYazQaIRqNSobDoi+Hw4Fer4eXL18Kyc5WHeVyWYrtKE9+W0HEaDRCPB6XC/jll1/CZrNhcXERbrdbhk4xYtNqtRJp8VJ1Oh0hoAuFgpCn5MTYpsTr9cpnpvMAIL+HEAgdFVt/lMtl/O///b9l7gvfCwsLKd3mtM5u97xlPfmvO3fuwGAwSHRP/oHE6tssBoBXr14VOOf+/fuwWq24du2aTBjNZrNSvDwej0UtptVqpeo9n89LxTsNGyNh9rDKZDLSjoXBByFWtZ5GFbBQCfbDH/4Q9XpdugVT6UXZPsUl7Mx9//59tFotGZXAIX985hSoEBqdZlGaTt5tOBzi4cOHsFgs0naJo7OJcvC+8e6pNUwMfmiraOfYZVwtUOeoAkLSqmhGrZOp1Wo4OzvD9773PUFcKA6Zm5sTOT7FKPPz8+j1ekgmk0in0/B4PDIOgnAyIV86youuNx5zzMrPUqkkA4cWFxfh9XrFgajRMGWFNM7EJklmMXLkZp2enoo4gMQ/FQxqARqrVdWHxAr0J0+eyJwYqoqWl5fFsdCRuN1ulMtl0fNfu3ZNmgkSAiG08bbVvYwOiKlWKhUcHx/DaDTKpD2+f7YaYfSiChkASKSidqPlgeWcd06YVCN7koW86Ixi+bu5h0+fPsXZ2Zlcfr/fj/X19YlCOUqXK5UKcrkcSqUSlpeXEY1GJxQmNB4AJjihN128fO4/HwfN+hMOumIldqVSmagdYgYLvMrG6BjIJaiRaDabFdiN/e9YHMkCTZ5n8lLk5wghfPXVV/I7nE4n3G43ZmZmxNG0220RutRqNTx//hylUgmRSAQzMzOiuKLaiZE5+Z1pF6PmcDgMt9uNXC6Hzc1NGAwGgYZZw8GshUGH2sGYJC9ltnyurBXjGAJOhuQ9VaNotTCXqAUAaTHy7NkzZLNZ+P1+eDwe4TeYFVDJ5/V6MR6PkUwmUSgUcOPGDSwsLMizIhrB9/w2XTbY/p5GfTgcSjDICaiNRkO4Kd4XojNqkbmalTAIAyABeSqVmih0XFlZmeBoVCSFCAwdGe/w6empOB7eYYPBgGQyKV0uVlZWpHdZoVCYyGSoFqMknsXsXzvnsrm5CeBVWqTVahEOh6XFB7MPEkmUvzFqZX8hPnBeakYjzDJUaTGzB/53dnYWs7OzckgZRVKux+mUy8vLUqPA98QKZBYvsd8VR5ESS1V7D71ezc+eZdMsDsqicoQYM3Bu0BqNBsbjMSKRiKTIWq1WOC3uPWWC6h4zqmbfJUZzrH3hrJDl5WWEw2GBcACIkeRkQJ1Oh/n5eREMUF3EegMGBCoxTXiKbWUYnTKdpxF+mzHHbMg3GAwkaiSUxYx4OByKyIRng4Qo+QI6HBpqBiDMDKlM5OVtt88nKqrnj1kRDQPVOHRECwsLE33y2HxRp9OhVCoJ38IBWXx+xWIRh4eH4lwYALBrRCAQmPr8AefzTbgIWbPQlk1de72eBEA0LLzD7DvH2iWeI+4fzwgVZoQA2X+s2+0ikUggkUhMwJDM0Dgp0mg0YnFxUbJkNk2MRCLQ6/XSOFIVTLBGh3VylCfTAFMC/jbTUNUuxpTvswEpVa9Go1EKj7moLONZYJBBkY4KodKuWq1WsYEsotTpdHC73fB6vaJA5O/pdrsSPFDByYyatpE2kFk6cG6X2DSYpD+fCwMMZmsWi+XCfAvwBs6Fw678fr+oSNi07fT0FAcHB4jH45ibm5MDBZyTemyLTaiHqid+UEIsZrNZ1CsHBwe4e/cuqtUq9vb20Gw2EQqFBN5ixMT2/9x0ACKly+fzODs7E52+RqMRyIwciKp958GkFh2AyCepXnuTzVUXi8pIlBKK6fV6OD4+RrfbxdLSEq5evSqfbzwey37QWTDiBiDYNd+TTqdDNBqF0+nE8fExzs7OUK/XcXJyIrJZSkRZzEXIkqSeOjebB4uyXwATtSRsRUOxAyNWpvdU7lERt7i4OHWtBoe9hcNh6TPGCJJQRDweFyUiC/SoymGUSIfB9izqeF8VHstms1IVzTbkdrsd165dE2fc6/WkwyyfqVarxfr6OmKxmARBhFtZ0EfHTDkuDWAulxMIls84FAqJivJtunIDwMOHDwFAVEmsHWPGWygU4Ha74ff7MRgM5Lxx9ALfO5EEYvwMmNh5OhqNQqPRIJPJYGdnB/V6XQb+ud1uhMNhcU4sGqSjY4NRnvdGo4FWqwWfz4f5+XkA5/Ymk8lIfzFm8cPhEMVicSKy5ln3er3weDwyAG6adXZ2Jl0neHdZaJpMJtFoNHDz5k3cunUL3W5XxjpQoKTW4zBo5vvmWdZoNJLlZjIZbG1toVqtYnt7G7VaDZ988olU7bM1Pu0cK+op8CFXSvSDWZ5aQM6u1VTxFQoFsY/8QxjQ6XSKUOYi641gMeBVTzFGtCrBqhKcJOwIS6gHk+SqXq+H3++faBfCn+fF12g0ImdkrQYryCmfJWRSr9fl0L4uPSRfQtUI51k3Gg2kUimRNZPgJyHMzwS8qhOYZtGo93rn0wt5kFTYj5JXtfiQahkaJJKevDSEDvlvhCbY842RPgul+ByZDVEcwQJF4BVRzoiasIIcmj+H0siJEYJQIx2S1nwOb6t0YrTM6IrnCHhFRNIo86wxuqMhVDsesIaF0TYvHR0juQ6qDw0GgyilVFiMVdcA5Exyj1Q4juePP0O+oF6vTxSn8VxQWKBWT7/N+VP3EICUDvCPyimRj+MdZibKoFG9W6y7IjcAYKKPHbF6GiUqC3neCPsR0WCkTsOo1nVwHyjf5h5SCk/VGd8H7RKRCY1GI1H5NIvwMfk6vgaDZkJHhUJBbBShYfUsUEBBZ6N2QwYm+zjSsLOTNMsm1DvFIYJGo1FgSO6T+h5pGxj0sTkw8EpcokKYKh3BZ8rncpF1Yedy7do1jEYjHB4e4vDwUOAvvim73Y5eryf9i9QiROLMNAqRSETknuyFw7qV4+NjFAoFOBwO3L59G8PhUFqe37p1C/Pz88jn89jf35f2EIFAALVaDQ8fPoROp4PP5xPDw0FLJLf1+vOBQWtra3j//fdl6BEhPI7C5YVi5Tz199Pq5K9evYrhcIitrS08fvwYfr8fS0tLgssOBudjBDjKlg6SCjISk+xwYDabkUgkpJiUFfrsq2a32xGPxzEajRAIBNDv97G+vo6FhQXpTk14kIaYRX1qrzM6uUKhMAGRzc/PY2NjQ2bPdLtdeL1eac+TTqfFQPOwv85vvMlihffu7i6ePn0Kr9crPBpw7sQ4alhVQbECmY5Hqz1v62K1WhEIBLC8vCzD7dglmnUSgUAAwWBQ5owvLS1hYWFBMjQWDPr9fvT7fRnDy4sPQHB4GiNKVJeXl3Hz5k0Ui0Ukk0l0u92Jlu3s00WlH/H2afcPOJcis+iUI4Rp4CjRZfGcmhnyudFpU+FoMBgQCoVw584dCYy63S4ODw9l9sja2hpGo5GIZ9bW1jA/Py97znoRDrj78ssvf+p9WywWkdwC504yGo1iaWkJ169fl07jmUwGPp9Papjo4CgcUtsTTbPYJ+3evXt48eKFdJVmGyGDwYBCoYCXL1/K+9Tr9VIv1mg0BEJdW1uD1+uF1+uV/SNcyoyWmTohw8FggPX1dYTDYSHutVotVlZWpJNGMpkU4QX7PFJAUfnz4V8MruPxOJaWlqRPGc8CeS2z+XzSLOF14M0CnAtbShb60XPTS/MFSTSRhOSDZWSsdvpkxsMplWp/LUqXyQHQSPR6PWnpQTEADz2n4FGtwuicURGdHAu9iEEGAgFRTDH6ZxTFaFIttOPvnGbxcFCBRtJMlVOygpfRK7+uygdJHDNac7vdgkNTNFEqlSQ6VqMhYrBMi0no8xBScEGlCzNQysC5t9wfqngYDVLHrwoM+Pp02NMaR/5eqpLYN02N+Pn5KWJQX4v4tV6vl0pl8l7MsKkqKpfL8nn4mTjzhAaDwQf5Bs4C4nvlM+U+kkimvJPPjs1K6TjU6Jr3iUT6tGePixkDs3PgVe0GX593UV10MgxwuN80NJzESeUnIS3Wz5ADU++wmh3RqLF9P2EcRtG8h6ra0GQyCfrADJ/PlAEH+wmqkTeDtmkWgzzycDqdTgI+tW9YJpOZ4Et5FsjzUjnJcgKLxTKx7wyE1BIPjea8xILiEu6JypdSBcnMCIDwQrShvLvMXniHWTys9hCjapVZJm35RdeFnQuVUsTtDQaDKMg4iIbEo2qog8EgbDabFKHxIrdaLRwfH0tbBlXvTuUFG7+x5w6n+BUKBTx79kw2iwZxYWFBuBZ2K2XbhVwuh8FgIE0JqWxjNDEcDrG/v4+trS1Eo1HcunULTqcTOzs7UlXPn51m5fN5jMdjzMzMCKnOC0llEAlKq9WKRCIhaavJZJIOtlTXcdoncW8W4nk8HgCQlh00uqPRCMfHxxLFHR8fo9/vS2Zkt9sF7yYvRZUaW1T0+32cnJwAOB9wxWyJ3Vl3dnbEgLAAkaof/u5p949Ci/n5eczOzsrFUjvMMjBgZEYpp8FgEOJ8NHrVkLFarcpUS+4RYT5mGFqtVhRA5P/K5TI2NzcxGAywuLgoExVnZ2fR7XZlrg0DALUZK/vr5XI5nJyciLKOwgQW+t64cQPj8Rg/+MEPcHh4CADi2KdddAzBYFAK/EgCs7O1SiwzgiUcSGUgoZHxeCxTaVUDbrVaMTMzIx0mRqORyICbzSYODw9RqVSwu7srZQLBYBB6vV76/uVyOXQ6HYHCCUXRuBM+V6v+AchMn1AohHfeeUfOqjpJ9G14U+B8kBkLvJkVc5Bgq9WSUg06UraAod0EID3F1Ca0RCRYU8RzyDPL7I2fl2eKPPZ4PBZ5O58LHQXRIwAyhfXk5ASbm5tyZqkK7Ha7mJ2dxZ07dzAej2X6MNvafO2ZCz+w1+vF7OysOIl2uy0t9En40NgRouLQHvZ/IqbI+guTyQSPxzMhc6Wsjhvb7Z63Ld/f38fZ2Rm2t7cxGo0k+6FUsVqtiqyO6hKqwLrdrlS1cg49nRcNZzqdxo0bN/Dpp59O8DXsBjzt5S6VStBqz3ubRaNR5HI5PH/+XDgfRtU0iOwHRuPIrIeRA2taisUifD4fbty4IdMCdTqdQFT8rCSfOaqYF4XKOq/Xi0QigWq1igcPHuD09BThcBihUAidTkdaTBSLRXHWhFa4pycnJzg9PcWVK1fw3nvvYTwe40c/+pH0O1IhsjddtVoNOt15J4eZmRmcnZ1JP7p8Pi9tc5gVEwNn92GeAxonduZmnQuNG/eWmcVgMBBhBNVdtVpNRigwOnc6nQgGg6jX69jb28PZ2ZkEN9VqVYIrnv9UKiUjK5h9VqtVpNNpqdVgAJJKpeT73sa5UNnn9XqFu6Qog5kXa5joXIxGo/RPo+FTs6hisYjT01PZb2aNVAYS6iF5zY7SpVIJOzs7GI/H8pok+9WW/oSNh8OhQJGquon7SedyenqK09NTrK+v4+OPPxYuh5/tTRVP6mJwGY1Gce3aNRSLRRwcHEg/PtbiEB3hfzl2gsEBBQvNZlPuMNsNUbVIRIOQIJ9foVCQ5r7kvllTyP2r1+vY3t5GoVAQQRKzQhWBYcbFZ0dhByv0FxcXAQDf/e53USwWJXD92jmXYrEoEBUAcSB8sdFoJK0vmGoz6kun0zLfglAV4TW1AlRVkPDwqvgusxv20OFGqWRzp9MRB8e+PsPhUNJnKnNI2KvV45wXE4lE5MH5fD4sLS2JoZ92Eftnusqpmfx8zCJYG8EIh8Ocut2utJkgjAdAMF2muoQ3VIKaeLq6pzSchA2pFGE7HY/Hg8FgIBFZJBIR/qbX6wnkxt+p1WqRSCQQi8Xg9/ulsM7n82FhYQGRSERkwtMs8iWcVUN1ESNrksZsAskzQ2fAIlJCUtw7VQxBeIXOhZ+LhbiEErRaLQqFgpxVtRMvM0vCbYTKIpGIZFsAfkrEMhgMZCR4MBgUpVYgEMDa2po0d3wbzoVwDYMUfk717pnN5okGiczyqVJUCXHeG9UYqvtA/J4SbRp3wrLcQ0KAasNFoiKDwUBQB45b5shv8qm0AzrdeYt/njWKSjwej0x7pUhomkWOgwWLw+EQbrdbso/x+Lzynn3X+Hx5FyjpVYUP/Cx03IRBKSYilKd2YR6NRhOdDqg24x3udDqwWCzw+Xzy7+Rv+JwIk1HkwuXxeKRzOpWfFosFkUhExqN87ZkLddbNZlMimWg0OhFZBAIB3Lx5UySBJAdLpZJUJDOS4GFlxK4SRdwsAEJgq4ddrVQFIFHl2dmZaOT1ej329vZwdHQEj8cjY1N5ME5PT3F4eCiOTK/X48MPP8S1a9ckqhoOh1hZWcGNGzckyp0W997b24NWq5XeWNTcD4dDMZxzc3NYWlqaKLLi6GWz2Yx4PD7hjIPB4IRiDphsc8NiVerbGWHz36koY/M7jkEl0bi5uYnd3V0kEgl89tln4vT0ej0ymQz29vYmWsjcuXMH165dQ6FQwIsXL9DtdrG8vIy1tTW4XC6JfKZZrPRmwOJ0OhGNRqWWggTl/Py8QIG9Xg/7+/vIZDJwuVwyeoCcCCWsrLgfj8fCq5D8pYiBXIlGo0GhUBCSczgcCrlK/J1GLJVKydCsmzdvSk0XZdsqrNjv93Ht2jWsrKxIs9LhcIgrV67IyO23UYoBwIMHD8QAc/DZ2traBLTidrvl3zirJJ/Po16vC89B5/K6UpQGlMWTJLJ1ulfz7Bl05nI5ieAJvdLBsOQhEAhgd3cXR0dH8Hq9WF1dnYCK8/k8Tk5OJooJ79y5g9XVVekQQNhtaWnprfdvZ2dHlK/dbhdOp1Ok77R5oVAIs7OzoqpluUSz2YTP58Pc3Jyc4X6/L86I4iHWvTCIJodIGI51K/l8fqKLMjMZFl/SPh8dHSGZTCIUCuH69euSTZtMJoFmWVc1GAyQSCRkyNrLly8laLt586Z0G//anQvwqvWFWjyn/iGsw8PKqIwHSI1y1cuiRtSMJPmz/H6VIKYzomSYmCIjFeLmNIQs4iSHwHST863p7JjOE4Yj4W21WoWAVL38m+4dcWlmB/ycqoiAERv3mBAOAMkWVHkmIz8u7iEjFhKGJFEZSdIBsUaFl4F1C2pEz7SZha7cEyoEGTmyUpnD3ahyoUNXhQpvurjv7E7AiJvZB//OcQ2UCnMPScaqMk31HDL75ucejc6bovLzM2Jj9kIhBM/Z61Egv0ZRgBrY8PyxqJMzeFhPRHKXBC4z27fpcAC8GhvM36/KxbmYiXAxA+Y4ArVglxkHjbvqdPiz5GfUinw1+ucZ5GuyHTzvOxczSLYr4t5Sbs+9Id/G58EiaGafb7OH/CwkyQn9cz94dpjd0flSBkxSnB1JgFdOmRmI+hx4fvm51Ap/ohPcP+4D684Y8KnZI3+edofdLWhjmCGxhouyfgp5mPVedF3YubDqlJEa25XwDblcLozHY1E78SDT6NMzUtdtNBpRrVaRz+cnjBaH3lQqFZm/MTc3B71eL5eCl95oNCIejyMWiyGbzeLg4EAiHxJq7733nmDvAFAul9Fut+H1evH555+jXq/j8ePHQpKl02nkcjlpq06VTz6fRzqdntq5RKNRAJMXmcZKPWB03oSo0um0TPzM5/MyfdJqtUoXZbfbjY2NDXFY7E21t7cHm82G999/Hy6XSxw9K5lHoxEWFhYwMzODdDqN3d1dUd8xwmXBrOpwCXd9+umnqNVquHv3rpC9m5ubEtXT8el0Opn5AwD//J//8zfePx5uCjaI51NqSo5Dnfui1mWQAGXNEAvwyuWynBVeXMp1c7kczGYzrl+/Dp/PJwYCgFyymZkZLCwsIJVKYWtrC8CrNjczMzNYXV0VA8SMpNlsYmFhAXfu3JF2PzxvHLtAhwNAeuq9TeYMQAo7mUFbLJaJdigMMti6R+2px+CDsB/5hEKhgHw+D4vFgrm5Ocmgaex4Zufm5n5q8iaNYCwWm+hNyPNJcc/GxoaIVXQ6neyZy+XCBx98gGazKfxlvV6XwlZ28uUzZQunae9wKBQCcG74W60WTCaTjAwhREjnzSyMWQ1wLop68eKFBBdEAE5OTuByubC8vCyjK1hEzaa/HMFRqVRQKBRERDUajZBIJHDlyhUZ/9xqtZDJZKSOcHl5GYPB+UgP9nUcDAaYmZmRM/jll1+iVCpNQGaELTm+olarIZlMXvgMvtGwMKpK2G6AmD6jClUuyChfxaVZ5ESIgWopfg8NG40ZMV5VUszXBc6jGZfLJTPuafgajQb0+vN5BMQZAUiaWa1WEQ6HMT8/L4ohGs5arSaOhmokzgp5m4PJJoCMqF7P3NS94vvga7KtBCNwRryE2LrdLlZXV2VP9Hq9GGE6VUZ7jKYYZbtcLoTDYWmhwWcHQNrm8PvViDcQCGBubg6lUglPnjwBcG4E6RTJUQDnUTxFBNMax9fl0YSzeLbYBl1tjaNmVWy38nrRY7lclnEGauFso9HAyckJHA4Hrl+/Li1niIcDr7grcnTMeGg83X/e5p+ELy/s2dmZ8FMUIVDCrwZQhDrG4/O57eVy+a2cC88CcX3+V31OzPr4vCnD5+ci9EdokRNSeU5UYp9OkSpQdkxWgw7yU5zzzmyDWS7JcApdAEhdnN/vRyKRQK1Ww/7+vrRT4R1W+UrKf9/mDhMqZZDDP7xTzCZUHoR7B5zzwZVKZaJWrVgsIpPJYDgcSnsYNQsmL01Ug2pP9hQEzm1zLBabCOwZZDP4KZfL2N3dlVk67XYbkUgEsVhM2m+pcngGaKz/o02hw7nIurBzIa9ydnaG4+NjjEYjrK6uCnxFMo6zIOiZ5+fnkUgkUCqVpMsmU0O1ip8fhEWZ7j+f16EWRTLSBCD8jUajkQPj8XjkUvR6PdjtdsE/eWFYQFgul/HVV19Bpzsfwbq8vDwBkdBI8QFSwDDt5SaMl8lkRKrKdjI0RjxMVH5QecI6CRYm8g9n0fBiswGeXq9HPB6f6GBMQ8WolKoqKnlI+NHBtdtthMNhBINBuTD9fh+ZTEbUTw8ePIBGo8Hq6ipWVlbkYAL4qRSfl0P99zdZ4XAYw+EQOzs7OD4+Fj6MF0LV/qv/T+lyqVQS6S/rMXgBAUgNDs8fZ15QpUViltXXiURC6jFYJxCPx0UazZohv9+PXq8nw8CKxaKosx4+fAiNRjMRBLGegcEOOwSod2Ta5XQ6MRyeN4dNpVIYj8cyg4VnnXJhcmkGg0G4VfY+YwYMQKrI1dofFoESouLd0WrPm4uSb1Gn23K2CzNsBp3hcFhm24xGI7kLVIA+efIEWq0W8/Pz0hqKi46ZwS9bmEx7h6ngSyaTwneQg6jVamg0GtIlWxUPhUIhGAwGKf5WRUSEoXQ6ncDJAEQxy9IO9mdjVqPRaKQDOWtoLBYLVldXRUTV7XbhdrsxOzsrWR+nrnI6571796DRaDA7Oys2lXeK75P25vUC4b9sXdi5EBPNZrN49uyZFN7RozEqIMYfDodhMpmwtLSEUCiEFy9e4OjoSIyU2iaGUWWv1xN81OfzST8mRjQnJyc4OzuD2+3GlStXZCATG2dyDjejeafTieXlZUnxKWMcDofIZDL46quvEIlE8Fu/9VtIJBI4OjoSRQ3xRkZRLDia9mCSizo9PcWTJ0/Q7XalshaAPEzyJIwWfD4fXC4XXrx4IQQlnTIJdmaNVNlw2BIPPp1/s9mU6Nfj8YhDo0yaHXmpv/d4PLh69apEf2qGkM1msbOzg2AwiF/7tV9DLBZDKpUS7T0zV0andC7TGsdEIoFer4f79+9PnD9GyaqKiTUCOt15rzWfz4cXL15gZ2dHolhmNfwZcjTkSMLhsDQRVTPiTCYDi8UildlsMGg2myUTZr87g8GAYDAoRpND7lgs+2d/9mfw+/345je/Cb/fL/sHYEJ9xA4Lb9OVG4D0wzo7O5M9ZOTNc8VCUi7C0vF4HFtbW9ja2pJqfAYidC6MspmNMUtklkLYfHt7GzabDTMzMwLFMer2+XySEfT7fcTjcdy5cwetVgtnZ2fS7aBeryOfz+P58+cIBoP463/9ryMajcowPpY60CDabLafUqK+6WKnkKOjIxkrzmmy5XJZWuezIS2zLwYPm5ubQpLzfak1WWxqyroYKgf7/b4obkulkkBlPIOskbJarbhx44agHd1uV2CxVqsFj8cjTrDVagnUHwwG8Z3vfAehUEhqWphMMOhQg+yvPXPh4gv+rIdESEH9d1781/X56vdQoqn+IbzDTIKppyoKUCWRP+vfVGnu6wQuyXVisoz4Vajq9c/3tmoTYHJokfoa6u/me+ceqNXe6ntSyf3XfxcvNP//Z+3v6z+n7p8KXXAf1bQZeEUQq3r5nyWVVZ/htOt1glQ94D/r96rKJOLI6v7S0Px/ez21Up57wp9R95fvgXvE7wUwkU2p70m9uOpZ5/tTn+XXoRRT3yeAv/AO8/Vf3wt1D/n1n3V21ddRz496Bvna3BP1Lqj7pL7267aAv4+chkpUq5/jZ92XaZ0L3wv372fZrZ/1u1/fP56N15+t+jxet1k8s+q+q2dQtXd/0blUxUMMZtU+bmpJCNfPuiMXPYua8duEQpfrcl2uy3W5LtfPWNNXZF2uy3W5Ltflulx/wbp0Lpfrcl2uy3W5vvZ16Vwu1+W6XJfrcn3t69K5XK7Ldbku1+X62telc7lcl+tyXa7L9bWvS+dyuS7X5bpcl+trX5fO5XJdrst1uS7X174uncvlulyX63Jdrq99XTqXy3W5Ltflulxf+7p0Lpfrcl2uy3W5vvZ16Vwu1+W6XJfrcn3t69K5XK7Ldbku1+X62telc7lcl+tyXa7L9bWvC7fc//a3vw2tVot4PI5wOIxCoYCtrS3YbDb8zb/5N7G2tiaDltrtNpLJpEw94xyMZ8+eycwGi8UCq9UKh8Mh81t0Oh1KpRJarRYcDocMWtrb20O1WpXJdiaTCR6PB2azGaFQCC6XC2azGTabDZ1OB/v7+2g2m5iZmUE8HpdhVb1eD3fv3sXx8TEsFgvsdjusVisSiQSsVutEi35OwOTQMHVw2L/+1//6jTf6V3/1V2W+SCAQkP0wGAz4q3/1r2JpaUlmrXc6HRQKBbTbbZyenqJYLKJQKODw8BB6vR7Ly8sTe8hW2hyKZDQaYTKZYLfbUa/X8f3vfx+np6fSMt7n82FjYwMWi0VmlXDSH8fBDgYD+P1+GZTF6XsPHjxAKpWaeHbBYBAmk0lmpFitVvh8Ppk2ylHXnFz6b/7Nv3nj/fsX/+JfQKvVIhQKwefz4ejoCD/+8Y9hNpvxm7/5m9jY2ECtVpNhcpzD8id/8id49OgRrFYrPB4PTCYTotGoTBUEztuVd7tdjEYjWK1WGI1G+P1+zM7Ool6v40/+5E+QTqcRCAQQCAQm2sl7PB7YbDaZGspBX5zgx/HJnML44sULZLNZLC4u4vr16zL9UZ0AybHhw+EQyWQSlUpFhr5pNBr843/8j994/wDg3/7bfwuNRiOTB1OpFO7fvw+9Xo/PPvsMs7Oz0trdbDYjGAxCo9Hgxz/+MV6+fClTXHU6nUzR9Pv9CAaDMrNnPB4jk8mgXC4jFAphaWkJ9Xod/+f//B+cnJzA6XTCZrPJ3Ce9Xi9D2djunRMvh8MhAoEAfD6ftKbv9/sy7IpnkLOWODPIYrHIXe50Onj27Bny+TzsdjucTic0Gg3+w3/4D2+8f//kn/wTaDQaBINBeDweHB8f40c/+hHMZjP+1t/6W1hfX5+YvJvL5dBut2XIF++wVqvF4uKifG4+23A4DK1Wi729PeTzecTjcayvr6PRaOB//a//hWQyCYfDAZfLJTOzeG85m4eTPznZdG1tDcvLyzAYDLBareh2u/j+97+P/f19hMNhzM7OTozSoA1XxyNUq1UZwMgx3//xP/7Hv3S/Luxc5ufnodVq4fV6J6bL8c1wtnM6nYbb7catW7dgs9lwfHyMbDYrA4GA88lsHBw1GAzkYNIYFYtFGd7EGQdGo1Hmamg0GhnB2mq15ICGQiGZ0zIej3F4eIiDgwPY7XZEo1HodDr4/X44nU40Gg1Uq1XU63UcHBxMGP5Go4HT01MZuUrjy/c4zYrFYtBqtTILO5FIwG63Q6/Xw+PxYDweY3d3F4eHh/D7/fjkk0/gdDqxu7uLdDoNq9WKVqsFrVaLaDQKr9crA7xMJhPcbjd0Oh0qlQrOzs5kiBjHNZvN5omZE+l0GjqdTj6fx+NBOBwG8GoORiqVwsHBARwOh0ypi8fjMnSoWCyKw9fr9UgkEojH4zIOtdvtyvdYLBbYbLap9g44H7amjmgOBAL49re/LQalUqkglUrh6OgIXq8XH3zwgTiQpaUlmeQJYGIcLad3Op3OiXkltVoNu7u76Ha7MBgMCAQCEsRwnjwnI6rjkbVarQxi4+RGh8OBeDwOg8GARCKBaDSK8XiM/f19dLtdlEolDAYDhMNh+P1+GSrW6/WQTqdRq9XgcDjgdrvfaq4L958jbP1+P375l39ZzqDBYECxWEQ2m4XH40EoFILdbsft27exvLyMg4MD3Lt3D8PhEGazWRzm2dkZrFYrotEoDAYD/H4/zGYzBoMBnj17hn6/D7fbLc6EM1H4WTjSnAGi0WhEJBKBwWDA/v4+njx5Ap/Ph/X1dZhMJszOziIajaLdbqNer8sd7vf78jVOHOWkVdoOvvY0i4HccDiUyY/vv/++OLder4dMJiPB68zMDLxeL1wuF9rtNlwulxhn2iEO4lJtm9lshsViQbPZxMuXLzEcDhEOh+F2u+W96HQ6GevdarVkTgvvCZ91NpvFyckJXC6X2HCr1Sr2KJvNot/vo1qtYjAYYGZmBuFwGM1mE7lcDv1+X0aKm0wmmM3mr38SZSwWAwAZX2q322VSH+dl7+/v4+HDh1heXsYv/dIvIR6Py+hTGgTgfGSt3W6XWdcGg0EmXXIE7GAwmBh6w+iPU/MY2RQKBQwGAwQCARlMxGFEp6enclE41S8cDsPhcCCVSqFUKslcc+B8tGgoFEKr1cLBwYFkLaPR6K0vN6NAZktOpxOJREKyjfF4jJOTE/zgBz/A+vo6/vbf/tuYm5uT+eMAkMvlZOyzz+fD2dkZ6vU69Ho9rFYr9Ho9Tk9PcXZ2NjGIidMC1SFPnIXNaaCMtNWhTvl8Hqenp5It2Gw2Gc18cHCAVColz5fRbCAQQLFYxMnJicyhr1QqCAQCiEQiUztnng++Z7fbjWvXrkl0WqvVkM1msbe3h/n5eQQCAUSjUdhsNiwtLWF3dxfVahW9Xk+cS7/fl+mJzFgYoTUaDeTzeQls1KiYs+d5Djkfns+AE0KPj4+xvb0Nv98Ph8MBh8Mh45OPj4+xtbWFer2Oo6MjdLtd3Lx5E06nUyZ9djodZLNZ1Ot1eDweGYE77WKA0Wq10Ol0EIvFcPPmTRgMBhQKBZkyynHaGo0GVqsVgUBADP/Lly8luyIa0G635RlZLBa43W6YzWZkMhns7+8DOL/zoVBIxuUOh0MZ1seZ7syELRaLZJdPnjzB/fv3MT8/j6WlJdhsNplye3p6inq9jlarhZ2dHVSrVRk93Ww2JahV11800O4iy2q1AnjlnG02GxKJBIxGI2w2G/r9vkyaDYVCWFlZkeyfQ+Gy2ayMMXc4HKjX62LLgHPnotfrYTab0W63ZSpkOByWAFM9oxz0xWmbHo9H7IFWq8WLFy+wubkpWY46qbZcLstk1JOTEwmU3G43yuUyDg4OZCIo7QMz94usCzuXTCYDjUYDn88nE+NoVHhZOZWw1Wrh4cOHODo6QjKZxNnZmYyCHY1GApUx2uHmMB13Op1ykcfjsVxkXmLCPipcpdfrxVv3ej0A55FaMBiExWKRmd/tdhtGoxGNRgPFYlF+Lx2TOoudKe7bzC3nKpVK0Gg0MhKasBUn7HGao8fjAQA8ePAAR0dHyGazqFQqqNfrMJvNACCztnU6nUASNLo8mNxTfp862U6n08nv4mhVjltl1M4xuxaLBQBkxKzFYoHBYEC1WhUIigeWDoD7yUPOWeyEFadZ1Wp14pxptVoZJcwsjcFItVrF/fv34fV6YTQaZX84UppG1Ol0wu/3TzhiPgubzSawYb1eR7/fFzjMaDSKsW+1Wuh2u5KZaTQayUQ6nY7MQGcGqdfrJSpkYEQIkeNtGc3ystvtdpjNZjmj0y4GUfz9nGdPVIBR/WAwQK1Ww+bmJjKZDEKhEDweD+r1OpxOJ7rdLobDoeyhy+WCyWRCu91Gr9dDq9WSOxgIBOQOtdvtiempFotFsgAaSZ7ddDot5zcYDMJms0nQSWgum80imUzKSHPCdG63W5wXHSGnLKoTP990NRoNAJOTIHlPaINoowaDAQ4ODpDP5+X+VSoVeYaqQ11YWJD3xzOo0+lgtVolU+Be0PYaDAbY7fYJ56xOoaxWqzItkxQCzzGn7jabTRQKBfT7fVgsFlgsFnmenU5HzgX3y2g0vtEZvLBzefToEfR6PRYXF5FIJGST9Xr9hBGyWq0ol8v43d/9XRm9qdFo4PV6MTc3h8FggL29PdTrdbz//vu4fv26zL3v9XpwuVySpVitVvR6PZRKJbmojA4JT/R6PYkiAoGAXIzhcAifz4dYLIZ2u41SqYR6vS4ePZfLYW9vD1qtFoFAQH4vjSeNtQolvc3FPjo6kpSXhpwRIWe32+12zM/Po9Pp4Ld/+7cxHA4FhjSZTHA6nRgOh0ilUuh2u7h27Ro2NjZkLnqv15PIAzg38oxwRqORGFqHw4FoNAqNRoOtrS30+324XC7Zq729PRQKBRiNRvh8PgyHQ+zt7QGA7FUymcTx8THMZjNWV1flPdJwcH56MBiUCJWQwDSLs+UZeBAitFgsSCQS8vr83v/6X/8rdDodPvroI1y9ehX9fl+ygnQ6jVarhXA4jBs3bqDVaomRUs8eDSnhMToecoTD4RD7+/uo1WrweDwIBAJotVp4/PgxSqUS9Hq9nOdSqQSdToezszPodDpkMhmBHO/cuQOfz4doNCr71W630W63Ybfb4Xa7xYG+zdrZ2QEACQQYkXIPyUd0Oh2JZnU6HTY2NjA3N4d2u41QKIRut4t8Po9Op4N4PI7r16+j1Wrh5ORE4Operwe73Y7V1VX0ej0cHh6iWCyK06bTHI/HcnZ1Oh1cLhd6vR4ePXqEer0Oo9GI9fV1aDQagTUZ6efzeZycnMBut+PGjRvwer0Ciw0GAzQaDbTbbfh8PpjNZslAp73H+XweAMTAqlAReSQafXIbNO6EXWmw0+k0ut0uPvvsM3z66adoNpvY29tDs9mUc+ZwOODz+TAYDJDJZFCv1yfgL6/Xi8FggNPTUySTSej1ekE7UqkUGo0G7HY75ubmMBqNkM/nodFoEAqFYLPZUCqVsLW1BZPJhKWlJbhcLsTjcUQiEQyHQ7HpamZkNBovvF8Xdi48iIRRaOA5351kkN1uR6vVQr1eR6/XE4/MtJCbw++nk2CqzKhKnZnNP4TjOPN+MBgIPqnT6X7mjHNeIv4+vr7ZbBYjTKiP2RNfi3wP/40QyjSLkIZerxenxSwMgBh/t9stBBqzPToF7iU/Aw0d3yOfDfeaWRi/h46N+wWcQxkqn6HuH38H/18lss1mM1wul/w8IUsV2yZMYjAY0Gw2JXqfZnHvCauoz5JBBuEtGqzxeIxGo4Futztx/kwmk+w3DYI6q5yfgUEG954GnnszHo/ljDEa5DkcDodiePic1JnohFJobJmZ8KyRlFYzMmYD0y7+vMFgkKCP7wnAxNknlg+ccyLE3fn95JlMJpOIOQgz0rmQY1Ezf+6/OvudgQjPOWFaikNo5Hi/GdAS5rFarbDZbIIEMLpnds4zT8c5rXPhHeY+8fOo50cNfJl9MoPiXeHPMZMymUwiAlHFL8yWNRqNfHbChjz/fC+0Dcx+VLtFbowOnO+TEKbJZILD4YDNZpPslZkTv5e/+00CxAs7F14OwlSxWAy3bt0SMp+ZRSwWQ71ex87OjhB1xGR5kBYXFzEajYSzIUnL6CebzSIYDGJ+fh4ajUai1dnZWczOzqLdbiObzaLb7WJmZka4nOPj4wmvT2zUYDBgfn4eRqMR0WgULpcL0WgUn376qSjbOp2OpN4GgwHXr1+fMLR7e3tCrk2zCL8B54bX5/PJ/hE7DoVCmJ2dFViFfJR6aA0GgyjrwuGwHDwqOdLpNIrFIrxer6jg4vE4AMDn88Hr9QrO3+l0YDAYhEc5OTnBcDiEzWabuPwUIBgMBiFm5+fn8cknn0gU2+v1BPIk1MP9o1hhZ2dn6v2r1WoiyKD4YHV1VbKAZDIJg8GA999/H8ViEf1+H81mc0K1Q4N//fp1cbSERmncK5UKGo0GxuMxnE4nAMDj8cBiscDv98Pv96PZbCKVSkmmTT6FwpRgMCgKIAZE4XBYDB8dGAM2GpZKpYJmswmdToc7d+5gPB5LoEFxxdtCtFqtVrKhcDiMq1evwmg0CsxptVqxvr6OSqUighH1jBHaWlxchNlslrtH4rxerws8xkxkNBqJWsnv9yMajaLVaiGTyQjsFYvFYLFYxM7EYjH4fD5x3OR+9Hq9ZMIAZD8YCPb7fSSTSYzHY7z77rsAIMHUyckJHj9+PPUeNptNAJCg0Gq1YmVlReD78XgMt9uNmZkZEbn0ej1RhamqLApw3G43SqUSarWa/JdUgtfrlc/VaDTQ6/UwNzeHpaUlEZy0223EYjH4/X4RsBBiZdbMII+8NO9wNBrFt771LQwGA5TLZQnQMpkMhsMhVldXxWbr9XpsbW3h0aNHF4a3L+xcGPkTX6Skk1EgAEkNqRwjL0NIgZEe5Zl2u10MLr18rVZDPp8XtQk9OyGaaDSKarWKUqmE4XAoWCtVUlqtFm63G0ajEe12W94rSUYSaU6nE4FAAPV6HePxGOVyWeR8Op1ODC49fSqVQqVSmZpUZcTOSMRqtSIUColCh0Y8FApJyqv+LLMIfhbCaAAkUu73+6jX6yiVSoLV8mf0ej1CoRBCoRBOT0/R6XTQaDQkgiYODEAiekZPZrMZXq9XoDkaTJfLhXq9jkePHqFSqUjgoUbearbTaDSm5l0IWRFatNvtwv9RmhqJREQVSEh1MBig2WyKITeZTAiFQnC73Wg0GuJI+JwHgwHa7bbwCsCrwIpS1sFgIIbX4XCIcorRJPeTGYnL5RJClVElnwthSDrCTqcDt9uNWCwmQUWtVgMAcdzTLjXrIL5O+St5NqPRKA6DhL0KDZPDcLvdYqQAiARbzVyYMarRtc1mg9vtlrPS7/fh8/mEa6Q9cDqdcob4/5FIBEajUX4n4ahut4tUKiVSacLf0WhUom4ASKVSyOfzU+8hMwlmYwaDAV6vF2azGc1mc0JGrtfrJWtmkEE7SXUesz5miYRCq9UqisUi9Ho96vW6wNuUyvOZ0eEzWFBVeHa7feJz8u4StjOZTIhEIpibm0Or1cLm5iaq1SparZbYBa/XK/ZXr9eLRPprdy63bt2SNJ0wxw9/+EOYzWaR8PJAUaE0Ho/hcrlgs9kkagYgUVG/35cHQKJpbW0N8/PzcLvdgu9ubW2hUqkIfFOtVrG9vY1+vw+v1wubzSYH32KxIBKJCHbLiL5YLIqBZoSjqoLq9TocDofAKpT30ZgGAgHMz89PfTBXV1cBvMJr6/U6/u///b+i3FhcXBTYh5CN1WoVaMtoNMphKpfLYhBYF0PHt7CwINGUy+XCYDBANpsVErvVaqFWqwk0w+dJZ2OxWLC+vg6n04nT01PkcjmBmVT1HnDu9CqVCk5PT1EulwXWI2RHQ8Ysa3V1derM5dq1awDOIR3KJ+k8jUYjZmZmYDQa0Wq1MBgMhCxWYT0GKWokzu8nMet2uyXCo6Hc29tDrVaTrLler0tNC7meTqcjPMv8/LzIwJkx7ezsiESUcLDZbEaj0UAymRSy3G63i2KSApDRaIRAIIBbt269VeaysrIC4BweKxaL8vmNRqPAIhTJMIvo9Xqo1+tIpVIiuaWzHQwGqFQqKJfLEqTRKBGKstlson5jlsj9JsTJPzyDBoMBkUgEZrN5wlE9f/4c4/F4wqHz/DM75RmhMIVOjXf52rVrU0Oza2trkkW0Wi2USiXcu3cPNpsNMzMzUptEeJpOjVAX7yT5Gj5biny63S4AYHZ2FvF4HC6XC8FgUJCaUqkEl8sFo9EomU6/3xdYUC3tiEQiEvAAkGfI+jU+a74+VWNqsM/si0GJ2+3GysrKhe/whZ3LRx99JA+Mape7d+/CarXi7/7dv4toNIpSqSSkFyM0t9sNq9UKl8slDujk5ARnZ2coFotIp9OSthmNRrzzzjsSOQFAsVjET37yExwdHUlxEp3LcDjE+vq6bFSv15OiSJJSJLdYU8BoSK3TyOVyaDQaE0oPYruU4H4dxnE8Hgt+nc/n8dVXX8Fms+Ef/aN/hLW1NSmWZIRttVpFKcSDwwvNaNBgMIhyR6fT4b333sPS0hKazSZqtRoqlQoymYxIWqnM4WelweVlCQQCuHLlCmZnZ/H48WOR+aZSKQAQDoFOu1QqIZlMolQqCVxH58IMwmAwiJR9WuP47rvvipE+Pj5GsVhELpeD3W7HBx98gEgkgnq9jnK5LNEinTIAeU+vOxcGN5VKBVqtFu+8845Ak4QYnz59inw+j1qtJgFLpVIBAMlIKpWK1Nh8+OGHiEajODo6QiqVQqFQwIsXL9Dv9xGLxSYyz2q1ioODA1QqFczNzUkkWyqVoNVqxQBFIhEsLS29lajknXfewXA4xIsXL5BKpZBOp/H48WPY7XZ8/vnnIrihc7ZYLOj1eqhWq6hWqwiFQmL0qV7iGVN5xNnZWYTD4Qn+IJ1O4+jo6KfqMlSokMXWbrcbt2/fFrlspVLB8fExHjx4gE6ng/n5eYmq+R7z+Ty63a4IYIbDoagZGXkzg5x2D/8/7P3Zc9xplt6HP7lgSSCRGzITiX0lCO6sYi3dNequ7gm12lbP4lBYjphxhMPyje0r3/hSF/bfoAv7xrLDDtkjeUayxmNLM9OapXumqru6imRxBYl9R+6ZADKRe/4uMJ/DF+zWb0CwfMc3glFFEszl/b7vWZ7znOewf6urq9re3lY2m9XOzo7ZtsnJScvgXIQDJxoMBpVIJKztACdFoAIEOT8/r0QiYQFmLpfTT3/6U21tbcnr9aparVpvCgX6YDBoFPne3l5NTk4qFouZY1hdXdXnn39u9icSiVjZotls2v5Rw+K5USPz+/2KxWK6cePGhe/whZ1LpVKx7ADjB7aMsSwUCsrlcjo6OlKn0zGYAXgFaIL6AR/aLVgRVbiMmWg0eo4n3mq1FIvF5PP5rKETY+xSNl0IamZmxhozc7mcRVVAJy6ZAOjPZZ7V63XLHi6zeF1JVmyExXJ8fKy9vT2VSiVjtXFAiXzd4j3PADyV1wTPpbAO1AJFs91u6/DwUP39/YrH4/ZvJVnxGTisWq1a6k8TJQ4uk8locHDQIjUK3jh/iuwej8cokjjvyxIiOBtAm319fdZpXq/XdXJyomKxaM2b7AmRGefDzVxdmiVRnLuX0hmEEY/HJZ3BDWRwFI/5rpLOFaR5RsBjY2NjltXn83lFIhEFg0E7CxSfoY5TfMf5eb1eDQ0NvZVz4V4AK7ZaLcuiarWa4e71el3lctk+v0vTJ5J1yR9+v//c/rkkEmqNnD+ibmBhMmcQAZcA5DYxBwIBzczMmAEulUqGNEg6R4CBiMFzgUIMGeiyi7vlQkVAjOwfv6jPuKQJt4eMjNutbUKYYC9dZCccDmtkZMTOII2/vD/3lveUXgVysHlnZ2fNjpOVoAqBrXDvKHA2dTZ6Dy96hy/sXJaXlyXJWB3xeFx3795Vt3sm9wC9mIiOyATmWLvdthpLNBq1i8VBqlararfbBs3k83nt7OxYNB4IBPTjH/9YP/7xjzU7O6vf+q3fUjQaNdyW9BeGCg6j3W5rfHxcH330ker1uv7Fv/gX+vLLL5VKpTQzM2OXCaYL8gk4wkKhIElmzC57uXO5nB1Mn89nkWi73dbKyoq+/vprg+pc+Qu+RyqV0tLSkjmObrdrmQ3/hr9DcuLFixfyer26cuWK+vr69Pnnn+snP/mJrly5ok8++USxWEzpdNoiIAzPwcGBRTXBYFDRaFQLCwtqNBr6/d//fX399deanp7WtWvX1Gw2NTQ0ZM8xnU7b96TJtVqtGlX3svvHZSV65oJLsoz58PDQ4Bto3hidVCpl9Zjj42NrqCS44WK6mSnY9SeffKJOp6NHjx7pq6++0sTEhP7u3/27CoVClg16vWfSNIFAwOAK8PLx8XF9+OGHqtfr+oM/+AN9/fXXunr1qlKplMl4cDeOjo7OqVPs7e3p+PjYoOLLOmfplRPAqLuBCOoaJycnBpvCCiQQRGrFZTySEZycnCidTqvT6ZjzhVQhSZ9++qm63a5+8Ytf6MGDB5qentann36qcDhssLQkg6FLpdK5+tfIyIg++eQT1et1/d7v/Z7u37+v+fl5jY2Nqd1uK5fLqVgsmmoHJAACquPjYw0PDyuVSl3awRAwUIOkpcDv9yuTySibzapQKCifz9tdghmHg6YmCQxJEEtzZKfTsZ427FG329XNmzd148YNPXjwQA8fPtTU1JT+/t//++dqVbBiJRnUJp05l0Qiof/iv/gvVKvV9C//5b/Uw4cPrXUBmalqtapwOKxgMHiud6zVahnr9k3u74WdC5Enh45iFlz/bDZrD5ZDSeSIgSTadhvuWESmZCw4JZoqkaeAEsmfFYtFi7CBedzX4+9wRHhtoki30M5nff2/7XbbDshlL3ej0TjHFuvr61MsFlOz2TSJHJcSymcjeuNQuxEk0Q8FabfrnEtJEZWojZQavNqlNxP1EcEQaUJZZM/oKiaypaHVNdLgzsfHxybt4VI433QBM8DC4vt3Oh2dnJz8EjORYIPMlH+Lc8GJvE7FBQt3qePsHbUVAqWhoSEjC0iv4BcyTgwtRV6ILbwGnxHqKs/Z7V4nsnQlQi67XDIB/V5EvIVCwQq6RLUu7d+NtInC+X5+v98oqtw5Fwnwer3W0ApaAPrhQmzsYW9vr51jPjO1HBhNEA0I1tz3ZW9BQ9wAknv9NvvntlHAKMSxHR0d6fT01O7463RvSfbvpVf0cLJBnj0QF5k/2ToqEmRzLnHFbdtw6fnYDCSjuDfYSDJMd394fnxGNyu96LqwcwFqgBpbKpW0s7NjBeNcLqfp6Wl99NFHOjk50YsXL8wTIhuyuLgor9dr1GVJZhzy+bxqtZpevnxp8AeMClhGY2Nj+g//w/9QgUBA29vb2t/fl6RzD8Xr9VpxkaLi3t6e/vzP/1ynp6eqVCq6fv26ksmkpqamrGiLICaHko0kQnnb5UI1XLrXH+jMzIwWFxd1cnKiZ8+eqVKpGNd8bGxMMzMzZpCIil1GFl3Bm5ubFr0TaXa7XS0sLFjXPDpmpMNuZgYWHI1GFY1GdXJyon/1r/6VHWpqMhMTE+cYWRxkYBVJmpqasuI6e3CZRXYFFEE9BYPb7XY1Pz+v9957zz4PzpEiMAYVqrXbOwBbanl5WSsrK5axuT0hS0tLikajFq3W63XLgoBZ+XPILKFQSPl8Xv/6X/9rnZ6eanBwUN/73vc0NjZmhBVXaYAAioz52rVrVqzlzy67VlZWJL2CaigE42COj481OTmpubk51et1HRwcGHsSgwgriUADUgh1p9PTUy0vL+v58+caGhqy2ghOaGxsTHfu3NHg4KDW1tbsvdvtthWwMZDI/ITDYeVyOf3Tf/pPdXp6qp6eHn366aeKx+NWE71z544qlYpRwyHqdDodzc/PW0D2Nk2U7D+RPP0t0MjL5bJSqZRu3rxpjeHValXBYNBIE2TPIC6cQVRETk9Ptb+/r83NTQ0PD5+Tl/H5fLpy5Yo5/OXl5XPBuqsxSAAdjUYViUSUyWT0k5/8xN73+vXrikajisfjRq6oVCrGpiVr5JzwnGEHXmRd2LmAnWLAK5WKcrmcms2mSqWSjo6OFA6HdffuXaXTab18+VK1Wk0jIyOKx+MaGRnRxMSEZT4I/7nRBmrApVJJ09PTRj0kCkch9ejoSFtbW1bAd1kRRI1E1L29vcpms/q//+//W9VqVb/2a7+mubk5xWIxxePxc8VTFq8FHz0SiVhEd1mmCZkLTsWFvPhvMpnU+++/r0wmY7pdfId4PG4URIp27Iv0KvLZ39/X0dGRJicndePGDUttO52OxsbGFI/HdXx8rK2tLctQgCrRYAOiRHQvl8vps88+U6VS0cLCgmZmZjQ6Omqq1dVq1SIooD36NZLJpFKplDKZjPb29i4dfZM5AyXgNPn83W5XIyMjunXrlo6Pj7W8vGyUSjBnnJJLk3brcp1OR1tbW8pms5qenlY4HD6HP09MTGh2dtaiYSJMIn2yQLe4nUgklE6n9dlnn6lareq73/2uFhYWzHlhfCSZA8xms9rf35fP5zMx0N3dXa2urr4VW2xnZ8cgGWjSgUDgHDQdj8d17949q/tRewF1wBlRYwM24654vV49f/5cu7u7mpubUzQaPZf1Dw8Pa2FhQfV63fopBgcHzUAmk0lJMlgM0dmDgwP923/7b1WtVvUbv/EbunnzpmXV1BOAaAcGBpROp03Ha3R01LIeMu7LLAI6t2GW7LhSqahYLGpubk43btxQPp83JQ3IJYFAQMPDw/L7/da/xILq3u2eCcYeHBzI4/Ho+vXrhigAsYZCIRUKBT179kz1el2RSMSkrtAwJOtBtXt9fV3/5t/8G52enurTTz/V/Py8BgcHFQqFDHE6PT1VKBSyjJzMBhuENMxFnfOFncutW7fUbre1vr6uFy9eGDOIBZySyWRULBYNqsF406vh8XgMSgiHw4pGowYzSLIUEH0gaLbdbldjY2MaGxs7x/12i9BuMZmLQUFwcXFRzWZTY2Nj1gdD9EVxliYwjLl01rxHf4ELo73poiC+s7Oj1dVVJZNJOzD0QlSrVa2urlojX71eN+fR19enZ8+eye/32/4RDVHwJSqRZBeewn673TYHhRYRJAUiOjB5HB4jEyQZk4gmVCItDL1LJfV6vZqenjbKNVpTbwMr0tAF+SEYDJqRABKAkkogALRAZAz8x6UhcufPgYI6nY6xHMm0W62WJicnNTIyYjASGSWCny71lAbeYrGodrutsbExNZtNU8OF9dNoNCzj4f60Wi0T+Tw6OtLGxoZqtZpCodClz58kY/rs7u6a+nYgEDDHQeNxsVg0FhEwKPg9xWOi9lQqZYrA3EF6MeLxuFFnKaoPDQ3p5s2bFuBwpoB9uGfsDRR3aPa0HwArQXgBGoMxiGHtdM5GSJycnNgzvuxaWFhQp9PR9va2tre3TcIe+JzPwJkjcCHjJ/PmrEJMgpxE4A3bjR4eF8JCEsZttQiHwxZkS696joCli8WiPB6Prl69qmazqUQiYRkIqBAUefpsXJ1D+grpG/zGncuPfvQj1Wo1/ZN/8k/0F3/xF5qenjYuvHR26E5OTrSysmJMI7/fbzz43d1dPX/+3NgxPT09un37ts2B4aCTgsEAojsZCuKHH36ok5MTJZNJww99Pp+KxaIxyYCbgMdIo7lAYOdEw0RL9NOMjIxobm5OnU5Hn332mXZ2ds7JLlxmvf/++6rVavrqq6/0R3/0R7p69arh9igll8tl/eQnP7FLBexyenqqbDarg4MD9ff3WwF4enpas7OzFh3hXGmYwgHv7e1ZJ++dO3dUKpUMvqJZjXkkHPp6vW71rN7eXn3rW9+yyBXGD4VLokfo5alUSvfu3VO73dZf/MVfaH19XSMjIybzfZn167/+62o0Gvq3//bf6tGjR0alpOGTs8bFppfK7Xp+8eKFent7beQDCsXUEyh2Dw8PmwBivV7XixcvVCqVNDk5qaWlJZXLZTt7U1NTGhwctGwTA0uRHKz/1q1b8nq9mp2d1fDwsDEDJVn/17Nnz7S2tqZkMml9PY8ePdLBwYHBVW9T0P/BD36ger2u//l//p/12WefmeqCmx23Wi1tbW2d672gWH14eKi9vT319/cb/XV4eNj00KiTUjgnGGy1WlpZWdHR0ZG+9a1v6aOPPlImk9EXX3yhRqOh9957T9PT09rd3dXKyoo5ZYwZ2dMnn3wir/dMC5AZOgQ/PMP9/X0b+zE9Pa12u62HDx/q8PDQEJTL7uHf+Tt/R/V6Xevr6/rqq68UiUQ0MTFhQRlniLoL0C13eH9/X8+fPz9H7Ll9+7Y1U5PhpVIpI6SAljBj6eOPP9YHH3yg4+Nj23eCvWKxaKNCEKmkBuj1evW9733P+r3InrLZrHw+nyULDx8+1PLysqampvSd73xH0pku4ubmpuLxuPUOXWS9ERWZSJ9Nw6gABUChpBDkRomSzhWPJNlF5AK6jXEU4vlZ/h0XF+zUZWK49QvqMEQMr0d8PAC3J4MCJ7/nfWnwJPO6zKKDl/1zm7v4/K6arEucgO77q4pv/D+/SL9dOIxiMf+GqJ3nSLZHtuRmBJAgXNFEfh7xSPd7vE6xdMkRfK/L7h/fgc8AgYPv6lLaeU/OE58LIgk/Q3bDa/OzQK3st1tU5zUpKPNs+IycWZw02Drvy/OgTkVRm7PoqmGQRfL53sa54CzcHimgMajDZDIutRhcH6MEjEYACCzOPtIMSvbsnlmyf/d7SzIiBRmnC5+6xXoWEDPwK2fAvbvus/gmFvcT2JPv4BIdIGfwCwKAC+FKr3TScOJI5rTbbXsu2CL39VyaOzViXpvzDNmB+4CTcbM2/pwATXrF8OW7sN+uDf//hIr8P/1P/5M1On344Ye6cuWKfu3Xfs0yFnBHZgzQbAcdD1FL0u5arWZe9uTkRBsbG3b4JJk8AQ/z+PhYh4eH+vGPf6yBgQGTmpfOLnGxWLSCJf0jXBDIB16vV3NzcxoeHtb29rZevHih/v5+w8CDwaDm5uasMQvoKRQKKRaLGZ55mfWHf/iHZoy+973vaXx8XJOTk+cYWxygSqViDWfQbpHroHekUqlYwdWdx5BMJq07d2hoyIpy7faZEusvfvELYy9BzMjn81pfX9eDBw/k850NBCPlJxM4OTmR3+/X7du3NT4+rmw2q9XVVWvY4vPNz8+rt7fXOsC9Xq9lRziAy6z/7X/73ySdHXQGbr333nsG0wAhoc8FFDs2NmafbWRkRJKMPMJ3dwvo4PNIn7jOlkZJ8PFOp2PQ4cuXL/Xzn//cajM0teG0IZ/w/A4PD7W1taW+vj7Nzs7a9E5qP+hudbtnGmenp6fW5X/Z9b/+r/+rpDNH/d5772l+fl6ffPKJYem9vb0Gmbkw4vz8vJaWljQwMGBw9eHhoSqVih48eKBnz56pWq3atNOJiQmThiIo5T7t7u7qq6++kiSD4ZaXl3X//n1rXCWSZoZSJBLR4eGhvvrqK7Xbbf3ar/2agsGgqfoODg7qgw8+MFkZWKRPnz41yOfq1avG8Lrs+j//z//TMtLx8XFNT0/rk08+MUcKGQPEhV/UPVBCJzukdeP+/fvWyNvtdjU1NWV9aECCZIagODD+PB6PKVak02mbdBmLxQzWpeEym83K4/FocnLS9vTly5eGoITDYY2OjlrCsL29bZBzIpHQ+Pi4kYousi7sXJ4+fSrpTMSPdHdsbMyaABuNhtLptI6OjqzeIsmyG+isYPnNZtMwe3dELLBMIBDQ0NCQYdKu0QWnpKgIzgmjCLE8NzoAwnFnQ2QyGcOH8eyhUMhe9/UsjX6Oy6z19XV5PB7r5E0mkwbREXm4tEHE8IDMoD2Cp4LpSzJmTKvVMsiAKN3lpuOgI5GI4vG4/H6/YanIuODUqQEAHx4eHqqnp0dzc3N20Bm/C/USRgnNlFBve3svP8GTtby8LJ/vbFro8PCwyQPhnF18m+yv0+nYAKVYLKapqSljFXY6ZyKbpVLJvg/ZInOBcPbSq+mnfGdqhFCtgWX9/jMNN7dRk/MtySR7wLEZPka0OjAwoOPjY5tEKb3S+HobQom7h8PDw0okEgZV0mFOQLG9vW3Py+PxmPNhVDTyMTQZM9KBviFqV5LMMJIxcwYDgYBisZi63a4KhYJJyhcKBfX19Skej59jKHU6HWWz2XMNvtVqVfl83rJJ4GC/33/u76jt8n0uuwheYRzGYjFNTEyYsC6wHFR3sk2CuWg0agxL6ngEbvSn4dChgVMiADbDcQ0ODpp2GorjNHCiw8i9A4FAKRxNOM4lNrLdbtv3YP9ACmBDhkKhC9ORL+xcFhYW7P/B6xnoc3BwYE6l0+lYjQDcvre3V+Fw2PjqFCuRlWBjO52OsUlI2dDOYWPBHjHC0Bbr9bpRbdnYYrFoNFEKzJ1OR7lczthQ0Hrdi0E3LJRDjCVF3Mus27dvS3qVDrvwINILQBXHx8fa398/R++NRqMaHx8/JyiHVhjQBPAZ/TOkyOileb1eK+ABGeXzectK7ty5o0AgoKWlJQWDQW1uburo6Ej9/f1aXFy05lTmoeBs6XvB8MFcQUoCJwiL7zLr13/919Xtnk3HRNiUQVc0HqLo4NaPgD4jkYj29/eNscPvwfURh0RHDofbbrdNBaJer2tjY8MUZj0ejwVUfr9fd+/eVSAQ0JUrVzQ0NKSNjQ2biULEd3p6qs3NTasFwZpiABaYOCO7mfsB/PE2iz3c3d1VOp1WIBDQ2tqaSc5AVKBnjTkrZHUYVERr5+fntbOzY7OYUK6mf8XtVQFqJIpuNptWVHaVOEAORkZG1N/fr0wmo6dPn+r09FRXr141J0PW6SIfaO5hG65fv24GPJ/P2+e67Bm8fv26ut2utV7AmC2XyzYQkaDUHS+xu7ur/f19y1pQIk+lUspms8pkMlZIB0Z0yQGt1ivVbjTFaHSkdkKAsri4qL6+PlOZzmazyuVylvF3u12dnp5a5gSZhAyexTluNpt68OCBDg8PrRfuG3cui4uL6nbPhAopFu3s7KjdbuvFixfK5/NWyGM8Jw2VXq/XJkKGQiHNzMwoFosZMwqsUDqDtBYXF3V4eGj6Ya6RoiMa1WUi/2QyqcXFRcsySAeLxeI5Y3BwcKBMJqN2u20Dn5CrIQ1FYgRnKL1ipVz2YL733ntmLFz9NYx1sVi0C8h4YJpJ6/W6RkdHzclMTU1peHhYW1tbNiHSbSaNxWLnonKiERe6zGazdglqtZpSqZTef/99DQ4OamZmxubSr62tKRKJ6OrVq/L7/TaYSJKxWggQwJhHR0d15coVSWcGCcPtHt43XX/v7/09NRoN/fEf/7GeP3+u3t5eazzd3NxU6W+m/FH3Y8BcPp/X8fGxIpGIUbF/9KMfaWZmRs1m04wC6sgUq3O5nF1KoKDT01OtrKxYH4DPdyb3XywWjcLLcKa+vj7t7u5qe3vbpO39fr+ePHliTo2RChjk19UbPJ6zqZawfdy612XWD3/4Q9Xrdf3hH/6hvv76a3m9XovGnz59qmw2a6QaWGKtVkvZbNYkW+LxuJLJpO7du6elpSU9fPjQImcyLTIwt05GZttqtezOA/MSJE1NTelb3/qWRckez9mAsMePHysWi+n69euSpM8++0wbGxvnVBrW19ft3pJJ3Lx5U81mU19//bUODw8VDoffirF4584dc5gEf9iSX/ziFzYSHNUA4NT9/X3lcjkb0BeNRvXBBx9oZGREL1++tMyFWgnNqdSku92uZdNIHFFrcrOZ0dFRG4UAGxW269DQkKampiSdZbCMTGefsac8p4mJCS0tLanRaOjLL7+0ScRvgkJc2LmUy2XzpBQEwYdRcoVjTgpM4d1N+YFNoNgCMcCYIbpz6zdQdimOulCWWzA9Pj4+V3iUXjVYIrtAyk4B0S0C8/2Oj49NroW+AFdL6TILVgsURdJf6SxKoJiMfhlRHjUFcFEaEuHIIzueTCYtGwGqQc2AQisFw76+Phuty+hb9pc9dQuUGAUKk4xDcIvDqAkAoxFFSrJn/jbFVQyd9GqsMvuIbphb0yGjZc+AcyN/M9XRvfxAgUS8OFyK0JAx+K6cIfaCAIR9I2qlNgNuDpFieHjYmIquY+Ecnpyc2PnzeDx2v9zs8DLr4ODAitycJ7S5COCAf4EAG42G1RS4p8wZ4Xti4OlzgZoOckEWjV2gaRAIC803oF6YphTo6YMhuGPEtKvA4aojEPzS4AgaQWvEZReZrCSTbwGyY++oMdOYTX2EZkb+HQV4WhHa7bYikYjdfZewQK1WksHNKM339/ebY/B4PIZMEFACa7n3j6bM1xdFfgKA3d1dQ0OYreMqJ/9t68LO5dmzZ9ZsRoEeailZALhiOp2WJPuSsVhMqVRK4+PjloLzkJPJpBXtpDOjsLOzYxGy61xI/+jUHxoa0uPHj7W7u6tKpaKXL1/adD/YL2507vefiRCOjo5agQvyQafTUT6fN7IBOGdPT48mJydtxsJlHQzabBTvKcj5fD4b9oOkSbFYtNnbOGe00CgakkkxPGtsbMzS6fX1dZOigBXnRkVTU1P6+OOPNTAwoEePHmlnZ0edTsfgJrdbn8ZNd6zw4OCgisWiZSTskyscCYUZ/Pfk5MQClMus58+f2/9PTEzYYff7/dZTgcMAJvR6vZqZmVEkElEymdTCwoI168GM63a7isViunbtmjmJvb09i8aBsU5OTpRIJKx3g+zE3dd0Om0MHiRqZmdn5fV6zdkCJ+XzeR0eHpoTkmT9JUCw3LGpqSlrrHubAOff/Jt/I+nMiMzOzmpsbMyiWZo5g8GgjcDd3t5WpVLR0tKSDZ6jR6xWq2ljY0Onp6cWGI6PjxsE2W6fCXQ+e/bM6g70XQE1LiwsaHBwUPv7+yoUCmo0GlpfXzehTwLShYUFIxN5vV7duXPH1IIhSvD6uVxOe3t75vh7enpsyFs6ndbu7u6l9/DJkyeSzhhTU1NTSqVSGh0dVbfbtWwfWSo+2/HxsRYXFzUxMaF4PG7nBqIRjaXMmJJkasanp6f2eSHEINOTSqX08ccfKxwO69mzZ5ZJQbKpVCoKBAKmE4fD8Pl85ugYvwELEvIJ9Zvd3V2rQ7/33numP3fR9UbaYm5xm8jbxVgp3EMxJBLEyAABvM4Kw0FheGDpgNcSkRP5uEYOGiCRlHTm3fv7+83ju14bsblGo2GfB4ovkS8YPPUNNxO6LCxGpEokS7QvyaisFDBPT0/PZXzsLcbUjaJdmq1Lm+UXGYsrvUK0SdRNtgJmDERE5im90lXi81SrVfvcFNTZPxw6+LJLb7ysc0HY0OPxGBGCxV5xVmD50UFOLxHZBhkCmRgFV5r9yPjAz92zSEbk/oL8wHcm43apvdT0gG7cn+PzuKxBV12AKN6lsl5mQWrBuLAf0isEgeCMPg2fz2dOhSwZKjoBInUM9znzHNgTSUYwcSndLhTD2WNvcAIDAwNqNptmg+ivAa3gLrBcin5PT481Dbp0/sssBEpd6I1zB/HAvVOcH5iy3GHslUvYcOsY2AdqvcBk0JI5u0D4BISVSsWybDIeNzinkZngW3qVbWMfOF+cedSX2T/O6kXWhZ0LzoBpiV7v2YwASdZUFovFlEgk1Ol0bM4FKqetVssKsO7AIQrCsE9CoZAdYDaWTAmHUSqV9Id/+IfWBwMjB8rj/fv3TVsLqYlCoWARB3ISQDkYEvDySqWibDZruDh/Dzx2mUWxM5FIGPZK1IWzGBkZMXgL2QxXknx7e9uKdUhF0GAFFXl6elpjY2NW+Ha/H0aqWCzqxz/+sUU4jUbD2EuSjBmG3A54sHSWaTI5EHiCbmBwcbIlyB1IoSP/c5m1vr4un89nw9DcOh09DpydoaEhlctl6zJPp9MqFAra3NxUMBjUzZs3raGOwnM+n7fX4s8kGZUaxwC76fPPPzciCVR4FKHz+byd81AoZBEirwVNl05tWFDj4+Oam5tTtVo1Zg9F/0AgYGN7L7tg9c3NzenWrVs2xIv6UTQaPccMu337tmU0NM2iOLywsGCIw+DgoKkjwHiCoYTTcWEaztsf//Ef216Pjo6akrfP59Pu7q6xxhjN7UbhQF3T09Oq1+smRTU2NqaJiQl7LTJTIvA7d+681f75fGd6g/Pz82q1WtrZ2fmlpsVgMKh2+2xM8MnJiQYHB61d4+joSH19fcYyoy8NKSECv6GhIaunkLkA86ZSKTWbTf3Jn/yJ9ShBOMlms+cYe0NDQ9b8uLW1JUm6e/eujaNnFg8qHiz2r9FoKJfLGQw/PT194f26sHPBWxJ5NRoNS9PdZiG0asAPOVTt9tnwHiIkICAwbrSMiDZ9Pt85VhNZE81qv/jFL6yPgU5qoiIuJqNRgUD8fr8ZdwwCTUwubppOp5VOp61ewXd7G468S9eNRqPGNCEb63a7isfjptFFHwUHpdlsWsF1enraxu2SZQFHAQMdHR2dq7MQbfh8Z7pupPgYkkqlYg6eqJJuYWi4XFCXCYbj5jMDqaytrVk0D6mAOs9lVjqdlt/v1/Xr1zUzM6NCoWD9GJwjV7sJiAECCBTWcDis+fl5M04DAwO2f41Gw6b0uZkqF5vGSei03e6rSas8T/q4/H6/FhYWTH+NKBC5dkkWjTNHJRqNKplMWq2D6LFarWpiYkJzc3MXZur8qkW9b2RkRDdv3tTW1pbW19dtXojb79DT06PZ2Vm7mzjI/f199fefTZ/FmY+MjKhcLlu/BVke78fddZsm6ZHp7e3VwsKCMacODw+tl4SMfGxszGBKSZZBkjlAi0caBjIOGSjw5tv2qpF9hkIhjY+PG/SFjhcZFDD72NjYuUmnBA2cU8aOYNdYnGXgaOnVqHNaFCAq+Hw+Xbt2TaOjo2o2mxbEQsqIxWIaGRkx4pJ0VuPlDvf395vTo4xBj+Ly8rIJqzabTWthuOi6sHMhkg6HwwqHw1agQ56F7AVDTi0DqiwNP91uV+l02qbESbJ6Bo4BWe54PG4NPP39/crlcuaAwMtxQHho6VWWNTAwYM1oGNiXL1/q8PDQKH1Qd0nZMaykgdCdgZkum7kQpfDwiL6azaYODg4M60TqQpIZLReShDZIPweceQ5APp+3pruhoSEr2vr9Z9pp1J/YRwgYQ0NDxvAC0uzr6zNWCZACEaJb18ApSzrXIcxrkXYDy1xm4TS8Xq+l/zDpoJa7WmHUeigmk5H09/cbldrtjUGskz2lkElAwnegUMt55RKHQiFdvXpVPt+rAXZk5e32mawMVNKVlRWVSiULgsj4CbqIzl21CTTV3gYWQ+WZQI+ueqaQutktlOxwOKxSqWQML2a6QFChtofzoacFCAfoemFhwQQXC4WCGVqIA319Z5M533//fUmyeiRs1Ha7bb0f0KRfr4MSweOUBgcHrbAPjAfz7jKLOwz5QJLpGubzeVOFBgKXziBD9pk77PV6jaXIGQR9kWT0f4gXXu/ZrKBQKKRsNmsMPBwPTD6yTWrLZPSwy0A7qInz7DmzbkM3Dg5bCPRJwHCRdWHnMjY2Jq/Xq9HRUY2MjBhe3Gw29fLlS62vr+vZs2f6/PPPFYlEdO3aNQWDQRsHGo1GzUuSFXBZMVYej8eKgTTsoQXV39+v5eXlcxRa8PBGo6GxsTHdunXLDpZ0RkJYXl5WT0+PQVqff/65yuWyNQTF43HduHFDsVhMOzs7SqfTBl+40jMYx8sWA92IGgl1mpVWVla0vb1tkE4ymdS3vvUtRSIR0wtCx8jr9Wpra8suC+k2HemQIIAFKYgODQ1peXlZy8vL5xpZif5SqZR119PZ+/DhQz179swmUUqycdMU6MPhsD766CNFo1EjRJAJSq+cC87oss55cnLSYFRG30KLX11dVaFQMGr35OSk/sE/+AcaHh42narBwUHTznr+/Lmq1arRbsH9/X6/9QvA7BocHNTt27cVi8W0vr6utbU1Ky6TrfX1nU1lpagLJPzVV1/p4cOHli35fD4dHByYzlaxWFQ0GtX3vvc9JRIJkz4haweak85gCozCZRfkDDrlGdJ1dHSkly9fKp/PGzw6Pz+v//K//C+VSqW0tramg4MDG9Pr9XptOBuQNbUW6ljU18gkvvWtb2l0dFQvX77UysqKMpmMZU00Sc/Nzel73/ueBQLdbld/9Ed/pD/90z9VIpGwPqJqtarNzU1tbW1Zh/77779v4zFwLMPDw9YjRH8NoreXWQQICGyCZtRqNW1vbxvsCrHp5s2bCgaD5si535JM1Z16oVt/gsnVaDSs1jU/P2+Zv+vMyfIkmWIAdXGPx6OnT58amQiW3+bmpl6+fGnBSyQS0ccff6xYLGZBDQgVgqnUaFwl579tXdi5uJMjwfBdLSlXC4eIH9kSl0roFoDJEsAH8ZhstKvUC7YtyaJlSSYR4c4ZcCmpvAfZDNg5RTU2mPoAzXduodUt+F8W1iGiZv/YQ6iU7J+72CsiMkmWUVAwJaugIxos39VZgs3Ed6HDGNYOUQufj+iKf8ueA8nwWsyBcVla+XzenpVbOOcZXna5/HpXS809h9KrcdJkZ5KsiCq90iTj//l+XHLewyUogIcTCFHA5Ry6BVJgYuBF9htSCFR5ZGA4x/R7wAZi/zDYrrLAZRdGH0FUV/lYevWMcRZunwX7wx6RyfKd+Y5uUZ/vBdXWlUShPgEMTqZCbY/n6aokuMOxUM8AssYOIfpK8MuiuP1N7B/BMIaW98fm8X6cf5wdZ4Y9IQhm77nn7lmlpkKmwneXZPAbWQtNztg2SAEu+afb7VrmhQ3hjnI2QAVcdQpe602Cwws7l/n5eUln3pTxwz09PYpEInrvvfc0MzNjNDw2yuv1amlpyaCMXC4nv9+v+fl5S5FzuZzVIdwHxEFvtVpaXV21DlbSY7KZGzduaHx8XOVyWVtbW/J6X029azQaVieBWnz37l3rzuZ1M5mMKpWKHj16pKdPn57T7cFI9Pb2vhVeC+WTIiDfp9VqaWlpyfZXkkVGzNcg4saZXLlyRaFQSOl0WgcHBwa3uemta+A2NzclyRpbA4GA3nvvPVNYDofDVnfgcmAAudCwXcLhsGWR7DcyEQ8fPtSjR48senfFPt3enMssqOpu0x10bJQZgBD7+vq0tbVlM1GQGalWq+rv7zcdKkgPruoBF4j6WLvd1s9+9rNzDag+n8+GOM3OztqMnL29PXW7Xdtv4I1AIGD7hwzJgwcPzo0G9/l8+uKLL/TgwQMr6Lp0WsYvvE2fC7A0Heb0k7XbZyMBGNSFod7Z2bHO7CtXrljw0dfXZ/edMzg4OKiJiQkL3IC0cJJkzNvb29ra2jJyS39/v+7cuaOpqSkdHh7q3/27fye/36/x8XGDlEAYxsbGTBUC5w/knkqlNDQ0pEePHunly5eGjNBrBMnAzQbfdOHw9vf3tb+/b5T93t5eyywwxD09PeaYU6mU5ubmTPOup6dHt27dsrYNZJcSicS5nh2CzmazqdXVVevBo/mWWS+Li4saGRlRoVAwfcBkMqm+vj6Tz6efyOfzmQpzJpMxxXcCfrIaYEtJ58a7uw77b1sXdi7odeVyOdNHQq48Ho9bGsV8FpgPFAozmYxBTtRHKEwFAgEbDAa7iQUfnCY6PG8sFlMwGDSuOdEEBTWiFJcS6POd6SpNTExYAxgRASygw8NDK+hSa2m1WnaQLruA5WAxERVKZ4aTDI1iJVEFRgl4R5JdNmpc1Bc4RNQHMByVSsUasohs0CAbGRlROBy2pkiozESebsQKpZKmOmBR4M1cLqednR0NDw9b0Rr1atZljSNRnqsQzHngjOFYoPICs9KkSp2JuTZkW69rUtFci1PMZDIGQSCECPkC3TKIIWQCZLsucaWnp8eGbTH0zN2/TCajjY0Ng0Iw0q9noJddPAc3AuauAQ+SibVaLQvmIn8zDZLsiaZAhu3l83m7/24zK2cKJtnR0ZE5NoalIQpLHwrClcBDzWbTHDTjurmbTJ10mxePj49Ncuf17IB12TMI1EfNb2hoyGoRriYh2ZRr34C0GEwYi8VMmBe9umg0apRsMh6eF6Ks3FFsIGcRRhgSVdRMXHSDM0iA6NLNpTNbyzPCPrkZ6puuCzsXCoGlUknb29vq7z8bcCXpXDczximbzRpfHTE+DvTm5qbNEQCz5WHwpWCAgH2DXZZKJfX09Fh36vr6ulZXVxUKhWwYUqFQ0PHxsQKBgCYnJ01/iCarWq2mnZ0dY1/l83kNDg6q2+2a8Yz8zbhQHmYymbS602UWSgA0eWF8OLD0EASDQbVaLWPPwQDh0FLjYpQxh5oLx8Esl8va3d2VJOvh4NIDfRCpQHVlyiL1gJ6eHk1PT5/jySO5gmYcPR58D3qagEopEhKAXHZx6fb3941RhKPkzNHE5gY3EChQIKjX63r69Kk2NjbM+JOtuc+qVCrp8PDQDAczWMrlshlghAqJ7tGjczvbBwcH1d/fbySXQqFgWenU1JR6enqsOdidXT8+Pm71MHpT3oQG+qtWMplUu3028I9GQ5yBCwkCAQ8PD0uSnUfOVqPR0KNHjwwGg2VG/9Hh4aHK5bJlw/T7YKjorufPqI16vV5rmMQOUAvkfkIYQrqHfd3a2rI+JRwNagw8q9HRUcvOLrMIsIvFotGyIQwQVNCr5ipFEFBSp6xUKnr69KnVR7GBBEvUVCD4QE9OpVI6PDy0TBdYf2VlRevr6+rr69ONGzcsMED6igZrt0QA0YWAc21tzWYy8ZnYP+4e0j8X3b8LOxcuYLlc1s7OjolR4hHBS4E/EEKjo59os16vm2z52NiYiTHygcG3c7mcHZjr168rEomo2TwbqQyM0dPToy+//FKbm5v65JNP9Omnn6rRaOjnP/+5Tk5OTKAQ6As2FYOdcrmcBgYGVCgU7MBzUZCycJ3LzMzMpamgHDbk7d3IinQbKiqOFWYShxYGycrKigl1wlDicwFDABNiQDAiQBs8s83NTe3s7OjWrVu6ffu26SYVCgWT76enxB1eRpMpkA1RNY6FoixU9FQqpampqUtfbM4QQoaDg4PG4sK5DA0NmYEHcuR7ks7XajXrGp+cnNT09PQ558JzKhaLevbsmQKBgL773e8qlUppb29PjUbDYC7IFfl8XtPT0xbcsF/xeFyJRMIifjT3GGI3MTFhmTn/hia38fFxI35IMumVt2GLJRIJNZtNPX36VFtbWwoGgzaeQZI9G54jdwB2JQtj3mg0TI7fbVItl8va2NhQOp02Ycxbt26do2DjXHp6evT06VPt7+/r1q1b+vTTT9VqtfTkyRMdHR1pYWFB7733nsE0MPX4L5Ttra0tkz6CeYayMtDi+Pi47t2790vBxEUXGT5tAW70TyAAeYh9BBGhD4beLAIJRm8QvBOAFAoFUyrv7+/XzZs3FY1GVSgUbAYLiAxCqHfv3tUHH3yg09NT/fznP1epVDIZfWpR/BvOI/WVtbU1+f1+m5yK6jIBNrTm27dvX9gGXniXXY82Pj5u2KL0qtgKLON6OwqYbocnWUytVjMmj0vDBDqbmJiwhwUDgsIVBVYwSH4BL2SzWfX2vhoDjBIrEEM0GtXCwoLhmhwGekMQhgNeOz4+trnWl1moRgeDQau/ECG6hVAcAAeN9BZYjsNBVz19B9QMXLbH1NSURZbUEMBX3e8FlZkiJVFPKBSywj2ZKM+Z/g7gI9JvCpf8ntoV8z4uu3/5fN72b35+3uBPziDsHVdRAOdCHwHUdS4MWa5LpcYghMNhXbt2zeoefHfgKmig7BUwL5nL8fGxBgYGFA6HTc6F84eRlc5qgYeHh9YpHQwGLcOGPtrb22tK42+zmCk/ODioK1eu2NmjhiHJ6o04benMsXO+qAFAj2632yZtj2QNbEsXGgSKIbtEqZsoGjiczIZzCVpxfHysnZ0dU19AK4ysECIJULj7eXDUOCHaG9507e3tGQEH9iL31aXwAhmTFYAwsOjBwcgDixEIuTVf7ClyVtTtKElw93AUTMHM5XLG0iVIzWQy6na7SiaTZjPm5uZ+iXwjyRio2J9AIKB6va7d3V15PB5Tef//ty7sXNxBUktLS4bNgdl6PB6TjvB6vYpGo6rX65a5RKNRg6gePnyoTCajfD6vdDptGQY8djj29+7ds80j66EewHvv7e1pb29POzs72tjY0MnJie7fv6/9/X2j2dHURwc7dZfx8XHVajWtra0ZRx8GDVx9DP/R0ZFevHghSfrP/rP/7I0OpSQbVjY5Oan333//XBMlLCDSY7KEer1ueCrFdAgNzFhZXl7W8PCwPvroIxtQVa/Xbf86nY5JepN2I6zXap0pMq+urprW0+npqTY2Niyri8fjyuVyevjwoVqtlq5du6aRkRHTaIMIUSqVNDAwYF34QAaw2Pb29vT111+r2+3qt3/7t994/549eya/36/FxUV997vfVelvBsARCLjFWwQD6fUB36dAn8vlVK1WlclktLy8rGg0apE3Z+3KlSv6jd/4DbVaLRt/DTmg0Wgok8moVqtpfX1dh4eHCoVCVr9bXV21JsvBwUHlcjlrWv3e975nzZAej8dmmZAJkinSYHjjxg0lk0lls1mjwl9m/yTp888/l99/Nhrg+9//vnK5nGXBkkylYmxsTPV63WYEJZNJRaNRi4JPT0/12WefaX9/X9VqVY8fP7bGaui2UK9hNlJnRILEZYGi4sAzOzk5MTIBkG42m9XXX38tj8ejH/7wh1pYWLBgKZ1O6//9f/9fK0AHAgEdHx9b1jQxMaGRkRGl02l99dVX6na7+uijj954//7iL/5Cfr9f77//vj788ENT8qBxlPMOBZ5hiGjfkU3V63U9fvzY1Kaz2awikYgJsLqjz8PhsGXs1WrVBsrhgGjLKBQKOjg40Pr6uo6Pj/Xo0SOl02mTb8lms3r48KEk6dNPP9XY2JgSiYQ++ugjHR0d6eHDh+ZMJNnYj97eXt27d0+JREKFQkErKyvqdDr6jd/4jb91vy7sXEj/wNVfL/QQpbjUXf6eiJLufZc2CjXRbVLEY0PT5O/dAj3Gl2iHTlIolhg3t7AGLkrkjyOEAkhdhMNCNAKm+jZsJ5qVoCGC1bJcCiu/ftV+oJdEVlWtVq3p1G0Wdbt02S8wVzdDAy6iDsAlx+CQTbLX/Dw0SfbSpT+Dy7tUb5fWepnF+aPoTAMa2QLMODftZ0/YM/aDDBsIl4jXpVqSMbNvRJq8PoVqziHED+AGnDn7zdnh2bg0fvf3PAuIGsCykDfepqCPA5NkAQqRqntvOZd8L545GQNGnTOIFh7PiCZSsm2+D5kQZ8qlk/MZeGav7y1OiH/HProag9gkMiL6rYjI6/X6OWXjN12wtCSdu8M8Y7eYzx3jHvFZY7GYarWaZXguRRuyBOgK+8e9c2nhLsHDJdZQq3Ep39xDaN7s++DgoN0J6lQucgIkD8JCr9BF14WdC7jsy5cvtby8bBGjJMPV3cgD6hxRoc/n09WrV8/1chCpe73ecwVq6iA0lT158sQazmiypBclFAppampKnU5HDx48MGMQDAaVTCatIL2/v28FNbTMICaMjIwoFovZJEGK2hS+aZJDrfQyK5/Py+s9UzpdX183WXVgCvaPugY6TbCVZmdnLYV99uyZDg4O5PV6NTs7q97eXmUyGZVKJROZOz4+1uPHj1WpVPT111+rUCiYFpTP5zMhSCZzhkIh7e7umkMjC7l165bC4bCpCJyenmpnZ8cGt1FsDoVCev78udUP6Ej2es8GlIVCId2+ffvSsBiZyZMnT7S5uWnRGg4Tp42A3+7urnVko2t2+/ZttdttHRwcWMQJ8w15GOmVMvfOzo7q9bpWV1dNOQHnREZG7cfjOZs9wjOjznT16lVFIhHbu62tLWuKRckZxdyNjQ3t7u5aDQvWW7FYNM2ut1k4xbW1NWMguc9ckgVwNCqenp5qb2/PisVjY2MG5dDQTJ0Nw0jRnf1CWZpOdZ4lfRd0ordaLYvQgZ/C4bBSqZSN92g0GlpbW9Pa2prRk7vdrmZnZzU+Pq6NjQ0bYshALeqcMAMvG+DQZnFwcKCf/exn584gDotgABgK5uHx8bEWFhZ08+ZNUziGGQosDy2exlwcKlI5oAmUBoDJabNwJa2456lUymjJBJTZbFaFQkFDQ0MGdw4PD5uiBSiOJPsu1NxcSPdvW2/MFqMzl0X9AvXXdrtt2kvo6gAXuI14YLH8HuNLEx9RRrlc1uPHj5VOp3X16lWL3jmASHq0Wi3rXOfAs3loJ0kySAQ20PDwsKanp8/RKLkQLu6ME7vsBYfuTOTEwZTOOn/B2r1er118d0oi7DjwVZwt1G86j6GIV6tVpdNplctlPX/+3BwUUSPZRigUUiKRUL3+avYGz5vpl61Wy0YCIOdDNIkTInIElnMl+judjo2Evez+8VwpquPApFfBDZIq0LaZSEnmzPkslUo24hqIgXPKmczn8+agDg4OzqnMwuYiOgdP52ITVaNth55XuVw2CIxRyJBTPB6PUUCBL8l4GLoF0++yi8wrnU6fG43rGkfGQhP8UDfodDoG/RHVEsm70Tb0fc4BtF0GAxIIcM8lnTOw5XLZInTODzL/ZECPHj3S/v6+xsbGdHp6agPuYH5ub29LkhlxhuPRxnDZBZJCLQi0BIdM5k4Wh+goe8J8eu4emS1OloBWkqEtvMf29rYODw8Vi8UM4gW1cVmTZLfYMuja1BmBvfP5vILBoPL5vCKRiG7fvm2KKq9T3/l3nI+Lrgs7F7407As3rUcEDVqn3+839dFEIqFIJKLh4WEzCC5UwmtStIe3Tjrc19en9957T/V63TbW1ZNy+1mgACK81mq19OLFCxt1CzWUhjrolVAnwUARh3QhISJ3SfpP/pP/5MIbzGLMM/AShTK//2yKpsvfD4VC+vDDD+0C0ktELYFLwgWm6c7tQ6FYz0Q+aJ2pVMpUXNk/dLboFxgaGrLv/ezZM3P8FGPdg9dqtUwNmKmYfX19Nt+bjNeN4v7+3//7b7x/zM1ASoOhS36/3yiwrvw4jJ1AIGBNuq6UPBceSIZeJldHiQs+Ojp6DhLDyOMc6vW6QqGQRfBXrlwxxtXW1pZ1jDcaDZND6e3tteeJk3SNUSwWMwZmoVAwGO5tFjRfsoeBgQHLulwpEArvyWRS0ivHPjs7a5+J84uDxXnzOpKMBtzX16ebN2+a8CP0dRwbrEmkU+gfaTabNhuFIXTYARAFsk1qpUDjPT1no4Q9Ho/1iODYLrvIViG+9PT0aGJi4hyVm30YGBjQnTt37Hyy1+l02gIGF9YikwOed0sKAwMDunXrlubn5+1nXAUACDwIjvp8PmvKhhrOuaUnjjPOPaC+Qk+Xx+OxYBriELD9RdeFnYsrW0DahkFDpZexvIODg5qdnTUtonA4bNEDxVcioGazaY1UHC6UakulkgKBgH7wgx8oGo2aDhINlWCKFN858BMTE8bZ/tnPfmZOa3Bw0DrSt7a29Pz5c3W7XdOLYmzw9PS0bt68qd7eXtOtOjw8NP2uy6xkMmkMm2q1anRJ4JPBwUGLiBKJhL7zne8oGo3ahSiVSgbtUZSHqRSJREzYDuMFH7+vr8903nCupVJJKysrVpBkljZFRdLoUqmkv/qrv5L0ao7K2NiYwuGwKcLW63Xr/N/d3VWxWLQxxz09PSoUCjo9PdX29raNOfjH//gfv/H+zc/Pq9PpaGtryzKpxcVFa1ALBAIqFovK5XImIjk0NKRoNKqhoaFfil65VLD4wKah/IbDYWtu5TJiZI+OjmxQFkKdYP/9/f26fv269Vw8f/78XAPs1NSU6bBxYTEUZAoUzr1er9LptM20B4a+7Lp3757a7baWl5e1ublpo5ldggcGJBaL6aOPPrLeDpfZhcoDdgBDT63LrSEB+Y6MjBi5p6+vT9lsVvfv3zfKNoZbkgUngUBAOzs72t3dPUfjHR0dVX9/vwqFgtLptOmT8WeFQkGJREJzc3PqdDr64osvLCK/LA1ZOoPFICecnJwY7OnWKwqFgrG0vvvd757TO2PsA3VhN2CBZfZ6PZt7t7i4aHYRiBUlb5olCUSDwaDpCW5sbGh1dVX9/f12jsfHxyW9EgyGhNLpdKwHMZFI6MaNG5JkahwgEhddbzTPhQNGsQpoiqI46RkFLQ4jBTouo+sQaJDEY+N8XB0qxASBiXg9V9vHHfhEJEZqzS9J9rklWYTPLyAlt0Pf/bdvs1wjwgVGppuCGRG1G10Bk1BsdwvuQC/UtCRZRIQTAloh2kaW4ujoyOAWSeeaplwdIfYQ6MP93GQlRK+MyCVS6+npsYhdekX6uMwCbmKvuOTtdtuCHLcYDb4MMQPpFle1m4ZFPqvP5zMqNo6E5lH3mQCbvn7+KWQTTbrd+jSZUqskYueO8HsCAIQH+/r6rKjOd7zs4jvxGo3G2VwVjCNGCmqtSyp5vcGZIjn0ZF4Dp00ARV2Au0oQCEmG78ZzJTLnXAL9YHukV9p2wGm8HkEXbCuYaiAsvPfb7J9L+nBhKHdQGI7GPX+UFUBkIC7w2dzvAeTMn7nnSXqFIrn0be4oTpbPB8HAPb8uMQfChatEQh2S7NylW7/J/l3YuYAtuvMxTk5OjHboFpdarZY1CtIPAdsFCm0+n9etW7d0584ddTodk93Y2tpSJpNRPB7X1NSUGo2G/vqv/1q1Ws1gsWKxqOXlZYMsKPrdvHlTzWZTKysrFo1PTEzYwWy323r58qVFS1evXjXOeavVso5+8EyiMKQt3qYYCE0SVggChRgUjAlqsHt7e8rlcrZXHBCygEKhoBs3bujWrVu2f7VaTQ8fPlSpVFIkEtHY2Jiazaa+/PJL1Wo1jY2NaXR0VJlMRr/4xS90enqqyclJq6188MEHajabevbsmeliQWLA4ezu7qpardroakgVKLhOTU1ZrUGS1d1oQLss2+nZs2f2/2RE6+vr6u3t1Z07d0ytl/dcXl42h4ohwyHs7++rWCxqdnZW8/Pz9nw9Ho/W19ct+0FLDiVojBa02FqtptHRUZM9unHjhtFMS6XSOSM3NDSkZrOp9fV1VSoVTU5O6sqVK+p2uzaugm5qjARZFpAQAcNlFyNzK5WK0fk3NjY0ODioTz/9VNPT0+eCiq+//lrSeSFYtw4kyRpX2UOINRsbG0omk5qdnZV0Nuyt0WhoaWlJV69eVTab1erqqg2rGx4eViKRUCqVUq1W05MnT0zdg2I+mRUjo4nQuRsU9uPxuEXwzWbT9hQjftlVKpXsc3AGDw8PFQwG9emnnyoejxtEz/75fGc6dMlk0lALNMZyuZzm5+e1sLBge9tqtbS5ualMJqNkMmkknpWVFaO2DwwM6OTkRPv7+9Y8DJw9MzOjbrdrWU2z2bRmd+o8Ozs7KhaLmpiY0OLiovUEAZWOjY1Jkjl+dO5w6hddF3YuwAZ4b3B76dXwHhZsLpe2SbaBEaSeQjEZlg18bb/fbyywbDZrFDhmxHAo3ea2WCxmxqxSqVgESLRNcZyLTxMgxoeZNXw/Ilcwzre52GRiGFgIC0h2E71xSfh+uVxOmUzGqLQYyGq1apAaWWGr1bK+iW63a8afOgU8embdU4fhtWm4og7zupQFWR+NrzhbMlkuFlHc64XOt3HOsFVoeDw+PrZ9QeaCmgcFZ9dQki26A8zQZ8LwAHkdHByc69Fxp5GSXaPzxAwhoFcIGcjj8GdQn1GOps5GHY49JvrHQLmDy9yo+TKLjKPdbhtjcH9/35SGyZ75TBA8yOokWSZHxAz64EJjNI2SCXW7XYNHx8fHLXCj7kntkPPi9XpVKpWUz+c1MjJi95SzRiZMlie9ymzdyJ09ZVImdbnLLjIHSdbEzKA8UBuyeP4OIgSfAdo86AwN4wS5nU7HRG1RLgeJwNZh00BvaADmWWDv6OSHkcs9gP3VarUsKaDuKsk+P3cI+/emNas3rrmEw2GLsq9evSq/369SqaSvv/5ax8fHFo2Pjo6aMGIsFjO5Bq/Xa82AYH3Q43A8fJlq9WxO+9zcnBnLVCplcyhOT0+NIox3R0iPPgFJ1qFPtyzNf59//rnx8jksXBz6ZMDUeViXvdzAfhRMT09PLdpuNpvGTKpWq6Yu7ff7NTExYfTPk5MT9fT0mHpqu30mwwFdlP3DQGEYbt68Ka/3bBbP6OiodnZ2dHBwoGq1qvHxcctwHj16pFqtpoODAzt8XAgMEzWZTqej9fV1M4RAoUQ4KCLkcjnT05L0RofTXRgYaM8IQMKWyeVyxkakoxyolKFr0NvJpJEDgm2HvBCvSf8G+010HYlETA2CSai1Wk0///nPjUru8XhsEJZ7/shSvV6v1tfXJb0ac81eSq/6noBCqTe+TZ8L++VCbtT9KpWKNjc3LRCQXrG4qIOCufO5GH0MnLO3t2fGy1VmgOTgdsvHYjFduXLFsmcCwy+//NIylKGhIQs4uYPdbtdsEFI+wHPSK+agS5jBYQHRX3ahtUaGhoQQ+mHPnj0zpwFVGGUR10FLr+BBapVkhHxG1CcYdEc2xuhs5LNqtZo1oLfbrwarARm7TgPbhdhqp9PR559/boV+N0HgczebZ4LAKJa8Sc3qwj9JhA+rCdn7ZvOVkCIXYHh4WKOjozbadnR01C6ZpHOyIggnEiXRH4FzGRwc1NTUlCkpU/yD6pxIJBQKhVSv1234EDRB93VQZJ6bm9Pw8LDW19f1+PFj9fX1GfkAz4ysDBEG0djbwBIccJdPTv2J9Bp65/DwsObm5kzfJxaLKZ/Pmybb8PCwRdq7u7uqVCra29szvrvrXPr7+3X16lVFo1ElEgnbv+fPn+vo6Eijo6NKpVJ2OVA3Jhojq8R4Ly4uKh6Pq1AomHbZ8PCwZSVkflBK8/m8CoWCGf23cS6wqCjSE3Fj5MhSgEmHhoY0Pj6uZDJptG8yK6BPhpuhlcXf8cwRcAyFQhoZGVEymdTQ0JD1bLCfu7u7evTokeHvriaTSzvnc9HzwsVGOud1CAgIimjzbZ2LJGN2er1eG2N9enqq3d1dKyy7DhrYD4MFcw1W1utNd+1226iwBIjAVUiJID1CB3skEtGzZ8/08OFD+Xw+TU1NKRgMmoMm0CFyD4fD2t3d1cuXL+XxeEwOBefvygMB6xE8XnbhXNxaLPXd3d1d7e7uGrIDuQbIiv3m+bnOBaQBtKfZbNodxo7FYjHrAWRvsXM422w2a4KsOAsXcSI7vXr1qhKJhF68eKGvvvpKPT09mpqaMsIFjgXVBfrKyPAvut6IOuHCC0i9SNLExITC4bCxl5jEFgwGTd0XOKLValn0ziLCpLDUbDZNFr2np8fqOHhWIBJohqenp+c0eIisuazMGyFChQpJpIh6L4U09J+azaZ2dnaMtvsmG/v6CofDdhDz+bxRE/k7YEbqJWgxoTYATCadHXJkIXAow8PDBnd4PB7F43GNjIwY0YLIvFwuW68INTQMLUbudV04F2rD6fDeRI3InRPhuLRKUmsynMssqMX0Z2D8+K7ACUi+RCIRDQ4OGrMG2aBAIKCZmRklEolzEAtMICJfJGOogdXrdWWzWat9AJtCgYX1iKEDjujt7T3HDHtddQGKN/1VR0dHFnW7HdxQm98GFgOqhBwSDoetX8c1ljg8IMNGo2FZCa8zNzenkZERM1zu67MikYgxu1qtlqkDE5GzD9gISdaLNTExoYGBAYN+isWi1tfXrWbEmQV2xTBSEAcCo7DOHJ63gcX4njx7gmfpzFlQwEewNxaLKRAIWK8UrLDBwUFNTk5aEy1wnyQLTti/RCJxru+P1ydzBlojkKFGCpyKQ6XW3Ww2f+nOA5fTQ0jmTTACjI99vegdfqPMhVpArVZTOBy2mSAU1bLZrLLZrPr6+mwk6OPHj7WxsWEFv0AgYFE54mpuBIVzGRsb09WrV1Wv1607FX0jlzWxvb2tcrms8fFxXblyxfj5bkq8urqqr776yg42s657e1+NQ2XwEaoC09PTqtfrWllZ0ebmpj3oyzLHZmdn1W6fKZgeHByYRhZML4/Ho3w+r2w2a7UAj8djCrYwbwKBgK5du6ZQKKT19XWtrKwYcQGoTDrrL+I9acByxT2ZT7K7u6uDgwPF43GNj48rEAjY/mE4VldXdf/+fYtWh4aGrO4DZhwMBpVOp7W5ualwOKzp6WkrppPRwK2/zKKZ89GjR1pZWdH169d17949i6r7+/t1cHCgvb09o1v6fD49ePBAKysrisfjmpmZ0fDwsK5fv65AIKD79+/r/v376u3t1eLiop0HmFNk2Iz+LRQKBgMBTQD/UUxF8QFqciAQ0NOnT/VXf/VXptTNvyWDoEF1e3tb+/v7Gh4eNnl8sHvkaN5m0XCby+WUy+WUSCT0rW99yyJimmQrlYqdwW63q7/4i7/Qo0ePNDw8rNnZWcViMb333nsKBoP6+uuvdf/+fUmvptUCAY2Pj+v69et2hvb29sw4ojfIHT46OtLMzIx++MMfmqZdX1+fBQzPnj3Tl19+aZL6sOx4XqlUyuYenZycGPRG7WB/f18jIyNvdYdhvJVKJZ2cnGhiYsJo/lCtoUfT39LtdvXo0SOtra0pkUhoYWFB/f39unbtmvr6+mxkiMuAI8DhzDYaDdO3I2gjGKXO2m63jRodCARsEBuQFmOYCczIvGkep1cRlYiJiQldvXrV9plRE+Fw+ML790Y1F0kWKRCRguHClacu4KaiNB/y88wucTMQDBEZils8cjWbKIxSGKM4SLerW/hzCQj8HRdWkqX/fDa+JxAgn4k/fxtaMho+1CTc7w0my/65hVWiDjeiIdIA/6SwSmbw+l6AlZMZAbm4/R2QMtz9c2mrr3ftEt26lFUcG8/t9ef4NqQIolKgBZcAQc8FpAUwdyK6o6MjU+H1eDwmd4ORAkZw4QuXTk/0jOQNTYboLZGNuHvk0lbd/7pGBAybehT/hj3kWQJnvO1yi/KSzn0G7gJRKueJMwL7ktcZHBy07JrX5NxK5+8Td46aIvAZZAcQA0lWkOffuGoFwIX8PGgC7Qf/vrPlwoxvS8x5fXHmCUbcmidnFfo5wQoOBCfC5yHT5/lghzwej5UMMPYu1Z3vJr0a7kfdkOfA98Ye8GyhT7v2/PWfd7PsN9m/CzuXVCpl/88bPn361LxwPB5XqVQy3JZOaEmWHnLxMdqketKrKW/AXIeHh6afVa/XLQqgi9nt7gWWo7D74MEDVSqVc6ylVCpln1uSDYBqtVqmXkozIhlGs9lUIpGw4uHbNLG5EAL9OF999ZX6+/tNfiadTlunrCsb4SofUCT1eDymk8YewWQis9za2pL0ig4Mo4b99ng8xmknOKBx8vj42HpAut2upqen7edbrZZlRtVqVU+fPlW1WlUymdSNGzcMboSRRR3hbZpQoeaib9XpdPTZZ59pYGBAH374ocbGxpROp5XJZMzZIEfjQglQf+mTwajRdQ1R5PVgAuOG8yALppbU6Zzp0TWbTT148EC1Ws36P4ikgbpOT0+tYfj09FSPHz+2kdbT09NG+CDqhlzyth36QKGhUMhmyXz++ecaGBjQwsKCdcPn83lT3iCjptiM0aKTm3HJ7FWz2dTh4aGKxaLR6b1er7UvYPCq1aophfv9fmsYpqn3pz/9qTKZjOnhnZycyO/3KxQKWX8W6uatVssaelHsRkkZ+Ju6LCOoL7NgD/LfTqdjNrDZbCqZTGp3d1ebm5vy+/1Gb3cJHjSSw8jKZrOWbSeTSfl8Pu3t7alUKimRSBhLll4/t3eQoJ2aC6SLYrGoP/7jPzalcmqTjNsAoozH45qcnLSaUaNxpmp99epV9fX1mSp2JBKxJuZ8Pn/h/bqwcyElJ1otlUoG10xOTiocDtvkNCI4t4DIF8OxuHiyG7kVi8VznfjI72PgiYBg9VAMdGcoLC8vK5vNGt04EomYwCM01FAopPHxcR0fH2t9fd2of9SJ8vm8sXvC4bAymYwZpcssnGOj0VBvb6/pBQHFALEwDM1VnX3d0FE/cJtNETssl8v2HMrlskWmbtSBk/V6vQYBuaqnjx49Mt21WCymWCxmB47ohrk02WzW9ObofXEbVSkCUpS+7KL2MTo6qkQiof39fT18+FA9PT2amZmx54akD6xDVwmCiI3GNpfKTvE+m81aPwPNaTDTqEFJsp+nARPiCD02pVLJfp4aDjU7dMI40/v7+8rn86aFx8+4DXd8h7dZRO5A1K1WyyBr7nc+n9fh4aFh616v1/TF3CZGnDCGnrPa7XatxvR64+TrnwUHTaHf4/Ho5OREBwcH+su//Eutrq5qampK4+PjRiLCKNP3FolE7LxDhuE+UW+jf4wG2csunh8ZB71Wfr9fqVRKfr9fuVzOYDHoyewDTZfYKT4jZ9ZV46AuSjDuNp66iI0k6+lBI69cLuvhw4fa2dlRMplUIpE412ROnRACxMnJiV6+fKlyuayFhQWNjIycg936+/steWDsw0XWhZ0LUIvLpY5EIpJkQnitVsumNcJWoMPYTcFhSsGOAqro6+uzWfDHx8emycQENWizOAiicZouh4eHNTQ0pKmpKcMS8egwSNzI3e32h1tOZMF70jA1MDBgej2XWWtra5JepZuwWaRXYpoej+ccJkyUSdaCY6cwDGTg9/utUQqKIZE6vT3NZtOo3O4iI4OJJ53Vh6D7ImRIXSCTyRjNe3Bw0BwuXfBkgRgdIJ3h4eFfeu83Waurq5JeBTcw/7jEaJdxjjDIaGeRReBIYOe4cAI0dUYaU4PD2TA1UHplqAmMYEF5vV7NzMzY9+90OueaUSn6krFDFkFgER0onIrH4zEJEQzwZRd9aUCxQNpkyjTroilG30UikTAlDRf24/tznoEKr169qqmpKbtbEEoajYZmZmY0PT1tAQgwTb1et2fLyPJoNGp3GJkfsnMCBRw60Xw6nbYMi/sL08kl0VxmYQMJKprNpj3XSqWidDqtdrttNgzBSFiO1E1xtHwHgmPqKVNTU/ZdsZWlUknNZtNsIP8WFl0mkzH719fXZ+yvUChkf4bAqtfrteCPxk6cFqxG4DwX4iVQv+h6oyZKinXQdjHuOzs7qlQqunbtmm7dumVRnNvExsPnQJKdlMtlozsGg0HduHFDk5OTWl5e1l/+5V+qVCppeXlZR0dH+uEPf6j333/fNIbo76AZkUO4tLRkgo4cWCJfNgrngiE8Pj42CfFqtWrUVui8qVTKOO2XWY8fP5bX67XBSzCXWq2zgV3NZlOzs7PWMYsECVRuV1vpdcyVAh6DhgKBgDY2NnT//n3TETs5OdG3v/1tLS0t2YEH/kPKm56Q69evW1Tp9XpN60qSQR0YFLIRstmNjQ2LemA4eb1nk/+mp6cvvX8PHz60KBc2HRL+wLFuwRFYdnx8XPPz80ZigJQC9o9xpI5FtzlDwKrVqnXVDw4Oamlpyc6Ii39z/jDC9GeUSiUNDg7a/m1tbVkxFXo+2RP1MGoc0hl8m0qlrPfpbZyLOyLBnU4qydSuk8mkJicnjZ5dr9c1OTmpRCJhewhdFhtAdg09fHFxUcFgUCsrK/rss89UKpW0urqqk5MTI460Wq/k4VHvhuEUjUb1rW99y4K8crlsQaPP57M+N+SFUPdoNBpWuOa+eDweUx2PxWJvNAP+9UWghA3kDhHAFQoFRaNRE7Pk7ENuYpFZQ5ygjwp7tbS0pIGBAR0cHOjFixfWJlAulxWNRjUzM2MOkwmvCHOivLy0tGR3gOeM3JX0qgzBOAeCscPDQxOi5f6DOk1OTmphYeGbL+jD9KET3C0WseFuVyr4rltI50BSuIJOSiEQmiFfmA2ngQ5qMZFot9s9111MpIcTdAvWbAhRB0YAxgnvR2RCoe1Nu1L/fQuYAcOEYwDHl2RYNOkzFxcDBn2T2guZCqkzUSC9BkjLIMAYDocteiGqA4KTZH08Xq/Xinx8d2A36ZUyNoYcyAEih6uR5sJ5LkHgsvtHJEotjddmb12KuVuYhwrP54C9NjIyYgGI9GqAndfrtZkYqBiD/7v9Ei75olKp2Hd2SRFuoZTaTX9/v41GyGazdg5cvTYCMyJmnsllF5lys9m0wWHcLT4nGTw1H7eAjgy/JNNz6+k5G83A8+Huc15oxKPuGo/HrWGyWCxa5gesRl3MhW6hsbP4c3oxXCKB+2/c88czJ7u8zCLjoHOd+8n/49AgNfFM+S932S2Kwypz7whIj9v1z10Lh8Pm2Hp7z8YQgGxQR3Tt8q/6rsCgUPbpbcLB8HldgoFrC79x50Lh7OHDh3rx4oVisZhmZ2eNUkgx8MWLF2b4+IB4cNI+DuPExIRmZmZ0cnKira0tVatVPXjwwPjrpHSJRELdbld37tzR+Pi4QQ6np6dW/PR6vdYoCVuj9Dez4eGWu13WRNLFYlEHBwd2WWggAjZgUbC97OVGhv3g4EAbGxtmAHEQjBl4/vy5XX70zijkYfTC4bA55oWFBWtWPDk50fb2ttE10YqamppSq3U2ohh6N1pCKDJLZ+qnMIFw3sBHKEf7fD6NjIxofn5et2/fNnzd5/MpkUgoGo0aq8+9fDRnvs3+dbtdIz00Gg3D4MH0GbLmGhEMJEbS3e+pqSndu3fPuqRrtZoODw9tRshHH32kZrNpkeKdO3d0584dFQoF0xajSY65OT6fzxr6jo6OzKFxdiiMT0xM6OOPPzZ16XK5bDODyGoQlqxUKpbZvw1rbGpqyrq4t7a2FAwGrZeMrGFzc9POAcHC7u6uMpmMMpmMVlZW5Pf7df36dXMUs7OzRsKBkYiBQ+afmesfffSRPvjgA2uAPDo6ssDn9PRUT58+/SXmEvUq6osEWOPj47p79641D5bLZVNAwPF0Oh3t7e1ZJogzusxCMeD58+fa3d21LIK6CojMzs7Oua56zjwqJWQBQ0NDpsNHL8zp6akKhYIF4jgBUJNbt25penrabBs1ROotL1++NBsIY5f9pDSRSqWM6jw2NmbyUNyhWq12bhwDPXZuk/tF1htlLtCBM5mMeWK3QY7L6fF4jCrrykj39fWdKz5RZCJ163bPhmkdHx+b8KLP5zMYjuY0MhW6rSlGw7Di79AvcjMlSdakBruCjIhIl0uFUSTieF0d900WjClJ5x4QThcnSX0E+AG6pftgyarAayuVinXVn5ycqFAoKB6PW2GT96YO5WYk6EERcWGY3e+JVpskc3YoIAMbcgbcZla3voFzvOyCxokgH9kDmSbOrFqt2t5SB+IZEr3yrGm4LZfLOjg4sOcN7ZbGSrIeOq6BW3C2RKn0/XDRca7Qal0YictNY537WmTkPp/PnIxL7LjsolbaarWs5oOmH1E5g/R6enoMXwc2oSbZ09OjSqViWbFrsF3pJPaQ50PtDWfBnSUDInNxKbhu8y2EBpc+Hg6HjaAhyd6LXhmgHuoHFMYvs8hQUfyQZKKYoAtuHw8MWdbx8bH1LMXjcasBMi6cLJU6EjUTbKZblHezCmwrd9g9J+49hr1J/QmyUrvdNtuMHXYDNNCU19sT/rZ1YeeytbVl7Kzvf//7FtHS7cumgBuCXVMYdjWXeND5fN6iXPRuMLRuE+D+/r5h37DJmOtBv0Jvb69NymPcrAvpUK/Y39+Xx+PR5OSkFhcXdXp6apEjsxJGRkZ08+ZNdbtdffHFF9rd3VUikdDY2NilncvBwYGks8hpeHjY+i+gVwODcQmBIQcGBkysk5kgwC4HBwfG3sAAceHI+rrdrmUpzGo4OjoyXBonFAgEFI1G1Wg0dHh4aA1W4XDYnl2r1bKCM53qwDrAmfV63eRrut2unjx5omw2q3A4bI2hl1lQkefm5my6IzAOMAWd7G5WODo6qr6+PpsCSQbKud3c3DzXE8Bll2TPhO+5vLxs+PaLFy9MWwpo8saNG6rVatra2rJsgz3d2Niwgik0eZg77fbZdMuDgwNrFp6ZmVGnc6ZCfXR0pEwmY8HCZRdQ7NjYmBk21BjK5fI56jhGqLe31xo/UbFgv/L5vI6Pj7W9vW0OAXimVqtZPxFBAY77yZMnSqfTlv1NT0/brBEg1p2dHVWrVXNe0HipR2HEoZBLZy0P7NX8/LympqbU7Z6pE2cyGSUSCRUKhTfSx3JXuVxWt9u1sdTAcWjUQcphL2DRQRKhhgf83263jQTg9/vtHlJSiEQimpycNFsJQ29jY0PFYlEvXrxQvV635nSae2mUbTQav9TL5/F4tLGxYc274+PjljAQmFLDTqVS6nQ6evTokdbX141C/zrz79+3LrzL9JxMTk7q+vXrymQyWl5etoFT4OB4RLr34/G4QqGQaYe5ER2DgOLxuD755BMNDQ1ZcTOZTGpiYsKEFCk4bm5u6uTkRDs7O2q326ZZxLCxSqWiw8ND5XI5DQ8P2+WGrcImzs3NGT4Jj393d9dohPF4XN1uV7lczr4nWdFlFtnewsKCJicnjcqNqCEEBCQryPwo0NMJ3m63zbDSa9Db22sRIpEZ2RiRMxIa/Pfly5fqdDq6e/euJicnFQqFNDY2pqOjIz19+lTZbFbT09MWGMDQYaAVhAzo4+zf4eGhrl69qjt37hjVEsjpTfDa1xcGH0HPo6Mj621AjoXXdmtS6KlBRKAZstPpWNDC2GKgBLcGRa0LuIJ/z+AzLtrY2Jjm5+et+HpwcGCNhkCHNLKyF0TiNMgeHBwom83qypUrunXrlmU6UONfFxd800V9I5lMKplMWqYL2+jo6EjRaNTYTsDE0WhUIyMj1ujLHvDc2cO5uTnLhMnUBgcHTf+tWCxqbW3NApP9/X1JZ2oSdIi7QwFzuZzdgWq1akEPChvsCwFpKBRSJpPR3t6ejZeQZMaWMReXvcNHR0fyer3mLI6OjkzTD7V1bCCF/k6nY8oGHo9HOzs71tQMcSibzSoWi+nOnTvWttFut+1O1ut1HR4e2sDAavVsDPrq6qra7bZu3rxpMj7UjyGO0I7BOXZrvsPDw9rb27O+LVoRisWiUqmUMU8zmYyePXtm6ioXdc4Xdi6lUsmKt0SMeDEuC4wWME+aKV9PfzGARCSMAMZAuENyJBkEg6GkUIgjopBNIZJic6PRUDqdtkxIOoMGiIhc7j61hGg0qmQyadEwUjCpVOqtpCM41IVCwSBGokfSTgT5gFx46EQ5wFsYT7dg6RY12RMgKRwVdR2Px2OidGQhMEpqtZplMa3WqxHGNKRSoMUAU+hj/2CW8axisZhNXwTDvcxaW1szY0VWx3dAjoOsEDjW5/NZo26r1bL6CDAZEB7fDVkNdJQgBdCJDsNMegUnQhpBnBJtMyBjYLxkMmmwCWQL6gqcQVSrKXhLsuiV7/Y2i1qf29Aci8UsW5XO6goTExNWBAdzPzg4sACrt7fXej24D/RAudJMBEH8PZJCkgxOh/gAhC3JxBiBuICIGYw3ODh4TgtPkhEsksmkzeKh4S8ej+vGjRvnAojLLAgb5XLZMhMgZCB2aPuMW+jt7VW5XNba2pp9Hvd8QjkHFoccwB12lQWkV6OjgaM5x5AygDBRvKbOBzrE/iJZRAOodAahjY2NmdgrLR+pVErXr1+3MsU3XtAn9YVaGfmbwVB8KBR2XbouXg+aIRefOsnr/H8aeyj4E6njsMh8AoGAfXEUbGmiwuiEw2G9ePFCa2trmpub07e//W3r7iXSoFES/H1xcdHSRFLw2dlZi+zfBtbZ3d21C1sqlYxi2u12LaLAEDOCgIiyXC4rFotpZmbmnLQOETVRCReWSw2+C8eeaCqfz9tlJjUHT+cQDg8Pa3t7W6urq4rH47p586aCwaDBaAyaAp/t6+vTlStXztGmW62W5ufnNTc3p2AwaMKOl1k//vGP5fV6DaKZnp7Wxx9/rGbzTJV7f39fiURCV69elST7bsxP6e3ttc5+RDxh+AAlSrJzRNQOscTr9Rp1vlAoqFgsGnzBeaEmSZsghAABAABJREFUNjY2prGxMW1vb+v58+dKJBK6ffu2OXmPx6ODgwOtr68bRV86G0N848YN5XI5raysqNlsampqSleuXDHj/DZssZ/+9KcWeXOebt++rVarZQPoxsbGjMgAjLO3t6d8Pm9FcpyL2zgK3I2Rp+YG1ZueDzLhvr6+c+rbZMOcYbTydnZ2tLe3p3A4rNnZWYN5/H6/6XiRgUH6uXr1qiqVilZWVtTpdHT9+nW99957VjO47CLQqtXO5tUMDQ1ZIEVWQzsBWWer1dLW1pYODw+NLAQJimANyJfeOmpSBIjYQUkm4+/3+02QF9kiMkrprGufceTFYtF0yqjvSK/GOrjZ/N27d3Xt2jWVy2WDzu/evav33nvvjffrws6FiIMsBI8pvaJjkp5y6DB6fGGGI7laNtDtXGkWSZa+STqnE+UWwyn44X0p6GOAyZL45fL6gaAwMvQ6gBFTMKb/gcjsbRekCJcS6WYhRAbsDfUi9tyl+fIzYKlu5kIUieOk6cttVvtV3Huav1wn5mZGFA/Rh3M7kNk/5OGJ0N19v+xyO+mhvbN3LOi6LlzlUrjJtvg+rqF5nTpNJi3JmFR03FP85CyTgdLYhvHjdcjGXe0yl1ACXOXO/iDYojjNa12Wyu3uIa/tRr1ky2QmkuzegAxAcnH3iYjZvZPcZ+wA+8v+85x4RkBwrnNynxN7StbKe3Gu6WvieQSDQasTttttk0fhTl92D8nkXNUE7jD7gT1iYUuYBUWA4P7iLLKf/AISddEV7v+vIgS5TggbS6sBPwOR4nXqu0vwAYYEdYIIhC36xgv6dG/zAeFYY5RI90mjl5eXDVslLdvb27NifyAQ0M7Ojra3txWPx/Xxxx9rcHDQInVw28HBQd26dUuxWEzpdNoKYBiva9euaXZ2Vul0WhsbG2ZUqW8sLS2pt7dXxWLRJKtbrZZisZju3r2r4+NjPXjwwFhapOj060xNTdnsiAcPHqjT6ei//W//24tum62ZmRlJMnkGMgkeqsfjMYpwtVpVJpMxWQsgl9XVVbs8fX192t/f1+7uroaGhrS4uGhYL9E00RyKztTGOOy1Wk0LCwtKJBLK5/M2jwLtIzr6fT7fuS7rdDqtWCymb3/72zo+PrZmTYwP34MO+Z6eHmWzWYvMLrOIPDn0KL1KZzADBWGXUQfswPtub28bFbm/v1+lUkmZTEahUEiRvxljDRxTq9X04sUL9fefzcOB/g1DLhKJqN1u6/r165qYmFAulzN9pmKxaFDJwsKCESuA6GBS0Sj49OlTnZycWMMrjYPSqyI8iuNv41yWlpbsrHG/3LlFsBQPDw+tOE9jLt30hULBGIjInezv7ysUCmlhYcGMEK+1sbGh3t6zYWHUP92Cdbvd1vz8vGZnZ5XNZrW1taVms2kEotHRUV25csUka9rtM4XlbDarkZER3b17V9VqVc+ePbPaWzabNYVuICX0yeijuczCGboqEaAB1IT5Jb2Cn4Cy3aAQEg81DsbFM7oCotGzZ88s60YLkV+gFcBWOzs71sJAiWF0dFSLi4vG4IQkUigUtLi4qLt371rtiJEZpVLJzrNbF4Rm/o07l4GBgXMb61KRX4+gm82maTS5zYI8IOjFQCt4WyicpNrMNqGBjV4BDBjaX6lUythhYP0ez1ln7sjIiLEhwNNbrTPhRWZNgJ/yOfgMHApGlO7s7FiU+aaL4hiSNlwwN3vhfXEMbiMbESCReaPRsANA1zEOn+9B5kXNiv4DGrUoGo6Ojlpm5GY8aDdBQyWI6Ha7isfjmpqaUqlU0vPnzw2SdOmUvJeL218WlgBCBPunxkaUR3ZBwyHwIGk/UChYNI4IY+lmGETcuVzO4FiMLVkbP5dIJKwHbHd399z+oxXmZlE8X2BlNObIaHO5nAVkGC+a4w4PD98qe6ZfrFKpGGxJUMj9BWJyO8bJqFA1lmSoBSzB16N2r9erXC6nnZ0dc7JkHUDiQDRIA8H0pI4GLD07O2uvTzEc9lcqlbIpmpxpiBOI21LHfFPj+PpyM3mWKzNDu4Kr9wcq4iIO0iv5fpwRdWLqKdiAzc1NDQwM2GRflxZMQ+bQ0JBGRkasFiS9UqBHQxGbib5aJpPRzMzMOdYbrwlJAxIRwZgLXV5kXdi5hEIhY0+VSiVFo1GDq2q1mmkm8ebguqSy6XTaGEo8XNRZGXRFhkPRji8FUySdTht9GcVRqLxQ/prNpuGHLtuC/oSNjQ1jMFHcnpub09zcnCkru+kuhhiHeFnnQqaSy+W0sbGhWq1mHHmcKRfTZYtB6aYXA4cgycZIRyIRM+r8e+pOvb29llozLQ9CgySjogaDQVNIpZYTDoetSZNiNdIbOFqPx2PTLIEMiNbcLuvX5SfedOE4qUe0220tLS2Zwed9OQvAAtA06QbHidNB7vZ3eDweUzWgRwN14GAwqFKpZN+bruparWYaZDTqkgXH43HNzc2dgzmAFmCu+Xw+zc3N2T7jCDEc/J4z9DbOhXtGIy9ZA5+vv7/f6NI8L6/XazRk5uVQF3GL9R6Px9h0wDCjo6MWHKZSKZvYyeA0BClx9J1Ox4rUkizjYLYS4445T8ViUV9//bV6enrO6cxxZyHl0LPxtqrSKJtns1ltb2+bjZNk51CSQYgQRubn5zU/P2+ClMCRwNfUpg4PD20vPB6PTTnt6+vT6OiohoaGrFbq8/nO1bzdSafc12azqWg0qtnZWctSufs4tYcPH0qSFhcXdeXKFXPELmRHPxPB0TeeuTCnfnV1VcvLy6ZG7PP5DJsjYvD7/ZqamrL/JpNJ3b9/X2tra3ZpJBmWh4RLpVKxAio6UTCm6KSnSRMhRRovfT6fpqenVaudjU4+PT21fgEMJtEzMNOTJ0+USqX0H//H/7HGxsaMwky0zUPnQFOPuczq7+83SuHXX3+ter2uxcVFBQIBS4PpYyBbGhwc1JUrVzQ+Pq7nz59bb49bJCXCJJuB9UTxHUjl8PDQnAu9C9QL2u22peXValUvXrxQpVJRNBrVzZs3rWkMuuXp6anW19f17NkzJZNJ/fCHP9TIyIg2Nzct8sRAgA8z7+KyUSN1gHQ6rSdPnlhhF6YXhU86oMH0gRPQUHOldDCSkiwgYUIgnxuj6/F49OLFC62urmpgYMB6RcgCJJmsO7Du6Oio3n//feuVwamUSiXraUmlUvqH//Afanx8XC9fvtTW1paNAnCb8rrdrmVLl12o3ZZKJT1+/FidTke3bt0y1hc9Fgz8a7Va6uvrUyKRsA56MgpXIZvGXBos0bcaGRnRzMyMIQMEfi9fvjRYGodMpgsjkuAuFotpcXHRBpxxF/v6+gxGS6VS+t3f/V27J+vr6xbokjUMDg4a0++yd3h8fFzNZlOrq6t69OiRarWarl69ajUjVyLLVcKemZnRyMiIHj9+rOXlZeuAR4SWGtvOzo5Rr5EmgmIMQYLgGtgfJ5XJZKx/z9XNSyaTWlpaOneHY7GYwbCfffaZksmkfvSjHymVSimdTpuSBplWKBRSPB5Xq9Wy3ryLrDeaREmmAI7pHgJ3ATFgKF/XBnJf8/Wu49fptRxg4Dfe001P+bJukdF9LdI+lx7pQnmk3P8+ih2vzx5cdgG/AHVQ9OT7uXvA+7gyHK8/1F+1f6//nfv6fF+3KOvuFfvDd+bPXi8iuq9Hlvf6v/1Vn+dt9o4F1Ibzcj+/e1b4r/sdXn9/93OyT6+fGXd/eW/3DPLn7u9ZnP9fBYuwfxBagJpf36dvgkTC4rXd7+EiCe57un/n7qH787/q37l3he/l0ppd++GeqX/fen3fXn8/Ai32+ldBVnyet10u2eN1irD73Fzixev78Prncp/v68/D43klo+Xuwev2jj9z77R7L9w/d//ebR52e+R+1Tl2X+eiZ9LTfZtQ6N16t96td+vderd+xbp8u++79W69W+/Wu/Vu/XvWO+fybr1b79a79W594+udc3m33q136916t77x9c65vFvv1rv1br1b3/h651zerXfr3Xq33q1vfL1zLu/Wu/VuvVvv1je+3jmXd+vderferXfrG1/vnMu79W69W+/Wu/WNr3fO5d16t96td+vd+sbXO+fybr1b79a79W594+udc3m33q136916t77x9c65vFvv1rv1br1b3/i6sCryP/gH/0B+v98mP25ubuqv//qv1dPTo9/8zd/U4uLiuUFdPT09arfbevLkiTY2NnR6eqqjoyP5/X5NTk5qaGjIBi+5C0VRJtAdHR3pj/7oj7S5uWnqykwE7O/v18TEhKLRqI3wbTabKhQKJjfNBE0k6V+8eKFMJqN4PK6xsTEFAgHF43H19vaek4lncNnu7q4NKUPB9b/5b/6bN97o3/3d35XX69Xg4KACgYBJx4dCIf3X//V/rXv37imTyejg4EDNZtMGYj148ECrq6umYtvb26vR0VGbORIMBtVsNm2ODiOZ+/v7NTQ0pFqtppcvX6pUKikcDisUCqmnp8eGa6G4zC8k1+v1uhYWFjQ7O2tqqNVqVX/yJ3+ily9f6sqVK7p7967NVe/p6VGpVNLx8bFNdOx2u0qn0yZnj5rqf/ff/XdvvH//6B/9I3k8HpN/Pzg40MOHDxUIBPRbv/VbWlpasmFNrGazqV/84hd6+fKlnY+enh5NTk4qFAopGAwqGAza+WBCYLVaVSKR0OzsrKrVqj7//HObzog0fSqVsumIDBRj1gWjdCcmJjQ6OmqvXa1W9fDhQ5seGovFNDAwYLPNC4WCyuWyotGo5ufn1e12tby8rGw2awOcJOmf/JN/8sb7J53dYZ/Pp8nJSaVSKa2vr+sv//Iv1d/fr//qv/qvdO/ePfuOR0dHWl5e1tHRkfb391UoFHR0dKR0Oi2/36/Z2VmFw2EbhcwAMEk2QiISiWhsbEy1Wk1Pnz5VPp83G+GOLUgkEhoaGrLxFo1GQ/l8Xo1GQ+Pj40qlUnbvT09P9Wd/9md68eKFRkdHNT09fe4OMxuJeVBer9dGGCD73+l09I//8T9+4/37e3/v78nr9SqVSikWi2l/f18PHjxQIBDQ7/zO7+jGjRs24tu9w6urqzaKolqtyu/3a3x8XMFgUAMDAzYnikF8Q0NDCgQCCgQCCgaDOj091VdffaVcLmdji/v7+xWPx+0u9/X1qVqt6ujo6Jyy8tjYmFKplNnMRqOhzz//XBsbGxoeHrZnwP6dnJyoWq3aEEaPx6ODgwObWMrMqP/+v//v/9b9urBzcaWfpVcG2JWqRwL79dnrr89r/1XrdblqVxac9+O/rtz+6z/n/gx/x+v/KplvPrM7EdKVdef/3fnhl1m/Sgrb7/fbKILXZfEx9uwxw6bcveLf8Wevy7W7f/e6lDZy267Mu7sHSGszhZHvz2dy9wlj6o5iQAqdfXzb+e+/6vMRbPA8mahIcOPuX7fbte/yuny5u3fuHiGr7o4jcEcZuNL0nD93z9k/zp6kc/Lr7Ik7o8d9Nu7+vf76l1mvjxBwz6Arwc53d/fv9ZEAr8u9s9w/c8cf8HfcIXf0xesS/+7rcZakMxv0+ogM97y5w7fc58NzdJ/TZdbr0vPuGXTHCXCH+bz8DHbkV41WcPeH/XNHR/C8+C/v9/odc5d7Bt3JwZxn3u/1/eP93cm8l9m/CzuXhYUF+Xw+hUIhtdttJZNJ/eAHP5DP57NBMul0Wjs7O4pEInr//fdt2FUkEtHBwYFOT08temeueKvVMu/r9XpVKpVs8iRT+Dwej6LRqI1ddQ9XsVjU0dGRDdTxeDwaGhqSJIu6BgYGbBb88PCwjRLN5XLqdDpaX1+XJIvoGIlbq9V0cHCgo6MjG951WefC9EjGRBOtBQIB9fb2qlAoaHt7W8+ePVM0GtVHH32kYDBow5KY5NntdhUIBGxAGJEQ40o5BK1WS6VSyca8Dg4O2gCtRqOhdDptF5FpgMFgUD6fz6bR7e/va3l5WQMDA0omk/L7/RaNMzmPkaztdluRSMQyqUqlYiNnGWLGqOzLLD4Tk03HxsZsWBoTRA8PD7W+vq54PK6/83f+jv39zMyMcrmcPWeyjU6nY5lWNBq1uSPdblenp6daXV1Vt9tVLBazYVlkD8fHxzYAjNHTGBIyOfYvGAxqYmLCPsvk5KSKxaJldaVSycZKh0IhVSoV3b9/X41GQ4eHhzo+Pj4XZFx2jY6OyuPx2HePRqP6+OOP7UwyNntra+vcHd7c3FQ6ndb+/r6NX47H44pGozo+Ptbx8bECgYCi0ah8Pp9FuZVKRblczhzV4ODguVk8uVzOMguGv/X3958zYhsbG7aHY2NjFvXH43EbXtbpdJROp20PI5GIqtWqstmsTSet1WpvfQbJhKLR6Lnx6729vRoYGNDJyYm2tra0srKiZDKpX//1X1c4HFYqldL29rYKhYJ2dnYkSfF43J4DE3iHh4dtumm1WlWtVtPR0ZEajYadc+6wdGbfWB6Px8ZRu8Hz3t6e1tbWFAwGNTU1pZ6eHg0PD9selUol+zmPx2P7x+Rb7GS1WrWhaBddF3Yu09PT9iU6nY5isZjGxsbk8/nMgOTzea2urmpsbEzf/va37WHw37W1NZuoNzAwoHq9biNcBwYGzFkwfS+fz1tkGQqFbHa569E5OENDQzaWFiN5cHCg9fV1Mw5AOExuY+QvRrKnp0fxeFyVSkX7+/s6PT1VOp3W8fGxjRK+7OUGfmFxQPv6+uT3+21G+trammZnZzUxMaGxsTFFIhHNzMwYnIeh7u3tNRhocHDQDjkGjxQcZ8vQKjKNQqFg41i9Xq+CwaA9m1Qqpd7eXq2ururBgweKRCK6cuWKQqGQlpaWNDIyoo2NDT158kSVSkXb29uq1WpaXFzUzMyMyuWydnd3LaNhlvfw8PCl9w/HjmMNhUKanZ21kcatVkvZbFbLy8uan59XLBbT+Pi4BgcHNT09ra2tLZuYGgwG1dPTo0qlcm68cU9Pj2q1mlqtlo6Pj5XNZtXb26upqSkFg0EVi0WVSiXVajVz3JVKxbIkv99vn29gYECrq6t6+vSpEomETVadmppSNBq1yaJAGe12Wzdu3FAikdDR0ZFWVlZ0enqq4+Nj1et1hcNhG+192QVETIQaDoeVSCQsKymXy1pZWdHnn3+uq1ev6jd/8zc1NTWlQCBgY523t7fl9XoViUQUjUZtLjvTPxkvzdjyYrFoiEEgEDDnwhnsdDo6OTlRT0+PhoaGFI/Hz2V6+/v72t7eVjQaVavVUigUsj1cW1vT/v6+6vW6Qa9LS0saHh7W8fGxtra27DPUajVFo1Elk8lL7yGjwUOhkIaGhhSJRLSwsGCfF1vy/PlzSdL8/Lymp6cNPt3b21O9Xlen01EkElF/f785Z7/fr3A4LL/fr0wmo5OTExuLLcnGDZMF1et1lUol+xnGahOk84wzmYy2trYUjUbts09MTCgSiWhnZ0eHh4c6PT21UsK1a9cUi8VUqVS0urpqMB9jvEOh0IX378LOpVgsSnqV7jabTQ0MDFgGgVfr6+tTs9nU8+fPtbu7aykcDoC54IVCQaFQSCMjI+ZpSc3ITojES6WSGo2GpZmk64xABu7AgDOKtVarmactl8uq1+tmzI+Pj1Uul+2Seb1ei3QZy0rExfd8m2mK7J+bjlLnqVQqti846S+//FKxWMyiuHq9roGBAfl8PnPK0WjULqObJTA6lQPlQg0YwFQqZSNvicaJevL5vKXTRPlErMViUT6fzzB4d08jkYjNaW+1WgYJAQUAH1xmlctl+7ftdluBQMCieYw7l6pSqejJkycWeeEs+vv7LVLudDoaHBy0Oe4uBCqdjaVOJpMG8zDjnQh8cHBQnU7Hxj4zZ5yL32q1LKMcHBzUycmJ2u22ent7bdx2JpMx+IQaWSgUUrVaNQiGvWWc89s4l0wmI0l2T6lj9Pb2anBwUN1u196r0WhYfahcLqtSqZiBYbR4vV6X3++3+fUej8cgmL6+PnOy3W5Xx8fHVg8DVmImfb1et+h8aGhI7XZbmUzGzhyGmHHSJycn6u3t1fHxsd11Sfa+g4ODhpLwffl7YNPLLDJMsgsMuQsbcs6r1ap+8YtfaHNzU6VSSScnJ6rVajZR9vj4WJVKxYI5r9dr9SYyYBCddrutcrlsdg6UBsQol8tZoIgNxN55PB4Fg0GrV0kyR5LJZJTJZMxeUOMJBoM2Epr3k2TZ5UXXhZ3L5uamORUyFy7o2NiYXTjS+v/n//l/1G63NT09rZGREUlnM6iBz2q1mt5//33dvn1b1WpVm5ubFgExe5rsplgs6vT01ByK3+9XNBpVt9tVLpfT6emp/H6/ksmkqtWqnj9/rlwup/7+fg0ODkqSDg8PzTD09fUpnU7r4OBAgUBAS0tLlr4GAgFLRckKyITe5mJvbm5KevWAME4YvEAgYIZqc3NT/8v/8r/I7/fr+vXrmp6e1unpqaLRqGq1mnZ2dlSpVDQ3N6dPPvlEpVJJjx490snJiSRZtpJKpdRut3V4eGjwWU9PjwYGBjQ5OalOp6OvvvpK+XzeLnGj0dCzZ89ULpft55idfXJyIr/fr2KxqN3dXQseEomEAoGApqentbCwIElqNBo6PT1VIBAwbJ854JdZe3t7ks4MCxfA6/UalMJr4/j+r//r/1JPT48SiYSi0ahFhrVaTbu7uyoWi/rwww/1/vvv2/kj4+t2u4pEIorFYmq1Wjo4ODD4oLe3V0NDQ5bJf/HFF8rn8xoeHtbU1JQ6nY5Fg/39/VpcXFSj0TDDnsvl1NfXp/X1db148UKBQEDXrl1TJBLRyMiIRkdHLYv2+XwaGhoyA/EmUeOvWs+ePbPnzB0DZgyFQpZ1RaNRnZyc6Pd+7/fk8XiUSqUUj8fV6XQ0PDxs896r1ao++eQTfec739HJyYnW1tbsnEE4GR4etvpRtVq1+tLAwIDZhdXVVaXTafX19WlkZETValUvX75UoVBQMBjU9PS0Go2GcrmcEQfa7bYODg60tbUlj8ejZDJpRet4PK5Go2GOYGBgQIFAwJzCZRfQUTabtbOFUQaFAJXJ5/P6p//0n8rv92tmZkZjY2PmQCG6VCoV3blzR9evX1elUtHGxoZqtZo5lYGBAQ0NDaler6tSqejk5MQC8cHBQSWTSYNw8/m87V+9XtfOzo6KxaL8fr/GxsbU6XQs865Wq+rv79fW1paeP39uZzAWi2lkZESJRMIcO1A0tv5NSgMXdi5EHW7hCG9NxIeRJFVrNBqq1Wq2YdQJ2CA32nSL+ESPRJR48b6+PqtRkIoCi7hzpt3iKT9LBM1rUWOAlUFUCPTV09NjUSVYPBHSZZZb2OWzEDXy5xh+0nxJhr02Go1f+g5EoLyGJCt+8jzc9XqBlnpXX1+fZWZuUZB9cme9s8cYJPfyutHw0NCQfUfOCZHUZRYRp1vcdue6EzFTTyPygp3X399vmZmb8WDE3cIwAdTr55Tv0d/fb/+G5+DuqaRzZ1OS+vr6rJhK1upCvThHCASBQEDSqyIyTL7LOmdJdoaazaa9D+/Nd+XZVatVy2AjkYg9O5cQ4Z5jXtu9xy5ZgtXb22vfmb1hDyG38L2JmrmbGDzuJHCTC5fydz6fz/aQ7B/G4NvsH5+NYJP7J+lc/bhWqxkygsHnTpLdcG56e3vttYGu2UPXDrnQI/vV7XbPZaLuwo5x9lwyFDUaWLc8D84n95rf871dNubfti7sXDCOXNbJyUndvHlTPT09Ojg4sOh3YWHBqHh4SJc14/V6zxUWyUpwRvl8XuVy2QrvPT09GhsbUyKRUCqVUiqV0vHxsTY3Nw0aikQiGhgYUKVSUaPRUDKZVDAYtAdCQZqDCk0aQ8LnbTQaKhaL8ng8RgXlMm9sbGhzc9Mc35suLgvQUSKR0OLionp6euyyX7lyRSMjI4a5E2WBybOHs7Ozlr2Vy2XVajWjhe7t7ZlRgESAsQwGg1YIzWazajQaVpiFfgqFdnx83J4XWSTOr7e3V0tLS+rv71e9XrdCbyAQ0OnpqWKxmH7wgx8Y7t5sNrW5uanHjx9fev9cgxIIBBSLxTQ1NSW/369sNqtcLqfBwUF9/PHHKpfLevLkiarV6jk2DAby2rVr8ng8ikQiyufzBilwlnO5nGVjwK1k5eFwWJVKRTs7O2o0GgoGg7p27Zp6e3t1enqqbrdrQQusoXA4rLm5OXMQ7XZbV69e1X/wH/wHajabyufzajabOjk50crKirxer27fvi1JOj09VavV0vb2ttbW1i69f+7CuCWTSX3wwQfq7e01KG9iYkKxWEzlclnPnz9XtVo1+NZlCk1MTBjBh4yb14WsMDw8bJE6xnViYkJTU1Oq1WpWQ4zFYkY4gQAQj8cVCoXOkXgmJyftcweDQY2Pj+t73/ueqtWq1tfXDZ6s1+sKBoO6ceOG3Zt2u62VlRXt7Oxceg+BtVKplJLJpCYnJ3Xr1i15vV5tbGwol8spGAzqW9/6lkqlkpaXl41efHx8bI5xYGBA169fN+iazI5sfH9/X8ViUaOjo1YjTqVSikQiGhoaMupypVJRq9VSIpGwQKVYLBq5BucAtE+mhbO/fv26PB6PZYXY7N3dXXm9Xr3//vvqdDpmV1dXV/XkyZML79+FnQteFwNNvcTj8VgvSCgUss2gAIh3JaJxMcCenh5Vq1U7eO1224qYwFlusRkH4/P5rKZCTcCNyHh91tDQkJLJpDkWN+qvVCpaXl42hgtZFgaXaGx3d9d+5rKLaIECPPUmahewT4rFojKZjEWTFAGJYOiPoBbSarUsOqH2gsMm2ifKDgaDVufBOQ8ODqpSqRimTO2AjCUQCJhzJtKHI0/hsVwuy+/3q9lsGm++2+2qXC7r9PRUu7u7ymazl94/MH2cAFGrdFb0PT4+NqdNVOdSWwkment7zXFw3tzAB6YgGSRnxefzWWAgnTl8HCm4ON+NSBa2I3AFWHy9XlcikdD4+LgqlYoeP35sdcVaraZQKKSZmRn5fD7r0djb2zOs/G3OH4ssb2xsTL29vQbTcIcDgYB2d3ctwHJJNDgVUATgxNf3sL+/X7Va7VzGCeurVCoZkQYoCePW6Zz1a1FjxO4QQGE4gXE4Y/l83gJHnBCOrdVqGZx82T3EuZJ1xmIxJRIJSdLa2ppOTk4UjUYVi8UUCAS0t7dn5w9IjF+JREKDg4NWV+Z+QiqhJk0WAXyJc6lUKioWi1b7plZFgENGChIxNDRkz5qgB5LN8fGxHjx4YPWr4+NjhUIhqwWVy2Vz4Dj/i6wLO5dr165ZzaXZbCqbzernP/+5FXuIUiQZFg5ORwRI2kY9o9FoWEGeFHJyclILCwuWPjcaDWN1AbFRkAWaaLfbqtfrOj09VV9fn6ampjQwMKByuWwO4eXLl/J6vUokEhYheDwei0JPTk6MsgtMAATCQb1+/fqlefKwVDqdjnK5nDHiAoGAZmZmFI/HVS6Xzci48KD0qghLdNjpdFQul1Uul4190263NTw8rGAwqGg0atjp+vq6HUQgIwwV8BVOiWJ/OBy2Z0RNAgp6MBg0uOPo6Eibm5sql8saHx+3yw38wOeKx+O6e/fupfdvZmbGLmqtVlM2m9XDhw+tfjU9PW3UYqJooKbXe4Fw1DwD2DLNZlPDw8NKJpPG7mq1Wtrf31e1WtXx8bHBHTglDANQZl9fnyYnJzU4OKhyuayjoyN5vV6LBgcGBuT3+y1yh65LcAZMQWCAYYxGo291/iRZPQwnk8lk9NOf/lSDg4OanJxUIpGweyS9gpUx9Dh3nmutVrPstNVqqVqtqt1uK5VK2TkcHh5WrVbT3t6eisWisTZdRmEymbSG36OjI/X29mpmZuac04aV2O12jS3GeYA2C2mGGh9ROmdhZGTEspnLrGvXrkk6Y7YSMP3kJz8x6Gl2dladTkeNRsNg2tdhQJ4/8BJ3jH3sdDqanp7W5OSkscMajYb29vZUqVTsfJ6entrdD4VC5xhkgUBAi4uLCoVCxkbrdDpaW1sz9Kmvr8/Obrlc1tbWlgqFgkZGRoyUU61WDf6jYf2DDz648Bm8sHO5deuW2u22tra2dHBwoIODA62trSkQCOijjz7S+Pi4Go2GXQpwUoqvPGTYXy72iTHy+/26ceOGrly5olKppIODA9VqNW1vb1tPAFg6zgXI7ejoSLlcTsPDw5qbm9P4+Li2traMbvfkyRO1Wi0tLi4qmUwaJEYhrVKpaGxsTB6Px1hrFOvoioftdplFp3Yul1M+n5ckraysKBKJaHJyUiMjI2o2m8pkMmZQXKPo9mJIskNRKpUMW+3p6dHIyIhFlaFQSIVCQblczlQSyGiA/8gESX97enqMBk3kvbGxob/+6782IzIyMmJc/FKppLW1NRWLRYsq3U5e6hQjIyOKxWKX2jvpzDB2Oh0dHBwom82qUqloa2tLwWBQv/7rv66ZmRnt7+9rd3fXCp+/yrlwdlqtll3Qk5MTg0s+/PBDzc/PW7d4qVTS9va2Dg8PLYvAKbn9GPV6XYVCQeFwWCMjI0omk0qn0+rt7bXL2263NTc3p+HhYVWrVZ2cnBgFvVKpaGhoyPp5MPA4MODLt1nXrl2z4IbM4fnz5wqFQvpP/9P/VGNjY8rn8zo9PbUsm8gYAgBqBNvb20bygG5MZj03N2eohiTrRdvd3bUawsnJiTmLcDhsBq1YLNqdGB0dVaVSUaVS0ebmptbW1iwDYM/pdcF5uY6F2lg4HFZfX59GR0fPRfNvum7fvq1Op2PQfaFQ0KNHjxQMBvWjH/1IV65cUTqdtm586o9kZn19fWYLsZW/6g5fu3ZN4+PjOjk5UT6fN8eaTqc1PT1twQw9PoFAQAMDAxZ0xeNxXblyRVNTU9rd3dX+/r7S6bQePXpk0CfkIEoRa2trymQy6u3tVTweN3SDe9Tf36/p6WnFYrEL798b1VxI0YigweNJpbh0OA4KlDSauQ2Q7gd0aauuAeA9w+GwvXehUDBIxC1uQuck7YOuy0Om8Q8apVvYdnnhFK4peAJ/vN4l+6YLWIG6BZnc0NCQTk9PlcvlTP4DB0qUDZEAZhmRjiTL3tgr9onIo9lsKhaLGWxxeHhosB/GQnpVSCRS5Fe73VZ/f79mZmYM4sjn84pEIgZdcplhrpBJcQZcOvLb7h+HHbpmIBBQtVpVsVhUsVi0hi8onS4chqMjmMFwA9e654mfoQmVn0MGBjJDT0+POVK3ExvogdoizD0ac2Ey8nxpRq1UKrZHPFfOpNscd5kFE47PSk2TAnQ2m1U+n1culzN0wOv1GlxMJO6y9IAMidhZLnRNTXB0dFSdTseyuFgsZu/vkkXYf/ZQOusTm5ubs2eSyWSssRqCBPej2WyeI/VQ64IeftnF6xLscV4GBwctuOAX8CfPFgYg8C53S5KVDri/fGf37tMr6PF4TIIH1IG7h2MFmuQuUnOZnJxUvV5Xt9u1HiPgYfdeufYOaj+2Gcd+kXXhnc7lcpLOHlYikbAPQwTNgUQ/jIYg+O2xWMw2iAfFgeIL8+c07hAR3b59Wx6PR8+ePdPy8rLGxsa0tLSkgYEBgxSgyUHprdfrVpyNRCL6rd/6LXU6Hf3Zn/2Znj59qqmpKV29etVqIKSIYL4wYKBcAjNd1jhSnCeyBTP2er06ODjQzs6OCoWCstmsPViYWmCgdEDn83m1Wi2LzGj2pJuc/p/Dw0N5PB59+OGH8nq9+pM/+RP96Z/+qa5cuaLf/d3fVTwetyY9DDHROv1KFAz/0T/6R6rVavrn//yf6+HDh7py5YrVN6D6Qtt1AwMgAuohl2U74XB7e3s1PDxscJgkHRwcaHt72/ZRktWGMIr0XHBZyEwwGNTocJBAh5J048YNeb1effHFF/rpT3+q6elp/Uf/0X+kcDisnZ0doykD+VSrVRUKBXPoqVRKn3zyier1uv7Fv/gXun//vhYXF/Xee++Zw6lUKkbRx9FxHpvNpj3/t6Eip9NpM0A0Hc/MzMjj8SiTyWhzc9MyXWoyPT09Oj4+VqFQ0OjoqKampgyuc+FlvoNrNMnYJBn558///M/1x3/8x1pcXNR//p//5+fOIMZXkikXEPBMTEzo448/Vq1W0z/7Z/9Mf/3Xf62rV68aPRvFC0lWPOez5XI5g4Ogdl92/6QzR+dSn6UziHFnZ0f5fN6UAQhwqAezp+wXDocWAOArslp68bxerz7++GP19PTopz/9qZ3B3/zN31Q4HFY2m9Xx8bHVbPv7+03hhNaNqakpffjhh6rVavqDP/gDff3115qenlZfX5816RIkoJwA/E7j8PT0tK5cuXLhIOfCzgXjSJTqGmXSY+oiXFQiaLcxiIgGSh6RN18EuAJoyCUAQNmDokekIp2n2QLNYeDYdB402KZLI3VZFETx4PvValUDAwOWzVxm8W9pUqPpDud8dHRkjtjFtvk8wBRudOfi327nMwebCxsOhy3KJCqB+YQhZW8kmeF1SQR0Y0syg+fi2URYfBb+Pb8na7wsJMHrsw8UN9vttjV0Alu5lFmXSMIz5py52ajbyAsciEFAZNV1TG7/k9vcRubC93ep2ZxN2FUunZdo1qVrdzoduwcY7W+CiuyyKIeHhy2byOVyOj4+NqkPhCj5PtBeYe252DvPl8CC80d/2tDQkGUokEBwmECN0ivaNywvzktfX5/Vb4DVMJ7A8JwT9up1LT7kod4mQOSckDVHo1G1222DGiHKEKxJOvf/bjO225ZBZs5euzawt7fX6sE9PT2WkXAGyULczAW7hX0D7aHgT3bvZmKcL/aNM0wDLWfzovt3YeeSzWaNuUWB3uVjU4yndkCBNBAImHEaGRmR1+tVPp+3hkmcFYdxa2tLa2tr9uc9PT1GhYvH47p3755lJzg0lxvuQjPxeFwTExM6OjrSn/3Zn1mGtLS0ZOwxj8ejeDyugYEBU8pF3kM6q5UEAgEr2F7WOHKx+ZwwbjAo5XJZqVRK77//vsrlsjVFplIpY6C4B9vt3+Fy0WC5v79v8iccmnq9rmvXrul3fud3FAqFDJ7Z2NiwpjCaYcHFYZxkMhn9+Z//uQUP165dM/y1Xq9bJsF3Q4PL4/FYrcoVmLzMcuEoF87h0rZaLc3Pz+ujjz5StVo16Y+BgQFzRDB7XFaXmzlTS1hfX1ckEjE1WSC1K1euGBOyWCzq+PhYh4eHymazikQiRvUEHsKglstl/f7v/7458du3b2tubs4aPNkznJObdc7Pz1t0/DbFfOmXRS+BTlutlmUs4+Pjev/993VycqLl5WXL2qHfon9FB7zryImC19fXtbOzc06Tjnu5sLCg3/7t31YkEtHh4aHBmTjtaDRqjqLRaFg9IZvN6vPPP7da1Mcff6xUKmUsM84Xxps75fV6NTw8bFnr2/SqYV/cfhtJFsS0221NTU3p3r17Jp9yenqqUChkjpwzyGvwXGCU1et1PXnyRM+fPz93BrFpCwsL+of/8B8aqaBeryubzapQKJzrWwF+CwaDlt38s3/2z1SpVNRsNnXr1i1NTk5qdnbWnBg1Fp/vTNKLDPb69etGGniTJtQLOxdYL+CubiSKg4nH47pz546Ojo70+PFjS9Xo2CWtJ3rGq0K1g1Wzv7+veDyuubk5SbIoEpokPQEu64OLB4ul2+1qZGREExMTevnypR48eKBqtaqlpSVj80AZpeCHBlkul9P+/r4kaXZ2VqlUyrqB3ybydhuSaPIiyqtUKopGo7p796729vb08OFDVSoVk3kAXyXawTEDR1H7ymazKpVKunr1qhYXFw26bDQampqa0sTEhEFtCHseHh5aDxHRJZldMBjUysqK/vW//tc6OTnRp59+qvn5eWP48DNcaLdxlqBidHTUHM5l969YLJoBI2MANuRyj42N6d69e8rn8waruCwdMsVisWgEEgIY6gO7u7s6PDw0XSiCI5/Pp/HxcQsITk5OTB8L6jKXmqwoFospGo0qnU7rJz/5iSqVipaWljQ7O2u6cWTtZNndblfZbFYHBwfWEzY+Pm5SJ5fdP+mX1YthzAHJHB0d6fr163rvvfe0v7+vR48eqVQqGZmAnjJJlsljE0ATms2miW3OzMxoenra2FH1et0k4Okpc+u1MPTcjIkgYmtrS3/yJ3+iSqWib3/72waL87MYRRoNXfRhcHDQCthIHV1muTYGR+VSiTudjhKJhJ3BUqmkcrmsoaEhC14ZRTEwMGA21GXcUX89Pj62ojyITavV0vj4uK5cuWISQpBSjo+PTe/MrQeRXW1tbenf/bt/p5OTE3344YemGpBKpYylB5zoIhiSNDU1pZmZGWWzWe3v73/zBf2rV68aHrexsWHRFA8VtsLu7q4d2Ha7bUKK0DDdRjL+HZG83+9XKBRSo9FQ5G+UZV1nNDo6qlQqpWq1qoODA6s7sPl4VQq1rvYQkhDJZNJqRlwMlx6YyWTUbDYtwuDgu3DfZdatW7fU6XSUzWa1ublpSreSzDnU63VlMhmVSiWDm2CEBINBi8RIV+PxuBEb0HwCc6VTvdVq2SXmkNRqNaNDt9ttqwHhLICzYPnU63VduXJFzWZTExMTisfj1ixHj430yrH39vZqfn7eUuxMJvNWcIQkozEXi0UTMiQ6o2hO5kZTLPCJC50QdUMUSSaTdrEkWW8BNUPprHYgySi77F+j0dDMzIzN18HJsoDAut2uZmZmVK/XrUmxp6dHhULB4BGv12vssXq9btR1NKJcmOeyCyrz1taWXrx4oXg8fo5Nh8PI5/M6OjqyM3hycmI6bdIZzERdc3h42Fhs6IghojowMGBUWyj2GLR6vW6aWMxjIhtwSSoEkd1uV4uLi2ZgYdVxF1BfgD3m8/mM/Vmr1SwTfJuCPozFw8NDY4TxOQhyqtWq9vb2jIUI/MR+AYPSHItSiCQ7cyBEOCKX9j0zM6NEIqH+/n5DV5LJpCkmE+Cwf9zR09NTY/SibN7f36+joyNrSejr61OhULBa9/T0tHw+nzFq6Z+76LrwTn/ve99TvV7XH/zBH+hnP/uZKSK70hpHR0d69OjRuca1XC6nTCajdDqt3d1d9fX1WYSMuJ0kizZGRkbMsYDl82CWlpb0wQcfWAd6rVZTKpXS0NCQSqWS0um0sTZghhAVMPRqYWFB8Xjc1GglmYbU9va2QUqLi4vqdDp6+PChDg4OzjVwXmb96Ec/Ur1e1//xf/wf+uKLLxSPx1UsFq2ZFHHDlZUVowQHAgHt7+/rxYsXBu24NZTh4eFz8u3UlmiiOj09Va12NqipXC5byn5ycqKNjQ3V63UtLi5aoxRkAgwZkVdvb6++853vqLe31/pckA+nuZBncHR0pLGxMb3//vuSpPv375szwJhdZv32b/+26vW6/vk//+f66quvlEwmVa/XDbpDreDBgwfWcwFt9OjoSIeHh9ra2lJ/f78Zp9HRUd27d0/7+/tG3CD4wEDCTKrVarp3757u3r2rcrmsFy9eqNFoWD/H6emp1RIIbqrVqglufvjhh0aLDQQCyuVy2traUk9Pj6lQQ3uORqN2/h49eqTDw8NvpKD/gx/8QI1GQ//j//g/6s///M81Pj5ue0hzbqPR0ObmpiqVitVV8/m8dnZ21NfXpydPnli9hloKmnwwEWHBuU3SW1tbqlQqmp+f18cff2z0WuBij8dzrojvsudAOb7//e9bzbKnp0dHR0cqFArqds9Ut7vdrjY2NiwTv3Pnjrrdrn7xi19od3dX8XjcBmBdZn3nO99Ro9HQv/pX/0qPHz/W6OjoObFev99vTDFgpWq1ajWLQCCgly9fqr+/X1NTUwqHw6ZpiNgmdxb9NepunM+ZmRktLCwYqw84u6+vz0gV3F+yQmpQN2/eVG9vr7Vj5PN57e/vq6enR6Ojo+rp6VE+n9f29rbGx8d17949STIb+KYjCy7sXOjCpUgJvonEfW9vr1GRpVcpuEsRdim/rxeuXP0st4ue13HrO8Aj0iu8E+/sFvFwLK6uD9ADhVuiRsgGZDMYQZf59DYLajRQ3ut0TvaUbMMtvLq0abcACJzG92632/ZavypCo1BP1uh23EMmcKFGlwbLnvKLg4uzIyJzI0/eE2Prnos3XcBQdF+7OksYR86QS6N0SRtuIZVal3uh6/W6GS4gU4r/0Elfp6Kyf7B8IEHwHu6zdGsUYNyutAo/x3679HD3Zy67yMDdz+SeQTIHnpcLNfG5XNiE58v+8TldNQV3z9kT7hMRtksD53Xc5/Q6pCzp3Bkk0n/987rtBZzlt1nUfvnsrp3CDvFseS/2lHMivbIpwP38vEtZdjXLXLo6mSAO173zbr3Z3W9+zwLCo45MmYM941m7FGk+F8/rIuvCzuX3f//37bB//PHH1qiDuunAwIBKpZI1YaFVs7CwcE4yptPpqFAoWNfu7u6uHRIwSwpg4KSHh4eSzuh+T58+lc/ns0JooVDQwcGB0um0NjY25PefDRNibCqyFgwTAkIrFAqmxDo5OalAIKCRkRFLr1EO6O3tNRgDmuhl1r/8l//SmGGzs7NaWFjQp59+arADjgL5fZzP0tLSOQVbYAsgSEYSE8HNzMyY7IV0BluOjo4qHA7r6OhIn3322bleGyIdBltJZ9AQB5ci7YsXL+T1em2ey97enp49e2bd2+FwWENDQ5qdnVW3ezael+fKpXobtt3/8D/8D/Z97t69q5GREYvEcNqVSsVorWDiECEQPeUZFItFk+VHBwrSA9Ht6z0/uVxOL1++tGxNkkn1MKjM6/UaWQRjXKlUDJaBws2cDTBxZqtASwWG8vvPhkghXfQ2zuX3fu/3jDxw9+5dzc3N6Tvf+Y6RQVyWF1Cj3+83ogLZs/RK86xcLutnP/uZ3dN2+0zFAQkhzg9oRCaT0V/91V/ZecYxS2cyPl9++aX8fr8WFhYUDAZNIaJcLmt7e1t+v9/IJFtbW/r666/V39+vpaUlqznQ+IxmW6vVOkdzvuwe/u//+/9u/3/79m2Nj4/rvffeM7o2ASSsMhQvxsfHz9X+ut2u8vm8QfvUPJ49e2YIDX1RbkDR6XS0v7+v+/fvWz0zEonYXKLd3V09fvxYHo/Hzgz38+TkRLu7u5LOAn6USVZWVozYxL2fnZ010hR3FvmZ/08k91dWVuTxeDQ1NWUzpKPRqAmiubRMn89nWF8kEjFRtVAoZDgq6SJGvFKpyOv12mwVMh6Xrsd0ucHBQZPrBteG7YKoJnginHHqFeVyWYODg9ZH49Z8XEYJUbDbOEbEd5m1trYmSWaYEomE8cyRAXFrBGRQkUjEOPUwY4juTk5OlMlk7IASeYCdU8vh2aBRhb4TzCYKum6Hs0scoG9DOssgkJVgznmtVjOYk4NL7YqoU5I15V1mPXr0yJzb9PS0ksmk6Z1xscGZJZkhgV2GMYNFBOaPPEahUDh3kV6nY9MMzJmhJtJoNEwd4uDgwBy3pF/Siup2u8aeq1QqJt9BBIt0e6FQ0OHhoVG/3WbFt1kvXrywrAuYlxnq7Ak1NncP0bMKBAJWBwCqpou80WhYbSqZTFo0TV0R8gU1CQIml0F5fHysdDpt3eBkK0BkhUJBPp/PtPWOjo6UyWSs3ss+QZPmDnOf3FaDy6yXL1/K4zkTjh0dHVUikbBhay6Dzr17Ho/HbKB7BnO5nM1zQXCSOh4kBJAdd8EkHBoasllEZFTsH1Rx9p3PdHx8bMEVMGw+n7e9BFkKhULWI+bS+N3s+yLrws7lww8/tNQfgzY0NGQT+2ALAY0dHh6atAAYLUVYpBjIbtxOVNhHGLVGo2EimJ3O2ThTvD/RARTGu3fvGp6JIc7n8+aNSV1pVmPT9/b2bN6GJBNq5IHg+N7mciO9kU6nlc/nlc/ntby8rJ6eHsuuSGGRVeFwbWxs2Mhj+P7j4+NKp9MmHZLP5y3aTKVSOjk5UaFQMMiAHpdSqWSqqkCZUGevXr1qDs3v92tvb08HBwfy+XznhBRXVlZsv5rNpg4ODnR8fGyHjo7+drut9fV104N7Gxrod7/7XUlnwQQjmrkE2WzWdK1wAtTftra21OmcycZTxGQ6YKFQsGmnnMO+vj5FIhEdHR0ZMYBImJ4aeiwk2e9RR+7p6bFgADkan89nI2bb7bZJycAs29/ft+eChtfY2JharZb9rNsrcdmFthhQKvpYNOa6kjZMVYTkgtEZGRkxYdJ4PG53Ccfb7XZ169YtTU9Pq1arGSLh9qEw3RWj5TZeorY9OTlp6hXUIHE4aG2dnp7aWaXWASQZiUQ0PT2tdrttjb04qLepuWCcDw4OJMnGiyOeCiRHtgqKQ30Kavbo6KgmJiZ0enpqZw0b0N9/NqiuVCqZQ4jH4wY/Hx4empikz+ez+VP9/f26d++e/H6/ncFcLqe9vT35fD4tLCwYIkItjGfCaxJQMheHbn6Ynm+C3lzYuXz88cdqtVr66quvtLu7a5fb4/GYcQS/bTQa5oUpZiH3PjQ0pA8++OCc8QZ/hJY5NDRk/7bT6RiVj4eKc6EnADYYfR10sgMZDQ0NaWpqSl7v2ZhW+NtcbijGkBOg5Xa7XZOqABe+7MFEMI/ILZfLaXl5WR6PRwcHB6pUKsYQwbkglkivwfj4uIaHh7W4uKipqSnjv4Pfw5oZHR01SjJNgJ1Ox8YGBINBw2yJmhOJhJaWlix1l856S/b395VIJHTjxg35fD59/fXXNq4VJsve3p5FNn6/3/jz0hmUSVEd6uVl1ve//321Wi198cUXevLkiV0mSabKDfR1enqqnZ0dkzQ5OjrS6Oiorl+/rmQyqXv37mlmZkZPnz41xg3OhWYzVz6DjJZgyev1WiYHRTQSiWhubs4K2h6Px3q2xsbGdOvWLfX19WljY8OeN5AQZwxixPDwsK5evSrpjK0IY+ptncvVq1fVarVsXACD6SSZdh9d7ETI9DbV63UbAR6NRi16bzbPZqxD3pFeSbWk02kTpAViYzwC8+PJntvtMwHG69evKxAIWEa1t7enarWqyN+M+/b5fFpdXVU2m1W73bahhZB8aCKen5/X+++/b023kkxs9LLr+9//vprNpv7yL/9SL1++VKfTMZLF+vq6SqWS9bIcHR1Z0AU0R3tFNBrVhx9+qJGREb148cIMOzOcgsGgUqnUOaeLugVtEuwl2V2321UqldL169etadfr9eqzzz7Tzs6OUqmUbty4ob6+Pu3u7lrwKp2d/f39fbMVKJ3AROX9qAtddF3YueTzeWNxUEyl47Wvr88oqUR4wApAA8g7E0VLr2acICEinaXiYJdEbPQNuJAHzCkwYgqLRJ+k4+igwU3v6+uzXgUKtGRFGBjSbRwJzswV23zTRQTH6+HI+D0XsL+/3wqqdOHC06ceRTETOA+HiuHGINFJ/7rqKtAZjY/sBQbapWxSOyBKCgQCisfj1jNACo7CAhEi0a4k0656mz4XGICNRsPOHk4QdhKOEYOC0Q8GgyYmyT4BLQJjEUxwlt1zBRzK9+vv7zfpnkKhcE5MFWiNLJIaABeZLJ6CKn9G4FKv100rjffkLL+tc+EMQm6BkSjJ9pKJl9yLbveVFPzQ0JAZH84TBXxqltJZTQPFBCAbt6YDWQBGHirT9F8BFbpFculVhzx9cwSlFKyxT2Sv2WzWiCv0x73NHS79zcx6+lRo8CQwoCXADbTYY5/Pp3g8bjI13BfOQ7vd1ujoqKQzu4imIY4J28cdgnno9/vPTVAlg3eV3d0pnDx7bA22Deif+wvszZ+5Iz2+8T6Xzz//3P4/HA7bbAsYIeCNPT09pkVTqVQ0Pj6uZDKpeDxuUvo4Fx58f3+/RkdHDXYCC399dgDU5VAopPn5edP/wpg2Gg2j5PX29lojG/05Xu+Z5P7k5KSy2ax2dnbMKHW7r+Zao3iK0xsbG1Mmk7H5DJdZKysrxuCg657CMRkImR/Oo16v6+rVq0ZbZB6D1+u1YV80fxItt1otraysqFwuK51OW78KDY7QlKenpzUwMKDNzU3TZwNCnJiYsANJv8/29raRA2jiOjo6MmfFHkOLLhaL8vnO5r5MTEyYRMVlWXdffPGFGRBqVuPj4xYwwLzCWJVKJfX2ng01i8ViGh4e1szMjDmd3d1dy2rJbCGK0FCIPhgGi+KoC8Hev3/fFI+R2xgaGlJvb69SqZR9XyBKMhN+z5/5/X5rvCNzxTAh0/M2ChHSq5qB3++34WfJZNIMUL1et0bldDptNRqCmmQyqStXrljGSxMfdYPR0VFzki9evFChUND+/v45liJstUAgoBs3bmhwcFDLy8uWzR0cHFjkjGAoNRSi61AopHg8bs+IPaYHhbP/85//3CC869eva29vT5ubm5c+gw8fPpR0xpCbmJiwmhXBM9+N80Lf0/T0tBKJhOLxuGZmZox1xTDF8fFx6+Ph+bx8+dLqgW5fGjZicHBQN2/eVH9/v43tbrfb2tzctAAJ5iPKKHt7e0Y5R7iWRVCZyWRMJxKNwUgkokgkYrDwN+5cwEh58BRvyTzwwmQ17ofGw/NlpVfFXQp/dOi7SqI8LCIXl+3h0g154DxYCns4DorWFOcpSHMRcGpESq/TbHkfaHmXWTTpcTCILIiyiYjZW/4uEAicK6hC8yUVxqFD/+TQEs2QBaJ3xPflF3vAdwaPJfqmk5jZ6LCb3OdIdAWFkR4ZolPomkRrl1mlvxlkhiFzlbmJqrh4sPyazaZpuMFAJItl//jM7K1LJXUzcLIcVyfPpYeTDVFIJrpkBvrJyYnVGJAYYsgdjtylNQObuVI/bsPjZRYZFkO3XHoxdzYQCNgd59xzh9l3N0uVXo1VoHhM4yI1WJdKTeTr3mE+A4w/zjBBH58NrTwXfQDdIPBwO/SpRSQSCUMz3qaZFxvo8/mMPcU+kuG7CAmflTuMDYRcQwbHOcAOYfv4GZwySAGOgAyec9NoNM4RpNgXlI/JxHlPnjXZKfdBku0tJQ2e65vs3YWdC1+AWR+dztmwKnD3brdrRedAIGB4I9kFMzjw1MjBULRLp9NWmI/FYvJ4PBb9cvg41MVi0SiLyEGTxnW7Xa2vr8vnO5shMjIyYhefy86ENTdDaLfbNmUQRlG32zUtnp6eHiuIXmYdHh7K7/cb24liKk6WCHFiYkJDQ0OGV/v9fuVyOeVyOa2vr6u/v1/Xrl0zA0+jKDUQl/POARwZGTEmGoXDJ0+emFPjYEK+IFUfGBjQ1NSUkTh8Pp+Nd2XS4MnJidbX13VycmL6XVB2yQYxIG4k/6YLNtz4+LjGxsbUbre1sbFhDtbr9ZqWXCgU0t7enhkZ8OxsNqu+vj5NTEwYPOsSP7rdrqLRqE0+BXIEMkJzrt1u60//9E/tkodCIRWLRa2vr5vjgZIcj8fPQVGoYgMTwzZrtVqamZnRlStXVCgUtLKyYtBQtVrV0NCQJicn34qKzH0aHx+34Wr7+/vnenNcqZKRkRGrIUHmWF1d1cDAgObn5434gCAnWcTo6Kh13UsyuMjv91tjbrFY1E9/+lN7RtgRFArW1tbss8zMzFhh3Os9G3c8NTVlrQQQVRqNhubm5nTt2jXTfYO6D0Ts0vTfdME4nZqaMggLmSjONbXRQqGgTCZjMF82m7WMivYHdMBgmkFNJlNst9sWVLF/BBpHR0d68OCBkUR4j729PavjQv4ZHh62/fN4PNa4iXOBzdhoNDQ7O6urV68a9bvdbpuThpjyjRf0MTrDw8OamppSqVTS7u6uZRZElTiG4eFhi3ygElLIY0zp4OCgBgYGVCgUtL29rVqtpkQiYXPKiTS4rDxE5Kg9Ho/JFriSHDB5AoGApqamDLskO6BHhka6crmsVqtlEVu5XLZsh8YzJsBd9nID0/T392tsbEwHBwdaXV01qRsictgkY2NjJmkC/loqlTQ4OKjZ2dlzkadbjyJCdKNDDiYRYbPZ1NbWlvx+v+LxuPUTQEek7wESBmwWsGXkX3gv1A7i8bgVefkFbMLAqcvuH/BoMBg0puHu7q7a7baJHfb19SmZTJoRBx/nO6NfxXx2pG7cTmYiOpwu9SkcMEwrnufCwoJGRkZMgYIsUTqTrBkdHbXMh8yf0dKhUOjcmO9EIqGRkRFtbm5a3w11mHA4/FYKB9IZjRUYOpVKqVgs6vDw0LJOgjeibZTEyaJh/QWDQS0tLRktmSwPQ0qfmTsZkhofatCVSkXPnj2Tz+cznTUo9TDUjo6OtLCwoGQyaVA1QcT09LS8Xq/ZAvq1IOMwbgPGGrAzNcu32T96+46OjrS3t2dZLQEFTpleKOqZnLXBwUFjf3GP6/WzAX6oPgwMDJxDEFw0Q5KxSIEJ+/v7dXx8bM4Ohtrt27c1PT0t6ZVAJjp7ZMUEnchjjY6Oand3V3t7e2o2m8bafVOVjTfKXNyuVzaMdI3shHkaNB9S2OOidrvdX8IPj46OrIYAywGjRMRLUw8RChQ90mlGe7K4yHDwwbVpJoJ1wcF3oT4KcaTaQGVIeVxmRSIRy8Lo/QgGg0b5rNVqyufz2traMtpzLBbT/v6+zciBXpjNZo3+CezAa7qNojgfhDnJ0nAkcPC93rPBTXx3HFun07HnwuVhOih4d6vVMs03V9cMjTiK/ezfZZfb50FhG+yfS0CQ4jZ90WiKwaS5DpYXBo2eE+olRPFkSy7Zwi3c40CHhoZ08+ZNuys8B/pngJmQBalUKqYbB7zBPlEX4ztifFy6/GUWAR+NcBBjYDAyP4R5QdJZjwsD7Pr7+016iHNJrxo0X+AopHAoeKM87nb0w47CoQwMDGhubs6CHs4OtUMM7Pb2tqrVqjUiSrJmWejpRPlkFJAy3gZWZPH8ee1ms2kTULPZrHZ3d82uwHijEx4NMKRhuHNHR0dGGGDkNQHv4OCgyW2VSiVzQshXEbzRb8h7A6seHh4apd7r9Rp9nABaOqNUuz1ebp+bi5BANLnIurBzITV28WUKwcxQ5+9TqZS+//3vKxwOn1OnpShEUY2NhV1ETQBmEsXWDz74QIlEQs+ePdOzZ8/O9SAQbU5OTuratWvWrOnz+fTw4UM9ffrU+lZ8Pp9pnZFCBoNB3blz51xtBUNEtOpinpddRNQ9PT0WvXHZv/rqK21ublrNaHp6Wr/zO7+jRCJhtOVUKmUq0RsbGzo+PrZsh0NE3YWGNfBYFIyJONAFazabSqVSZkBv3rx5rqP4yy+/1MOHD43Y4PF4tLKyYmSNcrmsWCymX///sfdmz41nWX7fFys3ECsJ7juZ+15r13RNT6t6FmnaGsmy9aLFkt/06Ef/BfoXpHD4QQ/WEqEY2TMhR1iO0fRUb7XnSjKTyX0BQYIgQBIAscMP7M/hRU5LykSW3/JGMKoykwSB+7v3LN/zPd/zN/6Gksmk0c4RhKxWq9bAiIhop4vPiUF360HPnz/X7u6uBQNzc3P6J//kn2hwcFA7Ozva3Ny0iJaeBFcmiEBJkl1AyAj9/f364IMPlEgkDEIgc+EenJ2daWhoSO+//74xz4LBoD7//HP9+te/NiZVIBAwQ40Rcs8fTJ1ms9kGg8DWo4+k0zU+Pm73SrqckeLz+bSysqKVlRX19/crHA5rcHBQH374oak67+3taWxszKDh58+fW72DYJN+sGQyaU2A4XBYXV1dmpqasjHhEBZcGj1aeaOjo217+PTpUy0tLamnp0eJREIej0ePHz82uLpavRhE+KMf/chYjASuODaYajjut13U4TDC5+fn+u6777S5uWmIzNTUlP6H/+F/0MDAgBXJYSxK0tbWlmWBNNUC4+GICTB7eno0Pz+v/v5+LS0taXl52XrlarWaBYizs7NGdKKG/ctf/lJfffWVwaper1dra2vWZxUIXEyl/eijjxSPx02sFngXBiU9cW9yBt8ocyFrcRvvgK3cIr6bKoP7UwDGENKZCxZNYcktXmJMKpWKGS4OCKwpagNoPb1aeCK74T24kgqv6g0Bn5CJuX0ZwGidLg6L+3tdiRa3QC5dzgeneIh0vnQRzboFV4qBbnHU/TPRNY6SAp7P5zO46rfJOvCZXd01AgIwcmBROnrpaXHp1O5Xp5cbo08THa/v0rHdvyMqA1LgPUuXZ9k9f1CY+V6eic/nM6aWS3vFUZN9v1rkZv/cLItLyjngc/C+kP8hi3L3ijv1NospjEBc7u/AkfG5cNRAZhSvuTtkQARE1Ok4Cy5hJxAItGlpsX9Qmgki3fEGfPFe3H3lntMe4NZ2cFxA25yJtyHjsNxxzNg3XhO40YXwcUIErHwe9hubhZ2Eoo4t4L5RWuCzcmY5SwSZr9oQPjMwOTahu7vbnu35+bkV/CGSwNblPZDxYQ++d+cSj8clybjryC2QWnOhK5WKScVTNxkfH2/rEbh+/bpBPru7uwoGgxbF831czFqtpi+++MLkTkgvp6amFAxeqPSSQtJUhPOiMbG/v9+gISLpVqtlEB4Xd3FxUS9fvjTJFDw7l4WH1Mki66DwBn5frVZND4xL4/P5tL6+bgq5H330kWV3gUBA169fVyQSMWVUt9cE5gkUwlqtZgrIGC+Px6Px8XF1d3fr5s2bmpmZscFhQDOuJARFXWRDeH9E72DRX375pR4+fGgH0efzGYWXZrxOF02ZHs/F2Fqyh1qtptnZWU1NTVkk29PTo83NTVN8vXnzptHlu7q6NDMzY3N7Dg8PrXcHQ0h2zrn4+c9/bjJDFMWp8SCHdHJyouXlZfn9fu3v7ysYDJqeGHTYUChkeHqz2dTq6qo5fjLtpaUlYxnxPjivMHk6XQsLC0ZSofCLk0MtHDq31+u1Bt6BgQFTDIAivbCwYOrY2WzWgiCcDGw61CDW1taMNVcoFNTV1aV79+6pp6dH09PTSiQSOjk50eHhoT0nWIAEZszgQWFhc3NTz549M4mnrq4ufffdd3ry5EkbdMlecp87XZyjQCBgJQGCr/v37+v69euSLoPFVCqlw8ND+f2Xg+Zgoc7Pz6u3t9dkX+LxuObm5tp6ZHider2uR48eqVKpWNuFz+cz3UYGz52fn2tlZcX6WLzeiz4sty+ROnRvb6+Wlpb05ZdfqlqtKpVKqVgs6uuvv9aTJ09suBnNk24P0ffuXND5wkhA+3MNsKuK7OolMRTr/PzcSAHDw8PW6ESRNhAIGH7reurDw8M2xVlSe+bQRyIRGxVMZCXJKKl8dXV1GaUXI0wEBJ64vb1t2luwgVysttOaC6KdwCJg/c1m0xrTyABfFQGEgYXsNXLxOFwOE9Een4tMDb48xWYgCIrLsVjMmgFhBXGYcHi8NxguGE4yGJzf+vq6dQjzWcBr3waSoLHPHaeNs6Iw6jbJQfgAjoWJhMFjiiaDvqhn0bBLPYZ+DkgfyOaQLVNfAvbjvCC3Q/QJHT8cDtvZlWT1PFQttra2rEMb4wo5w418O1lAbxTBMV7NZtO0r3AKRLW1Ws0YnGioSWqb7EljK/JOr0bK1GHIyGgXSCaTVhxPJBKWBbkNpmTZNJTCSo1Gowal85rUpQiSCBBfZZx2uuLxuEGhoDdkk0zoJCjhbkqy5w6lHyJSLBazPjTIKJBpYGeB8JBNcI8IHiEphEIhO8+8R1Afdw8CgYASiYTi8biRqLjzPp9P6XRam5ubGhgYsEZhN+CXXt8GvlHNhaj74OCgjdfupmnAWy5EAWcbb7+ysmIOgzQSOjPpNNQ8ScZQImvCkDabTe3s7Ghra8t0e6AeVioVe6gYN+RUWq0LvRwiLMaswuSAJkra6fP5TJqlU+eClMjW1pYV/HAC9OW4WCldu8Vi0YqnGNWHDx/qxYsXbb0+XB53rykAE5lns1nrdcDJbm9v2wjrK1eumDNC3I6mL2BPHBX1p3q9birNzWazrSOeJkC//0JL6W2YOmRBh4eHxhKDaDA+Pm7Pko5zFrUyIs5Go2EsJYIOF8ogQDo5OVE6nbZgJpFItJ0/ovydnR3t7OxYBA57rlgsKh6P22AnoCjkVhjbzFmkCRiKPuKrwB3Ab2+zOIOpVEobGxuWoWOEMNxMJ0SxnGzXLd6vrKwY3ZuMhT2ENAKLkF6evr4+HR8fG70WssL29rbVKxYWFoyCC/UXhWDgLxoL6VVrtVptJA1my9PgyN3AjnTKuON3pdNpUxiWZEQC6jywL6kpuYxAvlZWVsyJkxnwGYENaWzGmSBtVCqVjPHl8/msJhYKhTQxMaFms2lj5uPxuGkSkgEymjubzbaJzeIU+d5YLGZ9bwQZb3KHX9u5uM10qVSqLW0Cl4Nih4wD0Tk/R0oHG4axn2CKrzqXVCqlYDCo0dFRxeNxZTIZSZeSLs1m05hf169fN+0kONvhcNgGgVGvOTw8bGOySDJ4h6Y7BjMBR0jS8PCw0R87Wfz+nZ0dPX361CLorq4uk81waa803wFlYSTr9br29/fVaDQ0OztrYnRcIKLN/f19vXz50uCHRCJhGZMkg7l2dnaUz+d17do1ffLJJzo/P9eXX36pbDariYkJg0O4uGRARGV07XI46eadmJgwtk6r1dLk5KQWFhbeyrm0Wheio4wGICMYHh62iNvFnXGUBBLAhEtLSzo7O9P8/LyuXLnS1lwHEy6VSmlpaUl+v1+3bt2yIWzAwbDrnj17pt3dXd2+fVu3bt1SvV7X8vKyisWipqenNTExYQa6XC7r4ODAJl8SRcPAAUKMxWKmkkD0jyLG2/S5cBc5G2T+bmTb1dWl0dFRU9iFvAGVm+cMc3Jubk7z8/N2/iAloGC+ublpgooDAwOq1WpG7OD3bm5u6vDwULdv39b9+/ctsMxmsyaZQsDEGSQTJTNCXBHnEo/HDTonGxobG9P09HTHe0h2vL+/b0PTuEfSRcCGY0OmhaxUuqxf0F9EiwM2kwZHvvfs7Eyrq6sKBAK6ceOGYrGYdeKjYODxeLS8vKz9/X3duHFDd+/eNWZmsVjU8PCwBgcHLRus1+smdosKCc6FhICA4VUbmEwmNTMz89rZ3xtpi1FsGhoasqiHzIX0FeFKvDDFZ1f2BW9Jgw74Nf+Oo2L+NpGRS4cm/UQ1lTQa6Alp9EgkYg1ebBz6UsAfcLz53UAUwWDQ6LX8XacHEwG/aDSqa9euWZqJY5Bk0TR7CcRHAZXCG3IuzWZT+Xy+bUQxBbdoNKqFhQWriYGF02PEkDbo3a4eGbWFeDxuBIeDgwOLavz+i1kSOFqgEBe6cTuQvV6vzdTpdP94fkj/4PBgyAG10HzG5ebvyGLpJ8Fwc1k5E5zdUCikubk5+6y9vb0G08LGI3tyv3Ak9A7QY5HJZNp6rSjyktlDleWz0BMG9RcBxLdxLog9hkIhLSwsSLqEOF4lwrgLGJA+LRwInz+TyRjU6vZfRSIRM0YEckCm0Lq5f2Qq6IwdHR3Z6yJ/Qx8btPCBgQGTPXIJRThqDCbQLg7vbe4w+4dCM3eTAIV7KumvZZpkoGQpBEJAlNhRoNne3t7fagNdvURKFQQv3AtGaODsuOucW7/fb3Aye+bq3xGY4Zz5PdR4X2e9tnN5/PixvF6vxsfHNTs7a86jXq8bM4OIgQtVKpU0MTFhip68aWZHQMfkgHBoAoFA25hNXh95FBxarXYxI3p/f98aharVqjY2NkxmmvkYL1++lHTR2MYchGDwYqbB119/bQdHkjWIdnV16cMPP7SRxHSE//jHP37dbbPFIKlbt27pj//4j3V0dKTV1VXLSHDEaBRx4PiKRCIaGxtTvV7X+vq66WetrKyYXhrO3u/3a3Jy0lJkIhVmiZTLZRvdy7AsUmok9TOZjGWnqVRKv/rVr9RoNPTBBx9oenpa4+PjGhoaUqFQ0JMnT5TL5QzqACP2+/3W4LW7u2v79/f+3t974/1bXFyU1+vV1atX9emnn1p9jAtWKBRsRk65XNbOzo5arZbi8bhBdQMDA5KkoaEhGx27vLysRCJhc1/AuycmJvTjH/9YHs/lHPuenh5zUG70DDnj5OTEshOyETLp5eVlSdLdu3dtOF0oFFKxWDR1ZrdYDAUcJef9/X2jgf70pz994/2TLu/wvXv39JOf/ESZTEbLy8vmNIEAMUDAM8DE3d3dNoRvd3fX6kzb29saHBzURx99ZL0d9frFrPvJyUnrlyoWi9bn0Wq1rF9jZ2fHYJ3x8XEVCgU9fPjQYF3qKw8fPlSj0dB7772nkZERU2QoFAp6/PixKVUDD+/s7CgYDGpwcFB9fX026rrVaunv/t2/+8b7t7q6ajbw7t271mvj1k9Bbwh6IWuAStDAzZAvILZyuWyZFmcwmUzqo48+soz9/PzcYMxWq2U9fwyrQ8KfMebUbaULm/by5Us1m01dvXpVyWRS4+PjVm54/Pixcrmcms2mqaZvb29b02gwGNT+/r6RoP7xP/7H/839em3nQrEX9grpHhmEW+whHSTNkmSMIzeiIFJ8FXsk8oFVw6wJFzrj+90vinrMquC1gN1YFLZgpLgZEam9Ox+EzwMk0MmisA2rhkI8v4/6lFsQpJYlyRqw6Ouh5kG0/Grhl0Ifkbg76lm6HD/s6o9Rr3E1oUjjwY95pnwO+pXcaAbmIJ/B7YPodAGBQNk8Pz+37I73SvbEuYKK/GpE6Srj8vkJlNhHYEsgoFdp6e755vmxf/xu/g3jw3PFiHO+gSbcLKxUKqmrq8ugDM7129BpadoDGaCp9VXKMzRVvjhXgUDAnIvbTsDnftUpgW64zaquA2PvOcN8RmqL7thyaMcElaAonMHf1uSNDeAz8B46XeVy2e4sKAKfhXPB832VXcoZpJZKA7DbkuF+sU/sH7AWNtDNmt0smn3jy31v7L/bJAnZym1pcO88QS+ssTfp9Xtt58Jm7ezsWMEc6MG9wKTwDHA6Pz/X1taWNekRZUIjdQcx1Wo1K8AdHBxY0X95edlSPLj6ZC90rtPIxAPo7e3VyMiIrl69qng8bpudTqd1cHBgjBNJpnC6vr5uDxLYhM9Ch3CnzoUD8/jxY62trdm8Bw6a20tQLBa1tramcrlsETUqArVazab/uQ1rZCCwmGhwLRQK+vbbb5XJZKwmQc2gu7vb6jCBQMAiJqAkdMQCgYB1FOdyOX333XcaGRmxSBo1hlQq1ZbBUGCHDkrzXieLBr2lpSWjTcIWcpUVyCbW1tZM/NDv92tubs4IC4uLi6bjxIwh1/B0dXUpm83qV7/6lUXW7kwVMkxJxkgjUsaotVotDQ0N6c6dOwanAsscHBxoZGTEBtiNjo5qcHDQsnrXIXNXgsGgJiYmOt4/6VLaf2lpSRsbG1Zbgi3W1dVl9al8Pq/NzU2DnPP5vCYmJjQ+Pi6Px2PSMYFAQBMTE+rq6rK2AiL1dDpt5I/Hjx8rm81aWwDOirsG8QHCAGdweHhY09PT6u7utrlRx8fHdn/cyYtDQ0P2rLARblc8Rf5OYTFgo5WVFTtf2WxWkkyGiudcKpW0ublpTcV9fX0aGxvTxMSEZbOHh4dqtVo2uyabzapQKNgdPjk50cOHD3V+fq7nz5+bGCx1OIIlVL2liwyf2pjH41EymdStW7dM1YNAYHd3V9lsVqlUSl7vhfp5IpFQrVYz+w56wh2Cafba5+11v5GIKZfL2S93h9sEAhey0+DM8NndXglegw8Phk8nqBs5UojN5/N6/Pixjo6ONDExYfAXy+u9kCyv1Wra3t5uK0pFo1ETqWSAD4NywHHp7keqI51OtzGIKCTyQDtdZHAMP6Jw7PF4FIvF1NPTY1RPBjUReZB5sE88eGaGwyxxVVOhm+bzeT179kzpdFqhUMjgIepmQJGuGgFOob+/X/F4XI1GQ+Pj4zo9PdX6+rpyuZxFO11dXYpEIgqFQpJk74GIEacMRNbpxSbbYDomz8Xj8VhdDNz67OxMm5ubJmlOPxQ4//Hxsfb29hSJRBSJRCwK5TP5/X4LKgiOuGicNxdnJ/OmLkSWHIlErJ+ImsLy8rIODg4kyWo5SJfs7Oy0FcZ57gzLghra6aL4vbe3Zxg9Z5uMD2eWz+eVyWSMvt1oNGzqI1FtPp9XMplUIpEwhpd0QRtHwp8gZ3Fx0ZQm6L4Ph8NmG9B6IzjEeEYiEXO8yWRSp6enNsmSxta+vj5NTk4a05IggSzQrZUhP9/JIivDCcAqBCqj348ayNbWlmUTjCnhGRSLReVyOft72HioC6BcwhC3ly9fKpfLWRsFNSf2CUcDw4+sqL+/X6Ojo/L7/TYtk7NIQBYKhXTlyhX19vZqa2tL0qUemt/vt6wUNuv3zhZD3RU9oZ6eHsXjcZMPAGKq1Wrq6urS3bt32zrB3cI4b85NlSlud3d3WyqIQbp3755qtZrxs2u1S6FBfpYaCsaGov/Lly/tIELNY04ExptGJw6NdMlbl2Qd+2+TUsM2AtZDQBMmkDt8CGyb9wHmDdyEQYN5QybiOkWMZDgc1gcffGB8dpdAQEEcaRhgv6GhITu4BwcHyv9mPg+MGyRjyHQIGvL5vElaYCzQkUJ0sNMFow6lARwf0ZTbN5JIJOzC4lzGxsasBsKZcWEcqL4udZUMGOfjqjzwuTlzNOtKMl22RqOh1dVVFYtFg1nRYOvt7bV6DXAlxWyfz2fzjSBtEHC8TUGfcw8cRRYRCAQ0PDxsDcaw1j7++GNJ0sjIiEnhADkS0VJjcovOjIjAMXq9Xn300UemH8b+EAgCSXInW62WxsfHLSBDdRtYDgSBgBSyCE2DTNQcHBy0Qj/GPp1OS5L+zt/5O2+8f0BwPDNsYFdXl8bGxqyXBSYqGRpivGS7rqIAWSGN5NCAMeIoY9++fdtsIhAVd9KFCaGvozjh9Xq1sbGhXC5nNUHmIXEOfD6fkXqOj4+t0ROnRDZGn83rrtd2LhMTE2o0GqYjFovFdP36dfX19dnBTKVS2tnZUSwW03vvvWeXCKiM2efAaK4i8eDgoGHBqLFSaP7www8ViUTs0p+enloDEBCCJDMSpJn5fF4PHz40DNvnuxgZEI1Gtbe3p9XVVUmXcy5SqZSOjo4UjUZteJQ7OOrg4KBjWCyZTFpWRuGPRjkyF2od4XBYCwsLlpmQEdK9TLpPZ3I0GtXo6KgZBxwL0eFHH31kOm9ELi9evDD4AfYJkdHMzIz6+vpUq9UMGgFqmJ+ftyL/2tqams2mHbqjoyNzdjgnqM6vDnZ60zUzM2PkhGw2q3g8runp6bbzd3h4qFQqpUgkort37xpLjLEPKCK40jQYPC40Aqb0pni9XnNeRIgHBwf64osvDMIgoMHZ0byXy+X06NGjtubf2dlZ9ff3m7adJIv4GcmcSCSMYr69vW0wEBBMpwtKKiQSxk8Q0ff19RkykUgk9NFHHymRSFiT48HBgWnL0edGUToSiejKlSvWoErBWrpoPvz0008VDoetyI0mIT0gLtW9p6dHV69eVW9vr7LZrB49emT1lVAoZFp529vbdo6BE/f29pTP500jD9Vfuv/RoPvn//yfv/H+oQLNGQ6HwxoZGbHfFQ6HlclklE6nbVQASAGN3oeHh39NriaXyykajVr2QzaDKgH6dv39/YYIHB0d6fHjxwbXUrvG3mIDT05O9OjRI52fnxuUPj09barYiIKm02lVq1Xt7+/r+PhYQ0NDWlhYUCAQsCZiPtvrOpjXdi4YcdJYSRbp4jkxeuhZUQCTZDUPDhMek25lUnPUUt3OUgqaeG1wbaI8InkgNuAEDIlbFASqIauiZiRdkg4wuGQAbk2pU+P4aoGP9LnZbFrDJg+NqJqCHUU6t+eFvaU7FzzdnTjJRXAbuniWPAsidbIlnq3bzIWj4r25KTeRPxTN6G/mwFOzoj/KPQtvs4iYoU4ChblNqW5073Z8Q7XmPUNK6O3ttf1jbynAu8VToF1gB84wTaZE7hRpeb/sOdkMmQqqF2TZrnEAvwcRcIvVnS5XvoO7gKKGdNl3wv6RVVBod5W4we5hMqK7JV2O4sWIAuWSdfKaZHR8dmAw7p5Lb+cMcv+xPaAcECzc4XAMJ6THjM/VaYD4Kimo2Wy2NR/yutgN97PzWd07XKvVrGjvnkGCboJnnIxLG4ZIQfYCWYDeFHf/sJuulhnkEOBkMkeQI/p3+DnO/5soRby2c4EW6PV6jb72y1/+Ul1dXfrggw9MEhpZkqdPn1qxFUyayHx3d1cnJyeanp42zS0O/sbGhorFog0rajabNtuC1DKXy9nfITM9MTGhGzduqFwu6+nTpxa9gMOy2fv7+9YdzewZNisYDFpnOUweGCfMDOl0uSq6wHo0stE5DE/95OREi4uLxubo6emxjmdohplMRnfu3NG9e/fssNXrdW1tbSmTySgWi2lkZESVSkVff/21Go2G7d/h4aHW1tZ0fn5uDaoTExP64IMPVCqV9O233+r4+FhjY2MaGRlRvV63rmN+dnR01KjiUKn7+/tN94n6ClDB3t6eNjY23iitdhfKCpAHeM4YYbJTSVaER40ZFWqf70JdmGyZ8bcw6zhru7u7bfImEAdoEGXkdblctvEEsVhMc3NzqtVqWl1dVaFQUCQS0cTEhI3vrdVqOjg40NHRkWWnzWbTIFuYgJxbj+dCA25wcNBUMd7GuaTTaaur1OsXWnwbGxsG4VATAL5eXFw0KIo+HyDm7e1tpdNp3b17Vw8ePGijZy8uLur4+FiDg4OanJxUtVrVl19+2SYHdXx8rGfPnqlWq2l8fFyxWExTU1O6efOm6vW6qXj09/drfHzc3le9Xtfq6qoymYxGR0eNJEQfEL019N3gSF1GaqfOhcyR14PeS5Y7NjZmz7JQKNhYZpfqTWCcSqWUzWZ1/fp1Xb9+3Wp4rVZLa2trZr+Ad/nd0WhUsVjMZFpKpZLNw5mdndV7772nSqWiJ0+eKJ/PW5sCRBd6qHZ2doyO3GhcNEITLECuwHaOjo7as8ORvs56bedCQZUol+Kz3+/XycmJRdDQRGn0cwv2RJCwyPx+vxWM87+Z8MdESVgRkowkQJQHtAP2jsQIBcJSqaTj42NrsnIXETwyL0QY/BdjRUQMFEc00OnBJJvgwVSrVXug1FFcCjIRJRxzojMgKkRBh4aGVK/XrcheKBSs0Ympe8izABtCqCB6gYOfTCbtkgJ1Ea3QX8TcjmQy2cb6qdVqZoyp69DchkGDP9/JImrk/JXLZZOocSNBSUZ3p9ZDNzzUXp4FZAQidmqKpP6wCTGanAteG8kUspfe3l57H6VSSZFIxDI36ZIOSsQNhs/7po+GCB3aNZ+RWkWni9/N+6FPDOzdbSfgToK30zzZaDQsAkdEFp1ASDoQY/x+v82HZxokJArgZjJk2ISDg4PWaV8sFs2xuaQgIGKYfmStZEVE6tgdsnM3aOx0/zjvoDN0uRPEUI+RZLJDrlySz3epwUjNc2BgwDKcarVqpAXKCpLaGkK7u7ttv6kDgzy4ShzFYtHk+10yEHVUskSSAEk2roRs0e0/RIfvdffvjbTFpL+eOgNFnJ6eKpfLWdGJywOV1oWyjo6ODGqAEsrmcTigxPn9fg0PD2t0dNTE1Oh7qVQqmpqaMhmapaUl48IT7WezWUshYWaBnYId41Aw7mwuqT0Ho1PHIl3SGIlKI5GIsYRgdAEXdHV1aWBgwDSswGuJfin8V6tVa67a29szdonbrYs+GMQBDB46b4ODg+rv79fZ2Zl+9rOf2ecFq6bByyVQRKNRZTIZ/af/9J+MlUfxXrqE9Vy5GAaLvQ2VW5IpOUSjUU1PT0u6uHjQgKmhAFENDQ1Z8ynQDE5DumzQxdEfHx8bKYKC/cTEhMEO1LX4uZGREZOVefz4sXWcEyjBAiKogRTAM8e5EDhB3cZxUSeCIv42zoXMm/82Gg1NTk7K778YYraysmLoArJECExGIhFzvPV63e6QJO3v76tYLGp3d9fILwRjsAWRTuIMEolXKhXbw0KhoK+//tpYZtQj3D4pnsnMzIzOz8/1V3/1V9ZtDsPq1f4jV8mde9jJItgl+wLGwrEx9O/8/NyyQeSJurq6rDbEoDhaA4DAoAtTe3MJUtC9Y7GY3bf9/X2dn5+b4vbJyYm+++47C6rK5YuZW0DsyOdwhyuVio0jZ8/cXiZsKY4QGf7vnS2GB3V7JYhEuUjHx8c6Pj5WNBrV3bt3jZUA7ffk5ESlUsmgEh4I8BNGCQyQvo35+XmjJDJ8h81Drp4CPQaM6JYIHEeSTCYVi8Wso9p1LpLanItbr6D20OlC3gM6MNF9rVazLl2irUgkYoU9FA7o0KZTnJ4XtNLW19fbZCBwLr29vZqcnLQMDwPJ94BLZzIZLS0tSZLVXqhREBA0m00NDw8rEoloa2tLS0tL6u3t1bVr1wxSQYUBQ5/JZMzBdAqJ8VzIHKhJgLfncjkzQgQtUI8HBgYMxiXKBAKTZGq9L168ULFYtCiPLBWo16Ufk0lUq1W72JlMRmtraxaF+/1+qx3i1Pg3xFKhJBMJDw4OKhaLWbMazplsyJU46WThVCAtEMmj+kDPC8aHwV1Q11OplPb29tRqteyM0D0ODAQEiXPhuVGsBlok2CiXy1bnPDo60srKSlsQgqMFWvR4PLp27ZqSyaRevnyphw8fqru7W9euXTM2G7UG7Mn5+bnto1sbedOFI4GmT6CIfaE4DiMLcsf09LSGhoZs0iyoD3YGMdiNjQ2DrgjGCSbHxsaMuk59a2JiwogZPT09xigkWCeLdLN4j8ejkZGRtmCBs+Hz+UwtHdIFgRf2gmfyOuu1rSV4G5Q0pLIxwhw4jGc8HrdOdPoRMA4YKLeLmtfncDP7AvFDGtDonwGqYhoePSuS7GBTpDo5OdH29rYdNv4LSYCD4zbAwQIim+H/O138HgqisF4oKLvFU7egls1mlc/njdLZ19enubk5jY6OWpcvxoCDV6lULNrECdEMx/M4PT21KJUIk5QY1hOQ4PHxsWVN5XLZCosUTVFYZv/Qb6vVaqZnhS5Vp4tnCxEBphO1Mwwy8Buf3S0aU/gcHR21ZjAyBC4ohpeaFeQBIAtJVncAXgPegVhB0x5d47lczlhCEF5gj0HK4HspPBM98trSZeTc6QL6xVDQn+TxeDQzM2NZB2cQWJlmXGj63d3dJi0ENVmSPQf6Itw5Sm53eLVaNeor2QT9FGRu7JNLbuA+wyiDMo2xf3UkM8EHxl/SX4PJ32RxBnEG0J25D/xbPp+3MgGNqXxW3geUdKCqVutCD5D312q1NDAwYFNhsb0gC7lczvaOQES6HF6HIDBIEzJZwJqBQMAgPHefYX82m00LtFxpLPp0Xme9tnOhUerw8FBbW1u6du2a7t+/b1E4XbvZbNY425L05Zdfanl5WYODg5qbm1NfX5/ee+899fT06MWLF1pcXLR6CfztVqulZDKpubk5NRoN7e7u6vDw0Ga2UB8IBoPa3d3V6empYrGY0e8GBgYMPgkEAlpdXdXGxoYx1XhAJycnBkEB6xwdHSkSiZgwI0b/TVgSv20R4aRSKWUyGc3MzOjq1asmMBmLxbS3t2d6PrFYTJL08OFDvXz5UgMDA/Z9H3/8sfr7+/Xw4UN98803CgaDJrJIhhCPxw3vPjk5seiDKJoRqaTDjFFmXjcMPq/Xq5cvX+rx48fWcIejm56etpG0PT092tvbUzab1cjIiBYWFlSv17Wzs2PFc5xBJ4vzt7Kyop2dHd2+fdtGaYdCIQWDQaVSKds/9OzYP/f8XblyRX19fVpcXNTTp0+NIgz0xWyNmZkZ1et1bW5umtI28MD+/r7tZ6PRMEJJf3+/UaS5Fy9evNA333xjMBkBCz0JExMT1hV/dnZmzZeNRkMHBwcGU4KLd7qoWWQyGeVyOc3Nzen+/fsKh8N677331N3drePjYx0dHdlgOEn6xS9+oWfPnhlFPxKJaGFhQZFIREtLS3r69KkNAfT5fAbroEKAsge9KtDoob8CYaEV5nbsE92vra3ZeGPgp3q9rpGREYVCIY2NjRk0dHh4qMHBQc3MzFgmC8HgbTr0BwYG1Gg09OzZM62vr+vOnTv60Y9+ZIScnp6etjMIYejRo0daX1+3OUy9vb26d++ewuGwFhcXtbi4qGAwqPn5eWtUpJhPTXV3d9dgM+4wKifAVYyJRlgTm8O9+frrr62HhX2v1S7GjDBb5+DgwKjlnMHDw0NLAt4ke35t50Jxx43gMbgunZVGNLw5l7Gvr68NsmKYFOtV+h6/i4gFeIqNpBBNtM+f+X4OJZEnv4MNBfKgcM9r8DtfXWRUnS4iU/ZRku0HjDEK1DixVqtlcCIRJvUsYKhqtWoRCs1lHAQuLRETshRAVq5WmCRzxhR93ef9Ki2XiJHMErYTkSLvyd3LV2nCb7KgalMLIWqm6I1xBu5xz1+hUDDIxIU12D8+t0vhdCm7nDEuNoaN7yOzIKBxqak8B/aHDIoCtQvB8SVdjhjgd1DLfJvFs3LrpuwjytrUW3hf7h6SecJiJFODpspncgMIPgPnjwDI1WHjedIISGZHNM7rcB7JRGCQuWfwv3ZHXZvSyYKt5qI17AdzXHAMwN7UdoHgQUE4g5B1XMiVc+SeAZcSTr2Z+833YNN+2/5z5tzzLV3aJfesua/lvsabUuFf+7TiSGgWCgaDFjUnk0mFQiEb2RkKhczJ8GZxMq1Wy2TOgWSgYxJlgw8eHh6aLAkfnNQNaiZslWAwqNPTU52fn2t9fV1nZ2eG79brdSviUvyOxWK6e/euyuWy6QTF43FrXsOhAV9QGOx0jY6OSrqIfnCUT548MSVpv9+vTCZjlG93xgwS5ThHspDDw0MdHh7awQ4GL0brYmTBZrmwr4pc0mcUDAZNQieTyei7776z+kNvb68x02hkxUAB3aBnxEEtlUpaX183o+L3+03Gv1NokSF0k5OTBsP96le/UigU0v379zU0NNQm007U6/YmSDJ4wePx2GgGOprRB2PsLMVufg6IDdhKkhkBIr9SqaQ/+7M/MyppV1dXm9QRRh0IuVqtan19XdVq1bKwZrNp8vKwkOj/eps1OTmpVqulkZERy1rJOqQLqGZ/f18vXrwwNWEg01gsZkKe1IJAK5AeIiDJ5XIGHZ2enkqSwXv07RDcSDLlbKaN5vN5ffXVVwa/A4Ex+ArjSYd8tVrVw4cPDc4DMj48PLQMEUr99vZ2x2dwZGTEAtDx8XEFg0F9++23CoVCptRMw+urRh64yoXsXZFJ4PtSqaSdnR0LGrG71LgIEF/tYeF7IVY9ffq0rd+t0WhoZGTE1DUgVySTSVUqFbOBNANjT4HCsRv/v3ToS7JOZDrGt7e3zdhEo1FzLkTELnWX7ABGB/iyJPPu0Ayh7hWLxTZZCYwavHZ6blALhgL95MkTS43j8bjC4bDGx8eNRgpFb3R0VPl83oQdY7GYySLAjuJzu7htJwvnhgHe2trS8vKyurq6lMvl7PPigPldXA4yMIwjF5zRzrCRstmsDg8PLXMAIkJXi+gfqiE1n+7ubqPwPn/+XIeHhzaSlwgRWIUohiIiHbzoTFWrF7NvcI4ULXGYnSxwZ6Tf6fdBGy4UChkriGDmt+HDZHbAezTBIbNBP04sFtPp6akZWVQmiOCpBxJIUTc5PT3V06dPtb29bUxJskqiepoj+R3Hx8c6OTlpg0MhA3R6sX/b4rXJ2FOplNbX1xUIBIw0g6YYGSz3Dko0hgqCDI7PbRzFSOLAyJCkS30uzqLH4zEkAyeHUOP+/r6dwXA4bFNRKXTT9NxsNk0z8Pr169aXQT8PDKhcLqfj4+OOzyDOjzpfNpu1iZ7T09Pq7+833UAyNM4c980lC7E/2EFqKJQAqGF2d3frypUrikQihkK4NWxsCq/BGAcGukmywJn6F71rdOofHR3ZZMpkMilJRkYhyCY4fd312s5lb2/P5Fm6u7utcAkMhTyIO1gJHJVGNebEczhwIrAqvF6vzTGHIVKpVKwozDz539YvAvXP7/frypUrFklycAcGBqzZjtdGtZWiFhpF5XLZ+kboSXC71DtZh4eHxhaje50aBIO4arUL7TPpkpHh8/nMSHFJ3QfMZ0ShAHYZ/UI0VrZaLY2NjRktl4sHWSCRSCgWi5l6K5RbvlxhSi7N2dmZGXNJ1gNDJCbJ6I1EnZ0uxsriMClakvFhfAcHB612R62HLmi3q5rCNXsNFDE3N2f1HZ4J0S5kFRe6hH4PnRbCAFk154asDyMAAYEvzh7Pluyy0WiY4YVk0ulKpVJ2R4mEucMMM4MazJ4RIFLc5ay9GvzgJGAcBQIX6t4wjo6OjlSr1TQ/P6/JyUlVKhVrE8AR0HRLHQpbwx3m2VLMxvHhpOjJYeQxagzUF3p7ezUzM9Px/q2trdkZ5FlSK4aw4fF4rJgONMv7djvkuXfU2Vw2LmSofD5vBJaVlRUj2yCPRRZJ8EEg3d3drenpabubEFa4CzD1IFZAiiKbR5bILTGgP/gmdefXdi5ra2vyeDyamJiwLnY6YPGmyLS7Ec3Y2JimpqaMqUTE3WhcTFREZA6skkhwd3dXi4uLOj091cuXL1UoFPTRRx+1dfST6dClOjU1ZRecKICGyeHhYYPdYEttbW0Zdun3+40HzkWXLjTBEI5MJpMdX+7t7W15vV4NDQ0ZG2tqasoKxi9fvtTU1JSuXLnShoWzxxwGLovb/EhU2dPTYxpjm5ub5rxfvHih09NTGzhGhM8zgc2FgZ2fn7eIuV6/UEOFoHF4eGhsEi45GR77ChTkyk5AS+90/7hcyNMTtTWbTaPITk1NaX5+3pxmvV7X6Oio5ufnLaDgzEiX8kVkYRQ2A4GA9vb2tLi4qLOzM62tralQKOjWrVs2UhmcP51OG8WTYU+zs7MGN1CfGhkZMeYdPV1ovZGBMt4XjJsAJB6PWzH6bSR0NjY2DHdHAJIRwru7u9rc3NTY2JhmZmbaam1Akpw9SW3NqJAXyLAXFhY0PDystbU1ffHFFzo9PbUxE+Pj4zbgi8iYxmqcdl9fnxYWFtoi9FAopJGREfszir2cUf4euA41AZeVNzY2ptnZ2Y73kGFro6OjSiaT8vv9pti8s7OjjY0Nzc7O6urVq5JkdbnR0VGNjIxYawTwc6vVsvskyRo0cfw7OztKpVIqFAp68eKFSqWSjYvG7gLXl8tlE3OlDon9IwCAnQa8C4EJmI3zyaA7sizGviNI+71TkYFlyDiIzNgU6hLUUYBfyAo4QBjKZrNpzC66wIliePh0g+IwSJGh07kRPNE4y9UEAwpxC3BAGURArx64V//MZ+z0YBKZVCoV5XI5SWozvpKMBvhqQQ4Ygb2Fhk2UQ4QsXSoQQI1tNpttUizUCoAgwH+ldk0oisjADxRU2cPu7u42WEy67NfgefKZvo/9I8LmfbqHH2PsZmRErUBRwAWtVsveH0xBmHFcWKi0dMRz/ug/cokJUF7JfAkKXIKKdAkHUYMMBAIGs7jzMtxOeH4eIsDbFKOly4ibZlGIH/xu6SJoA07hd/HMCXAktelMofZLNA88XS6XLeOK/kapHDFRsiG3wOxmGbye+/fYBs4UGXWz2bTAiLvMe3EL2W59opPlogdkWi48xR5xzrA57KNLSCKL6e3tbWPGAT9hI/v7++Xz+Wx0CfRugut6vW71WOnybpCJSJdDzKA8u/vnZtRuDcd9Jq5szpuQcl7buYyNjanZvJgKubu7a7Q6ImZkYPb39xUIBOxC0p3sMg4YTDQzM2OSIysrKyoUClb0DQQCRiUcHx9XrVbT1atXdeXKFdM2Ao8kGn327Jm8Xq/BWG7KyINuNi8UiaempvTgwYO2OhHFRukyM8Lg8OdOL/fVq1fVaDS0vLysJ0+eKJFIaG5urg3eyeVy+vbbb40RBhPHZcsFAgGjG0ajUX388ceW3lYqFT1//lxHR0dKJBI2HIuxq/fv39fs7Kx1lwNfcZBWVlbaGCNQb4FlIAXU63XNzs7qwYMHpu57enqqeDzeNhqAgr5rlDpdn3zyib3Hly9fmhaV22NQKpX06NGjNtgUowNM4vF4TNp8bGxMN27caGsUo6AfDoc1MTEhj8ej6elpNZtNjY+Pa2xszIbO1Wo1zczMGHFgc3PTYEvXSWPMPR6PQXLT09N6//33dXR0pI2NDYOQo9Fom5EFWgqFQqbs3elC2fzg4EDLy8s2jIuo1u/3K51O6+c//7kxoGC0YeipoRFdh8NhjY2NWdBZqVS0uLiow8NDI0W0Wi2rg9y7d8/01qgfplIpKx4z4x5nTF+W23hMABWJRHTt2jXlcjkbaw1RolartTnqVqv11lTuBw8eqNlsam1tTUtLS+rv7zcbCCmnVqtpaWlJjcalOCT7B2sM24aS9K1bt3R+fm6jx2mMDoVCunnzphqNhkZHR1WtVnX79m3dunXLbCC1QrK158+ftz0fgiWIFtKljM3IyIidQdTPUcCGbk+ghkgwz+F11hs1UfKgSGExQh6PxyJgxtHC8ACCsV/4m14CmuqohUiyFLfRaFgTknTJz6cxDkNFRAWjhSIjGRWHCifD/5PCM9/CLbTyem7xEiPhGq03XTCrYIW4OlFAUvQfEEVgtKhBUZ/CyFBnOj8/N5ihUCgok8m0zReBlQIeW6lU7PmxhzTJ4VAxjjT+Qcbg/QSDQQ0MDJhcD8/J1dIi+nL3r9NiaiwWM/gSZ+/SnYFKkK/nArhRL/vmji0YHBw0OQ4iUgqbZDScQ6ABd49c3SVeg3Pk1p2oUdBnRcSP3E9XV5dBc26xl2ZNN5rtdLlD0ZhqSGRNbY36iM/nsy5zHDRBAtkpkSzyTgQUTIl0GYs+n88aK3FYLg3XJc3w7Nwisktldlmc1HfdplUicJwLZCFes9MF81S6gFSBRiE+IPGCTiJ1ZzIqGH98biDFaDSqs7Mzk8Xi+7jfLiyOAjXkJiBt7iYTW7FfnB3OnktNBg3CbgLL0RBNBvPb7vHrrNd2Lmzq5OSkpqam2vjXFKTdhwgOCrUNMUkXu93c3NTu7q4Zf7dgTiEUB4UBffnypdVL6vV6GxY4MzOjavVCEbdUKlkB1tXV4ZISFcHh93g8Ojo60vn5uc3TkC7GhvL5XoU63mTxgCYnJw0iw6ATrYG7U0eBYgxTCUFFahvZbFY7OztGiKCZDO0ynD8XnymSYOD1el1DQ0MGawwMDKhSqWh7e9u64OkP2draUqPRMAFCnjPyKfV63QTx2L9ms6mHDx+aOuybRD2vLjLa4eFhk29BvA/2HIefWgIOAoYM0bE7vgBIj8AJJhhwhKS2GsnW1paKxaJSqZTq9brNBwoEAoarb25uqlAoKB6Pm9RQKpVStXo5U4ZFwdbr9erw8FDpdFrxeFyzs7PGgkK2hu71ThfPjbpfo9Gweg8yTEwoRNcOui9sKzIEDB71LvTefD6fyQ3F43GDwDiH6+vrOjg4sHku1WrVzji/t1arKZVK2R2Ox+NqNptG7EFdgswA2+IK5pK5N5tNfffdd0qlUhodHbXAopMFA5I6LJAR5wnWIVAy3ftQ0LEzrVZLmUymTV+M58roBumyr4a9q1Qq1tCL3E6j0bA7TL2LM1gsFg3KpY5MEM55hjRwdHSkSqWira0tUwWfnp5Wo9HQ8+fPlclkLCj/3jMXIv6xsTENDg7q5OREu7u7Oj8/t3GwbkMOtRaoy9ls1mQEiJ6QH6cQ7fbFgAOSOsOdZxImjIbbt2+bPPTc3JxOT0/1/PlzpdNpjYyMqK+vrw02QoSNGeyk2h6PR/l83iIuIJFHjx7Z97kaZG+6cM4jIyMaGxszHSUiMjKrVqtl9YxwOGxSJRxsRBrpC4IlcuPGDRPJc/tRiPyq1ap2d3e1trams7Mzk8ORZDBcLBYzBlg2mzU5mbOzM5OYZwwzGQy07UbjYlgYNSwIFF9++aUymUzbON9OFgq9aMNlMhkrciJkyr75fD6TLkGiBlXhUqmktbU1nZycWKSIygDRLlI64Ptunwl6a+4ICpw0EO+zZ8+UyWSsb8WFOii+sn+SLFrPZDIWgN27d8/ODc21vKdOF3AI9H3OINE22Sm1HwI3RGN3dnYMDuSs0psVjUZ148YNI8+goMH9I4rOZrNGS19dXVWj0dDdu3etVQC2KIPnZmZmNDIyYsEVhhCHT8aDvEo6nVYmk9HCwoI++OADNZtNHR4eanl52XqxOj2DuVxOXq/XzuDx8bEpf+DwCEDD4bDi8bixCwOBgDlA6q6QiaiPAvPShNnV1dVW86jVatrd3TWK+tHRUdv7Gx4e1tTUlLVXpFIpzc7OmtQW4raI1uZyOQtsCcwODg50cnKiK1eu6MMPP5QkLS0tWYCDCvXrrNd2Lngu0uFGo2HUYsbgEmW4jXtQP4FSpEscnOI8jUXSpX6SW7ijOx0nQBRAWg7em0qlzLjx2kS8bnrpFvn4LDCzIpGIhoaGVC5fyJNHo1FNTEwokUi0jT5+07W5udlGecUg8dCJ4MCMcWRutE0HvgttATMC+8Ce6+vrszHK9Kq4fQe8h1chiFarZT9HNsffAQPBTMFA0m+AVloikbCLw7Q+othO948MA7gBbSygCM5j9DfjtPk81AEwiDDD3O5vzp9LEoB8AOwDbIQSQCaTsUsPLk0RGzUKWFiVSsVooi4tFngC+Gx4eNj2ivdLhhGLxTQwMNDR3rEYBQzKwHME9oT2jM4a+0LPFw6ac0enOUrbbjDD/rpaYUTk3HH60xD6JAuBYUcmAIOOkR7Ad+5YYenCZuDYksmkwdDDw8OqVCoaHh5+qzuMIZYuyQ0ELyAirhoywTGwNMxV7rbbB0MfFBCzezZoukVQEhSHvjHO39nZmTKZTJs4MGzKZrNpdXO3T4hnAdljdHTU2HDYwEgkYixNZLFeZ722c1laWpLX61Uul1MikdDg4KANOyKaHR4etgKUOxfk9PTUDgdYM0wPqHwuuwdPj/EbGRlRq9WyJijwTgwbUQxzTIi4Dw4OlEqllEgkdPPmTYNIgsGgstms9vf3ValUDCu/efOm5ufnTXurXq9rcnLSmvTexGu/uj7//HODCRmARIGQouXw8LBu3LjRxqDZ29szvSlGqlJXCIfDikQibQ6cBqzx8XFNTExYXQJCQrPZtH0Ba5VkeK3H4zFIZnV1VS9evNDQ0JDu379vRrnRaNjYZwgSPp9P77//vm7evKl8Pq/NzU2Vy2WLet0BWJ2s7777Th6PxyAdtNaazaZh28PDwxofHzejhPQ9AQzvk34eV6ID7NxtSsPJvEpB397e1urqqmWEKEpQ9MS4rays6OHDhxoaGtKDBw+sbyMQCOjg4EDb29tmHD0ej+7evatr167p7OzM4OKrV6/qxo0b34u22OLiovW5EFlPT0+3MZuIfnG2rVbLCu5AhpKMqIGEPk6Lvh2cFc8cmBbCApF7pVKxIIHaSqt1IdqYSCS0s7OjtbU1JRIJ3b1710gGPp/PIm+ibr/frxs3bmhubs6y73q9rjt37ujWrVvWJd/pWl5etoALPbGrV6+2GeyxsTHNzc1JuhyASC8JARj9OATc1G5cyJ66HDWbyclJo/gXi0UdHR1ZMIMSNdCv3+/X+Pi4JicntbS0pMXFRU1MTOh3f/d327QgUZLnfvh8Pl29elUzMzPGAq3X65qYmNDk5KQhAd975kIWAcuIwp4kO4QUkrgsr1Jo3YvMZZYudYNc+jARKkU7CrEUJaFGu3pOfD/4LZkOKaar2UMUyr9zOMkCuDzua73NImWuVCrmOCEq8LBIiVutlkXjGC867Mm6XPq2S3d02V4USyEsYGi5nNAOeS2K5K5gIM8N7NjdT5wNUhXsKeQCNKfYP6KwThbnjf1wsy5e0yWSsH9uhzFRIRkK55PPJF1q3HGeCHbceiD7w+vwb2TNbrMk++fKf/Bn6gsYFDJAYLNarWbyJ9BL32aRIYHf0yDnUkyBxNjzer1uNG5ew+2B4Uy5FHSXGk4AwznDmXIuMJ5k5RAfXKq8e+YJPN09dVshCFrdrBKHLr3dTCZ+FvvA5+bMQCRw7RH3g7NB7Zbz8+od5ixyHl3tQFQ03P1j3zmDqJJDnHCDJPaZ90xNl/eIPWXgI88faI/3/707lytXrtiGnZycqK+v768VsRBZrNcvZmyQAZycnNgGeb1e8654XVRQe3p67EMhIdHT06ObN29aA9Cr/RNTU1MaGRlRPp+3wjsFMKAs0mmv16tUKqWzszMlk0mj9BHlQovM5/Pa3t5Wo3ExGhiY5W0u99jYmKRLQ8ioUwyc27ldr9d1fHxsBsbv9+vs7MyyR3orMpmMFhcXTSfNnVvv8Xi0vr6uYPBidDMaYRhdDMHQ0JCmpqZ0fHxs74cDSPTIxWfKZbFY1PDwsD755BMVCgVTTN7b2zNOPsVXaOf5fN5mwnSyULMlcgWXdyNDScZ+of4DGYTfCx4eCASsGB0Oh3X16lVzlq3WhYx+KpVSb2+v7t+/r1gsZlCSK0k0MTGhmZkZZTIZ7ezsWCZPhvCjH/3ILnWtVrNMdGxsTJ9++qmKxaKePHliGmL7+/vK5/NtMudEpEC8//Sf/tOO9nBqaqrtDPLaLiOIPapUKqY+TJ0T2JUgzOfzaW9vT3t7e0okEvrBD35gzDrqg9lsVt3d3bp9+7ZisZhyuZw1uBIsoWDMZ2dRuwNmgj1JfWhwcFAffvihTk5O9NVXX1m3O6rMzPghMIIw0ekZJCPBoVI7IfOTZPA0rNByuWw28OTkRNlsVoFAwLL5zc1NbW5uWs2KDF+SUd57e3tNqRxHgES+1+vVwsKCRkdHdXBwoK2trTZRz5GREQ0ODioYDCqfzxuxiTLAZ599prOzMz169MjIOYyhz2azhjj19PQok8kYxPY667Wdy8DAgBXHKF6BC7sG3XU0RDw0XeJcSPkYlUqd41VpjGw2a2k1xVpqDaxoNGrFQA4t7weckogRpgl9IBhdCr1g9Pl83qAyIjt34FMni4Y59gfIkP1zax/g9a5SMwU45EUoUu/u7ppDCIfDBo8B1XR3d2toaEjBYNBScT6Xx+OxOgWFZpdQgWQLF6lWq9kBHB0d1eTkpPL5vJaWltRsXjSAuoVrSca6wuB3erFhtHGGgAKpH3C5KYK655HPjaYdtYSTkxPt7OxocHBQ8/PzbfWWavVi0BlQKMwdN3PDgQwMDJjiAVBZq9UyowkuTr9LJpPRyMiIpqamjLlHtsLsFJ4FZz2fz9ugrk4XdTPOFoGNCwtKsiwJWRpgLlQOqLd0d3dbICZdqiWTnZVKJROypfZHrVS6NNKIt56cnLQFcTT+QlBxnzsw/NjYWFt9A7IO8JyktjuUTqc73kOkp05OTqwOhU0g++DccQch7Lgjj7mr3d3dyuVy2tjY0PDwsK5du9ZG0aaOwn6QibhfHo/HxmsAzbkZIOK9OELOZ61Ws7ES+XxeL168MFKEq+/ooioE36/bjvFGfS5QURmNeePGDUt3GaTjdin7fD4NDQ1pcHDQ+gcwXBTlSLf4GWSro9GoNSgx+5zoulwuKxaLWRrJg+7u7jbacaNx0XzJKFwOHhDR8fGxlpaW5PP5tLCwoIWFBTuUGCfeTzQatei404OZTCbVbDa1vr6uvb09a4wiSsQZY5jItnCQe3t7dvmI+iSZSjQyEX6/334X6bNb5Mbow4aD8VOr1ayXhPeQTCY1Pz9vjhCmi3TBnPnlL38pr9erqakpzczMWFFSkhlC5CwoxHbaJ8RnWl1dNVopjWtcAAwLuL3ffznmOJPJaHV1tY3d5vVeCJ+Gw2GDOihQc/7ohwInZ7YFdHwIDtRaqOE1Gg0lEgmbiYGhOT4+NsP9zTffGANucHCwrf5FsZYMiT6Kt+1zabVaVnNzC9yuceSOJhIJM4LBYFBHR0daX1+XJDOCkUjEsgv6UCRZfRNyALA2/Rzn5+d2h2mebDabpl4MnDk2Nqbh4WFJl3eYoXDpdFpffvmlPB6P5ufnTZiRQIo7Qr0NnbJO7zA2MJfLaWtrS9VqVZOTk20NpvSVsIfopI2PjyufzyuVSlnQA3uNaaZk2qgaMDCRvUaLjLkukUjE3htOn/kv9PeEw2FNTU2ZsnW1ejH9lyD7q6++ksfjsdqy6yDdwr3r8L/3gj79IgcHB3r8+LF138MYI5XDeHG5mYi4u7trzoXoEQwRBhrMBBrTkPjG8HK43WhckimIAn0hVx6Px3Xz5k1LTSECeL1eUw9OJpP6kz/5Ew0NDembb77R4uJiGx6NYB4Fyk6NI13MS0tLpvFE+kqEyOdEUBD9MWaZr6ystFGLYT41m01tbm6qr69P169f19jYmO2xdCmjUa/XTQqeSB34h94QKOL1+oUY471791SpVHR4eGjFxHq9rv39fX3xxRcaGRnRP/yH/1ATExMW0ZEt0HNC4xdZRSdrfHxc1WpVv/71r/XLX/5S9+7d04MHDyyDIFp7dWrexMSEksmkFTZpWqQGNjQ0ZBLwqGUDWeBUMLj0FqBSC3We5lb6XHDQDCgjI4EG6vNdiAeurq4qHo/rs88+UzKZVDqdtrML3EJGT93nbTIX2GpHR0e2F3Nzc+b0CaqAktAJ5Aw+efLESAjALmjfkf3TK4TadjQaNedPgJlOp82o+v1+Y4T19PRocnJS5XJZGxsbKpfLGhoa0vvvv2+RPL1JR0dH2t3d1ZMnT5RMJvX3//7f19jYmPb3921UB4FQMBg06SNqDJ0smkWBoz0ejz788EO7X9RWoHwDx6EPt7q6asxQ7n5XV1cbstBsNi1w4uebzaZBk9ls1uDnWCxmwRzo0Pj4uMrlsrEUUQGgwZ2yQ7lcViqV0rNnzzQ4OKg/+ZM/0cjIiPb29qwfhtojDkf6/8m5kCVIskPI+m0ezn0jrp7Pq5fj1eIQPwM84Rb9X03d/0uv6b4v0ml+j1uzAXukKPbqprlFNgxYp8st0rmp/3/pNfmdwImvEgrcfeDPGFV+F9AXf+f+HP/+6t+5e8AFwdG6dF32j8I6RVZ3r1/9LO4ZetPlspdc+ulvW+6eumfA/XeK2Lw/92fcfSey5ufcugT74P6d+/ndYu+rX5La9s99Vu6FduuMb3sGuTNuIf6/9r3u/eXrv/Q9bpHf/V18rlc7u9l/906wh+4+UCR399f9Geo27h1+9efd9/o261Ub+Or+uXfa/V6XHMP3vbpPriF3/44iOq/rZpav2kD3Wbjv2bUHr54zd/9cEtT3YfM8rbf56Xfr3Xq33q136936Lavzdt936916t96td+vd+i+sd87l3Xq33q1369363tc75/JuvVvv1rv1bn3v651zebferXfr3Xq3vvf1zrm8W+/Wu/VuvVvf+3rnXN6td+vderfere99vXMu79a79W69W+/W977eOZd36916t96td+t7X++cy7v1br1b79a79b2vd87l3Xq33q1369363tc75/JuvVvv1rv1bn3v651zebferXfr3Xq3vvf12qrI/+P/+D/a7JOJiQltbGzo888/V1dXl/7pP/2nunPnjk5PT21gF3PtV1ZWtLu7a0NoJNlwHyZFuqNic7mcisWi4vG4JiYmVCgU9POf/1zpdFpTU1OanJxUrVbTycmJPJ6Lee+Dg4OmIHp+fq719XUVi0VduXJFc3NzCgQCCofDOj8/15//+Z/bTOkrV66oq6tLoVDoryncouTKEDFXbfR//V//1zfe6H/0j/6RvF6vEomEYrGY9vf39eTJE/X19ekf/aN/ZNL25+fnOj8/1+7urgqFgp48eaKNjQ1Jss+YSCTU09PzWxWIu7q6TA69r69PlUpFKysrOj091eDgoAYHB23uvHQxzIsR0D09PapWq9rb2zO588HBQfX29ioWi6lSqegv/uIvtLKyoitXrpjkPaMOzs7ObB5FOBxWo9FQJpNRoVAw+XBJ+l/+l//ljffv008/VSAQ0AcffKCbN29qa2tLv/71r+Xz+fR7v/d7mp6eVigUUn9/vyqVig4ODlQqlfTy5Uvt7e3ZEDmfz6doNGqzZ5hfjvIxs0uGhoY0Pz+v09NT/d//9/+tnZ0dGwUhyV5renpayWTSlGcZSFer1RSJRBQOh23SarPZ1OPHj5VKpRSNRk3SHjVa5rqwarWaNjc3lcvlTKlZkv7ZP/tnb7x/0sUd9nq9NiMlnU5rcXFRPp9PH330kUZHRzU8PGyy7fv7+zbw7/z8XC9fvtTPf/5zNRoNzczM2HiMnp4e9fb2amRkRH6/X9lsVmdnZxoaGtLCwoJOTk70f/1f/5c2NjZMTTgajerq1avq7e1VJBJpG7/baDRUKBTUbDY1OzurqakpO7OVSkUvX760aZ8odzPWNxaLqb+/v20uyd7engqFgo1Fljq7w3/wB39g84uGh4e1t7enb7/9VsFgUH/8x3+shYUFU7p21bs3NjaUTqd1dnamg4MDGwXB3CDmKDGygDUwMKCJiQkVi0V9/vnnSqfTqlarqlQq6u/v19TUVNvobGbK8LuliwFnAwMDNqCsVqvpyZMn2tvbs5HWvb29mp6eVl9fX9sY6r6+PjUaDW1ubiqfz7cNwvsX/+Jf/Df367Wdy8zMjBky5jH88Ic/tENxcHCgnZ0dbWxsKBKJ6M6dO+rr61N/f7+mp6e1s7Oj7777zib0uQadw8HgrFqtpkajoePjYzUaDU1NTWlwcFBdXV02KItN3N/f18nJiXp7exUOh21aYDAY1OrqqpaWlhSNRjU5OSmv16tQKGQT33CEjP4cGBhQPB63oU4MLarVaurv77f5Hp0s5lowNCkUCunevXt22Pf395VOp7W7u2v719vbq6GhIe3t7SmdTmt5ednksRlH4O4fDhE5fBw8v4NxpUz5ZJJeT0+PQqGQSWz39/eru7tb+/v7WlpaUigUssFtw8PDGhoaUqPR0MbGhr1Gs9lUPB5XJBKxyXZMsGSuC7PgO1nT09M2AbJYLKq/v1+ffPKJvF6vIpGIqtWq1tbWlM1mFYvF9P7776uvr0+Dg4M2J2V9fd1mBvX29tpgJ6Zuer1ec+4nJydKpVI2vZJZIP39/TaGW5KdIZwsz9jj8Wh/f1/Ly8uKxWJaWFiwuSLuFFHmgHg8Hl2/fl3d3d0qFAo6PDy0MbdnZ2c2/+h1Z2n8thWJRGxMtnQx3+XKlSsWsPT19Wl9fV2//OUvFQ6HdevWLQ0PD9sI8NPTU42Pj6vZbGpsbMyMFXPVMXLn5+c6Pj628eGcwfHxcbu7TDasVqvK5/PyeDzq7++34WUEInt7e9rZ2VEoFNLw8LCNd+jt7bXBWdJFUOD3+3X16lVFIhGdnZ3ZYEGmo+LIOj2DQ0NDFiDG43F1d3crFotZYODxeJRKpbS+vq5kMqnPPvtMkUhEsVhMOzs7ymQyFoQMDg6qv79ffr/fzmAkErER28ViUZlMxu6w1+u1Ue9M1mR+knQ5HoNAjzkvh4eH2t3dVSgU0vj4uAKBgOLxuEKhkE5OTmzwWK1WUzAY1ODgoGKxmEqlkgWZnEGCsdddr+1cRkdH1Wq1dHx8rKOjIw0MDOj69es2MCmbzWp7e1uLi4uanJzUj370Iw0PDysajapUKsnr9erRo0dqNpuKRqNKJBJ2kRm36/f77SAzNtfn82l4eFh+v9/mUBP9MEfd4/EoGo1a1sHI0/X1da2vr2tgYEDn5+fq6+tTOBxWPB5XPp+3CItMh8+Tz+e1ublpg7kajYZFp50eTDeaqlar6uvrs4fdarWUzWa1vr6uxcVFzc3N6ac//anGxsYUj8eVyWT07Nkzra2tWRZFpMJExb6+PgWDQRtVyqxtRiAz97y7u9sm2jExjyyGuei9vb1qNBp68eKFHj16pEgkopOTE4XDYd27d0/j4+NaW1vT06dPVSwWlUqlVK1WdfPmTXV3dyubzerly5c2mIvXZGR1J2t4eNgu0Pn5ufr7+zU7OyuPx6Nisahqtard3V09ffpUCwsL+u/+u/9OExMTCofDGhkZ0drams1PZ7rnycmJisViW+TLhEAuE/tN8MLERSYdMvmyt7fXBuThZI6OjvTixQslk0lzTBjxzc1NHRwc2O/COQ8PD9u012KxqOPjY5VKJQvU3mYmCQEEhodn4vf7FY1G1dPTo93dXf3lX/6lJicnde/ePcXjcUMWEomEksmkBYj9/f029lqSzXxh2ufp6an29/dt/4aGhlQul23EMhNDeX7JZNImlnIWt7a2tLOzo6GhIQt62ONMJmPPFIM6MjJiI4339vZswFapVFIkEjFH2MnC8cViMbMjCwsLki5nNB0dHenJkye6fv26JiYmbGIpwcHJyYlarZai0ahCoZBlAz6fT319ffJ6vSoUCjYqngmdPp/PAnJ3bHi1WrWAMhKJ2GRfZmil02mlUinF43GbyJlMJu0M7uzsqF6vW3bc1dWlgYEBlctlbW1tWSBaKpXeOMB+beeyv7+vVqtl8739fr/S6XTbPGjS+1KpZFPreCNAXUS6R0dHikajBmmRJUiyUaVMWSwUChYFM2QoFArZhLbz83P19vbK7/erXq/r5ORE5+fnki7mhnd3d9so5GAwqEAgYFMLK5WKuru7zaMnk0l74OVy2SYAuoPLOlmHh4c2+IjIls+JAeZAHRwc6Msvv9TAwEDbPG5mYQMbMONekmV0ZG6kvKTZTF7E2YyOjrbNRQ+FQjbp8Pj4WOVy2QIBxkczpjafz+vs7MzmxgONxGIxxeNxG4fs/k4+b6cXm8MPNBgIBGy0K6k9o7ZPT0/1zTffaGNjQ7lcToVCQblczqb64Xy7u7s1NTVl0STRGxkeQYp0OcCL0c2MjGUfgFeli6mAZNZAcExLZfhTPp9XPp9Xs9k0gxoOh9Xb22tOzc3i32a8Mev09LRt+BcDttzhUd3d3YpGo/L5fFpeXrbx2YzgZU8Y+x2NRrWwsGCv12g05Pf7DbbFkbmjz7u6uux9ENwUi0VzQhhP4KX+/n75fD5ls1kFg0HbW0ZKSxeOMxAItA2xI/jiPrxN1ifJoHigVEZgu/Ps+ezValWPHj3S7u6u9vb2dHR0pNPTU/X29lrgXCqVFA6HlUgkJMkGd0kyCI9zeXp62hascQbr9bqy2azZZDJwPj/2mUmXTP6tVCrKZrM6Pj62/evu7rbfy14C/2KrgsHg9+9cHj16JEmGEZ+dnSmXyykUCun+/fuKx+OGY2ezWf3pn/6pWq2WxsbGNDAwIK/Xq9nZWVWrVW1vb6tQKOjTTz/VJ598onw+r8ePH+vs7MyymHA4rMHBQZVKJRuRzIdnJG+z2dTx8bHS6bSNW67X69rb21M+n1c0GtXMzIyq1aqlpMzRPjs7s3GhGNDZ2VldvXrVjHepVNLo6KhFTG/jXF68eCFJNpecCI73487Izufz2tvbUzAYtBpXrVbTxMSEyuWyNjc3dXJyorm5OX3yySc6Pj7W119/rbOzM3utUChk87SlyxnbRO4DAwOq1+t69OiR9vf3FY1G1dfXZxFLJpNRd3e3pqen2yC2/f191et1pVIpHR0dGaTU3d2tyclJTU9PW0YKbs4lCYfDHV/wzc1Nc1TudD5GNsdiMQtmUqmU/tW/+ldmVIjMx8bGLEssl8s2KrlQKOjly5cql8tWP8A5E6Rg4Bnpy/49fPjQ9i+ZTKpSqWh9fV3Hx8fq6+uz+eX7+/sWUUciEYN7enp6dPv2bcXjcY2MjCiRSCifz1utA8gCQ/s2K51Oy+v1mgHjrLjTDMPhsKanp1UsFvUf/+N/tJHfzWbTxja3Wi3t7OyoWCzqD/7gD/TZZ5+pUCjoxYsXVnMjqOvv71e9Xtfh4aFKpZIFat3d3YrH42o2m8rn8zo4ODDIiTrF2dmZenp6NDQ0pFqtpvX1dXk8HoPVT09PtbW1pUAgoNnZWavXMC68Wq1aQIlBfpu1t7cnj8ejs7MzhUIhRSIRjY2NmUPGMEejURUKBf0f/8f/Yb+X7HhwcFD1el1ra2s6PT3Ve++9p5mZGZVKJa2vrxuS09/fbzDe+fm5Hj9+rNPTU4XDYYOYh4eHzVZlMhl1dXVpenpazWZT29vbKpfLNl68Xq+bIzk7O1NXV5c2Nze1sbFh46j7+/sVDocVDod1cnJiyA02l9HV37tzAdoCN3cjIOaM47VbrZZlCuVyWefn5/YG3YNMuk00xNhN5nC7415rtZp6e3vt4gPHEbm6mQXwFTOqJVnkgrEh6vB4PAYXAR+RPkpqg3PK5fLrn8RXFvCKO4qYaID33tXVZZg+0EupVDL4AMfuzlR3MyteB2PAeFh3HC2fH6PCXrpjWNlHinoUu4HjSPPB8N2oh2fK/vX09BhOWy6XO3YujAMmq+TcACsy1z0UChnUxDliRjzGhb1iHzjD/B5gFvd7yKQJYtg/4Ae+1x2/jBElknQzVzfj5/wxUplnB5TCsyGzf5sFfIPRcM8P2WV/f799T6lUsrHI1Pck2R5g6MiocYQ4Q84gRtaF4oLBoBWPX7UD7ihg/p7nxJkNhUKGfAB1stfu6GM3A61Wqx3vHc/W/Xzu6zMOPBQKWb2pXq+rr69PPT09lgVIsn3ns+PE3bvGOeB72G/ONDbNRT9eHefsjtp+dZT0q06RZ8tnwwbzekCe37tzqdVq8ng8Bn0kk0ldv37dHAYp3vXr1y3l4jJwYfhzLBZTLBZTMBi0ugcHZn19XXt7exodHTVHU61W5ff7NTk5qatXr+r8/Nwi6Lm5OSvWF4tFNZtNjY+Pa3R01A5oX1+fpqen1dXVZfj39PS0fvjDH6pcLmtnZ8dwT8gBP/zhD9VoNAwegRzwX5s7/l/d6N8YIVhcQ0NDunnzpkF0tVpNV69e1fz8vHK5nJ48eaJCoWAwABdXkiYmJiRdkAT4zJOTk5blZTIZ+Xw+S40pXMdiMYu4i8Wi6vW6xsbGjGFDDcatEbiGwOfz2X5MTk7qhz/8oaXltVrNCtWRSEQ/+clPDEqrVCpKp9N6+PBhx/AOxrdSqej4+NjOmt/v18HBgba3t9Xd3a3f//3f18nJiZaXl1UsFu0SxmIxhUIhC4AajYb6+vqUy+UMUggEAlpdXdX+/r5mZmaMDTc5OanBwUFNTExocnLSCu2lUqmtyCtdXNyBgYE2p4GzpWhLlvzDH/7QYLpGo6GTkxMtLi6qXC5rcnLSoOJ6va6trS2trKy8FTxGMNVsNq2GNj09re7ubrsrQ0ND6urqUj6fV6PRsIKxdME8SiaTCgQCGh8fl8fj0fj4uLFEM5mMcrmcFa+TyaQ5R5hzV65c0ZUrV3R8fKxnz56pUqkYIzEUCimbzZpRBar1+Xzq7+/XlStX2oKh8fFx/dEf/ZHVXjF8uVxOjUZDQ0NDkmSv8/LlSz19+rTjO4wxJ8gYGhrSrVu35PP5tLGxoaOjI/X19em9997T6empXrx4oVKp1IZO4Azu3bsnn89nTDFgeOpshUJBY2Nj5jAnJyc1NDSkaDSqaDSqcrls9250dNRqeQcHBxYMEPwQzESjUXP2knT9+nX90R/9karVqtX/eN8ej0c3b96UdAkJs3+vewZf27ngdYn6o9GoJiYmFAgEdHR0ZLjz4OCgYe3VatVqIuCkRLo8KBgjRNYnJydGkxsdHbXfTao4NjamXC5nNSBojKVSyQqLYMbFYlGlUslSa943/00kElY3ODk5Maw3EAhocnKyzWtvbGzYw+xkET1gxPr7+zUyMqJAIGCOErYaxpJsBeyYA8Nn7urqsjoUuOru7q7tKQbDxU57enrMmbksOPa52WzaZcS5EGXD7qOgC2X15cuXBruBC8/MzBjRo1Qq6fDwUOl0ui2yf5NF1AplE4Pu8/m0ubmpTCZjNNrj42ODoYiIqcmQTfCawJNEcxSheW2/32+UW14fMghRKlk156W3t1fSZdbW29urZDJp2Q8RfH9/v8GchULBcHi/369wOGyZTKPRUCqVMgZjpwtUwa1vwl7jjhJM+P1+xWIxi2Y9Ho8ikYidB84g1O/z83PLtE9OTpTL5dTb22sZJ89heHhY8/Pz2t3d1bNnz+x3EjyUSiW7L/wMBn14eNjqHc1mU0NDQ5qYmND5+bkWFxeVz+eVy+WsNkIBPB6Pq7e31yi1ne4hWQCZBGxESUYKisVixmzd2dlRo9Gwz0FmEQgENDw8bIiIS1CivnJ8fKz+/n67t+Fw2Gp40WhUJycnOjo6Ur1etzvcbDYt03wV6cAZUjpoNptKJBIaHR21GmEul1OlUtHZ2ZnC4bAmJycNSm+1WtrY2HijM/jazuXu3btmpE5PT5VOp7W0tKTe3l7F43FzKhg7DhzpKfgrdRKKmYVCwQ58o9HQ/Py8Yc9wvFdWVpTJZLS+vq6+vj6jGdbrdY2MjKivr0/NZtPgt+HhYcN66/W6CoWCNjc31Wq1NDU1pVgspvPzc6P87e3t6ezszAgHvB8KjIFAQAMDA1pYWOg4ciSKomCO4evt7dXAwIDRe4+Pjy1aBL7hkIB3koZT04DsQNYRiUSsf6VUKuno6EhHR0cG3/CZyVxg9J2entrBp6eDYvTLly/VaDQ0MDCgvr4+5fN5+Xw+FQoFra6u2v4RHQFXSRdGfGRkRO+//37H+/fRRx+p2Wxqf39f2WxWBwcH+vbbb41IMjY2Zp+XC8bz6+vrs0spyQgLQGzQYev1um7evKlbt25Zcb5QKGh9fb0Ngz49PdX6+roqlYoxFakTdHV1aWxszMgFvMaLFy/azh/3o1gsamdnR4VCwQIZHJ3LIJqamrJsotM1Pz+vZrNpfSuVSkW/+MUv2upWLnEGo4fxJ+iQpIODA9XrdUUiEWMTnp2dqVqt6urVq7pz547V9iqVil68eKGTkxODs4+OjrS3t2csLhwR8Ob4+Lg5HOkCzlpdXZXH47EzSIbi9oXBnMTA4qhDoZCSyaRGRkY6di5Xrlxp+/PR0ZF+/vOfWw8X9Q4XygZq7OnpMUJLq9VSqVSyz1ur1Yw0we/BcdN7Qq/O0NCQOYBsNqtqtWrBD38fDAY1OzurUCikUqmk8/Nz1et12z/qq/SunJ2daXd3VycnJ1ZX8fv9lhCQPQ4NDen69euvfQZf27m8//77qtfrev78uV0sDsYPf/hDJZNJFYtF84Iuu4Q+gcnJSVUqFe3s7Ojw8NDoy93d3RocHFRPT4+uX7+ugYEBK6geHh7q7OzMCneNRkPlctkK9PF43IwtUd/Y2JhGRkbMKC8tLekv//IvrVjm4rmlUknb29vGpODvcYrAQMlkUrdu3erYOALTZTIZHR4eGsc8Go3qj/7ojzQyMqKDgwNlMhmjKxLtUJ+hjgG+XSwWdXp62paZjI+PW1EUzNzNhKQL1tDa2pokGVvl/Pxce3t7ikajevDggdG/vV6vXrx4oaWlJZVKJd26dUujo6Oq1+sWpS4vL+vk5ETT09OGQ7s9GcFgUJOTk5qcnOxo7yTpRz/6kWq1mv7qr/5Ke3t72t/f1/n5ucLhsD766CONjY0Zk42ghiwZpwf7bn9/X/l83npmcC40ZN68eVPpdFovX77U2dmZXrx4of39fTMahUJBW1tbajQamp6eViKR0MHBgTY3N5VIJPThhx8a+QLD+vTpU5XLZQsWJFlxeHNzU2dnZ1ZUBboge6CZjXPZ6bpx44adwXw+r1QqpS+++EI9PT1GKCAzd50LmT5ZS61WUyqVUj6fN4jbRQ5u3bplRqheryuTyehnP/uZ1tbWVC6XjcHHHoZCIauVFYtF9fT0aG5uzoK9er1ufXLValW3b9/W6Oio9bBwh8/PzzU0NKREImG/G9sTj8ct0+nUuXD/Dw8Plc/ndXh4qKdPn6q3t1d/82/+Tc3PzyudTpvTJMCBSQhaQ1ANlI9TpiZ548YNzc/PG8Enl8tpa2tL6XTaYPBisajDw0MjzPT29hp7LhaLaXZ2VqOjo0qlUkqn0zo8PNTy8rIajYbBycViUQcHB0aMODs70+TkpNlUWhkINLFh3zssBjXVjQZJk7mchULBegck2SVxu97BT6vVquGnsH/4MBTl6NmAdx0IBKyeQCEKggGwGpEBEA+bv7CwoFKpZJgsP+sut5iIoymXy+aQSMk7WRxomFxcWGAFDhEwkiSjJ5dKJYNS3P3kc0qy98u/EdHVajW7pB6Px/oC6F8AInp1D3jPfA+MFuki8ueySBdwS61WszoPz9p15EBCnS5qRBgLmDS9vb2WTZycnOj4+NgaH6FWk1HTE+ASGtzoEtgPEgr75/ZQHRwcGOOOn+NZURTlDFarVYMLp6amLLvMZDKWtbpNwXxxH4gqef98nk4XUCm/h8a8YDBohqZQKOj09FRnZ2dtsCwkCpcqS4TL2cNpkv3Qa1WtVhUOh5VMJtVsNtv6jdg3l8ZLnYbzA0V8cnLSPgNMRb/fr1KppEKhYM3JnGnuf6FQkHQRlLnkjTddZCOS7DzD3jo/P1c2m7Uv+qBwcpxdzocLdUtqI0mxh7Vazc4MWbfX67XG0Wg02tYUGwgELEOCks2z6e7uNtZpo9HQ4eGh3QPOA2eRTIdnCuni/Py8DZH4b63Xdi5bW1uSLi7RxMSEEomE0f+Ojo60u7vb1lAFJgktEKPT1dWl+fl5TUxM2EM+Pz/X4eGhQQUY23Q6LUn65JNP5Pf79fnnn+sXv/iFpqen9Xf/7t9VPB7/awYDHL1QKNhDjcVi+mf/7J+pUqnoT//0T/X48WONj4/rypUr5jQgLPBQSFExsOCWnS5gj1gsZtIPdBwfHx/r4OBA6XRaOzs71nTY3d2tYrFoznBoaMjUEEqlkuHm9EPgDOkwPzg4kCR98MEH8vl8+su//Ev95V/+paanp/Unf/In5nQ44Fw8IkgczeDgoP7n//l/Vrlc1p/+6Z/q0aNHmpqaMnx+YmLCWDjsG3tZKBRUrVY1ODio0dHRji/20tKSpIsLdO3aNaN1sn/AZYeHh6YkANy3v79vjasu1EnDZCAQ0ODgoFHskRfZ29uTJN2/f1+BQEDfffedfvnLX2p8fFyfffaZ0WFLpZL1DoVCIaOHptNpHRwcKBaL6Z/8k3+ier2uP/uzP9MXX3yhsbExzc3NqVwuW4ZDUAZO7/F4tLu7q0qlYvT8t2miTKfTbT0qPT09Bjfu7e1pfX3d3o90aUCpp1Cjo7F5cHDQIm631kQkDOux1WpZNvPtt9/ql7/8pcbGxvSTn/xEkUjEHFFfX58SiYRBnewjWd0/+Af/QLVaTX/6p3+qL774wppOecbUT0FMcFo0Y0PB7dRB7+zsWKtEPB5XIpEwKIzO/KOjI7t3oA4EZQRGHo+nrZeMe0eTK6SVs7MzaxL/4IMPFAgE9NVXX+nrr7/W2NiYfv/3f1/9/f2G7gBpUVfNZDIWnAwPD1v2/+///b/Xl19+qZGREWsdIIDJZrOGghA84pASiYTZrNdZb0RF5gARtdB1nk6nlc/nrYDuemjpEkPGO4PhvvqQiXQ44LB96Gbt7u62BxIKhdr42GRFpJ1uU6HP59PAwIB9H3iny6YgUno1c4FFRr2i08vtFjbBUomI8/m8YdZEV9RX+CyS2ui37ntyC+1AkkTqgUDAIny/32+QUTQaVTweVy6Xa6M/sn8uccHv95vKAfvHvxN5kkbj5IgaiVyJhDrdP3qggBgwts1m01J7+kL4HERZRGbNZrOtoQ6CBPRpCB0YNZ49zwtmX6PRsPOP8XT7Gdg/PjvkA4gpbmDw6nLPnyQLFtjjt3EuRN7cCyJvMgHOArRtmKDcJd4/gRyGm30CnnZlX/g3SDaBQECFQsGab4H8yKRg97mRN3c4Go3a+To7OzMliVfvOwgIz5leJWRnOl1uO4ZLra7VagaV8dk4g5LseVJnZXEesTvYyWq1apkYGWM4HLZg7vz83Gph/f39Oj4+Nhgf+8A+uL+X/QMVisVi9l743dIlHR8bCAwfiUTaWhb+W+u1nQuGmRqEJIs4Dg8PdXh4qPHxcd28eVOnp6d69uyZisWi1T+QzsCTY2wx2L29vSqXy9rd3dXu7q76+vqs9oKW0+TkpP7W3/pb6u7u1u7urhUVOWBIWGAgibwODg7061//2jKaq1evGt22XC4rHA5bTwxQE9EYXdMuVt7Jwmi4TpAHfXx8rOPjYyUSCd24cUPFYlEbGxsqlUoaHBy0ughGC4MOTAJuC/NoY2NDoVBIiUTCLur5+blu376tcDhs+1StVi2Nl2T4Pp+TFDubzerzzz83mOj+/fsaHBy0QjZ8funC2QAHeb0XIomhUMggqE4L0jCAgEOpOXFRzs7ONDIyovv37xvzhTQ+Go1qaGhIU1NT8vl8Oj09NaiGS3h6emoNpKenp9YH5TqU2dlZxWIx+f1+5fN565oGSuPPx8fHRoGfm5tTsVjU//l//p+qVqvq7+/XZ599ZuoUwG805tHBDTx248YN65s4Pz9/K1gMI+veY4wyZ2hsbMwaP4+OjgySCgaDGhgY0Pz8fFtfBpkHMkClUklbW1sqFotKJBKanJy0Pgq/36/p6Wl9/PHHCgQCWl5ebkMcuIecH7KESCSig4MD/Yt/8S9sv+/du6eBgQGNjIyoWCxaQEDNxXXQOJlXe0DedBHgSBe2D2UFygV+/4W2Gc3fGxsbJlXU09Njkb90YcCxNy4BqlqtanFx0eBYiCoEIxMTE/rxj3+snp4e5XI5nZ6eKpPJ6PT01OqyBDDNZtMCiJOTE/2rf/WvrLmU2unc3JwFtMVi0cgPyL54PB4tLCy0SQ99786FyEKSGR8wQaiZ8/Pzunr1qlKplH79618rm81qamrKtGyAlYgYifQQtqPzO5/Pa3p6WtPT0wZznZ+fm6pvoVDQ9va2RUWwaugKxrl0d3erp6dHm5ub+o//8T+qVCrp448/1vT0tHXdS7IHwueiJ4foBPbJ2xRTidr5PeCuMEXy+bxmZmZ07949HR4eanNz07q5p6am7BC7UTJOiqin1Wrp4ODA9o+fg/02NTVljDeiaogFODAidOmyPrS+vq7/9J/+k4rFoj799FPNzc2pr69PoVDIDJbboCXJ4CYMAMX2To0jzgrogACgXq+bgY7H47p//75OTk709ddfq1qtmhPGwbBnZGGSbP/L5bK2t7e1t7eniYkJJZNJY83U63UNDw/r+vXrxp5DHgiDSOMmfVuDg4NKJBJaWVnRz3/+c9VqNf3kJz/R1atXrb5AXwN9Hr29vcbwgyU2Pj6uVCqlra2ttzqDGCgCKbI3qMnlctn6SQqFgkHLZPeRSESjo6MKBoPmoAnuTk9PLfM5PDzU1taWFhYWNDMzY9kITESgudXVVdVqNdMp4/nyTBqNS9Hazc1N/dmf/ZnK5bL+6I/+SNevXzdVBIgtZ2dnBtcBj9GcTHb6tpkLd5jMnaCKQHl8fFwPHjxQNps1SjFNlBALJJlCvEsuwu5sbW3p4OBAV65csTtM5u2K68IWOzk5sQyajBJoE0JLOp3W//P//D86Pz/Xhx9+qKmpKY2MjGh0dNTqWDjC3t5e5XI5nZ2dWUAwMjKiXC6no6Oj77+gD1MilUppeXnZ8Gw2haIuTCg2E3XNrq4uuzCscDhsBX2i0aGhIZMgAPfn0E5MTJgMPxcaqABD4cI2pOUej8ekZwYGBgwi4nJg8F3FVmpCNBj9NgLAm6xr165Jurg0a2tr6u/vt89HFFOr1XR8fGx1K6/Xa701NF9Kl4XZRCJhcB8HkD4eot1arWaUw5mZGWPLIOcCNZbICydWq9VMow3MtlqtKh6PG/bv9kYEAgHT2QoEApqenrZiILWzt7nYN27cUKvV0snJiam8EkSQySETD6QAo+38/FypVMoMqht1UxQFxqNwiuIvl9/j8ZgiNNkc0SsRI2eZHi8MtsfjUTKZtJ4E5Dg41/wdBjoQCCiRSMjv9xt7EMjvbTIXFI03NzeVSqUUDoc1NDRkAQs1E/aM+wA1OZVK6dmzZ1ZEr9frGhoa0sjIiNUO6MlANgmH5vZZLSwsWKCBYCV9VBAIXIo9Na3bt2+bk4fIg8gjoo2lUkmrq6umdSddUIZpSH4TVd9X182bN60+hWIwNSjOIYEv+ntAWLA62SOgJuBVnn2zeSGzEwwG23QDqWkSYFPro2lXam9dINg8Pz+3to/p6WlVKhWNjY3ZOUY0FadCoMX78HguBFhPTk6sVPG667Wdyx//8R+rXC7rX/7Lf6n/9//9f5VIJHTt2jX19PQoEokYnXVlZcW4193d3dbwKF3KQkM7RrXW7cYdGhoy9gqKsFtbWyoUCpqentZ7771nHcxkUx6PR9lsVnt7e2agm82mFbe8Xq8++eQTkzwgGuUCuVjw6empRkdHde/ePbVaLf3qV7/S1taWFaQ7lS+hY/3P/uzP9OWXX5paL4YJiA4lUukiwtzc3DRNJgrSfOa7d+9aQZEGOaisGNFSqaTl5WWdnZ1pdHRUCwsLBofV63Xr9odAAXRFcZSva9euyev1GvWWjMfj8Zha7OrqqvL5vMbHx/XBBx9Ikp4+farNzU3LYDrdvz/8wz9UtVrVn//5n+vp06eWVSBh4vVeqMkuLS1ZNujW7+jLwvh1dXVpYWGhLTtpNBoaHR21s0V9Cty6r69PV65cMTYQTMZQKGTUVAwy2mpkqSg4o+6LFDo9QH6/X1988YWePHmi6elp3bx5U16vV19//bX29vbsjr0NrHP//n1VKhU9evRIn3/+ucbGxvTgwQMzujjaXC5nDsbVODs+Ptbm5qY8Ho9F7D/5yU90//59C0zo3mdfS6WSBTLNZlMffPCBHjx4oHw+bz0wQ0NDikQidofZc4KgXC6nvr4+/fSnP22rk6IMTA+GJH355Zd6/Pix5ubm9Ad/8AfyeDz67rvvtLq6+tbO5Q//8A9VqVT0b/7NvzFSECKn1DUymYzJ2B8eHrbVP7e3t7WysqKenh7Nzs4qGo1qdHRUs7OzOj4+tsCCWUi8LlBrtVrV1NSU7t27p4ODA5t9lUwmLViljUGSBWP0A7333nvy+XyampqyeisEmImJCQWDQX399dd6+vSphoeHdffuXbVaLX311Vfa3d01OaLXXa/tXF5lfXGxcS7MESAqBPZ6tTPVhZ7ILHgA6B1RlCKbIeWEEgmbxi1CwZSi4IeRfLVwysZD83T1gYrFYlvByuX683OdXm6XCkvtBcyWqJcLQ0FS+uud/UAZLtWVKL3ZbJqxZbkZHVkSGDEFQPYRPBsyBs+H7M7daxq2YNG575OoSbqMunjPnUbeRKiuUgTGgsxDuqSfQh4BDnEhSffsQUJxRfrYP1d+iEI4/w/8CiwmyfbKpYPDWGTfyGhKpZKxl1zI+VXoFMgKB/e2NQOeBXuI0oPPd6kZ51LyJbUZdPYYZ0HzLWQUt0Yjye4tRBxgNM6/q9PmwrU8P/7uVRo2ewmKQQ2J9wp06hI63M/QyaInCqgNTS+aI3lenBvpsv2C+83zIyPk8/IFcoIIsFtkd9EY3gP2i+fnsmchBGFzeD8sam1uT5Br59w6KSgR5+F11ms7l3/9r/+1UUtv376tmZkZffrpp+rv77ci6+bmpl6+fNnmgChIkYKTVpIlrK2tqVQqKZVKqVaraXx83KCXqakpw+4pXv3sZz+z2RDUY+r1uslJ+P1+zc7OWoc+nfi7u7tqtVqan59XMpnU9va2Xrx4oUgkok8//dTUihmEtrm5aYaBJi+gmE7Wn//5n1skMT09rZmZGf3O7/yOceSBSY6OjsxJSjJ4AZG+RqOh7e1t69D94osvTBJFkjUw4oyCwaCmp6etKL28vGx8eByVJO3u7uqrr76Sz+ez/cOAQGuUZOye9fV1ayC7deuWiTCOjY3J7/fr+fPnajabyuVybY6w0/373/63/03SBcng1q1bRoV3xT+hwvNZa7WaTeFjmiZSKhSgocCT7WKo6KOpVCqm0Lu5uWmQKlE+Bm5ra0tfffWV/H6/5ufnDVYDZkilUnbJaWrb2dmxWiPU8+vXr5ucP6SUcDis/v7+t57n8m//7b81Y/uDH/xAIyMjunPnjvVFSJcOEZabx+MxORPUc2lqPDs7s2y1UqnYGZmbmzOoTLpwujs7OwaRNxoNk5CBcQaFF+XjRCKhUChksDj7TB0qFotpb29PL1++tB6Y3t5eJRIJ/c7v/I4CgYDNGaJRc2hoSOPj4x2fwf/9f//fLWD5nd/5HQ0PD+vWrVsKBoN2Z8/OzkyJwKVY0+iITAtUd87eycmJlpaWVK1WNTs7q2Qy2fa7Oc9bW1vmQCEHIAWTTqe1vr5u7EQ0zbq7u3V6emoTbYGrd3d3tbq6avaC3rWpqSn19vYaYaarq0vxePz/v3kuz58/t9QvkUgYR5qDHwwGbXIkBosCHcXiqakpw/JxCqTduVxO9XrdPoTffzEdD5xfuoj+t7e3rSsYxhV8emT5oay6TBi45xSwzs7OtL+/b+lnPB63Mb0wkMiCUBkgMupkbWxsGCwXDoc1MDBgY0pp/CMyciMfJDQikYhGRkaMQEFzJTLaYK0U94nYvV6vyUM0GhdaX0R5MMmgdh4cHCgYDGp0dNRYS0SbOC+02k5OTnR4eKi+vj7DsyFWwNZyo34uR6fG8enTp/L7/bp586ZGR0ctAMHoEeW5vQMwtjiDdKAzx6dQKBhk4/Y1SZeK0C41m94hBkXBZHTPE2MKiBrJzKkDUmdhlgbS89Bt3Y58MgxXQfdtnMuLFy/k9Xo1MTGh0dFRG2NNI2ir1bJGaBwLTXo4N1QOqDnl83lzzES/ML/IgM7Pzy1jAC1A2y8QCFjxm2GAwWBQyWTSAi9sBDORIJ4UCgUdHR21QUmw8MrlspE0iO7po+n0Di8vL8vn8+n69euanJxUMpk0+I/MjeZlAgOv12s1ZEY1VKtVmzJJJu0SIiAjuW0I7CXnDJgU5iKMw+PjY2tlILMmo0IuqlAoKBQKGckG50NtkcF5ZEo+n89QKgg1r7Ne27lcvXpVrdaFLhZpMENwuKxgta5RoV4QjUZNYsPn82lwcNDoj3jSVqulgYEBzc7OyufzmbOKxWLq7e1VKpWy4UV4ZBcmu3//vinOhkIh08vp7e016Qs8NirOfr9fy8vL2tvb08nJiU5PTxWPxzU7O6t6va6vvvrKIjKXUfamC4VRlGMPDw/1/Plzy8qgSbtwDRHk3t5eW1YFPZPLWCgULDObm5vT/Py8vV6r1TLjS7ETlpcLNQSDQd29e1ddXV3GBltfX7dC+NWrV41GvrOzo9PTU7s8zEchUg2FQja5lLkVGNtOjeNnn30mSUZX57P5fL42ajsOBrybet/AwIBFlIxucGskDJ3yer0mGMjYiJGREWvY3Nvbs6FbgUDAalOBQMDGFI+Njam/v18HBwdKpVLy+/1thA56cej9oPALo6qrq0uxWMz2k4I2v7fTdePGDUmyPgiCLmqWpVLJ4LJisdhmtCgcA52RfTOZlrqWJCOBEPTV63Xr74IgA9UY4wgTC+yfoj1GmA5z9pCu/Gg0ak4XpILgElUEFH/5TJ3u4e/93u9ZFn54eGgZkcdzoXzhyl2hd8ZZpEA/MTFhWcfIyIg1ifKZsGWRSETFYtFgq1gsZgKz0OzJLiHedHd369atW5ZZY1t2d3et7ofDgY1H1kLAzx3iPdBqQpCFnt7rrNd2Ljdu3FCj0dCzZ89sqtru7q6azaYWFxd1cHBg+k1EumQm1WpVoVBI+/v76uvr061bt5RMJpXJZIzySwQNlz6bzVpHLIPIUqmUdnZ22mQjWAMDA3rvvfcsOvD7/abyGQqFTLTv2bNndgmiv5lJvbS01NbgFwqFtLCwoEajoS+++MIO0ts0Ad67d0/1el3ffPONdnZ2dHBwoMXFRXk8HuuxoGDGpSyXy6ZTFA6Hrev8008/1djYmLLZrI16pScBKmkmk9HGxoY5l0ajoZ2dHeshqlarhhWTYT548EDd3d0mq76xsaFUKqXx8XFdu3ZNPp9PX375pXZ2dsw5wSaB/dNqXYgzoiMGQYHP1On6wz/8Q9VqNf385z/X6uqqTXZsNi8GI52enppqMZL4MGUKhYKGh4dNi+zGjRuKx+NqNBp2MWHzSDLHfXx8LJ/PZwOhNjc3tbm5aXANmUutVrOhX+jkdXV1aXd3V9vb21Y49/v9evTokRk4MhZGd9NXRIOr61xwPG+TucD4JMApFAra399XrVbTixcvlM1mTUSVvcO5lEoljY+PG+WfPpONjY22AAMDT2ZIZk0wuL+/r3Q6re7ubvtcZOrRaFRTU1Omrg7JBlYVI5ZXVlZ0eHhoUCe1DIgU7OXMzIwqlYoePnxoAVsul+vYuXz22WcWcC4vL1uNrtls6uXLl8rn8xoeHrbxFwwtlGRsw3q9bvp9g4ODevHihWmGuXRiDDs1YzJltAm9Xq+hMayRkRHrQwLFQL8xmUzqzp076u7uVjqdtsCJZnb2BRJUKBSyJm9eD+fyvddceMiSLPLjjUE7hqfvpqSSLE2Lx+PG+XaL+z6fz8YWQ9s7OTlRPp8340eKDOSRSCQMF+RQk0FRa6CWwUGXZBg2kA9Ff/5MtgVzyuu9mJlN4bXTRQQiyTrM6cJ35Ws4rNVq1VSeaYSioZLOc96/3++3ekyzeak6DbQHxAKdkeeBtAepPLAdAoUU/jHCQGnU2CgaAkVSo6rVaiYsCjuL99Bpn0Y6nTYWGxcQuBQV6b6+PqNk0xvF96HjFgqFrFjKOXEzra6urra5GpxNSfbvPI9gMGgwD30CkCYoHlPbKhQK9juR2idSJUhyu9tTqZSkS6l7gpC3WUdHRwZTsYfUUMhmmeMjye6O1+u1e8tzx5BLsi51Akv3DCN7xNlhIZfT1dVliAdtBNSF3AKyqxrh0oyJ3tkrznOj0bAAgjPo8/neiEr76iLIdOVxCFA5izQhc5/ps+IcxmIxm8jKe6PFgBpKMBg04gc0cM4PziYQCJg+IIoPtE5AOIFEhaIAdg576ko1uaQe+gePjo4kyQIpzsTrrtd2Lqurq5JkjUJQSyVZAxuNYMfHx1pZWdHZ2ZkGBwcVj8c1OTlpmQX9BkRivb29hlNDZz46OtLm5qYkWYqHgenv79cHH3ygcDis58+fa39/X6enpzYaeHx8XD09PdbzgLEgXRwZGbFo1a2vkC2k02n91V/9lTGhbt++bcX2TtlOL1++vNhw/8WgrVgsZvPbqbWQUu/v7yuXyymfzxt5Ah0jDBTvlV6Ljz/+2A7Xt99+q0KhYHRjGExc2P7+fs3OzlqDaTabVf4345XpVwLCoFfh6dOn1hQ5PDxsjWtkc61Wy+DSYrFo5IDBwUFdvXpVBwcH2t/f79i5/MVf/IVhzuDu77//vvz+i3krmUzGHDZNemdnZ7p27ZomJiYUi8XsXMTjcXMQYNfXr1+Xz+fT+fm5MpmMdnd3tbS0ZI4cMkAikdDg4KANytvY2LAO6VwuZ4VbelfQU9vc3DRDMjMzo62tLW1vbysYDGpmZkY9PT3a29vT4eGhvQfqm1euXNHW1pZWV1c7VjiQpF/+8pfy+XxGXgmHw7p165Yk2bMeGhrS2NiY9vf3LcsaGxuzsRoQJMgIoVdjNJEl4V7t7u7aXSfj83q9GhoaMm2sx48fG9S6t7dnz4bgk2eQzWYNUpqentbe3p7ZJepju7u7SqfTisfjVgMLBoO6du2akSg6vcOff/65JBnaEovFdOPGDbMTjNKANcv475GRERuwODc3Zxk/8P7ExISazaauXLliNS6EbKlFo6LB68diMf3gBz9Qb2+vZT8ej8dgbGpWfX19Fjjt7e3J6/Xa0DcCUQINr9drMkDpdFqZTMYCsHA4bFDk667Xdi5gpMihoFwqyeQdYNkQHdBYxBvk+0hjof0iMiddRm/0J/DBwYmJgng9iuxg5OCJblQvXTYewlKhzgMlUJJFm41GQ7lcTn7/heR5T0+PYfydGkf2D20sBkm5EQyO41W5ejJFCvG8D75wGDgqCtWwpsgYcATQhvkdpLukym6hEbojw+CI1vh3l17qKi5AUx4cHLQL/jZU2lwuZ+eDZ4/WEg6Q8wUNFlo1ewdt+NVzh/4aBBGYPy7ppFwu/zViB5+H7JM6Gawm6SLK5jUgV5A9SZfjrl0qLTWgYDBoE1sJHN4kcnx1UTsBVuasEem69xjIVJLtoUu5JSPmZ+gDqtfrFjQS5fOZqKuS0QKVca5ADfgvhBO//1IlmjMZDodNnsRd7HWpVFIulzOY3FW9fhsJIvYDm8R/0UkDGiZraTabpgEGa4yGbbcB2KWfc6dcGj/31yV2oCDt2kcYaqA80gUkSfDMvYdCTUYCCiFdUs2pq8ZiMbMbb7Je27lQTEwmkybhsL29bYa4XC4bI6yvr087OzvK5/NGbzs9PdWTJ0/U19en2dlZk+sH381kMoaVxmIxw7ElGRuNi1Wv1/Wf//N/but1cdVQwc8ZOMZME5/Pp+npaY2NjVnTGzBapVKxVLtYLFojFA9NusDiO4169vf35fP5dPXqVWvSY1oicA60bq/Xqzt37uj4+FjBYFDpdNpqUJATmLnAJXZ1j9grHAP7REPb2dmZvvvuO7u0GAFE97a2tswALiws6Pz8XEdHRyYFMT09rcPDQ21vb6tQKFgNJhQK2aRGeirIGL1er6X9nSwO9+joqAYHBxWJRIw9RNBDJuLzXSh3c9mPjo6sKRAnw75zPnZ3d63TG7VfokXX2Pn9fu3u7mpvb88Knz6fT+l02oYxpVIpdXd3a35+XtPT0zbcjpri6OioBWawc/x+v+bm5mwoGFMM6S6v1WoaGRl5qw59HKqr+bW6umpFW8gsXu/l5Ec01jhTR0dHCgaD1giNs65Wq9rd3VW1WtWVK1c0PDysbDZrgZ6L8/v9F6Op/92/+3cWPJGNUw9l3s7o6KiGh4d1enpqDZyzs7MaGBgwA4vhbbVaGh0dNeYl95uM1+fz/bWBX2+yMOojIyM2yvrFixeSZAHJwMCAksmkstmskZ08Ho/BuYjJAqsSHBWLRW1vb5scDgGc++zcPrOjoyP97Gc/k9/vtyAvl8vp4OBAjUZDi4uL8vl8Gh0d1cjIiGUdnDcyG1oOCIzYV2rqQJvValW9vb1tavb/rfVGTZREO7FYTKenpzo4ODCqJVEib254eLgt+jk/P9fW1pb6+vo0PDxsY1KJGMEz+cCIB0qXxUC8eLVa1dOnT+XxeKxjHG8dCATsvTIciOIlnP2JiQmrd2B0mAGC5AZ9N67kC/IYnax8Pm+vn0wmdXx8bAaHaIY+glarpcnJSYXDYRvbSoYVDoc1Oztrhg7nAm2aC8+lp2bAIaQWQT8BdTAidYxqqVQy/SEUm3nvU1NTkmTUSSAyCtFEqLwm7zUajb5VQRrG0uzsrJrNpkWS1JDQbqrVakokEmZwIExALBkbG2tT985kMspms1bwh6nDuZJkWDZUTgKr6elpDQwMmMIBbET2KhaLtTWP0u9Frc9tsgRaZsATQQMZOdI0b7N/ZC440HQ6bfpUZGrAWBTL3bktCCQyBposBIgF7J85Ma4EETNpgsGg8vm81tbW5PV6de/ePRskCM2eonU4HNa1a9cs8uZ5k31BVqHWwlnb3t62gXLShf1JJpNvpbLBfYrH4xofH1ehUDBFAbKAnp4eG1/uzgEi64Q96zaW9/T0qFQqWUALJOg6E/5MY+PZ2ZkFV9hTGLwEdSh3zM7OtmVr9NuAosCoI8AOh8Pa3d1VKpUyFAnpooGBge+/oA+nmt4CV+tqe3vbZivjoTEmcNhxGl6vV/v7+xbF4BRgG0G/o5Do9/tNYsPV6KEYRcRARkTNBUcA24oLzNS/fD5vsxJgRxABkcbSLStdpoqdLvbPFaEjY1pZWbGiajgcliRjyJAV9vb2GsTEUCeoyNIlTRpIg/eKMcFJsneopkqyZ0XRdWRkxHjykCQoVNL4lU6nbZLg+Pi4JNloBEYluB3CwBWdLgwcUCifoVqt2mwMhti5Gl6cP7fGd3h42FbYpfGNy8/5I+uDJcVoBBw9gQ4RK3Uv4EEmVFYqFQuicrmcVldXDf9HzJGiKwaFjMztN3Gj104W00XppSGbJSOhpgg9W7oI7FAUgPwgyTId3iswLBE0Rm54eFgej8ekUqD7ExBRaK5UKopGo7p3754VnclIj46OVCwWzd7kcjltbm5aUOjz+ex5s4cErpwXHOCb1AxeXdxbl1JPNpJOp1Uul3VwcGDNigTbSLX09PQoGo2q0bgcZ04pAf04CB3UPiFzDAwMmFOmToLDwG6R0QOrtVoXclBHR0eq1+smJ4NeIbAbNhAiD9AlUKUrmfXboMj/0npt54JCMQ1MkgzTX1tb08rKip4/f27Nfj/+8Y+VSCSMPkwRyev16vnz5wZHERGBB4Ixl8tlM5aTk5OmdErjI+w1aI8U13p6eky59dGjR0b3pVbBqFRkKxKJhD777DMlk0nLYprNi1n0rpwH7K1O19TUlDGriLJgbHz55ZdGXiDt/lt/628pFosplUrp/PxcAwMDunXrltHBs9msRY70vlAA7uvrszqSz3cxywZBSwwuMBAMKNhUvb29VmBeXFzU8+fPre9CkhYXFw1aOz4+1sDAgH7/939fyWTSGt4w9DgTstu32T+YMUAo0EpPTk708OFDOxdAIz/96U8Vi8X07bffmi4SmfTa2prVDAhwOH+QGnC+EDpGRkb06NEjHR0dmcS8K4w5MzOju3fvWpOs1+vV48eP9ezZM/X392t8fFw+n0+pVEorKyvKZrPa399XIpHQ/Py8hoaGTMqHbMAVIXQz1U7XlStXDCpJJBJWNK5Wq0az3tnZ0fPnzy1D7u/v187Ojo6OjsxY1+t1bWxstNU3yB6DwaBJ71Ok7unp0bVr1xSJRPT48WM9efLE9h5Itlgsanh4WB9++GEbs+z58+cGN3IG9/f3zXlVKhX19/fr7t27bTUPVDxgP2FwYUB1sqi7IV8jXcpOPXr0yPpJaFT9e3/v7ykej2t3d1dbW1saGBiwMQ9ATtxJOvUbjYb1X/X09NhokFu3bikWi+nx48d6/PhxWy8hNmpqako3btxok9/58ssv9fDhQ3str9drI6FZkUhE9+7dMzFiziCyVNQlz8/Ptb29/dr79drOxYWESOddfSLeAAV0Dg8sEbcnhaiWhyPJog7SPjwnBWKahoi2oTv29PQYtZnX4zWBMYj6SC/dQrZ0GSUSNcDewqu7X50uYDgK+BhCSWY8eM9e76WqLrAWnxdaIEXAVwkO0DbpqvX7/eZMibbJLMHWcUxEeOwh75PL5EbSbtGR91Aul02q21UacL86JUSQSbnFZD4LcK1LxSTCdB3vq5+dSNstcgMfSpdzQJBwIfCA4dhsNo1+T3SHA3DhSrcI78rz8Lz5/vPzc4Nw3Z4qnod7tjtZZCsgBGRn1I54X25jLcSJSqViBWrOFmeSQJHsAUIKz8ulLrukBLI1xnHwjFxqMecQhwOawVlym3fJoBAN5b64e/g2i7lOEBTc34sdfNX+cN5cGyVdni1XVYOs0LWltGy4dxhnwhniOUFGcu8rzof3wXvxeC4nzrLvBO3MKnr1DLrEgtdZr+1cwHuJWCnERSIR3blzRyMjI9bvQvp/cnJiMjEU3IPBoG7duqVIJKJ0Oq39/X3DJ13BNqCcRqNhRUdkUoLBoFH6rly5oqGhIaMxcpBJ5+mgxfAODw8rEAjo6OhIqVTK4LBisajl5WUtLy+bnAdUWkgJQFadrImJCXtAXGyc182bNzUzM9PmBGk2Y8hVpVKxEchXr15Vb2+v9QNBx+XwUDQcGhpSrVbT6uqqMe/4Gh4eVjAY1MLCgiYnJ43gQFZF7Ql4EvHAkZER+Xw+a1yUZLDmN998oydPnlhkj5Ho7e01Z93pmpubkySDIHCUwWBQN27c0JUrV3R2dqbT01P19vbaWWEcbalUsiLxtWvXLCtMpVLq7+/XzMyMSZDT7Uxd4i/+4i8sk4Yqeu/ePQUCAau5tFot602RLgIXsqlqtWpQB2SWFy9eqFQqGdxbLBb17NkzPX361Iw3gUKnDvnVNTk5abpW6+vrbWw57pEkIzsMDg5aBuDxeJTL5ayx+datWwb57O/vKxQKWQMkZ4yO+HK5rG+//dZqO0gIXb9+XaFQSLdv39b4+Lj29/f15MkTo5rTR4RdIHMaGRmxjOr58+fmzGq1mhYXF7W0tNRmRN2gwjXwb7ru3LkjSVYjxmh3d3fr7t27unr1qhlp5vI0Go02WB8ocH5+Xv39/dbP193dbbbJdRBe78Uk0K+//tqUqY+Pj9v670ZHR5VMJlUul/Xdd98Z3RxpHT47yMTCwoJ6e3v19OlT/eIXv1CtVjPo7KuvvtLTp0+NbAVs6TJ3v3fnAisDWWfwbb/fb5AFEUitdil7Pzg4qKGhIXM2zWbTBjexWcAuUA+JOOmAPjw8tH4VinboZUUiEYXD4Tb8FX0wZCfIDMBmafrC2AB7gRW7jXA0R70tJEHKjgaRG8Eh7QAMUiwWtbu7q3r9QhJ/cHBQ2WxW6XTaOOfMfCCTcam0FGWhmVKbYQ/Azru7uxWNRhWJRKxoRwEcrr6ktsMErRepc34njD/wZrIpoqy3NZBoVWWzWYOkyDooPGMo3YYxejqOjo6sSExBG7pqf3+/RkdH1dPTo+3tbYPIqF2lUinrXqdHhrlA9HERdFGoB7KVZOeLoCmZTOrg4MDeLw7o+PhYOzs7CoVCJsNPtPgmEeN/aSFrQz8NsAcMIiAvhDRBBWighCEqyfrFyFz6+/uNXeZmKB7PRXMt89wxsDRVozuYSCR0eHjYppUHhdal6dOMyNBAsnMCt+PjY21vb5tx5N/IDt7mDkMSOT09tdoNZ9CdvQKqwxmlPo3+oSTTp2s2mxZkUHtz58DwGtS4gJ55NtSL3SFzbt2J4BAbCBkjFotpY2PD4H7gzcPDQ21sbNjcGJAjPuebyF+9tnPhDbvDmigowcahu7dcLhs0AqbLQyd6gPLI2FiMN8U9qLGSjPrITAOalgKBgLa2trS+vq5YLKbr16/bATs9PbXipVuMZ4YLmQtNb0Q5FD2BiGjgGhwcfKt5JDDdwLXdIi1wRH9/vzFFGENMtEdTpdfr1bNnz4wzz/vmArF/xWLRDlosFlMymbSCtMfjMaiNhk2yEjJEmjPJ/Piih4YiP9ERApB0wSMhAzOGAWadXm4M7fHxcZsyLHCC2w/UarUMwnpV2rzZbGp3d9fgE6jJEA+IkJkt0mq1dOvWLQt0qtWqET78fr9SqZS2t7eN3uuyprq7u80gcQZevHihjY0NHR4emmHe2NiQ3+830UaaCHE8rdal0OPbGEckRWBJ8tr8maIvKAIKF2jDMSLA7/crnU5bT4o7coOC/snJidHnJZmg5MHBQRsTrLe3V4uLi3r48KGpQgPPYFNcNmi1WjUC0c7OjsmW0Ct2dnbWpgbs9jUNDg5qbGys4ztM8JvP5+1skGGQVdETJF2WBgiGcHD1el3r6+v2Gi4ETR2q0Wgon88btRgnz4RQmiP9fr+RQyKRiObm5gw6JrjHxpIckLWmUilzuDSUe71ec/Yw/igTwAb93tlifr/fDhpQAgcTHjRGy+/3GyMh/5sRyLlcTltbWxZVhkIhzc3NaWFhoS2iAD7L5/Pa399XV1eXrly5YtE1lF7w46WlJe3t7enjjz/Wj370IxMrPDo6ss5hailEk81m0wqqNLAx6tjl9ksXkhnAKzdv3jSc800XNYitrS09evRI3d3dRl4gCiaz8nq9VqPBuQD5YPwlaX5+XgsLC22NlUQiBwcHevHihXp7e/XjH/9YIyMjWl1dtS5iHAP9B7OzszZMikxxZGTEiA2np6cmIQ+tl2cAg6TRaCgSiWhgYEDXrl2zg1mr1TQ0NNTW3/Gmi30/Pj7W+vp6W/8FuDWHH5UFomd3VkatVtPu7q6Nn6WHimyV2mAmk9He3p56e3v10UcfaXx83LrqiRalC/bhwcGBHjx4oB/84Ad2J4rFoil3uzRTpOrJUimm1+t1y6RdeRmMz9jYmGZmZjreP+nCuRBkuQoPkszR4FwIVCjwEgFT64Muzahc/h6juL+/r8PDQ62vr9tgwIGBAdPcwlZ0d3frm2++0crKij766CP97b/9t1Wv1/XkyRMVCgVTYM/n81pfX7fz7ff7rZschy7JGv9c58J/Jycndfv27Y73kJ63fD6vzc3NtnpQs9m0PjXo0RhlVCug/tbrdW1ubqpWqxlsi0OhnkiGtLq6qkAgoJs3b5r4LxA96g9fffWV1tbW9ODBA3300UdqtVqm6UfPzPn5uYm57u3tWX2PvQBRAVJDMonPRtvC3Nzc9+9c0um0ms0LETM0gYBdpMshTUSALrxFH4eL10ELPDw8NLYSUARFWiAtLqFb3KYYyeGHQkpqeHBwYIaaiBdIrq+vz4wmrAgK0sBDRCRERNAMOz2YzJ6ORCK6du2aHUyXxMDeUGCFyUVWMzY2ZhAU6Xc2m21TTCDrisfjJlECpElxm4Y1cPR8Pq94PG500mw2q5OTE2saxVgDZ/CFJAp0cH5/q3WphURaT82j00U/QXd3t2ZmZizzoz5BURPKNZkO+8H+udRK6gKSTHmXoinjeMlscRpcLM44rDWiU5pj2VMyZ2jTZEpkKNVq1VSFOVtIsgN3oquHgnGna21tzeBJRh6zOHtMkIUJB7RMVM795AzSYEsGzVmmix5bwb3F6LsUf1AK1IFRTj4+PrYZ8C4akkgk2qB0kBHuM5ko9RoCEOZH0aT8pgtHRjOhq7wAixEIjKBGkunLAeOz7+j50WhMHw/oQ3d3t6ampqymCgMT+J/XdzNzsh9mxGBTC4WCoUjUTiKRiMGiwJec60qlomw2a9kaBIA3OYOv7Vy++OIL+Xw+Xbt2Tbdu3WoTp8zn822ihUARtdrFTPdoNKpwOKyxsTGj3u7v79tXIpEwKiGdqTTFVSoVLS8vmxzG6Oio6vW69X/QAHdwcGBF5ocPH2pvb8+yo2KxqOfPn6vRaOh3fud3NDIyopmZGf3u7/6uSqWS6aAxcIcMwOe7UMQNh8M6PDzU4eGhJOlv/+2//fon8jeLQWZ3797VH//xH2t/f1+PHz82uq7rnL1er0EYzIFA1bRarWp9fd0YHYuLixocHNTw8LDVkprNpmZnZ3XlyhWD4s7OztTX16fx8XFzFuXyxVhlcODR0VGVSiVTyCX1zmQy+vWvf616va7f/d3f1fT0tHWyn52d6fHjxwatwc8nSyUzSKfT1n3dyULr7d69e/rBD35g8CyMRK/Xa9ARkCCUVGosd+7cMToq+DdBCMavUCjo/Pxc4+Pj+tGPfiSPx2PnnGeDQaxWq0qlUlpbW9Pk5KQ1PP7qV7/S7u6uPvroI8XjcWtSq9fr1r2O6uzp6am+/fZbgxYhw2xtbSkYvBgjMTIyov39fT1//lytVks//elPO9rD//Af/oN8Pp/u3r2rv/E3/obNA8IJE9QEAgGbG1KpVDQ5OWkz16HSbm5u6vT01DLJUCik6elpy2BQSEdNm8wciJbApVKptA272t7eVrFY1HfffWeqv5FIREdHR6bCnkwmTWsvFospl8vpF7/4hUnbSxe04c3NTWOrxuNxra+v6xe/+IWazab++//+v3/j/Xvx4oU8Ho+mpqZ0584dC2TdRlgyLWp+oDRurQ/FAkYe7OzsWNMuzqNarZrSO/VPoDVqOig3AHcj218sFrW4uKh0Oq0rV64YVLmysqJGo2FahdhbbCCNtDhrYNrx8XFTxFhdXVWr1dL/9D/9T//N/Xpt5wKXXbqUF4GOSrHR7Rvgi4iop6dHiUSiTaodqMI1ipIsayHzoAucRjoal4A90NSh/4INJjN41StLsuIqqb47LIpuYNdrM2el08I0qTxRjkvHdveP/+cLh0P0glQ+ESJRi/vZiN74fvqI6GtxaxFAI64KK5kgGCzGlD2EfUKEC42Z98TrUzuidvA2TahkQkRdLsHi1ayPPSWL5hzADERtmyCCfZAuo0DoxpKsadUlOLjRIkoE6Lqdnp4qn89bJE0GzHMkA8ARU5glUycz4D5x3mlQ7nTlfzNPCZZdrVazqPXVvhr3zEuyDBFBU/ceQoCgBkO2TabsUtelSxkVomjOFLArdT3qQuy5+zyhLPf09FiUD+mAn3FJKtgAKLadLObd8BkJbPh8bhe8W0dhX6nHgCLQ2InNcf/Lz7k9hS5kBnHEpbpjt7B/ZNPSJanEJYfwfvh/7rB0qdGGjeX5oKj9Ouu1nQs0xf39fcOP6bLHMTB6F1kENH4Y+QqsQ8NVd3e3sb8ODg6Uz+eNzUWN4eTkRF9//bU1YjJJjgdD/aVSqWhzc9MK0cPDwxoYGDD5jTt37qhcLuv09FRPnz41uINi8/DwsMnEc1h48BR6wdk7WUTXDx8+1LNnz0y/jIMGuyoWi6lQKOjly5c2x6Wvr09TU1NWjIQ2TINkT0+P0um0crmcGdfd3V2LuB8/ftzWPIbjIaIDGnQpkDyjaDSq4eFh3bhxw6L9b7/9VgMDA/Z+KMxCn3YprpLsYnFROlno2S0uLurJkycWwdGY6vf7DeJCBoNJhcFg0AZ4gc8fHx8bNNhoNCzz4uIwFKxcLuv58+fK5/MaGBiw4rI7eTAejyufz+s//+f/3NbYh95ZvX4xcIxM++joyPB5n+9CB21iYsKcsNvT02g0jPLtkgM6WcjvrK+vW+aKsQUuTSQSSiaTOj09bRsgls/nNT09rdnZWWuKxYGCy5+enrbJmyCvU6lUtLa2Zh3pwI+Li4sWvKFZtbKyYiKkg4ODGh8fN9ou8OPOzo42NzctS0D1+MaNG1paWtL6+roqlYoV8wk+YQ52upC2obmYfXAdKqxBhuqRudAMPjk5qXr9QssNqBl0ggCM4DCfzxu1H/RBupSD4bxiB87Pz/XNN99Y4NjT06OxsTHdvHnT6i2lUslmFaGgEgwGNTs7K4/Ho0ePHtm5x6FBAvL5fBoZGfn+YTEK+IeHh6YpBUZIdOpipxwEiujRaNTqJBhSNsrrvZAZcT051OLj42NtbGxoa2vLmF6k57CtyKSQmIeuC9zRarU0MTFh4nAUxXAY169ft0PvFqvw8K4T6xTzJgva3t42yIaGNBrI+HwIbUJ5BELB4DAugK568GQcJTMykNlZXl42uXIYdJAJent7bc9wqGDnGIdoNKrR0VEbhUyjab1eN/FHniecfbfp1KVBdrqQc19aWjLICGYd0BvUavf8UTx363RkF0Sa1E4waoFAwMQjz87O9PTpU+VyOd26dcto7+jqNZsXXfz0SUkXUR/1BXp86EOCLEEAFQ6Hdfv2bYVCITM4ZOu8N+b6vI1zlmRRKsP+OGsuFZmagosC+HwXowiodWCwySyoFVELoJOd7A5YOpPJaHZ21vrekJOnWOzxeAyWRmoKqfpms2mB0Orqqg08KxaLGhgY0MLCgqLRqDKZjLa3t9syMIIm2Kyd3mFQGu6AWzelVgUJolQqaXt7W+VyWbFYTP39/UbwgJ2VyWSsfukyFnnvtGoUCgU9f/5cuVzOZkHRtMldJaPc3Nw0G0r/IKwypu3CtsN5xGIxzc3Nqb+/3+4WGRHPmdfCDr3OemPqE28cIT3gBmAe0vwPPvjA+N/9/f1WPKrVaobNw69GvA28l8NLX8wPfvAD3bt3r41WSHrKxcCZSJeXyOfzaWdnx6ALDjGFMcgAzM7IZDI6Pj62CA7aIIw3N+1904WIHQ4DiIEMAYfJfty/f1+tVqvtYJJRcbB4bxh2WCShUKitP+C9995rg3+AlahJYPyJwmZmZqz4DL+eQz86OqrR0VFJl2KOsH+YRkjw4Pf7refobbrzpUsqPIYMmi/ODYYT0d3169fl8XhMaw0WIxEZBXaiRd4zLBl6CWKxmA3UQtSyq6urDZaVZI4buJVgYnFx0eAlj8djzxPDdH5+bnOI9vf3jfWEI3HJEG+jzSZdwocY20AgYDPgo78ZANfd3W3U43v37ln9r6+vzzI0FIfplSHrcfXRCPqAcG/dumWsy3g8bsVsnAsGn2dMwFWv1/X06VODlcPhsDX+UjRn8ijq01CdYSdWq1VjhrpKIW+6gLSAi1z1h+HhYZvwSsMxd5b9GxgYkCSrS3P2EPTkvhLgAB329fXp6tWrZjuDwaAxOIHJIFsRILt29MWLF1aXqVQqloFzJiqVivb29tTd3W0Crn6/X+Pj42ZrK5WKqTy/7noj5wIUUa1WFQ6HNT8/bwyIrq4updNp7e3tKZlM6vd+7/dMfpr0C8ol0Rw4NcbVnbkBBNPf36+/83f+joaHh03qHLpyvV43ITgcFgYiGAwqm81aty4Q2NDQkAKBgFKplCmwbm9vy+PxaGdnR+l0WoODg1pYWDC4jnHCbzPsanBw0IxfsVhUPB63AiiXEwp2PB7X7/7u71pRFHVkCthkHExL5FKTfcViMbt0wWBQU1NTFhlnMhkVCgVTPMUxQxvu7u7W7du31dfXp7OzM6NM8nspBu7u7mp1ddWo6SgIoMLABQFeQRyy0/3r6uoynL3ZbBq9NR6P6wc/+IHGx8f15MkTffPNN4pGo/rhD39ohgzxvo2NDauLcNFQcwDaiUajmp6etuyQz9zf329KsThoV9YFg9rb26u5uTn19fVpaWlJP//5z62hr6urS0NDQ+rp6VE2m9Xh4aHOzs60srKiZrOp9fV1pVIphcNhg4mAmvb29iwq7XSRiWPQGFjX3d1t8Gomk9HBwYGSyaR+/OMf2/RT1KPJGjY3N7W1taXJyUmbl0ImibFzadULCwuWGdHHgpF0pUqgQ7OHa2tr+vzzz21aKCrJ/Nvjx49VKBS0trYmv9+vtbU1bW1taWxsTLdv35bXe6Fl+DaaYixgcYKSSCRigpzz8/OKxWLWd0dGSrBHXffk5KSN1UWA5jJqUSfxer3Wi3Xr1q22ab3Hx8d69uxZmwAtqsVdXV0mdAkZhyzV7/drYWHBeo4Yl0Ghfnd3V2dnZ0bG8Hq9hvZwl193vbZzcRVBJRmPW5LJEFBUw9O5XHqiRS4380dQWYYsAFOCyJsNpqDK5kKFJHuh6xwjAbtCutQOIxLg7zks0CthT5BRuJ2tZE2dptT8Xmoa9XrdHCREBVf+xd0vn8/XRrkm4/P5fOYYXA0iV5uKbJL6AJeYfYZC6WZSRDNukx0RaK12MQis2bzQ1XKNAzAG6gk4Aoq9vF4ni2dPVEsWQg8G/84e8pmBujhD9B7Q00JGjWMmMnWL3RgBt5jK+SPixOHT1Q9syJnB4LqkAKAQoliCILB0l24NpfZtnAuLMy1dFIo9Ho9F4fRjuCQM6iqQPchwORcgF6AXfA8Nrj6fz8gkLIwdUT6ZH9G3pLbz4hKG6MfAEUmXquWcD7fmx/67GdLbLJ6HdAkFgmrwvFxyC8oir55B6q3UVbEB3E1XXJI/c75RdUDXDRibZ8H+8X6Bu/l7t15JJgsqQj2c1+HZYgNfF8F5bedC8ZlCWT6fVyaTsaIwg6CQbPjqq68kyUYiE2WfnZ3pyZMnymazunnzpj7++GODdyhcHR8fa3h4WPPz8/J4PPrFL35hBaru7m4bn0rmQsp57do1nZ+f67vvvtPx8XGbrAqR5tbWlnK5nEZGRnT37t02h0M2BlOi0WiYs3H7RTpZL1++tL4cj8ejTCajtbU19fT06JNPPtHk5KRlH+fn5/ryyy/bUmo34ltfX9fh4aFu3rypu3fvtvUdQI2NxWKanJxUuVy2oiBGA22parWq+fl560e4evWqzs/P9ejRIx0fH1uXLvz9RuNC5+3o6EgzMzO6f/++ms2LhtRKpaKRkRGbGIljIVqm2NkptJhOpw3Gm5+fV7lc1srKivW4kFGAyy8tLcnn89kYgHw+b535dNBfu3ZNDx48MLki2EQoI/f19ZniLVkTTaPLy8uqVCo2S2Nqako3b940AgWyMsy+4RkdHByoXC4rmUza0DiKrRMTExodHbUIl74eV9vu+3AuvN75+bkWFxfV39+vubk5ayBGSWF1dVWbm5smL8LobGDdWCymiYkJ3bhxQ5LM0e/s7Gh/f98+T7PZ1LNnz1QoFCybPDo6snM5OjqqaDSqZDJp4xuOjo7M6WJbIPlASQ6FQlpYWFCj0bCMYHR01CJ/DCH1KgLgTh0Mzo56X6FQsIZoVxkCx4wiCfR21vn5uZElZmdndefOnbbgYXV1ValUysg01WrV4FV6pxjWVy6Xbf8GBgZ05coV1Wo1bWxsqFAoKBqNam5urs1mUnPr7e3V+Pi4Nb5Wq1WNj48b8kPAj6I6Dud1z+BrOxc34oJ3TUEOyirUtkKhYBeYZrZKpWJ9ALlczrBl6MlEw8ViUdls1iLyRuNCgvrk5MQ0hfh+IA1SSor3NLa50QDvnWYiuPau9IV04RyLxaIZM3B0+iU6vdzUAoiukaDp6elpU3bl36jxlEolg/QCgYBlflBzBwcHLavkcMOQwrjncjljnsHco1mQ90NnNllSPp+3DnyIAnQbp9NpjY6OWq8CjZSwzqCnurRqd5RrJwuMHkPhSoQcHR21qchyWYBxgbhOTk6MNIFxovcKmNYlopDJUPyEIEL2BlGFc8Z5Oj091eHhYVtDnTsCGVjUneRIfQgoEWdHJuPWYN5mwQSkKc6db+KqVfAZiZBxHGR1LuGDniy3xw3GEVEzTFK/369QKKTz83Prq4jFYtYLAsGEzB2CCs+R506dgv2lwA407maMnDuyok6di9sqwZ9zuZwFvND9+TcITwTV3GHqMtwLZH3cvaNuNDQ0pGazafNe6BniWWA7YGj29/db5oNKBHuKs+W887zZU8gcbmMlzlSSzZ753p0LxSi3+35iYkI+n88YMHxgekf6+/tNJI0UuFartW3m6uqqRY4UrBBlZGYJReREIqGBgQEbPgYLx432Sb+Rujg4ODCYgk0ZHh5WoVDQr371KzMKwCxun4PX67VLAj7f6SJ9RwSQSBXYBRo1DhkG1MjIiDUGooYK/FitVk3JeGdnx4wFjhxyglu0TSQSppTqRt5nZ2f68ssvDf5BO+5VMUbpotny9PRUP/vZz4yJxcEl5XYLlvz5bWAdzh9OhImmEDey2aydL5gtwATUE6gr0QWez+e1srKicrlsmQ/v14UtkLQhauQ8l8tl279gMGiSGx6Px+jxZCrQiYeGhjQ9PW2MPt4HOloEQzhQnhPP/20WfTsEW/F43DLm4+NjffPNNyqVStbZTi2VGTVIJxF0SVI2m7X5TGSwDPZqNptKpVKmuuzxeKwBMpVKWdCDsnQgEDAlbppKiaA5g17vxTRSskrozJxNt2gP+QjniNPqdPE7gO+oa3i9F6rhu7u7lvmGQiHNzs4a2xL5LNhXbt8gZxelBtRE3H67qakpoxwnEgmFQiFlMhmdn59reHhYiURCzWZTGxsb9hq0O1DCODk5MTQGG7S1tWWIFOcd28L3uzUisvfXWW80iVK69N5EAdDfGMBEsf/mzZsKh8Nt9DUiIVRsq9WqNjY27MPRzDM4OCiv12vFamTKcS7IGpTLZavXHBwcaHl52Q5fOBy2gWBkIh6PR1evXlUymdTOzo5WVlbU3d1tNDyMk6S2iMuduNdp1EPEhJAczouOey4V+wcRYnJyUqOjo0Z/xJjTPMZUxc3NTYsUycaOj49N9gThwMHBQeVyOavrEOWl02mtr69LkkXjOJdSqaT9/X1JF0PPhoeHlU6ntbS0pK6uLk1PTxtrBskX9yIR0YJFd7JQneVw9/b2KpFIqFaraXl5WUdHR0YaoIBKlsNlhKSAkkM+n9fGxoaxjagtkJk3Gg1zYtHfKHkPDQ0pGo2aVE48HlcoFFKhULABUJLs+WBIyCavXr2qubk5g5XJqsDO3ZHXbiMbo6TfJnPhDAIlsoeVSkVLS0vmaMvlshXOQQagvBM0EL3ncjmtra210bPd85NOpxUOh/XBBx/Y3kUiEUUiEW1tbalYLBopgE59JIgIVImggbgWFhY0NjamFy9e2Az76G9EFiGTuAGRWyt6m5rLq1kQ4wjILFKplPWQAFEh4oqEDZ30jHVvtVrK5/M6OzvT+vq6oSgQL0qlkg2bc/euu7tbu7u7KpVKGhoaMqbp9va2qR7gSHmm1LnJmmHBSrIM2mVDQlcnoKAu+L03UboCd3hwIi1k4SmwUgMhfWMeOAW/4eFhxWIxMzoUaoHcJBkMhbEqFApWyHKL+aRz9XrdpP/p4QCiOTo60t7ensFMQBQcRFSRiVqJeLlISKe8jaovlxHZbCTHg8GgJicnNTw8bMaxr6/PRtFySKAHEhGh2cTeoZVGVgk1m8+FtAhwBxlOsVi0LJIIi34GXoveAfaeTmwKf3D1X+2bgE6OptjbNAFSIAV+SCaTGhkZUXd3tyYnJxWPx3V8fGyyNYwmJqJ0C61ubYHiuTvWmt4ZZopIMsMgXeiQUdCt1WomKMrPYnCIqDl/XPpcLqfT01OjkmLAJRkZg/vAfuN83qaJUrqcnEhggdMdHR1t629BqoQMYXd3137e7/cbc4s9peBP7RJR0GQyqWAwaA6Us+eyjsjcCBpcKIx9pPeLANDtZge27enpsfotEbgkg9RQQug0wIH4QxaZSCQ0NjZmNgcExiUGIaGPnSKbZ8IkWZl0wfZyx0ZQc+Eu8hpudtNqtcxG0KKATSNYDwQCyuVyVjfn+UMIoNZLGQJIOxqNmrwMNaM3OX+v7VzANIkAhoaGNDExoVAopHv37ikUClk0CB9dutDUYj7A3Nycurq6NDc3J5/vYuDU5uamRVMej8ei92Qyqbm5OTUaDW1tbSmTybQdZDb84OBAJycnGh4e1tWrV9tYY3y9ePFCT548Mf0wDiVd6m6ajVje5OSkKpWKvvnmGytOTk5OdnwwgYS2t7eVyWQ0Pj6u999/X9FoVB988IESiYR2dna0sbGhYDBofTaPHj3S+vq6ksmkFhYWNDAwoA8//FChUEhLS0t69uyZuru7defOHfl8PhvGRMTk8XiMeru7u2tpLhEScOXQ0JANEWKuBPWSFy9e6Lvvvmvbv0AgYHpmGPnd3V0dHh5qYGBAExMTqtVqevHihba3tzUxMaGFhYWOay5kkru7u9rY2NDNmzf14MEDRaNRXb16VV1dXTZSu6enxwT/vvjiCy0vL2twcFDz8/Pq6urSgwcPFAgEzPHRSwAsgLOenZ2185fNZo3OSkG3p6fHMkrmknR1dSmZTLY1kj59+lS/+tWvLDrFCTNAbHp6Wr29vUZ1JvDwer2muRUKhRQOh9868sYY0S0PNZpxC1Cke3t7bbQ5e5hIJGwE9scff2x9UEDP9HKh0zY2NqYbN26oWCzqL/7iL5RKpSx7xkm0Wi3T9pubm9ODBw/s83d1dRk7cnt7W7u7u1ZvJciA6JNIJIwunk6nLfigjpHNZjUyMqKBgYGO7zDzcNbX17W6uqoPP/xQf/Inf9LWWHhwcKBUKqVgMGhjhR89eqS1tTX19/draGhIvb29unPnjsLhsKE+tAz4fD6jfxPgVKtVI9IQ3PO5ms2mNjc3VSwWNTU1pdu3b6u/v9/QBKD2ly9f6smTJ9b6IcmcHnTx3t5eq4dHo1HNzMyo0Wjo0aNHbSKgr7te27m82uQkyYw0mCwRAoUrUjskYKDDEZm8Srl0NYjcngYMIu+BghOvzyH9/9p7s9/GsyzP70tSC0VKIkVx074rFHvknllVWVXd09XTVXCjxw8zMGwPbL/b8LsBv/gPMOC/oA3YRs9gMB4YXtDAuKd7as+ozNgXRWjfN+4iRYqrH1SfE5fqmhklI/2mCwQyM1Licn/3nuV7vud7SO3IOKT25juaitB8cmd5kAnxOfh597t/F02AbqHsMiU2m81akRc8liI6hoUmPWAAt1mSegT76Rb5wU3BTikEsn/sK8+N/XOfO3tAlO6yR4DBqMm5tGrS//eBxXgtPoP7ni6VmAvg9q6442GBMxhq5RZpXQiGwrfbF8L7UvikXuaeN+kd1fMP0dfRIYPqzMLw88f9LC7Zo9P9u7yH7CPPBoVzsjKXfs95AWWAfMAkRbdpkr1z9xCYsVgs2jNyKdhuvwfQqltHcRsz3echyZ67u1ecexZ32aX7d7Kg/Lr7iK0AnsdYs4fSuzvc1dVltor947tCiHL33qUzu9R6F6qCtML5Zp+kdvo2/8/9e1o43N4k93vxffkdtxXlKuvKzgU6IHTW09NTvXjxok3mfGtrS6urq/L7/ZqYmFBXV5c5m3K5bFEZm44Egpvp7O3tWZRIDQEcmy8HJitd4MhMnDs+PjaFz0KhYN3V5+fnVuugQIo2FqSCSqVidZ2enh4dHx+rWq0qEokYPXltbe3KG3t5MR+G2RfZbFYrKyvq6+tTMpm0orQrgyPJVA6A5NC1gkVHZy2MEWiG1BugP5OpwewBjwW/RYH69PRUv/vd71Qqlezilkolo6NSzwAKq9frevnypfUrgHfv7+8bFApk9/bt2/di6ng8HoMEfT6fHj16pN7eXs3MzCgUCllWA+ZPhAYTqVgsWh1Fko6Pj7W2tmaZsySj2jI9VZIxH4GQ0BuT3sG3vH4qldIvfvELg5bI6On8B65AJ+/8/NwicrJAHIvHczHuF+P4Po5FeifhBOHB5/Pp2bNnlm2RPa2urhoriBrQyMhIG/SJKvnh4aENvwPa29nZUT6f187OjhFCaBuQpHw+bwy6VqulSCRic2HQ1Po//o//Q8fHx7ZPrrIE7L1wOKyf/exnOjs708rKira3txUKhUyd4eTkxNSFCbrozetkoWh869YtDQ8PKxQK6eHDh5blhUIhG4aGXSRAxWngXLmD9L7wfKvVizHeUJpBdAiocTDSu6ZYGjVh4RUKBf3617821iMOIxQKGdxOeQL7iLwWem1dXV0G93JmgMyuuq7sXGiGom9gY2NDBwcH1vMC5r23t2d4K70RGEU+bKVSsY5VZhmQbmWzWR0dHVl0SO2EKBIvDo4/MjJixgKa87Nnz3R8fKxEIqFYLGYjRH0+n+GHsD1wcNlsVgsLC4aXQ3VmlC26T51mL8gyUF95/fq1vv76a2Pq0AuEM3YzLjIs6R1mzvcFbyVST6fTbdpp/DyZINRNqNdQkImqCoWCFcg5tNAcXVkXXr9er5uGGcPFms2m1RNgvhWLRZ2cnLx3zQCGDlLvRHxnZ2fa39/X7u6uRck4MqIzhAfJuHEGNKNKFw4nlUpZjYPfazabxopDMqjRaGhiYsKM9vn5uYkNHh4etvUJEVTxHIPBoMbGxpTP5/XixQul02lNT09bhk9mgyGALPM+y5UJajYvVHKRnnG14Y6OjmwCJBna4OCg1QeAVekv4byRbbs1JorfROswt2q1mtGgcSC8R7lc1jfffKO3b99qfn5es7Ozlp3yrClk37p1S6lUSk+fPtXh4aFJ+jOgrVarWUAEPNzpGaTVYWRkxAz51taWPV9JBtmxTwTS1PxAJVwmGwxR7iTiwAQYfr/faoiUDVw7BIIAkpHP5/Xo0SOzz5Ccbt26ZYkADa5TU1PKZrN6+fKlUqmUwr8fj0KmREbpPvurris7F2ApnAUfTLqQot7d3VWr1dLU1JRJsXR3dyuRSJjmlyTbAOig0rvhWF1dXZqfn9fU1FRbN+7BwYHq9bqmp6dNmoPiNAYZfNLj8WhxcVGJRMImqoGRk1KTboPn8t/5fN5YUZLayANMjOt0ZTIZ+Xw+Y43Asmo2LyTgabLE0BOxuNxz4CuXUYJ2Fvs9NTWlyclJ5fN5o8HSYAZlEbVqKIocYPpaRkZGrHGUbIToH7jC4/FYr4erTYaxBl7jObsKzJ0sPifkCwrOwAKnp6cKBAK6ceOGfXaK6279AwPoQnjd3d3WWNjb26vJyUnrleGf6I8hH8Q5dmXmoZkvLi5a0MMQLc45n6tarVqWBCwCi4ieG/f8oe31PgvnShbqUqQpuHd1dVldxVV/cCEXCA9AjJwRRjPfv3/fBuIR3BCN01ZApst3pK8MIgiK2/F43BogcbTUa6B600dCRgWCQQDgkjSGhoY63r/t7W1J70aCSO/61gicITvwnpKM/UoPEf1q1WrVyB3INnV3d2tkZEShUMj6BavVqra2tuTxeIwxBvWfQBjHFIvFLJNyhTIHBwcVi8XMeQOHU38DbqN9oVarmW28rKN21fWt5rnA1iKDuXnzplHWUqmUFdXdhTQMjXlQA+mJ4cLD5Lh586YikYg2Njb09ddfK5fL6fXr1yoUCopGo+Zc0B/b3NxUKpXS7OysZmZm7EKcn58rFAqZY8OxcGkl2YEkI0KUzz08RAmTk5NaWFjoGNZhiiUOz+/369atW0Yn3tra0tTUlObn59vqPThFGDYU07mYSF0g602qu7y8bKq+BwcHqlQqunPnjpLJpHK/H0PLs6NBkChnZmbm7zVAQp92WT/0aYC3w6W/3Czp8XhMubbTgj6zSKLRaFs/CAFGNptVMpnU5OSkOWefz2f/DTUbeM2V4+E8B4NBm/i3tramr776SoVCwfSXgExrtZrBaGSPwA3BYFAffvhhG23dbUgELy+Xy/ZcyCphkFUqFWsCBcuHlt7p/kmysx2PxzU6OmqZg9tnlkwmjRyCYSIq5vNjKGEv0lxHpjM2NtZ2h5HXT6fT+pM/+RMjy6BUfXBwYD0VwLaLi4vGxKJhE2gZxiX9XYxQyOfzOj4+NviL4X4MZ4tGo99KMv7yWl5els/n0/j4uPWOsS+ZTEbHx8eanZ3VwsKC1fqazabGx8c1NTXVZn/y+bypM6RSKYVCIdtXAuKdnR0VCgXT+Ds7O9Pdu3fbgoxms2loBWd+YGBAt2/fbpMwQrOs1WoZAQMCE/p10MlBbcj+uRuxWOxbjSq/snPhoLkSHjgG0j2ghsuFa6ITt5tUkjVqgSdKMk4/RtQVxBsYGLDoBSkWV+8GGqzLEydaY0MQ2kSwkaZEqHyulpNLMAAa6vRyA4udnZ1Zz41bxIOIQM3FhcGom+CMSW0RqMMZ8XPShcHAscL0cDvMgTvcgp7bV8CzIFuigYqMEtyeTmsgMGAAsF6XhOFGc992QWMvFos20dI9fzwneoEoRqL3RV9Ks9k0Oio9LLw2F46zA0aO/h37J13AWj6fzwrdUNYxuMAILmkCxwbUGQqFrFGQ8wdkQpaIASOLfB/nQk0EI+IWhtk/2Fhunccla+BceCZdXV0Wcbu9GTh0ImocAxRd6racDff8A8NALXYJHNwNr9drdxjqPX1KLqmEc8J6H1jWrXvCinUJNAQ79CPRuE2dGkjQJR0wZZYM1yVPEMTU63VDDvr7+xUKhdrqH9RMsS98b/es8PM8IzJ2VEeANTlr7JP7T/645JV/37qycwkEAmo0Gnr58qV2dnZMmwumk3RRDF1dXTWnQZ3ErZUQvbOpIyMjxqao1WqmeUWKPDAwYEXODz/8UKOjo5ZSIuXCg6Dgzpd3G+5isZi6u7s1NjZmn294eFjZbFapVMocC9AF34nCJZ+l08sNrXV1dVW/+tWvNDY2po8++kh+v9+arDKZjH7zm9+ou7tbQ0NDVgeB5YUB53kkk0ktLi6qVCpZdzjRTjgc1t27d1WvXwyqKpfLunXrlqanp80puLLzQBd8f2iw2Wy2TXkamIshTqlUSjs7O8rlcpqZmdH4+Hjb+FcuEYe2U1gMquzy8rI2Nzc1MTGhTz/91Awmmklv376VJIMVoQxLskuUSCQUDAa1uLioDz74QPl8XisrK8pms6Z0QH0psZUAAJqtSURBVBG71WppenpaXq9XDx480OLiohnfcrmsXC5ntOLd3V2DRYCdXGfl9XptTMDc3Jzu3r1rituoFA8ODhqM2Wq1TIGCzOh9ivrMfX/+/LlWVlYUj8d148aNtu7x3d1dra+vtylXXGZwAe/29fWpv79fn3zyiQ3xymQy2t7etsCObOnTTz9Vb2+v7t69q/n5easVUkPxeDymg4cyRTgcNql4V2KK7HV8fFwLCwvKZrMWdNC/AUnIDaBQQ+g0c3nw4IEajYY1bw4NDZnaAqMrqDtj7ziLaBvynUdHR22W1AcffKBSqaTd3V2rYVEXTiaTajab1jDMULRisajNzU1Vq1WDvyqVijY2Nuz59PT0WIDoqpSwH9FoVA8ePFA6nbYG6lgsZqMVyLI4v9Qor7p/V3YuRLdoSzHiFoopUEMmk2lTisUouh2eoVDImCiwb+jkJnLi/xHBINznUiTJmDj4l5kgrrcl7QQ7hHRQq9XaFFQltTVgEV250Uknq7+/3wp4zMHACbqRWzqdtv8G+3QZH11dXYaB9vT02MFymwxTqZRpPpHN0OlLkxVkC0l2CcjypAvHDJMFnBYnRP0Npgm0amRZJJkjwXm9T38Gr+fz+ayZztV54/tT88FBurIhvD/CqtSy6AWSZLUbmF7xeNzOGdAZqhSw4jiPsJ/4jNI7IUc3+3VlSsK/nxPjPm/3+WAI+P/vu4d8dwwxtRS3lga0SRADJMYd43sQ3aJX57YMYOzJ0lyHwB66Cr84MGpABAx8BuAdniMoAq9HrZIzyv4TYFAr5v51uo+0W3DPeEbYQPrMGAbInXUZYsCBUJIDgYCi0agJq9J7ls/nTa5JkqEGQFSuFAvUenpUyOrIOsnIyQrpQyITghBEAMgfIGC35ePbqBx8K8n9VqulhYUFjY+Py+PxGGWY9JeLxGbQ7Y2UdyaTMagJ4Uskvunod3Fcpg8eHR3ZRd3Y2FChULBRpqTmFHmr1aq2t7dN36i/v1+lUskGWsEHpwkUoUdXKmZsbEw3btxQs9nU48ePtb6+bgXlTjMXMr+bN28ao4ooG2dM4bi3t9fox3y/XC5n9F6YOplMxiI9IluK2DBbuAytVsvmmeRyORvTyqWHUVKr1YwIQITl8Xis4IocDBH56empFWf39/eVyWQUCoU0NjamRqOhFy9etE0XfJ+aiyQtLS1pYWFBkox9hswH9SA69Ck2+3w+Y6vhLAuFgjY2NqxQT3YLnDI8PKzx8XHDtM/OzvTkyRMtLy+bnBCBCVHy9773PVMEyGazdkExuNDHvV6vdnd3bZAdIqT7+/taWVlRJBLRnTt31GxeDBtjhkoul5PX69U//sf/uKM93NnZUavV0tzcnKampgxRYI4Q0DWBAnRzmFyFQkFHR0eS3vXrvH79Wo8ePbLAAuFa6mzo5yFf8/LlS62srOj09FRbW1vmqHEYYPp8FujKBDoej0e5XE6BQMBmLcEUZHro4eGhksmkPvzwQ0nSo0ePtLe3p7GxMctCO90/6SKLTiQSlom4ET4KIDSm8t2AUCFQUCdBOVmSEWtw5jA5CZwrlYo2NzdNd+3g4ECNRsPkX7q7LzTcOIM0U5NFZ7NZq3E1m01zhO75pJ0kHA7r/v37ajabevr0qXZ3d03f76r7d2XnAnY6NTWloaEhHR4e6vnz58bKqFQqZsxpAvP5LmQRksmkTTgDb6xWqzasJhqNmlQ2h5TiKnS/dDptFzqfz2t1dVWNRkO3b9/W2NiYGVi0wNLptHH30dWp1Wo2W35iYsIKvMj9n5yc6OTkxJoUMQYvX740j/8+NRdJmpub0/z8vDY2NmyUAMwbisxer9c02YhUkDGnflWr1bS3t6ft7W2NjIzoj/7oj+xnMbZQblm7u7s20mBlZUX1el137tzR2NiYBgcHNTQ0ZPIfuVzOCpelUkn7+/vG6kFzSHrXSOvz+Wz41dzcnO7du2dNeXt7e2asOr3YQFFLS0uanp7W1taWfvvb3xpMR02gXq8blMozJJhBZcLn85miAPv3x3/8xybOSLd5IpGwbLJcLmtjY8McL86O4nU8HtcHH3xggc/x8bHBv5wxfo9C9NbWVhtLiCFcd+7c0fz8vFqtlr766iutrKxYEft9YDGoqbdv39bc3FzbHWaIHecGSRqyO4ZLodZNRri+vq43b94oFovp888/b1MiRz2hXq/r1atXbb0vpVLJWg4Qruzv79fQ0JAajYb1qLjPD0IQNF36wlAW4HxubGxoYGBAk5OTkqR//a//tV68eGGsT4z5t12Hh4fy+Xy6ceOGpqendXBwoKdPnxoyAJTZaFxI+sRisbaxyjhKAmsQm2KxqFAoZAojBJTUUggQ6YmCEAV5RrqAfEdHRzUzM6N8Pm90eHqH+PlyuaxsNmt0+r29PUNzvF6v9vf3dXBwoHv37hk5C+csvesZu8q68i7v7+9bmgWzwE1xgZ7i8XgbtbNWq5n6qSTLXCjaAdXwGnSTQ6/1eDwGX7GpsEqazabRFIGVSNV5r0wmY8VY6jw4LlJmivcTExMaGRlRMpm0QxsOhzU7O2v0wE4vNwJ7RCXlclnj4+NGYEDGIhAIGIEBxokrVwN9u9VqtYkqSjIlUzqheQbMQSe1paCPjhoFUg4xF4KLzN+RCVCDAl6iQ3lyctJqcJVKpc3QR6NRS9U7WRRQDw4OLGNCTjyTyahcLls/A1Gcm85zViTZmSESY/+oCXKecFhQbmkqBaKQ3kEvxWLRGtEgXVSrVZ2cnEiSKThHo1HL9AhU2HfO39DQkEnuMxMmHo9rYmLivZwLkEYqlbK+D1hvOC6g5kAgYPsEzMUddtUZIpGIJiYmTMeN7B4jBAHI3S/Olzs+G0JJOp224JNAin4ZpFuACBlWB2oC3T4cDmtkZESnp6fWl3L//n2j2He6hzQ7MuIB5RHIN7Am6c1zCTDAU9gaoCkQl8sNl6A42DRIIvQ7Ad/yujgNaobArgTIzWbTEBPGdACtu0oAiUTC5nPBWMRRU4/5zmGxx48fy+PxWKcx1FIOgsfj0eTkpG7cuGGGqtFoGBzBctlc0BaJQqjbNBoNw1MbjYaNEqU/A7ydjcJREBmga8Uo1ng8rqmpKaPqug1MbqPa/Py8JicnlcvlTAJ/dnZWk5OT9p07xWv/r//r/5LH4zE9s/HxcX322WdqNBr61a9+pXQ6rUQioaWlJWNWAZlQYxkfH1e9XjeZfQZOwTA6PT3Vzs6Ojo6ONDk5afAljYAU93p6eqzBDE0haiytVkujo6NqNN5pKEWjUd25c8eYVzRrkklySL/44gs9ePBAh4eHevLkifU1JBIJhUKhb3UwLy9gTQwje9VqXWhTZTIZjY6Omj4TzgWYgq54n++d8ivKtXwmuqKR0Af6IwCi4a3RaBhFnP04PDy0iLqrq0uRSER7e3va39/XxMSEfvSjH1lW32q1dHh4aGKgyKp///vf1yeffKKtrS39/Oc/19nZmUE5iUTCqLmdrmw2K4/Ho5WVFe3v76u/v1+xWEySDLYJh8P2nOjKXllZ0d7enkKhkAkphn8v2x4IBGwoHbRWWFxdXV3a3983G0G9lREP1eq7efPSRQCRzWatZuDz+ayOkEwmdf/+feu1ACpm0BrIxIMHD7S0tKRcLqetrS01Gg199NFH+vLLL+35dbqgOZfLZe3u7tqockmmtB2NRhWLxdoYl8DtBHx8PwJsanEEZNC8Cbp9vouxI9T2ms2mDg8PjcoOpTyfz1tTJ6MhNjY29PbtW42MjOizzz6zkgOKJjs7O6be3Ww2de/ePc3Pz5t6eK1Ws94k1Ci+c+dCURaslcIeMAPFcjSKXDowFFcijj9EB3RZZaTmGDuiSbcoxyWjYZO/J5K+rNVDkYqfoRjGa8Jo6u/vbxvPDLEASmCnxpFDTaSLzhU1KnodXLozqbBL4ebn3T4Klz7sUl/ZJ2AA9hfjy/5R3AdCY//4PX4eJ8LBpyjI7/H8XfYRe88F6jRq5HwAPZBlsGCCkZ0Ap0D/dF8Hcgbn8DJVlfdxi9Lo4RF5UmRGjZdLTs2QIjzFan6OKB6mFbi9myFBCiiXy+b8iTDfZ7k9PvSOcHYoSBN1SzIyifvd+F2CCiBw/rjEA86hpLa/5/7xHGiQJLB0i+Hcffbe1d0COuKZkjGGw2GTVoF0wXdyz0KnC4UCHCDfg88LFIqdRPJfekd04Y5J784qi9YK9h4yEzaIe+W2M0AScJvCL++Ve4ep6UALZ+85g/QRoXDA/nOGrrKu7Fzm5+cvfuH3xSnSQpyBJLso0EKhImLQ3YY12A2MSp6dnVVvb69hy/v7+8ZoGR4ebpMlh7FWr9eN2nh0dKT19XUzMl6v1zr6YWS0Wi2tr68rlUppenpa9+7dU7FY1O9+9zsrbkEJBpYg0mJeTKfyL7du3TJnAcRHYY0hSNK7YhkRci6XM948xpmO/ZOTE5OO+fjjj9XX16doNGqO9vHjx/L7/ZqamjIIwTVkPT09htMeHx/bbB0cICkyhu38/Nx0nWKxmD788EMVi0U9ffrUCuT0OuEQOdgUWzvdv8vd6dQxGo0LSfuTkxMlk0m7AMApBwcHOjw8NGPG/2fY0vHxscLhsG7fvi2/3698Pm9dy8inf+9731M8HreaCc16Pp9PH374oW7duqWNjQ09fvxY0juG1dLSkm7fvm0Oo1wua29vz+pZf/RHf6RCoaBHjx4pl8tpfX3dCCxMecWAbWxsGLT605/+tKM9JFhw+zMIOMD+0T+rVCo6OjpSqVQyFubp6amWl5fV3X0xcwmnikLG3Nycenp6dHR01DYkDbpyNBrV4eFhW+1UuqDpLy0taXNz0wJT7MzS0pIikYgVtYHSKGRzh2nshXKM2gFOsFgs2oTPTntdyPJce0cAnMvllMvljKFZr1+Mm6CWCxkDB46i+N7ennZ2djQ4OKgbN26or6/P6jc4deDvSCRidRPsXCAQ0M2bNzUzM6Pt7W0tLy/b+W82LwY6zs7Oyuv12rOE1DQyMqJPP/1UpVJJT548MUV16tLUpAms0um0/d2VzttVN5bL7Ro5d36I2zDJw4V5Qs0AvSZqIjAYXHohTUAYeyI8d9QvDBdqBpFIxIrMfDaPx2OpIQ+UCCKTyRjUAF26VCpZtMg/SVuZS7O3t9dWIP82CyZSNpu1pkNGO/OafG53H2HMUJvp6urSyMiIdcQfHBxY1AlMAWMnlUopGAxqYmLCIh3SaiInpOLprYBQ4LL2+Dw0KRaLRevWhbbKd5Nk0RXRJDRh5kl0sqCGu5km0iiMfXazGbBo2HHsb0/PxTiD7u5updNp7ezsWHQNDEQ3/+bmplG9ySCIPKljDQ8Pa2FhwRoHXYfK1EAMOFT94+NjTUxMaGZmRrlcTi9fvpQk2z+K/m7NiEDsfZoA2Rs305DeqVdQz+vu7rbAsFAoWLbC30FdDgQCBjsmk0lrcj46OrJnkk6nTb4mFosZqcKFpekXqVQqxgIlG2H0Ac6X+1mr1RSLxUzCnuZgaoU8e5wO+/o+zgVYE1SDs8izpflRkgWNkCW46wRvQK+pVEqrq6tKJBKan59vy2bK5bLtn9d70b3PvB8yRhz91NSUyuWyVlZW2ppdY7GYksmkESigJDM2ZXx8XKenp1pZWbFMhTtOjY07e3Z2puPj4yvbwCs7F3eyXDqdNrE5okHXePEgoBMHg0EdHBzo9evXhv0DnXAY0OahE5/CMOQA6KNkFOPj4/bFT05OVK/XFY/HbWOldyNl6UFgkFl/f7/y+bxFmvPz85qbmzNdL2APSfY5+D78/bddUAppTHTTeeATnBywE+8NFdglBZDmkirv7e1ZJBiNRjU0NKREIqHe3l4T72S6Hz/j9V5Ijqytrdm8bTcTjcVi1rzojqmWLvDdr7/+Wl6vV3Nzc5qbmzOBzWw2a1kQQqc41E6dy/DwsNWB9vb22mZz0PDq8XhMTwrHE4/HFQqFlM/njU5NJE4EyTl2IRS/32+yIa6YJNk6rCOaB5nNQiBFExxBBdnq0NCQFWQfPXokr9erGzduaGFhwYIx7hIwD6xJnFSna2xsTM1m06awonQMdAK0wthdAjrmkuzv79tYYf64Ez9dFV6CwsnJyTbGHO0LKJNjO6h30SS9t7dnzayw6Qi01tbWrC+Ezzg5OanJyUnLHKR3GmA0OUJa6NS5RKNRNRoNLS8va2trS+Pj4yYnw3PhWRPkgg4kk0kruBMoAvmNjo5av069XjfyyPDwsCYnJy0Tpv/l5OREZ2dnCofDFryVy2X5/X7NzMyYQ4UklEwmValUbBz8zs6Ostmscrmcnj59Ko/nQiE5kUjYHed13dYS6f+nYWFQ4hBZrNfrWlhYsMMBiwaHQUFvcXFRk5OTevz4sV6+fGnZg/vBicwqlYqNKOY1wfcozkIHnJ2dNUbV3t6ePST6P2q1msbHx3Xv3j0rTjEXhdkp29vbisfj+vM//3OjSxPl0rCFYCCaU51mLvSQQJtEDt9tBIUAAQWxr6/Ppny+fPnSxuiCm/KnXq9rY2PDhmQhaQItlP4XoJnu7otBX16vV9lsVgcHB8b0A4ojbb5z545RJ12hz5OTEz1+/FjJZFL/5J/8E01MTFhEt7GxoeXlZcssw+GwRTw4rm+7EomEDW978uSJKpWKlpaWFAgENDQ0ZIXS/f19+x2v19umc8VnoJgcDAYNNuU8osEEC4rzTcRK5MiYB5wzwpm1Ws1YSn19fXYm6dtIpVJqNi9Uo3/5y18qmUzqP/6P/2NTyl5dXTVYUrpo3KNj2nX8nazZ2VnVajU9f/5cX3/9tebn5zU2NmYGGoYbOnhQg8fHxxWNRvX48WO9evXKjCfZC4SHYrFotQVGAAPJFAoFHR8fm7o4RpcGw7OzM/X29ppK7+bmpmXFUHp9Pp8KhYJWVlbMAeZyOSUSCf3pn/6pEomEBW+u0gQsPxh6ne4haiK//e1v9fTpU1WrVd26datNLsVluuFcxsbGFAqFtLq6qq2tLWtklWRj3CE11Go1szUoU8OORMjy4ODA+tIoATAEbGlpScViUc+fP9fp6an6+/tNmSEWi1mQDTMPJekf//jHikajFrwR3Fxu3nUbuv9D61sRvt2CnBtB4eWAdPhgwF1ERpc/lPvf7sXh9dzCNlGbW4zn/7tdsu5r8jNskPs5gaOoA13uguZ7uN/bLaJ/2+X+Lp/337W37s+7n+0PvZb7e+yfSyl1ZW3cPWcPgbzcQrf7PuwfP8/PAAm4+wcc5kY57ll4n8Vn4fO6BsL9bC5pAOjgD+2BG5Fd/s7uvru1CXf/3L3ieV4mBlwmDrif8w+dP/czXv4877t/7vsTIf+hc8jeuO/LWXK/7+XXZI8u74/bU+LeYX738rm+DNfxc3/o//E92EO3SO6+pvsa77PYD87gH8oi/5DhdT87e8Dnv2zr3Pdh392z9Yd+131f9sA9s/8uwoV7Di7byu9ieVrvA+Jer+t1va7X9bpef2C9H7fxel2v63W9rtf1+gPr2rlcr+t1va7X9frO17VzuV7X63pdr+v1na9r53K9rtf1ul7X6ztf187lel2v63W9rtd3vq6dy/W6Xtfrel2v73xdO5frdb2u1/W6Xt/5unYu1+t6Xa/rdb2+83XtXK7X9bpe1+t6fefr2rlcr+t1va7X9frO17VzuV7X63pdr+v1na9r53K9rtf1ul7X6ztf187lel2v63W9rtd3vq4suf/f/rf/rQ0v6u3tVSqV0tu3b+X3+/Uf/Uf/kRYWFlQsFm3iGkO7Xr16pZ2dHZtE2dvbq/HxcQ0MDNg8ElcSmvkOzDgpFAp6+PChjo+PlUgkFI/HbYCYO7+d93Nl4oeGhmxEarVa1fn5uZaXl3V0dKR4PK7x8fG2ueUMMmMsssfjsaltyGxL0n/9X//X33qjv/jiCxtqNDo6ahPoenp69JOf/EQzMzO2B3xe5n4wIOk3v/mNms2mpqambAhXf3+//H6/BgcH5fV6bYphMpnU/Py8Tk9P9f/+v/+vdnZ2dH5+rvPzc5vxwKAnd3Z6tVrV/v6+KpWKZmdnNTU1ZcPLarWalpeXbcQvM3dGRkbU19dnn7+3t1cDAwNqNps2MtUd4vY//o//47fev//mv/lv7N9brZZOTk60vLysgYEB/Vf/1X+lBw8eaGdnRxsbGzbbvtls6smTJ1pdXTV5cZ/Pp0gkokAgoOHhYRsAxaCrcDhsZzwYDKpQKOgXv/iFDg4OFI/HFYvF5Pf7bUJloVBQpVKR3++3oVjZbFa1Wk0zMzOamJho29uHDx9qa2tLk5OTunnzpo0RYGZHqVRST0+P+vv71Ww2dXx8rFKpZDPPJem//+//+2+9f5L0j//xP5bP59OdO3c0Ozur9fV1/d3f/Z26u7v1j/7RP9KNGzdsbDFi6dVqVb/5zW/0+vVr9ff3K5lM2igHJnEyWrtYLNrANcaZJ5NJFQoF/Zt/82+0t7enwcFBm/Xk9/vV1dVlw7IYssbMHcaMYyvC4bDOz8/185//XCsrKxobG9Ps7KwCgYDi8bh6e3tN0r+vr09DQ0NqtVra3d2153R2dqZWq6X/7r/77771/v3FX/yFjV6enZ3V8vKy/vqv/1rd3d36z/6z/0x37961n2VeSqlU0tdff623b98qGAxqeHjYvgu2jvHtjL5gouXw8LCmpqZUKpX061//WkdHR+rt7bU/kUjE7OnQ0JAKhYJNrmTMMdNBA4GARkZGVKvV9Dd/8zd6+/atJicndePGDfn9fvX399tMKYbAsX+pVKptSm+r1dL/8D/8D//B/bqyc2E6XjAY1ODgoPr6+hQMBm1zmMi3urqqaDSqH/zgB3aQxsfHlclktLOzI0m2qZJsKiXGsdls2px3Rq8yiTIYDMrr9apWq+n4+NhmRddqNQUCAZskicE8PDzUysqKDS7q6urSzMyMPTBeg7kMDAUrl8va3t5WvV7X/v6+isWijRDudNYBziMejysSiai/v1/xeFw+n0+hUEj1el2Hh4fa399XJBLRZ599psHBQe3u7iqVSml4eNhmeHMZueTuzBHGmDJ9E4eLk2XEMcaAeebDw8MaHx+3i9nV1WXDnQYHBzU5Oamuri4bz8pBPj09VTabVVdXl6anp22SIONqc7mcKpWKenp62oa/dbqYVZFMJhWLxRQIBBQKhey99vb2FA6HdevWLRuPPTk5af+Pi8P8FGaBEEwwZ4WxzNVq1QwBw6ZqtZqNHGZCZygUMgcbDAbVbDa1v7+vjY2Ntv3j2TcaDa2urur8/FypVErVatXOX6PR0M7Ojo1cbjQa8vv9CgaD77V38/PzNkSrUChocHBQf/Inf6Kuri4NDQ3ZoLc3b94oGo3qRz/6kTmCmZkZFQoFHR4eql6va3h42JxdOp22ceAej8eMEIFepVKxaZ4EMtLFQD7ucqFQaJs30tfXJ4/Ho3Q6rfX1dYVCIQt0JiYm7DyXy2WzPc1m085gsVi0sb5Mae3t7bXP3MlKJBI2WphJkD/84Q/NUTLIa3d3V+FwWB9//LH6+/sVDAa1sLCgXC6n/f19tVotm4hbLBZ1fHys7u5uDQwMtM2dqVQqOj4+VrVataF77vC6bDZrP396eto2Arynp0fNZlMHBwfKZrMKh8MqFos2KBCbs7+/b/vYbDY1MTGhkZERlctlsw2MrSaAuuodvrJz4aHjXAYHBxWPx+XxeNTT02MfZnl5WQsLCxobG9P4+LgdXEbBMp2QMcfMemZ079nZmc7Pz1WpVGyiX39/vwYGBmyITrVaVTabtXGxlUpF8Xhcg4ODNnbZ5/NZdhCNRhUMBjUwMKDR0VENDg5qZWVFGxsbbdMFvV6vwuGwKpWKMpmMKpWKNjY2lMvlFA6HNTw83DbU59us0dFRM/JEYoFAQJLMoB0dHenJkyeam5vTT3/6U42Ojlq2EQqFNDw8LOli/DCHg0E/GEa+z9nZmVKplA1sw3kzirpYLKparer4+NhGEMdiMXPOXV1d2t/f18HBgRKJhEKhkF2IcDhsI3+r1apN1WMWeiqV0srKis7OzlSpVNRsNm2i4vs4F3fYWzgctkmGzE8/PT3V8fFx22hZxhXv7e3ZqGF3EFaj0VBXV5fC4bBNOjw7O1OxWNTJyYkk2XfmvDJLvtFo6Pz8XPV63S4zzoWImfPn9Xo1MDBgs+Y3Nze1sbGhfD6vlZUVVSoV3bx5U4uLizbvnMFrHo9HgUBAjUbjvfZvYmJCkmwSYiQS0e3bt9XV1aVyuWxZ6+PHjzU3N6e/+Iu/0OTkpE3sXFlZsVHRwWBQoVBIuVxOuVzOJoIysphx2pxLpqESNLZaLVWrVbVaLZ2fn9vEyIGBAXV3d9v45c3NTa2srNiE2mAwqGQyqd7eXh0dHWlnZ0enp6fa3Ny06aLj4+M6OzvT5uamOZ5cLqdoNGpjiTtZnN+uri6dn59rYGBAH330kZ2jfD6v9fV1ffPNN5qfn9ef/dmfaWJiQoODg5qZmbH9k2TnltHt/Lc76IsJsGSDAwMDNrStUqkom83aYLezs7O26b0MaQNhGh4ettcYGRnR4OCgtra29Pr1axWLRR0cHFigH4vFdHp6qv39fZXLZR0cHOj09PRb79+VnUsulzPYo1qtmnEkPSYyJf3/+uuvLXp1U9VarWYOhKgTR8OfVqtlmUqz2bTXIEpnvjRRZ7FYNIjI6/Vaet5qtTQ4OCi/36/z83NJsp8/ODiwzAVjPzg4qP7+/rYJikQTwWCwbfzst13pdLptkh3jiXGsRG181idPnmhjY0MHBweWXg8MDEiSTk9PVS6XFY/HLdXFcfMaOIlWq6Visah6vW4wGAeUMbGlUskOt8fjMcPZ19enSCRis7dbrZb9PrO8W62WRVNkt61WS7VazWCwPzTN8Nuu09NTey3eIxAIKBAImOHi7BSLRT179kybm5s2qbBWq7WNkq5WqxobG1MsFrMMhjHUzWZTvb29SiQSBvESdXNxe3t7bWT1+fl5m+EvlUptEFwwGDRj29XVpVKppJOTE8uMotGopIsZ9/F4XKlUSgcHB6rX623TRN93mmI6nZYk+z5er9dGivPdgDQl6cWLFzo8PLT7xxkkiJEuEI2RkREzZjjaUChkz5xnwHnv7e2VJMsiisWi2QP+LpPJWAbJCHUCvkajoWAwqNPTU+XzecscJSkUCtn5BwrHlvBZOt3DQqEg6SLj8vv9Br2SuQDzMy76yZMn2t7etsmppVLJbJqbkS4sLLRNoySzZv9c2NaFJHHWzWbTRrj7/X4b9V6pVFSv182+YRf7+/vl8/lUKpXsLmA7w+GwBgYGVK1WLZji+5G1f+fOBUgrnU4bHjc1NaVAIGCRBtFpqVTS//w//89qtVr68MMPtbi4aLOhK5WK9vf3VSqVLMOp1WqGU4P19vb2anBw0CJ6Dgn1lsnJSbVaLW1vbyudTisejyuRSKhSqej169fK5XIWxbgHA4O4sbGhly9fanBwUJ999pl5ZYwNc8STyeRVt+jfu9bX1y3CKBaLlqL39vZqeHjY9pFo5q/+6q/sQjabTY2MjOjmzZtqNBp6+/atcrmc/viP/1gPHjxQLpfT48ePVa1W7TWYf35+fq43b94on89bZMMFr9frKhQKKpfLCoVCZkwrlYrBQeFwWK1WS7lczuAKn8+n3d1dra2tqbe3V/Pz8waXuRlUuVw2h0PNoNOLvb+/L+ndiO1wOGwRcSAQkNfrNSN/cHCgf/7P/7m8Xq+WlpY0OTmpcrlsmSKR7PT0tBYWFlQul7Wzs6NKpWKZyMDAgGKxmOr1unZ2dlQqlexCc9659Ol02iLIRqNhGHUgENDCwoIajYZOT08NSvR6vZbV9Pf368MPP9Tw8LBmZ2c1Njam9fV1vXr1SuVy2Rz++zpnSVpbW5P0zkFTHyW7Y247s+L/1b/6V5IuZscPDw+rq6tLiURCjUZD6XRa6XRaN27c0K1bt1Qul7W3t2cRPeerVqvZeSqXy/a8gHmazabevn2rTCajcDisSCSis7MzvX79WplMRoFAwCCw3d1d+Xw+i7yBkXt6ejQ5OanBwUFDJvL5vGXwQNoEVJ2ug4MDSTJ4NBgMWo1ufHzcgmW+wz/7Z/9MkjQ5OalEIiGPx2NB8cnJiSqVij766CN9+umnKhaLlsFSBmCRaeK4e3t71dPTY47+9evXOjg4MKdeLBa1vr6uk5MTDQ0NaWJiQrVaTYeHh3Z++QxHR0e2fwMDA5qcnFQymTTHjHPHuZTL5Svv15WdS7VaNUiFi9TT02O1E1I3sNVisaharWbpNlFLV1eXenp61Gg07Pcvz4gmGuC1u7u7VavVbGPBy4maXQzdNV54XOndjGk8Pc4rEAjY5+DiutGVm4ZSzOpk8f2J4sgCgAMxwIFAwGonRIfu/pIluoeM6IbIm2fE37OXZCeSLPr3+/22B279SXo3j9t9PhzOYDCooaEhKz5Tb3AxXyIzjHKlUunYufyhLIh9gGzBc3Mjw3K5bA6D3+3t7VUgELBos1arqdlsqlarmUMnQ3GhOH6X78P5I/N0Z8hfPuuX5637/X4jZQwODlp0yfsSSRJ0cAbfZ7nZBk6fSJjZ7rz32dmZcrmcOYdKpWLEF54DUDL3U5I9CyAvd0Y8++HWrzj3nG3+8FqcN/aP1yF75OzymgQ37hl04eD3cS6gH+7seshH0oXtAnryeDxKpVJWXCfww66wOFPVatWyU56Fm63yvfnO3GnuN//f3T9JhvSQdXAueV9gyL6+Psv4JNlzxX5KMhj4quvKzgXDkEgklEwmNTIyosXFRfl8PqXTaeXzeQWDQX366ac6OjpSLpdTPp+3giWrt7dXDx48sC/CwYMccHJyokKhoKGhIcNwo9GoarWaXcJSqaT9/X3DCGGKwDShJgEMRJTEYfZ4PLpz546+/PJL1Wo15XI5nZ+fq1Ao2OZOTk5KeueUlpeX9ebNG7tE33YRtfP6kUhEH374obq7u61uFIvF7L+pP3FRwuGwsek+/vhjeb1eTU5OWt0pnU4rlUrZ/o2NjdnvJJNJRSIRTU9Pa3p6WrlcTm/fvlWlUrHaBNmIy6rCuZCpclC7u7u1uLion/3sZ6pWqwbv+Hw+HRwcqNFo6ObNm5Jk5I/Xr1/r0aNHxrj7tqtSqVjUOjw8rJGREd2/f9/26ezsTAMDA7px44YKhYI8Ho9FzNSegDc///xz9fT0WJZKpnV2dmbO2a0XcdGGh4c1PDyss7MzHRwc6Pz8XOFw2GC5Uqlk0anrREOhkKLRqJ13zgHGj/eFSOLxePTjH//YDHWj0dDr16/1zTffGDuyk0WRHfLL+Pi4PvzwQ3V1denw8FDZbFb9/f26c+eOTk9P5ff7ValULDoHepRkGQjF7XK5bA5ne3tbuVxOkUhEY2Nj6u7uViKRUL1eVzgc1tDQkBEmarWahoaGjNWEQ+H8soLBoBKJhGX6QI0PHjzQ+fm5Fb7T6bQFWvPz8+boGo2Gtra2tLGx0fEZPD09NYdP7efOnTvy+XzKZDI6OTkxJCSbzUq6gEi5Azx79gNnfnx8rFqtZjA2ddD+/n4NDw9bENjV1aVkMqlEItF2BqPRqEKhkNWce3t7NT09reHhYWPbuQ4qkUiov7/fnv/5+bnBnzyXVqulxcVFC1RbrZbW1ta0trZ25f27snOhvkHUOjAwoKGhIXk8HqNLxuNxJZNJK/xD4S2Xy22eN5FIKBwOq1Qq2YUkgyHaHBgYMOMGfDQwMGCFbHBaDpokg9WCwaAZQfDWaDTahi1jPPP5vJ48edKWuhNVYniImqD5dbKIFDlgfX19SiaTFn2AI2N00um0fD6fvT8RBGyPYDCoYDBo0AMGlgJrKBSyyBFaaywWs+cD3RnDcXp6qkwmI0mWDfFZSbd7e3stS8TAU9/I5XIqFovGSIFyCatobW3N2CedLM4Gji4Wi2lsbEw+n09bW1tG4QW+ofCM8SYK6+np0djYmNX6pHeEisvZH1kY56Wvr88yc6J5CtvlclnFYtECpd7eXmND+f1+C4A4A0NDQ2YklpeXVSgUDMYBcsZxVqtVvX37VkdHRx3vn/Que6YuNzg4aOfh+PjYvk9/f796e3uVyWRs3zgPLmzNd8F4s/L5vA4PD+X1ejU6Oiqfz2cZOdBXPp834wg7EaQC8oO7hziXvr4+hcNhe71Wq6VCoWAtAwSJPT09ikQiki6caq1WM8JGp86F7EKS0cshNWUyGZXLZUWjUXOCAwMDbXVKl0iCzYJMQYZFhg8MHQqFLBjxer3mcGDNUqtyM2ho4KASnHuyvKGhIbOpfr9fp6enbWwzIGD2j7uxtbVlTNSrrCs7l9u3b9tmpNNpVatVnZ2dye/3KxKJaGJiQt3d3W0XikPa1dVlhXnpHZ8bVgyXu9VqmQcm0j8/P9fW1paKxaJGRkbMoLlpW19fnxWYA4GA7ty5o3A4rOPjY52cnNilxVGRnvb19SmXy+ng4EC5XM7gHRcig3M+NDSkjz766O/BG1dd9+/flySLAgqFgv7tv/236u3t1ejoqCKRiPWouEVkDD3OpVarKZVKKZ/PtzlICBN3795Vd3e3IpGIRkdHVa1W9fLlS+VyOctK0um00TSBBDlAMK1wXBjcjY0NMxbQZenL2N7e1unpqcFUOHAWLLkbN250fLE/+OAD2z/ghlqtpr6+PkWjUSWTSZVKJZ2enlpQIrU7JXqC+IyZTMYKnxgOnA4U0nK5rP39faXTaRWLRZVKJZ2dndllDIfDVhusVCrq6+vT1NSUhoaGVK1WDRpeW1sz8ojf77czWSwWzblAUCAbdCGOZDKpzz//vOP9c88gxmtnZ0cPHz406DIWixkZg4jVzdxciIpsK5/PS1Jbn8v09LRmZ2ftd6rVqvb29nR2dqZkMmlU5VKppGazaUaPqNnv92tqakrBYFDZbNYM2vr6unw+nyYmJjQ0NGR2A4o0ddXe3l7LWMi8g8GgJiYmrC7XyVpaWpJ0cQfdQIwi/sjIiHw+nyERfr/fsg7OJBAkDpkeJvYS1ia0Z5wNvToYdloAgNvIMkFfJiYmrO4FiWV9fV3SBSoDpO33+1UoFCxbIpgiESCw6unpUTKZ1AcffPDdO5cHDx6o1WppfX1du7u72t/f14sXLxQKhfSP/tE/0szMjEXN9J0QcROBwzji4BYKBSvUspGTk5OKRqOWRVQqFa2treno6MhSbzBxNjUYDOr4+FhbW1uKxWJaWFjQ3Nycfve73+n4+Ni45BiDQCBgWVA2m9X+/r6y2awmJyctiiJr4SIMDw8bnbiT9cknn6jVaunw8FC5XE7Hx8f66quvFAgE9E/+yT/RzMyMarWapfX8oZkPrBYYrNFomOPjZ/v6+vTBBx9oenraPmcqldLR0ZE2NjbMmJ2enmpvb0+NRkMDAwNWnK7X6+rr69PExITBP6Tfb9++tejK6/UqlUqpXC6rXC5ra2vLIDZScEltmHssFtPdu3c7ds5ffPGFGo2Gnj9/rtXVVR0dHent27cKhUL6i7/4C42Pj1v07RZDuVxEw27wkEql9OrVK4M6oM1T/+jv71e1WtX29rY2NzeVz+dt78vlsmWZ9BAQbM3NzRlkWavVtLKyol/+8pcqlUrmnIPBoNLptAqFgp49e6Z8Pq+FhQUjH5yfn1sjMAVjIJJO12effaZ6va5nz57p6OjIer36+/v1+eefa2xsTPl8XplMxowfMBVBDoabpkS3RwJo9MGDB5qdnVUqldLW1pZOT0+twFwoFMzAl8vltsbbbDar3d1dRSIR/dEf/ZEmJibM1uzt7enZs2dt9TH64AqFgvb29nR6emqUaFhN9BZxr3FKnax79+6p0WhoeXnZWivS6bQGBwf1gx/8QBMTE8pmszo5OTHyAjYK5AbnDEuLs1qtVpXJZAyyn5ycVD6fN7u3ublpkLMklctlpVIpY8R6vV6Vy2UdHR0pFArp448/VjKZVCqVUjabValU0tu3by3Ar9frFmSTRcII5lzD2iUror/oquvKzoXl9/stcm00GgoEAiqXyzo5ObGDWSgU7BAQYULrxZvCfnD7Xdg4oCIONv0lXq9XJycnRhxwcWsXPiuVSm3RvEvpAzoixZRkWQzRA5ep2Wwql8vp7OysLZvqZJVKJXOsPDSgptPTUx0cHOjo6EipVMpoh8BXsETICIgmeQaS7J9u1sO+Dg8PW4RD1B8Ohw1/x2gMDAyYYXVpxYFAQLOzs+bUM5mMQRIUfHFEZIg8V+AKoNFO2U4YJLIKVl9fn1F7M5mMwXOuAWE/eHZAS2SGkuy5cOZ4z1arZR3o3d3dymQyVsPj3BAYEalTOOYM9/X1aXp62s58Pp83aITP5fF4DN5k8bxdI/w+C/iF+wNUwtkH1qRVAOMM6kAUK8mibYrDfAcW5xClCejNUIphO2G4eG328Pz83CBBgtTx8XEjB9HPBMHC7fWCPstnABbjO3S6jwTFfr/fbBkZLk6uUCjo9PS0jZ7OeXAJJ9RXLpOQOIPcX8go2Fyac30+n7HKsHHu9wLWxUb4/X4LeGjYdnvn3B4ZMlZsCs+A0shV17cq6EsXDXx0luME9vb2tL6+rnw+b/ALHhJMNh6Pa2FhQR6PR9lsVqlUyiilZ2dnlsGQRvIg+/r69P3vf19er1e/+93v9PDhQ01PT+vjjz9WKBTS0dGR8vm8XeCenh5tbm5aAxxNazQk/ot/8S/06tUrzc7OmoQH1MZSqaQXL15Y7wmUy3K5rJmZGasDdbKWl5clvTMYQ0NDGhkZUbPZ1Nramp4/f658Pm/dzhwYshM6oMkCqWVxATGOp6enSqVS1kzp9Xr1+eefy+fz6Ze//KV+/etfa2RkRD/84Q81ODhoh3dwcNAkYWjWorYwOjqqP/3TP1Wj0dC//Jf/Ut98842Gh4eVTCaNsEEfCk4M2i88f/DdTp0zVPi+vj4jkuAYtra2tL6+blkZUBTOXJIZ8WbzQp6FDMDtRm61Wlbkx1h4PB796Ec/ksfj0c9//nP94he/0OzsrL788ktFIhELiqjTBYNB5fP5NgZPPB7XP/2n/1RnZ2f65//8n+vRo0eanJw07Jz+r2KxqO3t7baeB4zNyMiIxsfHOz5/7JMkK9oTKALTEnHDioQMU6lUVCqVjGRDvYGghNoIe31+fq7T01PlcjnrrXnw4IG6u7v18uVLvXz5UhMTE/rwww81ODjYJqETiUTk9/t1eHhowUq5XFYsFtMHH3ygarWq//P//D/16NEjzc3NGdTX19dn8k25XM6cTr1eNwUEl5LcycrlcpJkdSO/32/GOZfL6ejoyL43tUqPx2N1nkQi0UYUIssmEKOmVS6XLVA/Pj5Wq9XSBx98YDbwb/7mbzQzM6O/+Iu/UCQSsb13mWuQgk5PTw2O/OSTT3R+fq5/9s/+mb766istLS1Z138ikbDAEqYfDouA59uqbFzZuXBwKBBBX6MGQOrFByGSwQP7fD6LXsC53YYg11u7dF1SWWi3RCFw8mFaEAn6fD7Dg11dncHBQXOQNBdxifv6+gwHLZVKRvt0ez7IxDpddLG7mP/g4KBqtZp2dnZ0cnJiDCWXAuhqmkHZZG+AsoCf3A798/Nzlctlo1wDrcGog5TB6+DQgN9cWi3FUQgTMLPcaJXIhuyGn4WGSZbUqXMBEoWswedtNBoGV8HNJ1pzacE8a7cfhufBHpLpuQX97u5uDQ0NGdef70UvEe/rUvPJ5np7ey2L4wzz/kStBGk4Ss6yu6+czfddZJXcHQgKNN0hF0TEfbnXAuo13xW6L/9Opks9lnvG3afwjDGk4IwzYy/ogKcZlfejb4tGWYr0QDd8Np499xWInbve6T1GSYAzCLxOwEJzM5/LbX9w94/g1aUb8wd4sVQqWWAJykLACaTGc8RuutRl7gJ2u6enR9Fo1IIu1DWkd60XLuSKXeD8SWr7TldZV3Yux8fHhltjmIaHh+1LNZsXujTxeNwaJcGNgcTQbzo9PbVD4NZParWa3r59q83NTStIA6NJF/IVf/zHf6xwOGwPcW9vT4eHhwqHw0okEm0RX29vr4aGhpROp/WrX/3Kovzbt29rfn5ei4uLlq4CWUBDTaVS8nq9evDggSKRiEVEnS6iYC4VHd8cPK/Xq/n5eZOuoI4RDAatyW1mZkY+n8+o02QZdCqXy2WtrKzo1atXGh4e1tjYmO03lMUvvvhCvb29Ojw81MnJiX1nv9+vcrmsnp4enZ+fG+SQTCaVTqf1P/1P/5N1Ry8uLioajWp0dNScVbFYNOpjtVq14uDY2JhFkbCBOlmlUsn+neZJt1GPega499dff22fKZlMKh6PW9S4v79vVFsuFcXV5eVlraysaHR0VDdu3DAlhWKxqKmpKf3Df/gPrdBcLBbNKAPbuPpj3JPDw0P93//3/20X+oMPPtDExITm5+ctiCkWi+ZQTk9PjW01MzNjlHw30OhkcdZxppIsEwaGYg9piiQI5P5yh4lwMexA0ZVKRW/evNHr168N+sIgkoF8+eWX6uvr09HRkdLptDk0MnQ3OyMbLBQK+uu//mtzEg8ePNDIyIgFYSMjIwbrBgIBK/R7vRd6fn19fX9PlPPbrkqlYo7B7YMDviqVSkomk/roo49MfqZcLpsOI4QS2FzATTg79nRzc1Pr6+vG6AMmrFarmpyc1M9+9jMNDg5aEAmMicPp6emx+4Kdzufz+pf/8l+aztuf/MmfKBqNWjc+5AOcNHfK5/MZ+lMulw2huMq6snPBOHIBuJhu4w9FW6I5OoDBnaHVBYNBgy7chjW6oQuFgm7cuKGpqSmLimq1muLxuNUK8O7pdFrHx8cWhXk8HusPoY6wtbWlv/3bv9Xp6ak+/PBDTU1NaWJiQuPj48awQDah2Wzaa/p8Ps3Pz2tubk5ra2t69epVx5ebzla32A30BGQzOjqqTz/9VKlUyorTOJChoSElk0mrtbhsKEnmqMiCUD8grUWf7NatWzo7O9PR0VEbtRICBplRT0+PRkZGNDQ0pK2tLf3v//v/rlKppJ/85CdaWlrS0NCQ4vG4RUcI+aE3RaZGzxHGo9PFxQY3dxu+wLTD4bBu376t3d1dPXz40Ix+NBo1OJfOZElWtMfAV6tVHR4eGqTw8ccfq6enx6A2REcRyUTAslgsanx8XNPT0xaZgk/39fUpk8no//l//h8Vi0X9+Mc/1sLCgkZHRzU6Omr1KvTtiOD39vYkXcC6k5OTKhaLVkfsdLmBIOeGO42BDIVCunnzpnK5nLLZrNVVvF6vaQqScXF+iGh57e3tbWUyGY2PjysWi8nn81m9JxwOG2kBarXbCHy5toTAaz6f1+9+9zsVi0XdunVLc3Nz6u/vt4yPlgSyb3q/fD6fZmZmFI/HDbbqdA/JUN2mWJxztVpVpVJRJBLRvXv3lE6ndXBwoLOzM4MOydxoj0BpHFQEo440ECKSXq/XsspEIqHp6Wkz/mRL5+fnlgF3d3fbmUbwNpVK6Ze//KXK5bK+//3vm6Ycz5YyAPA1mRM1TvYvnU5f2Tlf2bncvHlTrdaF1Pn+/r4ajYZpIkkyyCCTybRRNoGVenp69OLFC+N1SzIRTCI6nA3FKrw8FzkSiSgejxuzQpI1W0EhdYtRZ2dnymQyajabmpyc1Pn5uSYmJpRMJtXT06NcLmdRuyQjI/h8Pi0sLBit8O3btyaf0inmvbS0ZBdvfX3dmjqheQaDQZ2fn2t/f1/5fN4OHPIs9Mawf/V63UYK4LDr9brJeCDbwr5KFxdwYmLCKI9ITXBBWVwWaL2tVktLS0uqVqsmr0FnO/TxYDCos7Mza8RErps6nGvQOlm3bt2yYubOzo6xcSRZJA3N+vT01GDbfD6vzc1NYylJUjabtdEDXHz2j4JtIBAwiAzGzujoqCYnJy2io0eDLIXfJ1vPZDIGT1JMjcfjpoMFMxDKZyaTsWL/jRs3rJeB+/Y+zlmSbty4oVarpXQ6rTdv3rQxfzBuhUJBq6ur5vDoHYFsQOMf3xFjBFzk8XgUjUYNCuO5A0UGAgGNjY0ZrMXeAdmSbfB+PEs3uIzH41avAkInKwaSk2Q9PC6d+X2y55s3b6rZbOro6MjuMFAgn6FSqRgtmvuB9A+Qp/sZ2D8MPQEPfW9uS0S1WrVaLQGO2+To0q/5vfPzcwv00CGEgQh9ngwUpQBqtQSznAPs+FXXlZ3LT37yE52fn+tf/at/pZcvXyqfz5ueFAepXC5rY2ND5XJZmUxGZ2dnRrc8Pj7Wzs6OyU9jGBOJhHW+orlFc9fg4KCq1ap1/I+OjurBgwdmQBqNhu7du6dwOKxCoWBwUaPRMEVRcN+PPvpIXq9XU1NTikQipvoJnjkwMGC03bGxMX3yySeSpF/84hfa2tpSJBKxYm8n6x/8g3+g8/Nz/eVf/qV+85vfaHJy0iThKdSfnZ3p5cuXlr5zkMvlsnZ3d7WxsdHWmOjqu21tbbU1PhE944ir1arm5+f14x//2HqLzs7ONDY2pqGhIStIUsgmG8hkMvL5fCbNTtMlTqurq8sypIcPH+rly5dKJBK6e/euWq2WHj58qN3dXYtwO625cP7+6q/+Sk+fPtXY2JhBANSvKpWKNjc3dXp6avWY/f19ra6uGkW1t7fXpPqZ6zIwMKBIJKLu7m6Fw2E1Gg1FIhFrlETLbWZmRl988YUymYzV5ehbyWazbVRR6V3TbavV0kcffSSfz6fx8XGFQiFT8kWBIhQK6fDwUNvb25qcnNQPfvADeTweffXVV1pbW7NArNP9c8/gX/3VX+nv/u7vNDY2Zhk+Tg69LlcdYG9vT6lUSv39/drY2DBqNHR+ol/GCYDvk40AOWLY7t69a0VvhDv7+/uVSqVs1IUrt0SddXFxUV6v15pg8/m8EYP6+vrU09NjMDkKDs1mU7/4xS+0sbGhiYkJzc7Odhwgcgb/1//1f9WvfvUrKwEAkfn9fuXzeb1+/dpqHs1m05i0fX192tvbM5ixp6dH4+Pj1pgLREu2DxsMskepVNKNGzd08+ZNgy0bjYYFSblczkYiADXiKKR3vYoEiBAuCKh6enq0tbWl/f19jY2N6f79+/J4PHr06JH29vaUSCTsrl9lXdm5uMU+6Z2+js/39/WW3GIa/9/t+KYARZZBpExkwWbxOtAI3ffngbowBBkOUA1enNoOMAowAFERdFwiB1drid+9XCT8tqtUKlkxkveBbICBdAvKLAqW7J/0Lj2nz4S9oXmVwqYk+8wuNZl6FBgrz61arRoOzO/9u6IVoDAyBp4D2RhwAe/pFq073T/OCPtCkZ2Mlc/CGblcLOX8cTaQu4A2zCWjaZVn7/7htVHvhWgiyWpSPCf35/nMZG84ceqCPF+3KM1r8Mwu01Y72UOwec4xFGDYfRh1d7EfrpadGylz3ziH0jvyCdCPexb4PmQ8dK8TFLr7xn12SRougYVslDvEH5dxx3N06eidLOBlvg/vwf0E3neJNuwfxAdqVGQ8kD8YreFmN5dtpkt6ItO8XAMCfmS5+o48b/bQRTUocbh7yF5xX1y6/lXWlZ3L//K//C/24ScmJqxmweFxG/8KhYLNo5ifnzcjCm2vVCoZHZTZKc+ePVOlUtHS0pJh13Dugdh2d3f14sULa+iRZEPI3rx5o4cPH0qSQUOQDwqFgjY3N9sYbPv7+1pfXzcGRn9/v0UMlUpFT58+tUMUj8eN1tfp+su//EtJFw/7e9/7nmZmZvT973/fYJVGo2GZE9BKd3e3xsbG1NfXZ5+v0WgYpr2ysqJSqaRCoaA3b97o/PxcU1NTNlWOAiHFvd3dXf385z+3bK2/v990hfb29vTmzRtJF0VUal2t1oUi8trampEOotGoUqmU9vb2DM6g5nXv3j11d3ebo8J5x+Px92pC/cu//EtjCc3NzWlxcVFffPFFGxx1dHRkUTeXcWRkxArrIyMjajQaNh2TxrNisaj9/X3V63Xdvn3bVGRh64CXp9NpPX782BQQoJkyR4YufGTs6YMpFAqmGYYR5cwSXBCpzs3NqV6v66uvvrLIk9ehZvm+Z/D09NTqPmNjYzYhEcWKbDbbVpe7deuWQYUu3InUCsoSZG4UilFYpr5SLBa1ublpdRG+D/Wk9fV1PX782LrwaWJtNBrW+Isz9Hg8dl96e3utAZpgiH0n4BoeHjbovlP04X/73/43NRoNZbNZq2neuHHDailkYtQHcTwzMzPW7E0jLPtXqVS0vLxshCHOD3YJyBRHcnx8rOfPnxt8Buvs/Pxce3t7+uqrr+T1ejU7O6v+/n5rbMfOugEWjefYGb/fr1gsZjAljeeu7hmMw6usKzuX5eVlg10QQ6Mu4rI9iGSIFAcHB+0DRyIRi3hhV3i9F6N5U6mU/d7Q0JBFQnhzGDupVEqhUMjwQKRQjo+PtbGxYcUyPDpO6vj4WB7PxdhiCmFg76S2GMiTkxPjxmNY+DydrtevXxssNzIyYgVdv99vLDYeHA/P4/HYoKrBwUElEgmdn59rZ2dH1WrVHHSxWLTiK7RiV76B/y4Wi9rZ2VF/f79GR0fV1dVlTaIMLSJlJ8KB3sw8GpgjpVLJ+glCoZBFUtFotI1SzsXgYnV6semk5/yhbdbf32/OhYjbdS68bzgc1sjIiDEZwZYlmYORLjKSWCxm54TCPE706OhIg4ODbcPFYOwgP0IXNlpPtVrN+r+KxaJCoZAKhYJBTXT2d3d3m2oEhh1UgMj3fZwLvVbsBw4NvSqconQRbVOvjEQiBiFevpucW+4mNHfqcm5vGGjB0dGR1U44g7DNTk5OTILIZZRSP4WwA3RMczJ0Ws4DvUrQgqlXvg/6sLy8bPVNBDhxytShGM9M9gTDdmhoyArjvH+xWFQ6nTbYmuGIbj8OWbnbc3JycmLNm5CpCEQODw/V3d2t8fFxq3URKFF+YBwEgSlZOuefwBJGLlkadP3vvM/lhz/8oZrNi5nejM2ksHxwcGBFzq6uLpNFQJhyfX3d9MeI0qLRqDE6crmcpepcZHBGZoIgVEdDEmnozs6OUqmU/H6/Pv30U/n9fi0uLmpgYMCkIyRpcXHRYDFqOGC7yL+wiJyazabN5iCl73R98cUXkt4ZPqJZr9drukGkmygeQP1jOBoXBSVjFxbDwMKQgw5Mgx9sMhoeia6ASrxer+7du6euri5TP6DjnVoBl91lsnV1dRlkBXRCPQjtL5hFGN9O1k9+8hM1mxczPQ4PD3V4eGjzZJAyoXDKuaIh8ODgwJS1uXgTExM2k4R95AK7MGWz2TRJGM6O29uyt7dndakHDx4YxOTzXYzZ3trasowPiHZ/f9+K/R6Pp40aTaPazZs3rZjvfp/3cS6ff/65ms2m0dB9Pp/dhd3dXUmyALFSqViARZEdB00fViAQsIZdzrYkm1Lb09Njw7xisZj6+vrU19dnCgrsDXRuFKv9fr8mJiYUCAS0s7NjHel379614OTg4MBqg9B+/X6/ORRsTL1e1+7urkE77zP24cGDB3aHIAnQ30fvCegNwUu9XreMlumpZB3U90AXUqmUGo0LSSYaZgkYGfAlyewlEBvvSetET0+P2cCNjQ1j09J8XK1eTBx12yN4BjijcDis6elps4EgEd9m/67sXH70ox+pXq/rb//2b7WxsaGhoSGLtDc2Nsybwr8+OTmxTadDlC7fzz//XMlkUm/evNHGxoalr5IsSoNlQZqL54Q9hegdjiEWi+nzzz/XwMCA5ufnFQgE9Nd//dfa3d1VPB7XBx98oO7ubh0dHdnYTjKuvb09o7nWajVNTk7qiy++kNfrtYt9GUf9tuuHP/yhGo2G1tbWtLOzYxBBrVbT06dPdXx8rLGxMU1PT1vHOJRYj8djlEToxJFIRGtra3r79m1bLQJCBI6B6D0YDBrFkQstyaLP2dlZk1+nRkOHdCAQMOZNKpUyY4NEOnAhUiKQDur1eptUO0XcTtZPf/pT685+9eqVFeol6eXLl0qlUhYxE0VjxJrNpg19Gxoa0qeffqpEIqFHjx7ZqGsk/aE5E/m2Wi3LUug/6e7utqxxa2tLqVRKt2/f1qeffmrYNYXczc1NJRIJffzxx+ru7tbbt291eHjYNlVxd3fXAohwOKxoNKr5+XnbM+7S0dFRR3vH+v73v69qtaq/+Zu/0cuXLyXJxgOgzUXUTMbqNgjGYjHNzs4qFArp/v37pgHIADTXuaD4zBlkmB+jODhbZCLn5+caHR3Vhx9+aGoHPt/FOI9sNqtEImEjFl69emUOw9UXo2aGSCkwMlI11Bg6PYMfffSR6vW6fv3rX2tra0uBQMCgpu3tbSvakz2BSECIIMAOh8P6+OOPNTQ0ZM6l0WhYsD44OGisREYZ00RJ5z5ZOjRvqPgffvihAoGARkZG1Nvba4HM2NiYlpaW1NXVpcePHxsMDEKBPYCCPD8/b3d+eXnZal//vzgXt9sWTM7tYWHEJuk7qRY6RvF4XENDQxocHLRaCx2+wWDQmFjg9XQJU7gmOnJTTTDvarVq1FCoumCzDAQDA6Ubn8sAbIMHJ92GI0/hEcZKp87l8PBQzWbT0ma+Q6PR0ODgoFFr2UNJRkfkwPL/KcZRK/J4LlSHKdADWwD1AAcQBfn9foPFMMKw9agVQNhgn8CqyYI4bNRl6PqF4UOk7xZuKVZ2sqCuXhaX9Hg81mVOEZkIj9oSWDKUaZ41Zxn4lMKrS+BwC+oESu5IbUZAAO+SufE9XRkSVAoYVUGmDmaPQ0eynvNJL45L9Ohkka1LsmZDsnmUClAZd/vQenp6rMcFKM1VDud78L2oA2D0IZC4ARwQIHRiAiRgRqBcSZYJMtKA50bWLqmN3otKBcKOnAMYfp0uF/LiXpLtuvvn9/sNNqSRnL0bHh42eSX2Dug1Go3aOcYRworlPLJPnAvXcQKt1et1g6qxCdR5CNQDgUDbmeK8uhRmGslRqZD098ge/751Zeeyu7trOPL09LRRP7u6ujQ6Omo6WfwM9EK46aFQyCSpa7Wajo6OjPLp9Xo1NzdnkBhzyaGTHh8fK5PJaHh4WJFIROPj41pYWLAoGR2ig4MDw67Z+MXFRTvYHo/HuviLxaIV0GAKNZtNixYePXrU5hgPDw91fHzcMV77r//1v7aLh/OFWlmr1RSNRjU4OGhwEgv6XzQaNaIDFOHu7m5NTk5acxWd63wHGvFwKKTu4+Pj+tM//VP19/fr0aNH2tzcVKvV0urqqgnc4ZBxdOhlxeNxDQwMaH9/XxsbG5LezfY4ODhQKpWyEbQY+2g0avpUna43b96o2byQZ4d+TkCCqsDp6anJvuMobt++bcXNWCxmbJ50Om1nGeMA1Rpef71eN8l9MuVGo6GJiQnNzMwYhZ0s5NmzZ+rp6bHiqMfjsRHWuVzOZMunp6etxuCyrKh7HRwcaGVlRd3d3YrFYpqZmdHJyYk5807X06dP7d/n5uasox0DQkMjjaNAwm5/CfeOZkoMnt/v1507dwzyoR1hY2PDnpvLiBwYGNDNmzfl9/uNzJPP541BNzIyYoHg2NiY6vW6VlZWLJCanp62qJzn1tPTo5OTE2tBYI5Pb2+vZmZmdHx8bHask/X69WtJaiuYE2zRQ0JpIJPJmIpDPB7X9PS0EomElpaW1Nvba/tNH5Tf7zfkABsINZv7i3OkWXNubs4G8ZXLZRsfApNxYGCgzdGsrKxYgD02NqZcLmdOC2eH48/lcvrtb39rKMTt27e1tbWllZWVKzeSX9m50EFMTwsSJnRzAwWQ5sEu6O/vt2gHI8QBw9i6RXiiRS4RUTOe2S0wuXLQCNzBLMFr42woMrvRPxEqNQsuliSbT8Ll49B0ejCBhFDTxSh6vV6DItwBPkRusEz4HlxQngXFRL6LSwGmrgI+iwPlPRltSrGa7AC4goiUZyC962rnsPM5XGolBx09KL7n+yzqNT6fzzIQokb2gO9N9odRg33jnlO+m6tTBvUTMgLnGQPAeeQ7u7UHvjOKyZxfsgOooBAggDuJ7skUMdbM2olGo5ZZgRZ0uoAvu7u7LXNhD8mwaCp1m/FgX3FWXKo795CfoV5FkZleD7c4zXfg7nJ+IAOBZnDO+/r62tAL7AXPjPd3s1bsAO9x+dl3shhsyN1BEZvvwnfk87AH3GP20KXk89whvbi2ikI895q77bZ58Pzc9grIT5wnl+mF/R4YGLC95vmwt25ZgjPI+SCLusq6snN58+aNZRhzc3MWmbhMBhg8NDdRM2Eo09bWltGIkaymM51mHhqxKM4CFwG19Pb2qlAo6Be/+EWbCN7JyYkVyDOZjCm+MhEzm81ahAOsMjw8bM1IZ2dnmp2d1a1bt+yz1uv1tuav96HSItrIwDMa0prNpkW+4XDYinyLi4vWqEoT2t7enhkZZBkoYsKAmpycNIYOlxPWEw70+PhY/+Jf/Iu2Q07U02w2tbq6alkeWQeEBxpcMa70DrRaF9L0UMcPDg6MwijJ5GQ63b/V1VX5fBdyPAx9ohbmypKPjIxY5Mr5W11dtQvOIKrBwUH7bLVazWookUhEzWbTMluiciI7Luzjx4/t96lFbW9vW2YEdLawsKDT01NrJJ2bm7PG4e7ubmOZ1et1xeNxTU1NGd0UeJYGxxs3brxXQR+DMzMzo5GREcuacKIEgyjkEnn39FwM8jo+Pjba+fz8vMLhsJLJpMLhsM1sqdVqpodWKBQsenbVKIjAv/rqK0MRqKceHBxYfSsQCGh0dNT2C01Csnlqia4RdmV1kMuh+N5qtTQ+Pt7x/iEJdfPmTc3MzJh0lAujupMop6enVSgUrHOfUczBYND2D3jr/PxcmUxGjcbFsLBwOKzz83MbywAEBxrg7h8wGbVafgYnMjMzYyyzrq4uk79i9gvvjQoK8i80qCL7gn256rqyc8GwLS0taWJiQsfHxzo4OLAIx+PxKBaLGd3Ulc8gmmXaHvIrXBQuc7Vata5/SYaputFyV9fF6FdS1FAoZIUuNoOoeXp62g5fNpu1gw3uDsceUc54PK6xsTFjmZGF1et1xWIxzc/Pd9zdS4SGRli9XrdeIL47+1av160/Q5JJtdCsyAhTXrfVaimbzapcLmtkZMSiNKJv6ltEVvT9SNL8/Lzi8biJdTINsF6v6/PPP9fU1FQbBZHOdp6526AWj8fVarW0u7urnZ0dS/vJEMDkO1lcmhs3bigejyuTydjcb4gZjD5meBw9G4eHhxYhMi4XqXEyNJg9RJYwzXDIZGpEv0xFHB4etmDo6OjInD8zgCASIExJrYFI021yRbGCPaVuRiCBEGmnCxg7GAxqbGzMCApugx49IV1dXRoeHjYYlvpBJpNRMBg0ochwOKyBgQHt7e3pyZMnOj091fj4eFuk7sK8GL5q9WJ0syS727AkPZ4LVe1AIGBwMVR3sv9YLGavVSqVtLu7awHawMCA0ZtddeXBwUEjMHSykIACtkun021wJRktTiMej7fpdAF9Dg4OanZ21gbX4ch3dnZ0fn7exqyjdg38xhk8Pz/XysqKpAv9PjIREBK//2J88eLiommzQT4ApiOjAQYul8saHh7W8PCw0um09eIAn9FW8p0X9JnfQCSMMWy1WoZJ53I5k1QB5jk6OlI2m7XCK3iu9I6WCz5KQZMiFtEftRpSY+YdAHtQcLp3754ZEGS7YUeR9eRyOW1sbLR1sNOz09PTY0qjGG2gEprEOl04F1dmHNE5qMhM4sNo83mLxaIZZ0l2SIiuC4WCMVNg7pydnZnG08TEhCn5ZrPZNgdJCj40NKQHDx7YMyATcPXXoK6SSVGHQVaFlBloqF6vG4TaaDTMcHS6f64zwCDWajVtb28b/Z3sobe31+Q54PLTsJhOp9voszhHHKYki7K7u7ttdjvQK4KpjUbDznk0GtXnn3+u7u5uU+Gt1Wqmbo2acCqV0suXL603xOO5ECwF3iM6BULGyDQaDWP0dLqAnil+Y+zITKmL0WAKdLa7u2utBsAosMsoVB8dHRmdFafOkLO+vj7bk3w+b9p53HMaHQOBgB48eNBWQ+np6TFJGM5goVDQ7u6uNfJKMvjYnRnvdsvzrKGQd7Ko17q9fWTt0OEhZHg8F7prkUjEAhXQlO7ubu3s7JjKOkEud61UKlmPCQEJDge2HcKV7J10gY7cvHlT3d3dVrPy+/2WlYRCIWPgvXnzRicnJ9rZ2VGr1bLeLaA5+nYoCUgyW/2dO5dwOGw8fRrvwOCWl5cNkvJ6vZqentZ/+p/+p+YBU6lUm6rvycmJdfO6kgIwbmA40Li1tLSkwcFBra2taX193YxDtfpOYnp0dFSLi4v2AH0+n/7Nv/k3+uUvf6nh4WHduXPHeiKYJS1dZD4fffSRwuGwUqmUMpmMzUHh+3i9XsuMOl3gwwMDA8ZuAqd/9eqV9vb2DJ5IJpM2WmBjY8PGN4Px0jsA5sprQY09Pj42CfiBgQHdv39fkUhEz5490/Pnz411hWGls5+CLHDPN998o2fPnlnk7PF4tLa2ptevX9uzGxwcNCiTTBM4w6Uip9NpUx/oZBEwkJEBQ1BI39jYaOuI/s//8/9csVjMNNPQFGu1Wtre3m6bJ+TWhrg41B/6+vp09+5dRaNR7e7uand31wgpqAj39/drenpaS0tLpmLt8Xj0d3/3d/rlL3+pcDhsWe/GxoYeP35szzoWi+lnP/uZEomE9U8AFxPVhkIhlctl7ezsvFfNZWhoyIwjNQ6o5evr68pms+rr69PAwIDGxsb0Z3/2ZwqFQjo+PtbJyUlboLC8vGxBCdp0e3t7pizt9/uN3t3f368PPvhA8Xhcz54907Nnz3R+fm6NojiE27dvmxw/6MLXX3+tx48fKxQKmUo6qMne3p5WV1cVDof1ox/9yJ4v9QVqVM1m07Kn92GLzc3NWeCM8ec8rq2taW9vzxxcMpnUj370Ixu5kMvlFIvFTOHg5cuXKpVKVuOCuuz1ehWNRu09eF7T09MaHh7W1taWGo13orzscaVS0cTEhD799FMLdqC+o02H/d3e3tabN2+UTqdtXMn3v/996wUDzuZ+kJFBeLrqurJzcQu4rp6VW7CS3k38owAvvUuFeQ3ponDkDsPBU2JA3D8cENcZAZGR3bhaZBSc+D2XpcWDhK5IMZzGRhoEiUr4DDzQThcFaEm2d5dJCTRCuVEDhgaokJTX1XfiAvOciHxdVgpZH82qOE8YTy613I3g2T8+EzU2dwomv0fURhYqtY9ffh+mE1ErDoUeFJ4tjpfPDpTD3mBQ+S5Ah25B1S0u07hLRgbHH3iSGozbjQ4RgLMDC1GSRYPUfcjAuUNkjET/UOl5DkCj7+Nc3PvHGeSZuA6N9+M78//djJf95P6wF5w/l/RAm8AfGlBFzYEM7XKR2lVbcI0dC2PonkHutquHhe26ajH6Dy132B39YQQ5l+0bVGwyJZdYJMkyQJc270KvnCHODRCpS5DgGeCMydjI8C/vH2fd/X/sH39HrdLdP+mdJtm32b8rO5exsTFJF4fu4OBAlUrFsLiFhQXNzc3Zh+ju7tbW1pZ2d3fVaDSsgBqPx9Xd3W2H6OTkxHBqpCfch4BBX1tbk893MeNif39fXV1dWlhYUG9vr8bHxzU0NKRsNqvV1VVzPB6PR+l02ob0oDPGiObnz5/rzZs3KhQKmpqa0tnZmX7729/qm2++UTgc1tTUVFt6DeTU6eVG7rxWqxnNlIj/zp07Gh0dtcsYCAQUCoXU29urhYUFTU1NGZe9u7tb8/PzhtMy0x0M2i3OYugeP35sEeXh4aFh7v39/bp165ZGR0eVzWb14sULeTweE1LM5XJmEGG5xeNx9ff3682bN/r666/bWC3Pnz/Xs2fP5Pf7LUp2A4TBwcGO9k66GBRHnQJsmn6IDz74QEtLS23GjE7+wcFBffDBBwaP+Xw+LS4uWqc4jJjh4WH19PSYQ0FJolarWaMlTagej8fqCh999JFmZ2d1cHCg3/72t/L5fFbQzeVypnpN3eb+/fvy+XxaXV3V06dPValUrAHvyZMnev36tUXfGGmCA4rSna54PC7pInqnkberq8uIENQz6Sd5/fq1BRRzc3PGJAwEAtaISgbR399vw+x45mRxjUZDDx8+bAsIBgYGtLCwIK/Xq4mJCdNqA8aGCs9oBIwnhrSnp8cgUYgRmUxGr169suZaGHku0+l99i+ZTBqLand31zrrm82mFhcXbY9gZ6J6DX0e/bDe3l49ePBAQ0NDNruJficCbNAFmpE5K24Qzpln7hJBFffR4/GoVCqZs2HmC5R8j8ejo6MjI1icnp7q+fPnRjemzgoLEAj9qnt4ZefS399vjA4KZTQrUmDG+9VqNauJUM+AOkhDFr0JhULBKL8Ycp/PZ5vUaDTsUjHOFnyQgl8kEmlj3bBx7gAdshaaPfv6+kzbjAdweHio9fV1E/RzvT14baeRTzgcVrPZtEIzagYU+cGzca5ugyCMmlQqZT9PYRL2STKZVG/vu1nmRG/1+rsZJ0hVoMEUDoc1PDyseDxuUxUlWXMr0BvZFcXe4eFhHRwctDkwJCS2trZMlt9tbHPhtk4WmZl7tngWjBlwAwG3j2p4eNiwaklWJ8Dg4FTIsMGZe3sv5sdvbW2ZPHk2m7VGSBiHsVjMoCNJVmc4Pz+37BHHR0DBz0IfbbVaOjg4MGFHDIDUPkL6fTIX+h+QVUJ+BropAQu9aHSHM2EUZwx5Z2pqyuAtv/9iWmp3d7e9PncZphTsRwJJzkgikVAsFjONPEmWbVDId/+4Y4bZW+jbqCL4/X4bo0A2RBT/PvtHWYC7RWYSDoetgRuHA4Q0MjKiSCRitSiv90IjDxuD/eFMujNWIJcAX9LMCmSKswiHw221a7JSGnzJpN26L2gAQRvM3p2dHaPnuzAqz+U7dy5grel02maHkLJJaiv+8IF5kHSb0qsAk8iFb9y0u16vK5/PG30zFosZPOGm8d3d3TZ8q6uryya0HR8fG+tifHzcLhX0VWh7zEZ3lYMp0AJf8BACgYApMXey2D/UZnGU0rtxBi70hJyF9G6eNc4WfBcD6HZLu4SHo6MjIyzQW9Fqtcyp9PX1aXl5WS9evDB6JMwpBokRVOBYNzc3dXx8rL29PavzoHgrXRQ9aQYF+mw0LpRyoTB3sqBkr66u2rnAcADnAI9J7yZzIgroMp5WVlYMYmHvkHWnyIyzpU8AWRkyc3pnlpeXtb6+Lq/Xq8XFRYPtyuWy7TOQk8/ns4I2tT2o6Ihf1ut19fZejJcmSsegfhsa6B9aFLhzv5/74f69q+/X399vZw1YBPiE2sDq6qp9F+681G58IKnQ3Is+Fn+AgahlMdq8Xq8bcxF2E/1CUGMbjYYZWzIu2InA5QRcnBOULjpd9NExm8rdP3r7+vr6NDo6avUsIDtgNGCtlZUVnZycGNKC/WSvYebhjKLRqEZGRuwsA2l3d3dbqwdsrnq9rsPDQ+uVotZC0F0oFIwJ5pKsOIMog4yOjrYV9wOBgNXCrnTerrqxMCRgGiBh7l5mV7KBJksMldfrtb4D9MRmZmY0NzfXZiDdbGVjY8PSSi4GNQAKTmtrazo4ONDi4qI++eQTlctlkwyPx+MaHx+3Tms2j4cMHZVLBRXT/UM6ToTfaTOgK6lBGgwEwOGiboBoJ4cMR0zz59ramhqNho3WdSMQBPNSqZT1Fd2+fdv6ZyqVikKhkCKRiHw+n549e6bV1VV99tlnpp306tUrVatV07oqlUo6PDw0hlir1dLh4aFdtqOjI8OjoUVCV0bue3h42NL4Ttbg4KBqtYtJpy9fvjTozVWDkGS1I94nk8kolUrZ2Ww0GkZbJUMl8iWoQe3h7du31jlNgCNdGBOix9evX+vw8FD379/XP/gH/0C1Wk2vX79WsVjU2NiYUZEJEDibCFFi7GFqQX1mbARreHj4vanIRO+ZTEbb29vWrIgBcQMK9+wR2fIH57K/v9/mNFx8X7pwLmtra+rp6dHS0pJF14jR9vX1qdlsmjbhgwcP9NFHH+n8/Fy7u7vKZDLWl8ZnbDabprsHoUSSyQ7RJU9RnVqwJAtwOr3DGF5YVgR39JrQsDs6OmraadTJsD84h9XVVQsigMTdOgjZ3tu3bxUMBvVHf/RHGh0d1f7+vgl50s+2tbWlTCajhYUFLS0t6fz8XFtbW8rn8xoZGTElZs44Zw/ngsORZGcQxpk7j+f/t2FhSFUMDg5qbm6uDUqAosZkRbBZCtTAPWiS8YXozyBCI2qnkx52htvT4U5t9Hg8NkaXVNyVAIc6isIrhWx6RbgQkiwN5bJRDAYa4vt7PB7du3fv255Lk47hobmLyIqsyefzWVHXzZ7g+8OWq9frymazxrjp7u42TJS6ituNjSEgi+LQo15NOg5rDgiTLnL3fcLhsKR3w6Zw2DhQ4JVm80IOqFQqaWdnp2PjeHJyYhEV9T03Y4MNhHNxCR6SrG7kqkM0m++03mCjsf+SzCGhyA0MGwwGbf+AY1wJemacAL+h+eR2qg8PD2thYcH2B4cIBEHjK0FUsVg05eJOF1pbfr/fHNVl4gznBTkdIFI+Bw6W/0YPzM2ycDDMp/H5LlQVCI7YBxwu6hDcX6jRqVTKaO3n5+cGh0oy7TpJFozSbwIkjlo6UDh2oFPnwvz4QCCg6elpQxPIZqV398Gl79KnR6Hehdup5UJbdp0Mthayg9urRhBKn1wulzO1c+5fJpOxQI+xGY3GO71HngXBNxkRzzCdTpv9IQinreQq68rO5e3bt/L5fJqZmdGnn35qDVhkA6enp6YlViqVLO1n9gENZRxglJNfvXqlaDRqDUd80bGxMf3gBz8wTSHqFFxEGjjX19d1cHBgSsCVSkUHBwfWpU/auLy8rFarpQcPHmh8fNz0uvL5vB4+fGgd/PF43Iqx1GRqtZr29vasi/unP/3ptz6Yjx49ksfj0eTkpBYXF63e5GLpGCN6Bdxu3XA4rLGxMVWrVb169crqKMwXkWQNmPRO3L9/v42nTgRChy+ZwPHxsVKplKnvPnnyxIQTI5GI8vm8KRbMzc3ZZ2FswuPHj83BFwoFY9319PRoampK4XBYh4eHev78uVqtlv7L//K//Nb79/XXX8vn82lhYUGff/65waY0eeGMSfMxSFygkZERLS0tqVar6dGjRzo+PlaxWNTW1paGhoZsLC9S8aFQyPpknj17pnQ6rVgsZp3tKPkCb4Knn52dWSQOYyqTyejt27d2/shofvCDH+j09FTffPONETNw2js7O+rt7bVu+YODA6tz/dN/+k+/9f5J0vPnz43Q8NFHH9mQMww6vWUTExNtiuY0JgYCAcuAj4+PrYvbnS/iDr+bmprSwsKCWq2WjZBwqbew79LptA4ODnRycmLnZ3l5WXt7e9ZmkM/n9ezZMzUaDX3yySeamJgwmCufz+ubb76x+yRdBMOPHz+W3+/XBx98oGAwqFQqZcX+n/3sZ996/168eCGfz6d79+7phz/8oTKZjDY3N63+TE2DeiWOMBQKKZFItNWkj4+PLYPd2NhQJBL5e1JJMzMz+slPfiJJ1odE1kyfG6SG7e1t+f1+zc3NqVgsWkbd1dWlSCSi4+Nj05b78ssvNTc3Z2hIsVjUixcvjDAEDfr58+fy+/26e/euksmk8vm89vb2vvuaC5xrj8djXe94MIrvGEkyGWZ+4HGJKklxW61WG6WPP81m03pCMBCXm5a4EKTqLqbOZ3EpiGCdFKBhpOCtJVlkRuRDhz7yF9QVOlkwcIgEgfdc2q/733xWSZb9AVcQNZJ58PlcmiZZmMfjMSzfbRR0Mw32s1gs2qxuCpY8c5ygu399fX1tXe0ubRyMnmdG01enBVV3/AByGW70y/vxnpLaLgHRGtg4z8L9HbIHMuShoSGrxbnkBrfAzu8BObp/cOYETO455nxzHi7DytQQIpGIvTbZT6eLnghJpifHchtTXaoqewgVGDkXBne5Khb84TUwVLy2O3eIfXH3kH0CbQBSYk/4fc4fz8olAvEHBIOzyD+BzzpZkBTYP5fOzjnkLLjtE7wf6ARBHfvutnXwfCFa9Pf3q9lsmnN2adfcW+wvUCbZC6rWfD432IJGDgno8v65Z5b7xDn8zp0Lh6lWq2lzc1OlUsnGYJKmra+vmx7Y9va2qtWqTWCbmZnR/Py8arWaDg8Ptb+/r+7ud2N8icS5ZKlUSr/97W9VqVT05s0b62aV3sFjkqzhqL+/3wp99DbMzc3p008/NZ0r1ILz+bwxpOhEd6UQSFXBVHGIMzMzV92uv7d4SMxzAWPH4Hu9XiWTSY2NjdkgMeZhoFE1NTUlSdYzwN7DT5fe9bmcnp5qdXVVZ2dnevbsmeHXoVDIPg/OKxaL6ezsTA8fPrTDG/79YKi5uTkFAgHDuSnmM4wpGAxa8+VXX31l/S/M6IHqSzNsp4sOcTqLs9msZVNuXwTPj0I++wHrzufzmeIvlNiuri4bbtdoNKxpkej89evXBqfg6IEVXH085vPUajXLnpLJpMn4QBx5+/atjo6OrKh+WQMP1hOFab6bK4jZySLY2NzcND097hUBwt7enjXWQvnms9CUC2QCEYEGYYwR9OtsNqtf/OIXKpVKWl5eVjabVSgUsjOIcyJbki4QEpxgJBLRyMiIpqamrLufTPXZs2fWY0Stj/ko1DqovzDxEUWF992/N2/eaH19vW1eDcYZ6JmpkJQHjo+PFY/HNTc3p2bzQu8MclEikZDf79fR0ZH1s/X29iqbzep3v/udKpWKoTc4Uhy3JFM59vv9do75LLFYTJOTk/L7/crn86Y0kk6njQAgvZPgYfAdDF7IEqiCwMy8yrqycyGCgzEDrifJjDO0yvPzi7nsZBSlUsmolc3mhfbX8fGxURAxCl6v11g40BKRR4ECScYBLZH+ld7e3rZo2+/328Ps7e3V5uamstms9vf3TWaB1wDTpNAOjuzxeKz/IRKJmIRHp4tDRlRKUyYHhpQXlg3yMNAqMSzUDdzCNZRIKMwYqmw2q6+//loHBwdaWFjQjRs3LFoiAmRypatc0NfXZxpORNCSbAQ0DJXR0VF98cUXSiQS2tzcNIo5kRh9EUNDQ+9FiCAb3d/fVyqVUu730xNhv1EchrBBLYVLA8QJpx9JHYrRNKhxlsiMi8WiDaQjsgTD55lx9jOZjEXu1GogjQClcf6g9TLYCQdM8RwJlmKxaGSF9zGM0juSDdNfOYMwMnEIZCOMASdShpotyebeY4jozZBkTc0wS3O5nJ4/f65MJqOJiQljIYESkIlLF5M+YU6iqM7c+dHRUYOCC4WCgsGg3f+JiQn19l4Mx+J7ukxAenpcFYZvuwg0gd3JXrFbvb29bdNQ8/m8iXLy/rOzs2q1WjarBSjc4/HYGGKUEM7Ozkx659WrV8rlckbldpVIqIF2dXVZ3QUbSM2l1WqZACj7R0c+hCXISy6zDHtYKpWspv6d11yi0aikd53WAwMD5hj6+/ste5EuYJyZmZk2Z8FUOHcmBdP1mMKH3Lw7bInIjYtPMZWUj7SQ9+f3qZWsrq7q5OTE8EmwTfciA6+Bn9PYxSYzO90dhfxtFwU50kqXqUNTGNEwTVdQOOkhwOBBAWUfgRxJ1en2p3h7//59zc3NKRaLKRaLWTMXkBapOJE9dYtarabnz5+b3I8kU1R1qbM0Ae7t7SmdTqur60J5FeiCiBPqdSfLjXY9Ho9JA0myHim3S5qf40Ikk0kjeJCxSTLYhXoelwlINRgM6u7du+bc+H/8u9t3wftDFiFQgGBSrVbb1AKkd4rMXq/XpodihCj47u3tGdzxPpkLcCwQEU2x3d3dSiaTGhgYsCZANP3cpj1Xhbu3t1eBQMCyaBeOJZtDQbmrq0uff/65ZSmonAORUZ9wWxNgobZaLa2vr+v09NQ6/KlNcX9RaO/q6lI+n7fPwzAyek5ACzpdQHzQ3BFxpUfF7/cbzNTT06MHDx5YgIoKBiQIvmu1WtXJyYndf84sAr4Y/48//th6+Nz+MRAR+rVAbiAcdHV1aXt72/aEQJnGXu4D9hMb6Da0ExjRPHrVdWXnMjk5aZgxjXuopxIhAIkwihdZB9hCZCLg8IgNRiIRJZPJtqIgA4larZZ1Z4+MjCiZTOro6EgPHz5sE20E/4QJwwyIb775xt6b74GYHAcOyRfglng8rps3b8rnu1AFgBee+/1wsU4W+Dq4+eDgoEZGRuT3+w3awwiFQiF9/vnnRgslisH40NUL/ED9wx0zjAENBAL68Y9/bE4EdgmGi0OFMUbHKBgMand3Vz//+c8lyTrG7969q0QiofX1dT1//lzValUvX76Uz+fT8vKy9vf3NT4+rjt37qirq0vLy8s6OTkxuKhT40j6Du4OecSVcnH7J4AaQqFQ27wV+jn4TlzAoaEhM2hkgdQYPvnkE6vXoHQABAj7kH3v7+/XzZs3FQqFlE6nlU6n7dm1Wi0z4gwGcynIFLXHxsbMMH399dfa29tTqVQy9laniyZA6aL+EolEdOfOHQ0ODmpsbEyDg4Pa3NzU2tqahoaG9MMf/tBUn4GuNzc3zbBCmXVZXNT6wuGwqtWqRfR37txRJBKxmh6NgQRM7DmwI9TvbDarJ0+eWF1NkgVlUONh63k8HmvW5HzAvKxUKjbg7n3uMOeFO3znzh37vqAf+/v7ikaj+vLLL62FIRwO6+DgQK9evbJadDAYVCaTMSUR7i86jNls1qjpc3NzGhwcNIozsO3l2inO6O7duzaG+eXLl8YC6+3tNbgrn89bM+/5+cVEz5OTE+uZwb7Tp3h0dGRq8VdZV3YubsRGtMFYXDj/wAQUganRAI/APsHQ0PgGFIGGDkWoy1216HG1Wi3bZCIJHgqaWW7RC7gIY0IECK0S0gEPnCZKDjrwWac9GpeX1+u1iEuSGURXXYCUm0tH9y375xaFodECV/IzLt3RTWXJIDGyGGikT9hrt4kTo0aREkyXvydy4vNg8F0YjDPRycJZuvtCZzPZ2mVaLYEQXc9cSgrQSFu4g9owRARNZK7ANpw/9plsBxgRB4UhxOFdJh/QBMezqNVqCgaDbYP1JBmGz517H+fi6lIBSfFdXfIFwSKG3/3OfG/+3efzmVoGe4Qj53d5H1d63tUa45zRBEtmAKLAd+bsuMaN/Xb761xlZL4rxrW7u7tjlQ32z4WfaYkg62C5gTgFdnffICxA0+b8+Xw+2z8UULCjLnGK8+86ZTJMvqMLT7s/Q5DUbDYNJUJqyO/3t8ntuIQeZGS+8z4XNx0C3snn8+rt7dUHH3ygZDJpBq/RuNAfo/MX3BFM/OjoSLlcTktLS7p165bVFKSLgt7e3p7BbmDEeE8kuF+/fq18Pq9EIqFQKKT5+Xn94Ac/sCa24+Njkzhho6AArq+va3JyUjdu3LBUvVKpGF2arEm6iJhdfbJOox4cGnBLLpfT5uamDWdCu42fYWCX2/wHA4ZINx6P6+7du23yDm/evNHe3p7VmxqNhp4+fapSqaR4PG4REaQCDvbk5KQWFhbUaDS0v79vhjOZTJqOXK1W08HBgWl08fooDMzNzVnjFZ8ZqZlvcyj/0Do+PpYkq3tAMAgEAvriiy/ahkBVKhWLUAkKOH8U83O5nJLJpBYXFxUIBEx3a3d3VxsbGxoYGFA0GpXX69Xh4aG8Xq9lzoeHh3r79q1OT081Oztrc2QePHhghJft7e02JQSMA0q0ExMTun//vjVWVioVG+xEJtRqtWwwVSqVstkrnS7GOXR3X4zHrlQqNvTs/PxcyWTSoGOv16unT5+2BVhAm+VyWRsbG8rn87px44Y++ugjswn1el1v3rxRsVi0PazX6/r1r3/dphOWz+dtuNjo6KjV927evGnkkkwmYzOiOP80cnOegd+ldxCna+hx4pIscu90D7e3t83RjYyM6Pz8XA8fPlRfX58++ugjuyte78XIi+fPn9v57+vrs3pHqVTS6uqq2cAvvvjCgqF6va63b98ql8tpaGiorf2AGqnH41Eul9Pa2ppqtZqmp6cViUQUi8U0PT2tcrmsFy9eWAZH8E7m9fr1ax0dHWl6elq3bt0y50/2A9QHfAvshtO/6v5d2bmAuRMZwhYDsnEpiNREPB6PSRjgVV1F5d7eXiuYA+XQI0HHKwQAiqtEABTL6EthRjqSGpVKxdJn4B630E33LhEZHp3LB60XFhkb3Gnk6HYug7vSmMmDc2VzisWiZWVcHi4wkRdd6lCS0d06ODiwxtNW60KTDU0s0mgYNeCqFBLB9guFgiKRiOH0UjsVEWdLhARMAPwHtk/diuffaeZCIdkNUk5OTtTX12efyaVwQ+7gMhK1ETGS0QwMDFjUyPfL/X7gEo16nCkwdqJuMme3eE+U6vZlkaWzV+DfNMVSwKbhjvPGz5C5wMbqdHEnYadRtO/u7lY+n7dG5u7ubqPLIkfDmYXuz/3z+XyKx+Oq1WpWjOcOt1otCxDRxmLSJ5B4vV63gjMoCJ8VdpmbzbtBVqvVamu+bjYvpGtobcAmcYeoZXTqXOilIsOHuQYqg12TZAQP4Duo39SOXNHURCJh+91sNpXP57W/v2/9aq1Wy2wgdVUIT2QxZGiMRgGKhfTE+efuZLNZjY6OWuAnye6DS/WW3gV0wPDfuXMhPUOwr1QqGTUPHJpFN3hvb68mJiY0OTlpF667u1vDw8P2wdEBOzk5McPPAeZg37t3T729F9PfwuGw4vG4FhYWVCqVbMxquVzWb3/7W7swRIl0lhPtSxdzLcrlsl6+fGkGu9lsWpcsRX6KrcBRbuHy2y6gBSCsUCik8fFxK3g/f/7cGDjomDFbg34SvgfOt1q9GG/M5+TSUV9hvxcXF43qTM2K+hdzIvx+v1EnM5mMOTdgJNh6SK2AwUrvdOXIsjDQZJs4UGC4ThZGB+cCzk0hvFKpGCWdTvuuri7FYjETXUyn05Le0bU5d61WS2/evFGtdjHc6+zszOoTfX19FojEYjFzLvfv37fgpr+/X7lcTr/+9a+tQFupVGwIHF37OI/e3l6lUin9zd/8jTkmsiuMOE4HeKRQKLSRYTpZsPVcCMbtN9vf328LgKj3Xd5DGvNwhEdHR1a7BG4F1oONRs12aGhIkUjEVCaIvBOJhCTp2bNnFiwQ7HDGuX/Ygq6uLhuLDMznCnLisKnLEIC9b92Pwj1nULqAQZEVwglAlkBuibHRPHPuMCrz+/v79vs4TaRyYrGYEUyopUgXTmxyctI0xV68eGGwm8/ns0BAUpvW4M2bN9Xb26vXr18bZEjS4Pa9EAgQ3OPEr7K+lXPxer0KhUKW/tFQVS6/G08qXTB7oBsyUhb5FfjrMB5SqZTS6bSePXumUqlkMI3LWllaWrIHRV1mZmbGxCdJs7/55puLL/X7IjUMHS63x+Ox4lq5XNabN2/s+/l8Pk1OTpqWFhsKe4KIs9NF9gFZIRgMamhoSPV6XZubm9rZ2bFO70Qiobm5OVPcJSIm2qEPA6fukhJgoiCJMTAwYMXU4eFhRSIRBYNB4+nPzMxobGxMmUzG4DAMGs6MiJv9HxgYUDqdtrn2qCtALiBqcxtd3WasThZZxGVWEvTknZ0d26/+/n7rr5qentbY2JgNpiJjxrkAsTBADIyabKGrq8tIINTiWq2Wbt++3daEmMlkbIgahu7s7Mxkf8iiRkdHNTg4qO3tbdMum5+fN+IBgQG1mUwmY8Ph3sc5SzID7hIfQqGQ6vW6DSoDmunv79fs7KwFg2NjY+YQYIEiE8LZY4/JfiQZ6WF8fNyMMYodBEQTExNKJpPa29sz+IdeNZQsgOS8Xq8WFhasN+vo6MigMBcZcWc3Icfj1m87WSiRAxO6Wd7Ozo5SqZSxCKHfQwdG3wsjDnWejK9UKmlzc9PsKoxXHGUikbC+HortNFFiYw8ODrS2tmbnHDSG/SsUCvJ6LwRWY7GYwbs+37sxEShP4MQbjYapJhCEf+dNlMwLwMPSR+L1vtPL4QKQfgYCAdOtIo1FWysWi9nfSzJZDZwF8hsUjelQJppzPSwXAuNGJEg6R8MSDusybkjxnmicLIboB3LB+0jG43jpUQkGgzbDotVqaXh42NRyI5GIURvhzVOLqdVqikajbXTW7u5uizJZNEGSjsPMYUQvmQYzwDn4/f39mpqasgvu9XpVKBRMyRrWErCaSwEGYuQynJ+fWzPt+xTzpXeii7wvGazX69XQ0JAVySEacEHJwoCU+vr6NDc3p0QiYdkkhgwaO30DjObFQBGFA23QK8TzRRsKKXSiPPYPlhVGhUADmIVCN9EumSmwB8XrThcK10BatAAQEQN7VSoVax+AdUlDpcvGI2jAKdPv4tLAYRwRdBCo4Si6u7tNBuX8/LytMZA73Gg0jFUlyQgZGFFJRuyQZIaVIr/UPvSu00UdDNXxgYEBExjFEVCw7+vrs/HY5+fnxvhzyQV8drL7wcHBNnIOQpiUDAhmarV3wrb0oJB9EgCx5wSE2ECeF9kh+8YZxDlfhsW4w66N+Q+tK+80xd4XL15odXVV9+7d05dffmn4LRpecLbpgXn27JnW19cNrw4Gg7p9+7YGBgb08OFD/eY3v1FfX58+++wz6yiFn85BqNVqOjk5sZkZwC5us1k0GtX4+LjVccAmu7u7tbKyYrATQ6+AyLq7u0119eDgQMvLy4pGo9ZNfnx8bEVNDm8nixSdzGBoaEjz8/O2H+DSx8fHlvb7fD49ffpUa2trFv0EAgGjP+7t7Wlra8tYbh6Px9huw8PDmpiYULlc1pMnT5ROp9u+AxHYy5cvlclkNDs7qwcPHmhgYECTk5MKBAJG8VxdXdWbN2+MZs7zoGDIcDOi7EgkogcPHqharZo8OZlNpw4GNkvu92OLBwYGdO/ePStkBgIBbW5umtrsyMiIvF6vHj58qOXlZSUSCS0uLtpn6+/v15MnT/To0SN1d3drdHRUPT09WlhY0MjIiGXqFJDJcKgv8k8ueCKR0K1btxQIBDQ+Pt62f2/evDHtK4gj3d3dFjxFo1H19fVpZ2dH+/v7Gh0d1c2bN9VoXIwYcAO29yFFjI6OqlaraX19Xa9evdL8/LxRkYmMod3jpBuNhp48eaL19XVFIhFNT08rFArZsL6VlRUtLy+rq6vL+ntwCBAmqL1Cn8WxEKyh+oDS+uU7DHzz7Nkz67cYGBiwdgJqAcFgUIeHh4ZSkKHSD0MfXadnEMicuTszMzO6efNm2/5hA7ErHo9HT58+1fr6usLhsEZHR9XX12eK8s+fP9eTJ0/U29ur6elpa4RE0w04kcZXgkwCAeqzQO5kINwJGHIrKyt69eqVBZeuOgKBRG9vr7U7YB9ouGa8AXb9KuvKzoXI5jI9mIjK7/dbROKq1VIcJkrEIxPducVpd1Qni+I8Rdp8Pm9UZjf7cGVUiAzdZiOiKZee7Mp4YyiIivDa7wvnsFx6NoaLz+FmTvRL8PN0F5PiojA9ODioVCplr8+eE7EQeWAgwZvBYt2DA3UZuIQ9clNgCuPsPc8MwgN1An4WZ3CZvt0p3u02iLnLbTpDpoS9k2TFSxhDZCmRSMTo32S7OF+yDreAzD4BE0LlpJ7EM7jcAc6ZI4sBKiTb4zm4jgpGIb/v6k29T/aHob3M+iEb4Y5fPiNkbqhDS7ImSpALSXbmXL0wvj9ZGQ4BWIkzRdTtZvicI747Z5Bnw/lyX4P3dHu3WNzl9wlw2D+XFu1SeGG0Xs6kTk9PLeqHuk6/CYQOV0GAPeUuQqV3WwLcfW42m0YddjMO9z6zIDvwnTgPLinr8r59GziMdWXnkkgk1Gw2dffuXUWjUfl8Pv3qV79SMBg0Gh5yIxSSSMFh57C4rBQwJRnOv729bRvG5uCIjo6OzIBQlMSYSBfihplMRt98843K5bJFNNVqVfF43OCkWq1mNNGzszOjlRKZ0X+ARhWaZZcf0rdZTKKkmO/z+fTkyRPrvg8Gg1Y7IDV2DSrFdQ4CabArzS9J+/v7Oj091dDQkLa2tmxfcOQ4AQ4Xmcfw8LCkiyaqv/3bv1U+n7eZNrBWWKVSSRMTE/r888+tdrWxsaFEImFR/9bWlkE/09PTVlDtFPMeGRkx6C4ajaq7u1t/+7d/q4GBAX3ve9/T+Pi49vf3reDM5aRHxe0zoXZ2eHio7e1tBQIBzc3NqaurS8+fP9fDhw9tj7u6uuzcuH0GnF93QBkK07/+9a/bjEypVDIiDOcd2KRWq+nNmzc6P7+YWokUyMHBgT0vnCBF3E4XQcvMzIxlBdvb21aID4VCOj4+1sHBgYLBoGZnZ9t6z0qlkilnBwIBY9dRZwESTaVSpiLBXrvEDpxNpVKxDIMsifrN9va2yuWy1Wdo+qTZtdFoaGBgQIlEQpVKRa9evVK5XNbAwIDGx8fbzjtRODWaTu8wzvXWrVuamZlRtVrVmzdvTPJoeHjYzhTn3lUNQPsL8gmBN0zIfD6vrq4um1bLeWs2LwakUWNmdAQBDoERdcRcLqdf/epXluHBDEThhLoesGy1WtXTp09NBWV0dNRgWmqQkmw211XXlZ0LFFPSuVQqpZWVFUvn6B7lgOHpiJhd40yx0o1sOaRQFjkYQBaBQMA68tGEwgATSRAVvX37Vtls1vpTSBfdZrGenh7Dm9PptE5OTjQ4OGhkA7Ifagyut+9kYfxREajVLmT8yZ4ajYuhUfT0MK/bjWLdjM2NBt1M4eTkRIeHh0Zd7OrqsoiGA4lRkGTyPGDdxWJR33zzjba2tmxYWCwWM3HKTCZjKfvdu3eVSqX06NEj7e/vKxKJaHBw0Go8dBcPDQ1ZnazTiz04ONiW5eZyOa2srMjv92tmZkaBQMBGcLtSRGRkOBeyNZ/vQsAynU5b1uvz+XRwcGD1kVar1TZKF+PoRnkEOZKMavrs2TOlUikNDAyYNA2wJXUaGk6LxaIZk/HxcWPFuTR1zi31yU4X0Tx1EJiBMMPq9bqOjo5MmJSeL4I9kAkCHWjW3Asy2nw+r1QqZZRWshvYcrDMqJPh6Ijws9msnj9/rlQqZYKUwWDQxiFwP9HEymazJsa4tLRk44PJqHn+yB51GuCQuWB79vb2tLm5KUmmO4hzhlSCHhsZIXeAoNCVsYIsAXGHZwbhghozZBO3URf2HwjPixcvdHh4aGK19NNhb/g9bBHMxsXFRZs3hZ0mGwRFueq6snN58uSJpYQYM8QokffgAXCRKVTD7OFAQWmDG47BpYiOPMbR0ZHq9boJKsI2ATulb6FarSoSiVhBdXp6WtFo1CAuIkKfz2cNa4VCQfv7+0YVbbUuxOWOjo7M0NCVGovF2tLcThYRHJ/d7aCHzUFjIoVR9g+IAkPGZ6XnBz0mNKmSyWTbgWXuSTweVzweN6cN5FgsFg0C6e3t1ezsrAYGBqxvhX/3+XxWa6CewlQ7t8emUqmYsB/fESmbTpcLAcLAYYKfS8tkvDJnaXJy0qJdYCkKo16v15pspYv0n6wol8uZ9A+TL0dGRmyELYYLqGx4eNgyeuo2QBTd3e8UbBEWlN5l60C0bu8Y7+FCLu/TJyTJ7hGvC0To8XjaqPqw/xABHRoa0s2bN21fiZBhsdEVDn12fHzc+q8IzGCGcT5xUK5aRDAY1MjIiNGe6b1BQYHmTticbk8Tjuz09FR7e3v2nQmkvF6vZT6dLppQKbxzPyGaQAai7uEScAiEGU1M4CrJ/o5Apqenx84ZtOJMJmOtF8PDw7ZnIDzVatUykUajobm5OdMQY/9oCqagL13Aa0C92GTU7mG+QSiJRCIaGBj47msu//bf/ltLqcfGxtTT06PJyUk1Gg0dHh5qc3NTY2NjmpqaMuZYq3WhpTQ+Pm4y7G7jEfL8rmyIOyyJLuytrS2VSiV9+OGHlmqS2lGAYgMpaNfrde3u7urg4KCNFYOIIqm7y5zgAhDhwqIZGxszGK3Ty02RbHR0VPF4vK1xk2xlfn5eS0tLajQapuqLDL9L7yTCgyKIiirS5X19fdre3tazZ8+Uz+f15MkTZbNZfe9739P8/LxFPfR1pFIpM759fX26e/euwTQYk2AwaIQEnNL29rYpMNAzQoSW+72UOyKhw8PDxtDqZB0cHEi6oIOiwk3D19HRkXZ2djQxMWEd22DHRLs09pXLZWPaeL1eKxzzzMfGxjQ9PW1QH4OXqtWq/uzP/kz379+3Qn2lcjHoqlgstvXYYFjR0HKDq1QqZVEpDD5Jpr+Xy+VMHp0MDMLE+5w/6WJYGHuCEwauJYuLRqN2r2EpQoYAGaBJGkfJfeS5MBhrd3dXL168UKFQsL1EJQKKLNBzsVjU7OysCS7CNJXekU943m/evLEeNijvZCj8/WVFCPq8xsfHOz6Db9++NTp5LBYzJAdiEZmWq8PYaDQ0Ojpq3wuHQP1JkolUsn/hcFj9/f3a2trSkydPdHp6asoYd+7cUSKRsOzGnTuFI+nt7bU7TKDc29trTbvr6+vWauCOJ4Awg22gxgPLjv7C71z+JRgM2qU9OzuzlMot4hIZUoACs6ZjFJYI1DqyAiIe6ghudzKRAh3keE7gCRqSiL7cgi8GmYIfn5FokGFQ8POJGtyUk+jILRR2slzeOt3LbiGUiALJc7I7jDs/I72jNff29lo9AIcO5RadMujFjUbDMhGcV6PRMKdEVuIeRuAM0ncOGtRFDivyOe7n5DPyT/a9U0iCrJGLAJziFruJBt33Zy8w3AQMnMOhoaG/VwSVZHRkhPvOz89NHt39jpAxiJovvxavx/kmS4H2jNIAVE9gXn6f7/e+50+SZT7sE5E0iATkFjIK7jCUcwwid4JeCKBk7AN3B/aidFFzxIASodM3AaOJyNl9fWBUF9LF2AE9oYoMbHQZYWAfqdV2uofYkvPzc2WzWWOycc84azQc89l5nnwHlwADq8xVsEC3sdFoWFDHWQTiktRGgGDfCf7cc8PZcbXpOLswfXt6eiwLBTXhmfAefM/LpJp/53m76sZ+9tlnajYvNJ02NjaMsYRxxwGAtZJms4mMPvb5fJqYmLBi3O3bt62rvlKpmGx7OBzWBx98oHq9bmNXl5aWdOPGDZ2enmp9fd0K9b29vRZh+nw+RaNRwyCJ0NCmAreemZnRF198oUwmY2y2eDyu4eFh60jnIVOwvCxO923W0tKS6vW6vv76a71+/VqxWEzz8/MmL+73+7W/v6/l5WUzQLBKoE7THMbQpomJCS0sLKhYLGptbc3kIIA3iGI4oPfu3dOtW7d0enqqtbU1g43Gx8fVaDS0sbGhrq4u69gvFApGc6T2w1yb6elp3b592zLHw8PDNsiUiNx17gyc62RNTEyoXq/ryZMnWllZ0fDwsObm5ox0wAygly9fmhFxL14mk9HW1pbBZfF43GjMlUrFsgiUC3w+nz7//HPV63XLLD/77DPdvHlTh4eH2tnZUbVa1czMjPr7+5VOp/Xo0SP5fD7bP6ALWHw4j2AwqJmZGd2+fVv7+/t6+/atqSHH43EzPkTEsLeGhobey7mMjY2p2byYarizs6NYLKaFhQX19PTY+GJqltK7Gg1ZFGfQ5/NZtD02NqZEImFzl6DaU/S/deuWms2mFhYWVKvVdPfuXU1PT7dlQDj8SqWir7/+uu0zu8aQ2hZ7zLhmxnTThH1Zi4zM2g0mOlmjo6NmA9fW1hSNRu0ODw0NWc1zfX3dgpPLgSH7Cqwfj8cVi8V0fn5uDnJ9fV3ZbNa05hqNhhKJhKrVqj788EPNzc0Za5agiX2nF4iF2gmZH0EOxIf5+Xlls1lDGmhyJbjgTMBoc4Of/9D6Vk2ULptDkqX6ZAhkHkAjeGoiR0bVnp2dmReMx+MmnQ3sAqc6FAoZKQBoAJYFxSaiL/R64OezKB66v0Mx0JVzwHsT9WCEuNwc1E4vtytRnkql2maucInL5bL29/ctKuvu7rY9dIU7yVZcqASoiiYo9NagLns8HqsvuMw9mtVQB2C/JNlzZN9cpht1j1qtZvUUN0IkqyWC43t0ulBtANJ0KZySjMpN9uCy7FArAHKiC7m/v98CJNg57DN7i6pEtVo19V8yJgr+4XDY2FHUxzhnsJVwMkSoFKOJNNkbuqKld9EoEMb7UuKBPl2WF3vn9vUAR2EYqQ9isAkoOVuu03ML15xRHAPZM1kQC6MFVEbUzGeTZL0qbpaFniC1UV6L9+Jn3fHabmb5PvvnDnHjffn+3KPLIplQfN3PgNGHVUaxP5PJtBFBpAs4nBEGEBvcplBqrHwej8djsL/bZAzDFgiO/cMmY5vYc2Bg1lVJOVd2LkSwFNTZLEnWhe8WvYGq2IRCoWDwDbDM9va2McPYALqTfT6fNQ2RIpPVFAoFbW5uWlbUaFxIbiwsLFj2Uy6XrdOdghi1CrqgcWbUWlZXV7W8vKx4PK5bt24ZRk5xkaFOnay1tTVJF/NkEomEQUTQ++glkGTZA+rMwWDQDhwFzVqtZqOQXeFEnGA4HNb09LSazYvJeWdnZ1pdXdXR0ZEVPWu1mhX9/H6/JicnVa1WTSOJS0CdrNls2sXZ3d3V5uamzs/PtbW1ZUJ6KFXfu3dPjUZD33zzjXZ3dxWLxd4L7wYumZiYMPKHK/+C8SbdxwHS5EsTKd3e+Xy+bZzCwMCAyY3g8ImuyV5XVlZUKpWUSqW0trZmESHnfGlpSZVKxSR5oHlT/AYW8/l8SqVShqPTEc/ZTiQSunPnjkXJqVTKJIvep8Oc956bm9Pc3Fzb84Vi7AYI7A/QLEQYMtFKpaKdnZ22u0XtgzNFxgPLMJ/P6/Xr11aHqdVqGh8fN8d948YNlctlra2t6fT01PYQwgh3HnieqB2Yj0x6aGjIzv/h4aHS6bR2d3ct8v7Zz372rfePDGR+fl6zs7NmP05PTw3pAEKkaRjkALbr/v6+JJmB39zc1MbGhmX8zeaFbl4ymTSGJFBlpVLR06dPtbKyonw+r9XVVdVqNcViMZtOGYlETI6GvjnUHk5OTixQdM81qgLYCqSUqM8yFpsyx3eeubhzC5D24MPxgMFvXTG+SCSi/v5+ZbNZi9DoQGWMJxg+hx0VTwqfYLhHR0c2BxqhTKLz4eFhjYyMKJfL6enTp/b/BwYGLFtAABBHxvAlpDwgEdy9e1dffvmlUZzJirhYnaydnR35fD6TUD88PNSLFy/sgvCZuNjhcFgDAwPWH+GyY4jQ19fXtbGxoXg8ru9///um+UVvxNjYmHXTu4VTajuSjA2EqCXQ0vHxscmdu5g2l3tra0tra2uWZjebTe3s7Ojg4ECBQEALCwuSpJ///OdaWVlRs9k0Nl8ni/M3MjKiyclJCwro+nbH3mIEUIpIJBJGpS+VStrZ2bH95HPdv3/f2DbAim7RE/IDDMOtrS01Gg3THOvv79fMzIzy+bxWVlZ0fHysZDKpnp4e094jiMDgbW1tWa2MHgiyK0YwSDK5lu8ie6EgHY1GTQIeXTCGVnGPiZDd2R4Ued27TCBCUyWOHUNOHYLR3dwlaLyff/65nXn28OXLl0qlUkZowAFS90EGCvFUslgCHI/HY1AVmSs2odMAh3M1NjamSCSi4+Nj63o/PDxUsVi0/SMAgqVFhkCQTgZycHCg/f19BYNBTU1NGcSLDBF3nibK7e1tOyfs32effWYMz5GRERWLRa2srNgY8v7+fsvcXSIGNGiQHemiz+3k5ETz8/M2SqFYLGpvb6+tFnuVdWXnwkNEbBEnAJZOXYKCJ0aY+Q/1et2af6R3800ktWHk8OZdKAGIigiRSIGCKVmT3++3ZiscFQVypL5RDwXGc4uuyWRS0WhUo6OjxrQYGhrS1NSUQT+dOhcgE+RdisWiwVWkrBTTgOk8Ho/RQcnqXOYRlE6K9CiocnDdngpgNuZKnJ2dWeqL0d3f37donGd1cnJi9SjpHY2ViB8otNlsKhqNmkQEkXooFNLMzIwSiYTV5TpZSJBj6Lq7uxWJRFStVi0bY6KiS1UvFAoGyWH83LEAZL2k/UxKJPrk59l/aKRuPYfMm8AHXB/dLJwiWTj77hIzCLAmJiaUSCRMfn1wcFBTU1MaHh62M9Hp2t3dtbqY29UNwQXUIJFIGHxCkZ6zRHDAXrgd60AxZBZAbV1d71SUodm7jooesLOzM1MGhnpMvazRaCgcDreRQlxqNojJ6OioJicnFQqFDHIcHBzUxMSEIpGIMdk6WZxBoENEJnFq5XLZJmCSsUBeAjFBnwzIEVks1xkTxOGo6a0BJgeqJUDirBNAoso8ODhowphAkpAg2HcydcobExMTmpqaMrHcev1iJAJ6fKgzX2Vd2bm8ePGijYZHMatWuxiOVCgUNDY2pomJCWsIPD8/18HBgfL5vJLJpG7evKlWq2XzCDgoGFRJ9tAoaCJd7UpP0OUKFkhKT7/G/Py8urq6tLq6qrW1NcViMd26dctURf1+v7a3t/XmzRvDkVutlu7evavFxcU2GGN6etqGYr1P1Li7u2tsscPDQzuE0sUlwSky/4IDdnJyYp229GC4cvILCwsGW5VKJYPSaCqkeOeK2Z2cnBgNHGMAUYPXjUajWl1d1ebmpsbHx/XDH/7QlBK8Xq8pF7gR0NLSkiYnJw2yazQamp6e1vj4uEX3nV7sx48fS5I5sMnJSX366adGOacJ8dNPPzXYFYgvn88rFotpdnbWnAGK3lxiIEmownRCE5FL7wwqBpOoEmkYBEFnZmYM8tjd3VU0GtVHH33U1pCIPpUki1IXFhY0NTWldDqtN2/eqF6va2xsTLOzs2bs32f97ne/M7ru6OiokSIGBgbMqE9NTenOnTsGZZGdwF7i+yNThAMhk+H7uY2pPT0XY3qbzYtOcyjhULZxGicnJ1Zz5C6srKxY8fz27dsmHeX3+42CTnNmV1eX3eGTkxO9fPlS1eqF6vLs7KzV0ToNcFBdHx4e1uDgoOLxuBYXF9VoNIxQAKSOE242m9ZUWq1WLfjmmUejUevfgaVF8EyAQkApydAMBvY1Gg3TRgQ6B2EKhULa2trSmzdvNDw8bKPngcJ3dna0srJiwU53d7c+/fRT3bt3T0dHR3ry5InOz89148YN3b592+znd97nQrYC1kq07RbcOEz8t/RupK6bkfBz7t/x80RWGD0X/8W5gAWTgXDp3AIlhoAoyWUVuf9OdtBoNMwASu9mStM/876zINzucGTIibzcaJAGSww26TCRifSOSOF+FvbVbQCFWny5AZT9IhPkPaET8zMuyYGsiowQwgC1MWAUus6B59y6Rqc0ZOmd1pQrSeF+Xy4iRVTotESZOBPp3fn49wUMLlUcg8rZdCNK3pN+ARw4f08WxbmD4EI26VI9gaCQC6EpFM0v4OH32UMIMkA4LhuLs8gZYEGk+ENnTno3+tr9O/6eGgRwCgKTHo/HHJZLy3Yp7e4dJgB1ZZ+g0uLQgEIJvqCQMzb6fTM/MlZgQNAN93tzN8hwyPrIoi5T9N1Flii9O3+8BnvCGapWq1ZzpL7jjj0m6waZAAHiPvNMkBbibnAGydCxsQQT7PNV1pWdy/T0tKSLAwPHm85omC+kai6fn0uWz+f19ddf2+Z3dXXp6OhIh4eHGhwc1Pz8vBWfYPTkcjlzDP39/VanYSO6uro0PT2tWCxmdFgkLGA2ffzxx0ZLJkUklfz0009VKpVsLKvH4zFVWL4bziWTydjo3E4W0QlGHhiBy356eqpgMGhsL6K7TCaj09NT+0wUn3t6enR8fGwSD3fu3LEhQhj2Wu1C2v/BgweKRCIWNWK8ms2mZmZmdOPGDSugSu+mPi4sLOj+/fvWrEr01Wg0ND4+rgcPHpgRzOfz5vCB2IiqgsGgNVt26pzn5+clvWM2VatVbW9vGwSDwUJWw4VsWq2WzQzCKHm9F7I/29vbGhoa0v37963/AimU3d1ddXd3a3p6WsFg0ArHdHz39fVpYmJCN27c0Obmpl68eGGfl5EUMzMzxrpBweD09FSjo6P64z/+YxUKBT18+NDGGPf19Wl/f1+Hh4dqtVqmQst0wk73T5JlD9KFErHHczH8TXqnG5XL5XRwcKB6vW6D+2g4JoBxnQVEF6BUzrTH41E2m9Xx8bH6+vq0uLhoQ7MCgYBOTk60u7urer2u8fFxTU9Pa2dnR69evWpjz42NjdmwtnA4LI/Ho8PDQ5VKJSUSCX3xxRcql8t6/fq1KWyQneXzecu2gO9haP75n//5t94/oE03SMTeYXTdDA4GIsP5XIUDevtOTk5M5Xt+fr7N+BcKBZu2euPGDYXDYfn9/jbWns93MYdqdnbWZkLxGWjLAMkgKN3d3TUyz5dffqlSqaQXL15Ys+bz589NdZ5ADRTFFc/8D60rOxdqFsAvdOsS6YBnc/EktUV5lUrF8Hu0wjgMGEIyCnDgbDZrDAUKo0SbGGfmlgA1uI1W4+PjptGFF4bzPj4+rvHxcRWLRbvIkgzmoR+GiIxmt06hMTKiy3tDwyY9Efx7sVg0Y8Z+M8WO6G5nZ0fb29saHx/Xhx9+aP0WRIB0osPDB04keua5TkxMKPf7qZXsb71e1/DwsKanp5XJZLS8vGzjXGu1mpLJpEZGRozRQxTHwWf2DhNJz87OlEqlOjaOyGywTxhrsluibS6VSxxwHXhPT49pZvFMOcNkCF6v1wrDwLUIH/L+ZJ3MfYGiT/2K3gRm1adSKSNSpNNpjY+Pa3Z2Vul0Wg8fPrS9zefz1l8kyc4yOmDvA82CtROwwEJk38iUGRFNJEw3ONCNS+nnc6FQ4Ea1KBjQ14ND9vv9tkf1+sUck9HRUXNg1Kao4bqNntQv0um0ksmkJicnrW+L4jOy/jRpMnAL2ZhOzyB3mDtAZiS9a3Lls7t1GQJWV+6f54jkD04P+LOrq8savIPBoLH7QBPog4PBm0gkrF+PTJKgy20UbrVaKhQKOj09tfsN8wz4E7Yjma7bvU8t8Crrys4FWtzm5qbW19dVr9dtUh28doqSbqoYj8c1Njamk5MTra6u2t8TXZKC0UyFlwU2ALOFPw6VL5lMWiSAuurg4KCq1apF5WRE1WrVdJBI7blgPp+vTc2Xz4ehcPsmaEbsZLmNint7exoZGTGRQpwBF5xim9frNdw/nU7bwC7SfPS1mDNBQZ8IEZitXr8QvoOmiawMEA7kAqjcNLTCtqIIWSqVtL6+blnM48eP5fP5zFFzkYFMuQh8F7fj/Nsu1ABOTk50cHBgOl9er9eeORkewQhNohMTEzo+PtbKyopBClxCMlp0xMC0+/v7TRMKiRiiX2pxwIuMnUbPjsY16N3AmvRwkf3//Oc/l8fj0dLSkpaWloyyenZ2ZmQJSfY5gUY6XRA/tra2tLGx0db0ythdn89ntFQCuPHxcU1MTBjjCtiWvXM7uN2+qlAopJGREevlIJuB3s90UVfiaWBgwGpZzWbT5I8wctVq1VSSC4WCnj59Kq/Xq6mpKU1PT1uARrYoyeoMZO2dnsFQKGR1o729PYO+cAhAvyAAZCl9fX2anJy0mojbj4LKiKQ2nTmcKnNWotGoAoGAZYMoK7On6+vrKhQKNm8JWzc8PKzR0VGD2bgrFP+5w4uLi1pcXLS95+dgtvX397cxbK+yruxcwuGwXa4XL17I4/Hok08+Mb45xXSkD4hypqenNTU1pbdv32pnZ8cOMPghEA/469DQkEKhkD0UHtb5+cVIWoYWAWNgVIkimRJXrVatCAiVztXRgQo6PDysn/3sZxoZGdHBwYEJJFJjcbveBwcHO456ZmdnVa1W9fz5cz179kyFQsFGN8Ooo4gvvRuHPD4+rlgsptevX5tT5+LTTeuyPsD5h4aGLI0HMjw5OVEqlVJ3d7f1i9BAGAwGdf/+fRUKBX311VfK5/M21KhWq2l4eNgopIVCQYeHhzo8PFQikdBPf/pTJRIJvX371npfqEmQiWKIOt0/+Pu5XE6vX7+WJH344YeWFUO1zGaz5lR7e3t169YtTU1NWX8AtSVJVs87Pz/XxsaGAoGA7t27Z8O7YJXhMGu1mvWcLC0tGf5Nn00ymbR+Ii7//Py8ZZzowUkXWmm/+93vNDo6qv/iv/gvLEMEPiQokN5lL5eb8r7tog8ql8tpeXnZZHCAnXEmMNyoyU1MTCgej2ttbU2Hh4fWGyG9q3MSBEK/JTgEDiZwOjk50atXr9pgNL6zx+Ox5wxKwLhlsmFk+Pkem5ubisfj+vM//3Mlk0mtrq5qa2vLDD+vOTo6aiKunWZ/BHGnp6daXV1Vd3e3NSwDt7oQMQwvqMibm5v67W9/azIt2BWcC2iJOxXVVUGBELS/v9/WssGIau49+wzCcO/ePduvcrlsrSMnJydaWVnRyMiI/pP/5D/R+Pi4VlZWtL29bXddulAziUajFjBddf+u7Fzc4pDLCJHe0VP584foiBibf99yi4t/iBzgpntu4fpyUZJFKu0WYvkZIiGiQpdI4H6Wy8aw04Ig7395/9wi6eU9lPT3KKGXX9P9J//fhSPd6Jf343XZX97vD3Uvu8/C3R/pnXYWgQT7evnzvU8R1f0c7jlwjezlvXT/8Nkuw2Tu6/IaXBp3/yQZrOL+rvv/+Szu/hAA8FqX99DF5snw3DP6hzKU993Hy/RpPjfvd/k7ukV+PvtV3sP93pwL9965bDJeEyPrPufL59n9nC4EBUWazO4P2YHLZ7eTdfn5XrY9LPdO47DdrPPynf93/Z57di/vn4uyuM/z8nd3CS/uWby8f39IN+zyPfm2++dpvU+F8Hpdr+t1va7X9foDq3MA93pdr+t1va7X9fp3rGvncr2u1/W6XtfrO1/XzuV6Xa/rdb2u13e+rp3L9bpe1+t6Xa/vfF07l+t1va7X9bpe3/m6di7X63pdr+t1vb7zde1crtf1ul7X63p95+vauVyv63W9rtf1+s7XtXO5Xtfrel2v6/Wdr/8Px6voyrF1sbcAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 43%|████▎ | 86/200 [07:40<10:24, 5.48s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▎ | 87/200 [07:45<10:13, 5.43s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 88/200 [07:50<10:01, 5.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 89/200 [07:55<09:51, 5.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 90/200 [08:01<09:43, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 46%|████▌ | 91/200 [08:06<09:38, 5.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 46%|████▌ | 92/200 [08:12<09:55, 5.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 46%|████▋ | 93/200 [08:17<09:48, 5.50s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 47%|████▋ | 94/200 [08:23<09:42, 5.50s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 95/200 [08:28<09:36, 5.49s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n", - "Step 95: Generator loss: array(4.85981, dtype=float32), discriminator loss: array(2.4338, dtype=float32)\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" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 96/200 [08:35<10:05, 5.82s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Losses D=array(2.29125, dtype=float32) G=array(4.85981, dtype=float32)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 96/200 [08:39<09:22, 5.41s/it]\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[721], line 23\u001b[0m\n\u001b[1;32m 20\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n\u001b[1;32m 22\u001b[0m \u001b[38;5;66;03m# Update gradients\u001b[39;00m\n\u001b[0;32m---> 23\u001b[0m \u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdisc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparameters\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdisc_opt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# TODO Train Generator\u001b[39;00m\n\u001b[1;32m 26\u001b[0m G_loss,G_grads \u001b[38;5;241m=\u001b[39m G_loss_grad(gen, disc, batch_size, z_dim)\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + " 6%|▌ | 3/50 [00:14<03:49, 4.89s/it]" ] } ], "source": [ "# Set your parameters\n", - "n_epochs = 200\n", + "n_epochs = 50\n", "display_step = 5000\n", "cur_step = 0\n", "\n", @@ -2034,7 +515,7 @@ "\n", "for epoch in tqdm(range(n_epochs)):\n", "\n", - " for real in batch_iterate(batch_size, train_images):\n", + " for idx,real in enumerate(batch_iterate(batch_size, train_images)):\n", " \n", " # TODO Train Discriminator\n", " D_loss,D_grads = D_loss_grad(gen, disc,mx.array(real), batch_size, z_dim)\n", @@ -2054,15 +535,22 @@ " # Update gradients\n", " mx.eval(gen.parameters(), gen_opt.state) \n", " \n", - " if (cur_step + 1) % display_step == 0:\n", - " print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", + " # if (cur_step + 1) % display_step == 0:\n", + " # print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", + " # fake_noise = mx.array(get_noise(batch_size, z_dim))\n", + " # fake = gen(fake_noise)\n", + " # show_images(fake)\n", + " # show_images(real)\n", + " # cur_step += 1\n", + " \n", + " if epoch%10==0:\n", + " print(\"Epoch: {}, iteration: {}, Discriminator Loss:{}, Generator Loss: {}\".format(epoch,idx,D_loss,G_loss))\n", " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", " fake = gen(fake_noise)\n", " show_images(fake)\n", - " show_images(real)\n", - " cur_step += 1\n", - "\n", - " print('Losses D={0} G={1}'.format(D_loss,G_loss))" + " # show_images(real)\n", + " \n", + " # print('Losses D={0} G={1}'.format(D_loss,G_loss))" ] } ], From c2d731d8a3aef107cced44a78a939a13a6b378c5 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Tue, 30 Jul 2024 13:24:53 +0300 Subject: [PATCH 26/38] Updating GAN Code... --- gan/playground.ipynb | 98 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 97 insertions(+), 1 deletion(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 28051188..b2c68eff 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -497,7 +497,103 @@ "name": "stderr", "output_type": "stream", "text": [ - " 6%|▌ | 3/50 [00:14<03:49, 4.89s/it]" + " 20%|██ | 10/50 [00:48<03:09, 4.73s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 10, iteration: 468, Discriminator Loss:array(1.31833, dtype=float32), Generator Loss: array(0.469772, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 20/50 [01:35<02:22, 4.74s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 20, iteration: 468, Discriminator Loss:array(1.25664, dtype=float32), Generator Loss: array(0.526989, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 30/50 [02:23<01:34, 4.74s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 30, iteration: 468, Discriminator Loss:array(1.16943, dtype=float32), Generator Loss: array(0.59993, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 40/50 [03:11<00:47, 4.74s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 40, iteration: 468, Discriminator Loss:array(1.11762, dtype=float32), Generator Loss: array(0.624788, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [03:58<00:00, 4.78s/it]\n" ] } ], From 3bea855bd203e7da8b98b102ac72bbffb49f84b8 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Tue, 30 Jul 2024 13:45:09 +0300 Subject: [PATCH 27/38] Updating GAN Code... --- gan/playground.ipynb | 138 ++++++++++++++++++------------------------- 1 file changed, 57 insertions(+), 81 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index b2c68eff..be440fd7 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 517, + "execution_count": 538, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 518, + "execution_count": 539, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 519, + "execution_count": 540, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 520, + "execution_count": 541, "metadata": {}, "outputs": [], "source": [ @@ -71,13 +71,13 @@ }, { "cell_type": "code", - "execution_count": 521, + "execution_count": 542, "metadata": {}, "outputs": [], "source": [ "class Generator(nn.Module):\n", "\n", - " def __init__(self, z_dim:int = 10, im_dim:int = 784, hidden_dim: int = 64):\n", + " def __init__(self, z_dim:int = 32, im_dim:int = 784, hidden_dim: int = 128):\n", " super(Generator, self).__init__()\n", "\n", " self.gen = nn.Sequential(\n", @@ -95,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 522, + "execution_count": 543, "metadata": {}, "outputs": [ { @@ -104,26 +104,26 @@ "Generator(\n", " (gen): Sequential(\n", " (layers.0): Sequential(\n", - " (layers.0): Linear(input_dims=100, output_dims=64, bias=True)\n", - " (layers.1): BatchNorm(64, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", - " (layers.2): LeakyReLU()\n", - " )\n", - " (layers.1): Sequential(\n", - " (layers.0): Linear(input_dims=64, output_dims=128, bias=True)\n", + " (layers.0): Linear(input_dims=100, output_dims=128, bias=True)\n", " (layers.1): BatchNorm(128, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", " (layers.2): LeakyReLU()\n", " )\n", - " (layers.2): Sequential(\n", + " (layers.1): Sequential(\n", " (layers.0): Linear(input_dims=128, output_dims=256, bias=True)\n", " (layers.1): BatchNorm(256, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", " (layers.2): LeakyReLU()\n", " )\n", - " (layers.3): Linear(input_dims=256, output_dims=784, bias=True)\n", + " (layers.2): Sequential(\n", + " (layers.0): Linear(input_dims=256, output_dims=512, bias=True)\n", + " (layers.1): BatchNorm(512, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): LeakyReLU()\n", + " )\n", + " (layers.3): Linear(input_dims=512, output_dims=784, bias=True)\n", " )\n", ")" ] }, - "execution_count": 522, + "execution_count": 543, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 523, + "execution_count": 544, "metadata": {}, "outputs": [], "source": [ @@ -146,12 +146,12 @@ }, { "cell_type": "code", - "execution_count": 524, + "execution_count": 545, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -176,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 525, + "execution_count": 546, "metadata": {}, "outputs": [], "source": [ @@ -190,13 +190,13 @@ }, { "cell_type": "code", - "execution_count": 526, + "execution_count": 547, "metadata": {}, "outputs": [], "source": [ "class Discriminator(nn.Module):\n", "\n", - " def __init__(self,im_dim:int = 784, hidden_dim:int = 64):\n", + " def __init__(self,im_dim:int = 784, hidden_dim:int = 128):\n", " super(Discriminator, self).__init__()\n", "\n", " self.disc = nn.Sequential(\n", @@ -215,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 527, + "execution_count": 548, "metadata": {}, "outputs": [ { @@ -224,27 +224,27 @@ "Discriminator(\n", " (disc): Sequential(\n", " (layers.0): Sequential(\n", - " (layers.0): Linear(input_dims=784, output_dims=256, bias=True)\n", + " (layers.0): Linear(input_dims=784, output_dims=512, bias=True)\n", " (layers.1): LeakyReLU()\n", " (layers.2): Dropout(p=0.30000000000000004)\n", " )\n", " (layers.1): Sequential(\n", - " (layers.0): Linear(input_dims=256, output_dims=128, bias=True)\n", + " (layers.0): Linear(input_dims=512, output_dims=256, bias=True)\n", " (layers.1): LeakyReLU()\n", " (layers.2): Dropout(p=0.30000000000000004)\n", " )\n", " (layers.2): Sequential(\n", - " (layers.0): Linear(input_dims=128, output_dims=64, bias=True)\n", + " (layers.0): Linear(input_dims=256, output_dims=128, bias=True)\n", " (layers.1): LeakyReLU()\n", " (layers.2): Dropout(p=0.30000000000000004)\n", " )\n", - " (layers.3): Linear(input_dims=64, output_dims=1, bias=True)\n", + " (layers.3): Linear(input_dims=128, output_dims=1, bias=True)\n", " (layers.4): Sigmoid()\n", " )\n", ")" ] }, - "execution_count": 527, + "execution_count": 548, "metadata": {}, "output_type": "execute_result" } @@ -277,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 528, + "execution_count": 549, "metadata": {}, "outputs": [], "source": [ @@ -311,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 529, + "execution_count": 550, "metadata": {}, "outputs": [], "source": [ @@ -331,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 530, + "execution_count": 551, "metadata": {}, "outputs": [], "source": [ @@ -341,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 531, + "execution_count": 552, "metadata": {}, "outputs": [], "source": [ @@ -351,16 +351,16 @@ }, { "cell_type": "code", - "execution_count": 532, + "execution_count": 553, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 532, + "execution_count": 553, "metadata": {}, "output_type": "execute_result" }, @@ -381,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 533, + "execution_count": 554, "metadata": {}, "outputs": [], "source": [ @@ -394,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 534, + "execution_count": 555, "metadata": {}, "outputs": [], "source": [ @@ -418,12 +418,12 @@ }, { "cell_type": "code", - "execution_count": 535, + "execution_count": 556, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -448,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 536, + "execution_count": 557, "metadata": {}, "outputs": [], "source": [ @@ -466,26 +466,26 @@ }, { "cell_type": "code", - "execution_count": 537, + "execution_count": 558, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 0/50 [00:00" ] @@ -497,19 +497,19 @@ "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 10/50 [00:48<03:09, 4.73s/it]" + " 25%|██▌ | 50/200 [03:59<11:45, 4.70s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 10, iteration: 468, Discriminator Loss:array(1.31833, dtype=float32), Generator Loss: array(0.469772, dtype=float32)\n" + "Epoch: 50, iteration: 468, Discriminator Loss:array(1.02203, dtype=float32), Generator Loss: array(0.689288, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz92XPjaXbeiT/Y940ASHBfc6t9U6m75e5oyW7LDkd4fOvbufaV/5D5F+Zi5mIiRqGZibA1lq2RWm6ru6urq7oqK7NyYZLJfQOIHSB2zAXnc/iCXZIymeX4RfyCb0RGViVB4Iv3Pe9ZnvOcczzj8Xis23W7btftul2363tc3v9fP8Dtul2363bdrv//W7fG5Xbdrtt1u27X975ujcvtul2363bdru993RqX23W7btftul3f+7o1Lrfrdt2u23W7vvd1a1xu1+26Xbfrdn3v69a43K7bdbtu1+363tetcbldt+t23a7b9b2vW+Nyu27X7bpdt+t7X/5XfeEf/uEfajQa6eLiQt1uV9PT07p3756Gw6F+85vf6OTkRH/4h3+on/zkJxoOh6pUKup0OioWi6pWq0qlUpqdnVW/39fz589VqVT06aef6oc//KFOTk70V3/1Vzo/P5fP55PH49Hs7Kzu3r2rdrutzz77TKenpwqFQgoGg5Kk8XisQCCgd999V0tLS3rx4oW++OIL9Xo99ft9SdLS0pLm5+cVDAYVi8UUCASUSCQUDod1cXGhWq2maDSqlZUVRaNR9ft9DQYDlUolPXv2TK1WSwcHB6rVavL7/QoEApKkzc3N197ocDgsSRoOhxqNRpqbm9MHH3wgj8ejly9fqlarKRKJKBqNKhgMKp1Oy+v16uDgQKVSSYFAQKFQSH6/X7FYTH6/X9VqVZVKRcFgUKlUSj6fT/V6XZ1OR/1+X91uV5Lk9Xrl8Xi0uLio+fl51Wo1vXjxQsPhUMvLy8rn8zo+PtaLFy/k8/k0MzOjcDisarWqer2uQCCgeDwuSapWq7q4uNB4PNZ4PJbH41EoFJLP51MkElEoFFK/39fFxYUk2TNfXFyo1WppPB6r1+u99v798R//sTwej5LJpO1RPB6Xz+ezz9/f39fOzo5isZjW1tYUiUTUbrfV6XQUDAYViUTk8/kUjUbl9/u1s7Ojra0tpVIp3b17197P6/Vqc3NTv/rVrxSLxfSzn/3M9q1Wq6lYLOrhw4dqtVrq9XoaDodaXV3Ve++9p3g8rvn5eYXDYT169EhPnjxRt9tVs9nUYDBQs9m0/Wk2mwoGg5qenlY4HNZoNNJ4PFYmk9HGxobtncfjUaVSUalU0mg00l//9V+/9v5J0r/9t/9Ww+FQW1tb2t/fVyqV0vz8vMbjsQ4ODtRoNLS+vq779+8rGAwqFAppNBrpiy++0IsXLzQzM6MHDx7I4/Ho7OxMrVZLqVRKyWRSnU5HR0dHGgwGymazSiQS9rndbld7e3tqNptKJpNKJpPyeDwmOx988IGWlpb05Zdf6j/9p/+kbrer0WgkSZqenlYul1MoFFIikVAsFtMPf/hDrays6Ouvv9YvfvELhUIh3b17V8lkUoFAQD6fT6enp3r48KE6nY683ksfejweazAYSJJ++9vfvvb+ZbNZeTwe5XI5pdNpDYdDDQYDjcdju9eBQMD0hCT5fD6trKyoUCjo5OREz54902AwMD03PT2tfD6v0Whkuuvo6EjValXBYFDRaFSS1Ol0NBqN5PV65fP5NB6PbY8Gg4FGo5FyuZwWFhYkSRcXF/ZeJycnCoVCymQy8ng8KpfLarfbCgQCCgaD8nq9ikaj8nq96vf76vf78nq98vv9Go1GajQa6na79npJ2tvb+0f365WNSyaTsQ3odDpqtVqqVqsKhUL68MMP5fV61e129ctf/lLBYFD5fF4+n08+n0+BQECtVkvPnj2Tx+NROBzWwsKCTk9P9R/+w39Qr9fTYDBQOBxWs9lUp9PR3NycFhYW1Gw25fF4dHFxoV6vZ8oEIzEYDFSv11Wv19VoNOT1ejU3N6dIJKJIJGIH1u12NR6PtbW1pV6vp0QioXQ6rVarpb29PY1GI01PTyubzarX6ymdTiscDqtWq9l3bjQaumm3HJ/PN/H3aDRSqVSSz+czoWy326pWq5qamtKdO3cUjUZVKpXU7Xbl8XgUiUQkSY1GQ6PRyBRnr9dTt9uV1+u15xuNRhoOhxqPxybIZ2dnajabGo1G8vv98vv9KpfLqlarkqRCoWDvy14mEgl5PB4TZp/PZ4onHA6bEHo8HqXTacXjcbXbbZVKJfX7ffV6PfV6PfuON10ohYuLC7tU5+fnCoVC2tjYUCaTUbPZVK1Wk8fjUbFYnNgPv9+vRCKh4XCo7e1tU/bxeFzD4VBPnz6Vz+dTLpdTIpFQvV43Ze/z+cxAnp2dqV6vy+PxmCIZj8f288FgoEajIY/Ho+FwqJWVFTvX0WikSCSiQCCgWq2mcrmscDislZUVRSIR7e7u6ujoSMlkUsvLywqHw2q32xoMBgqFQkqn0zeWP+lSyQ+HQ3W7XfV6PTWbTZ2entr+BgIBVatVPX36VH6/X9FoVB6PR4PBQFNTUwoEAjo/P7e9TKfTqtVqevnypXw+nxmUXq+nYrGo6elpra6uqtPpqFwum4LE2HOHW62WTk5O1Gg0TEYCgYDJ1mAwkNfrNeP8t3/7t/pv/+2/qVqtqlQqyev1qlarKRgMamlpSbOzs2q1WqbwUciNRkPVavXGe4giTqfTmp6eVrfbVb1el9fr1dTUlOmjbrdrMuPxeDQajXRycqJqtarBYGB/JNmd9Hg8kmTOl8/nU7fbNZ3DXcZR5B6y79FoVMPhUDs7OwoGg1pYWFAkEjFHtdfrqd1uazwea2lpSeFw2Bzm4XCoTqej4XCoer2uwWCgdDqt1dVVjUYjPXr0SKenpxqNRhqNRvas/9h6ZePCxSwWi+r1euZ5SdIHH3yg6elp/epXv9Jnn32mZDKpWCymRCIhr9drl+n4+FiBQEB3795VOp3W5uamNjc3FYlEtLCwYN4ylxOPTrq03Hg7eHfBYFD9fl+tVsv+hMNh5XI5ZbNZtdttU0bD4VC9Xk/7+/uqVCpaWlrS/fv31W639e2336rZbOqdd94xIUomkwqHw4pGo2q1Wmq326rVajcWTLwnr9drSg/B5AJ0u11TmOl0WplMxiKBQCBg373dbqvf76vT6ZjR5NARqOFwqOFwaJ/ver+hUEjZbFZer9cikWw2q/n5efX7fe3t7anVaimdTiuRSGgwGKjf75twBwIBxWIxi644l3w+r0wmo1qtpk6nM/HHjfxusriMeLW9Xk+tVkuRSER3795VIpGwPyiz4XBo0S4XsNPp6Pj4WAcHB5qentbMzIza7bZ2dnY0GAy0tram6enp31NOfr9f3W7XlKTH4zEDzZl2u111Oh1TIkSKrVbLnIpCoaBkMqlyuayTkxNFIhE9ePBAkUhE3W5XZ2dnisViKhQKCofD5mXG43GToZuufr+v4XBoEXq73Z74fijgWq02EeFxHySZEs9kMkokEqpUKjo6OlI8HtfU1JRCoZBOTk5Ur9c1MzOj+fl5XVxc6MmTJybrvV5Pfr9f4XBYoVBIFxcXGg6Harfb5ghFo1GLIl3j0uv19OjRIxWLRUWjUcXjcY1GIzWbTYukkQHkHxnl/G56h9mjeDyubDarZrOpbrcrv9+v2dlZZTIZNRoN1et1i+RxdCqViil35Hk8HqvT6ahSqZixYI88Ho96vZ7K5fKEQudvUBhQmampKZ2dnen4+FixWEwbGxvKZrMKhUJKpVKq1Wra3d3VeDzW7Oys8vm8yS/OAKhUs9lUIpHQxsaGRqORXr58aUgFf15pv151Y4vFom2GJFPiqVTKPFg3UuFSc9GlyxDX5/MZXNbpdCzUQtAWFhY0MzOjeDyunZ0dNRoNu8yxWMwECugmnU4rEoloampKhULB3guBkq4Uezgc1vz8vPL5vHlMeGXxeFyJREKBQEC9Xk/1et0MV7/f19TUlObm5l51u35vIegYAjwJQlzpMqqJxWLyeDza39/X+fm5Go2GfD6fhsOhwUp4oAjWcDg0qApYwDVmCCHGKJlMamVlRT6fTy9fvjRlU6vVJrwqj8djihNFi0ASLruvwRuSpJmZGYN/2u22vF6vgsHgK3s91xdRG9+P7+r3+y0yaDQadkEwQjg54/FYJycn9u/hcFipVErT09Oq1Wo6PT1Vr9eziIPvOxqNzLjiBfLfyEmr1ZqQNf5cXFzo/PxcFxcXqlQq5uRUKhV1u131+335fD5zKHq9nsLhsHmt4/FYzWZTzWbTnKM3WWdnZ/adksnkBKTInQGVcP+NaCMWi5lS6nQ6uri4sAiPaNLdg/F4bNErMhYOh5VMJk2R4rAQDS0sLGgwGNh94b0DgYDS6bQ8Ho/a7bYikYidjc/n0/T0tL3H9eU6XnNzcxPP+joLR6JWq9ldAEolagX+DQaDJp9udI+B5/uFw2HFYjGLTqRLWQ+Hwzo7O1OpVNJ4PJ64Wx6Pxwx+IBBQv99XpVIxyLXT6ej8/NwiElAX9Ac/CwaDCgaDFm2jH0h/nJycSLqMRL1eryKRiEGar7Rfr7qxz58/lyTzDpLJpN566y3F43ETQjxaDEA0GlWz2dT+/r7m5+f1zjvvaDgc6vHjxyqVSpKkaDSqRCKhTCZjHls6ndbJyYl++ctfWijr9XqVy+U0Pz+vZDKphYUFhUIhw6Vdhep6PXjVwWBQfr9f9+7dUyqV0v7+vp49eya/36/V1VVFIhHFYjGFQiE1Gg1tbm6q0+nYgX388cf6yU9+cmPvmzwQB4OAYYy56NFoVKPRSJ9//rldLKABDDwL6LDT6RgMxffFMyKHgvdSr9c1Nzenf/JP/okJZr1eV6/X0/HxsSkE99Lj7Y7HY8XjcQWDQTUaDRN8LhCeZT6f13vvvWf5q3K5bHmbmxqXqampif/HwKGc2YNSqWTwiSQtLCyoUCioXC7r4cOHZjjT6bTm5+d17949FYtFHR8fm7F0jQpR+sXFhaLRqJaXl20/Op2OvvrqK9VqNVWrVe3t7SkSiWhlZUWxWEy1Wk2VSsWMjBtJptNpZbNZ9ft9bW1tmTFCYeD9AsNVq1Wdn5/fWDFK0rNnz+T1epXNZjU3N2fest/vVzKZVCgU0tnZmU5OTuzfvF6vSqWSarWa0um03n33XfX7fX3xxRc6OTkx5+u6ccEhAj1otVq6uLjQ9PS0OWmujAaDQRUKBRUKBfV6PZ2cnKjdbhsiAboRCoWUz+fV6XR0eHiora0tRaNRi15DodDEdybPMh6Plc/nLdq+yQJFOTg4ULPZ1NLSkj799FP5/X6THwwpehAIKxQKWaTDPZUuI9nl5WWLWkejkZaWlpTNZuXz+bS9va3RaKRUKmW6QbrUceSATk9PdXR0pG63azDq1taWIpGIOUntdtvkZzAYmAHjPYEs+f1KpaInT56Yg+Pz+ZRKpbS8vPzK+/fKxoXoIRwOm1XGoxsMBhZ2smn8N/gum45yxLtxPWE2AgXXarXU7XYNm52amlIqlVIsFjP4ByOCYeO9JZmiRXjBcVEgeKp+v98iLRQleRaSZYS5eA+vu64fCN+dfXAXhz0cDicMJ56e+73AdtlDwlb2hO/sGgvyPBiucDhs58R7cI7uufCHn/v9fjtPzgzvh0S3G0oDwdxkkdhEloiU+G54u+73Yg/wkjHo4XDYDLqLZQcCAbtwiURCU1NTikQiZqyQBb6zKzvk9fDUSXxKssQvSk6SedwkUVk4L61Wy6A2jBwR600X8o4nj0y5eD8eNPuHrLh7y35z70OhkO2n6+RhXDqdjsLhsMGWyWRSo9HIojOiRc4KyMfv96vf76vdbpu8u8/LwnmEFEEeEpngzhI931QGXciKfeRM2+222u22PQ/e/2AwmHgeV5+4++T+DAOCTI7H44kog5+7cshZEtW7BADuCH+QJ5/PN/GZw+Fw4vWgIcPh0D6Dz3uV9VrGBebD8vKyRqORvvzySwsFXXZSu93WN998I4/Ho5OTE/OK2+22gsGgcrmc8vm8Hf5wONTp6amxVoBwWq2W4vG4/uRP/kSFQsFCPC41z0WCkJxBrVYzLJTEPp7v8fGxnj59ahAKBxEIBAxaQ1BarZZ9/3q9rt3dXcPOX3cRriMQQAxer3eCQVStVifwfC5sOBw2tgeLKAtvHKPY7/ctrzIejy15DH5eq9X0X//rfzXjsL6+rlKppIODA0lXRpmzJZeAx473++6771p0gmKFHch7FYvFCRjwppHL3bt3jel0dnamRCKhxcVFOw+XuBCJRDQ7O6tgMGi4cyKRUD6flySDZbrdrr766iuDo8LhsO7fv6+lpSWTy1arpW+++Ubb29tGYnAhjEKhoPn5eZ2dnWl/f1+DwUBHR0eSLiPLmZkZSbKcGcoxk8moUChoOByqXC6bQQoEArq4uNDDhw81Ho8tMkep3VT+pCt46OLiwpLneNe1Ws2+LzKVTqcnDEa5XNbvfvc7SZfGMZlMmkxFIhFlMhl5vV6L0khWh0IhPXjwQPF4XPl8XrlcbiJiPjk5UalUUjqdViqVMthbkp4+farNzU35/X5LfG9tbalcLhuEg1ySs6xWq5ZsBwIkAgeiven+eb1eLS4uKhqNajAY6OnTpxM6MJ/Pa2ZmRt1uV8+fPzeHwM0Ter1ey+lWq1VVq1X1ej01Gg3bW+DU+fl5+Xw+y7+en5/r/PzcIjq/3690Oq18Pq96vW6Re71e13A41MzMjHK5nOVpMeJer1ehUEjJZNIS+TgK6BHgP5yIdrut09PTV5bBVzYuWK9EIqFCoaDz83Ntb2+bQux0Opa3GAwGxi5ot9sTQhuLxTQ7O6tsNmtKC9iALy9pIn/z4MED3blzRycnJzo5OTHLi9c5GAzMkJCQkq4sv7uJzWZTx8fH5imgRGDLQHMlKuNidbtd1Wq1Gwsm4TqeXyQSUSqVkiSDFciduFAZf6AlugwocHjX03E9z1QqZYLWarUsAiTp7PV6tbCwoKmpKV1cXEx4ZjwrkSl7hZc9PT2t6elpg40kqdlsGoHi7OxsAsLjWW9qXNLptHl8FxcXEzkymIS8N989HA4b/RjqsiSlUilLPJ+cnNhFC4fDBhkBURaLRf32t7+1pDX5G/Z4fn7eno08IrKcy+UsesSQI0+hUEixWMz2E8UVDAbtEo9GI+XzecPkpVf3Gr9ruXKDI4jnCmRDhORG6DgbnU5HJycnhmCwv9wZYCOUT7PZVLVaVTqd1gcffKCFhQWlUimlUikzpuRfLy4uLFrhHAKBgI6Pjy3aQNYrlYrOzs4mon5ktdls6vz83HSES5hxqcg3WTgGyWRSuVzOHLJerzeBKJAHLZfLprSJZpAbjDJMVyIc6TJKR1YoMYjH43YmoEIQfaanp815brVahh5wxkR06DU3D+TqGfIwoVDIkAg3/4oR/d4jl7m5Obu0hK3z8/MW0UBxrdfrlvjkS0iXnv/p6an9bjKZVLFYNGx5dXVVgUDA6hiq1apOTk4MmggEAup2u0bfxcsDh2232/Ze09PTZgxd6GI0GunOnTsqFAqqVqsqFosWkrdaLe3u7prnnc1mFY/H7UJmMpk3wmvX1tYsmYZndXZ2ZocmXSX7JRmj5rtgMzx0FHY0GrX9K5VKajQaKhQKWltbkySVSiVjpVSrVSWTSRUKBQUCAfs8Eo7uZ+Fteb1ezczMWKjc7/cNIoR6iROB0LJ3wAGSTNhvso6OjuzCttttlctlo12SLwBW8Xg8qlar9v1wFLg0XL5gMKjFxUWDYIfDoSUx0+m0CoWCBoOBFhYWTPZhIpHjajQaRp/P5/NGCcdjPTs7U7fbNUYUZ9pqtVQul00ZxWIxe/90Om1QG3+INt6EipzJZOTz+Yyu68Jb9XrdHCi820QioUgkMmG8UUC5XE7xeNwMSDQaVTqdViAQUD6ftxqjer1u+Vei5mKxaNF4KBTS+vq65ufnjYGIo+jxeLS0tDQBx4zHY73//vu6uLhQsVjU4eGhkTpcqE3ShBIlJ9hsNm98h4l8Ly4utLOzYyxIDJh0WSbw8uVLi/RDoZCWlpaUz+dVKpW0u7tr0B2KnggWpARdQ0TIPcLowxx06cQYUyIUUgaDwcAiIyAzoFZSCS7aA/tuOBwaiYbPAZp71fXKxmV1dVVer9cowFAVCU2DwaDK5bLOz8+VTCa1trZmGGskEtHBwYFdeBL4UPSo68hkMlpZWdH09LS2trb0q1/9ygSTOgKotBRWUaB0eHiozc1No/HiHXJJMX5TU1NWcPf8+XPj+6PsW62WYrGYJdTALnO5nP3uTdb9+/c1HA715MkT1Wo1UxZEg8Fg0IwLwsRFxrNwsXIYRb1eT1NTU3r33XeVSCTMQK6srOiTTz4xemmn09GXX36p3/3ud8pms/rBD36gaDSq7e1tFYtFC5VdTJmILplMam5uzqAR9ghePwlbPDsYQV6v14o63QjnJmtnZ0ej0WVtEN4ZRbD3799XNBq1KHUwGBhDEeNCPmU4HFriNZvNamZmRs1mUzs7O+p2uzo8PNT5+bnm5+ct2YlMTk1NKZPJ6Pz83Ojrx8fHViQ8PT1tCqPT6ajdbuvo6Mi8aukq19JoNHR2dqZwOGzMx5mZGYsiM5mMLi4u9PLlS9vzN6nRkKRcLie/368HDx7o/v37arVaFm3FYjHznJvNpjExY7GYKSyQBgo/8/m8Xrx4YTRuGHyFQkGSjKZMcjsSiej09FS7u7tKJpPa2NhQLBbT4uKiKTXkH1RidXVVs7OzZkxwEKPRqL7++mtVKhWNx2MjDLgUZKBIl9Ls5rded83Ozmo0Gun58+fa3983RIR7g3NNdEee9v79+3rvvff09OlTO0uMIaQc5BIdhcMBEnRwcGCoBrAuheEYFwhIo9HI4C33LgCzw+BEF/d6PSt6d3OqREuZTMaM/esY5lc2Li70AQ3QxeBJiBNR8N9APZKsEMu10iRPqXplM8ALEUpCxNnZWTNsJF85hFQqZbRFlynWbrd1dnamwWCgWCxm4WitVrNLA66YTCaNOcb3xvOEOnyTRXU1FxWF49J83YsARVS6Kn7j/wmxU6mUCoWCEonERL0LEIUrfP1+X4uLi2o2m4pGo6rX62q32+Zp89kIl8v+gdIINAF2DRzqRobXk/+8D4b+pov8GMl6vFhgzesJZ0kWpXi9XpOj68lPNzJ0E8M+n89gGPJYeI9EakQsGE4wfqAmlJmLZbvsReQX5g70TyLS8XhsigRI5E2MC/tFtImiJdJC4cAupJCYPI10FQ3wfTFI7B+v5U7hXLr5DhxGnglaOHtLpMY9wdOvVCoT9SHdblehUMjOnuVCem4U+aYL5e9CmSAMRBrFYtEKeaWru0NelagslUrJ6/VabZh0qR89Ho8Zde4VuonOG6AJ7vdEVoDHoEjzM2R0NBopGo1apO8SVdg7zhxjRE2Uiwy8ynpl4/Ly5Ut5vZc8+Hq9boIKTsyXIoGWTqcVjUZ1cnKicrmsRCKh999/34Tv5cuX8vv9WllZ0fz8vD766CPFYjH9+te/1vPnz7WwsKAf/OAHisViZmQePHigtbU1i2CkS7iO5C24Nh5LpVIxOujPf/5ztdttzc7OKplMGhXZrZe4e/eu1X8Awx0dHen09NQO+qYh9S9+8QtJsmgD5gbeDVAXRnpqakp+v9+gLBLJHKzP59NHH32kn/3sZzo7O9MvfvEL1et123cSxihKSVpeXtaPf/xjbW9v6//4P/4PVatV2w+UP8YYD5vo7fj4WNJVIR51MRh6oEzCa5KvKIjp6WnNz8/feP84b0mWS3IrzvFaXcbbeDxWsVjUYDDQ7Oys1VlhUJET9tTj8WhqakozMzPy+/3mfJydnRnrqdlsqlQqaWtra8K4NJtN81jBsYnoSFDjYQ4GA01PT2txcVGRSMR+9uWXX+rJkycWKUYiEb311lvKZDKqVCq/R0V/3YWhLZVKE4Z2NBpZUn1jY0OffvqplQVIl0n1k5MTxeNx5XI5eb1e7e7uam9vz6BOlFIgENDz58+1t7enxcVFvfXWWwoEAgYfQmd2Mf1sNquVlRWDzOr1urVdAjo7OTnRF198oYuLC8unDYdDc0hBH4CLpCtjCgwdiUQs73aT9fjxY0lX3Qwgs8TjcX366adaWVnRZ599ZkWH5Dr29/ctrwV8eP/+fWWzWctduW2D3M4FlUpF0qWxwDEnSoFIU6lU1Gq1rFQjEAgol8spEolY4v/09FRffvmler2elpeXNTU1pcPDQ7148cJymaQlpqen7X4QNTUaDWUyGeVyue/fuLjWE1aDpAmuPN4Y0QtJok6nY3kWScbGIr8Si8XMm6GgZzQamQUHGuK9fT6f0f74LATHpbu6hUsU2bktVIie3AI9l9VFrgAvFI/hJgshYbn0z+v0Q3dPuYQu7ZrXJRKJiaIwzoiokSS1yw6Jx+OWg4H4wL7CqLlejcsZshffVcjpFje6DBOXtgwh4SbLZcRxrhQVus/qGgt+j2iLvcWIsi+uoXHlyI2KXNo9NHWX7sm/4ZlLmvCo2WP2Eaycc6JSmgpyWG4oG/c7vumCtYTD5LKtgF1ABtzzjkQitocUIF9fRBXUvyBXGH2cEQginCcyS2REJMWZo3eIoGB4Eg0jp1DzXefXjcS/K4f5OvvGIgrljF2j4JJu2LtGo2F5P5h1uVzOzh+iFPowFAqZE+/1XraXAQmCns295K5xBwOBgMkPjnOz2bT7DTLjFutyhzkHzgX9Q+Eqe/oq65WNyw9+8ANjAVFkRaIHbDocDk+0bMHC03AOYXXhNMK/8/Nztdttw7phi0hX7JanT5/q+fPnSqfTRm2EPUII3m639eLFCzUaDQvrSILx2e12W36/3yw0Fx+2Cl7ocDjUwsKClpeXrejtpoLJd3EhKJTcaDSyKm+iI/p94Y0tLi7qpz/9qXls0iVj68WLF/J4PPpX/+pfGWOp0WhY1wEgsX6/r8PDQx0dHaler9t5rq+vK5/P64svvtDZ2Zm1buHSuMQId3F5uOBESFxkzpfEf6fT0ebm5o33D8eE5phAlJwfFyqZTOri4kIHBwcWsaRSKYNyvV6v3n77besfVqvVlMlkrMJ7amrKcGjqFPx+vyU7kVe8TnqR7e7u6tGjR0Yfli4NiOs4kXgG4gHXJnEbiUTMe5UuocCnT59qe3vbGEZvsoBfms2mXr58aXkonjmfz+vi4kKPHj1SJBJRoVAwQ4LCc+soXIKGz+fT0dGRKbSZmRl5PB5tb29bO5JkMmn3k7wsedvd3V3rSRgKhTQ1NWXGC6XO3sfjcTOKEEZAUFCmKMRAIGDF3m50fpP1zjvvaDwe6+zsTJVKxVhtwWBQu7u7Rh9+7733LJoFxh0MLvvYLS4uThRL53I5LS4umoMMNN3r9RSPx62nI01Sy+WypQ2AXJeWlhQMBrW3t6dvv/3W7q+bfM9kMvrxj3+sbrer4+Nji7xJVbDvdJ5w77ELx71OOcErS+uDBw+MVULDSkkThT2Ed8AwbiIVBQ5myqWlmp52K9ls1vIqvA/e9M7Ojv7bf/tvunPnjj744APLsTSbTTucbrerk5MTnZ6eKp/Pa2pqyhQQWKmLk7rFkfwNFCJJ7777rsFL4MQ3WW4hFxeBvA5MHZQ0woTX7PFc9u369NNPLcE3HF62ETk4OFChUNCPf/xjRaNRffHFF9re3rbOCW7iv1gs6sWLFwa3wDKDI//LX/7S3pdkIIYMA+MKFufiFipKV5EeXlQkEjE46aaeN/UYbldkIgXySvx7tVo1dhmdYl3m28rKiubm5uyCxWIxra6umgHAGFIrgEyQH6Hxqdfr1fLystVgPXz4cOLM3GgexYxCbDQa5nnCQuKSs4A8+v2+MpmM1UXddMHgq1arE3eGCCYcDqvX62lnZ8fIGnx3jAbRqNv5WpJ1SkDmaAB7fHysVCql999/XzMzM3rx4oUODw/l8XjMGWg2m2o0GtbrjeiPImqXUovDQk+y68WCeN7Au9Tm0ZHgTeqEVldXJ84vEokom81KktU5uc06Dw8PTdcMBgNrPwUKQZ5keXnZmJhu3jAej2tubk79fl87OzvW3/Do6Mj0FeSKbDZr3YuJQj0ej8lsPB7X8vKynQnvQU6sUCgYM9CtacOouIW8r7pe2bjgSUCTAyeF+dJut+1Bseh+v9/acLt86vn5eeVyObPePDSQDt48TDRqW7rdroWOp6en1gWXthlQQanmh/I5Ho+NHglTyE1gkbjsdDpGIwQyoS8UuYybej0oVcJgLqmbyOfSEgpDU+VZ9vf3FY/HLSLh5xSrBgKXXWuJvL755hv7XUmWfKcojwI22pfQIZhOyG6PLjePwflImsB8O52OxuOxKSvySMAh0Cpvun/kCKhaBtaj3xGJSEgNo9FI8Xhc6XTaLsV4PNbh4aHBojg+GH8MvXRlUGOxmHmgRNvr6+smj6lUSrlcTnNzcybHLgVWuuzgjDyBmRMd0r6GeiQgYOSh2+2q1WrZmd905XI5O0vOGWXebDat9sSF6oj8MURud3TuNPeWxLsL31JGUCqVDF4k6qM1jstGAz5CGUOm4F5wZ4Bn2CfkE/iM2hCQAD77TWDFw8NDc4yhAwMP88ytVsuKSN2SCZxxiCnonHa7re3tbUNOcNSAfik0JWeFAXKLhkEkyuWyGXWcF+4Ld549ANLjeehfh6Fmv4CD3Xq3V12vbFwWFxc1GAx0fHyser2u9fV1/cmf/ImGw6H+43/8j9rc3FQsFlMmk1EqldKdO3eMXkv7BzaZ0LBYLOrs7Mw2YzAYmALHYjabTX3zzTe2cffv35d02eus3+9rc3NTp6enWl5e1jvvvGPYZyaTsb5WwD90ZyVnBE65sLCgeDyub775Rs+ePbPkWiBw2c2Z19PL5yaLQ4Mp4tZW4OXiyfJcfr/foi+fz6ff/e53ikajunfvniX8acP+9OlTi7hqtZpKpZK+/fZb+37w2aHsIlh0TqjVanbpO52OotGofXeUoYv5YxQHg4H29/dNICUZdHE9gn0TtpjLFAPigoFH00e35TtOTj6f1+zs7ATT5+HDh+r1elpYWNDCwoLticfj0fHxsU5OToyJFwwGrbaLPMvU1JR+9KMfTTgBrVZLpVJJzWbT6L3AMN3u5TwTFA5eNfg3ihs6LR66JCsyRl7exLjgeZMTmJ2d1XvvvafxeKxHjx5ZR2Z3Ts54PDbYLp1OW1+wQCBgBi8QCBid1S3So27F57vskeX1erW0tGSt3Bl14ZJEyNMUCgXF43FzXF2iBgiE3+83uBSnYnt7WwcHB8pms7p7965FZq5Hf1MDQ9eRbDarbDZrjDmMCxA9naOJsom0MBb9fl9zc3PKZDIql8t68eKFstmsPvzwQ4PM3C7ZnU7HnGlyXUTFo9FIX3/9tfb391UoFLS6uqput2u9Eclx+Xw+06ncXYgwwGEwTN3ZVuzZxcWFRe3fe84Fj8vt6sl/c1iEyuB20lUvKF7rMhNGo5FZTh6a+SmEnyi+er1uicDr9FAElPwEm0qiy/2DkiMxiaJyvwsKDLYEP3+ThH4sFrOkOmHyd1Fo3f1BgFxKMt4veSM8EveCumfh5if4DuPxeGJWB8VZGBfGKhBpuL3CWERb0lWy/Tps5nqU16mTr7tgN11/Dzfx7npW4M0oP7fOgXN2KfR8F7x0lyLOeZA8db+r21WCxpxQklGy7r6498WN7FzDzFmzhy4U9SaLu+J2XHAjUlfpcu58rru/nANRA/9+3bN1jTayB2mCO3z9GXh/Xsszs5+ux+4m578rMnEdIRL8bn/D113cP+lSvlxd6DLvcCKAQ0kJoLxddij3yK0h4btcXFxYmxvyHhSmdrtdi+DRzRgNzmY4HFpk/l3EIX4ffURBNj/DueC5OJ/v3bj87d/+rXkGR0dHhpP6fD6DVMrlsmGs0Ag3Nzd1eHhohWLg2uFwWAcHBxYpEEL+5je/0dnZ2e/lH6AbQibgd2ZnZ7W0tGQJx4uLC7148UIXFxfW26lcLhtDikI4WBvdblf7+/tm5JaXl83r8Xq9KhaLBhkcHBzc2HP8gz/4A0myhC5sGDfcZwUCAQubXcEggtjd3TXCgSQjUqAYgXFQhrDiSqWSzs7OrDusW5e0srKiu3fvWgW8dEkYANJ4/PjxREhOhDgajax9hYt3A0e6Qv8mXjezdtg/cPnR6GoIGXx8MH86RZA/oH/d7Oys4dkkrTFeFO1RxzMcDm1EA/vnOlZ4lFRiU4nPnlBXwDMcHh5aB4i5uTnLSXJugcDlwK79/X2Dc7PZrDGw3mR9/fXXRs0FnwfCYpiZq6iozK9UKr8HV9FN4OjoyPrIuTlSSRYFeb3eieFzsKRwcCgshMHY6/V0dHRkjil5i0wm83sOC4arWCyaQc7n8woGg0YSQjcQBd7UuKCYye9hHIHJgsGgms2m6vW6FYfSvoWalrW1NduPdrutXC430ZWds+j3+zo4ONDjx481Ho+NLba5uanf/e531jEiEAgYIYVn8vl8unPnjiEl0JoZOYHhi8ViSiaTtn/1et2iLY/nsv8dsDd3n8LvV1mvbFwODg40HA5VKpUsFHQ3Gi57qVTSxcWFXerz83NVKhVLFrkFWY1Gw0JpRr7u7u7q5cuXNjuACAMvG4iN5F02m51oNcMzwgIiSiFRxfwXDpOLRg8kmudR5V+v1+3CgfHfZNE+hboLSYZlstx6C7d41DU+VPKCkfb7fSsg5bKhbPH6iEzq9brK5fIEmwnBT6VSWl1dVTwet7qXRCKheDxuPdbchYC6ngxnRSTler1vumjCidGEWedCTS4LkUvldh5A/oB4uEjkAiEM0JqoWCxOnA3GCzkEhiyXyyoUClYfA6xAzgqjz56gBGE/QYagV1er1bLhV7Avv8sJed1FhTvwm9/vV7FYNNjIxeRpCQIc55In6MDgwmHAYNxB/ri5Vsgfbl4WiM71pCVZL0KiE+6EG6VLss8jmsdoSTIo10VNXDrx6y6ejWflO0maOEecKfJ9OFZTU1M2VpoODqFQyBxD7g4/KxaLNuWT3njlclkHBwfy+Xwql8tGDKKPHUQa9C97D2xHZIhDlcvlbMKqCzeSN8VhvI5SvMp6ZeOSy+XMI6tUKvbhbq0A7QKSyaQViI3HY+NHP336dKIwjG69eMp4bS7ThoRnv9/X+vq6lpeXbVNQojRd5JJgeU9PT80rYpYBYSRzJuieSkhPWxG8MYq5wO5vCou5szTW1tYs50QoivKBgkinAD7P9fzxoNwEHN7Zs2fPdHh4ONFehvYuQCF4cG7h28nJif73//1/V7PZtLkSdLSmMJKLhLcIDx9Dw7+T+MWYkjgnOrjJevr0qV1YCnapLiYh7xoXlOXW1pZN4CsUCgqFQjYziGmKwLJQ3jEa0HXj8bg6nY41IgSy4MIGg5fzbZ4+fWrKD9nlQkNLpUNvLpezyw90RHTi8/n04Ycf2hnjjbKnN13z8/MajS6L+ohc+DzgOhwvYMXhcGgUZvqhtVothUIhY3NBKsHBQ/lSkEcJA3AODg2Knj2ndYqbZ3IhO+SdiApIV5LJF+/lJtnb7bbC4bAxXW+6ZmZmLBdFtX0ulzOjyc9c6Pvi4sIS8UTNQJ84048ePbL8IAZ2PB5rf3/f2h4xUO709NSiJNfA01WaJqfoMqjLNEPFKSK3uru7a0QKctyVSsWiTheGnJmZ0crKyvcfueTzeQ2Hl439uBBAKngWzMBIp9NaWloy5RiLxbS/v68vv/zSuOy0YDk/P5fH49H5+flE8SDGq9vt2qW+e/euUUbh0R8dHVnNAF4DNTWbm5va3d01wQfDDQaDOjw8tK4DjGelEM71vGAWEencNG/w9OlTBQKXHUzX19fl8Xj04sULE1Aa/dE5muFA0mTbDgTHvWwoXb/fr729PX3++ef2ue7r6WTs9hZir7788kv9l//yXzQYDGxK4cnJiVF6XazaZZK5ECUXmwpzSWbEo9GocrncjfZOuqyO9vv9evfdd7W0tPR7ORA+i+fiEu3t7aler2thYUEffPCBPRtFvfF43JQUEGK73dbJyYm2trasW0K3e9nOnYQsCXmMCyQK4A8wb87NZbbBlCQCR6YgUBQKBetm8fjxY52dnVn34TdZ9LCiazCdFPBKiepwCslxoLS2t7e1vb1tpABex3O5+SWv12vGhTNxGyhKVyOr6XJQr9d1fHw8UWPEH1feqcUi/xAOh7W+vq5oNGpjqMnXUrfGeIrrxcyvs+bn5+17AtVNT09POCdEZih9ZAn9tra2ZnVMwWBQ33zzjX79618rkUhYzzSKMff29rS1tWUMRI/Ho1QqZe36M5mMFagSgbIwsDs7O9ZDsdVqmTMKWw+YF0Nfr9ftffgb4zI7O2vD0V5lvbKmxAuD2w20guKRZN4gngzhLsmsRCJhORqS94RxGCyGgZHQ9ngui4QGg4HBDpIM4iBiApIjMcXfbrUpr+fikIB16yQymYx5HODlwBqE6TdZXA7qPUj6SlfJcbdoib5dbvIXrwbFSaQjycJn6iJ4X+lqNHChUNDGxoZ54tBsYajEYrEJ6jGRDufoes28t0t1dBUBz+AmsHn9TRYV5dVq1Rg0yAI5AmioyBuRLfLFZ7Nv7CGJU1g51WpVp6enJpsoMhcCJGohGsZQuw4S5+UmetkT6apPl5uwh5FGQhvFzHTXN8lbUeGdTCaN+ciZEf25nTXwoJFPt5CTAj6gShcqSqfTFmGSg4ORmUwmLY/C7+K4YGA4G34G25C6MBwKWFM4NtLlPSMRzUIX8L43jf4YuUHkwB0BasS54owgkLhEB5hjnDO1TewXUDPNZtl/ZIUzgsHnQok4NOg/FrVE6Fs3wqQ7CXKIkzocDm2eC+kHnP1XJZa81rAw6XI4EpW8XEgS7jMzM7p//755Ji4VLp/P6/79+1ZL8ujRI2vngLWOxWK6c+eO5ubmVK/XVSwWFYlE9LOf/Uy5XG7Ckzk8PJR0NVfk4cOH+vzzz20k7Wg00szMjAqFwsSFxNvNZDITVfsej0fLy8taWlqyGhEozFNTU6rX69rc3DSDcJM1Go2syy30SjfP0uv1zPBClpAuL0w2m7ViK7o388fn8+nRo0fGVMJwSJcKhfboP/3pT60X2a9+9Sv1ej1L7hcKBd29e9eGotGrCeFGSbg8eRwH6m5cg+R2GEABv8li1MJgcNnrKJVK2RgIDDEtzXEIoKFSf4WBBBJClqrVqh4/fqxqtapHjx5pd3fXokewbZQEjQSRI7y6eDxuBXV8VxSQJCuG293dVaVSmWjeSK0E8G0gELChTKVSSefn51YM+iZFlHze2tqastmszs/PrbcUFFSMMjksN3lOLQbGFlgSMgeO5f3793X37t2JjgZ/+qd/al52pVIxOBoHjuLX7e1tU9Aw/AaDq15swWDQukxwpsPh0PJjOLjQdiUZhbter1su6ybrxYsXliyHiowRgOREktzr9Vp0CwklGAxaMSe93KC1U73v9Xr1u9/9Tvv7+zaSAQgMEhJFkUTIOIhuLvD8/Fy9Xk+ZTEYPHjzQ0dGR9vf3rY0LkDiGEvJOs9m0u//06VOLxNl7RlK8ynpl44KH7CbM8HBQZHhtvB7vB6+bBKzLCpGuxsUSUsZiMQufaUtBrQL4JZaZxJQkmx5JsptkGhfyu+i+XGpJE3kkFh4CBW43FUx+D+wVzwyFh5HjbxQ4+8MAIjw8Ck/dIig+x/U43e9FV2k8cJdxQ98x1yt0f46h4zK7niyvwRtyoTiUq+vl32S5dR+VSsUiPZcmCQR1XSly1m4SFg8PfL/RaFg7GAxjMpm0BDwe4nX6OHtAohul7EKI7B9YNzLmEi/c5Xrs173VN6kwd6MsWiVhHInsXON1PUridW5kA3LhPhcoBZES7MdIJGJMKHInLiEDb971/rkPfAZy5/739SibMyHKIpf2Osno71puiYN0NdrbpSRz7zhDvgOv514gexRF02KfBRkHfUoux/0DmzSRSCgajVrdDXnlTqejVCo10VXbXeS1MVpEVMB+dLF2C95fZ2zGKxuXb7/9Vl7vZY8r2ry7PHcels6hLNqQtNttHR4eajC4rNDN5XJ2mSORiHmXhGJ8qVgsZkk5oqZqtaonT56o1+tZ4psCr2q1ao0xj4+PLQLgYqIEo9GoksmkJbNozEeYu76+rvH4ck7E9artmywujEs/li4Frlwu26UDx+bnMDb8fr8Vc2J0qZKWrsJal/rL5eNSAEVks1n903/6T03ZUQ+zsrKicrlsHg7wJkrbjfIYGzwajezZqYrms1wF3+l0bDjbTdYPfvADDYfDCRq2W8Pi8Vy2KocsQV4PQzA1NWU/Qwk0m02L0sCjNzY2tLy8bPkISCxU0LsFuBS5QtnkMkK7JxqgK22/39cnn3xiZ4jBAeajDxpnHQwG9cknn1jnhHq9fqO9Y/3617823B6F9PHHHxuLiiihXq9brpTnJBdJREgRL0lynM5QKKRSqaRnz56ZwaU+LZVKaWpqSsvLyzo9PVWxWLTBb71eT+fn5wbZ0vEXIz4cDo25RDdqF17EwQSiCgQC2tjY0HA4tH6IdFi/qQzChqPH18XFhUFlGxsbCofDajQaqtVqVnmPY5hKpXR0dKT/5X/5XyYMOcw7CEg4FXR+npqaMod8OLwcQ0IfMHIv9AcE7alWq1bQC6mJNkPXDSO6klwURtl1Dskz/ndr/7K/v29cc0JkZrpjFU9OTiY472wibRzOz88lXbZ+p0nkaDQypkcwGJygDGcyGbOY3W5X6XRa9+7d09nZmbVBh2lFdwA8h8FgYEwJ6HrQRLHYMLRgdPB8EBLG47E2NzetdcebFAFCAcQYu9RLlJhbuIQ3i1eBkZCu5o6Q62C/WSRcOQM3XB6NRlZrMBqNrO4C7Nfj8ViimapihJDPJvELPMqsdBpEuh4+v0O0ddN1584dDQYDnZ2dmYLH8HIRXVgHVhYYMW3vKSqFalsqlYwIMBqNzHE6PT3V5uamwRrdbtc6SpBMdRlRODV+/2XzS2ZrpNNpa8kzGAzs/SFvkJTGS6VVTa1WkyStr69rbW1NL1++1LfffvtGsOzz58/l9V72VgPOpK0+xBUcOX6OgQa6QykSiUgyyIeIjFIFjAH5BI/Ho/n5eYN3JVkVOkiGC+8AYblog1uA7LJV3e4P9OljkigD3XBCbwotch/cnAjfnZEOu7u7xq6kdogW9+VyWY8ePVIwGDS4nTw2rweKBvqamZmxNk0MkWN0BYhEoVDQ0tKSyuXyBKIwHo/tPWE9kp/CWSQfRUkIpR1uzs2l37fb7VdGH14roQ+fHMGXrjw4EvQcLEVs/DutTmB78AXxjrnARESxWMwSXG6RHLBXrVZTrVbT4eGheX9EB3gCJPCAfMLhsOHNhNp+/+UcF8JbsOCjoyOLKur1uqanpzU3N3djr4eDInrCgFBYBrvErTcA71xYWDCaJt4lCezryoY9hg5MgWUikbAu0BhZSVYjVCqVdHp6amdFToE/RFuuccYRcJ9HkhlzvMjvo86FppfZbFYffPCBMYqg0+JZoaCkK8OMkoSmjGGHyADE5io1kp8sPHnqTqanp01ZRaNRUzI+n8/IJtFo1LxO+oe5nQ+4uHiZ1H/4fD6LDF6+fGlePsy9my4UBnNCiDbH47H1h+POUFXuRn8w6YCe+G9YS0TYtF/i36jT4e5SgF2tVm16ratTRqORJZaRv2QyaTReaMpAQy6ch+GBJYZsonTdXns32T83z8jZ9no9izqI+NFhHs9l01miDPr2Qc5gwibREHKNnACXcZ9wtoEaSbIXi0Wdn5+boabtDmO2cZLcWiWX0o0Oh77MOZD/xaGlKPZV1mvNcyFEOj09tfoHSb/XEZdqZVqRw8Ah5CNZSdFiv9+3Ea7gj1hoF/YAmiiXyzo5OVGxWNSjR490eHho7ak9Ho9yuZx1CYBGjDf54x//WA8ePNDW1pbRW9955x0Fg0Eb1kR/KBLT3W5XS0tLevvtt28cvbi5KbwfFBKezcnJiUGHJEkZ3vTtt99qc3PTFAAHz3u6TCQStKurq0qlUnrw4IGy2axWV1ct/4Bnz2VttVoWEZbLZTtbjDQkgXw+b8O6gAtdxky73VY6ndbs7KwkqVwuW9TG+91k7e3tyev1an19XT/84Q+1s7OjX/7yl+bx+nw+K7wjOolGo1pfX1c2m1UkEjH2DQ5LPB63ztpAW19//bVevnxpUKAbGWazWeXzecViMc3NzSkcvhoFTCREFTOfn06n1Ww2beAS3wOIqNFoaGdnxyjIkC9mZ2fV7/f1+eef6/Dw0J7nTRayQa0OMA4eLp0jgIiJYoGmzs/PrWsBcPPs7KzRznHW6GyOcUGGKpWKGZNisajDw0OdnZ3p4ODAWtijvFCOFHzm83nduXNHoVDIKu+B011UgaJnShhQnt/VTukm+4f8ZLNZg9SRb7qTENViIN02MMlkUsPhZWcHtwsE8uOecTQa1dTUlKEE4XBYJycn1qR2dnbWZB0ojC4is7OzVtcExMgAv5mZGcViMYN73dwO+h3YzePx2B2bn5/X/Pz8K+/fK2tKqIuwIMDkpMmiPpcKzKaTSAVScRO9GA+EJJPJWCtulxaJ8iqXyxYuwyaB0kdIybPBQkHwwJax2LzeTcZJMigPL4+iuDepc+HwXEovxsGlNBLdEPK6n+fWEXyXknaTyCyMOErLjZzc3AzEBr6v6yFD73S9Q/4Af7j/zvdxZePve+ZXXSRxXXbMd+1xIpGYSFCy324xIjDK9SiSC8glRCG5lfzQNxlih2NFJIRXCTZPRIBiw8FyabF4km43XPq58frvw7gQrboUZBe6ZK8wEm7+zi0NkDRxh/F6MdqJRMKKUzFMJLeheddqtd9T9i5dm0Xeyh3i50YrLm0emj5OBGdMr0MS4DeNXLg/Xq/Xoid3T1gukxLUhZowF+Zjf/kjXY3kQNaBepEPZA+oHNga1CAajdoZuiUB/DcoEc46Ti93hbvv6kwXBnMp/f/YemVN+W/+zb/RcDjU119/bR2QGXnKwnrSw4uaFfIXe3t7Jqh4RYSK8/Pzisfj2tjYUKFQMG+ZcJqL+uTJEwsrCQ2LxaL6/b6Oj48nCoLeffddvfXWWyoWi/rqq69UKpX02Wef6fnz51aJ6vV6jeZ6fn4uv9+v2dlZffDBBxqNRvrtb3+r/f195fP5iTqb1120f6GokLyF13vZv6xSqZjyY2gUmDY4LvDZdcjKvZQo4dFopHK5bFDg/fv3zYPCI8SjHAwGqlQq2trasgpsl6Mfj8etMvf8/FzlctmUqd/vN3plqVQy7BZYkYgHSOKmBoaeTPDtwdvxwAOBgGHP0lUkNx6PVavVFAhcjiNIJBKanZ21DhGDweW4ZqKHzc1N7e/vK5PJaHFxUVNTU/rkk09UKBTMq0dxuExEeklJV9j81taWfvOb3ygcDmtlZUXj8Vi7u7tGbeaS371712AHqv0fPXqkfr+vQCCgpaUlg5HeJOfy1ltvaTi8bI/ETCaS9n6/384b7B7jk8vlrLC2VCr9HsuTSGx9fV3xeFwLCwuamppSsVjU9va2kR1ALb788kv5fD5NT09ramrKmKXATMil3+/X22+/rXv37qnZbGp/f1/SZTFoOp3W6emp9vb2DMpxG+TOzs7q448/tkj97OxMMzMzJqs3WX/0R39k5QQPHz400hGGABnH6GCQGS5GrlO67C5BLhDDAZ0fklI+n9fq6qo5Kr1eT7lczjqF4BReXFxYv7oHDx6oUqnoL/7iL3RwcGB0aDogcAYuozIajWphYUGJRMKcGlIDyCBsxet1a//QemVNubq6qn6/r6dPn9qgITbEpWYC9ZB0BS9k88E/CWVhesCUWVhYUKFQULVa1fHxsVlcKkyBG2DkcCGhIeMlEQ2hbDggWtJjhLDW0lXXU4bnSJfz2hmCdJ2m/DoLj4Joie+PB4GHiBdM9Th1GURPbtGaNAm3udRbFPtgMDChdhlqeDbupYYNhReIUMIO83q9hunS94xcBBx5DBt4PNHrmxIiCNExjnh4LisunU5rYWHBjHi/37daKqr2MYjkNpCDarVqMGqr1TLCCW055ufnLbJz2XwYd6JsDI90SY0/ODhQLpfT0tKS1Te4ESCFw67hdXvukTi/Tve9yYJ5xKwPSRY5kE/gjFxKO1E70aB05dHyXQKBy0mgwEKpVMogZXdmCxFiOp3WxsaG1cFBg3UjF6/3ssp/aWlJp6enevnypcHFyWTSyBjUB0HLH4/HBo37/X579mg0+kajtqenpzUYDLS9va1yuaxYLKZ8Pj9BfSaa4l6Sx4C0geMBtC1dkZ9YpAbocyddjkknl5pMJk3XEtF2u10Fg0HNzMxIupQhuqm46AjpDHo0EpHzeTisksxBdFGn13FuXvm2u15soVDQ7OysPvzwQ/l8Pu3u7qperxsm51IDaZnRaDQMpyTRxqa7cwW2tras3QYFgrRnIQGI548SwaCAt8NGy2Qy1rvrgw8+MDosvYb4+fn5uXmlRA9ffPGFVarOzMyo3W7riy++kM/n07/+1//6lTfYXXinbkIXqA7BwyNmX6A64kGgAEjQSVeVwHwGr8Gg12o1nZ6eTlwqnAG6PuMV4nERFUiyuS/sOTPiCcUJo3EypCv4j7/dsPwmiyQj+3FycmLFabwvEUwoFFImk5ko/GSPOp2O/S5RNt5iIBDQe++9p42NDaNaR6NRw8UxZi4kxHm680Lw7geDgdFGz87OLCqen583thjQK3sP2eKjjz6yTtw0O+VO3XTR54v6kpmZGW1sbMjj8Wh/f1/ValUrKytaXV2dgFTcYsmVlRV1u13bQzpbeDwea3OytbWl0Whkk1LJoQSDQasrIsmPHFO412q1bEJqOp02XRAOh/XWW2+p17uc/XR+fq7T01NrZUNxoVtr9cUXX5hhvH//vkajkfWZu8lijHW329X09LTtjXTVIgVDAUPOZU1SHhEMBq1jgdfrNXIFss3dxUjB0pVkpA/2ajgcGltSkra2tix/BT2ZKAlUAzmCLERumeQ/+oi0AqUa5I1e9Q6/VkJ/OBxa1LC6uqoPP/zQLgc8auAD2jvjUQQCAU1NTdkFx5Nkc7e2tjQej81jR0gSiYQ+/fRTaxtRqVTMoEhXnU/dPklLS0s2IZBGkDCMPvvsM9XrdaVSKc3MzKjRaNjFcpvh0WxxcXHRjMtXX311Y8EkmiD6GAwGdsm5ZMA9Ho9HtVrNPEpJlux06zQ4F0mm9NyiQYwL/Hf34kmXDgPD1ogSiQKCwaBFWZ1OR8fHx+bhUIsAtEbim2jHza9w4dxnvcnCuGBQKKZFobNP/X7fpqW6zRcxLhcXFzo5OVG1WjUG13g8tg4RS0tLE1g9ye7z83PzJFG8RLmcCWd6dHRkBoPeWmdnZwoGg/roo4+0uLiog4MDbW5umgMBvEerjbW1NaOglstlw9rfJG81MzNjMMpoNNL8/Lw2NjbsO7ZaLc3Pz2t1dVWNRkPPnj0zkgSwLKNySZwjZ5KsZc7h4aFBf7Suefvtt60Q2G1x4/P5LPrg3uEgzs/PWxlDOBzWgwcP1O129fOf/1ybm5tqNpuqVqtGInCh2lqtpt/97ncKhUL62c9+pvX1de3s7OjZs2c3Ztx9++23Vk81PT1txB83X4pzhtF0IWsKgGOxmN566y3Nzc2pVCpZBHZ6eirpskkwjYIxLsgz94n3dR2jYrGora0t20M6HiOL5AeB3dbW1vTuu++qVCrpP/yH/6DDw0MjUKTTaS0vL0uSycbrQtuvbFzA7hAKuudCY4Q9wgcDIYFHothCoctJlG7PHSArEqvMh8lms1aARbEP+QA2CoUHjZmkpUsbdAsBXVoyCsSlNNKShS4AeBXflSx/nUWNiYt1IihU5l6HGKUr+IEEJcqcsNj1MnhGFDxwAMoQWIAZDRS27u/vq1KpqFqt2t6CuXM+eD3gyG5EwjlgVKAsujkd9v+mxpmoy6W8gvkDYSWTSetfx9wfHB+33QtQGSwY9lOSEQZQoOTGgFWut9mgHYZLdQWSgTUGHRfICaWL8iESdM/bZf3RVoUivpuuk5MTY31hLKjortfr1gSSBDhe7vXIGaYS6ABQMXca448cQMC4Ljt05k6n01pcXFSz2VS5XFY8HjdnEegdIpFbxR8Ohw2+lq6cF6BOotLz83NjR11PUL/OInpAd/CZOMXsAyQNdBrPBUTHSAYcJJxM5Jj6NxwPyEqkFdAjwN4MFEMXUGsVjUYNYuWuUPgLzLy9va1ms6lwOGxF63QOQJe6kO/rrFc2LlRFk9B1mWJbW1vWpt7vv+zy+/HHHxvtzsUF/X6/5ufnFYvFtLW1pefPn5vXRlK+UqlofX1dS0tLxscGzjg9PTXWDV6Tm9dx8W4ElzoDKvo5QDwuksSu8IJxMl5gZmbGipdussDqXWYaShmqLB4iRWuuYXGZXnjsGFtyVtSrUN09MzNjM89brZay2awWFxd1enqqb7/9VmdnZ/q7v/s7PXnyxBQvxp88CmE++4qR4eJIV3Nc3GhzfX1dXq/X6I54wDe92FxcLhjRkt9/2Sm5UCgYXFWpVPT555+r2Wwa85COBiS0MXicBR4iRZF0pA2FQvrkk0+sHTr1E+fn52q1Wnry5ImOj4+1sbGhjz76SPF43CizT58+1dbWlkWlsBtrtZrBOpFIRA8ePFAikbDEL8y98fiyRTtNK1Op1BtFLr/+9a+NigwrEIW5vb1tVPhvv/1WyWRSd+7cUSqVMnYlUUEkEtEPfvAD6zRMs0kMOcSeubk561bMHaPZIpXzoVBIGxsb+vDDD3V8fKytrS1Jl94yfQeXlpasuzDEhouLCy0tLenOnTu6uLjQo0ePJprBMrTL4/Hom2++sRkob5L3YyR0vV63mhGM8OrqqmZmZuxzqedz4eB4PG6kHIow6VISi8W0trZmzLjBYGCFudIVjE3eL5lMamVlRZL0+eef6+XLl5qfn9edO3esE4FbwkFuKxwO6969e5qentZnn32mP//zP1cwGNTbb7+t9fV1Iw5w710I9LuYcf/Qeq3eYlxqoBz+DU8MGAd8jwIfEtAodS4L8AOWXppMNruKDE+d98MjdBPLYO4u2YDcgVtZ7j4LuQ43knKTa9e97psqR0Jjl0LJZyH0fA83UepSRrk47P11GqmbE3A/i+Um/t3eZBAh3CQkz8MzYdiu//t1YePZ2XugNWTipvvnwmw8Bwt5Yq/8fr9VE9NfDgOCR3i9s6sbhV2nzrvMH74/7wmUg8EfDq/arhP9uY4EXjXyBhnArTZ38x1E3y5ketNF+xiiOPcZ3E7F0MuJrt394fvFYjGbRArM5sob39mdb+LKEp/Jd4Q56vbQ465LMjiPPB9nQtTn0pJdiOp6TdmbRH7MSoH5dl2vEVF/V7eM4fBq9LFbHAr6wL/jPEEuclEKyBjkUHK5nDwejzmlVNaT+KdIGNoyiA0IBmQhInLgbheVACr/7xq5oPC5fDMzM/r444/V7/dVqVRUq9U0NTWl6enpidYbL1680P7+vrLZrJaWluT1erW9vS1JOjs7s9CYVghY6/F4bMWWXNxisWjKEAyeS49XlEgk9M4772hmZsbyN7Q/QGjdZHqz2VS73bape3Rb5eBQhoFA4I3GzAIHQL90K+4pLqMzKt7heHw5MOjs7My8DjwnEmzw/8vlshl6cGy6F1D01Wg09PjxY2PyRaNR836YcIfhlmReKcl6amZoC05vM4wVfyjqchPUXMKbUmkxTNcp2P1+X6VSSZImJozeu3dP3W7Xij6ByFCWKAOiYFqWAFdls1n99Kc/lXQJeeFdkuQEWoD26vV6bYJqp9NRJBLR48eP9fjxY6OV4szQBQEjRp2Wz+ez86To+PDw0HKEUJdvulB65CeQxeFwaBE+jRTJW9A7rN1uKx6PG3TCe4TDYc3MzBit1m14SCsbFD8RcCQSUa/Xs8mYTEdF+XI+RAYnJycGw0PHpXgVdh8ywkqlUrpz545BUYFAwCLGm8ogHRdqtZpevnxp/fg8Ho9NLsVoZzIZffDBB4rFYnr+/LkODw/NKEuyib0uk25vb8/yd+RS2FsGvPH+4XBYx8fHdi9AVba3t5VKpVQoFBSLxVQoFOwOk8uGGNXv93Xv3j2Tz1gspr29PW1ubk7kTWGWvW4B6mu1f0HR8qDLy8saDK5auNAew22pcXp6qhcvXqjf7xszgUZqUETJO3g8HrOio9HIlCDKFIycFi0oPK/3cuDX7OysAoGA9S9ycwAIOP8NTEe3YDxIchuMHuWg8YRvKph4u4w6DYfDFt4DHbktbyhabbVaqtVqv9eKg31PJpPGggMqxGOGNcIFK5VKdgEgF9AKZzweG/UQirY7c4J8i+tJu23sXZiJnJxLQnjT5XpT1/NSzWbTFAu95qgrYtok0Jx0hZnj2blUUaLwdDqtmZkZDQYD7e/vG/0e2Sa/B1unVCppf3/fIrZwOKzDw0MdHh4qlUoZrRyZBSLmrMj1kcCmOWO1WjWI1s1p3nRxx8iX8B2AlukcQG4KTJ9JhZwl0Q8NK6FV93o9Y4Xy/3i8RC3kdGiIiHMwMzOj5eVle40LI7pwE/kElxwk/b5xoYcaETaw+03vcDAYtPxvqVRSLpcz52x3d9fGZUDdX1xcVCaT0dnZmRkCtzN8rVabKOYul8vy+/0GQ6Lwe72eDUV069lKpZJCoZBWV1eVy+VsNDKvwdnO5XKms2HMQXWfnZ2d6GJdq9UmBiwCp7n7+KrrlY0LVFQS7YVCYeJwEYKDgwOrkkYhTk1NWSdkqqjxFjEStH9ZWVmxojIiB15/fHxsYRteMFBEJpPRxsaG0UeJsDhQvO3j42NLYhJ6E16jdIiSUMoo9TdpvMhiZDPKBfYFxvTo6EiBQMAKPCmcQ+G48BW0TBKG1BqQGMRAfPvttyqVShMhezAYNPz98PDQCl/ZE/4Q4aEUoUnSMJLIFfafdAXTEYlKVy3xb7pcwgdMrXQ6LekqD0N3aZ7BrR9oNBoqFouWvwK6cokQXOxKpWJt+HGGgC54Py4ZnjpODedYqVRMeTYaDe3u7loxJdFfIpGw3AOJWOSViKJSqVgC++zs7Mb7J8kcODc3SVIYRIDO4JLMIAJ/cXeZKkoBJMlk4KL5+XkVCgUzstTyECU2m01Fo1FNT0+bHoB5hiLDcaEQGxQCiBrZOjo6ktfrtZwjhmg4HGp/f990BaxUt77kddfDhw/tLhIZuGkC/ubZdnZ2VC6XJ2rD3HoRatuIPugMAbzYarWMRYvj6KYdKNHo9/s20Rd4FX1RqVR0cnJi7M/hcGidkjHA7BVGE4IQRgl48XWh2Vc2LltbW/L7/frBD35gvbg6nY4lphD+YrGoqakpJRIJxeNxSzbPzc1pcXFxov1CuVw2Kt7vfvc7DQYD/Q//w/+gTz/91CIe8hIoALwDYCPqXubm5vThhx8qnU5bUZrbCJBGi48fP7Z24GwUhpCmjFCofT6fVlZWJjoV31QwOZDDw0Ntb2/bsB+qniFLYFQ4UH4P9hpRAoaj1WpN0I/n5+e1sLBggtVsNvWLX/xCgUBA6+vrWl9ft55YHo9HpVJJm5ub1hiQEBx2IMaFc6BuIJFIWKHcwcGB1XbwzFwgLtab5gxcyjnGJZ/P20UcDi8HRp2enhpjCwPKeXJRaehJN25gUApBUU5uMakkg9fA8TmXWq2mTCajlZUVNZtNff755xYlEnHv7+8bWYJzp2vAX//1X6tYLNoI27m5OT148ECSDAomSX7TnJUkM8bg8R7PVcNY6iFQmDC9AoGAQYs4EOFwWHNzc8rlcjo9PTX2HYb9vffe08rKijH7uDvkGPC46VG3s7NjtSzUbCSTSXNgGL5FrmJ7e1ulUkm1Wk2PHz/W1NSU/tW/+leamZnRixcvtLOzo1qtpq2tLSML8bs3vb+S9Dd/8zeWvKdLN1EG3w9j6/F49PDhQ0WjUR0fH6tcLls9kJtz9Xg8BpcSodJdvFwua2trS17vZWeKcDhsaAJJ+3A4rGKxqFKpZBRpSFAUou/s7Fgz4dFopL29PRWLRX300Uf68MMPVSwW9Xd/93fa3d2dmMALoQq955KgXmW9snEhCiAsBC6hIBHMlgmLFxcXhqEGg0Hz1tweVUQ2wBOj0cg8HbwXDkCS/b4LwyB00D3dVgpu8pXX05DNpRbjjSYSCWWzWePc871J1F1PkL/OIkGL8OFdXC86dCEfno1w1E3gXy/mQ+kRzQWDQSv0cn8Hr4fPcHMYfDYXwC3a5FxcCikMLPaf93MTkq6BehPFSPU1RAaXwca/ccm5vJIMynS7M7t0Tl4PHZTviYfIs0OFrVQqEzVE1xPx7AGGlgQ1jg7RoluMRmQOXAZNWrqCn3Co3mS5+QzIBbQEIUoncieRi2wAL3PW0qVMu+QSonD37nFf2CdGLAP5oYhdqjKGjT1DrslNQMxhJhMdg3me65R/6YrK/qbRM2eEs4NOcGFrF751nTKYW+6ddZ0jl4hwnTyCTLnwMzLDv7GPEFrQG+4oc84aXUBXChwpdCzoD88DjP46HUpe2bjcuXNHkqybKco8EAhoeXlZ9+7d09OnT/Xw4UMrJKN4cX193RQ3wkuYTXHlxx9/LOnyokHho5CILw4cR0INajFcelgQiUTCSAUkTM/OzjQYDLS2tqa1tTWdnZ1pf3/flKnH49E777yjd955R4eHh/r88881GAxsGJTL/LnJAld22SwunZv6CZeVhrIidEYQrzPrpKumlnQbeOutt/Szn/3MoAJ6tEEb9fv9E80T8SglmZGmjQde5nA41N7eng4PDy16kWQzII6Pj61jNkWbvB/Pf9NFBwEWtM7RaKSTk5OJ+eDAjdLVnBL20HVCMJRg1YFAQG+//bYKhcLEDHMu+O7urvb29rSysqJ/8S/+hU3/cynQQL3tdtsGYyWTSes7trm5qV/+8pfK5/Oam5tTMBjUD3/4Q6PMPnv2zPKBkmzgHfj+6yRUry9qQlBkwErj8VjT09NaWlpSrVZTuVw25YXi83g8ymQy1sbGbZlfKpWM5MBZYxwlGS0essX6+rpevHihP/uzP1O5XFYikVChULB8YzKZ1L1795RKpVQul1WpVHR+fq4nT55oOBxqdXVV8/PzCgYvZ0qRFyKpTodnjDF1QtC/b3qHkQO6vFNoiCKmzyHUX2QNHTIej/Xy5Ut7P2pjyBW5hhAjTQ1fpVKxmjvyVQcHBxMEAKITv99v9VfxeFx/8Ad/YAab3x0MBioWi/qLv/gLcw4ymYymp6etc0mj0ZDX67VIHwP6vcNi4K8MWAJGoulZPp+3ufawbngNoRqek5vYROm4XjK5DaIUKJPkTmgV0el0LL+AIUGxuO/nUvlIYnY6HUvYuxaeRGEikbAEJu/H89xkoSw4GCACIhAIEC71k5/xh5+hpN1D5r/d5CbKi8Koo6MjVatV86DwhNwzgz7q9/vNIQCuGAwGevnypRWyksRFoMvlsnk7eE6815smoknGc1bAq0Bl8PDdAktJFm1EIhGlUimDEHFy8PrIm+CBo8RJpIOJt9ttay3j9tviGdymokTs2WxWy8vLGo1Gevr0qUqlkgKBgM3SyefzikQiBuNg7KCKspe0ob/pAkp2C0dRIOHw5dRDSDbIJ/Ard5LiWPr8AQvBcCSvQOTGmQFTBwKXXZNpw+QOmXMjo2QyqUwmY3lGatUGg4HBNbCp2u229vf3J7p6u1Rk971dBujrLu4dZCSgRSJYHDlkFFnj+1NcylmAikCSYL9wPt0SACA4ojK6TeBQ8Vp0LPsAw4/zoWNCMBg0shD7AaEjn8+rVqvZdErpqr7tdRzEVzYueHFABOl0Wuvr68ZIYI3Hl9WqP/jBD6ybKtP74JrjoZDUbLVaOjw8NE8a6AaozFXIHM7CwoIpRpez71IhXXyVNhxPnjzRycnJBAuLuQhUCPf7fb399tvqdDra3d3Vy5cvjcl100W1K8aKiEy6ah6IcXSpsRwqe4XCAR7g0rj1PkQY//f//X+bUg0Gg3ZRq9WqXrx4YYVpLvMKimokEtH9+/e1trZmCelOp2OOBElr6MmRSMSEn6QtEBHP+iaRC5eG/F6j0TAvFEV+584dvf3222o2m3r69KkajYbl/lCg4/HYWDfQbnEsSPp+++23JkcottHocuYLkwH/43/8j4aV8550kYUEMjU1pVgspna7rc8//9xwa4oTKe6Eag+U2Wq1dHR0NJEjcIfh3XQRZbmD+f74j//492qW2u22UqmUfvKTn1jbEUgv7PXCwoK8Xq/R1104DWM9PT2ttbW1iXo0twiyUChY3us6fEWFPTByPB7XRx99ZOyyvb09+xmePY4VjEGYcOSCU6mUPvnkkxvvYTqdnqDdox9Cocux2nQ8gIzgtqoCcqIrMrVRFDZTJE7iPhAI2Mhxt5sD70WkGIlErGu8i2QQ4eDo0B8Qooo0aeCmpqYsMoG2T4qDZ3dr7V5lvZZxkWRediqV0t27d62bqQvnxONxffzxx5qfn9fe3p7Ozs4UiUQ0HF72Jpufn7dQlTGwXEwuFN6pm4fAuPj9l1X+kiyheN24SFcFiAxfuri40Obmpj777DPzGGjBTnK1WCwqmUzq7t27uri40FdffaVvv/1Wd+/etSTlTRbYMVgyVETpyuAA6bnzZghHGTxF/gBF41JfwdFHo8vxxcwkf/fdd419JF2SIr788ktrSEcUKV16KNlsVplMRvfu3dMHH3ygly9fWp8pxvTu7OxYWwlmsqOEKfJyvStk56YLBQQ70RV0vLeNjQ396Z/+qQ4ODvTs2TM1m01NT0+bUiAXdHp6qnq9roWFhYl6DemyMebx8fFE0SMDz5LJpHK5nGq1mv7Lf/kvGg6HevDggebm5lSr1XR0dCRJNgSPSLhUKunx48caDod66623DNKB3sndQmHwjN1u1/BykrZvsnAQmQi5sbGhP/qjP5Lf77fzlC6Ny9zcnP7kT/5ECwsL1jyT++j1ejU3N2dsN2rOuG9ELbOzs1pbWzOiBPJAw1CYnURK0lVkinKEiUZNVqfT0f/5f/6fevjwoTljrgMAm80lqOzt7eng4ED5fF7vv//+je8wuVrmSXW7Xe3v7ysSiWh6etoo564s4eSOx2Pl83nr0k7rl1gsppWVFVWrVYPUiIhPT0+tVo18FjoW0sr1+S3oYaAuIvNms6nd3d2JhqnA3bFYTBsbG4rFYsa28/muBrURmcIofNV7/Mq7jNfDxe52uxay0/TR7UlD6CZddY4Fv7+4uJB01Y8pGo3apZqamrKxtOCJ0PwkTUQrPp/PJqOtra3ZhSZEJTnq9XqtbsDr9drzsYkcBMq62+3anAg8+XA4bBDCTRbPz8VzE6AYF2AKXsPFIZHIBSJpyB65ZACMEUlGaJyMDmDYGvvvRk0ujOH1eo0aXavVTLE0m02DxWgxwYRCsG63+v1NYBx3UWTL8wGfuN+h379sxFkqlSbOmcvERYNSCwTLnhL1ccZcVCqz2VewcH4PY++eJ2cD7s7rgdiAoehPRp7y7OzMOgvwrO75vskqFouSLs8EiISaBoo1R6ORCoWCksmkRaYUb6KswOORw1QqJemKVAKsyLx6lCIECiInngWvmejejURKpZL1zqKcgK7XEB9w2lxoLhAImGJk9hTMzJvKJMgBkSb5FM4XeApaOTkV2uJQWzUej83ZJlnu9/uN5coe8HPpqjYL4wIcSzQEhA0s6dbsuR0pPB6PMRhp1joajXR0dCS/329QJwiOi7AAlb/qemXjAg0Sj7Fer2t/f18ez2W7bqw0iTl41hScMWZ3PL4s1sM7YpTx+++/bxfZLbojLEPhsVFgqYwtpsU1+KfH47Futlx+aIlzc3M6Ojqyzs206qfA7PT0VA8fPrQio7m5ORtVe1PvG+8ULwsMmgMLBoM2AxtmEGw8wl6UC20x4KIDo0mXSpjQ2+PxWA+ifD6vs7MzPXv2zIwX9GBpMg8GTLK/v6/T01NL5kajUT18+FCHh4daX1/Xhx9+qHq9rl/84hdGL3ULPcm5kC96E1js7t27Go8vuza4WHAgcNlEMRaLqVgs6s///M/t3/P5vEqlknXrxQDMzMxMDG9zyRXg8zAe3ZzI1NSUFZUtLS2ZsgTOoP8b5wnRRJIVHPPeqVRK7777rorFon7zm99od3dX+/v7Ojk5UTab1cbGhuH0PDsK+abryZMnRqWdm5tTo9HQX/3VXxkVudvtanFxUR9//LECgYCePXum7e1tKy0gcnT7T0F/x+ASgeMVQ0VGSTWbTZVKJdMN0WhU9+/ft0pyRhhTJQ6klUwmreAa1GRra0vb29uKxWK6c+eOGTPYf9QPzczMaHZ2Vu12W998882N7/Di4qIGg6ueX7lcTp988onJDDJOTRTJ/t3dXeujBvza6XQsZ40TsbS0pF6vZ6gD+goDzl5Cdkqn00okElpZWTHjA5KBoXJJNjiQUJR9Pp/m5ubUbrf161//2ogvkqzMARQJinQmk3nle/zKxgWqKR4gjeqkK/wQ/JSwFpohX5ikNbg8EBsJeUnmebt0UUlm3d26FTwGQmG8eJd9QZRFQ0jpCmt0ixPhcxOKQwAgAkAR3ZQnj0DzDBy0SymGYng9ge96fq4ihKrsstjYI9cbJ2/jGg6X5kglNJeX88LLxMu+XgCGR40Hyd5cv7xu7ctNF17b9QSoWwwpyZQWdTwYAJSb+wzIMvLI5xDBYGyByKSryNmNzpFlmD+uPPO+eKq8D2cO3Mvzud0TcHiA894EVpSuqK/AKC4d2HXAkAscOYgQ0tUceRifLpEGqA8Ksfv81xEIabLTNfrBjXCIlIlOaGMCZO5SpV3mJefE5xHV8F5vso/cHbdcAhjMZXay1668ublNZIr34l675AD2U5LpO34HwwJrEoKLeydcYtN1MhD/zb6Ti3HJLrzGvb+v0yXilY3LP/tn/0z9fl9ff/21nj9/rmq1qu3tbTMkkiZYDGDG+XzeWC5UGGOxKZhyWREuYwKojfG5hUJB/+Jf/IuJeox+v6/nz5+rUCiYB4H3guBXKhV9+eWXGgwGymazNlUQvPc3v/nNhFKl4FCSzTIpFotG27zJQkhQZC63HQ8BosRwODR8nIZy38Xdx2gitHyHcDhsTJzRaGSeezab1U9+8hOrHgbGDAaDNtucMbW5XE4vXrzQwcGBDZXC4FCkSefh6yOTMXAoKOo03gQie/78uaQrRg05KC45kdzs7KztN3vFfAs6AJNbc2u3OAMSmuD2Ho/HeoH1+31LdkPJhVXF5ff7/RbBAOkwxtvv9xuUfHR0ZN5pNptVPB63nE4gEDAZWVhYsKmLJycnb6QYGVW+ublpOSC3snw4vOwY/eTJE/OImd/DCFwG+KHQ6NBAbzDXOHG3qSCnAHp+ft4o8d1uV4eHhxYhAysBr/K9z8/PjWUHDMTrO52OHj16NNEg05VBEtjkE266h9DhE4mE3n33XcViMeuhhxKmHQt5TzcHic7EQHLf7969q16vZ73TmGdDqcRgMDAYbHV1VWtra8pkMlpfX7du7uRFMFQ41ZBGoHQDZ1OEmc/nDZKkHRZtbshzuiSL/f397z/ncu/ePfV6Pe3s7BhdkgI0LpV0ZWDIT+RyOUUiEdtkNpTeVAjD9Vkl7nvRrp3q5eFwaIniRqNhjR1RJhwcf7fbbWt9Tu0GGGmv19Pu7u7EPBgmtHm9Xu3s7Fhb7DeZYe5SWzESeHH0TKPqnWhqMBhYcg/F5h4sLBDpKlrA85BkP6MFfzwe18zMjEqlktViUNyKEo1EIspkMsaMq1arSqVS5hCQyH327JntGzAbZ+d6UVyO1/F4vmudnZ3J4/HYGUHzdSuv+TfkAIXJhcXDJK9Bh1iX+4+imJqaslwC++jW7QB9HR8fS5Lh/XieyB31BlxyIh3kCYZYJpOxSJOoYjAY2FA7oOibyp90WTnf7Xa1s7NjsIjr9BApEA2srq5OFDrz73xf8Hw3HytNdvLmvencS26BvNNodNnIk+Q2IyIwLrA6Jdl+uTVWwFDss8tsoz8gERk065vuIVT7mZkZq3Z3uzTj0ELppq0SUQl0ahcKp2kk8LfP5zMGY7/f18HBgfr9vhnOpaUlvffee0omk1pYWLCaFua+wOpyB9DF43ELACBcUfgei8Usf8Tvk9uC0MKq1+uqVCrfv3H53e9+ZxTDXC43gWEvLCxYawwekLkFjCK93l6FJCxNI/kSKCU8QorcUKzAccfHx0bfDAQuO56SsKzVaubV06KaIVJMKZRk7TkIY4HksNCSLHHJdLibLhREtVq13mYu5CfJFDGwiMvLdz2I67UyKDb2ndYZ1ObQ642ZIMBf7AEQEAk+PJxkMqkPP/zQPLRqtaqXL19aQRcXhBwY34PEtnRFs37TOhciEuA76i4Gg4G1mCFidaPWQqHwe/AfUKcki7aACNxWQDhNXLxsNmv0YmjzRJwommAwqFwup3A4bDNmKDJ1SRIuNRoDBfkEZez3+01BMff8Tdbm5qZB2mDnRPruGGJqhhqNhkXWOzs7puxxHjAEJKWJyiiWbLVa2tvbs7/pSDweX3b2fvny5URXj2AwaEYChwF2KHeDs+UZgDph/aE/gHpcmQDefZO8qdfrnYDYXUeYMoxUKmWyh6EdDAbK5XJaW1uTx3PZdgmokzvvGnvpMn/61ltvTUTUs7Oz5qwT7ZGrpvan3W4bEYcxBXRMCQaDKhaLNnqe9lkwbjkL6cpR5bvh1L3qemXj8vOf/1xer9eqaTudjsrlssLhsO7cuaOFhQWDKPAaB4OBJbOYNoe1Bhd0lYZ0lXPhi7pjVhm1WSwW9dVXX6nX62ltbc0YG4eHh2q32/ryyy+twyiCiFKYnp5WPp/XeDzWwcGBpMuaGRdS63Q6evr0qaQrzvzS0pLu3r1746Q0CWCiLZeTTrQFZAakIGkip3JdSeMF0xsLZhjwz9zcnLxe70SfpunpafV6V63yDw4OdH5+bqOr/X6/zs7OdH5+rvX1dX300UeqVqva2tpSo9HQN998o5OTEyNQwMGXJufK8P9ERS7r5CZrZWXFyCB0dpYu5WZvb0+np6dGZiCp7PV6tbi4aF0djo6O7KLyu67n6VLFiZBg40QiEc3NzRm9FVYf0Q6KMJFIWARK7ge4q9/vq1wua3t726Lji4sL7e3tWTEhvb1o5CrJEtPIyk3X119/bRHG9PS0KY9QKKT79+9rampK+/v72t7els/nU7VatXomoCX2iNY/wGZQknHgvN7LQXF0VH7y5ImNPKeY8ODgwBiQGB3uAtEfkZN7Vi55AAdzdnZ2YqYPvbXG47E5V0DxN11uiUOtVpuA8GFQrq+vq1AoGKWf3+t2u1pbW9MPfvAD9ft9/d3f/Z2Oj48NviKp7+Y0GVBIPZvX6zV6+8XFhXZ3dzUej7WwsKBMJmNyVi6XrSEtCX3G04fDl93Y9/b2TJ74PBwknFt3ON1wODTD+b3nXNw+VTwIH+KG8fyMi4dxgPmEdYcChwBgLYkq3GQqnjUHAbUP2INk++npqTXTJMTE8tIqnVwE1eVuAs6F08DsgbDcZOdNFodGSMyhXmdSuUlB9pdL57Kw3JoWno8cFY0iKebjb/a71+tZ1S44PoWP7j7QygSPnES6W0Q2Go2M4Xc9GnP///p3et3lYuVEwG6RGHvARZVk50pdER0ZXE8Yb9gtQnVJE16v13IOfC4G1K3pgF02HA5tFguGR7oabez24nJzDBACgDBg3aFskI03WTh+eMzu+zN8jwJmHAIgaGBEajmAbVD45Amh/XMHG42GOYcUT1IvQS6C5ZIoyIddh56AuciREV26hBdkjZwBSAjve1MZRPm7Bo/PRC5gxLkODhFDr9fT6emp7Ts/dzsiuPuBPABB4giQQoAkwlmR72Y+FaUBREfAquTMiBolTci0q/PIm7qR+ffOFvu3//bfajgc6le/+pW+/vprSTLBPDw8NDyVy8SFpyMogpfNZvXee+9peXlZxWJRv/3tb01IvV6vNjY2rH02eDhwHKy0Wq02Ufnq8/l0fHyshw8fTrCD3AKsdrttCuTs7Ey1Wk1zc3OSZN1fUdTAS3y3er0+wda4ydrZ2bHwfX5+XpVKxfJX7r5xgPRGg/qJ4OBVAGHgCZ6fnxuUcn5+rsXFRb3zzjtKJBJaXl5WLBbTs2fP9OWXX2pqakp//Md/bB4Xo5GfPHki6aoXGAnIfD6v+/fvazAY6NGjR+r1eqpUKqpWq0okEnrrrbeUTCbNY+KMMFhQb9+kw8Fnn30mr9er9fV1bWxsqNfrWSt89gTyBcbS6/XqwYMHWlxcNNgGSBBGIFX8MzMzCoVCE12+UUjr6+uanZ01Y5RKpWzuyO7urnX23t/fV6fT0a9+9Sv1ej2tr69reXlZnU5Hh4eHuri4sHPK5XJmkMk90N/r7OzMIiMiZzeHcdN1584dDYdDPXv2zCjv5IZg2cH4xOCglOr1unK5nD799FODCQeDgU5PT62wzq3jQbExh+XZs2fm/HEvgd3IJ2CsgRTpB1apVAx1CIVCRmVutVpaWFiwfAYUfxQ7UPTx8bFqtZpF9zc1LrOzs2YUQqGQWq2W7SPU3263q0ePHikajWpxcdHg6lgspoODA/3qV79SKBTSe++9ZzktqOwQPEB2YrGY5ufnDdp2G4JSE4ihZXQ15QwPHz7U3t6edYJoNpumH+fn57W4uKjDw0M9f/7cECmfz2fvw/2CDUp90X+Xrshzc3OWWHKraaWrhCcsDddrdXnxCBWJ1OFwaPNNaNlCGwW3aAihQ1jdqm+sLJELHiB0OujQeDowVrrdrjW2c2nSeKwktcD4MW43hcX4fngNbsND14N1o5nrMJjrTeMpSTKq6nA4nKh34bWQJ2DfRCIRY/AR0bkkDHB0GuWB97qePcqOiwMRgecAC+bsUDw3vdjAnKPRyJQfCoVozsW3Ly4uzGN1WYCj0cja70hX1HBgE9dpwQMGbsTTJldIro/Poy6FOohCoWDRL4nv74IG3ZwAQ7vccdxvSuNm0RXXjZYkGUFnNBoZE4t75e6p3++3JoZ0KKYgz2UsVqtVU7TtdtsIMeRCXU8d59BFKHgfdEmv1zO2VDAYtPcYDocTsuAWJRKNulGf+1k3We6IDkoXJFk0Q89CcjLkc9FlnU5HBwcHCofDeuedd6y6HtiMzt1ueQJ5QLc42mVMQv5xO6jg+FWrVSOZDIdDa+m/srKiqakpG++BrnGp6i5S4uYXXwfafmXj8md/9mfmBQCxcHFJWKJIpKvIBZplJpPRwsKCQqGQHj9+rBcvXliIDFtHuqTXMrmSOgsYW3ib/Ey66noLh126IgXkcjktLi5OMM5evnypw8NDO0g35KQjbDAYNIwZz4ok5E0veTKZlCTDsTGy4MZ42ijJarVqF8HNdUlXA574mQuLlctlM4JEYJVKRfF4XHt7e+p2u9re3tb//D//zxoOh9ra2jKogIuDF39+fm5RKRgzfeJcQ/f8+XODVDDGKBCU9MXFhYrF4o33j3GyrVZLjx8/tkvl0mjdvAQhPXvLz1x2I+QGnBmgP7zC1dVVJZNJy5XQGHEwuGzgGQxezgiCpUaR3cLCgskcLEUMbC6XMyz+6OjIcpcQVUi8zs7OmncPjHVTpcja3t6295mfn5/YQ/49nU5rZWVFvV7P2pG4DE6G6GEoyUXV63Vtb2+bA0k0zHu4TEvk1q3joj6DKJ5kNPlO2jR5PJfdqbmnsCDv37+vSCSinZ0dHRwcqNls6vT01L47EaBrVF93UUpxnXTEM2N8QGKIzFwH7P79+/Ze9XrdYC6XpEB5ATN2gLbRFZAYcIh5L5xvGHYej8fgZIyNWzoCdNjtdm3kNO8Prd/r9U503nidQt5XNi5/+Zd/KY/Ho3Q6PZE483guq8Cnp6cnaiu4TCRPGUMMz75erxu3v9frqVqtajAYWA6AXjuu0nATTxSunZ6eWgdZl3Xl8Xi0tLSk5eVlY411Oh1jQuERSDLPvNPpWP0DzQ4lmadLMddNFi1ESqWSqtWqzZWRrnIYsF1Q0NKlUYJOCLwDlZZLiWEh0cgekABsNBqKx+M2p6ZUKunhw4fqdDqanp62kBgvfX5+XtFoVJVKRaenpzo9PdXLly/l9XoNEuCzh8OhMYlIgHM+br4FOOSm+8eUx5OTE+3t7U0YEJSSu/CwMC7us9BuB0or1EyXdptKpYzoAXWYZn5EL1x6jDjOALLzy1/+Uk+ePJlQQm+//bZmZmZ0cHCg58+fG1PHpcp6vV4jXrhU3zeNXmBAMsKZ7uLS1d2C7o9zQIEsUQZ0XPJLi4uLmp6etjsLqw1Ii6Szmxtxi/I4E5fVRW2Kx+NRoVBQoVCw4XqDwcCaz0IqCQQCun//vrLZrGq1mjY3N9VqtQylWFxctEjTzRW/7gImQqYwCHw3dB2OIkXmmUzGaPSRSES9Xs8MoHvvlpeXzbGFkEDETvSDQx4KhSw/Ta88Ota78CmdunFqIQihH0CimL7KXaI3G98L5x0Y+lXWKxuXfD4v6WpoGEwvICU+nG6+WEd3Q/f39zUYDIz+RmTCgRHeEmrjsV2n5LqUXQxAIpGw/lNcVpKrbIoL20hX1ezwvV2OP8/1XUVZN1l4EFTXuqwQ4BfpitLI4afTaYtYqMXAS+H788el3GIwpctLwaVHmfGZ5HLcCnHOZzweW9NHV6AwhCSIrysKaRKG4Oeut/q6C6MJBdZVxMBIkixhTYdmF3IhvGdfuKBurQcOB14i++4qJWpRJE00TSWfQ75sMBhoamrKDBJ7x7Nfj7aq/99UT2jj7B/vhczfdNGKBo+XmgwKIfF8yQEgZ0QvrVZLp6enlnf0eDzGEKMXmHtHgV3dc0AR874k8IFk3How6aqWy60N63Q6E3KGM0O9BmSVarVqr3fhzZtGgG53BSIH5JvvjW4EBpNkc1ZarZY5t0CAfAe3K4nbOZq7xiA39CysRp/PZ5Rit60TURCozmAwsOLeer1uRbzIJmQFFgaH7+GSF7534/LgwQONx2PLeczNzen999+XJL148UInJydW/4Ci8vv9unv3rtLptE5OTqyvFQfChaF62ufzTfQCo9kb9RSwFsAzEcBg8HIY0aeffmqREQaGoWJsMOEdl8vv92t9fV25XM6gu4ODA33xxRdW2IhhwQO5yaLT7tzcnPL5vIXtbt0FsCKHFwwGtbGxoQ8//FAvX77Ur3/964mZFbCYXAOMUXEpoltbWxa1oACpgwEXJ+SlCh+PbHV11ZwFakqIhGi5ct14uMwdtwPD9ejidRZ97PBk6doA1ESOaTweW0IS2XJrR2AO0n8JhwQHJx6P2wgB9mVnZ0fNZlP5fF75fN5omSRv6dwARp7NZi2Hs7a2NgErALdilFx23d7envb29pTP5/X222+bAY/H4xOw700XDiLQFQ5iv9/X06dP1el0LCrG0YP0QcIZ4zI1NaVIJGLjG2BJSVd5LPbCva+MIQdqZc/c3ljkWXiGUqlkdxdZxOmTZIYPR/Hu3bs6ODiwdvXkwKanpzU3N3djOXQdD5wNjAzyg8OCE9hut5VIJHTnzh0dHR3p9PTUiBKuk+zWi52cnOjg4GCiNpDCczoVFAoFk7OTkxPt7u6a7NJQMxQK6dtvv9XJyYnC4bDBXMfHx9rd3TWDDPokyYx+u93W9vb2RC0Ud+p7Ny6wp8BaPR6PeUJ4i653h5eIIPPAeBduwp3lJoGlK7gK2MKl1vF6FJrrVfJcGBiiAIo8+W+UIBEN3+s6HixpwiO5ycKIEDG4+RS+DwrZXewHxhY6q1t0+g95Yq4n78JvCAyX9frZsf/sF4lG3pNL5SYg3XNxLx7f9U1gHWqcJE10HeZz3GcilHdzUkQB0lX/MJfoQHRC0Sf7gGOCQeUs3Agajx3Hx83nEe26kAmGhcgPooJ0Bem6suhGtW9CRw6FQhMJWp7JjX5do+LSWPlu3E33/79L4bBH0lW9E4qKf+N7uxG3Kzc8m0sOQhHjGBK11Ov1CS8bYo+LBEhXdOabLFfOcJggikhX40gYzodDy/1zc8zufeP7oYtcAgWLfefnMDFBHpBVNzK/rheR7Wq1anlZV3/wfSTZs/BdMfqvc4dfeZfn5+c1GAx0dHSkg4MDK/YiyVqr1YzSWa/X9c0336jdbuvp06c6PDw0WicUY7dOAP487fi73a4V/DEWNR6P6ze/+Y0+//xzSZcJOmiBgcDlYJ1f/OIXltxbXV21sbSRSMRGLKPY6ZhcrVb1n//zfzZ6HwdLR1sEfmpq6o2KKDloErej0ci8Zheq40BRgA8fPrTpjyRFEQK3Epq9xIiFQiGDKN3EOt/H9dZ7vZ4VYBGdshcIGQpxPB6bV55MJo0G7SoYn89nDUxRBMBxN4V1aAk+Nzdn8zOoHSiXyzo+PraurZKMZu71eg0rn5ubm/j86elpzczM6Pz8XL/5zW8mmGL86Xa7VghIUpYaG7/fbxAMEC+LXlEnJycKBoPWtmhzc1NnZ2eanp7W6uqq+v2+jo6O1Ov1VCgUlMvlrLvEeDy2nBC1Im9CR6ZlCfnMRqMxUQCL9ypdKjPOHJlxO0MTEaJEcQJ9Pt8E9Ef+5aOPPlI+n9fz58+1ublpz4NBcxdML0kTETYyvLGxoVwup6OjI+3s7Ojk5ER/8zd/Y3AbOTEKtIkUJBld+Sbreg0X5AegqYuLC+sjR/6JjsPPnz835hz5FwpRMRZHR0fmdDPBd2NjQ5KswSjdycfjsX77299apA4b7Pz83Op7gFZpxc+oZYqQ0+m08vm8+v2+Ucrn5+c1PT2tcrmszc1Na/GFkXY71v9j65WNSyqVMuXCpg2HQwuXYNgQehOqwnoAR8ar9Pv9xlSRrua2k9OJx+MqFApKpVLa2NhQKpXS1taWCRgeNcLXbrd1dnambDarDz/80HpoEa2gFNwWBufn50YPdNvAkGzHAI7HYzNQb+L1kAB3e7LxMz7f9dw8nst53fv7+xNeBrg1380tCsQj4mKD47LcCML1tgOBgM0jhxrJ7wFrcEExbiTveS83/8LnwMRD2dzUuNARt9/v29kHAgGbg0LrH86XBDtFgCQp3fweRBTgAZqZul2X8TrZE7xDnCW3OBd5wXumbVEmk9Hc3JxR5k9OTqx/Gx5op9PR7OysVlZWrM38YDCwEcDQ51+HCnp9QUXmOfCgkSuK8riTwKgQILiX19EC5NklxnDedEsvFApaWlqy8RxMb8TxuI5g4AS6kQE1YDMzM1pYWDCjAZzHdxuPx5qamtL6+rpBViTXiXRuspBdZD0YvBzuBsEB5iBsQJLnwJ18N4gg3FvuoAsrUiE/Ozur8XhsRhM92Wg0tL+/P8E6hXzBKA4WXcNheWLQufPcoW63a2flUvUJItzc8KusV36lCy2Ew2G1Wi09fPhQXq9XxWLRqm5JHKOc+T3omuFwWIuLi4rH43rx4oUJL0n3XC5nE+oQ9ufPn1se4Z//83+uRqOhg4MD8x5h6EB1Pjk5sRYHsL/oXYRSisViWlpaMoF1G8wBgcHEQkEdHh6+UTLQhf1cvBWvgPYUrgKkoj4ajVrbe5QXCowEJ4aRIjJ3IJHbI4jP9/l81ojS5bjjLABDugYKLwvPmnCcxfdBWfD55JJualwwFq1WS7u7u+YojEYjc0LcWiUML8qS7zYYDIweixMBfRjPDuWD/GazWcuxPH/+XLFYTOVyeWKUhAu3wEzMZDIWfQOp5XI5tVotBQIBnZ2d2V4hYxQssr8Y6EQioVwu90awGHuPY8CeuBRh5NLr9VoPwWazaREOkGQ2m1U4HLakNdCU33/ZgYJR2KVSyZyo4XCohYUF/ehHP1K73Ta9QRQuXd0TEsxE7G69zd7enlG0NzY21O12zVFk2BXP6dZxlMtlPXr06MZ3mGfEMNdqNSuOLpVKVltFJCPJ8iY8D0Wc7FcsFjMDhVPDvXPbFBGVuAt5wPGhCarX6zUasyTLLyOnTNWFHYvhAtFAHgkE6PBBa6lXhcZe27ggCI1GwyAqFCERCiEXYzNbrZaCwcs5zel0Wu+9955tKJAF8+wfPHhgHHy8gUePHqnVaulHP/qRfvazn+nw8FD/z//z/xgbZDgcWnVzp9OxkQAUEwWDQWtfAdyVTCaVzWZNybieqYsN4y22Wi0bMXCT5TLeUN40sMTjy2QyVpeDgGG04/G4VlZWJMmaAboV8BgXmFN0MoZ2zWtcdg2tve/cuaNyuayjoyOLrNyRphAuuBQk/Rhvex2L5eKgqIGv3sS48Pn1el3Pnz9XKpWyccGLi4vWVhxaOjkZl+XCdzs9PVW5XJ6IUFdXVzUYDLS/v290TozUzMyM/H6/njx5oidPnigQCBjJZGZmRul0WrlcznqFUVMwNzene/fu2aXu9/vG/BsMBjo8PJQky1vBJiqXyyqXy7anJKqhY990uVEqhvl63YeL98/MzMjj8ejFixdWYsC9QNFQn4ZM+/2XI8iXlpZULBYN4uG919bWdP/+fe3u7uo//af/ZKOziSqRJQw1tVZAcT6fT1tbW/J6vVpbW9Pbb7+tfr9vBqdYLKpSqVjRJe8FCrCzs3NjGWT0BZEWnUckWS6aKBgHhb6GEBlmZmbU7Xb1zTffqFKpWHRCaQQ6tlKpWPpgOLwchUD3ifF4bIiO3+/X1taW6vW6Ucz7/b71WXSLT8kH3blzR8lkUl9//bX+63/9rxNtZ7j76A2v12uM38XFRYsGX2W9NsbjJlDd5J6LUxN6uaGzdAXJ4OV9F0TDz90EsltT4yaZryesSB5ziUiA8t7uRQK6cbn11/92v7P7fN/Xur5v7vdw98vdP/dv9s1d3/X8f98iEv2us+Bv9xndn7uf+12f5b7mTYyK+xkuE809S3fP/qFnYrnfieVSub/rs4FXkEtyEcja9f1xf8+VVfd8rj+Du9/AVe4z3NTj/q7Fs7pRy/X1D8nEdz2PKycuBd39fZCD6+flohzf9Z7u57vnz33n/K7rBfc8XZ11k3X9vdyoD/2CPFyHonk2t0OAKyfsp5sb/a49cGXXTcZf12vXdZ67r8CN/9Ceu9/X1bHoilfar/Gb3vrbdbtu1+26Xbfr2vr+XKHbdbtu1+26Xbfr/1u3xuV23a7bdbtu1/e+bo3L7bpdt+t23a7vfd0al9t1u27X7bpd3/u6NS6363bdrtt1u773dWtcbtftul2363Z97+vWuNyu23W7btft+t7XrXG5Xbfrdt2u2/W9r1vjcrtu1+26Xbfre1+3xuV23a7bdbtu1/e+bo3L7bpdt+t23a7vfd0al9t1u27X7bpd3/u6NS6363bdrtt1u7739cot9//H//F/1Gg00ubmpvb29lQoFPTOO+/I4/Foa2tL1WpVf/iHf6if/OQnNpGv3+/rm2++0c7OjtLptBYWFjQajXRycmLzpUejkc0L8Xq9Ni40m81qYWFBvV5Pz549U61W09zcnGZnZ21Yld/v1w9/+ENtbGzo7/7u7/Rnf/ZnGgwGymazCoVCNiBnZmZGH330kSKRiM2bfv78ub766iuFw2G99dZbSqVSNgvl6OhIn3/+uQaDgebm5mycL/NN/rf/7X977Y2+c+eOTcS7uLiwuSjX53Ncb/l+vVW7dDVL/btaml9vvX19NrkkG7QlyaYg0nqfeTOMYU6lUup2u6pUKhMz5jlfSda+m+dibop0OWCJAVKMIP7mm29ee/+Qv7OzM5XLZa2trelP/uRPNB6P9dlnn+nw8FAPHjzQ+++/PzF3/eDgQMViUbFYzMb8MqQqmUzasDDmlTAOgsFrFxcXevr0qarVqr2+1Wrp4OBAPp9P//yf/3O98847+uKLL/SXf/mXNi2Q1vKBQEBTU1O6d++ejaUOhULa39/X8+fPFQ6Hde/ePSUSCWuRzvyWfr+vR48e2QhaZuT85//8n197/yTpf/qf/icbsRuNRtVoNHR6eqper2dzgWKxmGKxmM0tkaT19XXNzs6qVqvp6OjIZvl0u13Nz89rcXFR1WpV33zzjU2eDAaDmp2d1d27d9Xv9/Xs2TNVKhW9fPlSOzs7Wlpa0r/8l/9SiURCxWJR9XrdRptzT5g9405oRf7H47FmZma0vLysVqulx48fq16vKxKJKBwO2zCyfr9vg8VyuZxmZmbk9Xr17//9v3/t/fvpT38qr9erpaUlFQoFxeNxzczM2FygYDCoFy9e6MmTJwoGgyoUCqaHmLiJ3lpaWlI8HtfJyYlOTk7k8/lsyidycHx8rKdPn8rj8WhmZkbRaNTei0Ffw+FQ6XRa0WhUhUJBd+/eVTgctjlFP//5z/WrX/3KJlt6PB6dn5/bSG/2mO/BYLi5uTn9wR/8gbxer548eaJisaher2fza/6v/+v/+kf365WNSzKZ1Gg0Uj6f13A4VC6XM2WRz+cVDAZVKpX013/914rFYlpeXlYgELALOxqNbGNzuZymp6d1dHSkg4MDSZdjbBkbGw6H1e/3dXx8bJP6xuOxyuWy2u22YrGY5ubmFAgE9Pz5c/vy6XR6YmBPPB63QWHPnj2T1+tVrVazIWSxWEw+n0+lUkmNRkPr6+vKZDI2KvTi4kKVSkX1en1iY2+y3KFKGFXpalaMdDVngWmAkuyiujMdUOIIB4OUGMuL0ndHEDMLJxQKTQz/4ufuREyeq9/vq91u2zC40Wg0MVOb2SburJPrY5WZ5MmEu5uuYDBo+9JqtWwwVDQa1fvvv68PPvhAp6en+tu//VuFw2GTj0ajYaOJa7WaGVHkdXt7e2IOydTUlOLxuCnGRqOhvb09nZ+fq1arqdFo2AhYj8ejly9fqt1u6/Dw0JwZlIC7v0wGfPbsmY1dxsA/efJEHo9Hy8vLmpubkyRVKhU7x0gkYtMB32RYmDsps1arqdvtqt1uy+PxmCJkLxjlLF3OU0IxnpycTIx4ZhhVLBbT9PS0GSRJisViSqfTdt+q1apmZ2e1trZmUyxHo5EymYwKhYK2t7f153/+50okEvrpT3+qmZkZnZ+fq1Kp2D6Ox2Mb4Fer1bS/v69Op2PnkEqlbJw6z9bpdOz+MuDuJiuVStmYca/Xq06no/39fUUiEaXTaWUyGRusxfh3HK1+v29jn8fjsUql0sQE03a7rf39fTOa6XRa2WxWn3zyiaSr2TqNRsPkv1QqaTAYKBQKKRwOq1wu6/Hjxyb/POfCwoINuPP5fFpcXLThdEzMZJQ0Q98ikYimpqbsDoXDYZuX9cry9qovjEajGo/HSqfTGg6HmpqaUjKZlCSl02n5fD4Vi0Vtbm4qm80qkUiYQcK4NJtNhcNhTU9PKx6Pq1KpmIfCKFpGIA+HQ5XLZTscjNP5+bkKhYLefvttBYNBff7553r58qUikYiSyaRNbXM9yE6no93dXQ2HQxWLRbVaLSUSCZt1Xa1W5fV6tbKyong8rng8bgYOr4eBZTcdf+PO8L6ugFmucUGBhUIhRaNRm2XNYCSmSbJvfFd3WNF144IRikaj5tm0Wi0zSNe/H/PJ3fdz35Nn4RncwVm8xp1wxx7cZAWDQTsDd6S21+vVBx98oJmZGf3FX/yFfve735kHmEgkbKpet9tVs9mU3+/X7OysotGoqtWqNjc3bf8YYsW01bW1NdVqNZs93mq1LMoLh8PyeDw6PDxUqVRSt9u1QVDhcNiiQPYJOX/27JlOTk60vLys+/fvm2LsdDpKpVJaWVlRt9s1o+jxeOxif9dgp9dZRL71et2eh/HfU1NTNk+91WqZMnYdg1arpXK5bKOfw+GwTTlEwWIIB4OBIpGIEomEJNl3Wlxc1IMHD3RxcaFisahut6vZ2VnNzMzo8ePH+vnPf658Pq9/9s/+mebm5tRsNnVxcTExRI0xwyjCbrerk5MTdbtdZbNZZTIZpVIpLS4uSpIpxF6vZ8r0JiuRSNjYaZ/Pp06no3q9rmg0qnfffdciQow08lqr1dRsNs1RHgwGajQa6vf7mpub0/z8vC4uLrSzs2N6K5VKmcHizDiTi4sLtdttVSoVDYdD5fN5mwRcLBbNuOE84/zHYjGLpKPRqCqVik5PT+2ec7fa7bZCoZBSqZRCoZD9fjgcVjQa/f7HHJdKJTMQvV5P7XbblDIXIJ1Oy+/3Kx6Pq9/vq9Vq2UxrRvn2+30bM9tqtRSLxSTJLiYHw+xpvGM2ttPpGOzm9/vN4xoOh+YdSJehMxskXSn1aDRqkFS9XpfH41EkErFRwIwX5rlQvMBmN51EeX1i3fXRwFwcFDyKACMiXXkvbnTB77kGgN8nouDf+N6M7/V4PLq4uPi9SYo8Kwbtu6beuXAdl/f6ZE13IiGRzU1XqVSSJBv3nMvl7Dt0Oh01Gg27SMwiZ5Q0ETMQHSOtB4OBGVlkIJFIKBwOq9vtam9vz5QCl9Pn85kyBTrz+/026901BsgO0eJ4PNb09LRdVEYyJxIJJRIJ87hdh+zi4kKNRkPBYFBra2tvNAkVB7HRaGgwGCgcDts+jsdjU+TMgs/lcna2/Fsmk9F4PFYymVQoFFKv19PZ2ZndJ74vioyoN5FIaGpqyua748x4PB41m02DEO/cuaNsNqtAIKBut2vwL3DteDy216ZSKdMp6XTaomrk/uzszGQ0Ho+bLN50omc8HpfH4zEvPxAI2D60Wi1zXF0kANkKBoNqNptqtVoW+fFcU1NTBosRNQDtEeHkcjklEgnbk2QyqXA4rMFgoGAwaM5Cv9+X3++3Udbn5+c2Mhvn6fz8XKFQ6PemZoJuxONx04fj8dgcDkaGv+p6ZePy7NmzCa+VaAMsL5VKaWpqykYUcyn4cvF43ISRUDYajWpqasreA2+Audtzc3MaDoc6OTlRu902zJnXBQIB8xgODg709OlT80y4tPPz85Jk8FE2m1UsFtMXX3yhv/7rv5bf79f6+rqi0aiazab29vbU7/ftdeRoFhcXbR76TRYQA4fpjld2DU+32zW8np8xm5z55byWi4tHRBSB8UCh4b0DD4C7ftcoWPbOhUZ4L3c0rzvzm+/kwn0s16l4E6/75cuX8vl82tjY0Pvvv2+QgnQZefb7fQUCAW1sbNh36nQ6Oj4+1tHRkWZnZ/XgwQNJ0sHBgZrNpiKRiAqFggKBgF2oVCplsvDrX//avGNkaW5uTsFgUMlkcmJEdLlc1vHx8cR44mq1qnq9rnA4bO9PbmVnZ0dPnjxRJBLRgwcPlE6nNT09bREo+4V3+eDBA3388cc3lj9JymQyGg6HOj8/V6/XUy6X03vvvSev16vt7W2dnp6q2+2q0+kok8no3XffVSQS0fb2to6Ojiy6d0eKF4tF7e7uqt/vmwFaXl62yAaPeGZmRpFIRIPBQEdHR/ZMXq9XZ2dnqtVqikaj+tM//VODs5rNpo2TRo4laWpqSrFYTLlcTvPz8/YzZscfHx+rXq/r2bNn8ng8Wl9f1/T09N+LGLzqmpmZmfj/UCikSCRiCrtSqaharU7Apu7zHh0d6fDw0KITch1ra2s6Pz/XycmJOp2O0um0ksmknj17pl/84heKxWL6N//m32hmZkbxeFz5fN6MZq/X05dffqnd3d0JNCEajSqdTuvZs2d68eKFRe/uvs/OzmplZcVkyuPxWN6ZO+DxeFQul1Uul81ovep6ZePSbrclaWLOuDsX+vocdpQe3iuv4ct7PB5TmHh2Xq/XvEoXq+d1WGo8U7wasG4+i4vMe143iq43zoZhqWu1mr2WDXdfd9PL/Q8p1utK3lX2bpTzXdEP7+3CBv/QM1z3PNxkKZfYhXQkWUQJjoyhdL/T9bnlyIMrE2+yMKQ8C58/GAzUbrc1HA7Vbrf/3vnfbjSFPEUikQl8nn/HawYr57vH43Elk0kFAgGLYtzIPRwOm3FnHzGukn5P6XBWgUDAiBK8DviD/CFOFe91k+XCS8Fg0IwY+8vncHbAOjgZLubu8/nMwWSfcFy4uxAFIClIl/BOu922OyXJchN48qFQyPJ93H8Sz9Klw8Lzc944Y+ylK9ecNXf/povIj31B95HrHI1GZkwl2ZlJsrvA98aA8tw4lMPhUOFwWLFYzOBVF4Fw9QH3lO/MOfX7fdXrdZNjn89nqAX6k+fCYeXMOHtJpgtxTl/XOXxlSa1Wq5IuQ8NoNKpEIqH19fWJJGCpVNLp6al5gOB7JLlIiBUKBUky3JRNH41GOj8/19nZmSqViprNpkKhkCVZXYtN9HJ0dGSez3A4VCKR0NramiKRiNrttmGb/P3111+r3W7L5/NpdXVVkUhECwsLCofD2t3d1cHBgVl9lABQWrFYvLGidBWLKyzSleBh5Nx8Cr8zGAwsTEXA+DmQAQbIjWqkKyPsLgSFn2G8uaB4/t1uV6lUSsvLy/J4PNrb21OlUjF8FmXvRjWxWEwzMzPm9bjQ25suEsOs0Wiko6MjDQYDlctlnZ2dKR6P686dO/Yc5FGKxaJCoZA2NjaUSCTMYSDSlmTKzVX2MIzISyCDKBr2GaUIhABG3e12LQ8IrDwej7W6umqOlXSV4zo7O9PDhw8NVpYuL/rW1tYbGeqf//zn8nq9mp+f18bGhmq1mv7qr/7K4GLuaz6fV6fT0eeff65Op2OKGogRxlkgEDAEgQh7PB6rWCwa+QUvGkbm1taW6vX6hJPQaDTU6XSMUTgajbS3t2fnkc1mNR6P7f4DRTYaDe3s7Bi5wOfzqdfrmaMQiUTk8Xi0uLioRCLxe977667V1VWNx2Odn58bioIBbLVadvatVmsChkK3DQYDg8BWVlaMvQV7FidlYWFB9+/fVzKZtBz3aDTS7u6uarWa7R/3NJ1OK51O6/T0VC9fvtT5+bn+/M//XMPhUCsrK3rw4IHOzs6MALC4uKh8Pq/5+Xndu3dPFxcXevLkiRqNhmZmZpTL5VQqlfSXf/mXGg6HymQyRlL57wKLdbtdU14cMJCW62FVq1WjwpH45A8PyOHXajXDqTkAlMdoNJLP57Pwl0RZOBy2xNxoNDL2Dhc2GAxqeXlZqVRKL1++VK1WM0y+1+tpd3dXlUpFs7Oz2tjYMCJAIBDQxcWFjo+PDZ9FuXB5EJqbLNejdj1XN2pACbokhuu/z++5//ZdEck/lvx1PXr+Hy8Jz4YLEQqFlE6n5fV6DfrBa+WZ3YgO+Ad8/U3hCPd5UcAsiB8w+0hyIqOxWMyiLRT11NSUOTher1fdbtecE1fZg5njKCUSCcViMYMM3dyUJIvM2ZtwOGwe88XFhTqdjiqVii4uLpRKpSzf4UY2sOGOj48tV0n+Buz8pmt3d1c+n0+FQkGZTEa1Wk0vX77UYDCwOxMMBpXNZnV+fq7j42PVajXlcjmlUil1Oh2DU/l+yK5rbF2STq/XUzqdtvzOycmJvR6ZIUpxkQYS2G4Sme/O75dKJR0dHcnn8ymTyVhEg5MGZEW+tNfrmWN3k5VOp41Q4OY4kC032Q5E7ff7DWocj8dGgpientbU1JQqlYrK5bI6nY7dQchG6NtOp6PDw0PTl+hMaNrT09NKpVKmn9rttjY3N9VsNjU1NaX333/fyBmDwcBo+fl8XtlsVvV63aJlDPVgMNDLly/V7/d19+7dCUj+e0/of/zxx5Jk4Vo8HrdLizdWq9VUqVSMkpdIJFQul02x93o9BQIBZbNZRSIRNZtNnZ6eKplMam1tzaAp2FokrbCcUEcjkYimp6ctTPZ4PKrVahbWF4tFw2thrc3MzGg0GqlQKKjZbCoejxsGXSqVLITnone7XVOqJNcODg5uLJgulOhSd6VJuE668vaIHohK3M++Dv9c//fv+jcXKnKT8+4zSFchMglLj+eSFUXS1zVcLj2Z54eDz2dwsd+Eyj0/P29Rbz6fn2D+oDxwboAeXDgV6IVEZzweV6PRMGoqig1Zg7ACaSQajU58B6JNHCfgIM4WthTQG0xG7oyLj2PM+/2+zs/PJcnqQ4AyoIS+yZqbmzMlXalU5PF4tLGxYdFXvV5XvV43ZUfekTvfarUmoDxyKKPRZa0adUTAPeSLms2m1QqdnZ3Ze7CXPp/PogzyNhgJ/o28oiQjC7jwE+QA9tRlXtbrdV1cXCidTmtxcfHGCf39/X2Lqk5PT+X3+43kw1nzzBhM6dIoBQIBMy5+v9/Yk4FAQNPT0xalwoo9ODgwduxwOFQsFjOWpyv/GDto5RinlZUVy1ft7e2pXC6bMcKQcBaDwcAi10KhoNnZWXte9A9oyOvAiq9sXH74wx9O5E9QxlzoXq9nCS2YY1NTU6pWqxby1et1hUIhqz+p1+vmyczNzZmHWCgU5PV6TcBghWxubuqrr77S7OyslpaWrHAJnBALfHp6alQ8FM/09LR8Pp/RGFHm1WpV29vbxl5zjYvH41EqlVI2m9WLFy+0s7PzRh44+4fQS1dK3YW63IQxXvJ3GQ3Xm/uHjMr1/+c5XBhNuipOIx9FzRFUbjcP5jLD8Lp4HyJAPMp4PG71Mjc1zsvLy2ZcstmsarWa1WjEYjF5vV41m037fm4hJMofJR2LxZRIJFStVnV+fq5wOKyZmRmjyafTaYueg8GgFhcXlUwmdXh4OAFJEJmjUHq9nkFqo9HIkqM8B4bE7/erWCzq4OBggg3F88RiMb311luSpLOzMzUaDTUaDXumm66lpSXbn2KxqHA4rAcPHliRY7VaVblcNirr9PT0xO8ThWJUY7GYeeWQIlxnh8iCqO/o6Mhk1s3JwqjifuI94zyiPMkBYPTIF0makC0XkoIUMR6PNTU1pbW1tRsbl5cvX2o0Gmlra0uHh4dKJpMGqWezWUNmUPjAUPPz85ZzQhYxrFNTU5qamlK9Xle1WjWG487OjlG/A4GA5ufnrS6Ks9je3jboH/o4zg6RT7vd1osXLyZKM4Dz2u22jo+PFQqFNDc3p2g0akWxIDvNZlO/+c1vzLC+jvy9snGhCBCvxE30QU32er1KJpNmPFwvjgspyeh6GJKpqSmz9AgrXgDJKrxoQnRCYwq5gByA51x63XA4VKPRsJoXlOT1vIF0meByk9u1Ws2gmGg0euPLjQIiZ8VnA5lcT9bzjNfhrn9MObuX++97bTwe1+rqqnw+n46OjlStVpVIJAzT5hlQjlTxu8YFFpX7WdeJCHhwRDVvohg5Py4nDDoM3Gg0UiQSUT6ftzxfLBbT2dmZFeiy971ez+iwJMnBxuv1ukULQBh8HyBDcnh4rChZZJ2CR0kTUQqGMBgMGlyLIee1nLkb1YLFp9PpG++fdFmMyXdx6el8V6DMVqs1QcYgckkmk5qamrLfZZ9IXFPvdnFxYexFnNHrkbJb+EuHB37u9/uVTqfNEAcCActluAls5Iv94W8MOdAuhINms2mR7cLCwmvvH0WfLoGh2Wzad0KOkCkISG4tGFEqkCnOrKuDcFAwCC7pCNng+1CnJmkC/eA9XVlyk/XXIXd0Xr1e1+Hh4YS+Jg/mkqFeZb2ycfniiy8seURtQDAYVK/XU6lUUr1eVzwe19tvv610Om2MLRJ9WFRJOjw81HA41P379/WjH/1IvV5P5XLZWiFUq1VNT08bREExz71795TNZq3WQJIKhYIKhYIJY6vV0t7enhk7j8djVdYciquw4eATavv9fjWbTUtKPnz4UBcXF8rn81paWrox5o1BXFlZ0ezsrBqNhlEPKWRy4YLvYmRdZ2fxb3iDLuz1DzHH1tbW9O/+3b9TPB7X//q//q/65S9/qbt37+rHP/6xpMvqcGBBFCEwKCEy1En3M1yjjAJrNBoGpb2JcXny5ImkS4iByu+FhQV5vV6rTZqentba2prVwni9Xj169EhPnjzR0tKSPv74Y4VCIZVKJRWLRQWDQatrQTk9efJEp6enWl1d1ccff2wy2263FQwGlc/ndXZ2pqdPn2o4HGp+fl7Ly8saDofmSZZKJavH4vl2dnY0GAyUz+eNoeZGPy5TUrrKK2C0wMffZJEYR/kPBgOVSiV5PB5NT09rbm5O5XJZR0dHZkB8Pp/effddLSwsKJVKKZFIWDX58fGxKb1kMqkHDx4oEoloa2tLJycnls+ErYVhxpjRcoQ6EBR2KBTS0tKSRaR00eBeUCR5cnKi8/Nzq63z+/2am5vT3NycnQOdBXAwUPLvvPPOa+8fBaQ4WyjceDxukQXdF4DuR6OR5XNDoZByuZzltSKRiOlH6TKKGY/HFj23222TS5wS2rOcn5/r2bNnajabymQyFslh7DAkoDTkrzF+sP9cFpskPX78WKVSSVNTU0aKeeedd6zGhg4Dr7Je2bgAOQBDuRQ5LDlQFBfStXbSVWIcrxfYpNVqWSEWkQv1FVzCUChkNQKup0D+h9YPQCJ8Pp4knur1RPf1RDZCjqKGDABv/6ZUZPczIpGI1WXg2bDwxHkGl5nEz79ruYbl+uL9EaxkMqmVlRUlk0mDHBOJhObm5sxwA3UQcSUSCXU6HTPq4LsulOY+i5vg/T4WWLxb1OjuCR5tMpm0/l2SLCE6Ho8VjUbNWJInwstljygG7Ha75mwAV2LIeU+cFKJ05I3ELqtarVrblOFwqGQyaYxL5Ak4RbqiIvNMyDlO3U0Xe+Ymd0lyU7Rcr9eNassdlK6YcNBxyR99lzeOXiDSdD1mzoR75ybh3TxWLBabINbQs4yOAm4/O3cBuxNp4uywp8CaN1mu18574HDxby5dnP12yyRcsoHb1ocoWJIZYuTcvU+gGkRNzWbTOgfwM+4DUDD/7TIg2ZPrJIl2u61yuWwQJYYynU6r2+1O3Lt/bL2ycYFdI8n6cnH5aJUyHA6tZxGbenR0pEqlYkkmSdrZ2TFa4zfffDPB+wYfdSEH4AxaUAB/0P/G7/crlUppaWlJlUrFiuSomCX5NR6PlUqlrB6BjUf5AKnB/vB4PHrnnXfs9bzupms4HFoyEBgQeJFLgBC6rWuu5yr+PuYZ/8bfXGogxuXlZa2urhpVmwRjIpHQ0tKSPvnkE8uFuYZ4d3dXx8fHhsMnk0nt7OxI0kQTQ1dQoai7ENGbMJ2QHZL1/X5fjx8/tl518XjcckPApCRc3377bSOA+P1+C/N5dsgdoVBIDx480Pr6uoLBoE5OTszLDAaDOjg40O7uriTZazwej46OjlSv122/m82m5QdgGbqXGgWJwULW4vG4UqmUGo2GDg4O5Pf79f7772t2dnaChHHTBXPt7OxM29vbE6QZjEE+n59ozkm0T2uRFy9eWB0ae8PeUsi3t7dn1GuKmHEc3Zoy2tBwR3O5nBYXF4280O12rQwhk8loZWXFjCFJ7qWlJdM13CWia+SQnm1Qqm96h+n2QRkGDEWcUq/Xa00kG42GNjc31e12tbq6qvX1dSOJeDwegxjJp7ksWjfxLl21rQFCJxqTLh2PZDKpbDarZrNpnVQwJBhY+j2ik2kTgyNGB4rV1VUrFqWJMJCzWw7xox/96B/dr1c2LoRsJI9oqAg7BG+I0J5Q7/z83KKeQqEgj+ey9gGW2cuXL5VMJrW+vm6Riotv0wsLr5NkH2EonhH1CS6Vtlqt6ujoyLwsfjcWi5lxQcnAKuGiw2ABxjo4OHijhD7eBKH6dcYWxoWLQpTktrT5x96b/5auClxdw72xsaE/+IM/UC6Xm/CMMNYbGxuWk0CQMTIopoWFBetcS8NP2IDudyHCwVt3DeFN1szMzATcVq1Wtb+/b/h8NBpVuVxWqVSayJ+Fw2EtLS1ZlIC37PV6LVmOwvH7/QbHnJ+fa29vz6I66mSePXumXC6njz/+WPF4XNJl4po8BewmFwqE7UcURFTAz5GpdDqtVCplHX0DgYAymYw2Njas2eSbODdEH9VqVS9fvlQ6nZ4oRoTAEolELLkPEYNeVgcHB+r3+xPtcqanp9XtdnV6emosJCrus9msMTLpdACCgV6A8izJcoFQe4HV4vG4CoWCGSXapOTzeVN6RI5uzz3IMbT9cXMkr7tghsGgo/ehW0QOZAuk2W63DSk4PT3V+fm5sbPIobGfMzMzZnhd6jzEI+4jTDN0hdsrkMgTvQjk6/f7rebr8PDQyCHoAdAhggYXyiWCQW5fdb1WnYskw+7wrL1er7E36vW6KpWKCaski0Dw1FDceJWxWEx+v98omChehJQEaygUMgip2+3q4ODAMHM3gdfv9zU1NSVJRjVl8wj7MDTXIQk8BiIi2tPQFwmq4E0WUY8bWqOIyU+5/Hm3nQvrOjPseo6D93P/wLaLx+OWXxiPL/suDYdDzc3N6Uc/+pF54pwBQkxR2nvvvWetKUguz83NqVKp6Pj42ASQPXUT2d/HooANbwoWGN8T7296etrautBz6eLiwhwUtyYDhhMyKF0WK8JEI7I4Pj42+ijw6Pn5uUXDRCfkqijQpP2L2xSUvcUhoGkkF7pYLGowGBj7yO3x9CY1GpIsCsbbpTkiMgEUx30Co+92uzo7O7O29W5BLDlDZHY0Ghk0ieG8LsPIiEteAQp3ISDeE0VKISRRSTKZ1PT09ITSA0VxjTffy42ib7IoDKb3F9+XWqvR6HJMRS6XM4e53+9bnoX8MbIEeuOyAGHiEs25zhDQF3Dl7Oys6Tb0RSaTsZ9DcOCenJ2dWWQ9GAwsGiI6HY/HxpolQHDTGu7Zvcp6ZeNCgU4sFrNQmkgik8nI7/fr6dOn2t/fv3xjp/0H3gceHBhvJpPR9PS0ms2mtre37eKhLOhYiyFYXFzUwsKCJe0lGSQC7ViShcHkclz88fj4WI1Gwz4b716ShexTU1N65513rCsAyiccDt9YWcK2uw5v+Xw+g5qo1HWb+rlw13WmB3vjspFc5hP49ezsrM2y4IJubm7K4/Ho/fff1z/9p/9U+Xze2C1EpwhWOp3Wv/7X/1qj0UgHBweqVCqan5+Xz+fTycmJXrx4oUajYZeOiwOz7PtYf/iHf6jh8HI+y9nZmXmz0GiLxaJmZ2e1uLioWCymhYUFBYNBq6bGaUDBU4cC/o3zAYxL1NPtdrW7u2t1HysrK7q4uNDe3p56vd6EIQaTpt3506dPrfMv0SBOGrT8dDqt1dVVJZNJ/frXv9ZXX32l5eVl/ZN/8k+UyWSMCn49z3SThTIhmZ7NZjU/Py+/32+5RRSS1+tVLpdTt9vV+fm5Dg4O7FmlS9JHp9NRs9nUycmJUbwDgYBmZ2eVTCZ1fn6u3d1dg8ldxxLqNmiHe/elK1o8tWexWMzgQZ/PZz3bUqnURE6M5rZ4/7y/y7676bp3754kGcKCcUEezs7OdO/ePZNBkJpcLmdoydzc3ERtyvn5uc1K2djYMGZcsViUJKOFo9SRoXD4cg4Q0Uqj0TDKsgv5Y1xGo5EVzLpEh16vp+npaX300UcaDofa2dnR1taWNf31er12NnS5flUE4pWNC18OJQfLwfX+EQ6Px2PeDx4EWLMrVAgnrczB7d2NREG5MBYe+nXFhWDi/eBhu8lHSRPKW/p9uqhbdU5LB3DmmwrndSNxPVnvsnNcquh3reu4MReXcyLEdedtXM/PcFYoBbwWLiRRE14iryGZKsku8nXGGM/0fS7Cd/I40pV8QCi5DjXxPa/nfXhe6OAwBn0+n5rNpnUhdhP0KHhXZvhDvQWRr4tNk8x1z0q6yh2xz9cL1DgvZB+o5032FagOBOA6y5DnYx+5C/zOeDw2yNHN//Be7v7yzNwbl6zg3jcgcIooXQhGulSuFF9TA4N+4Q5fJ3a4UYB0VQPjOpI3WS5RiEjruuKnLIMcBmfMfgIJ8txA4MibW0fmki74fPes+FyKe8fjy9ZLpBxcOJqc8vUCXldmucucp0ticZGe7z2hn8vlbGPxBujp5Ia0zDRgWNPu7q7Ozs4mogg89J2dHbXbbauaBt8GRkPg3JCQwTVU9PNakn4XFxd68eKF6vW6ZmdnVSgUVKlUrKcRHiqJs36/b0w1FLEko2ru7OyYcnEZQDddfK57sYvFosF3jBnAK5KuFLabl+EsXGVFlBiPx7W0tKR3331X4/HYqn0bjYZBey4lsd1ua2trS1tbW4rH4/qjP/ojFQoFnZ+fT1AuvV6v1eg8evRIf/M3f2NV3dKVsnYZcC6E9yYLJb67u6uvvvrKLq8ky/mcnZ2p3+8rFosZs21/f9/yF9RAzM3NWZfap0+fWrIzGAzq9PR0YqgYuD2MJeqeYCuRXCZB22q19PXXX1vxG5E53jTnlslkrFr85OTEFPfbb79t3QNGo5FRVul+8SbG5eHDh5KuqO7hcFjNZnOiZcpgcNmjDSPjsgGBxJGHTqejeDxuOTiU4tnZmfb391Wv13V6ejoB15KoRwl7PB4tLS3ZpNavv/5akmz/V1dXDWLc3NyU3+/XxsaG9T87OzuzqHE4HFodns/ns6gGqjqdGW4qixjd/f19nZ2d2eBC8sF0Jfj8888n+tthXNhz6YphmMvlJjoRkOMKBAIql8va3NyUdKl/GSuAvDOJ8vj4WNVqVdlsVmtra+p0Ovr2228tp+WyRd2Vy+VUKBQsx8Yevfvuu5b3GwwGliJwHalXWa89LAxPpN/vW1hFhX4mk7H8CzMZEC4iAELCZrOpSqWiUqmkaDSqxcVFCwHdoiE2B+tLFSqsLwSJQyaB2m63bXBQMBjU8fHxRKTlWnRweYwV3uRweNmenJbur1NA9PctFJL7+XjPRBxEd+5zXl+ut4YBBi+PRCLK5XK6c+eOKV2+A8LB++Jhnp+f6+nTp8pms/rRj35ktNTrCwz44uJCBwcHlsOSrqjfrlF0Pcs3MTCcBwoLEocbKVHb1O9fTSGlESrGJRqNWrFos9nU8fGx5f6CwaBNHkXmSKqTDAficaNk8gHT09Mql8s2sXFmZkapVGqiOavrrTI5lUQ4CXAwefB3chI0S7zpotUN5+KWEEAJdlvc8N3c80N2MSYk9TE23HMmb5KURqkSgdEuCrg5n8+rXC7r8PBQkkxZ5/N5IxRw7isrKxORDolzjDyGn5klPDNO7E3l8LoMSlcjvl0HhNwbEyDRO+7+UdJBeyqam4LqwBQ9OzuTz+czxqIbJbHfkD2o/yHC4r1cGN1FOSBEkFfr9XoGl9IEdjQaWbmHW3/3KuuVjQvMGC4ZkNF4PLaRxjCxpKvQcX5+Xvl83hrv9Xo9m+EsyYoy3QRspVJRLpfT/8veezw3umbpnQ8sHTxB0Nv05t6bN6tuV1d1dbdGXdXdE5L+Be0U2mg1m/kntJZ2CoWWWk1oIY3Ukmp6yt0yfX1aJr0BDSxBA4Iws6B+hweorComeGeXbwQjDUngw/e97zHP85xzMpmMyXdPT081NzdnsmCpW3aLusSP6CwUCnr9+rVqtZpFGp4Ag+CanZ21CJSojOFU4JZIIvtdtG54m3rIp8G9tTietPdfLAwFTnliYkLT09NaXFzUzMyMGUKGaUEUYqgqlYpJvX/0ox+ZWIO02tcTXFxcdoamrcXMzIwZaBwk186G5kAAIfVrHBl5LckCBgh63isej5vaCYk6s+hPTk6ssG96etogC4IUnk21WtXBwYGpfprNprW+YP/5Rp4EHcfHx/r8888NehoZGekalufrYgKBgPWMgk+ghov6IniQtbU1m39y08CG7IB+fzgUuBwEHDgc6i4I4CqVir788kuDU2i8uLq6avtDkpUP8Ix4DRw2zww05OzszHoGUvyKESRiprCS63j+/Ln29vbsHu/v76vRaOj+/ftKpVKq1Wp69eqVIRDsS4LHftabN28kyQq6KYQGtUE5RsspqIP19XWdn58rFospm81qaGjIpvUSnFOLB49HO61CoWDPolKpqFqtdk0R9Xvo7OxMy8vLViBJYbnPnPh5ijOBGgl+QGlCoZCmp6fVbDZVLpe1t7enTCZjPPV11rWdSyKRsAwEo0NUcPv2bWUyGfPMSIwbjcshW7lcznpzoeBCeTQ6OmrKo3A4rG+++Uabm5u2MelTtbe3Z0QkD5MsIBgM2jAxNuTw8LBevHihX//61114L7wBY28TiYTu3r1rLas59FQuE/GOj49rbm6u741J5ocT9Cmqdy7AfxwGfxg9ROEXDgbncu/ePS0uLmpubk6RSEQzMzNG4kO+5/N5w7JDoZD+/M//XH/zN3+jcDhs4w48/ENKvL+/r+3tbTWbTS0sLFiXVk+gekwXDb2HTvtZVI1Lsm7CSEO5X5lMRqOjo9ZEEWUMpOvu7q4GBwdtvDDOh3uAxDmfz1sbmYuLC21ubqpWq2lgYEATExPWTDUSiVj0uLKyos8++8zORiwW0/7+fteYBg6wdNV3Kx6P64MPPjBnRHYPx7SysmL1Hu9ysN+27t27Z69Jpk72z7NDnEDm4OHBcrmsFy9eaHBwUE+fPtXo6KhWV1f161//2qL6cDisjz/+2PqS9V6vh2h437W1NW1uburu3bv68MMPzbECEzebTcXjcau1W11d1eHhoUm+a7WaDSC8ffu2stmsjo6O9OLFC52cnBhsxfPu9x4uLy8rFArp0aNHunXrlnZ2dkwp552hV2X6AGFiYkL379+3ivqxsTHbI+fn54YukI3RMZnXptaEIBinSfZ4enpq0zcZ4MjyP+/Pjp+tEwqFLEBHxViv17W+vq6trS19+OGH+uCDD66tGLu2c/EGGniFKIt/80VTNCJkHE6vysl3ti0UCia7JK2Dd0DKR9PC4eFhm5+AVl+6GijFxjw+Pv4dkQCwE56fTIi2E5lMxmA1T/KfnZ2pVCr1vTGJWjG4fnmIyzuVt/2MdAVXcB9pd4KjXFhYsMK2ZrNpcyA2Nze1tbVl+D5ZKFEr0awkO+C0lNjY2LA2PaTkvrULnw1j3/uZ+Jl+o28vF/eSaQIAvg/ZT+8xyN9oNGr1TxQEFgoFFYtFy+jYOxhUoNmFhQU1m5dzMHAqtFDhc/nMk3uKc4YTDASuhkqh2vIZLc+yl1vz0vKbcleSTK0JDMvnh3fEiUUiEQvGUBJSM1Kv1222Cwabkb8zMzMmWe7NVqkqp5sC1wNBz8RD7iu1bETVQPOcJ84v7V9AA9gzQN1kpzTR7WexNyqVivb3943D9WQ5TtY7HM4pAfPAwICNFqGdCtwnhb0U4vK7jMEGvoLr5j6AJPlC0Xa7bfcPcQt8eaPRsAzTQ/XtdtumtAIrenEQZ+0669rOhQNDGkrHznA4bD2PDg8Ptbe3Z8Ya2IUCJoheKpuPjo60tbVldQNs4ng8LunS4QwODuqTTz7RyMiIjZk9OjrSysqK2u22Hj9+rGw2a/ju2dmZDg4OdHZ2pp2dHet0jEySueBsBg7WxcWFJicnDfulupaIfWdnx/DgfhaGkH5LODBvdHsJekldxtpDZRjVgYEB3blzR//iX/wLzczMaHp6WqOjo6Yy2d3d1X/8j/9RX3/9tZHKU1NT+sf/+B9rZGREe3t7prd/8eKFtYGhyvj4+FjLy8v6T//pP6ler+v+/ftG9r969cowenBkIDBf1+NT8n4XMAM9zuA1gsGgdaaFX8IYcT2pVEonJycaHR1Vo9HQysqKVldXlc/nbZQA99TXBFEx/+GHH9qQJ4zL69ev1Wg0rIATp4LRQLpJd/A7d+4oHA5rd3dX1Wq1y0mS0WYyGSUSCWvCivyYc0EW2e+i0DAavRwrnk6nrVvB2tqaDg4O9PTpU/3pn/6pGo2GdnZ2rK1SMHhZfY7TKBaL2t3dVTQa1ccff6xMJqOPP/7YanyAYiGdpUsHms/n9c0333QNG0TMU6/X9fnnnysUClm5QyqVMvKebBtCm+8nEgkLDICaAoHLKniKE8kMNzc3+w5wQEaePXumN2/eWB1cu922UexegCRdjc/g3s3OzhoHvL29bfug0WjYWXz9+rV1k8YB3L17V5lMxupi2GdeIenVbDi30dFRg/1RhW1tbalSqVjHd89pFwoFbW5uWlFmIBCwuV0TExPv1ILo2s7Ft0jxRTc81LOzMyPyvJGkR5aP8rgJRMySbOpkOBw2j0lmNDIyonQ6bRXMZChcgyeOW62WTk5OdHx8bMolDDTGwZNr0pV2HGyTaA44CEP9LmRW7yID4n29mur3yYr/UITF68B1UeMBN+Sx/kKhYNgw0ad/Dhh/oBLSbrKTcrms3d1dnZycaGJiwqrI/fgCrqk3uu7lYPo92B4S9DwU8JvHlfniWnzUSMZMBEfGQiZIBMxrwi1MTk7aISZyxlj75winRibsnxFYN0XBCFC8wo4ok73phQU3zVzIInzXBp8leXkqn0tS1/sHg1fFiPCbKOWooyJw821uOJ+BQMDOtUcVhoaG7Nxyz3xGAG/2tnNIYMPi+VJ8SMEtcFO/e5B775WjNNL1maW/nwg4CARp8cL0Tb5PQMaePD4+NqGJ/92zs7MuqNLLq4Elec5k7cjseRbYaLhWn+mwT9jDPBvP01x3Xdu5/OpXv5J01ZU2HL7sQNrpXM5LoI/XyclJ18MgDWRz8BrcMA4gB58PL8kw7Xg8rrOzM42Ojloa9+DBAyuEg3xG412r1VQoFLrmy/AggHUgbP3N5nO1Wpfdbuv1unXJ7a1XeNfFg2Nz+7oMbyxZ3pD6f3NfkX3TQRXRApMiqSEql8saGxvT48ePtbe3Z1j1559/blBHq9XS/Py8QYxbW1tqNpv67LPP9NVXX1nV7sXFhb766iu9evXKVFFeF0/07jkjH7XehJD+7W9/a59duhQKPH782FJ6DhuRIHwBxiiVSul73/ueHWIyC99GwyuMgHcjkYh2dnZUr9c1Pz+vhYUFDQ8P2xAsiGsUXl7lR6V1IBDQ+vq6/UwweDndcmpqSvV6Xaurq3ZNQBmLi4tdSrtvYwHr5nI53b17V+fn5zo8PDSxwvz8vBqNhv7zf/7PXYECexSSGcNEhodCi35oQIY4DkhulF6Qxsx3uXPnjiYnJ63zsSR7jc8++0wvX740hV0kEjGeNp/Pa21tTZKsxcnu7q5B7X7aKEEuhbT9LAQRkOrSJboSDl/2q0OFKF0GbgS4FJrTuQAVLM0ni8WitS6CB6bdEtBipVJRq3U5q2p/f78rW0GVuL29bU0nafE0NjZmLXcQM9BpgBEEzebV9FCgzXb7svP5wMCA7t69q2w2q4uLCxM6XWdd27lAZs3NzSkcDmt4eNgmOa6urtqme1sU629mMBg0dYxf/Aw1AWymVuuqtcLFxYXp2OFN2KjwCEBwSCH5Hl6XORpjY2NKJpNqt6/mX9MPCbWRV2345nT9LDY0UYXHZX1xlOcqiKZ7nRrOBWJ5eHhY9XrdyHUmgxKpMXjMK1PW1tbsORLRoPSj19M333yjX/7yl12Cg/X1dcOJuT4iYDIer2q7aeEf682bN4bvIzunTgRujW4FPqpj30AIBwIBi4APDw/tM/tnSwbEPUTkMT8/bzUdtGzBifksF2OMkw8Ggzo8PLToj8wBOFe6kugi/QS+5f6BDNzkXpIVMPl1b2/PoN47d+4onU7riy++0D/8wz90dRrw3cK5XroHoBBFAdfpdKxlUywWs5IEsH+mLh4eHtrwrYcPH1o3ADhcYPWDgwPr/DszM2NlDsBcL1++tJ5w9Jer1WpKJBKamprq2h+9Gc67LqrrA4GAPWd4ShweNTeSDC6G8yHQhhYge67ValYvdnp6arV+KGd5n06nY9J67CjPc2Jiwn4GZ84EVGoBcWyMfdja2rIu9Ox7mlnieFqtlnK5nO7cuaPNzU1TBl5nXdu5QISjavDRCSONwd/BxJEmQtBRkLezs2OKLR4A2QX1CzRSRLZHARSbD3UP0j1PKve2QPFwWDKZtEJDjAmGhBYKFDLyPqg/biJj9FAgaT3/hwPxmnSpu86gN6sBnqlWqzZVMRgMKh6PK5vNGifGQW6323ZAWaFQyGbhjI2N2fUAIwDZ9MIyvRlUr0zaCyHIBonq+zWO1EQQAWKwpcvWRB4qQVqL4R8YGNDp6alevnxpUCyBSTabtX3kl69GZo4FJGulUlG5XLZABYm2N1wcVO9MotHLqZapVMr2VKvVMkdF1M956XQ6liFxr2+yaJ8Ch9hqtaxnG5lEp9OxprAUlhYKBTM0DARD5koWzj0k8yJw84W71BH1FpSurq4aegCiQbt97nMymexqVkv2RBnEzMyMhoaGDA5mhgvZLLVw2Wy27/u4v79vtmphYUFHR0fK5/PWX61SqdjP0tMPJReZHmcDUY93PNgkxEgEh6AxvgYJ+iASiahQKHTJsUGECMKQlCM75t8Ua5Jhn56emvOTrmZQvXjxQpubm1ZPdN11bedChAcmiPQ1Fovpk08+MaIdKIpNRCTZ6XQMZ2RjDw0NWXO+ZrNpdQdDQ0NaXFzUD37wg99pkInXhxuA2GJT4lyIKlGQ8H80HpSusgScHN1th4aGLLVGsEC21e/G9LUEqDpw2CwyBG9IPBbam93gOCAI2+22vvOd72hpaUmlUsnS5NXVVTWbTWWzWU1OTlrBVigU0t27dzU3N6fZ2VlLh+EC2u3Luo9oNGpGhffnGt8G23HNSD+pOCcK62cBPywuLiqXy5mow9dX+HtN5fnExITi8bg2Nzf12WefdRW0DQ0NaX5+XvV6XcVi0V7HZ5OIWIga9/f3LeL39xji1vdyoqiNDA4J761bt8xRUU9ABIsCi0zx9evX2traMkL4Jg7m7t27Rj7v7Oxobm5Of/qnf6pWq6X/5//5f7SxsaF0Oq1Hjx4pmUzq7t27ikQi+slPfqJXr15ZycDAwID1CyyVSjZyAcJ7YmJCMzMzyufzev36tcE5FBmiipIuDdxvfvMbnZyc6Pbt2/r444+VSCQsE0GqOzo6qvv371sH9mbzsrnnhx9+aF0XotGoSe1LpZJWVlYkXfYaTKfTymazevz48bWltL1rZWVFkUhEH3/8se7du6eNjQ0TDdEpAJ4kHo8bqpDL5WxECOcEu1er1RSLxdRqtUxGT5cIoFkCafgUbC/V/xsbG5adEZzQa5FgmuFpoA3YPJRrpVJJlUrFoDuyzEajof/3//1/tbW1pcnJSc3Pz197D17bueDN0EEDQeE4PAlEGwbpqoElMJmP/P3/oYrh4aDzp1qVA9dbKc8HBe9HUsnm7XUwXmdPlOB7PCGFhoT0UkLguH7W26J7/z1/T3p/r3fxM+Co/osMy8M88Ay+pTsZCaOMeZ7gwOVy2YrX2Ny91+0/V+/f/b+9FLnf+4cEloPRKyzBgLM3cIAEFdLVYCevuiKy5f+86KTX2Z+dnenw8NBGLkN8U3RI9gQPhYiAqB5uxmeqvffLdziQukfX9vaWetfFvuYauX/86SE9shkvZvFSW/9Z4VYI7nCwRNa8lhc7eMEFr+ezT+49DRThILxYAIPL2fVqVAaOSVeFvHxdV0rbuxiDwZ7ywhzPL/nAFmiToAZhE/bRF65yb8kQIOThpMPhsEFufs/C1/Zyjn7shb9n0A68L1CstwXcU78v3hV1uPZdBm/c3t7W2dmZEomE7t+/r0gkYp09j46OTHpMUSQHilSZVgIeNhgcHLSMYn5+XmNjY2q1Wnr58qUikYimpqYUi8VULpfNW/NQMbD5fF6rq6uqVqt68+aNyuWywuGwSRoxTmCio6OjmpiY0NnZmenVae/NJvF8x02dC5AQh5u/90qNvQqK5dVj/mtyclKPHj3S1NSUFbVxr+iBdX5+rr29PW1tbWlsbEx37961nkhwB6TtFK1++umnWl1dVaVSsSibvl298JGkt6rouGbIz343KOtv/uZvTDzy6tUrSfqd51QsFlUoFJRKpbSwsKBUKmUOFRhKuiJ/CYwgRaXuglYUhMA0GxsbWl5eNnnr2NiY8XpUMVPvgZOn6BeFFFJ5EIDT01O7Rzh9FGtAGEiax8fHbyRF9kV0w8PDOj091ZdffmkdBpDog/9vb28bjN3pdKyfIGeO8035AJ2op6amrDMCn++rr75SsVjsEn9wHZlMpouHZTYMmefi4qLJiKkdwmgj/wY6xPbMzs7q448/NsQE6XJvAfO7LAQkfDZgPKTGPHv4KEQMh4eHyufzSiaTmpycNMgsGr0cQLe5uWmDvhjStre3p6mpKT148MB6NQ4NDWl3d1e7u7uWPQaDwa56PWp+ONeNRkP7+/s6Ozsz7hDoDCcWDof16NGjrmJa+jHW63V7Lc7Tt5650DKa6AfIwys0arWaKpWKzaRnRjQb2hNZkOx88fOkryjQwuGwMpmMbQzSPjw/hpZ2Lp4YoxU/GCQySAwk2COt1X2rCJY35jeRgnqnwuqN+N+WFfQ6Fv4OoZfNZjU2NqZsNmtqOg6fdNWGh01EnyzUIb56mSjz4ODAlD9g5ziqXjLvbSo2/u5hwJsu5tQfHx/r6OjIslyySu4xHIjHpH0k6Ul4BAA4EBw9fBZZOIFFsVjU3t6estmsZmZmuhRM7fZl8RnwGJwPFeYERODbvD7FyD569c+dzwEP1q9h5P74jK7ZbBpUgprKZxfMokF2S6Ef6iv4BLKUZDLZVbfCuQZJoL4Hpw6E7euS2Gt+nsno6KjBk8zmYa/65+WDJfq0dTqXjVsZu9AvLCvJupBQ8Nn7GRhMBtdCMEoA2+l0bP6URwngpUCFgEhxFIlEwtr2w6WSncAB+aDIN9KkHMEX/VJzCDTmHTwBDpyPb/gJ7HvddW3nksvl7OJpXUB7AXDQiYkJIwHJFDDWiURCk5OT1oDv/PzcZsNIspGnkEh4Vwql6HhM516UIEj49vf3VS6XdXFxoZmZGTvsqFuIQtkQkN1slrGxMdukELQeu2Rz97t6DbCX0CL/q1ar1u7BZ2Y+SuO1IJqPjo6sjxYEKxDM5OSkBgYG9N3vflczMzN6/Pix9RtjLgcQWiRyOWnx+PhYt27d0vDwsNbX1y2q8h0GPInPZ/HXxd8JJHr5mX7W1NSUycaRoEPGYzwmJia0tLRkzvL09NSiwHq9rlu3bqler2tvb8/EGxg0Og7zXGhSiXNm39KUkGe5vr6uQqFghDTRNvOCUqlUF9zl2xQRFHHP/FCocrmsUOhy1g8RPY0n+13b29uSZI6M6NdLdMlOyWbogjE5OdlVuMq9I8PzEDb8GIYS/iuZTJpTl2QwJO8HOU31PkaTc+hnOZXLZSsCbDab1tncj62W1MVXkOX266Ah7Hl+TNllTzUaDc3MzKjVumwBBLSFgg2e2cPWwIg+AEkmk2q1WlYzRDNMRhwDadFzjlqjer1ugQvdwBESAH1RcuFbGElX4zP8LKcHDx6o1boaXU+wft3s+Z2cCxAChXpUxhIhQuRxIH0rhFgspvHx8a6WBdSa8HA6nY6lekSFpJzpdFr5fF75fF6jo6OmsCmVStrd3dXBwYG1Ob9165ZGRka0vLxsEy7pJYXRoylcLBbTgwcPFIvFjGRtNptGlJMZMCWw34UB6VWwRaNRGxYmyeScvu4CZZ3HxKWr2dpALl40EI1Grajtk08+UaVS0ezsrKanp02BR1seFICQkktLS1Z3UCwWzcjiSHp5FM+J8X+9mZgvMutnUcSIo0skEpqenraMlTqUDz74QOfn59rZ2bFZQdRILS4uGuTC6AaMGxwTUZ/nADh4RI2VSsWeE606UCyGw2GNjY1pYmJC4+PjBiMEApd1IsvLy9ZFgLos7hktaoLBoIlUIILz+fyNxmxLMmMETwGaQIEeai76oaFWmp2d1fz8vDY2NvTmzRs7p/AgRMBIYX32yL3sbffC3ue+4MxwLj7zpi3OzMyMarWanj17ppWVFc3NzdkYZdqxcF4QcgAXeVFPv9BipVIxB9xqtWwq6unpqdbX160zA3vIOxeG58EpU1OGc4G3w7lEo1FzLsCuZCLBYNBsZrvd1q1bt+zekvExtHFpaUnpdNqQok6nYyhRMplUNpu1xqGIbqrVqrLZrB48eCDpsgzl8PCwS9F2nfVOkyiRFpbL5S4jQYRydHSkUqnUxSOQ8mHUgQo4cChxiDQw7LTNgBBlgyKBJOuAy/CwDRkGD8pDcmQmqNN81E124NN9oAjeo1/OwMNFLD4Xc72RZQeDwS7ZM5uZz0RanclkNDMzY21N+Nzo8IlCeU1UUUQgEJ1kiLRQ2dnZUaFQsLnnBBA+yvxDgoTfd4/eBv1dd1H8ynV1Oh0r7PJZweHhoR1IImnEIgQXwCV+ABz3lL0MZk5xL69DFuGzRO6vhyR80S1kM9ATvcYymYw1UAXD5zkxcMqTz3RO7nd5g815Ycoge4/INxAIWKA4Pj6uRCKhRCKhVCplSEQsFrO9Q+t3WipBcLOHyRzgliKRiHFLRPMerqQmhOfqxTqgGbw/8OXFxYUVdhI4ATkCb96knIAsFwSH+xgIBExx6TNNRAwDAwPKZrNWzBgIBFSr1XRxcWHGHKUgz4F7wz5m3/jOGECD2A+cKBkvwTEZJsESHB7SdzpEdDod2+MUsLNvvKz5W+dcIPe2tra0v7+vxcVF3bp1S5KskyzVpkhXpcsOpjs7OxobG9PS0pLNNwfv3d3dVTqd1gcffKBoNKqvvvpKL1680OPHj/XkyRNrc0+Po4mJCeszxMGUZLU1bAIiw9u3b3cp2XiIkUjESFccB1XtvsYGIwyh2e/h5oF4WAnDuLm52QUhUUQHTMDnki5hMiSOjx8/1l/91V8pGo1aBjMxMaFQKKTT01MbAITRgkshawE+iMfjZhxrtZr+5//8n3r27JnBihhaSZbJsHodBkGDz2De9nPvur744gsTeayurmphYcECEpwvI4p9seLw8LASiYTi8bg5mcePH1sW8eLFC4VCIesR9erVK+3t7en27dv66KOPjGgOBi/nk3t1Y6fTsVY7BF3eUOLkfWZEwDMzM6Pbt29bXzecNsW829vbCoUuu9TmcjkNDw9rYWHhRtAiPKVvjUTQAlQNvJrJZPS//W//m8FmOAsaldI6nvtTqVSsZTxOmc8O9NxuX/Ywe/XqlZHUsVhMjx49svbuOHvOAp24PQeUyWSMn6U3GuKB2dlZLSws6OLiwrp3U9Q5PT1tzSD/5m/+5p3vH46VDAWEZnBwUH/913+txcVFQz/oynx+fq4HDx50SXhbrZYVMPL8aQ7bbDa1tLSk8fFxnZ6eWiAPZwonQhmIJIOFx8fHtbCwoEwmo+9+97saHR21rimUbUiycd3YAzLPdrttwTt9+oB6c7mcoVXfunPxUsJewhsP7iNlokYMtoe7yAT4OekKEuCBvY0EhlhF8eW9OtfgyUbpqlCRqFG6kk/2yhi9GoqDgxSQiOAmh7t3eXjJw2b8iRPykBR/ci+93JhoHAIPyMv30jo7OzNtO7VCvJ+PqjCGnlvpvfbef2OE/pC0ut/FLB7ksT578vBrr3LNK++AG4GAfDNIolJJtvfI5ryUHeIfLN/LW98mFmBfYsj5GWq8ms1mV1bF8/B/Eh3fpEOEpK5r4pxyH33rGqBP4DLfz4szCk+HBJvn7yW/XvaMo/GF0/AHXrrtM0JgeJ4t5wQUgufHtRAwooSDN4OYxtD2ew85//4cYpOSyaQymYzZHzhe0BogRM47xd+cTy/R5nd4Pw/F4dS4HulKaIGNI9NIJBKW8fH/7CPsGlk/3yMT9Vyaz/behTt9J1gsEAhoYWFBDx8+NA93cXGhRCJhBD9KCeAs4IZo9GpsMWOOadswMDBgHpqCqGAwqDdv3iidTuu73/2uyT4hzohwfFU5h49hPRRYetKZNg1I8oLBoKXqiAqazabhoqg7uP6bRN/SldHwy3MWPFRkm2+bYkda/Omnn2pnZ0czMzP6q7/6K6VSKW1tbenNmzcqFosm3QTHZwO3223t7u5aREf7Djbe2NiYJicnrSuyJCOs31Zl77MT/3/+IN5Ehuzv09zcnMbGxqwwDYMIN/DgwQPLMj3Ex2hjOjy0Wi0lk0k9fvxYzWbTDvrExISCwaDGxsbsEAK/EB1T70ImDCmPkQSbphcTyj7Ud2TV7N/p6WklEgmbgplOp7W0tGTwEIYTI9vvAh4pl8va2trS+Pi4JiYmLFMhsKCk4Be/+IVFyz5b9ZLVb775RisrK4rH47p//74GBwdNmOI7X3zzzTc2ZI4u6pVKRScnJ1pdXdXZ2Zmy2aymp6fN8SPthZBm/25vb1vPwGw2q8HBQT158kRHR0caGxszWTC977h3HnruZxF0EJgmk0ndvn1b4XDYIGQEQNFoVB9++KHJhIvFYpciE0TEB9i00wqHw7q4uBzXzUyhQqGgs7Mza3/DfoPHkWSKWuwkXCqdCu7du2eODtVfJpORJLMR8ItnZ2eGhpBY0MD1W3cuGOLR0VGTYRJVAD2g8cZIEanxs/wf6d7Y2JhBG3A6tJYIBAKWlqGoAtLyxXIQk56kJCo8OjpSsVjs0uVjKOjgzIbrdDpdEwN5Dfr8sKH6NZBvg4e8coxoEYjOz53wmYoki3ZWV1e1vr6uR48e6S/+4i8UCoVUKpVs9AHzt3O5nJHXcFek9vBQ1B+Fw2HTtIPLExnx+2/7bL+Pa/FKsZs4F14DIQeVx/BMjUZD8XhcS0tLpu2nu+z29raJIoiKIe8Z33p4eGjtgZrNplWgA7ERJcPzHR4edkk8ifikqywc7gRn4rF37lsoFLK6COCdWCzWBW+y12/qoAnETk5ObLw4gSDXR+BXr9f15s0b24tnZ2cGS0sy57K9va1f//rXmp+f19OnT5XJZKyvH+eU2o39/X2DsmhdJMmaIfogzsuakXbjYBDWRCIRc9pzc3N2r4F1fBbF+fIIxrsu7j+BHvsH3qNarWp2dlZjY2Mmcrq4uDAn6tWAZFvsHURPoC8EuOPj4zY4DHtKZ3gEFPRN5P3oM9jpdOxZJJNJjY+PG4dM5kp/MhSnhULB0CCyPZRqrVbLnNC19tt1byyRzcnJiTY2NkzKRpEeI0fRplNDQiQ8PDxs5LCf2UIHZDYAGREQRDweN4khry/J4KxisWgSUSqYwY+JKn0xJXwFGY2HH/xm2dnZUblctg1xU87gDy1ffwAuzkYmW6G9jeczuGf1el3Pnz/Xzs6ONjY2bCY7xaEevyYrevHihYaHh/X06VNls1nl83lT1yHdBc7huXQ6HSMdWT6jIu33h5d7BqzY70IlQ0bpi2kxQicnJ1pZWeki69PptG7duqVkMtnVJghH4bOrUCikpaUlm0w6MTFhQZFXuw0NDVlH4+3tbZ2cnCiVSml2draL6AZq89XUvD+Bj4d6uI9nZ2fa2tr6HdEMDUP7XSjcxsbGzOEdHR1ZUBWNRk1gMzh4OX01FArp8PBQlUrFgkgPiU1OTurp06dW4FcsFg164t6OjIxocXHRAhYyAF99TiTvf4+AhDPK/wOFMV2UfU3UT2t6fpZslNXvPeSZUIsHytDpdCwjgWtBBYaRpgnq/v6+pKuBiQSKQI3whNgh+gJ6Hg8UiR6IZJYUaYKw8P9wfohEJicnTe4sydRu9FLE3k1PTxuHxv54F+f8zhX6Ozs7Wl1dtZbh5+fnWllZMaKYAjdUWoODg5qdnbX0ut1um6Lm+Pi4q54E4mhyclLSVY8nVCg4F/DZVqtlBhXpIw+Em0bRFREjEkXklsBjzeZlW3YirtevX0uSqWlu2tuJ33ubygq4w/elIhUlY8LR4iQ83n96eqqf//znCgaDWl9f75oBH4vFLJXF4RYKBT1//lxDQ0O6ffu2ksmkfvazn+nf/tt/a8ShPxQjIyPK5XIWtfc6l17VXe/nBb9nGmM/i84JMzMzmpyc7IpK0fmXy2Xr6MtYB2qvjo+Ptb+/r3A4bE0OPVEtXQZCT548sXb37A8atZKBx2Ix64BbKpW0t7enZDKpR48eWbdw+ApG01IZzv/n83m9efNGkUjE5OFkFkdHRzY+F4ilWq2ac+h35fN5BYNB3bp1SzMzMzo8PNTLly8tavbFeKlUSk+fPlUsFtPKyor1BiNIwBHcunVLS0tLKhaL+vLLL23mD4IezupHH32ki4sLG7UtyWBKCg99wIDxJdPsRScGBwd1cnJipQZcF0pP5Pmh0GUn91QqpcPDw65x2e+6nj17pkgkou9973uanZ21jtnAocFg0Lo4MDYBOPXi4kLFYlEbGxtWawL85ztHAOsTDO3u7ioUCpnTYIIq3R8CgYD29/d1enqqoaEh3bp1y4QXZJyMVtjY2FA4HNYPfvADLS4u2vOsVqv6H//jf2h/f193797V/Py8YrGY7ty5Y7J4Anw//O2PrWs7FzB35IC+9gJpIGR7L9fiN4V0lXVgQKUrhRdGCnKOjcS/pSsCy8MSksy58EU04clSDjlZFNkBv88mJdr37UXe1vrkuqsXCutdvBdOE27DixAg+3x67gl96aoJJ0qjcDhs2WGn0+kaq0umwb85BFwP3+d6+Lm3fbZeEr/X2fy+373uwuGhGuJ+oZwhM6Y40kuQqSxm9ACSSj9/BgEI8BbPCfiMIMfDV2R1ZCbAYf4LI0wdA/eEOi7OCNmA/5wY+m9LFIHxplLdPxtfUOrvB3vGN+Bkb3DGPLRGls2CMPbKNH8fOJ9eLg7XiNgBu4LdAA73UDFn1AcMdAjx0Dw2oZ/F82o2r7oUc0bYRxQhSlddh71Yx2fJvWfECwSwnzx/Mj44FU8HkInz+XhvgkCgRprPEmiyP0F2zs/Pu7ok0H+Q7Ee6EnRcZ13bufz0pz+1GyDJIu1o9HLMaTQa1ebmpg3vIcWibUA0GjVcj/Su3W7r4OBA4XBYExMTRkwVi0XNzs7q4cOHduPYWOC8f//3f2+FkBQNIhnlgPLzkUjEiumICL0unJtOgZOva1hcXFQ8Hle5XNbBwcGNOZe3wUMcCMbqYrgQLXBAUaB4iMU3CcSowx81m02b8TI4OKiPP/5YH330kXWs9k6Tgj0vjQVaQnUmqYvYla6ckv+MGE6fZXEg+11jY2PqdDra3d21rFKSkb5LS0taXl7W5uamJNnefPDggfWue/Lkid27QCBgZL8kK2qjBsvDkNlsVtJVN4Nisahnz55ZA0tIZHg6WnXwrL0IAiglkUjowYMHdkYgoGldRPCDM/RqqX7X06dPDdrc3Ny0rrjh8GU/LvYeRobOA8At1WrVYCgyfLLjbDarTz75xGo3EMnA7VHlfXp6aoXTVK2TaRKxN5uXo3hp4QQXATeKIxwaGrJAEDUh557MAYdGoIWYoJ/16NEjSVKtVtNvfvMbRaNRa4vFsMRisWgdtrmPQGTJZFJzc3OWyRPkAjVhGxOJhHUeQLl1eHioTqejra0tbW9va3Z21qTy1IChyEUAQBY5OTmpaDSq73//+5JkvSAzmYxxMf/0n/5T+z2KPhkaiAAGvv1bh8UKhYLhzV7DTjFfKpUydQZpopeIwiewKTwmyQHqnaMCqYe35XDRmZZ0Ddmz9+QYWR+Ze2gNA+JFAb1S0lDocpYLg8OI4vtZPtPAuXj5rt9cRLbcOxwh95WfldR1rfw/EQ8OBBK/3W4b1koGEwwGzYghO2U6He/d27Cyl5zvjWQ8D8P33iYTfpfla4329vbs2glaCCx4TkSNYOIDAwPK5XJdajGiUDJGv2/8vcSI0TOvWq1aZbZ05cg8ZOMLhRGlcM8o4MUY4MTYfzxbH6ET3d8k+8tkMmq1Wkbysp985kEBJREr6i6aIPrgkuCHs0zPLYhgCHjq0XCY3FcWZ5YspdVqdQluJJlDk2RdkrnXGHIvmiFY9EWYntPsZ9Fnr1qt2qA5pNT0NPRNWv2Z9fdZkgU57FVvG7ADHkUBnqeHI+gE+5asygsfOP8jIyMmEiG4gKBn/6EaIyBtNBrmJLG7tKm6Lnd6befy8ccfS5L1pUGBRaUt0QQH6+7du9Zl9/z83Ir1iFIGBgYMw/NwGBWuOCv6H2EouMloyokEiZYHBwetgyg/S6oJj9BsNg0rx2ANDg6aeo3NLsmwUsjLfhcFT6ShyFolmWqHnmYcEg8v9GYsbLpyuWwZD5LMTz75RFtbW/r6668VCASsWG1wcFClUknDw8P6Z//sn2loaEgLCwvW+WBxcVGHh4c6ODgww9LLobyNrPfXiOPxRspnk/1CPPB1EJ+ZTMb6iPGa2WxWS0tLGhgY0MTERJeAQ7qs8scgodK6deuW1QI0m00rEh0bG1Mmk7HMo9W67LHEvCIMNHsexRDZZDwe75pbMjo6agV4PGMgGzJnjG8ikdCTJ090fn6ufD6v3d1dxeNxJZPJG0Fk6+vr6nQ6NtgKDghHcnJyYrNeIOGHhoa0vr5uUyOBZrk31KX4eh6cTbvdtjMPJI1xHBwc1OPHjy3DQPSD3BjD7INBHBLtd1L/a8gd0FogcNnWiUJu39g0FAoZpN9v9kch+fb2tg4ODowK8AEy9ougjFHBnF3uC5lcPB7X+Ph4V1a6u7urvb0944xpWcS/h4aGdH5+OQKako9QKKRarWYzbAjOCYjq9bp1wMbuwE8Bu3HesU+UfSCG2t3dNT77n//zf/5H79e1ncvjx49NoeA3VDAYtCgCB5NOp/XRRx8plUppc3NTBwcHNnYTIz40NKRCoaBcLmdGSbqEP6anp61a/Pz83GA1NPPNZtMgtnK5LOkqih0ZGdH09LRS/2uu/MnJiTlAovhWq6Xl5WXbLERkGBQc58XFhZ4/f249yBiT28/yEQuHhCwIg0THX0hjMhCMEBkfuDTRMxuZqv3FxUX9+te/1uvXr825MNKgXC5rdHRUf/u3f2sOHJnp7OysHUQOOOs6zsVzLURjOEJgpn4XKibuxdjYmL7zne8oHA5ra2tLR0dH1mo/kUjo3r171uUVA09/JjoUpFIpJRIJHR8fa21tTefn5yqVShbU8Kx4DbLlo6Mja2uEc+EamYeBxPn8/NyqyRGg5PP5LqGDJOMwcS7z8/M6PT3VmzdvtLy8rKWlJZMn97u2t7fV6XRUqVRUq9WMewoGg6ZmyufzevbsmdWcDA0NaWtrSwcHB4rH45qcnOxy2r6bM9dPNAyky98HBgbMQFIXgyoPNSJZMvseuIv3lGSjvCVZ6QOZMrAUY455PghffIbzrmtvb0+tVkv5fN7qSFDP4VwWFhZ07949VSoV/fa3v9XR0ZHZTHgPsrBarWaTY/mszWbTBtBxbur1ug4ODlStVi14Pz8/17Nnz0yGPTo62tUxPJfLaWhoyGiJWq2m58+f6/z83Cb7IuXudDrWkBXY8eLiwnoNkh3t7e3p4ODg2yf09/b2FAgEzBuywPjC4bBlBdwMCHdSRyAL30NnbGysCxIiVfREPhkKVa0U9lxcXGhoaMiklUAatVrN3qdWq5mOnGvltYjaettUEKV6+AJsut/F6/tqZSJ5DDHwIYesV7ZNVDE1NaXh4WEdHh5qf3/fUtVOp6N8Pm/cEoaLaXbj4+O6deuWpqamjGspFosqlUra2dnR3t5eV6PKXmXbH3KsHHAcot+A34aEG77GO4d8Pq9AIKDd3V1rUsl70dqH+8x1gM/7RoGod4AXwL1x4nwuYAk/VhkVIX23yFDBquHJ4KpoTU+3YM8NekktKql4PK7Z2VkrCr5ujcHbVq802vN/nJV2+7K1C1kS2QeBJQovOEAgKA9JeTEA3B/za4BkQ6GQiYR6W/R7EQnOxkNwoVDIqs83Nze71IHAh51O53fUpezpfvfj/Py83T8mNtLHzBP0pVJJ9XrdYH0+Ow6W+jE4qGq1atm+56B6pc7cJ+nyvPnOBL3CkkQiYUIW7gnPzosveCalUkmnp6fa3NzU5uamSqWS/S57BBTpuvfv2tbyV7/6lUlBmbcOJMFNhVwvl8v64osvLGJjIzAOlnno8Xhcjx49Mi6Em+gLiIiq8PZ0pS2VSmo0GtZPh4I1yMBAIGDkVCwW0/T0tCmoSAHT6XRXdTakeqlU0tramlqty/nmdF69CWeAcfQZgK9roO8PB5UKWgi5Wq2mvb09DQ8P65NPPtHs7Ky+/PJLff755xZlt9tt/epXvzL4B6dEHdIPfvAD/ZN/8k+M16lUKlZhvbKyon/4h3/Q8fGxcS5/6CC+7f8hxIH8vHLvpg5ma2tLoVBI9+/f1+Lioo6OjvSb3/xG9Xrdqpc5NBT0JpNJO8DS1SAwagd8Y9JcLmfiDoanRaOXk/y8k97Z2VGlUrH9srCwoAcPHlhkSpCD86AfFgcf4hpohUAjGAxawRrZtCTNzc3p9u3bKhQKxjX1u6idQDCCI22329rY2LD+VI8ePTL+qdlsamZmxpwmDhpn7oscySzhmzhvFD7SNHVsbEzSJUwH73V6eqrp6WnNzMx0OXIyHVY0GtW9e/eUy+W0urqqTz/9VKlUSj/84Q81OjpqiEOz2bTCWM41DqrfvfiP//E/VqfTsewWdaJ0pSSrVqtWQ7a0tKRwOKwvvvjCoEYCCQbE7e/vm10h65ucnFQ6ndbBwYFWVlasFCIej+vs7MyyiUwmYxw2QTAIBZkLHUbi8bimpqasowr7lEFiGxsbqlar+vTTT/XFF18YTE5QHQwGrTv9dde1nQubCqLIy+R4YET6RGqdTqer+tiT00SNEKFeTswXeCYEGdcBtAUpSzSA8SBCATYKh8OmiPLyWw/hECX4/kf8nCdj+11+UxPtERF4STRZni9I5IBwzTScBDoDVvOfZ3Bw0Eg6iFG6IRMl0X+Mlh8YjLdxLf7af18GQ6Dxtu/f1MF4SThRPRlwb/HuH+KCMK6tVssyEk+mAuOx73gvsjlej9/DafhsACPrMxcUYz7C5YwA22GIvSgGp4XB7VdQIl2JIrzsV+oWZHgok+vgvnplIPfUcxqcV2wAETWfl89EFkF23lsE6RECXr+3dIH77HsMsk8GBwft/6XuDhLelrzr4j2BuOF0O52OOWpaKvm6G/YQgTNZKkEu+4w9iT3wP8di//BMPJ8TDoeNE/eBDveGZICMhyAWFAgbiErP1+B4qfe179d1f/B73/ueQU7VarVL9opBSqfTevjwoeGHwWBQ8/PzunPnjiqVinZ2dhQIBDQ9Pa1YLGYtILw6h1kYRE2BQMBUZbSAIWpkc5ENHRwcKBAImAzU6+q5UaOjo4pELgdjMfNjd3fXCGwfHYLTetVWv8sfZK8akq4MNxXQzWbTlHelUsmujcPJz7GRUqmUDfi6c+eOPQuyNTbG6Oio1tbWuuqEisWizs7OLGoms/POjo3Otfrn1fs9rxD0Sj0Mbr/rhz/8oTqdSynyz372M4v4JRk8AdRHcRufw49twHFzcImcUdacnJyY8olmgwcHBxYx3rt3z3BtoutXr14pk8lYt28I3XK5rJ2dHQ0ODho/4ztEbG9vKxAIWCeF/f19lUol5XI5PXz40GqUfBZ0U7UY0EwqlbI2TJJ09+5dDQ0NWeFeNBq1vl2JRMIKjYGzOUc4DgqUETYAh3EPx8bGDLIhGMpms3Yujo+Pu4h7ZNG0ej88PNQ333xjwoNaraZQKGQ94yRZlfr4+LiOj48NNiVbLJVKyufzfTvo//E//oeCwaDBhnxuzzvTx+vi4rKbczB4OTyNjiDsP84cEyCR6p+fn+vVq1dmQ2n7wrmjJVUmk9G9e/dsbzUaDaVSKRO54EjoVE9JBujCwMCACoWCdnZ2FAqFrF8fncUZA++pCbp3fOuw2MLCgtrttt68eWO1AVK3dC2dTmtiYqILs0+n09aIkpudTCaVSqUMtkJ1gmwuk8mo0WhYGwkiKR/F+UgELubo6MjkeVJ34SIwHjJGiqDowwN0cnJyYuODfcR5U+PocWlvbH0m4IsBiVSZr8HnIvLgoYNVs+ERP4yOjmpubs4w1lAopL29PeXzeTUaDTvMzBIhk/ERug8gvFME++79nv+7zyKJnm7inFF1bWxsaGVl5XfgACqhgVCp6Oe5YxxxgL3XSUROhMleu7i4sBYvsVjM+rQRofIVCFy2BQmFQqZQBE/n+7xmNBq1GhC4i3A4bER7JpPR+Pi4tTjx73WTPUjWSnQPRxcOh5XL5ZTL5fTq1Sutra0ZRg8n6Dkh9mksFjO4OBKJGE+DEcWRUINGJk4AODExoUjkcqwEQh3OCvwLw/r4Pc9XIMrw4gEy9lAoZP21PHTH0K5+1vLysmW1KNHIDryoSZIJknC2ZKUe5SGz8m2dgPOQihMQeS4RwQgKO6A1RjsDdbbbbZsXwz313AxqtqGhIc3MzFiNFsMYubcIFryE+Trr2s4Fj0u66duREJ3E43EzTtzkQqGgFy9eWKfUcDhsnrRcLpsskbnXPsLn5nKoiADIlGgKJ10VSQUCASOwUbcEg0FLnYk0ME7tdlujo6O2kT2OiWGmQvgmMkaPq+JQ+GLDkclxYHv5il6oynNapMF8+VGqCCkYCe0jdyIoLzDwPJp3HL3XguPgoJH+A6W8bQ/1uyqVilqtyzYli4uLti/C4bCpA2keSBdduCw/gkC6gl6popeuqqfhbGjYiEqM6BAYEXUNxoaAi+AAKTykKjCDn7Hum1ISJCDrf/XqlYLBoDUNHBwc1K1bt27koJFAMz8EPsPXzySTSS0uLioSiSiTyWhgYMDqOQgkqSFpNptKJpMaGxuz4smLi4uufmXs9cHBQXMM9Xpd1WpVb968MWUkNThbW1s6OzszbovRyqenp8rlcpJk81wo+PXt7Pf3941T49lgFDudy35Z/d5DOGBgMYIY+EsIcmwGDXiZoko5BWISsl8KTTmH2AqUYX6l02njX7ifXnJMRoddQbGI5DkYvBzxTk9GlKEoS0ulksGnlUrFzgrCl2w2++1nLjw8Dhjkp8eoMcLcGOlS/sjQHtrG+Hb41WrVKlfj8XgXZo0zK5VKNkea3wGLZCPjmdvttkUM8/PzevTokcrlsqWauVzOsiA4C3DPXC6n0dHRLiOLTp8DeRPn4n8XjJTvSTKoypP+3ph7484Bz2az1sgR6SGbkupe7tH+/r52dnYs0oKY5fvwOz6yJ+PodQweI2YfINP12aN/rZsaRknWw6tcLptSaHFxUbOzs9YN2qsTmSVO9TSwBng1GTMR4fT0tDKZjEqlkpGdNP3jM5ycnCifz+vi4sIIz+PjYxtfXK1WTX2GFBTukZEP0WjUphGSDSwsLGh6elpHR0f67LPP7PURdty+fftGajH6au3u7trEWPYR0Si1XhTVeiUUdVhkz/V63eDXUqmkN2/eWNU9GRnZCg6qWCyac1lZWVE4HNaf/umfKpfLqdFo6OXLlybBBgbsdC6nhz548KCryWU+n1ehULBxwMiEDw4OlMlkrIYLBeTg4KBu377ddznB3NycBdOSzDYRpFEOQLCHrQHeo5cigRz3kH5dfF64qOHhYc3Ozna1kEGsgkS53W5bcOWdHHwuAVI6ndbc3JyCwaC2tra0urpqDvjk5ETPnz+3GU9ktZw5n20SrF9nXdu5YITB7CiM8oYQrE+6imyJYDCmREBEbZK6OBrapLNZvDKltwrWVwP7B8CGBlo7Pz+3VBHniBzVY/Jgkd7wQ3D19gl619WbpfR+T+ruPeS//IIXopBqbGysqwsv97jdvixAA9ahGSIYO8+BbNArcnzk03u9/pr4E27MY8M+OyPquYlz8ffeE7RUc6O+oV8Y18JMGuotKBwbGRkxVRsO1dcf+I6yXDsFfj4i57lxHfwpyVQ90pWTBe4guyGDInPx/dB4bwQwNxnRK10R+ohxCPTgKHmmQLh8Dl/4y/eBHKWr9vs+4wWKhvsEukalB7RKVhOLxUxYgjiD6+VnCYBAOZB/9/Z783AsQS/X1Nu+6F0WgR+IAFCW/0Kk0Wq1usoXvCyegAwb6fsx4uSBUYEVeUYgE8iNkQfTrNNzxFwPz6hWqxmy09txgzOPHN93YODc8Ryv65yv7VyIdKenpzUwMKDz83NTIbGpmCHNQaTieX9/3yKJUChk0TJe8uLiQq9fv1Y4HLZIMRqN2gjZjY0NFQoFy1y8sgsSlM1IKwMqSqvVqoaHhzU2Nmbk2s7Ojm3kaDRqFf3c2JGREY2Njaler+unP/2p1tfXNT09rYWFhb4PN5kcB+BtzoPr9//vifxgMKjj42P9X//X/6VwOKwf/ehH+pu/+ZsurTvOhZkdhUJB//W//ldtbm7axqRYDojCV0T3Gg2ulQ3mlUQcDga9EXGxegOK3uztXRbpOC3dwd3Pzs705Zdf6tWrV124PA6mVCqpVqspm81aYeXCwoLi8biePXumr776yhwRTgYxAHsYPubo6EiHh4emYAI+jUajqlQqVltEcRoc0MTEhJLJpBqNhjY3N23swfz8vD33UOhypgaR+eTkpM7Pz/X8+XPLuKi96XctLS1ZsFYqlTQ6OmpCEMbXwgccHx9rdXVV5+fn1l5HktVueFIbwQN7l2dMXQ735vDwUNlsVjMzM+a4sBu3b9/W2tqadTjP5XLKZrOWNZ2cnOjVq1eKRCL667/+axsyiBP2WQRcDw4Obmdzc1PLy8t9w7NwLrdv31bqfw0kY2EDKZUgGIhELrte00ng4OBAAwMDVkD6zTff6Msvv9Tw8LCmp6e7inaB1+LxuJ48eaJMJmPdjhlUBkKBIIQga3d3V6enpyarr1ar+vzzzy1zpZsE55kWP3SnPj09Nam8D9SgIa6zrr1TechEGeCLvaogH21gfIj0KPbDoHnDw4wCmixS8OPVIdxYT8ISEREhsbEp6iSSYIORkuOcPNaNYcXpSTLlER0B+q2Q9hEdqzcDwGj5CLCXCKe5HPeM1iEYQF6PHmHFYtHad6TTaRvmtLOzY88Fw+pluWQivVHK2/gYH+H0Pnv/er2f/10WvICPFokQKQCEa+LeAFdQR0KER7EjEnWyHfafbynjIb2LiwvjeXpbi/BsJHV1pa7X6wbbYGgp0AV28vOLcMhEp2QM0s1n4sB7IATxsB3P3vOcGCovq8WQ+RZERMLcDxZnif15enqqQCBg5DoEM5AkClEq8nlPL24BNkdUQN+//f19ywD88tE4UXu/hP7x8XHXWfPiEN7L90DDLnnVFZ8pmUwaPEsAyXXyen4/wG1xj5hIOTw83JWh8fywmXxuWl4h6SYb5nkRnNI7Elm4DyKpCfzWORceHEOOksmk/uRP/kTNZlPPnz+39gR7e3sGg7TbbcViMc3Pz1ubBDIS7/VJ5y4uLrS+vq58Pm9tvoEZvKS2Xq9b+wVJXZ1OvTiAw9FqtQzzpRIVWSiELkQbhvLVq1c6Pz/X9va28UOo3fpZRO1vi5p4gEiOvTLMK6Aajcvpesz4KBaLJo8ku5mamlIqlVI+n9erV6+MKwLqIBrv5UL8tXGfe5UqXCvZjK+F4Pek33WgOJibQDoHBwd2H4lWITW53pmZGS0sLNjQsLOzM01PT9uegE+jMK1SqWh8fNyMU7PZ1ObmpimovEqRQw10AbbNvaFHFjBPMBg0Qpx9TMHnwcFBl4BgYWFBw8PDOjg4sNHUSMJpwYGU/ybO5be//a2kSyeIgnNzc1NDQ0P64IMPlEwmtbKyYjNeIKWJoPncQFS+Qhxj71WRXqzALCQUSGQA7XZbq6ur2tzc7JJb070APm14eNgKp1+/fm1lBz7YoCTh8PDQPmM4HO6qg5qZmek7c2FfHxwcmLODl8hms+bsUCcy6gLODQVZs9m0LK1arWpmZqarHqaX1A+FQpYd+qxcunRwcNK1Ws0gNERKCADoG8frwnsj8uBe+qaY09PTBq+zBz18/sfWOzuXk5MTVSoVjY2N6cMPP1Sz2bRU9vj4WIVCwaI5ohSaKsILUEXqZZzS5WYknSNV9z21MCLn5+fa3d1Vo9HQ2NiYHV6yI4Y0MZO83W4bvo2WPJ1O20AzsiB6RlE5e35+bjLrWq1mFb/9rD9U8c7h4DP4DAKHJ8laeOdyOSUSCZVKJX366aeSrorfHj16pNnZWa2ururzzz83lRRqLs9J9BLtbDx/aHsVavwfCpLew+3lyT5b8RlPP6tUKkm6kmIODQ2ZYon3mJyc1OPHjw0+rdVqmpmZsUFnweBl5fzW1pYKhYISiYSy2azBXXSRAOKBWyQIgXPknhJhw5HkcjnL1NvttkWn8C50rzg4ODA5ORBTOp02qTjiA585Hh0dmVPqd33zzTcKhS6HZ/kW+jiXeDyu4+NjvXr1SgMDA5qfn7f+Y0hXIewZ0sVZj8fjWlhYMD5FutrzoVDIRAKo4ZAHN5tNff755+bkqBEicLxz547VawELra2tGUk9NjbWFYzRyQJpOk4d0cT4+Hjf0Cz7HXkvdShwKDiCWCxmPHGr1bKeYoiNuMflclmpVMquCZ4DtShZVyBwqUakt5ifqYL6r1QqqdPpGBxIDzOydTpTE5TRyxDIlcCA85RKpazvI2fC1xdeZ13buZRKJcPkSceItJFYwgnQegRjQ/rM/Av+JOI5OTkx74jiie/zQH1UzPdIrX1FLkaabgEUYfHgiXRpQ01NA9fKz4GtJxIJtVotiwD6dS78Xm+FsCfT/M96KMn/nJcW46D9fV5fX9fp6anxTc1m056NrxHwRKmk38lQ/pjooPd33gZ3+YzIZzj9LCAVuDWiargcuITV1VU72DhSoFPgUOSjiDsIcCKRiD1nvy+kq8FPvsMyQcn5+blisZjxEj7LoQaDoMafGQwFz5VAyhsY3y+L6Zn9LqSoGF5fJ0JkKskKPXO5XFenYqJjRDBA0fAcEMm+1ojgjJoOYEq4BfbQ8PCwUqmUyXapR/HKMYIsHFMsFjPOK5lMGuyIHJjnTAsU+KR+nQtBAsYZaT/P3Gfy/kx7WJX9xvwfODQPUXH/POQKpMXMGzjj8/NzHRwcaH9/35yzJAsIJBkqxOuRGYGEeOiaOTzIjsPhcNe+fZd7d23nsry8rGAwqOnpad25c8eqefnACwsLKpfLyufzXYYbxcjp6andDNpHz8zMaHZ21tKzVqul+/fva3p62orMJL3V+BJVUjdA+xI/x4CNNzh4OagHvBPCcGpqqktKzRcDeaTLdJcW7jMzM31Hjl5F55U1vY6Tf7Op+Nzg8NLVLHQgCe+gdnZ2jG+q1WoaGRnR7du3rTp/fX39d9pl4HSJFt/Gs3inTrDg21L0ihM4ULwPhqffRV8633gvkUhYNNhoNFQoFPTy5Uv7HQKXwcFB7ezs6IsvvrCMYmBgwGAYnsfg4ODvjOgFGmXwEsWNW1tbZnADgcsGrIxk4EASNdZqNW1vb9ue5nvJZNKyc6J/hkRhtH2XZcZM9Ls+/PBDdTodU1wODg5qfn7epNQbGxuSpNu3bysej+vu3bsaGBjQmzdvtLu7q0qlYlJvshoGnJFlh8Nhq1/L5/NaXl62+0PxKaolgsdQKKRsNquFhQU9fvzYSGeI6efPn9uzj0QiGh8fVzwe76o4J2vinFDzMjAwoIWFBRMkEZj1swiYp6enlcvltLKyouXlZYOygdjhM1jsfRARSUYV4BjIeICjCSyA2JaXl1WtVjU7O2td43d3dxUOh/XNN99obW1Nc3NzevjwoQVekmygIopZSVbYS6DtM7/Dw0NtbW1pamrKYF0/PPBd1jsR+pC+wDZAKxCFXkYINojHps9Xb4tuZixALhNtEnFKMghGuirE6x0ixsPp/T/UO9JVV2E+BxDO2+Cg3swIcvUmh5vlIxrpKt32qzdC8DJcnwX0kuYQx9w/Ikqfdv8hiI73uE6E/PuyFi9F5nr/0PtdZ3l5NPAURbAMpvJNKoE7ibo4GG8zLBg6SZaxsBCpYECkq3ZC/J0/vbSWPcZn5xn5zgLsNZRT1EpIMrkrPCWB2k04F6rkGdzlX5tMjqCMe+CfMZmjtwUePvX3gD2B40YMgDOWZHuVew5ZD5zO62FTvAKMv/v7S4aHApWs0vcfIxDrZxH9S1f7xBc5Yu+4bp+V+Gvk97knZIEEoOxrAmjOu+dbEJcQAJFF4zxRIPJc+T+eCbWBHrXx6Igkcz79rms7l7/4i7+w9J4ZBahdpqamJMlqUc7Pz03tdXh4qEql0vUw7t27p3Q6rf39fa2vr5uSpN1u64svvtDz589tg46MjOj+/fvGMSBvnJmZMYKxWq1qbm5On3zyiZrNpkWJ4+PjymazNgJAkqampiziheAi5fbYLHijP0wo2vpZXmHCZuMws7mAH6TuppoYVGqBiNB8c75eB4UzOT4+1vLysvL5vFXleoWLdzYYb68g86m+j8j8a2Bkeh0Jn/GmSjHpsv2QdJniFwoFZbNZzc/Pq9lsamVlRbu7u2q1WhbpUaWNrHZgYEDf+973rDNEvV63A+4Vb2TZrGAwqKWlJRODbG9vKxwO64MPPjAOh5YxqHPm5+cVjUZ1eHio3d1dDQwM6NatW4bXUxkP/r6xsWEZGO2HHj16ZM6p3W4bT3mTw07vs+3tbesRNTc3p2g0ao0jOafNZlPPnj0zFRPcJvwVGH29XtfR0VFXvQWvRxPRYPCy0y9oB/BkuVxWp9OxIuBqtaqf/OQnGhkZ0dOnTzU7O2sOlszaOya6S1CfhoQW1ZQkI88Dgctx1ZOTk33vw5WVFYVCIYOfksmkfvzjHxtXt7W1pZGREWsxNTY2ZsF3q3U5EvrJkyf289vb25qamtLjx491dnZmI6QZsYDRp6zA0w8XFxc2Ip5M/Pz8XF9++aVisZiePHliIgKyVLoir6+va2trS/Pz89b14ejoSM1mU0tLS5qZmTE0gwCbUQjvUkj+Tr3Fms2m1tfXbehSu902fgV8mf45cC8MR4rFYqbWyWazmpubs8l+vvCJVghAAb3EFqk3xB/zniORiBYXFw12o4gpnU7bgZZkDwP5Kgoe2mcfHx8rm80aJNArM+x39fIsXp3lYS0PI/F7nrsgYvT9sngN7xxYjUZDpVLJeAjfKdZ/9b4G//bOhN/zHIp3HG97Ta8ku0nUnU6n1W63zaCk02mrJaE/nM86MPoY5PHxcVMKcd8QBhD18dl4zoFAwFqb04+uWq3agKtoNKqDgwNT4wE90I4DeCgcDne1FUKdRtNQFIk4bGAXIn0qv31U2c/iPOHIUqmUZQG+azPGnImks7Oz5gCSyWTXMyabJwrmfhNlU6sCTwvyAbaPKALnsra2pkwmo+9///saGxszYQbP2DsN/u/i4sLaJpFdeLEJiAqNXvvdh8Vi0URB9XpdIyMjmp2dtRob9iAOkYaaZGSIUKghqVarWlpa0uLioqrVqkGm4+Pj1rGA7ITmoR56Q0XL/WOCJQInAkPgVUafEFBLl610vAgF8QqtqFBn+iLt68KK13YuBwcHtpnGx8etQE26xPXAOr///e/bm7daLeuE7JsroviSrmZl8GEnJycNL5RkpDWzID744IMujubu3bt6+PChksmkFf3AxTCy16eQm5ubpgyieBDDQoO9UChkKhDwb3DxfpcvTMQok9r7VLcXanqbmAFyjdoMlifovYHnc3pCzkOAvb/PAfGOxEN5vdLj3mzFQwJeNnkTQt/X0gQCl52Enz9/boeWgkQwa7rq1mo1FYtFUyyFw2Ej7Rm5i6GSLjk24CNEITz3xcVFzczMdAkBcrmc5ubmrFttKHTZ4K9arVorEmpjMOLsAQyIP8y1Wk2RSMQQAAw2JQA3gRbhSMmYEdmcnZ2pUCjo9PTUgkSKpIm8x8bGVC6XjYskWpZkWXU+nzdUwzdJvLi40O7uriR1TUdELIPBQ0kKT0W5AdAN+wdlViqV0ujoqMLhq1ZUwGEUU/PeR0dHxgX3e45HR0cVDF72Kdza2lIikTD+kYaZkkxJ54NGFHD0uyPQQ6nYbDZNoEI9H07bdwYg44VDwmaROT548MCkywTuCDPgoG/fvq3BwcvJntQNYo88/8xnQFmLg/nWM5fd3V0FApettqenp1UsFvX69euuVhuLi4v68Y9/rLOzM21ubhqhHAhc9uOZnJw0UozDTMrIvxcWFvTo0SMTAKAYOT4+1uLiohYXF5XP57W/v6+Liwt98sknunXrlnZ2dvTy5UvDFqPRqJ49e6bXr18rFotZqvfq1StrvAn2DbwH/tluXw2UwhjcNGoE08doESFKMmfRS4pLV07AOxnfHfdt/A0HkefSm614jqY30yFLRBQATMf7eEfTy4OxwO1xRL2FoP0sP+cEeIm6j4WFBU1NTRm+Ts1Fu93WL37xC62urlqtUywW0507d5RMJrW8vKydnR3LWoFbcSBku3zOu3fvamlpSZubm/ov/+W/6PT0VPfu3bOhUHQ7fvnypfU+o4U5LYqAGlOplKamptTpdAyu4ucjkYhKpZIGBgY0OTmpWCymtbU129/9LoyNdy4EdVtbWzbemTNJa5zh4WFNTk4awY5Dh2/AIK6vr5ujx7kA925uburk5ER37twx45ZMJtVutw22RTgTjUYNusS5+ayIGo5edSMwbKPRsLHkPqgCyurXuUxMTEiSdbumAzEqv4GBAZVKJe3t7SkSiZjj47yQsZ6enppTRwRF8C1Jr1690s7Ojok44D4GBgZ0eHiow8NDk3HD/UmXWcjU1JROT0/1xRdfqFKpaGlpSUtLS4pEIjYs7sMPP9StW7dMFu+Dyl6lKjVKBP3pdPrbdy4cam/kpCslBG8YiUS6jLE3lm8jrr3R4mdInTkAnjB8m3KsN9L2WLXnFHgfItLfBwtJvyujvenycFPv//Vewx97jT/2cN9GsPe+/x97n7dBZO+6bsKx/LHXhVPyjo49xx7i++wfT/76iJLv+f3dG71JsoDAE/W9vBzv9/u+2Kdc89uu3V9Xb8Z4E8Wd/6ySuvY2r+37Ur0NHvX/37t4vbftM/+avF6vjejddz6A4vfeZoN6nyG/A6Htf+9tAdx1l3923u75z3Sde9QLH/u9wefxz8Gv3t/xr+cJeewc96IX/fCCprfZv97PzZcvkv1jK9C5aUj5fr1f79f79X69Xz3r5rra9+v9er/er/fr/epZ753L+/V+vV/v1/v1ra/3zuX9er/er/fr/frW13vn8n69X+/X+/V+fevrvXN5v96v9+v9er++9fXeubxf79f79X69X9/6eu9c3q/36/16v96vb329dy7v1/v1fr1f79e3vt47l/fr/Xq/3q/361tf753L+/V+vV/v1/v1ra/3zuX9er/er/fr/frW13vn8n69X+/X+/V+fevr2l2Rx8bGrLd/IpGw+S20dGc4Dd2G6cjJkCE/t4GZzLlcThMTEzZs5/z83IboJBIJjY2NSZKOj49t4A0jlRmuRHfPaDRqLaUZ++k7eTJXe2dnx1r5X1xcaHBwULOzsxoeHrYOofV6XdVq1cakMmuCFvkvXrx45xvNjJrejqjBYFCxWEzRaNSGUflZL3RHpaU7k/AYuMR0TGZg02WWlvFMDeR5DQ4O2hRAZtW0220btEVH1k6nYyOimdfhu876Dr10YuUe0eZckrXv9z9fLpff+f797d/+rTqdy4l5p6enunXrln70ox8pFAppeXlZpVJJ4+Pjmp6etmfIcDWGV/mx2ZJUKpVUKBQ0MjJi0yOr1apOTk50fHysQqEgSRoeHlYkErFJiycnJ8rn8+p0Ovrggw80NTWl5eVl/eY3v9HAwIA+/PBDpVIpbW1taXd3V4lEQnNzcwoGg3r16pUNCtvd3VU8HtfHH3+sVCplk1BZoVBIyWTSWtDv7++r3W7r//6//+93vn+S9M//+T9Xp9NRpVLR8fGxTTYcHh7Ww4cPNTo6qp/+9Kf6b//tv2l4eFiPHj3S0NCQ1tfXtbe3p+npaT1+/FiJREJLS0tKJBL6yU9+or/7u79TKpXSRx99pHQ6rcePH2t2dlZ///d/r3/37/6dAoGAPvnkE2WzWZVKJZuvwxTQw8NDHR8fK5PJaHZ21rqiS9Lh4aEKhYL9PPN4hoeHdXBwYBNI6R6MjZientYnn3yiaDSqo6Mjmwm1v7+vTqej//Jf/ss7379/82/+jZrNpj799FM9e/bMZt5gjxisxXlmGNv29rYODw81OTmpx48fq9PpaGVlRUdHR7Y/GfseCAQ0MTGhVCqlk5MTVSoVBQIBJRIJRaNRm/USi8U0PT1t496ly5lb6+vrajQaNu54ZmbGJgUzOvmv/uqvdPfuXX3zzTf62c9+pkgkYjOJSqWSzSPa3t5WMBjUgwcPlM1mNTo6qrGxMQWDQf2rf/Wv/uj9urZzYWHAfFvy3mmEkrpaYktXLcN7mzD3Tlrkdfgd/vS///saOft25P46/bXwbwaf+XkL/F5vq3V/nTdpI//7rru37X7velu78Le1Ne8dF/C25e/x2z7L7xuJ8LZnzZ+9Ler//1i+tb6fWcN780x7B6K9bd/5fcWfzMzobdvu19ta0eNI/X31M2z8ffE/41v1+3vrR0H0vv9N5gnx/r3D4Qhems2m3TvfWr13girX5H/ejy/wrfv993hNhqbxev4eYSR/3770Z/mPNXPvfe7+/fttBO8/1+9rq997DvwoEf/8/IgG//n8XukdAcHvMfbh940z+X22wj+78/NzXVxc2PNi+KC3oVwDn/VtAwr/0Lq2c2FmSiqV0vj4eNe0QQ7d0dGRarWaDTkaGBiwC240GiqXy3azmVV+cHDQNWbTj1nd39+XdDUoirGefu48D42pboyUHRgYUDweVzwe19nZmYrFoi4uLpRIJBSLxTQwMGADpdgwHHaG/1xcXGhvb08nJyddkW8/q3folj+4HGgenJ83wiZiRC6ZGZtDutxwzNw+OzuzbKt3dgaZIzNv2JDNZlORSMSyO56Zz6DYYAwUOj8/V71eVygUsgmMfsqi/2y9BqeflUql1Ol0NDw8rFarpUQiYVMbM5mMksmkDg8P9emnn9pAsKGhIRWLRRs1TObJfmWaJJMYg8GgstmsRYl+4Bmfl59jCuOLFy/09ddf2zWGQiEbZkfEOTAwYIPHfAY0OzuraDSq8fFxm/YYDod1cXFhEwLJQMPhsHK5XF/3jsXk2LOzM3vd/f19G90bj8dVrVa1sLCgTqfT9fMYtHA4rGazqeXlZbuHc3NzCgQCKhQKqtVqGhwc1Onpqer1uh48eKBwOKyFhQWl02nNzMxY9vT69WvV63UbC51Kpew5M/KXIW9MemQS6+npaZeBjEajXQ670Whob29Pw8PDFnGn0+kb3cPXr1+r2Wxqe3tb5XLZ0A8/e4Ux161WyyZMSpeDvOLxuJ1nBtKRPYfDYRsuFo1GbUjaxMRE1+ybmZkZpdNpG+3sERoGgnH+sVkMgUskEpKkn//85/r0009VLBa1t7enYDBoA87S6bSNkOc1Dg8PdX5+rq2tLTvX/8f/8X/80ft1befCQ4vH4xodHZX0u5FUs9lUqVSyg0KaxQxrpt7hGOr1uk1JJKIIBC4nIdbrdR0fH3dF4Rx0Ut9e51IulzU4OKjR0VENDQ0pk8lodHTUIIWLiwtzLMlkUtlsVo1GQ1tbWzo7OzPH5sezVioVnZycGETW72KT+WFQGFtG+PZmAURazCfHGZ6enurs7EzS1VAkpvQxc91PbeR1Ge3sDyFOg03tRxL3OhdJBpWRykciEcXjcRvNyyx2nhmb/6aDrmKxmH3eQCBgBiwajRpMsr29ra+//lq5XE63bt2ysbCFQkFDQ0NKJpOSLid5AmVcXFx0wVwfffSRwRl+Sio/d3JyopGREU1PT0uSXr58qe3tbc3NzenBgwdqt9va39/X+fm5crmcTRes1+t2n5mImUqlugbgpVIpC4aAiQ8PD1Wv1zU0NGRTXPtdnD8iVYI76XIE8vDwsDKZjCYmJnR2dqbt7W0bsQskxVjfjY0NHR0dKRaLaXJyUvV63WA7oNeLiwstWsdevAABAABJREFULCwoGo1qamrKgr14PK6trS2tr6/bLHqCwUQiYcETQcHg4KBisZiy2ayCwaB2d3cNQmSCa++QQQx3vV7X9PS0crlcV7bVz9rY2FC73VahUDD42p9lnEssFtPp6anK5bLOz89tdPbQ0JAFirFYzM7k/v6+IpGIUqmUotGoOSzsVCAQsEBydnZWd+/eVblc1tdff23PxweggUBAZ2dnZluOj48lXdnYr776Snt7e5KubDh25P79+4rH45KuBitWKhWjCkql0rXv37WdC3Osa7Watra2ujwhhgzjC+bNhyRS6p2i5rFVDtjw8LBCoZAKhYJxIxh8ommMLlGAT6nb7bbOzs4UDocN06xWqzo9PdXFxYW91vHxsW22k5MTnZ+fm+ElZeUANhoNy2Zuuryj7IUTfbrZCyt43qN3omGnczneFSfA97g3vZmDn1LH65Eqe+iG9/TXTXbC8yTr5P/eBr30wpr9LIIQ/5kwesz1hj+Lx+NdeDjGBg7FT5FMJpPGHRIBM4e9Xq8rGAzarPRqtWo8yNTUlEKhkEqlktrttuLxuBqNRlc0i9PHQfFscHpk2jjnwcFBjYyMKBQKmZEtFotqNBrGXd0UegwEAhobG1MsFlOhUNDx8bHNgCdiZr47DiIWi1kwh9Fib3pnR1ZTq9Xss3Iuz8/PFY1GzUmxXyXp5OREtVpN5+fn9trMhq/VaqpUKmq1Wpa5MCY4FAopl8vZKGbObTAYND5pcHBQjUZDlUpF1WpVxWKx7z1YLBbNbuVyOTUaDZ2cnFjAK8mur16vd03EbTQaCofDmpiYUCgUUrlc1vHxsdlGb8vOz891dnamVCqlO3fuqNls2ujsZDKpkZERVSoVFYtFnZ+fK51Oa2hoyBwWgczp6anxjeFwWOPj45Zh4mT5PCMjIxYo9kK9BDbeBl1nXdu5kK7m83m9ePFC2WxWd+7cMXiLqBgc+ujoyGZEAz8A+/gomE2Bg5iYmFA6ndazZ8+0srJiJBlQGRAOG9Vjkbx3pVIxp1atVlWr1VQoFIwYl2TErd9oENwe9yyXyzo7O9PExIRmZmb6Pty9OD/RFov74jcjxhPjWKlUDJpijC+O4/j42D4/zoXXZyN5op3lnY4fixoOh22TEz0SLBAtElEdHR2ZM/Kv76M68Np+F1G3516Ojo4UiUTUarUUi8UUj8f1ySef2P4DWiHQODg4UKvVMkHE1NSUZmZm1Gq1ND4+bk6nXq8bqT84OKhbt24plUrp8PBQxWJR2WxWT548sWeTyWTUaDR0fHxsM9zZp8lkUqenp+boeO/19XW9ePFC0WhU8/PzZsCTyaQGBgaUzWZVr9e1ublp0T1Reb+L53r37l09ePBAr1+/tsyIjL7ZbJrRwnCOjY1pbGzMjCIOAIcHlAzsmM/nVa/XTZTDHiGIIQvkDOTzeVWrVcXjcZXLZQ0NDWlqakrRaFSlUknr6+vKZrNKJpMKh8M6PDxUqVTS1NSUZajYEaDfoaEhpdNpBYNBnZycqFqt6s2bN/r666/VbDb1r//1v37n+/fmzRuFQiFNT09rdnZW5XJZa2trarVaJvoA0mu3212CmKOjIy0tLenhw4fqdDr6+c9/roODA4NtPXd4dHSkYrGoBw8e6K/+6q9Uq9X0xRdfWKZXKpVUq9W0vb1tQVU6nVYmk1EikTAUplwum50bHBzU/fv3TRAVi8UMjRkcHNT8/LyGh4dVq9XMnl9cXCgYDCqdTmt8fNxswnURiHeCxbzBIlOBT8GocABIWXEqeEIgJzIIb9TYfP61OBC9hBhG1BOinljEoHFtfB/jjVHlfSRZduQhHR9t3+Rwc/B6yV//59uWJ+Z6BQuSuq7VZ0D+3vwhUpvX4md6icBeEYXPnDzEx8/7jInv9Rspvm3518Ko+T3QC6HyPTgD4BOUbUTr7BmvNPSZNfsNx84aGBhQLBZTrVbrIo/9fvVnhUjS814ssiXgMzIHgp5egv1dl792zhhw6sDAgAVwZGDs2aGhIYNb/DPwWa93Ntw/D12DZJDNESTxDDjrfFYMGzaH7NzzG/49PDnOswSJ4PrINHoDrOuu8/NzQzRYHnaGLyNAhZdrNBr2/zx7/s+fV4/GeDQBNS6f24sEPNkeCAQsg0qlUhZsnp+fKxKJ2Fnx54XX4b1Bfsh2QIk8XH9dG3ht5wLmjcyv2WxaFIMh85hpPp/v2gw4DUiqdDqt/f19bW9vdzmU7e1tRSIRtdttw7VZx8fHdrMPDg4UCoVM6gy8wMPiAXIzJyYmJMlwyEgkYtHY0NCQQqGQpbNeTcF7ctP7zVwWFhbUbrdVLBZVrVa7jPPbFt8nzWcDeDiCA8O//eEC+wXm4GCwgThwvQbOO4NeI9nruLwMvDerQRHksyVvlN91kTkTLKTTac3Pz5u8OhQKaXNzUysrK4pGo5qYmNDQ0JBJNXO5nGZnZ+0zcxCHhoYsmsYZ8X6Tk5Nqt9s6PDxUPp83p1Sv1/Xq1SvLKBOJRJfSKplM2n0D1tnb2zNorNVqaWxsTH/5l3/Z5RCRgOKMOGOnp6caGBiwz9nvmpubU6fT0erqqr755htFIhHNz893Pf/d3V3LHm7fvq3h4WHlcjmlUik1Gg3V63Ujy+FMO52O4vG4lpaWNDw8bPLm09NTVatV429OT0917949pVIpDQ4OKpfLmbiB1+X8vXnzxkoA7t69K+lSlsz+5PcQeOzt7ZltIOvH+dy/f1/ZbNaym34XDjKfz1smynn0Yodms6mRkRHdunVLAwMD2tvbs2zjJz/5iTqdjpHkQKCpVEq5XE4DAwOWzayvr+vf//t/r1arpWq1qmQyqfHxcc3Nzen8/NwgLBAl6bJkJJlM6i/+4i8UCAT0xRdf6NmzZ5ZB1+t1HR4eGi94dnam4eFhDQ4Oanh4WFtbW8rn8xoeHtb4+Lg5fp41JSDXWe+kFpNkD6hSqZhiAm8JdtfpdHR8fGyYX28EC5l5cHBgDwkMH6IskUgYRsiGY2O0Wi2dnJwoGAza+xEpeO+O8gkCTZJxLZFIxIQFsVjMnBBKk14JIQa5X+eSSCTsvvjIvpd34e+9EtXeLx8Vv+2aEAFwr4ia/Xvy+bivvdwI7+H5Ha6Pa8Dp+WvyfydSe5eI522LaNeLOsbGxowLJEqjbgW14vDwsEWQ/nP33jPvSOEgRkdH1Wg0rPYKo3hxcaFisShJXXwEr+udAAbv5OTEDvfFxYXGxsY0Pz8v6bLuB/EINRnVarXrEAO33YRzwQlubm5qbW1Nk5OTmpqa6lJ1gjqgzkLBlUgkjPdieUQCGCqVSml6elrpdFqFQkEbGxsKBAIGTc/MzEi6UjgSUcPVlEolEwZBxmezWZ2cnOjg4EDNZtOyLDIxAigCQbJEjPydO3c0ODhogUa/mTTnH36ITNajBJIsgMlkMkbu8+zX19cldUuUCRzYq+ynSqWir776ytAb9nMymTT1KVwinx07ODc3p6GhIR0cHBhHjjM8PT01Xu309NRg9VarpXK5rEKhoGw2q9nZWYPDCcA88vLH1rWdCxuL4pxGo2FSTYxLpVJRrVazlCoej5uMEPVXMBjU/v6+FcNlMpku5ZSXGmOQuYkoLvj5YDBomcvp6amRt1I33u/JclJjNiGcEdgskRgHe25urouY63chuX5b9uPhK3/9PFR4D+4V1x8Ohy2i73WqwAJcM86G++cJPd4XA8k9ZzP5+4GB9+oYIjciMe8oyWpuKuXO5XLqdDoqFov22Q4ODgxaIeABniL4INr0/B7RGJEy+wgyFcl6Lpcz+AritdFoKBqNKpFIWObiHah/xlxnq9XS7OxsF8w6Pz+v0dFRU4QRAGBcRkdH1W63TYF3cXGhzc3Nvu+fJG1ubtr14XDB1znDExMTXRE+GPze3p49ZyCzeDxuRjEUCmlvb894qVgsppOTE1NMxWIxC+gw/MBfFHVGo1EjyqVLWzM0NGT3HcFQOp227HB9fV3B4GUhcjKZNIdzcXFhikrQgo2NDTOm/Sz2+uLiomZmZqzQFqeD40OpOjExoZGREW1ubur4+NggVH/+vcHf2dkxWbg/wzigTqejcrmsjY2Nrn3M63h4k3s8MTGhp0+fWvbDXhwbG9Pm5qZev34tSfY+3EtJdr7I+rwK9Trr2s4FaIj0aGBgQCMjI3aIgHwODw81MDCg8fFxDQ8Pa2xsTIlEQkdHRwaVbW9vq91uK51OW+U/X0AtGA02oCSLdDxPAxEpXR4Ub6ClK8IaSIl6GA/rIAxAIcP3hoeHtbi4qImJCeXzeTuc/azd3V1J3RyKh5+IqMBrvTOUZORoq9WyKCiRSCiZTJrm3TsYnw16rBvoEKfr1XBEKbw3+LTH+j0/wf8RVVH3ws8BPYXDl90EUBr1s4CoCA4ajYZ2d3e7IuBSqWRk6snJiaQrB4mUlcOPYuvk5ETDw8OamJjQwMCAOZFUKmU1BpOTk2o2m9rY2NDm5qYRzuFwWDs7OxZw4VyAvwgKEomEFhcXjeANhULKZDLK5XLmPI6Pj004MTIyovHxcXU6He3s7KharSqfz5sUtt+1srJif4drOTk5USQS0cjIiKLRqGZnZ606fHV11WrXzs7ODE0AbqJGZ3x8XJVKRc+fPzcIz0OgKOwwrj4Kvri4UKFQ0OHhoebm5nT79m2TuBPxU7uFAaSSf2dnR2/evNHIyIg++ugjKz2g2wFlBJ999pny+bz9u989SLZ0//59ffe739XOzo4+//xz20fNZlOJRELpdNoi/6GhIX3xxRcWWHtJt6SuvbKxsWEBUa9zIWgrFos6Pj62rg8gSuw/sh9+d3p6WtPT08rn8/r000/VaDR07949jY2N6Ve/+pXW1tbsOkgUUIYBBRN4kN1+684FSaon73EGRCVe+okSwRPqQ0NDdrharZYVTnGo/E3k7ygxvEoMA9PpdMy5AGexCUKhkDkLsFCUFaSVRJhg7R4/pYUD6gyUM/0e7l5Yya9ew+1/3htzIgfpSp/uHzZcB84EsppIjc8mXRLRvcSiFwV4h+KhM96Pn8HZ95KNOCkfrd8E0kEGiiILw8TegRiOxWJ2wHB41MMQlOBApEunDSwDH9crA/f4PbLkSqUiSbYv30YoA7H5rA3FJGIEsohYLGaBECQsz4xI2O+Vftbg4ODvXB/QMYql4eFhjYyM2M83m03jTSD1/X6gsJSsn8/pxSFAswRunc5lITBqPuqNeFaoq3jW8E/ARQRYg4ODWlxctBqmgYEBa49C5tJoNJRMJruy637vIUWu8Xhc0WhUyWRSs7OzOjk50fr6uhW7wjlxrnxRoxcXEIiQ+QJrcSb9eeK1WB4ezGQyVkyMHeW8cC5qtZq9LllUKBSyoI3A0tcyEaTW63XLYLn+66xrO5fDw0NJV9g0RYtDQ0NaXFzU5OSkzs7OTD5cKBQMEgE+oTqWGzYxMaGJiQnFYjFNTExYhTg3D69NLzPSwGq1qtXVVds4YIvr6+uKRCKamZnR8PCw1tfXtbW1ZRh2p9Mxopd+SZ1OxwQBpPjxeFwTExPqdDra2NiwClcOZ7+rl2fBQPv6oF4jzMY7PT01gybJHAe6c4xhLBazbAGnSkGex3PpwwY0xN+5Hu9AgEC8CtBzLRwMnLmH2HAEN+GrJOlnP/tZ178xihSaRaNRjY6O6tatWxoaGlIul1MkErGoOBAIaHx8XM1m00QkS0tLunfvnur1ura3t7tgPepNvHIHqefBwYF+9atfqV6v69atW8rlciat5ZmRbZMtHx4eKhQKmcEbGRmxOoxsNqvJyUnt7u7q4ODApPtkZSMjI7p7965yudyN7uHS0pLxmtTYEOHm83kdHx9rZGREuVzOonEk3BRHw5FIl7Zgd3dXhULB7pEkC4S8oQK1gIQnWgfvx0lFo1Gdn59reXnZOjAAp/FMa7WaarWanj59qn/0j/6RpEsI5+TkRL/85S/15ZdfWl1aPB7Xn//5n2thYUGff/65fvnLX/atFvv+97+vUChkXMTi4qI+/PBDVSoV/Yf/8B+0vr6uxcVF3blzR8FgUIeHh13FnD4oQfzCuSEgx7lwXjx3GQhcqh5BjYAHZ2dnDdodHx9XtVrVz3/+c+3v7xsPdnx8bHWDb9680fr6uuLxuH70ox/p/Pxcm5ubBs16qLfZbFovPBz9t+5cPFxDVIvqKhwOmzLHR9QYFaRwEJ1cHCmkhyy8tI7DTjsXCPdIJKJyuWzwBZlNpVLp8uBwNL6WA0089RF8Fpwam5lrwagTrfRLSnvi3nMSUrdC620PzqfIvE5vJsHi2nthP3BynMvQ0FBXZOMzpd4MjUgbGSaOzCvC+Ay9n8VnY71igndZ1WpV0lWHAPaXFxsA73gJrM/4PGFP4ELDUj7724QJPksD8oEUZU95mafPDIATMCBE8D4jJeBBKs81o8CkYDmXy91IFMFz9vuAZ4Th8BJ/zra/B+wN/o8gE8Pnn4fPBs/OzuwewE/Af3A/zs/PzdHQDQEhx9DQkHE7wKIUJbZal7VtwGiHh4ddARHwPAR7v86F18NhhsNhJZNJOw/sH9SuoCOetyQDQdjhM2WcC3xUL3/MYl8C8fKcgDbZZ5VKxfYkz5b7fX5+rlQqpUwmo7OzM1P/vU1yjKMBAbnuGb62c3nw4IGky2I28OxMJqNwOGyGvtlsanFxUdIVpguUEYvFNDY2Zhs8EAhoaWlJt2/flnRFtEPox2Ixzc3Nqd1uq1armeclfYe8o9fO2NiYhoaGrPspGxUjSppKVWyz2bQOn6jGMFyRSKRLD49DohVDvwslEVXgQI0e1vMEHhmidGmoKY7i59mEfJ/fGxkZ6eJc0um0QqGQFhYWtLCwYBg/GHG73VapVFI+n7eNRGQJKQqEyPcxPh5KgqfyToSfp/q330WHbF9AOzQ0ZMaMPliZTEbNZlM7Ozt2D2hZNDMzo2g0qpmZGYMCSqWSotGonjx5okDgqj8WyjDeU7pSbIXDYT169EjNZlNzc3P2nuzPcrlsAhbgCyq2vRwcsQHwkIceEA5ks1lFo1EVi0X7jH/913/d1z1cXl5WIBDQ3NyclpaWVK1WjQv8+OOPTfn2xRdfGI93cXGh0dFRDQ8Pq9Fo6PXr19ZFF2PLZ2NvA0seHR0ZOjA4OKhUKmV7sFgs6osvvlC9XjeDeH5+bmoqMjbuWTqd1sTEhCKRiA4PD1Wr1VQsFvXzn/9cnc5VL7KhoSHdu3fPjPnAwID1Tzs9PbVn389aWVlRIBDQzs6Owa7xeNyy1IWFBR0fH+tnP/uZhoeHNT09bcadLJEgCaEHRrsXTsZBsX+435lMRplMRul0WqOjo4pEItrY2FCxWNTCwoISiYSGhob05MkTLS4umj09OjqyczoxMaFkMmlZCa1qgCHJ3BEfYG/elRa4tnOhToNDSx2FJNPyE0kQxUgyAkq6rB3wstCJiQktLCzo9PRUm5ubXS0ihoeHNTMz0+UQDg8Ptbe3p0Qiodu3bysWi2lmZka5XM4yFCp6C4WCZUtsMkldvbdoNOi9v4/I2DQYtOHh4Wvf2N7lN83w8LDOzs66mhkCc4G7whvhQICtgEoGBga6Cv5wLnxmVECBQECjo6NWhXv//n0dHx9rY2NDFxcXBiuSFvuorlQqdeHGUnc7F89l4XA8rk/05lU0/TpnHLuHSUZHR9XpXNYMMKYhkUjo+PhY29vbxmcAQRGAYMzK5bJKpZIymYzBacvLy8rn8yYSkK4ifnT+OOpAIKBMJqOhoSGdnZ0pk8kYjMa+PT097eopBcfD86QWhmADnvL09NQMDAHc4eFh30on6aqG7O7du1paWtL29rYpj27fvq25uTmtra3p9evXXYWKiURCk5OT2tra0vLyssLhsKanpy2AZJ8BxfKsueZQKKSZmRnFYjFNTU3p/v372tzc1FdffWVcSjQaVaVSsT5bU1NTVmYgXaIccAvs7Wq1qm+++aYrsh8YGNDs7KwajYa16wGK6nQ61uutn4UjZv8D/xJUjY+Pa39/X6urq8pkMspms9ZQlmwHWMnDzgTb3EfOPj8XDAaVy+U0Njam6elpk49DvB8eHmp5edmUeAMDA7p165aazaYJaUKhkHUpmZqa0vj4uHZ3d7W2tmYybiB2atfoiIB99Dzsdda1nQutR3y9CeQd0SmGyFeDArsEAgFT1XDzSGF9VatPf4lGaGPAYex0OhYVbm5uWkrMa8CdEBWQ6VxcXJhWni+MIvJpIBfIL6J3MOh+jWMvl4QRfxtZzyb0ToPoh02HwaaQimwSHgTYgw7VtEeh7mdpaUmBQMAiHemybQfps8fQIcFJ+7luL9vmXvsD48l8XqPf+0ewAokZCATMOUOyIg2GRwMaAXv37Ym4twMDA6bCCYfDKhaLqlQqBllI6ppXRASP5Jn6AIzk8PCwze7hHBDdE616zgLDChkNj0RAQAbFnJCbEPp05eU+eby/VCpZvQsFk0hiyRLhtAiC9vb21G63jejm3AK7SLJCvNnZWSsW5HNTDzM2NqZ4PK719XWdnJwY3ATagDgIR8hZJbsmqAkELmtQaBXk62DopHwTtVgvnMa5JOAbHh42KE+S9vb2jEznPsJ1kiX4gmgCNS+uAU0h4CCraLfbJqCi3osWRQSYZEuILbwal6Bhbm7OWiVB3pOd8/k4c16wcZ11bedCBagkaxPhmxp2Oh3DPKlRwbhxICqVSlf/JGoWcEL0YgIH3N3dNf330dGRRcsUy0EoSpeRTTabVSAQsEMInBaJRDQ9PW3RDIVabBacFo7Qw0b0KfMEdj+L9/IyQzY5zhXn7J0FIgafOXHtU1NTmpqaUr1e197enjkcXycUi8WsKhoZeSaT0cOHD7tI5Vgspnw+b8V+vBb1Cnt7e9aSg+gc6bcn/36fdPldN2bvIkr2sCJYPwaYAECSRkdHFQqFrGIZWKRer5vBR9ggXXa8bbVa2t3dValU6nreGABkncfHx9rf37cAhKyT0QOzs7NKJpPW1+74+Fj5fN4iU0ldB7der1txZqvVUjqd1scff2wdBPy+69cwSrKmiUjDj4+PzUlubGzo+PhYyWRS09PT9n0i4WQyaQOqTk9P9fXXX2ttbU2pVEq3b9+2Pd1qtbS/v69araZkMql79+5ZtTpNQgn2PvroI3U6Hd2+fVvj4+P65S9/qXw+b5E6bXVQjgFLLS0tKZPJGMxEDVM0ejkYbGtry7o1Y6tOTk60u7urzc3NvrM/9q8XrJBN+y4GFMW+ePFCrVbLhAvxeFzT09Nqt9vWvp4OEyj2vBqTLsfRaNQcC3u7VqtpeXlZrVZLd+/e1fj4uPb29rS8vKyBgQHdvXtXQ0NDNojRt99hP09MTGhpaUnFYtH67qHY83wtIiFs/rcuRcY4kgZiMPzCMEpXslcyAR4GUAk3r5cM9caoUCiYwfBGGX7Ck4dANJ4PQO/NzeS6yXCIIPk9bxSJlH1RoCfZ+lm9KrHee+evkevAQfvP2hvd+M0+NDSkkZERywA5zL2kOtfiZaBsPl7Lf1aiHd7fb7BesrH38/FeN4m66cBN9obKTbqS2KJkA//3mYMkc46k/hhD6UqA4iWgCAbYn15ez+diT/KeZI1UufM63ANeH8weuISsivfiHuLAcM43cS5+HwGp+izKE9JemOBFHpwTskH2Gp/BPyOq9gligHOBqCkABnYkeGD5gIXr8IS37yrgz7znMMlO2b+eqH7X5UVN7DPsl7cPFDwyqqM3I2H/9RYc+3MJijM2NtZVhzQyMmK1asBiyMfJGuFnCSIIIDgTvvgSFMWrcdkjiEr4THzvWyf0eWHkrFTY4329QaJynJqD8/NzDQ8PW3X43t6eGo2GRkdHbfZKNps1gvXi4kIrKyv61a9+pWaz2YWRVyoVu45QKGSwTrPZtHSRA05ES+QIIdtsNpVKpZTNZnVxcWFdXKWrthSpVMpke8gw3xVz9MvX7/DwejcWijsiLTDiTCZjklAME3U86NnhFqge5lm0223t7e1pZ2dH2WzWsrv19XW1222trq6aE2cTsqGQUfL6yECBUtho/LxXl1AwSdT9Nof6LuuTTz5Rp9NRoVCwSnxm9Ozu7ioQCFi2hpQcLoRRscC5LAwXh5fnwqA4jCWG6/Dw0GCHWCxm+63dbiuTyWhhYcGI5ouLC9vvXDMw8MnJiRYWFvTo0SMjo5vNpklLw+Gw1tbWzHlhLN4lanzbolamXq8bd3r79m1TZJLBcp9AIqrVqnEi+XxeAwMDevLkibLZrCqVip1ZeNfJyUmNjY1pZmZGH374oUXn1IAAz9KyZG1tTS9fvtTBwYFGR0dNPg9xD/rAmAOeOQYdB5ZOpxUIBJTNZnV4eGj93xgjLV3xZ/0sH1RgY+CBjo6ODKaamJiwrNAjFCcnJ9re3jY7kEwmrXM7i70WCoV09+5d/fVf/7XC4bBKpZIajYYeP36sx48fq9Fo6Pbt2xbw4GjJPF68eKFQKKStrS3t7OxocnJSf/Inf2K1hcPDw9rY2NDr168NBqM7AoH89va2FZLTNRx4/Drr2s4F4+jbbRBBEOVz4z2px+/6KA3s0xPZtNMAly8UCmYA2fgM/fKvR+TIDA/er9PpWEuIQCBgSihPRtMwz0v+INTS6bQVcFJde5PV+x7+fvFvol8i1Xa7bREiAgPut5dzEnVEo5dzu8fGxizqOz8/N+dBPUi73Va1WlW9Xtfy8rI2Nze72qNQiNkbjXr+pBc24sBgEP3nxsndxLmwuVFhSTKCncwTnkKSYeDU3viIlT0ATEh2RxTvi8j8M4L05ICChfOcstms4d0ERAQBPFcy90gkYoYUQp/IFPjWZ/nwIze5h9wb0ABwevgS352Y5wx/QiHd3t6eDdq7e/eutra2jJv0UK50qfCbmpqyyD4QCNi9g6M6PT3Vs2fPlM/nu9q9IEk+Pj7WycmJZT7hcNigap6P7zCBivT4+NiMtg++3qUIsHe9bQ/jNOGEeYZkOT6oIoshKIbH8IW1nl/NZDK6d++ewuGwNjY2dHJyYsGmJOORd3Z2bMov2TeZ6cHBgcrlclefODKY8/NzbW9vS7oMPHzx8dnZmU1DBWYHovvWnUtvWi9J2WzW3hynQvQDOUQkjMMhGmcQ0DfffKNYLGYbiwgZjqfTuZKZNhqNLqLay4eBOcg8Op2rPjynp6cqFAoG/cRiMdXrda2trdl1+rSfz+vVINls1lpf9LP4PY+psoBmMIL++7R1OT09tftIE75UKmWjUVF0ULfB84hEIvrwww/NEbNpUFNx3zudjmq1mjlXIrOpqSk1Gg2Lrv29J5vFIJEZkoJLVxmvJ8j7Wb/97W+NhJyfnzfyvdFoWJcGnhmqGdJ67omHFaWrmh7mYYTDYW1ublq/KK734OCgi5MjGiXYIrL89a9/bRlGMBi0RpS+ISXPDTFKJBKxeq+BgQGLIom0mQIIEnCT5bsUYIiYRMkZoqkso40ZTEWbGgxTqVTS9va2ksmkfvjDHxrvh6S6Xq8rHo+rVCppaGjI+mwh7GHEMpA3MBaCG4KamZkZk8t7R06bHJwOkFCpVFK5XFatVjNZPPuXAVv9Zn9MGt3Z2dHh4aGOj49VLpcNVWk0Gqbq8lAoHUy4N+32VadyCsh9VwaCk6mpKU1OTlomwz2lHQ592+C4CDQJwlqtlhYWFmy6JM/FJwf0vOP3CFrZ//7M04ngunVC79wDHcVLNBq12gNaGHC4IdHQv5OhEM3h/T777DN9+eWXtnlQeIH3BYOXsxgKhYK1mKZhHQWZKBn42WAwaMqhtbU1ffPNN12OIxS6rGJnfjRwCjeXjYczwHiOjo7q7t27vwOtXHex0cD5iVA8ru1hN+9cGMYFlg3MwBAfYB2iNwwfjvbBgwdKpVJaXl7W8vKyCoWCvv76a52dnVkRK8Sph92SyaTGxsbMuEjqcugYdCBRoCQcoMeV2bT9rl//+tcKh8NWbR0Oh60yfH5+Xslk0jq6+spzisu8YIJn4fkZphw+f/5c6+vrXRg5Ro0+WnwO71gPDg60trZmHALy4bW1NYM+IMcp+t3Y2FA8Htfjx4+VSCRMcEB9C3BYvV7X6Ojo77THf9eFc8E51mq1LvWkJJszz+cIhUJdbfiprWCi45/92Z/pL//yL63LwdnZmUXStE4aGRnR7du3NTY2ZmMFyuWytUzBKNbrV6OSiaBnZ2f18OFDFYtFPX/+3Awyfc3m5uYkXakXy+WyjUGmMBVDXCgUrO6mn0VtE6KBk5MTFYtFU9vV63WbQQ8nLF06l0QiYdMwvQ2YmJjQ/fv3TQgAvI+abnp62toake0htuBzUu5Bs1YcdbPZ1KNHj/TBBx/o6OhIGxsbdl0ERrOzsyYgQr32NufC+66srFw7SHzn3mLIJiFLiYSIyvCyHG4i2VarZQbH3txF4cAnvqEd3peoinkxnrBFaoqDCAQClolIMmiE1gc8VKJ9XtcrM1AWAZ9B1PrGjO+62NAIF6Ruots7H/89DzdJV/JVIAIiUDKbdrttHWYxYltbWyoUClYw1Wq1uooEGQMwOjpqz8U/D67JCwfIFP3z9DJkHAq/6z/jTRadaGu1ml0H781oYxxaOHw1vMk7c7Jv36YdSOLg4MAyOPYdcOHo6KhJa4HjfMt9xCueBOc64Gf8wcbReO6NZ+5FJMDPvZDquy4yOMQBGCAgZF9ALF1l2QQySKKJrKnDAeYuFotWGX50dKRgMGhoBM8GLgWOAk6MDIaAhWw0EomYUV1cXLR6IN+bS5IpHHlvrhtDS8aAFLjf+9dsNk1SDazllX+tVsv4aFSwjCDmZ/2zpMeaF5DkcjlrCeTvMzAhMCTtZXxXA5Rp2LZAIGBtXSic9EPoKJQlC0IIwFcgELAs1befus66tnPZ3NxUKBSyKJEbx4Mrl8sm+wwGg+YYqtWqjo+PrRqemwWBPTU1ZbxCJBIxHBwiETkpUZPX/3NAgSa4noODA5MPz8/Pa39/X2trawYv+EZ3kUjEdOL8++TkRIeHhybHnZycVCh02VK838WGIirxETFGmP/zenQOPJsP8pURrr4eB9kj5PDs7Kyky6gf/ggH+ujRI7VaLX322Wfa2NjQrVu39PHHH1vUj1Pa2dmxdJ1rkmStLbhG4DyuEQPvizlvGnUHg0FtbW3ZYUSlRSCyv7+vly9fKhwOW+0FBy6RSGhiYkLt9mU3ArIJ5rMDFQFfAQ+NjIxobm5OqVRKt27d0tLSkkqlkr7++mtdXFzo7t27BlmNjo7aoSfAGRwc7Go8SZbvm7byHIGQvaoQoYUPmPpd09PTdibh3IhMFxYWNDo6qu3tbcvcyH7n5uasIzfcUCaTUTKZtKr6YrGof/iHf9DR0ZEZr8nJSd29e9dgw2KxqLW1Na2trVkHjUbjskt6uVw2NISshL1aLpc1OTmpH/3oRwoEAvrJT36iN2/eqNFomCR8f39fZ2dn1gctlUppfn5eodDluN+9vT2Njo5qYWGh733IPVhcXFQgEFC1WtX+/r4kmV26uLjQ8vKyCZEYAsb4BqTQBOGlUskaSSaTScXjcX3nO9/R9773PeNXcMzFYlErKytaXV21/S/JAqNKpaKDgwMNDl4OSAMRevPmjfE3oVBIGxsbKpVK2tvbs+xxa2tLp6enJlQBvgwEAvryyy/15s0bgwDhJv/YurZz8REsER0PycNOXvaJsUSBQHTh2zpgbH1E38t7+Ap5ei0RaZHB+EgZD0ykDWTmJccozjDefEFmcfDAczHc/S6fifjMha9euTD3l+jDR6zcD6m7+SXXiAwW0rNYLJpjBcv3fdy8eADIEpiSnwPq5HdwJkTYb4uogZV85tDvYl/hRAluyJzZY2dnZ4pEIl1/np2ddUlcMZJEeyiXfNZBRA8HRREjCh9+hmuDD/OSe+nKIfvnRfYZi8W6FHb8vD8HXr5KZNvvoj4IiTPPU5IVSrLXvdLPF+tiGDl3CBKOjo6M68BO+EJh3q9arRqnhXTc81RkdUjq2VcDAwMWoGIDpCsolvPtz3nvvfSqwH6WFwP58yXJnrHPBn3hr5fxsl+8wAlpMTA9wS8oDnb06OjIJnJKV3U2oC3YPQJU4DJQI/YnyjK+T+bofw5bQIcUOOHrnuNrOxfPdVBTAtQ0Ojpqai9gF1KxWCymTCajer2uZ8+eaWBgQHfu3DFVE/guh4imerlczvBtohL6jUlXXUInJiY0OjpqahagHG7I6emparWaQW+tVstmZxD1Egmk02nDvimi7O2p1W/0iMiAtNlHHjgPFC2k2MFg0KJA/3NsOGTh3AsUU72QFkby4OBAu7u7isVipoBDJn52dqbl5WWNjIxYj6I/+7M/049//GPt7Ozo5z//uUVq4MZETBhkahskmZTaO6SbKJ34HM1mU8fHx9aYtNVq2XygWq1m+5B7y/7LZDIm0QYqDQaDXQ0xPWyFo4VIpacenAiFg9QaYHi9mAF+kuvG4MCp0OdtY2NDZ2dnGhsbs4zU7xucJ1Md+13sB5AG9mCz2bR/dzodg2PS6XRXYfHs7KyePHmiUOiqe0atVjNym/ZBfoDfT37yE0UiV53KNzc39c0330i6KowNBoNWgLi7u2vzb3w5Qzqdtgx4dnZWAwMDKhQK2t3dVTwe1+LioiKRiKkf4Q4k2fjlXof1rut//s//KelqgFqn0zHeWdLvzMYhM4XvODo6MhqA4JjgB+eZSCS0s7OjX/ziFwapEcD5wBg4EXjLB/iNRkPPnz+3Mozj42ONjo6qXC4rFApZ5+1SqaSDgwMFAgG7f9gWWinBeR8fH5s45rrO+drOhRcFngBrlS4PcDgcNjni+fm5tbgHysrn89re3jYVBOR8Op02MgtJIVDY48ePrV1+rVbT4OCgxsbG7OeDwaDS6bSmpqa6pJt4ZUYxk/p7JyHJbiYdQYGpkF76h+brHvpZKOWILqSrmfRkgkRs8EFcLyo3rzgjG/AFUWDKZF/VatUOGFLaQqFgtQyRSMRgjnq9rt3dXaVSKS0uLmpkZET379/X7du39fLlS62vr5tCC4PppcdezOGl1B7i6bcyms8sdc8TguTE0EndThxuicaVo6OjFtGdnZ1Zy5dO52ouTW/bIiArP7AqHA5bpTV7xDsXIlY4CgyAdJX10+X4+PhYb9680cnJiTUU9MohDJFXdvW7uF4v5+ZcUOMUiUTMOUAm41jT6bS++93vKhgM6tmzZzo8PFSlUtH29rbB2dQJpVIpbWxs6OuvvzZosNO57AOHSg6FHhyir9sKBi9HmCOhpZYtEAhYzy7pssXK0NCQ7t69a4W2nGE+09TUlHK5XNcz6mfRx4ysg88pyUYfgyrE43EbKHd0dKRCoWBd5OHxEN/QUzEej5vYiEyOQHN6erprpDvwJtl3o9EwDo/WPl4+jyiK6wFJqtVqisfjGh8fVyKRUKFQMIgSIUyxWNTZ2ZmGh4f//3EuKBGOj48t0kXFRFrm1TPcdCJKIhpUIb6XDWQVB5PNzeFmJOzk5GQXoUgmJV0ZL16T+gYPgUiyjYokFzIXA0vKiTHgfXjtfpfvboyc1UMvQHd0huYgeb7Cdz3gUJJRsml9dgXUw+cHK8ewDQ4OanZ21uSapMVERVtbW2o2m1pZWdHe3l7XrG4Pc3FffJZEVuNJ/ptkLhhbnAztgVC1MQAOQ+4l0SjB8vm8Wq2WDg8PdXZ2pnK5LKlbWEEWMjQ0ZK1x0ul018HyNVw4HQwEAY6X4fsOCOPj42ZECGK4biT3PFeeC0bypmtlZcV4oDt37qjRaBh5z3nhHNHKhq7i0qUs+tmzZ8aNDg4Oanx83Mhq2irBucJ3NRoNbW1tmfIRB86+8Z0HqDbnnBMYeGh7bW3NmnhSWHlwcKBCoSDpUr5MUIoqztfr9Hsv2e/YB4x+p9PRysqKIRKgKHCClEEgx4dkbzQaxsclk0mTa6PgRBwBJxIKhazDvKcbCHAI7nBUoEC04slmswoGgxYsBAKBrvk6FxcX1nUB2JLsLB6PdwVT11nXdi7VatXUH2B5hULBpL1+PnkwGLQOsdVq1eoEpqen7caenJzYhydSD4fDXdW2fO/jjz+WdOkYvJgAzsY/cNQTKFEoKKrVagqHw7p7966mp6e1srKira0tw5D5TAcHB+a1qRuBgL/JQoFEFIdBka4wezgD7yw4iJ7c933YcrmcRkZGNDk5qXA4rIODA4N6yAZxtiMjI8pms0qn07p9+7bi8bhmZ2eVyWS0tbWlly9fGmzC/PM3b95oe3tbr1+/tpoNamO4L2DnnlfyLTG83LrfhaKNe1Cr1bS7u6vBwUH9o3/0jzQ3N2d943AcGMmZmRkdHBzo9evX1mMKo9oLkcAVjo6O2r0dHx/XyMiIFaHGYjHNzs5a1T4QKlkdgYskC1qAFcbHx7WwsGCqJ6C2er1uAgoibUkWdfLcbwKL/epXv1IoFNK9e/f0/e9/X+VyWZubm139+zg7qVRK7XbblFEjIyPK5/P67//9v9vwstHRUcu2EFScnZ3pzZs3yufz1i2dPcIZIyD0HAlZcDKZtGwzHo9rbGxMs7OzlmlWq1V99tlnev78uT744AP98Ic/1OnpqX7zm9+oWq3q3r17evz4sf386empye/Zv/3uQ8+PNZuXbVcePnyoVqulzc1NU3JdXFwOStvZ2TEpNPsKh8o5f/TokZ48eWL7bGhoSOPj40qn09rc3DQF3uvXr1Wv1632hUaWPvAgIxoZGbERy8ViUeVyWel0WvPz82q3L7tyVCoVoybgU8/OzjQ1NaWxsTEVi0UtLy+r3W7r9u3bGhkZ0d7enjY2Nq7tnK/tXHxfIoy2L0rzmKB05eVJ4bwAgP/zFeDcHEh1nJQntZFBe6Ke9/Ub1deN8D4+4kW6x/+B/fJzngQE8ngXIusPrV7j0Evee5EE95b7yefnT8+/0B2WugEyQghQCGQOLREOIgmcO3AEGWahUDB4zXMn3BcvPfarV5Lcuz/edWGQvAgCwpbsjHvmCycRe/Q6uLddr38eXmgBVu/3JAuIBNIa2M7fG0l2fyV1/QwELp+h1wj5TPQmZL5fdG72Q8sg6cmoycI8n0Tw5vuReWUg0e/x8bEFIZwZOE5+FliWe829pFsAHAlyXX8GUZeyJ4ARyQ567ZE/u95uvevqvf84TZ41WSr/BhV5mwzf86yUUiDb9jA3GRfcDLA6fLZ01RuRgNtfp59nxV6KxWKWHbGnyaChH7w839eqsdevs67tXBjAUygUtLW1ZWQTqg0/J5ob6RUS0hXHgDHHMEKCkSJC5PniPCCO8fFx62PEhg+FQqrVaiZ75kFzOOBLWq2WPv/88y4YhN45IyMj1hH4+PjYqo3pl+RbyfSzvHH0nIWHu6iyB1rxBo/RvXR7hQDd2tqSJL169UqdTsdqBvzvfec737F0F0PG5oEX4L0HBwf1ne98R8lkUn/3d3+nX/ziFwaDQRDi1Pg7hsMbIoIGOCEgwH7X/fv31el0TJGUSCQs0KCKXbpS7Tx8+NCwfEQm1CsR+fmmfpLMyGIEz8/PLStkUBUKNab8gW2fnJxoZ2fH9o83CPF4XB9++KFF7l9//bWSyaT11Xvw4IEJV8rlsmVEOESEGzeZJyRdttBBWnzr1i1dXFwY/j49PW0NKL3KS5IFLxTQAkuHw5cz6YmOv/nmG1UqFf32t7/V2tqaQqGQBS6zs7MaGRnR6uqq4fezs7MKh8PmbNl/SIYnJyctageeHBgY0F/+5V/q448/1vn5uc3yobakVCrZcwA6I/va2tqy7ur9LIw2BrZSqegf/uEfDL4EosYGeg6OVkFkLAQr6XTa0JrU/5p31Wg0bDw3veiQeFOzNjg4qKdPnyoYDGpvb8/qigim2IMUaVJ02W639eDBA33yySfWTouO0ycnJ3r16pWGh4dtxhGlGQTkvsv9H1vXdi40ciwUCma8/OCj3uKx3ujPe1OMUafTMWjIt4jxA52kK+eCAZauOBYiJshWr6wCKvPyUnoA+bEAOA5gOm4em+Pi4qJLytrP8p+/N6p/W1ZHNIIzI4L2mDSpMTwTJB/SW2SX2WzWBqoNDg4at8R99zLawcHLme6Q3/xcb3ZF5kIESgbB5+uVk3tBQj8rnU6r3W6baITMC4ybjQ+UiuH2WQ3ZnySL0ntn9HAv+IydTsdkyP75UY/Ez1xcXHSNK2BPnpycmGKNeo9SqaRwOGz/Bz/pYVEyT/Y9XNtNYDHfIoioFcgGRRaLAI7Pwp8+U+F8NZtNGweOUaQH2cTEhHFIwOfwVvTX8vJ5ZLgEQ0dHRybWoTsAjTEZj0DwAE9A9o5iEc4Mu9KvsMSfUYQexWLRnomP+FkEutg7KuSxNSARBOv0RWMvUBaBbQN2HRsbM0gLboRzR/AHTJbL5RQIBMxGZDIZq92j0wKQIcGVR4qos+pFoP7YurZzocEZpKTX9NMapFfGyQ3D8aBMmpiYUCKRMAUZkxFRgwHf0MGXzQPsQ3rYbDZN0tdsNq0giYpoqk8lWYU0s14wvqFQSDs7O9rb2zPjACkMod5ut22D93u4e+XEHkpi83gYhYyA+4hs2rcwSaVSppDhd4lYuN9seAwFP4vkleg7kUjoww8/1Pn5uX7zm9/o7OxMz58//x0CDwPh8V42HPvBZwLcPw9V9rMoCGOUsCQjhcvlss7OzjQ6OmoKJH8fMDzsAbJsVDXUCEBw9raIx3D6zNzDl51Ox/gWolKvWKJ5KM6bDKJQKJjIgj2MccIgIUC5KawoyXjRw8NDffnll9ra2rJnh/LLN5Nlr8H1+NqMtbU1bW9vW+AyPDyse/fuaXp6WgcHBza7CbiZQV9+hDQwFoFhNpvVnTt3NDg4aK/h61t6BRiFQsHm8EDsz8zMaHx83IQDzWbTAo6xsbGuer13XUtLS5Y9Hx0dKZFIaGpqys4ozxTUg8aPzEORroJiUBZsDkqvSCSi3d1dE9AQqOOccEa+MwSNTnmW8Xhcd+7csUFsnPXbt29b/zVk3CsrK2o0GsZnJ5NJg8UREcDtFgoFlUqlbx8Wo605RKePWqi0Jf3ji0ib6JLRrRMTE5qYmNDp6alViO7v72twcFBPnjyx6ujx8XFJsq6xVFzzWjw4YBeMjG/twmH1UmqiQDY41ak8aNQWpLt8TqCXfhYwUW+WIl0NEOP/gKtwLhSZAvFh0OlZREQeCARMnXN8fGxRCY37pKveYETNaOYTiYRmZmaUz+f1d3/3d1peXrZmhdJV+xakzsVi0Yy8V7P5n8W59MIs/axEImEqLrJIWnsgPkDdhXPx3B41REBfHi5FKMDnA6YAumDGOIoqsnMfDCChJbgKBq9qaHAuOJLh4WFrhYKhCAavWh+hMgoGg0as+8Fe/S4+//7+vnZ3d01kIkn7+/tGUvvu2MDLPoBot9taX19XvV7XgwcPLEu8d++ezs/P9erVK+3u7tqeuLi4nADrC3mJpL2MG6EApPPJyYkJcE5PT62zObxEsVjUxsaGhoeH9dFHHymdTltWUy6XjffgWVFF3+89XFxctHvRbl92a5+dnTUOa3Bw0OrIaK9/cXFhBptgGzUZwiY6bUMz1Go1bW5uWsmCD9xALnAu7K9KpWK2IhgM6tatW5qdnTWbzP8fHx/rt7/9rTY3N5XP5y2ov3PnjhKJhMbHx5XNZnVwcGDS648//li5XK4rg7nOurZzmZqa6pK6kaa12+0unBrDiXQUXFu66vaJMaCQzff1wmCAWXspIQePlhgobsLhsDVx8zUtXBcpuCcUaXLX6XS62nnDCSWTSUlXDfF8ptbP8sQmmK2XO3tDKF1Bcj7FxhmCr/J/nU7HDBn913A0/Ew4HDYJLEZDkilc4J8kGWRI9IWz4z2JOH19C1hzL2nOF/ey34XMk8Pog5h0Om195rgODgHBgSeAId4pJGu325YdUGRLOyCgCwwa0/2YNgiEgbwTBSM8InCrb53jCXr2Agaw3W7bs4LTAJaiDqvfRbDBMwJJ8NXYqBmbzaY5M0YOE+T4bBVIDIkrEE0ikeiSZNNWhK4PvUQxWSPZERkbvdfghwhicXIESRQ1AlehhGu3L4uj/fj0fvchTS/JOthvOOxWq2W9zSDc2+2rRrDSVRsoEJqJiQn7O8ELM2zgmf2fvhyBvbK4uKhMJmNoQjQatZlZ6XRamUzGOjhTQMtcLDq9c397UaBAIGB8Nvz4ddGba1vLH/3oR2q1Wta7p92+KqLMZrM2YInovlQqKRAIWHpLrx/Svnw+b0YykUgY4Tc0NGRyQT5oPp/X6emppW6ePAV39akpRYJsaKS36PObzabevHmj5eVlxWIxffe73zXCb3d31yS77fZlLyB6nN3EuSB88I38iBwZ/wpxBqTiMVqc38XFhdbW1jQ0NKS5uTnL5jY3N9XpdPTnf/7nmp2d7WrgCL5O1S2EPoKAg4MDzc3NGdk/MzNj8sTDw0MNDw9rampKgUBAW1tbJvcFIsKBgxNzyKWrvkceKutn0UVhb29PxWLRhk7RRwm4BmOHxJZq6oWFBWUyGYVCIZPcbmxsWGfiO3fuaGBgQPv7+zo8PLReT7TDJysaHh7W4eGh9vf3VSqVtLy83NVzbmRkxEbesre9+otnyp54G2dJ/RFRLDU0N11fffWVpKtMMx6PK5fL2RgABA/UZtDReW5uTlNTU+ZoUSaBSNDLb39/387X/Py8Dg8Ptba2pnA4rNnZ2a4WMkCE4XDYBv5ls1kznPTBYu+cnJxobW3NquBxiPfv31e9XrdIn9HQxWJRb968UTgc1l/8xV9YF5GbKD4//fRTe35AzhjmX/7yl9re3u6CrRYWFqxuzDfajEQievLkieLxuJaWlqzmCPJ+e3tb+Xze4ChqtaLRqDkvipWj0aj+6T/9p5qfn9ezZ8/005/+VNVqVT/72c90dnamp0+f6oMPPlC1WtWbN290dHRkUvH5+Xl99NFHNlzs6OjIMk4vZlpfX7fuC+/S+PPa1pIimkql0gUHsDjcnvDzESuVpsFg0HgNDhnkEWQbHUX5QKSQcDpo8VGHlMtlK7jCwWDwvNKGA4rBBn9FkktExGdAfUHW4pVv77owtl5azT3slVx3PSBXNAmEQDRINgeZDFzDZ8AZ+vtAcz0iYv7upZyehOc1eaa8X2+lc6/8k9W7D/q9fxxOny3xnMiIfWEZ18K/yaQldXXc9hmizyhxkF7sQKYEVATs51+bPQa8GQ6Hfyeb8xCTL8zzsmPIVK4TaOMm2R+FnHwesmSydWrGpKvhcIy+8NAsIgPOGs7z9PTUOCy4KiTYZNRe7s9r0l+QDN7fO/Y4XCtBDc+LIIhnyv/z3AlQce43CRBBYHhOPlMHoYGjJJjkDPlC40jkcoYPxZM8V19Y7W3Y4OCgOWCeie/vSNNU6oNAHGjxT+8334naz47xYgiet5ds92bN33rmgra6XC6bxA8+BaUBxmtkZET37t3T0NCQ9vb2VCqVNDw8rNHRUV1cXJjkUroqftza2tLAwEBX1MisCYreIBuBJfyDOj09tSh0ZmZGmUzG5hMQHWJ8qIydnZ01Y0tHUaIP0saBgQHraHqTCn1qA9iQvu9UtVq1XmxsLA7bw4cPtbCwYB1R2cxsCDYBEcXx8bF2dnZs3C4dD2gjkkqldHx83NWvDchzfX1dtVpNX3/9tfb393VwcGDQz8bGhqSr4VVkLZ3OVd0TogWpu8W+V8D1u4C0bt26ZY6fqBYIlU7QYPunp6daW1uztjZACUADiURCT58+tX1NtkwnCPqvAWVUKhUTfqDEu3fvnqamprS7u6vV1VW7R9IlDEWLGSLa0dFRJZNJUzRJV+MLKEyOx+OWwXol1fT0dN/3T5IJZBinfHJyonw+b8Yf2TaGCafC19HRkdbX1xUKhaw/INwUsBR9qeAWPvrooy6HPTExofHxccuegWBQ7SEwWV5etiASuI0AyottEPuACNy9e1eLi4va39/X+Pi4dane3983aKzfRYAINERfwnA4rImJCWUyGSvkrVQq+uabb7oCVRwyCk4KcYvFoiSZc/joo480MzNjAQfd4xOJhFXacz2BQECvX7/W6uqqdaIeGhoyAdbBwYF+/etf6/T01Hgv2tQcHR3p1atXxlu2Wpcjo1OplDm7UOiyFdfIyIgJAb71zAXlDVADhD1KmXq9bl54YGDAFGGQ6aTBRB9AQhwsIkMq6Wu1mhlgIDCiY19jMTs7q0QiYcYUhxOPx5XJZGxT+2JKNPUoi/hcdHYFPhsYGLCHiqKr3+WjYl/siXHmZ8iQwL5phf/69Wutr693qa5QhElXsBtqEAQKvdDVyMiIQWLn5+ddY02pVyAt99E9ajayzl5FmOeL3gaBcb39Lg50Npu1AsCjoyOrwajX6xofH7cpgEhcUZcRJQNNHB8fa3JyUtPT06pWq1peXrbXoIaG+8TnYGYJTojnRePUV69eSZIJTpDmDg4OGkxGPyqCDQwIxhaSF2fNF+KNm0iREQ4wLXFnZ0fLy8sW6XPtQIlkBmRsjUZDe3t7Jryh9mdw8LJDMnuDBoxkIY1Gw87wwsKC7t27Z7wIzpPzDI+ztbVldR70uqI7B/uIZ08QGIlcDr969OiRRkdHTcjy1VdfaW9vTyMjIybU6WfhXHzmVygUTCAzMjKi9fV1HR4eWgCMlN03rISQHx0dtYyHIJD34Hvlctlgy9T/miHTW3Sbz+dVrVY1OjpqXVBoTlur1ayvGZkVmd/Z2Zn29va6Wr0AwfkMG1gdHuZbdy4rKytmXHAWDM/BQWDMGo2GXrx4oeHhYbugZDKpyclJSbKKZzatVxrxoeinA6HuD6Ek41WIBIaHh83D0v7j4OBA+XzeMiGiolqtZtg481+oakcIAMSGBJBr7XfhGNkUvGYvhMTn5GEz3ZCIGRhPuiS5aVfD56MLKiQzxoGiS7Tt4ONTU1NKpVK2Qb182zsEHGEvn+KvGafn60l8xneT+4fYgsaoBAkYPPYemx8inxqOVqul3d1d+zwop6gLIltMJBI23wcYaG9vzw4mv49Ckeao5+fnlhn4+w/8QHdtBCw8d4oQMZJwO0TlDEYD9r2Jc0GlBaYOhEq7I84UWRvPjlZMnU7HVEnFYlEjIyNd/bKA8ugpRs1KKBSyanvpqucdyit+zg/8IyoHCaHINBgMWhFxpVLR4eGhCQC4bvpxefk0MB/ZYj+LPmLYCi/ooDYplUrpT/7kT7oM9/T0tMbGxizgwPYBu0MXeAETPRxv375tfCkBOvuJmj3uU7N52cEYxSv3HpEDbYqQ6RNkUZCJiAQ7wvXzXODIv/UiSipRSevZhEQ8zWbTiCtIfwjoZrNpPawgp4HVqIMh5cXRHB0d2RhiP4gHIi2ZTFr2xKGkboUIamtrS+vr64ZH4rSKxaIePXqkP/mTP1GxWNR/+k//yaA3oiAINK+iuUlK7bMuOut6lRjf99nN2dmZvvjiC+v5hXPgoLCRcrmcFhYWNDQ0pBcvXliXWqDEo6MjxeNxi0YLhYJWV1fVal0OPpqfn7cecKVSyaJ1TzJ7jsVzRNLbW9WA3yNTJ3Pqd0Ekl8tlq2VCubW5uan9/X2TpRLdcY9pErm8vGyvhbNltgiHPJfLWcdjeEHgLqJH7zwZuAQJ32g0lM/nLSJn/wPhEQliNJGdVqtVq8XwTS0RXABN3cS50B4euI0aEJwqyiJqywgeJycnDXbd399XKHQ5+hji//DwUKlUSk+ePNHQ0JCNZZiYmLAsDfEFz9BHxqiuIPjJ3j3XUygUtL6+rkAgoJmZGeVyOZXLZa2urtqz6HQ6FlTiXDxnedNyAmTSlE8Q5OBYBgYG9PTpU/3Zn/2Zjo6O9OWXX+rs7Ezf+c53dPfuXa2vr+vXv/51V7EvZwJumYzu5OREmUxG3/3udxUKhcyRENSXSiXVajUrvWCMBP0SgdURpeAIPQy5vr6uzc1Nzc7O6n//3/93LS4uWv3S+vq6jXLGQYGmXFcUcW3n4r0zqTCRARFLr/bfZyTcQLw1um8INqJgT2p6ngKIxtcnAE948hXog2iKlN0bQz5PuVy2SB3cFqfp5dV83lgs1vfhxjh7r+9fC7LbZwJE4N54832fBQFl0BsIg45MmygUvgzlHffdS4v9tfV+Vi9C8KuXzPd7gD/ZK/0uOJFemIsUH2ISiAHDwnUBj3qDA+nrZes4ASrZ4XQIfFie80G148Us0hV8wrAtiiup0fKYuielfQZGdtG7f2+y2NP+/FHLA0zqK/Or1apVjnMmiJypOwNm5RlHIpcjn4l24a0kmUCEswsq4Lk5vnxgw8+wD+kmQdE017i7u2sIhc8ybiLjlmTOEQdMAOfPo3TFhXiBCYYdeAyb5mubsI0owaSrGTFkhtxDuqSwP2gbQ0DIffLwMYXn3ikiuKjVasYVQfp7u+MFB9dd13YupJOk78gtBwYGlM1mzZu2222NjIxY+2hWJBKxQjLaFvgJdDgVbsbg4KBu376tRqNhHUelq3YlDAbDedDhE+w6EAiYGoPNy4MYHBzU2tqaXr58qYuLC6tuvXXrliYmJkzzDV5K4efs7GzfB9xvwt7F5qL1DffBO1NvXDh4qN729/etS0K5XDbjReGpdFUjs7W1pYWFBf3t3/6tYrGYtra29Pz5c+3t7dmBxyh6Qh5D7Q8pz41NzYZG0SZdOVXue7/OmUFN7JN0Oq2FhQWFw2FNTk4ql8tZxIXKyAcIBAdIX6PRqB2ooaEhzc/PWxX10dGRZmdn9cEHH0iStejH2OGc+CxedRYIBCwa9Y1C4Sfq9bpevnzZVadz584dBYNBffXVV6pUKnbAyQAnJyfN6Nwkc+GsUbUNmdxoNPTVV1/pq6++sn1er9e1s7Ojer1uQpJQKKRcLqdwOKz9/X3rOkCdycbGhsn4s9msyuWyPv30U0WjUc3Pz9vwKTgxKu+5d1Sao3JiXgnFlvQi4/zPz8/r6dOnBk+en5/r9evX+ru/+zvjF5GvA//4Nj7vuhhEd//+fWUyGS0vL+u///f/btlDOBy21kqMdKZ328rKioaHhzUxMaFoNGqfDWSA78HL4Hh+8YtfWJHo6OioOX/Pz9KPMRAIGCdIYILsGMWdJJvkGQ6Hde/ePUnSf/7P/1nS1egFsnnsAI6KsRDXWdd2LnhlIul4PG6HCXiKVM9X53NhGKFOp2NQBY5AUpc0ksgGmAuv6/FT6cq4eSySawXegpMho8FIE+F0Oh270fRCYoolr8Prk773s/D4vYWFfF7UVUR8vneVlwD6KMKT7cyP8MWtRH1evtlsNpXL5TQ5Oal0Oq3t7W3jHfz18Xf/J8tnJ1yLlwh7bqw3c+nXODKrnD1ApAZmHwwGTV1ItoFQhLS+13lKMiUW1c08q3D4cvwDESpZe++o696MTZI54ng8rnQ6ba3jA4GAVcbzfoFAwAQEODcyGFRcRJe+ELOf1evoOR8XFxdW1EwXAUQJp6enqlarOj09VTqd1szMTFc5AVwNophOp6NsNmuZJDVoExMTXWIU7pOXerN3+ZMv4GAKrVFqMTUVu0IDy/X1dQ0NDWl0dFSSjBfxdqOfRXaay+WslmxgYEAXFxe/w+vAO52cnFgbF84d97w3ePS9DUOhkMrlsorFotlI30HZB2pwZgQ12GXpUj69t7dn4gdsCsKCeDyus7MzqyHi/PtgkC/syrdO6CN/48XD4bA2Nja6iqFwGlThEzl7OOTi4kI7OzuGO8Zisa4WIZOTkxocHLQCNYyE76+USqX0wQcfKBqNanNz0zYwzsxXZafT6a5sxtcuYKQmJiaMcNzb27OUv91uW4V6tVrV5uamAoGA/uW//JfXvW1XN9plENTz+OaEQHjgo5B7ZGbSlaFGHUXkyzPAkb6tT1U0GrX2GKlUyqqvSZURQQBz4Ix4PqTJGAKcCgQ+EBHPiLQex4hapV/nQvM94CVfcc2am5uz/lG1Wq3LKdOmHXITYzM+Pm5V414ddXx8rJcvX5pTwQAAM75588YI90Dgsv4HfDqbzSoSiWhqakoTExNdgodcLqdsNmvPJxKJmPNnDgfZO/cPIcdNpNzSFcy8u7urnZ0dSZeqJAxMo9FQLBbT+Pi4jo+PdXh4aDJbIliyN/YIBohgLhQK6cWLF/ryyy8Vi8W0tLRkwdzx8bE52WKxqN/85jdqt9smKjk6OtLKyorq9bpF8tRooL7yyjCgvNPTU71588aI/GQyqU6nY8MMw+Gwqe1uEiCCxGxubmpjY0P1el1Pnjzpgi5PT0/1xRdfKBwO6+nTp101UsFg0Eauz83NKRaL6c2bN3r9+rXGxsZMog2vmEwm9f3vf19DQ0PWMYRAm9EHnAPfst+fR/g97KMk29MgJECaKG2B2XhP7Ondu3c1Pz9/7ft3beeSyWS6/s2AoVDoslkcbS54AL4hG5saAwteOD09rdHRUZMiSjI56ddff23abdQqOKFUKqWnT58aiVUul43gRdpLWpdMJo1Y5cbiYGg7Mzk5qXg8rlKppMPDwy6MFKNAsdx1vXbvImqnLgDJqc9okKxitHAuCCCAz2jZwqblZ3yxJdEfh4vMbGpqymoc/Kaq1+tdGDqvH41GDVtut69mRvi6Fgw898vjzz7q8XUw77owSgxSkq6yaSLiqakpM4xv3rwx3qLT6ZhCEcUTjjebzZpDwXkgiX/z5k2Xw4HQPDk50ddff23GC6NL0eDo6KgZ1rm5OSPt2+22stmsYrGYyZQl2QGnnoGZ6jh1zhLPoN8FOpDP560O5MGDB13Q0cjIiMHWGKmxsTFlMhkdHR3p8PDQ9o1Xz3lO4M2bN1pdXdXTp0/1ne98R51OR69evTLRQiwW0/b2tv7bf/tvajQa+if/5J9YwMMwKrpxYDNoWdLpXHU5pnygUqloc3PTxBk4SyCcTCZjRvgmvCnnkEGDk5OTevr0qQYGBmwPfv7553r27JkmJib0wx/+ULlczngfRkJfXFzYaOHnz5/r1atXOjk50aNHjxQMBo37yOVy+s53vmMUgpcfU0hJkI5jYR/j9Pl/ng9iDvggSRboYDMJupGu03ppaWlJP/7xj6/dLeKdylWBG4ANmBFNHyAuGnUICg24CxwUfcEgFOFHODgcImaHkw3hQSGgms2mcT7wK2DefI8oH5Kb1I7fI6pCncMmgUfwWY6H3vpd/kFi+D05jAoFGAn1GBsL+ImDL3UPLWL5n8NgIvn0/cVOTk5UKpUsOkQmTfoMFOfTZfgG70h6+SSu7W3CgH7vm1dcAXGSRUuXRvrg4KBLZttbdcy94fe85Jj7hVgAA+t/hnk5QJgsHDGyUuS+DM1iX/Fs2d8U8PoCX19b4/vA3XQlk0lTPs7MzKjdbqtUKtkzp50J5wRimkyKWfDsC0kWlFxcXNh9AurDUHLPsQfAZ2NjY1YAu7Oz0zXOg73mC6GRQwPFtdttFYtFE6wgTmEkw/z8fFddDOer3/1Ii6WLiwuL6jc3N21voHrNZrM2uZMeZAS+PguFImB+la+dwkl4JAA0gbOPiKrRaHRV4PM8W61WVyDl1Xlk4DhsZO7sYTqDE3BhD/m811nXdi5E8BBti4uL+v73v289sVCVVKtVpVIpzczMKBaLaW9vT+VyWaOjo/r444+NZELvzQyDqakpSZfSzt3dXZMvE3WyMUnFNzc3rSFlOp22ilePS+fzeet7hMQWuI5eZwzIYbQr86mBVei5xM3ud2NifJGoYty8BLPVuuzd5qEmD0FAkhNJe86jVqt1kXy8BpAZdUDz8/PWpZXagZcvX9rcDLIPFkZRUpcckTYfSCh9bQzGoHf/9Jv1SVd1Iv76cAY4O+p3kKYThBCIEHH5gCeVSpnBAxZAPoujIPLb3t7W9va2zs7OTPHI5yIzgnDFsHp4S5LJcFOplCYnJ1Uul/Xll1/q8PCwCwJlwTv6gtl+1/z8vAKBgJaWljQ1NaXf/OY3+nf/7t+pVqvZ0CrKAHz3AEh25MDSJXw9MjJi/x+JRLS3t2fwK4OmXr58aQ6b8d7MCProo4+sNmNzc9Neyz9fBBEUnwYCAeMuCoWCiXKky/q5QqGgg4MD3b59Wz/+8Y8ViUT07Nkz7e/vW61Hv/vw7//+743QX1xc1N7enn7yk5+YWo7o/vHjx6rX6/r000/VarX0wx/+UI8fP1a73bbu78DRiURC8/PzGh0dtf1Dn0ZKOYBGG42GQWB0JuF5lctlbWxsmEy6UChYUH18fGz7FaFULpfTq1evbPDj0tJSl4IXFMULe0qlkv7rf/2varfb+j//z//zj96vd3IueFGUQRwkj0lj+Ihg+CIChED3/a6i0csW95IMV/UkPZEkBtirZvzreG0810L05XFvol4eIhi8P7wYbt6H175pFN5LfvcS/LwvDtKT9/5Q+J/nT54NUZyXNvZ2Zu0lTbkP3nh7Mh7DjOPqvQaf3fhr5Gf97/Wz2ENe/OCLOIHeqAXgZ3yW97b397BW773tzdyQ5nJ//X330l5fV8G5wEH53+FPYCbei/3vRQjfRvbH5wC+pi8XGTqwCTAdDhao1GeB7DPgYu4fsJd0yQ+cnJx0iRF8ATFQLpX0CDQkWQCGcIPf6VVNgnJ4oYZX7VGr5qP8fu+lLxiHx0XujHMh6CIDJCDuzez9v9mb8IB+7/pzzbnl/nBuab8E/MYod1AbsnKfMfk97gNC7qHf39jzdrv9TpM8r+1cuHm0BwgGg9re3rbosNFoKB6P6wc/+IGazaYODg4sHQWTLBaLCoUuR58ODw9raWlJt27dMkgBAorKWzrh+nSb35+fnzdcmqhufX1d0WhU09PTBsMxO0OS4dZsVjYqRoPX5/Bx/c1m02pi+t2Yva1P+MySjCwnCwMXRelFWouaiM/rITscKQYtkUiYRHx6etpw6C+++EIjIyPa3d21z4b8mvfyBhQ11tzcnKRLMhi5I1/cS39vvKOGT/LS9Hdds7Oz9veDgwN7voFAwFqxh0Ihzc7Odn2W0dFRzc7O2jP28KLvUYcih55aHOhQKGSSezJZIEjk48ByBFDMN0GuG4/HraswQUKtVtOzZ89MxgrnUKlUrBW772ABPHoTB/3VV18pGAyqWCzq9evX2tvb0+zsrKEBSIpfvnxpXbdDoZA+++wzm+cEwsCZ8JAoHFStVtPQ0JDS6bSJAShQ9jwh85rK5bJKpZLS6bQePnyoRqOhjY0NHR8fK5/Pa3l52SYqRqPRrtbxxWJRsVhMDx8+7BJsSNIXX3yhgYEBq3T3Yzz6WT/4wQ8MXfjpT39qrax6Vajr6+vW5wzntru7q0ajYXYL6L5UKml1dVXDw8M6Pz/X8PCwFZz6gIcgc2trS8ViUZVKRcvLy0ZFdDodgwjpD0dJArYHJ/js2TOtra1Zt/dAIGBiCJRo7XZb+XxeweBlW36KaOnyfZ11befiIxMiqUqlokAgYOR3KpXS4uKiqtWq4Y1UzoN3srHC4bCy2aw1TeRAQ3pLl/UFcCfes6bTaU1PT2tgYMAKfkqlkorFogYHL6dZAgWBL0KQ+5oaz1n4KIKI3xPV1JX0S6j63/OwlySLQOBDiDCIXHzxqXSV/WDQfaTrK8JRVkEw+7oOHFa73bZWN0SsOBeM28DAgFV381x9ZCX9bvdjT/RKMmikX+dMM71KpWINJXlPZLPMSgcOQK6ay+VMAShdFbkRmICjBwIBa53h5cBkuZKsYSXGAaUZTiscDhtxTH0M9S5+KmulUrH6Axw4HWzJ/uF8eu91v8u3Uy8Wi2o2m11cp3TpXIvFojKZjB49emQqykqlYupL6XIKJA6ZqJg2TcCGzWbTSHlgNuwHo8W553AV4+Pjqtfr2t/ft9nxOzs7Ghsb08zMjEFKQNcnJycaHh62IVebm5s2nXV7e1uDg4N6+PBhF7/T71pcXFSzedn3bHV11YJR6WpP1et1lUolpVIp3b59284z6tN0Om0BCWpUnAL7bG5uzuryWGQwwF+VSsUUa3wf7phs0nfrlmS2wbfA4TzipFhAiBSVkxGCPl1nvVPmIl1pvYmqpSuPSGpPJAbcRWHV9PS0yfGIfLa2tjQ0NKRcLmfqLj8giFoTDLGvoCeqpMUBggEcHtErnhyiNxAI2AwUbjSRAtcmXXEMPjLtd3mCW1JXCi9dkY0HBwd2v3GCvG+v+gvHI13VZnB/fP8qryibmZmxKFCSnj9/rmKxaFFOJBKxQwyHdn5+rnw+b4QkzhF4ks+GY+qFALzx6de5zM3NWRRGb6peKAmyc3Bw0CTo7AUcjs9gfHYCPJtKpZTJZOyAkimTufDl5xdRnMg1QBonEgnduXPHCmNxcJDOg4ODdogbjYYGBwetIzP3CcfiObZ+18LCgiRZTQq4PXuPIIfvYZw7nY7NN0LhJl215PGqPe+sOXcERQSOZNnIYamngWvF2RJFc8bHxsbM2ZMNM2KZxqvBYNCaVnouGCeGKrWftb+/3wW9olAFVeBMcpZWVlaMf5Nkhh1FHq13crlcl6gHp1Wr1Qy9yefzNutle3vbmlriRID2vf3qrfHjOVFX5VtE5XI5a6XFF/VdCDooev/WMxcOMtmDJFM+AEtgPMgeiBzRrN+6dUvtdlvLy8s6PT21ViSjo6MmCSXToI8TG7aXL+E6ksmkRVc4jefPn6tcLlvbeA6k5yNwbJIsYmg2m13yUqJQ1BM3kTH2Rji+awAGkiFWPhPhd8Fkg8H/j73/eo48vc7D8adzzrkbaOQZTJ7NyyUpUqIpSpZoW1bJ5Qvr3hcul11l+5/wP+DyrcsXqpIlWypFirS4Ine5acJORM4NdM45/S7wfQ5ON2dFDLC++uFUoWYANLo/n/fzvic85znnGKXSnIqN0CFwNnVSexjkuCcSCcTjcall6PdPW4bTcyIz7+bNmwiHw3jx4oXgtuxFRliBB0pDcpzGqA0mZdpjel1ZXV0VRXF8fCzXoiMjXcVOxccu3uzErZlDrP4mfdjpdCIcDktnZeLz9Nzo+RkMZ+OkWbjHmi06T8PhUKYMkjXGIXecDe/xeCZoxuz4rCNA7R1fljV28+ZNjMdjbG9vI5PJwOfzSaEolSbbBg0GA2xtbUkeJh6Po1AoSCt37iPmYmhQuG7A6V5ko0tG6kwqk6nIM0cm2vPnzxEIBPDrv/7rSCQSQs3W7Xi4r4LBIOLxuOQCCGkmEgnZi+x1yO9fJ2cwLXt7e5JcZ40JCT+EQo+Pj3F4eCgogcFwRgdmlOL3+7G0tCTNNjWUqx2lWq2GJ0+eoNfrSbV/oVCQLsd8ToS06OxQnzHnxLwW68zYQ469CW02G2ZmZqQMgueK0DybxdI4f+3Ghcl1YsDAGeuGNwBAwj99iJl4Ozk5kQPP3AA9RHKpyZihJ6dx/WlhIpabj15Wo9GQqnN6qrp9vIa7KDr3wofLv6NCuUxiVXui03Cc/pk+PBo+00lz7X1rOI+RC40RlYVm32g4ic9Gd06gwWNeQl8rr5efScOojf/0Pej1uozXzU3Nw0qaMT8fOBtqxGfJz9RRCnBWc6TzS5qCzkOu807TtT2kERNu1UWxNKKklWsKKffreHxGoSYN1e12C/xG4R6kM3IZIe2U+TpNiJgulDUajYJIMBrmjHWeU60HAAh7jntT07/pFXONNc2ee5frq88gAOm0QENHR4W1dfw83SFYz58nPE7DcNF9qBu68j14jTSoBoNBSihodHVRMvMXrVYLx8fHMoCMBCT9PFgb0+l0xEBWKhWJTqjTdINUnlmNXui8qM7fkRlJ1Eb3YePzBCBpCQ3ln0fObVw4qIgGhUwQFlG63W602208fPhwgs7JC93f38c//MM/wGQySYIZODVW5XIZT58+FQNhsVgQDAYxMzMjCpMsF0YY3Pis0A8Gg0gkEqhWq1hbW8Ph4aEUTtVqNayvr2MwGEjXWRo4HnIqVF1/AkC8BI/Hg1AodGHjoqOQaUYMNxaAieQgsX0NP41GI4GqgDNFrpkxxLvZN4oJaHofVA70qDlWmk0Ai8Wi4Nk81FwPCg8Pr1lvYp1z0XU8wPmn2E3Lo0eP5O/n5uYEi9c5IxbUamNNh0KzZFg3xdom1kcAZ4QFVkUTH2d+jwnkxcVFAJBGmp1ORyi5rDAn7MCIyGw2o91uy4wXjuW9ffu2wGyaydPv97G2toZcLif029c53NPyk5/8BEajUSIkEgy63a7MTjEajTJojy13FhYWkEwmsbCwgG9+85vodrt4+fIlSqWSQMkul0tGRXPMhtFolCiNuVe+L9liAKTmjJXplPF4LN26OauEievNzU3Y7acjrnXehnk3OktGoxErKytIpVIy8G6aXHNeocEi/EsjwzzMYDBALBbDzZs30Wq1sLW1JZDfYDDAzZs38YMf/ADj8RiffvopPvnkE4kirNbTQXJMOTBC2dvbk4FnLA7nZ1N/8DroULEDgN/vx+HhIY6OjiSaNxqNEjGGw2Fcu3YNvV5PKPY8r4FAACsrK9KShtelHfJfJa8dudAKa0qyw+GA1+uVxDqT6drjrlarODw8lLwKNzYPPZtH8jBr6qsuGuIC0Wttt9sy65lhXbVaFSXDyn7WcJDLryGGadiM103ohRi6ppO+rkxj6Pw8Hblo1hVfo++f9FYaQiptvl5/z83HVjM6guNhpHKlkeBhpLfNjaSv51V0WipFzRh7VaJf//x1hbi52+2G2+2WeiXuQz6vbrf7S2uor4Pw2TQ1m+9D7208HgtVVht2zZqkU2A0GuWzR6ORGCo2S+RnM+pk5NDr9QQeI5uPz0I7IHxWlxXOPuHMGEZS3Bd6Br12tgAI7BeJRNBut7G3tzcRbTM3xTwS95su4KOzqYtZuYbMSWnYnXuMBXzMO+kWKBSdP2NkyzPDwYEks1zUuGj0QO8vPvN2u41YLAafzyefTXSl1+sJk5WO+fHxseSNgTNol+eJY0dIEtB7gGzH6XPHPa7n8zDyo+4cj8fyXKgz6bCzyn88Hste0PVXr6P/zm1cGP7zANC7Z3jLmyVLh6EhC/Y0dEYKHg0B6c0Wi0WGWDHJTIWqHzBhNlKeG40GbDabzE9gf7CDgwPpqMzRswz7nE4n5ufn5XX8LM3OoWJnok5j/K8rPDA8tNPh9XQCnJtYw3L8OTePDlXZ2ly326Ew78CJi1xDelzc0Dys/Gy2oSATilEeGT80XPyil6MhgWljelFhdTmhgvF4jGQyKTm/YrEoI1pZqT8cDpFMJhEKhSagVf6fjQ0BTECI/CKTSsN8xMI//fRTwfrZ0oekFO5ltkji7A0aF0bAzHVsbW3JmjLqZD6NI8G5Fy+6/4DT1komkwnz8/NYXFxELpfDy5cvpUfXYDCAw+FAPB5Hs9kUIoTOB7I5KM9LKpUSmjrXkAaMhoGGif2vmMNyuVyyp6k/mDPg0D+v1yu0c/beCgQC8Hq96PV6MmY4GAxK3oN9schwZH1cKBTCjRs3Lrx+7M3FynWSMXSdGB1uOtE894PB6dC5v/u7v5Okv8fjQTQaxeLiosxX6XQ6Yvyr1aq8PxW9ri+i/ngVgYczdTqdjjROvXfvHoxGIx4+fCj7MpPJwOl04rvf/S5sNhtyuZw0y3z06JHQ+/1+P+LxONLp9Lmj53MbF47sJAuLPHZuDmKerHQm7hwKhWSmNocPsaU4YTVuOj4A8rhpqRmGklfOfA0jH37Pg8AHQOVIPFnjuqSLVioVbG5uolqtCvmAog0MN/9lE/q8Zm4Qfg7/1UaEykh7aDQgNHq8J+Yk6GUQQuT6sTtroVCQMHs4HAo7T3up3KSNRkOSklwLvj+9f3qRNC58jgAmFDMN0EWFmDnn2LMLBB2VSqUi+4xU316vh9nZWYRCoQnMnh2AOY6BzgzzLd1ud+IgT+fGqtUqdnd30e/3EY1GxWPnIWdl88bGhkBAlUpF6mDYFYB7cX9/X5Smz+cTeE/PHNLEhYsKYZdEIoF0Oo1arYadnZ0JajdnpFDRMCojo41MPTo50WhUGkxub2+j0+mIIeFzZzKeRB+yvhg96eI99tHa2NiQ5o16dnyv14PP54PH40G/fzoQ0OPx4Pr169KpHTjNFzAiIOytGaUXEUarHFlQKBSwtrY2oYcITTGSIw2b5++jjz4SohBZY6lUCplMBgcHB6hUKkilUtLLjTki7lXuGSIMZC5qvcU9PhqNJvonvv/++zAajdje3hadl81mMTMzg7fffhupVAqPHz/G2toa9vb2sLa2NpFXTSaT0vLrPHJu40L2ES0z2zVrqi67IptMpolW+h6PRyIGJj6bzabkCdjnhl6hZnSQ6cSHxAiEClhXmjOZSxYTvSsdgQBnnUXpCbNJG1ktwFmSkp6QxjQvItN5CeCsMncasiGkoGnIrzJAwGT7e/4df0/FyZne2jjyQOhENjsl6zYp0yw3/Tl8DRUwyRl8T+3xXyZXAJzW11DY0p3vz6JXeti6vbrb7ZbaFxqcUqkkr6HB4R5hix8eZgCSRGXr+X6//0t7hS3WCaMxUo9EIhNRqU5oc5/ybOhCYT6DcDgsrWWYp7yo0MEi1EsmYK/Xk/6AhL/pSPC5aifNZDLJvKbp6JUKze12SysTwjDVahWRSAQej0dYYswX6n1PFl6n0xFYu9Vq4eTkRM67LqyepqcT1qXCJbmHif3LCJ1MMtG4f7gfGdFQ6dMh0eUNNKwGw2kB8MHBgbRrYaKdrYmi0agU6+p9ScNDAgaJDdPRNz+3Wq1ia2tLkCYWmANnU4R1+Qbfl+9D/UBo9TxybuPCwiT2ByL+yiQyFzORSEiRFg9ZMpmUBn5s9VAqleDxeOD1eic8WoZrBoMBGxsbcLlcuH37NgKBAIrFIg4ODiRBaDKZJkJ3hvVsHEePXhfwGQyGiaQhE8KMqvg+HIrGnj+snr4M0wQ4y7MAv+yFshaFOSJd46OjBx3dTB9sRiB0Anq9HtbW1mA2mxEKhQSS4ev4VavVZL4NjTk3+nTORDPMNLOM+QqNN2vjchm208OHD2E0GnHr1i2srq5K643BYCC8/X6/L1RZKjiG8uy7xFby7XYb6XQa8/Pzcm0Gw2nXZVJEGb0wqcq14iHn86RnyomNrGXw+Xy4fv260O7pBA2HQ/GiCSWx/T4dDEbRbK4KXJwMQWH38FKphEKhIAhBv9/HwsICotGoNISkoSXEwmp8Qt1LS0tYWFjA8fExjo+PJ4ZMcThaNBrF3NwcGo0GfvrTn+Lk5ASLi4tIJBIoFotYW1tDq9USQ8TkvTb2dBzYf4zoCGnfzGmcnJzAaDSiUCigUqkgFArh2rVrMBgMWF9fR7FYRDKZfK2W8dPCvawVO699MDjrcsDaHsKqhN11no0tcjKZDPL5PJrNpugXrcP8fj/6/b7070ulUkilUtjf35eqf47qYH9ATQph4eje3p7Mn3E4HFhZWZHfdbtdZLNZDIdD5PN5aWJL54KNMTna+muHxTR2yCiASmia5gmc4evEjuklMdk5TWOk8tVhH5NR+os0Rc3U4Ofz91oR6xknjBRYjKg3DO9Rw2q8Tq3ML2pcdNTzqs/WEYlOzk/LdI5GXxOVPeE0rhE3NmeaMH+icy/80gl6emLT16ojpX8smpteK73pX1fo7QMQL5fPSyd6GZ3p0QBk7GgFyHXSBancszpRy0ib9GHCQTRGuq8U30t7jIR8pokQwNngs+kolNcFnNUtvS5T51XCaI3XO51L0tdJog7rUTQMTaID789ut8t7M5KcZhjRgPKLe0zfN3NNo9FInjH/TjedpfHR66adK52nBM566emC14vI9L7QZ4AOFaM0Ott6v2hyzjRhQ1OZtdM47Yhq4g8jFu4hvq9+tvy5hjY512Y0GsnP2Elas9v4DPTZIrvyPPLaxgWAhKXxeBxGo1GKhmg8dE3Jp59+ipcvX8oGY9uXSCQillY3pKPHHQ6HMTc3J79jK2keXvYL0546Dy3hD1aeapiJEASjBFrlXq+HcDiMQCAgfXmGw+HEqNXLHG4qPU4A1EVTOrlLZhoxa8IAFG4W/Tx4/1wDDV9pg0W+PKEXRnHMZTECpYEnbMn8ABP6ryI9EI5kKxQd2fC5XNQwA5DCUR4Ii+W0k/ZoNBJSB+d7aCj1wYMHePjw4QRkGIlEYDKZxDvsdDqSsO73+8jn89K1mIeSkBLzWWyDUiqVkMvlMDs7i3feeUegDipjngut/PRach/wnsjoYbKb8A8P/WWgWeZ/WDdDphoVNqN13uO1a9cEsmIkS2VPims6ncb9+/eRz+cFfmIBdC6XwyeffDKR01pfX8dwOJTeYjTI3EP00HmuWYVOpU3Fq4lEGoZkSxmr1SroicPhQCwWkyj+osJuBizKbbfbUp/Hz6cTbTabhWTjcrlw/fr1iWfHomcSJ/g6FngTGsxmszCbzZibm5Ox5M+ePcNwOJQuG8BZ1/BAIIB+/3SyaL/fF0NCkg3/Lp1OY319XeYePXr0SIpA8/m8RF58b9LNX8fBfi3jwsXhA+UMAACC3XJTcBMcHR1hd3d3ItxPpVIIh8PiSXKzMXHODUFePzFyegiaEqq/6CWRTMDcEDFxTY/UxaAMD/l6RjbEV6eN10WERlNTL3k4dE0GsXfCeDz4fKC8Lq2wdY6DP9PCZ0RjZrPZEAwGxbPXmD9wViymu0rTi6JR03kfneMhRs7rnn4+FxUW4QGnz4uKkYedhoNRL71wzgkhM4eQhM6z0fBSeXMv+P1+2Wu6Yy/zEcBZ5wGbzYaFhQWMRiPs7OzIyAZ66dOero7imC/URXA6wW0ymQSWu4yBrtfrsFgsAreSngpAvFPudbPZLDBZOByGz+cTQ1gul7G5uYmDgwOkUinpD8h8BtuaNJtNvHjxQs6b2WyWyZ0cFay7XmjqNteM9z19BjR6AWCCZKJzrjSWFosFxWIR+Xz+wmvI3CsNIGfZAKfdAtg1g8ZlMBhIixjdM1BHJtRNbLBJQgPb2bBeb2ZmBhaLBdVqFdvb2zK11Gq1imPFXI7WJ0SYqOOGwyHcbjdCoZDMu2J7J5I42EQ0FovBYDhtRMr2Wa+Te35t48LwlSNJx+Mxjo6OhG3l8/mEkseE13A4FHYPH3S9XpcNDJzBZMx/cPzqYDAQKrGOXPiAaNTorfIg0hjRyyFxgLOjh8OhWHdCRqPRSDxN4AwqIClBP7jXFcIojJ744HVCXhMmpg+SVgQMUXl9NEY0nlqJa0hQ9yGq1+sTIbQOw6ejIgAT1b56c00rSe1daxLA9HW9rlC5ExJgDoxRGA+g3++XKGo8Hst0QjosrKMi/s0xuUyiRqNRYdDpZC29Ye5nFqYlk0nMzs5KhEw6PqMXnaAdj8+mpBYKBYmUiHFzrVkvZjAYpC0N28RcxriQxdbr9XBycgIAuHPnjiR4HQ4HqtUqSqWSnJ3RaITDw0PJV/G6t7e3USgUcHBwgLW1NbTbbalfq1Qq0qZnNDptTZRMJuU+9vb2UCwW0W634XK5EIvFJGcAnJF4jEaj5L7YxYPr1Ww24XK5EAgEYLVaJxpkMpLgz7j/CY1e1Enk2tOxYFTHaNhutyOfz0v+h9E2142i4XoNR9dqNanX46RN6h8azWAwKEqe68UzwPNntVpx9+5d2O32iXlGPH8bGxuiTzkplM+b10XjxbPWarVQKpWks/Z55NzGZRp/09FEsVhEp9PB3NwcAoGARDC6inxxcRHvv/8+RqMRnj59ikKhIP2uqOxGo5E0vIxEIvD5fMIQOzk5maDcEeNmgRkXnkkpGh2SD+Lx+ETvslwuJ3PECVUNBgOpftesHYvFIh2cL5ozoGFgdKIT3BpCorLWuDI9ZXrSHIBGWjAPEAA5XBq20gVzNCKMzl4VgXCDAWczLGhcGOVMkwtIHmBCX0c93APaaL6ucE6Ghj63t7dhMpmwurqKaDQqSkpDWdvb24Jnkw6rowF6fXQ+ZmZmkEgkJqItPUSJOQiO+P7e976HW7duCQOS3iwpxLVaDcFgENevX4fZbBbIo1QqoVwuy96gp0vPmEO5RqPTTrr0Hi8TPYfDYWGnHRwcIBAI4J133pmAER8/foz19fUJ47K9vS0RIGsxqOg3NjbECLBu6MmTJ9jb25Po1W63Y35+HsFgEA8ePMD6+jqMRiPW19fhcDjw5ptvYm5ubsKRicVi0nLG6/WiXq/j4OAAzWYTxWJR6ovYhp8JfhIPzGazdCBmjojnRsPMryPcuyzkHQwGYrBjsZi0v+F4Ao/HI4SIw8NDOfM0INP1ZXr8gsfjQaPRkLNNxiCNGFvu93o9GftMVl84HMb777+PVCqFTz75BA8ePJCz3+/38fTpUwDAm2++ie985zsYDk9HN7NejFHo8vIyjEajtPnPZrPY2to693q91pjj6YXWdQDTob4WKiKG5PpBTSeutdLSyWQdAvPvpuEgKjkNOU172tPMp1fd11eJVpavK6/63K9Stv/YNfxjZIDz/N1Xfcavuq/p69ffTyek/1/JNKlAR0J0Bl4F201fp5bpvcEc0vTnTb8HDTg/U+/VacKDft76czW0Of1/DUHr97yMTNPJ+TMqPObS9DXzGuhh03HU16Vzffr1fD4845rsQyeVZAV9f9P5POZj9DN91Wun9Yj+ub73ywqvQecb9TXq1zHa1rnQVz3LaUhbX/P0Z07vNYreN4RUNTrBv9HrbbVaBRWYvvZp8oEmMpxrncb/L7XBlVzJlVzJlfz/pVyusu1KruRKruRKruQVcmVcruRKruRKruRrlyvjciVXciVXciVfu1wZlyu5kiu5kiv52uXKuFzJlVzJlVzJ1y5XxuVKruRKruRKvna5Mi5XciVXciVX8rXLlXG5kiu5kiu5kq9drozLlVzJlVzJlXztcmVcruRKruRKruRrlyvjciVXciVXciVfu1wZlyu5kiu5kiv52uXcXZH/83/+zzCZTFheXsbs7CwODg7w2WefYTQaYW5uDn6/H8+fP8eTJ09gsVgQj8dl7gEHhdlsNhgMZyNc2+02ms0mTCaTTNwLBoNwuVzIZDJ4+fIlTCYTFhcX4XK5sLu7i729PZlNbjabsbm5iVwuh7fffhu/8zu/A6PRKDPSi8UiyuWyjE8dj8cyp4PDeTqdDvb399FsNqVlOudvW61WmbPBv+FavK74/f6JiXmc+6EnSE53VtUdoimcjTIejxEOh2XoWjabnRigZrfbZZgW54bwfThUiG3y2VafLe3b7TZGoxGcTiecTucrOwxz/fS460qlgnq9LvPtOZQKOG1T7vV6AZzOk3hduXHjBoDTVvu1Wm2iuyy79Oruvry/RqOBTqcDp9OJYDCI8XgsYxVcLhfcbrdM/ePQOs5s4ZAqPRZ5utsu595zXK3uVMvZRXpQ3ne/+10sLy/j5cuX+Oyzz2AymRCPx2Gz2WTeTqfTkRkcHKbHazUajXj8+PFrrx8A/Nf/+l8xGAzw4Ycf4tGjRzKKgkPeTCYTcrkcjo+PEQqF8I1vfANutxuffPIJXrx4gaWlJXzjG9+A0+mUs/yLX/wCP/vZz+B0OjE3NweXy4V4PA6/34/9/X08fvwYZrMZ169fl5kxDocDnU4HhUJBhoINh0PkcjkcHh4CgLTJD4VCCAQCcoZNJpO073/27Bk+/vhjWUO2/eeIgkwmA4vFgnfeeQfJZBKNRgPlchnj8Rj//b//99dev3/37/6dDJFzu91oNpsoFAqo1+t4+PAhstks3nnnHXznO99Bt9vF/v4+RqMRfuM3fgP3799HJpPBkydPUKvVsL29jWq1inQ6jYWFBXS7XeRyOXS7XVQqFbRaLSSTSayurmI0GuHg4EDGDhweHiIajeL999+Hx+ORGU3BYFCeJyea5nI5FAoF2O12BINBmSEzGo3g8XgQCARkqFulUsHW1hb29/dhtVrlGfh8PjgcDoRCIZk+/O///b//let1buPCVsv7+/vI5/PI5/M4Pj6GwWCAz+eD0WhENBrFt771LTQaDWxtbaHT6SAWi8kAJ+C0bXOlUsFgMEAoFMLMzAy63S7y+bzMgLFYLPB4PLh16xYsFots2mQyiTt37qDdbqNQKKDZbCIWiyEej8NkMuHnP/+5DASjorRarfK5eoJls9mUz+SY41arhWazCZ/PB4/HA5fLJe3UL9vynK2wqQg5u0KPFuDscSrM8XgMt9sNh8Mh10clyml9+XweZrMZiUQCBoMBuVxOZm00Gg15Lw5N08bKaDTC5/PJbJN6vY7xeCxt5DlRkEPZdMttblDgVOHz3tianffG1zebTfR6vQuPLKhWq/I+0/PX+VmU4XAo00g5a4RTAg2Gs1HTHGNtNpsRCoVgNBplDozX60UsFsNgMMDh4SGazaYYC91C3e12w+l0olaryRpNt9ZnS/bhcIjHjx/LsCYOBKODxefD6ZZ6vTkg6zKys7OD4XCISqUig81KpZJ8JoeZdTodVCoVvHz5Ena7HbVaTcaCBwIBWCwWuV/gbE4M55Jwr3EGEUfmBgIB2VMmkwmlUkmeVbfbhdvtxv3799Hr9WTN2ZLfbrfL1MpMJoP9/X1ks1kZ/8C5J16vF6FQaGLf88xx4NVFh9Z5vV4YjUZxhKl8w+GwTN6cn59HLBaTkdsco767u4tMJoODgwOZP8UZVJyWyzHRwWAQc3NzqNVq+Oijj9Dr9WR0u9frxc2bN2Waqm7Rf3Jygq2tLXg8Hrz11lsIBAIwGo1yLtlan8PTyuUy1tbWZIDheDyWGTlut1vmGm1tbWFnZwepVGpicu6vknMbF84ByGazMhWOiq1er8uAn0QigcPDQzx69AiFQkGUlx69yWmP8Xgcc3NzqFar4sVwXjs9ILvdjlQqJUPCxuMxDg8P8ZOf/EQeZjgcRiaTwePHj2X2t8fjEeOi585wozWbTfFWeYjb7TZarRaGw6EMKvJ4PDLzgBPgLiJUxNMjk7UnzKFNek6N0+mE3++XMaMcJ2w0GmWGt9frxdzcHCwWi0xB5P1oozg9E8NgOB3r7HK5JMrjjAcdbXJULw2HnlPCSIcDmjjbnJ/JtdXjpy8inLrHeSK8/q9aaypLTp+ksjEYDGJsarUaGo0GXC4XEokEzGazKNdIJIJkMol+vy+ODBUmp6zScHm93gnD+arZPZw/tLGxIWOUeSZKpRKAU2/d4XCIQtQGlMrhMnJ0dITRaCROByM2bfx5VulIUrnT8XG73RLh1Go18eR1pEcDy+F8dBY9Hg9sNpsM5uM6cdBaMpnEysoKGo0GMpkM2u227CcAiEQiMBqN2NraQqFQkPPI2SMmk0kiVN4PcHbmOOTsogPXOMaZDie9el7baDSCz+dDIBAQJ5fozNHREU5OTsQgRqNR2TsOhwONRkMmPi4uLmJubg5Pnz7Fl19+iXa7Lfdy7949LC4uSkRMMRgMKBaLePnyJcLhMO7cuSPRJZ9NvV4Xh4gjjQ8ODmA2mxEOh2G1WuFwOBAIBBAMBiWievz4MXZ2djAajeByuc7tIJ7buLhcLgAQ76FUKskNm0wmjEYjlMtl8YYcDgf8fj8cDodAQZxmSS/HarWiXC4LbEMvjXANIRaOieWBpPIcj8cSBVH5cJJbIBDA3t6ehNl6iiYhn9nZWQCQsDyTycjhODo6QqVSQSKRgMfjQa1WQ6lUurBx4d/Ra+JoXgAyFpoHXkMwHPPMB0sDqQ0mvT/CdhzPqw2AhpG08mK0OB6PZeyyHlvcbDYnoh4qSY5ffdVgLF4TZXpY1EWE78chSHow0nSkoKMZrpfX60U8Hsd4PEapVJKJhLxewk96Aiind/IeaXANBsPE6xlhzs7OilEfDocCc9Hx4toxsuM+4HhuPX6ZnqQeRsUo/KJCI8ZJrzoaZkShB1/RqFFarRay2SyMRqNAN1wHvq/RaES1WhUHgJMiCZFTyXNKLX/GEb21Wg3tdlvWRo/5dblcMoKXUxv1RFf97AnT8Sw1m03U6/VLGZdEIoHhcIidnR0cHR0hFArJtMZqtSpnhQbZ7/dLdMNx6n6/X67PZrOh3++jXC6j2WzK+tF5dLvdmJmZQafTkedgs9lQLpcF5gLOHH9GcIPBADs7O6JXPR4Pms2m6C+iIRxJbzQa4fV6JwbtGY1GlEol+ftUKoVQKASr1fr1G5dwOAyj0YhwOAyv1ytzonu9HiwWC3q9HnK5HIrFIgwGA7xeLwKBACKRCLxe78RcbOKB5XIZe3t76HQ6v4RXdzodea9SqSQGymq1olqtijdyeHgoD45QTjqdRiwWw+PHj/HTn/4Ubrcb6XRaMMhGo4F33nkH7777rmyEfr+PZ8+eiQL47LPPYLfbcffuXcTjcezv7wus8B//438894akcENTIRFiYF6AuY9GoyFRDA9Fs9mE2+1GKBTCaDSS6JGGkmEzlQ+jHxoqPUaZm5Sjlvk3w+EQDodjwkg0m03UajVYLBbB++md0lkwGAxiJDkymOsJQDxKu90uDsJFhFEb8W7mI8bjsRiDdrstikkbyF6vh7m5OXz3u99Fv9/H3/7t3yKbzYrhIDRKY6IhKj1JkPdBqEMb7kgkgng8jn6/j8PDQ1HErVYLLpcLN2/enBhry2fhcDiQTqfhdrvRarUEmiV0xWsxm80XXjvK7u4ujEYjZmZmMDs7i2KxiI2NDYxGI8mH8LOI/Q8GA1Hi1WpVzgjHXTM/x5ySwWDA4eEharUalpeX8c1vfhNWq1X2KvetNiC9Xk9gx+PjY4mS6Ug4HA7Z/3Qu6YDqaJhOFwDJvdDpzeVyyGazODk5uTAsRkj+ww8/xJ/+6Z/ijTfewMrKCkwmEw4ODpDJZDA3NydnYmZmRkaqVyoVmM1mzM7OTkx5rNfryOfzGAwG8Hg8ElmbTCZEo1G89dZbE9ebzWaxt7cHr9cLl8slkTT1i91uR7fbxc9+9jOYzWbcv38ft2/fRiaTwcnJCQaDAVKplBi+SCQCABJFc5R8s9nE7u4uRqMRYrEYksmkQI9fu3HhBtPjN6cTvVRohG70wQAgYbfdbpecCGfd06jQQEx70IPBQIwYsV49slUrAyZE9ax3/p4hOZW3Hn1K71Affnqa9EQvG7noJL0ebftVY0+5cTTkMD0+VxuNV42MZYSh31tHHEy807h0Op2JcdR8Zpy/zs961T3p7/Uz1DDQZdbvq9Zf/17vS71ehFyn14+v09dKD5uOi81mkznm9C61w2C1WuHz+QRP10qZf08DMX04GdHpCFM/p69j/fT76ajP4XAI1k5IjlGs2+2W/5vNZvHCp4VKh6gGc3DaKPKckzjCKE3nAekIMccCQD6PUT0dAD3Ol+eeXnu9XheSAteO76HHL7+uNJtNidQ4PpgRFCMH/Xk8W9N7jZ9PfcnzRgeK8DwdQDqBmqzEqIfrwWuifqMO4xpyvXXumWd7WjQiwMiaqMjr6L/XMi7j8RjHx8fY29tDuVxGNpvFaDRCKBSSJGkgEJCFIpzidDpRKBSws7MDg8GA+fl5eL1eFItFVKtVWXyLxYJkMomFhQVUq1WcnJyg1+tJeDedNLXb7XA4HBN5i9FohL/+67/GaDSC2WwWz4lJ/tXVVVnora0tDAYD8dBGoxH8fj9GoxG8Xq8cGIbkoVDowhuTho4h6WAwQLFYlJCWuQ5CX/QIuTY6Z6FnmPN7Joe1ceHmCQaDsFqt4hnzM/m3ZMilUin0ej3s7u6i0WjIwfb7/VheXobBYMDBwQHK5bJ4m0ajUeAUQkpms1mUFtl2X0fOYDweo9VqTbC4KPreeShIegCAw8ND/MVf/AUAIJ/PTySC+Vp+xmg0QqlUEuYjWTiRSATRaBS1Wk28e0aXdrsdi4uLEnG32204HA54PB7xLgGIgSMUSzKL1WpFu90Wz54RGWG9ryNyoZdaqVSQz+fh9/vxxhtvwGq1ipI+PDzE3t4egsEgvvvd70oSnq+x2+1ot9t48uQJisUi7HY7BoMB/H4/bt68CZvNho2NDRwfHwsTqdvt4smTJ6hWq3jjjTdw//59idZpxGh4Go0GrFYrVlZWYLVaUSwWUSqVUCwWxbnL5XKo1+twu93w+/2w2WwIBoMwm804Pj7GkydP4PV6kUqlYLPZ4PV64ff7kc/nL7V+/+N//A8Ap8r6n/2zfwYAePTokcBKwWAQsVgMsVgMnU4H6+vr6PV6khqo1WoSOWnHhPDz4eEher0estmsMLu45nNzc5J3LpVKGAwG8Hq9YkABSFTK9zUYDIhEIkIcWFlZQafTQblcRqlUgtPphMfjmYjQc7kcSqUS3G43VlZWBKGg0/46edNzGxd6+KTz1et1Ya9ovM9ut0+Ey4xier0eTk5OBNpgQprYK2+Q4a+mkTYaDVGu9XpdPGkqNo39N5tNbG9vo16v4+bNm1hZWZnwksjOKBQKOD4+RqfTEWzR7/dL0o6MEHoMDM8vitdqxcsDqteICVANIeikLj1prrOOuGiMXvXMNCRFZaY9Vypp0j57vR6Oj4/RbrflmRDCM5vNyOfzovS63a545oxE+Zk6iQ5M4sKXERoWGgEt2qvitdMAEW/XkIT2NKcjCnqPDocD4XAYgUAA4XAYkUgEFosF+XwerVZLPHLm+uhVEtLh/7UTMR1NtVot8WC1x8nno/+9jDidToxGp2zNcrk8QZrhdRHKI2MpHo/D5XJJcpgGYH9/H41GQ1hwXq8XyWQSDodD2IqEEJvNJrLZLPL5PG7evClJcOoKm80meTTC7MFgEB6PR2BWUpGHwyFKpRJarZagIyQOsDRhd3cXgUBAnEoSCYigXFSePHkCk8mEGzduYGlpCfl8Huvr6zAYDAiFQgiHw/D5fHA6neLwkdHKe61Wq+Jk6ci+2Wwil8uh0+mIbiSBQqMHwGnKwGw2i17kfiZBgFEg4Tn+bSgUQqvVQiaTQbVaFbKVzrERCrfb7eJY8Br5rM8bvZx7tR89eoTxeDwR3obDYfE8SDt0OBxot9s4PDwUL4yUX7I9GGKRtcMbHo1GePr0KSqVCiqVCk5OTiYSrD6fD/F4XKjI5MqT4z0zMyNeT6fTgcvlEgpfrVaD0WhEOp1GIBDA8fExdnZ2pCaHHHm/3y/JRYbixWJRGGwXhcX4gHSuwO12TySTB4OBMIlIoNBsNhob/UWoRP9L5U9FTKYZDYvBYJC8l9/vF8+0XC5jOBzC7Xb/Eqx5cHCA8XgspA1NwNDRCT1y1s7QO3K73fD5fJcyLszleTyeidC/3W5PQHU2mw2RSARmsxmlUknIHvxsDcNMExBY29PtdtFsNmXPU5FqNqPD4RDHJZVKyc/eeecdNJtNlMvlif03GAyQTCYRiURwcnKC3d3diXvTBkjDYcAkxHRRoYGKx+OIxWJwu90ol8sStfC9GQ1kMpmJ+q9AICCkBbvdjnA4jFqtJsns3d1dmM1m7O3t4fj4GG63G4FAAP1+X5Q9AMmTUvlz/9EJIuTIPAxzJ3ROotHoBAGCUZXFYkE0GhWyEJ9XqVRCo9FAoVCQ2rKLyP379+VskmhEum61WkWj0UCxWEShUBClr6HEXq8njixhZqfTKVBrLBZDt9uViIRwW6vVwvb2NqxWK3K5HAAIOqAjl16vh3w+L04kAFlTkiVIptBwHfNrrL1rtVpoNBrI5/MCBVMfeL3eczs65zYun376KQDIg4xEIrh+/booKYPBgGQyidnZWWFkkOd9cnICk8kkjBkaF0JO2WwWxWJRqHgbGxuyGZgEI+96eXkZ+Xwe2WwWtVoNR0dHKJfLuHHjBlZXV4V3Ti+MybTt7W1ZyEQigd3dXbx48QLBYBC3bt1CKpVCJBJBKBSSAsxut4tMJiOWnAm3iwg9Y0Z15ORzYzKXMRqd0qdZT8B8E5WdNhr0JBk96FyXzi1Uq1UA+KXcEz1Eskby+bwocI2LVyoV7O7uihGhoZvGk6exZbPZjEAgILUH8Xj8QmvH9TMajQgEAojH4wKXUnkQLh2PT+nHqVRKIJtWqzURmWgITDPoAEh9E1lLo9FIoAAeQnqBVqsVwWAQTqcTyWRS9vPS0hLMZjOq1Srq9To2NzfxZ3/2Z+h0Orh16xbi8TgePnyI/f39Ce9VX4deR0Zbl2WL0VFLJBKIRCKo1+uiCKnMgFPyjsViwcHBAY6OjrC9vY2TkxMsLS3hgw8+EIXFaLhUKsl9jsdj7O7uIp/PC0ROqmskEsF4PMbOzg5sNht8Ph8sFovARoFAAIlEQhASGhfC0d1uF2azGUtLSwiHwyiVSsJeo16KxWJwuVwCNQ0GA+TzeYxGI6FPXzQKfO+99+R9yuUyLBYLZmdn0ev1sLm5iWKxKMWuDodDroXPrdPpSPLe7/eLc+3z+STXS8Ooo13toDcaDQCQHBijpPH4tDiYLF4W4dK5a7fb4ugwl0j90O12cXh4iHq9LvutWq3i+PgYTqdTHBGbzSbIznnk3MaF4RYAeZi6fmU8HssN1Ot1KUbTuDYtOL3GTqcjXzabTRQrk0ya2cScSy6XE26+rsUgJsjDqmEYm82GcDgs98EoKx6Pw+fzCaRDr0ZXRnMDXFao/OmpcB24nuTzT0cpui6GClKvO3C60bxe78R7cN34e8JuzCPNzMxM5AR0Yl8zQvhzriefD7F07WXzmvR1UrkT8ruscaaRIZTCg9RqtcSbJYSjlbZ+j1eJplbT0HOdmXhlYtTpdCISici/rHR2u90AIDk85riq1ar8v1KpwGKxoNVqCRRBg6KVno4kuA8uU4QKQPKT3M/TCffhcCjFyiaTSSAZ4FQxsgaIZ5eFfyTY8MwwGU1lqSMFwr2sPwMgkad2oOjh6/UgtEU43mw2I51Oy16jgiWZh86BTvoTGryIUE9wrwBnBBoWi3Y6HVkTQuk0xswRcS/xGfD/dIp5jtrttug6UsUBiAPF9zYYTplzTqdTzmMsFoPBYMDMzIxEjTwjhCAHgwFyuZzA4mSg0djzdaVSCdVqVfJKXztb7K233hIF3Gq1pLjQaDSKF3t0dIT9/X20Wi0cHByg1+thdnZWFDsXjR4mQ0gAshhUXqTmaqVfr9elJQwTTaQ6OxwOqTbmg2ciNBaL4datW4LN2mw2zMzM4O7du3Jd9Xodu7u7qFQqApE5HA7Mz88LjHZwcHDhkJoRRSqVQjKZFApit9sV48jWH7reAjiDTABM5JtYUOjxeHDjxg3Y7XbZCDS0RqNRDAjx55WVFfzLf/kv4ff7hWNPCGM4HEqITEdhfX0dT58+xXh8Srn1+/04Pj6WYjwNtXFPUFGzQPbk5ORSRlozrwAgEAggmUwKNEqvkTgx8WHCWIT4gF9mTTHcN5tPW9iQqEAjRaXKNUomk/jggw8QCASQTqeFIj4cDlEoFPDhhx9KfZXBYJC9w2JBh8MhdUlU1NrIaIalZiy+Kq/2OsIzprsVhEIhdDodPH/+HIVCAd/+9rfxve99TxyDTqeDra0tweJZaLu2toZyuSwGmDR6HdVaLBaJmhllUmnp+hR60ixy1Hk/QmbhcBjXr1+HyWTCxsYGCoUCvv/97+Nf/at/hfF4LPTnra0tPH/+XNaM55/5iMvsQTo2NBYsJjeZTLh79y58Ph8+/vhj/OQnP4HReFoxzxxyKpWSM95qtZDP58WpdjqdcDgcuHXrljybwWCA7e1tHB4ewmQyYXV1FT6fD7lcTqJCtg0ql8uSJ/P5fPB6vbh165YUt9JAMJ/LiOrDDz/En/zJn8DhcOD9999HJBLB6uoqFhcXkc/n8ezZM1QqFWlts7S0hJs3b56btfhakYu2+Far9ZewYYairVZLvBEmlej9aRiAuQ1y5BnhaCWiKaSsS6CV1TRPAFLRy80LnGGTkUhEPHcWMBoMBinAJGeeYTPzDmRwXRaS0NEbE50UTeX9KohJv4b3resy2J6D3RJ4kJmQJ6xHiGpxcRGhUEhgxUAggFgshuHwtAsDKZYmkwkej2cCTnM4HMIgmU6i82/o5VFB/WNRw3lE55L4mXzu9Fo1zVV/ljbUwCQcpqOu6SiF96ihRxIymOBnWxN2cGCitVQqyTNilMeea8x98Zp0fYaOzvi9/vcyommnmmDCfBkJGqzC10XSOqlOyLtcLk9U3JPJp/OLfA86Qnq/MOLhM6U+IOTJYlQ+E64nPfrRaCT5mGKxKEqZ0c9oNBIDxr3Cz7uITO8/OgSM8oLBoLQV0uxOOjCElUjXZmKerFfChMxxkVTEaJkEh1arBafTKYaXEbzT6UQgEIDf78fMzAxCoZDo48FgALfbLfkvQnGEwohoBINBRKNRiS6NRqPUXdVqNYl+ziPnNi7cNDxUjUYDBwcHMJlMWFpaQiAQEBaKzWaTcDiVSmFubg7b29t48OABDAYDbty4IVaW0Ao3GpU6k+n87MFgIDkRtlPQCpptT+x2O2ZnZyUxSMgolUrBbDZLUovhLOG2fr+PaDSKdDot72kwGLC/v49MJjPRGuMiEolEZFMRNuF10Dul4bTb7YhGo7+UkKYy5Fpx041GI2xsbExQalnBS6+P4TPrWbhBCNuQETQajaTYldTper2OdDothWD0oIm56wptevtcPw1j6d+9rhCq4/PLZrPIZDIYDocSDRCb9ng84kwQvwbwSkIEf14oFESJkkbNaOWtt95COByWg03nw+FwYH19HY1GA+FwGHNzc7Db7bhx44bkCfh+W1tbYqhZ6EYmlM6X6d5lACSqJR36Mkbm+fPnMJlMmJ2dleQxu10sLi4inU6j1+vhr/7qr0TpDYdDqQjv9XrY398XeCmZTErnCu4rOki8B7ILmR9IJBJIJBJC4iHTTsOA7CCgq/gHg4HkV5hTK5VK+Mu//EsAkH3RarXg8/nEsbHb7bh16xZmZ2eRzWYlz3URYQ7v5OQEGxsbgnBYrVbk83nU63X4fD58//vfR6vVwvHxMQaDAY6OjuQeeE90WmdmZnD//n0MBgOUy2UpweCa/+Zv/qY4cePxWBhpbrdbSCskVfn9fkSjUdhsNuTzeVSrVSHTGAwGLC8vS0lEr9dDPB7Hd77zHcnf9Ho9rK2t4fDwUFIUoVAIN27cQCQSgcvl+n9DRSb0QdbP4eEh8vk8TCYTbt68KcqTEATxTnK/d3Z2sLGxAaPRiOXlZakE9fl8QgdmjoOKj5grIxb20Do5OcHa2hpqtdpElEIIaHZ2ViAwl8sFr9eLcDgMg8EwQW2kZ8XEXyKRwOzsrFwPuw60221J1F30cDNEzWazKBQKE7kNregYhXCTECrQ3hKTcWTasCp8PB4jEAjItcZiMYna7Ha75Lf0mvH+6akQ3wXOvBnWd5hMJoHuAEz02aJhfFVrFirO1+lLNC1UuvSiKIQp2AOtXq9LlGG32yciLN3KRQspolSCfC+yIldWVrC4uIi1tTWpaGf0dnh4iJ2dHayuriKVSsFqtSKdTiMYDArVnl2ZmWBlpwJNwwdODYluFMqo32KxIJVK4dq1a+f2Gl8l+/v7MJlMohB1hXsikYDT6cTu7i4+/fRTYWmZzWYpSuz3+8jlcpKgZ0+sWq0Gm80Gt9s98fzpuLAHF43LysqKOE2tVmuiqJoEALI2uX6j0UiYbazYbzab+PTTT2WP0SFg7qHf78PtdmN+fh7Xr1+HxWIRRuRFhOhFuVzG9va21LRYLBZUKhU5f2+99RbK5bKcXRoeQnPj8Vhyg9FoFMvLy6hUKshms5JIz+VyWF1dxdtvv43xeIytrS3UajX4fD7Jv7BhsMFgkDxyKBQCcJr3IzTJxqIk+rBXnt/vx927d0UfsmFou92Gz+fD7OwsbDYbZmdnEQwGhUX2tVORmYRm0SGLoEwmk3gvwGlSivRFnTOx2+24efOmeHOsNOVmikajkpgDTmG4paUlAJiAqKjYyNIh64meoMViEdyXUFq73UapVJLaAy4UW5uwR4/JZEKj0RAaHg8fk4O8x4sIE3M0vrqCWBfVkevP66WRJjQDnOVgCOMAZ32d4vE4otGowGRUCkxEEk48ODiA3W7H9vY2MpkMbDYb5ufnBRcmjEHa5J07d6QIrFqtyigD7QCQeUIlwS8qdhYdXkS0R0/lzj5N9XpdoljCIISfdDcHGk9dbKmT5vp7QhVut1von+PxGLOzs/B6vTg4OIDVasXJyYm0KifhgXBGt9sVPJxGgw6BhqQIWzAZzvWih0nYh1HDRYWQMPMjhEz4njxjVKJkJnG9mdNipTc7iK+urkokrhmF/DtdyEgq+XA4lJqzZDIJv9+PXC6H/f19yQUBmHAkWE6gYWEaEp5TRqcWi0Xq1ohiENa6qHFhLqfVaklRNskDzEFrhinhUIvFIueDuUju53q9jr29PTQaDemK7PV6pXCbxpBNVrknx+OxFAMTqjOZTOLE6sJz5juJXuhSCzqnJE8xl8N9TENIR5OFnOeRcxsXzsIoFArSLpyFdqzUT6VSWFhYQL1elyLBfr+PYrEIr9eL3/zN30Sn08HGxga2trZkM7P3F3nctVoN8Xgc8/PzACCHjwVcAKTpJBP0hUIBh4eHMJvN4o0Tr2Sy0GKxyCyIbDYrzeI4A6FarSKfz6NcLmN3d/eVsNtFQ+pMJgPgjGlnt9vFi6EipDImIYIbgaw3wnIaQqASoqG9ceMGrl27JoaR7TD6/T7i8bjMY3j06BEGgwHW19dxcnKC8Xgs3VYJaVL5uFwu/M7v/A76/T4+++wz7O3tCSQ1zR6icaFB46HSLX4uIiz0o4TDYdy8eROj0QiPHz9GvV6fOECEUNj0Uxtz3T2C+Rqd8wAgEZvBYMDm5iY2Nzfxxhtv4O2330an08HDhw+l2rnRaGB7exs/+clPEAqF8E//6T+V+SH7+/uoVCpiVMhW5GeSccUkdqVSmaCWEzEgFHgZIdypR1aQUgtggtmkabOEXILBINLpNIbDIba2tlCtVrG4uIhr164hl8vh448/FkPPKI2UW7KWWOfDSHo8HuO9997D4uIiPv30U+kanEgkYLfbsb+/L8ry5OQEwNloCrvdLvAZa21IDvB4PFheXhbUglAwEYuLyN/93d8BOI0wafzy+bxQ00OhEPb29rC9vS3lDNRbPKOEAJkDymaz+OyzzyT3Ox6PkUqlEAwG0el0pF6QBZbRaBSxWAylUgkvXrxAp9ORPmFmsxmpVArdbhcnJyfodDo4Pj4WAsDq6qrolEqlIvVaehbR7Ows5ufnZW/3ej3JI5EQ9LWzxXTjOSoU3c0VOEs6aw+BsAl/z9fzsOuNQmNDerG2kvRYCbfQA5j2PnUBERO7jGY0lk3Fx9fRq+OBZqEgh4vRM7uogiTWyc1F0Ql6XePAa9PwEq9PFwHqqMZgMMh60ygx3GU0wmdBw8OcFxst0usGzqrUNYvP5XKJN8h10bkVDe8xwtLXfFHRdF39HPXa6HVhlKSLKynTFHr9u2kKuzacmtxA2IHPTkNrhUIBFosFxWJRugdzL5JCqskt00l7XhNzG9NQ40WFVGkW5/EzuW9YHU74kntSEwx0fZN2cKb3KQBpf6/3jB56xnY0zENxbfje02eNn0dnZbpmQ+81APJ7NgPVUfVFpNlsyjN0uVyyZkRKaFS559jKSbPjOMCPyp1fr8q9UQfpHokkLDDyZF6Q+5bvpcktdKK4rpqOrPPajDq1juV7EhV6neaz5zYu6+vrgnkzdHvvvfeEy00Msd1uo9FoCHRGIcPDaDQimUxiaWlpwhNnsjcQCEwYFaPRiFAoJB41Qz0yvMh5Z6J8PB5LZ2EurNfrlWmW7MFVLBYnvA4yPliDwOrse/fuYXZ2FvV6Xd7/IqI3NBUH2Tk0rgxltejNoBluVDakW/NAra+v4/DwUKAIwpKM3nK53IQxYFIxn8/jf/7P/wmXy4Xbt2/D6/XKjAm/3y9OAVtGdDodqcjm+zE/wOumx0n49FVND88rhCSp2CqVivSqMxqNUgjKA85ZNjqCopLXTBl6izwwVKaktxOaAgCfzydD2ebn5yUBSo/66OgI2WwW/+f//B8pouS8mHg8Lolov98vxYmsiqYCoUIaDAaw2Wx45513MDs7K+2KLmNg7ty5A+CsEax2BElxDYfDuH//vsz+aDQasr8qlQpyuZwYPfbrymQyolBpKMxmMxYXF/Hmm2/K2TaZTqfK0oOmw8d28BaLBaurq2g0Gjg6OpLhXkz6x2IxcYQ4j4n5SypwTcb44osvJB8SjUaFUXbRNeR1sDVOo9FANpvFcHg6roOFjiR7cEYQi8QTiQTefPNNdDod7Ozs4PDwUDqEsJiUBka3FgIgkVI2m8Xm5qYMdDMajQJVVioVIW0wp00oazwey15nTdbJyQn29vbQ7Xal7Q/Zah6PB7FYDCaTSaKxcDgsyMd55NzGhfx2HmDNs+bDYs0LIRkOueH3bAs/OzsriwVMju5lAQ8tqdlslg3LxeaC87NoWRlZUGnrKIWwWLfbFciOnhoNBnFZQmk0dqxLuUz7F00xpndNb1iPf9bMEGCSccWNRwVIb0VHBWxKx9wKAMGjdXsZKnu32w23242joyNsbGwIEYDMLCbIm82m5LeoeKc3GZPoOsFKDPyyxoXRKKMWFqvRS2ZRHj3TV/XoohFh1MzoDThLqmviBIs+NeWdDohOcJP+TaVGJUMvNhwOI5lMSq2R1+uVnJ4exMZr499RoS4tLYnTc1GvGzgbaDU91ZJQbK/XQyQSQSwWk3vVEBK7OJhMJqTTaTgcDuTzeeRyOcl/6HZQ0WhUoFbWwDDpzGegITbmDEh2oAPJ6JzRAqNBRuZsXEl2KAsGCY36fD5xrrRnflFh8hw4c3q4nrp8gV0i2KWdLe4594UQIo0jo2LqTd2JgwY7m81id3dXzgFb5dAJKpVKUjROGNbj8QjMNRwOJZ9DZ5k5ZfaNJNFoZmZGrjObzcp1fO3GhTAUDwG9YCadibF6vV6ha47HY2SzWcFRmdDiIdMVvHw44XBYfkeviRgtvQPmdBgS0wtjQ0xCOH6/Hz6fT5KGTHKbTCax9iQX5HI5uN1uGTnKBWQUViwWJbd0EUkmk5Jf4Xox8UmIhApF5wAYfRkMBlkjri3/3mAwSEuZRCIhc3QWFhbQ6XTw4MED6TbLRCIhy2w2K4WjnG9jMBikmJBQQCaTESp3u93G1taWFLqRbcZISkMjuu7hMopxYWEBACTnx1YYJDVQAZEuquEPDSEyma1bbWhjzjWan5/HBx98gF6vhw8//FCePSGwYrGIVquFra0t7O7uCqtQQ5LMYdjtdilWbbfbcDqdODk5kT5QPBs0NrzWXq8nc+APDw+xtbV1qbwVFSENZ6/XE1INnZt+v496vS5dDzqdjig2DRtXKhW0222kUim89957E84O58pTMVGp0mDRwSsUCgK7OJ1OieYYydG4MqrnrBdGKZwWSmVvNp/2wDs+PhbyClsQBQIB5PN5UewXkXfeeQcApI2Nx+PB9evXJ54JGVVmsxlHR0cCZbEeZ2trS0g67Bb/+eefw+VyIZ1Oy1ozX8giVDrazH3Q6dZ1cyzDIMphNBqlq4l2Ytm1m+QcFsbryN5oNMqeJjnL7/fjxo0b5y5EfS3jAkBaUJCmC0Bod2SE6HzGycmJtHBma362HWEiW1cf+/1+pNNpCZW5wTiWk+0duPGp1LTlJ0uK40IJ2Wm2FSnS1WoVDx48QKVSkeE+jAZIpyyVSjg+Psb+/v6FjQvnTx8cHAjkQAiMHpVmaGhlR0oyaYA6v0LlxA0bDoextLSE2dlZ3L59G+VyGc+fPxdslpRPwgP1eh2j0Qj37t3D+++/j9FoJJ0KGOExqgQgnvru7i4ODw/FSDKqJdRCI8Vr1Xmki8jKyooYL21cgLN8IItENYuNURQNMZk3OhqhImfSlZ0ZvvWtb6Fer+Pzzz8XJ4ie5fHxMarVKra2trC5uTlROMzrcTgc0kixUChgPB4jk8lIYSW7NOuOC7qlDo1Lp9NBJpORUbMXlWKxCOCUicn6KEYGOmpixKqNCyFvKstyuQyj0Yh3330X/+Jf/AsAEMfp008/xfr6uhgXk+l08BXhZ7aSoXFlyUC73cbGxoYoUrPZjEQigVQqhUwmg+PjY+loQdjp1q1b0qeMMB4dIcKfwWAQwWBQHKaL7sP33nsPAGRdvF7vRBNNg+GsGwOb9zJyDQaDGA6HAmkNh6etdnK5HJ4+fQq/349OpzPRSoiOLc83HSmiDalUStAYzhHiuHPu92w2i52dHfh8PszPz8NkMiGfzwtxicWRfHZct8FgIIMVGSwEAgHcvn373AjEa7fc10yg6V5hwFmEw5CaYasO0ajkeajI3qHi1AwpwlwM54vFonjwGoYDztrk01sku4HJNL4XsVMeYL5Xr3c6U7zb7U50G+33++IVX/Rwk43B+gEqEE0lJIdfw3m6hoeQmf4ZoUQ2TlxYWBBGHGECep3soEADrJXueDwWTJ+USGLrjO4In/D5Uxil8LPoeVNxkqJ5WUIElTsVI9dNQ4iaqgpAPp8wml5zjfvzb9LpNFKpFJaWlqTv3LVr1wRuIRPo5OREIqBXJbv5OXQa2LSTDhVwlrjn/uJ1MAIgzMZ6mWnywesKPW6+LyNm5jU5Z4hKhU4P0QDtMPB7Mpp4PlnbQeHa0KEieYZOG4kQJpMJ1WpV8hVs4WMwGFAulzEajTAzMzPBgiR8xuiHiXLtgTOHkM1mJ3KxFxHuH1KuqTOY72BUTF3j9XrFoWFxue5W0uudznqJx+MCvzNHwsiSUT+vmyQF0sUJFwIQajTvT0Nng8FAqMuEFEkwIHRIyNvn84lz3+12pZ+Y0+mUQurzyGsbF+KHbDVAbF73yWHFJw84DwthCCrQYDAIv9+PbrcrtD1CL/SGuSij0WkV+qNHj2QRrNbTAUvlclkonlTeXq9XqoEpLDYksYCGjVBduVyWB8AOzgAmvK+LCmsU4vE45ubmUK1WcXBwMNGdlJ4uvXPmZKj4COFQaHwSiQR+53d+B4lEAnfu3EE6nUa73ZahVmTksdN0OBzGvXv3hD0EnEaff/M3fwMAklicnZ1FIpHA0dERPv/8c7RarQnYkoef18iWFK1WSxKtbEdB+O2iyrFUKkmEGo/H0Wq1UCwWJ6AvOhFkt43HY8zMzEiLew3fAWcwHdfW4/Hghz/8IX7wgx/A7/cjmUxiMBjgD//wD1Gr1fDJJ5/gj/7ojwTrp7PCthyEXPTeqtVqmJ2dxTe/+U2YzWZ88cUX0meM10AHhxG2jrI4j57w5Hnx7lfJe++9h8FggBcvXmBnZ0ecP5fLhbfeegvpdBoffvgh/uZv/maCdcTzpmf8cAjV0dER/tf/+l/imNEjJwTDSHxrawsAJDJklw32hms2m3C5XJJfomF/8eIFHj9+jGQyid/+7d+GxWLBw4cPpewgm82i3+9LZ+xsNotSqYRoNIpbt27BYDDg6dOnQt55Va7wvPLkyRN5ZuPxGKFQSCLftbU1FItFJJNJpNNpmEwmJJNJDIdDPH78GDs7OwiFQkin01IeUKlUsLCwgIWFBYTDYdy5c0dGDFMv5XI5jEYj0W2VSgWFQkGcfKfTiXg8LrkqdoLgGR6NTgcgVioVfPrpp/I3unMJo7lms4mVlRVcv34d+/v7ePnyJbrdLu7evStjuJ88eYLRaITf//3f/5XrdW7jwsSRTjgzQUpvhB4yDYjuzaQT9PSAdF0CYStCaroQi8ZJD7IhZ1+/hgeeh5TXpKlzNHhUECxqpKfAa2QUNK1ALyr0dKiEyUbTa6gpg4ST9LVPUwAZjtMoxWIxBINBeL1eABBPTfcfooJiOxZeE+FGAKLE6Q2SocfiMe6FadIBr0fvEZ1/uQydVrcC0bRx4KyDsIY9+ZmkteuOzNOUX3rvLLwjzs/3CYVCUn3OJCz3HfeXpt7r/AP3JK/hVRX2OnLl89A0Xz1a9zKRC/NRGg3gM+KZBSC9uXiGNEWWryFtWLdyJxuJ5A1GFABkzTQ9uF6vi3EhoyscDk84qQAE8qUDybwEkQfmcDRMTgXL11SrVRgMhtdqGT8tPB98RiQJEF6u1WoIBAIS7ekcFbtjMEfMs8DpvSww5TUDkPUfDocTjFBNShiPx4LScB30eSRSQyec10ZGroaHmeznZ/EzXC6X1N3Q8T+PnNu4vPHGGxiNRnjx4oXc5IsXL2CxnI4mnpmZkUVnkonJfg7AmZmZEaYNcw6s1M9ms+JFsWtssViUkN1ms0k/IovFMtFyIhAICA7ebDaxvLwMo9EodD16pQ6HQ/IwOkHK1jCszieZwGA4HRPKVh6v0/pgWjQcobsWs5UGITfO12DoyuJIHkoAoqTC4TCi0ShmZ2cRjUbh9XpxdHSEg4MDqeS12+2IxWLo9XpSCMeOx9VqFaFQSDbPvXv3ZJIn6ZPPnz8XPv1odNoripMACdVww2rYkQr25OREEojaIL2ukO5LIz8ajaQdD9eDMJ/BYBBPrt1uY29vTxqSElYjVs2cAg3I1tYWfvSjH0mNBg+e0Xg6Qvb3fu/3sLe3hx//+Me/VD1ORU3DQwhxd3cXP/nJT2AymSRXo+FYQhw0VHQGtPIkVf4y8tlnn2E0GmFnZwf5fF7Ygt1uFx9++CF+8YtfoFQqyUTJubk52Gw2lEol5HI5BINB/PCHPwQAKaImPAicwdw0CsfHx+IMplIpYSVWKhWBr4fD03kw7BLc6ZwO+VtYWBB4KJVKwel0SvU+uyIQZrJarbhz5w7M5rNBZXTgNNNMJ8svInTWZmZmEI1GhcLNKMbv96Ner+Ojjz6SZ0tFn0ql0O/3sbGxIQZhZmZGCETValX0qXY0Z2ZmJmpomGwnhNntdmG1WoURxzZD1DHPnj3D+vq66GW+N1u9EE2gc7a3tye1cWSLtdtt7O/vSz7pvA7iuY3L4uKiJPLYip0tRFZWViQJryvjSUHsdDrSeI+Hml4M4QRaVUYNNAwWi2WizoXdZpkXYWI+k8kINkvvkUlfl8s1kdyzWq1yXSyM0x1G6/W6QGesbSCN76Ket07Sato0P8Pn80nRnS4EpQcNnPVaY0RI8kMikZDeTfv7+ygUCojH49JGwufzod1uY2lpCUtLSzg+PsaHH34orfbZcTUajaJcLuPFixcol8s4OTkR+IsKsFqtSlRJRc78xTSDjRg4v5+OvF5HyuWyKF46KAz9WWdFY0FY1mw2yxRCvd70fvk8qGRdLpewwtxut3jRrPAOBoNYWlqC3W7HX/3VX0lnXibGKTrnQsVAZ4V7iPuIHibXh9/TuFBJUDleZg23trbEQajVatJ3r9/v49mzZ2g2mwgGg4hEIggEArh58ybsdjs+//xzHBwcIJVK4a233oLBYMCTJ08kMcyonFC4psXv7u7C5XLJ8zg5OcHOzo70ACTNndEPYUYSg1hXwkQ0CRnMYZrNp81b0+m0RCU0KCxApIOgm5heRKgvCEVVKhUZrRCNRuF0OvH06VO8ePFCnrHJZMK1a9ekluz4+BgGgwGzs7MTs5TI1iKUzOmU4XBY+oGRYUYjQZSHxY2MPNrttnQ62djYwM9//nN4vV6srKyIMR6NRjg8PMT6+josltOhZy6XS2j0TqdT5svQCOXzebmO88i5V5pegM/nw/LyMjqdzgS99sWLF+K1cqgM61UYvVAJsQaDbCTN7Wd7e9YQMMFsMpmQy+Um+nEBENZKr9cT74FJQbat0OwJMo2KxaIcVg0RkJdORcDF1MyNi4iOXDh2mD9jDcB0MR2jAUYJ/J6bqtVqSfdU5iTYBZX3QRaJz+fDeDwW54C0WCYp6Qnx+dGRYBSiYSV6PoxYNL6rvwgH6VqRy4iG4Sij0UggRsKcTOKS2cVaEq4dnzeNs67NSKVSSKVSwmYiLdtqtSKRSIiDo/e0pj3TI6d3PB6PZZqf0WgUFh5hM/a241nhl67B0d0HLmNc+Lm6awGNIhPo3PPtdluYiuxp1Ww28eDBA4zHY2mfZDAYpFuz9rg11Eakges/PZud+42lAoSG+DN+T0iJQ8V09+uTk5OJJrO8DlJo6QRdBn3g/Cer1Yrj42OYTKfzmQBItX40GsU3vvGNiRwU851sz0JYmk6J7jSsyUfMlxLOI+WYkSydYc6H4RnjM6UhpE7k8+FzAM4gZjpfzF9xQjCACZLT9evXz71e5zYurGyPx+NYXFyUjVGtVvHnf/7n0i0WANLpNG7fvi3WtFqtChZpMBgkKUw+fa/XE3YZlVKnczqkiFXihHJ0DQyhsFqtJjMMAoGAtPMPh8OiEAjtbGxsIJ/PSyERvYbRaCStKdg6hJAG2/tfprqXD5TJOspoNJK15eGx2+3SkbZQKIjXToWlq9QJEbGb6e3btzEzM4NKpYLj42OhNzLyOzo6Eq+GDgNbc9NTIcRGyIIYLa+BipSb3Ov1SpTKpDYZUMTJNfxzEaFjAkxOlKQnq401Dycpv1SqfHYcBra8vIz33ntPKLNGo1F6sz1//hxPnjwR2igAXLt2DSsrKzg4OJD6AJ2zISTEGfSseQmFQlhdXYXJZML29raQVxgh3bx5Ex6PR/Z0qVTC9vb2RMsgbWAuKrxeKh8qRCZ3jcbT2oa9vT0YDAbs7OzAYjntyBwKhVAsFvHll18CgEBMsVgM165dA3CWCyAcqB2KfD6PYrEoRAk+w/H4bAAd0Q46Kp1OB7FYTJrhsl8W6z9mZmawsLCAdruNJ0+eoFarIZlMShNcnZP1+Xw4OTm5VDnBb//2b2MwGODzzz/H8+fPMTc3h/fffx9Go1ES+ouLi1hZWUGz2cTW1hbq9ToODw9RKBTg9/tx584dgYv1CAcKzzPPLVtsMcIhe1DngcmQY5d5TS3nejNVQYYvmZfMtTAlwH6Cml7Nv7t16xbefPPNr58tphPSnJ3Bg8tFYdhpsVgkR6GTWLqCmolFvcm4MemZ8PXTbd65+XioGQYT7mAYzoXkgdIWXR9UDXfpZC/DWibVeJ8XEd6n9nL1502vA6MCnaeY/mxuDlK9mWRl40Gdh6CS5GfrRo6ayq0LO1n5rA0Kr19DP9PRir4fCvfFRUXf+/Qe4u/1/tIsPK7jdCKfz5Y5G4vFIpEzDxD3H+mkxPvpOeqOshraAiCwJOecszCQz4d5NSp41iuQHcQ9SrjjsrAYFT1zGVr5c32otOjF8vlOU/d1DoOv13tYO4pU9Pw99QidDXrx/X5/oi8gz51O6BMmZwsqdvVl80VdDKibnWrn4qLCPcFnxqie6IdusEviEtdtWgdqdqNuj8Nog6w6PifuMd4XcMaQnH7G1KOc/kkYmddOnd3v94XNR9EIhRb9LM+7B89tXNj2gVHH1tYWfvzjH0tC9M6dO/D5fDKHYWtrS3Ie2tCYTCZks1nZWAaDQTjvrVYLa2tryGQyMuLUaDRK2EiGGGU8HktVNHMGnI+QSCTEALKj6mAwQCgUQiwWE++HB0G3WtCHiMnyy/Z20g+XhpreAdt1M4rr9/sTcJ+uL+B9AxCPOJVK4datWwiHw+JlAhBSxPHxMY6Pj+H3+yVEnp+fR7fbRalUEojh+vXrqNVqePbsGTKZDJaWlvDuu+/i+PgYH3/8sUQ62qCQNk1IRbPfqNQ1Bf2iwi6y9N54oFmzYzabJcrl4eLhZZJT5114YJlnuH//PjwejxTisurbZDJJIdmjR4/w2WefAThtTe7xeCQK1Owgfs4HH3yADz74ADs7O/jLv/xLNBoNzM3NYXFxUbxZ9sjSkKfH48Hc3BwMBoNUlXNC4GWMC4krzLM1m00UCgVpn0RIcWZmRtYGOCOQWK1WYXEtLi4iEAhI6xDNlmNfQa4z55awfRKh14WFhQkDtb6+jk8++QROp1M6Ax8fH+Ply5dIp9P43ve+B5vNhnQ6jZOTE8kZEXqv/H/THTOZDPx+v3ROZ4643+//Unft1xGSbTie3e/3iw7Z29uTkcRM0lPnkeVK9IMGgrOWOCKDs+4J63NNe72eTIfVCIPOy1KPBINBlEolPH/+XOqP2NiSUDZzKNFoVPYZzy7ZpkSKWADMJrYnJyfndrDPbVxYvamrlA8ODtDtdrG8vIxQKIRgMIhwOIxqtYpMJjMRffDGuJGZSKV3oltC8CER3mDORFfa04tgEp8Piy1ovF6vtCohFY84u8fjwWg0kmIvrTCnhTMsOJvjosZF0wg1Pg+cRRH0KLQCBX7ZI6YCpwLUX/S8GdGQsVetVqURI2GQXq+Her2O8XgsjBN6ZSRCzM3NidetsWF9LZrizJ/z/zp5rZO9ryv0AHVURyXB9dPFiXwNk580Ktr7YoTDGiZCChqPZuK01+uJUuGICBaVTd87I6NwOIxbt25JbVi1WsXCwoKMiWCOi0w27dETI6f3SdLFZYwLnz/bIjEXwiiw2+2K16y79fLeaHS5f/x+v9S46eiVFF167tyPnDtP54qdAkj7Z92afqbs1UbH0ePxoNlsipHQkSlzVXRiSUbhvTBavahwhAjRGB1p0oAQ6ufe0nk0Oh165o/dbhf4iwQSMlsZ3epoUBsv7jVG2ppyXy6Xkc1mpfsBjVGv15N6PrbGohMLQAhShMa4d4l86Pk/v0peq3Gl0WjE8+fPkc1mcXBwIK0jiGGT4cWfaxrnaDTC/v4+HA4HYrGYeDGEqJgXIKWZLBtafgo3MBc6FoshnU4LW2o8HmN7exuFQmGiIwC9KjYc1B5vvV6faEFjNBpx7do1MWL0TC9TRKlhPCotHtRX1Tfwe35pOI1sMbaYYBWt3+9HIpEQujG9UbaooMdKFgq9Gk4L5IyXGzduCCvq4OAAxWJRaL9s1zMN42mlTKFxoVKnwr+IkJDAg+vz+SQ5yuS4Lj5k9Tn/T9YRk7pUEvV6HcViEXt7e3A4HNje3pb8wN7enih/wqrcr9oZ0Yff4/Hgzp07CIfDMk9kfn4eP/jBD1AqlVAul7GxsSFeMPeEwWCQugZG/rq+hMOiLiMsKB4MBkJKACDsOlJ7mStltB2JRMTDXllZkTzX/v4+XC4XotGoRG50JnlvXH8Wg7Img6wng8GAo6MjqRPhoCr+jd1uRzKZhNVqxYsXL2C1WrG7u4tisSgKdDw+LZbleHNGqoQzWU5QLpdRLBYv7CCSRuxwOHDz5k14vV5pqTM3NydTKbV3bzSedoFn+xnmbwmZcjAhmY1kbrFVFufV1Go1YUZqtqQWDipjhMyGlST2UAc5HA54vV5xRFlCQCTj0aNH8Pv9WF5ehtPpxOHhoTiQujj+V8lrJfT5r8Fw2kSR1o4Hnq+hUeECkPpG48K8Cb00zYaYmZmR8anFYhFWq1WYJrr3Ejc/B2DRexyNRtje3obZbMbNmzelLxnZOCQH0KDxbwihdbtd+Hw+MS7svcM2DRf1HHXOhjg/KbQ0Ljo6oVGhIdKdc/k3zWYTh4eHMkPe7XajVCpJ6xfecywWg8/nAwBRYoFAQGjQzWYT+/v7ePz4MVwuF95//32EQiG8ePFCZsSzeJKeqjZ69FypcPUa0cOaZsW8rjCqolHgMzKbzQIdAWeRlIZpRqPTolA2DyTTi4bDaDTKCOC///u/x4sXL8RYcc20oZzO4Wgja7VacevWLSwsLGBpaUlGc3//+99HoVDAn/zJn0irff3+hI8cDge63S62t7eFjeT1elEqlS6lGIHT5qmj0QiZTEY6QABnrCIAkrMky81gMCAajU44L81mE3/7t3+Lw8NDLC0tIRqNyn4mLEaIl3kIthSKx+NwuVwTeZ9MJoP9/X3pvsA2J/V6HTabDYlEAiaTCWtraxgOhzLpcWdnB8+ePUMkEsHv/d7vYWZmBqFQCIFAAJlMBl988QWGw6EoaubILrqGm5ubQiOem5uTgWAmkwlzc3Pw+XzY39+XZ8ccUTKZhNPpxNbWltTW8TyTKcqfMe/CSCQSiQg0BUByyRrFYZueer0u6Mrs7CxSqRQODw+RyWQmziejJToUjMIajQa2trawt7eHO3fu4N69e+LITtPNzyOvVaEPnOH9NBxU0vy/5uwbjUaBavThI/TC0JBNMGldPR6PWFJ6iyQJNJtN8bTs9tM50lSUOjfBa2EISwNISI7QBbHler0uo5OJSwJnDBgu7EVlOpnNzUQlpUN3m80mXhDDfE3nJZwQjUZlTghxWipMFphSSXLz1et18Vr4Gv4d+z+RqszeT0ajEcFgUPJBvE5NhKCnxuQujalOqLLe5SJC48HPpmdrMp32pGIil84Hn9V08piFacCpt7m8vCwwL6E/QjqkWBNeJOyhyQDLy8sAIO3K2cr88PAQyWRS1kzDI4PBQNqyk6nGqEtXcAOQliu6EedFZW9vD+Px6TRZwqQsBszn80KXpVFm/kqPMyAezwjEYDgtPtYIhSaOkC4bCoWEkp1IJESpcb8zV8v14hqTpMP8LWs+WC2fSCSEecr+YWwBQ0XLQmE2Nr1ozoXNMQEI5M9zTcZWt9sVR4yMT0b8ZrNZBqQxd0V4Vre0IsGBPdG046vPGfcE98w0+0znWTSRQEcsLE7mc2B0H4lEhLnH9lHj8Vgo/ueRcxsXhmC0gDwcrDDXtSVUZOPxWMJFRiL0dPv9voR4+Xwen376KZrNJu7evYu5uTmp4eBD4QyM4+NjBAIBzM3Nwe/3Y2FhAel0eqKdiV5IJqNYgMXrJ0uDuSPOQIlEIjg8PMQvfvEL9Ho9JBIJ6cHDXmoXEW5qHh7S/4Cz/AShBK/Xi3fffRderxePHz/G9va2YN4OhwNLS0uC59+5cweDwUCgG+Kp7NjKTdput/Hs2TM8f/4cs7Oz0pafBZizs7NYWlpCPp/HX//1X+Po6EgiJI/Hg4WFhQlsnpRI4KyynIlZKmnt3Wu2yUWEHbh5kCqVCjY2NgCcHmxdc8IBaDSgrAUolUpwOp147733pAdUOp1GJpPBj370IxkPwQQ627lz5MPa2pokcE0mE3w+H37rt34Ld+7cwdraGn7xi1+gVqvh+fPnUgy4tLSEWq2GarU6kQPkwLxms4lnz55JsSTbpPCLVHR6s5eRv/qrv5p4Fjdu3MBbb70FAPjRj36EcrkMAFKXsb29LQlyrimNtc/nEwNxdHQkXQ5IwOn3+9IZw+124/bt2zLXJplMolarSQQXDAYRCoVwcHAg3ZSp2Jjs5vVwTkuj0UA6nca3v/1tDIdD6YWlixGNRiPcbjdWVlYQi8UmFPdFhJ258/k89vf3hUQ0HA6xtraGcrksDovD4UA4HIbJZMLOzg5OTk5gsVjw1ltvCQzF8z4YDOD1enHnzh243W4x0CcnJ9jc3JxgP/IegMnJnCSxcH/SCLHgVDcDjsfjMsLk008/hd1ux7Vr16TQ3Ww2SyEnIWiOuWcR6Hnk3LtVM5WoJDT2R7iLSXheABNzDPl00lPj5IS8DAaDJKgYIvL10yEjP0/TSAEILEJFrr1HreQI13Gz6TkIhM/IHqKCvmjOgH83nfTV2L3Oy+geSvw7HhgmSXVikP2+6MGYzWZR8DxwDJt9Ph8ajQacTudEMSTbfPN50GPhl07u8h4omnTwqs13UW+RQi+Na8XoF8AEVZ3wld4/ut8ZE9rsw+bz+aTvlH5W0/uMe00TFcbjsXT71uMmWFdFBUJ4iC35+RlM6k/vCb1PdHR4GUIEACEfsMsB35P/EqrmOpNkw/PIbhpcG1JieU88S4wUuXZsL8TW81wnriX3MqnWmiTCnAH3L9eRz9vlck38vl6vo9lswmq1So89HfXzzF9EaJgIZzFnBJyNVObzJKTNQk7WoRDF0RE4HQnCokRXyIDT+VbqMn3WuC9ohIAzh0/vKV3cSvoz85HUIRyvoKF44Ax50Z0ofpW8titESppuOskq0GKxiJ2dHYFmgLP6AzY9M5tPZzRwU7x8+RLD4RA3btwAAJlrEAqF8I1vfEM8QfY8Yr+jQCAAi8WCXC6HSqWCWCyGxcVFAJjo3QRAEtesOif2T4bZ7du30ev1cPv2bUlYJpNJVCoVlEol8Wg5Vvff/Jt/87rLJsqI+CbrHbim3Gzj8WnF/vPnz2XSHw8ijQ1rLbLZLB48eCCtOmw2G8rlMo6OjnByciKFeOztxaLLYrGIv//7v5dZ4FarFZFIBLOzsxiPx3jzzTdx69YteL1euN1u1Go17O3toV6vC71yNBpNQKUaCtFQmc5R6I3+ujJt1MmoAiCHkdLr9WRglG4sSYVFh6jZbGJ3dxedTgf37t3D8vLyxAEDIElOGifSvNls8Y/+6I/wt3/7t2KwzGYzlpaWpMkno+bHjx+jWCxKtTs7dOt6CTpoVBJ6rbQxvaiQUry6uoqFhQX0+338+Mc/BgC43W68+eabYsxIS7ZarTLe1mAwYG9vDxaLRVriJJNJBAIBdDodnJycoN/vS74JgER477zzDhKJhKwtlSyh7m63i0gkguXlZTQaDezu7koXbz47Dfm4XC40m02sra1N5C7YOobzS1h8yLUma/QiQsOSyWTw7NkzaZFvt9sxPz+P+fl5tNttPH36FC6XS8YGb21tYWdnRzpJj0YjmU1F+vzMzAwWFxfR7/cnYF5G5ey9pp29YDAIh8OB2dlZBINB5HI5iXKj0ag4L41GQ8hPzJd3Oh0EAgG88cYbkuuyWq3IZDLI5XLCWiNkD0DQif8nkQs3XavVkmQcvQ5OkstkMlIECZwyTajYmWdhQimbzUqTudnZWQmz2dtmeXkZpVIJ6+vr6PV6SKVSSCaTAM6Kolidrbv46poaftEaE5Zj8RAb4xkMBmlIx0pi4rs0MsfHx6+7H0WoXKk46BUDEIoivwhFWCyWCY+c5IdqtSp07+FwiHQ6LUPR2KeJRozJQL0erVYLL1++nNgk169fFy9zbm5uwiPf29vD5uamNPXUleMM61/FGNPRFnDm4V5EdOSsabGMaKdJBPTSNUGCbV64b8nCIUNnOBzKSAadq2JfMOYcOp2O5KOOjo4wHA7x5ptviuMTiUTQ6XQmcmD7+/syD55ECz4nzQJkUny6TQeN0GWExnZmZga3b9/G5uYmPv/8cwDAN7/5TczOzqJWq0lPP+4Xr9eLUCgkdTG6ZQ0nnhKO7fV6UnFPj9vn82FhYQGpVEqMF8sLaJTYJYIEHHbnYLsiHQnQIep2u3ImuU7sEccRy2RhsTegLrx9XeH9VKtVcV4YyZGosLGxgYODA4EDrVYr8vm8wGI8K9VqVa6rWCxKTs9isaBarUqlPIkQh4eHqNfr4oBwyiZ1GJtmcm2ZV2WDUhojABIVcZ20o0tHkjlHQmSksWvk4lfut/MuLBWDLvAh/ESYhi1YCAUYDAYp6iuVSjIhjsVXxBoZqjJnwJCTnZC9Xi/i8bgk26lc2GoDOI146KXQcHAh2L2VG5AdRNlllYeOfG7mPQBMTIFkEeFFhO/Lh0+PQMOMwBkcQholDwPzHmSH6Cp/j8cjG4L5I51UJ/lBDzki44StXlgQNhqNkEwmpRaD73/z5k2USiWJinithBoIYUwPtaKCJ3ngosL3o+dEIsg0zMlr5s8IffE5BwIBmVNDOI3zhDqdDpxOJ+bm5oSuyWc3GAxwcnKC4+NjYc/o4luyaGw2G65fvw6j0YiVlRXJU/zar/2atE/JZDJCMrHb7bh3754wJOlV0hOnkNp/GXjx137t1wCcRhMvX76UflR0WHiOOTGSSiWVSknh5+7urjgonOfCWhk6mkwWs+bM4XBIA1NOUaSTRwKFpszyi/tc094NhtP2UayxKRaLsFgsMiaBEJ7RaJQzT7ICleNFZX19HePxWKJTjilmXsNutyOXy8lzY5W97sZMB4wONl9rNpuxu7srOT/mMwFI8Tdr0+g00kgw6U8iAxv0MgrSHbs1VMz/MxpjUEBjQ1KRLpnQe/JXyWsZF4PBIJXJtVpNKtbpcSUSCXg8HrkR1lP4/X60Wi0cHx8LTt1oNOD3+xEKhQQvJJyRzWal6IqbiS0f6IEz38PEUyAQEH6+ruQfj0+bNb58+RKDwQCrq6uIxWLY3d0V793n8wnVmEn2aDQqBstisWB7e1soqhcRMrEINQAQRczEt9747B9Ezz8cDuO9996D2Wz+pcaC1WoVT548EdYbm4HyoLPyN5vNyqQ6EiBWVlYwPz+ParWKbDaLXu90Ol4oFBJPLRQK4YMPPkClUsGjR4/w8uVLiRaY8DebzeKJa8MGQKDTQCBwobUDzjxT3pPJZJpI4pPNR7YL6dI3btyQXnh81jdu3MDc3Jwc0EwmgydPnqBarcLv9wu9fXV1FcApmaDZbOLhw4eiBAFMeMF0kvx+P1ZXV+H3+xGJRBAOh6UGo1gsSiRTKpUE6v0n/+SfYHZ2Fg8ePMCLFy/k+fZ6PVH+zBlcRv71v/7X6PV6+Nu//Vt89NFH8r5ms1lgmuXlZenYy15e165dw927dyXaGo1GSKVSsNlsyGQy0juQQ6W4b7xeL1ZXVzEejyUJvri4KEWAzKEwT8J8CluXcIiVzrsajact7+fm5rC2tiYdlmdmZhAOhyWHy9ERnU4HBwcHE3OgLipffPEFjMbT4Xz3799HpVLB/v6+9ANkflTvCVJ+2W2EepR1fdrIPH78WPIwvV5P+iOyoardbsf+/r7UnRDi297elqr7bDYrkU2r1UIul5OxADpfS/1psZx2qd/Y2BAyAJ32xcVF2Gw2cXRfBdf+Y3Ju40LaIacNMrxnwROn/OkDwKIqen7TVdY0QoxauPB2u102Mt+HdFEqVTZ0oxLVCSxuVCpmwjga2jMajRLqUVGSjkuvgdfG17PS9esWnUjVISfXgok+XZVLT50/Jz6qcWW+npXrOmqi183P1xW+fC3XW0OQpNFqMgINiSZJUJnTEJhMpgn22OsKDRPfT8NxwBnjTl+TjqDojblcLqG1MjJk5MGIlbUEejSvy+VCKBTCzMwMyuUySqWSVM6TOakJLoyyy+UyarWaTOJkvmI0GkkdB0dOkNWj4cOvIkhcRGq1msBw+ixyLXlW2EmDTkKtVpPRx2x0qLtqMIHO6EB3NtC1WVTAmvlIBhQVs4ZdvwqCYVRDJU1nkuSV6UiIe501UheNXgiBaao0u31wX+oehlxbRu1EVnj/XCcdRWjFTd1GtIKMMTq8VPakiuvzxvXRRCoNXTP/yyiJz4g6k3qHqASfJfMv55HXGham8wK0xMPhcKJ3Fect82EfHx9L/6FEIiEKkwqAlfHs/UVPb21tDT/72c/Q7/elFQZDwlAohHA4LNW4rPYFIJTbbDYrnsNwOEQ4HBYKYDabhcPhwFtvvSWHh4rg2bNnsnn7/b70OSMF+KIbU9NI6WnTqBBL5qHloTeZTJifn5ecECnJvAafzzfhHXc6HfziF7/A+vq65MbG47F0/GU9Qa/Xk55irPy22WwyoGk8Hgv2enBwgEqlgu3tbcnnRKNRwcPJkjEYDDIDhVi6wXDGqdckj4sIIR0qinw+j7W1NamDosFj0R4NQ6FQECw/kUjAarVia2sL29vb4hyRIkoDOB6Psbu7iz/90z+F3W7HN77xDcRiMbz33nt455138PjxY3z55ZcolUq4f/8+ZmdnEY/HBWf3+XzweDxShHp0dIRPPvkE/X4fN2/exK//+q/LsLput4sf//jHE7UwVIA0VlT6r+M1vkr++I//WPbi8vKyGA0aiuHwtDnn4eEharUaCoUCGo0GfvSjH+GnP/0prFYrZmdnYTAYJN/BHn36eS8sLCCRSKDT6eDo6AhOp1Oo4axMNxqN0t+OzhLzPYTFyV6ksibCsb+/L6PN33vvPYkIstkstre3kclkJIqkgdSG86LC0d1klAaDQXzrW9+acG63trakkr/T6cBisUjNCJ1o4CwCpx602+1CA2adGYlSHC9cKpWQTqcxPz8v0RkZrW63W4wY14KRPWnjdLhpdEulkuSzOMeHOomFrhaLRTpW68Li88i5jQsfFBOLjB6YJ+FC+v3+CXYQWQ/AWW8jbhJeLC3oYDCQIVdGo1FayZC5wgPmcrkm8i70AABII0WyrICzGemarkfoR7eZ4RejFV5XvV4XauNFvcivikx0/oNenvZuOGmTih2AYMs0GFwDtpXgpqVXrhPGNOzaw+fm1n/b7XZRrVYlrF5bW0O325XaEUZH/KJxITWanhQ7NWhv+CISDocBYKIoltdPzw84Mz68JiprOkQmk0n2FSNCr9cr+QXCUUzusxCVDCeXyyVYfq/Xk/5uTN5quKFarWJnZwcHBwd4/vw5AODmzZsIh8PodDool8sC2VarVUEF6LnzoPPrslHMwcEBTKbT2e7hcHiCOEAlTLhFnwcqsXg8PjGXRjthHKNL4g3PEHsSUlHq3oBU0twj9LTpbdPp0rRbIhOE3SKRCIbDIfL5vLCr2FOLz5tnbRqufV0hgsGIjZC9HslMA8S92O/3Jwb2cfYQ9ywNE4fRETnQ0DX7GuZyOSEOdLvdibHLumqfeRjm9LgOvH6NaLDgOhKJSN6QkQujKXZZ0VTn88i5jcva2hrG47FMSyQVlHRCDmSiYiJswM3BQ66JAJVKRRQmDySLxjqdDm7cuCFRTb1eF8/H6XSi3W4L5c7tdk9gq/SgSMNlZT4AqcInPEAPjJ4uNzi9fm1ULuN5c+CRrlvgQ+YG4IwVsnHobezv7wOAbEr2ZtIzHjgjZHFxEalUCtvb2/j8888lbOYGbLfbiEaj+K3f+i2BcsgI0pPnWq0WNjY2sL29LUrUbDZPNLKb5s8zOtEsJ9aQEEK4qNAbZMLbarVKNM2+VSxWDAQC+Na3vgX//zeXnIf/8PAQNpsNs7OzcLvdKBQKMmabnmSxWBSY5w/+4A8E77bZbFIFXqvVsLCwIBFjJBKB0+mcqIEAIJ20h8Mh7t+/j9HodMTw9va2ePyEHnluaJS5X5i8jcfjmJmZuVTe5caNGwJtOxyOicp49hojuYPV5Ha7XaJ+NgelU8Ti1MFgIM6aw+FANptFPp/H6uoqbty4Ia3xgTM679HRET788EPU63WBFvX9szsvPWgd0c3MzEiLo2KxiG63i5OTE4Gzed38TN3MlT+7iLz33nsAzhyYQqGAzz//XPrJRSIRqQ/RkWgul0OhUBB6L88iIwQW6wYCATH2drsd+XweL168kDV2uVyo1+vY3NyEy+WSPEwsFpOJomTO8lnQoNGBpNGmgeeEXtKkafSYIjCbzYjH4wiFQsjlctLL7TxybuPCEakHBwc4OTmRxnxms1m8PRoXUmlZr0KWA+EnTjar1WoybpUhYT6fR7VahdvtxvXr1+VAN5tN8TDJfOJDYvjMTsw8nIya2EYBAJaXlyWsZz6ILAtCVfTajUYjFhYWpLr+Mo0DSZslJktDQ5yUG4f1ESQZ0BtzOBySOCcLRxMDCG/cvHkTMzMzsNvtePLkCQCIV818TDgcxh/8wR8gGo3i8ePHODg4kAR0o9HA06dPkc1msbm5ie3tbfHOgVNjwYmcOsKicSF2T5iKXX0DgYC8x0Vkc3MTAGSNlpaWhOCwu7sr3RxarRaSySR+/dd/HbOzs0JLL5VKMnL33r17SKfTaLfbWF9fF7jAZDLJuOy3334bv/u7vysOD7vzkhJKViQbhbIOhgVzdMROTk7g8/lw69YtDIdD/PVf/zWeP38uUbcuqKMhIbyhHbdwOIx33nnnUlX6bFWj6cAejwf9fh/r6+soFovSIsVsPm30qbF3OhYAJqJFwk5+vx8OhwM7OzvIZrOIRqPS1063hxmPTyu9/+Iv/gKlUgnvvvsuFhYWJtinHHfAWjTdx4tV/vTm2Qqe8HUoFJLEtYboaTgvCm0TRt/d3UUmk0GxWEQmk5ERwuxYQsNCZKZQKGBvb08aaGpGm9/vn2hfRbHZbDg4OJBmsiQucahXKpXCG2+8gUAgILqCUSbZYna7XYaSEXVijodOM/M3ZIcyAuLeZVQVjUZRKpWEpn8eOfdOjcfjEwkqtoOhdZ6uJOaMEh2a6r5KVEgML6f75NDakv5Li8uNTo+bnHMuKpUblTY3Fj+PbCC2neHcGK/XK5xzhoLsNkBa9WVEt3oglEOPml6CXhuG1Ebj6RRIt9uNSCQia88Eqc438RlwDjb7gTEi4/u4XC60223U63WBMvWQLE0w4DXrAj7N16dwvTUkp+mPl11HzaxjwpKjGZhsBoBYLCYNPJlDYbTMfViv14WuHQ6HYbVapXO0wWCQKI4KQCdECZnxvfha0u+Zr2KNApPc+Xxe6LmpVEoYUWSwEbbQ+QEAcrjb7bY017yonJycwGQyIZFIIBQKoV6vixPIvAkNHD3eRqMha9hqtSR6J9sJgKwL56mMx2OBrnmPg8FAoC/urUgkAqPRKI1Ts9msKC+eYV4Pqc404lwr6iQNo1H/zMzMyNrzOvQU2NcVkkAqlYqMFyd7lnR25owIvzKqi8fjwj5lSkH3Z9T1YDxzzNf0ej25N+ZX2Plck2y0gWKXaUKafBaE0EmbJ0zGNScqQt1jMBikFRfzN+clNZ3buLz99ttC663X69Kcj544vVbg1Oomk8lfYuxQAdB6k6fe6/UEBqJ3XSqVROGSHsvmc/TsjEajdCENBAJiNOhlESu0Wq3I5XIwm81YWVnBzZs3sbm5iUePHgm92u/34/DwEF9++SWSySTeeustYcVVq9UJg3oRYcjOCI8dZoHTQWwcxsamd2wVws3L6mUqduA0DxaNRmGxWASWefjwoeRHbty4IVFks9lELBaT9umZTEYgifn5eTHcg8Fgok8b4RpdwMdJirwOKgw94yObzUquglGMHp3wusJRz3RYKpUKfvazn4lHNhwOMTc3hzfeeANmsxnPnj2DyWSSyJn9qoxGI46OjlCtVuFyuXDt2jW43W6kUilZ916vJx0gNIWTTg+T14TYbt26JRBYv9+XcRT7+/vI5/MolUrI5XKwWCyIRqNYWFjAxsYGHj9+LNXdbrdbFBMHNXGtCf/8/d///YXXDzil0lqtVly7dg3f/va38emnn+J//+//Lfub+4/P8OTkBI1GQ6DFSqWCTCYDk8kkEb2GAre2tiYq+s1msyT0OT+Gzst4PBY678OHD/H5559LZMTcz3g8ljoROlnTz4FeNGFbOkbJZBI/+MEPYDKZ8Mknn+Dg4EDGK1xUDg8PMRwOsbe3h729PSwsLODdd9+VZqXsl8Z18/l88Pl8SKfT0oFkPD7ta5hIJH5pvo1u4USI8u7du+h0Osjlcuh0OlhcXMTNmzcn+ghSxyYSCSwtLcFgMGB/f1/2I6NpXcZBBiSdNhrOZDIpRcB0qrLZrHQb4HCx88i5jQtDeNaekIPP31GYjGMho06Q8vXaG2RCmcqLGDT57rpIjp4rLScJAwyH9ftqpcDEGX+vKdJMcut+S0wy6hGglym+omi2HTA5B4SdZnXzTf0Quab0OgAIhsyEISmRZOQRPmQ+ibAiixnpgXNtdFU6I0A91Iprykhomiqq6zG+6j4vKtNeL9eMiWO+P58/vTUeClItGSGwlQb3AzF5esFcR8KXupIewMS9awyaFGNGJlQc9ETD4bA8Q723eB3ae9WRHyPNy7DF6LWTnsuiOeYjyeqbdiZ4PToipbfL6IEKUXvBjGgIndNRIWLB++71esIKI1zNZ8tnzkidjgqvkZ+n4Vn9jLiuWqledA01AUf3nGO0rinKAIQsZDKZJBrgM2AdHyn/+jOokzRBhzRoIg+aek/9SkIQo2w+B11+wMifehU4m45LtGSaqKP11uus3bmNy5MnT0RBMQFHjjkhsG63i8PDQ6EjWiwWPH78GLu7u7Db7YhGo+LBUuERh6dXsL+/j0KhMNHSmxuaJAEWarGgkE0YAYgnO13rwb46uVxOEpi8h/n5eXg8HmmvwJyH1WqVflG85otuTN2Hi4fj6OhIDDDvh803dfdfsvMqlQqcTqe0L08kEpiZmZGczXg8xttvv435+XnZHCQ6NBoNhEIhhEIhSeQS9gEg3nW5XMbW1haKxSIcDgfu3LkjA67o5QCQaneSJVjrRMU+HeLrJP9F5N1335WEONla+oAAQLFYxNOnT+H3+3Hz5k3BqA8PDxEKhTA/Py+RLF+fzWYRDAYFDmDEnEwmEQqFZE+Tus29xyTzixcvcHx8LJFtvV7Hw4cPkc1mcXR0NAErEQJi5MV9sLu7K2xIrhUdNioEHvrLGBeegc8++wzPnz+XyJU1KaPRSEaCA5BecxqBoCEig4l1YXROqBhJ/6dhZl+6QqGAUqmEWq2Go6MjgQ+1YdeGjGMOAoEAUqmUkAjYf4tjF6jkWbexvr4u3jcNYCgUulQ5wd27dzEej7GysiL3TOWuc8E0cHQUyTrlGAuXy4Xr168jGo3KlFgSmqxWK1ZWVuBwOJDJZKT1FZ+FxWIR2C2dTmM8Pi1QJcTNvZNKpaR4k0Xrh4eHGI/H4mDSwBEGJXTu8XjQ6/VkiNndu3exuLiIzc1NPHz4EMPhEH/4h3/4K9fr3MaFrZZNJpNYTnbW5Hxs3RqElr3dbuP4+BixWEzmaLB3DmtUWHfR6XSkQp8JKY2bkzUxGAwmLDo3OA8APW1N3SRTiV4l+3ux547f70c6nZ6om9D5CM47v6iCpDejCzsJfejXsIBUEw50hEa6odvtFhiKnpTRaEQ6nZZDzfdhk0Y29KMXB5x5saQvlstlYewlk0nEYjG5Pio6bnI2YGR+THeG1caFioJK6iKSTqcxHA6Fv/8qYfKebBuPxyP4OI0HO9vSyWHFOQ0jCQskcZDVmM/nBZZjBDkajYRBE41GkU6nxRiRucjnyMiPU1sZBQ2HZ0P26I1yH+jI/jJrR2HBH+E6Jr+psAlvs5qd7CfOKeGsEl2USJYozxkhGDILtZPDfOD+/v5EvkcX+vF96HnT4FJR2mw2afaouzQzD0kvnHvYbDZL5xC3243Z2dkL563Y15BOWaVSwe7uLgaDgew35kh4LngvpGWzDQ6JSKw70ZFCNBqVfFQ+n5e8DT+TBB+SHogOMSojUcBsNkutXz6fRy6XQ6/XE0KQ7hbCteO5Zo6GrOBYLIbNzU0cHh6em458buPCSYYsQhyPxxORRaPRkE1Ia8y6CCbWSKkFIFRIVpoCmFBahGqYZNJFh0w8m81maS8zHo/x+PFjee9kMineOOdT00MDINAICwTdbjfy+bwoLioBNunUbb4vIrplCHBWea0VBg+m9lSplAgTGgwG6f9DJhFJFsDkGGjWITAx2+l0ZKId19Lv90t4ToPEvzk+PpbCNg2LAadKsdFoyGdzk1K5E0LQSfjLMJ02NjakOJIeGt+XjgYj1maziY2NDTgcDolECLWSWsv9xymKBwcHkpOx2+0ol8v4xS9+gWaziUePHkndFEkmjID5LI+OjmTeyMnJiUxqnSa6kKFDw8bcDQ0ODZ+GpfS9XkZWV1fFYSkUCtI/ymQyCb2c0QudM7KfeN9sEcKKc5YEAGfTVml8ms2mNGzU78EGtWRQMgKic2IymSZYVWQ3MW/A5D5puCyYZCsiKnBGizQs7XYb29vbF14/5jeKxSKq1aqcFRZQki1GJ5WOC0cN8Dlz2iifAVvk8HxRN7FodTqnTWeQxtPn8wlTz2KxSDPQYrGIUCiEYDAozjzLF2j4qIOYBtBM33Q6LZBfoVCAwWBAIpE4N7x97tPOXlOaXsmmfDQk9CYMBoMMZvJ6vbh27ZokywFgaWlJNgM3L5Usi9WYxGP0wCKe0WgkyTsmD+12O7a3t/EP//APcLlc+MY3viHNMg8ODhCPx2WAj4ZwuFmfPXsmlpuKnd44hYt/UbYTH+Z0URgVMABhjRGKoNB4s4aEtSPsyTQajSSPoj0+GiRSvtmvicrKZrPh1q1bmJ2dFaVGmKter6NQKIiC5DOi10ZDaLFYJFnL99c5C0Ysl12/Bw8eAJhsMUOWTDweh8/nEzpqrVbDo0ePYDQaJ9oKPX78GE6nE/fv30csFsO1a9cwOzuLZrOJ9fV1DAYDLC8vIx6P4/j4WIaDra+vCxOKnrZmMfI+uUba+9ZQltFoRCAQQDAYlLEJpM1rMgE9fS3MG1yGtfj222+j3+/LECpN5mCdC2n5ACSa0556oVCAyWSSiJ51WXRMeH6oXNnokkXSHo9H8oN0akgOooJ1u91YXl6WkcU+nw/lclk6TxACY7RIQovRaEQul0OxWJRnROiddSPr6+sXRh+Ojo4wGAzw8OFDbGxswOPxyOAtRns3b97E6uqq9Ens9/uIx+MIBALodruSBiCik0qlcOPGDRkzwBqZRqMBu92OlZUV9Ho9HB0dSacNIjOtVkvOcCqVEqdwMBhgd3cXBwcHwkykEQLOiieZ47LZbDIOoV6vI5fLIRAI4Nq1a4KkELlaWFg4dwR9buNSrVYBnFVIaxx9OlFlNBoFoyZkQ0MDQDxE4KwVCq0+oS8qJ50k1p4lYSvSa4kd04vS9GUAUm9BZUcvkoqTdD/d+VOH23zPi25MFm+9Ct7QSXIm4aiIdUKZVen0iDhpkhAbE6U6+awppDQUNGL0EIHTnEuj0ZD8j07C65CdydVpkoWGzPgzHZldJCE4vX5cC72G9PI1ew04a7TKZ066OftZ0QsvFApCtSTG73a7Ua1WUSwWUa/XUa1WZXicToZzj9HbJMmFjtGr8iT0drVhetX6vYoowb18UeGYgOFwOMHC4nVxzpBuPsn9TrZWKpWSPaC9aULMJJ7QadT7UnflYITJn0/vG9a3EBYn8093EOC+4H4krMOcAe+NUSprxS56hvmMeK92u10o/JqMo50KXpc2CJr5pqN8nftinlX3ctP0dE104vsSqdCOCdEfkimoa+nMsNUOoy+9t+kQUr8zb3ReObdx+fzzzyX045wKshxIobRarZiZmUGtVsPnn3+ObreLt956SzxEn8+H4XA4wSrhInLQl8fjkap6cq0JqTAhTaNhsViklcVgMECxWJTFZpKM9Tlsv8FkeCAQwMrKChqNBh4/foxarSbt5xnRWCwW3Lt3D/F4HLu7u5fyelKpFIDTJDK7CNCo8DDS+yUv3mazSVEpB35ZracDfUimuHHjBqrVKp49eyaUbubEeDD39/dxcHAAn88Hr9eLarUq1M8XL17A5/NNKAzmLDSWTieAtTU0QuPxWXGphnUo/H7aq39dWV1dxWh0VsTL9aNXReqzFiqr0eh0jMC3v/1tGI1G7O3tCeTHiIUJTe6jTCYj1dGso6KS0JEljQvvnbUINpsNlUplognqcDiU+fWj0Uiq8DUrkq/lYdc1W8zDXFT+7M/+DMDpM0mn0xJBsNCvXC4jEong3r17aDab2NzclNb6DocDy8vLuH37NjqdDn70ox9hb29PnEq3242FhQVhOXFNnz59OkEK4DrpSLndbosSZS7U7/cjHA4LwSAQCOA73/kORqMRfvKTn2B9fV1mRY3HY4Ep2UmYCpGQDyF06pmLCO9hdnZW9EgoFJpgnDocDimvoEPL2p1SqYT9/X1YLBbcvXtXGGQsuaBxYjEwz/h4PJZO2qPRSCjg3IPc//wZIxz2uPN6vWg0GgL9/uZv/iauX7+OYrEo0RXberHmid0trFYrtre3Za4O68POI+c2LvRAWNSl8wFMYLEbLLu8Enfm35AGSi+PG40sBVLteKP0ErQSZvdfenIkBbjdbvFKeE18P3qm4/FYrDbxWS4UPV0aLcJugUAAsVhsYhrhRYSe96vyDjQE0+uhPSEeWK4HKcb0WpgvItSoaZ6sS7JYLDIBlHNzBoOBQJg8qIzsphUZ2Ty6nkArXB2Z0Ahrj/QybDH2+JpeP+ajuLZUytNRE1tcAMDe3p5EeIwGSWMmi5DdjNnlQSddpyMwfe88Izo61zRZnhVeK6NDCo24jtq51/V7XkSy2axAc+y9BZxNuWTXC91DT0esbrcb6XRacn48/3T2+J6sQWHErKMfFmpqWjlzrXxmVNZkOZGBFYlE5PMYQfLcaMPElv48OyxMvgwsy3UCMNGpnExZGjAmwhmp8OzynLKXF6NaGkEiFlxXjQ5pkhJwVhbC+9OTWOms6D3DSIcwttPpnGDuUt8CZ5E1zxrXmp0BCM2fR85tXMheiEajCAaDqFQq+Pjjj2EwGLC8vIz5+Xl5rcPhkC69VFjFYhF7e3uS7xgMBlJkxAdCzzgWi01YZh44LpzX60U6nRbmD5OtyWRSiotID5ydnZVRsxp6qFQq0i8tmUxKASZDcg7KIZ7s8/lw7dq1CytIzlRgKwbeF//VkAGjOio9RnCE7Agdsr0L4QcmR/1+P8rlshRKbmxsSJdbFpNxM5E5xy7HDJ91bQeVpsFgECU7bYC0V8rvqVSpIDUb6HVla2sLwCmkurCwgFarhUKhMHEdwWBQcoONRkP6jbHH3CeffALgFDtvNpuYmZlBOp1GvV7Hy5cvxYCzPT7H9vKeX3Wo9D3x0LMyn14m2xuR1KK9P3b2dbvdePbsmdwnnznhXxY3Xsa4vPHGGwAgLT80FFuv15HP56XBItEFneBnC6jxeCxRM41kr9ebGJTFZ84uyNFoVKJhtlfiGO5EIiF6gAn4VCoFn883kevSVHg6TrlcTnpp0VvnEK+NjQ1xei0Wi9R5XXQPsoUUnaVwOCyEEMKbOzs7UkyaTCYl6mPDV7YKYm714OAA/X4fkUgEb7/9tkyPZPsp5uFYakBointjMBhgb29Ponlen8l0Ol56MDjtbcacq9lsxtbWFkwmk0RDbG3Ef9lQtVKpiI4lg5HkqfPIuY0LW+lzcFexWMSjR49gNptx/fp1pFIpoQhSOZNCOBqNRMnphodms1m8SfLn2ZySm5MMIUY67XYbfr9fmr3t7+9L1W00GpUBOez/RE56MBiUPmJsjZDJZOB2u7GysgK32y1cfN0hmMaF9TAXjVzI0qJor5oesaad6gI1emRULNxw6+vrMk2QEQWHsG1tbeGLL76QdeOGI1RGmErXBE175bpQkJ+t+4fpa+LfTudaNEvsMl4jO/rOzc0hHo+jUCigWCxOGDGfz4fZ2VlJWlNJGgwGlMtlIZQQU+Y4A7K7KpWKsAM7nY4YiK8yivpnuqiNioMspXA4jGvXrsk+IK2ZzKG3335bBtVtb2/LXuAZYB0Tz+BF5ebNmwDOnhUhEBoXXbeiB7FRuTNCZmeCWCwmdWHZbFYaUTKC4Vn2eDxYWVlBIBAQL55TLUejkZQpEFay2Wwy7piGi8ln3j896lKpBK/Xi1gsNoFK9Ho97O3tCbzElvZsS3MRmT7DuhEk9/7+/j5++tOfwu/3C7GIA+xo4OhkkkBxfHyM69ev49vf/rZUx/NeGUUwJ01yDx3xXq+HYrGInZ0duS+bzYZ4PC5tgxh1MKLZ29sTJ5K5GhoXRuz84thtOt2vs3avbVxIz2WSVBd7cfHIHGIS6OjoSLw1VikzYadDZIPhrMeY9qpIItB1HewdxXwPN/NoNJJFb7fbMlKWnqxOsuqwfDg8neuSz+fhdDrFwyATjnjkRYURHENehq3a26DCBiDUUCbh9BpxI5MNw/diAVq1WpV55sPhWTdURkXakGiDM21cdCKfz4T/Mo9Cxa6L33g//J7e7GUUI/ffYDCQrtmkrPOeSIEn3s0aDF4H6bVUCI1GAzs7OxLpEn7gvtNrDmBirRj5aciLMIWuYSGLkrPeCfFooka1WpU9q2m9eo2p3C8Tuezu7sJgMCAWi0k3ZDIO2SeL62kymWQUNEf56up8UnEJXWvIJpVKIR6Pi1E0mUzSwoQwM8cCc71plBmJkDY+GAyk8znhT5vNhkAgIG2bLBYLyuWyjC1gpwFGTTQ4bPt/UUo32VZ0/OjVU+eYTKdd2ufn5+Hz+ZBIJITqr2FO5l8YxTElUKlUYDKZpB2UhsK4xzhSQM+CoaEhHGuz2YTyziT/eDwW1q3f74fH4xFSB/PeXLNarYZgMCjrzdHU7O78tUcuy8vLGI9Pq0ELhQK63S6CwaAow06nI8kjKuFWq4XNzU1kMhnZiB6PB2+99RYSiQQODg6wt7cnOQaGgbogkjDQcDjE7OwsZmZm0O/3sbm5KXTDbreLWCwmG5pdRguFAvb39yeUtvbkqTgIP2UyGaytrUn7aRocwlWaMv26QoyTyT5iwzSohHdYnEdqpmbLaSbcaDSSRD9ZbXwvXeBmtVrh8/ngcrkk1OX9AJAaFZ0ToZGhUX1VgpmfwQS2zoVoZgshvssYFuB0/41GI2QyGWxtbcFutyMUCmE8Hk8wvvh8iXtT0XNd2FnAZrPh5OQEu7u74sDo3JZ2PqgY6BDxNVSsxKa1kaZhoXHJ5XJyHYR4uX/ZQYFzg7QTxHwP98Bl1vH//t//KwldPc6i2WxK8tflcqHVakn3aKPRiI8++kiKo1utljgq0103uA/fffddvPvuu3KGa7UaPvroI+TzeXzzm9/E7du3YbFY8NFHHwnk3e/3cXh4iBcvXsBoNMoZvHHjhnSUpkL2+XxYXl5GMpkU2Pvly5doNBqST2LinWhHv99HOBzG3NzchQ303Nyc5PhYnNztdmEymaRh6q1bt8TRvX79uvQP41lh4ffOzg6KxaJ02SAKk8vlsLe3Jz3p2P3hxo0b8Pl82N/fx4sXL+B2u+VeTCaTjHlnDogDylhE7HQ6ZRjgwsICYrHYBPOSX4xw2MXEZrPh5s2biEQi+Oyzz/DFF198/UWUvAh6vwCk2R0PCRNm2psly4UXT7YZaW66m6dWouRsa/68VvIaE9aJLXpd7EFEmONVdGKdMNUbjlCAJi3wvi9qXHQSjqLhFm1IqHhIrdRRgYac6NnQKNHDJTbN17FbAq9B/+5VyWl9fdP/6mvWubCvWpdXvd9FRBtWGudpoVHjHvmqiInXxPwfX8PP0PdDppZ2UPjz6fX5qkQ/nRcA4l3q/BrZgzoy1musodPLRC4sDeAZASAOBJPSdByGw6F41Dzn006OXqNXrTGVF6N+PYJ4NDproaO7V9C5okOpk/Zsakkyjq53InSma3N43YyOeL8XXUPmPaiLWOHOyEj3HGM7G33/RFPIsON98/qZiyZsTziLv6f+oUNMp4POm3ZEtV7juup5NtyPGhUBzkgLHFtPXcTPpi46j5zbuPziF78AcMaUYF5lODydb7C9vY3FxUXZEMSdP/jgg4nJe1yoXC4Ht9uNN998U4wFcErZDQaDePbsGX784x9jMBhIERR7PNnt9okhN06nE9lsFj/5yU+EnswcC/snMaHKQVisJSG1lv3QnE7nxIAuhtbTSvl1hQ+Tf8+ITB9KHgqtlLSSJISo2+Lw4PDQ8/Dw71k8FQgEZKiWTryTdTNtdPkvK//5vWa2cZPzQOs10vCdwWCYaDVxEWHERcVEkgbvgdc3rei0Y8GfMzpmdEA4l0liKn1GfjMzM9LBgcQM7ZDQqGlYUTsLfO6sK3I6nUKwaLVaeP78ucB03BN0jvisCGdcxrhwjxC3Z3KYXjjZWSR2sM1QNBqVMcWEJxkhRqNRRKNR2bvdbhcff/wxNjY2hCGlYcTPP/9ceg2+8847MBgMknBeWFjAG2+8gUajgS+++EKgLray39zcxHg8xt27dzEzM4NKpYIvv/wS4/FY2GUkrfj9fszOzkofPaPxtMCS7/H7v//7r71+jJ7ZicHj8WB5eVnOI/NYjBaYW+Oeoj6y2Wy4fv06/H4/Dg4O8PLlS4RCIel6wFHNrIchvNVqtRCLxRAIBKRXWKfTQa1Wk9ofFkUCEEbb4uKinL/hcIjNzU1sbW3B4/EgGAyKA0HkiOwwUuYfPHgg/eJWV1fPvV7nNi4HBwcwGAwCPbHYqtfr4eDgAM1mEx6PB4lEQpSi0Xja6+rOnTuo1Woyc3t9fR2NRgPxeFxwXSZnE4kEUqkUDg4OBNfVkyA50IgMEOZH2H7D4XBIO2t6nKQwAxDFSE+UlGOLxSJMknw+j4ODA8kjXaZtiRYqHyplDTlNQzDAZLKf3zMqowGhJ6e9FB3d8P5ZtKUNC3BWm6JzBXwP3UVWG57p6IWKg4bnVfetcxMXEd2IVEeSX/V+mlCgjRo9Ph2FErPWRYpcF6PxbKATmUvT+TKuHeECzYybTvqz/Tyffb/fF8iM100vmNfB504FcFHh9XDtdFsRngdCI4Q6p/vYsV6LLYFcLpcM62Ou6uDgAIeHh6KkzGazJNyPjo5wcHCAubk53LlzR5y5SqWCQCCA27dvo1wu49mzZ+L1s0Elq8QtFoswVjmjJplMSt6AifdUKiUOktVqRTabxdra2i/VQ51XOBadSIweykUoiY5yv382zZZ7iTlBn8+Hb3zjG1hYWEAul5O2MmxMWyqVUCgUpM6F0Vyv15OuyNlsVligpCLzjA4GAzidTomuWCjN/VQul2VoIBmxZIRxP2h0iM5jNBqVNT2PvFZvMW7MUqkEt9uNmZkZjMenMxdYSPfs2TNJuLFIqNlsIpPJ4MGDB9JviIwnQhw8rLu7u9jd3cXW1pYwZQitcbMajUaZP7Czs4PDw0NUKhVEo9EJ2t/s7KxQqOnpJxIJiUZYfc/wnxvC6XTizTffhMFwNheeLdQvKix84ntMh6Ia+9QFenytbqlCGFC/Rlckc7NwUx8fH4sXqL14KulpggONAH9P4WfzPRiSc2Pzb6gAAEwo8csIOz0zmTxtyPjZhJbovfFnWtHrtkP0wJkz0JRjKksOfRqPx9IJmhEURUczGi7W+DShHTpM7EFFVhOxeUYpAFCr1QRSOjo6utQaMnKh0+Dz+bCwsIDBYIB0Og2v14tMJgOz2SwKiXTuUqk00aSSBpo5pUqlIvfK9k0k0bB/VjgcxvHxMY6Pj1GtVvHxxx/D4XAgFovh7bffRq/Xk+7bCwsLSCQSMJvNsgacp7S+vi4TKOmpa4KFZpkZDAZp1ZPJZJDP5y9sXLa3t0U5c+YOB7hxWu5gMBDCAmH6eDwuxvDg4EC6J7PNTjAYhMPhEOclGo1KL0QSLDKZDLrdLhKJBBKJBIxGI27fvo1utytj4DVaQTid54R0dgBS+8f+hJzyCZx2ziZTjzVGJNDMzc1hZWXl3M72a/UWG4/HMq1Rh1uhUAjNZhMvXrzAgwcP4Pf7ZSQr+9js7u7iZz/7mdCKdfLI6/VicXERZrMZX375JXZ3dwW64tQ2NiFkEQ833O7uLtrtNgKBAJLJpLSZYQTj9/slhOz3+0in0zAYDGKEmPyloWs0GohGo7h37540eSORIZPJTCiU1xGfzycJfYqm9+p8kv69TiYz+uKmBc4MAeEwGiEqYsKWetNNe6mMMvl5fE964zqZrLsj0PgQlwXO2u7oaEEn9C9qaK5fvy6V5IeHh78UPQBnzUgZVRuNRmkxwvtj0pn3T0+tVqtN1JXoa2drHMKwzB18leElbZSMNQq901qthnQ6je9///uo1Wr48Y9/jGw2KzU5rNvQ+Y9Go/FLXbRfV2hUCZGwf5TRaMTy8jICgQA2NjYAQAgivd5pl2QOO2MXDArbsnPt6ZAFAgFp5+T1enHv3j3Mz8/js88+k7b7L1++hMPhwL/9t/8W3/3ud/HFF1/gb/7mb2CxWHD//n34/X6sra1he3tbvPbBYIAvv/wStVoN4XAYqVRK4GA6NoSpmCsolUpotVrIZDI4Pj6+8Bl++fKlnBkONNzc3MRwOMTLly9RKpVw/fp13LlzB9VqVWpYZmZmcPPmTWEMMhdMiFWTfVi9T8eDBelffPEFjo6OcPPmTTH+b731FiwWC16+fInj42Ppq8dzSkeHnY2TySSMxtMiWja+LBaLUt9CmHN2dhZOp1NaH7Huy+124/bt2xNQ+T+63867sPSWpyESekOaQkkvnKLzB9pT1q/lhtWJTso0DKNzEvTQteeoDzqZPPx7rWR0ZKCvlX/LxKuudbgorMP1m04Ca/lVOZ3p6zzv3/IeuA5f9dlfJV+VlP+q97rMOn2VTMN+089DExRedQ3Tv9f38qvyadPRjP67r7rPf+z56uhOd6DQf/uq+7uoUpy+Lv1FJaTPil5j3r8+a/r3OsH9qs8AzuDS6boo1m8BmOhtpSMswr98H+Asx8XPnH5u+tr4Wbpu7KLryL/Xe4nvqyvyX/U89dpq/cXf8/24Nwhh88xqQhM/n/tnulBZr5VeD633+PppXTr9/HTOkNd13sjFMP46MIsruZIruZIruRIll5/deyVXciVXciVXMiVXxuVKruRKruRKvna5Mi5XciVXciVX8rXLlXG5kiu5kiu5kq9drozLlVzJlVzJlXztcmVcruRKruRKruRrlyvjciVXciVXciVfu1wZlyu5kiu5kiv52uXKuFzJlVzJlVzJ1y5XxuVKruRKruRKvna5Mi5XciVXciVX8rXLlXG5kiu5kiu5kq9drozLlVzJlVzJlXztcu6W+7/7u78Lo9GIZDKJSCQi0x37/T62t7dRqVSQTqextLQkU9fG4zHC4TB8Ph/K5TIODg7Q6/Vk3O7169dx48YN1Go1vHjxQmZvcHYDxyO/fPlSxtwOBgMZXWq1WhGPx2VqHtt2s+00B2Rxhgfn0bTbbfh8PoTDYYzHY5kFwTklnIvQ6/VkFoRuZ/3nf/7nr73Q/+k//ScAkAFS9XodR0dHaLVa2NraQrlcxo0bN/Dmm29iPB6j3W5PtAjnxM1Op4Pnz5+jWCzi+vXrWF1dlbHM3W5X2nB7vV5Eo1H0+31sbW1NzHnweDyYnZ2VcdF2ux3ZbFZm42QyGXQ6Hdy4cQPXrl2TiYQWi0WGrbHV+HA4lFHJ+XwelUoF9XodJycnGI1GcDgcsFqtMirXaDTiP/yH//Da63fjxg1Zv8FgAJfLJYPg+DO32w2PxyNjtgHg3r17WFxclJbonU4HOzs7Mqfi5OQEbrcbCwsLMJvN2NnZQTabhdPphN/vh8PhwNzcHNxuN7rdrgyn8nq9MBqN6Ha7MlAsl8vB5/PhO9/5DiKRCJ4/f46XL1/C7XYjlUphNBrh4cOHODg4kOmKBoNBpoR6vV643W7U63VkMhkYDAZcu3YN4XBYZmuMx2M8evTotdcPAH74wx/CYDAgHA7LnKNCoQCTyYTFxUX4fD4cHh7K/JR2uw2z2Yx//s//OT744APk83lsb2+j2+3KtMVisYhcLgebzYZwOAyj0YjNzU2Z/8K5SYuLi/B4PMhms8jlcohGo3j33XdhNpvx0UcfYXNzE6urq3j//ffhcDhknszu7i729/dl1s5oNJLZN5wn1Ov1cHJygm63O9ESnu37Q6EQHA4HnE4nPB4PDAYD/tt/+2+vvX537tyRzy+VSrBarXC5XAAg8304K8fn82F1dRV2ux1ffvkldnZ24HK5ZE4Pzwz3FOcTGY1GeL1eOJ1ONBoNlEqliTb+Xq8XHo9HhpWNx2P4/X44nU5Uq1XkcrmJkQIcdcBhYRaLBdFoFB6PB5lMBltbW7BarUin03C5XDI/qNfroV6vw2AwIBgMwuVyoVqtolQqYTweT0xP/So5t3GJRqMyDpbzFDqdDkwmE27cuCHDeTjt0OVywWQyyRS9XC6HjY0N9Pt9mQ2Qz+fh8/lkbjc3LB9Sv99Ht9tFNptFPp+XOdk81FSWDocDh4eHePnyJTweD37t134NkUgE4/EYzWZzwvAEg0GZYcCpkJwd0+l0MB6P4XQ6ce3aNfT7fTx8+BClUumXZly8rnCeC+ewc0LncDhEKBSCz+dDJBKB1WpFu91GLpdDr9dDJBKRKaAcm7q8vIzFxUUYjUbk83mYTCak02kAp+NnOZYUgAzE6na7iEQiMuEOgIwyHQ6HqNVqMm41EonAZDLBbrfLEC0O11pfX0en05HpoNo4u91uOBwOmEwm2ahUUtVqFZubmwBwIePCyYx2u10OdSQSkZngVDbD4RButxu3bt2SYW80mpyWSMfB5/MhFouh1+shl8vJs5idnUU+n8fh4aGsO99rNBrB6/Vibm4OFosFhUJBRvw6HA4YjUYcHBzIYDsqn2w2CwAIh8MIBAJotVqo1+uwWq1IJBKw2WwoFAqoVCqiDDi5tNFowG63w+v1XmjvUTgmORgMIh6Po1aryZyQUqmESqUCm82Gu3fvThhos9mMXC4nZ4yKcTQaIR6P44MPPkCn05E9m06nkU6nkclk8OLFC5njwoF5Ho8HJpMJJycn4rDwXD59+hQulwt37tyBz+eTkeocsMXR6Xa7HcViUQZwJZNJMUaZTEYGEJpMJrnWSCSC+fn5V47iPo9QsVJPcCIpAPkMzpkZjUbY3NyE2WwWB5f7lnp0NBqhUqmg3W4DOBs4R4dlPB7LmnFWDKemjsdj2Gw2uR5ORqXjpwcK6jlCg8EAJycnyOVyaDQa8rNCoYB6vY65uTmkUinkcjmUSiWZuUM9Th10HnmtSZRcAA7p6fV6sNvtmJ+fRyAQkPHE9GIsFot4s8fHx9jb2xMP02KxyKxojhDWs805IbDX66FcLiOfz8t0O5PJJF4zPZpisYjPPvsMkUgEv/Ebv4FoNCoHVQ/IodHj6FY98IljXJ1OJ9LpNAaDAZ49eyaexfQQoNcRDuYpl8vY29ubGH7FQ+T3+2E2mzEajVAqldButxEKheDxeOThms1mzMzMwO12I5PJ4PDwEG63G3NzczISlcaFg37oCNjtdiQSiYnNx43MSYeMBt1utxhnGtVer4enT5+Kt8/ppBwxu7KyIofXbrdjMBjItNFKpSLG6yLCyZKBQABerxculwvRaBSdTgfb29totVoyyMntdosn/vLlSxwcHIjx5IEzGo0Ih8NYXFwUx6fT6WB2dhYrKysYjUZ4/Pgx+v2+TKHk8w8Gg4jFYhiNRjLNz+v1IhgMitKkQ2O329Hr9WSKZDKZhNfrRafTQbPZhNPpxNLSEpxOJ548eSLPiajA7u4uqtUqYrEYwuHwpYawWa1WmEwmido5LbPT6aBYLKLdbmN5eRnLy8sSjQ2HQ5jNZpTLZeRyOezt7YlCNRqNWFxcxN27d1EsFpHP59Hr9TA7O4tQKIRWq4WTkxN5fpwY6/f7YTQaZfLizMwMAoEAdnZ28OjRI3i9XqyurgqSYLVaxcM3m81IJBKIx+PY2dmRPTs/Pw+r1YpqtYrt7W2EQiGk02lYLBacnJyg2WzC7/djfn7+3MOupqVWqwGA7HdG7cCZAqdRYJTM58XhZ3SO+TccwawHdHH8tt1uF+ek2WyK4dJ6D4A8Q4fDAbfbPYEm6CF4vD468tQR/JnZbMbq6ioWFhYmjCcNY6vVEkTqPHLuVebo12KxiGq1ikgkgkQiAYfDgXa7jdFoJJ44R41yHCYPtMPhwHA4lBnXHFOrp6eFw2E4nc6JRaBR8Xg88Hg8cLlciMfj8j6EFxju12o1nJycSFjPw20wGBCLxeDxeCZmsL9qKlupVJKH6PF4JLy/6OFmeDscDsX7Jhxit9tlw1cqFYkyuJalUkkMHq+zVquJ0aWR4D3Z7XY4nU74fD4xVr1eT6AYRhsGgwEulwsulwvBYBCzs7MCm9lsNoEoCYGORiPMz8+LEWQYz3ndPp9PNmS5XMZwOITFYpl4/UWNC+en876pfBl9DQYDMdA0jDpKJlTLyIZz7geDgYzm5bjecrmMfr8v0Fc6nYbb7UY+nxcYSUfD9Kr5vOjIpNNpxONxVCoVZDIZjMdjxONxWK1W1Ot1lEolmX1utVpxcnKCVqsFi8UCp9MJo9EIp9OJfr8vo3z1hMHXlXg8DqPRiHq9jhcvXkxMXe10OqjVaqhUKiiVSrBYLAI38znTsdTn1OVyiefc7XYlUm21WgCAQCAAk8mE2dlZhMNhdLtdVKtVgWkGgwEODw+RzWZxfHyMUqmETqeDL7/8EoeHh+KRd7tdFAoFGAwGcWparZaMrO50OjIunJEOnzdwqtyr1SrW19dhMBjwwx/+8LXXj3rMarXCZrPJueLPuJ+mIwYK4SYdnTAK4mRSo9GIXq+Hfr8Pm80Gm80mBotrz2ehHSW+1mazYTAYwGw2YzAYyH7h6Gw9UZgRFteHe6xarQo6wfXjZ72OYT73K71eL/r9Po6OjvDs2TO88cYb+N73vgen04m9vT1Uq1VRRi6XS3DDo6MjmWEeCAQwGo3kQdhstl8yLsvLy5ifn8fa2hp+9rOfiUJzOp3iyQSDQdy+fRsmkwlffvklDg4OYDAYcP36dVitVhwdHaFcLounUKvV8PTpU4xGI7z77rvw+XxijWkIdSTR6/Wwvb0tc+ej0ShisRhSqdSFD/fu7i4ACBzj9XqRTCYnRr/mcjns7+/D5XJhdXUVNpsN29vb2NnZwa1bt/Duu+9iPB7js88+w/HxMfb397G9vY1oNIrFxUUAp04APdNUKoVKpYLRaIR6vY5CoSDeDnNMiUQCoVBoAmZiiE/v2mq1IhaLwW63I51OYzweo16vo1wuw2azCayTy+Ukz7WzswMAWF1dRSQSwWAwQL/fv/CI2UAggH6/jxcvXmB7ext+vx8zMzMAgEKhgF6vJwbY5XJJdMZRsYPBQBwMOiEWiwW9Xg8GgwHRaFQU4+7uLrrdLmZmZuDxePCtb30L0WgUP//5z/Hzn/8cBoNBDjIVbr1eF5iJhzqVSuHGjRvY3NzEz3/+c/R6PYlSjo6OsLOzg36/jy+//FIUPQD4fD7B5ulYGQwGgakuKvfv30e/38dPf/pTPHjwAMlkEvfv3xeP//j4WM5YKBTC22+/Da/Xi3q9LmeY67m6uopkMgmLxSJGqV6vy8x3Pmca5nfffReJRAJffPEFHjx4ALvdLlD706dPUS6X0e120Wq1YDAYsLm5CavVips3b2JlZQWNRgObm5uSE2BeLBgMCrxE+JdObalUkmfkdDpxeHiIL7/8EqPRCP/lv/yX114/OmShUAherxetVgvFYhHAqX602+0CHREi08al1+sJFF+pVNDpdER5EypjKqHT6cDlcsHhcGA0GqFYLKLb7YojSsNGx4QOJZ2uer0uRok526WlJTG8BoMB7XZbkAmr1QqLxYJGo4GjoyOBdC0WC1qtlty73W4/93qd27gwF0KjYLFYBLYirEVlzAsnHsi/BSCeHV9HZUbFox8GD5zf74fX6xWvgEbAZDLJ4umHwxyA1+sVzJafred9T+dReF0ABFvkwttsNkkyXkQ0fk2o7lUyPa8dgKwR4Qh6NnrzdLvdibXu9/totVro9XpwOBySuJ++XypDHkAeCkYC9FydTidsNpv8TntAet34e+0w0Du+DKTD9+AacU00POBwOOTw0YsejUbiSHg8HgBnUTjXiN4jcKpAqBgJyfAzeb80vFw7/l7DFtqLJcyhzwqxbHqvvBdCvlw3q9UqiWx6yRcVOlOcy67vixGo3ps6cU/ohhEfI0PmDmu1mkQPnU5HckbMk/I9B4OB6AZCM4x0aDgIK5lMJvmXuQHmYalo6alzfTTExPvRkRcdjouIhpcodAg0rMXvuV95T/p99Mx67m1GYYxmp6E2AEImIeTMZ8f70+gFANl3+llPR1R89tTphLL1a6kLX+cMn9u4bG1twWAwYGFhAXfv3oXBYMCTJ08kGdjpdBCPxzEzM4Nut4uPP/5YQm0qvXa7LfCJ0+mUHATZRf1+Hy6XC7VaDbVaTSCOd955B7FYDI8fP8aXX36JZrMpGGa73Z7AMUejkWCjTJLTQyW8QG+DSoaLb7PZ4HK50Gg0cHx8jNFoJLARD8tFI5ft7W0YjUbMzMwgHo9jOBxKxGW322GxWCShbDAYhC3U7Xbh9XqRy+Xwx3/8xxMP1263S0RxfHyMQqEg4fbJyQnW19clQfvBBx+g3Sz06ykAAG3cSURBVG7LgeZhZ+4pFAohlUoJTMcEtcPhEPzaaDTiyZMnyGQygsHb7XZ5bsViUXILS0tLohypTC4KiQFnyc5IJCL3HgqFYDabMT8/D4vFAq/XC7/fj263i+3tbfT7fTgcDng8HkQiEbz33nvodrvCtisUCr+kmGiQ/X4/EokExuMxfv7znwtDptvtolgs4vPPPxflwQNNx4FKolgs4uOPP0Y+nxfF+/DhQ6yvryMSieD+/fvo9Xo4ODgQZhCT6ly7YDAIt9stBIHLCOHrxcVFwebr9TpGo5Hsy5mZGaTTaXQ6HXz00UcSwYXDYVitVty4cUMYnA8fPhQF1O125b1ImjCZTAgEArBYLNjZ2cHR0RG2trZQKBRgNBol0c28Ix0kGhcaM7fbDafTKYae0LDT6ZS8W6lUEuMzGAyE5cezS+VbLBYvHD1TuTYaDcm1EHmgg6cZhfF4XGD7ZrMp8DEAuFwugdaGwyGCwaCQUB4/fixQb6FQkNeYTCZcu3YNb7zxhuSWms2mkHhotKxWK1ZWVoRccnx8jHa7jbW1NQCnEV2z2ZTrt9lsCIVCsNvtaDQayOfzAuFpI8g1OK+c27iUy2WYTCbMz89jZWUF+XweL1++RKfTkYWIRqNwu93o9/vY398XppHRaJS8ABeYWCKhF3pzxWJRvDcyZBKJBGZmZrC+vi4JsEKhIJbWarUKzENvivg3w0rCHvQeGX3pPAstPhNXmnzATXFRBcmEWTKZhM1mQ6vVEoYTP8NqtcLhcAhThzkLm82GRqOBnZ0dGI1GJBIJuFwumM1mSXSTsURvmQctEAjgzTffRDqdRjabFdYS8dSjoyNUKhWBHZlMNpvN4tX7/X74fD7x2EulkpAxaHzo8bTbbTgcDvj9fmEQ9vt9AK+3MV8ljK4CgQBsNpsoHOL/ZrNZkr/M1yUSCXg8HoTDYSwtLaHZbGJzc1MIEjxkzJ3o5CgN/tHREer1unjWhD4I9TIXx71Oj7rVauHw8BC1Wk0irWw2i/F4LHlD5gPpaNEIARAmpM1mk8+/jIFmlEXqaqVSweHhIUajEdxut0BV0WgUuVwOBwcHqFarsidMJpPQol++fCkO2Kuor8PhEC6XC4HA/6+9M+ttO83S+0OKWkkt3CRSu2RJ3squctlV3ZVJd4ACphMgG+YqN7kIkC+Q75NPkLsESBBkgnSjJ51auqrscnmTbdmSqJ0URVLUQlFccsH8jg41NTM2XbnTCxhdbUvkf3nfszznOc+JKhAIGDkAaj+BU1dXl2KxmEXaPiv1n4eD8MXwUCikgYGBtvvjWkKhkAWn/G4kEmmrI7zvYv9iR3yBnu8lc6WO19vba07TE4JABdhTAwMDFigODAwYqkDtCvsUi8V07do1q9exz3Au3DvPFHpyrVZTPp+3jJGMkIBoYGBAfX19dq6li6ysU6bsOzuXGzdu2AFcX1/X2dmZwuGwpezNZlMHBwd6+vSpMRVgHsXjce3t7en169f28H06NzIyohs3blhfTCQSMYYRxWs8OFAXBahoNGp9GoVCwSIejOPe3p45G0mW/vHn/PzciugYxvPzcyUSCUmyzYMR7TRzGR0dVSgU0tjYmNLptCqVigYHB83BAoUAQdETQmbHvWO8yNoo3vnUuru7W+Vy2SJmjMDh4aHK5bJF3GxWjC8OxkeTRIlv3741Z7u0tKS1tTUVCgWDNaRWZAysRKQFFo3j7HRNT09bdAhejXGiLoRRgqMvyWjE6+vrymQyOj8/18HBgSQZA0y6KFRiLAcHB42mvLe3ZzABWQoQKYYU2IBCM++UCBeWXjabtesdGhoyqnE+nzeDzN7FSEmyIK5TwyhdQH65XM7OChAyhByCnEKhYM6M91koFLS5uWnGjMJ+IpHQ6emp9ZqA0RP5cv1kFdRJ+LdarWb3yx8cxd7enl6+fKlSqWS/s729rWw2a0ymarWqXC6n4+NjhcNhzczMKJFIqF6v6/T01AI1ArBOz7Bnd1LXA6r2xXgMMUYZSA+HSKtGIBCwehVBG06WoJGzODY2ZrZ2eXlZXV1dmpmZMTu7u7urkZERY+lCUCEI8s+bc763t6fNzU3bs77swPIEFc7fu653di4ff/yx9RS8fv3aqKhEs+fn58pms3r79q26uroMo5+bm9Pi4qKePn2qFy9etBW6eFlsCKJ0+gfwxoVCQVJrExIR8weKZrVa1YsXL3R+fm5G4+joyOAlcGYcE9FQrVZToVDQ4eGh9WmEw2GNjY1ZcY2mPQqQnax0Om004qmpKcugKpWKRbfgxNFoVB999JH6+vr07Nkzra+v2yb1MJokywqI2kdGRtp6K05PT7W5uWkHzLPVMA59fX2KRCJG02YzjYyMaGRkRNlsVj/99JNqtZquXbum2dlZa86UWgbc13hOT0/bmszAiYliO1k0QhJRV6tV2x/Uc46OjoyJRI0JGnEul9PKyooajYaGh4fV29vbRuSgZ4e9DOECqjORJLADjhcjyLvBiHEuyuWyotGoFhcXzRHS3zIyMtLWY0Rg4SnC1DgqlYqOjo4+yLngnHZ2drSxsdGGzfvP5lmyt3wvDHRpntv4+Lg++ugjY5Fe3gc8n2KxaMEJBI/j4+O2uq1npBEQQgiivtVoNJTJZHR0dGTFaK6tWq1qfHzc9jTGEvYTZ6zTM8zZSCaTGh8f1+HhoXZ2dlSv1+08Eej5WiM2T5LV0AYHBy243d/fV6VSsV4+SdbsyXmfmpqyBtunT59qfHxcv/3tb20PDwwMKB6Pa3Jy0vYqAd7w8LDV/eiJi0aj+v77763Z+fj42PY+NS72tGeS/X9xLtCMiUagrNEwFw6Htbu7ay/Q949IrWIrjY1EZxT7+vv7NTo6asaeQiCU2Egkokgkomg02tZwRAcw/G6gm8HBQXuJ9H7we6Sjp6enyuVyFrlhYAcHB9uMN4V0UuFONyabCfzY03KJZogO+E5SWA4XLBiKqUTMwGPUStgkPH+KoERCbG6eMak49Feci6dVEk36zXb5WfAZPO9gMKjT01OjJfPeOllE9vD9fR8B0BFFdjJjX/D3zoH7GB0dNUN3dHRkwQuQG9FcLBYz7LxcLlvW64viRPz8N++cfZtMJu07Cay2t7dVLpftDAFNQIn2JA7qR53WC6R2aqynZwM3UlfMZrNtRXZoyQSMktoi8HA4rPPzc42Ojlq7Ac+ajHxoaMjONcQCWgnY6+ypvr4+CyIh87Dq9br6+/t1dHSkSCTS1nPDZ3ONZPyebIDh/JBnyHvhXXNWYG4lk0nrxqfPhsI8kCeZH/YHhpfP/Dzs5sk8/C81T9h9AwMDRscul8uqVquGVgBPd3V1md07Pz+3AMcTEy7vMbJX/v0X73N59eqVUVBJkTc2NhQOh/Xb3/5W09PT5gm9Yzk7O9PR0ZFisZi+/PJLS1Wp0YyOjmp4eFjz8/Pq7u7W2tqastmseeP+/n4tLS1pZGTEOmzpo5CksbExczpHR0fq7u7W3NycNW3hRJ48eWI06f7+fq2srOjrr79Wb2+vbty4odHRUc3MzGh8fNxglbOzM0tbBwcHzch0shYWFiyVnZqa0snJiQqFgtEZcQY07a2vr6urq0uZTEY7OzsaGhrS2NiYwY/AJI1GS2JlcXFRAwMDWllZ0dbWliqVijF/MMI0HyYSCd28edOcKZ3lnnEiyYrIl1km/Ax1MyKsVCqlZDJp90RWViwWNTIyomg02rFz/uqrr9RsNrW7u2uRaKlUUm9vrxYWFjQ2NmYwYiAQsEPoi74DAwMGf1YqFX3xxRf6F//iXyibzer3v/+9SqWSbt68qaGhIR0eHurNmzfq6+vT/fv3NTw8rJcvX2p5eVnSBR7tsxnYSRSRp6amND4+bpmwJMViMR0cHCifz+t//I//Ydc4Pz+vZDKpWCymbDarly9fWhc/pI6JiYkPqlt5JhsU/Vwup97eXn3xxReamJjQ06dP9e2331pgAXxHY+na2po9y56eHk1OTmp0dNQy5vPzcwtYVlZW9M033ygYDBpF/OjoyIw+Kg50qfv+rHv37lmRGbYZBfBsNqvDw0Ntb2/r9evXVvtCFmpwcFDFYtHge9AHPr/TZ4iRBaKj946u96OjIy0uLurWrVsaGBiwYHp3d9fo7Uiq4AQw+kdHR0aa8vAhzetbW1uqVquKxWIaGRlRqVTSH/7wB/X09OhXv/qVbt68qd3dXb19+1alUklPnz61soK/dkkGfScSCd2+fdtqgdS/fRDJvuH8Q2V+l/XOlhJONREz3psMBBySqI0XyE3hXSksQSUcGhoylo/31MBjZCZsDGoMeHwyEei2MGyAY7q7u9vkUDCi1FqI1olWh4aGdHx8bIVeDqSn/3ayIpGIMdx4Ph7e87Rqni0YLjUs6h+QI8gqJLU1XMEY87gv3wf06BtS6QXwBUdJFp17x3P5OV4uZNOgCkMMliCwXacHmwNN5uKp7WQNnqThHaJ0ARtKF9Ef0Fej0TDHMzg4qKGhITv80gXrMJvNanBwsO2g+kNH9knheHh4WLFYzDJrPguo9+DgwJwR2ldkBx4uoufBE0s+ZPn3yHnirHm6LhmWf8acT+qtXDPkh3q9rqGhIfX39xvMEwgErPfNM/PYN9wvnw8EPTY2pt7e3rYzDnGHehUBD/saeOoy1MN9dlKYZrGXeDeS7P6wiR7J4Xp9PY8Mh6zQf6antZPp8L3YAYIDshP2xNDQkPL5vO2ZfD5v5Cj2zOWMhODd121/bp/83Pl/l/XeNZcXL15odXXVIrOBgQErGg8MDOj+/fsm++A5/rx8MpJQKKRkMmkCisFgsM1Don8ktQwLMjJol/EZeP2uri4rmoIj+v6Y+fl5k4+QpGQyqXv37ln0geEG/sJ4A7GhRNBp5E0U8+rVK33zzTfq7+9XNBo1ZwF8x6HjIADXSbIMB/YS8AxNorCKfFG+v79f165ds05pSBAYgMPDQ52dnSmRSGhqakrShdQENZhms6l0Om2wIEFFIpGwwIFomAiTQv7CwoJSqZQduE6fH1pMUqt2QDTd1dVlXfvd3d26e/euiW9Wq1W9fv3aMr/79+8bAaFeryuVSun8/Nzo7uVyWS9fvtTjx481NTWlv/qrv7LMr1QqKRaL6f79+5IuDA2HDcMKYQDndHBw0EZkAFoLBAJWgwKXX1tb08uXL40MQMMwBgUiQqfLF53J+m7evKlQKKRisaiTkxNFIhH9s3/2z1QqlSzbz2Qy+vbbb1UqlSxDo6Y1OjqqiYkJg7awBWQnn332mdU19/b2NDQ0pIWFBUMfgGY8vg+ETPAIPD40NGSGuVqtKh6Pa35+3pwLMBMNlSMjI0aLJhglaOxk+V4PAlSUN7Aj+Xxef/7zn9Xf3690Om3vDbjJ1yyA0wgEqQt79YjNzU2jNYfDYWMiJhIJ3b171yj5sMoGBwdVrVZNMgqn5SFREI1yuWx1SDIWD+uyZ+bn5xWLxXR4eGhtHO+y3tm5XLt2zSjGZB2jo6Pq7e1VtVpVPp9XX1+flpaWTG8JfTCwPh/hhkIhiwh9IY8HgFLt2dmZHj58qFwup4ODA5P+oLeBwmAoFFI8Htfp6alWVlZM7I+eEoqzFEpHRka0uLhoWC8v3zchQhEEAoAJ0slioz98+FA//PCDRkdHdfPmTXMqvgmR50G0jQQIcND+/r4ODw8tygZGI7oDPiDCHB8fN+bT2dlZW98ACq9kMtKFwiufdX5+rng83sbO8Tg679XLwZARQUf+0CZUL4OB7tLCwoIk6dGjR8pms0Y2AO7xTubOnTtaWFhQX1+f0Xox3H19fbp+/bpOTk707NkzraysaGZmRl988YUkmWEdHBw0gUTpwrF4iOzk5ETLy8tGP0Ykk/0PjVmS1RJw4Ht7e9re3lZPT4+xfRACRfvtQ+oFBCzUxCDSBAIBbW1taXd3V9evX9dHH31kWoAHBwfa29szo0qGBvklGo0qkUjo+PhYpVLJkInNzU1NTEzoxo0bqlQq+vbbb1UsFq3oTI2LWhKZD02/RNsevRgZGTEYGLgOGBtn7uuVyMuQKeH8PmR5WBjIX5IhHyhaU7ND6offBf72pQNqHtghskRg+cHBQd28eVOjo6OWkeNcCO5xWvx/4ERox2Tb3jmenJxoa2ur7UziqPke2idoZeB632m/vetDpUmJjCMcDhvUQ/EPraFms2mCixwSNguwAbhjJpOxjQKbC2x+b2/PIhG6Vj1scNlZgGtjnJFboNYSCoWM2ktPBk6OlNpnD3xGtVq1e/iQgjQvjCge+ITvhHXlKY5IQRDRYRzJ3nyPBffuswg2W6FQaKMDo5FVLBbNcOVyOaNHesUEmjv938ViMTvQns6Kdpkv6nKoPqQYDWWSwKZWq2l7e7uNTh0KhbS2tmZUWS/eh0FtNBpW7AQ2IdqmOQ5hyRcvXpgR8aQAnCnkCNiHPT09Oj4+1v7+vmUj/Dy1yoODA9uzOBk+D5o6798/rw9tQpWkx48fW82CoIxnGAgENDg4qOPjY71+/drqgdREms2mjXHwZJdisaiNjQ2rbZLdc55xsolEwqAxz2KCaQU0B7pBzxHBnSTrC4Nt6uFJniGQ+NHRkaEn7EcPS3eygIkJRMlW2F8YcZy434P+/nh2EBxQxvDX6mE3JFjK5bJJRyHzgoICgQzvgpaOnZ2dNtUJTy2/XLrgPoDn2OOSLCv3kjX/0Hpn57K+vq5ms2kFVFhctVrNGiY9K2ZmZsYgMAwdGC4NPvv7+3r06JEikYhmZ2eNBjw8PKxyuaxXr15ZI9rR0ZEpz5Lan5yc6OXLl9rd3dXS0pIVv4CV6HMhdaxWq1pZWbG+BRgnFCQ9HIZxoMGTl9wprEOzWr1eVzQaVTwe1+joqEUoFNHIGjjQxWLRni1KvBw8NiskCUmGW0NACAQCKpVKKpVKmpycNP2w1dVVo80CF5JZeHhSah2q2dlZSRcKrJFIRLFYzAQFz87OrAELaIzipHShON2pgfzxxx9t71ATefr0qfr7+60Y/ejRI3399dd/CwaQZNBWd3e39f/QEJjNZvW///f/Nu2xdDqtcrms//7f/7vplRFIEf0BBdIoF4lENDIyYo4N7Sn0m3Z3d1WpVEzqnL3AwQ6FQvrNb36jBw8eKJfL6cWLF5blEM2TWXa6/st/+S8KBALWXMj4h97eXi0tLRmZADiMIGN7e1s7Ozuan5+3s08fCzpU1WrVWIG9vb0aGxsz2jP7p7+/35w5PV9kdIFAwFQiUABA8RiVB99PJV0wt6QL9tri4qIWFhaUyWQMHuNZ043e6eJ8AOHT2Q4UD/MOOjGkIwgfKIAA7UF+QJ0gl8tZGUGS1UaBvum/Y9wGZAWcxN7enh49eqTe3l7du3dPIyMj+u6775TP5w1+45mxjzknBH/UlgmW2PP0IgF3vst6Z+dC+sfF4F1JbfHcp6enVnAD6iHaBK/lgfuGqcu0VwTw2FR8NhsRTNLTT32HLpvAQwF4a6IIrsffC16Z4q+ktuvr1LnQk+FTdBbRkM+KPIbvi9dEXxg37tcrCPh78DWGy6m4Z4VAx+VZ+fSfzwXyInKjhuMjIFJ87of37a+rk8W+Q2ATkUQyS0+4gJ7s35WXAYHGDG8fqMJ3KrMXeOdAsGSxPHPqSGQx9NFIsl4almfc8T452Owv/z79Hv/Q5yfJ6OiQXujDubwfpVaARpMvz5+WAPozvJIAgQ7kCDrHkXyCrAPL0cOowOScVwIdapG8Rw+b8+zIDj1BgWuGvcf59sFBJ8tnLt7e+CwdZ4kR/7nrvVyv84GG/wMFHBtGOwL7y2flOE/+APH7FoDL8Jffiz+XGXOtBN04oF88c9nY2Gh7IH6RDlJwB6IKh8Pa3NxULpfT7Oysbt++rWCwpXeDPhgUQjj3uVzOCkeZTMYMoNTKnnByHL7R0VGNj4+rv7/fGEX8TjQa1dTUlEqlklEo+/v7NTs720ZRzGQyqtfrRmOknkTUBryWz+c73pioIiMKh6QLNSs2KFx1okHfY4PhZEgQtE6YSTTpwRIhwsFJSRcSIDQNQhY4Pz/X6uqqwUewfojMkeAm3d7a2tL29nYbBEUB1o8TgMHldaM6WcAx//gf/2M9ePBAL1680H/7b/9Np6enevz4sRXCk8mkIpGIFhcXTW2hVqsplUppfn5elUpFr1+/1t7enpLJpNG7P/roIwUCLcXkoaEh5XI5ra+vq7u72z5zZWVFKysr6u5ujRHwBAbpQv3hzp07FhzU63WbyQI5AOMjyRpOz87O9NNPPxn822i0mjDX19dNi6vTwIZF38Vf/MVf6MGDB9rc3NT3339v+6tYLCocDuvmzZtWQPc9TYlEQnNzczo/P9fjx491cHCgubk5ffzxx5blewO7tbWlUqlkkBR6aysrK7Yng8GgZmdnTQOQesrt27fb5JloD2D/4siJ6H1jNkPh2NtMffVq050sCDiHh4dGIgLaZG/jIH1W6iEn3j8w+9HRkdH9uQccQSKR0Oeffy5JViJIp9O6c+eOna16vW7D6ebm5sxWYSsZggdcd9mBSe2SVgSLQNDNZtMyKjLBdz3D7+xcKEr54jvGjvQJA0JGgOGkc9cbsnK5bI1/vAzgoFwup1wup62tLUmyug0jVYmoSUv5dx4GLwi4gq7o09NTSzW9/tPOzo5OTk7U1dVlES9FdIyzz5w6WThFYCgiAVgnRAPoDfmM0Gd5vnher9dtcxOxoFJL8xtRNe/KZyR+kxMYwL7ztSeYS8A3aB+RLfjDjTHymkVg6t6ovu+C+jo5OakbN27o8PDQ9g1zPgYGBgyempiYMMYMhATm2wAHesgzkUgYK4efYwIpxIazszODkZrNpvr7+9vwbN4L7EPPbvOZ++WsGOwcSBFYExydoVq+cfNDnuHExISWlpYUCAT08uVLY1Cdn5+bdpvXusJZDA8Pa3R01LTBIEMwLpyZP1xjqVSy78ZgejYXw++SyaSi0agFU5BzBgcH26YfEjj6bJoGYQIi3hmwTk9Pj+1parWdPkPPWITcQ/bmoSK/z31tyNfgyHi5dp9ZgEKgP9dsNo0sQXMmBAIc7PHxsYaHh5VKpbS/v68XL15YMyzXwnX5DPDy+/H2nb3JewIl+sWdC8wWXpy/KDYgMy1gGIEVMyTo+++/t/R4fHxcb9++1Z///GcbZOM7k4mIKW6ywYlgUZ6Fiup7AOiHIQs6Pj42jBNWBSwYIqJGozWyFedCwT+Xy2lvb0+xWExzc3Md9xlA5V5eXrZpfhSYMYAYHt+YGI/HbZYJqqZABURB9XrdaKLg1rOzszZ7BcPP53sohkMZCASsW533BwWU72s2m8rn8zo+PjYVZmoZnknHULJQKKSJiQlrSiwUCh07l8nJyTbDPTw8rKWlJVPjRpU5m80abZz9CcyCNhvvMJ/P69WrV1Z8prGQf0MiBViX4igz4YeHh5VOp62BEGfOwdzc3LSRsp4I4IuqzWZrlC1sKE99h5CBkaGO2en66KOPzOGjpDE1NWXMQArHZM3sF4gPMzMzpvRLoX1vb09ff/21ZXAU6gcGBgzSBqYBJkWVg2yFGiwad9y7d9pQks/PW8PccIiJRMLGpFcqFc3OzmpiYkKnp6fK5/Mql8tGIpqamtLt27c7PsNA2j7wYuFE6PvzBX4CaC9ZxGfBQIRg4SF6gme+DwXkXC5n0kogPlKLpPP48WM7a15FwBMGpItOfJic6XRa3d3dymazJnCJrSdgA0r+xWsuOBcfhfLlPDwkOni4Z2dnFuWWy2V9++23GhgY0G9/+1uNj4/ru+++01//9V+rt7dXExMT1k09PDxsMyI8cwEIDEZZIHChJ+Wxbzbmzs6O9vb2LKKUZAXSTCaj5eVli0AxujQ+wSjLZrPa2dnR7du3NT8/3xZ1vs+6d++ezs/Ptbu7q+XlZcOjqS9hzBHEI4pAwXZ9fV3Ly8tqNBqmPu1rVPS3zM3NaXp6WpOTk6YBxjAtL4cDieDw8FCnp6eKxWIaHx+3LAXZcCQ6IGTwjre3t22sLUwoHBHPjZpET0+PDg8Ptbe31zFjbGpqSqFQyBwEYqeBQECffPKJxsbG9PDhQ3311Vdt7xljTfe2Zwzt7+/r6OjIspqBgQFTADg9PTUoix4aaoA9PT26du2aDR2jYc6zqIAZHz58aI6czMPXLIEfpRbsQgGX4AnnMjc3py+++KJjhQipFeBIrYgY8sLs7KwCgYDVUt68eWOZPOd7a2vLejXu379v1xeJRLS7u6uVlRWDkpG6p9bHZE3vXKAW08qASoQfkYFDki6cy/DwsAmJMtoBQdhKpaJisai+vj5NTEwYrEmGGw6HNT09rQcPHnTMGPPkAH9tfhHIIKpKnXBgYMAgce9AUqmU9f1A+sDu+cC82WzaPe7u7lrmAglIag0bfPTokdUiQRpAQy7Xe3AuAwMDmp2dtYGQuVzO7o09ODIyYgPdfvGaC5PIiE79zZHadXV1WSpNtEt0LLV6Pbzi6unpqfHl4/G4wQ+XaYZ07/uxq0SJXm+LKIX0E5qjdFEM5OBTP/B1AjIw3+cC5RYOe6eHG8kbolDE5Ig86A6noZSDROMUHdw4FDaPpDbBSsYTEAEC8UEhZDKlj0CADrLZrG1i30zl3yHXXKvVDJ8FP4di7QvTwHkfWnMhe93d3TX2DA6YA0lA4KmilUrF9ks2mzWIxWvPeekWMmWgVPYW+xna82XoQ2ov2nLP6ERhMHhuwF8wdCTZ/mePe0YPdPIP6dBHqQK2EtARz9ArTZOB8d1I5mAHpAtpdyDFeDxujhza6tHRUVtbARE1562vr88CLJ7DZWILcBnq5bAbuX5YVNT3IACRJYXDYcusCcI6WdQpgdd93YLn6BmfPwc/Xb4/DxNSX5UuGl55zswxGh4eNsdNoOdRCE9o8oEMGaUkC2o8OYs6FTCaJxswa4j9867Z83v1uYBrE+lDw3v+/Ln29/d18+ZNPXjwQJKMf80gsLGxMRuz+ujRI5v9vrCwoGg0aoNystmsGUBSw5s3byqZTBq8xQZmc3FAV1ZW7HBDuRwbG9PJyYlF7x6DpyOdF+LFM0lR7927Z5nQq1evJEn/6l/9q3d9bLYymYykljpyKpUyQUc6iKvVqpLJpHW9g7nzkiuViqanpw0uxNEBndy7d0+JREKfffaZFhYWbBOcnJyYjEYulzNiBr8bj8c1MjKi3d1dPXr0SMFgayAX0ER/f781yXqKMlmpJHMcExMTmpqaUldXl9bW1toYhCcnJzo4OOjYuezu7kqSdnZ2JLWi/JmZGXV1tfTXNjc39fLlS62vr0u6YPthEGdmZkws8Pz83DIVZo4gHUQ2RyOgJKsNXr9+XdevX9fIyIjh7d6REtiwz8rlsg0A43kw2mBwcNCaAnH8MNWA8jwzCfXdD4HFGD2Nw0+lUrp7966RbCiO0wuFEeJ58AcIemBgQNevX9etW7cMyms0Gnr9+rV2d3ftGVJLhS1GoEBtZ3Nz05qjvWHDsR0eHmp3d1cPHz5UtVo1VV+c8MjIiLUedHd3GxHIk1Go966srHRcc6Eh+3JQQzBIAOoHfBHoSO2MLf43m83auSAj8I3boCm//vWvLdgNhULKZrP64x//qJOTE0M3tre321AaXzeJRqM25jibzVqvF0HDs2fPLFFgEWCsra0pk8kYtP6u673GHP9cQfhyoQ3mF0VlDBKUQ7wuul40BLER8NikZBTlgQ6IqL1Ugj/UnhnFtEtqDLw8rpPNDDZ6OeuRZN3s9Jt8SOTtPy8QCOjg4KAtxWYBA3gaKJG1p0N6Ciyq0DxLNhb/DiXWa8R5amatVjOFXuS+MQQ0/Pnr8Y7G00F9Zunp1GRancJiPnNiL9ItT0YExCdddBFTLygWi1bshbZJkOI1zzzXn1oV0SRZID08f9fyZ4J7J5r1zaSwd8hG2dNezYLPo7b1IQV9T2n2tT7O5OXBaf6dsWf87JxAIGDUcOoz9IiRpbEHyNx5HtgLMjG/N/wZg2Hla0G+4xx7BPxO1sl9cJY8u6xTB83veQYdZxESC9fs7STL/x2/B0TN9fLsOZvQx+mxwYbisGGakSX7xWd5ghMZn99joCc+SPKO0CMZ71MWeC/hylAoZOrBtVprBGez2dTs7Kzm5uZUqVT0pz/9yR4YDJLZ2VkFg0Fr3IPhBbQWDAat2Ht+fq6+vj4lk0kzVNRTJicnTe2Y6IDBQHt7e1pbW9Px8bHW1taMOsxDxDjH43GFw2GjgELBrNVqNhsGBlwgcKFSzJ9OnQuMJhxbV1eXaSoxg0GSlpeXDZv2mxMGXb1e19jYmNWGms1WtzzGHEVksG2MLEW7oaEhFYtFvX792gwLjZEMWCqXyzZGtVKptNUrPIxCrYjggfHQtVpN169ft+IrWeOHSMajHjA8PKxoNGoZM1lUo9EweEG6kNSgqzwYDNqzpWZIM2tPT49pRFHQbDQabdJEZCowulCU9nDI5QXTJhAIaGJiQrVaa7ZIPp9vizQx1MzP6e7uNko6fzAgH7qArqPRqE5OTvTtt98ahEimC7ORFQ6HtbCwoGAwaKQcxCqRffEYPirHkUhEH330kdUdurq69ObNG719+1YHBwfa3d21OgtQru+9IgBbX1/X6empxsbGzKiiIAAUjh0BNvPBAoGunw3fyYJQQ7TPGcY5AykB33PPZ2dnRtMmoJVke5dGSO+wqGv+4Q9/sFktAwMDphNIjYqsFvvE/flGYs7rxsaGgsGWWgQ2wgfYnGP/7Hxg8T6QmPQezgUjNTQ0pMnJSe3v71uxHGjr6dOnev78uUVGoVBIH330kXVCo1HExDSazE5PT21iJBRmT3klUgTKyufzZgzg3odCIaM+EuUdHx/bJk+lUgaD4IzoquW7PRbuh0EReX5IzYCIyctf4DRhy2xtbZnUvpfNYUNQYB4aGjJHABEAIwU2yhwRNgrwwcjIiG02uvyhRCN6B4Vxc3NTOzs7NuwKjDwUCplkjHQhE8EYgYGBAY2Pj+v8/Fw7Ozva2tqyZ9/pKpVKVsiPRCI2CA5s/3LBkoMCtfbw8FCbm5sKBAI2TIosjXodgcbh4aHC4bBGRkYkXUSiOF5EG5EU+ruyCeouODIYjIzo9rNRPL6OGoSP/GFQ/hIrFotpcnJSa2trev36tWq1miYnJ01VgEAPR5xKpRSLxXRycmJ9PjMzM9ZZTh2LmgH1k76+Pk1PT0uSnWXmuZfLZRuPkEqllEql2rJ1nDYTVTHk9XpdmUzGRm3v7Oyop6dHU1NTpgBwuXbD3iDg7NS5AMlitBkPIMl0/7yyNWoiuVzOUAEgR5/1+1lLPltlsu/AwIA971QqZcEyavEHBwfa2tqy6/JZnSSDgunTA+HB1klqkzbyXfnsYZ7n+2TO7+xcuCmiO/S+AoGARabNZks912cKkUjEbsZHgXh7vC16RzR6QbUjipdkhVEw81qtpp2dHevRIG0G1wbvxtBSL6LQB0PGQ2P0MRCF5PN5nZ6e2jyZTmEJ0lqyIZrzJFnBjIYznlt3d7dpf4EnE12CYft5F2xepEpIZ8H0eScwxYDCMARovkF/hLEHFdHPK/cqAUTbQAPn5y3lZhhk6XTa5Oc7fX6Tk5OSZFkuG76np0fpdNpqRBik9fV1VatVawaULlQSgIOYPQQ0xT1LLXXZhYWFttpHNBpVNBq10d04dfY7ESfKx4VCwZwizECgSm9E2Gv8HMENh9vvnQ9Z1Bir1arW19d1cnKi2dlZNRoNY/X19/dbYMB+hFwwODioZDJp9VZYUWtra23RLz1jOEoCl1CopaSdTqdtPPLQ0FCbJAsGkQAV5+rhWxoPm82motGoJBmZw09L5N0QrEIX7zRA9E6Jd+1n3BOM4lxx0Dhf9pi/T5h6Hq0gqATOCwaDlvmQhRFUkfUA+/lsQ5LZUjIjT5TyxBGuyTs57L3XE+P632W9s3NZWFiwDfTmzRsT6OMh48Xp7iVCZuAU0bFP/YAI6JtoNBpWC6HQKskE9I6Pj43iSgf9kydPTJaarvCZmRmFQiFlMhltbW0pEolofHzcDi06TcArqOO+fftWa2trVsM4Pz/Xs2fPlM1m9eWXX34QjREDR40A1efz83N99dVXVmiHFx+LxdTb26udnR1TouYQQpWdmJiwTnE2JFkNnfocRphq4XDYdKE8TktRFConek6lUkmJREKTk5Pq6+szIVDkNKDJMoL1+PhYBwcHVjyenp7WxMSEUqmUpqenO8a779y5o1qtpvX1dW1tbZnxCofDevDggaampmwPZDIZ/af/9J8skozFYnb4EKmEYPD27du27+E5JpNJff7555ZxUaPp7m6NoYY6z8IQ1mqtwUv7+/va2toyJVnweBwejoKCebVaNdIMEh/8DFJKndLgWR999JHq9bp++uknvXr1SqlUSp988olCoZaga7VaNQXccrmsFy9e2Ljjer2udDqtTz75xK6DYOzRo0dt9UyUHQh6gKN7eno0PT2t4+NjQyGoQfrla57Uvnh25+ctmftcLqfh4WFTOwcSJ4v17xM4GNHHTvegh+zIBqB0E1xxtoD0+DfqUJfRD2ZZebgWY0/gyGf5wAr4kgB/YGDAmHXeyYTDYdOk83VSHBJd/lyXp+qDhlDi8L0777Leq8+l0WiYM6hWq23ejRfPxVOQB6/z0AJcaQp7noVAlzXpJZ/t4Q7PuGAj8p28dGA5PovvpjDtO1dJx6H8cpD9dwLPdSp85xkcx8fHZuR9MRfjBNxFpMG/g0Pby/t/zgAevR+s5juHcSQ4dRqn2OwcXg4NxVa6tHn3GBlffOVZ4jR5V0RcFMx9f1Qni/3kadDcKzRMYFb+eBo6+8ZnAOwJj03zLMkcIUPw2YgP8vs8Ux9xAxnSa0OmLMkcM5/rJUGki6ZPDJnHwD80c2E/+egVdQ0CRwwVGLsnJvjudp4p/+ZZXhSN+f/sbfZdMpk00ogvIhOt+3MNJM37xsgRoLEvIBNAEUYBwL/nTuEw1s/tXW9ofa2Cf/OZra+1+Hd6mRDgC/E8c/YCjd2wRdnrNIj7FoPL+x0bAuGHZ+UzRE+04H49VObv8x9a7+xcrl+/rlqtZp3L9GuQspFdoDQMS6NQKKhQKLR50/39/TZKH9FlX1+fbt68qcnJyTYOeygUsk5fCt9e/2p8fNyi1tPTU62ururo6EgTExO6deuWqdF6fJ6fR8Svu7ul3Erxt7u724rWKAoACXSykMbY2dmxwWfw9fv6+jQzM2PzPJrNpnZ2dox5h/ow9w60l0gkNDs7q8HBQU1MTFjT1eDgoLq6umziJ82CGPlms6np6WkrGjIzIhKJqNlszRWp1+uanp7WF198oXw+r2fPnlkREGiOg//DDz9IkhnfSCSiTz/9tC3Lazab1oPSyfJqDbVaTdFo1EZHP3/+XD/88IM+/vhjffbZZwoEAlaMr1ar2tjYMEPIdWLECSx4F0tLS5qenrb5O5VKRdFoVH19fRobG9Po6KhBa9CxOaRSq9738uVLra6umqaY14P6+uuvtbW1pXQ6rYmJCUkyBWGcGXLxMKuAxv4u4sD7PEMCJTILqZUd7O3tKZ/PK5FImIGnG5zsob+/31SOYX9hpHyEDrUbYg+Nj0DWDO7L5XJmL2COJhIJ0/SjTpvJZNqafPndnp4eY6qho5dOp5VMJpXJZPTVV1/ZdQKJenr/+y6fsfmalM9mPPRPNsNwPoaWUe/g5ygZYN980yTagTMzMxocHFQmk1EmkzGFg9HRUWuK3d3dVS6Xs2DdMw69E56amrL2A+BREAl6WQYHB210ONnN+z63d3YuNPU1m00zuH4squ8Wly5ojx4DxRMjdEikTRMgw4eY54Jx8DdHFISXhU3mtcyYez8xMWEzy4lkYLIMDw/by+fBM50RT83PcQAotHayMGJ0tAMZYoypERHh+WeK8eK7iQypkyDbDYTDMw0GL6ZrUryniBeLxSRdFCKJashEqtWqIpGIrl27pkAgYIOReAZkh/TA1Go1ky+JRCJWO8MJ+ci4k3WZFsv7ajZbI4Oz2awmJyctivZNpxwYIkIyaupGGEkMI1IYRHXsD6BfCv/AuL6QCiMMh04GGY/Hba+RRfoR281m0zLjYLDVdMjn+brDh6zLjbdkgrxz6m/SBZOJTMs3RcISwyGyr/hvsjwyYj7r+PhYExMTmpiYUKFQsN4d9jSCpxhgfqdcLltNiOslS4Yi63XTkLQhM5Qu5pF4Jtn7LoI7sl3Parvs+Pk73wrAOZPa6b4eneD3qM9QUyH7hTXqp/giv0QTcKPRsIz0snOh8XV0dNTeIbYUFEmS1cou//Foyj+03tm5PHz40BgXQ0NDVmyXZB28w8PDVtwFbuHQ+KltHn6CQutpmbu7uxocHFQ8HrcsAiYTkRyfTwTpGyW9zhOdpzgvmCNDQ0NWUIdMUCgUbHbK3Nycms2mMVTQneq0Q58XMjg4qNHRUcXjcc3NzZlz8QXhYDBoTg6HAvTke0dg0tBt3dvba5PlaOZCCNDPAiGDIULhsGQyGZvwGIlElE6nVau1Rj1//PHHOjo60tbWlorFohljakSk0/V6XYVCQc+fP1d3d7dRzj+U7bS9vW3XPjs7q56eHu3s7Nj+SiaTOj091U8//WR0UJxtX1+fdnd39fLlSzUarfHX0MEhOND9Di22t7e3rVmYbBF4DaiVd4PR89koUEKxWNQPP/xgjX6Dg4M6OzvT6uqqzRrq7u42Layfo4XyLDuFFSXpq6++MrYmmevr16/tnpLJpEqlkv785z+bdA5ntbe3V8fHx/rxxx/V29urGzduGDXYR97sQ+BQYNuurpbQaTqdNtuxuLhoNU/gZsgrTJ4l2yqXy3r9+rU5XHTv2HcEO8vLy1peXjZJo3A4bAFUMpnU3Nxcx89wampKzWbTyEwDAwNKJBKSWk3mnDUK9JIsmDg6OlI4HNann36qarWqtbU100SEGcpZR1SVzK/RaNggNmjEx8fHyuVy6u7u1sbGhvb29kwXDzQG5RNqy2RE29vbJmtFAyfsWHoNG42GjdUmkENv8Rd3Lj/++KMkmcFlw2DoTk9PLR0m0vWFKTIH2Eh+5K2nlcJOSqfTRn+NRqPq6WmNCyWqAR4huoJxhcHkYRWLRWM0AdtxcFB4XVtbs4l6u7u7mp2dNRmboaEhgyugE3a6YIZASJidnbVJdL4BCxy7Xr+Y0schw6lwzzgXIkc2n6cj4mh5VxgAiq/BYFDZbFaZTEaJREJ/+Zd/aWMJyGDu3r1rgpS7u7sWtUkyaXvqOYVCwTb+tWvXFIvFzAh1upiYODMzY8O8cC404jKmmPG9yOHEYjE9fvxYP/zwgxqNhqanpy1w8RAfBhZyAIV8X4fzzYPN5sU8d7JSnAtQUaPRUKFQ0I8//mhRLM5lfX3dml+JStfX1+1nfCSMEfoQWOybb75RKBTSP/kn/0TT09Pa3NzUs2fP1Gg0NDk5qZGREZVKJW1ubppG2MDAgFGRf/zxR/3hD39QX1+fbt++rVQqZcrS7Afukf2FIYecQy2VrNvXJUBFCJrI/ghqUeCo1WoaGhqyOgv02mAwqPX1dW1vbysWi5lSBUgJmXinAeLk5GRbUyh2CsgX5WVkYnwTLjDzJ598orOzM+XzeRWLxTbn4u0pWQW1rlwu1zZS5OjoyEYxbGxs2FmgUI9O3eTkpMbHx81h0+/CRNRCoaDe3t62SaGDg4PKZrPWVoLCODXid82g3/kpsxF8py0UO489YrzAczGW9JdIssMKlksUzEb0xhU5jmAw2ObRuQ6kRegMJsshMmfTQsvFKXZ3dxvrSmp5Z/oaaG703dVIf3ca9dCAeXJyYpkeSs1Iq/DCvaTFZVIBBrCrq0sTExNKp9OWiUgturYv9nHoOaAUj8/OzkwMEOmTZrNpkd7W1pY9T88UIcr1HdnUvzyhgnkX9CNheDpdOEGMNtfA88HIkJH4bMJPXLxM7IDFSO8LWlfs72Aw2AZnUFQmuNnZ2TE59LOzM6MhAwl5SA1IkiAAA0KGSsQfj8e1tLRkhgMjhMpDpwuRR8/O8mQGSCvAKgQzMJSIvmESFgoFYyxxbzAXaXb2s0oajYYikcjfCn58UZv7pBUBqIfrIzilJsaz4XcJRuPxuNkbjGqz2bResU4WUKjXDvMEF/YbTsWz1vg9xj739/dbxobDIPPjd31tLJ1Om4SNd+RQxDmH6OGBdJDZSWqzZexp5GQajQt1ZUoLnoTl4ctf3LnMzMyo0Wgok8kYxscNdHV1WcZSKpVMRhrq6snJiaLRqHHq/YRJGvFoRvKQFy9wa2vLOll5AJIsRaU3AFru5OSkBgYGrIkSyKzZbGpiYkLDw8Pa29uzoUWSbNwxxgu8M5/Pm3w8BqKTBdUYaE+SQW7QncPhsF3HgwcPNDIyosPDQ+txKRQKCoVCunXrlhKJhMbGxpRKpYywgETG1taWotGoIpGI0aq7urr0+vVr7e/vm4EYHBzUrVu3DAPf29vT0dGRXr16pYcPH2pxcVGzs7O2cTlUbPpoNGo4POw2Giyhlp+cnFifDNlCJ4solMNHnY5rI3NG7w4CB6k/wQ2OB5WHXC6nqakp/ct/+S81OjqqRCJhQROGg5rR0tKSNQ4SCPyf//N/tLKy8rMSOTAWyaDoI+nu7tbm5qY17wIdMcb7k08+0b/7d/9OoVBI//W//lctLy+rVCqZo+50/frXvzZH6plLXCfZGgEZZ259fd36f6amptTd3a39/X3rzi+VSkZ6GRwc1J07dzQ+Pq61tTWtrq6a0aM/jcF2BEQYZp6DJKshouqB42DmzuDgoH766Sf9zd/8jTk0oG66/W/cuGFGHSdFl30nCxV1Al9siyT7O8+YZOE89/f3rQl1bGxM6XRah4eH9vyAxXj20WhU4+PjGhkZ0eeff25oSl9fa0T8Tz/9ZL1K165d09bWlkG/+/v7RsPm3oHzUDhIp9PWDrG5uWklBBICSERnZ2d2bQRX77Le2blQVJdk9MqfY0qwKO5J7d3S9XrdOum5AV/cZKN5+nK5XDZ1Wd8g5SnQbDAOMPUVMimcAqKBzKj3rA4fuQIJeZiK1LuTxb3wmT5r8wq8ZANEYhx0H9kBpYTDYYt8fObn+ewsIBqKmkA43D+9P/wMcI+nhP7cYCxfMKWI6Km+vtmL3phOFpg8Ud5lavFlijGZVrlcVj6fVzAYtDqIz37pjSBL85kY38M9ol7ti9wogntYFgPNNfp6hM/g/PvxTCPfRAuM5IOqThcBXCAQMNKGdDGmGGMPPIPj8WQOplMy7I4ZTpwZzg/vAKHVUqnUdnbB9dmz/DzwqqfnkrVwjcBuBIH8Ds+W3yEr4+9wNJ0u3gHvk8K71N5g6R23/zvOVW9vr03gvWyjOOue3QWbFkFZnjH2F1vMZ/i2AQIEatPsW2y5z+Y549hk/5nszfexf+/sXDAyhUJBGxsbSqfTmp+fN0YQ7AxqCBh+5D/i8bhlLnTTb29va3t7W5FIRPPz89YZDwVvZ2dH1WpVr1+/tiIyL5MNiBwIBjIcDpuAIxsyHo8bVRFIDv0yz/F+8+aNKR97VhovAOZGJ8uLSVIUA7aanp42WRjw1qdPn6qvr0+FQqFNOgJ9rtPTU2UyGa2trbVFc/v7+0bbLpfLRudsNpsWzTcaDW1sbKinp8eeL5Fhvd7SLvNS6jT4AeP5YAKoD8jED7vyPUjUjTp9fkSIzMHxPRXMETk6OtLm5qZFsQiOopuGqi20W/ZspVLRN998Yw1tBDpSy9mPj48rEokYJZssORqN6je/+Y0+/fRTPXnyRH/84x/t+fqegHq9bu+Qvy+Xy1b0JuKFTvro0SP9x//4H00bjlEVHyKfI8nIGysrKyaFQ0ZOo+vbt2/14sUL9fT0mEo46hZ9fX02sGt3d9cUHA4PD02apFqtmiYdir/lctmaHNPptPWojI+Pq7u7W6OjozY1lFHG1FcDgYApboyNjSkQCCiTydhArEQioeHhYS0sLGhkZESvXr3SixcvFAqF9N1337X1bHi4vtPV1dWlqakpjY2NWR2ZgFG6GEVCZgMk7MkukHj6+vp048YNjY+Pq1gs6tmzZzahl9HtZHhzc3NaWFiwoBTCQjDYGifNADXuk2t6+/atwf/seWC5SqVio81BH6RWYjA8PKzp6WlzMNIFOeEXh8WIAo6Pj1UoFAz39ErHnmFDJALlMBAIWPGLaObw8LCt58XjjUBmlUpFW1tbpgnkb8xDVX42BzRUDBtDyGAG+RoQ3v3s7EwrKyva3d21LMZHktKFMnQniwzDzwEn4ojH4+rr6zPJkGq1qq2tLQWDQZMQicfjmp6eNkcH3lwsFpVIJDQzM2OHHwwWETtIDF7UjnoChiIWi9mUQaJTCo3+nV127pLaupKJrBhmBsHAs1U6WeDYRMpEddxzLBazOgAsGaI+miKBtCqV1mwUP3tkdXXVmGHUd8ggEDMlg0bKxk9TPDk50ddff217jj/SBd4O0QUHxPsn0vQD8k5OThQOh3X79m2NjY3ZvXzIgh6cy+X0/Plzg6qZgplIJMzxQCcnoIExNjQ0ZB3xQIPU+HzxGUdxfHxsah4MXYPMg+FlNIZnhwFdQoIhaKzX68rn81pbW7O9Go1GNTY2puHhYT19+lRra2u237q7u7WwsGC1Bd/c+b6LPc+4B9RHvMHl/nwxnowK+0nQik389NNPtbm5qefPnxsKA5pCRpZIJDQ+Pm4BI/ua57y9vW3XR9AHPIzIL5kqShMIsZKd+kx7YGDAWJOMT2EPv+vze2fnAsWzu7tbt2/fNmwboTskRuh3+Pjjj20TcbPeMLEx6CmgKaqvr0+pVMr6Z6rVqimCQhWGwUNqfXx8bF6e6JCaCUwq/m5/f1/lctkyLDBlhCHJvrwcCh3TH5JSE3kTCVJDCQQCpvAqyai7GK1wOKxYLKaRkRGLZmicou7B85Nk6sPSRaRKbadQKBhuD8THsDYPK8LEIbpiFgQD4XgezE6hFwYDBJOF1JuoDZilk8WG9sVh/v/6+rpNJ/SFW5pv6XU5ODhoO/DSBRHAU1qBA4FtDw8PLXDBIeTz+TYYkOY16kw4CwIST1ph79NrhHI00ChsN1h4kBE8w7KTlclkzKhRX6TIvLq6qsPDQx0cHBh0DINoe3tb+Xzegg2iYl+Q51lWKhVr5iMQrdVqts96enqsqE4dp1AoSJIpJWNHgsGg1RCJtEE+oCMnEgmFQiE9e/bMCBD1et3aCTjnZImcjU4WQrAnJyc2qvzvY0CyR2HRMqYYO4ro5E8//WT7FbYW1002TWOpJzYA/V7uFfJQrlexILNB6y+fz2t7e1s9PT2an5+3Wg6acoz55n1DCPrFay6///3vFQqF9Otf/1r379+3g1epVLS3t2d6Pzs7O5qentb8/Lz1ani2gsdSEa47OjqyLup79+5pfn5eBwcH2tjYUCDQkivv7u7W69evrdMc40sEz8aneEUDFnLgRAtbW1va3t42ymmhUNDDhw+VzWYVDAYN2qFBCXnrTCZjPQGdLC+ISI/E9va2ZRYU8BgJMD09bZFmvV43Tn1fX2ucLNAjBImnT5/q+PjYDAMRFMYsEAhoa2vLajrg32xkL1yYTCZNUp0UeWpqyiKfUCikt2/f6tmzZ4rFYvrn//yfK5VKKZvNWnq+tbWlarVqjpBIrtNFDYMIytcF+C4cQLVa1e7urkKhkJFPoLsDTdJfxT1xbdRf0FVj9rqvyeGQoDHXajVtbGxYtMgzODw8tIDE4/9dXV2anp7WvXv3VCgU9D//5/+0jnyg3jt37tie39nZMUr1hziXZ8+eSbroFYIAAlWXOgaZ4MTEhMLhsNbW1rS+vm4ZtjdqPjsDq8/n82aICORu3LihkZERUzNuNBqKx+PW/Af9OJPJqKurNcQuFArp4OBAr169sn0YCAQMwhkYGNDc3JyKxaL+5m/+xnQHg8GgxsbG9Fd/9VcaHBzU9va2jo+P2yRWOlljY2NGItrc3GzLJn2m6oMpqSX6Ozc3p+3tbRUKBYOlIpGItre39fz5c9tfMAXT6bTpr8F4fP36talEwGL0zdae5IIjJoiBJRoKhXT79m1NT0/r8ePHWltb08DAgO7fv69kMqnHjx9reXlZZ2dnevHiRVsm/j5Zi/SeBX0OOB6bDQYeTCc8RSMK/7CWvGEmcsQDg9Hz8j1MdpmBQxaE0+BziQyJysH6f664Ksk8MpsE50QTJpsRimY4HO7YuTAgDA0wnAbMJ6ioRCXcAyweakXci6dA+kjIFzuh2eJcyEZg79AjQuMU98oG4l2yqcgYuF5gQ1h8vlBIUygGGQZMpwsqt5fPgIrs6aoeGmB52MlTb/1+4r99hopyAr/LM/QUZgr6EE4o8hPZ+0K936+w7CgS4yy5dt/pTlbuJYA6WX5MLcVxInn2CHvAw8x8JxRVX/uEdIBUE/vBs6ZAOLq6uuw54dQDgYCdZ84D/W581uXlCRuQLLgH32vDeejp6WlToeh0eboxmZXvamfPeWoytVqYhNgWz0g9PDy0d40NIrCjxAD8TyaCAgd7EuVnroOaI++X/Q1qwXOlyZhniU2HaOCJQf/fCvr37t2T1IJ3vvvuO4OOurtbsx1g85B6o+IJ9ZCDe5nXHwwGrRufIjfwAJENKfbBwYGldxgVUm3vFMDl6VQFV5dkOlHUg+r1um7dutVWgKXmAy5cr9dtdnqnNYM7d+7Y5xN97e3tKRQKaXZ2VuFw2DZhtVq1CG5xcdGUBNgYyPBT3IMUwPU2m61ZEBRt4/G4Ocf5+Xltbm7q0aNHqlQqisVilp3hYMH8Dw4OLArP5XJqNBr2HOLxuI1XeP78ud68edM2SZQ5HslkUuFwWNls9r2KgZcXUTf319fXZ5BINBo1OOr4+NiytlAoZIrc1H44IBworgdnUCwWFQy2BtPdunXLai2lUsno9TiVQCBg9M69vT0b1AZELKlNTNP3ar18+dJGN/f19dmcIpQCpIvicTqdNr2xD1kMi0qlUurq6rK5Oz6aZ78PDw8blEW96uTkRI8fP7YAIxgMWkM1ET0wtVeGgG5PdonRpPjt7xdttR9++MFo+PRhRaNRNZtN+/vt7W3LltLptNLptBlIvtdDqB+68vm8pFaWS+ZLK4V0MVkUyj72bn19XblcTiMjI7p+/boFicyXYWgaVGNJ5qBPTk7U39+v69evtwmoUgpAyglI9+TkRAMDA/r88881NDSkN2/eaGNjo23S6KtXr0yt+8aNG2o2m4bKgEL5TMyzG/8+GPDyemfnEovF1Gg0tLm5qVwuZ3AK1Es8pefII+znC09Ec3hoIjsKXmQ9kizbQe6AjIkUnKyJSJTPg0pK9EJkK11kYBQaOSBsDIrXFJ/x9nxWp4sGTeA5DgVRRjQaNUYW7CFeKjRwDCAZl1fYZV4G2QMkC7IgjAn4MxE3DDqfjXDPOPRyuazNzU2LoDxNlibXRqMlqzI0NGTQCjAjke37NGBdXl7agvdMtOabKTFqnn5OpMveg5J8mb5M1Cy1oj+MGTVF9p8vyPr+K6Jor0bgaaJ8D+wxL4pKrYqoFhiCxjm+40MMJdAIBvcyacPTgX3hm7PljenQ0JBF0OFw2BhM7EnfFMjvodEH48zThj39uNFoqa/v7++3UY+xBwRRNK329vZqbGxMvb29NtcFWrnPLN7XOF5eZFs8E5/5AsddbjqUZPakv7/fFD98Lwl9ev7++Xfud2hoyIgm7H2eGe/g6OjIgvdkMqlEImHSVlwTzpmaVTKZVKVS0f7+vk329GiF/8O1vOt6Z+cCnRWjR6Toezdg19BoA9aNoiozXng5wD1Elr6jFZFJUmgcVrlctmmYfX19dtjoyJcu+OV+UBQRGQwPP3OGA+37PzCYZDJQH5vNpv7tv/237/yAWcA6KEgHg8E2RhO48+rqqoaHh3X37l07wBQBKQpDzYR5Qt3FQ0L9/f02gwdDisOIRCL68ssv1Wg0DFf3WQ8wA6oEgUBrXn2j0dI42tzctEZX4FG/N3i2wBrQlO/evdtxzeDu3buSLkQ7qaugVIDo6NDQkBUfOaAoHqTTaUmyCaQ+yMFRER1CT8aJUlDe2dkxcU7fa4WBg7FGz4eXNQ8Gg7p+/boGBgZskmt/f78mJiYUiURMH21gYMD0sIaHh9Xb26vDw0Otra19kHO5f/++PcOurq42JQamyUqtAGh/f1+///3v1Wi0Gqez2az6+/t1+/ZtY4QdHR0ZM8pD0KAYDG3DSGJAqQdQ64M4Qv3Uiy4yERQli2azqWQyac2BOB1qsGSSwWDQdNCQ+F9bW7Mmw//wH/7Dez8/ng/vgBHaFL8ZYMa9TUxMtEHOnHHo1+FwWOVyWVtbW5Jk0NSbN2/UbDb16aef6le/+pWVFXD+OIi1tTVrVsZWUTOmlSCdTttUXoJB3jGwbK1Ws9okkDPPVpJlYl5W613WOzsX2EjcBDxu6aI7FQobzVgUogqFglKplKV9RJ+RSMRqAL6Ww4Hd39+32g1G7+joSIODg9bXAdzBd0oXUSgRPVCa170aGxvT2NhYW3SLk+R76vW6RcU7OzttHf3vu6AB7+/vq1gsKhaLmbYYhfdyuaxMJqPZ2VktLCwolUppe3vb1AWazQvlXPpmiBbJCqExUphvNBpGl+RPJBLRb37zG3V3d9vvkwn5+gPRMgy+Wq2mhw8famNjwyANon1+HmdNw97GxoZKpZKuXbummzdvdox537x5U5Isu9rc3NTq6qqCwaBmZmZMkRn6Mx3kOORoNKpbt27ZocJpetkQCqLAeC9fvlRvb6/u3btnfRhkxQw+I2jp7m6NQKDWEAgEFIvFNDw8bDM4AoGArl27ppmZGb1+/dogjFQqZc4YyJS5SZ6Bh/5ep+vOnTuWidEG8PjxYzPOwIvsmZcvX9o5qNfrmpub09LSkkHKZCKcWc4KjhrDSfEeA4kRw7mQ3dLOAOQGmzEej1t/XbPZ1K1bt4xRyvuDaoxjPjw81LNnz9Td3a1/9I/+kUZHR5XP5/XNN990/AwJVFkTExO6d++eZXs+E+nt7dXi4qIxLyEn0F82PDyseDxuLQe+BWN3d1fFYlHT09PWA8Qz5l2Uy2VtbGxoe3u7DUWC0AM5aGxsTIeHh3ZNZ2dnxqoke/YMTJ4p2ZB/X+FwWJOTk7+8c8GL4enoJQAqItoFPgIbDIfDRkX0Y0Z90ajZbFq3OfURWDdg2xSHYTGROmIUmF6J48NYImNPhypwGhEmUT09FLB8aHT03arxePyDYR10fbge2GIYaYZzMcfh/PzcDhtUQyI7sh4cFPAgTp5nD3UTqIVMjGiKrI9nSnEeaQq495JMrA9SQCgUsvEFRGnd3d1tCtg+Un6fgqBfHtsGuoxGo2ZQuru7DcaDQUOBGkiKg0S9ELjAU2mBEDF+9APQoU4tB/irWCwqn8+3FZd9975/10T87AcK9dls1tS4LxswMv+enh4tLCx8UObCuSEYCQQC1ssAsQPHVqlU7MyzwPqbzaZl/UzJ9AVgnj2EHoyXJJtSiSODDME79bJPGOvLkDhUZmwNlGXpItDFGIZCIatXUcPsNEBkT9O4TVZHxkWRnGvi79hHOL3e3l5TcwDVoQ4cCoWUTCYt+JUu6ozYI/YTEDWZH/9WKpW0vr5uAUmxWGyrL/r2Cj7XkwGA2lBYwW5Lsprku6z3mufCZjg+PlYikdD169etAOfZR3Qv0yUPtjc6OqpAIGDy1Bj17u5updNp+//NZtOGDaHmiTGp1WrWyNXV1WXGeHx83KiCMGtQ8L3s8avV1gwSGCk8OJwLTXZATJVKReFw2ArrnSxUSynosvmazabW19dVLBY1NTVlQ7bQnoKujfQGGR/9KH4miCSLnOHIn5ycaGdnx543z2Z9fd2i/kQiYdH26emp1Vk2Nja0sbFh0WlfX2uo2Y0bN/TkyRMtLy8bhJdMJtueMdL/8/PzisVi1kvRqXF88+aN7T+6kxcWFoyi3d/fr9XVVVPvhnnHIYGyTBbDPcOc2d/fN8gALj/UX7Lj6enpNvilVqtpdXVVmUzGnD9OmaDocib8ww8/mGAgMNrDhw9VqVR0//593bp1S1KriEpvw/n5uSYmJvTxxx937JylC2mhYrGoTCajZDKp3/zmNzZSvK+vT+vr63r58qXpX3kmUr1e187OjkKhkPXh+HqTl2iCCeUbeo+PjzU7O6uPP/7YoC5GYu/v7xucg/E8Pz+34IYMu9Fo9TVtbGzYXJLT01OtrKzo+PhYqVRKyWRSkUjEiAvb29taXV1VKpXSv/7X/7rjZ7i5uWk2Z3Z2Vru7u/pf/+t/tWW0NNg2Gg2trKyo0WiY8wDq9xT/arVqCArn57PPPtPCwoImJyclXdDkyShRi6aQT+ayu7urnZ0dFYtFHR8fm8BopVIxeJf9T50NqBFihWcL0ldF3e/w8FDr6+vvTGp6r8zF01A9XY60jgPmoSZwbCIYokSPveMpfWHR63zxfXR+Q5+7rDVE2u2zLJ/FYNi4Fwp0GBU2NNHs5frAh/QY+KIzKTCZC7WNev1iqh/XQeH15/6wqHPgnKWLmS3AlX79HJWbZ0OU6TWIYKE0m00bfwABg2zI19Iu06D7+lqzcMjQOllkxpchWCBFX1zlHtmT1NSATyE1cL/+WfLvROD0H3AfvrvcwyEe2rhcQL5MfeYcQL/30TkMQP7wd5JM0bvTxbPzZwmlAbI/jJxv+OSs8xkEM8AmZPe+KA8szTOk7kLQ48k/0HH9+eezPGvJE3NYnEnf/OrfP+QZgitEXDtZ/jN5bx7lkPS3zpF/ljwDkJPLLD1IDuw5bKbvNQF24zz4gjvoB8w9vhOE57KNYD/+3PPk3/379BD4u6x3di6Tk5OWUZycnFihGcNGMyT9HKT6yJFUKhXT/InH4xocHGzb1KSwpMRAYJJMCJChSkNDQ6bOSkQDvOP7H8AeC4WC3rx5o3q9bnMroABSj6GQBf5LwxaGJZfLaXl5uePI+8svv1StVtOPP/6oly9fqlarGbUUeAEqIM1UOEwi4lwuZ6J3Q0NDOj4+bqtHce9EHWQ6DFrzonRg/L7XgoMOdBcOhzUxMaFKpWI0VobCnZyc2BjU5eVlra6u2hA0D+URGIAld/r8YC8h80EmGQgEjG4ciUT0xRdfqFwua2VlRaenp0omk1YoLxQKOj8/N1kTom32T29vrx48eKClpSUdHBxYpnP9+nWj3bPn0GmiqHt0dGQkEK+xRi2Q6arQvlGK9kX1k5MTbWxsWLbOOQiFQioUCpYhdbpevnyprq4uXb9+XV9++aUFBaALPT09yufzpkGH1Ah1H2pTXpokGAzaPSaTSUMvwuGw9vf3lclk7P57elojdmOxmBEYJGl9fd2iZqAukAuCyVqtZmeSLAtIqFaraXR0VJVKxWDiYrGoJ0+eqF5vzSMBBoWe38manZ1Vs9nU/v6+stms2R4Mb7PZtMwfEgmOvKenxxhjkiyDJEvr6uoyhOLFixc6PDzUzZs3lUql2vQbs9mscrmcdnd3TckYBemDgwMLWMmcCX68wC2UarJCqQX5+QCBTMcHoDipd13v7FyYcQK2R2MUBhjPCH6P8By1lMPDQ+3t7Zn8CVEgMi7AGHZh/2+j8WCazabi8bj1WdA1vbW1ZT01RFhEl6R3nh6J5AyMGDKIWq1mZARPkeQQYWA7xWsXFhZUq9WUyWQsAgOWwxnAJpMulGNhzZydnVl2Q3+P1wMiuuHw8z4ajYbVsoic+H1JZlx5fr5mwAE5ODgwSQjqQOfn50YphUnY3d1txUff0Ab99TIj8H0WnxOPx03wEOVrOsKBSfb39/XmzRujaaNJxb7l2UoXjbRSK7ucnp7W3bt3tbW1ZbWmW7duGfwCXbNYLNre5zmQCXu1CPYSQdT4+Lj1bXBWmHFSq9WsZoScDJkFfUcfkj1ns1n19PToV7/6lT7//HMdHR0pm81Kkl1TPB5XPB43Z+kp+VwrdH72KQ6GYWaTk5PWX0adbXp62gRlqQcyI4rM0p9hgksC0GazaTWqVCplhXKyP5wH1+rJBGNjY/ZzvLdOFtT09fV1G5jHcyAboOEWdAWbQmACVMr7pqSA3anVajaKAYgQEgqZEn18aAvyvTggj0b4GhYUfL6b8yDJ0BrugwCd6yXD5x7eZb2zcwHSgGnjU1nSu3A4rGvXrtlmg0dPjwVDrjCiaAPhqMge6EVIJBJWXKaZiIfz9u1bcyB4fKkFhW1tbZmkBYKN/DuzRpAq8YVfIvve3l4bC4w3TyaT+vTTTzuGdR49eqR6vW7Zkjc4RLOe/UJElM/nDd7z9QGiEuAd3x3MpkVBmKazQqFgOk4sMiPPJtvd3bWaViAQMKZbIBDQ8PCwRkdHlclktLOzY5x6AgtqPhTGaVStVqtWt+tkpVIpSa262PLyskW+9XrdRrz29PSYIZmamlKlUtHExIRGR0fbtLx41j5SJuBBOicej+vGjRtGMSZqxmEB6ySTScs0p6enLSLlHdNsx3OBCTQ5OamJiQm7Zo930/cEFRd4hIJyp4vvWV1dtdlAZB1+FAR1PsRfGRfM2fS9QvQ8MTMJQwSlemlpST09PZqenraRDjgUDNr09LRlIdFo1CjMBD1o2uHUkJAZHx+3PYAT5Mz39vYaw3BsbKwtAOh0D0KhDgQCdi3euXZ1dbUhBDDqeK84FUltRCLpQtzUF9jz+by+/fZbq/vWai1tRDTYsBFAzpBHyDwI2iVZq4XfU742CAnBw7YEXdglYMxfvObCiE36RMrlsnZ3d42yRv8Fstgsolx6H0gdS6WSpqenNTExocPDQzNobGpkwDGs8MN5KJlMRo1GQ7dv39b4+LhBaEdHR/r+++/bVEKR6w6FQsbuIbUNBoPGdoIjT9TBJpBaw9Lu3bvXcdTz+9//3q6vUqlYM9nAwIBmZ2c1MjJikJSnAdMTw/f29/drZ2fHMgffxyNd1FMYSVypVNqiYcYYYKiACYvFovb29uxQVKvVtp6PWq1mXdLj4+Mm9x+JRHTz5k0lEgkLAjhggUDABCXr9bpNBuxkzc7Oql6v6/Hjx3r16pWSyaSWlpYktVQhisWiNXBGIhEtLS2p2WyaRpPPYjc3N21+OcVW+g6Ab1KplGZmZmxfkwUSBA0PD1vWTeE6Fovp+PhYjx490sHBgT2/UqlkPVsUUEdGRmxwHTp2BG3xeFwLCwuGkUstSvebN286zvx4hrVazZ7h2NiYEQhWV1dVLBZ1584d3b9/3/D6YDCo8fFxG6KG4ySiHh0d1djYmEqlkp4/f2779/j42KTwBwYGzIFks1lls1nL3ru6urS0tNTWFHhwcKCVlRVjtaEC7OnthUJBAwMDlrFgn2i47uvr04MHD9pqlARZnQaI3rl73T6K5H19fQZZ+dEQ/KF+0tXVZT+Ps/UBNujCzs6OwYoYdVQzPImAc07WRuBKLZo9SuabSqVscB+ZpW/uJBgkoQCa/bkazd+33tm5oA9FAd83nHnaGnIkvtDGxcJIAroBbvJyCXjOUChktRb42TgXr1flC/l03VPwAkfHoRFJ8sC5Tl+05A8vlEjDQ2SdLK6X4t/l4j5RCFCg1/iBPgvbg9Qbg8dneMIEBr5SqZjThPXE30kyRp9vqCJKlNTG/iFy4X5isZgdEN4v94Gx8PDJhyyiRqjPfiIeAQ4RPgV0SfZeoV9zaKgzAfP4gifwHywpb9D5mZGRESuuEhHzrIAiYPbhmKULDbGzszOTxKHm6CNbX4ymLvghUbektiY5T4yRZNJG7CkgFaJWmGFQoz15gjOFKgOL+Uoe8qZtgKI1WZBvL+AeCQyp23kqLTUwDCzPnfcAFOvJFMBKnToXSX/rd3EYBFOe2s7P8zv0p2F3vL6gdzI4SFhyvqZTLBatw559hkPw1+cRJfYvNRRfZwb+5174b96pf36cpV8cFpufn7cvp2gHHEL0W6lUrOjooy6p1eH/6tUrDQwM6He/+51mZ2cVCAS0trZmDT30z3R3d9scDQpk8NaJVsBrfV/I1taW4eE0C8ZiMZ2cnOjNmzfq6urSp59+qomJCQUCAeXz+TYJDK7bs2Z2d3fNg7O5//2///fv+ths3b59W/V6Xc+fP1c+nzfoS2rRlPP5vM39JnsgOjk7O7ORpMxX4ABRd4DqSvpKH0qxWNTjx4/bdKlKpZJFwYeHh1aEp9EqnU6rv79fW1tb2t3dNWWEnp4ec97j4+P6p//0n1o0jq6UJFNQAPrgYHyIYXzz5o0CgZZU/MLCgsGdNPdByTw6OmrrtcBRZrNZo/xSxJyYmNDCwoJBkeDM0DjB+vP5vPUVoEgbCoVUqVQsUu3q6lImk7Ha3OnpqdLptK5du2bUe6JLqdUv8J//8382CG9qakqSDDfnea6trRl8i7HsdGUyGauJXL9+3aDFQCCg2dlZM3bAJQQgU1NTikQi2tjY0MOHD1WtXozBgK4NJE4gSWbNvwNXMcbb1/2oJ2D8MZ5SCzFIp9Omjlyr1bS4uGh9Mmtra0b/pt+EmgSQFMPOdnd39eLFi46zP2/kYU5h1Kk/E4Dz85LM+E9MTOi3v/2tzs/P9dVXX2lra8ucA/aGbB/2IA3mnCOek2cmXnYslCEQEy6VShoaGrLRGJubm0YigWZMIEugBXGiXm9J9zBGfHx8/JfvcyFCJYogqqCo1tvbaxMJg8Fgm6ELBoMmfjg4OGjZC5uCzchDxDDgOX1hFBYSNRGPGXtBR6Lcvr4+c148FKio3AdGyOPeOEZ6FKh3dGog4fuz8aSLqIfMjSFdnupK9kE0jfQJ/0a0RgTH9XvNK1QJPMzFTPNSqdSmdXS5OY3vIprle3t6WpMKGQTlDSfX2t3d3RadfUgxGsl0xEipqfl9SD2OZ+sp8mdnZzbEiqgOo8gepR7INSNzxLtnn7OvgHaYxSOpLRNnD/Ms/JkANx8cHLTay2W1CBqJ9/f37Ro/ZKFMPDo6ar1BXm1Xas1WwZmiokzWSl8KjX/04vCsyX5w4DC3JJlBhL3o5UXYu1CvvcDpwMCAotFoW0aIUywWi8rlcm2Kvjgx6oi+uE2duFNSDvuXjNwbfQJFzxC8TI3v6+uzCZY8u8vngnqVp6j77+Gc8rOXr4v/ZY9z316yiAAC1W/pIrthn2FrQUMuo0nvst7ZuXz33Xeq11vaXMVi0eiCkuzG6Qz16ezk5KR5PDjy29vbKpfLbd4S2h6NjLAoMIAYy1wuZ9Fos9lUJpMxuIeolcYlWFLUiur1utbW1tRsNq3ZqNFotA0rKpVKSqVSNuwsGo1adzmGq5P18uVL+2+iVDYXtOyzszNtbW1ZBMOBx0ivrKyYcSLS8awTagEDAwPa29vTysqKFfbBTMl4IFJ4Z8X/ZjIZgyLj8bgdJjqhl5eXTReORkypxUYiynn+/LnRznHmRESdLOo11I2YBijJJHLYI0Rk0LZhY+GcicR7enp0cHBg+88X33GovkkNAVFqAqVSSU+ePLH6H+8qlUqpp6dHu7u7Wl9ft2I3xWuo+BhuKLMs6oAwfDAI9DZ0uoBJyEiHh4fNseHcVldX9fz5c5Oz6e/vt4FdnBPPkNrb2zOa8LVr1wwKoz8N+BJH7YM6nIGfHsk+lFoEoVwup1KppHw+b6jI4uKiBT6lUklHR0daW1vTycmJGcxYLKZbt24ZyeT8/Nwo4p06F5whzpFR7DjYRqOhZDKpubk5G0OOhh21pO+//94cMB32KKITpGHIyQJhlPoAw8Nt7GvPuPOlBkoJXksRJKFeb82KQvMO+352dmYq9MDlOPFfHBZ78uSJPZRqtWoMLTZNs9lsG7dJ1JJOp81jwqbIZrPKZDJ2g3Tz9/T0WJdvqVSyoULgj0dHRyaWNzo6qmazJRW9trbW5nGhQfru7GKxqPPzc21tbanZvNBXAl45Pz+3CXrn5+d68OCBjVYlE/iQtbq6qq6ui5GuZBREc2RYxWLRjCORLLg/sAYMHV9YJXpmk+/u7ur58+eG2RPFQMWFVklkzmcFg0Ht7OzYtQ4PD5s6QKPR0MbGhra2tqxPY3BwUDdu3LD57mSve3t7bcVUakadOhcmn7569Urr6+u6efOmfv3rXxu0ihGikD42NqZwOGw6bkSz0I2TyaRyuZyy2azC4bD1UPE8PARFsyDPDxZPLpfT27dvTb682Wz1gS0tLSkajeqrr77S999/b78HcQDKNof5yZMnxiCD0YUqAjVOovoPWWRy6P0xvrm/v99ILRsbG/rxxx+NNhyJRGykABIrLCDDfD6v8fFxg9owfJxJH50DOfOcT05OtLKyoh9//LGtV41gJJ/PW9C3u7trcDKOuVwum7M/PDzU/Py8Ff9v376t3t5eY8chR9Wpc+HaY7GYhoaGtLe3Z+PX2S/RaFQ3btxQsVjU/v6+Md6kFhT64sULSbLsD/0vfp4MDYgNx0yvjN+H/rpgr4F8EGj5Gqof3837A2W4du2aEomElpeXTVwXbUc+kz34rk2o7+xchoaGrOB3dnZmh4O+F3BSYDMf7bGZkCLw8x58YV1q4a9gvb5YjfMql8sWlfKS8OwUvPn38/PWiFjELsHaMcgcXCA/XlR/f792d3etnnG5I7mThZQDsEso1NIQ8pGE72vxhXlweF4szwydJ+AqSdbIRyYTCASsgAqsADxAhsdzQLbCY7lkhXwWjDEyJ/YEUdjQ0FAbd95LrLxP1HN5lUolIzykUilFIhEdHR2Zs4WqTCMvwqYUUGkIxSAyodTPh4csAbsRJwtmzv5Dtsf3ewAXdnV1WS+Fb4Jk0qckm85Isd9r8QE3IRE0OjraxkL6kJoLpBLIA93d3VbYpbExkUhoZmbG6mZkdF6hgb0GPMofomemW0oXw8DYKzQYUlf1HefsdYJCFDrYN4lEwggvUPR5jkxpRV8Qx4NxpGeG3+9k+b4+Aj6yXZwLc2bo8wOWk9TWG8h7hIHnz6snKfEM/X7iuRUKBctyUOPwYwFYOGQCf4JIrqlSqSibzRpc7s8o2RAO6v+LKjLGkcwFyAiopFAo6PT01JxKKpUyqQcOLTMDSLuQE+fipZYc+urqqkX2GAAoyIeHhwYZoJ2DgRkfHzc2SigU0vr6unXkQpFm8zcajbY+E09FPj091ePHjxUKhTQ/P2+Z1Ycc7M8++0z1el1v377V5uam4vG45ufnFQwG7dnRWMYmhIrphRG9Qz4+Pm5zfhTygXvIWBiLjIE/ODiwPgJUVEdGRpRKpYzEQBc6A82InGZmZhSPx3V4eGhd6siiIz9ONgFcxwH0bLb3XYy8TqVS1kvFtaXTaU1PT1uzbiKR0J07d4yCTD/K1NSUDg8P9dd//ddaX1/XnTt39PHHH9swLJQYoNqTWZLZvn37Vm/fvtXg4KCuXbtm+wwWIO8RanSlUjGdvcXFRYVCIe3v72tra0szMzNKpVLWIwM9Gcd9cHCgnp4e3bp1S0NDQ3r69KnVYTpdtALQWApjrb+/X4uLixodHdWNGzdM3eH27dvq7+9XLpdTPp9vK/yTySQSCctyCCS3t7dtaCDXi0ElKo7H47p7967RYamhoRTth/wdHBxocHBQN2/eNJhrZWXF1DqAZz0dt1KpWIDIudrf37fz1cna29uzTIxgAiFTArK9vT2D/CGcXC7G0xcTDAYt0CGogRYM8w5KOCK+8XhcqVTKHBI9Pcj3o/FIgIpTPTk50cOHD41OT/ZC3Rt7B6GJd0bPTCgU0sjIiCYnJ3/5zIXCHLio74Rn05MFUAiCgQTnG8ckXfSPAONQ7MQIeTrpZU9JFsTP8iBJv/H8ZEy+AYsow1OPKYL7e+Rlc2885E4Xcy9IL4k42KxEN56qSorsSQSeNw8l2Xd7++yErM5L9AOf+YjE/69/njgCDpOncnOdpMp+RKqHRLgWagedOhff7Hp5bjkRP99BNkhRl7oeWchlJ1ev1614XSqVTEWad4PYKTpS9A1wfz6rA0Ilcicr8Y10ntp9mR7v9yjXebnY3+nCqPI9gUDAGhR5/3TaQ5IgIqZ2wB4hg+a+cMKNRsPUtKWLs8tz95ks2SOYvtdU8zUFnhHZEXbEU6kJFNn/kgz25hox9J1mLtgbakWekn35TP4cO5L7udyo6NECv/wevUzoYF/wb1wD78c/P7IeaM08T34GajL2ksWZ8QQnT1f+h9Z7qyJD84tEIm0SLOiIBYOtuSSvXr3S6emp4vG4hoaGrHEyGAxqamrKPO3h4aFFL6S1NEXSUc3mo8O8Wq3a2F3gsEqlojdv3mhkZERzc3M2W8NTUonKj4+PNTo6qqmpKdXrdauzQF2WZN3GkAToe/iQ1Ww2TdK8q6vL/pfGStLbw8NDPX36VEdHR4pGo1YfYWMgj57P57W1taVYLGZYMxLbno1Ew165XFY2m1W1WjVdJwKEfD5vkiNssP7+fpvfgGEH3oFxcnJyoj/96U/q6+sz8sD5+bnVaIA5I5GIJiYmLGJ634XxI6rmnXZ3d1t9ZW1tTZJMZaBcLttAJd+Nv7i4qAcPHqhebzWgbW9va3Nzs411ND4+biNgt7e3dXJyopGREd27d09HR0d69uyZ6aWVy2Ulk0ndvHlTjUZrZk+pVDKI6fz8vI0yi8I3TiuZTBo0B9usUCiY0RgZGVEmk1E+n/+gzAV9OKjPNL3ybHh30oX21fHxsba3t22k8NHRkXp7e3X79m2DUSE5/PGPf1Sz2dTu7q7dP5nO27dvVS6Xtbi4qE8//VQHBwf605/+pKOjI+VyOWNIEXAhNxSJRLS4uGiGGNJLqVTS1NSURkZG1Nvbq0Qi0RbUlEol626/du2aYrGY3rx5o9XV1Y6dC+eAQANHgjEni6Um5ANo9jBBIMsH1wTIQNGS7J4oQQDLdne3lOQhG/m/q9VaMkL0RXmnGgqFdO3aNY2NjWlra8vGG9PZf3h4qK6ulsbi3NycJNmY+WKxqLdv3/7yzgWmDBidJIMSmP9AcyMQmB8o5JkJiA7iJDhQRJzDw8NKJpMmFHdwcGD4am9vr3WTV6tV63Q9Pj62A9nT05KjHx4e1vDwsHlwDg7Y+PDwsEVBXOfAwIDhvpKsKRB47kPotFwDKsgcbLIMCsknJydmtIjOPF2WiAJjhaIB9GzqWsxbgdkXCASMku0ltokeqXXR9xMOh42xRo3KkyQoGiLfTxQPnk4UC15P0biTRVTGNXDtfJePYsHbq9WqMpmMVldX7ffj8bg+++wzLS0taXt727TplpeXrZ+J/ZJOpw3qQLssnU5re3vbCAT0aPT09GhyctLgmHK5rNHRUQ0PD+vw8NDGHng5IzIYrpso0kf1FFULhYJlBp0uJF9QhKjX68ZaYz+ReWJwgGZxNPv7+wZFjY2NGRRzenpqBWkgLuaMBAIBg8Ppi2PfIKLIO/a1RrJE+rCAgUqlkvb3920yJGeCaL6np8dmmQDbwhhFLaLTPeidHBkYRXf/DMlK/T35v8Mh4Vx81uJ7WQhsqSMTYBMwUi6oVCp2FmDYSmr7DvZOIpHQ9PS0Bc6XM0VJRvnHURMA+/f1D613di77+/sWifIlz58/VyAQ0Nu3b1UsFjU6Oqp0Om20z0gkYgwYMhfPA+dniJo8fRGpDnTEoD/DOCIi8iwxor/Xr19bdFMul41qSqMX40cpunEtUJepFSHeSG/AzMxMx70GQAd8/mUKsBcDrVQqpu/Es/GNfhQ7gf9qtZq2trasyXR+ft7uD8yczY+AJhAWFOtgMGh0cIq4nlPvG0vPzs6USCT0+eefW+MaxViYhFNTUxbNHRwcGP37XfHaywvHRUGYd97V1Rq21dXVpZOTE925c8cgzHq91XibSCSsN6Kvr88Ubb36AJkZVG40yc7PWzNVTk9PLaAh0KHeQ0ZFzwWBCLN0AoGA1aPA5AuFgn766SfLZhuNlsAilGugMdTFm82mRZKdLvbu3t6e6vW6jR6XZPJLPjonCEsmk5qenjZ2nNRSMs5msyZ0yX6mh4Ng8zKz6cWLF8pms6rXW9M8x8fHTXiUgMGzxnwdEgJEb2+vjo+P1d3dbXsbO5BOp22myuzsrAVAW1tbikaj+t3vftfx86Ph0Pf60WuF0jYtFNRBgVrJIoDDuGbPTMS48/mcU9iDBH0Em9Db/WBA9hLBFnAY7+H8/NzaN/L5fJs6AvAc38tgOxwoNvpd1zs7F+TSiWCIxM7Pz7W+vq5SqaSlpSWTMoemPDc3p8XFRRvxKV3Mu4fi6qGh8fFx85hEcC9evNDOzo6uX7+upaUlKyDX63W7HqLis7MzPXnyxOa2QzyYmJiwbuienh7t7OwYVEHEg+E/Pz83zSIij4mJCd29e/eDYB3YWTgNMkCMMp3RQD2hUMgkbSi2EclwbziX1dVV9ff3686dO5qenlZPT4/29/ft3ZXLZcXjcd28edMMJeN39/f3rVBIgbmnp0fZbFb7+/ttTaw4l/Hxcc3Nzenk5ETPnj1TsVi0CCeVSunOnTuSLjIeepI6zfx4T5BCOLzsgWq1qlu3bunzzz/X6emp1tbWdHx8bJMz0+m0zX//6aef9OTJE8ViMUWjUaOL0qMyNjamdDqt8fFxE0wtFova3NzU8vKyBgYGND4+rv7+fhtRvLOzo9evX1sthQz48PBQsVhMN27cMGNUrbZGeAPjETiMjo4qlUpZ3QBat9Tqjbp+/XrHzlm6KKpvbm5qY2NDqVRKt27dUrPZ1PLysnK5nJLJpBE7wOH/8i//Up999pnW19dNzv7FixcqFAr6/PPPTbMMtlIoFDIb4CPmZrNpY7IXFxf1b/7Nv9HQ0JCeP3+u7e1tC5p8pB8Oh63LnzU7Oyup5eBevHhhBq+rq8v6mur1uq5fv65yuazXr19rf39ff/EXf6Hf/e53HWfPvsgOfAf6gN3a39/X3t6e2TdJppaB8aa+C9GJeouvGcPCBcoaHh42YlEsFlOpVLLhex999JHGx8e1vb1tShaxWMxsAFmM1ILhXr16JUltaAf1I2rZlUrFAiMcI9DYu9b93tlSXi4SQakFy6MwdbmQBJRDUeiycSGaulwYY0Fj9DpB0gUhgJdNNEDa6lkaXAs/44vX/kHxvVz3z6W0nToX/x388d/tsVfYYJcbpi5DIpeL0kRFOAN/jxxAX7z3BXt/bb54+HPPh//mefDzfKZn//nv+RBIh8VzoEjJgWV/8H79dfLe6fUBfvq56/H34d8B1+9/zxfkuR6IKfw8P+sxeO6DrBCYxD8v/855B7y3X+IZeiaXp7N7R0Ad4HLxnjPmO8z98/L///LCAXlCw9/3O5fPoD+jPDf/jP2/sQ/9nvE6iO+7/i6C0WVyDNdxORB4HzLG3/Uc/P68TATyhX3/Gf58s6/8M/Gf76+Vf/c2/33OcKD5IfSTq3W1rtbVulpX62fWh4dBV+tqXa2rdbWu1qV15Vyu1tW6Wlfrav3i68q5XK2rdbWu1tX6xdeVc7laV+tqXa2r9YuvK+dyta7W1bpaV+sXX1fO5Wpdrat1ta7WL76unMvVulpX62pdrV98XTmXq3W1rtbVulq/+LpyLlfral2tq3W1fvH1fwH57WKncqJ1jwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -521,19 +521,19 @@ "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 20/50 [01:35<02:22, 4.74s/it]" + " 50%|█████ | 100/200 [07:56<07:49, 4.70s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 20, iteration: 468, Discriminator Loss:array(1.25664, dtype=float32), Generator Loss: array(0.526989, dtype=float32)\n" + "Epoch: 100, iteration: 468, Discriminator Loss:array(1.01599, dtype=float32), Generator Loss: array(0.691249, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -545,19 +545,19 @@ "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 30/50 [02:23<01:34, 4.74s/it]" + " 75%|███████▌ | 150/200 [11:57<03:58, 4.78s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 30, iteration: 468, Discriminator Loss:array(1.16943, dtype=float32), Generator Loss: array(0.59993, dtype=float32)\n" + "Epoch: 150, iteration: 468, Discriminator Loss:array(1.02523, dtype=float32), Generator Loss: array(0.686512, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -569,37 +569,13 @@ "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 40/50 [03:11<00:47, 4.74s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch: 40, iteration: 468, Discriminator Loss:array(1.11762, dtype=float32), Generator Loss: array(0.624788, dtype=float32)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 50/50 [03:58<00:00, 4.78s/it]\n" + "100%|██████████| 200/200 [15:59<00:00, 4.80s/it]\n" ] } ], "source": [ "# Set your parameters\n", - "n_epochs = 50\n", + "n_epochs = 200\n", "display_step = 5000\n", "cur_step = 0\n", "\n", @@ -639,12 +615,12 @@ " # show_images(real)\n", " # cur_step += 1\n", " \n", - " if epoch%10==0:\n", + " if epoch%50==0:\n", " print(\"Epoch: {}, iteration: {}, Discriminator Loss:{}, Generator Loss: {}\".format(epoch,idx,D_loss,G_loss))\n", " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", " fake = gen(fake_noise)\n", " show_images(fake)\n", - " # show_images(real)\n", + " # show_images(real) likjmnh jy,t\n", " \n", " # print('Losses D={0} G={1}'.format(D_loss,G_loss))" ] From ad2b6643c030cff5381957d900b50c850d039f06 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Tue, 30 Jul 2024 16:59:35 +0300 Subject: [PATCH 28/38] Updating GAN Code... --- gan/playground.ipynb | 78 ++++++++++++++++++++++---------------------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index be440fd7..2fda8980 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 538, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 539, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 540, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 541, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 542, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -95,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 543, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -123,7 +123,7 @@ ")" ] }, - "execution_count": 543, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 544, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -146,12 +146,12 @@ }, { "cell_type": "code", - "execution_count": 545, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -176,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 546, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -190,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": 547, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -215,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 548, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -244,7 +244,7 @@ ")" ] }, - "execution_count": 548, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -277,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 549, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -311,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 550, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -331,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 551, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -341,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 552, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -351,16 +351,16 @@ }, { "cell_type": "code", - "execution_count": 553, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 553, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -381,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 554, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -394,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 555, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -418,12 +418,12 @@ }, { "cell_type": "code", - "execution_count": 556, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -448,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 557, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -466,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 558, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -480,12 +480,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 0, iteration: 468, Discriminator Loss:array(1.31356, dtype=float32), Generator Loss: array(0.465569, dtype=float32)\n" + "Epoch: 0, iteration: 468, Discriminator Loss:array(1.32117, dtype=float32), Generator Loss: array(0.462009, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -497,19 +497,19 @@ "name": "stderr", "output_type": "stream", "text": [ - " 25%|██▌ | 50/200 [03:59<11:45, 4.70s/it]" + " 25%|██▌ | 50/200 [04:00<11:30, 4.60s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 50, iteration: 468, Discriminator Loss:array(1.02203, dtype=float32), Generator Loss: array(0.689288, dtype=float32)\n" + "Epoch: 50, iteration: 468, Discriminator Loss:array(1.04, dtype=float32), Generator Loss: array(0.682963, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -521,19 +521,19 @@ "name": "stderr", "output_type": "stream", "text": [ - " 50%|█████ | 100/200 [07:56<07:49, 4.70s/it]" + " 50%|█████ | 100/200 [07:56<08:08, 4.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 100, iteration: 468, Discriminator Loss:array(1.01599, dtype=float32), Generator Loss: array(0.691249, dtype=float32)\n" + "Epoch: 100, iteration: 468, Discriminator Loss:array(1.01769, dtype=float32), Generator Loss: array(0.685513, dtype=float32)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9aY9l53UdvO48z0PdmoeunpvdZJMUKcoxTSkUHScBAgOJDRjINyM/IX8kCPIpQYB8sWNBiWXJckSZpERRHJo9sMfqmodbt+48z9P7obJ27Xu6mqy+1cYLvG9toMFm9a1zz3nO8+xh7bX3Ng2HwyHO5EzO5EzO5Exeopj/376BMzmTMzmTM/n/npwZlzM5kzM5kzN56XJmXM7kTM7kTM7kpcuZcTmTMzmTMzmTly5nxuVMzuRMzuRMXrqcGZczOZMzOZMzeelyZlzO5EzO5EzO5KXLmXE5kzM5kzM5k5cuZ8blTM7kTM7kTF66WE/6QafTCZPJBK/XC7fbDZ/Ph3g8DofDAa/XC5vNhlQqhb29PZjNZrjdbgBAtVpFo9GAxWKB1WqFxWKB0+mE1WpFrVZDrVZDv99Hu93GcDiEz+eDy+VCr9dDp9PBcDhEr9fDYDBAp9NBt9tFOBzGtWvX4HQ6kcvlUKvVYDabYTKZ0O12kcvl0Gq10O120ev1YDabYbVaYbVaEQqF4Ha7Ua/XUalU4HQ6MT8/D5fLhVQqhWw2CzYtGAwGch3+vslkQrVafeGFfu211zAYDJBOp1EoFGCxWOBwOOByuXD16lXEYjHkcjkcHByg1+uh1Wqh3+/DZDIBALrdLprNJkwmE3w+H+x2O3q9nqxTuVxGv9+H0+mEzWZDJBLBwsICOp0Onjx5glKpBK/XK+8vkUjA4/HgwoULmJqawq1bt/D3f//36Ha7cDqdMJvNaLVaaLVaMJlMMJlMMJvN8Pv9cLlccLvdCAaDaLVa2NvbQ7PZhM1mg9Vqhc1mg8PhkPffbrfl5wCQyWReeP3+/b//9zCbzVhaWsL09LQ892AwAAAMh0NYrVb5XgAwmUwIh8Pw+/2yB/r9PsrlMtrtNrLZLDKZDCwWCzweDywWCwaDAQaDAXK5HLa2tuB2u/H9738fsVgMv//97/H73/8ekUgE169fh91ux8HBAUqlEpaWlvDaa6/BarViMBhgOBzK/rPb7QgEAjCbzej3+xgMBlhZWcHt27dht9uxtLQEr9cLs9kMs9mMTCaDhw8fAgAuXbqEaDQqzwsA//E//scXXj8AsjY8T3qdbDYbLBaL7Cktz2viYTKZ4HA44HQ60ev10Gg0MBgMYLVaYTabMRwO5XfNZrNci+vDP9zj+nt4nvnZ4777uJ9zD/b7fXS7Xbm+3sMAZC1fRP7Lf/kv6HQ6+NnPfobf/va3cv8WiwXBYBBOpxNerxd+vx+NRgN7e3tyjvnc/X4fNpsNExMTcLlcsNvtsNlsqNfr2NnZQafTQTweh9/vRzQalTP88OFDFItFuN1ueDwetNttlMtlmEwmLC4uIhqNYnt7G48ePYLFYsHU1BRcLhey2SwKhYI8g9VqxdTUlOxHq9WKZrOJ7e1tNJtNLC8vY25uDtlsFisrKxgOh1heXkY0GkUul0M2m8VgMMD+/v53rteJjQuNxXA4lAVrt9tyIACg1Wqh0WgAOFQqFosF586dw+TkJNLpNFZWVtDr9dDv92G320VRdjoddDod9Pt9ubbP58Pk5CS63S52d3flularFa1WC2tra7BarbLBut0uOp0O7HY7lpeX4XA4sLOzg729PTidTkQiEdnwrVZLjA6vbzabUa/XRYFzc7vdbpjNZgSDQUSj0ZMu1zNSKBQwHA7RbrdhMplgt9sRDAZhsViwu7uLZDKJZrOJer0um9ZsNmNubg6xWAzpdBpra2sADg+Q0+lErVaTdaFyonE+d+4c3nzzTdTrdRQKBbTbbfj9fgSDQfR6Pezt7QEASqUS/H4/UqkUhsMhbDYbAoEA7Ha7/B43odlsxmAwkJ9VKhV0Oh202210u105wBaLBRaLBSaTCR6PB06nE8FgEKFQCBaLZaz149rzPXU6HdRqNVitVpw7dw6hUAiNRgP1eh0A5HsKhQL29/fh8/kQiUTQ6/WwurqKcrmMRCKBV199FfV6HVtbW2g2m3A4HLBYLLDb7ZicnITVakW1WkWv18NwOEQikYDb7Zb9Ew6HEQqFMBgM8NVXX4mz4vV6YTKZxOA5nU5YLBYxtoPBQNbVZrPBZrOhUqmgXq+j3+9jcXFRlH6z2US73Uaz2Xyuoj+JaKPB/U2hUaUyN5vN8g4p/X4f/X5/5JraMeT75zW0UucfGjauDa9hNHbcb91ud+Q79bWosI33o42aPsvRaBSJRGLs9fvpT3+Kfr+P3d1dOJ1OOJ1OBAIBDAYDVCoVFItFNBoNVCoV2O12XLhwAVarFYVCQc5qsVjEcDhEv9+X98F19/v96Pf7cLlc4gifP38eABAOh1Gr1ZBOp5FOp+FwODA1NQUAqNfrqFarKBaLoltCoRB8Ph9qtZrsNRoym80Gu92OWq02coYHgwGy2Sza7TZ6vZ44Zd1uF4VCAV6vFxMTEyN74tvkxMaFXk+320W73Uar1UK5XBYPbTAYSHTCaMNutyMej+PmzZt48OAB7t+/j3a7LR6i0+mEy+WSlz8cDtHpdNDr9RAKhTA5OYl2u41kMolOpyNeSafTwe7uLkwmE/x+P5xOJ1qtFqrVKoLBIGZmZhCLxdBoNJBMJmWxrVarbABu8F6vh1KpJC+am5GenMPhgMPhQCKRwMLCghjSF5VKpQLgyGOy2Wzwer0YDodIJpPy7zw4VqtVPN7FxUX0+32srKzIOjudTlSrVbRaLdhsNvj9fnlOr9eLxcVFvPHGGyiVSvj888+RzWbh8Xjg9/tRqVSQyWTEe2cUNBwOYbfb4fV64XQ60Wg0RtaDxpmRFd89PXQaFSoWi8UCl8sFAIjFYpidnR17/QKBgNxLs9lEs9lEqVSC2+1GJBLB3NwcMpmMGDm73Y7BYIBUKoWDgwNEo1G43W60223s7u4inU4jkUjgwoULyGQyePz4sRhaRtaRSAQA0Gw2xYhzH1E5MBLe2dnBo0eP4PF4EA6HxSmxWCyw2WxwuVwwmUyoVCpyXhjJc6+1Wi3k83l4vV5MTU2JIW2322g0GqjVamOtHYWKmA4h9xrwbDQDYCQCoWhFTyWp/53nmAZKf4+OULg/aIy08N8Y6fE7+fu8rtHQ8Rl5PX6e3x0MBrG4uChG7UXlo48+AnDoaDscDvh8PkxNTaHX66FcLqNSqcgZiMVimJubQyAQwM7ODjKZDMxmM0qlkqzbYDCQdR8MBvB4PAAgDo7f78fs7CxsNhvi8Tg6nQ6+/vprpFIpcZhNJhM2NzeRy+XQ7XblvQUCAdnLNC40Kna7XfRoJpMZMcjFYhGlUgkejwfxeBwWi0V0fjgcxvLy8okdxBOvMjcQb5AKhj/jZ3hoCN2USiU8fvwYyWRSHt7n88Hr9cqD2mw2NBoN8YB7vR6azSYymcyI0uNGpefOTcPw1+FwwGQy4eDgAPV6HaVSSeC0crkMi8UiFtrj8cDr9aLb7eLg4ECUpX5WKk8AKBaL8pzjCDe6x+MRb5VKhi+fn6NHa7FYUCwWsb29Ld9PA1yr1WCz2RCLxWSzdjodtFotWCwWpFIp3Lp1SzwpRhyNRgO9Xg8ejwcOh2MEfjCZTOj3+6jVagKJ8Z60cdGwoclkgsvlknuj0mV0w88XCoURWOJFxe/3AwDa7bZEf4FAAE6nE/V6HdlsViBWq9Uq+8Pv9wtkVy6XMRgMkEgkEAwG4fF4UCgUUC6XxbNj9EzIktfiIcvn87BarfJvvV4P9XpdnCl6tA6HQ95ts9lEKpUSD5fReTAYFKiVkDAdGqfTCeBQmVNh2e32sfefFp5hvqvnRUMavgKOjIKGsowOpf6sjix0tAFA1ltHOvoPla/R8FC+K4LThoXXrFarSKVSY+9BnhWXyyUQM3UCYXO/349AIACfzyfQVaVSQblclmhmOByi2Wyi1+vB5/MhEAig3W4jn88LLGmxWLC/v4/79+/DZrOhWq2i2+0imUyi0WjAbrcjHA7D4XCg2+3KXk6lUuh0Okin06jX66jX6+LAuN1u2Gw29Ho91Go1OUfHrYd2BujwV6tV5PP5lx+5EP/3eDzweDwCTVCpE7ur1+twOp2YnZ2F2+3G9vY27t69i06ng0ajAZfLhcnJScTjcfFAGo2GLDhDyHK5jHq9Lg/i9XrFi3G5XPL76XRawlC/34/hcIgHDx6Ish0MBqjX62i1WjCbzZKTiEajuH79OhqNBh48eIBSqSTX570Oh0Px3mu1mkBJ4whfViwWkxC3UCjIGtKLo7fLvMfu7i62t7clLwAchcGTk5M4d+4cqtUqNjY25F47nQ5KpRLu3buHfr+ParUqSrNUKsFqtSIej8u1CGvQsB8cHIxg3bwfKlgaFf6X+G25XEa1WhWlwMhwOByiVCphe3t77PWbnJzEYDBAMplErVYT2NRqtSKfzyOXy4miI7RHA+5yuVCtVrG/vw+73Y5r164hHA6jUChgdXUVzWZToizu4XA4DJ/PJ/kpGrGNjQ2B+ex2O/L5vBhjOix+vx8+n28kwtrb25O1Gw6HcLvdmJ2dlXfe7/eRSCTg9XrFuSI+z7U86aH+rn3ocrng8/lG0Af+G0U7VkZFrh0hOnqEu7UBMRoH/W9cbx2daCPT6XSem1fRxu15z6jXi9dlvnPcdWQkFwwGEY/HJSLVDsH09DQuXLgg5y6fz0su9/z583j33XfR7/fxm9/8BqlUCjMzM1heXkahUEA6nRYIdjAYoFwuY2dnB8PhEPV6fWT/+P1+LC8vIxAIYGJiApVKBU+ePEEqlUKj0cDTp0/lPdEZIixdqVRQKpXQ6XREB1P/8F3wdweDARqNhuTN6eycaL1OurA6uaxxde11G4UJcSocbhR6TPQEer3eiAWlx8NDZfTqjZ/ToblOwmtPSOOOx0Uox4n+d2P4/6LCA6EPnMam9TPpP4SdCAkCkIOsQ2o+Y7fbHYFjqHC5fsYkqv5OLcYkK9+Fhjy0QdTvl/eiP6+VxzjCRLndbofD4ZCIl8aURoQepE62EmJkROHz+QQe5BryWvrZmETn+gPPT0zrNWs0GuJpElKgESfcwwhfvweeq16vN2LE+Tt6759WjBHJ8z6j//48pWzMr3zbdxq/3wipHff3512L70lHTcZ9ra9nzO28qNAY8r0ZoUX9vUYyEHOhwNG51/ejdSqdPOaR9bX4We6rdrs9Ag9yj9AZZCRkhCUZHfl8vhH9dlykqpEi3ttJ5MTGhVEEXya9r+FwKA/JG+52u9jZ2YHZbEatVhtJ9nY6Hayvr2Nvb09egsVigdvtFuXI5HMsFkO/30exWESr1YLT6YTH40G/30cymZRkImEYvjgqXy6Q8aX3+31hZTHUZCKfm5Avkgf7eV7USYVrkMlkhC1GeIKwH3NZ3HT8XipWepncnKlUSqAe5nIY9V2/fh0ffPABer0ebt26hXQ6PcLAI35PmIbvlLkGq9WKcrmMcrmMbrcrzBR6by6XC9FoVGBFhvlayZhMJonACMmNu4Y8NFNTU5icnBQSiDYAoVAIU1NTEin1+300m010u13EYjHcuHFDDgqfwel0Sp4JgORbNIEinU7D7XajWCzC7/fDarUim83K3vB4PHLgyuUyPv74Y5hMJonQK5UK0uk0+v2+4OA80IS7GPkVCgWJKEwmEyYmJuD1ekdIEuMK9xOhYSoUDU0Bzyp2vf+NToRWeITtCG/zdwE8o9SZp+B500qN+QE6nsex14bDoUQQnU4HqVRqBMbl5wCMQI+nMS6XLl0SfVculwXFobPAqJ/5OX73jRs3sLi4iHQ6jc8++wz1eh2pVErgXIfDgX6/j1gshmAwiGQyiWKxCJ/Ph+XlZQBANptFq9VCpVKRnOnHH388ApUWCgU4HA5Eo1F8//vfRyQSwe3bt3H//n30+31BNkgQWVxcxLVr19But7G6uopqtYpmsykoT7PZhN1ux8LCArxeL8rlMkql0onX68TGhcqx0+lIPoAeMQ8wcOQhVCoVsZAMsxjpMDRlCEbogUqUn3e5XPJ5UmSZTGX4yO/kyz3OC9fCf280GpIAppepozFuQh5oHsJxlSOvR0/E5XIJW4z5DHqrFHoNOqmmv79WqwmmSs+CzA+Xy4XLly+j2+0KzZC5Af4hBGgMj8nwIg2Z+RoAAoFarVZ4PB40m010Oh00m81nGEg0RlarVfbHacRkOmQXOhwO1Go1oUXSGNvtdmEflkolYQVyjy0sLAgFnh4l159/J9W6UqmgUCiI4mNilIeZB9Xn8wkDBzhUrAcHB/KuXC4XarWawFyENvU+pcEm3EnjYjabheX4MqIWvhvtfJ30954XEfDc0UhyDx73e1r0ntL5GP5dR3hG4fc7HA6hw2ez2ZFn5Of09U4TOQNAJBLBcDhEJpNBrVaTvcB71/lKrgchfCrx3d1dYWhR4ZdKJcmJcI8x3RAOhwEc6t9Go4FWqyVQ/9bWlkBydrsdrVZLzuW5c+cwNTUlxCcNNfL9k/jTaDSQTqeFmUcnkeiS3+/HxMQEhsPDhP9J986JjcuFCxcAjNatkJFDD5ILTdEeLBfBarUKXs1EFxUowzTi5rSS9OxoTQHIovN3Z2ZmcPHiRfT7ffEKqDibzaYkyzS2SLiOcFkikUA8HheskxCThuXGFSp/5ny4sbQHyagCOIKh+CJ5yBwOB5aWloQ+vL+/PxIGM5FcLpfxy1/+Ev1+H1tbW6hUKnItwkQMt9vtNgKBAGKxmChhl8uFQqGAfD6PSqUiHHw6DGS36foLRmKMQLlmpJ6fhspNr5Pvliwx7glSJ/lZwhY8lIVCAdvb2zCZTGJ4bDYbZmZmUKvVkEql0G63kcvlhNXD+/V6vbBarSiVSiNsH83AYQ5Bw5m1Wg3FYhFmsxnz8/Mwm83CBCIJggaRfyeDUCtBUvxPyxbTe+u4n3/b57VjpY2GzmvQAXW5XPB4PEIw+a5oweiUaEIL1/m4e2QEoNEPQpH6Po2Q0LgGJp/Py/0Fg0EMh0PJpdXr9RGImlFzr9fDw4cP0Wg0sLu7Kw5bJBIZIUfR0QMOafexWAwmkwnr6+sYDo9yLoz+eX1CX0RwSPZ58uSJ1GD5/X4569ybg8EAtVoN+/v78t6YV6SjTadHE4gmJydPvH4nNi7Xrl1Dv9/H48ePJXnKSIHG5TjqoTYuZNJMT0/D5/NJkZHODTAZWq/X5WD6fD54PB7x1F0uFyYmJmC324UW+L3vfQ//+l//a3S7Xdy7d09YQLVaDblcDo8fP5aXzRdTrVZhMpmEbry4uIgrV65ge3tbYDPe/2k9R+K1kUgEoVBIktBU2EacUx9IvWmdTieuX7+O+fl5fPHFF8J+YUEWN0ShUMBPfvITOeyst+BnyEZiPVIoFMLFixcRCARw6dIl+P1+lEolMbSlUkk8rm63O6Joec8OhwMej0eUoc57BINBofaOIzTCu7u72NrawvLyMi5fvgyXyyURiqaY8n0x38HCzcHgsJC10WjgypUreOWVV5DJZPDo0SOBX8m+IRWT183lcsjlchJxWywWoXxarVbxPOmVV6tVZLNZRKNRXLp0CQ6HQ+6VERO9b6fTCZ/PJxF6IBBAv9/H06dPkc1mkU6nJbk7rjzPuHzbZ/XntZLWZ0Hn1XhevV6vwCzfdc/UD/w7nT2df+L19e/oyJ3FwXQq+RnjfZ8GFstms2IYQqGQOCysQdKGkMZiOBzi7t27ePLkiRCF7HY7YrGYFFsSUSDD8tKlS5iensbGxgZu3bolyl7njXgedJTH91CpVPDNN98I/BoIBCS600FApVLB9vb2CAsOgNQLct2azaaQAmZmZk7sZJ/YuLACvNfrCR7Kl82HY/TB0IwPwEiH3icrtq1WK8Lh8Mii0WBpGMW4sQCMKBNuTP5ONBqFy+WC3+9HrVYTb7DRaGB/fx+VSkWUAQ0NIxlW/NO750s9LRWUxqHT6chmovfKZ9ch6XHJXirMcrmMTCYj1d2MHhlqE1dnGExDwuS1TnhrB4HPTcycUVar1cLk5KTkHRqNBpxOpxQTFotFUQBG6EEnPgGMbaB1bRK/d29vDw6HQ5wTt9sNl8sldOR+/7BjAWEx/oweY7PZxMHBAcrlsuwH0osZYWinghXYpOFzv3Pvk1rP+2PEDUDehY5SdRcGsi2pjAkJ0ylzu91SsHdaeZ5yYHRiNAZaSfOs8XNcH757nmGNZnyX8Hd55hi50Gki64/RAc+kz+eTAlZS7I9bHx15nQZ9oPFgbpSGhgaQjEy+QyPi4fP5kEgkZM143kKhkDhk3W4XlUpF4FSdVuBa6XXj8wHPRnyEvnw+HyqVisD/LEOIx+OIRqMYDAbybzxDhCQZLfH9cL+fRE5sXG7fvg3gEPoIBoPimZlMJqlZIfbs9Xpx/vx5OBwOPHjwANvb22Iw+v0+9vf3JcRaXl4WGl2j0ZBNacxFUAHTSDEKYbEa2yf4/X5cvXpV8gH0RJvNJsrlMn7yk5/g3r17iMVimJ6eRrlcxueffy60VLavYbKX4abL5UIgEDjpcj0jhPOY7PN4POIFMG/BZDyLoKhwyDKiN3H79m2YzWa8/fbb+Mu//Evs7e3hb//2b8WrpqFiXoHKj8QLbQT4p1wuY3V1FcFgEMFgEN1uF4uLi5idncXU1JTULN2/fx/7+/uYn5/HlStXUCqV8PHHH0v+ip45cJQz4nsExvcck8kkAEiEmc/n8Td/8zcwm824cuUKYrEY5ufnJdogRZTeG50efj9zIw8ePIDT6ZTkO4XJU+AoJ0LYsNlsIpfLSe6Mh45nYHZ2Vgyww+EQnJ7RIyHfXC6HUCiExcVFOBwOJJNJ7O3tweVyodFoyOfj8Ti8Xq/UNJ1WdI6D/0+loRPo2iHgZ5hbItzF59bsRUa5Riry84Sfc7lcUhhI8Xq9cLlcKJVK2NzcRLfblej76tWreO+991AoFPDzn/8c+/v7zzihdKCIrIxbQMlrkWBUKBQwOTmJd999V2pN+v0+vvnmG9GVTAMwh3n+/Hn80R/9EVqtFn76059ifX0d169fx/Xr15HNZpFMJlEul6UDiXYQ9fs4jqQEQNpy0ekZDoc4d+4crl27hr29PYnqrly5gkQigWg0iqmpKbRaLayvrwt0bjabpWyBBcSaUPPSqciVSgUm02FRGosVNVWYSVFCLqzyJhuHFlgzvMxms3iC3MCaqcWNrBUhlZSRGq2jG3o0zCfwmqxQp3cZDAZlMZkkazabAkswkW7kgo8jvDfd/kb3cwIwEiVxYxJD1sqRFFoAiMfjooj4PTzk2nhwHflvRjacPoQ0TlarFV6vF81mUzBmt9sNp9MpbD563cCzFHK+QyoD/fMXFUZ03FPD4RDZbBZmsxnValUKYnXSmoqI68p/I1us3++jUChIuxs6KvwcPWWKjlyZW6Jh4d4kG42JWX433xeTtb1eT+q++B2ERhh59vt92Qf0Jl+mcdEG5iSkAZ51I4RrTKKfNGIx3ouR8kqKOKFPHQmQpRcOh+X7NPuN93Lc940rmoHKvax7IQ6HQ2GP0aHR6+p2uxGLxaTFEyMcFjfyO0gWeV75gzEC499p6PV+J3GoXC5LlxW2QgoGg9KmiE4gdTefUevZF3UMT2xcaK2II5L1ZDKNskNo9QhbdbtdJBIJyX3oDdloNKT9yB/+4R9iOBxic3NTKuYZqnGBCQ9osdvt8Hg8mJ6exmuvvQav1yuGgRBHtVrF5uYmyuUyAGBiYgKDwQCbm5uo1WrCzNBQEa01yQX9fh+5XO6FFleLbpTHaCWZTIq3SIVPb5UKj0aTkIHGdTc3N/Hhhx+i0+lgaWkJs7OzyGQyUoDKnIhm83ETs6KeG5G9yLxeL6anpwUiymaz2N/fx9OnT8WTj0aj4n3TQ9WwKN+x3W7HuXPnEI/HkclkcHBwMLZyZI8lOgAejwcXL16EyXTYnNLpdEplcj6fx+eff45yuYzFxcWRiMRmsyGRSEgUQDIEq60ZKQ4GA6EYM8lJw0NmD/HscDgsuLvOPfKAOp1OzM3NiZM1GBxW7bvdblgsh10YuC+i0ag4afpsATiV1w1g5L3Q2yZ9l1EJP2P0jnkutIIh/MIoxgiHniTXwojQ6/UiHA5Ly6eNjQ1Zd3rQ2kEbDodYWVkRdIIJZ+2kko3G6FI7ruNItVqF2WxGPB6XgsQ7d+6MEGra7Tbm5uYE/iZkzfP6y1/+Uhiqbrcb+/v7+OSTT9DpdOBwOMRho45g+YGma9PIcp/RwHk8HgSDQQCQ9Wo0GiPQL99nu93G/v4+dnd3hV3Z7XalYeb+/r6gOG+99Rbm5uZQqVReqJD8xLuVD6RprDQuupKXEQD77ExOTiIcDmM4HCKfz49sOIZepOrROwMOk6flcnkkTKfXSu8cOGriGIlEsLy8DKfTKSEqFV6n00EymUSpVILZbJbqbN32hW0R+FzE1Jnsr9frYojGEWOkQMxdry3/jcqL8AgTasZiyFQqhV6vh2AwiEuXLon3QcXEGhjmUJgTOM7rmZqawltvvQW32y24N99PLpfD3t6e5K9ovNmMj/tA54X4HNPT01hYWEC328XGxsYLUWC1zMzMYDA4rNAnqYMV7oxGu90uisUi9vf3cefOHeTzeTF8PJgejwcLCwuCldPAMplJpURIjddkRMtcDKN3Ytp8p5rQAhyeCfbYczqdUldEcgWxd75/Db1qZg+di5chuteZNi5GPN2413VOkJ/XLCfgWbbod50XMq+i0Sii0SgmJyelEwJbEBkNG8/o7u4udnZ2xGDSodTUfW1MdXH1OMLcscvlQiKRQD6fx+rqKgaDgbQiYvcLOilEaQaDAQ4ODqRDcbvdhtPpRKFQQDKZhNPpRCwWk1w13wNLOp6XyySZge2MiMbQqLXbbel6QpSB+6pQKAi8y3cRCoUwMTGBZrMp++7SpUu4efMmbt++jfX19ZdfREnFRvzZWJNhxG91c7RqtSqW2WKxSJsLto+22Wx4+vQphsNDah9bE2gSAP/LjcyF5YJarVZhM9Ebb7fbqNVqyOfz2NraQrFYRDabFePHWhkqC+0h8L/0Rhm+jis3b94U7L1QKBy7WfhcbEDJBDrhLG6OixcvwuFwSBK/1WphZ2cHFotlJJJgcZZRGO7y+zTUQTq4xWJBuVzG/v4+Dg4OkMvlpEcXO/gyuU8FOhwOR5QVAGk62mg0XojGaJS1tTUhZeicEpU59yeVB/s/8cDr0RDcj+wYq2EresGsUSAsoHNG7OnG/WfsFMD95PF4hDJNRlmhUEClUoHD4cDCwoK0LdIEgna7LTB0JBKB2+1GtVpFtVp9KbAYDQL3tV43Pi9hb4ox/0JlbuyEoZGJ592rdkR0NBYKhaQexG63o1gsIp1OI5fLCeNPX/+4XITuXkGhY6efdxy5cOGC7LV8Pi+jGxiJkkBihLTo1DE6tFgs0j6Gbex17jUQCMDlcqHdbovTS+G1NLRNvTg5OYlr166JY9nv94XNyHPe6/WEmUhdzSLpXq+HTCYjVP2rV68KBf+bb75BqVRCLBY7MTz2wl2R6dkSauEX8aVzw7CqmIrFZDJJ76U33ngDiURCDMb+/j4+/vhjqWvhZtF4NjcMvXh6kZFIBNPT07Db7Uin03A6nQiFQqJEcrkctre38eWXXyKfz8uhYlEhsVvWhxDuo/Iljh8MBhEOh8dmO/3Zn/0Zut0uPvroI3z99deyYfRm5wZwOp2YmZmB1+sVSjRweDhCoRDee+89LC0t4c6dO/jqq69QrVaxvb2Nfr+PUCgkuC9hHbKSKIQyaBRYYAZAFKfL5cLKygoePXqE/f19SaYyotLUWNZnVKtV1Ot12Gw2KRZ89OgR+v0+lpeXceXKlbGhnd/+9rcCoYRCIalf4h6hc9BoNORQcR8ysl1YWEC/38fq6iqKxaLMpaEiHQ4PaZy5XE48SMIQOqfl9XoxOzsrjT8BSLt8HSFOTU0hkUjA7/cjkUhgMBhgfX0d+Xwe8/PzuHTpkhglfo/FYhnplXblyhXMz8/j8ePH2NraOhVbjAqZ51ZDLTqK5pnTxkIn9Zk/IIyoqbEniVR0ZEtndTAYYGZmBh988AGsViveffdd1Ot1fPrpp/jiiy+QTqdRLBbFydJ5UOoH3oPe63QQ+XynEfYFe/ToETY3NwW65/fbbDZxzGjITKZDdiM7QDDyuXbtGkKhEJ48eYJHjx6h0WhI2iASiQhsm8/nJe9KqDYQCKDT6UiRL3VsIpHAv/gX/0IcT55zGuuvv/4ag8FAZnGFw2FMTEygXq9jZWUFpVIJa2tryGQyuHDhAv7lv/yXsFgs+M1vfoPPPvsMCwsLuHjx4stP6OtkLF8qcxH63zXWDBzNWSFUQ5iG9S2McJiAJZuG19LJTioShr+kj3q9XjF+OqHIvEOlUpENpluGMGoxGkbjBtWe1rgJQfbkMUZ7x2Hb9Ep4j8y58DDSYJDG6HA4BD4MBAIy24VV87rDrjZqhJQIddGrOo7lw9/lM+jks04iGvcLIUo+/7ieoyZ9MDdAb197sNwbXAMydbhufH7uR75nXSDK+zX+jNfmvrXZbJJ4578bIRzeG5UfMNqfjPg3f5+KSedATutxa9F7zLj39L8DGFEixiSyPuPaWOiogudMoxracSTLNBQKSYKZkSBLHgiVa7jxuDNovDfjz16G0HjxfPAPjQsRHeZ6SB3n3uPe4fOxniQUCgnlGjjMaQaDQamJ4T42mUwjw/B0pwyfz4dgMCjthegkU+8xKCArz+12C0zIaIw5XXYCoN5mRK67rp9ETmxciNnxgBEr7ff7Qp+j0eEhpnLhwjqdTjSbTXzyySdwOBy4cuUKbty4AafTiYmJCXg8HvG8uYn6/b7AZDqhxUT+3NwcLly4gFAohFAoJPfK6W2PHj2S1v1UuOTEM4FO5cu5KIRMiNFTkWhs+UXl7/7u7wR3pcLVniMPK6mcDx48gN1ulxxDJBLBzMwMzGYzPv74YwwGA1y9ehV//Md/DOBIOdIAPXnyRNb5zTffRDQaxZ07d3Dnzh2BPtxuN95//33cvHlT8G6z2YxisYh8Pg+bzYalpSWJTpgA5vsGMOKBMh/GCILfQRjtzp07Y68fE90TExOIx+Mja8fnJ+GDuYl+vy85v2q1igcPHsBiOZzSt7CwIMWJWkmQyKEHtxH6YSTCA97pdLC3tydR0MzMDJrNpvRposLgfqPzEovF0Ov1ZHge+7fRefJ4PJifn4fFYkEmk0E2m0Wj0ZCu36cVI4ylhevAztIWi0W6cvCzxnosh8MBt9uNycnJkdqefD6PnZ0dcY60PvD5fLh58yYikQheffVVzM3NYWZmRtaWhrbVaqFQKIy0jtfnhUqdDECuNYXOj2ZejruGn3/+OYBD6FSTMzSrims1MTGBDz74AF6vF7/73e/w4MEDxONxzM7OYjgc4s6dO6jX67h8+TLef/99uN1ugcroVLKw12w248aNGwiFQrh79y7u3r0rnd09Ho+s3+XLlxEOh8V4DQYDhEIhIU9NTk6i2WxiZmYGCwsL2NrawubmpkBxbrdbOh4kk0n84he/kLWbmZlBtVrFp59++vJhMSYrtRfHBQaOaHqEEnTEQWvPTcc8AjF4htkAEAwGJUHK3+cLpULWlE+/349wOCzwR7/fl8JNTiEk44L0Uw190YDphKZOULOKms8+rqyvrwOAYLSaKqyhRUJzhEU4o4SskF6vh/X1dRSLRVy4cOGZ4Ue8FueOOBwOObisNwKOjMLS0hJu3rwpB7fX60nuymQ6bKdPb5KOA42jETunZ0YFQmfE4XBIHmFc0ZEInQ/gcN/p5qhkDBEb5kQ+QqR85mg0OtLjSUNF3BMa8gEgyVN6bmQi5vN5xONxuS8NR9AI63lEpNYy91MsFsVLpOPGNkiZTEYU62kT+sbo5HlKllEKadDasHAtuH/pULIPFokCAEbypjxbdAo4STEej8s+JqSk81yMkGmc+e+8B55VIyFBRzl0iI0OyYvKwcGBGCtdu2U0doxc5ubmpHkkC6c5noC5lkuXLmFubg7hcBgXLlyA0+mUti3ZbFY6kCwsLCCRSAjRgWeBA8vOnTuHRCIh9V1cd+4pjWj4/X7JATKHyYJpRk/sXca6Mp/Ph3K5LA2DTyInNi7E0Kl86KmaTCaZe+FyueThqPBoyQmlDIdDiRRarRb29/elwNBkOhz0tb+/PxLS8vc4K4ONLv1+P2ZmZhAKheTwGmEnJmDD4TC63cPW6aSzcoCY9my4kTXGrhvsjSt8Ripe5imojAaDAaLRKCYmJtBut5FOp9FsNoUayGS0xWLB9PS04LJMpHPY2urqqqwhm+h9+eWXWFlZwcbGhqzj5OSkdBEOBoNirPv9voTMW1tbuHfvHrrdLv7gD/5gZLPu7OwI/XN6elrmdRMXpyLUnuZJMPnnyeXLlyXBHQgEUK/XpWiUOQ6y21wu10jhZzablQmQAITJmEqlpPkfjQaNrp4ZRPiNRbWagce9ncvlhDpPyDcUComnSgNWKpUkOqICIKuI0BCL8YAjJR6JRJ4pMBxXNCRmTLzzvkwmk6AVPA86B6ONJQ3o1tbWSB/Acrk8Mq+I38fOHG+88QZmZmYwPz+PSCQiDDrmEGq1GhYWFvDBBx/g4OAAt27dEmPOYmTeu4aNLZbDdkYLCwsAIJNeT7P/AIyw+rhOLGsgWsJxDlarFZ9++qnkP8iGJax08+ZNmM2H7aA2NjakFZTNZkM2m0W5XMbW1pbMX3r69CkymYw4jT6fT4zX+fPncf78eSF/UA9qNCQajeLdd99Fp9ORHHWz2cTe3h5sNhvOnTsHt9uNubk56TU4PT0Nk8mEXC6HYrE4MlPmJHJi40JeP2dVMHzlg9rtdpmTTo8ZgAzo4dCkwWAgkUCr1cLe3p4shMViQTKZFPYEXyShDrfbLcr26tWrMtKYcBjwLPZKzJNtDrxer0x9owXW1FvCOcaiRF5vXKFxoSFxOp1CEGAksLS0hKtXr0q1bqVSwfnz5zE1NTVyTxwXPDk5KQqP7+Xrr78W6Iv3zXCez+D1enHlyhUJ05m38Xg8kvCj8b1z5w7m5+fx/vvvS9ttFn9tb28L+YDRJr+XhYQ80CdN+D5Prl69CgDSOSGTySCZTEqeiXU3W1tbiMfjuH79ujT3XF1dHVkPUrSTySQ2NzeF1kzvjZ7exMSE9P6y2+3I5XLI5/PSCNVoXHK5nDhbfL/z8/PSdbbfP6zuZjt11iQwwmG79Ewmg2+++Qa9Xk9GJgcCAemifVrR3ruR2cUIdjAYCA1W13oxQmRulO1O2NGA+1TDUJo9xegyFovh7bffFsYcvW1Gx+wQvbCwgEuXLmF1dRWlUgmZTEa+EziKpPidNC7RaBRvvvkmAEiN3WnIEABGIm8a/JmZGQDA5uamUOSnp6dRr9fx8ccfo9vt4ubNm3j11VdRr9eRz+fhdrvx9ttvI5FIYH19HU+fPoXT6RRDks/nUa1WpXzCZDJhZWVFHDgSBxYXFzExMYGLFy8Kg1QTUQDIu4lGo3jvvfcwGAykE0qz2cTu7i68Xi+uXr0q+9XhcGBiYgLXr19Ht9vFL37xC+zt7Ynz9NKNi058c3F1FTc7uzLfwmiDUYLJZJJ6F1pA4vfAUfW4MRnKjcl/0+ytYDAo9QX8fKvVQrFYlNkYfDn0oPXwp2g0Kslx7WHRKwEwEoKPW6MBQPByvuzBYCDYbSQSEaXJeR7T09OCn5ZKJZldAUDgHBah8jBy4qaR8cZ1pJJg3zWPx4N0Oi35hOXlZfFGWQ9Er5JJZ05eJEum1+tJTow944AjOJORGvfDuMaFTEL2Y6rVarIneS+sHRgMDgtkmePTUxcZPfC+mPAn1EHlxNoI/W8AhP7NfaSJK4yImNguFAoytwg4ap3EKJEjr3XUxOiKfe9IZyZl9DR7UJ/d4/7NmOw3/uEeIgzKe2YOlMaPEbN2Jghfud1uKUGgU8T9xqRxs9mUVkj82e7urhRTMj9RrValAFU/B4lDjKhOu/cosVhMnoUIjK6TI/OQ+o3vcDAYCEoyMTEhJIVOpwO3242ZmRmphTKZTMhms1KbQn1HJwY4GpVerVZht9uRSqXgdrulmFjXdQF4JpLR68T9wD3tcDgQCoXg9XpHiEWM2I21UN8mJzYuVM5UPlQsTqcT8/PzmJqaQiaTkRbOTKwVi0VUq1XMzc3htddew2AwwJ07d5DNZpHNZiVxzJwLe1/xwZmD6PV6suEmJyexsLAgiV094rZSqeDevXvIZDK4d+8eHj9+LPRkk8kkFOpIJIILFy6gVqvh66+/ltb/fDm6boNKRDNfXlTOnz+P4XCI3d1dpNNpdDodZLNZBAIBvPfee1heXsaDBw/w1VdfIRwO45//838Oj8eDDz/8ELdv38Ybb7yBt956CwDw5ZdfCvTFBnrcrJVKZWQYFHAUxtOohMNhLCwswOPx4De/+Q22t7fxx3/8x1hYWJDiQIvFghs3biAYDKJYLGJ9fR21Wg3b29soFotSI9JqtfDo0SPx2I3Dk8rl8khtyrhCmIhwlN/vx/T0NHq9Hh48eIBsNot4PI7JyUmUy2X81V/9FVqtFt555x1cvXoVqVQKuVxupHW9zWbDwsKCUKepOM1msxSmORwOUQb6eRj9cJ9yjDKdIbfbjbt372JtbU0Glfl8PkxMTIgTxp53mkhAZbmwsCD3QSP3IoOajhPdYkQbEOCI8cV9Dow2RiQ05vF4JMeimYWMRJxOJz7//HOpW+N1aGhisRjOnTuH6elpieaIPrRaLdTrdYGEstksHj58KJX4HIdw4cIFxONxIU7wHvk+rFYrWq0Wdnd3MRwOZa+e1ri8/fbbQvDo9XrI5/PY3NyU3B47NaRSKTgcDszPz0te49GjR7h48SL+6I/+SOpb9vf3MTc3h7feekvIRO12G48fP8bq6qp0TOb5ZsTC2Vfr6+vY3d1FrVbD/fv38eqrr0qKQLMT6ZiQpq+ZvTp9QThxbm5OoD6ORGYUq9lq3yUvXHRAr15bL90TiIefLWDYfI2Wnol9GicqHXp7xpyJppnqn9HT1wvW6/UEHmILFCam2c6aORUAgofyunw+/uF3Ge9hHGFBI/FsblLmDNjPp1wuw+v1IhqNCkWR6xMMBgWS4LPQI2J/IyNNks+kn4URjMViEeIDO7ASEhkOh+IhUgmykI+RE5UGHQIWHvI7NbnjtAebzC3uL73J2VafazkYDGQODenYwNHsGf4/yRqMUrWxOO4ZCAuRWKKLOJmv40FmNMnBbYSXmJekx8vcpVZazO+QBUXY9jStS4BRajGfy2jw9fPrdiHcPzpxTgWlIxeOfjBCJ7wGDZTVapUIhdEIDQsnHrJBZC6Xk3fMfctuHZqKrqE+Ej2oZ067/4Aj9IFRa7VaHfHoNcHJarXKKIX9/X0hbDBtUCgU5LyxiNbv9480uNVdszVblvkv7q9isThSRM79yPsiCYIF4bpNji6G1S29SGPWReTAi3U1f6GW+1Tq7JpLeIdTzFKpFDKZjHyOyTkqhdXVVXnZDBl1/Qo3qz7QFosFkUgEHo8HsVgM0WgUgUBADgaTuel0WoZipVIpFItFOJ1OLCwsCFSmYTe29QAg7Rx0m3AqTB4+epDjGhgm0wnr6BzK3bt3sbu7K/NtTCYTYrEYJicn8dZbb8Hn8+HSpUuYmJhAr9cThV+tVlEoFOB2uyXvRO8UGIXDuIGYEN3e3kYoFMJbb72F9957D1NTU9IIkiwpbtZ6vS79iZiz4b/pXAp/RuiNkA+58jw44wgVayKRkP2XzWYFfiCpgKwcv98Pi8WC7e1tad3DPnakbNIrI6TFAknCHYS4qOiZO6QDw0hRw7v8HUJsem9r4gW7RfCssEGoXiPNUNQsqXHF7/fDZDJJAXK1WpXogcpDw3Uk8eTzecmX8rPaAaOxMcLaWrgX2cfKYrFgc3NTICAWDK+vr6NarWJtbQ21Wg3xeBzvvfce9vf38fnnn6Ner+Pp06fY399Hr9fD9PS0KHye63a7jVKpJGvHqPC0BkZXxOvn4rnu9/tIJBIS8V+9ehVOpxOPHz/Gzs4OlpaWhBHHQuVqtYrbt28jGAzi8uXLotQ1pVobSEKDdDxIgvD5fGi321hbW4PJZJKK+5mZGUxOTiKTyeDzzz+X8cZk9l28eFFSA61WS6JBGjvmhxcXF1EoFJDNZk+8jic2LsybBAIBhEIhmT3Auoxeryc5Dt1qg9a82+2OwAb8Ob0hI4WQxsVkOiz0Y46FzDRtXKxW68gIUXridrsdExMTyOfzori5MMxXMHlFuipDaCNO63Q6JXIYR0hj5KHU1NKtrS2ZUsdIyu/3C3THJCErcwOBgHh8lUplhApsTPhqb5MFUpVKRcbCfu9738PVq1dHoB7tENCJ4OAwwkSMGDXEogu2dMt7vluy7sYRevTBYBDz8/PIZrPIZDJS30JFqEckDIeHnZMPDg7knRIWnJubw/b2NrLZ7MhEvnA4LElR7mHCYvRUmYDnACbdqpzvVucjjssDlEolpFIpObiEE/k5rch0RHoa4XOQimqxWIRxx33O+jFNOOEoXg1t6nvh+6WzaFQ+mhZMZ8Vut8u44FqtBofDgY2NDdy9e1feR6fTQSKRwLVr12C1WvHFF18I7GQ2m6VlPKFxnZftdrsjkNK35ZtOKsZcFJ8NOCox8Pl8uHjxIqLRKF599VXpem0ymRCPx+UdkGrOfTwxMYHFxUWBt3k9Rox8R8ytUndwv7lcLnS7XRwcHKDf7yObzaLT6cDlciEWi6FcLuPp06fS9JVGaXp6Go1GA6lUCrVaDaurq9jc3EQgEMDc3JzUMMViMUGjXnpCn942owCbzYaJiQkAkEJK9tchHAZADAN5/RoL5MvhAeIL5M+11wcctoqemZnBxMSENIqj98NZGMTUuRDc7MvLy+j1ejg4OJD+WxRuSCpTjRHzfjlS9DTQmGbeMAIkZKdD2Gq1it///vfY2NgQuKHdbuP+/ftoNBp4+PAh0um0wFQswDOZTNIJmUbFCE3R0/R6vfB4PKJ4mcDmO+BGJgPoypUrwqbTg66Gw6EcGF3PpL1Grutp1o607VKpNHKQ2d21Xq+P0EAZiRIepTGn4mRtFcfN0tNLJBJCpGCjQjIOCWuYTCbJdwFH/fYY5TD3xFkkPp9PHB5+1uVy4erVq0KIyGazI3USRArYh0+/n3GFypZGThdGU1n2ej2JXAkZag+axoX7WCvbra0tmM3mZ3JD+jOc8Eknkc/E2iAasbm5OVnzra0tybcwF0pnhs1w6eyy+pw9DTUky3c0ruzv7wPAiOMwPz8vhox1Tzs7O2g2m5iYmIDb7UY6nUY6nYbL5ZLuxISk6KzVajX89re/FSdcR1r6/OqIUetaFv0yd5xIJIQOz2h1cnJSnD+SBNhrkdBjOByG3++X98Hr8hxMT0+feL1ObFxoKcnQmJ6eljboKysryOfzkvwGIInKubk5JBIJ7O7uypxyzbZgzYsx5NQ1B/x5NBrF5cuXpUp7OBzi9u3b+OyzzwS/5QElrFOr1TAzM4Mf/OAHMJvN+OSTT+SQUTnSoOiiN75UFtnx0I2rIKnwmZfgkCgA4jUQx8/n8/irv/oruFwu/Jt/82/wzjvvYGtrC5988gmKxSIeP36MQqEAu90ueD37TtFw0lBRmRiNC2sqVldXce/ePczOzkrvLxqkUqmEZDIJn8+HH/7whwAgnHzNZCH1Vg82o4fDBDiV0bgSDofR7/ext7eHTCaDyclJXL9+He12G19//TU2NjawsLAgnbHJfNva2kI6nZZhW1T2ZrNZKMx0jLrdLi5evIi5uTlkMhmBMskupEMAHOV5AAgERmIK65Li8ThisRgajYZQ7gmvXr58Gd/73veQzWbx13/919jb2xMmValUwvb2tlyPuQwa2HGFHXkLhYJEEjxjPDOM/Ng922KxSJsfrgVwFOHwGo1GA19//fVITlMLz3UwGMTCwsIzM5NoDNLpNDweD9566y0kEgns7e3hm2++Gckt0llhLzvNgmJhJuEjwmW8ZyrWceTJkycwmY56JAaDQVy/fh39/mG/MfaEa7VaYkC9Xi/W1tawsbEBs9mMubk5KQTmO2XX9p/85CdST6Jr9oxGncaFTVLpUPN8h8NhvPrqq4jH43LuOcCx0+lIMWW1WpXRBswBvfbaa7hy5Qq2trbw8ccfSy6WBv/KlSsnpsO/cEKfUQbhEv7MSG0zsoM0j93oTehEvg43yQDjwdXtPfg7XFBCCTrq0ElYHhAuFBU9k7oaUuKBoSIGIF7GuBuTisFqtYqy191atQGg18D71ZEIa4hYk8H11PAUxZh804lsXWVsTNYR8mLCmvfI/zJP5vP55Ho6KW58Js3iGVf4bqkM+b60EWW+gwcQeHZ+er/flzkbJJswCcpn0J623o/6d/icx+ULjyO9aFIIFQer+Plz7kUqHT4PAHkfpxEjnHEcXKQ9YsLevLfnkTP0vn1eLRPfA5+DZ47MLjomWrcw90BijpHhxlwE/8711s/1MoXfy3NInUTIls5orVaDx+ORyJe1ehaLRRAQ9gDjGSQDz3gm9b4xkpqYb9bQK98RoTXuN64L/873RRIJMLqXeVb0PtD5tZPIiU+7VtjAofdz+/ZtSfyFw2HxFrjIAEasKql6rNylwuah1ZuTyWB6i8xBRCIR+Hw+UYDRaBQXL17EwcGB8Mu1YrNYLCiVSvj0008xHA4FzuD12DGXSp+ddmlIuLDhcFh46OPI66+/jsFggJ2dHaEiM9HI6Igbgm3YOYu9XC7D6XTixo0bEm5zZADzXYwaGSYzD6Pxbm7GUCiEQCAgnYODwSASiQQCgQCazSY2NjZQLBalYLXRaOD27dvS54kN9b7//e+j0+lI1Eq6uBF+oAfO1t/jCKEC0qh1M0r26pqZmUEikUC/35eEO/dErVaTddnZ2ZHrakVlsRwN7mIFONlcDocDhUJBWuaT+UdGkM5LaG+eioBeOiOXYrGIjz76SHDxubk5aVjY6/Vw9epVUZiMSPP5/FhrZ3xWioajtdLm/zNaYE6LxAUjc47njXBgtVodISbovF+xWMTKygqmpqawtLQEp9OJvb09JJNJZDIZMd5ffPGFMCUJgdGLPs74U+kxr0hCjhaesXHPcCgUgtl81JmbEKs+v0wNDAYDZDIZ9Pt9zM7O4ty5c+h2u0gmk/B6vVhaWsL09LTUjsXjcfz4xz8WeIz0fjpk+vnIHk0kEqJ7dYeUfr+P+/fvS+un6elpYXyyjT9zsEQfJiYmhHjDgY18LupSGs6XHrkYPQYmnwkX8LBT9Aak10FoTXt62pJqz4TeEr1sHnAmiqlIyWpgsSSvw0NDyi4hM1JWybZgNKR7iOlCOF6T8MS4GzMajaLf7yOVSo2wrPQa8JDSuJLSSW+HLWxY58GGnPRotRevKdX8w/VzuVwyBG04HMo7tNlsUpmfy+VkzTkTh6yrdrsNn8+HaDQqFGUNHx4XMWmDPY4Q952cnByZ1qfZViw4ZL8uOiyEEBj98F65LqxzMZvNkovQNU1cV7KQWLfDNfV4PPIOuHf5PtkKhqw5JlLJ2tMRi9/vRyAQGCEAaMhO9/h6GaKdRf0z4EgR0+tmayB9xnjOqLB1LZwWHc2xxxwpuXa7XX6mywoymcwI5ZhRDUlAvFeut14zvl/jWh33vC8ijBKoMxh9aQNNlIRD/lqtljjFbAjL/B8JI7w259l7PJ5nnkvD1XRs9Nh2HXX0+32BPkOh0Ah1Xkcj/DnPEOFRQtl6DXXkflIE4oV6i9GD0F/IjWQMlzUExkNG2icPtn7ZbrdblD+vzYrRQCCAWCwmldmlUgnr6+toNpu4c+cOdnd3kcvlZDIjlXev1xuxvABGXiipoHwRnE2vQ0B6mt1uF2trayddrmeEmKaGErkOxOjJbKKXMRgM8PTpUxmJygIpVutz9giv1e8fdkygsaTBZ+NJ5gCmp6cxPT0Nj8cjGG+5XMa9e/ckaW82Hxb0MSLhKFX2JKrX63j8+LFQSzW8xENmMpkkKTwcDk/ledfrdeH3s0iMBoPfzQQmGV1Op3OELbO3tzdCXyd2zvfCyIsRT6FQECai2+3GwcEBMpmMFPQxSiGMwz3NRDKhD0Yew+HhMLxeryeYPXDU3JXdfz0ej0TTpHQnEomRhq4vQzSUx3oHRs/8dw1lce0BSD6DCh84qqcywndm81Ex6MLCAs6fPy/94UhzTyaTKBaLI84AzyKNBa+ldQ0NDc85HR3qALPZLJ3N9bONI7rXWi6Xk6JYJvYnJyeRTCaxtbUFADJvhTlIog8cIV4qlbC5uYmvvvpKnrfT6eDg4EAMBd8R9wEJC9FoFK+88orQ5kulkqA3drsdMzMz8Hg8QsVn9Nxut3Hnzh1BcKanp0VXDgYDKXqnU8S+jKyjOzg4OPF6vVBvMeBZ7Pe4zW6MSpgMJ4SjMXri9+ymyoMGQDaVz+dDJBIRJhWH2lQqFdy/f19YYkxmawhPR1tW62G782AwiHw+L8aIn9dtPrrdw6FPhCoODg6wu7s7tufDjUY6NF+oVvpM7AEQb3V1dRU7OzvSBDEYDApJ4smTJzLVUidgtXGx2+2IxWJwu91YWlrC4uIiIpEIpqamRubAZDIZbG5uiidjMplQLBaRSqXg8XgwMTEhobnD4UA+n5eW8VxjepXacDJaKpfLKBaLY3vemrlFD1nTTpl0D4VCYnCYvDWZTNjc3MTa2prQlEm1jcfjknBvt9uoVqvy7Pv7+wKXklmXzWbFuNBL12tAB4nMJUbZzBuwjcmFCxcwNTUFAML4Y21DNBoV40Kna25uDufPnz8xJHFS4TnlnmFhnsb4jcaF+SI6NMb6G+M7poJnY8RXXnkFg8FhjyvOeE8mk+JQaQNFJ0XrFM1K1N489wSr9oGj3oder1ccqXHPMOF9OorhcFhIGufOnZOJuFTArIviHjh37hyuX78ueRom1G/duiXpA/1smtpOxy6RSAih6fr167Db7Xjw4IE412tra8IujEajaLVaSCaTiEajuHLlCmw2G+7du4ff/va3OH/+PN544w0MBoe1ihxYlkqlRCeTKh8Oh7GxsSEjFE4iJzYuPEB8MTrUZXirC8foHbKugLkEYJQXTwOiISguJpv7sV209qwqlYpUYLNiVod4JpNJPFiKTlayt1inczjRjZtZR1S9Xm9kvsfzkpUnEUZkVLq62A6AbCjSerl+ulKfGC+9SYbozC0RmiCPPhqNyvNoqIZ/zGazNAgsFApyKNj/SucsBoOB5B/YRJEtOxjxMXzXxXSsiOc9jrt+kUhE8hjb29sAjnrJ6fZAmUxGFJeOXHu9wz5ixKvNZrMw3phLopdJBg4LKRmJEOogpk+YoNVqwel0SlRML537XcMbzF8wmasTp1pR09tmN2c2PSTmfxrRSWINg9Ex0NAXcMQM05RywohMuBtzNnR0NHGEhoFwG5mOAOT8Gq8BjObFvu15jvsM9yCpyqeBFelgc79xr7daLck76i4CLBHgOAJW4lNPDgYDcfRKpZJA9pqsoyEo5jxYR0gdQnIQdTTzrozGLRYLCoUC1tbWpD6L3Q0IN+pJqpogRUeLe511OyeRExsX3agQgHilxIr9fr/UsrClAfuOzc/PSxsEeuTk8/MB6BXTWiYSCVy4cAHBYFC8bV1hzo6hnOPORCA7y3o8HmQymWe6oVJhhMNhXLp0SSpkWTWslSPDQBq14yiWJ5VMJgMAAsswyU1CA7vikjTAtb158yYuXbok1FduNja9ZPNNGouJiQkpNHz11VfRbrfx5ZdfIpfLAThsemm326XmIpVKYW9vTwrYHA4HXnnlFQSDQVSrVSnGqtVqcDqdMmKZHjsHm9VqNcHmubEJU9BAk3Y+jly7dk1gwq+++gqBQAAzMzMCQ7GIlgeaRpjJ5eHwsDkn93C/38fOzg52d3cBHOVKyEYk5Z5GweFwoFQqyXxx1hPxmbxeL2ZmZqTOhZGkETNn5ByPx6VDN6MWGhq73Y7JyUnYbDYplk0mk5Kj+fGPfzzWGhoZaxQjO5FCxcQxzYVCAdVqFWazGdPT0/B6vdjb2xuJOPT12UxRQ+Qk9Ph8PkxPT4vzYYwojsurHGdk9M+Pk36/LwO3jmO6vYgkEgkAR81LqZxbrZY4NYxkAEjtSyQSwdWrVxGJRCSq4P64evUqms0mdnZ2cHBwgGazKZM5iT60221sbW3JXqYuoYGmY8UzNxgMpNaIBmhvb0/qaDg4jMSSRqOBzc1NIUzQCWAPPibxSa8/qbxQ5EKhIeAGMG4sbi5NCdX/ZqTNAUdUQnrfzDGQKUZqH607PUhiq0xwkQCg71FzxvUz8MVpqp72rjX2e5qoBcBIZGQsDqVS0WtLI8s/w+FQoh8K14neN5VjMBhEJBLBxMQEWq2WFLHq/AdZcTSammZIr4XFkoxOuNaa/aXpyrozrC6y1FDouAl9Js3pZTH5SMWt59rQKwQg+4QHlWvNnB5hMEbcfEZ6dHwWzWjU0Cswuq+100XFSNIAFSydKf4unRpNiiDbkt9D5+lliNHTZyTMyMV4X8dRljXt+3nX19cgrMPEMdlKRhq+vrfnGQ59/eP+jb+no7LTGhY+M3B0hqkfdKRMNIKRmq5L0ZE8oxM2k9X1N9yP1GWE9LluOs+t35dGkHTuU7eKYsRFHanhT+pedk/hvue+ozN80jP8QmwxACP0O4ZR+/v7Ix1nmbAym814/PgxHjx4IJj7YDCQ0BDAiIKwWq3w+/3w+XxYWFjAm2++KUVXPp8PBwcHgnvn83nk83lhjM3Pz+OVV15Bq9XC7du3kUqlpO+UZjH5fD4EAgH0ej1sbGyIgWLSMRwOiyemsUWj9/SiwggtHA5LC3h6VDabTSKTer2OYDCI8+fPw+fzIZfL4de//rU8g8/nw+TkJDweD6anp6UFzPb2Nvr9PiYmJjA3N4fJyUkEg0EMBgN873vfE7yYm2Vzc1OMSjwex9zcHP7kT/4E1WoVX3zxhbRG4YYkLJjP58Vzmp2dhcvlwpMnT9DpdHDhwgUsLy+jXq9LbmJrawvFYnFkONo4wgMbCoWQSCSQSCRw8eJF2Gw2zMzMiAdJHP/p06cS/lOpEaYiPMrDxMp7i8Ui7UioKBgZUVEyEc3ZHlNTU5idnUWz2cSjR4/g8/nw5ptvSjuObrcrEGW/38f6+rq0nMnlcrDb7Th//ryclfX1dTx58gTZbFbmzAQCAZTLZalGP61o6Ot5P/N4PDh37pyMgXj69KmssdlsRiaTkQaxx7GyAAjZIxaL4YMPPpD5I/F4HMlkEp988gmy2axg/MCRQaHRoZB0QEOonVJt5OmUkRRDp0nnAsddQ1boa5IQ9YrX6xXYjNHL5cuX4fV6kclk8LOf/QyTk5OCCrzyyiuSLiiVSiP5FqJEhFrtdrsk73Xnh3w+L91SpqamEAqFZIAgI5PHjx/LvJhYLAaz+aiNUTAYxJUrV4TOzyS+w+FAuVzG/v6+MG273a44+i+9zoU5AV2ZqznvZrN5JLHKUHhvb09mhvBFk8WkabM0LrTk0WgUCwsLCAaDmJ6elumIpBxzpgivMzU1hbfffhuFQgF37tyRHmdkFunvdrvdYsnpodLj9Pl8AqdQjB7VOKIT3Gxjz83PvljkoZtMJqk7Ydt2ekIcesa5C9PT0zIatdPpiCILBoMylW5xcXGkMC2bzWJ1dVUqif1+PxYXF3Hjxg3s7+/jq6++Qi6Xk1bb+hCRWcbWKf3+YXv5Wq2GRCKB5eVlNBoN6dWWyWQEcjwNFZleIyOzaDQqM9vD4bCQEtLptDCQqtUqYrGY1PPo96kjCGLYVqv1mWiYkFGvd9iXjKwZevPBYBCTk5PY2dnB/v4+AoGAECy4bk6nExMTExgOD0cuEBKuVqvw+/2IxWLwer3Y2toSKvjGxoY8K0dLsH3SuKKV6vMMAsXhcGBychJerxe5XE7ycTyvhGh0Rwvj9ajggcNhb6+//rok11utliSI2eqGyMHzHDtCi7wPo+cOHFXhs0CV75Ew7mmoyISadETEbsdseKpLJBYWFuD3+/HFF1/g8ePHKBaL0v7m/PnzAkMyv0cdSedWpwxmZmbkXIdCIYHHGF1znDcp3sybtlot7OzsIBaLYW5uDna7XdAfj8eDqakpDAYDofCzXoZNbNk1vdlsCt3/pUcu7KjKyIVwCL1xp9Mp81Z0jQjrABiKARBFR0+QY4u9Xq94N0tLS4jFYiOY4tbWFr7++mtpUMl6D75Y3VWWhorFX0xUEf+v1WqyyIQxAIiVZnjLIrlCoSBGchxh/QL7WukXpKmAhGs0rXB2dhYej0fmi6RSKenCOxwOJXIDDufGLC8vi7LkIef8mIODA0nes6aDG4p5DToJ0WhUooJyuSwHVP/+cDjEpUuXcOnSJTgcDmxvb6NareLg4ADtdltyb3QexhW99myHwjXL5XLCcuLBYr6JtErmLjQtlpEqAFkjXa1MT5lD6egEARAKKhl3HK3MaZ5UGHReSCzp9/vSeoeOwu3bt9HtdmVmOvMRrAHZ29sTL/U0ypHGnbkxGjKSNTR8MxwOR4ZtAUdwEPcBo2mdF9E6YnJyEufPn5f5S9y/ulWOx+MRMoURMjfmW7QTyHwHh42xBgU4mvnD59DvDRi/eSXfOZPzmUwGT548AQCpxeOz0SkIBAKIRCIC8YdCIbjdbmSzWXm3uVxOIkCbzYbFxUVMTU1J7tDn8+HKlSuIRqPiHDcaDTgcDjQaDWHMxuNxzM/PCyrDurR4PC5phX6/L06ZyWTCV199JQMLWWZAYgwZlCRmAJDWNCeRE5/2aDQKALIxaVyY3AuHw1IgqNupuFwuBAIBuFwuScpzJCgH7MTjcbz55puIRCJ45ZVXMDc3J3UAw+FRm+n79+/jl7/85cgEOkY2rAxmxGGzHQ7WCYfDYki63S7K5bIkv5ggp5UfDofSqJGb5fz584hGo1hdXUW5XB7bcyRzi9EEcOR9aewZOEzWb25uwuPxYHZ2FvPz84hGo1haWkKz2cSvf/1r7OzsSC8tNkF0u9144403sLy8LM3sdMJ4e3sbDx48kBGqmknn8/mEaEGleP78eSE9bG9vSyKTFdXr6+uYnp7Gf/gP/wHz8/P46KOP8MUXX6BSqQiN98aNG0gkEkIVH/dgsyliMBjExMQEPB6PUJF3dnaQz+elCDEQCODVV1+F2WzG7373Ozx8+FDYVna7HVevXh0ZM0yIks8HQIgqjIxYTEpjzNbpZKD5fD6cP39eckFsxc8/pVIJZvPhoKuZmRmp3UqlUvjlL3+JZDKJ8+fPixJeWlqCyWSSnnzPg6BeRLj3EokEIpGI9Iijg0IyCx0x3QUaOMpTApA5H8CosrZYDvvWhcNhfO9738Of/umfIhwOY2lpSVq49/t96bzBvUIvnUrPyEwdDoeSRKdDSoYTqc6sSaLTSINF46LzC+PI0tISLBYLXnnlFSwtLeHu3bvY3NwUJiwRCJPJJFBzKBSSxpuEc+12O3Z2dtDtdvHkyRPs7u6KkXc6nbh+/TrefPNNWQOv14vXX38dsVhMojUy1IrFIn71q1/h008/xTvvvIN33nkHpVIJf/u3f4utrS0kEglBLkjmuXbtGhYXF/H73/8eP//5zxEIBPAnf/InUmtXKBSQTCbx5MkT9PuH49dJ8deIznfJC7V/AY6qyLWSNRYq0sugt0rskAlgXekaCoUEbmB7Z5/PJ94JQ2saDjar48ahV0jYjtXWbM6me+dojJ25B50gOy6a0JS+025OXtPoVfG5OaZYryeVHKMzson4O0yy6XG9VqtVaLX0Mpm85gx4rpn2JOklcmy12WwegRfoWdFxYMK/VCrB5/NJlTXpwYPB0cAh3dT0NOtHQ8mojB52o9F4LhuN74ywC4WHV//h5wCIgqLy1Ilcwr7a2+cfXRfC32HOSPeeIskgGAyi2WzKoDWeGTojjBKOa2nyIsL1YhW5kSCg9zZJM7pIUl+Dnz+OOsz7Z2sSRixms3lkXIExCmMuTF9f/5v+jK6H0zk0nbzXJISXkdTn9djqhxRsnmHNlOQZYHNJ7k2OJibMR7IG9SWvxXPMc86oqF6vSwTC6FrvV92vjntdd5sAIK2EdFPZYrEolGVOmuUaE06n/jqpnNi4kAZJmEm3B2BxJHsusZcTC8kCgQCi0SgWFxfRarWQy+XQ7XaxuLiIV199VSqpaXBoGKg4NjY2kE6nsbGxgYODA3lok8mETCaDRqMhnUatViuWl5cRCoWwv78vVdnD4VCKkILBIEqlktBzeWBINGg2m1LwR8ycvaZOGhIaRUMMjJqIzbMocm1tDel0Wr6Hs2aWlpYkLLXZbFheXpacFDsrc7NpFhWNESnFq6uruHXrlnjcTqcTS0tLAluQCXb16lUEAgGkUil88cUXomDYq2hychKdTgdPnz5FuVzG//pf/wsulwvFYlHGLPN3njx5gs3NTSmmHNc4c6Z3JpNBuVzG3NwcpqamYDabZTYKKeak7hKeslgs0rlZK3nmhLSzxAPOinn+v96f2kjpWgfWOPBzhDSImff7fWxvb+Pp06e4efMmLly4gNnZWfz5n/+50FE5q4RQJaN3jhA/DSxGY5JKpWTAn44+aCR7vcMpmru7u+JgUHEThqJx1caHP/d4PBKZkbJM2DmXy2Fvbw9bW1tSe0LFT6eLwvwL4WIaM+YC6egOh0Opntef5zvSeaHTOIdUsJ999plArWzCGY/HMTU1hZWVFTx9+hSNRkNGXA+HQ2Fufvrpp/B6vXj33XcxNTWFtbU1GfcQCoWErdXtdhGLxXD58mVhdjWbTaytrWF1dRWBQAAXLlwQA84Bgo8fP0a320U8HofT6ZQuAEw9mM1muf9yuSyQ92effQan0ynwMp0jk8kk+4UjLV56zoWJZnqu3FCkaDJK0JuU3jNxQr/fP1I5zgJL3clWY/P0OEql0sjYWu3187vJyedUNjLAjIeBkRHzOLrgj59j3mMwGIg3flqvRx9i44FkwSjJB8TASVUkb55rS9oiC0z1O+ABo2fE98LoL5/PS88w4BAOYwU/FSzfSzKZlDbthEBZRKmrz3d2dkaMrsbhyaoiUeI0bDE+Z6lUQjQale9gZMb3yPWlo6MT98a2REavTkcirVYLVqtVlCv3LYkt+nmY3KWSZN6R+5+wI50rUsHtdjsWFhakYjuVSgE4ovqy7Qf362mMC98vKdUU7eHrCIxtQ/S6aHYn9wTXgUaX3jZblXC/0lkkNK3fGb+fCIExL6nF+M4YjelISv8+z9RpkQfeKwd88T51/0PCiZVKRRrOApAi1Hw+L0aehYzUZbwG9Rnr2CwWi3R4YD6E7wKARDhkcwJHaQH2wqNO5f1zWCCfK5fLSR6La6lr6ui8UhedRF6ozoXKn6G69hqIVzO5OTk5KVCPHjEMQDobe71eFAoFYSvRu+R30Tjcv38fjx49EvoscDT4Z3FxEdPT04jH49KxlwVnbAJHg0PIjIqKRoPCCmzCDwxZ6VGd5mAzl6MhJRqCjY0NZLNZYQ9Fo1GcP39eqtLJBCO8tLOzI8wh9htjdbjJZJLNxI2qDb3H4xEWFLsdtNttmbVTrVZx9+5d5PN5eDwewXDX1tYEBmNxGJ2CYDAIu90uxaxagXNjUjmOe7gXFxcF+qSyZnPDS5cuYWlpCZVKBclkUpwgJvvz+TxisRgWFxclsgAgz0KlT0eGxWM0QIRA/H4/AAgBhM4MlSq9WPaK4x7WXQx0B2QadLbeINvPYrEgn89LTzmbzYb9/X1hmo0rVLx8Pxri0gYZOKoXsVgsUvhJxUa4kIwjVosTur1x4wYWFxdlvfU7pyIcDAZIpVJCXOH9GfMtRnjL6Ajomg+j86fhbn2NcYVGTUP6i4uLsFqtMrCwUqkICYhoD0eWsxN0p9PBrVu38Omnn8Ln8+Hf/bt/J44TERYSUfgchL9ZeFqr1fB//s//Qa1Ww/379yV/xnZQJNt4PB5cunRJSEI8t9TPgUBA3j/3Yi6Xk/5l2rDpjgonkRduuU8WFm/eSKWj183Rwevr64Lt0ZKzboUHl+0RQqGQWGAuaqvVwqNHj/DFF19IrYVO0s3Pz8tEv2KxiHK5jFQqJR43PaeJiQmpd6DiYxREBcG8gN6o3FB6w48jVKxUyNykhEqGw6EkpJm8j0ajqNfryGQykpBuNBpYX19HqVRCOBzG+fPnR3IyAAS/5+GjIqDBAY6mb9LAEAapVqt4+PAhSqUS3nnnHbzxxhvY2trC1taWYMka82UCl4eJ0BohOXqN3CfjytzcnOxB5ofy+TwcDgcuXbqEcDiMW7duYWVlRRhRwNH8dyZYHQ7HSJNKwng83MTTGTmYzWahympWEvNejGa47uxZ5vf7Ja/RbDaRSqXQ7/eldU4kEoHL5ZI+ZWzqylxXoVCQSNtmsyGdTiOZTJ7KuHD/8r3pHMdxdSU0Lqyd4vRT5hWYmJ+YmJDn9ng8uHLlCpaXlzE7OyuJdJ4hGmRCnOzvR9G5Fd6H8f51pMS9YGztoplnjLqMxulFRUNFdrsd8Xgcr7/+Onq9Hv7+7/8e6+vrMgaekBRwWA82NzcnNSSZTAb/+T//Z9y/fx9/8Rd/gb/4i7+QqKPRaGBjYwOpVEqMi2baJhIJWK1WPHr0CL/5zW+QSqUEKua6UVeZTCZcv34d58+fRyqVwurqKjqdDmZmZqQmZmZmBoPBQCCyWq0m49/5XexK8aJ68MTGhXARMTrCTTosZiLK4/FIkSUTuqzzADDC8GDCDxitpCUUxkZ/xjba9MZptOiN0YvXm43UY5PJJK0MeE29ARkGGql3jMhOUyHNZ9cvnt9BGImHoNlsYnt7W3qeMdmn27brCt7B4LDxHGmSrGavVCoSdRDPJ1Wb0UuhUJBpeEyyzszMYHp6Wir7CTmazWbk83n0+32hUrLwkNAbf8aoST/3ab1GANIlm/3lOp2ORIW9Xk+8aEYZrCWy2Q4nTrKCmZXjNptthKzBOgmd+6MyJpWUUQuAkd5anPfB3JNm/9GxYKsknfzV7UQ03KYhF7ZgOY1x0XRcbWi4945LsFPxUIEZP0MY0Ov1YmpqSoqgabzorLHt0/r6Oh4+fCjz3E8CNxuJA/r+qBOM/66NyWn3HsXlcsmaEA3RbX1IVqLDQaWcSqXgdrtlGioA6SnmdDplr3Bt6ZQRSeDZ7PV60rJoc3NTWreQKKN1C/dop9OR6ZiRSEQMOdv48Pf4fmjQtCGhQ8m2NSeVExsXYvRMhPMA6FYH4XBYkkblchml/zsbPJ/Py4vpdDpIpVIolUq4efMmXn31VanWJzTQ7/exsbGBf/zHf8TBwYF0PdbJOgByLavVKjUZZrMZk5OTEhkRy97d3RVMXC8YGw0yaTYYHLZKn52dBQCpqSFDbdxNqjFPwifMQ/AAElrJZDL48MMPBb9mEv8HP/gBer2eQFhMnNZqNamVIJWbhjmTyeCnP/2p9A4ijs7c1ubmptBm6/U6YrEY/vRP/xQzMzNIJpPY39+XfnHtdhuPHz+WteMGZT8vKkrdTl7TZ08T+dGZYYeFXC6HQqGAVqslI4FbrRYmJyelNx07PkQiEYEfmeMgzZj7ksaTkAYLVHWxr9frhdfrlcPPd1WtVjE1NYULFy6gXq/j9u3bKBQKEjU7nU5p8TE/P49EIgGn0ym5B+4vDqFiRwRdM0Ko+TRCWIMsJnrSx9WX8B663S52d3dlWJsRaiIxIh6P44033pDu2XReSFwhnfoXv/gFfvazn0kkTsfqu+Q45pixUl8Ln4GfOy4SelEJhUIAILVRrA0xm824efMmLl++LGesWq1ic3NTDEMqlcLs7CxeffVV9Pt9XL58WQqYNzY2pO6H+oFOPLukJ5NJVKtV3LlzB3fu3EGtVpMKeqIr1G1sk886mMePH8Pv9+PatWsAgMePH0s5gXZkTCbTCAJFx5Y99aLRqNTrnURObFyMiUuN6VM0n5w3RpycXiLxatJnWaDGA87vYKdaRhhG7+O4ZK4OWTnngAaGuQV6St9FLeZzcdGJq49rXHQrf3637r1GuE8fbOCo3Q7vnT8j11/3rKLCY9TImd5cR905ms9BCi/ZL0zYWa1W6cbLdeS90VMixKaVrU6e6n2j2TvjCJUtKZn8Xr5b/p3viu+LZAmG/M8L7bkezCnyjyabaLYZcNTbiQlQt9s9ovi4JrpjBY06YVx6iizaJcxzXG7hNOtnfFb9RxsXijY0Omr0er0SkWjIUxsJ3ZOM68P2T9lsViaxntSwGEXvX33//H/9nC9TtK7TyAmdDyMZiZAzCxN1bRD152AwQK1Wk/fO32UEy3NPZz2XyyGbzQpErXPfx60T9QHHLDMaZgsvTdQywoc6ktKkp5MyZl+4txiVhN/vx+TkJCwWi4RuxFG1d8NK5EAgIGM5l5aWpNvxuXPnRjYjB1ExitEsMCPnHjiqjAWO2tqThXFwcCDeA+ERXeCpGTCk4NETI9TChnT0mseV6elpDIdDGZPLyIWhqyYPMLdFJpnX60W9XsetW7fg8Xhw/fp1hMNhTE9Pw+fzCROPlNj9/X1sbGxIGxz2DKKR54EndKYVRCqVwl//9V9LcSDXJpvNYjgcYmZmBn6/X95ZpVLB48ePR0J73gdw1DaIU/PGlbt378JsNiMSicjkUbKnGHVygqbD4UC9Xpdai/n5ebkvPnupVJKaKfYj6/V60rmWVGJCWTabTdh2hKncbrfM64hGo4jFYgiHw3jnnXdkemepVBKjYTKZBOrc39/H+vo6/H4/3nnnHWmlw/dADJ2ElFQqhe3tbQwGA/yrf/WvxlpD5ryM1N/jHAFteAAI7Hfx4kX0ej2srKwIUafRaGB3dxe/+MUvEIlE8P777+PGjRvSdLFSqeC3v/0tNjY28OjRo5Gmpt8lRmNB/aMVnDYu2tA9L6oZV8jEYhG2xWLBw4cPnzFudML0GBKttLvdLgqFgpB4OCSN1zx37hxef/116YrdaDSkEPPg4GCEQGWs3yFJiHUrTFU0Gg2srKxIkSb7u62urgpsDEAG4mkHh//luf4nNS6swSCbSRcw6XoQs9ksCa5QKISZmRn4fD5cvnwZ0WhUhmTpRHMymRyhKTJXQ+9cW1d+D70F5lCoSJvNpvRE4v0wZ0H8kGGfZmOxAaf26FjkOa4EAgFR1JqyyfvSm5L3y2ehl7G7u4twOIw/+qM/knYrNJbsP7W2tiYMKUJaNNB8d5qCq2sAaODu3LmD4XCIQCAAv98v7BQ2eJyenpZkdi6Xw8bGhmxwHVJTSTGaPE3jymQyKZ4wvT2ya/jdrLTXtSZ+vx+hUGgExtnf3x8Z08A/g8FAOknwHTGSYQ0A9zcNGpmThMy4xu12W6al8n6Y8+v1etjc3MTXX3+NmZkZvP/++5ienpaW9sTAgaM5J+Vy+dRsMY3NA0fRlRbtmRqjGUJzvV5PZuoQySiXy3j48CGCwSD+4A/+QFhIAKRW7f79+8JYepE8iPFzOorj/WkE4Ltk3D1IB5V1Nnx27m+dByXpQ0czmubNhrOEwNrtthiEixcvYmZmRliGjUZDUAgSKjQyxLXUETX3KaN9Os3sJ3b9+nV4PB4ZHUHjQhIC19IYrf2TFFFqpobVapV8h8lkEjonKXe0zIPBAOFwWHBYeprsP+bz+SS85OEmHqz/aIqk0UC0Wi0cHBxIBKOhJRZC6het56wzTOV38hmZh6Eyo4I8DduJkwt1MWWlUhFueb9/2NH40qVLwhhh59LJyUlUKhU5mF999RX29vakkp7vp9/vS20Kaay8f4bXOpHLJLgeXa0PMqEkQmF0IPr9vvTzOq4OiO/RZrMhkUhIPuQ07Utee+018froeDDa5TA5QmROp1MMIGfX8D0zt8WcEO+NY7xnZ2dliBzrXFizwV53fEbgkMXGHA3HH5B1xj3F4l3mrTqdDuLxON5++21pNMhInZErIZNyuSzR0aVLl07lhWtDzy4OxpoRGlRG9Fqq1SpWV1fFuOuzpb10vn/uFRJLWCpwmgQ774vPohWq/u93XWMcobGNx+NIJBJCYmH01u12MT09LcXi7MzOSCubzeKTTz5Bp9PB+vo6KpWKFDuSvQhAchykd7O79P7+PorFouiL4/JMRiExgO8aAB48eCDMWupXnhE6NRrmYydkq9Uq8PRJ5IWNCz3tZrOJzc1N2WBms1nGZtZqNTx48ADNZhMTExNYWFhAuVwWTjsr44PB4AgVkgtBT5JsGi4AH9DpdCIajcJqtaJWq41YW97rcDgUY8bfsdsP58+zvsbYTp6HyW63Swt2HhI2gRt3Y7JdNwDxoOk1kNp7+fJl/PCHP0Q6nZbaFtKSNzc38eTJE4FM2BWZ/droBXE4Fyv7db0JjQtzEUzg0WjyXerIjwqS0Snf08HBgbRhZ82NPuBkjS0sLCAej+Pp06e4d+/e2J73u+++i36/jwcPHmBtbQ39fl+8xEgkImOBWcuztLQEp9MpB5IUY6vVitnZWaFvc7w0p01OTU0hHA6PVP1r6BE4hEUYRVy5cgXnzp0Tg0LIhHUK/X5f6Pc2mw2bm5tCAHjzzTcFMuN7Y3RBxiXrtebm5nD16tWXkndhUTM7Keh3wvevvWwKW4MAR0lyMgNpXNghguQO5k65p41V+OMIz6rOg+o/lOPyMKcR6rmZmRnE43GJLNgLsFwu49y5c3j//feRzWbxj//4jygWi7Ivd3Z28PDhw2eMw8TEhCAog8FA8iqhUAhTU1Not9uCELAW7zgDfdzzE8qicWk2m/jss89gsVgQCoUQj8fR6/WQz+dHGoFqMlE4HIbX65VO9CddzxdO6HOBNS7LfycsQQoyDxlZPZr6yY3HhBi9JeCI9qzxRP2HFl3nYejRMCQ0Js01BnscRqphNuAIjjBimuOKrmzm8/Hw8vsZ/rKdTr/fF+yeyq/f78toZ50cpufBQ83W+MbaHf2+9B+du9KwhbFolUwwGj9GA0ZsnMlsMmfY72hcSEJHkSwIDQQCI1P9NIVc5+wIL3LOEGEu3iuhXQAjPe6CwaC8Mwq/h3VEVPaENUivNZsPZwcRXuQe4LoyiqZyJHRJqJQRD6/N8bKn2Yf63GpnwPhO+D38vBHy1GvBPQlAIrxOpyMedqPR+FZv+zTPAZyMcnwahphRCFlqWjb3CCPTbDaLUqkk68KonXpJO+pks1I/AhBnh9EZZyNRJ3zbcxqf1fiuGbUTmSEpgFEz75kOov5d0q9P6hyc2Lhwo+u6Fq3szWYzdnZ2kM1mJSwmPul2uzE1NYVr167JEKVisShUOJfLJZGIriLXLcv1IrHFPOEQzXZikSEL3+i5a7YVISG+CB4QTaFk8o7PxqLBcYWJU3qNbMDIn1ssFqyuriKXy6HX60lUdf/+faysrIx4kTQ0NCKaIsrPcAgTDc9xiolGhRW7586dQ6fTwerqqtSQkDYdCATg8/lw8eJFXLt2DdVqFb///e+fURo05MSFHz58KA4FE7zjCIcpMVcSj8dx5coV2Gy2EZjM4/Gg2Wzi7t276PV6iMfjCAaDMt9GJ+hJ2hgOh1K8GAgEhI03Pz+Pbrcr0YPeJ/Pz8+Ik5HI5bG1t4cGDBzCZTIhGo/D5fJifn5emlLlcbqTDMCNPnpFutytrrAkRbP+Sz+eRTqdP5fVrY6Wrv3XOT0cFhJnp+R7HFGLUzOrxUCiEXC6Hr776SgxLoVCQAtvvun+tHJ+nQJlnJET6PGWrnVXtnJxG+v3DgW/1eh2BQACTk5Mwm82CBGxubmJtbU2+dzgcYnt7W947W+HwOYnyeDweoai3Wi2Zt8RO3Pv7+88YZ2OUoost+VnqPr47n8+HDz74ANevX8etW7fw61//+plGokRsMpmMOOcsluYY9pPICxVR8iHosWgKMXMSVOpU4CxyY7LTYrGI9ebiDQYDYcVoGMZIceR3U4l4vV7BujmnhV4qPXret/YYaESMwhdAxQ1AaKTA+E0r+bt8fsIOPBR6o+lWGADEQ9ItvenBkLnBTcXNTAojw2z9fMY//B1259XMMuAoQUpigdfrlYiByuK4zUZFxTb7Oic2jmjlPhgccvkDgQBsNhuKxeJID7HB4HCGOHNWhEX5dxaY6SiSf2c+QhcDE/qg4mUin/kF3bfNarVKvzwyJPX8G03PJ4TEfU6ijD5rrLuh43Qa46IjeH4fE7ka0tQeOdeHclyUwzNLgolGMBiJGyvoTyI0/Mc9B53Ab8vf8CzoP6cR/j6hfZPJhMnJSVknq9UqdGv2BWP9F2cz6c4ZAASWZ+6KESoht3Q6LUiF8T60/qDu4t7RkSb3G++TqQq2dNIOPO9N5824R6xWqzhhJ5ETG5dIJCIJaT34CDji6BOmouiNnE6n8eWXX8Ltdo9QaGOxGDKZDO7evTvCglhbW8Pu7q7g/mazGRMTE5iYmJBCNhYZdTodKeqjp06vhgV+gUBAEr2JRAK9Xg97e3sSOTFZzM9zETVl+TRez5UrVwBACuaOY10Yw2xSeG02m0Q6NOa6LqLf7wt5gZAPPXkq5OFwKB58r9eT4jZuynK5jMePH0uYTmXNeiS280mn07h375506NWRAI0jISgAQlOnch/XQN+/fx/D4VDyUDabTTwro7NCr5wwExsocpBXKpUacUYYRfBahBJ5oDlWNpfLCTEDONzfrH7udDoSzbCTQr1eRzqdRqFQQCqVEsy62WwiFAoJlZewR7lcFliJ9xePx+H1erG7u4utra1TGRfmczRMyMJAjinXz0aPl3tOw2JGo9NoNLC6ugq/348bN25gampK9uZwOBSjaYQ3jXJcdG2E4DWc/G15FWM90vM+d1KhA8KeXLOzs/je976H4XCI3/zmN8hms5I/JSTscDhw9epVTE5OIplM4sGDB+j1etKolmeQaEW328Wbb76J5eVlIajk83n88pe/xPb2trRVYud5Gg7uZZ5b/qETpPPZDx8+lBHkujEqdXWv1xMIHIBA20w5vHTjEggE5AUzFNV5BEIe3ID0MGkVOdiGijwWiyEWi6HfP2xB8tlnn42MHS6VSkin0yNheiwWw8WLFwFAklNs+kjFwtCPYTMXyufziZKcmpoSUgGNi8lkEuxT4/N8aafFiy9cuIB+v4+VlRVRUDwcx+WU+IezuSuVCgqFAobDoTSp5GZnkRqTxyy61JsGOOx2PDU1Jb3guK5ms1n49nyv2oi5XC5pK0NPlJMhrVar9BYDDiEXGiQAoqgJrY3rPa6srIiDEQ6HYTYftlnR3j6VMtut0DMnbZrjb5kwJU2eSXubzSaD6Uwmk3Qu5phk5rC0d0jYx+fzyQgAPiONTj6fRzabHck/ka3Ds8HOCYw62f2gUqnA7/djf39fxgiMKzoPSSU5MTEhjpq+to7eNVzMM8/15Z5lyyKv14srV64gEAjAbD4afa4ja00p/64zpb+Hxog6RnvtxmsZYe+XkethXtjlcqHf7yORSOD69evodDr49NNPn4H+uA/PnTuHt99+G1999RVu374t7ESePcLuZFNOTk7i5s2b0r8umUzi3r17I52MmdPWrElNvOHP6FhxL3a7XayurorOZC0XzzyNo+4YwHZGzB2deL1O+kEymzQ2xzCLEBVbWfDfjN4GowMWDTHSIZuEkQeT1jqhbjKZpKkalZ5eSFpg7TnyUDB0J8unWq2O4NdUCBpe4kbmdXiNcYWGcjAYSPt1eoq6qwF7TBFXBiDhqY5EOp0OPB7PSIRF74Q1IEYyQrPZHGlCp2ESrqF+x4Q57Ha7bDB6n7VaTZLPpKKz2R09IG2kGFGOa1zoYQOH8CEr73UBLme+sNcVmXEcfqRhQlK4uRdjsdjIXiJcxUNPB4MFpEy4soMBoTer9agHHKPUVquFYDAo56TX68Hv9wvENj09jX7/sCMtc32EiVlrpCviTyM6+iB0Sk9Yi4a2jcqc1+H/M4phpJNKpSQvQTKKHj9Op+e7KvSN30XRSefjDMq37bHTQGOE/6ik8/m8MDh1XdxweNiN+Nq1awgEArBYLNja2kI+n5f9yqiENYAs7NWsQ/b6SqfTMlJDk5145jUBg/qLheQ08DwLAARy0xX6dNAIHfM5jWUgL8JWPLFx2draAgCxdPphEokEYrEYNjY2BGriSFWjVz4YDLC5uQmr1YrV1VU4HA5JCnLBzGazPLjexGxNzgiEC81ErfFwc1b5wcEBvvrqK9TrdYFzNEbJ76SBooI1m83SNoHGaVwP6JtvvpFkL+tWjPkmQjomk0kGLNHbZUJckyXYxrtYLMrwJ1JauXm1FItFVKtVMV58rn7/sHU/DQPDc879rlQqePr06UhNBAsUGXkOBgNcuHAB8/PzyGazePjwoawh65E0HftFZXFxEcPhUCitk5OT0j+JRszj8SAej0s0MxgM8OTJEylmZFfuGzduYG5uDjs7O9jZ2ZFhS4RvWHlPSG9/f18MxPT0tDgpmnLMdWSrco/Hg729PaysrCAQCODcuXNyT1Tu7IL82muvwe1241e/+pVAS7Ozs3C73TISOR6PyxqcVui0lctlyfEZjQsT+mQUMYrRCp+5QM4hYl7o7t27UqhKJUbnlB0nmER+HtxsLN7T3607dRjzsYzo6YDp658278IGpfV6HfV6HRsbG1IGkc1mpf5vMBggHo/jz//8zzE5OYmPPvoIH3/8sYwZNpvNQu64ceMG3nvvPRwcHOAf/uEfpBvG/v6+0P0rlYpQmjmLiblWrsVgMBiZmcV8ZKlUkoiIuo0EC64Fa7i8Xi/OnTuHubk5bG1t4eOPPxZHFTiCmU8qJzYuuoiON6lfFl8gN4XRqFB0eEsvk56TtsDaS6MHxeQpNzwXl2GcTkIz2jBuTHqkfDm8Lu+dERG/X1vr00BjVLSEonS4r8V4ALhevBcKn40eicfjkehHRw362RlRDIfDkV5CRq9Ufz+/w8jMYZKP96fzbxpXJyFCFwiOI1TMGgKhF6zfLaNZOgz6uVl7w0Oqk9ksVOR7AUapu3ofce/wj15LAPIz3gP/n98HHI084Bo5HA6BnAlfcb/o4s/TGBejYiWSoPfJcdfXa2L8ff27bHHDiIgGmnvDmKc5jZwk4nnZog0YDS9JFhouPI70wP1D46I7QlPnsZnqYDBAtVqVXmL8DiIZ31Yewb1PSj1ZlnpdeGY1scC4Z5+Xy3oRA/3CXZGZOKVHajabkclkxEPhCFzOydCMDh6kUCgkytBisUgHUGPjQ4bmrGKtVqvSGoa4uIaM2OGVi0Oarcl02BeMs7z1fAz9PJFIBIFAAI1GQ/BN9sRixf+4sARfCF82IxZ+Pz1IzpthrZBR2QBHNR+lUkn6U7311luwWCz45ptvsLu7O8Li4qGmgmNiThsW0nKBo8lznEMCQHI5Ogel+4mZTCaUy2Xs7e0JfMbRqj6fD/l8HgcHB2MrR2569gtj2M+6FbPZjP39fezs7ACA7IXhcIipqSm0Wi2Zs5FIJBCJRMQb73a7WFlZAQApoiS7zWo9nE3EyvtMJgOXy4Xr16/DbDYjnU5L1N3r9UbIA8vLy9LmnBi5NlgApC+X3W7H/v6+4PbhcBj1el1muOgx0R988MFYa2j07mlw9ZnR+VLNYtKJ5OFwKE4K9ye9XrvdLs0pSY5g2yBG53rg2Hfth+dFNbxXY6KejsTzzql2ol5UYrEYzGYzZmdn4XA4BGbWZQ5U3JlMBv/jf/wP+P1+xGIxvPbaaygUCtje3kaz2RQW2KNHj5BKpZBIJPDHf/zH8Hq9KBaLePjwocxg6ff7Mi6eKAUbYtJI0HFhzpj7mMMT+RntLPPvLpdL9vr6+joeP36MdrstZJ3jIsWTyImNi7aamvPOXAgHVPl8PoEgjrshwliamswWHAwX9QYglu71ekcaO7KqXHuxxHU1BDccDqVJJhlLHNK0vb0tB4bPwumAvGfSA4/rVvsiwufh/ZP22u/3BZdn4plGk8+nGSG8T5PpqGjV6XRidnYWLpcLOzs7Ak3q79aUZWPBlE4i03AQfut0OiNsKsKIhAY0bEknge/SYrFIby8qmeMYQicRGlQ+A50GKj8SOEh60DVTnHBKJckWQH6/H61WC6VSCTs7O8Jqs9kOJ5Z6PB6JjPr9o5Y3NFA0YIT9mIfi/bHJZrlcxtbWluTT9DskGYPJe3ap5jRRfiedo9N45dphYz0Eo1Gj0aMBMZlM4lgQXdCKVBfZsj0OpyLqPCUJFazb+C75NiPwvKj/eWiJ8ZrjnmEWHoZCIfh8PpTLZektxv3GdazX67h37x4cDgd+9KMfYWpqClarVbpE0Chls1ns7e0BAM6fP4+JiQl8+umn0kAyl8sJZO9wOKRDh85Z8buBo3HqgUAA4XBYnAK9bpqWTP3Le2c9Fan4/MzzIplvkxMbF9LSNBzDjcMFZtU9PTtGCEwiM3fAhTVuHs2n5vXM5qNGixoaoLEzQjq0xBaLRQaVdbtd5HI5wSupmMiImJ6eluKlXC4nfbFMJpOE96yZGHdj8np8WcPhUb8vGjPS/zwejxhDVvtSCQ6HQ5nLwTUqlUpYXV0Vz9DY+ZnrwXXkBmQCjwlsGj4qIU155n2TGk2Mnc/GPFmhUBiB8Rhl6nEH44jOv9HQEC6gV1apVGTiIz26RCKBaDQqh7HZbCKZTEoUqhlxGuLiAez1eshkMtIWIxAISCEwDQuZZsAR7AFA2GtseKlZUzRyfC8mkwkLCwtS5c5Gp4x4otGodBAfV8jgY7SsoWc6jBr+I1GCDpA+89zP3L/dbhfb29vCqtPJekb97D5tVPBcE2OS32gkjLAOgBEvnGKsfzEaznGFnRY4ur1SqSCTyYyQaJi347hrDgO7e/cuKpUKstkszGYzrl69CrfbjXQ6jXQ6DafTid/85jdwuVzY3t5GLpfDYDDA3NycEAZIXQ+Hw8IUM5lMuHz5MiYnJ0XHms1mbG9vY29vT9ACu90ueWoycnU0TIeT+5R732KxYGpqSj5DB/4k8kJUZODohdNzZQiqMfDZ2Vm88847CIfDuH37Np4+fSotzskO054Hxxzz97nBCX2RNUFloCEiHaUw16JnWDNxRmvM1gc0LoFAADdu3EA4HMZXX32FBw8ejNRpFAoFdDodGU07rudIWJGKi5AB75ufIV34Rz/6EYLBIB48eICtra2RUaZUhDysxWIR9+/flzVl9MXNwaLHfD4vHiVwaMRjsRji8fgI9VtHOlTchKBIjSZbRpMeyuWyDBbTzDMamdMYFyZ/Gb0Ql2YbHCYqGYGQ2st11cpmY2MDAOTZSZ3udDqi6Li/ut2uNAOdnZ0VR4RKkM4KISTNUGQ0yNb+upElIyoAYngvXryIt99+WxoiNhoNgZwTiQReffXVU3WJ8Pv9GA6H0gxTr4kxoiQpgvlN3VGZxpGdFwgZrq+vyzvSsGyv15OiQ2DUSNBAOxwOUXr8t+cJ9xH3JB0hKkB9DZ1/01HXOMKxCKzBo5GhUdSlAIFAAMvLy3C5XNjc3MSjR48EsotEInjjjTdw8eJFPH78WMaK//znPxdYy2q1YnJyEpcvX0aj0cDvfvc7ZDIZxONxxONxVCoVVKtVWK1WvPbaa3jjjTeQzWaxvb2NYrGIW7duCcQ6HB4SKaanp2G325HL5dBsNuH1eoWUwy4UdMapdy0WC+bm5hAOh5FMJrG5uXli9OGFd6reIEYPQ29WHW7pcFEnR/XvGq+t/3uc92K8By06UUXRyTP9+/TQdHJfR0LGhPfLTkgelzCjQte1LPp59H3wmfQL14lFvZbH3bv20k8iGg41/s5x++C01NnvEv1+9FqQtGE0aHqt9HvWz3Xc9TXZhPtO71vjeuv1OO7v/D39/zwzACRq1/dHZTquGM/VST+v75F/P+79GyMG4zl63u8Z9+lpIwzj/b4s4X1yDxn3nvFzPFuED/Ve0gl0GkYaab0eWpcZSSUUXULBa9GQ8fP6WvwM95Tx/Bif2QiNnXi9hv8Ub+FMzuRMzuRM/n8t4zfLOpMzOZMzOZMzeY6cGZczOZMzOZMzeelyZlzO5EzO5EzO5KXLmXE5kzM5kzM5k5cuZ8blTM7kTM7kTF66nBmXMzmTMzmTM3npcmZczuRMzuRMzuSly5lxOZMzOZMzOZOXLmfG5UzO5EzO5ExeupwZlzM5kzM5kzN56XJmXM7kTM7kTM7kpcuZcTmTMzmTMzmTly5nxuVMzuRMzuRMXrq88JhjtoF3u92IRCIAgFQqJbMFOG6Y81kymQyKxeKxbfA5YdLpdCIcDsNsNiOXy8nIYz0gCjicrcGpkRxWxD/RaBSzs7PodrvY2dlBvV6H3W6H3W5Ht9uVOSYckOT1ehEIBODxeLCwsACXy4VHjx5hfX0dDocDwWAQAGRcs9PplME6HP37IsKW2BcuXMDc3JzMRm+1WlhbW0OxWMTS0hIuX76MZrOJra0tNJtNmVLJgUxutxuvv/464vE4tra2sLGxMdLKnFMzORNEj33tdDpot9sIhUK4cOECrFYrUqkUSqUSrl69in/2z/4ZarUa/uEf/gHJZFJabPf7fbTbbXi9Xvz5n/85bt68iU8//RT/+3//b/h8PvzoRz9COBzGl19+iW+++UbG53LGj271DQDVavWF10+PR+CwNf3cJpNppNU+p0TqMdF8HrYY50yVXq8ng8c8Ho+MsK1UKjJ50G63o1KpyEwdYzt63WKdI5g5JI2TLTmhkMP1AMDtdsv+SyaTSKfTI8+t2/Gz7fmLDGzSMj09jeHwcKQ1x2oDh63YOQROt5HnvtFTS4HDFu+RSAQul0vmuXS7XVSrVQwGA7hcLpmyygF0xkF0+tn06Gw92VKPwNBy3GREzo+5cOEC5ufnkc1m8ejRI5kuyrHOerT1iwp1AsePG0ctGO+X+10PZaPw/jlTqNVqIZ1OywwVtsLn9TgL6LgxD9x3ejaUbtOvW/XzZ8Dh8LhAICADHKlbOcuJ+k7fP7+/Uql853qd2LhwsBGH4rRaLRQKBblZh8Mh8yaGwyHy+bzMPeDgLc7D4PjYTqeDcrmMWq0mw53q9boMT9JT6eSG/+/cFeMic7oeFYlx7Khx/kav15MBThsbGzJBj9fncCo9t4GDtMYRXiudTsv8eg4ZouHjcCgeVpPJhCtXriAejyOVSuHRo0cYDofY399HsVhELBbDj3/8YxQKBdy5cwe1Wk3mgHDgGWfd83pOpxODwQAHBwcwm81yL3t7e/j1r38N4HAk7eLiIorFoqwJp+utrKygXC5jY2MDnU4HlUoFt27dgtPpRCqVembiJNeOI7DHXT891pgH77hDywPNw+92u+FwOGSAGJUQDw2NCsf9cv/pw1ytVmWCnxbuK63oOIDN6XTKlEIt2sgCh0ru4OAAVqsVtVptxFDxmsDhoKpEInGqeUI0jL1eT4y+niVCAwAAoVAIN27cgMvlwv3797G1tSXrMRgMUKvV0Gq15H4sFgui0SgAyBA7q9UqY7v5PJwO6/V6MTs7C4vFImORO53OyEhePT+FP6MY54/wv5lMBq1WC61WCwBk79LRpJM8jlAfmUwmGYgXDodlUJ0ewPZdc2molxqNhpxFn883sgf17Cu9z4BDfTw/Pw+r1Yp0Oo1yuQyPx4NgMIhutyvrcNyMFgrPL3DkvPh8Prjd7hGDxaF8nJ56UjmxcfF4PPLgjCo42MZms8l4V4vFInPB+/0+vF4vXC6XKAOr1Qq/3y8jfOnFcuMbh+/ohWHUZNxYNC70sDjgxjj8SXtONJAcDSoL8n+HMVEp6AFI3/aivkuo1PL5vMx5NyrGZrMp43c5RXJxcRGvvPIKHj58iK2tLTQaDRmVuri4iLfeegvb29v45ptv0G63ZYMHAgEEg0G5/16vJ+s3GAyQz+cBQNYpnU5ja2sLHo8HV69eRTAYFONvtVrh8XhgNpuxu7uL/f39kejy0aNHz7wrvhf+zGazwefzPRO9nlT4XvQAJv7RkwkZ1dCYMgqt1WqyNhRGZNqR0R46P9toNJ57X8b9pWesHzcrnmdEDzbjftDXNCrWQCCA+fn5U405ZrRCx4sDq4bDoYy3pTidTrz66qsIh8PI5XLY2dkBcOSFc030GOxAICBGuNVqwe12w263yzArbdCdTifm5+clwuGk0m8TY7RiPI/D4RDFYlGQEiIpNCp+vx/BYHDsPaiHb/FMTExMYDgcioOs74Vn/rhzwX3cbDZRq9XgdrsxNTUFq9UqkZH+Pb53roHH48HS0tKI4xQIBDA7O4tms4lSqSSOo74nLXQo9GRRv9+PcDgsEQ8n5tK4BIPBEzs4JzYu+sXrKWaEAaxWqygbHXHQqDDkZYQBQOacm0wm2XwUfl5HD3a7HU6nU2aL61GqVqt1ZO44cKSIqIzoyRI2onfLF6dDSO2B6PB2XOGEQR5sitlshtfrHRnx7PF4cOHCBYkyHj58iL29PbTbbRk76vf7EY/HZfQzvcZyuSybymgY+S709Em+Q3qw/X4fpVJJ5mXTMHGML+/fZDKNrDfhKHo7xnG1VOTjet581xoSpTLUMIkRRuF8c0KLw+FQlKGOfLTCP26yIIUGRO8ZY7RRKpVkZCyVC42d2WwWhcooW0/25OeNTla9XhcP97SiI0C73Y7hcDgShQCHjs76+rrA2lx/GnneF71ZOpXdblfePY0GoTO+M+7NRqMhyssIvRmdS66bhmm+a2w215GG6zRRH3CkAxn1DQYD1Ov1ZwyJMZo9Dgo0vl8abO5L473yOozAzGazRLxEJjjynJE3MDrZ1uv1jjhmrVZr5P4JD+vvJLQJHJ6lcrn8T2Nc9Iu2WCwChRkjEf1Z3jQNDx+Uyp2jXX0+34iio3JjhNHv9yXsY2itD7bT6cT09LTkGvTL5OKYzWZEo1EEAgEUi0XBt202G8xmsxhG3jNfJr07HppxxOl0AgBcLpfkAwgbLCwsIBAI4ODgAMlkErFYDH/2Z3+GcDiM//7f/zt+/vOfyyEMhUJ45513cOHCBTEWDocDy8vLiMViWFlZEaOgoSOde+H3aiPDqLLX62FnZ2dkA+lNp73U2dlZdDodpFIpmf3Nd0sIiu+ASn5c4ftwuVxwu92ivAGId8xoWgs9Sh4Us9ksHjVzWlppEg6jHBdFaEXHPcN9TIhRR6ZUpGazGX6/X+bFc5/qcbd8DkKlfA/ZbBb5fP7UCpL3z/t1u90YDAbiIACH76tUKuGjjz6CxWKReyHExPcxHA7h9/sxMTGBdruNfD4/8g6Yh+E1tTLtdrsoFotyfZ714xALAKIcCSVpCM8o+uz3+325h0qlIhH7OEKlz/3S7XYF/mcEoEdo8/7okGmDaBydzrwHDbBxz/GaGvp69OiR6FauHSNxQmLcV4FAAIuLi3A6nfL5g4ODEViY+5nrZwwiqtUqSqXSidfrxMaFG09b3MFgcOxsd70ofMFcWEJYxiSRPrja0mvR1+cffp6ev9HrM84+56HS9238fmAUhqGcZh689mZ4v1RyXBP9fTTGjUbjmQQ4vV4qWCptevDaEzFuYv7R74L3RW+MB5ebSicK+TN+Xv/RUKR+h0Yvbtz1439PAk8eF8k877/686dR3lx75iW/LUdglOcpVYpOdo8rdHD4/nRUru+VzgYNLw2L3l+8V/2ejdGENrDGs0MFyGjduGf0LPjnIQYOhwM2mw2DwUCU6nHPQjKN9sLHEY048Nl4Vl5UNxgddWAUGdGz7Y8TOtTMafO98BpMY3AtnE6nOGHcR0zaE1nidY1/aKAYhX7X2aOc2Lgw8cMNZDabJfIwmY4S4MFgUDxdHgh9Q1wAHkAqQDJzHA6HJPtbrdYIHs78iM4fkJnCkI/JRuLY/F5el16C9iAICTgcDrhcLjFAvC/CeKcReql82eFwGNPT0wCA7e1tVCoVuN1uuN1ulEol/Nf/+l8xGAywtbU1AsW0Wi189NFH+PLLL8VrIVw1HA4FEmu32+JlEDpjZKHDeb4/i8UiG41epBEz1mH5cHjIOqLiIbPkecafebnTwmL0sLl/gMPEJJUGnQKt1IywVaPRQLvdHjnM+n4JkT3PMDGa1kb5OLhKrxvXgRCNXlueHc2QMirU5zlcLyJXr17FcDhEKpVCPp+XqFyvmXYOGS36fD64XC60223U63VRRsPhEM1mU84kMOp8aKEC5ZnsdDqSOzSZDiHWVquFWq0Gq9WKaDQKm82GUqmEcrksxBd9fpeWlvDGG2+g2WziwYMHKJfLI9dvNBqw2+24du0aEokEtra2sLq6Oja8zYQ7nT69pzQEbXxP2ok2GiGyVjudDorFoiARRAC4N/heqFcnJibw3nvvwe/3iw588uQJfv/738Nut+PKlSvw+/0oFAooFosAIGzRfD6PZrMJj8eDy5cvo9vtChknEAjA6/U+c9+MZnk/J5ETGxeGuvrAEGYgs4H5Fy6KMULRG5cLrZW8ps8Ru9UeHzHc4XAohsLpdAqTiXgiDROvS2YH8x7G6IYHg9cibERDdZqIhcKDSsVoNpslZ1Eul5FMJjE5OYlgMIh6vY5Hjx49k5Cj90WDw7V1Op2Ix+MSqgNHOQ4KDQg/w9CYyoDPzSSjhjUBjEQnVEZ8F8cx8vT7Nv7euEL4QR9kvbbaCzwuSuCh5zsw3qfRe9bfa/x/YyTH73/eXuF1NfSjlfhxXrfxvk+bb4nFYkIg4H3oe9b3BRwZG1Kph8ND5hz3Hd+HVjjHrZ0xYgYgkRFZUg6HQ94jHR232y3QJ3UCr0lH9vz586jVakgmk+Jw8DuazSYsFgsmJiawsLCAarWK9fX1sc8znSpCofp5jdGSXk/ev/FnXFuv1yvGig4fnUD9WW1Y7XY7zp8/j3g8Dp/PB6fTiVarJczNmZkZTExMIJlMCsmiXC5L8r9arcLr9SIWi6HVaqFUKmEwGMDtdiMUCo3oSK4r9dFLNy4MqXXCjl+kvUBujng8DpPJhGKxiEqlIqwNq9UKr9cr+HSr1RqpDaASSyQSmJqagslkkusT+nK73XL97e1tFAoF+Hw+hMNhqbHhC6BB4b0xmXqc4WPYzOQYF1gnYMeVH/zgBxgOh0gmk8jlcgAgxoUhcK1Ww8HBAQaDgRhD1kr4fD5MTk7CbDajUqmIt97pdOBwOIRUsbCwAJPJJNGbNtr0uIfD4QhEwgMeiUREeetaCqfTiUAgAJvNJt9TrVZRLBYl4qPxsFgsQkUFDj0zh8MBj8cj0eU4wv3yPAhCR3cU7UAw18d1OM7wmEwmoWEyKuTh0t/Na1mtVoRCIXg8HsTjcczOzqLdbmN1dVW8be4nTTPW0YmGRzQhwghT8L5PI8wFEUaltwyM1n0YozVGaRp60iQKKjzt7NjtdoFujQpJOwV8Xzr66/V6qFarwubUSWiuidlsRq1Ww9bWlty7y+WS0gbCksPhYQ6s1WohlUo9k1N7EdElBPpZtBNlTNQDRzkXXffD32m1Wsjn8+Jw6vyuyWQSRIB7e2FhAfPz88IELRQKyOVyGA6H2N3dFXLE06dPcXBwIOUZ9XoduVxOmHx0DJrNpsDrZKsSqTGeEaIdL924uN3ukQiCX65hJf673+/H5OSkwCwsaCQryufzwW63i2fNJKvVapWQe3p6Gu+9957Un7D4CTj0wF5//XWYTCb87d/+Le7cuYNgMIhoNCqGh5xtr9c7UkvCxTYebnoFVNikFbrdbvEKjPTAF5H3338f3W4XH374IXZ3dwEc1hLQaBKCazQaI0WovGefz4dLly7BZDJhf38ftVpNksJU+na7HXNzc4hGo9jd3cWDBw/Q7XYlYuD1SaBg9GcymRCJREQ5kpTBTe33+7G4uChEBLPZjO3tbezs7IxEPcwhAZAaKJ/PB5/PJwWL40I7NAy6FkILn0NT1bWnzCQ8gGMhMX7G7XbD5XIJoYR4voaC+KwOhwPz8/OIxWK4cuUK3nnnHVSrVfzDP/wD9vf3Ua/XUavV5F3pIjWN/xvzhjqS0YSL0xqXra0tWUM6drwHo+OkEQNSYzWcxygXOCJB8BqEacjS0wrJGBHz/7Wx6vf7QiemMddOBdeQkQj3pNvtRqFQQLlcHiFYbG1tYW9vD81m81Q5Fxpl7i39TJqVajReJEJo+FbDXPV6XejA3L/dblfOtY78b968iR/+8Ieo1+vY3d1FpVJBLpdDvV7Hzs6OJOjv378Pq9WKcDiMYDCISqWCg4MDSWUwh8J3RIeQERSF0RUdrhfRfyc2Li6XSxaRXomxgl57XzQGGlvm5qOVNsJlzB0wuqEXWSwWZbEJgdFbnpqaQq1WQzAYlPsIBAIjB0O/bHpT9Az0BtGhoJbnhfwvIjoiWVxcRCAQQDqdlsPj9/slOrLb7ZiamhKogFEAw3waag3vUGEwd0Uvg++L/HkKn0XXPJjNZrhcLiwvL4siNJlM8Pv9mJmZkcMKHCqAbDYrCldDoTabDYuLiyPrzYMz7hpqJaS9ex504Cg5yjXVion3zGtp71ErBD63hliM3qjdbkcsFoPL5UIwGBTDGQqF4HA4hJWTTCbRarVEcWoHzGgIv23/PQ+uO806GhUkv0d/xkh64T3z/7m+dAppgDQ0+zzR361LGPT3DQaHtHy32y2wDqF4i8UiEaNxL+rnoBGncT4NtJhIJOSMUQnrd3Kc3uBzapTkuLUAjgyuzoPp39P5S+aHecaNTDsm32u1mnSL0HlUrnuj0RgpvNYOzrfBnSeRExuXiYmJkS8plUrY29sbwUGdTqdAH9lsFgBGuNuVSkWSpYxcjIYlHo8jGAxiZmZGKHekECYSCYTDYXg8HtjtdrhcLvzoRz/Cu+++i93dXTx58gSDwQDLy8sYDAb45ptvsLKyArvdjkAgAOCwDqRSqUhIrnFw7Z1q7N5oBMeRn/3sZ7Barfj+97+PH//4x1hfX8fHH38s7VguX76MXC6HTCaDaDSKH/7whwiFQvjwww8lHN/d3RXDQzpupVKR8NpsNiOTych3cp3ZqqPT6aBUKo2whQipsZI6Go3i3/7bf4vJyUl5XhagEfLqdDq4desWbDYbisUinjx5IlXsZrMZV65cwZ/+6Z8CAP7mb/4GDx8+hNVqxczMzNjrR8Xj8XgkkqxUKnKAuX/sdvuIgqbRpKfOddHvk9AuAPHstKLXpABGee+88w6CwaDsoenpaYEk4/E46vU6fv7znyOTyYx40VR2mqmjyS/GxLAR6juNaNjJKMZaL2N0ws/QIDLqYQunVqs1UljLqPF5uQbKcHiYxyFSoN8JAMzPz+PSpUs4ODjArVu3JPK22+2Yn5/He++9h3K5jF/96lcCD3EPUDfR0eV7GFc++OAD9Ho9fP3113j8+LHsOa7p8+BaGje9L7nGek2p5BltlMtlpNNp0a106ukETk1NCZSli6IJaw8Gh7UzuVxOWt/ovUVEiAbLbrcjHA7D7/ejVCphe3tbvo8OxIvIiY0LXwoPE5k/eiPQ+g0GR4VLxD61p6mjBiO7hPg8YQf9khg6aoyfUBvpumazWfjwNGD6+hr31JADxegl8GfHeXovIuVyWXJAkUgEOzs7UhcQDofhcrmkStbpdMLn80n9EOExhrx8H7x37bnQA+R1+I6MNGHgKAdF48IWLfPz85ifn5d1IyECgLSmiMfjCIfDoqiYi2PkGolERDnq+qFxFaVmMhkLUbVnbwzpeQ/G/JoWbUCMf+e/A0ctMpxOJyKRiMCaw+FQIm1+hlAmMBrRa+9RR1XHfZ+WlxW56Osdd22j4dXRFtfAuD5GlttxBuXbRBs0bdjp2Ph8PpTLZVlD7fR4PB4xHtyLNptthKWqn+80kYvf7xdkgWvEfaghI32++Hx6rXSkelz0TD3KNdWOhoZQiewcR5Sho0yECXiWzs9/Y80inTMSKfRzGPfDSeTExoUMonq9LklmKmVickxK6xBLK3IaJFpyl8uFUCgkeQUqSo/HA7/fj1gsJt9fr9cRi8UQi8UkHLZarSgUCkKPnJ2dFc8FAObm5pDP54X9RWaWhnx6vZ4kX6koXC6XNOUslUojRYnjyp/8yZ9gODzsQfRXf/VXyGazct1SqYRerweHw4HLly/DYrHgV7/6FYbDQwIADSL7NQGHSfZarYZAIACHw4FoNAqr1Sq5IY2BHxwcAICEyLolRjQaRTgcxqVLl/D9738fPp8PExMTQrJwOBxotVo4ODgQmiRbXzC68Xg8ktMaDAbY3d3F//yf/xPAYVNTRjgPHjw4FSxGj5leKQ8d72kwOOyDxAiB+06LyWQa6SihPTdthHVOhN8zOzuLubk5RCIRiaDI8JuampJzwNyUxWIRg8sGmTrRz/2ki+y0o2OEU8Z1bCiaPajzbfSEbTbbSMLXmOfRjhiVarPZRDqdPra25zjY2fj+TSaT5Oq0cSJ5gJ0pmFska63b7eLJkyf4yU9+gna7Lc1q/X4/EokEKpUK9vb2MBgMEIvFRGGSWDGOfPzxx+j3D/sDcs/oXlt8p3SijM1T7Xa73H+tVhvJVWnHplQqod1uSxTtcrlw+fJlRCIRLCwsiOPNiHF1dVXeDSNK/Yxcd2NXCX4337NmqWkCit6XjLJOIi9ERaZyZP0ELak+HCyMYiKKG0yH91zMQCCAaDQqbQh4EOmRBINBsdD9fl/6ZZG+NxgMhLMPANFoVKx6v99HPB7H1NSUvLhutyteOhdSc/e5Mczmw/5QAKS1AnC6nMtbb72FTqeDX/ziF/jd734n98QK5V6vJ8qrWCziiy++kGZ0DodDcho0iIyCPB4PPB4PEokEbDab1HAwSddut5HL5aRCXFeC22w2eQcXL17ED3/4Q9hsNnlm7RkWCgX0ej2pP2BX7Ha7PcLLHwwGyGQyyOVyI3AV2WvjCje0LuTivqKxbDabkp8yeqvaq2QjQ/2+aVS4lzXlmc8Rj8dx6dIlMSw2mw3T09OYmZmB1+sdier5Xfx9j8cjrB3gKILmfmeC1UizPo41Nq7Qw9eYPnBoKKiw6CTqym+9jsbInuQX7eUep3y0kTEaIIfDAbfbLZ40afTD4RDZbBaFQkFgRDpQ3W4XyWRSHCc6phMTE5ienobVasX+/j6AwxxsOBxGPp8fif5fVO7duzfy7FT8AEba2nBfcj01FOrz+URP6gJMHc3UajVJJ/DdzM3NYWZmBolEQgzLxMQEOp2ORMx8x5omrd8FHS39XdxffM90Ern+vIZ2Kl66caFHyMjAGEob6wZ0kpif0f/VD0lmFyOeXu+wl1WhUBBuOReOURM9WIZ1mnrLF7y7uystXviSmczXiX3jAWYrBn6n0TiOI/fv30ev10OhUHjGS+X3VqtVoRM6HA4EAgHxHICjZDaLIaPR6EjtwmAwQCgUQiwWQ6lUEkomDSmVKqNHHUXWajWkUinxYHXBo81mk/wX177b7SIYDKLRaMDn8wk9muvFZ9MHmUp3HOFG571pjFt3j3ge1KRp7tyvNK6MhPRB4zvXh5/KjwQHOjuMhHgPXCMyxLguGqrR98jv08lWfU5eFhzG9ddOH7+fLVWeV7+hoxyiCxaLBfV6faS9joa6dfRMofHWMBGTyPw7Pf/B4HA0Bh2cSqUiSpCOlc/nk78zUkylUpLf1eQWY+Hji4o+D3R62fGd9T+MAqlHAIzsK905WUNkOnrWJBvmREnsoUPC/ajp7sAh8Yr/bzSix0XARmiT9GTNqjPmHE+6H09sXJgoZqM6jSdSSdPS0mrrjaSVpL5pUnHZEZRFmOVyGbu7u5JMJuTARaUHQmVbKpXw8OFD4Wx3u12sr69jd3dXGFYA5F51+E/hxmu1WkgmkwAwYrH58seRv/u7vwNwaKwYWWkv0GKxIJvNYmtrS6jIpBDS22UbCyb3FhcXcePGDSSTSfz85z9HtVrFH/7hH+LcuXPY2trC7u4uer2eeH1+vx8+nw+tVgvZbFaKTbvdLnK5HB4/fiyFaSRNAIcbdmZmBu12GysrK8hkMjCbzdICPh6PjzSIpHNAzHcwGAjD77SKknkhvmMqc+bWuN+oxLlnuLcYwXa7Xfj9fqkM5ywN3QxT19YAR+wah8OBGzduIBqNjhSfAkc1GqSYkgDB6NQ4koDXNSrzfwphOYFmwPG/rG5nBwYt+t54ticmJuByuYSlpbteMCrWP6PQyQGOog1+p06406ufmppCIpFAOp3G119/jVarJVTnWCyG+fl5+Hw+LC0twW634x//8R/x+eefy30Ch7T4bDYr93WavAthVbfbDY/Hg2g0il6vh2w2i263K5B+r9cT4hDPOQk11IU0wPy7y+UaSSkQOSA0XSgURnp/8fxS55nNZgSDQenOYWSQGRPy2sjRuOjuA/yjKfgvogNfqHGlDvN5c/om9f/zcD/PWvJhqWyJAXPxGKHwZ1xMtoahF0MogvUEbCHB9g+MbPRCaZwROLLahJo0rZYbSt/7OEKOPA8X74HKj/djvC/t0fJQ8DP0dnR0SE/GbrfLECJuSnrXjCx1yKvfq5GCq4Xryn/nqAQeACp4h8Mx4ni8qNdzEtH7UEcoRtH7UytX4zPqe9OKzrjvdQSl6zO4ltVqFeVyWaBezRYyrqmGHo5LmPK9j7vvjOvwvLU5jhlH1IAKkoZADxUjNDQYDMR46+cwRj78Y7Uejt4gVESoWtPVTabDtjCaxk4YTZcjmM1m2WOMEgmV6j1OZT7uHiTjVFPICWVqx/l5Z0cn3/We1f9mRHt0Yp76knqR0TBhat3yn+v3vPfOd8A9rnWdZsoaf/9F9uELs8Xo+Wn4yWgRu92uUJGJoWplxsXnlEduWlpvwh6JREKSeWbzYbsUv9+PSqWCjY0Nwdip8CqVCprNJvb396Xho+7WCxxNkWP4zsVkm4hoNCo0PHY65X2fpgCLieNoNIpIJIJarYZ8Pi+hMj3iUCgkBpV5E9ZKsFMAK+Pz+bxw/1lAWi6X8fDhQywvL+Mv//Iv0Wq18MknnyCZTKJYLKJUKsFisUiRJnCYV7LZbJifn4fT6ZSqXa43K8w5zGx/fx9ra2u4d+8ehsMh3G43wuGwePYej0daSKTT6ZHis9MqSb5r5ueAIxjLyGKiM8G9quEzeuuEKXTug/vQ7/cDgEQbJE+QDdZoNARG5GEvFov47LPPsLe3h3v37iGbzY5EUEYx5oaMMDINmK5pGleYjzoOttJQGSevMnfBtvtOpxOJRALAYTTQarUQDoexvLwMl8uFWCwGk8mEzc1NZDIZmf0EQIwHFWQ8Hse7776LQCAwwqSjYzQxMQGHw4GDgwOk02lJhttsNszNzck56XQ6yGQyWF1dlQ7dfA6eOV278W2zeb5L3nvvPQwGA6ysrGB7e3ukhyEnjna7XYHUtRNHiG9iYgKDwQDpdFpyVXTGeCZ55uv1OsrlstRTsfP8+vo6PB4PpqenYTId0uAtFgu++eYbPH78WBzj5+W/uN9isRgWFhbQarWwvr4uELfH40Gr1ZJeZ9oxfxE68omNiw4l9WE9zroxt2GMZvTvDwaDkRG0tNg0BrFYTCIWfoZGgoq5VquNDMUZDocynpZV0dpj4b0Rt9Q4PIuyQqHQiOLSG/9Fed5aNATAxnCc8KbZJA6HQwyZ9lg0Rk5lRyPQ7/eFtcIE/uXLl/HKK6+g1Wrh6dOnAtFQmbAFD7Fhi8UiniSZLCRSkCPPkLler2N/fx/ffPMNHA4Hrl+/LslLADJ0CDgaE21kQo0rVIg6mjOG/8BoFMJ3b4yimWuh4dZ5Qhap8VqEjDSbTMM+vCYh1Y2NDWkQyPf+bWL07LXBYf7hecripKJbuRspscbiVOCodQ+VJeHV4XAodUaRSASBQECGmZnNZpRKpZGxucBRnoKJYpfLhaWlJUQikRF9wIJbsqII2WoH1OfzCfzD/bi3tyeIBZ+R0Rb/6JzXODI3N4dOp4Pt7e1nCsj1jCDqDw3lU3+RiMSaHN4rDYzNZhtpz6JbztARpdIPh8OSb5qYmJD1InHjuEhYi8vlQjQaRb1el1wXo6DnRbkvQoZ44d5i3PQ6AUrrzFCVis+YoDRCEMeFZWzZYjabkUwmhRlBr4ADcdjOgTkDnWhmHkdTcumxaOVKGjS9/3w+PwL7aIXO5xxXGNYTzuP1bTabGB56Yna7HYlEQqjW7AbLdaJyy+VyuHv3rihJUoQZ4WxsbIx0kna5XEgkEpIDsFqtuHjxIhYXF6XTAXFePqseZW02H87DGQwOuyqTVcboslqtikOwv78v0YFuIjquMHEKHJEstGLXWDi9Vk21NH6/VuD6c1QM9LA1u85ut0veiolm5nio6LLZLDY2NvD06VNUKhVxFowwsf5+I2Sn6cxasZxm/SjGe+He1gbabDaj2+1KAWi73Ybdbke3ezSSeWJiAlNTU+j3+9je3obdbsfBwQFMpsN+gpooQ8YT34/b7ca5c+ewvLwsY4IBiKHgc7daLczMzCAej6NUKuH8+fOoVqvY2NjA2tqaOGbM6bFGw+12j0S4dHBO69x8/fXXYhhoiLWjouFErinXHDiibfMdMKKiYS8UCgKPcfIrzxPPVyaTQb9/2B6LTt29e/ewsrKCra2tZxz+5xkJk8mEUqmEtbU1eVe8bzohfr9fdAudjn+SyIVenL453aGY2Cspl8BRYzqTyTRiheXLVZUyF5GdOgFgd3cXNpsNiURCeOrlchn5fB7JZFIMhtl82MSOTfh0e316RUZIy+v1YmZmZoSym8/nZfiPNozGnMc4Qpy6XC6jWCwKUYFKS1MJXS4XpqenZT15WHW4S48uk8nA7XYjkUhIhwSv14t+v4+1tTVpm9Hr9YRdUywWcXBwAIvlcKrlW2+9BafTKUaIdQG5XE4q+gkH8d/oUefzeXz11VcoFAojNOhSqTSC1wOnS1bTaDAXx+vp/eR2uxGLxdDr9SSBrh2O592Hhjz5b41GA6VSCTabDeFwWDxRv98vBob0WXqUhUIB6XQa6+vrePr0KYbDodDIjxvjq/cX74MREs+bJi6cFlLUhsSoJHhOaEx7vZ7QfOk0drtdpNNpuN1uvPbaazKc7tGjR3J/TCp7PJ6Rc+N2u+H1ejE7O4uZmRnMz8/j4sWLCAaDAEbPcKfTkahvYWFBzmk+n0cul8N/+k//CSsrK/IchPDcbjdmZ2eRSCRQr9eRSqXQaDREMZ/WuHz55Zfyd+oCjYgAEPSBe4JrajabpTmkRmH4eT7zcDhEIpGQUghCysxn9vuHnU5cLhcCgQBcLhf29vbw+eefS72cvi/g+NzLcDiUPmyaVMGzQOMyHB6NwNZ1XyeRExsX3ThSez8MU8nMMNYHcNNp/r4RluDGpsFqNpvCCtK8dibDdbJdV7Br2jAwOm9d3zvvk/kaTQ/VVp8H42W039ARG+9Pw3M6YWkymSQKqFaraDabkgAlE4tQIZWBbuNC3jtZVEa8Xn8vCRAAxChlMhlYrVZplWOxWATKo5LkzG8eHF2zQeiR7+JlJPO5sbWHqN8Rr62LLI9jK1GMB+64A8ifaVhQw5j6+arVKp4+fYrd3V0x0joaOe77deLa6GXyPOgE62kjF3YMYANFY35KwyjGddCQoabGWq1WRCIRiU647/S55jpxH0WjUSkAZGsnRizE9vnu6K13u4fTTZmvuXjxInK5nIx+9nq9ogxZ+Mz9b2RmjitGPWJ0lDWErg2rMUomlZtnhXtF1wFSN/F7eE2fz4epqSmEQiFpm8Ncs26ESuYZ9+txz3FcJE1Hn+9cR840iieVExsX4q7Gw8jOsNFoFHt7e9je3paFMplMYhi40Sg0JDqiYEjdbrextLSES5cuodfr4cGDBygUCuL9EGZh10+fz4dGo4FAICCbkIwvo2HQm3ZnZ0cgvOOwWB4kQn2nOdw6ZCY2y35c0WhUuPG8R4arPKiJRALnz58XskStVpOOwxw4RM+dTTw5PpbeGxUkCyRtNhtyuRyePn2K+fl5TE5Ootvt4vPPP5e+XcTH2QGAaxSLxXDhwgVsbGzgww8/RLPZlBYo7DOlo7/TGmlNCtCK12QySXHdYDAQPFq3hzfuWY3JawMFHBkvTT1nV4pisYhCoYBQKIR6vS6RosPhwObmJv7bf/tvyOVyUlWu8xfaIPIejEaD/07jqB0PXRw3rpw7dw7D4VAS9HQCdM5TKxwqRnrZJG6YzYdjHyqVCnw+H15//XWEQiFcuXIFVqsVv/rVr3Dv3j0x8Lo+a3JyEtevX4fFYkEmk0Gz2cSHH36IR48eCbWerYgsFgvW1tZw//59eR9msxk/+MEP8Ad/8Af4zW9+g5/+9KdwOp2Yn59HJBIRSJLPoCN+3sO4wv2vIT+uk9frhd1uFyQEOEoXGHM+DocDc3NzCIfD2N3dxe7urhgcRjg8f9yPZHueP38eP/rRj9Dr9bC6uopqtYq9vT2B/gBI/0GXyyUFzdp5Ps6J4T2ywwfwbITP93JSJ/HExkUfEnoi3JDsT0UPljfGA6yjFn3Tx3lO/Dt7Y5HqRzYGjQCjGPLK+d30nHQeg6IXlZtOHyY+j2bR6IU/jehoiptUewOkc/K7aQw03q4TscZNwQjG6IHQuGvvm6G6ZtDo+p9KpSKMNHpiTMgycTkYDJ7BjHlNrai0930a42L0pPVe4Xdr+EmvmVGMEYPx58/bk7qOS+d6qBAODg5kHoa+B33t457BGF1rI6MVlO5KPY5wAB7zEzqi1cZa36v+f0K4NC69Xg9+vx8ejweBQAATExMjNHQj2QGAwOfdbleIN/v7+1LfNTs7K0QSu90u3jkdPav1cEolHStSo3UZAZu5cp9qJ+I00TM9eY3MGM8gcHx/NuP/ayo796neW9rAa91DVl61WsX+/r5AYTp3S0PMs6r3tY5O9TvWEZLRidF61KhTv01ObFyi0SiGw8PeYmR0ud1u2Gw2ZDIZ1Go1ZLPZEYYXMJooNC4ycb7BYCCW+erVq1heXpbCyG63i1AoJJPp2IeIlbmxWAw+nw+7u7t4+PAharWa5BiMWLZeHBo+4Kjb64ULFzA/P49MJoP79++PwAfhcHik19mLCiEJ3f6eHV6Xl5cxMzODvb09ScoRJqNHXq/Xcf/+fQwGA4Ej9IZmAjqbzaJYLErOgMaD9RZcZyZYef10Oo0vvvhCDBMhMlKfHz9+jMFggGg0Co/HI1TvRqMBt9uNS5cuCV15MBiMdKalEX2RjWkUwnI8bIxMgaN2QsSFjfAmxag0eT19uHREwXZBi4uLCAaD+MEPfoB33nkH4XBYqN8mk2kEIjMqh+PgNgo/r3NYhDLY24mfCQaDEjWMK0QfIpEIpqenkc/nsbGxMZKTCgaDiEQiI/kyRm6EqAEIG5P7lBg+2wexxocKi2eZVPZyuYzHjx+jUqlge3sbrVYL29vbx84nmp6eRrPZlMFgXMtCoYBLly4BANLpNDKZjFDueXb4LhixnCbvQno9x3vTsTaZjkoHNJOR96lhL7YJ2t/fl/6CbDBLiUQiI8bfarUKFZl6j7q40+ngxo0buHjxIra3t/Hw4UP0eoc97MrlssxmAjDi8AGjtVyMVnhWgdHUAH/XCLF9m5zYuPh8PgmjdSdNi8UiBYzValUiF+YEjKKtNxP6VHxWqxWzs7O4fv06isUikskkut2jtt4ul0tyMTMzM9Jg0uv1YjgcSotoAM94Tvpw84Bqg8MuATdu3MDa2hqePn0qkQM3ZzQaHdv7ZoKWEQDv02q1YnJyEktLS6jX61hbW5ONqyOVdruNYrE4gl9rZc2IhxucWPVweNSuh+tML5DRJnCoeHK53EhITcy3VqthZWUFnU5Hagx2dnawuroq80tCoZAMLyJkSePyPGX/IkK2IiMltlfRilwnqo/7Hu25aUdHf17/P9/DxMQEJicncfnyZdy8eVMiZm1IjF6hhu6el/OhIeOgPP4hjq4hJZI8TmNcOJQqkUhI01HWc3EN6RkDR90sCJVodhaZmkz2kxDCHm8aluz3+2JsSqWSEEoePHgwQlvO5XLI5/Pi2bOrwvz8PHq9HjKZjDhNzf+HvfdqrjS9roPXyTlHZKDRADr3cAJnSA6TGCTKkqWyrStX2Req8l/wD/CF/4CvHK5VqpIplSVLliiR6uGQE3o6J6CR08k54Byc+F1Aa2Ofd9Ak+mC+u36qUD0DnPC+z7ufHdZee+9WC4FAAFNTU+h0Otjf38fR0dFI/kbXsfFZXcS4kO5P6ItV9FrR68XnTgebrwcgvfq4d3r5fD4EAgGhZjOvrTvC8zq63S7m5uakBuvw8HCEGKGNsZZ9Df0OBqeNg8+SWeobOnDnXec2LmcdEB4gYqGEqjTWTCHRSV5+Hh+2z+fDjRs3pJ2C5sLzx2azSSjsdrsxMTEhFpxRQKPRkF5H5LxrA8Jr1nAJFfhgcNIE88mTJ6hWq9Lunpt+dHSEVCo1tufN/aCxstvtWFxchNPpRDabxdHREfb29oR2TIHjQR0Oh0JPZdTCJn2snSEkaKz+5zPgj8fjkWFkDodDck5UMixka7VaopAWFxflkLBnGa+nUqmgXq9LYpFer/Z+eT3jLh1N8MAxt6TrpYyOgz4smpL8KrhTEwD4r+7xRFnk9RBS5HhdzmbR7z9r0RkYDofSpJDPidGBNoKtVgv5fP5CsA6bl+bzefR6PRQKhS/lQXVPv0gkArPZLBEP69ecTieuXr0Kl8slZ61Wq0nXayOkyvf2ej1ks1msrq5KQS/zo/pMut1uLC0tIRgMCkzW6XRklAabK7K4l62HyMQiU436RkfOF8m5cKwHi0k1A5YwFGWE8Fyv15Mmp5RVnVogEUlHzGyky2t3Op0yZ8VsPpnZlMlkZNopjT3LFpjc16Qf4MudVLQM0jnSzN9wOAwA0vBTn53zrNdq/6IPrPGQMu9CISINj3CWHu7E9/G18Xgcf/Inf4J4PI5UKiVVr5zbzj5GsVgMkUgETqdTKIzb29tCmaXAFotFEQReL5UIvVveg85RvHz5Euvr6yLUwEm7ekJtrLYeZ2nF3Gq1sLCwgA8++AAA8Omnn4601ne73QgGg8KMa7fbwuGnorPZbFhaWsLNmzclKiFkRgNDb4NRSigUQjgcRigUwvLyMqxWK7a2toQ7T0+HtTbMvQSDQXzzm9/EcDjEvXv3sLe3J32UOp0OUqmUECn43KlUtPK+iGLUUAAnj05NTY08IyMUAmCkOpsyTPljDoHXRs9MY86M8kgm8fl84hETfiiVSsjlcnK4X8e4MBfGe6QjpuELANJN4CKLRoJFh/x+/T3sahGNRnH9+nV4PB7k83kZudBsNuFyufD9738fS0tL+OSTT/DLX/4S+Xwez549E4XOXIIRGtra2kKhUJA+W0YizXB40vHhww8/xMLCwkh3DfZyY+0VnSK2OCLLNBwOj1SYc120v10+n4fZbMb8/DwmJiaQz+exvr6Ofr8vsFU0GpWW/xwzTsJNo9EQg66JPcwVMwoiQkH5tFqtmJqaksh1a2sLqVQKL168QLPZRL1eF+SAhChGmNw/zcylMdGpA+B0jozdbsfExAS+9rWvYTgc4le/+pXksV5n714roW+EmvjgjMlL4OwiMf03ABL28kCx/T0HazEEZH0Gf3SExAOpQzmGccYoRS9CYfo6udm6eaEOqS/C1tGeiK685z5oirWRPMHr1X3E+Dm8VgqTbuLIPE8wGJT95OfrEFhXFhN/Z6Shk/b0sjQVmvkbvpeGkEqbUQWJF+Mujd/zHsh0OitxzPWqw0DPkYqLz/YsCJUV4XqMBBf37SKFjtppo0NgvActl+MungXNfDTOUaHR02xLkje0Q8hmiZQ7/aOdOY0Q0HOnATYSffTSZ5jePgkJLpdLaLx0vnh2qaSNuQNew0Xyfrw37o+Rbs69o3LXkYJRRpnnZVTBSnuz2SwOor5mnagnmsNIDjiFMPm51CHGe9V68lU6ms+Z0OZZ0fx51mu33OcX0goyAUnv0Mj/N04h1EmlcDiM6elpuN1u/OpXv4LFYpHhX/F4HIuLiwLhJBIJwSK1og+FQrDZbDg4OBCrGwgEYLfbRxLMXNwc9uvp9/tScKchMkIvJpNJPIqL4LVs+83vaTQaePHihSSMr1y5gpcvX0pCjhX0hMMoTMDpjBlW4AOndSAUkkAggPfee08gM6vVir29Pezt7UnHVEI9yWQShUJBIkZCYW63W0YhkAWVSqWwv78vBZ4+nw83b96E0+nEkydPsLa2hng8jhs3bsBkMuHp06coFAq4efMmvv71r0s/s9ddnNnD595sNrG3tzcStWnDbDw0Zx0KzqTR82qMzDyPx4Pbt2/j1q1bmJub+9JhpZE7yyH4TcuogE0mk+QWqbRp4DWke5HF79G1UPRqOfOHSr9SqeDRo0dwOBxoNpsy7Iy5v48++giPHz9GsViUs8LZSZwxz8+n3tDGAPgymYLXSLq9bpnjcDgwNTUlSo99x7a3t0danvh8PsTjcaGNa0IRnYlxjQvzJYVCQUYEa0SCUTWHp+kmvNSZmsTBKZvs5zUxMQGz2Yy1tTWkUilYLBZBHYgGzc/PY2VlBfPz8/B4PKhWq9jb20OhUJCCc/a400gE75+LkRGfv3YS+v0+8vm8zJ1iQfTrojbnPuk0Ghpa0KG7/jswSkU2Mmf4r9PplHka2WxWwu52uy3tPnjAA4GAtNzo9U6HLhEu0qOP6Y1RiLmZXPTIdTEYl4ZH6FVQIC6SM9CeMQ1ypVKBx+PBzMwMotGotM+gB8Tr0XRLHn4WWBYKBQCnkRH33efzIRqNjigSYrT9/sn8F6fTiUQiIU0Fe72eXFun04HH4xHCxdHRkeS1ONGSNR6xWAxerxc7OzsjOR0A2NvbQ61WQzgcFphjnKWnKHI/WfuiuzEYI+TfdCh4eI0yzX0k3BuNRjE5OQmfz/clo6WjvXEgU51kpewaoSqjBz7u0pGqzhHQ49X3RYNLBaTHDxwfHyOdTkvnCDKaeGaZ+7BYLF9iDfJHU+f1M+JzoKzpe+bncwy62WweqaPjHrpcrpGWSfyXZ3hc48LzrwuPeX1U4IzM9HPVJCNeD/eVTq6eAHt4eDhSGK27O7OWzW63o1wuo1qtig5g7zJGlfxORvg6H2mMMPW98B4rlcqXztTrrHMbl+XlZfFwiJXqHk/Gi9a1D6xB0PNTaNErlQp8Ph+Wl5dH2EuJRAKXLl2SaIVwAWEWWuRyuSyefDweh91ul35W9AwYxpvNJ9MEmSBkwk3XxTAJSQFh5HVWpevrLEJCPEhms1mq8Le3t5HP5wXTNZtPewpdvXoVMzMzKJfL2NvbG8FJPR6PtDthVTj3J51Oy1RQ9sDK5/NyGPm3fD4Pl8uFcrmMbDYLi8WCer0+Mo9HQz/FYlEOBVtUPHz4EP1+H/v7+9J24/PPP5dkv9lsxu7uLn72s5/BbDbjP/yH//Da+8eIRzsrlCPKmqaB0uDo5LtxscvzWXVEwWAQExMTmJ2dRTKZRCQSkaaN9N4bjQY++eQTrK2tyTC48ywqN+N9MIJmjYeGfDUEetFFkooeumasC2MOld8PQIpGuXQdVrfbFTIHR19or5n3Go1GEQqFJEk9HA6xsbGBXC4nz7bZbGJ1dRWHh4eiXOPxuBA4NjY2pLURnU1CbcwN0DDxvV6vVyKLcZUlRxQzwnuV4qVMspkr9ZV2YLhHNEa8D5YpOJ1OLC4u4r333pNuyl6vF5OTk0JdXllZGXltsVjEwcGByHW73ZaZRdVqFbu7uyOMOk160JR3zjgqFosjqIBGBs6zXtu40MPlxpxlXGhQuMF2u108X229aVy8Xi+WlpYQiUTg9/vhdrulKIv5CE2F08q+XC6jUCig2+0iFovBZrNJxSsVpM5DxONxJJNJHBwcIJfLjeQ+dFETCQH0inTidZxF48KDyopvAJJAJ5TA31ksFqysrOA73/kOnj59iv39/RHGHb0Y0nKBU/ZSrVbDxsaGhOC62JEhNg8fBZre2MHBgXhcxuQ2WXT0uOr1Ou7fvy+QGq+BDQ5Zo3RwcICNjY2xDzY9Z2MSkgdZV08Dp23lmTM6C1IiAYGvo2EBIEPTaFzC4bBERyyYLBaL+OSTT/D555+LF8/1qvukN6vPDRdhXNaQabo5OytcZGl8vtVqSSQMnLYloUOojQujDVboDwYDgcN07o9RsTby/KGcRSIRXL58GT6fD7OzsxgMBuJ9U3nRuFgsFum43Ol0MD09DQDY3NzE48ePEQqFEI/HRR8NBgMpzGQkabfbMT09jUQigd3dXRQKhbHhbTI4ja2wjHtMmWSXAV2iwUXntV6vCzpDajL/XVxcxB//8R+LUTOZTvp9ESZnR+loNCrDFUkcCAaDaLfbWFpawqVLl7C/v49//ud/FuYXnxVzU9TXgUAAExMT0nZKOxBaV55nndu4FItF8So0BGOxWMQTISVYJ870j3ER3tGUYSoI3owO47VyZCdeGg49WhbAiMegDz0Vb7vdHsmxaChEJ7246fz7uMqRXq/2kvlZhEN4z5yyx9Cf7V4YSvMaW62WdHJmFEQcmHuoIQcNS/D3hCv4Lwu2HA6H7Cspnxr6IXtPdzWgt61hPR1NXSRnYEyI6oiFHr6GAIwQBH9vfH46GathFDYDjcViIxG1TkxTSbMPlF6/SVb0PejX/Ca4WbPdLro0FKJzdTqi6vf7UtDI3BsNuNl8OoWUtSl6H/Ue6PNEqJrRrP5Ovp7njcXSZHcRpuNe6HER2rvW18H7qNVqsFqtQmEedw9ZEqDzejqPxbwzHUCeKRoaMjIBjMwOoryxESWfRygU+hLDjR0SztKnJAXQ2NZqNakVrFQqkn+lE62RJn399XpdSjkucm7PbVwePnwIACPYKTft2rVrEg0QutHh1qsWW42Q606B5mczX8BCSS7mK5rNJiqVilBm8/m8cPmdTqdUkXNzmNth0Zaxn5L2gGnRWddAPv24ix4fi88Iv9FroUdisZx0Hv7ud7+LYDCIXC6Hu3fvotFoSF8fFqQxscicCBU8lammA1utVukxRoXLZ0Bj0O+fzIW5du0aIpGICFmxWMT6+voIlTEajeL27dvIZDKS+NNzNjhagAlcesTjLqPypnyQTchDx8NAx0Q3CDQunV/RhA6z2YxYLIZ3330XiUQCwWBw5Nr7/b7U9ZACr5OmxhyC8TuBLzN19PVoR8bIyLrI4vfp2SPMN2onQZcT2Gw23Lp1CwsLC2g0GsjlcnC5XHj//feRSCTwySef4OOPP5b3acWrK8DpwGQyGdTrdUxPT2N+fn4kaU/D4nQ6MT09Da/XKwjF0dERVldXxYHgkDHdfUJDVfwZDAbY3NzEzs6O3Ne4i7kN/ewIvcbjcfj9fkFSiH6YTCaEQiH4fD6hIhN+0mMkIpEIlpeXpQmwzWbD8vKyFI/zd9rZ1U5kv9+XHCqNPruWkFp+9epVeL1e6ZCgC+LJKD06OkKhUBADxcS/jurPu85tXM5KkPEw6t4+OvnNizkr0QqMeo1GmMD4AOmNavyfmK7uVKstLd/HQ8MDe1Ydgb4ffb3a+/oqlvH79TXqxCOhJ3psumW7jnIYSVIQNOzCz9XPhvCHXvxcGgCG3dxXPQ1RP0/jHumEKX+MbJ2L7Jter4qKjf//KiVv/GwdqTJPFQqFEAwGv0RCoFJuNpsjbEijsTBe73mWjh4o88b9/iqWMe/zqvPAZ6vp/ibTCbMtEolICxx+xlnRiP4sfQb1wC0tN4yWCAcxGtcDCGnsuTf8fypbfg/fr69h3GWEXPXSlH2eT23MjX2+dOqAJASXyyUONc//WUvfm7GEwBhZEyYk45XECzb7ZQEnz75GV4zRuqbun2e9duNKrUDY/399fR17e3vStsJqtcrAL7K/GN5rIeMgMM6KOD4+RiwWQzgcRiAQQDwel/C33W5LCK7JBHpwGB8u8wfMC+jq5unpaYTDYeRyOYmyeG8UajZ41J7jRfItALC+vv4lWIzsIz05k5Hb3bt34Xa7cXBwICOjh8OhdKH2+XzY29vD9vb2iDFl6M05JEz2eb1eafXB50ihYsTE+hTOZiGllNXRuvL48ePHqFQqkrglrZvPh2wV3e7GOOP7dZaOHLTSMJlMAnnxkBFWIfOtWCyO5KpetZiTC4VCWFxcxPz8vEC+wClcVCgU8OmnnyKVSiGdTkvUwzoiRoPcX34278OY5OXS8+k1g1En3i+ydPRmhNnIFNSIAbs/HB0d4f79+6IIeU2ErXh9jMb197FMgXVCc3NzmJubQ6fTkRZLbOXC80tartfrxebmJgqFghTNms3mkTkkdJ7C4TAsFovUiLB6HoD0QNQEg3GW0SnW95nL5VCpVBAMBrGysjLCLqUO1PJAtIateFguAECQDJZm8Pcmk0mKoPm9pA0fHh4KkkMKNveFUcn+/j6cTifefvtt/PCHP8TDhw/xy1/+Uog6jGASicSInHBUeSgUklHW51mvVaHPG9T5FgBCI6awsoLeZrNJYsgYuRCaYWsEKnmHwyFJvFAoJAqi2+2iWq0ilUqJZ88cEClzPLhU0j6fD5FIBNVqdaRp38TEhMBIWtlrr4MCxJyNpgaPs7LZLIBTpc5hPwAE39Rdfbe3t6UpKOfec1gVqbG6Lb4xKnM4HOKhENqpVqvIZDIjXja9KfbLMplMQjdmwpuYLBVnu93GwcEB0um0eEJut1tGKevcB6Me3tu43vdZ3jCfCR0BLm0w2ZLmty3uoc/nQzKZRDQaRSwWg9/vH5mWSpnb3t7G/v6+jBag4h0MBiOesjGSYwRJTF4vyp9WjIT+znr96y5tSIy/470xr8cZ7S6XC8+ePcPu7u4IXVYXAdJrPytyI82ZsjgzM4Nr164hnU7LtE46o5Rxlh5oefR4PMJ61LVS9Kapb1jfpsd5MBJgacJXEQHqzyBMCkBYhrr7w/7+vsgg0QMyVC0WC8LhsMC6wKmTS+ecDtRwOJRpqPzeXq8nM3HYU4yQNPUk9WuxWITH48F3vvMd3LhxA41GA59++umI45dIJBCPx+UZdzodaW2ka3HOs85tXPToTnonDMN4iKiQmRSi8WGSiUqAVt3n82FiYgJOpxP7+/vi9RaLRUxOTgpTZX19XdqvMALR1NTp6WmJRNrttkzCo2DSkwcgrB4aG51UY86HSXUjBk4FPs5itTyplQzzzWaz1JoUi0Vks1kJozmtkgeOQthoNKRJZzKZlPYXNM42mw2hUAhTU1PSksc4UIj3zesJh8NSgLWzs4NmsykJ7Wq1iq2tLemCy+epC2npcYZCISEa6Gd9UUjCKNBGKMsIIWkM/lXLqPQ19ZfKQRsWDTXoJosc4kbHQENxRtaUhgl1qxo6BroanUZfE0oustguh1ELe3LxGXIfGJXQeBAmZZQyGAywtraGTCaDra0tIZPwXrmPlItQKITvf//7mJ6eHjHaLAfgZzE67vf72N7eFjILcOJA5PN5QTK8Xq+Mlub5ZoTp9XqFgEISAWVR525fd3EaqiYJGQ1qvV7H7u7uiBHUFHMNEZtMJlSrVWxubsJutyOdTsNut6NYLCIUCmFiYmIEUeCe8vsoL+l0Gmtra6jX68LiY5EnWXSc0ul2u5FOp9FoNLC3tyeQHPUlozB+h0YhSB8/b+70tcYcEybS43b5Qwov4YpisQiz2YxAICDQlO47ZLGcDMm6fPkyGo0GVldXcXx8jFQqhVgshitXrsDj8aDRaOCv/uqvpBpd059dLhc+/PBDLC8vS2NJAMIFT6fTwp+n553JZKSvEq9b1xLU63XZcACCqWvseJwVCoWE6uf1eqXdORtYzszM4Pnz5zJ3nZW5TqcTw+EQ8XhchoXdv38fuVwOwWAQCwsLqFarQkGmhzc5OSntyIvFokBvnU5HDj0Pm9frxcLCAm7cuIFyuYyXL18in8/jnXfewe/8zu9gbW0NL1++RKPRECoyk/0AhJ+fTCYxMzMj1d6kU2uIYNzFg6o9bTo3xLM1XEryxW+iTmqsmUaW38NaHu4/yRj0Eg8ODnB4eCjt96vVquS/dH7PaBS0waUDw2tmhMyREvTkCTcZEYDXXSsrK3IfZBDxM3kmSUHWP4w6GAF0u1189tln0r+LLC7eK/MFLCOYm5vDv//3/x7vvPOODBkjTbZcLuO///f/jkePHsFkMiEej6PT6eDhw4doNBpi7NrtNg4PD+WshkIhFAoF1Go1cWzZbDMQCIjzwwi60+nIOIFxz7DP58NwOES9XpdzZHQa2OlCy5jP55NiZG1cLBaLjAmgLqJeDAaDuHbtGgKBAHw+nxROaieeEe7Lly9x9+5dVCoVMQx0SnhOFxcXcf36dTgcDty/fx/7+/vSqonGxWq1yvAxBgNaz/v9fkxNTZ27y8ZYsBgtqPZG+Xt6kMbiGx4qo3Jg+Gr0BpgnYWM2znHmQaTSYCVvt9sVvFr32+J/81ppNGggz4LreA/83VeV0Of9sj6AHh4L0EgF1j9UnCwmZesL7VnzeWhyBb1iOgTM6RDC4Wt09T/zTdFoVJQcnQkqTUauxgS29ux1Xkf/jNv6BRiVv9+0aMR0ovq3LcquzWZDJBLB9PS0QLJ6kQWnaZpnMZWM36sj31d9t46SdeL3q0zma1ownSat7Hg+aaTJSmRCXcN1dGaM0Ro/nw5dLBZDIpGQ+jXm8chu4jhe6gzuq2YXago9FTlwWoOmzzxnTelENeWWed1xHR39HHQEoVME3D/9NzJT9X5rcpKmz1NHsMyCssXITBMZmBvm+eZ7+BwIR+vzynwfdSONIq+ZOlYz6/i+o6MjlMvlr964sE8OldBZAk9KKBlOfJh8ncbtmRjVCWl2FZ2ZmcHx8THu3LkjRobGirg2N2R9fR35fB7dbhczMzMydIgKgFQ7wkwrKyuIx+PY3d3F6uqqKAhCEZx+yRbT5JlrD3Ocxd5iHDTEtiJmsxl7e3s4ODhAp9ORVjb0ElmZHIlEMD8/j06ng0KhID2/NAzBnEwkEoHNZpNOBdvb2/Lf/X5fxhbzftk2IhgMwu/34w/+4A9wdHSEbDaLjz76SCje3W5XDD0NIXAaorMliGbw0EiybmHc/TPCecDoAefhoXwYa3zOWvw74cFAIIDf+Z3fwXe/+11EIpGR4svhcIhMJoNnz55hc3NTvP9isSi92oyGQCsinZPQ12yxnA6QoiOm82d0gnQjxHEXnYt8Pi8FxMZaMjaPZXdknTet1WrI5XIjTpiR2qsN1/LyMv7gD/4AyWQSgUBABn49ffoUXq8Xc3NzI/NJWq0WcrkcrFYrYrEYkskk8vm8wI8ARG/QoeTzaTQakqOgsea5ICGH8jvuYl6CURINInACxdlsNpn1omWAhphyCUDqAbUM0qDq3ObR0ZF0w2BdGf/OvSGxhPdIXcX9oq7URexWq1WaBOv909Eezzcd/83Nzdca+/BabDEaFxbKGT1/Wlft7dNjoFetvV1irlQSTPB7PB60Wi1pYaLbxgCjlMJ6vS4Kk/MO2FJBP0wmlpkQJwtDY/I8YNrgsIXDRSMXKkd6IxzRajaftoHRuD9DZA5H8/l8wvsPBoNyYHQERIYIC6JY5Md5G3xefI7Mzxgjn4mJCWkeyLogXcxHWeBzowAzytFFrzond5FZGsbv1EsrXZ0bM+Zbzko4cz8oexMTE1haWhpJvFOO6vU68vm8GBPtcLzq2vR3G2VI5174/LSBovIy4vXjLnr/7XZ7hLlnPK90/iiHuraNiseYC9L5SF6ry+XC3NycQDqE9thS3nhPxPeZtGb/LGNUyN5eek+p5Pk8mKcEIPdDKGncZfTk9bVT5rk/wCiBwpiv1XCtRn+0waGOBSAOp5ZHGiAW8mrZMZZk8N51WYZ2Wng92ukxIhMaCj/Pem1YjA9HM4IohLpFs256qMNa5mFoaDiYyO/3j9QXVKtV1Go1CfOIuzIJziTX/Pw8ksmkPGC2gWm321hdXcX6+jqi0Shu3LghNNu7d++iUChI2K831khOoGAyVL/IMpvNWFxcHJmBrcNQKhn9es4IIVHBZrPh6tWrWFlZQa1Wk3Gmdrsdx8fHMl+8WCzKdD56ebzHo6MjHBwcSPTk9/uxs7MjQ56oNLa2tpDNZsXwaThNHwANjeiwfzgcyvPShn6cpb1lnbzn33hvGvvnfWgvUhsBvs/r9eLq1atIJBKCyfN19XodH3/8MdLpNFZXV/Hy5UsUCgVpG0OIksa53z/tsm28dq2QNG5ORXlWZGKsPr/IYlRpNpuFzsprIryiCRo6GmZOiuMVOPEwFArB4/Hg+PhY0Areh8/nw9zcnLR1cjqdmJ+fh8ViQblcxieffIJSqYT9/X2RIxKBmK9rt9sCZRcKBZEpAMKaPD4+lp5aOlqkjuHZog4adx+1ngAgRhbASKcR/s7o8OicIJc2kFp+gRPm2ZUrVxCNRkVnakYuC7N5b8wVk9E4HA5HyjMeP34Mq9WKdDotutUIyeqlnf5xcs6vXefCUJTYIPMYTJrpOgOTyTQyu6Hb7Yoh8Xq9kgxkO3m+j5x3QluMlhheUsjdbjdmZ2exuLg4gqeyfqTX62F3dxfRaBTvvvsuLBYL/uqv/kqaDBpbX/Bh6Ietc0EXMS78joWFBdy6dQtra2tYW1sTqqFOLmtee6VSkfuamZlBIBDA8vIygsEgstksstksarWaGBfCavV6Hel0WrwaYz6L8AEjmGKxKMaFPZHYdVXn2VgzQG+HcqGVIHDqjGhm4UUO9llCbVTUGlbSDDLj4dG5B+AEzl1eXsbk5CRCodDIQWo0Grhz5w4eP36M/f19pFKpkWicSX9Gmsw7GeEiHf1qw3wW3KoN4EWhML0qlYrsDaN8YvDGTgqUQzoghEyTyaTUQNXrdQQCAUxPT4/UaTHS8Xq9UldGmWIH8EePHuHevXvY3d1FJpORfSCcQ7ljB2SShLSRDYfDuHbtGhqNhgwL0wpdV5brfM64i7LMa9Bzi3jGCDVr+eKzpwHiMkazWk6HwyH8fj+Wlpakwp9Iy2AwkJIN5kbJFHW73RIhAhC2X7vdxtramjiX1NM6T63zqNqR01HM66zXzrBqDJqbxvDdGKbywXKTiZfr19MjohdHeiEZSPQEmNSmwLhcLnm49FB4YOlBsQNqo9GQJo6Ehyh87JrKXlrGFt7s90McetyDTpilXC5ja2sLlUpF5l4Tow6Hw4L1s3hTQwGahUL40OfzCXOO0FS9Xhe4UCtXo3dMj5XTBcPhMHq9k+mKvCbWKfD6aWwp5DTmFotFkoraa+RrNbY+ztKGXRsxIyRGT42JYhbV6XvW8sh8EPeeSnA4PJ2LHg6HMTk5KXVWej+dTif8fv9IAtR4zfSez1Ik9H6NEISGoWm0LlrIS6SBzhyjBeC0KSOvgfAyFTPfrxsaUn7YXTwYDAoNmHLAvAFRi0wmg0wmg83NTSnCfVVESweG55H6gDLFDtwkFujFe+N98BxchFRi1GPUZVon6DwMlyZLULb0+6hHadjJzmProrNm0BwfHyOTychUT8o7kRZ+Lh0F6lfj9Wo5NBKuqKP1eXudde6d1vghL5xePqMAzQyiodGKWrOjGIFQqAl/sTcPZ7own2K1nnRU5Uax7xE9G1ruWq2G1dVVFAoFHBwcYDAYIJVK4f/8n/8jh0EzpqLRKH73d38XkUgEv/71r3H//n1RoHa7HQsLC5iYmMD29rb0NhpnES99+fIlnj59imAwiPn5eQBAKpVCo9HA9evX8f7776NQKODnP/85yuUywuEwvF4vSqUSNjY2EIvF8N5778Hv94tyc7vdkvRcX19HKpVCuVyWvX8V42g4HEqr/rfeegs/+MEP0Gg08Pd///eo1WoSiVJpm0wmSfRy+Xw+LC0twefzYXd3F+l0WkYqAxBIjn3Hxo3+qBSMMCaAEfkijTsej8NqtUr3Br34eo4ujsViWFpawszMjJAhms2mDK4jCeTo6Ahra2vyGYSXONaWvae00tAFkNoho+K02+0Cd/JZcVYPnRu32y3jlC8SxXAOz+zsLObn56VXWKfTQSQSkXNMx4LXwNb47MChO0nQQPh8PiwuLsJut8vwKsK6hLiGwyF+/etf49e//jVKpZK0gD+rZx+VqW7+yF5cNPqZTEagPiNrjdcPnOaASLsdd1FuqLc0zMVnq9lfvAddn8IuDoTC9f3S2SXDLpFIwOPxSONUHdWUy2V88cUXyGazaLVaUu5RrVbFWDCHS/Ycv5N/597w+7Uh0ew8o1N03jWWGdcXzwt7VUilfzQjQiet+XdWJ1OBMSTTRUQ68amptLS03W5X5jbQ8vJ3+nDzszXll5utsXxNB77IolAwwU5Pnvui75X32OudtN5mkztd2MboQM93Z7RojC70NXDpZ8XIhDmyV8FJwCmFUn+mJhHo1/J5878v4jVqmEFHKsZ/tZwZiRhGedS1LDoC5nfoxDQhXSO8RXnWRtPoYJ21l/qAa6/ReJiN13wR40Jloa/lrMI+fr9mZVJ5kxCg4dB2uy1QENlv/X5feoMRQu/1eiiVStJ1Qs96f9Wil6/3XRefkhqtr1vDjvo+jHIz7tKsLn6PUTnrZ6b1ifH58nr1vySXUN7OcsgGg4Ek8xkV6ihTQ+uUz7P24LcZDv3615W91z7tvFDS46icCYuwnQOpsuyrQ8G0Wq2Ynp5GJBIRGCoQCAhDZ29vDx9//LEIE3sc+Xw+KcBiBTo91HA4jL29PayurqJWq4nHCUBgDipcGg8atkajgV/84hew2Wzi/WtYhwO2OGZ3XMEkpEWvhi1EiOt3Oh2sr68LZm21WhGPx/HjH/8YH3zwgShCVtMzcmNkEwqFxKOjl6znvxghMQrd9PS0dEl4/vy5tNPR1ffEw2lsPR7PyPOkISQEQgq4yWQS5aG98XGWJpJoI2L8l99VKBRgMplGukDb7faR9yaTSczOzmJychKNRgP5fB6hUEjulXlAOgE0wrwG4tcsoDRCgKR1Go0K4RFGg+xWreWThoCOlh4lMe7iZ+/u7kq/Nc0y0q/RcAmLYtmyXV+n9sKfPn0Kj8eDb3/727h69SqmpqYQDAbR6/Wws7ODSqWCra0tHBwcoNFoiJydxeAyyikAyQlFo1G43W7U63WZicS95F7xGVNmqHgv0tnc6Lxwv4DT/mU8A3ReCInqejven/5vnp/BYDBCotDGi6+lYx0KhcRAc6YVX0M94/f74ff7RyZ76pwRUR8NXWpWpzYqrwuPvbZx0R42ZwNwGBUfLlkLrJqm8mF4Gw6HkUgkUK/XUalUEAqFsLKyArvdjs3NTWxtbcHv9yMWiwm7LBKJSFUxE5LMObAdCZPbNGgApEaFYbmmdRKjXF9fFxiMAkGFxUE/2kMaZxk9LCYogVPh5yFmHsDv9+Pq1av48MMPR7BTNr3j3hPaabfbePz4MXZ3d5HP589kaGmhNpvNkqTt9XrI5XKyd8bwWRe2WSwW+Vxd1KWLs4iBU0kRCh13aaE2GhcjbZJQCnBqzHlotCFiryy2IiFEw/eyVT/v0Ril0Oga36c7Bpy1/7wHfi5zQsbXm0ynQ8K0QbvoHpZKJaEDGxl3+rt5fewzx/OuoVaNGBwdHcmevv/++9Lpl4aEOQJ2BqBBNX6vcZ/o4NDpcrvdiEajAE7rx+g4aENlNMTas7/o0pEkDQmhMn3dhMqMcqDfr88I30cWIq/b6JzQwWe7HFKEddQJnI6mMLJdqRM5nIxMO32ujJGg8b9/23pt40KBIvWQHiHZXfQuAEgyTdPk2J7E5XJJtW65XMbOzo7g5QsLCzJSlXNZgNOJjXydxXIyF75YLErhJD0XekRUDqFQCIPBQFgtZrNZqJf0wigYmnlEb4LKY9zDzQfGe+dh5EM2mUwIBoOi6GkkCSPkcjlsbGzAYrEIg0QbQwo4I0Cn04nNzc2RrtQUFj0ulR4g8XTOwCGjRBsZY6jPHBbzLCQ8BAIBzM3NwWw2I5VKyUydixxsYzhPuEUfcCMUpd/HAl1NmQdOlBP3nZRZFpiVy2WUy2U8ePAAqVRKukrr6IlGk3Kn5Unvm85P8m+aSaevVS8jpHYR48K9I+RCo3BWTk5H7zoXRKNEB4QQDiOYbreLjY0NfPLJJ5iamsLVq1dHunDo6vPfBMMYr1vDeIx46KwYDRJ/Z6ScfxWLRoCePhcjdB09GOtzzvos/Te+5/DwEP1+H9FoFM1mU5x5k8mEra0tbG9vI5fLyQTYTCbzpc/lfYdCIWkRRRYZjbsurDSiG2fB6a8rf6+d0OcGcJ4FcBqS6rCJfyPbxeFwIBQKyUxnn8+HTCYjzCSz2SzMm+vXr48IDOs5aKA468FsNmN7exulUkngMD54QjM6b8EQn91+jewvHdVws0l/1oWV4yx6vKFQCJFIBJVKRQo9SXSIx+O4cuUKqtUqHjx4IOOC9/b28MUXX+DP/uzP4HQ68Z/+03/CzZs3pdAMOFFCdrsdb7/9Nm7dugW73Y7PPvtMWnCzU4HVasXk5CQ+/PBDuN1u7O7uolQqSaUv81O8Vwqa9oT0s2m329jb2wNwCl2Fw2F88MEHMJlM+OSTT0Ygs3H3Tws//+U1UYloCMv4Po/Hg5mZGQAnpBEqplqthomJCYHH2LGAvazS6TTu3LmDjY0NgS8JFwKQNilkOeoDSOVDuSVMR6iMe2w0hMCoB3oRg6IXDR2jXV47Db9WKGazWRQaHStCK/paWbysI9aHDx8ik8ngnXfewdTUlBgeFkkyH/q65Bjume6fZaT98j6N+T7tEIy7+B0apuTnUZ60odZtYF71WcbFriNbW1tIJpOo1+sjMNWjR4/wd3/3d8hms3jw4IHIpNFIMbpJJBK4fv26kEHY0FKPMOZ7eC/UgdrojLPGgsX4sCgcOqFkxBS1USLmyY7Ex8fHYnwYITCJpWsJdCJbd64FTg83q8ONnhjDQQqDDlHJ8dYHWFv9szzgcRfHwrIeRXvxhFvY3poHfjA4mVW+t7eHer0u3Z6pAInn6odP5ep2u6V1Njsi62I/KmJO9NNet37GXHyeOlfA/dHFs9zjarUqUKRuvzPu+k0CbvS6eLA0pEIIi9EDnyf3kQwoEjiMUZrRCzWyvrTs81/CmMCXe50Zr82oHM/C5i+6eM30sInd60hdfyflRTOieJ1alvg+yoXuAkCPuVgsypyg18HutXOj917nPHhPxvNqNJb8/VexjM9F6w8+P57F13VKKWvFYhFra2uIRqOYnZ0VlCGfz6NcLovj+6poDzhx8vP5vOgAI4GC+6ZlQ++zfu6vK4evZVwocHr+CnBqKfk3rbC5wcfHx1Kol8vlYLFYkEgkMDExIb3Ier0eyuUyHA6HJJZdLhfeeust+P3+EWYPDRBhHFKPAYwcCjLHaLl5qJxOJyKRCAaDgTAu6H1R+fKgGJtfjrP+6I/+CL1eD/fu3cOLFy9GIgG2Ms/lchLi0mDfvXsXL1++xOzsLP7kT/5EuqWSMsuxzqyVoCJMJBL49re/jVQqJZ1atWE+Pj6G0+nEzZs3hYa9vr4Ok8kk9HCdkGa9C7s6k/3V6XSQSqVG5lXk83n8/Oc/F7KHbuk97joL/9XKXEfOGtLRhvvw8FDYdIPBALFYTPZxa2sL5XIZS0tLkpD3er3w+XySFCXEazKd1qYQGgROlStzFTRmw+FQCvx47XzuhF75vHk/2njxvl/X0zcuJohZREukAIBAl8yPWq1WGWDFvJLeTw6gYqslygadwHa7jWw2i0ePHqHdbuOzzz5DJpNBNpv9EsnhNz1vzd6k08BkN9EHvTTkyMQ+HaKLFvLqa9PG6izHgLkhTWp6nTUcDvHgwQP8l//yXzA1NYU//dM/xfLyMnZ3d/HixYsRaPE3GZcXL15gf39f9Bv1nZYtOr10MllgqbsPjIPanNu46INspHjq19BbNS79YDnkiglCwiYMv1lhXigU4PV6R5S7LsSkB8aqaD5A9hRiuM8DY3wQZP7o/lBcOlH9VXiOk5OT6HQ6YhB06E5FzbnsFotFYD9O3YtGo4jH41Lop6mHZCbRS+r3T/qNRaNRaT6oISQNL7HXGveM+6K9cq3USCIwdhLQ+0cWoMViQSwWE8LHRejcZ3mJZ62zoCU6IqS369eQ1komG/N2PIg0VnRYtII1enpULPp1/G5NItGvO+s+9d+MjKeLKEadGKcs6nIC7p92DHWNBl/H/WDpAPN5dF50yQA95kKhIISRceAw/f387t+UB+V96Ajsq4IYjZHlq/6uo7txVrlcFp2Qy+Wknooy+qp7PyulwOsBRskxxkhanw+e13Gd6nMbF61sdQGQEetjAp2eKmmWLGCiQiTnnUytarUqiWwAggv2ej08f/4cqVRKZpq7XC5EIhEAGKHf6nbaFCYWcFFZE2LrdDoywVIXG/KQ0GujYiRWPK5wZjIZMaK6SpfX5vP55P7ZjUBPp8tms/jpT38qxWrBYBDLy8u4evUqWq0WDg8PBZ4aDocyTbLX68m4Z0Z+HOPr9Xrx7Nkz/PM//7MMfWJOxuv1IpVKIZPJiODZ7XZMT09jZmYGxWIRmUzmTCFntELv1+12j0SP4yw+G82aMzoMOueiHQr9bOmRWa1W1Go1bGxsCJ27UqngyZMnAjfQ42TLl2g0KgY7l8uNtDPn9+ioSdcbcQ9dLpdE/nomPM8PDRCVO+XgovIHnObEeBbZQmk4HI4U3QKn0CYVEuVTF1jqXmS8X6vVim9/+9t46623xDhx4BdZjhpuedWis8IhZb1eTwwTI0VGhvo9XDoJrp2krwoW4zLCsfx/RoHGSFu//lWfp//t9/solUr4y7/8S3z88cfSaUTnFvkvjS71npY74MuMS+DUCHMvNSzOZ08HTNcDnme9lnF51aZx8e9kkFgspzOteePD4VCEhNW9NDiEGDSdr9PpYHt7W9q0xONxaV3Bzyd8Q8HlogJiOxAaDYfDgXw+j0KhMML44CGhUWEdjdvtljqVcYWTUzZpAPU+MinKBoY0OLolR6FQwPPnz6VxZSwWAwBMT0+jXC7j4cOHqNVqXxK0TqcjzDsy7QKBAGZnZ+FwOPCzn/0Mn3zyiUAlpCZHIhE0Gg1ks1kRNpvNhmQyiUuXLqHf72N3d3eEeaWVvMfjgc1mk30ksWBcaEd/NqNdbdSolPUce2PNBpUaaxLIkOPUTYfDgY8++gjPnz+X99jtdiSTSaF7RyIRIUBQVo21KVS4dKKAU8+QM0xI7zU6Z/pfs/l0mBvPykWgMUYYpLCSLagLIrn6/b40kdSdyulMsCeezqUxv/nOO+/g3/ybf4NyuYxUKiVKitCgVoq/7TxxGqsuGKTMaQakVuzcO0KX2un6qo0L11kGRifGuTSEa7wWI8zLz6tUKvjZz34mzgl1K1+nzzzln3JJQ8Tr0d+jr52lAzraZ0BBZ45OyXmjmNfuiswvPgsu4gEaDocCQdDYABhJDPJvxF/Pevjaqg6HQwnvWq2WeJ9kNulDrmc6EPdktMUaDQ21GR8yIRQaO865uMjhZisaYtvAKYOMo3OHw6HklmgENaODwlGv12E2m7G6ugqn04lms4mdnR25Zn2NpNSy15PT6ZSJn1Swg8FAClODwaDAb/v7++JlU3lmMhmhGJPtxk7C7CnFGg8+c8rLuPAAF+9NM42MIbtRnvR7dY8sQoi93snI652dHdhsNomc9XcxCU2Dobs9nEV84HdrT5LfSbnT9RhnKRx+DiEsTQsfd7ElD/M8PFP6POhrYr0OlQ+VlYanjdBPp9PBy5cv8dFHH0nhbC6XEyeKi7TYV0UT3BMyzDQjSitPHRUAEKdMR7bUC7yncRehYyOb6iyjpY2fJjzQEJ/VU80YhWmoivk86qSzZIHP0UjO0NfJz+IZ1dRpve/a4OhSDeaxzrNMw3NKK60YL0zDDtwAUgMpOOTBa6xdP2x9U/xv48My5ibozU1NTUmB5GAwEC9JW2e/3w+fzydNHweDgbRRIexh9Dg0pm6z2TA7Owu/349MJoPDw0PZ5NddFExde8OiPnoiTCAzYrLZbKhUKmg2mygUCtjf3xcDpGexMFKk8uP+E2pkiByPxxGLxeDz+TA9PQ0AePr0KQ4ODuDz+RCNRhGJRPC9730PsVgMP/vZz3Dnzh3JadFRYFK82+3C7/fj9u3bCAQC2N7eFiNKL97n88HhcEj3huFw+KVeX+dZxpyf/p0RCtPypN9PpUiokw6DhrI0jMaDR7ljx1v9+Tp60d6fyXTSF8zv90tLI+0EaZnTkLOGJVgsTIILqfNGpXTe9Y1vfAODwQAHBwfIZrMj3qkuPAUgPc+sVqvAhLxnnnXuu87BWiwWGTXMDuedTgc7OzsykMpsPmkoSmjxLA+en30WbHhWvoOfOzMzg2QyiWq1it3dXXHOhsPhSJRFJ+J11sLCAobDE8iZdS5nXb++D30PXq9XSESaDm+8F76exojRusViQbPZlLo/434Y36+vg783m82iY/QcGO3w0qEwRtJ6nUcHvlady3kslsYKqUSNYTC9CB1CvsoD4O/4eYTKdBdUDavpw3dWlEEFpCMvXgcTnNo7psd6Ua+b13tWAljnr/g92sPVWLjZbBasnAWoNptNFAEVGNuiAxCIiqypVqslMJ9x3DM9FqO3yOsyQgzGkN9IhKDSHVchnrX42doZYMTMZ/qqCJPyQY+SP3w+NNh6P+gMkZ2j8WjjATTKrzG5fxYkpD1KPeFQG7pXnY/XXXxGlHNjW52z7oNKzqjM9Z7SOWIk3mq14PP5AIw2u33VNRmVoZZXnVs5C2kwwknGfAL/2/j3cRavzel0vrJ1DZc2EnRqgsGgVNRr46KvSzvIWm6MRtb4mrMcX32vxns/az/ocGjZ4N9tNpvksc6zXouKzINmFHR92HUSiAf4+PhYrDYAGbbEg8ww/VW4qDFE1OE4h2npjp98P39vtVoRDAYBnE6CpNHQxm52dhYzMzMol8vY3NwEAPj9foTD4ZGCs3FWJBLBcDgUz0MbQZ0fYfKTrd3peRHPDofD+JM/+RMsLS3hV7/6Fe7cuQO73S6UWu2pFYtF+Hw+/PjHP8bU1BTu37+PR48ewWKxCOW5Wq2KIanX6zg8PESxWITT6cTh4aEkdUnQoIfLkLrb7WJtbQ02m20kIqP3o5uI/qaDeN6lDwOfodPplKQvr42epT5AGmrh3jPSpgeqIQ/KBYkVg8EpjVMnSY0GlvLHdvT8DBa8ApAEPWWeXvfk5CRKpRI2NzcFVtFG9CLGZX9/HybTSUHplStXUKlUkEqlhHrM88r9YZ/A2dlZxONxIc20221kMpmRyH9mZgZ/+Id/CK/Xizt37uDZs2cwmU76s3GREamjOBomnYe02+2YnZ2Fy+VCJpORoknj89d7wmeWy+WkZRNhPCOkP+7K5/Mwm82YmpqSabYbGxtfavfP66PSj8fjCIVCmJmZwVtvvYVWq4W/+Zu/kXo/7g1nYJFmzLzRcDgcmcnEcg/KBwe2NRoN6RKt79fI9iPMyu/VDgwh+ePjY1SrVUEr2Bnk5s2b52Z9jt3+xWg9tYerPUl6fQzxmcinB8Xk7G/yTPQyWnPO9jYaPCrmbrcr4TnhHF6//i6T6aT9yszMDCwWC3Z3d0eSWEzEjmtciDcTs9TXS29Bt8XWeDQPIJtXXr9+He+++y5SqRQ++eQTuUY90oDYssPhwNLSEpaXl7GzsyN7RSeAERqNp9lslgJINsXjZ1MJ6KLZwWAgrea9Xq+wxJhYJBX1ol630ePSn0ePinCtUQFp5QyM9l3iQTFGvlou+Dpj8avx+ozeJTFqDVtyD8+C7/x+PyYnJwEA29vbX/rsi3rd7MsXDAYRjUYxHA6RTqcBjM4coZEhjd3r9Uo9GokIhLSomBwOB1ZWVhAOh3H//n0pLTDuF50YYxTE50AHJRAIIBAIiHHWUelZz5TPr9lsCtngVUpw3D1kLtfpdEqbJqOxMl4jI7pIJILJyUmsrKygXq9LzZF+H2FyXf3PKIK6QaMrfA0JO9oZMUY2emmjTnnU0QlZvfoerFYrotEoVlZWzp23em3joi2hjlz4/xo2ASCt2BllMFmui3qsVitisRhMJpNUqGs8kZtOQWaPI5PJdGbEYzyMLLak10qlqCMHs9mMQqGAtbU1aUnDw8cQ9iK9sRYWFkaSwhqSYeRA6I+4KBU5FR4P9927d1EsFvHs2TOhD2uoBjgRIK/XC5PJhPv372N3dxe7u7viPRvpoGSsAaPTRvnfx8fHYtgSiQS2t7fx9OlTOJ1OXL58GR6PB7lcDsViUVr99Pt9eZ5kKF1EOXIZo2YyBnXEYayHAkbnluvPAk69QQ2/8nv08wK+DP+9KinNZ8ZIQDtGhHqoWC0Wi3QNrlQq8twpdxaLRRLy4y7m/RqNBg4ODmSgnHYCzyJK5HI5iWh4PXRgGJENh0N88skncDgc2N/fl1yfJg6wCwI/n44VO08QyjWZTMjlcjLCmzqCrV5otFicS5jJeD4ZeeoBcL8pR3KepZ0pPieT6TQHpV9HKjpnrOjIj7C0lgFji31G4FoXannk70nWOcuJ45ng5wOnZAJ+t9bf7XZbWsQY4djDw0N8+umnX33koiMTY/GcpmJSKfOCmR9gxa4mAtCzCwQCmJiYkBCNm8QNoFdKT7rVaiGfz0uIZ2ROGPM8g8HgSz2R+Plms1keajabRTqdHsEud3d3BXph2DrOWllZkf3hAC1CN7p+gYchEAgI/k7qJ5P0v/jFL3D37l3k83lh0GnaKIWIExI//vhjqUEwTj3kTyAQwMzMDIbDoYwZoAKkF+twOPDuu+/i61//Ov7pn/4JL1++RDAYxPe+9z0kk0l89NFHKJfL0iRyMBiIZ8x2NF/l4rXTU+XvuA+Uj1cZACofUtWZLzDmoHT/JWB0UJ7Oh+lnCJzm9+gEaZnk5/Ba6Xzl83lR3oRDgBNYNRqNXsg4k8Jfq9WQSqVEtjTEwqU93lQqJTAtHSQalUAggGAwiE6ng5/97GfSm46KlDJeLBZHqMj8lwSARCIhYwC63a40b9SRO50l7g+dGOoRozLUNXdsnUJFP+6iTGez2ZHv4Hhx7pFunFssFlGpVLC3t4cHDx4IqqJlQEffOppmB4JX5VUGg4HU+p2V26Rs6rOva2CMqQTWJWqDxrW3tzcSUf+2Nfb0JuNBMSos/Tod6ehDazwo2ii86vvO+pzfdo1nQTJnvc8IiQCnCfhx4TAuzRk33qMx6gK+DFPoe9GCqz147W3r99CLNJlMI9GNXjzoNOj6Wvi9AISdpqt3eTB0eM2DYPysi1Tpv2q9SgbOo4iN+/6q1xj//jqfrRXqq95PI66ZlPoz+JqLGBctQ2flN433yf/+TYQCIzRlZJ3xc896L5f21vV3Gs/cWdCg8X2/6b6NcOq461WRqjaaRt2j9chZOvKsddazeZXeOs89nVdmX/VZOsl/nnVuKvKb9Wa9WW/Wm/VmnXddjF/7Zr1Zb9ab9Wa9WWesN8blzXqz3qw36836ytcb4/JmvVlv1pv1Zn3l641xebPerDfrzXqzvvL1xri8WW/Wm/VmvVlf+XpjXN6sN+vNerPerK98vTEub9ab9Wa9WW/WV77eGJc36816s96sN+srX2+My5v1Zr1Zb9ab9ZWvN8blzXqz3qw36836ytcb4/JmvVlv1pv1Zn3l641xebPerDfrzXqzvvJ17q7IbMfO+dHshqo7ga6srODWrVvo9/uo1+tot9t4+fIl9vf35XM4/4PjPnu9HpxOJyKRiLTxtlqtSKVSePHiBYbDoQygyufzMpWOnVTZoZcDc/QytqnmXBJO3mPbdC6fzwePx4NarYZ0Og2TyYT5+XmEw2GZqDgcDrG2tvbaG/2Tn/wEw+FQ2m8vLS3hRz/6EYbDIT7++GPs7+/jypUruH37towI6Ha7SKfTMm+bkwFnZmbg8XiQTqdxeHiIUCiE27dvw+FwYHV1FYeHh/B6vQiFQuh2u9jY2ECtVpNOs9PT0/j+97+PYDAIr9cLp9OJQCCAWCyGcrmMv//7v0cmk8GHH36I999/H6urq/jzP/9zVKtVTExMIBAIYGpqCpcuXUKz2cSDBw9QKpVQrVZRr9eRTCZx69Yt2O12mQbK0bfD4RB/8Rd/8dr7F4vFZBre3NwcotEolpeXYbVa0Wq10O12sbq6iidPnsBut2NiYkJajJtMJiSTSVy9ehWNRgN/9Vd/hY2NDcRiMcRiMZERs9kMj8cDh8OBcrmMdDoNl8uF9957D9FoFB9//DF+9atfIR6P44MPPoDL5cLGxgby+TxmZmZw7do1GUjX6/Wwvr6Ozc1NLC4u4l/9q38Fq9WKv/7rv8azZ89gt9vhdDoxMTGBP/zDP0QsFsPf/u3f4qOPPoLP55PztrW1hVKpJG3pzWYzfvGLX7z2/gHAf/2v/xXAyeweh8Mhz52TH30+Hx4/foy7d+/C4XBgamoKHo8Hly5dQjKZlLbt5XIZ//t//2+sr68jEonIlFWeMc6v4ZA+Tkp1OBwyWdLr9WJubk4msOpRyHwOJpMJ9+7dw+PHj3H58mX80R/9ESwWC37605/i4cOHIoMOh0PGfPN8hcNhLC4uot/v4+7duzg8PITf70coFILJZMJ//s//+bX3j4OyfvSjH+H999+X9viNRgM///nPsbOzg2g0imQyCa/Xi9nZWTgcDtTrdRwdHcHtdiMUCqHdbuPu3bsygqTf72NiYgLf+c534PP5sLe3h0KhgEKhgP39fVitViwsLMDj8eDTTz/FZ599hkuXLuHf/bt/B7/fj42NDWSzWXzjG9/AH//xH6PZbOIf//EfZcoodWw4HIbVahUdyO8OhUJ4//334fP58D//5//EX/zFX2BhYQHf+973YLVa8ejRI6TTaUxMTGBubg4WiwX/7b/9t9+6X689zwU4ezKebjHN3581pU3PgDG2zefvgdPBTmc1beb4Tz31kq3cjWNN9fUbW1jr+Rw0lHpY0kVGohrXWe2u9R6wFb8eIqZH7hqv1di6/7e1NOfrtcHV7cD1XIez5p/oZ8TXU0Bp5Pmjh3QZ72fcxUmYnMynZ5Ccdd8csMVBc3pvOV7AOPjuVfesh6Zx8f71azmZUDte+u/6GXK6H2fC6PHUXPocnfWZr7u0DOizqJd+/myhT6Ohn7kemGZsK8/P1zLK9+rZN2zfbvw9/zXeP7/HbDbL1FUtE8bn96r9G/dcU771NXOfOM6CcgWcDN3T+kjrSz1Sgz+cgWPUjfwOPUGScsPf8Xs4xl2PkjDKuVFXsJU+Zxn9pjPB159rv867sRxuw8E4PLh64AyHW3EkZr/fx8HBgQgAp7VVKhU0m00ZHcxBYN1uV2ZgN5tNlMtl2Ri73S6KbGZmBj/4wQ/g9Xqxt7eHSqUim9Pr9VCr1UbmDnCCnhZwPgCXy4W5uTm4XC60Wi20221YLBZEo1ExYq+a3/A6KxKJSEQ3HJ5M5uPs+WQyiUQiAavVinQ6LZM2j4+P0Ww2ZRodAHl9NBpFo9HAzs6ODFCjYHD6JxVpIpFAOByG2+2WiZC9Xg/lchmtVgs2m01GqJbLZVQqFVSrVZkiyAFQtVoNwMkEvlqthnw+D6fTidnZWSwtLaFarcpwqFKphF6vJ4OMWq2WTBgdZ/3gBz8Q56PX68mkQpvNhkQiIVMWbTabRMwmkwk3b97E3NwczGYzDg4O0G63EQwGsbCwIFFyq9USL3JqagpWq1UOc6VSweeffw6LxYJisQin04nj42M8e/ZMDqHVakWpVMKDBw/g8/lw7do1hEIhpFIpeQ61Wg02mw0ejweJRALBYBCxWEwi106nI9fndrvFmMZiMbhcLiQSCRmBPO762te+NoI+aKVMhd3v91Gr1XB8fIz19XXxzHleOPAuGAxieXkZR0dHqFQq6PV6aDQasFgsuHXrFubm5nB0dCQTKFdXV3F0dCR7ns1m8eTJEwyHQ8zNzSESiYhydTgcmJmZkQgrHA7D5XKh0WjA4XBgfn4eHo8H0WgUExMTaLfb2NnZGZEv6hsASCQSMhCOA8fGWe+//z6Ak1Hl9+/fF71iNpuRSCQwNzcHq9UKm82GarWKO3fuoN1uY2VlBTMzMxItms1mTE1NyRBFnhlGpG63G06nUyIenlXgRJdduXIFNpsN9+7dg8Vigc/ng9vtxsHBAX7605+KXIbD4REHkO/n83c4HHA4HKhWq/h//+//od/vY39/X6LMSqUCADLpldd6XuN8buPS7XbFG+EcZ6fTKRdMo0JBDQaDACCbydnMAGS8aigUkkNE43V4eIiDgwMAEG+A30MLHY/H8bu/+7uIRqP4/PPPsb29jVqthkKhgFarJfAVLSwn1XEQk1ZSNpsNkUgEwWAQqVQK1WoVVqsVwWBQ7tUYYY2zAoEA+v2+jIRtNBrY3d2F1+vFtWvXEI1GkclkcHBwgKOjI+TzefFmOabU4XDI9U5MTGBnZ0e8Gs7d5p5z8JfZbEYkEoHZbEY4HEYwGBQB48hVekJutxu1Wg31el3gLO4VYcFutysOQiaTQSKRwK1bt5BMJkVoqTiOjo5Qr9fR6XRwdHR0IePy3nvvod/vY2trC4eHh6jVaiiXywIvUUasViuazSb29vbQ7/dx48YNxGIx1Go1ZLNZdLtdOYydTkecmkKhgE6ng2AwKM+KymN3dxftdhterxcejwedTgebm5sAgImJCQSDQdRqNezt7SESieDmzZsIhUIC5w6HJ9MyeWbC4TASiQTm5+dRKBTwq1/9Cul0WrxxPZY2GAzC7XYjkUggmUxeaNjaysoKBoMBDg4OkM/nR+Biq9UqDlyj0UC5XMbGxgb6/T4ikQjC4bA8R5PJJLDr/v4+CoUC2u02yuUybDYbotEobt68iUwmg5cvX6LVamFnZweFQgGTk5OYnJxEqVTCJ598gk6ng29+85sATsbv1ut1uN1ugXBsNhsCgYAYdQCYmppCMplEIBBAJBJBsVjEkydPkM1m5dnSMeSkS54fysk468aNGxgMBlhfX8eLFy9kMqzX68Uf/MEfYHl5WUY5N5tN3L9/H8ViEcFgEIuLiwL702ngeaOj9sUXX6DVaokxorPbbreRTqfRarVw+fJlLC4uolar4fnz5+j3+7h9+zZmZ2eRy+Xw5MkTeL1evP322wiHwyPjqznIjedyOBzC6XSiVqvhwYMHqFQqI1BpvV6XKbQcUEhjep51buOi4S+TySSjbLWwW61W5HI52Gw2GSvc6/Xg9/tHcjOcpU5oi9MMeagIGdAwMdwjFtvpdMRLXF9fRy6XE6+HcAjf73A4cHx8/CXIq9lsipErFosyn57X3Gq15BqtViv6/f4rpzieZzmdTjEuNpsNXq8XiURCRie3Wi20Wi0Z5cwozOv1wuVyifffarWQy+UwHA5FGXo8HpkGOTMzA7PZPAJh8D6JTVerVVEILpdLFDSFbWlpCclkEh6PRww2ja3H45EIleNSuf+VSgX1el3G9XY6HXkGZ+XEXmc1Go2REa+UiX6/LxEMI65WqyX302w2cXh4iGq1ikwmA+DEo+PsdR3B0tHR0yCZj+B4XUaDkUhEzkSr1YLdbsfk5CS8Xq+Mnj46OoLVakW73cb29rZEBn6/Hx6PR0b3Xr16FclkcgQfpyIg7FGr1c6ciPk6i8Zdy1i1WhV58Xg8ODw8BHASAQaDQdmHRqOBfr+PTqcDs9kskQ/llBAav6dWq6HZbKLf78Nms2FpaQnT09NwuVxwOp1IJBK4efMmer2eOD9OpxM2m00iDsrvcHgy2z2fz4uDZbVaReExEvB6veJUMrdAmMrhcKDT6YhSHWdpXUdHl1FGp9NBrVZDpVJBsVhEoVBALBaDx+OB2WxGoVCA2WxGKpUSp5Wy1m63AZzkFXu9HmKxGPx+PwCIA+R0OtHr9TA1NSXGko4iz4DZbMbExARcLhd8Ph9cLpeMLT46OkImk8FgMIDD4YDP54PP54Pf74fNZsPCwgKazabslzYqNpsNPp9PnNav3LjwAwlTeb1eLC0tiddosVjw4sULPH78GMPhUPBHl8uFyclJtFotgblCoZAYDkJe9CgcDgfsdju8Xi/C4TCGwyEKhQKOj4/h9XoRCARQr9fxZ3/2ZyOel9vtlgfCyCoQCMDv96PT6cjsbOLc+XweR0dHOD4+xtbWlgi1zWZDr9eT2eVU3Bf1eugN86HHYjFcu3YNdrsd1WoV5XIZ1WoVtVoNR0dHaDQa6PV6mJubw+zsLLLZLFZXV9Fut/HixQvs7u7CYrFIuE246+bNm5idnRVvqF6v4+nTpyiXy/D5fJiamsLx8TFevnwpiU+v1wu73Y7FxUUEAgH86Ec/gtVqRSaTwebmJqrVKmZnZ9HtdhGNRuHxeJDP53FwcIBer4fnz5/DZrMhm83Ks2IEeOXKFcTjcXnO4y4a1FarBYvFIvPFTSYTDg4OUK/XcXBwgMPDQ5jNZjk0fM7VahWpVAputxvf/va3EYvFxMPs9XoSadtsNlHsJpMJHo8Ht27dQiQSwe7uLvb39+H1ejE/Pw+TyYTHjx9jf38fs7OzuHr1KgAgnU5jZ2cHrVYLDocDtVoNOzs7sFqtePfddzEzMyNOA71eAMhkMigUCqjX6zJDngotnU5jdXX1QtFzoVDAYDAQ+LJYLGJzc1OcMqIOdCJmZmYAnJz5fD4/kq9oNpvyWcfHx2KwCImmUimJdD0eD27fvg2fz4dsNotMJoPJyUncvHkTg8EA+XwetVpNlB2dQ0aVdJDW19dhs9kwOTmJQCCAdruNZrMJq9WKt99+G8AJ8pHNZuFwONBoNOSavV4v9vf3sbGxMfYeMg1AR9nhcMDr9UrS/vDwEDs7O9jY2IDNZhP4qt/vC6kmm83C5XLhm9/8JiYmJgSGNJlMuHr1qqQU/H4/AoGAwL0ej0eiS+o23n+n08Hh4SHm5uZw7do1uFwuRKNR2O12gbJSqRQ+/fRT9Pt9fPjhh7h06ZIQHIbDISYmJgQB6Xa7yGQyePTokehdv98vcO15HZxzGxefzwcAZ87I1olI4tUMYXV0wmSvZnrRCNFD4gPTUBj/ZWjb7XZxdHQkVpibrhN/wGi0RXiCEBCjB0ZhzCW5XC7xxujJ63sYdzGJRq9YJ9D1tepZ2/p9OiGuPWuyk+j96CQzP5fGmyE5ozr+jhFZt9uV/7fb7eKt6wQuDRmFnPtNr5Wf73a7BdbQhIJx95DOQafTGdkr/qvDf3qGlJVqtSqKTu+Pzr2RWcYkK++Xyt1IrtDJfj3vfTAYSJ6MbBxGwoyAzWazODB0dnT+QyfSeT6ovM+bTH3VHgKQz2VEQFRA7wuhL55TwqH6ddwv7jfzp8zDAqeOHuWCES9lUCezdaSidYrD4UC/30er1ZKIi145r4/y2mw2xWHg93JxX8cllpRKpREZNBI2dG6WZ8Vut6NSqaDRaIwwbbnHPLvcD0000Q69PkvG/df6gK+hDDJfwn3jNTJqYj6XhBWtm4zfo2XjPOvcxuWHP/wh+v0+Hj16hJcvX6JUKmFvbw9ms1mosolEAh9++CFqtRqePHmCRqMhlGS73Y54PD7ysP1+vyTyCoUCer0eZmZmsLKyglQqhdXVVYG5GOoFg0GYTCZMTU3Bbrfj8uXLiMfjyGQy2NraQqfTEQ+q2+2iWCzKBg2HQ0mQRSIRrKyswG63IxAICB5ut9tRLpclnzExMQGv14tMJiM4/jirXC6j1+shm83i4OAA/X4fXq8XXq8XU1NTiMfjclj4MAk5MRIg/BKLxRCNRpFKpbC7uyvCYLVaUavVsLGxIUJrsVgQj8eFvtxut+H3+/HjH/94ZK8cDgfy+TzK5TJKpZIoFCrEQqGAfr+PWCwGp9MJv9+PcDgMs9kMn88Hq9WK+fl5ySlRSTJyoICP6zV+9NFHQuZgJERP2+Vywe/3o9FoIBQKiffH6Iu5mUgkIrBqqVQSYgL3VHtlDocDfr8fg8EADx48EMV0fHyMUqmEbDYLACMEjc3NTfR6PWQyGbRaLYGACMuaTCY0Gg0UCgU0m01Uq1VxxHq9njwP7h1zlTQ8zFmOu37961/DYrHg8uXLmJmZGYGRv/71r2NychLPnz8XyPnKlSvweDyo1+totVojDiE9aUb7hJBJsKBchEIh9Ho9bGxsoNVqIZ1OI5PJwG63w+fzSf6On29UqtPT07hy5QoKhQIeP34sMknUgQanVqvJv81mE5FIBMvLy3A6nYI+8DvGXX/+538O4IScQ0SkVCrB6XRifn4ebrcbc3NzSCQS6HQ6YlS2t7eF1h6NRuHz+eSc6KiWiA7Pf6lUQjqdFieaJReMhvP5vBBACFXzWT19+hSVSgXRaBThcBiNRkM+ezAYoNVqSSSuHSaSgYATtIXOEvM//78k9BcWFtDtdrG+vo5utyvJrOFwiMPDQzQaDUQiEczMzCCfz0sivNPpCG5HT4jMLeYAaIBoXCYnJ8XKM2fDnAINAOGl5eVl4ZNnMpkRz5PJMM0coYIgZ9vlciEcDovHzutk2M8QvNVqva4sjqxWqyXsqXq9DpfLhWw2i+PjY0xPT8sB0N4gYSAmlnu9Hux2u9QPpFKpEaYcoy+txF0uF6anpxEKhcQrcblcWFxcxGAwQKVSkYPKnBPzTdxr5i7oHdFTdLlcotypoFlHwDzS0dERarUa2u22fP44i3z/YDCIRCIx8jdej47GmNRl5MLclMvlEpybXjuVpMPhEO/ZarUKgzCXywnbi3JdKpXku81msxgdMszItKNnyT3h2SkWi0in05IIZy6DBoVeLI2MjhTHXQcHB+IEEEPnvU5NTWF5eRnpdFrIO5FIBIFAQOQWgERZZHIxJ2Cz2RAKhWTvGTF7vV4cHR2hXC6jUChInQshG4vFgqOjI5FZHZkR9o1GoyPJ7Xq9DrPZLLnDVquFVCqFdrstBrrZbArky8iUpKFx9/D58+ewWCzCBmTkx6WJQI1GA9VqFd1uV+CweDw+whgDTkgMlUpFjDbPMiMN5rqo1ImuUD8yr0l9wbzS+vo6MpkMlpaW5N515EPHe319fSSaDwQCAtmGQiEAEOjN+Hx+2zq3cSEzoVQqiWfFG9YMm5cvX+L4+BiBQEDYMmfVPzCxSMNCa8liP7vdjm9961sjfHd9wDQcww3N5XKi0Lhhw+EQPp8PyWRSCrZIOZ2amkKv1xsRTDKp8vm8YM/ASUicy+XGjlyotMLhMJaXl+HxeAT6S6fTqFar2N7exv7+vhSaEsslpDIYDOD1ehGLxZBIJLC3tyfeBu/P6XSi1WohFAphampKjCc9TSZDCRnlcjkcHByMQG+EJChk/X4fKysrMJlM4s3zALPQEzgptE0mk8J2I1Tm9/uFITfuun79OoCTsJxeML3ucrksyeZAIDDCMKTc8d5JHOl2u3C5XEgmk+LwUEkSwuHnLC0tCR2bFPpYLAar1SoyMzk5icuXL6Pb7WJ7exuNRkPyYPROGWESrqDioFGcmZlBIpHA0dGRGCpCHsfHx5IHHHcxEdztdpHP58UxofNQr9cRCARw48YN2O12NJtNHB8fI5/Po1AoyL6QVRYIBGAymRAIBEQO+v0+gsGgkHboKbfbbYG8uc88WzQI8Xgc09PT4hgOBgMkk0lxXgBI/oWRHpP1yWRSmG0sDk4mkzCZTFLgIvqEzwABAABJREFUS4U8bvT8k5/8RLx+OrJerxc2m01II9wjm80mhbCFQkFYY4yeycC02+2YmpoStqbNZgNwYnRCoRDi8TiAUee02WwiEAjgO9/5jiBHR0dHsn9+v1+KLhcWFjAzMyMyOhwO5TxSjzO3Z7VaMTExgZmZGTQaDWQymZGEPtGg865zG5eHDx8KPMLD2Ww24XA4EI/H4XK5JHlMNgjrWFh7UKlURrDp4+Nj1Go1iWKsVivK5TLy+Tzm5+fxwQcfwGKxCJ2VuKUuamMkUqvVcHh4KMaFn0nYa2pqCj6fTwSLUFGpVMIXX3yBbDYrUIlmxPEA0esy5jTOu3iIk8mk1DfQ0DIxvr+/j+3tbUxNTeHq1auIxWJYX1/HwcGBCJ3f70cikcDU1BRWV1cFLllaWoLL5UKhUECtVpPP0HkVwnCM/FqtFn79619jd3dXchTk1B8fH0v4HwwGcf36ddjtdqmG556T9ksvizUjjx49gslkwvvvv4+pqSlRBOPmDL72ta+h3+/j8ePHWFtbEyU3HJ50PWg0GgLDMFIla4jGhTAVPTy32y21BqVSSQgXpAETipienobVasXBwQH29/cRjUZx+/ZtOJ1Oqdm6efMmvve976HT6eDx48cj3mgqlRLjQEVOyJjkA5Ixvva1ryGdTuP+/fvyGlKAyRgbd8ViMYme0uk0SqWSeKT0tAOBAN555x0cHR0hnU4LtZzG7vj4WLxn4CTRHA6HUSqVsL+/j6OjI7kf1mnZbDaBjXgGGWUDEJLG5OQkPvzwQzEInU5HPos5VZII6vX6SATNqOn27dtCuaYCz2azSKfTYsTG3cN/+2//LbrdLv7hH/4Bn332GYLBIObn52E2m7G/vy9OoNVqxfT0NN5++20EAgFxGiORCGKxGOx2u9Tj0akw5l6ZZiBRIZfL4ejoCJubm6hUKkgmk/jRj34El8uFu3fvYnt7G8lkEvPz82g0GkilUgiHw5ibm8PMzMzImchms6J3dakDr/trX/sa1tfX8eDBA3Q6HczNzQns/DoO4rmNSzKZHEk4MikJQA6NTkDy4TJS0NxqYoe9Xk9omwy3yRbxeDwjioiH0O/3C6xhsViEUUGs0Fi5Dpx4RswLUUipPBqNhnhRDJvpFQEnmDpDd8JV46xgMDhSwEaFR0yz3W7DZDJJCxoAkhDWNRdOp1OSajR+9HCYRPd4PIhEIkKTpOHm/zNH0G634fF4MDExITAnFQgNNz0VUpA1551eO5OpxNydTid8Pp88V3rsGk9/3UVaK7F8ncRnQpnKCzglQtBbJvuI18Hnz2Qx5ZfPHYAYLyaBaawYZWtvk6wh5ntoiKlwyE5jpA5AoFrudaPREAeHNOtQKCTeKe9r3MXzRBiUz59wCc8zk8qUPVJXeZ5tNptEV6SY0+hoVINwID+bTiEdQ+41ZZPyo/eeUFiz2ZQomhCZZqpSOdLpJc260+nA5XJhampqRAeNswjxMypyOBxybhnxUqYoo91uFw6HQyLqer0u98nnT2jS7/ePVPkTegROiRHcb51/o8MZCoXEYE9PTwvLi3tMnaqdPN1BgVAcI2TWNlEnaYf4POvcxuX3f//30ev18PDhQ6yvr6NWqyGTyUjRFYv0YrGYPAgaFioz5mLYWyyVSuHw8FCq5N1uN5aXl4W6XKlUBBYzm81YWlrC5cuXxeoPh0NEIhF4vV7s7OyMcMOBU/p0qVTCp59+CrvdLhARlYvdbhflTGisUqlgd3cXx8fH2N3dFbrmRajIb731Fvr9PtbW1gQyCQaD4kWy39K1a9fg9/ulSp/FjPV6HcVicaTbQDgclgjngw8+EO+CBX/MJfn9/pGcUrFYxNOnT9FqtTA/P48rV67g7t27+Ou//msJg1nLAECeq9PpRLFYRL1el+IvAALJTU5OIhqNikFjjQNhjIskpFdXV6VG6urVqyiXy9je3haokD2dpqen0W63pa9SJBKB0+lEu92WvnRkI05MTIg3T6VIJc7CPULBVIhUxmRYRaNReL1e6WVmsVhw48YN9Ho9PHjwAHt7e7Db7fjggw/Q7Xbx8ccfo1AowGQyIRqNCk2+2Wzi+fPnkkNgQds777yDubk57O7uYn19/UJsMTqBrPx2OByYnZ2ViI5nVUPOvV4P8Xgcc3Nzskes26nX6wiFQlhYWEAwGJTuDqlUCvl8Hm63G8FgUPaL+ShGbKyrCAaDkngme45KdXt7G7u7uwCAyclJdDodrK2toVarjcB0NOy5XA6NRgO5XA7Pnj2Dw+HAv/7X/xpXr15FOp3G3t7e2Hu4s7MDk8mEubk5LC4uYm9vD59++imGw6GcQzp7VqtVPH2v14vl5WVUq1Wsrq7Kc41EIoI0RKNRXL9+HT6fTxCAaDQqBpuoAjuHeL1e6dW3uLiIlZWVEedqenoavV5PkvYkWjBHzgiOOUTm1A4PD+Hz+WA2m/H2229LOoKF7jrH9NvWuY1LNBpFr9eDz+cTpUzvhsqcniLzKfS4KZCk8DFpORgMxIunZ0hPczAYSOhGZUePnDRDKhZej45cdPSiaYz0iOiBut1uaXfAiIoKlpRnJrgvUh3t9/slR0BvRkd4jPoCgQDcbrdAN5pmyHsiLGWz2RAOhxEKheDz+cRD73a7I5CkplPzHuhVx2Ixaa9BRhQPOJ+pMd9Fz4/GWzcc5R6Gw2FJXvM+LrLowHg8Hng8HikI1JEL80mk2VIe6anpXlb00mlweXgJE+jFpDWT1Zq2TE+SHjTzNIPBQGSInivlihGYpuATwikWi+LhE/IJBALiPV7EuFAxsImoLgXQ9F9S5nmPrCHjdenCZgAia16vV84mAIEXSbLhnmtvWXfh0EXK3EtClmxuq6nh3EeeTbPZLGw7OrOM1qPRqLAux91DOhQk1GSzWSFuMHL2eDyS02BkT7klPZg5Z82OY16DDjJli+gGnxWZkUQg6PDoejzuO3DiWHMvCYtRR/J1xlRFs9mE2+2WInmeCT7X80Z+5zYuhEyy2Sz29/fhdrtx48YNAJAaAiaUarUanj17JvjccDiEx+MR6i/ZFHa7XZg/ZLJ0u13s7u4imUxiaWlJNpcFbVT0DP906MywVdceDAYDRCIRXL9+HTabDZlMRthaZEPs7OwAOPFo3W63UGepbHhgtPC/7qKSKxQKePHiBUKh0IjC5eGZnZ0dqRXgDyuaLRYLdnZ2sL29jeXlZXz3u98Vb45UYVaAh8NhETgacCayr1y5guPjY1QqFezs7OD4+BgzMzMjyT2G1dFoVBgjLpcL8XhcPK1yuYxPP/0UqVRK9jscDuP27dvo9Xr49NNPkc1mR9ryjLN6vZPmgCR81Go1Obj0qHZ3d8XLpVEMh8NSvFer1SQCDgaD8Pv9Qm+/dOkSAIzIEYsDSXNdWlrCtWvXAJwqxlAoBI/HI61htPLzeDwjsBbrO4LBoFyz1WqVrsJM9lOJ2Gw2vHz5EplMRhK5F4HFnj59CrPZjEuXLmF+fh7FYhH3798X2DcWi0nuhbRaGg22CUmn03A4HHj//fdhMpkwMzMjhIpLly6h2+1iZmZG6KvsDsGc4/z8PILBoLDkCLsBkCiOzFBN16XcAhAn0263i4Gj8qQSDofDWFpagt1ul6JAFgGPu4dTU1MYDAbY3NzEZ599JrlJ6jPCmTovQUebBoY9BMkuTCaTuHTp0kiXDNLoQ6EQIpGIOEZutxsTExMiYzQK3Cc6djTWZrNZmLSE4RnNDwYDMZLNZlNyRp1OB1tbW5iamsLi4iLMZjMeP36MbDY7Uu9ynnVubUmFWy6XkcvlMD09jfn5edhsNgnlY7EY4vG4hN7FYlE8C7bYJruHnlMkEkGj0ZC+T51OB5lMBg6HAxMTExJJDAYDqRmgl0C6KwvMaBA0I43siBs3bsDhcAjkQIyz3W5LIjKRSCAWiwntVyt3Rk/j0hjpIVQqFUmAk7YInNZVxONx4avTCyP2/vbbb6PT6eBnP/sZDg4OcOnSJdy6dQvpdBoPHjwQ5cnGoqRwc1FIyWQhHTGTyQhbh4acipPMH+Za6BnR6Ozt7eHOnTvIZDICr4TDYVy6dEmMC/n+pK6Ps6jM6SkS0wdOe8dVq1WUSiWBP10ul+SUGM1ZrVZMTk5KM0OL5aTxH9l5ZEgVCgXs7u5KM0bgBGp47733hC3EWiV67jzQNISszaLCoZLx+XwCTZnNZiGNsKcbvVaz+aTZJtmTF+lwAJxATFarFSsrKzIuYXNzE4PBQKi1+XwemUwGExMTePvttxGPxyUqHQ6H0oxzZWVFRjrQUWRbfp4d9hYjs5BO0tLSEur1Ora3t+WsEXJjc0qyG5mTJEuLRkQXdfM56ujZ5/NhcnJSrofRTyAQGHv/CGPmcjncu3dvJDomoUVTpXWBLBU+qfq81+npaVy9elUq9YfDIQKBgOSSGTGSWRYMBhEMBnF8fCwwOa+DuURdkMkeZmTm9vt9iY5oXIgQsXVTOp2WSJlkJnZHeJ3UwLmNy9OnT2UDeEgZ9jE3wBCXjCtCV8RvNT+diTD+RCIRACf4PamEbIFC2IvV4cRZAUhO4iwISRdGGqtd2RxPV6/ygdDbp+DQmwfGT6jSWFAxM4zloWCkUq1WpTbFZDKhUqkgnU4LA4TQmt/vx9HRkdBymT+YmJiQYiwaJ0ZCuqkemUCbm5tCSy2Xy6IUmXxkrqnT6cihZnX0+vo6CoWCsPFIg65UKtjf3xeMvdFoCM1xXONMhe10OmV2B4viKB/EigGIMiLl12aziXNDD5jeIvuSmUwmpFIpybHQWaFz02w2pUqbn0HKPaEwfjfzgvl8Xg42i+5qtZrg8YRzCE1RodJRoPGiN3+RFY/HJbHLEoIrV65gOBxKvoxnhi1+GNGwmeHExMSIF8x90lDXzs4OcrncSONVOn/cE23s6bSx35XVahWnjs9A0391l95WqyURIosrScyo1+uyd1SoF4Fnnzx5IhB2IpGQ72E9j8/nkx6AdrtdDCQjYNK2AQhrTzPYuIc8d36/XyBIOj2Ef0lYYIRMyIsyxXNfLBZFZgGIHi6Xy8LMJUGCNXBEaNbX18WRI2mFReznWec2Ln/7t38LAHKI7Xa7eI8HBwdyaHiI6EEz1GIxGgAUi0VpLsifhYUFOJ1OTE5OiteZy+Xgcrmk/TZhGmKUFD7WglAQdQEhoQ9imyxiCofD0jspHo9LVMawnPmL10lg/aaVy+UEXmPVP4sQNTPr8PAQ09PTuHXrFnw+H/b39/Hs2TMUCgU8fPhQcgSJRAKlUgkfffSRdKFl3oWQIT1jtuXgGIO9vT380z/9k1RGk+par9dhs5209Hc6ndKDigrd7Xbj1q1bSCQSWF1dxb1799Dv95FMJjExMYFCoYBKpQKz2SxV7Xt7eygWi5ibm8PVq1fHZouRHch2+YRUAIjB8/l8mJiYwNHREQ4ODoQlSOXy7rvvSmTB+qBYLIZOp4N0Oo1ms4kvvvgCm5ubiMfjMmyKEFmxWJTeYtwjjjJgZMpn2el0kM/nsbm5KYPeOp0OisWiYO/cbwDyr8PhkL5fFosFKysr0gnhIjk/AFheXobFYpHE+eTkJH7wgx9IlMoCXNL+WTB98+ZNae9y/fp1iaypNAlNMcr+/PPP8dlnn2FqagpXrlwBcJrjIzzldrslKiLjjvkrKknSt1l5T8+eThkLUUOhECYmJmC1ngwLI2RKphPrmer1upCExln/9//+X5jNJ80hV1ZWxJGy2WyIx+MIh8PIZDKo1WrweDzSqJNQPOWTJBE6P5qJOhgMUCgUcHR0hFAoJHvLgkzKmG5ESfiy3W5Lg0yel52dHezt7cl+DwYnXT9SqRTS6TS2t7fR7/fFAff7/eLY37lzRxxrNtqdnp7+6iv0mYynlwicdlklRswLpPJnwokRjU4OM2LRPGtuLrFp3XKDURA9Pb6fYSiZExoX5H8zcgIguKRuq8EDRc+Y0RKTWOzDcxGvR0N2vD5+Jz1ewn30dpj852HQBX76M3jAWYmr90fTNDXllkVz9C4JLQKniV9GSSyCY/RDL1Sz8ugRA5B23cx/6aTxuAdbJz8pX4FAQD6z3W6LzGmaNKmVmuFFL40sMhpXFqoBo/2UiIXr1jaakmlMMmt4hEqY/a6YH+TeMBemyQiMOPkMNcHiIotep8VikWesYSJ6/VTMOnrjWSQsSTmgTNMIE77keW02m7KPumsHr4HYPwkj3A+OaKDTyGfKPWaimfvC6zNS91lToiHucWWQ9TgAhNRBnQRA5IoyQsPAZ07SCPeASAJRHwBSrsD2QToa5j7z/rgfpJVrPcbnQIeZcBiZYYyeydhjvorOt+52rWXzdcoJzm1c2GKcictmsynFbPSuuNjznwKsMWO73S5Ryu7uLra2tuTB9ft9KbScmZnBjRs3YDKZpPWH1WqVimqTyYROp4ONjQ08efJEKIa0ssDJoSckkU6npf6CFEkWdn766aeoVqu4desWlpeXUa/XpUKZwn3RhKoO17V3yMjCZrNhcXERX/va13B8fIyPPvroS5j47du3hRTAiILXeffuXZjNJ7NbGMFEIhFR+oRbeIjJCGLkQkXR6/VkwNvc3Bzm5+elMPLo6Ah7e3syIIqkBB7sa9euYXZ2ViiaZJ1wWNf29vbYSpLRJxWWz+fD7OwsOp0O7t27h3Q6LUaUDgNpl+VyeQRK5YGdnJzE1NTUiPORSCSEAkoohYdycnJSxkcUCgU5jHSWCDk+ffoUpVIJ9+7dE2iBB75UKgntk7JEByAYDMLn8wmll7LBkQt6Zs8467333sNgcNKF+OXLl4jFYlheXka328Xnn38u+R0aO54VAELlTqfTkhfQZ5oyAgBLS0uYmJhAKpWSjtnsuE0j1G6fzCixWk86GhORIAzD+Szsys0oRjP63G43FhcXpWCT3UNYD0MKfDqdRjgcFiU87hlmby6iLcFgEEtLS+j1etje3sbOzo44Pu12W2A0GmIiBcPhEJVKRZwIklQos7oOhrk3XTdEeWU0DEDkkbVonHHFMRThcFgcvPX1dWxsbIjRY69AIkNEbehskYRlNptRr9fPvV/nNi7EmFmdS/yZ1OHp6WmxxDwU2tPkYg8qn88nzSqpnABIPoZeKUNkAOLNU0ExQZ7JZIRiSK9JF/Axodrr9aS/FCMj9iUqFApYWVmR5CrDZ92P5yya6nkX71NHDwyHaSzJBikUCjg8PJRW5AAEwjGZTOIFa0+Xw5/YeicUCklBF4AR74MCytwAf2hw6BQQl9f3zvoCYub0KslyWVpaGvHaWS/CSGnc/aOAAxBSQiKREI+N4xx4CPhDlpuONHSuj8+X72NrcebeqCyY56InTDnXUAW9wkwmg0wmg2w2K9fF3J0e0MZnoa/F6/VKFAZghF5/UTo3W6SwQSlzf1R8bAPU7/eFFqvbrtRqNezv7wM4OXtMqvMsMUrhlM1arYZSqQSbzYaVlRX4fD55Hu12G8ViUeRXn+tu96SRbTqdlj5t2vlhzQxzAHwmZN/R2DOKp6dOR2jcpeWBhdfxeFwmbZbLZXg8HjGipVJJSjJ08p/RCQtS+WzpdDDnzH3RSATPrS56pPGlkWCLfUKw7ItItmapVEKxWBw5EzRkLFtwOBxwu91y1jTV+7zr3MYlHA4LNuvz+YQGenx8Mg5VXywPESEgwkq6rsXpdI4oxFwuB6fTiatXr2J2dhbRaFTYaFQUTMATW6QCI47OIjH2+2G+xWq1Sj5oZ2cH3W4XU1NTuHz5siTaeEBYgLW+vi70QoaGZNSMs4rFIobDIUKhEG7evIlSqYStrS1hdLA79LNnz6SKm/guFSmFixFQOBwW/j6VfyQSkf5KNEascOYekLJL75jwJL2YpaUlYTk9fPgQAOTAMg9D1g8pwPwOFoQySciozOfzjQzYet118+ZNAKfV48DpTBGOMuYBJGuG+04IgB2y/X7/yHwenc/gxD/KHItD6c1RebFAlYaIUSDbtDACd7vdYoyGw6E4Z7xObaA44pvGhR4r8y+EYsZdzGdMTEwAgLQisdls+PrXvy7NTAllklpNcgdhH54X3USV99Lv97G5uYlMJoNUKiXRKxUh8x5OpxPLy8uSFyXEpaFqfh9hV/6w+px7oZ87ISen0ykUX+CkKznrUMZdP/rRjwBgZNoljdXNmzexvLw8UkN15coVea6UB3aJoDNHchH1GwCBabPZLJ4/fy7fw3xer9cTlifbxBApYpseyuXe3p5EcLrOizNjOK2SEQ6NC+dvUYYZWZPtdp71WrCY2XxSkRwMBsVItFotrK6ujgiATohTGVAhAhDvl8qBXo/b7caVK1dkWBUtJiMNesxsK0+lQbiE2CUVGllMzWZTWBF7e3solUq4ffu2UFT5XSQH5PN5rK6uSu80HqSLTFJkoi2RSCASiWB7e1tGFrCyvFqt4tGjR6KMLJaTfkusgGeVLAXY6XRKq34exGg0ikQigUAgIJPtDg4OZKzy7u6uDDViAzyv1ysFjy6XCzdu3MDk5CTu3LmDe/fuIRwO48qVK7Db7eINJRIJrKysSBsQel6Hh4fSUl7jtuFw+LWSgcb1ta99DYPBAMViUWZ7kwJ769YtaU8BQGRmMBjg8ePHAr2m02mRD7KwtBHp9/syZpufRWYVC8pYp8L2Ol6vV+AGwmKVSmXEuHBYGeFNreDo0LD9DqFLfi5ZQvzOcfcPgPT1mpycFEVL6uo3vvENMZJURPSuM5kMisWiwFK68JSeOvex1Wphc3MTn376qZx5wtOsGeK446tXryIQCMj30mjRK2dETONPGHJlZQXT09PI5XI4PDwcKaKkEuawM0aAjKBIrx1n/eQnPxHYjrk8Gv7bt28jEAgIlZstZ2w2G549e4adnR2USiXs7u6O5F9pXAizmc1m7O7uolqtIpvNSt6XeSnuC3sdttttKexl+YfVakU8HkcwGEQ6nRaK8ebmpugb9lZcWVlBqVTCP/zDPyCbzX5JX5PFx0JgOuvnWec2Lpz6x6QuDw8Fgrgxw1sKBgvMjB1J6THzYbNoz+fzCYSjq011NTvZN7S29KYphGSdMPxkgh6AcL6pqFh5TTiCypHhLAWX/XvGPdyEDDh1jhP09H3zWgGMHLpisSi4NimWVEjEc7XRocHmPQAYiXoYUeqIz263Y3p6eqTif2JiAktLS/B4PJIM5lwaeja6FTqjPOLJ/G4qe+Lq4yxOoiwUCqhWqwiFQtJqRleYU+7Y8Zc5DmLH/H4qCX14GVkTTqFiYvNFUuHZKoWQAqEdThJlwl7nCXS9EavvPR6PdIFgERwjFObJSNeld3mRyIXOXLFYRC6Xk7o0Ekh0Yp6RLBPpjK50PoBQH1lcjN40a5DRDCeTcsQBZY/eNGEs5kiBUyiXn8McI7+T+0q9BECYkYTMNKyoSyA+/PDD196/jY0NABCZ53VT3+mzOBwOpc6PXZn5nCmr3C+SPnguaZCp0CnfPPs8azqyYwTK/dDFwCRR0Zki2087P4wW+XwJ85rNZsnFsJP6eaHFcxuXly9fAjiFJZjoZsGSLq4h28NkMmF5eRlLS0vY2dnB4eGhML/M5pNxx+z1NTMzI2N4tYHQ2DRpe5VKBVtbWygWi1LBTKF1u93SAZmv8/l8UjdCTHg4HOLRo0cCd8XjcUl0ksHB+3U4HLhy5Qq+9a1vjSiJ11lMdmqcmfeYTCalqnlnZ0e6GTgcDjx79gzPnj0TCIJ5pk6nI7NN6EEx2a1riPg8CPtQMMiKI2Ps1q1b+J3f+R0Eg0FcvnxZRkq/9957IszMJ7Af2oMHD3B8fIzDw8MRaiTrngAIkzASiWBubm7sLge//OUvxWg0Gg3cuHED7733ngxAa7VaqNVq8t0cM0wjbLFYpFqeETBfS9gOgERdOjeXTqdlMBMPHSNmNiRsNBoyOrpUKqFer6NQKCCXy8HhcAicwPqW6elpzMzMSMRCzJy94BKJhETNZvPJ7HWSO8Zd+/v76Pf7ePjwIV6+fImbN2/i6tWrcDgc2NvbE+XLLhgkfvDZA5AaqnA4jGAwiGKxiN3dXcl7NZtNPHnyBJubmwgEAkgmk+h2uzIwi4W5rC3qdrvSybpSqSCbzYoxDwaD4oTxnFgsFmntQvo5HScAYjA9Ho/AwtzftbU1PHr0CN1uF//xP/7H196///W//heA0/EZ7CDs8/lQKpXkHBYKBXS7XaytraHT6YjDSnSHTgwheULgOu/Han5Sv9kNOZVKoVwuS2TJ+ifKtqbBMwdOItPs7CyGwyGePn2Kvb09zM7OIhaLiUPBAlYaaDreHC5Xq9UEWj7POvdJ1xQ6esZU1vQOuPTfddKUNDqNNzudTgnRmSvR8AZxVP3D6IXGhpaXn8mwnV65bjtP5g1zBPyb9sLopTG64nXyUIyzqNR1QozXSQWivQdCcaTZakoioxTtZeq2N0wQ0ivk7/XruE/05F0ulxTL6VkzZKMxEiGNm540oxheI78HOB0sxeei8yWvuziilwlKhuyUK8J69XpdKvU5b4bkA2LHdFYI5RF+1RE3gJFrpezpJCjvkTkryiL3SlM5uQeUXwAio4xgeY3shkvZ4L5RLsddjIyZqyRDkx40628YZRNVoIwRRWDil1EEnwlnphDKM9KUaQR0GQD3gpGMTkDz3rk/bGPCvdbPjZ/DiJBQE1l8vAbK7DiLdXrcM6/XO0INpgwSTmRXZjYmJSwHYCSCYRTE6JXoDfeaupT6lxEozzCjSEYvvB4iF3wdoWKdu9E6g069z+cTOeD7WLP4OuUE5zYut27dEjaMhkF4YTQ+pMnxol++fCkV4AzjAAgbhy32OV8iHo8LU4JeLj0cttxneEZMn1RPKg1+Fzuw+v1+GWVML4wKlIaFeaJoNCoMDOCURcGisnEL2eLxOPr9vnjBgUAA09PTcLvd2N/fR6VSwYsXL/Ds2TPJ7TDh9r3vfQ/NZlPYdYRlKKgUFmLNsVhM9oeFe0dHR9ja2sLm5qZUFVutVszMzEhyNRQKSRGmw+HAzs4ONjc35TkFAgG89dZbWF5eFrybBW6DwUAGE+XzeWHwMHmdy+Xw4MEDmEwm/Omf/ulr7x8psUykh0IhrK2tCdRlMpmk55rO72mHhl7ZxMQEPB4PNjc3hV7OaI9eMj1ezjeZmJgQxR+JRJBIJKQyGoDsAyNBGmKSQNj6hjj70dER9vf3Ja9mNptlkicHNZHdyOj63XffHUv2uJ4+fSr1OtevX0cgEBAcnjJCLN/tdmN6elpamxwfHyMWiwn1NxwOw+FwiFdOSIs0ZbZeofe7tLQkA9bonZPyzUJUnk2iIoRtdO5Qs5uA0+Ja5lkJpdNRJGREogohxnEWPX9eI+u5TCYTgsEgnE4ncrkcPvnkkxEDpqvvaWR1zRFzqSSSsNedw+GQzt8AZFAfjUAsFoPL5cLKygomJyeRSqVkpAA7RmiYmg4OC9NrtRr+/u//Hp1ORxzLGzdu4PLlyzg8PMTdu3dFj7M8Y25u7tz7dW7jwpbbhCWIY9Nia+Oii5ZYCUqLqb0MwljExonpc4YKP5e9y1gJS4+PAsiHR8VPz4lC0O/3pV5AF2vxwdIDIvOFHG8AEkWwuvgidRqDwUAMCb1UtrEvFovY29vD4eGhRHGhUAjvvPOOKHMeYBakMrrQuRT2KGNFc6vVEpgmn89LAzpWRE9PTyMajWJqamrEsNhsNpkLHwqFpM0Jk7ePHj3CkydPRrpdk/fv8Xhkfg4dBOYjxl00IlTAlC0mHG02G3K5nNQa0GnR3jHvOZFICKRDZUP5JW5ND9Hr9WJxcVGYP/3+yQRG9lzTcKMuxNSJeTZpHAwGI62TCoUCPB4PZmdn4ff7hbzBoXGES/r9k/EKnEo47trb24PJdNIynhAT61aYXykWi0ilUvD5fMIQZfTncDjEISJ+D0BovjzjNBjMPwCQseKs1Pd4PNK/inLHwkp63NxDynM6nUav1xuZdEknVOdqiQLoSbl0Klwu19iMTza95H3zejVFmW31mW+ms8JSDkLURGkoU3SIGDEmEgkZdMb6QnYuB05ysoSvOcac/ceYX6Qe1pN5Ca9z/PSDBw9gt9sllXDz5k3cvn0bq6ur2NnZEVSo1WrJ4MCvnC3GmeFMzBMz1DUSFBQyYBjyUQDoRbD9Cdu8EAqzWk8GLbHHESMdMiXY4ZQhOCMaHnDetN5IbgaZWeTOT0xMYH5+Hp1ORyiTvC8AggPTc+x0ThrWjWtcCCdyeh3ns/Ow0MtlGwsy1wjT0PiR/k3mDQV7YWFhBNvnYWXEw5CWz4KJP3o3FGqLxSJ5lV6vJ5Ekk4qcBEoMnnAOE5ePHz9Gr9cTb5MJSGL54x5s0mSbzSYODg4QiUSwsLAgFExCX7r2wmq1ylhZJoqZf3G73UJP1VATDQMjWafTKXk+HbFwT5jA1+2P+D00NixK1JG9hop5Vgjh6IaEfDYXqRHiWlhYAHDKGnM4HNLTj9F+KBQSr5xFm6FQCNPT07DZbCNJ7V7vZHqqEWrRRoWEC83WCgQCIxMmaVB0O3ou7oHFYpFuvnQGGZEQQiZdnhEinZ7hcChnifs6zrp06ZLQifP5PMxmswzpY26v1+tJPRFwYoCSySSi0ajIEevFAAi9l2eYDUB5f2zQSz1EopIeWNbv9yV/yDxLqVQaGUxIg0hDQdSH0DJ19draGorFojhD2mBTR553ndu4pFIpUU700qhouBKJBObn5yWM6na7UkhGJeTz+fCNb3xDBoLxYlkMNTs7i9nZWemDZTKZBNKyWq3ClU+n09KZlp48hYYC5HK5EI1G0e128fDhQzF6x8fHmJ2dxTvvvINisYgHDx5IyM1alEuXLgl+SWZRPp+/UIU+ABlFWq/XkclkYLWeTCkMBoOYmpoSskSpVBpRyFarVaqi+TcOGpqcnMT3vvc9IUdwzzweDxqNhvTN0jx7Ci2xWSa8WVlcLBbFO2KUR6YR638AiFG02U7miD948ADz8/P47ne/C6vVihcvXgg9N5PJjL1/77//PrrdLu7cuYMXL17g7bffxjvvvAO73Y5nz54hn8/D6/VKgpK5jOvXr2NpaQmrq6v4+c9/jqOjI2xvbwOA1AkR1wcgSWnmlrxer9BCp6amsLKyIhFQr3fSOy2dTuPg4ECeB1l0/CGMQboyi+coq/l8HhaLBfl8XuqtiMPzeZFMcZH17rvvCvpQq9XgcrnEQB8eHkqJABuV1mo1HB0d4erVq7h27RrW19dx584dVCoVqZxPJBJIJBKSByW8c3R0JFi9zWaT/oM3btzApUuXpPOv1WqVmjX2i9MGhntB3QBgZPwDSx74vHTukgaZNWY0RuOu999/X6jZbBA5Pz8Pu90uSrnX62F5eVkYtQBkyGEqlcKTJ0+k5qrdbkvEyrEguh8jcNqGKBAIwOFwCJuTCAVwMq4kl8vJ2eTId6IHRuPCESmUY0ang8EAv/zlL1EoFBAMBgUyp3Epl8tCTDrPOrdx0a0n6CkwTNMJTNLwGO5ppc//pnVl5PMqOjPfx6Sp9o64NLUUwIiHT1yW/00MmNfFCIAMCybFONGNxZc0qDrZ+7qLOD5hOVbT8vp1bzNgdMwr6b/8HUkJunJWF5TxX72f2rgzhGcykLknwo3G31HAuc/MJ0SjUQCn+DeT+7xWXfXLz7uIcaaiIeRZLBbhcDiklxehQp2HO4tIoKNB5rcI41Ju9b5yrzSmzwOrK6d17yt680y8akIGf0eKvXF/gVOqPj1yXuNFliYtsNiTnYar1eoIq47OI2EgGl9d5c5zy04NzFvxHvU+8J6YcGdE8yokQH+GpplrvaCjZl6bJv3wefB7aHTGXbqnHp2yWq0m9SfMh+iuGNSF1DNGncb9YEcTALKXvEcm1TlCgpCaHv71m3LB2rBQh7IXIT+L55xyDJwWizJqoj44bwR9buNSqVSkmpwtQbhpGxsbKJVKMmKUBxo4ZaiQrdFut/HJJ58I+4rzxkkp1Jx6rXi5KcTCif8TxgBOm1LOzs7C6/VKdBMOh/HWW2/BbDZja2tLEpD37t2TXMBwOMTMzAzm5ubg9/sxMTGBXu9krHMul/tSuP6665vf/CYGgwEODg6Qz+cRDodx48YNDAYDKagkjNfr9aSye39/H7u7u5iZmcHbb78t4TIjGmLcrO6emZlBJBKRLgk0BD6fD4uLi3IQmOycmZnBxMQEpqenhWVz+/ZtofYy/6WxXKvVikuXLuHdd9+VXloMo3WU5Xa7MTMzIzUHhGPGWT//+c/R7/dlFs7q6ir+x//4HyPQiNvtlpYwmprNjgGE/Qi3JpNJXL16FfV6Hevr69LFgPJFh4cReTQa/VKVPLtVuFwuObSUSe6HhmP4N7b6oYPA80TjxHwVk91k71xEBunJ7+/vY2dnR+rFzOaTThDE3N955x3pg0X4mw4OW8IEg0H0+30h2XBeC6+PDLROpwO/34+VlRUpFp6dnRWlyTxhv98Xww1AChUJeR4dHSGdTgOAQGrsdszor9PpwO12y34VCgUAwMzMDAKBAEqlkhQmjrPu37+PXq+HVCqFo6Mj7Ozs4O/+7u/kOgiVkjxCnXVwcCAzk9g8lXmmZDIpRIGdnR3Zt+PjY4TDYUxNTUlejiMJCP1yn0lyYf6H3RXIFKOxJdLEuhpSnQkt0yAzL/fee++NDGVkZ/SvnC3Gw6HZNBaLRQb4aOtM9gY9Nk3j7PV64i2R3USYRie3tDLn+xhyU8kxyUtcmkwITh8sl8uSpCVThe3+SRRgiD0cDuHz+ZBMJqVokBtuDC3HWTwEnK3AxHKv1xOIIRgMShKQ1FPy2jn4i+Ewm/PRMyMVmF6l3nN6nj6fTyr6+Tq/3y9V44QV2IqGcCAjHU0tDgaDmJ2dRaVSkRoo4DSMp6dPI8lc2bjK8fDwULBzQjtsp8+GkowIgdN+V4Rwda6JHjAJHEYjwCJHAJKLYi2X0Utm9EdiwFnRBQ83nwk9fkJGOqKgI8Z7YPIVOM0ljrv42YQ1S6UStre3BfLkoD+26XE6neKgEKNntOD1eoWiT8hPow86giHDkQ1VCd1SyesoW3vZulCVnTkAjMBthPCoGKk7dILcZrMJAUB3vn7dRdiLEHOj0cDe3p7kjylflB2eGeYdAYjeI7OV0B4H1LH3XLfbHYlQWMhIxqLOKRFF0qPMeR38HgAjCAwp8jpBz9o7DimLRqPSe47OKhlr51nnNi5LS0uwWCxYWFjAxMQEstksnj59ikajIQee7QR0mMbkZrlcxuHh4Qi3mt4b6Z12u12Kf6iMmJSld8NNWV5eRqPREIycm2az2cSLCgaDuHnzpuC6vV4Ph4eHyGQymJ2dRSKRQKPRwOHhoRwUegBbW1uy2ZOTkyP1CeMsGk9GRuVyGXfu3BFKKnNUzB8xWuOBdDgc2N/fHxmYFg6HR1pvMH/Dee2cdqi9QOLXy8vLUpXPTsp8ZlSSZODws4CTUa8TExMYDodiqHWlPFktT548gc1mk8FOhULhQl7j7OzsSDRL5UMvmp40GysSuqVSojKlYSH99uXLl+h2u0IrZlFmKBTC5OQkYrGYyAplix2A2+02MpmMNH0ETme/a4PCg2mz2TA7OytMKk0zBSB9nfx+P2ZnZ0dglXb7ZNLhRZL6uu6Bcj07Oyv5DCqazz//XPbEbrcjm82Kk7O/vy8RL4sHmaSmslpcXEQymZQiR7/fj1u3biEajcLr9aJQKAgphMqahAsacEKgfM5sxWQymXDp0iXEYjHU63U8efJE4Fg6qzR4b731lhg6Vr2zqeQ4a3l5WXI3yWRSKOOsmWPnDNKTaRhIDioUCtjc3BRnmAWhJDtMTU3JtZKVSEeSLFvKcqvVkmiN57VSqYx0kWCdG1vD0DjfuHFDOjPs7e0JWUmPNyiVSuJ85/N5kXvdZeW3rdc2LouLi5ienpbKUyYv+/0+ZmZm8O1vf1t45vQwWXnOgVk8dE6nU+oHotEozGYzMpkMtra25FByBoJuVGe1WrG8vIxOpyPDqHRVPTH4qakpJJNJ6UXWbDaRSqWQy+Wkvw6t9GAwEOYar5dh/9TUlBRejrsYXrLn0Oeff46PPvpIkn4AhBUCnBZbEoYknGG324VtFovFhAHECIaJfE0Z18bl+PgYbrcby8vLEqHRe6IHywPt8/kQjUZRrVbFuExOTsLn8+Hg4AAbGxsYDE6aZYbDYamHaTabePbsmSh/q9WKfD4vtNdx1szMjETHVJKMMMi4yWazODg4gMvlwuTkpORf2CKIPdA47K5YLAqUQuNBI5VIJHD58mUZKpdMJiWSK5VKWFtbE7JEpVKRAjttXJi0J5xrtVpx+fJlLC4u4vnz5/jss89G6kNisZjAYKwxyeVyUgx6UcaYbjHCnNnS0pKcP5fLhe3tbXz22Wfwer3igDx8+BBbW1uSiCYMZLPZUCqV8PLlS3g8HpFLDjfj3rGuwuPxSJ8rElIIeVH5MzGva+cASKW5xWLBlStXMDk5iS+++AJPnz7FYDCA1+uVuhOesdu3b8NqtWJzcxOlUkng2nFlkHR0v9+PmZkZ7OzsiHFhdTtZrOz+zv5/4XAYz58/x/3799Fut0fo/sViEeFwGAsLCyOFjjROZMER0qKBWV9fH6lZAyBOOI0LSSmMdKxWq9CN19bWcO/ePdTrdezv70tvQbadKRaLwhAkuep1Omyc+5XsicUvLJfLIqz0NtgWBMBIqMrWAvQYOBDLbDYLlZPJQPbg4YEkPx04TYIx0c2wl6FiKBQaeZ0eXhWPx4U3zhoWCjdbWrAA8/j4WB6I9qJeZ5bBWfsHQDwDVkEz38TDzpb/OuGnsXjCPGbzaftrekE6aUljyMQ/62p0uK1hDF6brhmigacC0LAPv0eze+g1ssByMBhI91XCAeMqRxoGKiLKBSEPPmfmBBjhED4l7ZXeHA0VlRgjF+4Hc4Ks79H9lghh0VjrAWqMDLh/uscaiynpcfp8vpHmnoRz6Akz6qJCuWjkwnknbLlOSJQMJUYQhJx4bWQpMXIgi5JUV1ZyM3rm/jPXRoWlYSN67/w8Lbs0pLpXF6M/5gypKJl3NULW3W4X1WpVyArsRcbnP87K5/NSCJ3L5VCr1QSyZLkEiUAOhwOxWExILbo8gnqFLMB8Pg8AQioiaqFTA5o4QVQHOI3g9X+T/UmCDnM4jIJp4FmYrq+HhoVQJ3NiJG+9zv6d27isr6+L8g0EAjg4OEC9Xke/3xdvtl6v4xe/+MUIDZBhHQv6yPsmZssW+DQ+9FyIC3OsLSMbFjQSPrPb7dJmfmpqCgDkUFCovF4vZmZmBGvkw75//z68Xi+uXLkCr9eLg4MDrK+vIxAIYHZ2FiaTScaWsnJ5XK9ne3tb6kRarRYODw8lfGeYyodot9sF7trd3UWhUBBFT+G22WyIRqMSsWg44fj4GNVqVaidxLk9Hg/C4bDgqlS8FHjWrtDo0ZDVajVks1n0+30xgHzGnU5HWEU3btzA0tISnjx5gnv37qHX6+HSpUtYWloaMTjjrCdPnsj+HR0dIZlM4oc//CHsdjt2dnZQrValiwANx2AwkNk2WpkDp/NJ6IlTLpLJpLxnYWFBIDcmMomX6xEG7Bem2VWEE6vVqhjrfr+P7e1tZLNZuN1uLCws4OjoCBsbG0J84X5zYFsqlRJ6M+Vg3PXixQshkKRSKYRCISwtLcFut+POnTvY29tDMBhEMpkUIzQYnHRyTiaTUqdBZyOVSiGTyYhy1O1DiEqQqktDwsJTs9ksUTuNVqVSERTi8PBQuvzyGbE+rlKpSCHn1atXpcCZOQjmOVjMSJq1JhqNs1ixvrGxgf39fQQCAczMzEjRKI0ozzWhJ86LItTFlva9Xk9GPMzOzmJ5eVmgZHYeYK708uXLCAaDAt0yx0W9wPNLvct+ebVaDfl8fsQx2dvbQ7d7Mmr60qVL0q250WggEokIRMocIXPB1IFfec6FnjZHZjK0o7Wj0meCnFW7ml6nKbFM6tE7oWdBKIz4HplRZELQG6ShoJDp5BW9INaWkJ5MVg/nlBMb5TXxARnnbdCqX6S3U+Vfho9RcBiyWq1WqXyl10xPm5ELvx8YpV5rRUPIUCc2jct4T0Yac79/2gWa38HIhVAUnxEFmsaM+8JwX+eBNHV93P3THhO9MkYUhAz4XTpS0N4f75+/Y9LXYrFI9KB7KZEiqusnKFuUSe41D/tZ0ZkmQmjSBSMpPgM+E+YYLBaLFGLynFzEuBhp6rrgkEgBAPGQ2daHUR3PJnA6c0RTe/lcOGiKiIKuQ9OJe12PdBatm9/BvdAyTwXKTgzsekCZ07kL1hsxahq3EJr7QQeHHQYYteh74zWx04jutq3vlSgGdQLPlUYvtHzw3vUPnymfo34efD0A2Rd+J8kkmhKue7hx/+gw6VzwedZrUZG5waQk/+QnPwEAoSKTYcKNZkgFQCpzmXSmoiHMwPbjpMAyVOt0Onj+/DlSqZTQDwFIziYcDsPv9+Pg4AC//OUv4XQ6cf36dcHO6RURwtBQF635zs4OvF6vdL5lVORwODAxMYFEIiGJ/nGTgf/4j/8Is/mkEzQPxMrKirReCIVCgqXS86JAaViQiXyXy4V4PC6HWzNTGo0GrNaToUqtVgvPnz+XCl56J6SA82BzMXmsoThO8ux0TjrfOhwOocXy9d1uFxsbG1IMt7CwIL9j1HaRde3aNQCnLC2LxYLPPvsMAOT7GbbrSI4Je+aNNJsOgNTjcKzxtWvXBNOfmpqSSBKAODzZbBYbGxsoFApywP1+PyKRiMw3Yi+mZDIpz81ms2FpaQnRaBTlclk8SiqEeDwuo5v39/dH4DJ9wMddf/RHf4R+v49cLodSqQSz2Yx/+Id/EEbclStXJMIlDEoPu1wuS+RyfHyMTCYjzSOXlpYQiUSETMJhfySj0PhrUgxnK3GOE6Hb+fl5ye0cHx8jmUwiFAoJ6YdRArsyT0xMoFQqIZ1O4+joCMFgUPpfUTY7nZPmkRyiNy7rk85qJBKRvn/sqEGn4eDgQHTVzMwMHA4Hdnd3hQBC3abhV6YJWDTNSIFRIA1itVrF3t6etJDipEvtuLBDCnUVO8KzNQwA6SFI4pJms9HgF4tFHBwcwGQywe/3w+l0IpVKvRb6cG7jQpYAPddYLIZbt24BOKkQZfdhsqJ04RgL/1jJTUhGHx4qRypAekGDwUCa43m9XmnJEY1Ghc8dCATw4sUL3L17V/rykGdO5UkGGr0CetzAaZt1MraojDweD+bm5oSZwi6o46znz58LIYJedzwelwp348wbRoo8RDQ0pN7SY9LRBACJHgOBAMLhsGD12WxWmCxMyhkjFyou7UHRG+IhbTab0uWA7+FestbGYrEgGo2i0+lgfX1dnh0LOMdZk5OTAE7zacViEevr6xK92my2kWiX1NBMJiPT+XROifev8wBMBFNZhkIh8T65L1SwmUwGhUJhZNLm5OQkarUaVldXZYgTjRyT6NPT05iensbGxgYODg5Goj5+BnuksQ0/Pf+LGhcOXGNrkI2NDfzyl7+EyWTCN7/5TUxOTopM6JwpC1RbrZa0iSkUCjI6IJlMIvgvo3nZ/HVyclIMN3DaVkd77MViEfV6XWA0naegUdfdyH0+n5BPSNnn+eYz8nq9UufF66aRBCBtkcZZmr5PVh/PJiHifD6P58+fw+Vyod0+mey6v78vraN43nQOihEEozUaUvZ3A07PdT6fl3ESetw5c1d07Okg0tknMkOWLtEhMsG008V8GhmQExMT8Pv9Qv//yo0L6adsH00hJQ7OhJHODQAQb4E4eL/fl+l+R0dHI7MJdE0CIx8AUpUaDAalaGt6elrYIcViUVpocGM1U4oPS4eHGprjPRHfpNEzmUyC15ZKpQvBEsvLy/LduVxuhOa7sbEBq9WKUqkko58JsySTSczNzaFeryObzY4YEn1wDg4ORtg1lUpFPOinT59KEpnsknq9Lmwmkhn4w1oRJquprGl0yHBhDzLmfdhsk5XLpN+SycNIZ5zF9zFCYZEh80M6SUxoS1fUa4iMe8SENgtM2ZDSGNFVq1V0u13kcjlks1ns7e2JIY3H40gmkyLPVCi6kSIhVQAyubDfPyni5MFmhJBKpQCcsDOpMCwWi7B5LpLQZwsnOjH9fl960fV6PclLELJKJpPodDrS2qbRaAgJhkrN7XbLXKZkMgm/3z8yhRaAeMJ6TAZbvjSbTUQiEWltRDosi6T5vHhNNHYsiuVez8/Py/z4x48fS1uVQCCAlZUVYQNeJOdCp0yXUwAQMpMulSCUyjwTKdC6EwdRi7m5Oek1yK4TnU5HSBTdbhcvX75EuVzG7u6u5Ew4M0vT21lLRidfR/TUy8znEP1hjR8d/KOjIzgcDly9elXuW+cNv3LjcunSJQyHQxk4xGTUYDCQHkR88AwRSb28fPkyCoWCFGyxpkXPtGdtCvE/Ri5m82l77ng8jmg0Kn14AOBv/uZv8OjRI1QqFfFkms2mdAzI5/MSMVFZ8FD4/X50Oh05MDMzM9KunsZudXVV6k+ojMdZ77//Pvr9Pp4+fYrt7W3pD2QymZDNZuXQkdZND+Y73/kObty4ga2tLWxtbYnXB0DyIcViEffu3UOz2ZS6lc3NTdy9e1d6mOlJnQBkSh4AiTR1Dshqtco8ClJ7iYHn83mkUilsbW3BbD7texQKhTA1NTUy35seKSPCcZUjDSqdBrKFAIxEwgz/yRoj5g98OQfDFvIc4+z3+5FMJuXgk5mUz+dRq9Wwvb0t3RR4wL/5zW/i9u3byGaz2NrakpydXiQ9tNttHBwcyCTNxcVFIblQ4W9ubmJ2dhbf+MY3xAkDTnJZ7Ao87mLTSeYsu92uQK68TzpoHo8Hi4uLMJvNyOVyyOVyqFarYqC45+xmEYvFcOnSJRl0Rdye8ppKpUb65bEXVrfblYJi5jNY1U/GGqMoyg+jZzqIFosF169fR61Ww4MHD/DZZ59haWkJly5dkomqwIlx3dnZGVsGGYWx5oO1UoxKmbujzPP+6VzRmdYM15WVFXzwwQdoNptCmeb+TE9PS0foX/ziF9ja2pLoATid8Lq8vIz5+XmBWQFICkKXIOhCdJ55XhtfB5w4U9PT03jvvfdgs9mwt7cn+lU7t79tndu4kFHEhBujDGLzxJXJvOFFcIATk1Zms1lYSWwPQeuqPQEmqGj5id8yiaaLKnWHTwAjNFxeHxOnFG7dK43hKj1IAEIAoLDr/NA4i0pdU4A17VcztPg3nXQ1m83SLpzKiiE+PRMaafZE4/Am3q/uZcX71gk8Xge9HHpY3CtixewxpI0tr0sPcGME+roez1mLh2YwGAh2zHyTTnySAMEok8pY7zmfJ5k3+seYM9RsHMJCzN1odpcepETniv9Pb5ZKmy08SAmPxWLSILNer8sMFZPJNFLFT89y3FUsFuWZMlo1RuMkb5Bso+FtshiBU4NOqIpJbe4zjaKGw4gqcA+1I2rcLybyecZ1kTOLBHUlPB2iUCgkpQUsHeAMeH1d4yyiM9xD4zMhuSn4L+OVgVPige4uzL3UJA6eQz5zOhZsREnng7pOfzbl02w2SzqAqIOGg/k9RILoUFIHM6LhfeluKIxICcWfZ53buPAmgBOBYeENcDoTPBaLYWpqCs1mE+vr62i1WkLb48WbTCZp28H8iuZ0a0iNkcjk5CTm5+cRj8elMIlKlUkyRkoAZOQoD/VwOBT22vb2Ng4PD2WjAUhfM3bvTSQSuHHjhoSINIwXqXMhtu71ejE1NTUywnZycnKkdoL7ywdNr2FpaUmSqXt7e0gkEtJdmvdD74xcfDYJZS1HIBCQhnQcxERcFzhJju/v70sUNDs7i4ODAzx79gztdlta8Gsvkwl19lCqVqvY39/HcDhEIpGA3++XaGtcWPHhw4cwm81YWVkRmJADtWi4iYMPBgOhTnN4ksfjEWi0UCig3W5LkV8wGEQ8Hpf2OJybQogGgFRYv3jxAuVyWbzpJ0+eIJPJyN4SZiXc2+12JZfi8/lw69YtGaRFxcQonLPnC4UCvvjiC5jNZly5ckUahF6kuhwAfv3rX8Nms+Fb3/oWlpeXUSgUsL6+jn6/LzkOdlJwuVwCa7ZaLWmN9PWvf30k9zM9PS1dJ/gZNABsMHp8fCwQ9Pb2Nh49eiTdNYATo0fjRDLB8+fPkc/nxQiHw2FcvnxZILBIJCLGgqQC4ASGv3XrFkqlkgynu3nzJhKJhDA0L1JOYLGcdELmwDnmd0iHn5ycxMrKikDVrVZLCqFJHOl2u9jc3JSmuI1GAyaTCdPT07BYTrqgxGIxlEolvHjxQmSCxlZTkImylEolWCwWzMzMoNFo4PHjxzI3yul0ot1uS5R3+/ZtTE9PC4vz+PhYrpWGslwu47PPPoPNZsP777+PGzduiNNz3uj53MZFY5XGJBmtIjv98vXD4VDGzgKjI2HpIes8AT9L/0smC5Uii5Qo4PRstDXX9Ej9O0Yi1WpVEoO6iIv0ZFZJa1rjWZ/7OovvJSRHw8bIjMabwqeph9xnVtGT/ULGh74uQgYsTtVRF70jGjb+v67hYHJeR3B2u32ENkpPlXvExCnJCIxU+Rz1vYzrebPCmngyWWH8fH6H1WoVPNrotRGHZoRIhtJZP4QQGIHTmybrjl42qfmJRALhcFicHlbeHx8fSzdbwruEgKgoAoHACE2fXQD6/b4McdKkl3FXPp8XkgyfKx07fj8p/KwDYl6QOTXOGiFExSJTRr98BoyQNZWVMA3zL6Tm6g4GAISKXalUxHhQ/tkSxefzCXxstVolCqSh7Pf7UqfTaDRkwNxFFqFlRhfMMbLQlBBYJBJBvV7HwcEB+v2+EHj0pNvDw0M5I8yDch85GI57QKaeEVbWOW7KM0lHbKfD15M5S/g6FouJI8BnwRwO75WQn9VqHcl3f+XGhQV7tK66ZkBP5GMil1REQjJMvDkcDiQSCbjdbmxtbYnnRCEERuEasr/YXZcFRBpu42HgBnNDGXVQWVBB9Ho9RKNR3Lx5UzrsMsdCRUpPgA+bdT3jroODg5HIjB4LPSlCf1NTUyM06Xq9jkePHo3Up8RiMSQSCbRaLWxvb6Ner+Pw8FCiIxpEwhuTk5PSx434uK5XYDU4MVfOzQAgdNGpqSkhSpRKJWFgDYdDCfmnp6dl3Ornn38uitVut8vEvHEXoapyuYytrS2ZWcFWQOFwGNlsVqAfVk4Dp7kpMnZ4kJvNJp48eYLp6WksLCyIEtMQXqPRwC9+8Qvs7u5ifX0duVwO/X5fDub777+Py5cvi/JgNFcoFFAsFmV0N6dNkrWTyWSwu7srOUXmCo+OjkbaJO3t7QnR4yK92QAIc+3FixfS/ZkJ5Pn5eUxNTUm9CM+ghmHpUGpoiZRq0pAtFovIHfep3W7j6dOnyGQyQle32WxSgHjlyhXMz88LfBQMBvHWW29hampK8hckWmgYif0KCZHzmRK+0oML0+k0stnshQp5GeHTOPT7fTx69AhW68m48GvXrglduNfrSSdwOrSMzGw2G6anp7G4uAiHwyGsQxJDqOg5nZZUaw5sBCAwIUsVrly5IvrT4/Hghz/8IY6OjrC+vo6trS0EAgEsLy8Lg5H9yUiFpw7lNevWRYzWSaf+yhP64XBYsDyGyoSjNP7JEC8cDotn12g0EAgEpDL/ypUr0qplf39/pDDHWMxDyu7k5KQosXa7LZ/LA2nEuQFIYp+eKnHzbreLSCSC27dvS+hZrVbFstO4kNoXiUQklzHuOjw8BACJUgjpMeIjHj89PS1RQLd7Mmxtf39/xPt56623EIvF8OzZM+zu7sogqV6vJ51TgVOPaGJiAtFoFLOzs3KgWQDLCYA01kwQer1ebG5uYmdnByaTSZhDjx49QiqVGmktT/hueXkZb7/9NtbW1rC/v49GoyGhOGsCxvW8iVFzHjibBrpcLty6dQuJRALlchm1Wk2UERPCzO3RmE9OTsLr9cqUTnrv2rgwImo2m/jVr34lPaFYzMsutW+99ZaMUyCFnWyo3d1dmEwmgYuZn2CtyaNHjzAcDsW48DqoyFk3AUA6VlyEikxm0NbWFl68eCHPjYy5ubk5ab3CqI+RLCFsDotidELizOzsLK5evTpS2EpDPhgMsLa2hrW1NRljzsagwWAQKysruHz5skRzwWBQ7pdRN4tzmbuxWCyo1+vY3t4eiQx1YSc7+tLg7+/vY2tra2zjwlEjZL2VSiXs7+9LBT27U7AHIKndW1tbSKfTcu2hUAhXr17FwsICUqkU9vf34ff7EY/HBR4n5Z1D1tgglQ4m0QeLxYJ4PI7FxUWB7i0WC65evQqLxYKf/vSnePLkCWKxGG7evAm32y2flc/nBb6mbtW5Mzqo6+vrI0Su865za8u9vT0AkMQwE+haWVC5cxNZHElqIgWViposLEIy+qEHAgFcunRJ6IQULioAt9stTCbCHYRtyMzhv/raGKLratZgMCghJz+H0zP5EFlvMO6iN6fDX3LkCSWRrUOlPxwORUiB08JRGnkAwqdnsg84Tcoy8a73hl2LuZ+EtPhdVqtVrpUCCECgEH4H21xouLBQKODhw4fY39+XppDs6AxgBNN93aXrJeidcu9Y2MlaK6/Xi4mJCdjtdjFGWrYYxbpcLmnvwoMZCoWk+I4UdMJXxm4GzDc1m02J5Pns2u22eKNOpxOHh4dwuVxYXFwUA0OYxel0ygA4sqcYeZGiy1HcF4lc2NJDj7klfJfJZOD1epHNZlGtVmGz2aT1PjvnEqPXz5BOj8lkQj6fR7fbRTKZlE4JbBOkm42SsVQsFgV+I3JAGWM9HPe92z3prG2znXSW1sXR/X5fii511MkSCBYiUjmPuzRhiAgIHbVCoYCdnR2JLkguMSbygVHWIuFaMgb7/b4wuOgIMwLk64io8LuB02GORHaq1aroW+ZK1tfXpcxAV/1brVapuaM+0VAf85LUB1955HLnzh1YLBZR+PRYdRsQCisfhNV6MmZ2bm4OpVJJCsMODw+lWzIr8ymM/Ly5uTn8/u//vkAKHHVss9kkZ8GGlNFoVB4WD4pmopEFpKOiXu+k99hgMMDi4iImJiakTxIfhNVqxdzcHEKhkGC94/Lk6/W65I/YF2xxcVHoyaR7Pn36VITPbrfj937v9/Duu+9KjQFwItwc3haJRNBut4UqSuiFDSq5r+wqywJTNvWsVCo4OjpCKBTCxMQELBaLJKQ3Nzfx9OnTEZIFmT+BQEDmrxOzffz4MdbW1oQRxOfDnAEHeI2zOGiMTCPgdDbG2toatre3pXdaPB7HO++8A7fbjVQqhadPnwrLjTUn7XYbi4uLWF5ehtPpFJosOywXCgWsra3JYdKdZQFIZTR7ppHazvG25XIZ0WgUy8vLODw8xC9/+UuYzWZJjBM60xXnhHk1G4pR2a9+9SvkcrkLNV5cWFiQAt1Wq4VqtYqDgwPUajXcu3cP29vbwvRLJpP4xje+Aa/XK0llEh/MZrMoPp/Ph0QiAYvFgmfPnsHhcMjes9K+UChIJE4ohlGgz+cTyFt73ozSee62trbw6aefYjg86WHH3nuM5qgM2bLHaj0ZaEcGmdvtRrvdxsuXL8emc9NRq9VqyOVycLvdQs54/vw5VldXR9hWNGo6xwqMtmpxOBxScJxKpURH0cFlHRQRCW2wmPfpdrsol8sIBAKIx+NoNBp48OAB8vk8KpWKFED+5V/+JaxWK775zW9ifn5edGgwGMS7776LUCgkVHvObrHZbPjud7+Ly5cv4+HDh/j1r3/91edc2PZFU3h1Ih2AbBgjF53I08k9ssaYbNWbzkjG4/EgFAoJy4LMEJ001LUruoqaykNTh0nV07Rj3XuMiVzSfXmtxoKpcZOCGmphcR+nxTHcpxfJa+J9Mrw3FgECpx2R2ZqbyTxN/yRGTWGicHJfNA2cXjujH+CUZszP5OGgcucPITZdzMjvopc/7mLEyuiA0STlgXvLfdCU77Mq8WkMjFX4vBfdlUAn2inXRtqxzhmyMl33PdMDphh5cc/5PmO3BUY17Epxkb5YAKQokc+GXjKvQfeS0rKjv5O/Yy6ExA7KDaMVRiiacKLlkFRvHQEy8tB7qOWUeD+LgYlGcH81sYXdQhhZ6X5xFzHQerHo2mq1ijPLxruUP6IfzP8QfuUeUIYJ91Pn8AxycS+Ye+Rnksigac10+hn1ABBnmhESnQON5vB93FuSKVjArs/bufbnvBvJ5nGci1Eul5FKpTAYDKRrLKEoh8OBeDwOu90uRUFszQFA2vYXCgWp8qeyYtdddqel9w2cGi9iwex1ReydHjIPK2eb8CHzO8xmMwqFAu7duyceBrH4paUlaeFAZZ/P52XU8biLxsLr9Uryk0LG6IjFh06nE1NTU8JG6Xa7yOfzePDggVBJw+Gw4OBerxc//vGP0W638fjxY+zs7Mj3Op1OGXYVDodF2BhidzodMdJk8TCJHw6H8eGHH6JWq0luZ2dnB+VyWbBz5oWOj48RCATwgx/8QA4H29eQXsr8xjiL81R4sGKxmPRmo5IhHGUymbC2tibPemlpSQyEx+PBrVu3EIvFpMcaDy0VAZOcjJI5i4T9vnggGWFoJejz+fCtb30Lx8fHuHv3Lu7cuSOUUwD44osvsLOzg2azKd+dTqeRz+fF0+TyeDyIRqMi67FY7EIy+K1vfUuo2NVqVRSzxvD1hM/NzU0AJ3Ama0fYkv/27duIRCJSt8MBaswXsrWLJvgwWc9uwSR72GwnIzzcbrfoDc4H2tnZwcOHD+WaTCaTDNzK5XJCtmEHDRp1Rog0KMw9fvvb3x57D3UPuEgkgng8jpWVFSmr0OgNW65YrVasrKxgcXFRuqt7vV4sLi5ifn5ePptOIeE/zvGhY81/qf/C4TCuXbuGYDCI5eVlGTRGA88O0tlsVnqQEa1YXV3Fzs6O6KRGo4FPP/1UEv1kmlKP0mnUxbfnWec2LqQNEt8n3XU4HErylBdCCMLtdqPZbApdk1EODRULg4DTqIXtJMib15WuOpLgDxPRzO8Ap54g8xqEQjQtli1rnE6nsKmmp6cxMzMDu90uvG+G7+zlM25Cld/L5KP2AqiAGXJ7PB7p58Pohr1+iJmSBsxWGQsLCxgMBtLxQOfDQqEQEomEfBY9fOK93B/2V9vb20OtVpOqa9ZfMOrkVE8+793dXRwfH+O9997D8vKyPBdNK6fXfhFYjNERqb9XrlwRDn+32x2Zka6dAY64JlV+ZWVFhnG5XC5RrtwzkhV4qDlJkFAfHRh6qLqtCA2fyWTCF198gY2NDZFZk8mE/f19yW8w58bzkc1mUSgURorYSqWSFPQSGhx3UUboxTscDun3xui8UChI7QPzGIRYWUZgMpmkbQllmAl45k04gZbPhjR6Gmx67dw7DqpilKYZdNvb21KQSyeIESbPPOE2vqbT6UhExYgsEAhgcXFx7P3j3uuRApcuXZJuI2SmEQKnU0vnu1gsAjh1GmKxmEQawGnJBEc5MGq2WCwCUZEB6/P5pO1LPB5HIBCQEoLhcCh5au4hc6pkKrILgm7rpPs96hIRHY3qaOi3rXMbFwoRE/JMZhFHJq6noQLSXNlugDdAmrKmODJpyrnm7K/DfAwhn8FggGq1ikePHom389Zbb8nDYcNHANIUkkqDycVarSafaSQK8AHzIVIwCV9dZDFxTzorcxbsU0XPlfgrw1i25uBeMKIiFdNqtQqnv1wuC/MsGo3KLA4Wn/I5cBH+ogEl885kMslckaOjIyEDXLp0CZFIBNVqFblcTiAKFqpScNmnigxBRl/jwoq8LjLb0um0FHlpiIGePqmVZP+RnUQYh/fNmiedhNYQFz1JFl4yec28AFmSNKjaq+PzCgQCMthMH3gqJCZQSVLg5wOn9T0sDL6IcaHcvXz5Ejs7OyOwJTttk31EnJ8QCSEwti0CTupm2NdPOyyaFMDXZrNZKT7lvhDqY4mCZswZIV232y0jmel4sS4NOE2yc/S3zWaTiJFFyK/jdZ+16LTpjiOsBWISnvAS84O6s4Ce/0IWpU4lEN71er2Ix+MSqeihaSRasNktDSgLpSm/ZNGyRsntdkuNEuWNZxg4ZfkSBiUc73A4pN7l4OAA+Xz+q8+50LjwYQGQDWXCm8lP4n0AZMQsjQ47fU5MTIgSInvEYrHI3xmCHx8fSwjNTS4Wi/jHf/xHlMtlzM3N4fvf/77Q6owPieE4P+/w8FCYQhrWIJ5NK03vgTgpw9yLLDKbyEwj7ZhDl+r1unjHjEi43xwDoOm1uVwOW1tbI3kh5gWi0Shu3LiBUCiE+fl5RKNR2T+jcaFRqVarI2MF6CHq4ku2LP/888/x6NEjgQDMZrO0cWethi7YYl+tcQ83C3GZsyiVSnj8+LHU/Xg8Hly/fh2XLl1Cr9cTthpwIrtzc3N49913YbWe9ExjkVmtVpOmiyzC0zkUdh5IpVJiYCmP/KFHT0iOkAL3JplM4rvf/S78fr8Yj5cvXwq9mbAFoxsqKOBEgdPRYQuccRdhvfv37+Phw4fiBDqdTqliv3TpkvQRpLEkTKVJKFtbW0ilUnj48CG++OILxGIxfPDBB/D5fHI/HBU9HJ70JNzd3R3JRTDPydEG2rjoehYq1Fu3bkm1vtvtlh53jGhrtRqSyaTUgBWLRTGcAEai+XEWzy0VPdsB2Ww2XLt2DbFYTGrQWCza7/dHOj0T9iM5iA44o2QA0guR+rXZbErfulAoJJAcKeT9fn9kREev1xP9RSQpEongvffeg9frFVj37t27ePnypRh8slHdbjeCwaBcN7t9sNvKVx65aNhAQxt8sIxOiKHyRrWy1weHkQNhCR4sAJJgotIHTgvbeCAIz9FDphHjAaTV54Ojt2/spcSkFWEIsq6A0X5UTF6Pu3hg2EKcMItOhLKZHR8+k5z0Hrn3lX+Z2U5YT/cR4usYovO+mJxn8R+fpf4ubfjICOIz9fl8I8lsKiU+Rz5DdhAmns/6IU3XHWdpFiLDew2X8tDr8cDcU0aczAMRU2ZSnVE2X0fvjUZGJ7b5/YQZmVA1Gu3BYCDTCBmlcw+42IOKTgz3k8ZcJ96/ikXnj7lNesU8r5Qf5jR1mxueQxI2CP+Q4s5nxH5kVJSEvk0mk9TZMBLifBZNsSVMRgKJrg5ndKNJK9wj5tNI0qAjSJkjrH+RcgKefxpIRlj63nl+dCRLaJCQHfNSdGY1vZ3XTPoyz5tONbCYnBERz5RuUkmCAYvAnU6ntI/hslqtmJ2dlc4T1CfUEcxD8lloJOA869w7HY/HZXMZvnPDU6mUCEQkEpGHTehAs2I080W3iWaydzgcCnbKfkzAaZNLvp5FRqlUSowIIyST6aSlik5c8uHVarURhWQ2m8UDWFtbw87OjuDpOinHNvPjwhI8xPPz83jrrbeQyWRw9+5d8Sys1pNK8+vXr6NQKOAXv/iF8P8JKzG0v3fvHp4/fw673Y6lpSVUq1Wsra2NJJvz+TzK5bLkr46OjjA3N4fZ2Vkxpvq55PN53Lt3TwomWZtRKBQkB0TqJyGqS5cuAThlcB0eHmJ/f1+GuJnNZjx69EhgKuZ3xlmMikhyaLVa8nn0eiuVCp4+fSokjH6/j+vXryMUCqHZbOLx48dSINtut8ULpCIlFdnn80kTSU4cTCQSEkHEYjH83u/9ntwjIUQmdamQZ2ZmkEgk5PlQIQ6HJz3Xvv71r6NWq0m+aGpqSpLdNKCct6FrwsZdH3/8Mczmk/5s7777LlqtFsrlslwz82Issnv06BGazSbm5+eRSCTQaDRw9+5dQQ9Yt0TCBAtIFxYWEI/HUa1Wpas48xQcWxwOh/GjH/0IwWBQvpt5qOFwKJ3K/X4/3nvvPTE8vV5PoFfKntvtFlLMjRs3cOXKFXE2ut0u0uk0arWawODjLuqWeDwudR80MoSFNdyfSqXQbreRSCSElswcV7VaFdh4cnLyS4xMNqBklE1jMjU1hampKcm1OJ1OeV82m8WTJ0/Esfn/2HuPIEvP6zz4uTnnfDvnnggMJiAQJAASJMVgiS65JFeptHCV5fLCC2+8tZcuL7yVFy67XOWyXJLlkixLpCgSgQAxA8wAE3t6Ok3nm3PO9/6L5nP6vU1Q6rkNr/4+VV0z03PD973f+57wnOecQx0aCoWQz+clUuYemp+fxx/90R+hUqng9u3bot8Gg6MW/ITt2ckbGO7e8Q/JC3VFBo7bddOLUxP1KuuEXj//DkBouBTi5PSOubAqHZEbit45fxjFqOwGRilsN03Ih7gmDYpqGIHjCIWV7szVEOtlu2yVkvyiwvUibs32IFRyVqtVGhzymuhVM4nG6ImFWpFIRAw070dleLBpIxUfPVDVe+OasDZFp9NJQppVyFQOrMjm9EA2/FSfWbPZlPVklMAE51lyViouzZb2arsb1i6RnVQsFsXDBY49y263K8wiRomMvum9c90Z8RFW5T5kjsbn8w0V6vIsEOIym81wuVyS4KbnOBgMZIYJAInQbTabRLUmkwndbldwe56lsxgXFiGaTCaMjY3J3I5WqyW1KDQ0nLhZrVYFq6cRZt6VSXY2C6Ue4LkuFotCVmDRLc8oozqPxyN7ihEbzy2nMjqdTnlOjAg4BZNROLv8su8YAGEQMsrnHjxLISWfl91uF+ox75v5DkaAah6T+bKTe5e9GL+MrKRGPYQHGbmQkMFcNItyWfTs8/lkzQmtEdmhnlhcXMTExATK5TI8Ho/odj4vwsRMFTC/flo5tXEplUoSrjERRaXGOhYeLJfLhZmZGZjNZjx9+hSZTEaG92i1WukppiaP2KXT4/HAZrOh2Wzi7t27crB1Op0UZJHayEIt5oB4CLnpWLykRkakJdJLo8LR6/VCEFBJBYFAQNg6yWTy1At7Um7cuAHgqBfTz372M2SzWWQyGWi1WjES+Xwet2/fxmAwwIULFyTSSqfTUoDZ6XRkPgsAgdcYUVCp87n0+32hFrNtDrsfME9CsgC776o1N81mU1qdsAiRDfXW19dlo2o0R11dr1y5AgCSr6BHe1ahceX10SASJ2abHkYKNNzb29soFArwer3CbmLNAZOz3W5X4IV79+4hn8+jVCohmUxKTsfn80k3a7fbLdMc0+m05A1Pjgau1WpS30Klx8NbKpXw8ccfS5LZYrEglUoJrZ5EFEb7hDbOkjNgY83B4LjhpgoFErZ1uVxCPSUhh2fd5XJJvlCr1UpjWir/wWCAra0tbGxsCGxtNptx4cIFeDwejI+Po9c7GhhIOju9c73+qAM6SRTFX0381Gq1cLvdmJmZkf3EyJSO6czMjDiBn332mSSne70eDg4OUCqVMDc3h4mJiZELoWmY6CQUCgVks9mhM0zmGFEclks8fvxYxpmTXddoNMRp53lpt9tYX19HPB4fysHOz89LzR+vgxEL92Amk0Gj0RCn2Gq1Ynd3F/v7+9Drj7qqExliru///J//g0ajgefPnwsFv9/vD5VK0MCreaHTyKmNC9kEbB9CT0UtyqK1drlcGBsbk8raRqMhSfxOp4PPP/8cqVRK6gzYV4czNehNPX78+Ogif+Vpc0gTK7ADgQC2trZkU5N0QO+MtF8mxOk52O12lMtlweXJz+esGNbMMAHndDqFIjqq53jp0iV0Oh08ePBAkmhqNbbD4ZB6Eq/Xi1u3bsFms+Hzzz/H4eGhVJ8zGmCtkNlsluiAdE61B1O/30cikUDxV7PPy+UyotEo/H6/vJeJR/ZOAo5ZZGoTQHr6ZrNZhr9xM+r1ely5cgVvvfWWRICEz7hfzpKzovICjivzGZXQQXG73ZicnEQ6nRZP++DgAAcHB5idnZVGiCo8p46K7fV6+Pjjj6UrARlTX//61+F2uxEKhRCJRMQ4tNtH/ary+fxQPpLG5eDgALFYDD6fTzoBMJ9xeHiIra0tiRRNJhNisRhSqZQMuCL7ja3dQ6HQmbxuVrWTtUgcn+vHfJLD4ZB8S71el1wCDbNer0coFILFYpHhYWqUvb29jVgsJmeR0CxbOTmdTlSrVRwcHAzlB4gWABhqlNhqtTA5OSlV5WRWEq3w+/24du0afD4fbt++jUePHg2hItlsFo1GA1NTU0LcGEVoCFiWwJognt9wOCwGlXRgQpsHBwfQ6XS4evWqGChCY2qhY7PZxCeffILHjx9LtOp2uzE9PT2ECrEIneSVTCYjcC91it1uRzqdxr179zAxMYFvfvObsFgswk49ODjAF198MRSxMHInVZljOUguYO79NHJq4zI1NQUAQgVVlQUvTqfTCZ+dNRncxKS+AZCog4lkJvQMBoOMLaaBUGmZTPbRs9FoNOJF8Hq4MCrzi16+WvGsYo+MoPgnoxp+D0N0eg2jCNfK4/FgcnIS5XIZiURC2FXFYhFWqxVzc3PQ6/VSYGoymaRtB+9TpbQyURqJRKTYSe2iwPUwGAzSybjb7WJ8fBxWq1UYYqzrUKvJaTRarRZ2dnakgwGNmsPhEPiNUVYikUCtVkMikRAo0mazoVQqSfuaUYQQDJUfk/U6nU4waI1GI9P6mIgHjlu4x+PxITIDnRLSZ2k01JqqRqOBWCwmCoWwDiEqdd1IvOCeZP6GVdUkGrCzMLtEq7CxmthmMtbtdqPb7SIWi50JFmPymKQSKhOdTodQKIRAIIBut4uVlRWUSiUxbPTGKd3u0RRavV4v4wfIamR9yfj4uMA6Go0GiURCEAd69HRMCNVS6XJ92E3bYDAI40vt6uF2u6UJKdeWeogwIw0ni2KZH2a+8EWkWCxCo9HIjBnWznA9GV2aTCYhBxGOs9ls0gQSgBSXk0gDHI9LZl/AXq8ndGcWMZfLZRQKBemHyGiNzjVRnmKxKD3a2BuMSI06k4XRCR1SRpPc+3Qo/H4/crmcjBE4jZzauLz11lvodru4d+8eVldX5QAAx94f54l3Oh3cvXtXDpvBYECr1cLBwYGM9nS5XFhbW8Pq6qp4kxaLBTs7Ozg4OMD4+DguXbokBxOARBXtdhvPnj1Dt9uV2fCq1f2yalIWEZFip7YiUVswkEpKZhErg+nFjiqEFaanp7GwsCCbpd1uyyCgW7du4Z133kE6ncZPf/pTlEolvPbaa3j11VelRxYjgV6vJ3UJbrcbExMT6Pf7ePDggZASmGNhvoTfw9bqrKxW23MwJ0GmC9vIf/DBBzAYDHjjjTcwMzMjdSPqhLyDgwM8ePBAWpwz2ev3+5HNZvH8+fORmU/E5C0WCyKRiBxgk8mEmzdvYmpqCh9//DF+9rOfDTHz2DKkUCjg/v37sm9J2eQepbNBHJu/azab+Oyzz6DT6YTmytEIJHuwqp/NAtkt/OrVq7h06RIKhQI2Nzdlxkc+n8fMzAxeffVViX7Y2YI4OdvTsJffw4cP8emnn566xuDLhO/1eDxDA9d0Op3AVn/zN3+DP/uzP4PL5cKtW7fgdDoFrqNTwWi/Xq8PRSJbW1totVq4fPmyjLve29tDp9PB/fv30e/3MTExIWvHzhgsmNbr9XKe6ajOzMxgYmJCDDmfp1arxfT0NK5duyaGlyQD7nnSfskYLBQK+OKLLzAYDPCNb3zjhdePw8IuX76MaDQqxstisWBqagrT09PSyoZlAhxpTVLJT37ykyESCp0W1pVQ/xDJKBQKKBaLsj/YEmtsbAxvvvmmDKgDIDVVnU5H1t3pdOKNN95Ao9GQzukqJZvOw9jYGIxGo4wfIcmk3+8jEAhgcXERP//5z/F3f/d3Q212/j554ToX5jVUGis9CZVSpyZDVZiK8wRItVQTWHwfLSyF8Bs9Hf4QM6aSpCFR6c/E6pmHAY4MDRWVmuBX74nfQeVLL2pUYTR1sqqb+Q3eJ69DzZ2oypJMkH6/P1QAyjwSw2a1GFAlBXDdVFo3XwtAqM80zHyNWpFPb4wwC+ty6O3QM+K1qG28zyokZwAYar3CZ87nrtLgCaNxxAH/HzhuYspog/ej7m3eL+e2A5BKaLUinNeneoakdKo1G8zv8BlwrbmX+XwZpbKWRv3cs4hKbOE+ZC6V90BDq3YDJxTJc8pKcYvFIlAglRf3JteX+4r3oDIb+f9q7zT+H/cP9xdwXD7ANeS+owdP3dLtdoVkxOiZebFRhOeQ38kzyTwEI0PudZWVSgSBQ/jo0PKsM5dJUc8+cOycsqCZBZJcF+oqEgFIbGEXBhXKUqPfk7U/jPi4frxPtQPLV25c7t+/L39fWFhApVJBIpH4tVoCJs65WUmhm56exquvvirQRTweR7lclg2bSqVQqVQkkVculwWCS6fT0rsom83CbDYLTr24uAibzYa1tTXcvXsXWq0WPp8PFosFlUpFFAJbeLBtjdPpxGuvvYZ6vY61tTVhNFHhU8GQ1TE5OYn5+fmRk4GJRAIAZOORWstr6vf7ePLkCbrdLux2O15//XUYDAZsbGzgL/7iLxCJRHDlyhX0ej04nU4UCgXY7XahPpIBZTabMT4+Ln3euGnr9ToikQgWFxcRjUZx8eJFmM1mPH/+HKlUShKCNEhk4pVKJdhsNiwvL0vb8vv372N8fBxvvPGG5B7y+bwYX4vFgmg0KkOowuGw/H7Ug221WgVeIT2Y+Pn+/r5AXj/4wQ8kgcpmqyfrq9g5emJiAlNTU0gkEnjvvfek7oiJUhomQlsAJBHOnnVMpoZCIaFpkgLv8XjEkBAOCgaD6HQ6iMfj+OCDDwS27ff7uHDhAl5//XWk02k8ffoUhUIB169fF6ybYyZGFVbQZ7NZbGxswOl0Sn+rWCyGjY0NGI1GfP/73wcAwfNNJhOi0ShKpRLi8bgYBsJfV65cQSwWw/Pnz2VSJ58TEQHCqS6XC36/X55Fr9fD2toaCoUCrl27hosXL6Jer0uncBYkUsmyINBoNCKdTuNP//RPh7oDkAmXz+fxxRdfQK/X491338X4+DjS6fRQkfCLCun45XIZKysrsNlsCAQCMBgMkmcKh8MSBXAsdaFQENSGXcmDwaAwv1wuF1KpFG7fvo1SqSROGZ0g9j1kCxjmYfx+PywWC27fvo3t7W2pG2RLpkajIfvO4/EI5J7JZIaGv7EoWaPRIBKJ4Gtf+xqKxaK0dSIF32KxYHZ29quHxTh3nrUB9IAJvVgsFqk3oUdEy87EOJPae3t7wlig50KPggaF3VQHgwFyuRzK5bKEh8DxHImJiQkEg0FRJKSqchwnmThMVrMq2+PxCA1va2tLlCofKJPhxNJZODeqcSFmrdKeqbzIzGIiemJiAm+88QacTieePHmC1dVVmExHEzw1Go1sBEaCZJ7U63WB/tSBU1ReJpMJkUgE4XBYIIP9/X3xepgTUcNzFkGGQiEYDAbs7OygUChgbGwMk5OTKBaL0lyTCpjwCSt93W43IpGIeFijCJ0XUno5fIv5qWaziampKczNzSGVSmFtbQ3AcBR4suAuHA5jeXlZPHRGPfQ0+V5G28y98fnpdDrE43FkMhno9XrMzc3JGSj+au55Op0WQ0hGm0ajQTqdlp5ZvD+73S5Ds6rV6pD3reLiowrXgU1EuVf6/T6eP3+OZDIJh8OBpaUl1Ot17O/vC1uQUx5Zy8PIxOl0Sr6PUWSr1RJohTkP5lS4ZymEtg8PDzE3NydUVxJeTnYHZl2LVqtFPB7HkydPoNfrMTY2JlNr6XzF43GBtAkhq91DXlTYVZqObzAYxMTEhDBN1V6F1H1ms1kakwYCAYHT2PQzEolIW6I7d+5Izki9XxoTzhoiqYbjO3K5HDY3N+F0OmUERzKZHMqxkDLOPDj7jTFqJONvamoKMzMziMVi2NvbE/1HFIrtlU4jpzYuTMzx76z+ZjLZ7XYjk8kgmUwOJdUJfe3u7uKDDz5Ar3fU24hFUuxcTAiLh7/T6UgCkwVu5IvrdDpJ0jMKisfjMJlMQrMkZ/+kMKSl4uTn0QhaLBaBSQh7sOX94eHhyGwdRiqhUEjmqF+4cAGdTge7u7soFovCnrNYLHj06BEMhqOBSV//+tcRiURkXdPptNwvIRfWppA1psJQhDYGgwE2Nzclj2Q0GqVXEDcOcEycsNlsmJqaGmqyGIlE4HA4UK/X8fHHH0uYzE4A3Mg8XBzzSur1qF4j6c5sM67T6bC7uyvGmc+aRnVubg5TU1OioCqVytCYVo7aZcFbOByW1jZMbDKh6fP54HQ6ZXAYIwnmu3hI19bWoNEcjZUOh8NwOBwyf4aD4JgArlarQ7R3GjcW/LFNx9ramhAUrl27NtLaUdQZ8KzPODg4AACh6VN5AsDExISsPR0Qzh7h82Dfu2azibGxMclpOp1OoXNrNBpMTU0J4sCptjyLy8vLkof55JNPhuqA2FiR7VQYNXGfMipWSRWsgVlYWIBGo0G1WsXm5iba7bbc0yhCqJ7RF+n5jC6oe54/fz5UAzQ/Py8UbDrPtVoNBoMBsVhMioJZdEsHlHOpWMxtNptFB7JHISFpVtLncjkYjUZcuXJFShF45p4/fy4wbSAQEMo0cFQkT4ed+Wiy3dbW1iS4eJHGny9ERQYgkQlDUVbHsiV6PB4XbJWRQKfTQbVaxfb2Nnq9nng1THQRxyZOz/b9Ozs7wijrdrsCc3HDUOHz/3lgSK0lSUAVbmiGgiwOIkXZarXK9/T7fVH2vJ5Rhd7txMSENJJcWlpCr9fDvXv3EI/H4XA4JJH36aefot1u46233sKbb74p112tVhGLxSS5SIP1xhtvwG63I5FICI2UyTo2y7t37x4+//xzOJ1OlMtloWrTSAUCgaFchc/nk3HVzL9wjbe2tnDnzh3o9XqEw2FYLBZhmlB44OhFqe3kX1QIU7lcLoRCIZTLZWxubg4lR3O5HDY2NhAMBvGNb3wDbrdbWo7v7e1he3sb7XZbINB8Po/t7W04nU6pyyKGzahEpztq5MgRtBy6Ri+djRwLhQIePnwIp9OJN998E8FgEIlEAolEYogRpE71I2S8sLAAm82GbreLvb091Ot1qVx/+PAhWq0W3nzzTXz/+98/UyFqpVIRh4M1U9vb22JsuC/y+TwcDodAzmyf3+sddaNWm9fW63WBx6enpzEYDETxsr7EbDbjlVdeQSAQkGtRC1zHxsZgMBiwubmJv/3bv4XD4cA3v/lNKV3odDooFovY2tpCu92G2+0WmE1lpZFdRSj8ypUr6Pf70qAxFAphcXFxZAeRJB9G/ySHMDcEQCJWNdqYmpqCzWbD/v4+vvjiC3GU6dQZDAYEg0HcuHFjKD9itVoFzbDZbNJlnmcpkUhIr0GSpkqlEnw+H959911Eo1Hs7e0J5XtlZQUGgwE3btzA+Pi4kCcMBoOM+LDZbJIX8nq9qNfruH//PgqFAr72ta/he9/73qn34AtnWAkXUAmpSdOTSSP1hxCamlBWE6KqnOy1w9eq5AG1YleFW9Qk2j9E2/wyMgLvQ/2/k0m8UeTkd6msJRU2YI6ATCYAEtqrXQZ4v1yD3/RM+JkqLZdrRiiQwtfwM9iGhK9Xa2eAYVooRY1MVGKBCjueRXhvvHf+qLUW/X5/KEnNNeVz4PWr1dR8DupaUriG6u/UdVb3K79b/U5eFwBZ95OfS89bfbbcB1xntdvFKML1V5O4XxZJ8ne8jy/bV7w+3p9KkuD7VDhSpW+rOoT3RciPxl19HidJNifP5m+CqlXiESOeL9M3L7J+vG9+Nj9f1Rt0TtTXqoQJ6kOVuUUyifp8VaLRSTj0N+k4tbxCJQ3xOal7j3T837SOfHaMCLl+p00NaAZnPe3nci7nci7nci4n5GxNds7lXM7lXM7lXL5Ezo3LuZzLuZzLuXzlcm5czuVczuVczuUrl3Pjci7nci7nci5fuZwbl3M5l3M5l3P5yuXcuJzLuZzLuZzLVy7nxuVczuVczuVcvnI5Ny7nci7nci7n8pXLuXE5l3M5l3M5l69czo3LuZzLuZzLuXzlcm5czuVczuVczuUrl3Pjci7nci7nci5fuZy6xardbodWq0U0GkUgEIDH48H09DRarRbef/997O/v41vf+hZ++7d/e2igzkcffYTHjx9LZ1iXy4Xvfe97mJqawueff45PP/0UU1NT+P3f/314PB48evQIOzs7MoNaHYfabDbRarUQCoVw48YNWCwWHBwcIJ/P4zvf+Q7+6I/+CJlMBv/xP/5HPHv2DEtLS5ifn0c8Hsdnn32GwWCA3/qt38Ly8jJWVlZw+/ZteDwe/PCHP0QgEMBf//Vf46OPPpJuo5wfwvGr7Ka6t7f3wgv97/7dv0On08Gnn36KlZUV6YpqMBgQiURkFrnP50OtVsPm5qbMpue8klarBZvNhldffRXhcFgmxOXzeaytraHdbmNxcVFmY1itVpnZUa1Wpctxq9VCLpfDYDCQtu/5fB6JRAJGo1FahGezWeRyOQCQ8b9LS0sIBoNIp9M4PDyUNt8A8IMf/ABvvfUWVlZW8Kd/+qfodDp48803MTU1hb29Payvr8uMkheVt99+GwBkXLPVaoXP50O73cbjx4+RTqexsLCACxcuSLfXbreLnZ0dJJNJuXcAMqqXIw4CgQCuX78Oi8WCzc1NaZPPFvXBYBBmsxlbW1vY2tqC0WiE1+uVP+12O6ampnD58mWZXcR5RyaTCaVSCbu7u0ND8C5fvozXX38dg8EAmUwG9XodDx48wOrqKvx+P5aXl2UkAj+Hoyn+/b//9y+8fgDwx3/8x+j3+8hmsygUCuh0OjIamJ1zA4EAQqEQut2uvMZsNsusD7vdjn6/j3Q6jXq9DpvNBrvdjkqlIueV007r9TqKxSLMZjOWl5fhcrmwt7eH/f19tNttlMtlGSPRbrdhtVrhdDrhdrtx69YteL1ebG1tYXt7G1arVWaO8Cxyrkmz2UQqlUK73cbCwgImJycRi8Xw6aefAgBee+01TExMoFgsyr7/N//m37zw+plMJmg0GthsNpn7xL3UarXQ7XYRjUYxPj6Ofr+PcrmMTqcjww4p6p5ip2LOujEYDPK7fD6Pw8NDaDQaGU3CM8nxzexazFEH4+Pj6Ha7ODw8RK1Wk3EaHGKn1WoxNjYGl8uFXC6HRCIBs9mMyclJmM1mZDIZ5PN5dDodab1PHah2o+Zgwb9PTm1cOBO6VCqh0WggmUwiHo/L/01MTMj40XK5jNXVVRm4xJkobrcber0eqVQKuVwOzWYT8/PzMBgM+PDDD6HRaBCPx1EsFtFqtUSRcPF0Oh3sdjvMZrO0fg4Gg3C73chms/iv//W/otFooFQqyfhQr9eLarUKnU6HZrOJJ0+eIBaLyZyPVquFO3fuwOFwyKhcdVodR95+WdvrF5EPP/xQBi4Fg0EZitbr9VAul3FwcACr1YpcLge3241vfetbMJlMePjwIZ4/fy5DrjgfhaN+HQ6HtMHnbJpkMonx8XGMj49Dq9UiHA7LULLd3V3Y7XbcvHlTxi1Xq9UhA6q22m80GvLszGbzkIIuFoti/DUaDVZXV2XSp9PplJbxhUIBVqsVly9fHrnlvjp2moPrONtnYWEBc3Nz8Hq98Hg8qNVq2NjYkJk8nMDH/We1WqHT6VCpVGSk9uPHj6HT6VAul2UsdD6fH3pOHCFtNptlVC+Nu9/vH5q5Uy6XZTxys9lEJpNBo9GQNU4mk3jw4MFQq3ar1Yrp6WkYjUa5hv39fXQ6HdhsNhlmNqpwJhOHWKmjFTh2l8OoDAaDTG/lBNh2uz10HvR6PRwOh0w1jcViADA0GoCTFblHqIh1Oh0mJydlPxeLRTEYBoMB5XIZer0epVIJ5XJ5aG+ybX4mk8H29ja0Wq0Y+1KpJOONL1++DI1Gg1qthrW1NZlQO+o55n1zwqbaip7rypn1HJlBnaWOAuGUV8608vl86Ha7yOfzYrA40JBDFzm5t9VqQaPRwGq1YmxsTKZg1ut1dDodJJNJOS8GgwGdTkcMIO+hWCyi2WyiVqvJOIdUKgWDwYBarTb0et4nn+OLjHx4IeMCQAZ9caGMRqPMSXe5XHJD29vbSKfTopi8Xi+mpqZkYl+hUEAoFMLExAQKhQK++OIL2cCch8ChNBxUxeFfZrNZDobX64VOpxvyVFwuF6xWK2w2G5xOpygTDrkCIKM7G40Gnjx5AqPRiHa7PXQoOJtBna8xqnzxxRfiNfj9fthsNng8HrRaLdy/fx+pVApmsxnFYhFGoxE3btxAMBhEpVKRDUMvM5fLySS7UCgkw6tarRZisRhyuZwMJOMgLeBo/vvKygrcbjcuXLgAq9WKp0+fSgSlKhuufbvdlkFSqnHpdDqoVCoYDAZimHZ2drCzswObzQa/3w+TySRD3jwejxi7UYT3QAOjDu4aHx+Hy+USpcYxr4VCAYFAAC6XSyIUs9mMcDgMq9WKjY0NmfnOCI1zdcrlskz18/l80Ol0svcsFgv8fj80Gg22t7dRLpfRaDTE4+SkQbPZLIPW8vk86vU67HY7TCaTOFdqFGSxWBCNRmU6ZrvdRiwWk7HcnDY6qtAT5fApfqfFYsHi4iK8Xi+2t7exubkJk8mEaDQKvV6PTqeDUqkkCpOGgoaakyWNRqOcXc4RoXMIYEghOxwOGRveaDRkoikHDXJkd61Wk7U8ORul0WggFovBZrNhenoaTqcTz549w/Pnz2VUuE6nw8rKClKpFMbHxxEMBkfeg6px4b9V54oTKYkYcJKp1WqVaJoze+gkhUIhGdN+eHgoI8vVSb4ajUamiHLWjcVikdHZ6lyrXC4HvV4Pr9cLg8GASqUieoPnp1qtimHhfCGOTj85T0i97pNziv4hObVx4QhUXiCNhs1mw+zsLLxeL/R6vcA5HPPKw8sL0ul08Hq98Pv9MuZVp9Ph0qVLaDQaODw8RC6Xg91uF4ueSqXQaDRgMplksmQmk4HBYBBlwIPLWfcc7ZvNZlEsFtFut9Hr9WSAjl6vl7ASgIyv5ax0TtLkIvO7Rz3c9Lb4vfw8en+1Wg0ul0sMca1WQy6XkznYFotFRozy4dOAtlot5PN5OZSNRgO5XA47Ozui4Hu9HuLxuBhqfr/D4YDL5ZIZ2pz6R6+J41VpwPh7ztTmgeM9cm05CIpjhg0GAxwOx8gHm7Pe6XxYLBaZAslotl6vI5fLyYRRzhqnx0/vj5ACYQvgGPbltat7i0OrCAF1u11ks1mJqFXYQKvVwul0QqfTyd7W6XSiBHw+HxwOh0xP7Pf76HQ60Gq1Eq03m02Uy2VxdhwOh0wJPEvkok4Q7Ha7Mq5Zr9cPoQVut1uijW63C5PJJKOYHQ6HQGs0Cul0WlAKTt3U6/XynBi90Qi3Wi25H05A1el0yOVyODw8RL/fl+i83+8jEAjI2GfuPV6b3W6Xc8noz+/3w+VyyVrRWWKEf5YzTF1gMpkAHA8Dc7vdsp4nHRU65HzWHEtuMpngdDrFuZuamkKr1cL+/r5MrqUzpw7CA46cO64z14noDsdP05Bx/9IQcjAYp7sCx2PEqTdpHNVoi/d0Wjn1KwOBgFivwWCAsbEx3LhxA263G0tLS/B6vbh79y5+9rOfwePx4NVXX4XVasUvfvELHB4eIp1OY3V1FW63G//4H/9jzM3NoVwuo1qtwmQy4bXXXkO/38fPf/5zPH78GOPj47h06RKazSZu376NdDoNh8MBr9eLRqOB9fV1CU81Gg0CgQAmJibgdDqxtLQkY1Y3NjaQyWRQq9UE1+UCmkwm9Ho9mSXt8XhkBG2hUBBjxPG6nNc9itCQMRficDjg8/nQ6XRk/OvY2BgmJydhsViQyWSQyWSQSqVQqVQwMzOD119/XSKEcrkMv98Pn8+HYrGIWq2GUqmEUqmEYrGI3d1dib5oeDh1kYfS4/GI91gqlcSj2tnZkdDb6XSK56/X6yU/UK/XYbFYhqYscj4358H3+31kMhlRBna7/dRT7E7K2NiYTOvj8xgbG4PRaJS8RCqVwsbGhnhr/X4fbrcbk5OTKBQKODg4QK/XQyqVEoekVqvBYrHIYadXTHyZcEWr1cLY2BhmZ2cRj8fx0UcfoV6vy4hvKl3mJWkI2+22rInRaMT8/DwikQh2d3exuroqRheAjNduNBrIZDJy7tR58meJXKxWKwaDARqNxpBR1Wg0ODg4EMh2cnJS4FruFavVCrvdDr/fL4prMBjIuN1arSY5moODA2SzWXi9XkxMTAi8VSqVkMvlRGnR0FosFtTrdTx58gQrKysAjpSpxWLBzMwMFhYWxHi0Wi2Uy2UxhITkGBVxxLLNZpPJl0ajEVarVf79ZdM3TyP8Ho4cNplM8vdLly7B7/fj8ePHuHfvHsxmMyYmJoaiVEZ+NpsNCwsLiEajKJfLKBaLsNvtuHDhArRaLX7+858jm83CaDTC5XLJOqv6rtFoYGdnZ2gqKJ0i4BjloJ5TR8+rRkudRjsYDOBwOODxeFCtVpFIJIYm1mo0GkE4TiOnNi4nx9QyLCbcxA3Hm+V4Vh4w/p2bmsqHi6COSj0ZUvN3RqNREor8TnokXFheT7PZRKPREEWjjm41mUxDIR6VJJPbVDK8Hv4w7zSK+Hw+AEcRoOrhq+Nh6QUBQK1WE0/E7XbD4XDIxlEPiDrKl+/l+nCuOIkBlG63K7CaOqpYXWeupzrGl8q21WrJjHAaJMIi9Pi5GU0mk8wJP8vBZiTCUJ77iWun7puT42KJO/M6+Tp1TCz3Gu+B+10llKj7lN9DZ4F5QD5D9cASd6fCpHNDuOEkZk+PH8BQBKV6mqMIoyd6olSWjAi4X056p3SMqFDV6+IPE/78O3+vju2mwaVhUEdMc49wn3Dt+H8qRN1qteR88HkBx7AV14uvpwNChTqqnMy7qjqQz5J7gs/3ZN5Y1SdcF1Uv8nNPnjt1RDVRARobnlfqFDXKUUcx8++q/lEjbq1WOxSd877Uc6XqqH9ITm1cDg4OAEA2RaFQwPb2NvR6PR4+fIjBYIBoNIpvfetbKJfL+OSTT1Aul5FIJFAulwVbttls4iUdHBxgf38fBoNBwlgm9pLJJJLJpGwms9mMsbExXLhwAclkEqlUChqNBmNjY5JsNplMaDQa+PDDD8W4EMbhoaEH2Gg0UK1WYbFY8NJLL8Fut0uyklgvHzrnqtNDH0X+8A//EP1+H/F4XLwSsn9KpRKSyaQoF3UTXLx4Ee+88w7K5TJSqRSq1Sr29vZQLBbhdDoxNTUFo9GI8fFxuN1ulEol5PN5GAwGwamBY4NSq9WQzWbx/vvviwJj6O5wOGAymXDp0iU4nU5sb29jb29PmFN8Xa1Ww8LCAm7cuCEQSbPZlIRjs9mU3NGtW7cQDodRrVaFVTaKfPHFFxKFlctlWCwWwduvXr2KYDAIj8eDixcvyvdUq9WhfdTpdGA0GjE2Ngan04lUKiXXvb29DZ1Oh9nZWQSDQXmvOnecUM1gMMDCwgJ0Oh3GxsYkKRsMBtFqteQ5UZFbLBZcv34dACQPQ8PLA24ymeD1eiW6IIyRSCRQqVQk0XoWCYVCAI4dkna7LYlg5jxotKlUtFotfD4fnE4ngOO8o81mE3aUzWZDo9EQxpbVah0ixpCp1G63kclkkEwmMRgM8OzZMyE9kDixuLgIALIXmRxX2ZrpdBrJZBJ+vx+RSAQ6nQ69Xk+MI7+XjL1IJIKFhQU0Gg3U6/WR14/fT7IFo6Nms4lPPvkE/X4f4+Pj+Pa3v41isYgnT56gVCqhUqmg1WoJvGgwGCQ3yujZYDAIAyufz8s+KRQKYkgGg4EwB6kXGUkxAmWOLJPJDOXImDOkATEYDPIe6l9GSk6nU3KWhL+Z56F+Oo2c2riQSscPbjQaKBQK0Gq1SKVSqNfrcLvdmJ6exuHhIWKxGOLxuGDkTB6STdbr9XB4eIjd3V3xinjQ9Hq95Bw0Gs0Q3hsIBOSGuSiElYAj47e/v49CoSBKWlXWpHeqXlMwGITP50O5XBaIzG63Sw6D930WvPbKlSuy6fP5/FDkxAQuWUa8D4PBgFdeeQVXr17F8+fP8fz5cxSLRRSLRZRKJcHsyf5R80hqpGW1WoeYLbVaDTs7O7J+VqsVrVZLIsPJyUn4/X7k83mhlzLBSAXkdDqxsLAgEV+j0RDmlUajQbFYhEajQTQaxcLCAg4ODlCpVAQzflFJJBJC76zVajAajajX63A6nZifnxc2FxWny+UCcJSbKxaLsjY6nU4ICuVyGTqdDq1WS4xnNBoVr7darUrOQWXs2O12hMNhmM1meL1egQ2tVqsYMTIUiWN7vV5otVrJOdDTVH+cTqcQVAwGg1wXr0ONPkcRm80GABKBcL/TYaQhVb1svt7lcsk1kJZuMpngdrsRDAbRbDah1+uHjEu5XEYmk0G/3xcnj/Rhs9mMdDqNZrMpe5CJaCpMg8Eg0ZbqsROCowEiHVe9ft4Tc3LhcBjZbFYinlGEZ5+frdPpROnH43FUq1WEQiHMzMwgkUjgs88+E1ovo1GLxQKdTifnnc6YVqtFrVYDAMlR0uiraBEjOdXRZdR4MsLgWlD/Wq1W0ZuMtGmsSHbhPq7X62LEeG6MRuMLwdqnNi6vv/46+v0+9vb2kEwm4Xa78fLLL2MwGMiG2d7exs9//nNotVrcvHkTvV4Pq6ur2NvbQyQSwZUrV8RbowKiomWylwszMTEh7CKVobKxsQGtVot33nlHHgSVX6vVEqydi67X6xGJRHDr1i04HA44nU5YLBasrq4imUyiXC5jbW1taDNXKhUUCgV0u114PB5YrVa0220Ui8WRleOjR4+GNiEPLz1nlabZ6/VQKpWg1WqxubkJvV6PRCIhng4ZR2SlNJtNxONxNJtN+Hw+WCyWoVoW1YgR5imVSqKIuY70hLa2tpBMJpHL5QRyICmDyhKA1IF4vV5JcsdiMRgMBqHstlotxONx8YJGhcUcDodAI51OR6CbVquF3d1dlEolgWBZV0GCCZPE3W5XDhW9wXq9Dp1Oh0gkItFku92Gz+eTPA8T/0zkMmLU6XQ4PDzE+vo6HA4HksmkMPZqtZqwG1VHhtE0jWG/30culxM6KemoZAfZbDbMzc0hmUzi4OBg5P0HHFGK+SdZT/y8drstbDLu91wuJ8qTyXiSY0gAYH0G92Cj0YDH44HNZkOpVJJzxO/ivq9UKnj27JnkJnw+H0qlErLZ7BBjyel0Sk4KgKwN9938/LwYfkZGpVJpKKrv9XpCdy6XyyMbF6fTicFgIA4ovXnguFQjFovhzp076Ha7iEQi8Hq9EgX4/X6JzKgHVFifn0HonDBsv9+X+2NUq9VqhVofDofh8XiGno8K3xJav3DhAiwWixj/TCaDw8NDYS02Gg3k83kAR9ETDbHf75dcdDabPfX6ndq4vPPOO6KcEokEvF4vbt68iX6/j7W1Nezv72NjYwNra2tYWFjAv/yX/xKhUAh//ud/jkKhgOnpabzxxhtSW8ECK9YSkKFCK3/16lX87u/+rjywcrmMu3fv4vPPP8f8/Dx+//d/Hw6HA5988gk2NzclMV+r1cTToUVfXFzEP/tn/wzBYBD1el2879u3b0uNg0ajweTkJCKRCIrFIjKZDDQaDWZmZjA2NoaDgwPxnkcRwjpULoTtiHXTuPD/0um0GGdGNOl0GgB+zbhUq1XE43G0Wi3MzMwgFAphc3MT29vbUiyo1+uFP88CKTU3Ua/XBRpZW1sTo0O8mxEJWWZMMtrtdkSjURgMBjx8+BB7e3sYGxvD5cuXYTab0Ww2cXBwgFqtJsprFHG5XOIB0wgyV7C1tQWNRiPU8rm5OXz7299GKBSSgrd6vS7sGuaEyPV3Op0YHx8X2IDJe8J+m5ubKJfLsNlsQiFfXFxEv9/HxsYGnjx5Il4f16rb7cLn88n3ER+v1+uoVqtSCMpn3Wq1kM1mYTabUa1Whcb//e9/H4uLi2i1Wnj27NmZoNl8Pi9r2Gw2hfEJYChKJzO0VCqhVquhUqnAaDRK8p4wlUZzVNzH3One3h4qlQqi0Si8Xi/K5bIYCzURTGNwcHAglOKJiQkxLmScdbtdBAIBBAKBIUULHClzFpsCEPSEsKnX68XS0hIMBgN2dnaQyWQEmh3VuPBe6dDSEDBJrtFosL+/j2QyCZ/Phxs3bsBqtcqeCoVCgmAwamQEyLUh25Aoj8lkEpJEvV5HuVxGuVyG2WyWwspIJIJAIIBkMolsNvtrSXi9Xg+fz4dr167B7XaLg//w4UOsr68DgEQxNMCEMkl5npiYwOrqKp49e3ZqB/HUxoUPNRgMYnl5GR6PR2AvhnUM9UmRZaKTVeHEyB0OB9xuN2Kx2BDMYLFYRPGHQiEpEGRhFW9Sre0IBoPodrtIJpOoVqswm82IRqPodrtysH0+nyTr1WJElYYMQO7FbDZjdnZWHja9tBfheJ8UtYhJ5ZHTsFLRc+My+cikmtVqxfj4+JARpYfCfApzHQaDQaAUwgUUNUkIQAwNmXFU2mSOEB6k18u6IbXuhetIY67SL4npq3z/UcTn80kURvhJTfLTm2OCkkqtUqmIQaWHpibRVWHinRRtUjjJgmPkwqRpv98XFqFK72S0wgi02+2KkgGO6ZwqHEX40uPxQK/Xi1fbbDYlKjsLoQTAkDer0sVJ2eZeKZVKwlojRKPCe4xcSC/O5XIoFosC+fG+eO0AhEZNGFev18Nms0GjOSoozOVyYnDpCBH+5p6kYWXHgF6vh3Q6Lc+HZ8nr9cJkMqFSqUhuietut9tHXj9GAaQ6s+iQe0FNwp98Hw0MWYA2m03gxHq9LsaaaIIK8fb7/aFqfpKQWJweDAbh9/tFdwEQNIH7kM+XBbncyzwPfG6MVFUYjY5PrVZ7oT14auPCRPvXvvY1/OhHP8La2hr+4i/+QmiBBoMBPp8Pfr8fs7OzkgRkWJtOp/Hnf/7nCIfD+Nf/+l/j5ZdfRiwWQzqdhtPpxDvvvINIJCLefDQalYInm80m1awXLlwQHNVoNOKNN96A0WjE3bt3USgUoNPpsLi4CKfTKQns2dlZ4aHTuyFGTIVOb0Kr1WJ2dha/93u/h36/j7/4i7/AF198AbPZLAmwUYQHmRgoi/HogWk0RwV5a2trUhzJBKBer0c0GsWVK1dQrVbxZ3/2Z9jd3YXNZkMkEhFPl7RGs9ksLDkVjwaOGS+8D1ZAW61W8WLplS0sLODixYtIJpO4d+8eut0uFhYWEIlE4PP5EA6HJcJhHmZiYgL9fh87OzvodruyPxYXF3H58uUX4smrcuPGDbk2KsB4PI56vY7Dw0NUKhXx9jQaDd5//31RZny2yWQSJpMJoVBoSMmoLLa5uTnMzs4KLNHr9WS/MXLR6XSS01teXsbk5CSKxSLS6bQY1Ha7LTlFRuVUGHa7XXJnKo17dnYWFy5cQCaTkfoldpJghHUW4T2SQsvfEfrwer3odDpYWVmRiKrb7Ur05/V6cfnyZVSrVbz33nvIZrPiSHAPdrtdIe5ks1lsbGxAo9FgfHxcGHNUXGNjYxgMjqrD9/b2MDU1hYsXL2IwGEgejw4qYTuN5qhw2uv1ol6v48MPP4Tf78c3vvENKXZlndjKyoo4ZiyG5X2PIjQur7zyCmZnZ7G1tYW/+7u/E/iIsDoZkicT6slkUkoqXn31VVy/fh337t3Dp59+KgbDZDJhbGwMXq93qDLe4XBIZwjqxLGxMYFNGaUT8aDxY37WZrMJpd7tdsPpdEphbrValf+j4ff5fPIsnj59isePH0Or1b6QcT71SWdk4nQ6EQqFpGcTFRPxauKtagKZCSwWBtFLUymvjGYYvTidTvl/WlKv1ysPmZ4Xabrc0Hq9XphDlUoFjUZDqlWpCE96wNwcKs02EonIwSMkRE9rFKFyVymz9GiYmEwkEuJRc6Py/skm4n2r9Fp6HO12W1hFNJi8X9VrVYX/R69fvVY+T1ZL87mpXQ9UBW40GuFwOKSIk/g48zxUrqMIFavK3iqVSrIX+KfFYkGv10OhUBiiR6udH2jguc4qlZQtQlRsm/RbRmqE1QBIdKdeDwvXCNXxuxkd8hmeNPSEOu12u1DPWe3PGrOziErVZaJcNW6s/SFEyiia683nC0Cuhb3l1KJj/snohZAv9xn3NplxwDHVnCwp/sn15v2r9O9msynMSP6ebZ/Yu4zOAff3WaJnRq1OpxOBQEDynOwUQRo2r5kRO9ePOWEWTZKEQ5hXpcire0OtX+F+pr4kTOt2u+FyuWCz2SSiZhTP96lOFJESs9kskWa73R5iMBLy4zoTdfrKI5fvfe970njxJz/5iVhIPlCj0YiJiQm89NJLaLfb+F//63+hXq9jd3cXmUwGvV5Pqmx//OMf4+HDh2i32/iDP/gDaLVa3Lt3Dw8ePBDvQqfTSbKOFEIm0WgYyLCo1+twuVz4zne+M6Rkx8bGEAgEpKhKp9MhHA6L8rDZbEgkEvjJT34iXQCY/NvY2BB2Eg0QPfpRhIqHxZMMkcnYstlsmJyclPtNpVJS9Wy324fgK5vNhuXlZXS7Xdy/f38o1FVrLZjjYH2HmsClkgmFQgJx8XvUxo2kwjLnAUDqZnj9drtdIjC3242dnR1sbW2h1+vhxo0bGB8fBwAUCoWR1g6AhPWPHj3C8+fPZfOTzcKogsWMjUZD8lHsUzU9PS0VzYy0bty4gXa7LfkFQreBQAAzMzPQarWYmJgQhaBW8DMvwaJH5jQcDsdQSxIWaRKiabVaCAQC0vfu2bNnqFarODw8lAMeiUTQ6XSwurqKVColivUsQlIBuxYwAcz1VSvw8/m8NDxlNMw+aqRiT09PS8GxzWbD5cuX5Wyy8p7wMiEcm80Gn88n+UWNRoPLly/LelJXkCVF5ehyuTAzMwO9Xi9wDR0m5gcIgdJZYG4rGo0K5fks8sMf/hD9fh/b29uSS2ZUQRo5DRhzge12e6gFC0saNjc3JbdLyIvnMxaLCTEiHA4P6R9GRXT8WPRIpu6rr74q5QostJ6bmxtikvb7fWkpxag7k8kIG5HP/9GjR+j3+xKlkwV5Wjm1cbl16xZqtRr++q//Gn/zN38j+DpvlNjf7Ows9vb28Itf/AKxWEysuBqKf/bZZ9Dr9Xj77bfx7rvvIh6P48c//jFKpRIWFhYwNjaGUCgk0RJxSXqStKw0Lmwn8corr6BWqwm/nGG8ioV6PB6JijweD54/f45PPvlEmD5sq3B4eChMOFrvsySkq9UqtNqjBns+n086ntIjMZvNCAaDUp2/t7eHUqkkoTEPNo2R2+3G8+fPpUuv3+8XbxQ4ViRq8dnJ6EWr1UqtAL0uGjZuaDKG1HCYXi0jGl53OByG3+9HtVqVvmNzc3O4fv06dnd3sb6+fqbqaPbaunv3LkKhEC5cuCCJSHqzdrtd9glzA0zwRiIRAJAutTMzM5idnZWO0J1OB9lsFh6PBx6PB8FgcCjZqhay0ZtWnQ1GuGQYhkIheDweqV9ipEBWXygUQj6fx87ODiqVCrLZLCqVCsLhMK5evSreZKFQEMroWYSROOtHVOXNqIlUVea0CC0zt8AuyUtLS/B4PFhbW5O6jOnpaakGZxsZrjlRBXri9XpdFNz09DQikQgODg6wuroqBoK5FuCIxDI3NyctiNSOznQmqCMIaapV6nRGz5Kzev3116UX4ccffyx9xJiLInRlsVhQKBSwtrYmrE86fGytkkgkpGsBk/a8L3YUAYCpqamhfC0A2e9kvzJ6piHKZDLSxWN6ehoLCwvilLMNFIkNwWBQaMbqPq9Wq9KlhPVVahR7Gjm1cfmrv/ortNtt7O/vi2KnwmLCNB6P49GjRyiXyxgbG4PD4ZCDfBL3J1+diUF6v+Pj4+LxseaDyoIbhS22VZghkUhITyli2UzekzlGdpHaGI69yJifIL0wkUhIdTsf6FkSqsyrABCFx82UTCYlkcZrBCBeJumDhPeYbGZtjsoAcrvdUmHL+haG1yQ1UHFQMdP78vv9Ul/TbDYxNjaGcDiMWq2GeDyOfr8vh0it06FHXSgUpB/ahQsXAED2DL28Udfv8ePH6Ha7KBaLomQ5RoDPhzkeRhYM+wlZcA/SMNJj63Q6GB8fh0ajEVqnyWQSZcU14jrSAWm320gkEtJ+x2q1yn5lsrtSqQy1i6djxGJUUnxVuKLX64nXTeIJ8z5nUY6EXxitVCoVqSUjNMvnyUiZyWYaB5595mR4bsgYUyvOGWWrdHjmrprNphgBJvu9Xi+Wl5fFQ2ZtiNlshsvlEsiGhoWt4i0Wi+gYrg+NHZ+pz+eTkolR2WIffvghut0u4vG47HmeW5V0wSJs5mFOOiWkpBMuttlssmYk0jAaobEn8sKWTzzbjUYD2WwW7XYbqVQKu7u7wlZUnS5GqywZ6HQ6Ur9kMBiEAMDn1Ol0RLeoLL8XiZ5PbVz+7b/9t6L41J5S/J1Go8GzZ8+wuroKn8+Hmzdvwmq14qOPPkIulxOrSe9Ho9GI997tdiVRdeXKFVy4cEHgKeA4T8FNnMlk8Mtf/hKNRgMzMzPw+/1YWVnBhx9+CJ1Oh5mZGbhcLqHUEW9lqEyLzENDL4xSLBbx7NkzgQ3o7blcrpEP98zMDPr9ozkYpBVWKhUAwNraGkwmk1R60+MixMCuAhMTE0O9u3hfhUIBz549Q6fTQTgcllbcZGwRFuO8h2azKdXALL4KBAK4evWqbHwaErfbLRToTqeDiYkJeDweeL1ejI2NodVqSQj+4MEDrK2tIRQK4d1334VOp8P+/j4+//xzMZJq88QXkf/7f/8vAEjRJnA0U4KsIzauLBQKsFgs0tOKNQn0Dtnhl5EkiSKXL1+G0+mUZKrVahXmHSNdRuGs6SKUxZ5abrdbYJpms4lEIoFEIoFgMCjGhWy6g4MDbG5uSqEkz5JOd9S+iDkr1vTQuThL3oWQRrvdFsPAaJhdLqgEyRDkGrAPWDgcRrvdxtOnT5HNZqX4FoAUVdOw8H2k4Pf7R407JyYm0G63EQ6Hh3IphNVbrRa2trakgwb3DgkBrMcYHx/H/Py8kCcajYbMmnI6nbh586aQY+x2O/b39xGLxUYuJ/jjP/5jiZSYd2Pek5C9Gg0CGGLAMoIFIIpbPfM0SMFgEBMTEwKXk3DR6XQwNTWFyclJdDodmWVTq9XkrD19+lS6kbCHIRl0CwsL6HQ62NzcRKPRQCgUwvLyMnK5HLa2tobo4tVqVWoG1dzPi+RMT/3KbDYrdET2PzpJvyP7iskjHhhguF8OH26r1RqqPmZxVbFYlFANOKZQ8uZU5hWjG1IhSV0m/ZkPndfLh0GYi1EOk9U8YKyQ5cY/i8cIQKIR3jsTyFRGhHGINXs8Hsllqdx+htX8NyvRg8EgOp2OhOb8YSgOQDY2GUtknbA7Nb0jroHT6ZRBUHwW9IT4WbwPPkPmZ/i9fE50KM4qvBc+U34+Dwafl3rI1aQ5hU5RvV4XL1BtV6JCier/UaFQGRACVNeCjSFZNEqnio4VE/y8fhVHZ3Ka76UDobLXRhV6nep68Du4JiTiABCKvNrdme9V15fnkmeT+5XvYWKe+kIlCKhro+ZSVTidLEB1D3DN1ALhZrMpTgP3M6MxPhuVEPKiotKqSTcnVP737bUv+526r9QIlcaLsDaNCx1OwqPM35E0w9wO9xSdT/7/ya72jK7ZnkYle9DBYT82PusXzfmd2rhQAbIVPi+MG8dgMODSpUt4+eWXUS6X8fnnn6NQKAz10aLy4gIUCgU8fvxY2Ai9Xg9bW1twOp147bXX8Hu/93vQ6XTY3d1FpVJBIBCA2+1GIBDA/Pw8CoUCnj59KkOK/H4/gCNDw2R0Op2WWSfdbhe7u7uIx+PY2dnBysqKVHVrNBq8/vrreOmll5BMJoUu+uTJE1n4s/Qlevr0KTQajTBNBoOBVFyrXQBYoPqjH/0INpsNd+/exfr6uiTjut2uFKtNTEzgypUrMBgM+P73vw/gKJ/AzUL4w+/3w2w2I5VK4fDwEG63G5cuXZLkqs1mk/wADzUVBhP2xOODwSDC4TAKhQIePHggnQCIoZOeur29LcoyFAohFothbW1t5IP90ksvATgmE6hzbqiQOZ2SkCsPEL+TURPzAt1uV2jphHCmpqYQCAQwPj4On88nEBD3D6G5eDyOSqWCw8NDuWc6CLlcTiAoPjc6NMTae72eJPlZ26HmGFmpz3EChKFGhXQASGsV1vIQslZZlGxJYjAY8Lu/+7tS08Pog3AxabEsCrVYLAiFQgL5cU2pN0ipZ1TCSJ21Is1mU9ib/D4AMoyMUFm/30c4HJaaLxagktjDerfp6Wl84xvfgFarlcJCRoOjRi6MLIkO5HI5PH/+XEgcjLLYTolw1UnjoRoirjf3ikajQTablWFzFy9eRL/fl7EadN45WqDVOpoEvLq6KucYgOjYWCyGUqmE8fFx+fxSqYRWq4XHjx/jo48+krWlQ8k5WJw0vL6+jkwmIwb8tHJq48JFYTKQSTkuOJPDFy5cwMHBgTRjpPev4rX0JE5WJ3c6HRl2MzEx8WuzBUgtZW+odrst/a88Hg8ikcgQw4v8e3q2nU5HugIwhAQgypPDmjQaDZLJpCTs6IGfpTqaCkht+U9Pih4D8yasFfJ4PFhdXRXPBIDUeORyOVGArC/RarV4+vQpDg4OhiKXYDAo7TjYj8vn88Htdgv9m/2d6EGr4a/67Jg0z2azQweb3jzzGcR9nU6njDYgE2gUCQaD8mx5IElfpcIgRNbtdiUnoj4zNfLl+jMa4QA2OkAqTMqDyiJBXgOnblJB6/X6oQJD7isA4sCQvUa2GyEp1YvnfldzDoyyzmJcCKey0WGj0RiCKVXmldvtxsLCAmw2G2KxmChorjn3AhO+hI3V4l9GXyqDjGgBRz4wkiGUdvL+uE7M59AZs9vtUtGvFm4WCgVxDvlZpFerBdRnEUKUNAoAJKKw2+1wOp2o1+tSQKvSzk9+NyNZwlg6nU7OEKFp6l06H0R1nE6nUNUTiQQikQjC4bAwTnu9nkTXBoNB8p40/NlsFuvr65Jz47Oj3mPBbDwel5zWSdjv75NTG5eLFy9Cq9ViamoKkUgE8Xj814qs9vf38bd/+7fo9XqYn5/H5OQk4vG49Kii5WZCnYtOnNdiseDKlSuYnp7Gyy+/LFAH62aogBOJBH7xi18glUohnU5Drz9qdLm7uwun04mXX35Zkt8sgPR4POh2u3j8+DFisRgcDgd+7/d+T6KsfD6P1dVVaDQaZDIZPH36VBg8xOzPMiyMvbn4oFjMpBpBVs0Wi0W89957MJuPJlNOTU3BarXKLPiZmRnMz8+j3+/jwYMHsvZqZb6aQORMlnA4jHq9jlAoJJNDOSaa9Stqkp9QBwDBjVmgSUYbAKHeXrx4UdqoeDweDAZHlfL1el2ch1G9RrXOipAeFR4jJDLc2AiUpAYytqhIGfqzAyyNp8lkwszMDCYnJ+HxeASmZIeGfD4vRWn7+/vitdMQEPZhMR8JA+VyWVhDNIyTk5NYXl5Gr3c0X4bRDEkkZOaoEKjaY2sUoefK58v+WzTMVMJM4h8eHsJkMiGdTktfPb7W5/MJPZnFd6TLqgl8tacYabhq1b8KOzOPwHojXqPaMZ3Ro9qFm44XCyjJ3uI6ptNp6c11ls7Sbrdb8lGxWGxoTUjQIXUbgKAA6j1SOauwOD+DBKOXXnoJ09PTuHjxolDDx8fHBWnQ6/UyVZZrPj09jV6vJzT9YDAoJCnCk5ubm+h2u3j27Bl2dnZgsVhw7do1tFotHB4eSr9BAJIP73Q60lqn0zkaC/CV17lcunQJer0eU1NTCIVC0Gg0uH//PtrttiQq9/f3cf/+fUQiEfzgBz+Ax+PBw4cPsbW1NYS9cwMDx6EmGVE3b97E1772NQQCAVEYVCas3YjH43jvvfeQSCSkaJNVpuPj47h27RqWl5fx2Wef4e7du7LZ+v0+VlZWkEgk8N3vfhd/8Ad/gP39fTx58gTFYlHGoebzeWxtbclGZD7mLJMUicvTyHDM62AwwOHhoXDSQ6EQisUi/vZv/xb9fh+XL1/G7Ows6vU64vE47HY73nzzTUSjUXz66af45JNP5LCzHQ5rUlTjwqQh4ZhIJAKXy4WpqSn4fL6hoi0qBkY/9DKZvM/n88JMMRqNWF5elvY0TqdTmEa1Wg3Pnz/HwcGBNNQb1WtU2UZscUH6MCube73jwW9kBfn9foFVWBRIQ+X3+zE9PQ0Awq6ZnZ2VvmGkXO/v78sYWg7GYo8tMpg4wsFqtWJychJOp1P2kwqD8PUXLlzAxYsXUalUpBZMNSg8yCfza2fxulXjwn3BolNGtfR02+029vb2YDAYkM/nZT2p+DkdkoOwNBqNKDoackZ6ZEzxflh0yDNNZUXjQkeTXSN43/Ssmddi3pRKWqfTCcXb4XDI/aRSKcnNnkXoMHFvMwKgceE1UJ9FIhFxaDSa4xHPar6Ff6fh1Wg0eOmll/DNb35TCsR7vZ50KqfDVyqV8Itf/AKVSgXj4+OYmZnB7u4unj17Jq1lGDmbzWYZsFitVrGysoLd3V288soruHHjBorFoqBNvE6WIagtpF50753auOTzeUm0Eb4ipMDNxJ/BYCATC0nRY7jPg8PDzGQl2ThU4moLaX4ucVXmZwiJ0AhwIYnJM4lMr6/f74uXy4Qg+d2DwUAa5qnePyEislxGNS5jY2MAjpUk8yfdblcqy1WIQk3Cq2vEYkIqsunpaaES8v300Bi2k1JKSESv14uyJ1TBflqqcaFwgw0GA6lgZwhPmiQZVcBwApPPnZDVqMqR+RUmGYu/msxHpcPmlMS4uRZUWDR4ZM6pNUAn75WeOJ0btYCR90PIjcWbatW5agiDwaDQ33lAWdzJZoqsI6FXqxJcuKepiM8iqhIjDKUmhUmNZ1JeJdaEw2HxzIkg0GGikSL0RVIEcOy9q3RWnU4nHjH1BSnGxV91bOaasziS60HlepK4wb1HR4OQMCMtlYwwqlDPqEQPfr96rvl3OjPcQ3zfyZozXt/JNkPUVaoOpNOjGil+HnCsN/icyCQj3NlsNiXfRfIEqfskXTAaZdTJ50GSxGnl1Mbl3r17Q8lAWm+1oIcyGAxw+/btoYWg10PFSJ41IQQmjulVk5HU6/UEt97a2sLKygr29/cBQAwJq9jZjTWZTErNg8Vigc/nw8LCAoDj7qlUCGoyM5/Pi9FkrogUzMuXL+PWrVsjH/Dvfve7AI7bN+zt7eH27dtSAMqGhTxoDH+JL6uRDqvBI5EIXnnlFdks/X4fd+7cwfr6OgqFAjKZDIxGo7SpsFqtiEajaLVa0nfJ5XLBYrFgcnISFy9eFPiS3iOZY1RMfD6JREKMDFumU0HRGBGPp6fK9j2jyEcffQTg2IFgfoDYs9/vHwrt2c+Lw9HITORnGI1GdLtdeT2VUalUQiqVgsfjwfj4OFqt1tC8Gyo0EgY45pjOkSpTU1OYmJhAsVjEzs6OOC+NRgO7u7v4+OOPpQ5IbV7IBCsJFBxzzGmmo4pagc1zybNYKBSk8SHP997eHvr9Pr71rW/h5ZdfRjqdxsbGhtRKZLNZuFwuLCwsyGwXAJJUZ4KYCoxsJ5vNhlqthtu3b0Oj0QicWigUkEgkBArnM6JjRPiSDh+dQI1GI/UaHo9HGJRk57F7+FkNdC6XA3DMguM+51mho8o8UiaTkboV5qdo1Om80tFlEbrT6RSomkxOkk00Gg0KhYLUyamsWyJBLHY+ODhALBaTM8nUgF5/1KKfnZTp7HFYYrlcltZJdM7p+M7NzeHChQunpiOf2rjUajUJmUi1VCtGWTnLRB65/zwwJ6l39B4ZqvOBqb15KPQOyFBTNxtZPIQc+P3sj8QEMhNi9LDoFZG+rCZUeRi4UQj7sXhxFCFTh/2p1DoGrgO9Mq4HDxOxWFafcy1YR0DFTUjiJBbNefeMgEjhZjKRSVMqNDV6ocfFw0mjT++QG49FjITeVO+V3tlZilBVr5HDthidqLRn3jO/l1EAjRyfwUkMXMXCVTqn6nycFO45FiCS7UQSCY0RZ8zQi2YtCKMvRgyMplUsnvucbMuvgs6tUo6Zl1C7EDNKU6M8El7o0FFJcg147XxGJDCo66zqDNYbAcd9xVRqr0qjpROrTk5Vo0nuL7U9z8kSCO7rs6wfv+9kaYL6/RQVAqNzrOZX1IiH50c1nGrkf1JvnoSouMdJniBLcjAYSAd1GqrBYCAlDiQ5kSh1sjheXUNGViwzOI2cWlNGIpGh6IM3TobV1NSU5DMIQag0ZR4itWaFLWEYzagJwGazKfDOwcGBJEUJIXm9XulyzIT7SRyTPcKKxSLC4bBESkajEalUCv/pP/0ntNttuN1uXLt2TQqw9vf3cefOHcF1c7kcDg4O8PTp05FhMW5yQkjM31AharVaoXJT+fT7fRlcRkiK0KTL5ZIcCJsc9vtHfYk2Nzcl0czOCaQ2OhwONJtNJJNJoZQaDAZJ2Kuww/LyMubn59FoNHB4eCj5Gn7ftWvXABwpoUQigfv372N1dRVms1lovE6nExcuXEChUEA6nR45of+jH/0I3W4XT58+xfb2tuDxZrNZku75fH6oU6+aqAeOGVs8SIxOSC9utVqST2BRJvMr6XR6qHNsOByGXq/H/Pw8ZmdnBS5kQR8JJvv7+3LPZNpRuF8Je1y+fBmLi4tIJpPSkUB1lnhGRhXSVOk512o16VDAPaq2ApmcnES/30cqlcJHH30kho6RIg1ALpeTujIAiMViSCQSQwW/NDD5fF7o34RcCoWCtPch7Es6PZ0btd6F16HT6cTgUuGxbIHtd6gUWTV/lgr9t99+W9iaZAyqcC1ZbWouhrqN50vtxMEILRAIiAPOivvDw0PZv8x/VatV+P1++P1+1Go1iZBYGHrSIPAz6Qjw/+lUs4C33+9LTZDdbheCEdmdNPylUgl7e3tfvXFh9TFxO9Xqer1ehEIhrK2tScTCm6SXQUvORaW1V3sR0dOkwqWR4nQ5RhlcBAo3m5p86vePGq7t7+9Dp9PJvAj243n48CF+8YtfwGw249q1a5icnMTs7CwmJyfx+PFjqXSlgctkMtjf3x85cuE9M0FOQwFAMHy/349XXnkFWq1WGHVPnjwRRly5XBYvh4WsZEwFg0Gh1DLZzMiNNFv+sF9Vt9uVw8p1I1RInF2j0UjrdyohKtjp6Wm0223JHWxsbODTTz+Fx+PBzMyMtFVnp2TSGUeRW7duod1uI5lMigHjD2Ek0oKBozHcer0egUBAOkrQe6V3SxiWY3OZB2TuiZ59sViUtjaM4NgiJhKJyBx5t9stERJwhHvv7OyIouMUS7PZLPCDWsQ4OTmJGzduYHt7G/F4XBQICzI54G1UIVzEvTUYDIS5SJiY55WKjeeI9VdTU1PSSoRMMlb5A5D9xmFn7GZNQ0pYh0qLRABOpOXnMKJipK/OOSJhhREdAIlc0+k09vb2JKLneWOeiEXKo8ilS5fQ7/dxcHCAdDoNrVYr81lo/BhtqdGJ+r3c/3yObG1Dh5pUd0JwwBGcyY4QZHWyZQ7XlLOs6LTSCVGZacAxVMjvoxNmt9tFtzIvS6eWn0GD85UbF+AYZuAmJ6RFb4FUWdW7oneu1R71yVKpkH6/H9FoFHq9HpcvX4bVahWlpPa5YbEVi6gAiFdE7r+arFYVgdoLS6UlchSqVqsV5Vsul2WUABlivJder4dEIvEiyzUke3t70Gg0KJfLcDqdyGQyMpKYSb9sNounT5/CZrMhGo2K4qRnxzX3+/2CW7NNw7179wTTt1gsEvlxEzGpTk+fiW+1HoYOA3u7MfpQq/y5FvxpNBpIJpOynteuXROvWB2bCxzNShn1YJPuy9waw3yV7hkIBABAWpeQvq42nwQw5NGxndHVq1dhMBhkRg29e7IVOYCKygyAFBIyb0gmUSwWQyqVQrPZFHq3OumTik7ttK3THc37WFlZQb1el4F3FNK6zyJUwLx/zgJptVoyD4gNNpkD5XqqkYQaEbIlEvF6Qmnsb8e8g5rQZ0dmtaeaCsex8BaA1GOxfojePp21YDCIRqMheSudTiedmBOJhNCTeZbZSHMU2dnZkUiOUSz3Ns+YqrdIIuJzV+FhGmd2xyYiYzabpYyjXC5L9MC8G7u8k/7PZ+RwOAQe47OmMBdIQ8Kzb7fbJWhQu1GzYSk/hxMvmec6rZzauKhYHofPOJ1OoSQzWiF2SOtJj1hNmjJZNzU1hcXFRQSDQVy/fh1utxt+vx8Oh0NgNCZv1Sp+AJI3UZUIPbO9vT3JJUSjUfj9fjEuGxsb2Nvbky7EDDlZuMTENxODVF75fB7Pnj0bGdZ5+PAhgOPW5gaDQXoEcYwzu+NOTEwgGo3KwLNEIiHwgtVqxeLiIgKBAA4ODrC/v4+DgwP89Kc/RS6XkwPP6EeFHPkMeK+DwUASh8T6GcmNjY1JnooFXsxnqC1SGLHk83nMzMzg5Zdfxvb2Nt5//33UajWJupaWlvDqq6+OnFClcvN6vbh06dIQK4eKi8OmstksPvvsM1QqFcmFMGemwhSkGkejUbz11ltwuVxiBOhE8WBbrdYhCj29PPZ6qtVq0kpjdXUVe3t7Q01R8/n8UM0HhU6XTqfDzs4O4vE4otEorl27Jrk50tD39/dHjvyA45ketVoNnU4HXq8XMzMzqNVqMkbDaDSK1x8KhcRZo3Fn1Mw1ZVSWSqWwtbUl0bXH40EymRSFzJwia6wKhQJSqdQQW5KIA9eNxb0OhwPxeFz65zFq52TaVCqF999/H4lEAq+++ipeeukl7O3t4aOPPkK73cbk5CRcLhemp6exuLg4cvR379492YtsVEqSCteICp8kAwDIZDJDeUKLxYLp6WnRMay3mp+fh9PpxKVLlzAxMYGtrS2BVcfHx4XuHwwGUSwW4fF40Ov14PV6odVqEY/Hsb29LU4A9ylzLazLIVzOxrQkb/CMqTrOZDIhGo3C5/MhlUq9UG+2F8Z4GCapRV1UNMDxQKKTxoXKQE0QEw5Sey2pFD16g1R8hDNUL5QRDH94jVSMjJRUjny73ZbZH0yME0JqtVrSwJB4J7n96nCjFxWVFs3+bKwJSaVSACDemcPhQKVSkfslLZuFY3y4XEdCK2q+RKVf8prVXBZwDNVxnfi5aiKb8AW9XpUpUy6XhTXFZ6HWoTCxy2d7FrYONz6fE69FTZJyr3GdmTvg3uS90mGgp6jOwSEUplaMs0sDKc/8zpOOFL+DyWb199zXvEZ6/ip5gvufTEX+UBnyekYVdaAXE/DcY7xG4Dhhrd4Tr48eLRUaI1ieWSIV6u8BSJ6LTirRBrXI7+T3qdReNWHOtSW9lhGySghS+44RViSzdFTjwjwynQ+eC343zxqjl9+khPkaQtfUgdRFhMfolPN5cb8QkVDPrpp3UiMkng2+lt+vUurp9JzU03xmXEMA8pmnkVMbl5NV3z6fDy+99BIMBgNSqRSq1SoSiQQODg5k0/CiGA1wc5RKJaGR9no96WDscrnw6quvYmFhQQ4zoSAmtDnQiuwWFsmRzsuIxGw2Y29vD4eHh5KA5EPSaDTw+Xy4dOmS5HGKxaL0QXv55Zfxz//5P4fJZML777+P58+fIxAI4OLFi6ddri8VnU6HhYUFLC8vy6aoVquIx+PIZDJCH240Grh3755UG9+4cQOdTgfb29tIp9PSoiadTsvslevXr0ulLaExDkWjtFotxOPxoSQn6wKYnCWkRFYY6aAsZKMHenBwgLt370qEGAgEhNZMPjzxZzKDWDcxijx58kQSwqVSSajZWq1WvoPtLbrdroxyZZ5GTQhPTEzIcLbp6Wnpu5ZOp5FMJuX+GblOTk4KKUCj0UgUTceHCVwypyYmJqT4kLkcNfcIQIY4dbtHsz0YEVHhqKw7vp+klVFlbW0NWq0W0WgUkUhEno9K6WVpAWncVEgWiwW1Wg0PHjwQYghbCpHGzD518Xhcfkfyx+TkpLRsIZmEdHHWtfF+tVqtOC50AiwWCxYWFtDr9RAMBmG1WpHL5SSaYcEhu14wOmDimggHRwx8/etff+H1I7uNylWn0wmiQHIJOzYzYqARVOH1ZrOJnZ0d6fPH9+7u7sJqtUpBeK/Xkz1ut9thMBik5VAsFhMjozoudBhYzkEIz2AwyBkmS7Ver0skwufgcrmk1sbn86Hf72N3dxepVEpGK5+WVHJq48IPpAfBFh/07pkA4sKr3gf/zcNFL4Iz33u9niQwy+WyeNY0Lnw/jZaagFZDdE66i0QisvFTqZRYYHq7wPEIXxosHjSORb5w4QKMRiMePnyIw8NDGZ96FraORnPUuJLMO3omasFfrVaD2WwWDJRhcz6fF7YVi0nVVh2cuc2EKT0PeiMABA5j0o6epLrxmUdR+1jR0+bzJ4OJrfhZQEmHguE/vS7mL0gEGEWYXCT0xMIwrfa4sSQAcYBUhhhxaHq1TL5zbYHjnA6NIOsTiJ2z5xjzJ4wYGdFx35NNxQhIjcRVz57MRbXRJSMXlaJOp4775yx1GtwXVDw0yozsVK+VkYp67nlm6dwxkiT1mo7bYDCQe6exIvRDFiNwXPPFfahGo8xR0KvW6XSS+CaszFZQfEbcgzxXbO1DB5fdG0YVeu/qOnGtVMhZLcLl2VOfG6N+ABLB0chbrVbpPEKaOyM3vk4dfa1GIXxORBBsNptAYXQceP28DrUZLw0ioUh2ttje3kalUhE6/Gkjv1Mbl3feeUcujPTBlZUVYRwwzBsbGxNOu1arxdLSEsLhMDKZDLa2tgTW0el0WFxcxDe/+U1YLBZp3qfT6RCPx4cOJw/b9va2tEohbn5ytC/DTJ1OJ5h7qVTCxx9/LBRHerX0rnO5nCRgAWB/fx//43/8D+j1emxubsoIXJXB8aJCD+rZs2cSpbGg0e12Y3JyUowu2WT02nitpL8y0mLRJxkm7XZbOqqqSpVrxI7ShOR48Niqm8rD6/UilUrJOjGP0+l0cP/+faFJLi4uypq2223s7u5K3oj95hYXFyWkVxXZi8rrr78ukQuHcMVisSG4lIpchQfdbjd8Pp8YN9Kw6YXq9XpxSMhEIkuJ1fYkorB4DcAQpZnRHb87Go3C5XIJ1TmXy2FtbU0iKpIReD18L6+xUqng4OBAHDYqRnYhH1Xq9Tr0ej0ymYxAS4Rdp6amZEgVlT6Vo9pHjNEsR98WfzXmmAl9Gh52Y6CBIaNPhXvUujR28iCSwH1HaJV5vna7LcWBZrMZExMTQ3mEZDIpkzGj0SgGg4Hk0uhUjAqLjY2NQavVIhQKwev1Sud1XheVPb+Da7i0tIRAIIBkMon19fUhWI2djMlqI2V6fX1d9J4abXMd0um0kJMolUpFmIDxeBwGg0FqqahH6ZyybdL4+Dja7TYODg4EMmQjYdKs+/2jWVAmk+mFYMVTG5e3335b2BkejwfvvfcefvzjHwuDRaPRSL0LLw4AXnnlFbz++uu4d+8e1tfXBbfUarVYWFjAb/3WbwmuR8ZULBaTUcOqR7S3t4d4PC5Wnp6T6hX0ej1JfNJbYvjc7XYRiUQkhFZ7kpGXz+r5P/mTP5FQkXAEPZdRhN7a2toatra2ZJiVwWCQiXPcpIRwmEjnGFO/3y/MjkKhgEKhIM0Ut7e3pcUI8w/E7oEjL5EjjenZAMd1AYwaC4WCVFsHg0H4/X4J25vNJj788EPcvn0bX//61/E7v/M76HQ6WFtbkx5c8XhcakWsVisuXLggB0ut+XhRee211+Tei8Ui1tbWcP/+fTSbTfku9d6puLxeL5xOJ0qlEmKxmBxMKlZWwc/OzopBsNlschhVjL1YLGJ/fx9ms1nWUcX3gaPoKBqNotc7mt3ebDaxt7eHRCKBZrOJ2dlZhEIhmVuk5kGIgZfLZRwcHAA4arvESEml+I8ibKGSy+XQbrfhcDiEqj09PS3Uc+AYodDpjrpUeDyeIW+b9FfWjtTrdamZYecGOqKEhmh4GMkx0qBibjQaKJVKQx4y4R6+v9FoYG1tDbFYDJcvX8bS0hK63aNRGoQrG42GNAal91+r1eDz+RAOh0c2LiqzdW5uDqurq1hbW5NuBACkKzIAye9dvXoVV69exaNHj7C3tyeOOCNY1uBxGFwmk0EikUC5XEYqlYLVasW1a9dknASZg6lUSowxa7u4n2gEiPAQ7lbztBaLBWNjY0KZZ5sk6lbWvU1MTMiwsv8nLfdjsRg0mqNZAJzqxhCTXoY6sY84fqfTwf7+PrLZrIRn3MA8RIRPeICr1Sqy2azUqIyNjclmO5ko5UPkoul0OmG5MDTk9xKvVhNv/On1evB4PAgEArLALAIk5fksHVW/rHUHJ3RSyVA5srbAZDJJU0kqQgCCv6r9h3hw1UQ+75UbmYaUB0BlXDGcJpylPpNGoyENCrVarXDpGbGwvoTQEt8zGAyk0SM3+6iwInMcVGTc+DSUJJcwelB7fKkdC1TYlu/lD6EvOi2EHJn0d7vdknSlBw8cw340DvQMGa2qfbGIdbNAU21hz/yXCjGyb5faf2xUodJTYRlSUXnu1A4ZKoGDz45V8mrxLQ0r14DPRq3r4H7iffd6PVlvdf+dbMvEqJwGhrkt9fNUhhO/k/uARJhyuTzUBmYUoY6pVqsyN4lni1RdtQUQr5m6jF3kCVUT9isWi8JU1Wg0EoEQoeHaAsfIEaEyOuW8Z0abrO1hbprGm6/jOlGvcQ/yh2eI68x9/P/EuLz//vtDBUEMydhzJhgMirKy2+2YmZmBwWDAxsYGnjx5MpTYpEeyvb2Nn/70pwAgG4cHMp1OY2dnBy6XC//oH/0jSeKZzWYxIiqWTevsdrvx2muvSedmrVaL1dVV8XKBY4VL/JKLv7y8jDfeeEO6IpPmZ7FYpG/VqJ73yy+/LFg0HxILNflw1eZxsVhMigCZIGYynUqCrexZM0DIj/kGbiD2j6rX60ilUgiHw4hGo0M1IjwcLJBjfQbhtXQ6LaH00tISTCYTdnZ20Gg0sLOzI0Wu9K55GLa3t9Hr9TA2NobZ2dmRD/bjx48BQNhuxWJRqqInJyel1kSlYDLSYZEnGy2yYIxdodkvzW63y54oFAqIx+Mwm824cuWKRECTk5NDhXI0pOosG1bos8NDqVSS/CGNMFuzU4Gzfol1E1RA7FvG8dhnMS5sr7+7u4tYLIZwOCwJ8I2NDSmUZF87wtSc9aPVaoUlps45Utvf05BScbHTLl+fzWaRy+XEoFORkblHGj3RChJtmEMkZMn8C/N+KluVCAOJCel0Gvv7+xgMBjJDZhRhfmJ3d/fXoHTWn3D/8DparRYePHiAZ8+eCULAtIBWq5UR5eqZIZOPBbzc8yoUy5ZO3W5XGnsSTmSvQLvdLjlY1sAxr6uea1X/8MfhcEjyPpvNolAoSF3daffgC405Vj3HZrMpSWF17KdqQYnRZTIZCdfUjcN8BwAJjblJ2UOMjDLVO+TBU3FNegkMNZmMBSD9r1RvnE371LoFXjMrubnxGTGoydUXFbVjMY0rE6FqREWlyI3GegzV61ar6FUa8ckaipPUTuC4V5FKUVQjHSZgWV9EjJzrT0PEhDqTvlwnlc2kUp95OEaNXDgjg05Ip9MRpg6vV6VmqpRJFeNW14NrqFJyea/qD9eV+4HrpLK5aGRId6XCZU5FXRN69ydzYvQW+bkkJqi04VGdGwByRpkwJ01cLQ3g/dC7pefP61OHVp18nqrjqEKzpM+qkQxwTInlZ/M9/CydTieGW+0Ozr2mkg6oC9Qku3odatnDqKQI3gsdi2azOUR0UfcQ9wzPORW6SvemEWZEQR1JREItzFQT90RhVOTh5A8LfqkfmftiJM/PYI6G18R1U/WCqmNeZGzGqY3L5ubmEH99bm4O//Sf/lPodDo8f/5cegZls1mYTCaBtBKJhCT/6BnPzc3B7XaL1VU3ATFmq9WKl19+GWazWZKa29vb2N7eFlqd2WzG9PQ0AoEA4vE4nj9/Dp3uqNKZoSppzOFwGGbz0UQ/0vPW1tbQ7/fF+93Z2ZFkIZk1ExMTcDgcUnU9KhWU41CpeBhJqEwXKkmTySQt9MvlMm7fvo3x8XEMBkdN58bHx6WXE2dtcH25IVXjGAwGxTMmPEdlbTAYEAgEhPXDAVI+nw9Pnz7F+vo6gsEgrl27Jp53Op0WCNFgMGB5eRkAcHh4iGQyKfjuYDDA1NSUPPeTBVovIqurqwAwFGmplPV6vS55DKvViqmpKRiNRlHiKvuLtPh+vy/RdyqVkhoW0t7ZW+vw8BD7+/tCA3W5XJidnYXZbBbFEY/Hsbq6OpQX4SEnFNTtHk3mdDqdQ8l8Pj/SQLk3+v2+JPG/rMDtRcVut4uSoWfN+2cfORpHlbJKWMrv92NmZkbgcVLM6SSxearK5OQMFP4uFAphampqqO7CbD6aLMu+eDabDbdu3YLX60WxWMTh4SECgQDm5uYERqbBIb2cMKjD4UChUIDdbhfigt1ux+TkJCwWCzKZzMgODqMklSzy6quvYjA4Gll+cHAgzqBKRVYVOGErdSSA6sD0+/0hiIxGlYMLSWbhPqCD3+v1hB1LNihhOzUy5nlg9EwHhzCiWuZRqVSETDA+Po7d3V1pWXQaObVxIXOAFtfpdOKtt96CVnvUX+fw8BD5fB4HBwfQ6XQSyqodX1lgNzk5iUgkglgsJqE+F5ehtMPhwOTkpCSqir+aWx6Px6UNApu+RaNRwf9ZKU08nZ9LGjFnSpPOZ7FYMDs7C6vVKsaFh5iwEROFTIiNIiyUJAzHw8vOAqphUQ3I5uamXNPY2JhsRtJUiZmqiVNGR1TC5K9PTk5iYmIC5XIZz58/l6QuD0Gr1ZI8TzAYxKNHjxCLxaTrstqElAfZ4XDI9Eni5SoWHQ6HpViVBXijCHN+rL8JBoPCnmPbEe4Rt9stHQZYNMsDrSaSGZmpc4dUeqzT6ZSaBNZzFAoFRKNRzM3NCYRJI0/ohQQNAIKLM6fGtio8yFRG9AwZ1XOPMPIj1HIWYeRCz52QLOE31kXEYjHx9JkHJf17ZmYGAIYosVRQZIhROTLaIkTW6/XgdDoRCoXkeQHH0TKbfnL9nE6n0Ou51+iRM3qhU+bz+cRoUimXy2V57ow0XwTWOSknB47Ryej3+9jf30c+nx8ilDCnxHVWGXIqmUEtHmdUORgMxGjybFYqFaRSKenYEQgE5P41Go3k5bi23W53COoiY5PRN/cWz7K6J1mvY7VasbCwgEgkgnw+D+DLO4R/mZzauHBIDBegUCjgzp070Ol00tSQIS7DVa1Wi+XlZYTDYVQqFaTTaaHHARDl1mw2kUqlxHtmY8Xd3V15HTc5E3osmOJGczgciEQiwjShV0OPhqwWANIsk6FoOp2W9y0tLaHVaokiJPPtLIoRgOQbGLaTmj0YDOTAsKUOqclms1mMGut0WCzIZpq5XE5mdQMQthMASb4zB0X+er1el/wCC03tdjvGxsZgMBjw9OlTrK2tIZvNCq2SUydtNhvm5+eh0x2NTWW9hNVqlWiPlOh+vz9USHYWtpO6/5hfYhM9GhcymHq9HjY2NqSPmtPpFKo1uyGzaSUj6EePHqHX68mhZ9fldruNra0tuTetViuNLplPIRVfhcwYTbFrN5k+7F7AvAH3NnAEmbE7szoSgdf+IsnUL5NEIiEGTHXcyGTkHBcqNfbh2tjYEDg8FotJ8a3b7RbDwWhVbXGjEh/YZSIcDiMUCgktmw7Szs4OarWaMP9IBCkWi9BqtWJ4WB/kcrnk3AwGAySTSYlEiQ4QGVAJB2ch5aikEX4edVS/f9RPjV4/HRcq85OD+Bg5MmLg56pGhmgEC4OZS6KDEg6HBd0gdEnYkg4L6dz84T612+1CwAEgz02d18W1z2Qy6Pf7yOVycl2nkRfqigwcK/pUKoW//Mu/FIyVoS89Qt7Ea6+9hm9961tYXV3FT3/6UzEk2WwWXq8XwWBQKs05KpTfQ4YQLTvDR71eD7/fL00p6W3Pz89LJMDiSA4RotdJxUF6Z7vdlm7Hr7zyCi5fvoxKpSKU53g8Lsnss3iO169fh0ajkbb+jx8/xuHhoUQLLEoNBAIIBAK4dOkSrFYr0uk0stms9F5qtVpIJpPQ6XQyEIjeymAwQCQSkVqjfr+PYDCI3/7t3xbIgxuezTt3d3extrYm7d4rlQp+9rOfIZlMYnJyUiZoPn78GAaDAQsLC5ifn8fTp0/x6aefQq/XI5FISE8l1m8cHByg2+0OeURnWcOTrCbgOCqoVCri2ZFOzaaFS0tLmJyclDbp9NKj0aj0aTo4OMB7772HXC43RL+dnJxEu93G2toaisUiJicn5bPoPbJJKg0X2WVGo1EKX41GIyKRyFCuwGq1IhgMDmHqg8FAksT0PFVv9kXw7i+Tra0tScpfvnwZuVxOelERZjKbzVJbtbCwIDUtrC9bW1uDzWaTERVkO/Ec0XEhBZhGgEWBY2Nj0pSTcOGnn36Kra0tOJ1OTE9Po9/vY2trS869Xq9HvV4XyOy1117D1NQUSqUSstksKpWKFPoxJ0ODDByzWdWeeqMI+4jRAHQ6HaysrIgRcLvd4twMBgOZgcXaJlWHkUTEqEJNDVBY+Mj8Jp0Akm5mZ2dhMpmwtbWFRqMhDFIVfudIE5WEotfr4fV6USqVJKKmcRobG8PExIQQsFi/prKDv/I6Fy4AFQRvnCF/t9uVLp/dbldaR9BC04smVEYlxwiCi85FVSlzPGQqBY8V+fQECN3QeNBjIsbJhSKsR5yXi87kI2Em3iPZO3zNqBuTSTHi2VSQ9IapgMvlsnRD5jXw+lkcyfCanhi9DzWxz7Cch1qtfKYHTXiLjgEdB64xcJzE5LUyP0AlTzyYB4MwkwoHlcvlIXLBKMJEJe+dBhmA5JhUj1Kl7XIN+UPFQ7iV66r29CLFmrBVr9cTmJFJXPX58DlyzXig1esHjhl8JKVwnVThvgcg0BLRgLMIvVneE/cJz52asCXkp3q8PKeE7cg8ImzGeyI5hhHcyXwizyQ/m5GFmtNVIRuuLdeXuQW1BxcjQj5HkhHUhLT6M4rw+08SDyg0FuxQzLOuriOfreqQ89yqEQvl5Hu5fnSqDQaD6DZ+lsr+VFEDPtuThoxnh/qdOUoSobifeW3/T2AxWrhWq4VIJILr169jMBjg3r17yGazWFpawpUrV1AsFnHv3j0Jo+/du4fBYIClpSU0Gg2srKxIyNXr9SRhqD58laKrJq9YTDg+Pi5FRwAQDAaxuLg4dPPMJ5hMJqHRUXGGQiEsLCygWq1ibW1Nam4KhYJsZKPRiOXlZbjdbmxubmJlZWXkhD77T92/fx/7+/tDdEkqrFgshng8Lj2v/H6/1Ifk83mkUinY7XbcunVLplKqM0Y0mqNeZalUCgsLC7h586Z0Ak6lUshkMkin03A4HJiYmJAeYAyRNzc3odVqMTs7i6mpKcmh8fUAcOfOHaE/07jQWDO/ZjAYBFLhHByfzyd9ks4iXq9Xor/p6emhyIVRQKlUwurqqhxuKilOA00kEsjlctjb24PFYpFn4fF4BDLj3qXhYoeEhYWFoameTMwSGmRLErLj2OpdbUFDHJ6KQG2bwkNPSGN8fBxOpxPZbFZgrVGFsHCj0ZBoc3p6GgCGoMV8Pg+v1wu32y09vNjRgEqHXTRWVlbw+eefw2A4muvEKnjOHWFlN0cWMN+kQsQul0vIAOyUzBwqz7DRaJRyhw8++ADpdFro7TabDS+99BJMJhMeP36M9fV1qXynA0zHRK1DeVEhKsOkusvlksg+nU6jVqshGAxifHxcuoUzN0XHRW2JRIeWxuNk1EIjq9FohMU3MTGBsbExgVWJQiQSCcn1WCwWzM/Pw2azYWdnRwo3GaWobFF+FyWVSqFYLMLtdstoeA4b5HV85bAYE2JUDqwsp7fS6XRkRjtvkJ4NFRrZRSqNUE1w80Z58ScjBZUuzB9aXG5gelX0IlRaovrDWRyMcFRWB3unkbjAluKjUhiBY28nk8ng+fPnsjnU9jWsQ7FYLCiXy5KA1Wq1EgHQI1a9W66N6pXrdDohPQCQhDoNrBoJEtMtlUqiJAwGgxAfiOP2+0cdFHZ3d4c8Sm5aHjqPxyONQtlqhRX0ZxHS2NXCSV6D6ojwdepBYCKfSXJCJGo/NNZvEDtnsR8TsGzbr/a8o7JQqahkgp0stOQ90GPlM1C9cnqP3BPs9cTnMKpzAwzDOSq5gM+Q3m25XIZer5foj1EKP4MwFaHVbDYLq9UqEzzVKEUtqla9aTUaVlvoUBHzDKvFg4yykskkNjc3odFopE8au26wDg44LkHgfZ9VeAaIpgCQnA+jPsLyNGY0ElxvPlf+ybU9eZ6B4UiOZ4frTOPMZ1ar1YYKUglJHh4eCiKh0viZtqDB5PexZo4EHZ1OJ8XeKlX5NHJq40IIgmOCe70e7t69K+EyJ/o9ePAAg8EAk5OT6PV6qNVqePbsmbRdcTqd+O3f/m3o9Xqsr6/j2bNnQxeuUhS54Orho4L75S9/CafTiYsXLyISiaBWq2Fra0taWVitVjx8+BBPnz5FtVrFK6+8IonDfD4Pi8Uy1G5aq9ViamoKExMTKJVK2N/fl7YI7G7Lwq1RhBHE2NgYms2meN6DwVExKVuTsB3H7u6u0HnJfOLwoVQqJV737/zO7wgpgbU7bAlBphgPPZOw1WoVX3zxBUqlktDICW/Qu2M0MjY2Ji1euJFdLhcmJiawuLiIfr8vyW1GZyz+5OFid9uzHHIe7Eqlgl7vqJ8ZxxJQYbEfGOFZtvgBIA0i9Xq99NFijgaAOD3EswmXaTSaoeFkVCyENekBkvJqt9sxNTUFrVaL7e1tmR3k8Xig0WhkMJ0KTVFRTU5OyqwTwrBk7RiNRszNzY20dpTr16+j1+tJjz4A0mOOipHXZTKZEI/HZW3Hx8dhs9lkvDGdiVAohHfeeQcGw9EMF51OJ80/6Rgxh6Oy91j/Rgo5FS0ZSdyvbD0DQEoHOJZ8eXkZN27cgE6nk47i7CFGHcXvV43MqHuQCf1IJAKTySSTGVutlkTJpVIJOzs74qTyPYxEmZe8cuUK/H4/Hjx4gC+++GKoNY7aZYPRuAqdM1eSzWZRr9eRTCaHGnJ2u13s7OzAYrEgmUxKroafy3Wh49LtdqU/nArfx+NxIbCMQoN/IeOi1WoxPT2NaDSKtbU1/OQnP0G73cbs7Cz8fj/q9TqePHkCt9uNl19+GRaLBXfv3sXm5iYAYHl5GX6/H9/97ncxMTGB//2//ze2traGsFHVyPwm45LP5/HZZ59JUpRT23K5HNxuNy5duoRAIID9/X381V/9FcbHx/GNb3wDwFH4uru7C7vdPpQk1Wg0mJiYwPXr1yWBVa/XcXBwgEQiIV7eqELjQrgoEong6tWrqNfrWF1dxc7ODnw+nzSWPDg4QDabxfT0NCKRCILBIBYWFlAul/E//+f/xPr6upAlKpUKNjY2UC6Xsb6+LvkueuGcXMmJiltbW3j8+DHi8bgYsZM5AQC4evUqZmZmkEql8PjxYzSbTekkvLi4iHfffReNRgNffPEFcrkcstmsGBdO2bTZbMJ+ehGO/G8SRl9arRapVGoIjvF4PAKhMNlMSjDpmTS4kUgEvV4P2Wx2KG/CXJzBYJDJfaS8q8ZFzQPyh0ybpaUl2O121Go1PH36VLoqaDQaxONxaafOKIIGbnZ2Vhh7zCnQkyfl/iyw4tWrV6UdiVr7YzQapbKexqXb7Ur5gU6nkyFf7OX1+PFjZLNZBINBXLp0SfZPt9vFs2fPhNnJ5Dq9c0Yj1WpVHDgal06nI0l5OgYulwt+vx/5fB7r6+vo9/u4ePEiwuEwLl68iKtXr6JWq+Hzzz+XgV3sy0clys7pquM6irDLwNzcHMbGxrCxsSHnjcLib+aF1ZwWI6xAIIDf+q3fwsLCArRaLZ49eyZ5a64ZkSKSGgipcb8Ui0Wsrq5KKxo6KkxdkKTE6nzmooHjgnWLxQK/3y+sR14nUZxkMiloiJr3Oa2c2rjQi0skEnJQafXIbecCkp7McHdqako8ZtJmtVqteEIMGVVoQ4UMmNQku4xWnAmtWq0Gg8GA8fFxGAwG8RjZlLFQKMjoYvZ9AiCbeHl5Gd3u0Qhdzguh0XE4HOLdUVGNIrw3Un7p5TE/Ua/XpdEmcEwN5HUQW+W0O3qQZOowgc/8DRO3pBTyT7Y1YcsIes3qplHhnXw+j3a7Le23mTzMZDIySyOTyQhmz88iJEV6sFarlfb2o4i6DqQMc/w1293QyyezRq3pYG8w1jyonqSKebNOqtfrCRkiFArJOFp1PAOTxvQGCTUwwc1CQ7bpUetXSD0fDAYIBAICZ6TTaWlMysJEtvQh/j6q8D6dTqdMOuU6qcl4rhmT5Gw7REp/r9cTSjCJJXzuPNvcjzTKJN+okSbXjA0rqQQJEbMLA8d6EG5ivRybkLLeRu3EQL3BZ00dc5acC6nNyWRSSgLYT5FRO6Nn7ifuVZIY6NAyd8315fNXlTj3No2s2+2Gx+OB1+vFYDCQbg78PnZWZmRPGrxqFFQnkhD6YDCA3+//NSIFa6DUmqIXOcOnNi7s0rq7uyuhKWdVczhQMBhEJBJBo9HA48eP0e128corr+DmzZuoVCo4PDwcogP6/X5cunQJDocDm5ubkvPgBuGGJrVxeXkZV65cGSouIga7uLiImzdvIp/P47//9/+Ora0tbG1tCVWX0Q/nxnS7XYErvv3tb8Nms+Hu3bt48uSJ0Ev1ej2mp6cxNTU1dOhGERIYOHZZjRBu3bo1NIisWCzi6dOnaDabUplfq9VweHiIbveoszMHgbGew+PxwOl0Ih6Py0Ak1kpUKhVotVoZiZzL5ZBIJH5tvgWVpc1mg16vR6VSwfr6ukSiwNHQrng8jpWVFayvr8v7iM1TadCgrK+vI5PJYGlpCS+//PLIa0gYijk6r9eLxcVFqZti76S9vT15Dw8Gx+Uyqcymnep8e/ZYSqVS4igtLCzAbrfjpZdeQigUkkI+enXdblciJcI4zWYT6+vrqFQq4tzQu+Q1AZBqdxbD6fV6PHnyBPfv35caL7PZjFdffRUXL148c1dp4NjBYS82UrtPrhcVCfOBVPCdztFIbp1OJ10fisXiULddGhdCpy+99JIodEKXhKnIdiTZBDgu9GTtHBl9DocD09PT4m3b7XZUq1U8ePBgKBpTm1sy7wNAFD9HEI8iiUQCg8FRNT6N9OTkJAaDowat1WpVygkajQZ2d3fRarWkRT+dvUqlglwuh0wmI10bAMi10lljpON0OjEzM4NgMIhAIIBgMAiXyzVEtNDrj7oXLy8vo1wuC7We0ZDaJoYOPCnvdrsdly5dgs1mw/7+PpLJpAQQGo0Gfr9f1j0SiXz1VGSyXfjwuEFOQlhqcqvX6wlrQ6vVivfGjajT6QQ6YRRETJ1CD0Q9wKwJIR7IamC73S44OvFXKnF6HYwIuLHJsGDEpbZiADCUuD6L0MARHqBHS6+PVG/+W62QpodHD5MJQXLZuc6khzOxyXtX8eBsNiuJer73JLzDH64TvSji1yrUxTYXDNkpKqWUHtRZYAlep7of1D/VdQOOoy8VclVpvVxDereEY5kcVemz3HOMlDudjuSl+Jl8Pqy3YfTLFh9cG34vAFHg6jWoiX8yyZjv5H4dVdRnabPZpPMuCTHq/lep2yoszf3L+6CS4r3T+DGBT8OkXre6j7nP2B2BCXk176qeEXWGDhmL/GwaMUYBavJcvf5RjQt1oFocye9T99TJPa72ZON9MD+qfg6NC/cUDb163yoBhfd48jwwAuLz/k3CfcnoSn1eak2aqg/VvfAPyamNCwuCSDFkCM/Iwm63o9lsYmNjA0ajUbpy3rx5E7du3UI6nZYwGoDALRxY86Mf/Qj1eh0ff/yxwC30hDk1UKM56tBJ/FmdisYELdlQZFWoTSvp0ZDa++TJExm96nA40G63MTMzA4vFIvkDFo+xfmPUZOD9+/eh0Wiwubkp1F8mPbm5eC+EXQBI0jAYDMLtdqPVauHRo0eIx+NDD319fR1arRZzc3NYWlqCx+MRAgKx6P39fWxtbcmgLTKiut2uhOCEOAeDAXw+H9xuNzQaDQ4ODmAymfDKK6/A6/Vie3sbKysrMJvNWFpagtVqxaNHjwQXZ8hP41goFLCxsTFy5ELjxPkyrIBvNpti8PgncAw1nGzhQ6aZ2WwWo63RaIacm0KhIA6PXq8XZcIfg8Eghaq8v0QigQcPHshcE/aXmp2dFUei0zkaZkUYlx7r06dPMRgM4PV68frrr6NSqWB6eho63VH/KnrwjJZGFTV60miOxmQ/ePAA/X5fYDJ2ITYajUPrTMeFeaeDgwPxbvP5PKrVKg4PDzEYDHDz5k3pH0iDQweExcytVktyADQKJLn0+0fFv3y2ZIYSkhsbG4PX68X6+jq++OILOJ1OfP3rX4fX65UWKCxlACDkjlQqha2tLfT7fXznO9954fVTB8WRAr+xsQHgGMZOp9MSTTDnOTY2Ju11/H6/EDtSqRTi8TiA42S7VquV0dBkFvKc8/M5Vp6kD8KX1WoV9+/fl0m11Cf8XDo4dNJ4Tgknk5RDw0YjRYitXC7L9Z5GTm1cqOg575o3oyZvOQve5XJhfn4egUAAk5OTmJmZkRoA3jAXhpWtrIbe3NzE8+fPh2AWm80m7RNqtZpU5rMdPpNfXBzSG/mQAIhXyI1Rq9UQi8VkgzPJy5DWbDaLAWDrGLK3RhHCilR2tVpNOk1zPgu9Aibf2JyyWq3KvRLKSCQSQ3RE0kdZaa/2a2o2m6I0M5nM0Dhp1dtUPVEVWiAjjI7AhQsXoNPpEIvFYLPZsLCwII0HedioBIkh12o1aSQ4ijDStdvtCAaDcjAI47FDMhUn60/U7g7lcvnXcgS8T8IxnHTJAkPi+GpehgZKq9XKdEW20mHVeb/fRyAQgM/nk32sNqpkdNPtdqWe5vXXX8f09DSq1ao8a3ZmUKnoowoTz4yWmFRnATQAoZMzmgcg0QxJIWQXMbFMsgab2167dk0gSEYK9LAbjQbS6bQYfuCYzm2xWBAKhQSe5VnmniGbieej1Wphf38f4XAYXq8X09PTKBQKMjk2nU6L8nU6nTg8PJTppaMIIxfVYaHTzbonRq5kLPK73W43/H4/5ufn0Wq1cO/ePSSTSekaAWCoIPxk9MGfarUqe475FL3+qDEszzj/7yQScbKOhs4Ro3U1Z0bEhtT9weC4eepp5dTGheEYL4AHjZgsKYbA0SYgBe7hw4fodrtIp9PSvoFjYNWkFEPja9euwW63I5VKYWdnR9o9RKNRWK1WWK1WqaOgN8RwnlZYxTPplTOhSCgCOO41xNwErXS1WpWRo/QYTvLNX1Q4IpVJ+3K5LEVxKlOJBxo4xqgZQTECIT2aGCwhLn4ODyBrB9gLi21KCFkSmlC9GN4v14cKkd9x//59xONxwZfNZrOQJNicjz3IAMgzY8g9qnFh+F6tVlEoFMQw8J55qJlD4L6g56uycHgNHFNLRhjzMExcBoNBoZKSPkzFwa4T7OtEh4T7mNerdkTQ6486VBPCSCQSwpzq9/s4ODgQpk4+n5e/OxwOJJPJM7PtJiYmMBgMZAiVyWTC4uIigCP2IuFU5io4dI9EEq32eEAcjTBb29hsNol42bON5w2AOGa8VxqZVqsFg8GA6elpuFwuiTq4T7k/SRE3GAyIxWLIZDJot9u4ceOGtKbi2SUMyyg5kUjITB/mO0cVOtjsiVgoFABAYCv2FmONX7fblVZSiUQCsVhMagQZnbF0gEaLpJN0Oo3nz5+LA8cejaRvs30UzzLvkRCyCm8SKlRrWvjDPchzfpIMMwpTDBjBuPDwUDHz4lmhDUA8CmKtGxsb0scoHA7j3Xffhc/nE9YDE6StVgtvv/02Xn/9dTx9+hS/+MUv4HA48P3vfx/z8/NDrAuVBcLPoJefTqcRi8Xk2gmZEMOm18NOs9lsFnq9XuoguJEBSLJYpQWOIqQdspah+KuRudyM3W4XHo8HPp9P2B78vk7naJrnysrKUKQRDocxPj4udQU09iqbrt1uo1QqyXhgKkn1XmhcyIcHIMwm4sLctKSnzs/PS4Ke7Co2PSTdF4AMUOKkx1Hxbu413qdKWWc0kc/npcke8wLRaBQ+n08IHCr2XSwWpR6ALdk9Ho9E4xzSBmCogNVqtUqhI2tS2GEbwFDbD8IMNLbAUa1YIpHAzs6OPAONRoO1tTUcHh4KjKbT6YSVubOzg1QqdaaE/tLSEnq9HlZXVxGPx2G1WnH9+vWhdiG1Wk2Ki2lcSBKhMm00GkilUiiVSpidncXMzIwQOPr9o+7dHO1ABIJwIL3tQqGA+/fvo9Vq4erVq5ibmxOkgDlS1ZAajUaBlFZXV5FKpXDlyhW8++67ogsYtZD8wdzB7u4uqtUqfD6fDMAaRajrPB4PxsfHpQV+v9+XvFy/3xcjy+FgRHh4lgOBAP7Fv/gXuHLlinw2lb9er8f4+Dh8Ph8ePXqEH//4xzCZTHj55ZcxNjYmey2Xy0nOWc0tscOBGpXz2hkhsuiZ56fbPWotxW4CqrEjMnKSbXYaeaE6F4Z/PNgqHqgmwHng2aeGFEqv1ysUXNVjV3ndxMqdTid8Pp948q1WayjqUCl1/f7R3Ivt7W1pg8CiKUYcVJz0JFltzWsAIB4TX6car5MFni8qhFHYzZgdDUwmk3iDNCpcTyp4VnxzfcnmIszQ7/eFBUO6o1pfwPczOqNno96X6pXw+QIQ+jFxWsKQpICTJMEokRu40WgI3MQpjny2o4i6/moCnfAJ7+lkFA1gyEPT6XSifFRiCl8/GBz11SIlmVXmPPisoWD+hXUa9CjVvnTcT7xeQgyM8JgT4x4jdAYc15Vx75JKexbjwiiU16zmlVRohueB0QrXhOeq1+vB5XKJUSLMyD2oJtZ51tV9ppJTVAINIRo6DyqdmO2nAIiDyPOj7gHSoPl9jEJZtc4q+VGEtUqMKFWSBnBM51eT34SWqOjV5DuvhTqT60+9YzabpYUNIV6eQeYCmZsFIOQmwoc0urwmFQ4+SXI5idAAkPVWySYvEjmf2rhMTk4COJ6TzfYP6u/0er3wrNVeT51OB9FoFG+++SZ8Ph+cTqf0peJGJGRCxeD3+3Hjxg0MBgOk02kUi0XMzc1JIaNahNbtdvHgwQP8l//yX6Ttxvj4uMx2b7VaQqHmg19cXMQrr7wi4WSzeTSMLJPJCBRARUZlS8M2iszOzqLb7eLu3bt4+vQpZmdnpbI5FouhXC4jmUzi4OBAej4ZjUYkEglpPcOBZ+Pj47Db7SgWi9jY2IDdbsf8/LzkaTKZjOSoiIfncjkZscs1I16rGhNuOHqhpVJJDrrFYsEbb7yB6elp7O7uYnV1VXj7hJ3o1W9tbcFsNmNqagqXL1+WvTCq0Klh7yriy4TzOH+FmDZhUZWFx6mGpVIJOt1R5+OLFy9KNTLrhXjgnj9/Do/Hg29+85viGLndbqGFV6tV7O7uSpdvRsvsBM1cFyESRj6DwdGcmzfffFPWuN1uIxaLCfFlcXEROt3R4LtsNgvgKDF9Ftnc3ES328Xq6irW1tYwNzeHCxcuCKVY9WjZW421Nk6nc2j4HgkNHBJoNBoxPT0ttUPtdltqeWgcSBZhjZXaHp45HHYuZ74iFArB5/Oh2Wwil8uh3+9jcnISi4uLAjEy0mm329LPTN3Hy8vLUqNzcibLi8jVq1el9IFrSSeZeo57nHuVTEYaZEbSNMTs3q46EblcDsViESaTCd/61rek/urw8FD2YTqdxt7enrBiu92u9PGjI8KcIWFa5k54faToA8dOJLtwUBfTCWJHArVz/T8kL9z+hRd40tulJVQjF9VTMZlMQ7mWarUqHrjqvfEGiW0SIqhWqwiHw5Ig5GdzMbLZrCQUFxcXBROlkmSSlcqD1f00hCoVldaZUQK9C3ohowiLvoiVer1ewbfVwjHy9aPRqHgnrDpmEz+y5zgFkQeaLD4qcnoaXCM1OXjyuZ2MDHQ6nUAYXAudTgePx4NoNIp0Oi2Gm0rJ6XRKi2+29ybriLNNRl0/Fe7jevH6CF2pz4tkBnqBqpdMnNrpdMLhcGAwGEgNwkn2Hr1OtZ0OP4dOFnMYhD8YpXJvsQOzGjESXuG/2TJ9MBjIgdbpdGIkNRrNELQ2ipCdSOiIBsBsNgu0ybXqdDryenYsUM88nUHWpjEyUKd80lMHjnMShGGA40Q+119l75GQQuJOsVhEMpmUaJPNMVU9QL3BaIawDtvBkMgz6h5k+yXWiKlIxkkUh9dBth2jPrZ/4T0zQuV7eV4Hg6MC7mAwiHa7LV3IaaSZD6XBZM0KSx6Yt1GJNYy0GAkxeuL68dmrFGSeYbbL+n8Ci3HR6HkwaWUwGMS7yGQy4jXfunULVqsV+/v72N/fB3CENev1enzyySfodDp49dVX8eabb6JYLOLJkycolUrI5XLy+epC6fV6ZDIZPH78GNFoFK+99hoMBgOePHmC7e1taU9isVgwMTGBUCgk1E9iojqdDlNTU9Ln6c6dO+h0Osjn82i1WjLBkn28zGYz5ufn4fV6sbm5iadPn46cUN3a2hLYb3FxEdPT0zKjJJFIYHd3V9o4EDu1Wq2Yn5/HzZs3pXCRI6PZuZcHh/DZ/Py8DBpjxwG/3z9U28JNot6LmsgnnDE2Nga3241yuYzDw0PUajVsb2+LpxkOhwWHp6Kv1+ty+InXp9NpMS6jCj2sZrOJZDI5VDvDoloW5JlMJil8TSaTyGQyMJvNiEQi6Ha7ODg4QLPZRCaTkYNKyIukB9aXNBoNmU3DYVVqnpFNBOklslWK2WzG3t6e9GtjLoeHfjAY4PHjx6LEqehnZmbEgFEh0QMm5XRUuX//PoAjI7y0tIS5uTmEw2FoNBrs7+/L2Sv+amAZh0Mx2U7FR0+akWCz2ZTJsaRXA0cGiMWaer1enAvCqRMTE+h2u9JlmnOZVINASBKAfFe/f9RfLxKJCEzHnGsmkxHFr7KdmCNmPuz73//+C6/f7u6uXL8KJQHHUBgNjt1ux4ULF2Cz2bCxsYHDw0MhkHAAoM1mw8TEBGZmZiQ9wHNJp4ksRjqdn3/+uRif8fFxBAIB3Lt3T0g2dIScTqfsVRpswmqhUEhGbdPpZEKfr+G+M5lMUrRJKvRpodlTGxcqIhZe0cswGo3wer0YGxtDq9WSVt43btyAx+NBNpuVBmihUAjtdhufffaZeCEXL15EPB7H3bt3kclkpOUzIxiDwSAc8e3tbQwGA1y+fBnXrl2DwWDA5uYm7ty5g52dHbRaLWmNPjU1hb29PbHW5Mpz4NP6+jru378vRX6kLLL4y+FwwG63Y3FxERMTE6jX62dquc/KcYPBgJmZGWHnUMltb29L+NpoNJDNZqVO6ObNm7hz5w5u374th4Pt8gmFMToJBoNYXl4W1har9x0OhygEQmMqPMaDokYwwWAQs7OziMfjopBpZIxGo9BsqeTb7Tbq9brQwLVarbSaoSIaVQiHqm1VWIBGpc3mlB6PR4atZbNZ5HI5hEIh+P1+of62WkcTRsmaYuify+VkBjsJEclkcohG73a7hWDCFjT9fl8Mid/vh9lsFujMbrcLs46D7HZ3d/Hs2TNhK/b7fVy+fBkTExPiydK48FmTJDGqsEns8vIypqamMDY2JmtC75gDzljkR4VHj5mRH58pc6parRaRSESijFqtNtSw02w2S11MMpmU58YIm3lD1lXxnDEKITmCCXKiJ4QK6TSxtgU4zjOwLoROwahC2LPf7w8VnPK71FyGzWaTWh+2iyEVvN/vi2Nx6dIlXLlyZcgho27la2nMu90u9vb2sLe3h+npafzwhz+E2WzGw4cPxUEhYsSu4YyaeW2Eg8PhMDKZDGKxmJxbGhaV7k2Si8/nE1jytPD2qY0LL1BNlBI2IG3S6XTijTfegNlsRiqVQjqdRrfbhd/vh16vl2Q7Ia9kMolf/vKXsjntdjsSicTQlEj2amKiEwCy2azkJsheYfimYt1qohc48iry+bwUczH5yrwPE30nixjJKz8LhdFut2MwGAyFt2yHrfaM6vePCs6WlpZkXs3BwYHUaKiFgVarVdrjAxAPjrkwAEKVNJvNCAaDsNvtKBQKkgvgZtFqteI9Ujn2ej3E43Fp+MiNT+oxDbfX6xXmH3Fa7hUaH7ZdGVV4eMn4I5GAnhkdC3q86XQaWu1R4RibM6pJWDWvRCWhQm8A5PrZPofGn33gTCbTEBWZ0SO7CVM5k/7bbrdlDLWqWPl9ahNLKgMWW9LInWUPer1eObOczElaNw1Iq9WSfN3k5KRg9/l8XtaZcB/fwyJF7mV1ThDPH6MOnn3SuEmKUBtpql48e4bV63W43e6h9i2EqfR6PSKRiDDG2AeRMD1ZioSCzioqKYbKWIX6WCwei8WQzWaFHk/DTOXPaIIR8WAwEKIMX0fYj0Qk1htptUcdT9i+6CSbi9dIJ111iqvVKvL5vCBEdGKYoqCQEclIjc+P+/UfklMbl3g8PsSNJnWu3z8aSbq3t4ff/d3fxR/+4R9if38f//k//2fE43EEAgEsLS0hm83i4cOHACDDvp49e4Z79+4hHA7jrbfeQiQSwfr6ulTHk6tOPJobRqvV4s6dO7BardjZ2UHxV7O7WXnNh8lW8Fz4druNjY0N7O3tSb6CeQQ2zqRCIcTGcbnk6Y96uAnJxONxPH/+fKjNDZPmwNGm8Pl8+NGPfoRoNIpPP/0Ut2/flh5AAMSrZkdoUgkJZTA5rUYLbrdbGohub29jf39fjES73RbP2G63Y2lpCU6nE5ubm/jiiy+El6/RaATb5Vo4nU7cvHkTfr9fYAw2tWTNQb1elyTsWepcgGPsnvCIevDGx8dx9epV5PN53LlzB6VSCYFAAGNjY0I5J0TA+iqVrcRDRmYknZxEIoFSqYRCoYBisSi1EhaLRd7PtjqtVgsbGxvSIsZms6HT6eDw8BAmkwmzs7MyWpmQBAs+a7WaQHCt1lHb+6tXryIUCmF1dRUPHz48U53L4uKiGJb9/X0MBgMEg0HJsXGSK/Nk165dg9VqxerqqvT+IxkiGAxKxbnX64XVapV8xsLCAqLRqOxBwlWs9I9EIsjlctL37/DwEPl8HlNTU/D5fFLvpdPpkEgkkEwm4XK5MDs7K7AiIweyLq9duwaHw4EHDx7g2bNnEs0CEDotUYmzUJGBY1Yp1wqAOLhjY2OYnp5Gs9nE3bt3xcHlHqajNTk5CZfLhWQyiXv37sHpdKLZbMJsNiORSEgUzNyW2m4oGAxCp9NhdXUV3W5X4EvqZfW76Pjw+geDo1HauVxO/l+n0w2RUHie6IzRwaxUKgLpnkZObVzUJI/64UwGqRixRqMRD9rpdA5h+VqtVpqxsdWzzWaT+Qd8HQ87v1NNltFDJCWUHiAfPFteMw+gsr5UCiSttZrQ5nfTS2BYSSLBqMqRm0Pt/cOHTg9VpcOq90zvjMaFXWqB415P/FwWGvJg09s4SSdUPS8eVq6T0+mUiIjRAT0/dS8wkmBSWKV4qteuEiRO6/WcFLUm5yR9k8lK3g89QhIY+D6+njg9hc+c/6/uP7KZaFjpgKhsRTpCdExO5oP4/Vx/GkaypXht6t/5/FU6LpXDqEJPX3U6VIzdbDaLF0znUaXOniyyVdeVuQ2uvZp05pqpvfJUPcJ9wR9ei1r0qiag+XrV2WOEBRw7IicT03zdWYzLSd33ZcLnxzYs3K+8D8Kjbrdb6ofY9RqAPB9Gt1wHtWRCpQ2rcBavS6V1q2UfXA+V4HPy2tWzwtdyXV9kD576pJPZQm9UZUXwYT99+hT/7b/9Nwm3LBYL0uk04vE4vF4vbt68CbfbjVdeeQWBQACfffYZfvnLX0Kv12NjY0NgjFAoJLUfDDPtdjuy2azAPH6/X6wtDzSx3vX1dZjNZqTTaXQ6HfF69Hq9jCNlEWe73UYikZDQjwwTbkK2tKlWq9IMchThAV1eXhavjtFLIBCA3+9HLBaTDr1/8id/ApfLhYWFBbzxxhvCJGNeodk8Gqe7traGaDSK7373u/B4PKhUKlhdXR36bjLk1tfXsb6+jkKhIJ/FWS+Ee/R6PS5duoSpqSlJQFII4fCAEPpgfcbe3p7k19TqbLU31qg1BipThYeIh5hKL5lMYn19Hd1uV1qCcCbP+Pg4Ll++jMHgqJM0acw0EnRETjY2ZTU69wXni4yPjwthpVwuSy5Arc5XoZ6ZmRkhOOzt7UGr1eLy5ctoNBrY29tDs9lEMBjE1NSU9CfjOgNHHR4InYwqi4uL6PV68Pl8KBaLQjFmtNbrHfWA29/fl+p59sb6+te/jnw+LyNzef7ZLoYFpaQq0zOmR6/23mJOBzgqcL58+TIMBgNcLpeQIfhnIBDA7Oys5IDUImDSeJvNo2F57G+2t7c31B6eCEYoFDpTrRU7dvD5ct+otONOp4Pt7e2hxrTMg4RCISwuLsLpdGJxcREejwfdbhe7u7ui+wAI5Mx7Ztdiv9+PtbU1rK6uynrxXljewWijUChIjpXOA+FIrh8jIzoGhOW4RjQkatuXF3GuX4iKTDbQySQWlUk2m8X9+/flcOr1emFGOJ1OjI+PIxgM4vLly4hEIkin05LUVAdNEb9Vk2MOhwPlclmwTeK6jEYY4lH5GgwGUd4Gg0EmaLIS1W63IxQKoV6vIx6PC9OHhoXUa+YmAJwJr6XH7vf74ff7pe6EGKrBYJC2/LVaDY8ePZKpmlNTU9Jvil4xD/bOzg7M5qORzYRP0un0kKHkOuVyOanyZ2M7zuUgPVWnOxqPzCphUoupUHgf5MhT+XW7xy1+OFuc60UDQJbQKMJIg1GfqmTpwbEbNg8SACkYHAwG0rcqHo8LMYL3RrYMlQZ/T0+/1+sNNcdkYp6RDY2KSulUod1AIACdTodnz54hmUwiGo1iZmZG6kkGg4H0TaORAiCMJ6fTeaZ5OABkdpKqbBgFc78DEEiGedCZmRlMTU3BarVKNEwHst1uS3fsdrstfdeohBn10Vlju3k1pxQOh2UvMYlMqI3dMghJskK91WoJHZlRAmnWpVJJImnmOev1OqxW61BbkxcVfh71hHouqDO4NoTsVJKMyWSSibwTExNwu92SxFcp2tx3KjzqdDoRDAaxtraGTCYjURrPo8qq455V86J0VE5GxbwP1iUySgKOnTfqHBKETisv1LiSN0NlxZvh4VbZEEyW22w2qb/Y3NxELBYTNs7GxgZisZhAPqz2JZ2Oh5cbh6yuYrEoynd/f1+SjXxQzKFwcVjBCwAzMzOYn59HtVpFIpFAp9OB0+mE3W6XsFwNpwl1uFwu+Hy+kZUjJ9IxwVcsFqWGgevI+Qk0sGazGbFYDJ999pk0LiRxgtMXOWdkZWUFGxsbQnUMh8OYn59Hp9PB+vo6SqUSKpUKJicnpamfTqfD/Pw85ubmpCjRYDDg/v37WF1dxdOnT+Wg+v1+6HQ6USp0FuhxEaZkE1PCAPPz89Lp9rQUxi8TtTMv2XyBQECSxXz+TqdTqJvMZ1AxxuNxdLvHzSm5b8nwAo5mafB3hDIJwTF/pNUeTQ80mUzY3d0V1plKEKHnzD5UhOlY7ElKtFqrwz3JP7lm7DrOCvFRhdEaGXFcN54/Qsk0LGQRkYJbr9flM9RO1CxyZDR8kkrLAlGWFkSjUQDHsOr4+Dg8Hs8QzMPmtYR7SNhQFR/7v2m12iFE44033hDlTkZho9FANBpFOBwe2bioMJzKDNNoNPLsTzIwgeMarVqtho2NDVgsFqHHs0SBNXDUVfwM5ovW19elNxk/lygCa42Y51MhLfV6aVjJnGWynwwyNTVAg0Nni3rpRSK/F5rnwsNNmIWhdD6flxwLixUZLs7OziISiaBQKODJkyfodDr46KOPhvB44o9Wq1XyG/S4+/2+zGhh1JTL5XDnzh3o9XqpD7HZbNKJlVEKANlcNHzXr1/HxMQE7t69i4cPH0Kv12NyclI8dF47owp6+eFwGJOTkyNvTBqXQqGAra0t1Ot1pFIp8W7pmXONXS4XjEYjdnZ2sLOzI8rJ6XTi29/+NqanpyVxmMlk8Nlnn0mURSXm8/lQLpfx6NEjbG5uYnJyEnNzcxIB6nQ6XLlyBdevX5chRul0Gn/9138tA5EGg6NGhJFIBEajUbroejwezMzMoN1uY2dnB9VqVWqeqBCMRiMWFhbg8Xiwv7+P58+fj5yQJmOLiV4SFLRarUwxJFTHrtGNRgMXLlzA5OSkdGloNptCTeWaut1uhEIhIQowwjpZVMp9yD1uNBplsBwVBJ0ig+Fowmg4HJY8IUkAhJDYKZveYqVSEZiNg6mazabQ68/S+BM4GvHNhC6hPkJZnBjJRpK85m63i42NDcTjcYG/zWazdCbn7zKZjDRWpTfP6Z+sk4rH41heXsbS0hIASC6Rw8sYeRLaLZVKAl/T4aLBVQt6m80mnj9/jkajgeXlZczOzqJYLArcSOhsYmICk5OTI6+hSmii8LNI8VdfoxoXg8GAcrmMx48fi6JW87vtdltq2NQWLjT4HI2g5koZQfHscu8x8lZzW2pekhErCT16/VFDVebc2MZINS6Mdkl2OY28UHZVpbuph+/k4qvJd/U19EpolSkM0X7TRZ98YLTCfK+KB6rXxmvl64Dj5CFpqPxu4osMY3/TfY+6Mfl9vP6TZAX1e9W1VUNklbjAjXeSOaO+RvVCuLHohatJejWRyh5GhCV5TfS+1HwHf6eur/oc1c8f1Siroh5q9fvVDgr8bvVZ8vdftj9Vsgk/7+RzUL9fJVuoXRBUqPjk/fN58P9UaEK9H/Xa+KcK1X0VcvIeVIV1UnGevFfgGBoChskVv+lcnKTG8n1q/kz9DJVM8WXJ/5PvVUk4KnmHZ5w/6v49i4H++9b1NK9Rz71K5FA/48s+6+Q+O/m5J8/G3ycndSRwTDj5sveOuvc0g69q157LuZzLuZzLufxKvnoTfi7nci7nci7/v5dz43Iu53Iu53IuX7mcG5dzOZdzOZdz+crl3Licy7mcy7mcy1cu58blXM7lXM7lXL5yOTcu53Iu53Iu5/KVy7lxOZdzOZdzOZevXM6Ny7mcy7mcy7l85XJuXM7lXM7lXM7lK5dz43Iu53Iu53IuX7mcG5dzOZdzOZdz+crl3Licy7mcy7mcy1cu58blXM7lXM7lXL5yOXXL/f/wH/4DOp0O7t69i6dPn8qQIHWm8vj4OGZmZmQ+QafTQSwWQzablSlmnDPCyXdshc0hNJxlwJbbAGQATjwel4FPzWZzaNAQW4MbDAZEo1FYrdah2d/FYhGNRgNra2tIJpNYWlrC9evX0Wq1sLW1hVqtBrfbLaOTObMmEAjAbrfL0LB+v49/9a/+1Qsv9I9+9CP0ej1sbW3h4OBAJuwBQKlUQqvVwttvv43vf//7yGazeO+995DJZJDP52X2SLvdht1uxze+8Q1Eo1FsbW1hY2MDBoMBbrdbBjy1220ZGdtqtbC+vo5isSgtu+12O8bHx2G323HhwgVEo1FUKhXk83nUajVsb2+jXq/jtddew/Xr17G+vo4//dM/RaPRwM2bNzE1NSUjZvP5PD744AOk02mYzWYZ+NZut2GxWPD6669jcnISOzs7ePbsGfr9Pp4+ffrC6+f1eqHRaOB0OuF0OmWEbqfTkWfLuUCcxKeOKlZHQJhMJmnzzqFgTqdTBjNxvAEH5LElOmeiGwwGeT1blHs8HkQiEXQ6HRweHqLRaEhb82aziVKpBJ1Oh5mZGXi9XjSbTTQaDZmBYzAYsLa2ht3dXWnDrtPpYLfbZS9yRtGzZ89eeP0A4Pbt20P3o85Z5+hefk+v10O9XgcATE1NyV6qVqtDreEPDw9xeHgo68q5H5xhwsmFXH8OUuP0S41GI5MlOSuKowY4lMxkMslYcAAyBZR7ttFoIB6Po91uY3x8HKFQCN1uV56B2+2GxWJBsVhENpvFYDDAP/kn/+SF14/jmL/3ve/hjTfekNlP7XZbxiyXy2WZlcMZQXx+TqcT4XAYtVoN77//Pvb392Vwl9PpxPz8PMxmM0qlEur1OsrlMlKpFCwWC65duwaPx4Of/OQn+NnPfoapqSn88Ic/hN1ux8rKCmKxGK5cuYK3334bGo0G2WwWjUYD6+vr2NzcxOzsLL7zne/AbDZjdXUVyWQS+XweyWQSfr8fP/jBDxAIBPA3f/M3+PDDD+F2u0WXb25uIp/PIxqNYmpqChqNBn/8x3/8D67XqY0L5wgEg0F0u92hUbYcp8tDybkhHHbEyZMclMT35PN55PN5OBwOzM3NwWQyydCdWq2GQqEAs9mMixcvwu12y1xym82G8fFxOQQcwkQjkEgkkEqlZDZ9tVrF7u4uGo0GWq0WzGazTMezWq24ceMGzGazTK5TZx1wWBjHKI86oWBzcxP9fh/FYhHA8TwWjUYDi8UCvV6PQqGAhw8fQqvV4sKFC5ifn8fDhw+xvb0tsxaMRqNsagBygF0uF/R6PWKxmHwHpwtevnwZWq0WlUoFtVoNPp8PV65cgdlsRjqdxvr6ujwTTlzkUKx6vY5msymT6XZ2dlAoFIaU8+zsLObm5sQA1+t15HI5aDQaHBwcoFQqIZfLDc3iflHhJFH+nfNB+OfJuSvcF36/H1arFbVaTa7J7XaLIuS+LZVKvzZgiUIjos4hB44nlaozd/hc7XY76vW6GEC+nkPoaFy0Wi2KxaIMEOP18xpqtRqazSasVuuZZ5HwM7mf1Vk9Pp8PJpNJxghrtVr4fD7odDqZmmo0GmG1WjEYDGQUs0ajGZosCRyNIKcB5+RIdV4M9wCNF4eGNZtN5PN52eccfkW9oc7AofPa7/dhMpmwtLQka88/6cDyteVyGeVyeeQz/Prrr8vsmJWVFZlxr9Vq4ff74fV6YTAYZDjho0eP0O12ce3aNczPz8NoNIqzwzMbiUQQjUZRKpVw7949tFotRKNReL1eOXP1eh0ffPABgKOheXNzc9Dr9fjss8/EETGbzTg8PMRf/uVfwuFw4MqVK/D7/UgkEjCbzTJht9/vw2w2w263y/u63S5+8pOfSDBQr9dhNBplf3LyK523r3xYGB+I1+uF0WiE1+vF7OysXKjBYMD+/j52dnZkpjQjmEqlIoqUU9j0er3MDw8Gg1heXpYpahzpm0wm4XQ6YbPZEAwGUalUUCwWEQqFcOvWLZjNZsTjcRSLRfEci8UiNjc3kUwmYTab4fP50Gg0kEgkZNFoXLLZLILBIC5cuIBQKIR0Oo18Pi8Kq9PpIJFIyGjfRqMxwpY8Ek4dPDmcSj1IlUoFGxsb8Pv9uHHjBiwWCxKJBA4ODsS4GAwGUWQcOGQ0GmUqIGfJGwwGNBoNOBwOzM/Pw+VyIZfLIZvNIhKJ4ObNm9Dr9fjpT3+Kvb09+Hw+RKNRGbNKw6JOpOt0OojH40ilUrJGgUAA7777LsLhMDKZDAqFAkqlkiifVCqFTCaDZrOJer0+8sFmFEEFzkP1ZQPeVONCb5GjiAHA4XDAZrPJZ1SrVaRSKZkWSeeIe1ZdZ3XSH40EJzZyzjiVDJ0Z1aDWajXxdhuNhhx4dZCYuk/UIV1U7KMKv4fOG0fearVaURzpdBrlchl6vV7Ghm9tbSEWi8HtdmNsbAyDwQCFQgGNRgM+nw+hUEiiRa75SWPIdeV+IvrAaEan06HdbiOXy0Gr1cLhcEikxnHTXHN1UBuVJaPpYrEo48D1ev2QMa1Wq0OR14vKlStX0O/3kUwmZfJlsViE2WyGx+MRx4NnaGNjA9VqFfPz87Db7UOIjtFohN1uRzQaxYULF7CxsYHV1VXkcjl87Wtfg9frlUm4RBMqlQpmZmYwMzODYrGIlZUVdDodzM/PIxgMIpVK4d69ewiHw+KQ22w2mEwmWQuuN8fKO51OpNNpfPDBB0gmk7BarbBYLDCbzTK63GAwyKht1bn6h+TUxkU93BQesnK5DOBoBnypVEKn05E50GazGQsLC2L9qETpRdMjoVdrMBhkrCkAMQTFYlE8BIPBgIODA+h0OlSrVTSbTRkj2mq14Ha7xRuz2Wzw+XwykpeHVzV6u7u7qFaryOfz4vUDkAPDsar0hEYRl8sla9bv9+H1ejEzMwOtVivjYe12O2w2GwaDAXZ3d6HT6VCv12GxWGRMqcFgQLPZRKVSgdFoRDQahclkgtVqhUajgc/nQ6/Xg9/vl7HMqVQKqVRKIstcLodHjx5Bq9Uin88DwNAMdKfTKQe6UCig1+shFArBbrfLoaaxbbVaSCaTaDabKBaLqFQqqFarqNfrcvipmK1W68jrR3jFZDLBaDQOTQelcqLQgaHyp2GhYeK+5d7TarVDUJs6YhY4nqKoTj3kREGHwyFQHO+X+1rdb+r1qlMX1YP6ZZ9PUSctjirqvTOCJ0RVLpfRbDbR6XQEiuMesFgscDgcsFqt4jRybDdwNOK31+vJKHGOP1fvg+tA3cDRuRSuHxWaxWKBzWaDVqsV54av4XUyatHr9QKD0iHS6XRinKhYrVYr3G73mQw095vVapV74zXVajUUi0UxvNFoFO12G/1+HwcHB+h0OjKq3Ww2S8QXj8dRKpXEKaHDwxHENpsNCwsLGAwGsNlsEkFP/X/tvdlz22eW3v8ABAESIAACILivErUvlhfZvdi9znR6KpNKapJcJX9C/pnc5z6VSipJTU1mpqd6Zno8cW9eZFuyFlKkuIEbSBAkAG7YfhfM5/AArUkoyL87vVUq2zIJfL/vcpbnec55p6ZUr9ftOvhoNKrx8XGl02mzmScnJwoEAjo4ONCDBw8MlmR++vr6FAgEdPv2bY2MjBiEh03xt9dy/fu37lzYOMBeREHVatVwz42NDa2vr6tUKunFixeq1+v60Y9+pLfeektHR0c6ODjQ0dGRFhYWdHBwYEagXq9ra2tL0WjU7ms/OTnR5OSkbdpSqaT+/n7Nzs6qUCjod7/7nY6Pj5VMJhWNRm0Ru7q6dOnSJYt+cC6jo6MtG/Pp06f6/PPPVSgU7GeJ1knnu7q6FIvFDDcllexkjI+PSzq/1nhqakrf/e53FQwG9fTpU+3u7trCl8tl/frXv9bR0ZF6e3s1MDBgkV4wGLR5HBkZ0ZUrV1quzQ2Hw5qYmNDg4KAuXbqk/f19/c//+T+1srKi4eFhDQ0NaWtrS7/+9a/VbDYNj97f39fW1pZCoZBGRkbsvvaVlRU1m03dvHnT1qlcLqtYLFo28tVXX9ld33AWwHZAfiMjI3bnfScjHo8rEAgomUyqr6/PODmw7Xg8rs3NTeVyOYvO6vW6dnd3tb29bdFuKBSyrI9sIRQKaXh42KLSvb09gxsbjYYddL6T/R8KhTQ+Pq6BgQHt7e1pY2ND1WpVOzs7qtfrdr2zh9nIiPj/3mEQ6QPPvezK4dcxjGS9BFZwOtKZgTs8PNTIyIgFJUDbQCE9PT2WuZFZ1Go1FYtFMzyseTQatWAGgxwIBOy+91AoZNkN73VycqJSqaTe3l719/ebkQTK4sruvb09lctlJRIJpdNpNZtN4xSBnYDTcKgYzEQi0fH8MWKxmDmszc1NVatV49TghXt6evTWW28pEomoUCjo008/NTQmHo/rT+CVUl8AAHBASURBVP/0TzUzM6OlpSV9+eWXqlarmpmZsbnY2dlRrVZTJBJRf3+/bt++rVQqpeXlZS0vLysej+vatWu2doVCQalUSjdu3DAbwnx2d3drY2NDf//3f6+uri599NFHunz5spLJpIaHhzU2NqaxsbGWbLBUKml9fd2cpnQGY25ubn77sBibClwdDoIIDVyZTSmdHQg2EekpaRYYPxESBCopGERo+93yHECgNTY8Bwf4AAijp6dH9Xq9Ja2u1+sGjxEpsHn9Pdvt93G/LKK86CBiKpfLRjTy3e130VerVXN0RBcMH0VjhCSZ8fN3dGPomXOMnY+mcZpHR0c6Pj62SCkWixlnAEmL8KJWqykajSqRSJjR8XeVk4FKsu/EWfsMo5Ph7wvnXbxxbr+z3js6fpe/83ewk6W8zHh7vqD9DnpJtpaxWMzOB3vO3/f+svvivSDGr493gDxDO/z3qsNzR/zxZ/Vl34dhJmvBIXLeJP0B5+XnzD+z3+N+TpjL9u9v/6xaraZqtWqwInPEZ/p18ffNky2+7gDVQATCnuH7/ffBVSBGKBaLqlQq9lx8Rq1Ws0Cb7BzUh+HPK+9GoBMMBs0pSLJzikMGQTg9PVWlUlEgEGiBJYEyPeTIZ3sO/Z+CoP9v48LO5Xvf+56q1ap+9atfaX5+3uAXFFldXV0aGBhQJpNRuVy2g9bf32+EMD9369YtSWfRaF9fn/b3902xlUqlNDs7q+fPn+vhw4eSpLGxMcViMVWrVW1vb6u3t1c/+clPWrDDg4MDU6Xx8xzWo6Mj7e7u6vT0VIVCQXt7e4pGo/rud7+rnp4eDQ8PG8ZIGskE4li2t7e1vr5+0en6g/Huu++qVqvpt7/9rZaWlhQKhbSxsaFQKKSdnR3jeqSzCAGcGGN/cnKi/f19NZtNpdNpSWcRy+bmpkVsRMFAfY8fP1ZPT4/efvttffjhh6pUKiqXy+ru7tbdu3fNIBJdbWxsKBwO6/Lly4pGo3ry5ImWl5dbYKT+/n4lk0lNT08brAJUyXP7DHF3d9cUVoeHhx0bx/39fYt8d3d3LbMAGiU6jsfjxtlxiLyzIcotl8t2mHCe0lmGTrRN5C6dOy6yDsQf8ElDQ0P63ve+p8PDQ3322WcqFApmCIExUPX19PQYj+dVbEBPJycnOjg4sHXlgBPAdTqAXMfGxpROp1uCmoGBAaVSKYVCIeXz+RZyPB6PK5vNmtHxTsUr63A4/BODBbfDmvlAB9gLRR9QXLFYVK1WUywWM0HG9va2Tk9PWzgUSbbuoVDIAipgWo8+cL47zf7+x//4HwqFQvrggw9069YtC5Z5hp6eHg0ODhrCQTa/vr6uZ8+eaWRkRPfu3TMeGY5paWnJMpFoNGqK2XK5rJ2dHe3t7enjjz9u4ZtqtZoePXrUAluRiR4fH+vZs2c6ODhQOp1WMpnU4eGhwYzYwfX1dX322Wc6PT3V3t6ewYnYPxwy6xQOh42rvMi4sHMZHx833gUPnkwmTVILJwEhBHZNpIvHQ/YZDoeVTCaVSCS0tbWl+fl5U1GkUinjUIi0+vr6THIai8U0MzNjCrTu7m7DLTnIwCiS7LuRV5ZKJaXTaWWzWYOdIpGITk5OVK1WW6Jj/rm7u6tKpdKx2ml4eNiUaPv7+zo4OFC5XDZhQ6VSMSOOYcagc+BQTGEsS6WSDg8P7TCB5XZ3d1v0lMlk9N5772lyclK5XE65XM7UduDVRNNHR0eKRCJKp9MGWYBlV6tVBYNBpdNp9fX1qb+/X9ls1pxzJBIxHg1smUyoWCyqWq3a/ulkkH3AY5AtBQIBm6tUKmVqRjI3H1GyF4AXffTHnGHIvShAOudDPC8COd5oNDQyMqKxsTELrOAeyRzJ0CORiHp6euwZ2Jvth5folXnneV4nc4EvwYkR0TabTZMFw6V54U0mk1EymTSDxz4jgmaf+oytPRPBMbdnbUC6XmVKECHJ9rMk21Osq1dw9vf3t6AQnCOCMwzl60CLc3NzCofDunnzpjlLnDNnKBqNGpzKPiyVStrZ2VE2m9Xw8LCSyaS6u7tbnCDoAuvAfAIXAlFFo1FFo1EdHR1pa2vL9j3UwPHxscrlspaXl7Wzs6Pp6WlTmHphBFwk6jD4VtYcaBLbC0/DObnIuLBz+fWvf61qtaqjoyMNDw+bdBJFViKR0NHRkWGFYJ6ZTEaZTEbb29vK5XKSzgxtLBZTpVIxDJ+H5md2dnY0NDRkss5IJKJsNqtMJqPu7m4jjznsGxsbWlxcVCAQ0O7urnp6eszREfUDWaA5Hx8fV6PR0O7urv1MuVxWJBKxSMjLhCHlOhnffPONLerAwIB6enrsAO3t7alQKJix6+rq0uDgoB0MDizQxKVLlzQwMKAXL15ocXFRoVBIQ0NDLZAXpGM8Hpckg7dw7NKZoV5ZWdH+/r5xBmRU4XBYq6urKpfL6uvrs03KM5DOF4tFraysWJRNtI7MNJlMamBgQLu7uy3Z2asOBBE+ysXJYoiBCILBoAYHB9VoNFQoFLS/v9/CmWFcyLKYZ/YasnQ+12czRObJZNKiQHiHhYUFHR8fm+Pw0XoikTD1GUYA40GGBGzC/AUCAQ0ODlrm6uXYnQzOCwYEY8GaeEfqZdlkzEdHR9rf329ZQ5ylfyfqUQiMyCi6u7u1t7dnkuutrS3LyDxMw/cj6S2VSjo9PVVXV5cFFRDZZFs4G+ptmHOCDzLfWCzW8fz9yZ/8iX3er371K9VqNbNbW1tb2t/fN8kuGRMCCZwksPHOzo5ldKAIyKVZl1gspoGBAVWrVfss5NTd3d26evWqzUl3d7fGxsZ07do1C4J3dnaUyWSUSqV0enqqTCYjSSYQom6p0WiYrR0ZGdHg4KCOjo5MzMPZIAu76Liwc/nbv/1byyLGxsZ0cHCgjY0N9fb26saNG+rv79fh4aGRwul02hxCNpu19A9D2d/fr6OjIztEcDCrq6taWVlRPB7X2NiYZTqQcYlEQuVyWblczg5crVbT5uamlpaWzAgQtUP4gWESIfT392tqakoHBweam5vT9va2Njc3lc/nlUwmNTk5qZ6eHstudnZ2tLi42LFz+eKLLySdGXSUVxitnZ0dbW9vGxfQ39+vS5cuGcTDs1PLc/PmTY2Pj+v4+Fjz8/Pq6enR2NiYRcRsRpyYJMNb2fgYuWfPnmlhYcGULt5wYIBSqZRu3bqlaDRqShgMaqlU0uPHj81w8Y6VSkW9vb360Y9+pOHhYSsw69S5sI57e3sm3mAtgBGoqYIA7e3t1ZMnT1QqlRSNRjU4OGgRIREs0S0GYHJyUtlsVsViUZubm5ZtAU9Vq1VFo1GNjY0pFAppfX1de3t72t3d1ePHj+0zyUSIZjOZjAKBgBGtKNMkmRwYqSwwE+s6OjqqfD6v9fX1judPkiEBnCeyCUktmTKGBGhub29Ph4eHKpfL2t3dbVFpZTIZ40jJwPf391WpVEydFQqFLEvHOPrPJ5vx2WI+nzcIs1AoGLGNMKBWqykej1sQgfSdIKyvr08jIyOmvCwWi+rv7zeH08n4N//m3+j09FR//ud/rl/+8pcaGhrSnTt31NXVZYrJqakpxeNxe95ms2l7izlvNpsG8SUSCb3zzjsmiKKYm2CIrI1s8OnTp9re3lYmk9GtW7dMwdlsNnXlyhXdv3/fMpzd3V2bW4pK6/W6qTyBj3t6ejQzM6NkMql33nlHN2/e1Nramn7zm9/o8PDQ4Od8Pq+NjY0L78ELO5fh4WFJ55FjJBIx+IoMBDkx8FOtVlOpVLLiSC/dI1ohQuGAsWn5b491I49jc0tqeVGMM8aHv+PniGrgOchEenp6rGgJrJTnB/qT1ILBv+pIpVJGsCGdbhcItH+2l416gq99ThAvABHW63XLuCKRiMGPnqSjOK+rq0vxePwPBAFAmMwXDpsCOYwIkY1XgRFlhsNhVSoVbW5uWjTb6SBDJRMGZoPL84o5on+gEAyXJyf5TOlc/AD0SMU4hq49wvcDKMNLd1FXIZKIxWImr08mkwaVscd4bp4HZZPvLoGE9XXUYgReZGwQ9VKrIIRz2U7uA337ZyDjqNfrBqVS9c+6+D+cLzJc71w8l0MAgFgIrks650FxKjjycDjcEowBcXtByuvIueGBUCjGYjFT3dGdghofoCgkwkDN2CZvn8j4fO2UJHtu9i7vz14jK8RWxuPxFnVmNBo1ewPqUKvVVCgUjN+KRqMWTFQqFR0cHFgASfEqNuBVC8kv7Fz+xb/4F6rX63rw4IGePXtm7QFqtZoWFxf1xRdfqL+/X/39/VbxLJ1BD9vb29re3rbP4iGBFMLhsOGGU1NTGhwc1O7urhUeUqgJpk6KeHR0ZHUuEKgYs6OjI1twrwJLJBJWfPnw4UNlMhn94Ac/0MDAgEXiq6ur+s1vfqNGo2GGmczJG/lXGR988IEajYaWlpYMdvLDE8jBYNCMJ9wMh7G9qI7irWw2axp45Lanp6eKx+OmYUf9lcvl9PTpU5N3DwwMaH5+Xuvr63bYA4GA+vr6DG9nc09OTqqvr8/a2EjStWvXzPgCc2CgX7x4oa+//rpFddfJwMjfu3dPV69e1crKin73u98ZTwSsROSPuKNarVpNxt7enkKhkMlome9qtWpdB+r1ugqFgjlh9h8BBkYADiiZTCoejxsMm06n9dFHHymbzerrr7/WkydPrCaBfRwOh/Xo0SP95je/UalUUi6X09HRkYljyNolaWNjQ8+fP1ckEnmtOitJlint7u7q+PhY8XjcIG7vUNrVW/AHlAog8aabBsWjk5OT9sx7e3stTok2J+1G1av2PNeFM43FYlYfByfQ29trFeTPnz9XPB7XrVu3FI/HrZCXei5J5tSBnjrNXH7zm98oEAhYu5S1tTV9+umnCoVC+uEPf6jp6Wklk0mlUikLrE9PTzU6Omp2iC4RGHVIe/Zho9GwQLy/v1+jo6NqNM46OxweHhrvmUwmLfjLZDKKx+NW2d/V1WXr9PjxY83NzSkWi1mC8OzZM21tbZnjPjk5aSmM3tzcVG9vr7LZbAs1MDw8rOnp6W/fuYD9sUFYMDIF0iuiAzw0kcXJyYmltGwk6VyOSDQejUaVTCYNrsB7A5thMCC+WBBP0ILd8u8e+wWfhXQmKkXui3IK40I0B4ncKSyRSqVUr9dtk/nh58D3dkKRxFwyRzgOcF0Wn0PMHElnhjEWiymRSJhh55Dh2OGmvEpOkkm9vSOEjyJaYl5YW0ktRYjHx8fa3d1VX1/fa9UYkKmRBeAMvIyYOZBkkS/ZqD+8L5O9ErmzX9rXxkuI/d8xDzgg2iKNjIwon89re3tbsVjMoJFMJqNoNKrNzU0lk8kWmWf7vIOLg+X7Oe50QBCj4GNO2qXP/Hu79Bsin7lnLr16D0GPFyR42Th/vAS2PXPxf7z8lnVAfUhUTvZCls3c+XIC78A6Gfv7+2bcM5mMdnZ2VKlUTFZM5kCQwtlFpAQMBQLAO3NWqZ3xgQ0Zm+dj2888ZxynS4AiyfYNReyUH5DxkIkyXwcHB4ZKIXTC/kp6pf13YeeytrZm+OvR0ZESiYQdjunpaStWzGazVmVLlFcsFhWPx/Xhhx9KksEBbJSTkxMtLy/bJioWi+rt7dWVK1eMPPXEIYQtnpcICGyYCWehksmkrl27Zr2TwDrT6bR6e3u1sLCg9fX1FgXI9evXbZHX19cVDod148aNC09s+wB6QnZNtIHBrFarmpyc1NWrV1Uul/Xs2TNrPofU9cqVK+rq6tL8/LyePHmiwcFBffjhhyqVSlpcXNTJyYmy2ay1PLl3757BHhDqhUJBJycnunfvnkXs1NOkUqkWxRzZYjqdtrlC/TIyMqKf//zn2t3d1ccff6zd3V1ls1mrVic7lc6cGbLLTo3j5cuXJUkrKytaXFzU/v6+iSDAsoGnMKDADRC9/CkUCrbvgB0kmYHCWdL1wOv74aCuXbtmB5o9Cj+HzPTWrVu6du2atra29NVXX7UY2mQyqdu3bxvXR1ZRr9dVLpe1srJiZwUVl+8e0cmgBUkgEGjp2eVrGKgbOz4+tugW5SUiDUnGUzFvwLH8IdP0dTv1et3WrVwuG8zDz2FAga/5Hr82XhGG4jQcDiufzxuHQzCE42aNCNY6HcxDpVLR2tqaiZekM8ezs7NjhbQEKtJZP8bx8XGtr6/rxYsX6urq0sTEhDKZjPFUvb29Gh4eNhEDjjESibQEPJcvX7Z2O9hQsiVQGR9kZTIZTU1NSTq3u93d3UqlUpYsECR5+xsIBJROpy07xSa8yriwc6HquFQq2aQh8RscHDRsv7+/3+SMTBTG8fbt25JkxoENvru7q6dPn+ro6MhwwampKXMIRId4+VAoZI0s8/m8kdNAZPAFRPw9PT2anp5WNBq1xo40jWs2mwYHofWXpMnJSVWrVW1tbalQKBhk16lxpH6BKlcPgRF5zM7O6sMPP1Qul9PDhw9t83Jgrly5omq1qr/927/V6uqqfvazn+n27dsG4/naipGREV26dMn0/QcHB1atHo1GdenSJUlnHXaJvmh0iWqJaIc/GO7j42M7MIuLi/qv//W/am5uTrOzs5YZgptLMkjjddROVBB/9tlnevbsWUs20Z61EWhgTDyPJKnlubxE1WeOsVjMulb7z5DODuzExITNS09PjwYGBjQxMSHpvLHm1NSUxsfH9dVXX+kf/uEfVCqVNDw8bHUOMzMzZsz9c0C4NptNg99Y19cZwGpeydZeREkWj4MGdqTljq8pwtCTweJUvLMmGsfpIBzxvKjPZFgn+Bqej3/3GQiBmSQziEh1eQ5fzEg21Wnm4nsflkolc2Y43v39fRMg4MTD4bBGRkaUzWZNuQhHOjAwoEqlYhkv/RVpxcP3kPFJ0sjIiN566y0LQKgFImtqL1ZG9ICS19fOoTLD2QSDQW1ubmp7e1vhcNgC9c3NTavpYf4vMi7sXLa3t20D+tYPkMPUmCSTyRbtvteyA1XQ+hrHUa/XNT09LUkaHR1VKpUyOagn4/hMFhhVDRNGhgMBzkbiGUkJkS+iL/fOCxiPSfcN+F6nTgOVEFJZGmdSX3J6eta2+/Hjxzo+PtalS5eUzWa1vLysra0tHR0dWfZYq521hSgWi5qbm1OxWDRe6ObNm5qcnLS+RUCYwFdEpV9//bVOT0+1tramQqGgfD5vEkYIeorPcISozUjJafszNjZmxGWpVFIsFrP281tbW6pWq+rq6notWGxlZUWNRsNwZ95NOieqcWhEtb555MsGa8/vBQIBDQ8Pa2pqyiJD5luSdS4Ih8NaXl42RVBvb69lyJ4kDQQCJi29ceOGyuWyenp6dHh4aO3Od3Z2WkhST3wz5xjJTvkqBg6C/lu8XzvEhyPl53Eu3tj7LABDD7Tqiej2iLf9e7AVvCeGC0gcnoqsFE7RP7Mf7bYCCI31eB3nsra2ZrxtPB7X4eGhqeHIYoHpfIEpbZJ6enqse7N0lu2EQiErD9jb27Ni8FKp1CJ+YK+D1CCgoEaJjMU7eOYfrpYskv5nXLHh1wYEIxgMKpfLWeZH4farzN2Fncvz588lnS3ewMCAae9rtZphy+FwWNlsVs1m0wheUjrSfe672NzctMUfGhrSRx99ZLUDkkxW62WPbO5ardZSpYtXHR0d1dHRkUE/LMrx8bHy+bz6+vqsghapKY01+bt8Pm8QX3f3WRPNWq1mUtpON+bOzo6RZzgUUmSc9vz8vHK5nM1HNBrVX/zFX1i3ZtrxQ66ur6/r4OBA4XDY3utnP/uZ3nnnHR0eHpq6hR5LOOKFhQX9+Z//uXZ3d83AkFX19PRYry74AZQvgUBAY2NjGh4eVi6X0/Pnz1Uul3X79m1NT09rYWFBS0tLunz5sm7duqV6va6nT59aM1HkuJ2MBw8e2GGhVgCn4rs2o2SkTkg674fnDTh7DEiSjPfGjRv63ve+p83NTT1//tygNUkmbS8UCnrw4IFOT081ODhofelSqZR1Dubvtra2FA6H9Ud/9Ec6PT3Vw4cPrSbr4cOHLRJtjCI8EtkDRhfcu9MBrAksxXd1d3ebIITzJclqmnCqzB2Euw/iMG6+GND3peL8ErCBKBB0wvl4OIiSgYGBAeM0mCPpvMZGOleG+WyWjJBnoyN1p7zpo0eP1NXVpffee09DQ0MKBoMWPGQyGRMzYZtQw5VKJe3t7SmRSOhHP/qR6vW6NjY2tLGxYX29Tk5OTNixvLysfD5vzWeZG0mGQqBKDIVCBomRtfvgpFKpWNCIU15bW9Pi4mJLCy+yVmTz29vb1jPwww8/1NTUlAmCvnVCH+yeha1Wq2a8vMRXOsdHiRTYLBxwcG3gE+m8/oRoxreDIDph45CNYBQODw8timonpCH7vDHCQ6Ou8hXuRGYsKJEAOvFOnQs1LbwTUJ4nIr0ElffwEZiXYHosm9/HCXhVGevB2njIiuyPKKudwCVdJ0v1wgJPgvMOSMWJtngGrwbqdACpATX4zLSdpPfv8DKn8rKfITNg/qjhIKuAn2HfESiQSTGXZMk4PbJvjCD/v1wuWwsYX5jKefEZDLzIt0HmY6T857/scz00ReTvpfNkBFJrBwz+m5/1mQv7hgCSPSyd9yfz3SX8vvKO1QsqPCfmyX//XASZ/P9OB/sZ5w+0xTNAAcAF+zos3zEaB4Sxpi0N/41T4qyRYSNhbxdDsbb8DnAqijXqm1Ch0jwU1SOZV7vgAri5HX7+1utcfv7zn6ter+vZs2daWlrS+vq6fve73ykUCunOnTu6fPmyQRFEOwwiCjbP3bt3Va/Xtb6+rlwup56eHsNh8fpszEgkounpaWtt3t/f3+JUVldXtbCwYFXmfAZFVpCswDt87tjYmO7fv69SqaTPPvtMxWJR09PTGhsbs5vt/EHf2dkxuV4n4/nz57bw3EbH3RUTExN2E93NmzdNwsvPkJm89dZbCgaD1sEWfBlnWa1W9fnnn2tubk4jIyOanZ016BFCExiGi6C2t7fNcBNd0qr7vffe0w9/+EPt7OxYH6PR0VErAMVhkz0ODw9bm/HPP//ccGNqiLwc/VUHEW06nbZCWt/tGCcHQcmh5bAyRzgKIDbWE6jvyZMn2tvb0+3bt/Wnf/qnCgQCWlpa0sHBgb7++ms9fPjQ+oXBJQEPhkJnrd8/+eQTVatVjY+Pa3R01A51pVLR6uqqybjhv959913F43HNz89raWnJDKcka9Pi4blOB/fpoFZClYbhADohWCGQAxaDfJZk2QSF0F4+DGzDTZHNZtO+pz2IIVuB26GKnHeNx+MaGRkxRaokK1tg7RGLeKPc19dnMmv+Hviu08E8wOFMTU3p9u3bOjk50aeffqpvvvnGHIV07sDX1tZMjOHl1qA5FC8T4FJHMzg4aLwwcD+qTw/xsfeY48PDQz158kTFYtH6D0ajUQ0NDalaPbsQDPtGBwEyV5wkAiY+l73zKtnzhWd6enralFOS7HbHnp4evfPOO9bTiQ3Ki3IIkf4Gg+d3spycnLQod9q9P7UqVLpStcqknJ6etlzP6/sO8fP+bhLpvNleLBbT5OSkcQ35fN5I2mq12nKfAgqR14HFisWiHSZa0hDVEgVls1nNzMxod3dXT548sXqEUChkmyMQCNiFR1Qi+4icmqKuri5dvny5JfIgQwPG8Df8tePpgcBZq4zR0VHL2pgXrx4hSvIKvK2tLT179swI1J6eHuvy3On8sabMBXNHxtIe5WOcvOPx88Q+8I6nq6vLrhK4evWqZmZmzBgVCgU9fvxYOzs7ks4vsCLDJiuu1Wra2NjQwcGBotGoBgYGWjg7itQQxvT29mpwcFDZbNa6W3gC19cGvQ5f4H+fIA/4yke/Uqs0XlJLo0kCLlRxXvpNUMcfL+Jgf/nn94aWYmZIc1ACsmFJLdE8EBB2AFUl6x0IBOzs0O8Ox9DpAJ3hTzwe1/T0tCqVij755BNtbm7afvTcErYEJ+o/i33nOSeCYQRP7Cvewe9j72AJnk9OToyq4HI/lGSIKhDtYOMIMHzRaiaTsf3nUZ+Ljgs7l9XVVSNtr169qmAwqPn5eUmyHv++DoXq7Ww2ayQ/GxP1UzAYtEgFJ5PJZOxuDfoR0SDx8PBQCwsLLVJXHy3t7e2ZUQRiYvMSUaDAOjw8NFycYjJEBD66IhsbHh429VAnY2Njw0h1Gs8BExC5fPPNN9b88cWLF3aBGOok+CyUe/BaOKju7m7Nzs5qaGhIQ0NDmpyctM0N/r+8vKzd3V2tra3ZofON9sCFh4eH1d3drb//+79Xs9nUxMSEms2mYcVcICXJiEWMg6SWqnJJJhDodGDkyZg4aETcRORsfgwM9TUefvE/D/kMtzQzM2PteR4/fqxaraaHDx8qn8+b3NsLC/r7+61ZIcHQO++8Yxnm3/3d35kxrNVqVsg5MTGhiYkJy7JWV1etMy0/L50r1TCar+NcgGloI8RgXxL15nI5E2AEg8GWi9+8MWQdyFT4fxiocDhswhIcFXsRR4vRlM4LKyG5cWo0B0UQ4vuLsYdxmLRMCQQC1hPNn+VIJNIxvPiv/tW/UjAYNOGQJCvYvH37tsbGxixbh/fr7u5WLpczkp79235NBXswEDgrtNza2tLBwYHdx+LrqXgHD1cCsxcKhZYsw3ffWFhYUL1eVzwet/uZsMmsi++/iJoMZRmqtIuOCzuX5eVlBYNBpVIp6/DLPSAbGxva399Xf3+/UqmUSqWSnjx5ouPjY125ckXj4+MtkaWvTRgcHNTh4aHW1tYknWVI1DR4wjEQCGh5edn0/0RRRDhU6YfDZy3g4/G4RRFozqvVqp4/f24OZnBw0NQfGAgOhlfM0IDTH8hXHevr6woGgxodHbXNSUTA5V9Isuv1ujmfu3fv6tKlS5Ym1+t1u1XSF3iS/dy5c0dvv/22ZXk4XRpTLi0taWdnRysrKzo5OTEJI5lUMpnUz372M928eVN/8zd/o1/+8peamJjQj3/8Y3V1denjjz/W8+fPdfPmTb3//vtW1EXggUOnrb1v2Pe6zqXZPJPCIuckoiVD8tExmUt/f79lu+wBjKEvyCMLnJ2d1ezsrBqNhh4+fKhSqaRPP/3Urv9lfxwdHZkYZXBwUD09PSqXy4pGo7p//75SqZT+03/6T/rFL35h2ZbHrkdHRzU7O6tSqaTPP/9cu7u75lx8nQLYvef/Oh0YEu7iQRCDhDccDqtYLCqXyxmUGg6HraErvcJ8ux2yBoJL6qBOT0+tTgr+iQib7uaIXIjiOc+9vb12CSDFkpD7Hg3BuXi+hishDg4OlMvlTFmJ1P5lRcwXHf/23/5bNRoNbWxsWFV9oVBQKBTS3bt3FYvFrJkrLfQJ0B48eGAO2gdcZNpAgoFAQCsrK6ZGXF1dVTQatc4Y7AfOA3+YYwpLpfOrCILBoPL5vObn51Wr1XT16lVduXLFnEulUtH8/LxKpZLByTgVHD3Osr3V0/9tXNi5oLfGkHObHAvdLg8l3YYXoFsqcmV+h+id6lFJdsDadfQYTG619H2gJJlx6+/vb/GwGBs2PBsdJQ9Fc7XaWdsaJpmshyjgVe4y+IOJ/j/pJe/rNxg3ZvKMRCpEiJVKRXt7e8rlcqrX69rZ2VGxWFQ6ndbg4KAkWeToO6/6uSEFBzdmrYj6IpGzVvt0rIbnmZ2dVSaTsd8hY2k0GmYciDwxKgg9PHlMxW+nclpgMf/fXkyC0fDQjiRzBD7698/VXkRIFugdtyeyCXgIlpDK9vf3m8pud3fX+uzR2YI/7GW4Cq6AIIpnzf33eaf0OoPfxzFglICjEcawj9gbzDGOG6PuA0U+i+9BocXgvfjul5HPHnLxzwcM5YUOzH975b0Xv4COeP6INehkUOi9sbGhfD7f0pCUPYYABNWXJFNlSuccGu9dqVQUiUTs3Euyz2B/gVB49Wt7oWhPT491OabmBij/4OBAlUrFOBUcUW9vr1KpVIs0vJ037+7uNkiNbPCiNvDCu3VpaUnSOW5LJAP2ykICZU1MTCgQCGh6elrDw8NaXV3V6uqqQUw8ONgpMslAIGCyYaIeNhLS2LW1NX311Vem14ZkHBkZUV9fn65du2b3UZNWQ2RLZ5LSWu3s4q5UKqUPP/xQ6XRaKysr2tjYsHbTXV1dViTHRUCdHnCvxsDw4rRmZ2c1MjKira0tuyJ1YmLCalm42vThw4dGlNZqNf30pz/Vj3/8Yx0eHmpxcdFk2/AytLgPBM4uoqI3G5GPJGu5ffv2bX300UcaHh62tg/f+c539O677+r4+Fj7+/t2L3hPz9llV7///e9tYwcCAb148cIuNwJ/53DfvHlTP/3pTzuePwoI+TwMYnd3t4kMSqVSy22BHAbqiSD0MWzg4nCC3hFjoLxD8N9NBE3x5M2bN/Xd735Xh4eH+sd//EdtbW0pGAzq+9//vjY3N/XFF1+YYpAzFAqFVCqVtLKyYtdtg4v7Z+Gwt9d0vOrwvcn83SvValXLy8uWNQBVI13HgWLgTk5O7F1AK4iA6/W6ZQjeKXsuyTt4n1E2Gme9/OAYUDJxVUK7ao7/R8aDnBbOl5ZLXkXo6zpedfzn//yf1WyedWwuFAq6fv26fv7znysUCml1ddWk/Fwb/ld/9VdWN4cdGxkZscC2Uqno6OhI+Xy+JejmEjTKAnyWBucZi8VM8k4RL9dfHBwcaGVlRaVSSRsbG9ra2lImk9H169ctE93a2tL169f19ttva3t7Ww8fPlStVtPAwEDLPS6hUEgDAwNmd589e3bh7PnCJx3P6/XtXjYotUodwV/xhGCCPo3zeCMptaQWKS2fiYfGGJC18HPI9fr6+szp4Vyk824CRN14dAhENjRpoa/I5jl9hvaqw2O9HnYDXweWIFLFoSEi8HCOh3XQuiNVlGQSQw4cEaGP2BlEkejlaWsOR8JmJ1Ilw+KeDQ5NKHTW5ZcGe7ybj3x9C/FXHd4p+WyCPQaP1S479nJLold+xkMs7VFxu7TTfy5OBiiSOhD2Fo4ddSOFmvB5OA+IVYw4RG77OWFPvEp19MsGn+chNs4XKkvOq1fVwUv5zA/jj4OSWrNLxBY+++Nn/Od4VMGfOW9LmHf/7qyDX7P2LJO19XzV63Q54BqAQqFg/AnvAVnPMx8cHGhzc9P6wnG+sQO+BstL0Al0/Pt5m8N3kbn4TI2MiayYxr4UNhOg+FIPbC8IDndA+Toh0KdQ6Lz7xkXGhZ3LpUuX1Gg0Wjw0BDMX5XhlEtJO7n84OjqytuMQ/hxuDKZ0jpET4dRqNW1vb1vxXDAYtLYLwWBQ2WzWJg3jFQwGrWtAqVRSIpHQ5OSkORcmnJYRuVzO+ijBvYA3ZrNZu2yHQtKf/exnF502G7du3VKj0VAul9PGxkYLts4cAadQOQ/Weu/ePW1ubhqP5QlQpNs484ODA62trZmK5vDw0Kr45+bmND8/b52DmX8iZknmjEKhkFZWViyTQqpI+n16eqpHjx4ZSS3JxAHNZtPuX+GAz83NWafsP/uzP3vl+bt3756azbNWPSi2pLPDRZbLYfeGGQ0/Ubd3LP39/ZqYmDAIhXVvNM66SKD62tzctD5mOGI4uPHxcU1NTSmRSJijyGQy9hkLCwva2toyFRoQQ61WM96LfUkxHN/p63hepycWY21tzbJYikcJFL1KCSdMIIDx8eoxoLDT01Nrn4SDYE/6bAvHurm5affkcI49p+TVfQSRxWKxpfMBEBkCHR8AQGqjFEXRR8b/OopPLqxDxh+Px/XixQvjNrLZrKEqXKx2enpqnBXtlLq7uzU+Pq7u7m4VCgXr3ky2isE/PDzU0tKSiaj8fVapVEo3btywq+IROJHZ+KC1r69P9XrdrleH98nlcvrkk0/UbDZ17do1KyaPRqMql8tWesE+HBkZeSVR04Wdy9DQkGq1s2r8Wq1m1e5eeomnJfIJh8OmTYfvIJJAbUOEQ2VpIpFowcEp1jw8PLSaDSIEDgqEPGoSrwxbX1/X5OSk7t69awQhUTeXcbHZOXREC+CNfX191nCv0405Pj5ulbkYY+8sPbFfq53duXB8fKy33npLt2/fViQSscvQvASXg4OTQBhAlHd4eKj5+Xmtra3ZRWwYSV/TwJr559rZ2dGTJ080PDyssbExi2AajYZV+ILVNxoNa4HRbDaVSCRaDv36+rrm5+c7nr+ZmRnjkXAunvcgMmNe2iW3OFqfNbOH4Qh8ZMfVDRC0Ht6gYWIikdDAwIDBiDj+eDyuev2s7x2OiUaNYNlUbWNIIbHT6bQCgYApAr3c9HXIfOmsSwTvEAqFLHviLLU3hiTjxaBL59kvzmZ7e1t7e3s2541GwyBU3gkYnZ5vKKzIwP3v8t8eQua846iAYavVqhUDkvX7e5iQ0krnGQLP2smAR0Y0QHNPvx/K5bLm5uYsY5NkxcdArASNOCt/QZx0nnFVq2c3T0KoZzIZ4xeBYwn4yP4I/Fg3BEmSrA8jQfju7q59/u3bt+1agu7ubm1tbWlzc7NlfVKplNEdFxmvROg3Gg2lUinrGLy7u2vR6tDQkEEEZCrSuaEC5kHiGIlEjORErYKx8+mul9nyuUdHR4ZXev5Cao3mI5GIRkZG1Nvbq42NDXV3d1tVdDgcVjqdbrk/mmiJynRISD7vdcbS0pIdmtHRUYsygDwCgfN74ZmvUOjsymGitMuXLxskhYOnNoJMK5VKGW7tISvmhsjQk+Hg7CjZaEcSDoet4SdROfNN4RaREEWCROJg9BwcLwHuZFBDQI0Phw010fr6usrlckvNAEaZ/eGJZ/ZcMplUX1+fRkdHbe8RhbPHgAiI4OPxuCYnJ63Vy9jYmNVqIfne3d21bMVzXLSZKZVK9i7MCfJ9MHdPYkuv1tfpZYPACQLXq9KoEfEwKSorakg8Se55D8h/70C9sIQzCVxDHRv9/jxPwqVacAkEfL4eC4ic2i/vqHymt7293QIpISzpdHCXSaFQ0MLCglKplGZnZw0y3Nra0vHxsUn7cXgEcEB2p6enyuVy2t3dVbPZ1ODgoMGDfn96+BtYnD2XSCSUSqWskBWIlZozJN44UvhFnHK1enajKiT/5uamyeS7urq0v79vWR6fRy3hRccrdUUOBs+qyYeGhjQ/P69f/vKXOj09tatYh4aGNDo6qv39fX3zzTdGuILbcY84joQIJxwOG9YPzufVZBgFomSiSaA2b0Dq9bp9bjab1eTkpEFDTHaj0dD09LQuXbqkcrmstbW1lrtd+vv7NTs7a7UKRJjeELzq+PzzzxUMBjU+Pq5r166pUCjoxYsXdmCIKNiQHJK5uTk9evRI169f109+8hPruVarnbV2YJPfvn1biUTCWu7jmH3hGHgthh6nlE6n7blCobOGlFtbWxoYGNC9e/fs+mo2Jd+NyoXDjSNJpVIaHR21A+J7LXU6f8+ePZN0LkCIxWK6dOmSrVGpVDJD5TFleANgU+YWQzM8PKyhoSHdv39fvb29mpub0/r6uknbqVlAkknPtVu3bimdTuvOnTu2nhsbGyoUClpcXLRsngI6uEKyZpQ80rkToQce+wEjDbTzOvMnyW7IBPqVzjIQVEYQxmSCHrrhYrnR0VELKBAlxGIxk4gj8U8kEqbUI2OhGh3ohiCmv79fsVjMro/u7e01e0BGgGzaZzaoQumoAdfHviPDRXDEJWyd8qZvv/22qtWq/vIv/1KffvqpPvjgA73//vvq7u7Wxx9/rOXlZUNEfIDI9Rp7e3taXl62YKharerWrVu6c+dOy5mnu3upVLLAhPN1+fJl3b17t6WFFuUVe3t7VmdDUOM5aepo/DUbfMbc3NwfdJ7glk0gcRRo3zqhj0fjgSjmAbpCxuiJRySVGCUgACAnCHdPKvH3EOwQit7hcPAwkEwIv0dVq5cye0kz/y6dXxRF6uqJYIwxEQQL1cngGX12NzY2ZvOC0/N1K4ggSPUhBIEsgKM8/OQzIU/2MRcM1sdXAnMYiGxZE74bMpioDLk3BhHnDsxDdNxoNCz673TQwaGdiPYEsp9H3r+dFPZ7gHmSzoUN5XLZ7iwCLvNZNfMFRIjj8Vm1v7ZWOu8IwFngOT1EBRRFpMpe9hmCJ8Y7GcBJwMvSuVCHvUGEC9/i4SqfGfj96tV37E3qVvzPEk37jsy8m+d1vGyZ9/fE9suyOfa952u89Pp1hBAMAgXWmA7GiDCwOdRzeXvlRQ/MA2gIcw3E7W0OZxc4jHOKPeF72Bu+6NZnLuw9vgd75ykM5pC96K9K99noRceFncvY2JhF19JZFHT37l3t7+/r888/1/b2tu7du6f+/v4W1Q5cRSwWs35YFEh5nJerTGOxmPXRIS0j88FYnZycGLTEBVVc1hQIBOyKTwh9Mi4Wt9lsWnv4vb095fN5uy2RC3JyuZwajYb1BfKL08m4e/euJNnzXrt2TePj4zo8PNRf/uVfan5+3jYeMCMLT+GeN6ocZjI9YEta5fCu8FLpdNrgBe9YwG7p7ksbGgKDRqNh95bAI/jCOyqPpfM6FzBlsgpJ1jW206iRiIlnKpfLJm3v6+tTMpnUzs6O3ZXDu6L+8xkLeywUChmU9vTpUwWDQX3yySd6+vSpotGo3UN+7do1JRIJ5XI5ra2tKZ1Om2QTI1osFrW0tKRCoaCDg4MW/JybUeEC4Qi4kpYsAujIO25a7dBpoNP5k2Ttg4CaqD0DVmk0GhoaGtLIyIikc6UdBqrRaO1y3micqS6RvPuIvd1p40xKpZKR8JJsHgYHB40s9r8DjyDJbACBLdkJRrQ9wBwcHGzZx81m07LFTsb/+l//S41GQwsLCzo5OdHjx4/1H//jf7S7mLLZrAYGBizQ2NzcNLiQPeI7M2PP4JG5N2V7e9tUZplMRqlUStPT0xoZGdHg4KAFz5LsXZl71JoHBwfmyKmboRMIdAIEfTgcNvuOjWHtu7q6rMSDffKtZy44A6IBNoUkuwCLhocYYSJv76HxikTGpNaeWIaP4ffgIlCWeWUYnpxoEqIWo8ydCUy+jxr95AM1sRlRHlGU1N5p+FUHxVbJZFKxWEzZbFbXrl2zeiEfzbBxiHpeBscxh8wp79IO3xGdYEwxTqwlG9NLJdG3A5XwcxDdkNZ8BxE8sARQCZEQ++V1nIuXphOhlctlUwXhZNl7RK4eXvXvTbQIYczBo9ZoZGREY2NjpigbGBiwBok+cyfDJhjiULdnBKwt/4+5JjtiDf213NJ5QR01Ha8TgWP0wdrJuHyQBwlPcMZ+8pkp8wa34dvkgzCwVj5z4efhndi7kUjEoKuX/R7ZHOtJgITKlLn2qISvTvd3P3nF4KuO1dVVNZtNg2D39va0s7OjeDyu8fHxlvtsfAYAbAzZjl3z2VmjcdZSiCsYuB8LpCgej1tnD5+1sX7YZQIYvgfHC+/VLg7xSluKh/3co4rDtr5K9nxh5+KLuvCQPqpnAihcgoTm+lF+r1qtmgqH9BzYpF6vt9zBwJW5vj6g2WwqmUyaNLWvr88OKVGL78ODSgvnsLW1pVKpZAcskUjorbfe0tHRkeG7LDxGgENwUX33y0Y2m1UwGLTbLvf29vRf/st/0cHBgXUwJfsi4j49PdXAwIDGxsY0NTVlDpiOAul0uqWwzsMztHvZ29vT8+fPtb6+brfe9fX1aWZmRn19fbp+/brdlAdX4dvIk2aTua2vr2t3d9c2ZDAY1P3791UsFvXo0SOTOv/+97+390gmk6pWq1aI28m4fPmyqY5QDxEB4tTYo0TYFOxyOypRl+//FAgEzDl1d3dbmw1gmkajofX19Ra1YLVatSuoacq5tLRkBWxcDAdHyB8CI+qwwLvpaEB2g2Hw0DA4+etkLnRcHhwcbCG2fa0ZUCLBjoem/R9gT/YHgg6gnGAwaJXi7EeUXUiKfUAjnRdUIr7wWYc3bFS8w715iJQswWf5OPaenp7XulOItkCJRMJuOqX5KFwf3dmBmsLhsGXKyKo9t1EsFs1p+WL0/v5+65jhW+GUSiW9ePHCAnpaviAJB8bmHEjnNUdk8DMzM0qn0+rp6dHi4qKazaadKfZlJpPRpUuX7LnZv68SYL+ScwkEAhal7O/v26EDygFWAnrAQ/OSHBYuCstkMpZGYhilcwcGr0KNAf+f9vS+II+iSjIXoDbIxlwup0qlolwup/39fQWD5w3oINRwQD4lx7n45+tk4FxGRkY0MDCgXC6n//bf/ptdTdxoNJTJZDQ+Pq6TkxNtbW2pXq9rcnJSk5OT1uLcR4ZDQ0MaHh5uaciJc9nY2NAXX3yhvb09LSwstBjD4eFhffDBB0qn0xodHTVC1W9Kryphfnmu9fV1E3B4nf3h4aF1OEDAwOGgQ2unc0idFTUjGGxULDgbnh8jNTQ0ZIT78vJyC1EvnWcu6XTaVGBXr17VwcGBtre3Va+fXQ2BGoyMeGdnx+TJ+/v75lwgXqm3YH3pv0UdAdkP3Q84vHBuFKiy5t+GYpH+gJylcDhsAYIPzngOHIzUyh8AU/szwfUQXk1ERkh/Owh5nAp3BXGO6/W6GTkiZc/zEOEjoeUiMR/9s0b+D9BaKpV6LUL/8uXL5tASiURLSytQFZRkvb29Gh8fNyFTNBq1esCTkxOzPfv7+1pdXTU0gwy1Wq0qkUgYXM18UzPDNRi+pKNcLv+BbNyjB/QMm5mZ0bVr17SysqInT56YqAmaIZ1O6+rVq7p7964pbdmPr1LIe2HnwiYjWvGV7EiLg8GgFQRSQES04vFaqpYp8PEksveyYIM+7fUpoZcxSuedcElF4X5OTk4sQwI+A4Okp1Y4HDYyzRPjkHP+OToZOGWiAN/yghoN0moPOUpnRCKqHaIhpI1g/kSP4KTlcln5fF77+/tmaKXzC9e8eAIjAQTmmxOSgcIj0KYC1Qn8B1zLpUuXrK6DCJQD5p/jVQdwBpkbECaYczKZtDVH2YVhRp0FZACkSEBE5Nkue0ctQ8EkhD1rRVeCarVq0mNfaU4RG5wLsBJGu73q3cMbXpLq/7wOoR+Px80Io/YjiCiXy6YUI8MjyCPzl85rXrzRbxdJeOfksxq+4+DgwApfWU9gRr+/gcE4856r4NnbHS6QWHu9DmvroeFXHajbisWiisWiuru7W/ruYei5pj2ZTNq7dXd3txRRYue47uP4+NhQGA9bMafAY+wditHJ0L1cmQyZ7JEgDJtJB4l6vW5rsLGxYXvQ7zWgR39/00XHK9W5SLI21pBOzeZZO3YUNQ8fPtTx8bHW19dbuu6iriByHhwctMjbq0BCoZBxJRsbG5Jk+LBXkrDRUF+xiJCGODayKi4YgtTc2dnR3NycySvT6bROTk60t7dnWRNkFmnjq2i82wcXg1FESlodDAY1OTlpEBcqjenpaYVCIW1tbRlRXC6XjaiMxWIt1wTwfBiLXC6nhw8fthCI4Nwonpg3CEUur0qlUsZboYFfWlqy6C+bzSqfz+vx48c6OTkxmGJyclK3b9/WN998o9XVVbvciC7VQ0NDHRtHX/sB8buzs6NQKKTh4WENDw8bVNPX16fLly8rGo1qd3fXLl7jQOHAM5mMJicnTQbrlZDHx8daWlpSIpHQD37wA126dEnFYtGCJYKNXC5nZD5XUFDsRsTJ78FPwCNI562OGo2GGVcvHsHAYiRfx7lMTU2p2Tyr01hdXVVPT48SiYRqtVpLy3/gaQpMPY9KRuH7pBGIsX8xZlSNVyoVbW9vW8ZxcHCgbDZrRYDUbMArdHd3GwxE8FOr1czesE6cdam1BghxEPPl1Y/8eyfj+fPnajabWltb0/b2ti5duqT79+8rHA5rY2ND6+vrSiQSunnzpgWt1Ocgtpmenm5RJK6vr2t1ddX6JpJJ8k4E3r6uJRKJ2Ln2tTDscQKiUCikFy9eGLoknWUzq6urKpfLGhwc1M2bN1UoFLSysmKlI9QjsraInujl+P8b50I0Qr8mSdZXycNJcAaodohuPKHqdfw+I+FwEWW+DJLynp3FaJdLQuJ5aS4EFkYYw+tJcC/nbf+uTgcKK8hbitLgLuB6cAIYGr85+eOJy3ZVDtke2RG32/GOvIef/+7ublsvL9/0yhEyVRRLvmiS7wCLR9LsswvetdPh24j7YMTPA/8OtNDb22uXwfkLzphX5gG4ln96EpsomQCJVvtEjog/cO4eduIZXyZ59gWt7fuO7+bv/Dq/DqGPgAaoiHX0yMDLSHj+n59j3sXvK1+G4Ml47IV3pGSPXioPAuGzIOn8XL+Mf/mnDN0/9fevA217bkeSCV1AEUAivPRYkmUb8FEetiLbiEajNj8eiscOvEycwj56GdHu10I6P/NklpxZX6bA2eGMcWbgAam9uSj3fGHngqQUOKe3t1c3b940XTf/7OvrU7lcVn9/v46Pj00dBWRBhT4HGaiMQ06UBNwAUVWtVi3bAQ4DvqhWq1pdXdU333xjmCK1JGxKCqpCobMq9qOjI5OSLi8vWxdbyDd+H2w9mUxqaGioYwfzq1/9SsFg0NrJSNKdO3eMRE4kEtrY2NDa2po5ZVLrVCplBBtkG//PG6mTkxPNz8/b3SOk57lczuaeTcaFYv7KWLI2nDKcwd7ensFrdB32Gv+JiQl1d3drc3NTjx49UqlUsuLW9kaWnY7V1VVbPxwXh2BlZUWbm5tWoIhzDQQCKhQKtncJVJhbMjyMejAYtCLUUCikH/zgBxYh0z5nfX1d2WxW77zzjrq6uoxHAmbz6iBf8wK0geHl7zHCrAs/A9zjHZk3bJ0MDLsn08kCkMpjYE5Ozq7appK7v7/f7n9nvsLhcAsUQ7YBTArXwXtKZ1ndyMiI9VjzzrtarSqfz1tG1d3dbdG4D06Q7PJZ2J5gMKjl5WW7jwb4lsCpWCyaISaYe5Vx48YNSWdlGZRVAP/WameNfNfX1/X48WP19vZqbGyspc1KuVy2riZwbLw/iE21WtXk5KRxs6BC7EP4Foom9/f3zWZFIhFNTEyoXq8bHBaLxTQzM2PvEAwGrftBs9nU4uKioQLwPlNTU6rVavr444/tdwKBs04lCLguMi7sXMAbwZ1HR0c1NjZm8sZAIKCBgQENDg62aOchszzhSkSCY+DQSzIP6QuKNjc3VS6XFQ6Hlc1m7TP4HUj/Z8+eKRqNWhsTUmMWBWiBAjjuVqD7AE0qwUZrtZrdMZ/JZKxhXSdjbm7OhA49PT0aHR3VW2+9pb6+Pg0NDSkajVqqDI9Rr9fNAQwNDWlmZka9vb3GJ/DuRHTANM+fPzeVCpkP9RPIRXFa8XhckUikpXUKn7W/v2+OinX3FwodHR3Z1cZ9fX2an5/XV199ZWRtIBAwQtdHbJ2MQqEgqbUdPvUhwHJEiBS1hcNhqwon3ZdkFejISdmHZLOHh4eamJjQtWvXjMina8HS0pLNHxJsL0TB0ICns+/I3oi2eV6ftWDY/eH1mcvrRN2SLEsCIiKDo5UO/BCih3w+r8PDQ01NTbXwku1ZM50DfFbpuSXmQ5J1hPCFgDhV1GW+uBKn0Nvba85lf39fu7u7liUTcHV1dWl5eVnFYtEMcjAYNKON4KfTMTY2pmazaXf0oAjkeVF/zc3NWXlBOBy2ZqsEu6AB7eUEzBctXgYGBjQ+Pm7ZBRkHrYNQI5KhAKudnp5aUIcd8NkgzowAsf1ysUwmY1eVNxpnxd7JZNKUaRfdhxc+7el02mSZRAIYf+4mSCQS6u/v1+HhoVZXV1WtVjU9PW03IhKBjI+PKx6P6+TkROvr65bV+NQX1Q0RG+khsBYcD8bOX2KDESTqpmcRhpYitmw2a1wQqiNJNvFeAnpwcGC8SSdjcnJSkmyjo6zq6enR/v6+IpGIKdk4VLFYTFNTU5qdnbUo0ZP4EKQ7Ozv67LPPVCwWtba2Zs/O94GPexEAhZEolSDrA4GANSM8PT1VIpEwyTdGgN5IuVxOhULBnHE8HtcHH3xgd9AQKHDIXmegKPJiBuS6KGkgi09OToxTOD4+Nk7F19kcHR1pYmJCk5OTKhaLevjwoYkBEIDk83lJ0vb2tg4PD20v7O/va21tTb29vS13b/T391szRWAn/g6SnIPNnvLSed+3yzshFFyvS+jzrI1Gw2AXiOVisWjNZzF4IyMj1nBWkjkeYEdgNp85s78l2d/V63X19/ebgKKvr0+xWEwDAwPm8CuVigKBgGVIXvHH2pMBc/aBKmnw2GicFXV6Qp+5Yw1eR3HHfiDAIUPGnrAHfMdsAjfqqDyU12w2lc1mNTg4qL6+PitWpMEvEFWj0bAgd3193fgdLkykJRdBoYeL4Vdp8SPJAgUyGM6/b5rb1dWl27dvW5YHz8OFhRcZF3Yuo6OjqtVqVqHNpFarVSNwfbsQlBOJREITExM6OjqyA3n79m2Nj4/r6dOnmpub08HBgRYXF63pG9EgKTyX1RC9EL0HAgEtLS1Z7QXOBZLvxYsXWllZ0fDwsJGs8ARIBQ8PDw0z54D5yIJWFb6yvZNx+/Zt1et1g3AODg70/PnzFkzeqzKAHn/+85/r3Xff1f7+vjY3Nw33DYfDBtWsrq7qr//6r82RAidAvvHMcFfd3d3KZrPKZDKan5/X8+fP1d/fb9co4xjGxsY0NDSkUChkDT8xzhsbG5qfn1dXV5d1Vv3www/1x3/8x3rw4IEePHigYrFocBPGsdMBT0aQQVDQ1dVlkujt7W3bm0+ePDEIgCyNmqdcLqdyuazx8XH9yZ/8iZ4/f64HDx5od3fXMrxm86wLLPsbpR7ww7Nnz0xKKp05l5GREWtVfnBwYDAue67ZbKq/v986GzA/1De0Zylk+wREr7P/pLP73nHGkLasDfJsOjNHIhG7btwbH7LAmZkZu2YaGNDXfnjFZqPRsPotnFoymdTk5GTLXk2n09aZwkvMgYQIIJPJpIk3mFsk8Bh5n0XxTPDBnY6VlRUFg0Gl02mTIhMgAHeDuiSTSV27dk09PT3WOcIXOGOgZ2Zm9N577xkU393drVQqZXNFgLS8vKx8Pq9cLqf19XXLLKWzMgeIea5qIAvGVhaLRVPy9vX12blIJBIWoBOY5XI5jY+P64MPPlA0GrWShIODA+vxd5FxYecC0YgnxKOCF/vFlM7JPiI+9Nm0Qejr6zNjzsuRnvlFINLzmYsXCPDzHhoiE6FhoO/TRGonyWAQ3umfIjchJKn16WQAwZE9vUzGScToiUscDfwT0B6RGH+Ardi4kIOk3nyPl3iC99IqH6kjWQYHlQOMofCKIAhtSaYqQZ3CO/iag06HV9B42MSrCDmQnmjmgOF0mWOyv1Kp1LIfiBbhPRCnELEzj2SCPBtwY7PZtAPJOjEX7E/mzb8PBqGdROdnfL1Cp4MzwHP4vcx54X1RbHkCmfEy0t8LFTwBzx8Pifq1ohuHdN5/z0OAQEK+5ornZ/39vuZ3fcEfUBB7sdNBKyk6frPufg6B3SOR8wviJNmZ4koKMjpgPbqMMO9k46yLtwE4MOYIm+Y7o+Dc+X8EhthqL40OhUIGzbMnCPDhkoDXuPnzIuPCzgUVxNDQkCmcUJANDw9bOxDSWS7fWlxcNAJub2/PFjmVStmdAT6ioC23H8lkUoODg9bPiSp+FpiNC9xEFgNuTuEaEmouwSGdHRgYUHd3t9bW1rS5uWl3YzebTTPeHIhOYbFsNqtarWZZAQVsZGLd3d0t0kLqIEqlkp4+fWpFiqTIjcZZQeH29rYKhYI5E3qMeWPOf0cikZbL2EKhkC5dumTFW2Dq4LZDQ0PKZDI6ODjQ8vKydnd3VSgUVKlUjMhuNs+vfd3f39f//t//2zgZX6fwupwBhpvDQoTHc0vn0BRwTCAQ0ODgoJG+BER0qd3a2tJf/dVfmTOMxWLW46q3t1elUqmlLxg3S3IIgWxYP6JM6ZwXyOVyBk1y4IHeOC9Ev+wx9rV0TqZ6zqjTQeNQuAKCREl2Bvf29nRwcKBoNGpXbfs1QB3lRQm+1Qhn0LfXJ9gh64D4x6jSpsUXCGMP6Kd1eHiofD5vfMLJyYlVsGOQG43z++0x3kDA1I+8Tq3akydPTMiQTqetZICAmU4ko6OjajabyuVyNq/snZGRETUaDcueuWIgGo0aFzU+Pm5XsZNNM49wLr5p7eLioq0nLYKAXZHfRyIR45PhlgcHBzU+Pi5Junbtmur1ugkPKpWK5ufnFQqFdOfOHSP6+byLjFdmWMHq0LRL5xgoBhvvCKmJxh/Mc2try5QHwFAcJk/+gZf66Np3bOVnvMyTzKVer2t8fNxae/BZ8DNkR729vRodHW15B+ncc/O5PjvqZJDZET1Ra8EhI2rjGWgRUa1WDa8lKiTF5/CixoGHAELx8m/WBGUJc8Z7M0iba7Vai/EBN6a+CYgCgy+dY+J8l88w20ngTgYOiiIyFIP8PZGkr7+AvPdzASQEhu0JTeoukItzqD0RTnbEISMbgkAGsoWj8eQ9n+MzF1+g6OW4fm/7IKrT4QUF3GnkB8/in9FnnTg59jBz0J7B+CzIZy9+nXAmvq5COkctfOZCYAhchgNjnQgwms2mXbIGKiHJAgC/Zp0MnAdzxOf6ujXex3NvBHbwTAh2UBhy7ul8TIaA7YRXYk59V2MC4EKhYF0mWB/sHXNFfRxd0H0RO3uLIBFol30AupNIJL5958KBOjg40Pr6upFWPBhwDRNGtMLf+QKfvr4+41a6u7stovPKGaCw/v5+TU5OampqSplMxtrLcBAwekSeFEpCpmJ8abuwsLCg1dVVjY6Oanp6WpKMpCLbobK62WxqcnJS2WzWFqJT4+gvCyOS9sIF6YzXunbtWou4QDovFiRC5rZO1sMbHQwUB6mvr0/vvvuustmsxsfHTYVCz6fFxUVTWyE75UrVfD6vtbU1LS0tmbyUK6L7+vrsygCuoeZ+DUl/ECH6Vh2djHZn0Ww2rSUFB9VXYuNQ2JtccRsKhYw4Ze9WKhULlu7cuaOZmRm9ePFCX3zxhQkd4CFoXskV2T6TxdAip8e4elIaaA2hih8+cm8frwsrSjJ5vYdIcBZeaowDKBQKCgaD1s8NpVcwGGwhgMmogHSPjo5UKBQsug4Ggxao0MGcNSTLZE6oFUKK7KNpDDi8V7thDAQCdpU6kJBXr/mSh07GpUuXLMMsFArWMy0UCuny5csaGxszRWEwGDRui7MG5xEOh+0uIYpsPeXgVbn83m9/+1utrq5aESoZUTgc1vXr13Xjxg0LWOmWcXh4qIWFBS0uLprilCab6XTa+FXmTjoXbezs7NjzPnnyRPl8XsvLy5qbm/v2YTGihlKppPX1dQWDQV2+fNlwU0mGG/qCSxwIqb8kw8DZJBg2n7GQ6iYSCY2NjRmBCJ6NkoxLlxqNhm3goaEh4w/AJyF6l5eXtba2poGBAY2Ojurw8FBffvml9vf3NTs7a5dc+cieRfOtxF91UKcBAc2honXI8fGxxsfHdfnyZSNYcbi7u7smYfYCBzqnAj3BMRC10azv/v37un79ujkXOiBUKhV9+eWXVn1fqVSUzWY1OjqqVCplsM7m5qZBQ4eHhyqVSspms7px40aLdHpiYkIjIyOWVXnp5cjIiKanpzuGFXH+BBDtslXprDIbRRjwK06cfmvhcFiXLl2yPcKVwxjvO3fu6NatW6bmQ9iArBuV3sbGhslS4/G4PU8gEDCj57NIjJqvuEf9x37zzsUrivy/v07mB96P4IXnQlrdzu/RzoYbCIG/A4GAoQ+cDcQ3ZHzFYtEKB7u7u62oFRIZh+SRClSeGF+cXalUUqlUsvX21ezwY8xRKpVSf3+/tVXhs3mO1znDU1NT9u9k8U+ePFEsFtPt27d15cqVlu4Hly9ftowK3oPAbGJiQsPDw/ZeZOEE5v7Sr2KxqAcPHlgdn29V1NvbqytXrui73/2uoTKcN5CO7e1tu0gwmUxqZGREmUxG6+vrWl5ebuEEOZ+FQsGCzmAwaEICguSLjAs7FxYqHo/r6tWrSiaTLWStJLurgYjEE8bSeasLNqBXEJE6YyhpIpjNZk0Gy0EgHcSweOKTv6eQCIkzB5nIi9vyUOvQQoU7GCBwh4aGLOLj2TsZHETa4fgWFqHQWUM6ikFJsxuNhq5fv66JiQlL/durddsVRH5OEUN4Uo+og468zFN3d7cGBgbsmmMisIWFBev8KrVCK9KZs+SzmD+iRjZhMBhsabzZyfA1TUdHRwoGz5piAr0S0bI+tMLh/g7eoa+vT9lsVkNDQ5JaW2zg1MnmvDOAbPc94XwwhNPzmYvPAhgceAIHlHvU5MDN8NlehIAh7XSwbmR1BHYe3vJFkUA1nJHe3t6WWjUfGOKEIJaZVxyt7x3mzzK2AEdENsgz+SyQPUiQCdTsRTw4aGBdDxezdzsd8XhcjUbD2vnQKDIYPOupSONSmrmy51dXV82eeOk2Dhm1IApb1pn6qv39fRMKeLjUZ36+qzHZNV1B2F+bm5sqlUrWFRvHFQwGrYkoA8612Wza1RPNZtNu5b3IuLBz+frrrxUKhfTee+/pxo0bKpVK2t7ebpH2ra6u6tmzZ+rp6dHMzIxN8vDwsNLptDKZjI6OjrS0tPQH0laMEdH56OiofvjDHyqVStmlTT09PRa1enLOt0jxhm17e9sgJfqT3bx5U+Fw2IpAy+Wy1tfX1d3dre3tbT1//tz6mkUiEf3xH/+xZmdnJb3eHeYUaiL1HBkZ0Z07d1Sr1fTb3/5Wa2trqlQq+od/+AcjVsPhsN5991394Ac/MMcNNNTuZBhsXN/bqlQqaWtry1r6e0KSquiZmRndvXtXXV1dyuVyWl5e1u9+9zt9/vnnGh0d1Xe+8x0Fg0EtLi62RJtdXWd9jGKxmFZXV+2ueyBAoLyhoSEzNJ0Mom6EIaOjo3r77bcVCASscA5o7OTkpKWNPVEuopDbt29rZmZG+XxeW1tbVhF+cnKip0+f6uuvv1Y+n2/hdYDPfANM6Tz6p1fW4eGhvvjiC2vc2n4QMaSMWCym+/fvK51O68svv9TTp0/NyKNMQvQBp9PpwHijDIIkZ60kGRKAQ+HsYLTIegiOuJCPPUbtVaPRsD51RNhA4r6iXDrLAgqFgtUiAYchcCEwwFjD+eJIgHcRIkSjUcXjcQ0PD1uWRR2Nv2jrVcf4+LhqtZrJ8MlSu7u79eTJEy0tLamvr0/T09Pq7++3DiaPHz82MRM/T4YIkR8MBk1pCbdRKpU0Pz+vQqGg3t5eDQ8P23x4xR4dvOPxuEHeS0tL2traUiQS0Y0bN7S1tWWdyoeGhpTNZrW3t6elpSXF43FNT08bH9RoNEy4EgqFdPv2bQ0NDem3v/2ttYS5yLjwSacSNBQKWbM7ohb4FqJg6dwQe+mlzziI3phkIhXgATYRi8FGYmP4aNJ/vie8yZ48mQyuCS7rv9MTzkRBUut9CJ0O+Kd2QlM6l1sCuXComNdoNGrqF0lmeDyuT9EVMBTP7bM6L+FkkNURSdfrdRWLRR0dHZmRkNSSireTr14N5klg5hECmVY/nQyflfrI2K8v+8O/N/sGB4Kx9jBEs9k0x4ehOzw8tHfjvZhv3smruIAjiUyJxD2PKJ1L9HlmztT/jQt4nWylfQ6ZE2qFmFO/75lf/45kdry73wPtZLNXcfqz6yFc1svvS6lV1OANKP8PR49iDUfPWW7Pqv1+4PM6nU8vy240GobKkJFgdHGcPCuIg2+34/cfyI5XeXopMQKW3t5em+92pSwiDK9q9agGJQOBQMCCJIJ0Pt9DuY1Gw2wKwRlBwUUDnAs7Fx6SyHFra0svXrxQvV63SIjLwriIKxwOa2lpSc+ePTOFh1eGUfTDpAKfDAwMGGQFJMDhYyJodX14eGiZRyQSabkLZWZmRvfv3zflBs6PtgfPnz9XtVo1fmN2dlYfffSRisWiVlZWFAgENDs7q0wmo42NDa2srHSsFqO3V7lcNr5jbW3NoBhwbUkWuYDzc/HX3Nyc6vW6dUd9+vSpnj59qpOTE+uJRfQjyeAN7onxFc18H0KHpaUli/bz+byq1aquXr2qf/fv/l2LKiwej2tkZEQ9PT3WZ4h+SUNDQ9aJgMPBXRDLy8v667/+awUCAf2H//AfXnn+fHFrMHh2h8qXX35phDOV5FznAGRy5coVjY6Oqq+vz/YMxWADAwO6deuWBSSHh4f6i7/4Cz179syUOr42AIIVgxeJRDQ2NqbLly9rbW1Nv/jFL3R4eKhCoWDOFAfozxERdDweVzgc1tzcnEKhkEnkPUeDIeE+mNcZfDfQFWpDb5jZFzwzRicUCrWo5/b399VonN+eWC6X7bNisZgZXYw7BpV38hwmkBmRt58zbEp7QCPJunUjSBgcHGzJ6gnGOEv1et34tU4GLVzi8biuXbumZDJpkDUG2QeyGxsbCgaDGhsb009/+tOWGpabN29qYGDA5ko6F8F0d3fbuUSRls1mrRErtWgUQ46Pj2t0dNTmt6+vT9///vd1dHSkjz/+WL/+9a8NJg4Gg/rqq6/M9uAIaY2ztLSkjY0N46sRSLH/vaL2/zVeGaMAW6W9SrPZ1ODgoMnogK/A13d3d43HoL0G90BXKpU/gHpYAN+zjKjHGxfUJrXaWQ8sUrjT01OD665cuaKpqamWGwhRnlAsRpTAc929e1fFYlGJREKNRqOFWMzn8x1LGYlk24k6okAvnQyFQi31KFTP4jRpT7K1taWtra0WuIGDLp1nDRhduidgsPz1zXt7e9re3tbJyYm2t7dVq9V09+5dvffee9rf3zdHTPvvUChkKTKcB2IA74wODg6sAhuFVSfj6OhI0nn0SLty/3n+agaM2eTkpGZnZ1uu70XtNTAwYNCJpJb7THyXY/YVykMfeSeTSQ0PD2t5eVlPnz61AMFLiH3kzGCfS2pZV7IFb0yJ7F+nRsM/E5kq6+ejYepVmGPe3XNFCGq8LBbHgnqsXebslVpeQUfwCO/Fnm+X8HLWPc9VqVS0urqqaDRqN44SiAItSrJqfu716dS5+FY/2WxW2WxWly9fVigUsrPkIVNETNwqSQBMU0su6eN6C+bYO2rmB56sUqmYY04mkyaQ8F3VEa00m0198sknWl5eNtQmEAgol8sZTE4HDoKNzc1Nzc/P2xz5FlHUKl0UfXilCn1wQQzhyMiIgsGgXYBDFkBBJYcKb8fm8huFA8PflUolxWIxI215ETY+GxnCKhgMamJiogUeQYmCs8KwhMNh7e3ttUQIvFtXV5dOT08tm/rmm290enqqbDarWCxmrVU6dS4cJElWVHX9+nXV63UtLi5aLy/kncB2z58/VygU0tramh4+fChJJqiAwANO49ASHRHNDQ0NmYQbmMdzJjgdesaxsbinZH9/XysrK6YUw9ggliDaRqHDAFpETdVeHPsqo11pCCbvYTkCGAjcYDCotbU1g1CAJoHGyOI8VPr+++8rGo0ql8vp0aNHL62IjkajGh8fV09PjwqFgj7//HMtLS2ZgWaPM49k5jyn7w7gzwKG3ncJYK34udcZ6XRazWbTMudAIGDFwswFQaKvwaCvnZcf857AMu3dCiDffQ0HToRzRx0FzoHu6R7uqVardnMskBn7LhKJ2PXfOBAcv1fWMYc0VO3UubQX8h4dHRk3RwEkjWhBSRqNhsFJlDgwx+37kjnzijvehdZQcJzRaFQjIyPW0489xbvSHZwsp7+/X7Ozsy28HcF6rVbT2tqagsGgEfY4Lzo/r66uWrH2RefvlZyLdFYTsrq6quHhYd29e7elAIoOxkRgXhUiqUU5w2FhQphgdOO+Kp5JQKqYz+f15Zdf6vDwUD09Pbpx44bBXeDr0rkh6urq0sDAgI6OjpTL5exgAJ2w0NRsLCws6JNPPtHx8bFGR0eN+6E4rpPhscqTkxMNDAzon/2zf6Zarab//t//u2n4uf2QwqUvv/xSa2tr2tjY0JMnT6xpp3QW1cZiMVUqFcsOIWCHh4d15coVDQwMaHJyUkNDQ1ZtTqTKupIW054HB7q9va3Hjx/r4OBAL168aKnbwOhiHLq6uiwrZGAQ0um0ycE7hRWlc1UWzVGpFvaZHxJ1ssKenh6ru1hZWVFPT4/ef/99jY6OWsaFVDYUCulnP/uZPvzwQ3322WdqNpt2bS2QrnTWMeKtt95SJBLRp59+qpWVlZYmqzyrdypeCUU2gCNkwAmwh6knIQP1tWCdjMHBQTM8+/v7VjFOVE+1PVcEQH773mIEMR7XR5GIgcPIcn7JWoAXcS7U0WQyGQ0PD1tG5fcUqqxwOGwZMx28e3t7rb7DoxwYZK9mbTabxuN2OgiS2U80aA2Hw7anksmkpqamrCkvgSTyaxwBfcSks6wcJSMZHKIe+F4Cu97eXvu8qakp6xHma9uwlQRFdGH/yU9+omQyaZxaLpfTwsKCjo6O9Pz5c1t/SkjGx8cVDoftXbmy+1tXi1WrVdtIvjOtdxDUmJDmedkiHpLJ4rN8Dx4vraNuoKury/6flz36S6r8z3sJLJG0J8f8VbXeufjM6+TkxK4oxSmwYJ06F/BnxvHxsbVxYW67u7tt8/uIhe6nGBaiSCA1T4B6EprN4vuOocQBK/dSVLIQDAHPyEb1kTO/w7vhnIGFcKS+5xbGtZPhZbjtAhEG2YyXqNMN1veFox4A6W8gEDAIiIgUo+6hGIIVWh+xb72woV1E4f94abOXk+I0fKbDWfFYPjUTnQ6cn983PKvPqhjsMdYdx8g/A4GAnUmgbZ6Tz29vyMl38U9IY3gLL8zhO4HZ+Fz/++2f64UCDO98Xje48TaQTMSjEkDB1LRUq1Ulk0n7DE/W4wC9MIl38GQ/3TqYW+gHKvKZd2ynr++LxWIaHx836TE/5znuSqVi6kY6VJC1kF1BHZB9XmRc2LngRaenpzU8PGytpCVZW5fBwUH963/9r80oeQIM79fV1WURSCKR0OjoqFWEMjnIg7/88kuTj0aj0RajgENBgkjaCKEVCoU0Nzen9fV19fb2tlSkbm5uqr+/X9lsVj09PXZF7sLCglZWVhSPx/XDH/5QgUDAusUi2+v0cMMhcSiXlpa0tLQk6dxxU6SGKIHCRpwEV8BStUuUCEYunWP0iBQKhYImJiZULpc1OjqqkZERnZycaHFx0Tqr4jwg7LiMjCJKIk/pvI0NhoCCt56eHr148UK5XM4OB/8kQHidmyiBb+CEfPaFgYHLCgaDBpOwVyKRiEXp29vbyufz6u/vtzomINa1tTXt7u7q2bNn1v8JmHJ2dlbXrl1TpVKxLt5cGsWzeTiYdWt3LgRnOGQOtnTeggV+ij9wXa8zuCe9VquZnJeMCocNdFQulzU/P6+joyO79pp7U6TzYMnD0+Pj4xYgInhgHbxoB0OF8QIq4uzjdLu7u5VMJu3aYvagr9cC/gRyb781FN6GbNFn1q86cIa0oM9kMhobG1MwGLS12djYsI4V1KpBvhNA0icwEAiY+ImeadhF+txdunSppdsxHQ5GR0f17rvvmi0lGISMJ5C4ceOGbt68qZ2dHX399ddG7AcCAV2/fl0//vGPVSwWdXJyonw+r6mpKXundpvSXuD7/xoXdi7AVihdgsHzFhakzTgLamA89OIlc/yT4ipJLVJMitWKxaLC4bBtJt8kj4iStjJE6GxWSRaZorpqNpsWmdKlWJIdeCrXo9GoNXP00R6QUieDg+HTXAQRZElsQjI6jBLP4A0SnJTPBjyuX6vV7LKgYrFocBJRE1cNEIF76TaYMI3vPCTBO/iInPXFwHoJKM/kVYKdDKJ2SPWXyUoxnL42hYNGFI3DqdfrLa00OKD5fN7us4GDYlBrwT7iIrD2bITP8vUAnqj33AO/4wdrxM/zMz5C7mQgimDN2teRv+e52CMYRiBU6dy5ENliKCW1yGf5eS/7l86zIF9MyRoCI5KF+MuuPCLiMz1GOzTm/x8owetkf5L+wJH5NYe7wpYw75wxzzHjQL3UnbkiW/VdkzmXvb29isViSqVSSiQShipAynt4NpPJKJVKmfOC5wJGy2QyLehNPB63u7s8mkSwgHT/IuOVOJdA4KzimfYGEPdcgSudF0NSQYvyZmRkRDMzM1aFvr6+3lL7cOnSJdsUoVDIqmF9dlIsFlu+KxKJaHh42AyfrxVhc/OZu7u7tsBwDIuLi1a5GomcXYt67949azUOaV2pVBQKhZTNZjvemBMTE2o0GtY2wvdR4p25cyGZTOr+/fvq7e21C7koojw+PrZ7JeCBIMtrtZrGxsZMmUK6/Pz5cy0uLurhw4eW7kLy0wWXzYUDA9MGIyba5mZRFFfVatVEB8lkUt/5znfMkNfrdasK9rU7nQxajHiD6CN7BjzL9PS0ent77RZA9oT/+ZWVFX322WctNVO7u7vWLJD3wJjl83k9fPhQgUBA4+PjajQayufz1uMM+GJoaEi9vb3a2NiwSBGHR0ExcnhfYySdE+Lc5Ans1mg0LKrvdGC8MP6SzHBLsvNNNgInRSE0vbSAVQh4uEyMYIdnpzyBwIzzRGDEPsMYdnd3W9dgPye8P8/N7agIVvye4FxVKhWT1jMwwJ2Ozc1N44MikYjdbxMMnsmNeddms9nSrWB7e1vSmaGfnJxsqUcjEAQ+Pjk50Zdffml7hwAmlUpZiQaXMiIK2drasltjV1ZW1NXVpWw2axcQUq4wNjZmXS3YD59++qnBwF1dXZqfn9fc3JxxO/CRwICDg4MXnq9XrnPBuJOqSrL7WKjgRaoH10IrgevXr5t8kAlvNpvW6qWnp8cyE1ppHB8fa21tTXt7e1b8w6BlSbN5JrdNp9N2UdT+/r5NCLCW54YODg4sbV1YWFA4HNZPfvIT3bhxw+A5uB2cSyqVuvDEto/h4WGraSFj4UBJ51ekbm9v69KlS7pz546Ghob04MEDkwZyGx1GaXBw0LIFovlUKmUKGm6Z+/rrr1suU7t+/br+/b//94rFYpqfn2+pDeDAe2ko4gecfjKZNCgU6C0YDOo73/mO3nrrLYt+yTgxkL5G4VWHj5BfNrxCKxI5u0ucKmd4IwwBOPn6+roZd9Q1HqvmpkScS7FYVLlcViaT0Z07d1oqrXEu7JNUKmUHH0MaiURMrr2ysmLt+NsLK2nY2k60E1R1OjC07BcyO89RgAR4no46C96fz4LYJ2PBcXPFBSpNRAS0JcHhwsu0V6vX63UTuEjnSlEkugQMU1NTGhwctLXHKcGtHhwc2BkmE3ydwT4nm6Leh8CWILerq8u6fPDOOJrBwUELlHjmk5MTc8SNRkO///3v9fvf/96CumQyqe9+97saHh62myrJeJAPb25uand3V+vr6+rp6bFuBtvb23r27JmSyaRmZmZMGYrk+dGjR2aju7q6tLi4qJWVFaXTaV26dMk6AyBqSqVSF57HCzuXW7duWWRQr9ctS2BBq9WqEZ6ovSQZjksUhgEcHh62lCuRSNhBpgMrrUoo8kH77pvuSecpJNf9VqtV7ezsWL8sogSyBArq8PKQ4xiHQqHQovdHZSK1pt+vOtg4GDZfTYxksaenR1euXFE6ndbGxoZxSGNjY5LOIydSVuSdvj4gEAhoc3PTMhcMH+07mMMXL16ot7dXW1tb1qAQOS6OhI3P2mFMvaLMZxCsh+9lBgT1OnMnySI4L4X0pDhRNKQv2crx8bE5CIwV8AwOhyCGQ4aTQXEG7ODbwHAjo293Qs84VGucE0/i4uCYc54FWIX3oagNrBsy+nUgHaBF/ukxdHgLgjoapUoyDoM/Ht4hw4Vs9hALgZMfQOHAhr6A0zf3RJbcaDTsRlWeOZlMWqbsq+CZI+bVfz8BT3v9zasMeDAiel/iMDg4qNHRURWLRe3s7NitmMwn90zNz88rHA4bD8RcRiIRbW9vq9lsqlwuW4Negp75+Xnl83lls1mzlel0WtJ5xw5gddaXrHNsbMzKEwKBgGVVyN5xjM3m2ZUFvv8b30PrLgRSFxkXdi5/9md/pkajodXVVbtSdGdnxyIKLu/JZDI6OTm7drRarRo5FQqFTN01MzOjoaEhi8YSiYTdE7+xsaG9vT2NjIzo2rVrlirSvmB9fV1Sq5qKw0zKDn7LP9lY8Xhc7733nm7fvq0nT57o008/VblctkuIKpWKdf3EseAQeNZOjSR9idbW1mzjEBnu7OxIkt577z19+OGH1qn59PRU9+/f19tvv20OsVKpWJ2HjyZu3rypUCikjz/+WF999ZVFykiBBwYGtLOzo1KppM3NTf3qV79SKBTSixcvlM/n1dvba5X/yCRrtZp1nObwt7dmZ36904MQx2CDKb9O5OiveCaD8YQjQQqR8uPHj9VsNq2zNkVgPCNBkm8U6fnAw8NDy67bO0XUameXvoVCIW1sbBi23t/fb1ErmR1zRbawvLysXC5nGTFZIVkLfAO96KjJ8ZLkTgfCAzIpoEvpXI0Hae9Jcnq18QeOCugLgrtdEuu5QJ4bx4LdwLjiDMhmyIbW1tZMlMNV5XTXRpaPMwoGg3brbb1et/ufWGvfNbuTwZqPjY1ZIEaR5927dzU5Oanf//73+uKLL9RoNKywmSut8/m8dTYmyC0Wi9rb25N0zhcBgW1ubmpjY0P1el0LCwsKBs86Tly+fLklEyFjBsL2nOvw8LCmp6eN06EbRz6ft+JqLoaDn93Y2LDsMx6Pa3Z2VuPj4/ryyy/16aefXrje6pVa7lNcE4/H7UD71JUsBriHzUpGw2YmuuPngGM8qcfmCQQC5rxIbVkE6fxQcAgkWW0LxsyTqESGQA+hUMhaixCp8278LkQ2v9vJ8IQmcKF0Tt568pG/wwiSfQBFdnV1WXEUxoKMiGjIw24ejsJ4kcm9LDIm9Zf0BwKGWq1mKTS4L3ANGQDQks9YMFadDj9f7cP/HUo2HBt7i//nsywyIS9pxRCSxXhS3WfpKOsIbrwEloicdfBkNP+P4MXzHTyrj+b/qXfuZPigiz+eTPfPQwbihTv88eIEL0/23+N5EL9O7AOEEP79WAMvYW6X2XvnyPdyRjlX/tpq/26SWuzCqw72jrd7XLpFxsxz+SAUrhc+iADFfy5kvCSrEZLOuynwrr5EA3vni5+Zd8QbXmzCvvZnG66FPQyHxmWJBAleUHNR3urCzuUf//EfFQwGlc1mDaahHTsbBUlbf3+/3nrrLfOkRCLpdFqVSkUrKytW9AcmmkgkLHPZ3t5WNBq1BXn48KF2dnaUTqc1OztrijDUK6FQSKurq3ry5IkCgYBSqZQRZBDzPOdXX32lhw8fanR0VO+8847JmAuFgkFoPtIG6iCa6DTq+eabb4zQZ+G8np/5LJfLSiQSunz5snp7e7W6uqpHjx5pYGBA77//vqSz4kZ6qtEjqFgs2kYfHR01sYQk7e7umiOhToPLryiqolcceK3XuBPNhkIhg4GuXr2qn//85zo8PNSDBw+s2eXjx48VCp11tQbSQLHnyeNXHZDGnoxuh8dOTk4saiVLQboeCoUs2uQiKgrDIpGI9bQi65BkzpkO0gcHB3Y1AgEQ0JsfPqPCMPDuBC8USvqsib56KI1wUN5Rvs7w3ArPz3PB7SBgofAOtRf8JQEMZ8wrKcnguEaatfZRMxCuJBPIYEDJmH1R6/DwcIu4BjFAMHh2VTq/AzSH6IJ7oBApYIAJ1K5fv/7K80fBJt2zh4aGdOvWLcViMR0cHFi3h/fee0/FYlGPHj0yhZbvG9jX16crV660tB7a2NjQr371K6uR8XYoHA7rrbfeMiEIkvLZ2VnV63U9evRIKysrGhwc1NTUlE5PT/X8+XNVKhVNTU1pfHxcsVhMQ0NDljVFo1Gtrq7q008/VVdXl+bm5qy56/e//30rvSgUCrpy5YrdH+Ub6P6/xoV369LSkkKhkFWHevWVdN6ygI05MjKibDZrEZhvp+0VXRCKEF4cYHiI09NTbW5uan19vcUoQmpxjXEweHZzXiAQsN5lRBKk9cfHx4ZdxmIxS025UhQD3E6wgu/SZqaTsbW1ZZEyUUh7ZMfdDWNjY3rnnXfU39+vhYUFPX78WHfv3rWK2e7ubpVKJVP1RKPRFnUTGQ7ZA/AbWK8vxIKwRx0E5ERQAM7NYYfLiMViunfvnm126awWand312qIkLNCWL4OJEHk9DLFjzdiQJccTrIH6glokNjb22tNKAOBgBkp36KGCB2DgHrKHy6cnc88fWZENEkkjsMgKgemk2T4Nso/+DE+v7048FWHfy7e2/OJ1WrV+sBFo1GDx6TzNi6+HIFu3fAwXFSFY/HIAZ9P30ACQ4w1580XX8Ih8Fxe8SfJoDDOOZE91wiMjIzYOaCuhKi9k4GAZn9/X/l8XolEQvF4XLFYzDL2cDissbEx+16UhwQZQGnpdNpUhQRyOFEP/8Iljo6OanR0VHNzc1pbW7Peh43G2dUi8/PzajQaGh4etsCTMgIgRrJGOo1wcaIkK8F4++23NTExIeksIKbzCUEU33mRcWHnAga8srJi6dHMzIxFd8HgWadaMoBf//rXCofDmpiYsO6fkozoBOahChWlxeDgoEWZu7u7Fu0kk0kVi0V99dVX1t6EKLuvr88OIXh4IBCwewt8tAo0U6lUDC/P5/MqFAoaGhpSJBLRwcGBcrmcAoGArly5ong8/tJGia8yfPEWTnpgYEC1Ws3UJECIkUhET58+tVqXmZkZZTIZkxxvbW0ZtowQAaNPlES31NPT05ZritnoOBhS4EQioffff1+NRqOlzQcXCyEVj0aj9h2/+c1vdHR0pO3tbYMuIS83NjZsHfv6+qydxesS+y8zEETPGHIPy7BeBBmNxlltlM8IKFrs6uoyB8KhlmRZGfwM8ALfzXMB9/jn4v9jXOAluDclGAwaPFutVpXL5cyY+gzM15h0OoBOvJiETgBwMPAetVpNuVzOsi6yFGTGiGx8TVY73IuT8GQ6AQ5zIrVe58C/A6/D9bFXfZ0Ia8p8NRpntRjXrl2zeg0gJ2D515lD37OQzG1+ft7eDSdKEDk8PKxMJmOdpsvlsra2tlSr1fTkyRNtbW1ZRr+3t2dNckdGRqxdFdk2+7Orq8uuKfYOm9Y+y8vL6urq0o0bN8yZwINWKhXjTeFqh4eHFQqdXdPMnUfSWYY1NTVlPPHOzo4ikYg++OCDC8/XhZ0LhjUQCGh/f1/ZbFbXr183IjgSiWh5eVkLCwva2NjQL37xC1UqFf3kJz8xiEyS6d3B7GmTnUqlLErC0VCVSkSXy+WsVuPq1atWzY7jYZOhEb93757BHX19fRZZAJcsLy/r4OBAm5ubKhQKVmmez+e1uLioQCCgyclJRSIR8+CdRo6o3NDIp9NpI9oePXqkfD6vZDKp/v5+HR8f68GDB6rVanrnnXd069Ytu/Tr9PRUq6uryufzdstitVrV5uamEXJHR0caHR3V/fv37bmPjo6sPxHdYakTorMvMOHf/d3fWReD8fFxZTIZXbt2zZz0/v6+9vb29Dd/8zctODy8GL2renp6dPv2bQ0ODmp1dVVra2sdOxePy3vcHGMJIQxu7zF7eAMkvRg9MoRms2lSbQ+dUBjKXeLSec8wsg/e3VeQt4sDpPMmnplMRolEQhsbGxZZ0vRwZ2fHskAG74lxfR1RBBi9r1Px3Jx0jtFTsU00zBmnQp+zCkzm1WfMAcEIykZUUYgccNagDzgXv5e8WpOu1jy3dy5c+5BKpXTv3j2DyngOf1VCpwOEhMvT9vb29PDhQzUaDQuUKa5NpVJ65513FI/HzbksLCxoYWHBuBcCaxRetLYfGRlRKpUyVEKS1bghEfb363AxWqlU0tzcnDKZjP7lv/yXGhsb0/z8vF68eKFCoaD19XWFQiF99NFHFnhPTEyor69P7733ntLptF0H39fXp6tXr6pSqejBgwfa2NjQH/3RH+mf//N/fmHu9MLOhSjQQw6ewPKEOek/sk5Pxnnj7IlU/6edxONnibT84fBRK8OnlPyuT9P5bP9z7ZBGO4Hcrih61dH+3tJ5M1DmwP9dO+Toicl2YtV/h58v1qUdpvF8jy/mYi3bIR4ipna5LBBRO2nqv4Pn93//uuMiBrZ9T/HMnrT38wYs87L19Qo1//0X3Qvta9+eeflMi6zev6P/3tdxLjyLX4N2UYGHLf1Z9+/gz2f7M/rP9c/8snd42c+0r88/9TP8nd/TXjDDe/DzXiz0uqNd2edtSHu3i3Y40Quf/B9sJ8/u/90HAf77/dx7ns8HO0Cp2E7m1M9Lu0DCfybfjx33QdT/awSa35YU5c14M96MN+PNeDP+z+i8UdGb8Wa8GW/Gm/Fm/BPjjXN5M96MN+PNeDO+9fHGubwZb8ab8Wa8Gd/6eONc3ow34814M96Mb328cS5vxpvxZrwZb8a3Pt44lzfjzXgz3ow341sfb5zLm/FmvBlvxpvxrY83zuXNeDPejDfjzfjWxxvn8ma8GW/Gm/FmfOvj/wNOnShqH94s1QAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -545,19 +545,19 @@ "name": "stderr", "output_type": "stream", "text": [ - " 75%|███████▌ | 150/200 [11:57<03:58, 4.78s/it]" + " 75%|███████▌ | 150/200 [12:03<03:53, 4.68s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 150, iteration: 468, Discriminator Loss:array(1.02523, dtype=float32), Generator Loss: array(0.686512, dtype=float32)\n" + "Epoch: 150, iteration: 468, Discriminator Loss:array(1.0305, dtype=float32), Generator Loss: array(0.684713, dtype=float32)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9Z5Ok53Uejl+dc87Tk8POJuwCC4AgSEIMMiXZClXWC1WpymW/8Gv7vausT+Ev4FSWq1S2LEu2fpRAkQRJECDSYnOYPNM9nXOO/xfj68zpxoKc7VmSgP5zqqZmd2a6+3nu575PuM51zjGMx+MxLuRCLuRCLuRCXqAYf9MXcCEXciEXciH/+OTCuFzIhVzIhVzIC5cL43IhF3IhF3IhL1wujMuFXMiFXMiFvHC5MC4XciEXciEX8sLlwrhcyIVcyIVcyAuXC+NyIRdyIRdyIS9cLozLhVzIhVzIhbxwuTAuF3IhF3IhF/LCxXzWP/wP/+E/wGQy4fr161hdXZ343Wg0wng8xuHhIQ4ODgAANpsNFosFq6urSCaT6HQ6qNVq6PV6KBQKaLfbKBQKyOVycLvdWF5ehsViQSqVQqlUwtzcHDY3NzEajXB0dIRGo4Fer4d+v49IJIJXX30VdrsdmUwGtVoNBoMBRuOJrRyPx/J/k8mEarWK3d1dGAwG3Lp1CwsLC9je3sbdu3dhsViwtLQEu92Ora0t7O/vw+/3Y3l5GVarFWxgwPcCgG9+85vPvdB2ux0AMBgMMBwOYTAYYDAYZP0AwGQywWQywe/349q1a7Db7Xjw4AH29/cnPp/XZLPZYLPZMBwO0Wq1MBqNYLVaYTab0e/30e12YTAYYLfbYTKZ0O120ev15JoMBgNsNhvMZjMGgwF6vR5MJhN8Ph8sFgtarRba7TYMBoN8drfbxXA4hM1mg8PhwGg0Qrvdxmg0gtPphN1ux2AwkJ9xb0x/Pa/8xV/8BbrdLv7n//yf+MEPfgCPx4NYLAaXy4WFhQX4fD643W54vV5kMhl873vfQ6VSwdWrV7G4uIhUKoU7d+7AZrPhG9/4BhKJBA4ODrC9vY1+v49Go4HhcIjhcIjxeIxgMIiFhQWMRiPkcjl0Oh2srq5idXUVHo8HCwsLMBqN2N/fR6FQQK/XQ6fTgdFohMPhgNFoxKNHj7C1tQWbzQa/3w+73Y5EIgGv14uDgwM8efIEoVAIf/iHf4hoNIrvf//7eP/999Hr9dBqtWC1WnH58mVEo1HUajWUy2WMRiM8fPjwudcPAP7tv/23shdtNhv29vbwk5/8BIPBAPF4HG63G7lcDplMRs6QyWTC0tKS/D4cDsPhcGBhYQEulws/+MEP8Pbbb8NoNMLr9cJoNKJSqaDVasmeMhqNcLvdsFqtSCQSiMfjSCaTeOutt2A0GvFf/st/wbvvvotXX30Vv/d7v4d6vY6//uu/xuHhIbrdLrrdLkwmk+xtl8sl+sVqtSISieA73/kOgsEgvve97+EnP/kJhsMhBoMBAMjrPB4P/H4/AOCDDz547vXT+uX/3+Usa3Bm4xKPx2EwGNBut7G3t4fBYIBOpwOz2YzFxUX4fD54vV4EAgEAJ4rSYDAglUrh6OgITqcTgUAAg8EAtVoN9XodFosFi4uLMBgMaDabMBgMCAaDiMfj8Hg8cLlc6HQ6aDabKJfLCIfDmJ+fBwA8ePAABoMBHo8HTqcT9XodpVIJJpMJkUgEdrtdNpXJZJKNZrPZJpToeDxGpVIRRbuysgK73Q6n0wmj0SjKkMp61o3Fz6chcTqdiEQiGI/HKBQKaLVaGI/HGA6HaDQa2NragslkQr1eFyM3Go3kwPPaer3ehALv9/sTSpJ/TwNCo8aDMv234/EYzWYTRqMRg8FArpefwf/TgBiNRrhcLphMJozHYwwGAzGg+rqA8x3KH//4xxiNRrBYLHjttddQr9eRyWSQz+dRr9fhdDphNpthsVjQ7/fF0PX7faTTaXS7XSQSCVgsFozHY7RaLbRaLfT7fVkzg8GAzc1NxGIxWad2uy3G5+DgANVqFVarFffv34fZbEY0GoXP50OlUkGxWAQA9Pt9GI1GWCwW2YuBQAAOhwPz8/MIBAJoNBoYj8dot9vY3t5GoVBAvV6Xtez3+zCbzfK1vr6OaDQqDsks0mg05N8GgwG9Xg+DwQDdbheFQgG1Wk2cidFoJM5Jp9NBt9uF0+mEzWYDADx+/Bj9fh/ZbBZOpxODwQClUglmsxm3bt3C6uoqnjx5gnfffRfdbhetVgudTgdWqxUGgwHVahXpdBrD4RA7OzswGo04ODjA//2//xeDwUD2vdFonPhus9lw5coVxGIxpNNpbG9vo9fr4e2334bdbsf+/j4GgwGMRiOcTicAiKGx2WyIRCKy959XLozK88mZjUs4HBbFU61WJRJxOByIx+Ow2WxwOp3weDzymtFohP39fWSzWfF8RqMRms0marUaIpEIYrEYOp0OcrkcxuMxotEoYrGYKAoqsXq9jmQyiWQyiVKphLt376Lf7+Pq1avw+/2oVCooFAqw2WyIRqPinVmtVlgsFlGcfE+TyQSXy4Ver4darYbhcIhgMCibz2w2yz2MRiPxTGfdYMPhcOL/drsdsVgM4/EYjUYD7XZblDcVn8FgkOunEQBOI5zhcIh+vz+hwLXHBmDCuBiNRlGajERoCIxGoxw63if/9lnRBq/HarXC4XDAarWi3W6j0+lMGKwXdSA/+eQTGI1GJJNJXL16FTs7O3j48KHsQ4vFgtFohOFwCJfLhcXFRdhsNrRaLRQKBVitVoRCIVgsFgAQZdfv98VA09m5du0a6vU68vm8rFG73Ua73UYmkxEFb7fb8dZbbyEej6Ner6PT6cg1GAwGmM1mBINB2O12BINBOBwOxGIxhEIhHB4eylofHR2hVCqh2WzCbrdjPB6LU8TvCwsLeP3112dWjADEcFgsFoluB4MB+v0+qtXqRDQ9Ho/R7XYBAL1eD71eD+PxGFarFcPhEAcHBygWi+h0OrDb7Wi1WvIcNjc38d3vfhdOpxMffvghut2u7Cmr1QqTyYROp4N8Po/BYACn0wmr1YpsNou9vT2YzWb4/X5xDsfjsRhrp9OJtbU1rK+vYzgc4v79+6hUKkilUuJ8cX8TLaATYbFY4Pf7Ze9fyK9WzmxcbDabeKJms1kUN5XfaDQShU3FNBqN4HK54Ha7Bb7hwSNMU6lUZJOPx2PUajUAJwfX5XKh3W7DbrfD7/fD4XDIpgmHwxgOh3A6nTCZTHA4HAgGg7DZbBL1DIdDdDodNBoNHB8fYzQaIRqNipFzuVziSVFRaoXIgwicwkGzKksqdm3wKpWKGAgqcS00Ns+KROiB00tzOBwATpQVFQGFa6uvn8+B/zeZTLDZbBiPx2IgtLLhd94Hr4se7nA4FE+Yh1zfx3k8bgByf5VKBY1GA6VSSeA+i8UiBtdiscDtdiORSMDtdst6MAKmg9Tr9eB2u7GysoJms4lcLofRaIROp4NSqST7we12Y2FhAV6vVwzMaDRCv9+HyWQSCKlcLosxYhTlcDjg9Xolqut0Otjf38fx8TG63S6uXLki60+HgJEK74cGJpfL4YMPPoDRaMQf/MEfzLSG9XodwImRMZvNKJVKE/tBPyeTyYRwOCxOCaMeno96vS77kvuA+2l/fx8ffPABDg8PYbPZxEmiUu/3+wAAj8cjOmU4HMJkMsHtdosRIMrAyJKQ7tHRkThR165dQ7PZxN7eHhqNhjiDhMG4htyb6XT6XAb6Qs4uhrN2Rb579y4ATMAdfIihUAgOh0MwVuBECY1GIxweHiKfz8PhcIhSz2QyaDab4jUCpzAav3s8HoRCIQnfx+MxIpEIIpGI5BjG4zGcTicsFouE3larFXNzc7Db7cjn8ygWi8jlcvj0008xGAywubkpkQ09m36/L0pS47tGoxF2ux1msxn5fF7C+H/xL/7Fcy+03W6HwWBAOByG3+9Ho9FANpsVxc/1fNbj0N6kyWRCIBCAzWZDs9lEo9EQj9hsNiObzaJarU68noeaBuFZ4nK54Pf7MRwOUS6X0ev1BD6jkdFKotvtiidsNpvF4EwbEq20eKh1ZHVW+ZM/+RMMBgNsb2/j6OhIFL/RaJyIPCwWCxKJBL797W8jEAiIstnb28P777+Pfr8Pm80Go9EoHnCxWMQHH3yAZrOJWCwmEG84HBaFyb18eHiIfr+Per2OwWCARqOBbrcre9lsNsvzWVtbw+LiosBq3W4XOzs7KBaLePXVV/Gd73wHrVYL7733HorFolxrq9VCsViE2WzG1atXEQ6HkUqlsLOzg+FwiHQ6/dzrBwCvvfaaQIKM2ugYdDqdiefi9Xpx5coVOBwOHB8fixNIKDwSicDpdKLT6aDVaqHX66FarWI4HCIQCMDlckk0zDPpcDhwcHCAg4MDWK1WBAIBGI1G5HI51Go1uFwuBAIB2O12xONx2O12VKtVVKtVtFotZLNZDIdD+Hw+2O123Lp1C9/5zndQKBTwV3/1V0ilUnJv0WgUV69eFSeu3W4LujEajcSJfR45r4P0j0leaM6F3rWGVAAI/j/9O+0RE5bi4eHPaKgIQ/F9KPyd9jR09MP/GwwGCe8BTHiX9O55eJjUJuylF4vvQfgMOE3kn9fb0Yqa98aITa/fsx6ajlhofJ+10Qkf0FNmfuTzch76PXQuhtEcn5f+m2flb/jsNHSn71NDbLMK74uevd1uh9vtls+gA0IvmHuLUcA0cYFGifvH5XJJBFuv18WIc58w6vR4PGi1WuK5U7nqtWJU0+v1xPAQMmw0GqjVauh0OnJvek15r9qgG41GifI/zzk4i/Bc8Fq00Z/ef4ShrFYrgFNojMaFcCq/A5AcB3ASQTudTni9XoG3uI7cx5RnnY1p8oeO4Ak/MiqlnuDZ+DzyCOHNi9zJr0fObFzItgoEAsIK0bgwvVeDwSAYLr05k8mE0WiERqMBo9EIv9+PUCiEcrkshzYcDgvMRniGCepKpSKeNENkbhJ60uVyGZlMBsCJF85kaigUmth0jUYDFotFjA2ViVYAHo8HiURC7o0YNZXoTAv9/w5XpVJBtVqdOJQUbZz1QSMLjN4gcWhKr9dDLpeTA+p2u9Hr9dButwFg4uBqQ8VDzd+3Wi1YLBYkk0nYbDZks1nk8/mJz3I4HHC5XJL8tdvtWFpagtPpRKlUQrVaFQXPa6fSPY9xoQK5evUqbt68Kcqk3W7jzp07kreiAnn33Xfh9Xpx6dIlzM/PCwuv2Wzi+PgY7XYbrVYLu7u78Pv92NzchNlsxscff4zHjx8jkUjIMyuVSuj1egiHw9jY2EAmk8HOzo4YGM1k4j5jlHJ4eCiOxHA4RLPZlCjohz/8oZyhSCSCZrMpUYAmbbwoA51KpSZyLtwHhLppLAaDgewxDS3rnAWNVK1WQ61WQygUwquvvgqXyyWRRiwWw9raGtrtNt577z3k83nY7XbMzc1N5FwIp49GIxSLRcnJWK1WMWrdbleifJ6Bx48fS66l3+8LAYh53XQ6DZPJhGazKVHm56EDF/Li5czGhYwqwlvas5r2sshiYsjNyIKb1u12w263o9PpwGKxwG63w+v1Sp6FWGuz2QRw6uV3Oh15L8JixNuLxaLkVXh4LBaLQBsUGhF6ZjQu9MromWmFyIN+nuiF10A44vP+ZjrHoY2BzWYTZaBfQ5iQHjjzW9oL1TRKHk5tXGjIzWYzfD4fnE6nGAotfF78PCZfvV6vPCOtTKe98POIwWCYgEbJPORzZOJ4OBzi8PAQbrcb0WgUiURCIE5GiyRN5HI5LC4u4o033pA8XT6fh81mE0ZXNptFp9NBIBBAIBCQ/cLcBdeTTCp62dVqVSKqaciwVqthf38fTqcTyWQSDodDYCoafj4vvRfPs4b1el2cD163dmZ03oT7jOvMhDjhXUaLXAeDwYBkMgm/349sNotKpYJYLIbl5WWBpUjsCYfDYgB6vR68Xi8cDgc6nY6cTQByDkejkUR1es8Wi0Vsb2/DZrMJFK73Mu+X+RZGORfy65EzGxdSgC0Wi2wAQjqEmXR46/f7hS1WKBQkxNYJYIvFIvTKVqsl1EeDwYB6vY5CoSA0SQ0jaMiLX/SADAaDeOz0BEejEYLBIAaDgST7NbTD3A6jCUJirDegoqTymEWYW5qGmQhDkS5Nw8MDRkiRsA6vk0aCsIWmFrPGgIrk1VdfRSQSgcPhgMPhEG+00+ng/v37SKVSE/BhJpOBxWJBrVYThagp3VTg3APpdBqlUgn1el3Wm06Frpmhsp5F1tfXJSJghGo0GtFsNuV6mMQ1Go3C3nr06BFqtRoqlQqOj4/R6/WEOca8m8PhwMOHD2EwGFCpVGC1WgXSYWKfrK5qtYpyuSyRM/c1FbXdbsfKygrcbjdcLpcY6d3dXSEV9Ho9+Hw+BINBABBSAGEfngMAQlM3m8146aWXZlo7CmFE4AQiY2QOQIgYXq8XyWQSACR3xzXTUBb3g8fjEUduZ2dH8pjj8QnF/t69e5Jvou5IpVJyj1arFV6vF16vF2azWXQEzwkNOokv3W4Xu7u7KBaLE8QVvjYcDsPj8aDf70/sReqJ85zhL5NoZ1ITlPizX4ec2bisrKxgNBoJ9EFFwyiFh5BY+MrKCkwmE3Z3d1EoFOByuRAKhSShaDAYJGlKr4YKgoWP6XQanU4H1WoV3W5XjAVwulCsQ/D7/VKfoBOMDIX52fTs6cmQuuxwOETZt9ttlMtlDAaDieiJjKVZhLROivbA7Ha7KGD+HY0slRcjNApzV0xO83eNRkMMMdf429/+Nq5du4ZoNIp4PI52u418Po9SqYT/9J/+E9Lp9ISXyjWmt60hUJ2/MhqN6Pf7ODo6+gx1mRFkMplEIBDA8fExarXazJ7jlStXhHq6t7cnXjSN5GAwEMiu3++jXC5LzdDTp08lErZYLFheXobf75evarWKTz/9VOAT1jn5/X4MBgNxNqjUeH+MfvW+8Hq9eO211zA/P4/FxUUkk0ns7+/j+9//vkC31WpVCCtkOrHGhTUjXEdS9C9duoSbN2+ei0bLMoFGo4FWqzWxb3iWE4kE1tfX0Ww28fjxYzSbTXGsaIh07YnFYoHP50Ov18OjR48AAHNzcwgEAsjlcjg4OJCI0mazoV6vC4RL5iRh8mAwiEQigeFwiEKhgMFggCtXrmB9fV3Wo16v48///M9xcHAg1wycGhfmeAqFAh4+fCj5tWc9q3+sonWLzlF/YY2LTtxrS8gbASAeDIvAeABZ0Mj3oNLSNQakOtPzJkTDOgqGyDQKlUplomCPUBoA2bjEhqmkgdOqdgByiJlg1PRaTUgwm80T3uQsopPfGt8GJmnBunATmKQj8/7oZeq8ht4wpGb7fD4xnFwT0nf5XgsLC1hfX0e5XEYqlfrc4keuIw80k+U6ea5zO/ze7XbRaDQmCCGzyOHhIYbDIXK5HCqViqyjpmLzi9R4ri+/sx6HEaDD4ZDal0QiIRTner0uDg8AqTBvNBqyT7hGurMBf6droiwWCzweD5aWluDz+Z5JaOH/eY40CYZK3el0St5xVuGzY8SgITfCZJrWTYeCz5MQLF9DBcYzrVmDhMW73S5Go5FEcl6vV+jFhLYJrTGvQho0YdBwOCz3QAOhiyqZm9HECkY1RqMRsVgMbrcb7Xb7XNHzF1GetR8+75zps/nrWIMzGxeGqxqb1ZWzpAWTdVOtViURzeQ4Dz1pyEwKsm7FaDSiUCigUCjAaDxpJwEAoVAIo9EIlUoFlUoFR0dHePDgAWq1muRvhsOhGDEm9GmwjEajcN49Ho/g6VQKVFRMCut8AWE0tt+Y9aFQWQQCAbjdbrRaLeTz+Yl8CQ83DS8PHpkxOv/CqIFGghuKxazr6+t44403BHJgvop1SC6XC9FoFH/0R3+EV199FT/96U/xl3/5l2i325+p56ESJdvOYDBIfkwbeO1o0DhlMhlRPtMsoeeR//bf/huAk0iVkTIVUSgUwsLCgigarfDYTsjpdErdBg1QPB7HjRs3xENuNpt4++23cefOHRwdHSGTycDhcEhFOACBZki7bTQaaDabcDqd8Pl8GAwGSKVS6HQ60kImGo3iD/7gD9DpdPDuu+9KBESYzuPxSC5D51tsNhs2NzcRCoVQqVQkwpxVmDdlmxxG6ISGiTpwHxJipDFgVEvDTePJKDIUComeIGmFRZYbGxvw+XxwOByw2+1Ip9P40Y9+JPB3o9GQ6DMYDOKVV15BKBTC3NycIBLACbmC9Wxutxt+vx/9fl9a8DgcDthsNmHGuVwu/PZv/zauXLmCDz/8ED/60Y8+N+f5ZZLpszb9O21I+LeMPKlbftVyZuPyeUlZDYdoA8IkGo2Qfp3Gl+kJ0WNiPoBetk6ik80EQGo86HHxAOjkKhWZzmvwMOhIjNfEQ6NZXJqKfB6Lr9eInpaGkTSNWFOIpyMUvY6a+strBSDYfygUkqI0XgOVF9chHo/DYrHgyZMn4nlOyzStmSy9X0Ry4H3ROGp8fxbR1fI6grVYLAiFQhNFvdwD9KYBSE8qzeiy2Wzwer3iGNFI0EOnIWXUx8iI98dnML0vmB/g87LZbAgEAuj3+wiFQgLzMvJjLdU0Pm42myeg41ardS4qsoZHNJEDgOxLHZ3wGrj39Hnl/fFax+OxOHeEpXWU4/F4EAgEpC0Pk+0ajtVlCX6/X2rCSCACTvI/TqdzIlLlOeczY5RPYgIjeLfb/Rl68pdV9FnWuWd9Ts9LoDmvnPm005ul4hoMBsjlcgBOD5rf75d/U0kzkQtMMp8YcXBz0DNn3oUeOHDavqHRaCCfz6PRaExEK4wK+v0+rFYrfD6fNKnjZvb7/YJBaoM4GAxQKBQmCAlUUsCJt6crmWd9YFQKbJ0DnBw4bggqQvbGYvSkIa9pmEpfjyZTMO90cHCAQCCA+fl5RKNReDweWSseYp/PB4PhpKcbI0VGnVqmGWp8HjrhT0OjFRfvW8NUswhzLoeHh5IA5zqwLx33DWmnJEjwPhcWFgCcUHKZX+GzjkQi6PV6WFxcxOHhISKRiPx9rVZDLpdDKBTC/Py8VMu3Wi2B2mh8/H4/bty4gYWFBaysrEhhKnMIyWQSwWAQxWIRKysr0rOs2WyiUqkIxbtYLMoeZ2uddDp9rjVk3pGRhfZguSfZCFbTppl/qtfrqNfrYowJR/J8ra+vw2Kx4MGDBygWi+Is8fWRSAT7+/s4ODiQnBjbIPn9fly+fBlf+cpX4PP5sLKyAq/XK73WAIhDcOvWLVgsFpRKJWQyGZjNZty8eRMGgwE7OztSZMoz/PDhQ1QqFTx58uTcBvo3LURZ6LDoPFitVpMiUW1k+J175wuXc9HJXYvFMlGRS2VC7xA49aqZcOUN05Og8SD9U7dXoZdrt9ulPobJddIaGYpzsfmZwEmdi8/ng8vlkuRsIBCAyWSaKGCjl0ZWDJtgappyPp+Xnk/0amcRXluz2RQPmRXK9AJpXLieOmE5ncvQoqNK/p4VzQAkacpWOTz0NPL63nu9nrQJ0TKdZ+Oz5c+mKceksurI8DyHenFxURwBRhT8DGL2zCV1Oh1ks1n0+325L4fDgUgkIjUmVDLsVxUOhzEYDBCNRhGJRLC2toY33ngD7XYbP/rRj1CtVhGPx7GxsQGn04l79+5NeNE88B6PRyr/g8Gg5GposMPhsDDIYrGYdPTmHiQdl7VXhJ56vR6KxeK5IB06M5VKRQwHowV6+uwOQGG+iTUkmnVFVp3b7RYIy2Kx4OHDh6jVagJRA6dnslar4cGDB7LnLRaLNKtdWVnBzZs34XQ6BfriPtUkkY2NDWH45XI5WK1WrK2tweFwoFQqYXt7W+BPANjf30culxPW6Zc5ciH6QviQOUQ6dnx206xU7ZD+uuTMxoXtEnggqfQBSMKMVEPCYjQwhGCYiGM4xzoFFr5Nh91kqjDBSqorqZE6oer1eqXegklQMq1IMODf6i/gNJmpK3j5xTzNefIFzxKfz4dr164BAJ4+fYpSqSQ5FF2Yp5Pr/NIwGXBKYOAG0/UH3W4XNptN+qhpKFAL752OwC8TGn/gdCMzWtW/Izx6XuE6cBwC8wWMiDRhwO12IxgMitIk46tWq8FsNmNjYwMbGxuIx+MyViCfz8seYQfw7e1tiSJqtRoODw/FqaJHzX0TjUaxtrYmVFjdH4xKluvEqFRDsWxfRAo1jSfhYbfbLV3FZxWyAElqYdNPAHJWtKPAeyDKwD5hRqNR4KperycR7NOnT2EymVCpVABAip0ZNRSLRelQTaPFqI97mM6AJgBRV5B2rqGvRqMhkR2vjcxP7nOSggiHf5lrXQhP2mw2LC4uwuFwoFarCV1dG+LftBE9s3FhN1in0ylwFfsfXb9+HQsLCygUCuIx0jAwbA4EAsKfL5fL6HQ6qNfrMuOFNRXcyEzcsq03mwtSCbOnWDabRa1WQzKZxPz8PNxut2xaHW3QaDSbTTnIrVZLYD6z2SyME25ak8mExcVFoaS+iEQgH3gikcDv/d7vYTQaIZvN4uDgYMKgEW7RTT2nv1OoAEwmkxhgm82GSqUCr9crnqDGp6fzPWwvwqrzZ4mOQhiWk3ygWX4mk0kgNk2vPo9QqS4tLWFpaQmpVAofffSRGFIqFuaavvrVr8Lj8WB7e1sq0zOZDPx+P373d38Xy8vLKJfLQq1/+vQput0ugsEgrl69iqOjI/zkJz8R48JoaDg86bqcTCZhMpkkGT0/P48/+qM/gtfrFQYao2qy0qhsubdpWMhiKpfLyOVyggboeptwOIyFhYVzGZdKpQKj8aSzdCQSQblcFjYXa37oCOocFaFlwo8WiwXz8/OIRCLY3d1FOp1GLpfD7u4ugNMoneepXq/jRz/6Ecxms0C+brcbsVhMDCeLq/kzbQBowEulElqtltQKNRoNFItF2Gy2CRSFRpiRtYb1NGHiyyh0ShwOB1555RX4fD7cvXtX+u3RQeD+ehbiMQ1xT//sRclz9RbTNFm2bNCwlE7Ua7qsrvLle+nogSHytHfO1+j8AzedrlSfho74Ol08xdeTc689ar6er6PyJgyov16U6GiNn6OTq/TaphP2z0pI6vwD15GHlcw5HXnpDcX6IUYsz3p/nTykd8SoCsBnXjd9LS9CCIXprtL0arnPdO0Er1N7sBq+ZWSr348eIWGu6UhsurmjhgE18UPTzPl/VutTMZJlR0quhunoqevIXLPyZhWy63hdhASZ6Kcy0pXuvBdeg75Hnk191jUUqs8rPwM4rUnRCXldJDkNsRLJIKmBhayEyw0Gg0RPJBboNv+8NgBfauMyfd362fD5/KajFS3PnXPhIff7/fjWt74F4GTTZrNZaYvBgw5AZrcwKQqcdiHWcAapmDRU3W5XOs9qK6wbFw4GA3i9XtnAZOGwLQeVEY3KYDCQ4VLc+FarVYaAsQmh0WgUpawTZmRdzSLTBnBvbw//+T//Z4k2gsHgBCTB9dO1CbrNvvbshsOhYPc8bMlkEr/zO7+DWCwmA9z05zNXsb29jZ2dHRwcHIgRmTYWujiNg9xyuZzUnkwzVbrdrjzrFxG1AMDBwQGMRiMikYhME9Rdrdn7iwPB9vf3YTAYkMvlUK1WEQgEMDc3B6fTiWw2i3a7jXg8jsuXL6Pb7WJ+fl48bUYw0WhUuigz+mVkq+FD5iO2t7dlWqNuZXRwcID/9b/+l8xs6ff7SCaTWF9fRz6fx/3795FOpxEIBLCxsYFKpYL9/X0pUDWbzXj69Cl2dnbOFblw33Amk8ViwbVr1zAYDHBwcIBKpSJRTafTwfHx8USeBTgpEmXifGdnR/q5GQynrFC2OOLrWEzLEQjtdhuBQABLS0tSWMlZObdv34bH40E8HhfUwWAwoFQq4fDwEKVSCe+88w6ePn0q5Id2u40HDx7AZDIhGAzKzCfSoZlrabfbcDqdXygFfFaZ7oDSbDZx+/Zt2Gw2KVQnKqPz48DnN679vJ+9sGt+nj+mJ0NYKplMYjwe4+jo6DM3ptlY9CKYKJ62wPSEdXTAhLFWpFrp0oNiGE98na9lc0p6VoxWCMWRNKAjKxo7er6atqo/+zzCdanX69LpgCMLeE8UGtTpz5+mvzLHBZx65xzFy7G0n/csq9WqMIT09fEzGaUS+w8GgwgGg5IboGLRX1zPZ0VBswqfGWeAAJBoQ7d/IUGBjCcaA+Zi2Bet3+8jGo0iGAwKfNvr9ZDJZFAul8U4jEYjaU3SaDSkroVes84JsC09HRpG+61WC9vb2wLv8ufz8/Not9solUooFosIhULS6oR1OizsZMPT80QufB48k4TrBoMBjo6OZJ2ogLWx5ZmnYeeoch216ahA055JqeYETuZbmB9l1NZsNpHP59HtduHz+Sao62ySWS6XcXh4iN3dXXEQNWOQDDM92ZX5x8FgcC46/G9KdHTM/cbaHrPZLIaUjv0XxXieeaVXV1cBnEQi9OCOjo4EGybbhtMgFxcXYTKZkEqlpEaBm49V4s8KT4n7UvnrOg/mBdrtNnK53ERuBzhtqsiiNJPJJAOi6PGReEC2GiMW3SmA1FEaLMIk592YRqMR0WhUuvNmMhmMRiNRdjykwCmkQIMNnOYdpiEovs5isWB9fR3xeBzBYBAPHjxAMBiUjtPMLwGnBp4jpBkl6qhFwxJMonLYFamkjKh4DcTVOU+eCqTZbAqNdRah88Ho2Ww2Ix6PA4DMFuG9drtdZLNZ9Ho9MYahUAg+n09o70zkszDw8PBQvGd2AHj11VfFgTEajXj48KF0VNZOj9F40hK/VCphNBphdXUVwWAQJpMJjUYDTqcTX/3qV9FoNGRNg8Eg5ubm4PP58MYbbyCXy4li5PtRMabTaVgsFly9evVcyehbt27J+tFgEDlYWlqSWTY0Bjdv3kSv15Puwzx/fA9G/ozsuHe5Fz0eD8LhMHw+H27cuIFwOCwwuM1mQygUkgQ8I0mPxwOHwyGf8eDBAzx58kT0AI2G2XwyRyoWi6HX60nharfbRSqVQq/Xk5wgc6rAKQLzZRKNDFB3zc3N4Zvf/Cbsdjv+7u/+TtoS/SKHjs7pr4vQcGZtubm5KcqFh5M0QNIuqfjZhp2TJFkFTO+GEAtwikkz/GZikZ4jcMqQKJfLory4mXSEQRyXkQDDR427u91ueDweqe7lDHPSje12OxqNBgqFgnhT9NrPQ0UGThR6PB7H2tqaVI5zLbkWGuvWBkTDTs/aQDQc165dw61bt5BKpXDnzh0EAgFcvXpVBixpTBw4MS7FYlHqPnRtDb0lGmAAE3RYRjV8Bkwokn5OJerz+ZDL5c7VeoP7ZTQayXNPJpNwOp14+eWXEYvFJPJkVDgajYTV5Ha7pf0KW8LTqDebTWlKyY6+m5ub+MpXvjIxQfX4+Bj1el0Uq06YMgJhIjwcDgvk6XA48LWvfQ0AxNjyWiORiJwRRoNkS1FpFgoFRKNRXL9+/VzR82uvvYbhcIinT5/KrHn211teXobdbhfl73Q6MT8/LzTpo6Mjyc9p0Q4LAFH84/EYwWAQm5ubCAaD8ox0noyedjgcFto4dQONywcffID//b//N0KhEK5duyb6ggPIXn31VbmmYrEoSX6n0ynGi9cFnE7B/LKJTgvw2Xz3u9+Fy+XC/fv3cffu3V9oXDTy8SIRhV8kZzYubPugE0c6aUpFw4hB8/Q1LGMwnHZApjLi4eUN6wOkow4qMbJHGOZSAeqEpzZm0+/Ba55OiJEVMxqNRBExkmLi97zJQG5+KhGz2SwtZ561OfT6anhQw2KMHEmPZXRJ71R731xTrkm1WkU+nxe2Ht9/GqedfiYa/9VQiN4fNEpMjjNndB7RkRxw2o6Fe5Nr6fF4YLVahWUEnEQ4+pp5vaTkMlFcLpelDRGvmbVYhOK4Dty3/GwaYR3JsYaJhpGRHZPThUJBmFu8Hp4RsqPq9Try+fy56PB00pijYgQD4DMDzHQLpGcRNjTN1+PxSASoo1+r1YpgMCg1VtpB0FE6SRY0HPziGSbMyBoOEgsYyTDvook6XDueH11P9mWLXLRoh0/Py3I6nXLmP+/+ft33fWbjcnh4CADSbpz4NhVuv9+H3W6XQrWnT58CONl82qvs9Xo4OjpCo9GQ2RyEXeSi/p/nw+/aW2GIS8VAZgs3GjedwWAQNkq325W+YKRGAxD8nJ5sOByWWROxWEy8J342w/9ZZTQa4ejoCNlsFm63G3Nzc1J1TuMybUDYUoNMI+A036RrP1599VXperu1tYVyuYxarSa9lugR8jWkxT59+hQ///nPJxr96XwLN6TugqALZzUzSA904uew+zJhkvOs33g8Fho7FTQ7cHs8HummYLfbsby8DKPRiPfffx8PHz7EpUuXsLq6OuGgsGYln89jb28PxWJRRkTQ2JLEMR6ftJBnvomUbd4r74v7j7RoJrGp+Jh3qdVqKJVKKJVKuH37trT6Z+RXqVQEamu1WqhUKtjb25t57QAInFetVlEsFjEYDMQhYRTHFvfj8VjyXHyuwGcdG9Yd1et1bG1tSZ0b9+WVK1fg9/sRCAQkr8V103UZ3DfM4xHGJe27Vqvh9u3b8jvW2LC7Abtu0zDxvGhyjmbxfdlEQ9Umk0lIVCwUn5+fl+4ln/f6X3dngjMbF1pE7ZnoBPN0NTEjHcIx2rslU4xfeuE0NDQNBWnRik9TTvV76IJNvkYfDiZdeT30oDTLjFESqauzCq+B5AZND9aJfB096PvR90DhOpFSqqcAktJJxtv0OjBia7fbkpfS1/ms65++nmdFL9PPaLoGZVbjQqVAz55wFvMT2uOnJ6eJHlT4XGt6stVqVWqDqGDp+TL3ou/lWftTR3d633E/6bVnl2gal2q1Kt+dTidsNpswHnUUyJ+dx/sk8YEOgqbsM/9CI0iDomm8+jlP16HoNdFniMWXer9P7xcyFPVeelbZAbtr+3w+iUoZpfM6NAlGU6cZgf66IKEXLdRdPOt0FKm3XnSR94uQMxsXbmwmlcbjseQK2NWX4el0opPsLXrhm5ubsjFIifR6vVLFz/5aPFzEoklZ1FAP+5NFo1FsbGzA5XLB7/cLbss2F4xWNIRGpaM7B7AIkG35dZdievezCPNHvKd2uz1BiIhEIhMDtXhACG1p2JAKjfNLbDYbyuWyjHYtlUqYn5/H66+/Lt0T6PEBkILAYrEoXavJStKHmp/HnJiuEdE5ByqOYDAoxXbHx8cTXiIPwqzG5fj4+DM/4+dyEBhhLaPRCJ/PB6/Xi5dffhl+vx+JRAKRSEQ8cuCk59RPfvITqTUBgKtXr8qwKdYhEXbjPCHu28FgIMWuKysreP311xGJRDA/Pz/hVGloh4zFSqWCYrEoMByjLq4xI+X5+XmYzWYUi0WZ7TKr3L59G8DJeWWfOeYa2bU4lUphe3tbim95bogYEDYm661UKuHBgwcCi7OHWzgcRjAYRCqVQr1eh9/vlxYw0Wh0ogaOFG2/3y+/K5fL0sLo4OBAEvlGo1Gci1qtJvmV119/HQ6HA/v7+0ilUnKe7XY7rly5gmg0iidPnuDu3bu/Eg9eO62/KuNlNBrx0ksv4Zvf/Kb0uRsMBjLVVOveL4I8V+QCnCZx6d0xBOVG0Ykng8Eg+QxdN0Imzd7eHnK5nHhsmimmPapWqyU8dSpbHlpCCV6vV7jxhD3o0VIBaq+IXhsZL/S+6AnQi+Lr6CHNunGYTOehYq8os9ksbKfhcPiZvl7Pao+tqbhs68Ius8fHxzJOdm1tDZFIRBQCjdZgMBClxg609JB1PkF/HrFdKhldo8TcAqcrUhFqdps2WrNIuVwGAIH5gFPuP2GjWq0miozsMUJmHo9HWuIzcZ1Op/Hee+/BZrMhkUgIfXttbQ1HR0e4f/++YPeMlBjpkT5LJmE0GsXNmzcRCASEUDLdJJTnhu9RrVZRq9UEnmXU5HK5EIlEhBHF/ntsSjirHBwcADhxdJgHZR4pkUhgYWFBmkF2Oh0sLS2JsqSxczqdE8l4Gkp2bHA6nVhYWMDy8jJ6vR5KpZKQBPj8/H6/RIL6fHMMBKfPMieVz+cn4GI6edQ5sVgMa2trwh5kt3RC91euXMHi4qLUw/wqFLCOxn5VxoWsvm984xtS7EuHO5/Pf+EisjMbF3rwpPuxzUa/38fu7i7K5bJ491arFYFAQLBRMrc0Xs+WJUtLS6LMqQB1XkBX7nIzDoenvbdIP3U6neLdkHLKJLwO7af77+jPoiLhwaEink5AziKsQ9Fhu/4ajUaYm5vDpUuXhL3EtdZ9s4BJ5gsrvnm9rNOpVCr45JNPEI/Hsbi4KPkx3melUpEqZybdWTRYqVTEKAOTje9okHXSldfIPcDpnzpRq+uQZhEWghLOYfdrq9UqHH8qbQB47733JmjIjUYDt2/fljwGxzpcv35dpikyR8J6mmQyiVarhVQqNQGXMUFPZpjH40Gz2cSdO3ekTTz3M3AS9etu2IQw2e4/FArBbDaLobFYLNIShXVZHI53HsXI6Bk4iV58Ph8SiQTsdjsKhYJMiQROYUCeZe4tPYsJwESHA8I1zWYThUIBoVAIq6ur0tiSkzbpaJGyzLlAhUIBh4eHci41VdrhcMjQsHQ6jWq1Koa71+tNzMghY5Wt+re2tnB8fIzd3V05Ky9apgkwL1J49pmDYmkBYXo657oLyhdBnmtY2Hh8Mma02WzC5/NJdfOTJ0+QTqflcOvmc6x0ZoU+lSnncLAJYSaTmWgxwXwM8zf0FgmLMQeSTCaxsrICl8slQ6GYvKYhIT2VHphmTulIgkrRbDZLzohKIRqNYm5ubmYqKHFhHghdAMaDeuXKFXz9619HNpvF3/zN3yCbzcoh03UEXEMaXL4vcW6n04lMJoP/83/+D+bn53Hz5k2Ew2H5XbvdxvHxsfRqazQacLvdiMfjE8lnnWehAdbKTUN3xMQpVB6MRs+bM0gmkxiNRigUCqhUKnC73dKrLpVKybMbDofIZDLY39+H2+3Gn/7pn+LatWv46KOP8Ld/+7fi1ZpMJqyvr+O3f/u3xYgajScNGRkxuN1uKdxj0SQdGO4vJsBLpRL+7u/+DvF4XKAsFnxSaZOeTXYVCSn1eh1erxeHh4cyXCsUCgEAtre3ZV78ebsdBINBjMdjyfGEw2HcuHEDBoMBH3zwgdSy0JEgcSeRSGBtbQ3pdBp3796V3M14PBbDYTCcDg8kjJ1IJPCd73xHBtQBkDIA7TwyP/jBBx/gb/7mb2C1WnHr1i34fD65Zw4QMxpPWssfHx8L2tFut/Hhhx9KVNPv9xEMBqWO7b333puAfH8VBuBXBYfx/FHfBYNBLC8vC3GEKQV2ifhSGheNlWslQ+hIF1LRM9FJw+nkvU7Ga2XLkFfTBnUFPTc1vWGG64QgdD6FSS7NYNK5Aj4wXgNfz3vSjBay0WbNGeiNpyOQ6eQ6IRJNnPg8mY6CjEbjRFKYBplfZJNpmrb2ELnGACZIBNP7YDryetZ10ggzf3BetorD4RDWHt9Tt/KYplwzOV2v14Xmy33JiIoRBPDZNjU0VKPRaIJwMX0PfC/mCTUBgPAr9xFbDTGqppLVHSGA09HaACbaH72IhK3Oh9KA8L40hEdF3el0hLlFr1+ffd4rqd28Z+4v5lm5V7iW3A8aVh0MBmL8S6WSnDmuAfN+jIo1YUc7PUQm2KKH+5uv+bIJi5G5X3XyXjvJX1pYTPecYjKeIXQsFhMMkK0XDg8PpXiSyU9WVnOBmJQjEYBwDSt4qVCY6ObfDIdDMShstc+/N5lM4plFIhGBgnQrGIaXoVBIIAsebkIihOuI/RaLRdy7dw+j0Qjf/OY3n3uhpxlFPJCMjhqNBt577z08evQI3W5XvFUqe50zedb78rvf75eCVh7Mo6MjqftIJBLSuoeKuF6vo9FoIJvNyqFn7zbd20wbr06nI2QJijbQVADMd5zXuEQikYm2MtFoFIuLixgOh0in06hUKvD5fOLxEzp98OABstks/H4/vvvd78JoNEqinnuHBZCE2ywWi5AEuGeDwaDsY66HhisSiYRAYoRlCSOZTCYsLCxgNDoZu0zacTAYRLlcxvHxsRgmvjfJF3S0XkQRL8kiRqNRorIf/vCHsFgsE5Ridk9mrQ9FP3M6Z2TcUUwmEyKRiEDh3B+cJcTohs+SMDnHZLBw+Wc/+xkASMcEsuxYQ8dOG3w/jlfXzuj29ragJIlEQiD2L5OMxycjyd944w3Mz89jbW1tggJPXayp8V8UObNxmbb4VPpGo1HYVkzosskcvefPu2HCUbrrq54pwkl89Fx0h2R6O9xg/NIwDQshtReqcWubzSaeI2mmjFo4w4Uhe6FQkNB6Fpk2DNrrI7TVbreRzWY/V4HQ+/tFdGHmudj3aTgcChOMsAwNPFuNaAiSlGFGa9PvTw/8WUWfGvKjmM3miTkgswpbgjC3RkeGSpmQIPMYvD725bp8+TLm5+dhtVrRaDTQ6/WEYEKPnM4HoRrdP0y3ENGsPd630+lENBqVPBBw2iiS+P94PBYlqqOB6dklwGeLVhntnMe46KiUuYpyuSzJeJ4Xso54DplT0xAur5VrxXXQdT68dh3d6aJg7SzonCIJJ2TW8flwfzLPo+nefJY862SZMqfFQXjnWb/flHAc+dLSEnw+H4BT9iV14nnymb8qeS7jYjSedKVlJ2JGLlT0xPKJvVPR8e8ZBjPMp0HgBgMgST8NAVAx1Wo1HB0dAYBQO5kj4AEETg8/i6q0Z6OFSoYUS8p4PBbDSZiK3s+snoFmqk0rZP5bF2rqg8a10wqdz4RrQ2iF0IKm0e7v70ubjXg8LtEbKdzLy8uoVCqSE6Mh1oqECpz5GD5D3oNeOwqjMkJB5+nNFg6HRVF5vV7Y7XaBu+hMMJLVtRi5XA6VSgWRSAS1Wk3a/litVpnnAmBipHE6nYbVasXly5clZ0LFxMFU9OgZ6bDAV9d1kGLM2TpUrKFQCHt7e3jw4IFEjK1WS5hWDodDckhknr0ISOfatWuSt2J7HO4/3e7e4/FMsEA1EWe61ovGhwWTdrsd2WwWqVRKplFyPRiZsAnlzs4OWq2WUJEPDw8RCATgdrsRjUYxHJ62mwIgXR7YcLRUKglFXVfj84sEABqrL6PQoWPHb+7dVCqFH/zgB0in0zJH54smzwWLARCmQj6fx+PHjzEajRCJROByuSQ8oxUlE4RUV71ZybohI4ufwQSwVqZUFjQuhBSo7Lj5NPXTYDAIy8br9WJpaQkWi0WU9Wh00nGWURCjJCpHYtE0Lkxszio6UnkWZg2cttLQXj69xs+b10DFr2eQkAFGOPDw8BDNZhNzc3NYXFyUTtJOp1M8IuLcuoWOhsO0cdHQgj7MFO3ZE2LRkw5nERoX9o4jVMlZNIwK2MGYa5FOp6VLQK1Wg8VikQFwbNrp8XiwsrICk8mETz75BMfHx1haWsLm5iYMBgOKxaIkt7VR0zAaa660Iq3Vajg4OJBI2GazYWFhAYFAAHfu3MG77747YaRp+EhAASAjgPV8klnl2rVrGA6HePTokUCmfB46p+F2u2XvEHYhzEnjwjNE75nDq9xuN773ve+JcWE+Vhe0krH3+PFjlMtlgTXH47Ew7XRvwEwmI8l/NixdWlrCw4cP8fjxYznDVMRsvEnCx+HhoUwhZVT5ZRHeUygUQiKRgM/ng8ViQaFQwF/91V9hZ2cHqVTqN32Zz5Tn6i0GQBSyxtupOJhE52Eaj8fSnoWetS7AAiAeEeEMKjYyc2iEdJitDQ4Tt/Qq6ZFrujEA2Vwa26UBY+Uvw20AE6E+lcV5KvRZV6ALIqeTcJoZpu9PExm0aEPKdeM90XADkMp1MpXoKNBocVzC9Pvzvmlc9LprY0HDQ0M4XZXOaz1P6w0qH0ZOzL+NRiNpLWKxWFAqleDxeLC8vCytVEh5J9w3GAykn1g+n0ev10M8Hhf2USgUQjAYlGma3B+ELRnxklmoaaHA6R7lF6MA4HQENSMEGjjCvqzBYaHnaDSStSYhY1ZJp9MT0STZRnQCWWzL5DfPCnOamoqtnTQ+l3Q6LQby2rVrmJubm8i78N+k/LP9TblcRrVanUjQk9ij28nwzLRaLTnPyWRyIlfLQmz22KNMD8z7Mgh1qd1uh8/nk/IOIhLMlX5R80hnNi6kxR4dHSGXy8lIUofDIRuK+Q6N21P5kR0zHA4FBgAgxVMLCwswm82SwNNt9Yl7azYXNwq7+pL1wwehm2V2u13s7OzAaDRiZWUFwWBwonngwcEB2u02FhYWBPpikpLKgxj/rJ53KBQSuI0e4bQnqjsA8EASopqG0jTLhoeQr2OUyMNcq9UwGo2k+y2hnuHwZJ7L/v7+Z5LzAKSGAzjtTUT6M/n2OqeSyWRk5AILZXUfsOmOus8jjx49AjAJExLSvHz5MrxeL/b29nD//n2srKzg93//9zE3N4fXX399YuAVoc52u42dnR3cvn1bMHnmDBOJBOLxOJaXl8X50EWXZG5pY+R0OiccoGmqOVlQrM+wWCxYWVlBLpcTurHP55N8WbFYxGg0kvqk5eVlrK6unks5vvPOOwAghoxGhfBoJBJBpVKRcRMk3pD8kclk8OjRI0EedE6uUCjghz/8ITweD7773e/ij//4jyVyIOWaDki1WkUul8OTJ0+Qz+dlVDR1CYsze70e8vn8BNtzMBhIkWc4HMa3vvUtVCoV/OQnP0GpVJIC1E6ng1wuJ/ueiMCXKedCh4IlGxsbG3Kmms0mstmsjJb4IspzjTmm10Euvk6m0TMAMKH4mCzWh0JXw9Mr1wk/ik7ma+aUFo0JP6sOA5hMmmvyAF+jGVea/qyjls+j5p5VmOj+Re+hIzfNDmMUxt/xPfR7aWOkoS1GN3xWhP9YOPksWEuvn6Y66veil6n7RRGSoEEmJZhrqfNLzyuEiaaflcFwUmDHiIyKk8wkAEITZoTL13HNNOHDbrfD6/XKYDH+HSMXdkLQ3SQY8eq8iE5kk6hCphOZZMw58hoYNegEuqbmawfjPGvIvcwv/Ux5HXpv6LM5HXFrlmWn0xG25fz8PAKBwASFm7Aqh65xQm2z2RTHg+iGHlKmnSoAEm2z3ZAey8xr1WvIFj18zl8W0WvP3BVhRRZ764LWL5o8d0J/Y2MDm5ubokBYKe1yuYQyqMPZbDYruHY8HhcMlj2h8vm89Dni7GsW+wUCAVSrVXzyySfI5XLIZDICr2laIRUccV0uvIaMGMlks1lpXU4DeP36dZhMJplyx/diXsJms6HRaCCdTmM8HuPy5cvPvdClUkmUhL5uYJKjrvMcJFD4fD40Gg3x4nSrlumNpQefsffV5uYmEomEeJI0mk6nE9euXUO328XW1hY++ugjUcwGg2FiHXmtGgJiMpzX7HQ6sby8LPfGSKfdbkt37Fnl6OhIImDSzgnXABDSAAsXP/roI2xtbaFYLKJWqyEUCmFpaUnmurjdbrz88ssIhUIyuMputwvji5EIW4Zsb2/j+PhYFCyjJnrKHo9HlB0VHfMHR0dH+Oijj9BqtRAMBoViT2OxuLgo9HF2Y9azjHq9Hg4PDycov7MIjSXvn9Agk+mVSkV6nFmtVoRCIVgsFhweHkoxM6NAtlman5+XNjGMUDY3N7G+vi6RyHg8llHDjx8/xpMnT3B4eIgnT55I5wFGojQyjIz0WbHZbHK+SVhhDZeeikklTOSEfeYKhYJEhF8GoYNE56jZbMp46fv37/9CJu4XQZ6riNJoNCIWi0nbF3oq7PdkMJy2eKESTKVSSKVSkqh0Op1IJBJSUcqWIX6/X7BSLqrT6ZR6mp2dHTnQrLmZ9s41XstkJX9HhUjIzeFwiIeaSCTgdrtx9+5d6bdFowKceFM6zJ5FyKAjTEKvFnh2dS/vx+fzIR6PS2U630PDZTr3ogtVee2EeDiiltEQBy6RiKEjIj5LPmN65rrinowmQnCsHWISGDgtAmR0MSvjqVQqwWAwSB6EdR98RoROHQ4HRqMR9vf3YbFYkE6nUSwWBQ6lp01mFhlFjDQCgQD8fr/spX6/j3Q6jZ2dHSEn0HCz3opV5+xKwQiN15fNZmX+OxP7Xq9XKubZGoVKknkDAJJ4L5VKws6cVRiBu91uhMNhaQHE1j3MZVQqlQlyQj6fl72nFTjrpq5cuYLhcCgJ/Lm5OcRiMXHSmB+oVqtiVNgDj52tGeWSnKPzVQDkM7kmmp6sqbjUHzqKJLzL8QVfluiFOoJ5wm63i+PjYzx48AD7+/vnaqT765AzGxe/3y8bi3MhyC5hR95arSYeJBWZLu45Pj4WpUBMl3M3SCtm+M0aGT3DhIfWYrFIs0eXyzUROpKhRCYPlSLDfOZOAMg96EmMHLPKfk9krNCTmvVh6sgEOD0szFPRUGh6qM79DAYDeL1e6f1FIsQ0Bq8JDwyrqchIadVGmTUYuqBQEwJIxqBhoALQECUPMXMFXFd+f1aE9bxy9epViYi5Nw4ODmC325FMJuX6vF4vvF4v1tbWpDZmMBhI7oKHlXuO90Pl6Xa7EQwGhbTC/Aw9diZUuX6VSgWpVEoUqtFolHooJqrZpZdJc3rgzOWwNQy7AvMZ9vt9iVho0M4jjCrZx4uKVl8b60MY1dMQ6zyXhkR1PYxO3E/DoKRqM+9iMJxMKeUIbOoNABKBEk3g+dA98Gh8NdTG5xcKhaRRKa+5UChIXvE3qZCnGaK/SHjt2ugbDAbpMK31xBdRzmxcODyLuDNvfDweyyhh8tVdLhdisZi023A4HEilUvj000+lER57i21sbEj7eRbHsRU4R78SS+Vi2u12LCwswO12IxAICFRCWI0jdTnell4ME6OhUEggucFggMPDQ1E6nLW+tLQkSWpWu5/HuPDg8fWkPwOYyJHovzMYDOI1er1eGaxGBctkOj28aZozI7ZQKIR4PC5rof/G5XJJg8dwOCwUXxIzaIDYPyqTycgseF1nA0A6tOqWJdMe6Kzy9a9/HcPhEPfv38fu7i6azebEgC06EJFIBNFoFLdu3ZIeXt1uVxSZpgpTYVUqFTx58gSDwQDJZBJLS0vodrtyoNlPjzkZ3Solm83Kc3jppZcwGo3EIOzs7GBvb0+osjTgDodDuiI3Gg3s7Oyg0+ng29/+Nr7yla/INTUaDVSrVVSr1QnG2azy8ssvYzgc4u7du9jb2xODYbPZ4Pf7BZHguGZC2DSIbKcDnOZaCNcAp+QTRsaagKNHbBPCIsWahBKeDYvFgnA4LMPF6CwOBgMZob60tCQjFrhOwEmD07m5OTFmnU4HP/7xj4W085s0Ljq3eZZrIAJAVqPuiELSxRfVsADPYVzouVGxaSEMxcQ8GUwslGQnVB5sRhk0GMBkvyv+XLNtdIKU78lZJsQlmTzla/Qmp/EATunP9KT4OypBJm/58Bjes3DzRYiG6ggpaoLBtFL+PK/1l3kuJpNJ2Hza29OQ4TRFk541mXqaIg1A4DwqD21E9LXoZ6vhs1mE10pWF++d5IRWqzXRn4vXQVabx+MRg1Kv14Wcop+9Xk+2gtf92TSNnJ/FhqeEbMkuIyvM7/dPkE4YGTBRzXvimWFb/0ajIYW80w7ErMIIwG63IxwOC1ylYWY2R2TOjPfF7hfTkw51vtPhcMDpdEqNCoX3zMFsrBHSZ52GR8NAdF75XjzXjFzJBON7sY6m0WgIisE8EPcMG49+0YX5RRaVtlotFAoFiaJ/0TjjL4qc2bg8fvwYAATTJ74+Ho8lYuFiWCwWgRM4KwMAqtWqRA8cfVytVoUWaTabpaOybqhHthiT/qFQCLFYDD6fDx6PR6A2p9MJAOJlkcan2TCdTgeFQgFOpxOLi4sT3oQutsvlcpKEDgQC8hmzPtDp5L1uMeN2u4WuStrw9MwKsvQIjxDuoUwrd96X3W7HpUuX8Morr0hvKipqzfRhm5jhcIhoNAqz2Yx8Po9isYhOp4Pj42MxyMFgcIJxx+vUSkg7GEz2Pmvg11mFsFU8HkcymcTBwQFqtRr6/b5APKwFaLVayOVy6Ha7SCaTmJ+fl3Xrdrv45JNP0Ov1hN7JJDcNKHOBu7u7SKVS2Nvbw9HRkSg3m80Gn88n1OJms4mNjQ1J1O/u7uLo6Ai3bt3C7/7u78oQt2q1ih/+8IfY2tqS4khGpAbDSdHv22+/LQoSgOTFiBicR6HcvXsXJpMJly9fxm/91m/h4OBARlzTQMbjcbz00kuo1Wr49NNP0W63sbS0hGg0ilwuh3K5PPHMuR8ikQhu3LghUT+f/3h8Qr//2c9+hr29PWxtbSGdTsv+Z9QJQNYVOOkpRgPDJrKMjJ48eYL9/X0kk0msra3BbrfLiIqjoyOUSqWJ3O3q6iquXbuGe/fu4cMPPzw3vDirnPXZ0SFOJpP42te+BovFgu3tbTx9+lSMaCqV+sJSkClnNi4Mh+m566iD1b2akqwTnvRquJnY14reme5FpN9julaAvyNbiF+EOzQtmnAJoxNNqe31egKZae+bCVzt/UQiEVgsls/UmjyvaO8MwIRyp0dNL5HrMV08xihCe9nTcNuziAEej2eCFsqfa0qxvk5GmVToNPAkbzBpra9FM9y0caEiooMw6/qRRsziRjYbpcEAIM02WWRJxpPX60W73ZZCO0Jd8Xhc9gmjNd4XYTGOQGbimUw73W5Hzx1h9FGv1yWnWKvVxLseDoeoVCpSQ0LlbDKZZFAXr99oNEqjUebmziPlclnO4vz8vMw90XvLarUiHo9P5FNIAmA0Bkx2gyY5Zn5+Hn6/X84VcDpSu1AoiOJvtVqw2+0T3Si4D/kM6aHz5/oskMpMpp+OXMhoozidTly9ehXRaPRLU+uio/RIJAIA2NnZQa1WE6SGra3OQ+//VcuZjQshFT2RkUrE4/FIO41sNivtWVgxTV42lZYOw8n6oDfOLsmFQkH6QunPp9GiUuX8Ft1+49atWxNMEmKXRqMRc3NzMv+AzCO+39LSEuLxuPR7AiDV0jSgs4o2yvRMyNBifoKHvtvtSuW4LhrU684DMp3L0MaI7LFyuYx8Pi8GVXuBoVBImjkyx7C9vS2tYOjRExbl4dWMNV4jCybpMfLzyeQi22cWefr0KQwGg7RpIRXVYDBI08V+v49MJiN5Nz5/jvJlvyqn04lOpwOv14t8Pg+DwYBLly6JYS2XyygUCjg+Ppa8nO7qwDYuTHRzzd9//30AwMrKCubn5xEOhwUGslqt8Pv9eOutt7C5uSn5Ql0wSPo9cwOMZgkDsavxrFKr1WAymXD79m1ks1mUSiUUi0UMh0NpK8KIj100dO2Z1WqVWUm3bt1CLBbDwsIClpaW4Pf7BUXQUTrJIYzQjo+PZe4SyTisPNe9BglrUZlqByeZTEqEs7u7K+1n+IwASNPLVquFnZ0d1Ot1HB8fnxtaPI/8spyLLji3WCyo1WoymjqfzwuaA0CGBH5RDQvwHMaF3hN7OZGTbrPZcOXKFYRCIWxvbyOXy4knQ7ZHuVwWnjoZS8BkqxIaF2LRxWIR+XwejUZD4BjdFZmLynoHej82mw2xWAxWqxV7e3vY29uT62YrCw5zYsTAz6YnlM/npSEixwLws8/DFiOmTMVL3Jh4/uLiIhKJxARLDjgtYKWCJ5VZM3R08R6vkfdWrVYlAUjjQoNA6i1fd3R0hEePHiGbzUq7fN3yg2wy7f3x83iwGUkyCtBFsrN6jbu7uwIhMhIhvOH3+0Vxka1GpcncSTwel44C4XAYg8HJ7PFSqQSv14tLly7BZrNJU0caZM4VYdTBvMTc3JwoOK7Bxx9/DI/HI/UzZITRIFmtVrz55psT99VoNPDw4UNUq1XJjZnN5onRynQsztPhAIA4M/fu3cPDhw/lmVssFok2OA1SO48aVWCd0JtvvolLly4JO4+RiDZGNC7j8eRQMSboWVvk9XrF0BICpkEhu5NrYLFYsLm5icXFRTx58gSffPIJjEajRLR0yNjRmoy7QqGAcrk8cWZ+nfLL9r0myDCSbjQauHfvnuS6eT80Kl/0ep3nHhbG5JjZbBaIhJXRTqdTpjXSa6Ri0bxzLhJwooiouHX9AEN0FkYCp1AcDzoVB7uvkl3CvkPTLVH4b17DtEHjYWCfMcJATNSex7hQNEFBRxncQJzjwohOV7yzhoO/m/aEdIiscyssZmM1OA8qIwpNAZ2GDzVLTifoNTSkCw4JZeiWHby+88CKfG29Xkcmk0G9XhcIlGw4Pkuuk25FNBqNUCwW5TVkD7I2RXuBzP9xPaY7OdBg60Q9WVVkAPJZ0EDk83nJUVgslonBcLu7u6jX6zKHiKwos/lkzPFgcNINmPT+WYXPn/tCQ84Uu90uVH0+8+FwiGKxKL2szGazXDup+3ocAPezJqOUSiWk02kxcITAOEmSMCD3LYdjcQ35DMg2Y3NWndMjdEjdEolEpIiSe4BR4a9bps/n58k0SYbfp3Oc5zlLvy557nkunEnu8XgQjUZhMBiEDhgKhbCysoJqtYp79+7JPHB94MhzJ0zF2grtqbFGgkOX8vm8FPNxU1LxkXbs8/mkII4eiq7y1f9+VoKc0QCvk9EQaZi6sn4W0dEaI4HpjVIsFoVSyQPg9Xrl8LIOQXcm1htM/5sH2GazSbtuMqn6/T6KxSL6/b4oxNFoNMEaI7atG35q/Jv1IG63G8vLy3A4HDg8PMTx8bHQmZk74oGhcphFGAUdHh4inU5LFOPz+XD16lUZwxsKheQ5c1RCIBBAp9PBgwcPhFDi9/vhdDrhdrsBYKLnFxlPVPDcS3yO7EtmsViEpj43NyfRD58d90wmk8G7774r47LdbjfS6TS2t7dlD+v+Z16vF3NzcwAg5yEUCiESiZyrt5g2GlRYdOqoxKLRKJLJpECao9FJQSrHmHPsdzqdFsIMc0Z81tMtSbj2n376KXK5nCAMLCMoFosoFApCmrFarVhaWoLVapU9RcfPbDYjl8thOBxKVEk4nXBpp9NBJBLBtWvX5DlaLBYcHBz8xiIXrjvlWfAY9aNGU2hgqL/Om/v9dcpzRS7aU9Z1GsBp7ynd/ZieGjnuDLP59zqhrb0eeinT1ltTFaeVlPaSdd8wDRsx2azpxvohafoyw3viwOdNnPH69RrqhDivm50FNByhN+LnXcP0z6ko+aXfb/p1XBNGm9OwGoCJdvk6KqLBme4xp/M+XLvzHApNf6YjQGWmr0m3neHfWiwWgUumSQz63qnY+TtNoNCfQw+ZuTw6RtyX2qHRRae68LhSqQgTj1AjFaWGjnmNPFvnSUYzEuC54Fni8+M687wCp125meMi5KmLcXXvPf18ee/1el36iE0znPTfM8pkBwObzSaGBIDoFv3cdZSkkQddZEznjCjEF0Ex6z31rN/x/OivL0vEQjmzcXG5XBiNTrsix+NxeVg8aMViUQrwDIaTAr1kMikYNzcJvRzCPTRCACQPoYcJkWrKylRdVb6wsDDhrRoMBrjdbsn3tFotWCwWybMYjSdDx8rlMnK5nFT789DoeQ+6BoS1FLM+WCpaesWsMdARkzyU/wc5Em4kZMCDwar36Y2m/+12uxGPxxGPxwWm1IVxHBpGiK1QKODevXuSCGfyXbO9tDfLrtbVahXFYlEMMp0FnV/RnvKsEo/HJXnv9XpRqVRwdHSERqOBO3fuIJVKSZ6EmLvJZJK8gPaKmS9JpVI4ODiQ5K/BYMDly5fhdrsFrioWi1L5TwVmMpkmFBijo9XVVTgcDmnVw9ykwWDAzZs3MRqd9NpjUSYZb6urq+JZp9NpNBoNFAoFMY5kRLGX26xy48YNAJBEt8/nw/z8PMbjMfb29oRNx2LYVColEFS/38fCwgJu3boFn8+Hy5cvIxgMCrowzUQcjUbY3d3FT37yE2QyGTx9+lTyYSSxHB8fy7mLx+OYn5/HxsaG5GHIoHvw4AF8Ph8uXbokHdT9fj8+/fRTKX6lg0oHqVAo4JNPPoHX68Wbb76JSCSCYrEoDL/zyotgaU2/fjoqITQ9DXU/67VfRDmzceEG5/Aes9ksCX0qHMJbOophSwtSRhni8ZDq6EVHMGzLQhqoLrzS5AC+f71eF0VAOIN0PVYgU+GxL1apVBIqKJWEpmZq73z6QT+v8HXaM5z2uimEDViXM53I1dGAfm8tXHuv1ys5EJ27orKkQmEtRrlclsOqE/e6gwA9RFZVM9qJx+OSyKYnrDsHnKdKnzTSeDwu8NDR0RF6vZ4YFlKHWcjIXArZN1RkbGR4cHCAUqmEdruNcrkMo9Eo7Yh6vZ7AlGSR0YvXNHlGS06nU1oGaXZhp9NBMBjE+vq6QMgki3Q6HTidTgSDQXg8HjGM3J+a1k2Dfp7IhYakWCyiUqlgbm4OL730kjiGTLQz2shkMhMUbL/fL7UsgUBAHCWdKwFO+7RVKhXcvXtXRjHw+hndVatVeR4ejwexWAzr6+tSrgBAkvmsl/P7/Ugmk/D7/djZ2ZnI19L5GQ6HQoohw0633XlWBP88Mh3FvgjRRkV/1/nO6XM/63X/ugzTmY0LL4heBZOmo9FIQllGN/1+H9VqVUJ8trtgMk1HBPw3q5ABSCKWFGPCEMFgUCpWmXOpVCpy+HSHXNKf2WXZ5/NNhMYa7iDlM5fLSVNL3S5EM4XO82D0BtHQGw8nKdlMuNMoTMt0ovlZwiI11hYxauMm5n0z8mCBXKVSmYASCfXoRL9mgfH9SBG9evUqUqmU5HReVChPqCqfz4uCZvX7YDBApVJBNBrF9evXUa/X8fjxYwwGA4FEaPD4LJvNJtxuN9bW1iRyGY1GKJVKeP/997G/vy8thRi5aTo1FSVnB7lcrgkYjGxKOgZs3ZHL5eTfnI4KnNbx0Nisrq7CarVKhMT813nWkSPCmZdIp9OC5efzecnBLS0tIZ/PY2trC+PxWFiM8/PzAE4hbe7facVHsog+75xh7/f7EQgE0O12ZUia3W6H1WpFq9VCuVyWNeb+Z67O7XbD4XBIpT/b9dC4jMdj+R1f3+/3sb+/j9FohL29Pen7dh45a3L+F4k2UNybbM+kIVINMWsYfZbP/3VHO8811JxQVygUkqry4XAIl8slXr/dbker1ZI23ewYS2+InHcydhgx6JYR5LMHAgG4XC45ZJFIRIoaGb4z2e/1emUULj1HFmmSY8/r5Gb3er3odrvSVuHx48fY399HPB7HzZs3pVuAxWKZYGrMIrw3naOgQeXvdNKOB2raeOi8Ez2bZwkTpuwuoI2LFlJPU6kUMpmM5A/0pue/NbbNiIXXZDKZsLGxgW9961v49NNP8fHHH5+LADEtvN9UKoVSqYRAICCDz8i2unHjBn7/939fpkXW63UhLNApAiC1Oj6fD7FYbIIZ973vfQ+ffPKJQLWaHktPvdfroVQqwWg0YmFhQeouCBUyh8K6IbaZGY1GAn1FIhHpJkxSACPKeDyO69evTzSMPDg4kLHis8r29jaA0z2YyWTw4YcfTnj2hLxcLhd+9rOfYTQa4cqVK3jjjTfkvDKy1eOLtVfMbgKEuA0GgzQWXV9fx/r6OlKpFN555x00m01pD8UO6ISECbmTCs4u5oeHh2KYVldXMRwOZd9y3Sn9fh+PHj3C/v6+OFIvIqH/IhQ1zzJh8FgsBrPZjGw2KxEzoXCuw+dFL9M/+yLAZ89tXPSm0tEHfw+cDudieE+GiU4a0hMl1DDt4fKzpj13KmNNhdVeNX9PCu54PJZDyvfiIXG5XBP1IQ6HQ2Zd6C4BhP3OA0lMryM/U7+vDod/WfL+Fx0Qrh0PLXAKa2m2EQ0EqaD0aOk5PYuZMh260zmg53l8fIxmswmfzwej0ThR7HWeja5ZTfx8Phe9JvwZDy0r7Unn1TRpzR4khMX/6whER3rcQ16vV7xNTckHIPCrw+GQQkQ6JyTCMGLRMC7PFQCpb2Fk8Kzc3PMKoyNd36XPBHulccYL9wzJCRq2Zr4UgEDIvE6WBxCmJKxNKLVcLqPT6YgRCYVCCIfDsNlsEhFS4QYCAcTjcXg8Hhk/wLkzOpfHvWq1WsXx1df1LILMF000DPZ5udRnyRc1F3Nm48LqV62AWWGr61eAk8Iw4rX1eh37+/tCXeahp+LhJtF1JDqiofLQ3qXVapW225yPYTAYpFsvvZ5oNCoMmVarJTg2cDJ2OJFIyLUaDAZsbGzg+vXrE7UbbLpHb21Wr0cbTeZwyMDRxnH675/1PkwSP+tv6EVyTk0kEhFYRdcw8POYe8rn81Ldro3KNONrmuGmCRH37t3D3bt3EQgE8Prrr2M0GuH27dvIZDLnpnLn83m5ZnrBHD3AfFKtVsPe3p7UYtjtdmSzWdy+fRt+vx+JREKG21mtVnF6ut0uSqWStG53Op3SroQsMxoqTkB8+eWXpaO00+mE3+9HMBgEAOm4wNb97XYbpVIJ/X5fYF0+E7ZboQGikfvkk0+ket3hcKBer59r/wGn/dlIXGE9jclkknqVYrGIn/70p6hWq8KmPD4+xr179xAMBrG0tCTnTueYeF4HgwEODg6wv7+P+/fv4+HDh9Kuha13Hj58CLfbjZWVFbjdbly7dg3JZBJHR0d48OAB/H4/Xn/9dSQSCXzta19DMBhErVbDgwcPZC0Z6enaHYPBID3bOArBaDQiHA5Lnk4bzV+nTJ/X6ShDk2Smx3toKFvDaZRpZuEXRZ6Lisw8Aem503URumiKCU32GdO0WF3zwYOoMXzgNHTX3wGIB0ecm94eX8+/Z70CaxzYcE9TF3k9fPBsyTF9L9ownKfOQAs/g5/zPF7pL4sCaMBYhMo8mMVikc/k8yFhQndb1c/0F3lR+nM4FKtYLGJ1dVWIBPROGdLPuvlZZ0Ks32g0iiGkAWSUQqVoMJw0oSTEQKYhnRHm5dh3jJRhwpHtdlsiFzoEhAzJWuOICN3lm3tM91djTQkVux6ZrCFljo3gYDLdIfi8cA73Gq9H5z91pMdWI/x71rdo8o6+Nk1XZ2RRLBZlng1hSMJXfF/OGQqFQgiFQgJxk65NRyAej2M4HEokRMPH3oGaXs65NMyRMTJkFK+jr9+0TCfxubeeRTt+1rnR9/EiyQUvSp6LLTYejyXByRCa0QQPDkeMhsNh+P1+GRlLD4hwgdlslkl4PLTcmPQuuCHYNoKeSjAYRCKREFKBzlvoELjb7QpNNhAITFBBiQ0zmauTuhz/qg8z512cd2PSgyPMY7FYkEgk4PF4pKcVgM/Ahrw3AJ8xwDqc5u9LpRLu3LmDubk5rK+vw+VyIZvNCrX73r17qFar2N7elqhlNBrJvB2r1SrECCZn9TrrhC4PPed0lMtlfPTRRzCZTkZZT1NVZxHdagXARO0Fr6VcLuP27dvSWwwA1tfXEQ6H0e/3sbOzM+EBxmIxmSnCqv98Pi9JYSpBJpipPEkOYRcIRrZ0XiqVCnq93sT7UGGSFk3P2mQyoVgsSpPNV199Ffl8Hg8fPpT3ZH6Ro7JnlY2NDQCYyIe0222YTCfD+Ugl57lino20eU72rNfrMqOJua1OpyPR39HRkZBE2PWcThoNWTgcxssvvwyfz4ejoyPcv39fWuU0Gg384Ac/gNPpRDqdRjablX3IZ02ngt2jdQEn+7HRCQ4EAhOzil5EzuV55ZdB3CwJAE4jl7O8nr/7RZHRi5BZjNeZjQtZW6xAJquBh4lDwpjHYNVuIBCAx+NBoVDA9vY2RqPRBCzBNhrcPGzVT2yaEBi7pQ6HQ6EfT0+xY06HQozX4/FId9Hj42NJ9BeLRYGZCJ3xILPlt45WzmNc+DrOBqGYTCZEo1HEYjEYDAap0NdUXv0e+gETJ9e5CADCmnn69ClarRZKpRIikQiOjo5wdHSEnZ0d/PVf/7XAC7q9v91uF5opW3zQm9T5IT4fHnBdsFqr1fDw4UMYDAZRwuc1ynqmPKNUtvdhjqxeryObzYqCYf7C7/cjn8/j8PBQBnH1+328+uqriMVi6Pf7MpSNa0JKPXBaQEoHi8lv0vHpjTM6oRFPp9PIZDISRTPaZ1fbdDotTpfVasW3vvUtXLt2DXt7e9jd3RW2FUsAzmtcVlZWMBqdVNzTWSAzUzsxpF1rokm73UatVhPnzGg86V6Ry+VkoN6TJ08kEiScOD2ThQ6i3+/HlStX4PF48PHHH+O9996T3mqNRgPvv/++ECfK5bIMIOTr6RxOt3OhUdFEIfYuq9VqMp3yiyLaMZwu6v68v3+en78ImTWnc2bjQg9Bd4jlAbRYLBKhcGYINxQ9EYbGDP90yDoejwWy4ftz0U0mk/QRstvtAkNQ8fNwc1657sjLCIghNReKuSJuUkIOhIoMBgNCodDJAplP547zM2cRRm88dFrhtFotYTgBp8lq4DQPo9lm/L9mk01HBlS+1WoVe3t7AIDDw0McHh4ik8lMeP2a/sjnxYT2dFJb00/pXNCwMJLidRsMhonk+XkOgB6+xcFfzKElEgl4vV4cHx9LG3k2RSQLqVwuI51OC/Q3GAyQTqfx+PFj2UOaBUUiApU7aciMXo6OjqSOZjQaifKjgeHv+Nyo8OgMjcdjJJNJWRvux8FgAJvNhsXFRUmMM8nt9XrPtYZ6no7f7xenzGKxYHl5eaKNC++Ze7bRaMgzZr7D6XQik8lIyx8SImiodHKa+4d5KpPJhPv37wu7lJ3KXS6XRH29Xk9QCpYr0JkhwYB0dDo4PP9kvml9wZqxLxJ8pPOYX6TrmpZZru/MxiWbzQql0OVyoV6vS5+g+fl5SQg6nU6BARiJMOdBr5wwA8eZ6ov3+XySC+AGY++l1dVVxONx2Gw28VrocTJ5Tcqp2WxGoVCQw350dCSwHhPQZJNR4adSKRQKBfh8PmxubooyMZlMQgiYdQNwsBpnibhcLiwuLgKAVGVrxs10fybgNPTXBoGGWreooQEvlUro9Xr48Y9/LOOBDw4OJlrf0MDxwPZ6PSE4aMWgc11sNkhohcJDrd9f18Wc5/Ds7e3BbDYjHo9jY2MD2WxW+p698sorWFxcxAcffIBsNgufz4c33ngDfr8fVqsV2WwWu7u7+Oijj9DtdgWWbbVa2NraEg9X54/ImNKFsxwc1+l08NFHH2E0GkmPsvn5eVy/fl1yebVaDaFQCM1mcyJR//TpUxQKBaytreH1118HACEmsFbG5/Ph61//OprNJv7hH/4BqVQKDocDc3Nz54oA79y5A6PRiNXVVSwtLUnjV6fTia997WuYn5+XURd0/ljsyI7EbP6ZzWZht9uRTqeRSqXE8QAwMbtHKyWj0YhIJILLly+j1Wrhf/yP/4HhcCgD4Nh5o9Fo4PDwEI1GA1/96lfx6quvSpEvo9NGo4FwOIz5+Xl0Oh3s7u6i1WpJDz6OUOc8J3YaYD+yL4pMow5fRJn13D7XmGODwSDcfyobnUwjNEUoiZ4wPRqNdzNstdls4mWTQkqlr5O4ug8Sva1p0dfCv6dHz8/XCUB6ZkwQUymPRqOJ+9FFjrMuNOmRHF2rCQqED/h5z2Jl0aN+Fm2ZTRxpBHmwGX2QzFCpVCSXpJ+fbpOuoyYt+rnxGqavkb/X9O7p/NCsonue0YulE8EISe9LRrmEXNnDi+sMnPagY7Ke96ijr+mkKiMNJqjJtqJhZj6S18XX8meMkOnF0xgBp7ODSKflPmcuRMMTs0i73ZZr4D7T783zqeuwCP9xjXiWGWU9q2uFNip8T12QS+eJFHEOGJteJyIFul+dfv6MBvWe1HtUMxz7/b7kNb5IxuUfs5zZuORyOWHf1Ot12Gw2JJNJUcqEnYjDA5AQmi1FWJDIHmGsIM9ms/jwww9lXOzc3Bzcbjc8Hg+GwyESiYQcZLP5ZDjZ2tqa1KEQttKNA4GTjcahQzpxRsXbarVEMVssFnS7XYmuWLypJ2uep+X+jRs3MBwOpXJ8NDrp8AtAYBX9GdNKxO/3Y21tDePxWBKpNALBYBDf/OY34XQ68bOf/QxbW1vyusFggO3tbYFp+Ly4JoTn6DxMy7Ri0Aw/KgG93s866EajUVqGzKocaRDZlcHj8eC3f/u30ev1cOfOHfzoRz8SZpLdbpc+VjR0zHNR6RgMJ2Nkb968iU6nI2Njdf81Mgl1zRM9Xyplwmz37t1Dv9+XnJXZbMbe3h6ePHkCj8eD+fl5GAwnFfhsAQ+cwJflchn1eh3pdFoiGLaL9/v9uHnzJrLZLFKp1LmiPz5DIgo0vN1uF++8846QZRjZr6ysSJ6D1O9UKgUAcq509MBBY9zfNBBM4HNGCWew0JAcHR3h4OAAKysriEQiYrja7TZ2d3cBQAYIDodDRCIRzM3NyV6Y7hLOPPDdu3cl2mYH6/MSS36VwrNz3ij/iyLPlXPRHiuriU0mk9QLaPYW/45sMkIOpA+y5sLv96NUKiGbzaJSqUj7dtI7+T4AxPtgo0BOxqO3p68POKUO6w1Fb4heFb1E7ZkRJiIkpj2hWYV4PJv1kTYLQGatTCtq7fk6HA5Eo1GMRidzSZrNplyP0+kU+u/Dhw8naoOGw6FUk+sOzzpHMu0Z8zO1IqaRoMLQHqlm7Okv/TcsiDvP4SaE2el04Pf7sbq6ikajgbfffht37tyRaJV7TkcQuqCOX36/H4uLi6hWq8hmsxJR6MaqACSXNx6PJW/I/zNXlcvlMBgM4PV6cfXqVWH/HR4eIhwOSy3LdLEkDSbbuzQaDXg8HjlPyWQSHo/nM4WNswjvm04MacSDwUAalm5sbEyQcei0EYalc0ZD7HK5kEgkUK1WpTcZo34dtTKfUigUUCgUZD8bjUYUi0WBEfU+I7RLx4/MQxrATCYjz417nuea9HLmqgjlcj9+0UTvy38scmbjEg6HYTCc9vfRsyEYYrdaLRwcHIi3ZzCc0I7j8fiEF0PYgYep1Wrh6tWrotiz2awMuJqua2CvMCpMABNtWjhUi14lw2BCWswZMblHg0Ka6Nra2oTnSAaZVjazyO3btzEcDiXpDEDID4wmAMi/pz2Xer0uVFrmogBIVfNHH30kLW3eeustZLNZbG9vT1Qv65oi/kzTP6c9Jh50JpuZxNfvMx6P5TloerB2MHj95znYVMwejwfhcBidTgfvvPOOsP50DZau50kkEgiHw7KvSLk1mU5mfzx9+hSNRkPmlbAWJhQK4Z//83+OXq+Hra2tiYJLPh+j8WRstsvlklYyNpsNwWAQZrMZ8/Pz4ljRazabzdIotVgsihJsNBoIBoNYXFwUuGk4HErjSACSvD6vMAekhYywdDotjM7NzU04nU6JCDnNlVE/56tQIbLTdjqdRqlUEoibES5hbp5RTq5kZDsej3H37l2MRiOZE5RIJBCLxVAsFiWHyL51bDo6HA4n8qOsqXI6nQAgMCaZp19Emc5P/WOQM2tLUmV5+BhiE1oxmUzI5XLIZrPCLWeCLhKJSPUzcEqzLZVKqFQqcDgcuHXrFkwmE7a2tpBKpRCLxRCNRqWQitP72BQvk8nIAff7/bK5LBaL9BDjVD9+0YsJh8Mol8uSdGYUQD683W6H3+/HaDRCKpVCrVabKLicRd59910Ap5uIxAODwTDBa6fXppN8BsMJRZmRDjcgo8Bmsymwxj/9p/8Ur7zyCj7++GMcHBxMtEhhx10NX+kmgM8iEFCpE8ahged1UGHSI9a/AyBKXjcUnEW4/qzAfvLkCb73ve8J+4cGkK1Y+MwTiQSuXr0Km80mBoRr3Wg08ODBAzSbTWm9z15kb731Fv7lv/yXaLVa+O///b/j6dOn0tKEz8dsNmNjYwMLCwsIBoMTA756vR6Wl5fhdDpRKpXw9OlTDAYDxGIxeDwejEYj6eVWKBTQ6XSwsbGBl156CZlMBnfu3MFgMBCYlvT+8yofOhnTFe48n+wLePnyZfzxH/8x5ufnsb29jXQ6jWq1OtHXj9FFu92G3+/HpUuXpPaHaAIT6syrcu+zqwHP93g8RiaTwc9//nPY7XZcv35d1jQej2N3dxcPHjxAo9GQcdZ0EI3Gk16BGvbjlFGj0SikIg5c+6JGB1/0xP7zynNPopzG1fkzDUnx8GpYZPo1moUE4DPV/tqTn07S6UTd9PtOX4/+vGlYRP+Or9OkAf5Mv++s8qxCyOcJhTXzavpaCM9wLXSCfvoeP+99f5nSetZ6Pevfv+xzZpVpiI73zAT9562lJptMkw2AyWp1/UXqMfM2+r35XZNHaPymSSv83OnktiYL6AhQR/bTZAn9/UXI9PPQ10JSiybG6DXQ185IVefmpp/bs/YGz5u+V5Is9Ppq8o3+zGnCxbOe/bToz7yQX60Yxv+Y4rALuZALuZAL+ULIFy+zdSEXciEXciFferkwLhdyIRdyIRfywuXCuFzIhVzIhVzIC5cL43IhF3IhF3IhL1wujMuFXMiFXMiFvHC5MC4XciEXciEX8sLlwrhcyIVcyIVcyAuXC+NyIRdyIRdyIS9cLozLhVzIhVzIhbxwuTAuF3IhF3IhF/LC5cK4XMiFXMiFXMgLlwvjciEXciEXciEvXC6My4VcyIVcyIW8cDlzy/3/7//7/zAYDHDnzh08ffoUsVgM165dg8ViQb1eR7fbRb/fR7fbhd1uRyKRgM1mk3bYvV4P7XZbJtw5HA7s7Oxge3sbBoNBZttzQh7nv3PynNVqxdHREVKpFJaXl/FHf/RH8Pl8MpVRT5aMxWKw2+3Y39/H0dGRDIMaj8eIRqNwu92oVqsolUrw+Xx4/fXX4fF48Pd///f4yU9+InMu7HY7Ll26hGg0ikwmg4ODA4zHY/z5n//5cy/0n/3Zn8FgMCAYDMpkPK/XKzNj6vW6TNhzOp2yfvl8HpVKRWZk6HEGbD3OmfFmsxmxWAw+n09GwHIQk8lkwttvv42///u/x/z8PH7nd35HxvHq0cd2ux1LS0twOp0ol8uoVqswGAzyd5yp/vjxY3z00UcwmUyYm5uD3W5HvV6XoWOj0QgWiwULCwvw+/2o1WoolUoYj8f4N//m3zz3+v37f//vZQAUZ9jk83lYLBbcvHkT0WhUWvBnMhm8/fbbaDQa+K3f+i3cuHEDOzs7+OlPfwqTyYRbt24hGo1iZ2cHT58+lf1ntVoRiUTg9Xpllg2naHJuO/c0h1/duXMHR0dHuHr1Kr7xjW+g3+/j/v37KJfL2Nvbw+HhITY2NvCHf/iH8Pv9aLfb6Pf7uHfvHn72s5/B4XDg5Zdfhs/nQ6/XQ7/fx9bWFv7hH/4BAPBP/sk/wfr6ukyzNBqN+M53vvPc6wcA//W//lcMh0Pcvn0bjx8/RjQaxaVLl+B0OhGLxWQ4Hwer/eAHP0CtVsPly5exuLiIfD6Pra0tGcttsVhkVHm9Xsf29jZ6vR7m5+dl8NlLL72EZrOJf/iHf0A6nUY8HkcikUCv15NZNYlEAn6/H3t7ezKaeGFhAU6nE/1+X4aXrayswGw2o1qtot1uo16vo1QqodVqYX9/H51OB+vr61heXpb5MUajEdFoFC6XC+VyGYVCAePxGH/2Z3820/pxWF+j0UAkEsHGxoYMfmu1WggEAgiFQjLMbDgcypypo6MjfPrppzAYDFhdXZVnzhlIHMcQCoVkqGEwGES/35fR5rlcDvl8Hn6/X4a58Uw2Gg2USiXYbDYsLi7C6XSi0WjIHC3gZLQJx2zfuXMH77zzjug5t9uNTCYj46R7vR5sNhtu3LiBeDyOcrmMfD6P8XiMf/2v//UvXa8zG5eHDx9iPB6j2+0iEAjI7HKLxSIPr9VqoVwuw+FwyE232230ej1ZKIPBgEajgUqlgnq9LsOLKpUKxuMxgsEgPB4PhsMh3G43+v0+jo6O0Ol04HQ6sbKyAqvVip/+9Kew2WyyMbPZLHZ3d2E0GmXgF+eZG41GlEolmRXR7XZRKBTw5MkThEIhrK2tiSL8rd/6LdRqNaTTaRiNRng8Hni9XlHis84kyefzcu82mw0ulwvhcFgOaCgUkjksnOBnsVjQbDaRyWQmZmVwYJrf70cgEMBoNJIRuPv7++j1evB6vaKMaIQSiQTefPNNeL1eGaTE961Wq8jlcrBarej3+zIlU4/9HY1G2NnZQa1Wk2FNnMKoJ3x2u11Uq1WYTCa43W54vV70+32ZdzKL+P1+AJBJqJ1OB9lsFgBkIJfNZhMn5caNG+j1erDb7Uin0+j1elhaWgJwMvAsm83C7Xbj1q1b6HQ6cmhisRjm5uYwHo9l1gvntJfLZdnf4XAYJpMJLpcLy8vL6Pf7eO+992TaYSKRQLPZRCqVgtVqRSgUQiAQkD14fHwMh8OBwWCA27dvTzynbreLubk52Gw2GYSn721W4dpHIhGMx2PYbDYMh0P0+32YTCZYrVbk83lks1kYDAbcvHkTwMlQtf39fTQaDZlv43K54HQ60el0kE6nYbFYcPny5YmBbV6vVwbNJZNJuX6egeXlZRnuZ7VakUwmZaZNPB6Hw+GYGCioZzhxxLLJZEK/34fdbke/34fD4UC73ZappTxLNpsNbrf7XNMey+UyxuOxrEG1WsW9e/dgsVgQDodlPHSj0RB9YjAYsLe3h6OjIwyHQ6ytrcm+4XdeF8eHdzod9Ho9cXD4dwDQbrfR6XRkqB0Hr3FMeqPRgNFolHHcw+FQhhxy9HShUECv10O9XofP55P9ZbFYEAqF4HK50G63USqVxMmmnnqeeUJnNi57e3syttjr9aJcLmN3dxcWiwVer1dGsNbrdfT7fXi9XvR6PdRqNbRaLcTjcXg8HozHY5RKJdTrdbRaLQBAv99HsVjEaDRCIBCAy+WSDVCv15HP51EoFHD58mXMzc2hWq3i7t27GI/HeOuttxAOh1Gr1fDo0SOMRiMEg0E4HA5sbm5ibW1NvAduzn6/j3K5jP39fYkIOKY2Go0ilUrJRuJIZw7hmnVjVioVABBvzefzYTgcwuVyydzyXq8ns8npjXQ6HRSLRTgcDvj9/olRww6HA3Nzc+h0OjJ69vj4GLlcDmtra3J4m80m+v2+GF2TyTShqAwGA1qtFjKZjGxATgr0er0AIFFlKpXC4eGhTHoEAJfLBb/fD6fTicFggHq9jk6nI/vF6XTKiNxZ18/tdsskVJfLhWw2i1KpJAqlXq8jEAggGAzCYrFgfX0dRqMRhUIB+XweJpNJxm1zvPbCwgKWlpZkzHCv10MoFMLCwoJM3Gy328jlcqjVatjd3cXW1pZMXeR9B4NBZLNZ3LlzR34Xj8clKuLBpCMwHo/FaHQ6Hezu7sroa+6NhYUFuN1uuN1uGd9stVrPZVzoGPn9flHGnU5HlKXZbEalUhGn61vf+hY8Hg/ee+89bG9vy1RRRnNutxuNRgP5fB7hcBirq6vweDyCPuhzE41GxViUy2VxDB0Oh1yX2WyG2+2WCJJTUDlZkvdAD5/KdTwew+v1YjAYoNFoTEyntFgsEpVy7PGswrNLhd9sNpFOp8V58Hg8smeIIlgsFpmuGwwGsbS0BJPJJCPYbTYbHA6HjGLmyPFOpwOv1wuLxQIAYlydTidcLpcYcBpzu92ObrcrU345ilwPy+P4b6I2HOvNyMpkMomOoR7X02hpxM4qzzXmGDgdW0ujwodnNptlap3dbkc4HJaNQyv54MEDGXmqp/6ZzWaEQiEAJ95VpVKRg2symWQTMpLp9/ti6VOpFIbDIUqlklxPPB6X13MELyEHp9MpD/7mzZtwOp3odrvI5/OwWq2w2WwYjUZwOByyQQkRHR8fzxy5zM3NyQGmNxcKhcRY8yCOx+OJ6Xw8nMCJETYYDPD5fPJzjii22WwnD/T/3S894H6/j1qtJpu+0+lMPCsaTH0YGYXQEA2HQ9RqNVm/WCyGdruNZrMp0xq73a54h1Qu4/EY7XYbrVYLg8FAZqnPIrlcbuL//X4f169fF4WSz+dhs9kQjUZlbXmPDodDorDRaCTRGWe4j8dj1Go1tNttZLNZGZlLY0jDFggEZBQ2RxjTIajX6zK2+OnTp6hUKmi1WvD5fABOnLNisYh6vS6R+qVLl1Cv12G322XsMD+TKEGn05G1bjQa55pEyYmRdKgYNZjNZol8Acj5qVar6HQ6sFgsmJubkzXhWvb7fbhcLiwsLMBut6NWq6HX6yEYDAoUWy6X5bxbLBaBZOx2u+iGXq+HwWCAUqmETCYj55Pv2Wq1JiLoRqOBWq0miplwrc1mE8drNBqhUqnAZDKJcRqNRuIQzSKhUEgcVOotIjRerxcOh0OmkjocDgAQCDEcDsPv98PlcgliwDPBKZ9cEz4HAILu0OAQTbHb7ej1erJXGMnv7+/DZDIhmUyKrqNBoM6kLmQESuNCp9ZisQgCAZyONj/LxFotZzYuV69exWg0QjqdFk86kUjIDGwqIxqdjY0NmRVOj/rBgwcwm8146aWXEA6HxVA5HA4sLCzAaDTi+PgYR0dHWFxcxKVLlwCcWO1WqyVeSbvdlgjk9u3bGA6HiMfj4jldunRJ5tPzq91uo9vtShh4+fJlfPWrX0Wr1cLOzg4ymQyi0ajMKQ+FQjCZTAJnPHnyBJ9++unMm/O1114TT95mswkMYTabxRBT0fE7jTg3HZX56uqqRI/Hx8ewWq0IBoPi0XDj1mo1mU3earVkvZk30BGSyWRCJBIRj1J7eYTmhsMhgsEgEokESqUSstkszGYzut2uRA6JRELw7l6vh1KpJAeGRnIWefToEQAgk8mgVCrh9ddfx7/6V/8Ko9EI//E//kc8fvwYTqcTm5ub8Pl8WF1dFaeAcE6/3xcsmetAz/f4+Fg8at5LMpmEyWRCNBqVscr9fh/z8/P42te+BofDgdu3b+Pg4ACZTAYPHz6ExWJBr9eD3++H2+1GMpkEALz77rsYjUbY399HuVzGm2++iX/2z/4Z+v0+Hj9+jEajIVDT4eEhfvazn6HT6Qi8CDx7fPfzCPMXxWJRog1CUYVCAa1WC+FwGDdu3EC328XR0RH6/T4ikQjm5ubg8XgQjUbR6XTwwQcfIJ/PIxaLIZFISM5lOBzirbfewsbGBtLpNB4/fozRaASPxwObzSb7tN/vo9lsyj222208ffoUH3zwAQwGA+bn5+FyueD1euF2uyVaAoBsNouDgwOEw2FxPIPBoDhYRFCYZ/X7/ROKf1ZZXl4WR6TZbMLpdCIcDkvkohEXwpyj0QiRSEScbo/HAwDicOmx2jxzPJcA5NxVKhWBuxOJhCAENHIGgwE7Ozv46KOPxJkKh8Nwu91iYAmBtlotiVrohNEQcb1brZY4rtVqFXa7XSLGs8qZjYteBIZZVExcSHrTVFb8ncb2eYH0rvv9voSs9Oj5uuFwKMlkeiX8++n3YLjO5DS9NFr1ZrMpnjzvw2q1yut4gPV98L2omGjxZxFuHCak9ToCEG+Fa0TPguE/11/j79rL1dAC8ykkOnB9pufEU+lTYXHdeb/8ea/XE+NEz8tqtQpurJUfn4ueb64P3KzCCIoYMNeAB5QeMD2uXq83kZCnN6s9r+n59YQraGS4NvwM/p95QuL9PLjcd/V6XdbI7XYDgODolUoFxWIR7XZbFJ3FYpmAvnivfAYmkwmj0QjtdvtcxsVut8sa8nxyv2mCCO+DcCtzZyQ28O/7/b7kPogm0LFgxNHr9eTzuTd4D/w8EoEYpRkMBoF49P7U0XCz2YTX65VohpE6r39671AB83zPun68b0JUhKd4DRRGnkQiSIAg7My14PXrnMj0c2DuT+9f7kH+zmg0SiQzGo3Q6XTQarXkfOqohefD5XKJDuea8BxoyJxffI+zypmNC1kOXq8X4XBYIBDgNC9Cz9ZutwvDiYyvpaUlrK2tyUKOx2Nks1kcHR0hkUggEonA5/PB7XZjfn4e3W4XT548EWiITKvl5WXkcjkUi0X5GQ9no9FAu92WcJiK/ODgAB9//LEklc1mM1qtlkBhzE1QMRmNRoFCCoUCqtUqyuWyKKtZhJafYadWGplMBoPBYAJDzmazEtWtra2JgSUEwGvkhiEzJRqNIhaLoVAo4P79+wBOwnkyb6gsgNMwmRuZh/rRo0cYDoeSc6lUKtjb2xOv3+v1wuv1YnNzE8CpYRwOhyiXy2i322L8mLCk8pg157K5uSlMGp/PB6PRiL29PdRqNdRqNYxGI+RyOdy9exderxfFYhEulwsrKyuIx+OCZfd6PeTzebTbbfj9fsGYNzc3BV579OgRBoMB5ubmMBqN8OTJEyGgkBFXrVZhNpvFaJlMJszPz8salctlgVl1jqvf76PdbqNQKGB7exuDwQCHh4eo1+uiqFKpFAqFAoxGI/x+P5aXl1GpVJBKpWZePwC4du0ahsOhEEi08vb7/fB4PGg0Grh7964YF157NBpFuVzGRx99JEgE4Srm5QKBABqNBn7+85/jpz/9qeQxqcCAk6R4Op2WyH08HqPZbAr84/f7YbVakUgk4PV64fP5hL13fHyMTqeDo6MjHB0dIRwOIxaLYTgcYm9vD61Wa2J9mLdZWVmB3+9HqVRCPp+fGZrlffr9/gk9MBqNhDCkHRYaskgkIgy5drstBpXOIp0kQqbZbFb0G5U9ERfuLeazB4OBGHyLxYIrV65gOBwin88jl8vB7/fD5/MJu1GfUa/Xi2g0CgAT0T0dW76OxCHqwbPuwTMbl1wuJ1RQfoVCIcHjmURj8oyJQkYGPp8P8/PzAE6YU8R4CUE4nU7Bp51OJ7LZLFKplNBjLRYLbDYbIpGIUOR6vR7cbrckknnQCcV4vV54PB5hwOhkMx++x+PBysoKvF4v8vm8JKK58emx06OiYn5eoXegPRV6C8RTickyj0AF73a7hWEGQDYJk3nj8RjlchmDwUCotLVaTRhqfr9foDZGbQDEM9LeyXA4FM+av6vX66hUKsLg42YnBt1sNsWz4nNnFERvnAZoVq+R0MLGxgYWFxeRyWRw//59lEol8Y5brRYKhQKazSaAE6JBLBaTtWcCu16vC8HAbrcDgOS/MpkMisUiotGoHLZMJiPGnvdIB8bn80mkSFZcp9ORSEVHgAAmoAk+M54f5sOq1SparZYoHj5P7olZJRwOSwREj5fers1mg8FgQKVSQS6XE++ahsHpdCKfz+P4+BjNZnMiKtHRdLfbxc7ODlKpFFZXVxGLxWS/G41GtNttMbxkAHLNxuOxRKVutxsejwdutxsul0vyWs1mE7VaTSAht9stDiWZfLxmQvWhUAjhcBiDwUCM9ixitVonoG06Crz+Vqs1gQrQkQuHw5JT5d/wLNJ4M5nf6/XEeQEgCXWPxzMR0Xa7XYHWuL5WqxXhcBjdbhf7+/sTJRqaMMBkPaMvAKKPdYROaI5OOo3fWY3zmY1LPB4HcEKF293dFSXGg0PFNBgMZBGZ0Mvn8+KZc4EsFgs2NjYmaiTIXSfVliQCwkPEgUlN5GczfGfSiZs+GAwiEAhMJNhWV1cRCoXQarVECT158kS84lgshmq1iv39fdkcVLw+n29mz5EPkw/R7XYjGo0KDs0QN5fLSRLaaDSi1WoJ5slEPjcna4bMZrNELtxwADA/Py95IxpgTYag8ddwZ6fTEUiD3uZgMJAc1NLSEoLBoJAlBoOBKFJGkIFAAFevXsV4PJbQu9FooFAozOw1hkIhMXTb29tST6OZS9FoFMvLyxgMBkJTZlK4Vqshk8kIRs28EyGWfD6PVqsFi8WCWCwm98fPMBqNosBIb3U4HJifn8fc3Jx4p9x/4/EYyWQSyWQS1WoVOzs7aDQaQpHlWrNOSLPYWAtCJbizs4PRaCTnYVZpNBoYj8eihCqVipxNKig+dyqjXq+H3d1dDIdDHB4e4v79+xgOhwiHw1Lf8vDhQzSbTYlmSDBhUr3T6ci6p9NppFIpUYY0+tqR01AQvf16vY6DgwMhGCSTSYRCIYH6NCRZrVbh9/uFFFCpVNBsNiUXNqswMc6zo8k2AIQwQIeC8CPzhDwrNFBEMAi90jEiYsF8Kx1r0p+nIxdtvJmiIImBrE/mQI1GI1ZXV+FyuUT3djqdCZYdcAIlrqysiINIxycQCLz4yGV+fh6j0Qjb29tIpVLo9/tYXl6eoJfSqpLdwPqSXC4nyofeNkO4hYUFlEol3L59WzyTTqeDcDgsSX6GkPSqBoOBsDRIaSYbSltestDm5+fxjW98Y4KZUSwWkcvlUKlUcOfOHTSbTXzzm9/E1atX5UFrqh4jgFmF+Gu5XEa9XkcikcD8/Lx4fSRLHB8fw+VyYW1tDVarFcViEel0WuqIiKHSGIbDYTm09HqoEFdWVmAymYRFx0PLvMJgMJBNR8NAY0aYggyxaDQKp9OJ1dVVcTRopFqtlnDvSVBYXl4GcKLQut0uUqmUPLtZJBaLYTQa4fj4GHt7e3KQ6KH6/X4kEglsbGygUCjgwYMHkig+OjqSSMFqtWJjY0MOCT3hTCaDdrsNt9stURkjLq53pVLB7u6uOASsgVpdXZ3ApRldrKysYGFhAU+ePJGkPZOmZrNZ9tfS0hJsNhu2t7fRarUwNzeH119/HePxGD/+8Y/x6NEjLCwsYHV1debIGQBqtRoASGTQ6XSEkkohq4uGdzAY4MmTJzg+PkYqlcLdu3dhsVjw5ptvwuPxoFKpIJvNSlEkFS+hHtYfDYdDmM1mHB4eCuza6/UENvJ6vROsQr5Pp9MBABSLRWxtbaHX6yEejyMcDiMSicDlcsl6E5lotVpCNLJarcjlcmg0GggGg1KfNIvQk+ee5jrSyeU9dTodybeZTKYJmJPsrcXFRTEu1HHZbBa1Wg12u13IHYTgmP+t1Wo4PDyUSE7nkGiQLRYLIpGIOF3BYFAgXaPRiMuXL2NhYUGuhaSKWq0m7+V0OnH58mWJZkmvDofDZ16vMxsXhlea8ZBKpcQDI2RGOiXDLZvNJgkvKlgmBslCarfbUrTHMJNGinQ5euwARAGSpcRDoBNeesFNJpMUVJXLZWFL8P11wpx0SlI0CfMxkTxr5EIqJOnZRqNR6KA6Ic4QVCfZicXzs8ky4+Glx2GxWMRz0kk5bmoKPSVixMCp10XlQo+wXq9PJPu4pkxk93q9iRoEhuK66IvXR1hmFjk8PBQHo16vS8Q1GAzgcDgQjUZhMpmkhspms8Hj8UjSVRNQqDwdDofsC2L9fB6NRgPb29tSEErvW6+B9qxZD6UToZowwtxOIBDAcDiE1+sVL5yRNZ/RcDhEs9mU/RCJRERRnSehz/ORy+XQbrdRrVbFI+52u2L49T7jZ9JgLCwswGKxCBTodrulqJoUb0LPwEl9F88OIVyiF/wcwkoGgwEej0fWTRMYSKQhFZdGghAu6b6MkomG8Nzwe7fbnXkNec2EVgmpavqwrguhM0unmhEzKdTMx3FNWKRIFIbvx/wxc7Q6utMwqYahuZc1DMo8KKHHfr8ve5vIDvXU9L6hHtV65JfJmf+Sm4UJ40wmg7/9278FcJIojEQiSCaTQtejkWCYRzqd1WpFIBAQT21/fx/RaBRf/epXZUMcHh5KFbbZbBYaJI3C3t4ebt++jWKxKGE3jR4hJYb2jUYDPp8PiUQCBoMB9+/fx9OnT+F0OsWDXFxclA1+7949mEwmrK6ufiY3ch4JBoMAMFFs+vDhQyEl0IAsLy+Lgur3+xPFiUy0BQIBuN1u7O/v4+7du4L90/trNpswmUxSoc4NRaNtMBgkL0Dh/TOBx1YQR0dHiMfjUm3c7XalzoAkB1LSC4UC9vb2JIc2Ho9xeHgotNdvfOMbM+Pdf/EXfyHKx+FwoNFoIJvNwmKx4Ctf+QoSiQR2dnbw7rvvyjXZ7XbE43EpzA0GgxgOh9ISKB6P49q1awKz1ut1FAoF1Go1bG9v49NPPxVcnxRjwpVcr1wuB6/Xi8XFRaytrcFms4kiaDabkr+4ceOGwEkulwtbW1tCbXc6nbIHDAaDVH6zjce1a9cE0z9PQp9OwTvvvIMPPvgAi4uLePPNN2E2m6W9CNlERqNROmrQ8VpeXsa3v/1tAJAODRsbG7h27Rra7TbS6TRarRa2traQyWSQz+fx9OlTcdCCwaAYB0LXNKTtdltgTQCShyL9Xne2uHTpElZWVlAoFPDee+/B4XAI9ZytWRqNBra2tmAwGLC8vIxYLCYdE2ZdQyIjRBicTicCgYCcNQBiSHnmuI5EbLxer+SbCM1S8W9ubooOSqfTouTtdjvW1tbgdrvFQWBtmUYCvF4vYrEYrFarGOler4dUKgWbzSbwOHO7qVQK29vbAs0SCaLOpq5gnQsJKmfVh2c3Qzj1gKm48/k8AIiVZcsHXahDGIdeJqEDAJIYJc2R0QIXkCEjq7xpORlyk1rMqna+P3BKq+V1E9oiFMT/s5CMi1mv1wVmIZREj/U8RoaeE702GsrhcCj3Ro+GHhY3F70bjeXSu6MHpQtG9eHRyXpNC6do6jO9Qx31sMCNr9f0UXqbmpdPmuM0bTQajcpBnEV0ItZgMEgfJToSJINUKhU4nU5pH8KKZq/XKz2fcrmcJKvdbjeGw6HkswjLdrtdKZqNxWJSw8AoTVMzuW5ULNzH3J80ikbjSZ8rj8eDbDb7GXq/9tJp8JgjpBN1HuNCw1Eul5FKpSRaI4NR7ws+VxpSRqNsjUNqP4k9rCNjxKjZdAAm1oIeP4XrQA99PB4L5EOHimeHUZPH45Gi1NFoJDAUz8dgMJCcKnUIIeBZ15B7v9vtSoTOqJj6ivpOlwlQz5C+z2iVOot/w31DHUidyToVQmB8LtMEHcJcOnKhfuTn67o2RjWMplhQznPNqIjXopm7Z5EzG5fFxUUMh0Pcu3dPEqoABIppt9toNBool8uoVCq4ffs2qtWqJNMcDgd8Ph8sFotAWuFwGHNzc1KhTj49C/XW19eltQGFOYSrV69ibm5uouqZ7WTYOysWi2FxcVEKI41GI65fv45kMjmhFGhAstksCoWCKFIm2HXjt1mF4WYul0OpVAIA8Qzp4RCyqdfrePz48QSDgwVPTGozOReNRifYX6FQSLwjhrrsj8U+YDQEVBrj8VgagLJeZDQawel0YnFxEdFoVKKZ6b5RZADRs5mfn4fZbBZGCiNYQgqzHuyXX34ZwCk0QS9bM5yYk+p2u9jb25NOETpiGY9P+texI8STJ08wHJ4UVDKiTiQS6HQ6ePjwoVx/tVqFz+eTvlyst1pdXcXm5ibC4bAcOiZh6WlyfYbDIQqFAsrlMkajEdbX12Gz2VCtVsUZYx5ja2sLdrsdly9fhtPpnDjgs8rHH38sCury5cuIRqNyf9yH9Hr57DSDi+eKypyV/SxW5L2zWen8/Ly00qnVatjb20M0GsXLL7+MXC4nlFhG4uyxxQpz7lH2DtOKt1qtCjEGOOl9aDabsb6+jtXVVQDAnTt3AECKP3X+dhahASatl84noS/Sq9lTcXd3V1h1JChx35FcMd2VgQl3wn505MmQC4VCiEajKJVKePDggeR36LQxx8X8J2FPpib4OWTKEmmiU0gEqNPpiHOlW+c8T5eIMxsXUoDL5TLu3r07kY+gNWdVZz6fx71794RTTqVHxhHrUTY2NrC5uSlKlZuIPPy5uTl5f51LodILBoNwu93SSJGeCrH0QCAgeDVfv7KygpWVFZTL5QnK5Wg0EkYThRg/u/mehwbKjUiohOwmjWFyM/X7J806i8WiGBd2O2aNDlkifr9frm08HktLE0II7AfWarUkSciNpvMspCkyQT8cDiWCC4VCQvmmUmFuiNAj6yd09TU3rC4Km1U5rq2tYTQaoVwuo1ariTcHQKjS3W5XIAp2DxgMBtLNgD3GSD2vVCo4OjqStiTcNwBwfHwskVa1WpXebPF4XLxiwm6Li4sCF9BLdTgcYrz5bNmKhwWY8/PzE9Ed8xr9fh/7+/tS/MmEuD4Hs8jW1pbsRfYuI7TC66bnzWuiwePzJ2pA77fb7aJYLIrXzD5i4XAY7XYbc3NzqFQqeOedd5DJZDA/Pz9BTCAsyCp6rhUJFWTQ0YOnx01Kr9PpFKh8OBxiaWkJ8XgcxWJRlCj78ukk+CyikQHmHKnfqMPYSJINPcnoopEGIBEyyTKMihmFJBIJJJNJiSYajQY+/PBDVCoVJJNJJBIJZLNZpNNpNBoNOZfsPM59p/Mrur6QXw6HA/F4XIgdLO2IRCJSSzgYDKRjB8lAZ16vs/7h1taWUIjX1taExkoowGq1otFoYG9vD81mU7xA0hkZshJzJUthd3dXQj3mZVir8uDBAwkhdRg4GAyk+R4ZFnwouqaBXG2+np4LDyrfEzit+WAUVqlUYDAYpJGeTtrNIjS0xLN5QHgoTSaTkBMqlYocJib9fD7fhHEh80PDYPoaNYzFzUXaJOEHFlS1Wi2B6WgQaCx03QANIQ8B+xsR3iNhg6wZGijmwbj2swijFBo7eqD0+EmXZuuKo6MjgVp4IHgtDPl5uHi9JHIQ2iI7kFFiv98XeE7Dr6zxIAuS70cvnF4/c4qEd0juoIKnwrVYLLK/6dXqSGJWWV9fF2PG/Fo2m/2M5826KgBCmODz53kke1D3y9LFudMKPB6Pi2Gg46SdFBJ/+Bn6/5pQor1mGnMy8Ojhb21toVgsSoKcPycEPesaEqpmzoT5F/ZeYy6JcClhR0YuJJgQMuX+0BCrjmYI4xOS5L/pSJENR71F+E+3wWEdDfcb4TieQ01wofPLfCHRFOrO54W0z2xcfvzjH8NoNCIWi+HrX/86arUajo+PAUCUUKFQwMOHD+FwOLC4uAir1SrUW14kvRK32410Oo379+9PRCXELff39/H48WOhE3OB6GXSk71z5w4ymQzm5uZw5coVDAYDgUhoHPhaJqdYF8MQmx6ILoAj02R5eRl+v3+CwTGLbG9vA8AEhspCvEAgALvdLt4CFSbv1e12Sw+nwWCAhw8folgsSiNF4LTjrVaE9OQZIlNR0bgMBgNJvBaLRYFnuPEjkYh4rXQgeA8ej0fmUdDrbrVaUi0PnHqgVMDP4/VMC2cBsYhyMBjgb//2b8W49Xo9rK6u4tKlSygWi/jpT38qrc9Jiw+FQhNOBuGxarUqEAOrwtlPi+vEaJtMJJIWGCEyD8D3JuRKx4bwMWsZSCgZDAYol8sCHdHDJSGBUQvrj2b1ugHgrbfeknKCw8ND6bxgMBiQTCbl3kk+IbuPVHN65dowapqsZh8CkDXxeDwCw2WzWXzyyScSkRHC4RqySwWNvG5ayVygzg0R8gmHwxiPTzpbHB8fw2Q66YJtsVjQ7XaRyWRgs9nOVU7APAvnLVF/0dFiESkjzEQiMZGfYhcSo9EouSgqe+ZGGI2xPIFFyexdxnyZwWDA3NwchsOhdHGnE0pjQR1Cx4YjPhjd87rpDPT7felaTWNFvaEjs7PKmY0LPa5YLCbdYHkT08lmbg6r1SoN14DTIiRaWt2XieGlTnQxuqAXTtiICTQaBt1ZlYePHg0PNx84vXR+Pg+ubsegYRxi3efFvOlx6fuj8teVsfQoiHGSeKAphfwb7bFQdNJbG2t6HVwfrj3rg6bzIoQLuRm1x6ijPK1Q6LHTA9aJalJLZxVGcLweercAhMFGSrpeP+3980BxTbmfCB9w/2pvjX9PHJ3PbBri41ozEqHXSJYZu0pTWWhyB5+9TvBT0fKzdGQ4q5C4wnsETlv38FlqViLXiOulIVxNbKDnrTF9ALKnCLtxD/JeuS9pZKg7nhX98ZzSQSSzjsaXn8UIj/vPaDRO3NN5iDn6DDMKoE7QuUrqLSpi6iUaFa6DNpbci3pd9OdS0fMsaaM+fV4ZmWgHh2dAJ+mnyxO4VtQR+uzztc/T3+7MxqVQKMBkMgm+TEvd7/cF31xcXMQrr7wii9Pv93Hnzh3cuXMHsVgMly5dEkvLCwwGg8JgYVuM4fCk7cnKygqcTqd0SNU5iUKhgHq9Lt4+mV4scGP7CJ/PJ3/f6XSwvb2NYrEo78UCv263i0QigStXrkjfMSZgi8Wi5JRmlYWFBQCnG6pQKODRo0cTWCw9D5vNJgm9o6MjqR5nTyb2dwMgSWxSZHl4mITTP+OB5Tp3Oh0cHBwgm81KOExGCABht5AyyYPDJDrzU9ywJFV4vV7Mzc3J3xGGIZX2jTfeeO71Yx8zs9ksfZcuX74slORUKiU4NFt+JJNJrKysYG5uDkdHR3j48CFMJhOuX78Or9crzobFYsG1a9cATHYeZlsedv1m52TWhWgvlUqt2+3i8PAQzWYTkUgEwWAQh4eHeOedd9DpdJBIJKTnltvtlr5wpHezap9sN3qW7XZbZh7NKjQuhDlJ+qDhInTEqJ3EkHA4LK3yec+MYPgFnNbCUUFlMhns7OxMdEAATun4hIjD4TACgYDs616vh6OjI6kf8nq9yGazePz4saz3cHjSx3B+fh7tdlsKUPkMWq0WSqWSRM1Wq1UKLMfj8UzTPPU55UAtTkAlsYHnmzRlQuqM7J8+fSqwJyEsvq92KDXTTqcNGD1w4CHPMuE0l8sl9Xrj8Rjz8/NSh3R8fCwQG589HSLCa6SAu1wuRCKRiYAgl8tJnvr69eu/dL2eq86Flo7enqaz9ft92Gw26R9GZcIpf7qFOxN0miGisfperyctRtxut7SOpqIkaYCbhXALcztsZslNxTxKs9lEsVhEJpMR49hut3F8fCwbJRgMwmw2ywwURjm68HIWYc5JF+kxL8EoQhuFSCQCs9mMfD4vITNpg4QhCfHxcNP7mPY4NUOEa8ziKbJQGHlq5aqTtAAmvCTSMek9cpPSW6Jhq1Qqonir1erM66cr6knc4LMqFovSlsVsNkvrfzbtY/1TpVIR75B7mW0yODuIEAYNBqNZRkD07qejWXropNezESXnomxtbUmOzWQyCRGDe4usotFoJJ4xHQZN/T6PceE96z2iIxgqSRJrqFhY7c5r4f6YjiAByLoxOmGfNN4f9zjfR5cauFwuqWdj1ThhHQCyl0gXNxgMkofksyTioSMYnjPmM2fdg/wcTdogfZefxz1IA8Hzw71TqVRgs9nkunV+hdGzjganSyEY5dAx0oiNNkK8ZwBCwtBEIBojGmtGRozC2D+SRo4kFjrdZ1qvsy7sq6++CqPRiEuXLmFhYQFWq1W6CrPAx2o9mXNPmIFMDc48IMuHN0l4QBcDJRIJuFwuBAIB8Rjp1RDLZvim20cDmMAyjUajeLW0zOPxWCqjtZdERR0IBKTPTi6Xk0PGWhjdR+h5ReeACLNwMmEwGITX60WpVBK2h07W8e+ZICR1k/kObjY2uGMCVif6NSuJI0yZQ2Crc84OoZc6NzcnY6WZtJ0u3KK3w89n99cPP/xwguHE5zTrwWZRWTqdlpHEjFBHo5OZGSxkZG5Ak0AcDgeWl5flEOsDNRgMpH3O48ePheWzvLwsUTXnsdOIMjdH48qWOqPRCKFQSPraMYr7yle+gl6vh/X1dTkPhNDYhsjv9wtDklNb79+/j5///OdCpz1PrRUntdLj5X4EMLEv9aArVrSTdEJFSeNDJUhyxXA4lEisWq1KDRdhrePjY+nxRsiLXRL4fwBIJpMyvZZsqo2NDfT7J0PilpaWMBqNZHY9gIniQRr58fikZoY1OclkcuY1LBaLACC5MHaLHg6HkjflcDze82AwkLNLQ8xcKo0ydda046AhM+49djVpNBpIpVITjSRJ9CGdnnVJNGSMOoPB4ISzz2fT6XTEqAwGA+zt7U04Ub1eTyL+s8iZjcsbb7wBo9GIpaUlSVRtbW3BZDLh1VdfxeLiIh49eoQ7d+7AarUKLMLIg/UtAAR35qLQ0zAajZibm8Pi4qIwSRwOh9RusPKWSVNGOUy001sHIPUg6XQaDodDGjxyFCkppMPhUIwMPSLCbcPhUOAJ3fxyFqFxYdEVk8LASeLU6/VKXVC324XX64XNZhPPmnVChP3sdru0OmEESSPwLE47I8xqtSoeCHMVvGcOgZubm0MwGJzoZ0WPv1AoTBgXemPD4RCLi4tIJBLY29vD+++/j06ng2g0Ku17zqMY0+k0hsOTOqutrS0kk0ncunVLiura7bYk9OnVUUajkyr7lZUVAKcjY+m9E8qqVqv4/ve/jzt37mB1dRWvvfYaBoMB7t+/L0pWGxfiz1arFdVqVQa3kerMXILRaMSbb74J4ERp+v1+qc1pt9vIZDIoFAoIBoNIJpNCna3X63j77bdx9+5dfOMb38Dv/d7vncvB4QgGXRhLEgKVI6MtGj0+a8JfzAMxkuP6Eh1g8Slp30xOj8cnBai7u7s4PDwEcBr5UPHS2WSpAYkohNkLhQLG45NuB2tra9jb28ODBw/k/NtsNsRiMQSDQTSbTWSzWZky22g0sLm5iYWFhedmPVFYAxcKhcS4sJkoYU4SChgV0LhwPDfp7cxlUKlTeeu8rt1u/0zbn3q9juPj44keYzT83J+hUAivvPKKNE7Vjup4PBYkqNlsSr0Q9zMhyuPjYzx8+FAcKDqdup7rl8mZjQs9HTKxaMVJdyW3mjeok1p+v18gA+CUykplqMM60oi5WDoc5E0NBgPpfqrDbR481spwY+vEFJu58XCwGlrjtYSMiAsztH0RxoUQEhlWAMRI8vekJbNAKhKJiBdDb5IGg4aEHqVOwOn+RFx3JvFpZMjm4zpqD5WvoXEhNx445fzTuE9XUrPeRlOZydibRXgA2UeMxpVFnBr6ZM3SeHxa90MDQyiKRpuKhrCjju4YpTHC09ChhhkJXVA0o0lTPvVr6Bwxf8FCYkYEhEtooFqtFg4ODmA2m/G1r31tpjWcpp+y4Su9Y54JHVUQ5mq1WhOdMoBJYgdhO0LJulUNHRCu7/RakdlIT557mzqESX+y1waDk556HE3N+iDqG6IUzOfSqWXn5lmNi26rRN1QqVQkb6QT8zQcpPQTAdH5Tz4TTWii6HUnJEW4kM0xuScHg8EEK1GvGz/PbDaLU0U9wn/zmnXnAHZht1qtAnPyvV64cWHIf/fuXRQKBXg8Hum8ycp83XuJm5bFUKTtEQbiaNKFhQX0ej3xfkejk8JFjZXzoHIzNxoNGU2cTqdRLpcFtmEfseXlZczNzUlinAqGvZ0YjdRqNdy/f1/gM4bRLJxkiM027JqZ9TxC2natVpO+aazPYTdZ4KRYlYl24ASOvHTpEsrlMg4PD8UTA04ObSAQmIiIqMhJC2b0yCLVbreLUqmEp0+folqtIpfLSfSjWTs0IlQqhC7IpiPLjLk45n46nQ5sNhs2NjaEdm0wGITmOqtxoSGZn5/H5uYmUqmUDIDTh5ceI/M7dISi0SjW19cxGo2wu7sr3Wep9FmIyQ4THAXc6/WkP1qr1ZowHDr3RIdoutCOhoT3TWXHKLXf7yOZTCIajUqyn1i9zXYyv2h+fh75fB5/+Zd/CQD40z/905nWkGy5QCAAj8eD4+NjFItFGI2nVeFUYMPhUBLN7MkViURkABfPInNg7MjNHGsulxPnpd/vo1wui0Kk0ICwW7RmL9H54r7zer24ceMGBoOTcQqkUufz+YneW1SQ7PfG3E29XsfR0RF2d3cBAH/yJ3/y3Oun2wax9OL+/fuwWCxSfc+zQwNoMJzUZrGvGg020Rs6GcBpLoyIQ7PZRKFQQK/Xk1lT+XwelUpFIl9CWcwhezweyWdp46Lp2nQwqd9Go5FE2noGzuXLl6UYlCSP55HnSuhT8bMgkIwlTQfmIdO1DoweeMAYiejEIqOLaVrtdEKaUVKz2RTLrT0yjRtP00oZ3TChqxOqhNsMBoMkBYHTDrH0CmY1LoQhGKForFTXRdBT4H0xmuHB00k+ri/XTdNW+cX74TVwQ3P9+KW7MU/XLmh6t4Zl+Dx0xMSolCwkrh+JCrMaFyYiiV+zHqjb7U5EoZpSq40gq8oZXetDRm+bxBT+jkqTHreGAymaXqz3K9dhOvFPg0vvk0QY7i2Nv/PZE/ajw3Me4XXx8xhx8hoByBppQzm9D/h39OB5P9QDXDe2p2feQ5MS+Dmahq3JPfqaCHnz3NAIsl6N16VpzoTjqAN0HmYW4TPm/uI967IGrWO0Dpl2SnTUS92gnxEjNEaDhK34eTrfzGc5Tf/X76n3JvUb14HnVj8DTaXW55vXfxY5s3HZ398HAKliNhqNwhbi4dvb28O7774Lv9+Pr371q/B4PIJ9mkwm3Lp1C8PhULyYw8ND6S46Nzcn9DfdioN1AlSChMNY+Edq3cLCAl555RVJjnMz0JNmSEjF2m63ZYiUx+PBaDQSKI1tD4CTdjHsJvo8HUGnheNEgUlWl4awppOcg8FARrvywDEXxXXXA3409EgvZDgcSn6FHlylUhGWGA9pKBTCxsaGJHapNAkv6Rng/OxGoyGUz1arJU0ZielreBM4VSazCA82D1E0GsUrr7yCTqcjPdii0Sg2NjYEFiPtloeOERpbaKTTaXz/+99HuVyWeSvASR89k8mEJ0+eSKSoRw9QgRgMBhwcHOCTTz4Rgggj3dFoJDnDfr8vLJvR6KRPXC6XmxhSZzab8emnn+L4+BjJZBKvvfaaMN9WV1dhs9kmmpnOIoygdG0T2ZQPHz7E3t4ekskklpaWROEYDAYhJnA/EYYiU4+lADTGhHKYy9MOIKMZriM7PzMnylY7kUhEHB7tCBLq5F5gtPTee+9NOFXRaBTXrl0ThhtHOHPe0SzC4Yi9Xk/KE1iUyX6BZHqynoXrxQ7i022CuB7c13QG+UXDwiLnXC4nnbt1PzDCvsvLy6Kvpg0a10/XFw4GJ5NQHzx4IO1lYrGYwMGacUZE6qzyXHUuwGm7C7IPSFXr90+G3Tx8+BCJRAKvv/46TCaTeAvhcBhLS0uSIG00GqLkwuEwEomEUPRIAGD+gd4kLbcedQpA4INLly7J2FkuZq/Xmyi8pKdFz6HdbovHHgqFZJOTE84Jg8DsI3qB0/nbfLA6h8QHTqHXQKy6VCpJ40rioTS6WukajUYxFmzYyH5WzE9xqp/Gb7lB2UOIsAe9Tya9tRdIz4lGptlsyvXRg5zON/BeZxF6WvSofT4fVlZW0OmczFSv1+tSPwJA6qV4iAwGg4wOjsVicDgc0lafTRW73a7AvZX/N7OeBZCE/TSd12g0CiyzsLCAubk5iaBo2OjpEvqkka5Wq0in00LQsFgs2N/fx/vvv48rV65gdXVVqPrMjxC6nVUYpfDZMYpi/zle39WrVyWaIayjJ3MOh6cFooS1aFQYdfPvpsk7hIOBk2iEESXn/9BZYqRCqJHPkUaba2I2nzTPJMzL/by8vCysx9FoJF74dM7neYQMq9FohHq9jsFg8JkxwWwDQ+eMe4EjA3jf1EmMkPV6U5/q0oFpp5BQrM7ZkL3G+hrtwPK9dMTE88GBerlcDsBn8+gAJqDQs8qZjQtH/FarVZRKJcGC7Xa7sF2KxaKwSTg+la0fRqOTfmHc1OzHs76+LtQ+eu1cGD5IMn+IiXNT0SvlIhNn56wEUhOpdLmp6K0xPKXyJRuEHp7RaJS5FTrMnUUYlfABkxJL6iaNHLvOUolzc+hiLF0T4/P5ZCNwg3HDHx8fT9QuEN9lDVKr1ZLJixoz5nWSRj4ajWT8ciwWE7qz9m6HwyGOj4+FHEFnJBwOy8Em5DOLcB7PaDRCPp+H0WgUNhHrdvb39yeS4UajUa4VgHjrhIb0jBAWwxFi1AqCyX8aFBoZi8WCYDCIeDwOm82GYrEoNFBGl7r7Axl7TJ6vrq7CbDbLfczPz4s3nEqlYDabJ7oWb2xszLx+ACTn5fV65f5CoRC63a4Qa0ja4TOlh61hbebY2LWAUCmNDlvjcN8Q2tH7j+s4GAyEtsyCSaIEdGLp6HBIHM8mO5+7XC5he9J5C4VCAhcROvb5fFhYWJjZuOh6Ml4D74G5J6IQmrFIh5CRhslkEqeBbVkACNGABlF3+6bh1vWDNNrsg8dcmu6GzvPJYnf+PbusjMdjcc6pc3VneK4zI/LnKSc4s3FhN9h0Oo3t7W3YbDbMzc3BZDLhk08+QSaTEQqtyWTC3t4eCoUCXnvtNWxsbGBraws//vGPJdSyWCy4fPkybt68KQlD/pwQFqMP5lZowEqlkrSYYRTS650MxeHsEG5Q1q6QQkvGExdpOBwik8lIdXc+n0csFsO1a9dgs9mwv78vdEHCU//u3/27sy6bCCMTJnhJM+x0OshkMshkMjKIzWKxiDKjEmN0w3sdj8fC6Gi328hmsxgOhwiFQjIvhBXNVArcmM1mUwzaxsYGEokEVldXsbi4iPF4LDU+Ho8HCwsLyOVyuH37tkCHkUhEmjFSGff7fTx9+nSiGy0jUToO5+lwsLm5ieHwZI77zs4OwuGwDFdqtVo4Pj5GtVqV4VTJZBIulwuXL1+WlvtUToRtOA+GrMXxeCwwC40OFSHhFO0AsSvy+vo6qtUqDg8PpY15MBiUtWa+hixHRkgcZcwE+s2bN3Hp0iVks1ncvXt3olXMtWvX8Oabb87MdAIgdTJ+vx8ej0fIGVT4dJ52d3fFYdFMIhYKGo1GSQAzQmPEOhqNpCDVYDDImINyuSwKmKwrkn/K5TLS6TSSySQWFhbg9XplvAMAuUZCizReLLLu9XqIRqMTLEoqR51f5eiIWYXXo5PkJOf8/Oc/lyFidHAIMZMNSHKB2WyWNlputxuhUAij0UicWL4/6cakDDM9wJElJGiQGJVIJBAKheQ6mZ+ik3N4eIjxeIxLly7B6/VKtMVR26QgHxwcyHXzDDN1QJj8LHJm48KkI1kJjDaIEf7/2HuP5sizLMvvuIRwAC7hAloGQmekFl1Z09XVXd3VihxywcVMczE23JFmNO74KWY55HYW5NjYjPXMtKrpLtGVWVlZmZUqdCACWrs7HC6gHHDFBfi7eI7OskI6chnPLCwjEYDD/f3fu+Lcc88lKgUjJU0ul8t2sHgwGCQovm4BzI0q3IKTdK5ddbGrFEOMA3DTPxcW+bqiGr/bpVLDvQ8Gg9Z45MJWnSy3uMeFdSW4LxYA2Qc3+sCw8H1AfS7ZgdcD/sNhA88QSbt7B9ZLLwfP56KOl1uk5tm4hVd+FuN7Mfr8uoL4ZRfUVhguvDZQnUuldM+oK2kD/k4GKKktCyGz4PfwGdknnoVbNHWfh6ta4Xape71ei65h7BERuovIGDhYkkWLRK5XKeiTTVEL4H3B8sOZuOSMi4QRMhjukUsOcO/vxeyAu+ieHTcTpMcGEUvOHgukwmUguuwymEwgIy4phcZG9313slwom31kTy+SIvge925zVtlPF/7DtrlnD0KK6zQvkgd4Lbfb370L7CH1Le4p79N9Bm5NFagSG8/vdO/Fb1uXdi5DQ0PmXcPhsEZGRoz2hgGBBw9FsVKp6B/+4R/0D//wD0YR5rJLZ8aRYWJElW7HPYvCHs1QRJ7SWS2DrlHmnxDxgZsHg+dT6iR9rfGQzqCXoaEhTUxM6L333lMwGDTKY6FQ0O7ubscpNUN2kPUIh8MaGhpStVq1pjrXGJIlUStBR8nn85mhdZtIcarAFETNFPo8nrOm0p2dHR0eHioWi1kmQhPg48eP1dvbq+npaYNO+J5XXnlFrdZZgxs0USjkGD6g0nA4rLGxMTNavC9gg07WL37xC3k8Hk1OTmpubk4DAwOKxWIm23NwcGBjtoFLCDooXEOS4IIRfXMWLvY80R/h9pog8YHuFxnLwMCAwVylUkkHBwfmuPv6+nTz5k1Vq1V98sknWllZsdEBKC4Ae3Lex8fHValU9Pnnn1sjMHIcP/zhDzvaQ5TEc7mcdnZ21Nvbq6mpKatZrKysaGZmRnNzc2YsvV6vqWPDwHKXawi5d4zBgGpNZsRZwFmTvY+Njen69esaHR3VjRs3rEERZ0ajbF9fn9UICPZcg1+v103/KhwOa2JiQs1m08gK8Xhc6XS6YwfDWSELDQQCNrcGIxwOh5VMJtvqKh6PxwYmMkyPAOKivBJ3BWUI6n2gFmQ/MDLdRl3XWdEoSS0rFArZ8/d4PHa2eZ/8LPNcBgcHrfa2tLSkbDbbxqK9zLq0c0EQjRSOAh9vEO8HlMCmFAoFVSoVTU5Oanx83LynJGMfUJimyOQaoIsRCtEfURKODcYamQ2OCoNG/4BbGMab82DAIgcHB804gZG7aWsnCzybz8OFIYNzayzSeQ8Akg7UOMhKeD2MJ1Et/+ZGOESLRMAU8CVZ0ZReBC6N23zo95+NPXAdGkaD7KjZPB/KlEgkNDk5Ka/Xq52dHeu3AeLpZO3s7Mjv91uhFj4+GDKacmDw9GOglkxGisFyswAMJEaHTJVMjsZB9tmNEIEqKL67GTSwCHIfUGlLpZIkGTREFzbRKZAKZwBRS4QYO10YZ6J5GJkU+Rls5TZKUh/iv8jFuFkI545oGgPpdpxzJnlNngNOPxqNKhaLmV4c9wxHxH67hWjpn5JssD3ca4/nTDwVxupVetVcVqa7N6ARQGWuDqLr+KgTulRh9/tw0jhj6lScVfaRM+jC57w/shko7KAG9Ao1m03Tz3Mdi8tgo/YFw3V5edkUzb/J3n2jmgvFHxzMzs5OW0Q6ODhoOPja2ppNosOYwXJgc90BS0RLfr9f2WzWMFU3JXOHWrHpMKeYseBitQgIgvsT0ddqNcMuaaZLp9NKJBImdlgul+XxeLS3t2dEAeRaOlmMNIbu7ApPAj8QNZC5SGeyEjgQNLw4kIhYUsvgEMF+I8Pg60g58D0+35nCMheOaIj6CEV56ivSWbHv4ODAFKf5t1arZcoHtVpNa2trBrXV62cSGC4d+5suzsLh4aHW1tastiSdSarQme1mHjgELpRLBOnp6VEulzOlgp2dHXMK7r5wWTmv6IihUCGpTTIIYwmxoqenR5VKRY8ePbJ6xczMjGVe9frZTB03W0eFIBaL6a233rIazuDg4JUYix9//LEkWZOh63yZjNpsNrW2tmbvAebk1taWotGo6QoSNWPsDg4OtLy8bNkJ/07mQRaHA+nt7VUikbB6BBDQ4eHhP3GgGD++TvaCcQQqlc4cKBkpd+jevXuamJj4J/0a33SRYWCzKNK7wQuQ7cXshN9N5sv9k8413JgGSXAHYtNsNq3OQsMmLQlI0KTTaQ0MDBgUSG0ER+xmnTj6i9kOjpJnRVAIBdstK1xmXdq5pFIptVpnwo8M33n06JEdTumMGXTr1i0TbkPO3O/3W4d5s3k+f5tUt6enR9euXVNXV5dWVla0s7OjwcFBmxlPtE2zo8uWYNOi0ajS6bQ5LElmOI6PjxWLxRQMBo1tls1mtba2ZtlPKpUysbxGo2HzN5BHQZ+s00UnPeNiJZlzkWQYPDO2+Xomk1EsFtPKyop+/etfq1artelWIWlCTcWt5SDvAdvoonMhmolGo201GLI+RAGJViVpY2NDe3t7Gh0dtSFuwG4YFJyLJKONhkIhc1CdLAqxyKA0Gg0NDw8rGAxqZGREg4ODpngtnSlKXKwfwQ6bmJjQwMCAdnd3jSX41Vdf6fj42MZJU2gl45LOoOFMJqNCoWDfz3OsVCqGU0OHx7lsbW3p448/1tHRke7cuaOpqSnb92KxqMePHyufz5sBGh4e1uzsrAVN9N9chYYsSZ988om8Xq9u3rypiYkJSbImR9e5APPFYjF1dXUZG3R4eNiEJLm3rkzS8vKyDg4OlE6nbRKtW9PCaPIaQ0NDFiUTlWM7iKRxIJxN6byfi7qaJCMHwH6kXhoIBHTnzh319vaackCn+4hzgxCBU+CuXnSkqAu4nfIEL9Q5pXPCAmzaTCbTNqSPLJou+VQqZXaPoC2dTrdlwC5VmUZd9tRtouTew1zFLkOXhzkJeeebOOdLOxeiZrIBmnlqtZqi0agSiYRFafV63cafkupzWSkk4jHdbnSKz6FQyCAH6byDnR4NIkAMKgb0YkGNCIOags/ns02HMgpbC8VPMEoeOu/FPdydLBweMAefx224I+3HAeBYOXzQjl2ZC7dQCJuDSIc9hUzhakmhnAy27sIUOAlk0GEFkf4TwbmMFeAgaj7ALW7x8irG0S2auxEUVG4yExaYvKvXBaWSfz84OFChUFCpVGrTxSKLRGSQgurR0ZHNJ8Fhs19EzMCX9XpdhULB5g3xu3Hqrqy8K7cPMw3qNw6e33GV5RI7Dg8PbU+IbjGSFHyBYggeotGonQ2XXOJqaPFs0ORLp9MKhULa3d21LJYMUjoLquhtGxgYMGPsqmEgMcT7wum6HffcfWwJRAjIC0iyuPf7my73PYCecO58Pp/ZCmArzt1FlqHbRgF1udFotEncM2Sxu7vboH6XigxbliycYMaVb6J25fZb8cz4DMCXBOv8P4iQ1E6s+iY28NLOZXl5WY1GQ0tLS9rY2FClUtHOzo5CoZD+7M/+TLOzsyoUClpYWFBfX5/m5ubU09NjWjhAPm7hD1Ven89nRpHIvtU603vi++lyXl1dbWN1YRRIgzn01AnozF1eXm6T2kin03r99deVzWb1H/7Df9Dm5qY9PKAeenFIf69CpaWAvrOzY3TqlZUVtVotpVIppVIpdXd3W7YHbsuAqoGBAc3OzloU6PV62/jvRBsbGxumPUR9BN03nPTAwICp7wYCATMEGGKonjSVcono9wBGK5VKll4HAgFtbW0pm81qbGxMN2/eNCgUFgzGq5OFrhcXyWW4zc/Pa2NjwzSc3N/FKGMiZJwcWlOPHz/W0dGRfRb6pZLJpObm5hQMBi2g+fTTT/XJJ5+op6fH1LIHBgasADo2NmbR6dHRkRYWFrSysqLu7m6NjIxY8b6rq0sbGxt68eKF6UVhCAOBgDY3Ny2YKxQKOj4+1szMjG7dunWlmoub/W1sbCgej9vcoKOjI+VyOYPz3ObasbExc5w0ymJ4gE/r9bomJiZUr9fb7vy7775r2SEZHn+nuA1Jw6U/E/UXi0WrNeG8KFQ/fPhQH330kXw+n91TBF8PDw8tS+G8TE9P6+bNmx3TuaGrHx8fG6IBPToYPFeCPzw8VCAQsNEYlUpFR0dHBgW6vXzcVekMpWg0GlpZWTEtsVgsZkG4q0kXi8WUyWRMGYJRDXxWxF1xNgQUOOFWq6W9vT1rzCUboQyASgp3qV6vW0Z/WWjs0icV4083NlkFxcdoNGowFNElF4FsxS3mwzai6Yn/cnCJpNwohAzFLaCBBbrRC19zsw0YGC7lmY0nGsG5SDINMNJPahedFqTdlBR6IVkEkZibubhURJgmLszAIaYTnUVBk68Tlbqcd5eFQ6rbdij+/2dAFEnx1v15YAyX/cP7dckGLkPvKk2ofOaLUAJR1/HxsV1+l2r8ddmS+xxdaqn72tBMKcJDZtjb2zPyAFCDW1zlGUAtJVgAwoGyy1kj8wP+oSBODwJqCgQRV8n+3II05x1DwzkE0gEe5U7CjiMTZV2kdXMvCTpwVK4CtUvswC7Qr+JS9Xktl83HvebrBJS8ntuCwJnneaIo0qmDJnsHCoOIhC3hrrjtEpxHt33Azb4hP5D5SGdZNYH1xWK/S3pyaf/8cc8i9oL35cJh/B7sHWeT7AV4282sLlLJf9u69C6vrKxIOmMXTU1NtcnaDw0NSToz4Lu7uzo8PDSvubm5aZMo6ZwnCnKLrNAWiTKBHfb397W4uKh8Pq98Pm8fGl2zyclJiwbYPPB9mgVdqRNwTaKAWq2msbExDQ4O2gaiQQSnn2IbM146Wdvb22o2z9QATk9PlUgkNDU1ZewS6kE0NxLNwM8ncsGQ+3w+LS4u6smTJ8ZGghnjarC57CMm/cFg8nrPGrBoxNzb27OBSm5U5fbYuD1NMN2YkYFcTKNxNnfFlfCRriafc/v2bTWbTRuohkOh1jM5OdnmvHd3d+0ilUolg5V6eno0Pj6ucDise/fuaXBwUNlsVr/61a+0v79vZ5qokH0gOg2Hw/L5fKaPl0qlbNYQJBCMy9DQkLEqiQKBuXw+n27dutXGpAKmADKFrdZsNm2Ymcfj0f/8P//PHe0hNSKM0t7enpaWluT1ejUxMaHh4WGD95gzs7e3ZwEezvtiQRrH4E5X9fl8Bjkj00QABWnGDaiwAxSP2Rc62LmzsBLJAtFgIwPj3AeDQd28eVONRkOrq6sG51Mb62Q9ePBA0nkgQpOu+3q7u7vK5XI6OTnRwsJCm0wTtS0MP7Dn8vKykUgkGbrhkiVw8ui8YUPdgBOn7wbXID+UFFwGaaPRsFo0+8edd1mRrnPHLt+4ceO37tc30hbzeDxKp9MGNTClkA/FATs5OdHW1pYCgYDW19e1u7urcDgsSSZVAKOJyBNnwYd1G32y2aw2NjbM4POgwMZTqZRF+BAGenp6TOAS2my9XjfuOBcabSe//2ykMJMgqR3QbVwsFq9UDAQbJsWk98HFME9PT5XNZu1AufUp9wISaebzeS0sLKinp8f6SnCkrqIAhy8SiWhwcFDSueouWWez2TR2GP8GWQNWmtsoR/QNA4jCdV9fnxqNhjY2NuTz+RSPx03o1M1kvukaHh62SJ6hbkdHR8bpx0FSvyC7JmKl476/v1/j4+M2kCqVSmltbU1LS0u2R+4ZZRH9gt2TSeAEuMDskXQGQ6VSqbb+Leo86XTaFC4kGUzB3BO3kbbRaJiu1FWWizZQ9CVgo4gMSy6fz2tlZcWmSfIzwMVuwAEiwT3j/BAQUfMjupZkQQ6vizFzoRgcOv0lKB1whkKhkLHAOJ/cAaDLZrOpzc3NtjvRKSy2trZm0Cw1j0wmY1k7mTu1aLS6WJAMeAbSGSIEmYPPVqlUrC5L9sudd9mxLgvNJQ2QTRPw8Touy5a9ZfwIDLRgMGjsX0aHuzVON8P/bevSzmVyctKiwGfPntkgHnBY2AZAAAMDAwoGg1ancAuBQCQDAwM2HZAPnkgkDBYAu+VSUJgiS6HuQnMfB99lAaFWKsmKga4mFdEVPTwjIyNtBj2bzWplZcVm1nQKixFFuz0owHTUlLiERCj8HNATUSEOfXBwULdv3zZn6w66Ys+IYqRzdQS+7h5IdMS8Xq+y2axF+xSoeR9cUGCTWq2m+fl5o5ATtTJ9kmZOl1XWyQJKGR4eViwWUz6f1+LiohWEyTJI76empuTxeNqGfgGLULOrVCrK5/Pa3t5uY02l02ljaWHocGY0+xLBr6+vG+Wey8lsHfYMdmKtVrNGOvaC4i3vj7PB85uenpbH49HW1pbVGztdF7PVSqWira0te059fX0aGhqyegqZFxlLtVo1ujUSS8B/LimHs+1Cr3ydsweUBORMcIlDdzUIObOIuVKMJngkiCHSHhoaaqMiT0xMKJPJKBqNfuNGQHfB5CTzJ4ji98LUgsIObMr9JrNCTBfUgnYNVwAUhICaMiUBfjfOiXPoFvI9Ho85NuwuCAbPkddkLDKBWL1eN628/v5+Q25wnN8kwLm0c7l3755OT0/1ox/9SB9//LFisZiy2awGBgZ069YtJRIJK5ij4Et2gqEBbyRSSSQSmpiYUKlU0tOnT3V6empFrVKppKWlJcOcJVm0wMPhQUORpuMdhVRqDzxE8EgeALL7FHX/5E/+RDdu3LBidrlc1v/9f//f+vTTT9siyU4WxpE6AY7A5zsb34oRlM6caCKRkN/vt+yhVqsZnALTa2xsTCMjI8pms/rlL39pKa2rYOAul+nFYcOR0gR4fHxsjKi5uTlNT09LkhkPam4wn2q1mj07Iijef6vV0uLiovb29hSPx6/UYwDePjs7q2QyqV//+tf6+c9/boVk4AEyqddee029vb168OCBlpeXVSgUtLKyYoaNbHR+fl65XM4y1kgkYrAvTaWVSkWHh4em1ODW9Q4PD9XV1aWZmRmDH4eGhszwQmt/8eKF6vW67t27p6Ghobba2/r6uvb39426jFHx+/165ZVXlMlk9I//+I969OjRlWSIgLLGxsY0MTGhx48fm94fMu3Hx8fG2rp27ZqksyIvUCvitECM1EJBBoD3Dg8PbbQvRgsqvCQj7qAPWCqV1Gw2rdfC1WPDKNIEij7b9va2Xrx4YQQd2FkzMzM2CsLv9+vu3btGVc9msx076Ivq6MfHx3r27JkkmQJzKBSyBmwgVKZmspfcHZo6/f6z0QVra2umekw27E6gRJMOeRxJhtSwl+FwWEdHR3r69KnK5bLGxsZMXYWfwZYQkLr1RwRVyQJhY1L3A+K8zLq0c+Hw0JVKTQXG1v7+vnXCk0YTSRLpAfOQOsNOcmlvX5fmuSwSinl4VZgUXq/XDjKYLa/LRrnUWB6wx+MxBVcMCawoupiRGXGn6H3TxWdGhI7fSWTAQ+Y9uoU/qb1Tmq+53dFE1m5Uxv65n186Vz1wC6M4HiIh3sPXOQRek0gNmISalVvMvEgr7XQR2R4cHFh/BY6RKJbojQjX/f0X6Z8UM1GS+E0GBxILgYpbdCbgINMgYkdLD8E/sk2CBRcuganHeSCyZVWrVWNUDg4Ofm3QcNnlFtWBRyDSkM0xCphMFsOOo+QZuzNhLio28F/uJx3h7nt3MzQXtnYzZPB97gHnDJvAnXXJO+57hWFIdF6r1czOdLIILt19k2QQoHSugebe4Yv3yN1Tl+CEDBaQINke3+f+kWSfm+yRrB1GJN/HM3fPrPvMeU783X1vZIr8/DeBFC/tXBYXF9VqncnZv/XWWyZfLZ0Vq1dXVzU+Pq433njDNrvValmXL5EE6qZAasiEjIyMWM8MEFcikbCUnVG1UDlJPff29rS/vy+/36/x8XEdHR1pdXVVp6en1vQG7dR9UMPDw5qbm7MpjMViUQcHB/rJT35idFyKgq+++qoePHigTz75pOPLTYH5+fPnWl9f1+3bt3Xnzh35fD6LiMPhsP1enAgPGhojGVe9XjdSwtbWllZWVlQsFq3xynUsUI7JGoEGgRyAayicolxLLUU6rzm4kitAUcPDw2q1WlpeXtbGxoa8Xq8qlYpFZm7/QqeZy4sXLyTJ5shXKhVTO15ZWdHa2prx+pGAiUajqlQqbfRporFisaidnR2DtSRZ8ZUoMxqN6uTkRC9evND6+rqWl5etX4rsEeMnyWp6jx8/VrVa1ezsrA36unPnjk5OTvThhx9qYWHBlKj7+/utdvnrX/9aDx48sBEAPp9PDx8+VKNxpnb9P/wP/8OVSBFIux8eHmpxcVHb29vmyMLhsGKxmNbW1vTZZ58pmUzq937v9xSLxazOxUJVAOUK6SyKhz6by+WMBIEjymazhuWTNWMHOFMEjfX6mfr68fGxaRgCMxEAuoa5q6tLw8PDikQiWl1dNWLM4uKi6vW6Njc31dPTo6mpqStRkRn1DtEhHo9renpaPp/PBg8S3dOEyl2Gfeh20fO99A0uLy9bnYN6CRkGwSlfA3oOhUIWEDSbTYO2yeLJZghwQEeq1WqbLBEjCjY2NrSzs9PGJCMwQpXjW6+5IHQWCARMyC4cDhs2yL9z4cGRafKRZAV3NsilsYZCIcMUiYoxiKTaLqUZYwGzy+/3G/xGNhSLxTQ0NGR9JTCvMI7JZNLSWL/fr62tLeVyOXV1dRm1lamF29vbFjl1slxYCZiBCN+tv1zMGNyaC010bs8K44qpteBYiK6JbtwsiMzNzSiAs4DIpHOFa+iHbsbiRmgoDrj0VSI5V+PpKouskQy50WhYVgwDz5XeoEPfzbb5DODHFOGB9Ij4CCAwQpVKRYVCwbIKMryLdGYMaS6X0/7+vuLxuI1QQHK9WCxqeXlZHo9HyWTSOrmpa8A4k2RF1YODA8ViMQ0PD1+pzwX5D3q2XHUIaqXHx8daXV21SJp76e4JGTh1BAyhu6fsK9keRBY32wMW5GcwohAlgHc5d27mzbPkLNJEyHmF1EGGBaOM89HJcqWEisXiPwnaOPNIqFyE0TmHZNvYTvaLoI736LZq8LouMnDRPhLQ87v4dzcIcl8Lh02N3A02CTJ5LV4HPcTLrEvvcj6fl8fjUSKRUH9/v46Pj3X//n15PGfzIVA8fvDggXVo+3w+bW5uGo6byWQs0gV62t7eltfrbctSlpaWtLOzY7UT8OfDw0NtbW3Zpe3p6dG9e/dMEoFCKjNiMI7g4G6fABkVzIvT01ONjIwYcwqozR3WA9mgk/Xaa6+p2WwqGo1qenpasVhMu7u7Zpyhc6OOjJT33t6eTUQcHBxsK8jTwFatVs1R1mpnGmQuv186M/wDAwMGFfLZ0+l0W2Oc338mDklhnjoRkxQ5xKj6NhoN5XI5uyxknrB33F6YqzjnV155pa0Jtbu72+RZpLPLAnxFdgKswqUBjuD7otGo3n33XTNEkoyW3t/fb42v7p7zB2PHhd7e3jZDSCc4rKKTkxM9f/5cjUZD169ft7G+yWTSiq0oX1+/ft0aiKXzjGJ/f18/+9nPJEl//Md/3NEeunBqvX4mUDkzM2OIBOzIkZERRSIRg+OAaaRzYgpZCxJO7t06PDxUoVBQKBQyOSUybpwyWmmMTqZWyDwUhtfh8GDcuSxFYDvgMFhi2CL0uFxYbXNzs2OIlqGHg4ODJo3CFMm+vj719/ebo6RUAGusUCgYEuD1es3ZFgoFbW1taX9/XyMjI2YXkJ9yFZFdOJtgAIo92V2hUJDX61Umk1GrdTa7iiwS+JHgEcFQ6RymhGSF+oHbH8P7+dadC4YwFospFAqZRHsgENAPfvADTU1NaWlpSU+fPlVfX5+uX7+u7u6zKZVbW1uam5vTvXv3TKLA6/VqZWVFS0tL6u/v18zMjAKBgBYWFrSzs6ONjQ3Nz8+30Qcx8jC5gsGgbt26pbGxMYvwu7q6rH8AaicS7G5TEh3AZDyQAiQZLl6v121AGfpknRYD7969q2azqWQyab1AOGx01OilQRGXyHV9fb2tk16SsVDgw0PH3djYsBnlkiwD4vVwLjRfpVIpjY6OWs0GFhqcd4YUwX13axmxWMyiuGKxaDAYhU2Px2PjYGEOdepc6FloNBpWs2IcNr0DDBIDh3bZNdI52yibzVoRe2ZmxorEOH/UsdHRu4jTu0w7LiUD27q6ujQ+Pt4mO3NwcGBG7d69exoeHpYkO8cw1SKRiObm5rS7u2sw4ODgoKLRqObn53X//v0r1VzcZuNG40wSBY0xzglBYFdXlzVy4khdvJ4JrTCwpPNoGBgbiiuZBA4T54KxdTPv/f19RaNRjY+PG7mHYjZFfwKFWCxmk1IpUiNCC1RFbxABwfb2dsf7hyMeGRkxZYXnz5+r1WrZeON8Pm/z7VG1yOfzxkjlbsH+KhaL2tzctDYPMnGCOBy7SyIhK3GlX2AfogiNAgd3mGdOQICCeTKZ1OnpqdbX13V0dGRwMo4aajWZKrW0y6xLOxdeEI9cr9eNqw69jQcO1/z09NSa8nBINErC2iJiInKkjsDrEXW4F9rr9ZpkB7ItGAO3oxTHAIWu1WqZHg/w2snJiTkMlyJMIQuIyp2N0MliQiMzvJGHkGQRMFg0FFVojRMTE5ZpgbW6MijAPC6HHdgqEAhYBAiDSTrvrEamA6hMkhlaDib7QSrOWQAPJq12szqeJ4aHDLJT50LE61KrgRLJlrhkPCv0p2i2BE4BB+eSQwNttVpKJBIKhUK2FxhGIk2pnRABPZz3xecMh8P2B6o3ECjTLmmOI0qFGenz+XTt2jUzJODkOMdOF8QFakYuXMn5c1Ub3L4J6byATGDiniH2hSbm4eFh620DKnWDDLJiHDs2xYWCMIYuscfNgiHZ0E/jNv4BhbVaLet5guzR6aKtgYZsasrSuXCm2ziMbSHLJpuXztUMXHkWd04NAQ1ni7tL2cAlpVBzxjEQeLptDmR+EHYgVnG/0bjDZkCUAAZ1+7y+defCou8kEAhofHzccHagimvXrqlarWpra0uNRkNzc3MaHR3VwcGBVldXTeqhv7/f5qtTkDo6OtLKyooNpmGuBAePvgufz6ft7W2jFkIFfeONN6yb+ejoSJubm9bDkM/nJZ3168TjcWtMIhqGKcMhxUPDikskEkqlUt90u2w9efJE0jnjIhQKaWRkRM1m094jNSoK4oFAQNPT03rllVfMqfp8PnPqu7u7Wltbs658FKNrtbNRBPQoTE9PKxwOm5Nws5Te3l4dHR0plUppampK1WrVCtd0NbtYcV9fnzW17ezsWN8EWQxy9zs7OxYlAT0yPqCT5TbnASWVy2WrrzELngwAwcRnz55pfX3djH9XV5cmJycVDoe1v7/fBsd4PB5NTU1peHi4rV7A9xEYQJLAuUCNx6FnMhmlUilNTExoYmLC2GM4kGq1qo2NDT1//tzgBxcvf+211/Sv/tW/UjAY1M9//nMtLS1J0pUyZ+kswAHaZt4NLLV8Pm/GGgfAH7JeaqM4FTS26JXBaafTac3Ozrb1aVBXCAQCFuBh9La2trSzs2NiqVCiMXYUogn4CEzz+byePn2qSqWihYUFGwVBgIF22cbGhgqFggYGBtqg1G+6oB3j+BKJhO7evSuv12vno7e31wIKl9TCe8E5U++kR4tBfjiFcDj8tVp8bo8LNoPnR1Owz+ezYBanjiNptVoWjNELeHx8rK2tLSvyX+xVlNTWMH1ZQsSlnYtLA6RZko5blxooydJUPO3AwIB9SDwhEQmb7FIbv452J8kiJjd6JpIj2nGpoRxQFzN2i2hucZj/8hp81osaPZ0ezP39fTOM7J3b7e5S/yRZzQMqNNAL++BGl3yui+kzv4cL60Y0LJfuyB+eBfTQi3RF4ByiQyjgbmH8YqbBGbnKcs8MTpLfJf1TfTCepfs+/H6/YdVg+Rf3jJoNi5+7SEzgM+Jw+FmMCPUAN2KmhnVRLNNtbiNrBxUgikTQtdNFHVE6P0NuVnLxs1Gzcs+ZuyfcZfpXyLzdwi/0X5yJW/PjOXHe3GwJ0gF3kN/TbJ4LUbrFcOockDIw4vw/GSYwXycLUgnPgHvD53CDVb5Ghkydw91v/pBR8+zJLsnQpHY1cM4jv+NiCwB7yvtwsz7Ok9tv5wY2vH/OB3eOz81ducy6tHMZHx+XpLaDxi9DZ2xzc9OGRDHIhuIuh8Ol4bGZXDSUQ4eHh7W9va2VlRX7HhwVhILR0VF7fbpJXUgI+pzH41EqldJrr71mRb5qtar19XU9efJEwWDQhk1hhHiogUDAipv5fF6ff/65Wq2W/uiP/uiy22Zra2tLksy5NBoNffXVV/J6vQZbQY/t7e01emooFFIsFlOlUjEqJM6d7EOSOWLSZqQ8oCvyRzpvooJcgVr1ixcvzPBJaptn7grbuRleX1+fbt++bf0c7v5Laovwnz17plarpbm5uW+8fxx+oM+9vT2LupD3yOfzymazVicCdr1586Zp2+EMeU9g1IODg6ZX5fL6kdZBZBTIkHoZ7ysajWpmZsYaSwuFgmUrZHcXWVPV6tnI8D/8wz9UJBLRj3/8Y3388cd68eKF/vIv/1Ld3d02uhvSzFVYd7wX6pjFYtFkiWAoAbWQlQDRjYyMGIEEAwOcQy2FO3N0dGQzh5g3hHwP2a3bGwW0E4vFNDExoUAgoOfPn2tpaUkzMzOamprS3t6enj9/rpOTE6VSKfX395saczAYNFVlRiiQZWMc3YC2U+eCbUPfa3NzUw8ePJDf77fx3rlczjI5hsZNTk4qmUyaw3T7TBgHXyqV7DyjnQYbDYIUdxvHzjMjE+nq6jL4H7RnYGDA2g5gVyJPw+rq6tK1a9cUDAa1urpqfU6wfHt7e03B/sWLF/J4PPrOd77zW/fr0s4lFotJavfaYHhEJoeHhyYxPjEx0UZZhdXAhXQbkbh01WrViqD5fN4cgXROl4S3jUQHDCjXg+MgiApCoZANX3ry5ImOjo5ULpe1vLxsxpsokd9FtImOWi6X0+bmZseYN1RtMi8kwckuYMUUCoU2+iEXlEwCCI/Ig+X2DxCdu82uHESifpwFfSilUsmEOd3fDdQBjZUi6dHRkTWcwniDEs73Y4D8fr9yuZzJe3eyeDYEAdBMYS55vV6Vy2XrySBKZojcwMCAwXJEeTSl4lwIVtxzAIMKgUvonBhUInEmNwYCAaOIu9EjThYjJ8kCptu3b2t4eFj37983J/ngwQO74Ly+yxbsZLkZOnWm7e1tqx24qgLg8ECFdNK7ozGoaXBHLzb+IVLr9/sNq89ms9re3rasyY2kvV6vOXdgmlgsZrA6rEQycFobAoGAidciMivJAhyci/TNtLEurmKxKK/Xa1p5pVJJDx48MNgY4767u2uIDFkI9RYyEzJmbB+QJNAhDd4Eo7FYrK1JUjrP5Kk1UkPkfPIMYO6S7XF33QwbhiSOx63NYLNcUsZl1qWdC2k9rI6urrPpj0SApVJJgUDAZlpIMmPoYrQuLx3DSvNPpVLR5uam9RREIhHrHZDOokMiTJonq9WqOS6a3rLZrP2b1M755nL29/eb2CMRFd7c/X8OKuKHnXb4wmBjNggPPRAIKJlMqr+/X8lk0rIBMrR6va69vT1jnEhqMwQcBBw8zjkcDhvVVZL9Tkn2/W4WSup+cnI2gZLLzoHm5yA9cKEZF4wukms8m82mHXIozp1ebJ5TtVq1mRNQW90eq+npaYOePB5P28x3SAY829PTU3sGLoOOiJyLSG3v+PjYYGCK03fv3rXPRfGUswabj5qiSy3t7+/X7/3e7xkzMJ/PG4U5mUzq7t27RtOFtDA4ONhx1C2d3Z9W60yZeWNjw0glGF8mdY6OjrbBiZFIxOpKg4ODRnd3xWI5izwn4DQMPBBgNptVPp+3nyHbHh8fV3d3tzGnms1mm2AlhpKzQFDA/pER+P1+JZNJm5zo9Xo1OTlpzddXKehfv35dkqwJt6urS6+++qr8fr8xF6llkSET2Ln6dC60hPMhO4H9iCYY2UO9XjeY0D0DfEacESiPSyHmzrrFffaRrGZzc9MYqWjP4URRqr74u3/burRz4SESGXZ1dSmdTsvr9Wp3d1fFYtHSU6Ivt4ZCLwFG0IVRiOR7e3v12Wef6bPPPrOmMQpjFNBGR0etAFuv140aPTIyorGxMYso8vm8GRO8LzAZvH6of2RIXCYYPUQpYJNXwbzfeecdNRoNLSwsaGNjQ729vcasA3pCAw2uPmy2ra0tU0EA8kKdl+gYo+c2uDJznfcPdOYyycBuqY0dHh5qY2PDJDMuwqBkrOFwWPF4XM1mUxsbG6rX6zb+lQXR4/j4WBMTE7p+/XrHkXdXV5c5/e3tbSMxSDIJ/uvXr+sHP/iBTk5OtLq6qmq1ag2etVrNqKzQaIHKXIiBC+0KVaKA4DapVqtnQ+W++93v6nvf+57pdLVaLesbOjo6sm5uivcY7TfffFM/+MEPVK/XtbKyYlnxwMCAxsfH9Z3vfEcDAwMm0U+/y1VgsWQyqXq9roWFBT1+/FjT09P63d/9Xfn9fq2trWl/f1+Dg4OamJiw5k4ovejJDQ8PG2EDdAFDRq3IlW2h1kLvxs7OjrLZrEFhXq/XlAz29vZMpj6TyZjNgRFG9sez4l5Xq1Vtb2+3PVPeeyAQ0M2bNw2uo87ayXrzzTfVaJyNk1hcXNTIyIjee+89BQIBY12Fw2ETGwW+or6HiCvZllv/goADkQmNxkQiYYoF2CTXwAOVYadoTscuuLJEbh0VKJR67tLSkk5OTqz/yhWDTSaTpgXn3u/ftr7RsDCgF6J3PClv1v3gRLGkYMAUGEGiUNJbqLTSOQ2PjMVt4mHzwFORO0GSAu/sMnqY8AgHn9QTZ4F3B2ri3/hZHqAblXeyXO9/UYGAg8D74TMAkZ2cnFiRlMicCITIhYt3USGVZ0PkxoEH1gDGYZYMkSKv7T5P4AWcIgbfjcb4fMBl/P83acC6uHjG9XrdnMrIyIikcz06ghiXRimd0zmJiN0CvUsGcJ2o+8yIwIkKYU4BQ9CkFolE2ujuOO6LZAJgDwr4ZGLIIUWjUcv4gD75+1Wci6sP6EKl7r0lgnYVIth3zqa7D+wNRXipvcjs9kZJMid0sYhcq9WMlcl5plucrJg9h4ZP9kmNz6Xyc655nsDwV8n8qBO5xA2334meKOB4t1AvyRionDvumNsU2Wg0zLlQt4Ypy91z9x3bxF7zjF2SDnaLn3cdEg3kZHSu06PEILXDid96Qf/x48fyer1GY3QVQcEDpfPpZuiILSwsqNlsKhaLGXUZKCObzWpnZ8fwXSKPsbExHR8fm14OhotGtGQyqVdffVV9fX32cF+8eKGf//zn8ng8NuiJP9VqVYuLi6b4u7u7q9nZWZNJZ+PX19e1s7NjUQSaVNRDfpPa8GUWXfNkam7WQJbHoaBe4fOd6Y4dHh5aYdrj8ZgWEYV3skhJZtjogIZiTV8S2CzPi/kii4uL+uKLL9RqnYmPkikEAmfCpGijSbI6xPj4uF1YICMuOjTyZDJp2ef8/LwkmdLyN1npdNqy34WFBd2+fVt//ud/Lq/Xq1//+tdG537+/LldbpwzEB8Oxx25wMV3O/jdnqNg8ExeHpiVuhLn49GjR8pms8pkMnr77bfNyDabZ7NPent7rclVkm7cuKFUKqX9/X198cUX2t/f17Nnz3R4eKjXX39df/qnf6psNqtf/OIXqtfrmpqaMlgKp/rGG290dAY3NzclnZEi7t69q0QiYVAThpIGRmRgCMYIQNzxADgi5JK4G67iQSAQMESALGZvb88CD7/fb5TamZkZff/731ejcTbgizEXiJLG43Ej9TA+uFAomEEk+HQ75CVZ9pdIJJROpzt20JwpYGsK3TQalstlg8fc3wHVHIKJC6HSA0Ug5J4bsmhgZWBIxiMMDw8b6xSYGMIJ55qAh2DA4/HYCORIJGKZEZC4C6VBXScQYH+/dedycHAgj8fT1iSJwB+d7dJ5YZlU7ODgQKVSyTqWKQwRgcLsITqRZJ2hLo7KA6GDF8fBInX0+/0meU3xHziPTmDgCaAoIgn+TubCwyWKYuM7WdR/eMBuBONi1/w79SmUUhl0JZ0dVlhHOFeyPbIWV/WZCIYCPxkOz4pCXTabtQKhK37Je6QPh0iL7IcithsVEhFzcZAS73T/6Lrn/QaDQSONPHv2TNls1hSJeW9uBMnP8lo4T+jEbvTuZqhE0e7URKLnQCBgEh/RaFThcFher9dIDxgMno/H41E8HtfQ0JBWVlasSRVYLxQKaWpqyowVkj8uBHqVhWFgf6CQu1Rt3qvL5GTv6NOBzstrcY7ZU6/3fKici2q4RXyeA3uK+kQmk1GtVtPOzo41PxJBc6YpnhOckZVjW3iGBAkQPYj+O4VmORdkfm6jI7ATCIybBfN1Pr9LDeZzSbJGWzIKSgg4B1f1uaenx/TACHzcBlS3LcQl0bjnGdsGFEfzKfaR88YdcTOZy6xLOxdmGdTrdW1vb1tjGXCHa7Q4NB7PmUR6NpttYzrhUEjNa7WaTZrc2toy40kT1ejoqG0kePfKyooVtXmAMzMzhgujf7a8vGyyMdQFYL58/vnnajabJnPBZsOiCQQCunbtmhKJhDUndmocYeVw+MGLKa5zUDl8GAIXvqAxNZvN2t5MT08bWQLIx+Px2PMIBAKmiEBjpNQ+vIxiKXWeW7duWQEUA8FnRx7F4/EYdZJn5176QqEg6fxCFotFm4XSyfrpT39qMOjv//7va3x83HptIDzQKAZU5/V69c477+jGjRtmnHE0YNJkiJxZjBJwba1WUywWs070QqGgSCSia9euGe2YYutXX31lNS4XOuN9BQIBlUolyyhRpHXhvKdPn2p3d1fpdFrVatWmZGJoPB6P/uIv/qKjPaxUKlagp9eHHjQg7CdPnmhlZUWNRsOiYLL8SqVi+llkzgQyrr4gmH13d7fB19z569evK5PJWDbs3kmmiaKo4TKaiJwbjUbbZEnuAWw/kBXgNwJXCvAEHZ0s9w7D5HMzC+q90Px5/olEQslk0oLcWq1maEUoFNLo6KidIbIGgl8EeiORiJrNpkkt4QjQTqM+AiSM8onf7zfkAucA9A8cy9mGRUqtlxHXbgMrQcO77777W/fr0s6FzUFSheIYzXP1er2N2saFJZXHwDca50KH09PTmp2dVaPR0M7Ojo0ShnvvGr1UKmUp4cnJibEbiMqDwbNZ7ugZ9fT0aHl52QqlFOzdaZVPnjwxTah6va47d+5obm5OpVLJ4BU45EQFnTqXbDYr6ZyKTIQI5c/FvhuNhmVtsVjMUtZcLmfF0ZOTE42OjtqoAlJvHj7F+K6uLg0NDSkUCun58+cmgolCAdlkMBg0IcHZ2VklEgmL+HAuvC4dyHt7e1ZgPzg4MDICi34mt9mt05rVJ598Ir/fr5s3b+rWrVvWKc4sl0KhYEoMR0dHNmb5xo0b1mPiQpNE1GR+1IhwLrxnjJ/H49HOzo6xtq5fv67e3l5ls1mbCfP06VNJ7XN0eJ4nJycKhUIWZcJkow5G3YHRFvF4XMfHx/rss8+0ubnZJmba6aIgDCsJXB/DgbJGLpdrkxlCv29/f1/d3d0WWO7v7xs0BlXaZSzCCmW/MbQ9PT3a3d3Vl19+qWq1qsHBQSvC0yyM4oQ7GItA6Pnz56aoIJ0hJ8yR4nUYs8Fdop/pKs4FlQ+3tkm2xv11VdpBADKZjNLptMrlsimR7Ozs6ODgQDMzM6ahRgDLWcZpYB+kc/l7YEpJ5pwJENw7T98P9pTzSADF7+SeYzthqYJqQJkGir/M+kbCldIZNp1IJCxbAUYBZweqgtfNQ6/Vatra2rIUORQK6fj4WGtrazo5OTHqLcarUqmYE2K2Aykx0TsOjOI4DqC/v9+iRWiqvHdSPGZsY/BOT0+tZyYWi2lqaspYHDjPq6zBwUG1Wi2b6OdSNskwXJiA94ocDLgqDpc/fC6YNRhLVz0BZpU7kwMjy9cQB3XrQVwCGtXAyYnWwIyJvCBEULyWZIQFGFidLjKt/f195fN5o3TXajXrX8lms9ra2lIwGNS9e/cUCoVM3bdUKpmxYY+AVo+Pj80xEHW7Qn00sAILd3d3a3d316LCk5MTDQwM2Jlxqdj8l8JzuVzWo0ePDOIBh/d6vdra2lI+n2+LesPhsE5PT00J/CoFaX7PwMCAsTXX19fNOA4ODrbJB83MzCgSiSgSidhZyWazBmdTx+B94USRXwFawWG4vSkwwBqNc0Vkv99vyunRaNSeE87azTYxvK4Kt0tdhpnFkDkcKXXaThbOjLuDdA9ZBrAoQRiGGjr84eGh1tfXDdLmGQOX8b6i0ah9HoJngk2gQrds0Gg0TGqGeimBXrFYNIgWx+pCXthUd8yGdN5A7PP57M4gCXPZdWnn8uzZM/l8Pt2+fVvT09Pm+Vy8Oh6PK5PJqFKpqFwu6+DgwJzL8vKyvvjiC/l8Pr366qvWlPb06VPF43G99tprCoVCyuVyKpfLev78uTmVzz77TH7/2cjX27dvq1Kp6Pnz56rVaka9hT1Bk113d7fW19e1trZmURVYZ71eN0Xck5MTxeNxVatVZTIZUwpF4h1D5tJIO1lAM/fv3zdl1tHRUcsa3E54d/H7dnd3tbq6Kp/Pp9nZWUWjUfusdJb7/X7rCqbedXp6ajRasi6XPYMCq8tYAR7M5/O6f/++BgYGNDExYcJ4OP9KpaLe3l699957CoVCevLkiRYXF41S7bKxSMs7XTClNjc3VSqV2ogDd+7cUSKR0H/9r/9VH330kWZnZ/Uv/+W/1Pj4uGlfLS8v65NPPlGtVjPIhvHcuVxOf/u3f6uDgwO9//77unHjhhWly+WyNjc3zehPTU3p6OhI8/PzBo8AJf7zf/7PDVLgAru49eHhoX70ox/p6dOnunXrlt5++2319/ebgsBPf/pTPXnyxCioqAPE43HduHHDeio6XRMTE3ZPw+GwdnZ29NFHH0mS5ubm7O5Wq1UNDQ3phz/8oUZGRqy5L5/P69GjR+ZsT05OdOPGDd29e9fIFLVaTcPDw0qlUioWi0YRBkLN5XKWGeEMGKvdaDQ0OzurYDCoyclJy8jpOmcGEkXw6elpvfbaawaVu7WPvb09bW9vm7JCOBxWIpHQ0NBQx86FzFY6Iy4RvLKnKJvjaO7evWvqJK1WS7lcTr/85S/VarV07do1c4wU5YHJh4aG1NfXZ6QnGIk4JZc0xd8hf7z66qsmGQWUXqlU1NfXZ3OreN9I7qMkHQwGbeQ3pCCcYLVaNWd+2QDnG405po7i0u3cwpnL7CKFd5kT/Jtb3GPjMW4I6VEsJmUnJcaZUQQj66CxCiMGtMH7dp0CcAhUXVJa6J6uxhHvm9/Zac2AfaCg6b4ft5js1gH43RcphK6Ap4uDsjcU2F1yhSs9ThTi8/kMH3ZhnIvvx4XuqNO45AOenVs4d2mL/PxVu8vBizFMZM5ujY/3hdPma6T3ZFFuoyRRIEYUpWS3MOpG0BAciPD5nGR+fA2pc/6d8+iOVuaO8F45F+wV/0ZG1On54z38JliNc+YW39ljF7N3SRDSOUSEWsLFArJ7BqmBAElebEgGmkPPLxgMWqbjLveZU4fiXLpsMeq8rloE76mTdbFI7u4ne+LuzUUbSXDHM+cO8poEX9zPiw2qLuzN93GG+L0uRRzYnTaCi3VFl5bvIiEERxfbJtxzepl1aefi9lgAb/ChiH4ZZdzV1WVMnrW1NWWzWXk8Hutw5TCipuvxeEwSAlZULBZTOp1WrVYz5gRpXjQa1Z/92Z/J5zsbTra+vm4/4zYHgsm7UJP70KUzp0mj287OjvWHkAng5AYGBjQzM3PZ7fony9VHi0QiFtm7h5NmNTclBerr6uqyhq14PK6uri7T12o2m8b0SqfTplRANEj6jXEIh8O6fv267TtMLhphyV7i8bjGxsZspLHf71c2m7UaAOyWhYUFeb1n83l2d3et7gIGDeSIhFAnC/gORzY0NKQ333xTXq9XS0tLevjwoTY2NqxA/bOf/UzxeFzj4+NKJpMWSHR1nakik8nOz8/r4OBA6XTaeiyICIFhmC3COGU60ak3hEIh7ezs6C//8i8Vj8f13e9+V4lEQs+ePdOjR4+sE5pnidosTorppycnJ8biikQikmTzQT777DN9+umnkqT/6//6vzraw42NDYOXaAL9zne+o9PTUz19+lQPHz40ja9gMKiVlZU25V2v92wcOfpXMNzcgKLVaplaR7PZNMknJrCSlZHNNJtNTUxMWAT/5MkT9fX16caNG+rv77fhcKAPnAUIGpubm+rt7TXpnY2NDT179qxNZ3Bqasp6hzY2Njp2Lm4fT6t11og9OjqqRqOhtbU1owOjYgLrC8Pv8Xj07rvvWjsF/05ws7m5ac4Q9MFlqLpIQH9/v9GqqWs2m009efLEMgxqWDwPnAt2GlvSaDQssNrc3NTS0lIb+oBj5qx+687lYnMNHk1S21wFhmpFIhH19vZqc3PTDAPTJsHx+vv729gn0GUpvIELU4QnPQsGg7px44aCwaCWl5eNgeUWyznobiPR10V99XrdCpSs7u5uk3NnCBDGtNPFIcFhfV0EQPqLY0Qr6fT01Pp/iDCgvPLvYMuuUCRBAIaQXgAmX/I1aIgQNDiEyIcD/UiymlE8Hm8TkazVzgYfUfDjIlIbcXWeOlnUd3iW3d3dxhj78ssvtbi4aDBdo9HQ8vKydnd3TZvKbXgD+iwUCsZYAnOWZMxCsj0K+tvb2xZNurIbDLx68uSJ9bv4/X5VKhWtra0ZxEAUirPnfFK3QVIGuI8ze3p6qnw+r62trStlLkA4FNx7eno0Pj6uo6Mjffrpp1pdXW2jmLv1BO46kCJ9LjgR932dnJxof3/fAhWcKkoDg4OD1qPSbDbteZTLZeXzeYOyoA5Tj3FbBQiWgMz4PKenp9rd3TU7w95nMhmtrq5qbW2t4z0ks8BZ+P1+xeNx1et1PX/+3HS5YAvu7u5adkK2wllEdsXj8ZijRKsPIsnX2S2yCZhxsMbcM+L2aRFgQ4+mMdWdHUPG6POdjTfZ29szZw8MCyr0Teqml3YuZAB8KHDNWq1mkTaHihoF6ejo6KgxJShSk03wwOjhAFvt6+vTa6+9JknWkLe5uanNzU11dXVpcXHRjB6RD8XmTCajnp4eY6dxMDgQXu/Z+OKNjQ2DWZiKB9SC8UDuxp321snigBBlBYNBg6RwGDC4KJy2Wi2lUimLYhHEg+3jNgCSWQKhuKoC0GWhb3o8HuXzeYPPiGDYP5oMcQSwSTjYQJ7QffkM0WjUiARgzcAlrvxOJ+v111+XdC6OWKlU9OMf/9iYhkR8iURCAwMDunbtminCosgAnb7ZbLZBUzT28X4ZoBaJRFSr1WxWSG9vr77//e+bOnCr1dLo6KhisZid5d7eXlUqFa2srBj1l4tPLTCVSimZTJoQJZRferTcuhsMrEwmo9nZ2Y72jsXZRh4Io3h6ejb6dmpqyp5xV1eX9etQ/+HfgBZxyqgro5AB+sBZkc4DS2jQnEOfz2fY/8DAgNLptMlBuUET58bn82lwcNAaDfv7+9VqtfTgwQOjpk9MTFixneyQgAFn2MliuJ/LMFxaWrK6RCaTsb60VqultbU1eb1ejY+PK5VK2ed1+2R4b2Q7BLtoGjIp0m2C5D1w/8gyoGRjCwkMyEBoOKUO7o4i5/yT2ZPlu/C2m51eZl3auaALBssqm81a1kCktb+/b5pfSFF/97vf1d27d7WysmKS7kTKUNuQ2Q8EAsZEicVipgkEdviTn/xEX375pRqNhh4/fmyS8Ei4k4bTF+P1nnXTlkolLS4uqlqtWhS2ubmpFy9eKBAI2Nz0RCKhaDRqND8gs4ODAxPM7DTyJtqBKokj9vl8SqVSNqkTRtSTJ090enqq9957T+Pj49Zf5NI5XWFOIiS3v0U6c6rFYtGYOrCBcEBg29Fo1IqAblc1xrdcLlsQQSHWpUviIIGWyE4hQuD0OnUu3/3ud9VsNrW5uWkKyx9++KGazaZRqLlUg4ODunv3rmk1HR4eyu/32zhssiwCG+ifyNAHAmejFoaHh7W/v6/Hjx9rY2ND//yf/3P9+Z//uUqlkr766ivVajVdv37dNOrAxff29rS5uWmd6ARi0pnSQDKZ1NDQkKkOLC8v6/DwUD09PRoZGbGMxuM5G33L+WBOeqeLMwKEnM/n9eTJE9tDGhj5Q+EXGA9NQJyMx+MxFWAG152enrY5TogqmUzGomECKe4SitWgFShqQBpxnQvQL5m0dKYt98knn6hYLOrWrVs2KhrJKpQVrupccJDcGYaVtVotjY2NKZlMam9vT17vmUL3ixcvVKvVlEwmrU+lVqtZkI7yBwE5DpA+lng8rpGREavT0TRNFsHeoPqNWC0ZPlkyIp7Ar6Ojo4pGoxYQAXfRtDs8PGyEIJeEA2HisuvSzuVioeri1/Bsbh+BW3hyi078+bp0j9cljXQLyUTiFL/cohP/7hamgXi+ziHwGvyMW7xyO5C/rkh51eW+Np/1otHAWLE37ItbUHUjCPc13P9ejDTcwp/7mVxa928yYBd/n1vs5r8ue9B9Phff2zddULe/rkjqFs35fS6t2z23/N3dP/cZu4Vt3ivnGcPi1vTYNxeG5Q5c3HeWSw5wzxj/5j4X9tYlTVxlXXwebr2Es3+ReOKeUX72Yrf51+3fxWfi3nH3c7h3z+03Am24uFzCictGBI5y/53v6bTOcnHvXPvC/l0s4PPZ3HPA1y/eTb7PfZ8Xba37vNxFHYzX49zzTNxnwPfzMy5l3v03N7tyn1cn9s/T+jZ2/eV6uV6ul+vlermc1XlH1sv1cr1cL9fL9XL9hvXSubxcL9fL9XK9XN/6eulcXq6X6+V6uV6ub329dC4v18v1cr1cL9e3vl46l5fr5Xq5Xq6X61tfL53Ly/VyvVwv18v1ra+XzuXlerlerpfr5frW10vn8nK9XC/Xy/VyfevrpXN5uV6ul+vlerm+9fXSubxcL9fL9XK9XN/6eulcXq6X6+V6uV6ub329dC4v18v1cr1cL9e3vi6tivxv/s2/0enpqf72b/9Wv/jFLzQ4OKjr16+ru7tbvb296urq0tzcnG7fvq1yuawvv/xS+/v7puhZLBa1srJi0+z6+/uVTCaVTqe1ubmpv//7v1elUtHU1JRSqZTGxsZ07949HR4e6u/+7u+0trZmkvFI/0ciEf3FX/yF3n33Xf3d3/2d/u2//bfq6urS9773PaXTaeVyOeXzefX392toaEiNRkMff/yxlpeXdffuXb3//vsqlUr60Y9+pGw2q8HBQUUiEaVSKd28edPGrJ6cnOjZs2f64osv1Gg0lM/nv/FG/x//x/9hMvVMq9vd3ZXP57OBZCsrK3r+/Ln6+vo0OztrM0X6+vqUSCRs3kaxWNTx8bFevHihZ8+etQ0YYkwvY2WZIuf1ehUKhRQKhRSPx3Xr1i0FAgE9f/5cOzs7Ghwc1Pj4uEnAIwN+cHBgw4mazaby+bwODg70yiuv6J/9s38mj8ejQqFgMu3Imvf09KjRaGhzc1PlcrltLz788MNvvH//z//z/0iS/Y6enh4bq4Ci68HBgU3VXFxc1OnpqX7nd35Ht27dUrVaVaVSMSn5k5MT7e7uKpfL2fySer2uX//611paWtJrr72mP/3TP1Wz2dT9+/dVKBQ0NDSkTCajZDKpV199Vd3d3dra2mobNMdwK6T3eVZ7e3vy+/169913NT4+rp2dHa2srCgYDGpkZERdXV2an5/XysqKYrGYzZKXzmccISH/f/6f/+c33j9J+nf/7t/J6/Xq7t27mpqa+lp15FwuZ6MdwuGwgsGgYrGYBgYGbAx4rVZTPp/X0dGR9vf3ValUbJYIkw5PTk4UjUY1MjJir3t0dGR/IpGIZmZmbK4Rw9JQAkcNmBlDzDiSpKGhIQ0MDKhQKGh7e1sej8fGCRSLRVUqFYXDYY2OjtrIA3d6qMfj0cjIyDfev88//1ynp6f6q7/6K3344YcaHR3V22+/rYGBAY2OjiocDuvw8FAHBwfa2trS3//932t/f19/8id/orffflsPHjzQX/3VX8nr9eo73/mO0um0lpaWbKbOwcGBTYU8OTnRnTt39Ad/8Aeq1Wr65JNPlMvldOPGDc3NzSkej2tubk6BQECbm5s2U4c96u7ulsfj0dOnT/X8+XN1d3fbzKqbN28qlUrpiy++sImt//1//98rmUzqpz/9qT7++GObWRQMBvXd735XExMTKpVKNpfo//1//9/ful+Xdi6uhPPFWetItTOv+eKkSiTF+a8rk+/Od2YGifu9rgS4K8nNwDFX7t2VJf9Nkuru15DDZmIeP39R+p/hQK5k+zddrgS9dCaDjTz2Rdl/6VzmndECruy7O6WO98nidd3fdVGam9d3ZfOZQe7OSef7Xfly9vmiNLw7RuGi1Pe3sS6+1sUxCK40uPtvjC5gHy+eC/f9S+cz693BZhf3V5IZwotnypX/d4fOXZSYd/9cHF3hfq/7nq8qHc+zc9+r+2wvvq+Lox5+03u5KHF/8SxfXO4IjovrN42gcG3Gxa+77/M3Sdu739PpHjIjRZLdATeo4kwwCsIdH8BZufjZL9olXhubeHH0B8+BOSyuTeXzucu1z5zHr3vG7ntwz6w7voQZUN/6sLBsNmvDalKplFKplIaGhtTb22vDqwqFgv76r/9aoVBIk5OTCgaDevbsmdbW1lSpVFQul20+9MDAgLa3t3X//n2FQiG999578vl82t7eVj6fV1dXl00CDAaDisfjtgmRSETXrl1TOBzW0NCQWq2WRkZG9Ed/9Ec2jKdcLtvfq9WqVlZWdHp6alPiisWiefQ/+IM/UDAYbJtHQ8QeDocVjUZVKBSUTCbtcH3TlUwm7WBXq1UNDAwoEom0DfhigBATAr1er0ZHR5VMJlUqlbS3tyePx2NZysbGho2HbrVa8vl8mpiY0ODgoLa3t22WOBMXI5GIBgcH1Ww29eDBAzukPF+mX3J4eD/u901OTto0zM3NzTbjeHBwoGq1qnA4rHQ6rVarZcPjJLUNHvqmi1nkOItKpaKtrS0Fg0Fdv35d8XhcxWJRy8vLOjg4UC6XU71e18OHD5XL5SzTabVaNpSJKJlRw16vV++8845+7/d+z4ZcEakzHjqdTqtWq9mgMiYrMjXR5/NpYGBAPT09CoVCGhoassFVkmxYFiOkm82mZT5er1eDg4M2IZAsmTHhV3XWs7OzFlBcHGnc39+vYDCocDhsRprMaXd3V5ubm3ZvmVy4v7+v7u5uxePxtjHEDPFjoql7ZyKRiA3sc5GI7u5uHRwc2B5GIhEbykUwGY1G7Zxzt8PhsGVU9XrdBtaBpuDgAoGAjo+PLYseGxv7xvu3uLioRqOheDyud955R+VyWR999JF8Pp9u3rypeDyuUqmkQqEgr9er6elps0X/+I//qNPTU01OTtr48q2tLRUKBe3v79sdDgQCunnzpjKZjBKJhN39g4MD5fN5dXd3q9U6m6j78OFDdXV16caNG0qn09rf31c2mzW7wfA5zjLD2tLptKLRqEKhkDyes0mpW1tbOj4+ltfr1djYmEqlku1nOp3WyMiIRkdHv9GwxEs7F8Zg+nw+xeNxxeNxmwA4NDSkvr4+ra2t6aOPPtLo6KjeeOMNJRIJzc/PK5fLWbpIptDX16f5+Xl9/vnnmpmZ0Q9/+ENFo1H96Ec/0sLCgrq7uy3lDQQCikQiNkI3k8no3Xff1cDAgBm/ZDKpt99+WwcHB3rx4oVBIF6v12AJpjG2Wi2Vy2Wtrq5qeHhYf/zHf6yRkRHt7e2pVCopl8vZhL5UKmVTGhln28lihjpzzJmY6PV6dXJyYiNGg8GgDg4OtLm52TbMzOfzaWdnR9J59JXP51UsFiXJoKtMJqObN2/K7/drZWXFhihxGaPRqPb29vTixQudnJxocHBQ4XBYpVJJ29vb8vl8SiaTNtWxu7vbxhwDaUajUVUqFYMH+/r6DH7Y39+3n5VkGS2ZV6dRI5cKR3lwcKCVlRX19vbq9u3bisfjBsMdHR3ZpEm+Njg4qKmpKfn9fp2cnJiT4r2dnJwoGAzqzp07unXrlgqFgjY3NyWdZ5EY0u3tbX355ZeqVqu6e/euRkdHdXh4qEKhYEaQPejt7TX4sdFoKBAIqKury5zPycmJ9vb27CLHYjEzihjxQqGg3t5eMwadrtHRUYOostmsurq6bIooM91DoZA9MwKt7e1t5XI5u4NMQSyXyzaG242EcR4ETe4zD4VCikajOjk5UbFYVKvVUjgcttHO1WrVIm3QCSJmggOeic/nU19fn05PT1WtVm3KbU9Pj4LBoKEYjAI+OjpSpVLpePDfxsaGPB6PBgYGlMlkdP/+ff3d3/2dBSrpdFr5fF7b29vKZDL6gz/4A4XDYX355ZdaXFxUMpnUtWvX5PV6Db4rlUoWPPCer1+/rnv37lnWcXJyouPjY5VKJZukCYzW3d2t4eFh3bx5UysrKyoWi/L5fBodHVUwGLSpoAQLTLjs6+uzPT89PVUul1O1WrVJn8FgUMVi0c58Mpm0QPuyDubSzoWxmIVCQX6/X7VaTdls1mY19/X16eDgwA7f/Py8tra2dHh4qEgkYvir3++38cGtVsvedLVa1fHxsSYnJ9vGubZaLYVCIXV3dysSiRjO/vjxY8PK/X6/jo+PValUdHx8bPgu6V0oFNLw8LCazaaWl5dVKBTMYx8dHSmbzcrj8ahcLqtSqVhU1mg0lMvldHx8rEKhYBlDJ4s56UdHR6pWq20pNhh9NpvV/v6+jY72+/2q1+sW9UqyMbUufEfGxYErFouq1WqGQ5MhhcNhnZ6eyuPxKBaL6fT0VF6vV4eHh+rr69OtW7cs8ma+N9E9KTrQISNpuey1Wk1HR0c2FpcIkwidrKbTxWhlDJc77RKnJsnee6t1Np6ZWes9PT32taOjI5taGAwGbax1q9WyetjBwYFKpZKOj4/NgGYyGUUiER0fHysWi+n4+NieUSAQMMfAxeV8uQbt8PBQxWJRR0dHBmH29/dbtlypVBQKhWxmfTgcls/nU7VatTN01UU9jPHkZBzu5FgXLsUZ4iw8Ho96enoM6iFgwphzdjkDBBUXoXSyUTc7YSRvT09PmyElM5TOAg2yKkltdgBovdVq6eTkpA2yw+F1GuD09PRIkorFora2tlQulzU8PGw2yuv1WtaZTCYVj8cVDoc1NjbWVtfjHLZaLQtEcLaSLEvhjvn9/jbEoK+vT8fHx/a+FhYWVK/XtbCwoM3NTfX29uro6MjeE8/z5ORE1WrVgpnj42O9/vrr9jyB41guhCZJ29vbmp+fV6vV0s2bN3/rfl3auTDHfW9vz4z38+fP5fP5rFBUqVQUiUR0cnKi//bf/puks/RzbGxMiURCExMTqlar+sUvfqGFhQUNDAzo9u3bGhgYsPnx77//viYnJ/XkyRN9+OGHOj09NYMxNjam0dFRzc/P69/9u3+n3d1dO2gU6yRZdBsOh63Y9md/9mcKBoP64IMPtLCwoHw+r/X1dRUKBT158kRbW1tm+CuVinZ2dtRoNLS/v69AIKB8Pm/ZWycLZ1ooFAyyq1arVvitVqsWoTB7HMO1t7dn0VlXV5euXbtmDgZYClggm81a9hONRuX3+zU1NaX+/n7l83nt7u7K4/FocnJS9XrdZr3funVL3/3udxUIBAxDXlpaMhIG4327u7vt7319fTo5ObHi7t7enra2tizg6OrqUjweVyAQMAig08xvYGBAzWZTh4eH9qwxGsVi0bDgoaEhVatVM9h9fX3q6ekxI9doNLS7u2tF5VgspsPDQ+VyObVaLYM1stms1tbW5Pf7dePGDXMu6XTa9hRY6PT0VH19fRoZGWmbWb66uqr19fW24GB3d9cQAAwqTvrRo0d68eKFGSaiUukMknn06NGVnYvX61UkErGAg30EhiPzIPjxeDzq6+szA9rb26tGo2E/f3R0pI2NDfn9fstgcS5kvWTafGbOEw6Cr/X391vWxvnf39/X4eFhW0E/k8mY88JBAzG6NQkyf5xiMBhUJBLp2LkMDg6qVqvp8ePH+uqrrxSPx/Xqq68qEAhYTS+dThsBZ3p62mbbX79+Xfl8XgsLC6pWq+ZkJiYmNDw8rHw+r08++cQ+p8fjUSKR0Pj4uILBoL7zne8Y6aHRaGhvb0/SmSP6+c9/rr/6q7/S4eGhSqWS4vG4ZmZm7HlxRsvlsg4ODvTpp59qZWVF3/ve9/Qv/sW/0MnJiR4+fKhSqWTO/OJIZ6/Xq6+++kp///d/r1qtpv/lf/lffut+Xdq59Pf3q16vt0UMbqHcLaJiBCTZ4QQDJYU8Pj5WNBpVOBxWT0+PfSg2r16vW4Qfi8VsozAsbmQPpOAeNqCn/v5+q2O4BWw3OiLCJLVutVrq7u5Wo9Gw1+ICdLqIrA8PD82pkAlx0FwCARdCUlsxmuUWiT0ej0VuONuenh719fVZdNrd3W0GhLnvGAKcBQeKz0zEyqF2i9VEQhQveZ/u//O9Lomg04sNlOWSHPx+f9vzIXIlGqZg7ZJI+Duf4fT0VI1Gw6JSMlpen8AFo3eR2AK8dnJyosPDQ4MfA4GAPWf+AOsdHR3Ze8fgSrLX4dy57Caiz06ds3Q+B90t8H7djHb2in12SRwYb84o0PNFUgpRr+sMCYRwWu59ckk80vmZdzMozg+OzyUWuP/GXXcJAC4p6CqkHBwydTMCuEqlYgV23sPJyYlOTk7k9/sVCoVUqVTs/WLneN84Z/a9VCqZU3ADEbI5Mm2QjVKpZPaTLK9cLts+VqtVFYtFQzZKpZJBkDzPi/aNc8Jz5DVAM37burRzuXv3rk5PT/Xs2TNVq1WFQiGl02nDiXt6erS0tKStrS3Dlv1+v4aHh3Xt2jUdHR1pcXFR+/v7thHRaFTXr183uKhcLutHP/qR6vW6CoWC1tbWFI1G9eabb2pqakrlclk7Ozvq7e01jwuVlpSvu7tbY2Nj6u/vN9poPp/Xv//3/177+/tGpR0aGtI777wjj8djhl6SERaAiDgMS0tLktTx5X7y5IkajYYqlYqRBXh4IyMj6u7uNgw2GAwarTOfz9tBA3ahzoSxGRgY0OzsrAYGBjQ3N6ehoSErXtZqNSMDUMgmLff5fJqcnNTs7Kyq1ar+8R//UV1dXRofHzdsPBKJaGdnR1988YXq9bpSqZTh8AsLC/J6vXbBXGPNYSWaOjg4MBilk/Xll18aBOZmpqFQSBMTExoZGbHMTZIVend3d1UqldTf3694PG41w2g0qnw+r0ePHikej+uNN94wOPbg4EB9fX16/fXXzYnm83m7tPl83iBfApRKpaJcLqdgMKjJyUkrZnd1dalUKmlzc1ONRsNqbGSiwGk+n0+FQkHValU+n0+ZTMbqCVCvcTSdrpOTE/t5In+cw0UIpF6vG1zbarUsAARS7u3tVV9fnwYGBpRIJOx3eDweC+gwnjiORqNhVGTqOziAVqtlkKF0ns0AhZMJY7QrlYoFmaenp8rn8zo5OZF05oh6e3uNaICTxvB2ujCqr776qm7duqXu7m719/erVqvp2bNnbUX6cDiscrmsSCSi8fFxJZNJc0xAYIeHh9rf39f6+roGBgb01ltvyefz6bPPPtNnn32mmZkZDQwMyO/3a3d3V6enp0omk0qlUoYSFAoFNZvNtkzd7/frwYMHmp+ft8CScsHJyYkODg6MEPTRRx8ZfdwNuHiOXV1dbQ7565h8v2ld2rmkUikz3nhaWDHRaNQiZh4wxfe+vj7FYjGDf/b391WtVtVsNtXd3a1EIqFqtWqY/NLSkra3t61+QAFtaGhIJycn2t7eVigU0u3btw0OAq8ulUoKhULKZDJW4xkaGtLR0ZEePnxokATwCXWYzc1Nw8+BpIaHh9XV1WWReKVSUV9fX8fOBaN3eHio4+Njq1twQIEZyA7B2il6UrwEn3YXJIdYLKbh4WENDw9bHQXjThRN5I4D4PKurq5qdXXValvUaPr7+83IuBnM/v6+Njc31dXVZWwU6ZxswAHEcZMNXAVW5PXIVMmIw+GwIpGIent72zK/Wq2m09NTY2OFw2HLaCFI5HI59fb2Gjsnl8upUqmot7dXqVRK9Xpd6+vrOjo6MkNYKpWsvtdsNhUMBrWzs6P5+Xl1dXVJkjHz4vG4GU7OdFdXlw4PD1WpVBQMBg2KIpMFFurr67P6kEv373QR0bv9M/xxs1IW+0fk3Gg0jFHE2SWCh27r8XgMZQARkNTWenBycmJROBkZLD63PsXvcbM8onXsDGw0+sfcDIX/XszSOt1D3lc6nVZ/f7+9x6OjI9tTelywF0CQyWSybX9dm1cqlTQ6OqpMJqPe3l796le/0vb2ttX3vF6vSqWS9Q7xuyqViiqVirq7u9vKAvV6Xfl83oKS7u5uHR0daWdnx4gpgUBAh4eHdodBNtw76pIiLlLsL7Mu7VwWFhbUaDSUSCT0/vvvW22i0WgoGo3aQwSqwqBsbm4qFArZ5cPIUfinCWtlZUX7+/va2dlRpVIx59Xf328RK1BFtVrVwsKCTk9Ptb6+rnw+r3K5bFQ9fnZtbU2hUMjosET/oVBIMzMzmp6eVrFY1KeffqqdnR37fRQCOfwej0fVatWw506WC6VQHzg8PDT4r1arqb+/3yIQIMHu7m4NDg4aDEjaTDQ5NDSknp4elctlK9Dv7e1Z5kLkGAqFJMkyyt7eXoPRms2mwuGw5ubmJJ2xR6DPcjBnZ2fN2KysrFik6EIFRGjd3d26f/++JJlju0oxX5JGRkbMAFGfIiv58MMPNTAwoN3dXe3u7qq3t1fj4+OW+XEeqdF1d3erp6dHg4ODunbtmjEdd3d3FQqFjPgwPz+ver1ucFc+nzejsL29bSw/3hd7IcmMLYHE9PS06vW6sbOA04i+YfbA8hjsKQABAABJREFUCPvZz35mNQIK8KOjo1eCxWAHSbKgCWcmqY2d2Gq1LJgi25bOe1oINLj3bpGa5t2joyOVSiX7PW5me3x8bNGySxwhwwHSwfDRaMmdcOEan8+nwcHBtvfPc8YpUodxqfbfdKXTaXu2RP/AUjs7O2a8qTPu7e3p8PBQHo9Hm5ubKhQKWl1dtc+QSqXU399vNeXHjx+r2WwaqcM1+Pv7+yqXyyoWi7p//74x/kBcyDAIWufm5gy2i0QiKpfLWl5ebjuzQ0NDCofDlsUAk7mkHY/Ho6WlJeVyOUnS7/3e7337fS7Pnj2Tx+NRKpXS5OSkFhcX9Y//+I+W+uJYwLqhHa+urho77NmzZ8YQ4+CWy2Xt7u7qxYsXxs45OTkxb09KTLYTCARUKpW0tLSko6Mjra2tGV1zZ2fHIsCenp62XgbqKOPj40qn07p9+7bm5ua0tLSk1dVVPX36VMPDw8Yrp5BPVF6v160HoJOFUeBSnJycaH9/33BZDmUymdT+/r4eP36so6Mji37c6BLDwOFpNBoqFova29uzXiKcSzAYtPSaPgU477CQarWaotGoUqmUjo+P2xh10lkUfuPGDbVaLX3++edaX19XuVy2w0g0PDMzo0gkorW1NX3wwQfWz9Pd3W2RZqewzvj4uGUN8Pmz2ayq1aqePXumZrNp1N+hoSGNjY2pr69Pjx49sjpavV63LAX+fjQaVbVa1eLiojwej+7du6ehoSGtra3p4cOHVo/xer3a2NjQxsaGkTHq9brK5bIxc8LhsMGDwGlEtdeuXZOktuyvXq/bnSET8/v9Wltb09/93d+p2WzqlVdesUgZhYZOF3Ul2FdkABhptwYUCAQ0MDAgj8ejUqmkUqlkWaokHR8fW4BD5kJ2St2LgM+FxjDwQLpkHdVq1e48cObh4aE5idPTUzOkMM8kmXNJp9Nf27AKa8ytbXa6YIZtb2+rWCxaJkrrwObmpsLhsFKplFHMa7WaNjY25PP5tL+/r93dXfX09Oidd95RJpNRJpPR0NCQcrmcPvroIwsIYTniHGmRWFlZ0fr6uu0h2ZkkC6wjkYjefvttZTIZDQ8PK51Oq1Ao6NGjR/Z+T05OFAqFNDAwYOophUJBo6OjtpfY0IWFBR0dHenVV1/VD3/4Q6sF/7Z1aedCwbxYLGpnZ0d7e3t2qJAtgPpJhMQlIzUGlkgmk4aBh8NhSdLExIRBLXt7e5ZyE+WDV5OqcZihMBNF0WTIgaZ4yKWHtprNZrW4uKjt7W0Fg0FFo1Elk0kNDQ1JkhXcyBRc6nAniwfCnvB+eX2MlXSeerppvVss53Nx0blsfE4uNzTScDhsjpGfdZknvAb/z/cAXfDeyah4nv39/XYAcVKcAyJUuPGlUkm7u7tXutxQhanZ4fjJ8vr7+xWNRq1WAR3dzdICgYA10lL3coup0hk1vNVqWWBDBAwbkmIpZ+/k5MQuNq9B3REGFXcCiNEtoLp9NsDL7BO1L5/Pd6V6gXReZ5HOIR6XyMEeu+eEM+hmzrxnHAYwKCwz7ibUcZcIIMkMfalUautod+8yv9ttkHTpzBhU7gzP8iLUx+e9SK/uZG1vb6vZbGpra8tqcGRUUPhhh4EiuLAwUjrYNkgzfX19qtVqJouVzWbNoa+vr0uSMS+LxaJ2d3ftdXGePD9qUNDak8mknf1EIqG+vj4VCgXLtAkIQIhwaJwRv9+vRCJh3/NNHPSlnQs1j//yX/6LPvjgAw0PD+vNN99Uq9XS/fv3lc1mlclkdPv2bdVqNRUKBZ2enlqhs7+/X6+//rplD+FwWJlMxuCOt99+W0dHR/qbv/kbff7559a4SPQElBaNRm1DeH3otX19fVZ0xDjyEIHhlpeXtbW1pefPn+vDDz+U13vWFZ3JZHTr1i3Nzs5qY2NDv/rVr3R8fKyDgwOD+q5CA73ocCUZRo1zBqqh7kIRs6ury2oHMDaq1aqi0aipIwwODloDHzROUtvJyUmDY2hO/eijj3RwcGB9DmRQFJtbrVZbEZzIsVgsKpfLKZlManJy0rIwNIegTlPDeuWVV3Tjxg09fPhQn376acd9QjirtbU1vXjxQpFIRFNTU/L5fAZbpVIpiy4pgNKtjIGHYn14eKjh4WHrZL5+/bpBrmtra+ru7tbt27fb6LrJZFKjo6NaXl7WkydPrFGTi9fT02P9H9Ch6U8gayBqJKs5OjrS6uqqjo+PLUullun3+3Xt2jXdunVLa2trBk13uuj14RnTV8L9ch0AUB9MxMHBQTMqOAI34IFKLMk06Xw+n6LRqCRZAABEWiwW9ejRI2ONEqi6sBW0eJiW0rm8UVdXlzVFc+6DwaARPlwHBcuUz96pc/nrv/5rtVotU8YgSAwGg5qentbo6KhCoZARQ8g6Xrx4oY2NDaVSKcXjcWNwQqGmTjo7O6vDw0P9+3//77W4uKi9vT09fvxYkUhE3//+902DEMjt+fPnFtR5vV4NDAxIOrMxjx8/tp4XnNa9e/dUr9e1srLShva0Wi3dunVLktrYjdQT79y5o1QqZYSqb9258NCLxaLW1taMWizJilJgiESyRHvAXMgyhMNh9fX1Gd7IBa5Wq9Y9yh8arShGEn2yieC5RFcceDbczRgwhLBWSqWSenp6NDo6qr6+PsXjcaVSKTvMHE4irauk1W4RnoPnRoGuPhEFfJcyKp0/eCK8vr6+tu+n2M/faR5EsJJaA0bx9PS0DYd33597iV2Ywc3oXGMFxEIBmp/v6+sz4/FNmCYXF8+ZZlm6sF0dJthLcPqBUTgz3d3dVq+hWZWIm0sL6xC5GDIbMmIXcnXrSLyOqwcFjAQ1nMVruvsJfEthFrzd7cw/PDy8knOhmO1S2Pls1EvcDMalDIMWcA/5HndRe3FrOWRhblBBPQq5F1fXj3oN75dn72YsIBQXacm8tstO4/s4e1eBFYvFoprNM/HWnZ0dc8Td3d2anp624IJMl7PJvezp6bFgjffI1/1+v2KxmI6OjtoklyBzBINBs5c0nQNnsreuneIc828+n8/quf39/ZbdsM80p9NT5JIqotGoMpmMZWqXDbIv7Vz+43/8j+b1iOSQCwiFQkokEiYJs7+/r6WlJYMOpDNtrd/5nd9Rq9WyAvr3vvc9Xb9+3Q59MBjU3NycfL4zCRIw5kqlouXlZU1PT2tyctIeqCulwSbTI8DGkEqTio6OjioSifwTKRg2NBKJqL+/34wh2lE0j3bqXOj74X0BHbnspmq1qq2tLXugLsPF7Y+Jx+Pyer2G19K4Bz6+vb1txhGn6ff7TcEX5+k6nEQioUgkoqOjIy0sLJjS7fHxsUn8NBoNra6uGq6OWgMBAs2nHo9HMzMz6urqUrlc1pMnT0yWpVPjSIGXPdvf39ezZ8/aaLQQFSjCu7ApZyAYDGp0dFTxeFxTU1P2Ptk/HJZLZXVrKJAIMHicw3g8ruHhYYVCIQ0ODlrEiGRKX1+fRdHg8Vxul+WGhtn09LR97vn5eT19+lSPHz/uOPOT1MawAlLlDpD9EYy40JMLo+KE3CAGxhbPiPomcBjBHBluLpdTqVSy1+FZ0SPEeQ4Gg5aFw2LEeZOhEGHncjlzzNgnshVUF9zP3cmanp5WrVbT1taWisWiBa/NZlPr6+s6PDzU4OCg0um0ZcDQ/7FLlAFo2kb9GufabDY1Pj6u27dvm1EH7lteXlYgENCtW7fU39+vpaUlQzeAYLHF77zzjoaHhzU5Oane3t42IlA8Hld/f79B1mj1EeB0dXWZFFYwGLR6d7FY1OLi4rff5/LBBx/YIcR4AztQKI5EIgqHwyaxQW+DdFYUvn37to6OjvTXf/3XevDggW7fvm2HEMojPR9DQ0O6fv26jo6O9MEHHyibzWp6elqpVMrYZG5D00Vc1sWHMRo9PT1mkCuVimGP9ObAqiJjks5kbwYGBto49J0snCzvm4tKZkLUnM/nrdsbGKfZbBpDp9VqGeMtnU5rdHS0De/e2trS1taWQqGQRemHh4fq7e3V1taWlpeXJckiKwxuLBbT5OSkZXQ4wJOTEw0MDJjwZiaT0cHBgfUr9fT0KJ1Oq6enR9lsVuvr60okEpqbmzPKLb0hHNJOFnUSoESovJKMot3X16dyuWyQKX9OTk4s0/Z4PBocHNTp6amGhoY0NDTUxjxyG0jJXNzm3nK53FazIbgJh8N2aRELTCQS5sBd5wXEyF6AABDRBoNBc+aIO66trWl1dfVKzoW7CN2evh3XGfNvLuWUTIPzAIKAQeQ881quPAsZBOoTSKdwFghSUaag9tXdfT7Kg+CLqL9SqZhjIVJHUysajdpzZj8hDMDG7DR7IXr3+XwGl1OLRqWC1om9vT09ePBA5XLZiCPsLWy5YrFoTZZkvbAGJycnNTExoXv37qlareqXv/ylstmsQb8EIfQcQgnnrN24cUMzMzO2h26GQ5sDmf7h4aGWl5dNNLTVahm0CTQJY21ra+vbdy43b95Us3mmprqzs2MsDpc7XqlUjE0DLXV7e9vqL0T+U1NTluZd7K0gOoXzXq/XlUgkTP8I+t3Q0JApqUJpdg+sS6l0U/X9/X2rCWDcM5mMUXh/+ctfmscmkuT/R0dHr0xFpmiLbpDH47EiHwYf7N9tRgRikGTZFT06RJDN5pnCrhstHR8fa2VlxTjxvD4RofvabrbmEjWOj4+1sLBgBwx6JLAaekfI7RDtuKQFj8djGWanC+NP/1G9fqbpheZXIBBQsVi0zCMUCpkzQt+OS8X7WF9ft/2Acg47sVwuy+fzGVW2VCoZm4fGYc5rT09PW/Nub2+v0YglWXc2xV2Uht0ObeA8l7pNxg2T6ir7R4BE1oFzIfrFENGPQs8J9S7gE9c4u47cJYNggCjK40CAq/lZDBc/58LAUvuYAJASfoasyCVmANNK7T1XZAd8vZOFwxofH9frr79uxtaF5bGFCKq6JAxkiLq6unT9+nWrEwInwx7lfLlMrY2NDRUKBZVKJfs7jpisD6eSSqXsPLvwnEt04A9BBEEvRAK0FF2Wan9/v0ZHRy8d4FzaufzRH/2RTk9P9eGHH1oHMx+OukQ2m1W5XFY8Htdrr72m7u5u/eIXv1ClUjG4pa+vT++++666urqUz+f12WefWYc0lxXHgk7WxMSEQUNQom/fvm2put/v1/r6usnPYzTdTcTIZLNZizBo+Lp27Zp6e3v1+PFj/eQnP1EymdSNGzfk9Xq1s7Ojw8NDZTIZzc3NXbqB6OLC6UEfJsIgXZXOL32j0TDhTORxXGx2eHhYiURCS0tLevbsWZtxRMIbAwANmOI8WQ8RO8PQqIWRiXR3d2tnZ8eM6pMnTwxv5wLBmUd5lUY26cyY4lA4uOg/dbIwXAQlFMP9/jPtr8nJSb148ULz8/NWvCQDJftMpVIWHXo8HhsAR6bsinXu7+9re3tbkixK3tzcNMbQxMSEwcS7u7sKh8N67bXXDGrA0JBlbW9vt+nJLS0t6cmTJ/L7/RoZGTGxQaAlItpEImGjJdyCeyeLngsYl6iFe71ejY+Pmy4gjMC1tTWdnJyYPht7KMlqVrxXnD3woVvzZNQFZAYWRpH/QuWmDgRsRmbHmXJpzaenp229QjBCcWgez7ligMvC62QBvb7++ut65ZVX9PDhQ/2n//SfdHJyYqQNfkcsFtMbb7yhYDCo58+fa2NjwwKv/v5+vfXWWwbPgwI8e/ZMx8fHCofDGh8f19bWlj744AMdHBxodXXV9pAG6YmJCfl8Zxp2hUJB6XRaf/iHf6hIJGLQOcgOcLQbLOCY2eNa7Uw89+nTp9bH6LIGU6mUXnvttW+/5uJ2EuMJwYwvpkl8H+wk0jX4/OFw2FK6crls2KjrSd1DBPwA5c+l6LqwEgV9fp4L7kZKF98fPwOGyx/SdC4auK1bmP8my70QGGmalIAPiX7cBjc+Mz0F/B3Gj9vMJp0bQhaRHpedjJNMCSkVoAucsFs4dWERDiMRN8EANSXYUpwN3hfReacLGImolVoPrBt+F46Megs1Areoy0VzI223UA2cgnFij4GDJFlA5XZHYxg5f64j5lmSYQPVoG3n9/vNQEMzpZYhyYzXVZzLxWI9r+tm+uyxq6jgZv/UvNg73vNFarJbVHf7TNzv/bqeFH6W3wNpxIV13O9zPxsB5cUiP07uKsV86Tzzc2u93GG3UdQlw+DIXVvFPac5lnPmoghuuYBaFAw593tdkoNbf+Qc8X4IWF1nzv4TTBHYcCbds0I2ir24zLr0bWd4jHSmUFsqlfTf/tt/s83w+8+kw1EFhc4ai8U0Nzen69ev64033jAeNUXrGzdu2JuHVgirjIfCAY3FYhoZGVG5XNbz589tpgRaRSMjI3aBG42GJiYmNDo6qmKxqBcvXlgjZCqVUiwWUzqdVrlc1scff6y9vT319fVpbGxMp6en+uKLL+yQ1+t1G2wmqaMxs0SNYMzSWW9Pq9WyBqbx8XHTBdvd3TUqtHRW9J2dnbX3sri4aE7JZZnt7+9bHwoGrq+vT8lkUiMjI6ayiiw+0OPu7q4ZHHB1Di/KvcA2GEii8g8//NCUBEZGRqzZi+ZMoB2K2p0spL6h8abTab3zzjsGwc3Pz8vr9Wpubk4nJyd68uSJOelWq6VUKmVUzWw2a/WBwcFBcw5EcBgppHfYF2b74FDdix8KhaxxmK/19/crFApZNH9wcKD5+XnL8BFKRX0ZAkalUtHS0pK8Xq/NOvH5fCYl0+lCYQID093dbeOOJVkPEbRyghAKxgcHB0b7R+uMoExSWzBCXYJeFlijBwcHBi2y5+5nYk/ow0Bp2mV6cdYx4q5DJ/OinsgzvRhodrKWl5fl9XqtPy8UCmlubs76nqhBQjrK5/OGuEjt0insAWQaSESuUy+VSurr61NXV5dB94wfB7aE2ZhKpdRqtfTixQv19/cbuYT+lkKhoA8++MB+ttFoaGhoSFNTU8rn8/rJT36inZ0dTU1N6e2339bW1pa++uoreb1eUzyfn5/Xp59+qkajof/tf/vffut+Xdq5kGqSEVBfkc6kOeij4L8cAIQtofmi+cTGwkiiUETxDpVfDqskK+oRRXOwIRYw8IjDDofc6/VajwBGjo50qIUbGxuamZlRJpNRoVAweRMuDJFwp4u9I/rhs4LDu3IXRNvQXWmwgyyxvLxsDYkYPvYb/JvL6OLp9FH4/X6LmjCkZAZkgcASRD5AE0T0RPKnp6fGcKP2wtx4ahFEahiJThb6YES9MP/8fr8WFhZUKpUUi8WsYRNWHIEMjWrNZtOYMNDh3cjPpcRCoOA9h0Ih08lDWwxqKBmnS2+GUuo2lu7t7RncyPMjgOA50dPk8/msqdB9Bp0uEAKyB84U2TNnHMNOIOjeAaahMhmWnyErdrMjMli3qZboV2qn5GN0QR74Hvfzs3j/oBVuBuRmV24twc0mO13AcpB+EB31+/3G/iOwkM5JPLx/Pq8kk06i/koGWa/XDT4E6fH7/dbHRu0UkVuyXtAk2gzc/iVqiRsbG6ZqzPMfGRnR8fGxNjY2tL6+rsnJSaXTaYMb3WdcLBa1ubn57Rf0kccYHh7WrVu3ND8/r93dXdXrdcViMRvPCk0UZksymVQ0GrV6CgeDN01WQhrNoSCVDgQCSiQSxgijgRC2y+npqSmDYsATiYQCgYDJx5ycnGhsbEyNRkPJZNIot0iDvPbaa7pz545Fml6vV6urq1bnCAaDSiQSSqVSHR/OO3fuGKxC2gtvnvG5fr/fMkSEGBlKtLOzYwV2vgfj715s6I5ARGSHyDqgzgociIyFCytgaJaXl7W0tGSv22w27VATmUtqu/xurajROBsJ61KeO92/P/7jP1ardTYPp1Kp2LCzVqtlc36o03k8Hr3yyitqNs+Gw21vb5seGBABNFfX2cI+dMdKSOcwDH0u1WrV2EGSzEnxzDAIhUJBi4uLOjw81M7OjkXU8XhcAwMDVrSl4RND6WZQwGpocV1lAatBWjg+Ptb29nYbTRsnAsmG4M/N0Agk2DMcA/8lI+nu7lYoFLK6KPU76bw3DogTBwaMRNYBu8qFtshUqJ9xLlqtlv1so3EmISPJoHfOoCQ7u99kod5BwydBS29vr+bm5tTd3W2NzS6VmzsJEYfaXr1et1op5wB2J5p0d+/eNQaa1+vV06dPtbq6ag7IhQpduSHONplTV1eX7ty5Y4EAAUIqlVIgENB7772nfD6v2dlZhcNhE8Gt188kjhYXFxUIBPTmm29++zWXFy9eKBgM6pVXXtHv/u7vamBgwPSj4GMT8R4eHuqrr77S4eGhfvd3f1eTk5Nfq/Xl4rZuPQSskV4LvDad/9DwwCsZtwtLg16WVCplvPLx8XErPsfjca2srOjJkyeKRCJ6//33rSDtzuRAYqS3t1c3b97U22+/3XHd4JVXXmnDU10ZdjR+fD6f9vb2FAgErLM5n88bbbFcLttBo3iJoXSlWjCSpMS3bt0yGXjG2FKLwbmAaSNnfnh4qMXFRX355ZfGEpFk4nmxWMyifrd3BZgtEolIUhvESSTUyfrzP/9zNZtNLS4uamNjw7I0j8ej6elpRSIRffnll3r69Kni8bjeeusthUIhK0zD7HEdCIrd9AiAawOpYEg5p5ubm8YOymazbardsNFoXJXO7sxXX31lrCwy+cHBQU1OTur27ds6Pj7WkydPDN6l1gdbEWdMNnMVWAzncnBwYM6F7G5sbMzYggQLsVhMvb292t3dNQMNyxDyh0ueIeBxJe5p9IXSiuOuVqtGcgAWwrmgOIGDqdVqZltwWmSYOL/t7W0dHx/b/QbC43dDKInH4x0HOKg/AEUTYPX09Oj73/++JicnTePPrT+RNUNZl2RZTiwWs7uIWCwkm2QyqVdffdUcriStra1ZCwXOhTNBLQ+mJKMcaFRldDKZkvv+3n//fRt+h2LH2NiYtSbk83mNjIzorbfeurQNvLSlJD3mknLYvF6vTfTD2CEKiHHGELChpNsUyV381MV/s9lsm/IvmQ/YcOn/nxOCGgBURAryRDwwK4iSoPy5NEkeKtpPQBrSGYRVLpeVzWY7LugT7eAoJCkej7fBTC4xgT4btzhHZoax47K7sAJOG/iP9N01VNQh+OzAIC4Mye/j+4l4JNn3UcBkn6Au8ppu5ObCm50s+ldKpZKKxaI5Ty6WSwThvOH4+DfOCLAqmbPrIHnPfH5gQRfucf/L73YL4e4+0UcAZV46y/TIsqrVqo2icO8Bzx84AkbSVZyLS27geWPAyZD43dRTeL7cdT4vaAOUeV5XOh9kh82QzoVbCX54P26x/2KBnj8Xz68LL7nPyA3eWq2WZc/8rKum3MkCJiWzoK2B7Mw9f7xHziIUfvf3u0QP+oCYacPMJ5pwgUQ51y5Rhr2jMZwMl/POuXFtBDaFOhgwMhmdSxHn8+K0Llu3urRzAZt9/vy5tra2tLu7axTF2dlZzczMaHd3V9ls1sZzcmmJulZXV9Xb26upqSn19vYqm81qZWVFPT09GhkZaTvQ2WxWn3zyiXp7e5VIJKwHBijn2bNn2tvb08bGholocpig4wIBJZNJXbt2Tc1mU3//939v0v9EUevr69rd3bX6TaVSMThnf39fx8fHev78uXK5nDwej/7X//V/vey22YpEImo0Gnr27JkePXqkGzdu6E//9E/l8/n0xRdfmCNFV4r5D36/37IpLhE4Kl3hpK7sdbPZVDQa1djYmEWfHHoMHEVm6k3MH4FphcyDi+VyYUjRqRVgVID5qBVRiCTrvErN6v79+2o0GjYnnFGuQINux7x0VrQPBALm5FwSw/b2to6OjuxsYdT47MBSLuRIdO4yz9zl9qgQZff19en69evKZrNWwwM2rFQqWl9fV7VaNcgM2JICba1WUy6X0/b2thKJhNLp9JUK0hAO3GyXe01/S19fn4aGhlSr1Yx2HYvFTJodEoM72IxI1nUoBGfU9ri/ZNjUVTCI7P1F5wkry3VeGEyIFWQ2Xu9ZHw7EB4rcbnR/lQX8vrm5aUMHmbvy/vvvG9uSOggBQj6f19LSkqampow+zHmiWF4sFm0w4MLCgnZ2dpTJZAzSQpkb0oBLLSaLYRHsoH7OsyPgRimjXC7b2PUHDx6oUqkYfM5ZpsmcWuHCwoI8Ho/+9//9f/+t+3Vp58JlwoshTEdUQeTjyhwEg0HrfSCddCNCvCY/R0ELQwTPGqPPn/39fRvVeVGI7usoitRM3PTc9eTgl25ES2TH4byqrhPvjctEmuxeTvaB98aeu8bP/TqZDn93P7dbRL/4c65B5lnwsy5ciTPj2bmYuksNJeN0MyyMAZ+P6KrTS47zhOvP+GU63t3fC8uP30fBE0fp7iuOmvfr0lyBR91sxf0MGFOiZvccE3VDTnENChed/aLGRZaFcQYSok551YK02/xGhoQjdM8AkCsNfW72xx66z/9isdrNMNyMkj/uPl6kFV/8XrJyFzZ394H34maLZMoEj67NuUqv0P7+vprNpp1BAk+km9xmUrfmIp2jBdwHPpfLwIQEQyaDDSQ48/l8bU4E+rNLvf46ijIZFPvI2aa+42YusOCw2dJ5zdEl8lxmXdq5ELVzWdyi4K9+9Ss9efLENpeagNvE1t/fr0QiIb/fbzMFNjY2TAQTT0v3aaFQsOgKWGZlZcUahmg48vv9mpmZsWgbfbJEImF1IDBNj8ejTCajarVqiqDHx8dW2OfQusaJg8vXOl2PHj2ymtCrr76qeDyupaUlMzqDg4PK5XKmgnrnzh1rgCRycVVPudyrq6tWkHaLwBAe6vW6PYuLfT0Ul13MFtyfg04UhhOj6EwU29fXp1u3bqmvr8+gSg5vMBjU+Pi44vG4dnZ2LLPpZK2tranZbNroZiJHmg8HBwe1vLysbDar/v5+DQ4O2pRUSaaZ5fF4LPJrNs80qVxxTTB0mtuIQDH0UL2h2zIBdHp6WkNDQ9abQvZNxoKqOEw6itFI48B+CoVC6unpsQZlVKsLhYK2t7evFIG7kBiGj3OUy+VMNNGFoOv1uhlVMjq/3690Oq1Wq2UU3Iv75PZZ1Go1qyNwRqrVqmWE9ItQA2NGDC0OOEJJbUYTQ0cgxe9yC/g4s29j/fSnP7VMlh4+EI7t7W09fPjQiBeMf+7p6dHU1JT6+/ttjpXX67XP+fTpUz169MgQAb//TAn7xo0bBpURzHs8HuXzee3u7tpsmNPTU2MZzs7OWv0YJWQcrOuoa7Wa9abhWBijUigU9PTpU5MvisVieuuttySdITyLi4vffod+uVyW1M6Vl87ggBcvXqjZbBreeXR0pJGREWMrUfzFkO3u7uro6Mgov24XN5MloeoRKZ2eng8ccwXUhoeHNTg4aLi11+vV0NCQRkZGLDOgTuHz+Uyyn/fRaDS0sbFhw5CI5KT2MatXdS6rq6vyer1KpVLKZDKS2h32wMCAlpeXNT8/r1gsZjNvoAQCV3g8502X6KNBM6YYR2GaSI3CJ3/IDIERJFl3uCu770bTrIvRKwoKyWTSZnoTUUGhjEQiRpvsNPuDeo1hr1Qq2t7eNvmZarWqXC5nopw4Nwr1GHP6RXy+szHH0KhpUkSxu1gsWp8Ln5sgh/ND0Xt4eNh6YIguiSghYcRisba6A++H15b0T1higUBAw8PDGhgY0P379/X06dNLX+yvW66RpVEUevDu7q6KxaJJwhMNNxoNg6rd80UtDykbzgVEGNe5gD5geNExI/BzGZScY4r2bjbk0sVdijQOh6Dn6Oiorbfl21qPHz+Wz3cm/4KgJK0XKB24pCXYpgx747NJ53p4Ozs7+vnPf65IJKLXXntNkUhEmUxGg4OD2t7e1vPnz9uov2Q59PgRPHZ3dyuTyej111+3Dn328OIzp87jPhMkX7LZrOr1up3p/v5+pVIpG+64uLh4aWf9jWsuSGns7e1pb29PkuwCuJeC0cMYtkqlotXVVUnn3f5EQFxccFKcxebmpjwej7a3t7W/v6+1tTVtbGxYEb/RaBg1udlsmiS127THQyyXy/beYrGYQXIYIHciH/pQboe0K5TYyerr65Mka4LioXHBwOjRySI9pXmKiINskcwKyAU8lQs+MDCg0dFRa2KU2mEdVwqdzwYzjVoL6XtfX5/1lMBokc4HyK2vr7eRKzDUHo/HJvTRTNfpSqfThndXKhWFw2HduHHDyA+k+ARBSOCg4QbEQHYaDAbbZqcQRWOsyCKAA6iXAGniqBFDbLVayuVybd3VUEIlmeFxi9NcUu4Iv4ss1ev1Ws1ld3fXfrbTRdbIf12HS4YAwYAMh8+Asi4OiUCLIVbSuZwLn1dSG8yNsrcL/cCgi0QixmTEybrsR/fsuhAdmTifiz2lX0Rqlw66OELimyxU2oPBoPb3962uScMoDYrUMslGUOGm2ReHXq+fTUZ95513jLhEsAQVfHh42Nhwh4eHZj8IDl1m48HBgZ48eWIK526g4v5O7ifClfV63dTVi8WiaRCCVqyurqpWO5uoCZHjMuvSzoXieCaTUSKR0OLiomkj3bhxQ9euXbNIp1Ao6Ne//rXBVPRrPHz4UD6fT7du3TKq4ezsrI6Pj20+wo0bNzQyMqIXL15YfWd+fl61Wk0vXrzQ8+fP7YDD3JDOKK8jIyPWbwMcR9NlNpuVJKONEtmEw2HNz89bo9Dp6ami0ajefvttdXd3W5ZF0b/TyJvO7qWlJW1sbJjqKcrH9frZmOO5uTnrqAcaGB4etvnbSOYw/ZBMslKpyOfzmTNNJpO6e/eu0Y8v4uRABicnJ8aEY743DB0cTDQa1d27d+Xz+fTBBx8on88bF77VaunBgweSZGyScDiswcFBNRoNffnll9re3lZvb+8/ET38Jgt1gmKxqKOjI83MzOi/++/+O/n9fn3xxRc2ehYGFlATpIfNzU0tLy+b8ent7dXExISmpqZMHQJMnGg6EokYzAKUWiwW1Wg0jFEVi8WUSCRUq9W0srKi7u5uTUxM2AwdYDnpLJtirrp0PmPIlTiBDsq4348//lhra2tWh7nK4uzyDKDSUpuDpIFQK9EvwQ4BGcEHMG9fX5+Ojo6swQ65J+nM4TCDBzicQj6MKDeowqjRL4RDpTblMt3ctoX9/f22zn2+H6is2Wxaf1Gn2cybb76pRqNhvVPJZFJvvPGGWq2W/uEf/kHLy8uWCXR3d+vZs2eKRCL6F//iX+iVV17R06dP9dFHH9kICOnMYf1P/9P/ZIV5WG7c/XA4bBMpd3d3rWTg9v4A65ZKJf3sZz/T0NCQDQjkeePgIXOQNROgXrt2TclkUgsLC21TUSXpq6++0tramiESl13faBIl0TVw0eDgoHlFV3GXhh4XXpFk0Q/QE9kFr9dsns9BJ5qkPuBq4rjMESJRptEBa4BdE0VSCHP1zgYGBkxW2qURer1ei0yBw3iYnS7YM642G1o/LCAyv99v7xdjD6XRbULFILnFWDJCoLGLBX1SY6IYlzLJ4SNiIRKE/UWE6+LhF4vcLgvGLTISrXfqXKgDuNADBWfpLOXv7e01LBsIy2UK8buhe2O4cLowaVxiBYVtt1OcM8zruFkHgY9r6GgU5lm7zZIYV54PY5PdvcOQXrV24BI63DsknWcxZOu/6XeyN5xLvs99bTIbMga+hpHns7lZJDXDr8tUfhMZhef+dffShdFw4kB8Ho+noybKeDxuzZmlUsmCKe4epBegWDdjI6vhrPAeCRA5zy6xxt1ztx7s7qtLzMC2gQy5ZAmXwCTJnExvb69ByC7dnOyREgjtCt/EBl7aufzFX/yFGo2GHj9+rMXFRWUyGf3Lf/kvdXx8rA8++EA/+9nPNDU1pbm5OZsCCJRQKpWUSCR0584dg3darZYSiYSSyaRNqmw0GqZNRhMkchgU5F1mCzWD3t5ezczM6O2331YsFtOtW7eMgouhSSQSkmQXiKgSBwdJwaU7tlotbW5uam1tzX5Xp8ZxZGTE3nd/f7+Oj4/1i1/8Qn6/38aXBoNBkxeZn59XvV43/BnuOwYKBhZEBIwDB4ZGKQ4NkUh3d7cODw+NStrV1aVUKqV8Pq9CoWB0UY/HYxInjEUGSnr11Vct0wPW8Hg81oF8eHiohw8fqtU605bLZDJX7jBPJpNGLjg+Ptba2pp+8pOfWDE4Go1qcHBQb775ps2nyGazisfj6unpMZ5+IBDQ0NCQwuGwurq6rLhMc+7m5qaazab6+vqUSCR0enqqbDbbxgySZAENmQt0Wo/HY/APDMNisailpSXLTsGwUcWNRqP2npeXl3VycmKNw5lMRtFoVLlczt5bpwsolKDP4/FYDYuRBUAsNDlSI6GWAnzM/cDJuA2SsC9xxEC51FpwFgQ/g4ODGh4eViwWs65yshTusdtTBTnAHVvhQo2cSe48AqYMrgN+/6brrbfessbQSCSi6elpDQ4O2nsJBAKanJzU7OysqtWqZXJLS0tqtVoKhUJ6++23DX7EFkBaIgChTnJ4eGiZLqgETst1GHTjj4yMaHZ2VpFIxJqYceo4vVarZVkeBJbu7m7T7iPQ6urqsqZRoEd3zMpl1qWdy8zMjGq1mqVHsBMqlYr+5m/+RgsLC+ru7tbw8HAbPZjiEcwhr9dr2D4fDg/ZaDSsgE404zalsVw6IkwJnBH6UlChL0p5uD/LAyNbcFNtnBhzFsDBO3UujGtGH2xnZ8egOjejI1ujluTOICdz4X2SFbp05t9U8CRS5vso5gHLkN3hvDwej0XzNLQiThmPxy0SIxuTZFH8wcGBNYqm02nFYjGjjXcKK0LOIKo9PDzUxsaGenp6DIYCBt3d3dXS0lJbwRLjh/PlorkNbEA4RJA8Kwyj2ygHdEiGC5YtybJC9o8+r3q9booFyMXAcuzq6tLKyorRXHHEMKdgbF2FDn+RCkwGK50PLON97e/vmwbaRcorWQD0a+lcE8xlI7m1JPc1CAy5czg0shc3s75IwSaSduuNbmbO53Pp3DhDNOU6ddDJZNJkWvb39w1e5/cRYE1MTBi8yPiQ9fV1jY+Pa3BwUMFg0GYuUdd0sxIyc5w5NvAiQcENhCEFDQ8Pt7HE3ADAbabEaUDAumhjISPw+pLsPXzrVOSf/vSnhu1D8aVQy0Xo6uoyKRNEIVEw5rBBCcVYEJHwgY+OjlStVq3BkkOOrlZ/f79hxX6/3yKbkZERpdNpu4hkQ9D7MNpLS0va3d21npZKpWIRCBIroVDI1F9HR0c1ODhoF6HTBdupXC4b7iyd96rwoIEHgUqgIgIzcVGAI4Eqp6am2j5jJBJpg8GIjKgvQKklMmIAm2tEIpGIRa1EZicnJ9rZ2VG5XLY9CoVCbQq3wWBQd+/eNeO9sbFhMNFVoEWfz6dXXnlFsVjMmIOcu9PTs2F00rmh6+/vVz6fV7FYVCQSsYIpOL0LPdCAyx7h8H2+s9njXq9XL1680OLiooLBoOnlFYtFGxWLYcOA7u3tWWH37t27lv2SMS0uLkqSkR8o5iK/IZ0bEM7+VTIXd1gYDX70M/C1VqulUqlkxA562TA0ZAagDy4tGNIGdbqLTqnRaFj9gMDQpfnDWJTOO8TdrwFluT0jnClqja5sDpAugcNF6v03XdwnygFdXV3a2tqyTAp4inomxXjEXXt6eow+j/0jaPR4ziakot6Qy+XU3d2tsbExg3dLpZIRSpjFAw0bR4tdA9VwGaPAg5y1UqmkFy9emL2E+QmiRB1yfHy8LVO97Lq0tfzZz34mr9eryclJDQ0NaX9/X5ubm1ZglWQMm0gkopmZGfn9fv3t3/6t7t+/b0XMgYEB3blzx7S0XOciyeoruVxOa2trRrdlg6mnDA8P22UkhUun0/J4PCqXyxbRw70nMltZWdGzZ88sOujq6tL09LS6urps0hufzeM5061CYJAL1cna3d1Vs9lsY1VdZL1QCyKFlqS9vT3T63IjPjqU6YWYmZlRKBTSgwcPtLq6qrGxMbsM0jljBp0riqvQh5vNpjKZjLHHTk9PDbahaAhcUS6Xtbe3p2w2axcWaKzVaimZTNrk0k8//VSbm5sWVFxl+f1+3blzR6+99pp++ctf6oMPPrDhSuxtsVi0qZDd3d02CfX69eu6e/euGVWXVo4jclmLLsUVscGDgwM9ffpUfX19Gh8ft9ETKBiz166SxMbGhoaHh/Xmm29aT87p6anW19f161//Wt3d3dYnBEQbDJ5P8nTraSgMdLpwLhTL0ZGTzhSfg8GgZWmgD25GTZbjFsndPjLuHYKxUFy/zrn09vZqeHjYajwYTFidGEGg9Z6eHqOQu1NkeX6Io7rIBM8SxwUNvdPFmRgcHFQ0GlW5XDb2IveEewyNvFqt2rCw/v7+NlmX3t5eU1P2+XyKxWKSzpQAcrmcRkZGNDo6avWYUChkWTXU/larZXUWtx7p1hCPj48tk3Gh8nK5rEePHll2FAgEDAUAHWg2mxofH9fw8LAqlUobPf+3rUs7F1Jemr4wMvSW0KWazWYNt4O1NDs7a7MqkKvmMnNgXTlwGCdDQ0P2AMCGScfB9wcHBzUwMGDZhdfrNWPDICmiIxdL5/1/XYqHBAxRHJ/9KlE3tG0yl3q9blkVERxFaP7Q68NgNQwOExgpmqIMXa1W1dfXp8nJSSUSCYM/cEjuoeBzuwVCLjnOjyySrI0olj8DAwNt0X53d7cJQRLFusXhq0TdOzs7kmTQXTabNUYV9HhYQxhp6iOcD7I49tEthCLIiBF0zxrGjmfF52H/LsI37DeQbavVUjabNQjNlaPhs0HyQHmbs8kZhjp6lUXUiUMhC+Fcu4VmnAoGnMwM3S73s0pn9xcYkXog7DIcqqvSAEzj9mK4kTHwi5sNuiwrzjO1C6J0lxCAc5HOC/9XucOcQT4HeoQ4VHp/tra27PlyLvv6+jQyMmKOh/eHPaWeAVTPzBgybd7/0dGRKXJzt4EVCfDcwMh9tgQEnGeyL/qcqtWqySHh1Futlp2DQCCgwcHBS+/XpZ0L3mxra8sGb2EA/X6/Ncp9+umnGhsb08zMjHp6enTv3j298sorFj2gIxaPx61RjUI2ToAmnv7+fm1vb+vp06cqFot2OPx+v6anp5VMJnX79m2NjIxYCh4IBCySZlFwJMWLxWJaW1vT8+fP7XcSHSAFvry8bI4uGo0qEomYlHYna35+3gqb1FImJyfNENJ8VygU2grujM1lr5CLINX1+/0qFou6f/++ent79f777+v69euW/qO7hAx5vV5vk4Vw8W2iRyTqYcX4/X6jlY+Pj1ttI51Oq1Ao6Mc//rEKhYISiYRu3LihYrGoJ0+eGPRHH8hVGgA/+eQTNRoNPX/+XKurq8pkMnrrrbeM9UdxuFarqb+/3zqUcTJcOhzT4eGh9agEAgGl02mLDNkH+mK4jBAHXFYN5wYYIhA4GxEBdEYm+Mtf/lI+n0+3b982QsHs7Kx2d3f1y1/+UqVSSe+//77efPNNra+v66OPPlKj0dDs7KwSiYQVvTut+UmySJe+GYrA1A1c9hHPjYDg8PDQPhuv5TLqqMG2Wi3l83lDHDY2NmwvyTikM2dE4dnNemHkAXHxXsiovF6vGXJgXbcWRZDAXZNk9Rei9k738Fe/+pX9nc9dq9VMcTgWi+np06f64IMPNDIyov/xf/wflUqlDCLGofJZT05OtLm5qa+++krxeNyCJCB+dNIoKXg8Zz1/n3/+uQWd1JtHRkbaFM9hjnEHySxd1iYK3bVaTQ8fPtT29ramp6c1Ojqqvb09g22npqYUi8U0Pj6u2dnZS/daXdq5EM1xUFw6IzTbi/j+ycmJcd5p+sEIEP25BWrXuRAluaKBGESK/WwsD4AL4EpY4FRIJ11ZGhwQh+0iZVSSSXVQ9O7UuWBYXcruxToOF+RihOcW/dzCH1grkSIMkEQiYQ7LvUgujdOV93D/UEiEYUPE6r5n+hCAC3k+0JRp8mJGCRDeVYrRwCs4WVQfyIZ57mRVbhc8Z4Ho2f2DgcTwsOc4YRwS58clFZDluHUFF1pzG9FQDmBfJdmzg1nG+QTe4My4hIyrOBeW21DnwkjuH/escx65k7wnghcCGD4rkBR3mSzGpfTzeX7TZ3KL+C6dmf93+7bcjIuvu19z99ClNX/TxSyaryPKuOMbCCBxJuyLS//+usyXxR67Iw1AKDgrZNzSeROu2xDrZicuKoLjxpFfpH7Tf0SzpiRLCmCdfesF/fn5eUnnrKWBgQENDQ2ZHEKz2bRBOc1mU1tbW9ra2lImk1E8HrcRwoFAwLBXitRoDkkyDSqkp8lYYIEhjeLOCHHpxTAaWF6vV+VyWSsrK6rX64pGozbrYGpqyiKzRuOs+fPhw4c236DVaunp06daWVkxmY9Oi/pzc3NWAwFe3NraknQ+84SaC0VyKIBkLEgwALUMDQ3ZM8DpDg8PW9NbKpUyUgA4OtnRixcvbJqoi6NiBNgXv99vUTYQhsvfdyEPoiF0iZCJp1ZzFVXk5eVlK5LeuHHDorRWq2UOBjKGz+ezGSQoxoZCIcXjcTsn/f39BrVAmHCZRbDKqtWq7t+/r7W1NTujbmMls2/corf7fTg66cyQFAoFSTK59lqtpqmpKWUyGZ2cnOjLL7+0WRoUj/v6+pTL5bSwsCBJ+uEPf9jRHgKrTU5O2lnmmXKfpPOsBOo7Z4dgjv3xer2mRwWl2OfzGQWb7ITvy2azVstjCJgrSOsyv3CsLkRHnRaIGCdCM2sgEDB1YfezQUaBxiypo9rLxsaGFd6j0aj6+vqUSqXU09OjWCxm9Ofp6WmFQiG9ePHCtBLL5bIymYzm5ubsfvT09BiDlsCo2Wxa/Qjo7/j4WAsLC3rx4oV9NmoiGHrUIui0J+AjOOfOo6Dh1np7enr0h3/4hzo6OtLCwoJWVlYkySBa4HHGb3s8Hv3RH/3Rb92vS1tK8EbWwMCASYvgMYeHhzU2NqZ8Pq8PP/zQusbdSJdIDaOE56Z5jWFUdI27XbyIUTLjwI1+XFkNNpz/wtmv1+vGZguFQsbOgIpKIX9yclLXr19Xs9nUs2fPbOhQNBr9J9Tmyy70xHAiq6urBi+6ysZELRwueiaIavk36YzmOzs7axGby57jczabTe3u7lo0hbxHNptVpVIxwgB76TZqcrHRLeru7rZZ6GQCbvFQOldjpkBN9EsxudO6Sy6Xk9/v19TUlG7evGmGiZ4GGIjsEVEXgnyJRMKgLViFODw+B86A6A+4aG1tTU+ePGmrQZDhAg1DGnGN8sVIudVqmQAhmXaz2bTa0cHBgVZXV834YDAgJgCtdrqAn2BawqTCeFPk5zkRKZdKJVUqFXMI1FcCgYDNpeG8wnSDzUXPDPR0smuXouw2Bbq0XAIWSW3ogVtAx3kDjRaLRe3v75t9aLVabczUr5P1v+wqFApW7+WzpdNpCwphsSaTSauzNZtNra6uKpfLaW5uzoJBMoh4PG5OhTPiBiqSDMpdW1szwgPPh+dFgIDzxwHx993dXeVyOVUqFdvvWCymdDqtrq4u3b59Wx7PmTDml19+aZ/N4/EYexDiz2VXx9xaJFsuRvKRSMSKeEdHR1Y4D4VCNpuAgwebgdRMOk953dQd78poWOof0DbdYirQHcaO3zU8PKzT09O2uQlIhLgQ0OjoqAYGBkxiAVol6W6n+lgcoN3dXXMYFMcikYhBizx8l62DvDzOmMOJUyaqg+uOfAQLo+L2tmQyGfX39xtZwu3zYZYMl8Pr9apYLBrcSPGQjn4ygq6uLh0dHcnj8ZgkCj0mpOGdXuwbN24Yzoxx4aJVq1X19vYql8upWCwaTIFjgwW1uLho6gLSmZNGw40iJoEKLCPOABAtESZ74M5DYW4GPTEUfIGEMUgDAwMGP3JZfT6fBU9IrrgwsWuEO11ucdeFAyVZ4AF1Vjo7l8CeOI3NzU1zsowFd7NnnITLTOTMkXXQ14Mci0sSwA4w9wYIm+I9+whlHycOScalSFN/IcMlWOr0DKIOLJ0FF1tbW1aMv3btmmKxmI6Pj61fJ5VK2b6gIIJdw8bxvrj7kgyBoa4NQuDq/vE86VNhvhaQGH1VBJUQk1yn1Wq1rEVieXnZeofeffddI+fU63U9ffpUuVzOWjcuuzp2LgcHB1bwoSFIOoumyTyYu8LlpDMULJHiNCwaLhMPgMtN5EERORaLaWRkxKJjt7kNmh7pH9HNtWvXdHx8rJ/+9Kd68eKFcrmc1tfX7fe0Wi2Njo7q9u3bxkunQJtKpUx887LFrIsrGDyTBF9fX9eLFy80ODhowouSrIcI0UCcJRI2KKHiXLze81HQAwMDJto5ODioZDJpRUMYRyi3wu6bmZkxmuTBwYE5h56eHk1OThq8RFEUBeKbN28qnU6bUGS9Xjfos6enxwKI4eFhNZtNbWxsWJ/CVQr67733nprNs6Flu7u7qlQqNiZ6cXHRInHo5ZKsCAqn/9mzZ20jpScnJzU1NSVJFpQAI+BcaL6k8bG/v1/hcNjo6wQxvb29SqVSxpis1c6Gba2vr5uyAc4sFotZgZuaZSAQ0NjYmIaGhtoIGJubm6Z+i4PpdOFcXCYc5xK9OmokgUBAyWTSImIoxPPz8woEAtYCEA6HlclkLHDDcOJcsAOSTECWBkS68iELAUnWamfDyI6Pjy0IcmEgfjfOm94QDClOk+wKp+w6r07Wn/zJn6jZbOr+/ftmQ549e6auri59//vf1/T0tO1NLBbTq6++asEY9UH2hcCZz316emrBbjKZNOdSLpdVLpdVqVSsJQHnTtF+f39f6+vrisViBqUjHIzyBtkpfwgYEQJeXFxUtVrVH/zBH+j3f//37QySHPD7v8nYjEs7FxqYXJYMcA0elAY7eNUcGndGCOk/WCL0OyJ1FxYDggGqgfXBZXTTw68rtLtFc5wMDxqDRwRGTwywXaVSadMyA07qtKDvsmoSiYTC4XBbxuYWgPlMrVbLLr9rXMgwuCwcaKAB9zXJGNwiPr8XGOOi1hXOnYMvnWeUF1lFvBaXwc0a2V/21e3Z+KaL4IFDj9aZJPsMUIx5v+wf/8b7ZJ9dqqbUrt5ABgLVFOPkOmGaVhuNRhuZhSyYCNtlPpGVSrIokv2h0IpSAPsFcYMsvdPlQl5E9+4doiZ2kbLu0pL578WGRX6O5+s6MvaOr188e+6ddunHLPfvLrGF17lIeHGDg4tZylWoyAQwUH95HmRopVLJHJ/7eXt6egzKd9EVlwjjQvouEw27ieN07yVBOeiLCyMCu3o853qQZDw0YkK4Qd+M/adjH/SJINdVtrjUfl12Y99++21J53WMjY0Nff7555Jkw7ny+bz+83/+z4pEIrp3755CoZCy2azh5YlEQo3GmT5ZoVDQ22+/rXfeeUeHh4daXFxUuVzW/fv3tbKyYhgtUYgL2YBDg/mWy2Ub9sQhAPfHwYEVv/LKK5qdndVXX31lzo2mzs3NTeVyOdMgYqCR3+/X0tKSstlsx0wTaICvv/66fvCDH6hUKpmUDo4SyrMbSfDeXYy+2WxaBEI2d+PGDaMIu41pEAKq1arpk7n052g0qqGhITswrVbLFKqpNUnnRgI5C4qYh4eH2tnZ+VqSRldXl65fv67R0VGTq+80e0FCn3kX4L+tVsto61tbW6YDx0qlUopEItrZ2TENqEwmo0wmY7p14Pk4HY/nrM9kfn5e+XxeuVxOpVLJRFHRlkK3DidGDxPqyfF4XBMTEwYPNptnXfu7u7sKBoOampqyojf1NWYcPX36VB6PR2+88YY140FB73Rtb29LOp9gSB2z1WpZrYL6gcucJFuG4h0MBm3mCDAXQSBO1cX9pfNAj7oAyuWhUMhm4bCAZ4CFQSZg1+FMKNT7/X47zxjEWq2mra0ta5MgiO20ZiqdNUJLMjivp6dHq6ur1hRbLpc1OTmp/v5+1Wo1FYtFnZycGJRPk2i9XreieSaTMYo5cKnHc65Wvrm5qY2NDW1sbFimjs2AnNRoNAzexmFtbW0pl8vp5s2bmpubMwe4v7+vn/zkJ5qfn9fExIRu374tr9erW7duqV4/Gxr34x//2FARr9drau3pdFqjo6PffuYCu4IIAWqoJKPh7ezsmNQHBfxcLmeYIUX8jY0NbW9v68aNG6YfRkHdnRDJhyNKkM5wcqJzl6J3UczNjY5cmigHmwly/f39Nvfk4ODAsEV3ZoIkG9fc6cKIhcNhTU5O2hRO17kQIfJZiC5cKq9LASeT48LSM8Aia3E1ilwCgcvucqNu1JpdsVAWr4dz56LzGfl3DBVGiefQqXPhWWDgwbYl2WcHtnSdC3Wog4MDY+G48htkHS4tFup6qVQyVhhn3aU4o4PFmWPPcOrd3d02x8PNDnC8ZJrRaNRgYuCH9fV1i5SJUIHKOl2cXzeDBTLijOAQ3LoMDgKmHTXQ7u7uf0LqcGsn7OXFTJfPw//TIMrZcbNLt0biZpbusyCjcpEKsgPqb/z8VajI7B/vF/1CWIegMZxzsmVIPG5tiFJCIpFos1VuWwQOwa25sIC7uQM8U5dSTPCcSqVsCipnu1gsamxszKYGAx8STB0eHmp3d9dqzp2oa1zauUCvJIVFsdXjOZuyx1jPsbExY4XV63Xt7e1pfX29TX9qYGBAx8fH2tjY0N/8zd9IOseByVj4PowTRgHH4ableFIyC+ZANJtN6zKlYPv8+XPlcjnV63Xdu3fPHjh0O0YJ3L59u01oEUfU6Xr69KlRAh8+fGjSG0QGpKxcRA4tn4UL4vWeyU8ggYPBdKEwF36isIlYHpkLBnhwcNAgBIqH1KwYTc2zcQ337u6uRVIcQA5ppVKx+hoCfqTgncISH3/8sbxer0W5sFcweODTXGiYbzCUGD0LTOXznY8t5qy45JStrS3t7OzYDHNgTLJJlCZcqLDVapm8EbAxQpiSrBZFNk1GQNY0PDysZDKpUCikvb09e/8wFsvlcsfFaEk2fwdSidfr1f7+vnw+n1H93fECBA57e3tWk+H+wbLkM9ILhFGU1AaRAiW5tGJe33Uk7Aeqvq4IKHYhmUy29Z25kC6GkACH5UJknTqXL7/8Ul6vV6Ojo0qlUva5PR6PZmZmlEqlVK/X9eTJE+uwh/6McyVId2nU2WzW7ADOk/IAe49NcOuKExMTpp/IGV1fX5ckXbt2TZOTkxocHDRyBPW93/md37H5LSMjI5Jk9TZUlXd2dvTgwQOrf+GQ8vn8tw+L8QHBvZF2IRsgxWbKIlHh3t6etra2lE6nDdpiMiDd/pFIRHNzc4bzlUolozpTmIOp5DoXojlJ5mkDgYAymYzJrOPt6fd4+vSp5ufndf36db3xxhs6PT3VwsKCibfBYuECMfM8Ho/b5+1kvXjxQh6Px4rP1F5gwbnCgO5BcpsCcerj4+OmXkux3mUCuQYPhhWOlmdDdJlIJNTd3W2ZI6qx1WrVIDdSdOlcIZWgoaurS2NjYwZBupL0wHmVSsVovp3uH13JyWTSoBycbzgcVqvVsmzTbV5k/AN0dvo5yDRg27FXZF/AudVq1eolFJubzaZFrxfZjShQ+P1+zc/Pa2FhwdiMwWBQMzMzGhkZMTq4JAsO4vG4PU+mr1KUJTC4CluMUcuIleJcULtmqB8OmWi7VCopm8221VzIMnAu/L/LasO5YNRw4MCyZBEupRjIFyr29va2crmcTk9PTYOL++nCmLwWowMw6NQhYHl26lgk6eHDh/Y7sWFke+Pj47p27ZoeP36sx48fq1QqaWZmpo3en0gklE6njfbt9XotU+jt7dXo6KiCwaAKhYLB/WgdSmpDYYLBoEZHR5VMJq0k4PV6TSBzenraMnzaPHgOb775pp15EBICwMnJSY2Pj2txcVHr6+tGJMKxbG5ufvvOhcPFBaWpCu4+KRWyJbFYzNgx165d0/DwcNsldgvHBwcHhgejzokRI3MB5yaL4YFhPLh0cPUhCRBdkJkQpfn9fpuOt7KyYhLxkoy6B0xBxEbk1ckKhUJWXGPfiPSgDbpNlERgGFGX9398fGyXkU5193Jz0aBg8nv4N+ncCWH8GRF8dHRk749InUgUnLu/v19HR0fWLwHOC3vHfX84ROaudGoc3RoRs+rd39FqtdTf36+JiQnLVGjMcyNcsmN6CWDFEfhQayBTg8JNEysMReSMiPi4vC6BhCIrWarbA4LDBkohsILVx3sIh8NWS7iqc+Ec9fT0tEn/QyTAUKJ5BrwDYQfHAETtNs6634+mHGQEt0aIMwbuAlKin83dc14Dp+MW7Pk+9sPdF94Hz5Tv5ec6XdyrcrlsNbxMJqOuri67h6lUygy7Cw8joHsRYiX4Q+PLhbzdu8q+sg+gQh6PxwY1Up5gD3jP1PNyuZxarZZN6+XOI/nkiumWSiWbd8V0V5o+v3Xn8uDBA8sKmP1OHWJra8vGnK6trZnz6evr07Vr1/Q7v/M7NvaVyNJlTdC8yEEjzSNLong4Pj6usbExgzMODw/11VdfaX19XclkUhMTEzYXGt440fjKyopqtZrC4bCuX7+uk5MTLS0tWQErm81az8PR0ZHRSTEeExMTbfWFb7rS6bR8Pp/RTTc3N/Xll18aIwSdH5qy0PBZXV3Vzs6OYbiQDKrVqqanp3Xt2jWLjsC/6eKPRCK2D2DqXC6cUS6X09bWltGgyQ7odi4UCm3MHLIZN/Ih4ieFp5mMmkMikdDe3p41C3ayJicn5fV6NTY2Zk2Q6KcxHwj11kKhoF/84hc2Q11Sm1FZW1vT7u6uQQfsB46FmhMMSOaKQwTo7++34WFkAbDYuMh+v9/gxVKppIWFBWtWq9frpl/nOjGMF8/C5/Pp2rVrSqVSpmR9FVgMeA6tMpo0W62WqfOSiYIsAGfSgU6tCgfg9XptYBeZjCtxAwuJ/gi3XsKZRqkAlXPOMMERAddFGI2Ai/+6gStOD7o1SMpV6PBkw5ubm9re3lYkEtEbb7yhgYEBg8UikYiuXbumo6MjU7+Ym5tTJpNRo3GmAuLz+drmTTGeBNIH750AG7uIugAozOLiora2tkyKf3Z2Vq+//ro9B/pefD6fcrmcPv30U52cnOj27dtKp9NaW1vTs2fPVCwW9fjxY5XLZWuKHxkZ0Ztvvqlms2kElcnJSd24cePSDvrSzuUifko6KrVTXjlw9FPgmb1er2UBHDyXkeIOYyIqBaelMfCi8qd0VmjP5/MG/TQaDZOfIGuBaUOPDfQ9UkaKqEQLRJet1rl2EqyYTp0LkTdZGDAShX73M2HMyQjcYp1bUwGfls7nX7iUY74G7u827fHcLkZEZCf09RCdcrFduR1eA90tfgeL2oerfdSpcyHyIxPCENH7QrRHTcWlU7On7mcGg6eADXzjEik4m8jmgJFj9Nhvl4rMH/YVp89zcYeTXWTP8dpkXNwB2FtXkc/5uoWh5rPzbC5GzS6V/yIEy9/5GYr4QIEuDOWSbS7eI5dEIMmenZt1XizGu42I7h+3F8z9fUDOnTpooD1+r6S2Hj3eL7bRpbGT7ZKRupkYZ4dzQkaO/XGbZ/lMkqz+5zbrunYLxIVMhz8EAPv7+9YzBmmA7CUcDtv5YM9RWvnWnQtGhVpIoVDQ5uam6vW6JicnTRJhfX3dPnCz2dTy8rJFb/wbSrS7u7va2tqySyfJIt7h4WG9+uqrikQiunnzpqLRqDUzUm9hGuLOzo7S6bTi8biazbMZIgcHBxoaGlI6nTa67OHhoQ0qotv/InXS7/crnU7r7t27ajQaevbsmfL5fBt9sJPFiGcYIZOTk7p165YZR5cJUqvVtLq6al3AhULBcGpYRox35uJwQIEQarWape4MNHJFQ4G+YP5Eo1Fdv369jWdPURkozK3voDOEtEez2bRmTuofXGKk568y7Aq6JlkbDByMHwzGxcVFFQoFk7WBBsqCnUQEjmMFRqtUKkYT//zzz43liMOQzkkSGAECBJwDdafFxUWtra1Jkp3d/f19LSwsaHl5Wevr6237hxpuX1+fDeQjACkWi1pfX78SLAa7bX19XblcTolEQteuXbP9A7aDTs7nc0VepXNpGLJWnDoD1NxAk1rm3t6eicCSAUGKGBwctLsIs+5i8OpmIgQyNPKSPVGLdRlvFx2c1Hnd5c6dO/b5MeCofWDPcrmctre3bVKqJBs5QnDL+6X/CsOOPU2lUgqHw3bHIK5Eo1FzLm69j3uXTqc1PDysrq4ubW5uamdnx7Kj09NTs2nYzI2NDa2srCgYDOq9995TV1eXPvvsMz169Mio/fTBoDYA+eAy69LOBSOGoQB7bLXO5lyPjY1pYWHBvBoRLLjg+vq67t+/L5/vTHYcJWMyCiJkDGY4HNbMzIxJ04fDYWPV0NQjybpzG42GQVpASfTWgHlTY6nVatbhT4TlGumBgQHNzs5arwdNR4gOdrKGh4clnWtSxeNx3bp1S5JMMwgl0kajYT0pQDKuPDwPHPaVG81w+eiOPj4+Vi6X08HBgR1CnDPRPvLwdNVjEHBU0jlLkH0Czjg6OlKxWLQiYzwet2idSBvDexUqLQ4Cw0UWwWemFkUgg9giVFCX8cYeUoPhwpFR8JnW1tasBghVk9/nKlK7RpZ/g4G3t7en3t5ek3WpVqva3d01qAGB1nq9rnA4rGQyqa6uLoMeed/Iy1+FigwUhWBpq3WmSoHjoE5JMZzPQ6Z9sWjP+YFGS/0K1IL6FkX/4+Nj+x6eAUFTOBw2qPvrWF1uRiCdox7U93COOBc3GPi21tDQkKTzLIueJI/HY6SDlZUVLS0t6fj42Ki8QNkwK0FzCExw6Ht7e3YOBgYGVK1WbYAhDhxIkmfWbDYNSUKw1uPxqFAoWGDIH/rZlpeXjTCwt7enWCymyclJxWIxPX/+3PphSqWSvTYj3l2o+betSzsXqIPPnz+3qOWVV14x7JWIsdU6U6m9deuW+vv77bIGAmeT2ThYrkAikYAkixJd2XY6/onwMAZwxaH3bW9vm8MCwhoYGNDJyYnGx8e1v79vgo1glkRTkUhEN27c0NTUlDUTnZ6e2kW/akGVKAYMlCmeMFkuwjHUetDCcruYJdnFhSHH1zFYLBhhMNKoI2xublpEjEGBEXgRYkNtGaYVWRaOiqKtz+ezaYQoLDx79szEDa8SeedyOTN4Pp/PYDsXX3ffC1lNOp3W9PS0Da7iYlOUdkU4T09Plc1mtbq6qmKxqFAoZP1a1LBarZZJvFBop74IuxGjRnDAZEwyzq6uLsO3cULUEVdWVtTX12eF4PHxcYXDYR0eHur58+dXMpg4BGotBBgujMT8GxfawmBz59xaB87OvcvAJ41Gw2ou1G7YUyJ49pOgikZoV+UAxw060t/fb6OhXdjn8PDQsm0ke4BvqRFeZVHzAkoKBoMm7gjMGYlE9L3vfc8asXEWLkznQod8HqjoJycnRvNfX183e8n3YwskmfMaHh5uE+d0+4sIuHA07G2j0VAikdCbb75p54CggBlSmUzGlJ+xNy4i8dvWpZ0L/Q5ffvmlfvKTn+jtt9/Wv/7X/1p+v18//vGPtbS0pK2tLeP6v/fee0okEvr000/17Nkz0/eSzpvtLjoXnAq9EUQ8h4eH8vl82tvbM2NYKpUsC0in05LOZNk5YGwUzDDXuHi9Xu3u7mp+ft4u1MDAgN588029//77evr0qf7yL//SDkskElG5XP7GqqDuYjAZA4H29va0vLwsSTYylwgfTPTk5MQ6wVkcNOiD29vbZizYg52dHZsZDyHCvaQ7OztaWFgwhV4X+yWTkWTOrru72xgwZEF8Fhfzhpt/dHRkRADSdiKhTi/45uamJFk9yOs967+AVszgJBh2UF3Hx8d1584dq825kb/H42lTFDg+Ptba2poePnyo09NTM2LT09MKh8PWE0SgAa334OBAmUzG9MYocJdKJeVyOaXTaV2/fl2Dg4NmqEulkjEIXTro1taWNbbyO4eHh1UqlUyOv9PFc0JdAZgSh+BmITDuYJdx7vb39w1+dY0kd5r6AmeKYAknShTtarihPAF0SuZOawB9XuwfdTXaExBUPD091fb2tvL5vCKRiMbHx9uy7atAipIMZXn27JlWV1c1MzOj3//935fH49EXX3yhnZ0d/eAHP9Cf/dmfKZ/PKxgMGjR7sa7qNjQjv8IY7H/4h3+wHhPYkJwRnDPCwR6PR6lUypz4RUUNMkYmAVNTBr25d++eBZtokMXjcWUyGeuj4bVXVlY0Pz9/6ez50s6FdCgQOJ+dQGMlkE5PT48mJiZMFoKmNjYGw+IWOIFz3AdPJALFDmMG39pNy6nXuF3COCzqPGw4KakbRdCvA4a5tbWlcrlsERTpPe+vU7wWQ05E535elwEDBOMW8t3lFi6BplwBRQp7+/v7NvvBnc7HvvDZXaMCxAC7xp3ySAZ5cHCgSqViRtmteaC1JZ0zkzCmblG1kwVRBIjG7/dbA6RrFDGEF/swaHb7/9j7rya7ziQ7GF7He2/LG6CAAmEI0Dabpodtxkoz01LEKEbSnfQz9Bv0A6S7CSkktWKkmdaoe7p7mu1JgiAIb8qh/PHe+/NelFZWnsMCWahCfzdfZQQCJOrUPns/+3nSrFyZqe9BJ+V1Ap+wG73e8WsxbwNADizhXE2PJeWXLTqYzOXeC4fDMkeGtGXS5TlCgBENP3/SrtzAYYU7E/OMeLVHrfe3XgtGdrpGymg0jjiJXN/xP/wdfW3tzPD3jrpfKlfCmNqgARg5K1TGurCY74P7kmfnJKLzTJrYMS58buZw6QyT/q7vg/pKkz24njr5zvyRJqOwbRAdVr0HmdvlGrIMgFEqzz71AqN+RuDstszrceDei8ixjcuTJ09gsVjwwQcf4MaNG6hUKvjHf/xHodxVKhV84xvfwLe+9S2USiXcunVLCoB4KMvl8ghLgrUyDNMAyKav1Wp4/Pix0IoDgQCSySSSySRcLpcUqrH/DnBQba6VxWeffYZHjx4hFovh+vXrIwqcA8OCwSC+973vIRwO4+OPP8ZPfvIThMNhvPLKKzAajXj69CkymcwIy+0ksrW1JSEulX04HIbFcjCX2ufzCQuKUCONq6750WyxRCKBdDotBp8wTafTEYoi63psNhtKpZLw1y9evCiJWovFglQqhe3tbcFXnU4nZmdnJc9FSIvGlzAa8yy6MI4FbwAEZslkMiPw54sKu2ufP38ey8vLqFQqWF9fh9F40OGZFeaRSERaB2UyGaytrQmkSNyY96EPMCnFNJrAYcFoOp2WCKXRaCASichAKACicGi46MEvLi7K86fTaenVNhgM4Ha78Z3vfAeNRgMrKyuyjy2Wg35xFy5cGKGDO51OfP/73z8VtENFTGNHmI5wiq4ZabVaUkTKnxEapMIBILNedG2GNuSEKbkuVI5kwY03oqVipQIMBoMyi0ezp+jMkJhChCMcDmNxcVGMGgAxPDo3eRIhLOb1emX0L3NERqNROkVwOBife2trC81mU0YFa9YdkRoaII48cDqdQgogtdtoNEqX4lgshg8//BDBYFBmXDEvy7UhPEznkOxPfe5pMNhlxWAwIBQKod/v4+HDhzCZTNI1guzGlw6LsQ0GE0NkHLCKmIZifn4e+/v7grNTGRKv1YV89KKAw0Q0PVDCLMBB00JGMKwhoLBAstPpjHhHw+FwpF0BexZpz4UWPRqNIhqNotPpYHNzUwrJGOkwhOV1TyJMLmsokAlheg2kNepOyPxbKy8aF1J/Sb3VxqdarSKZTMr92+125PN5gfZoDHT1OaMNekmcK6LXmFXDNLb0JjVTR3P0yaqq1+uSWD+NkLFYr9cl50JvTDO2SEXm56jQ9Rrqoj/mBsdp2QAkJ8I6rX6/Lww6rVB1RE5lzNk49HqpPOx2uxSpsQiWuQjS781mM7LZLOr1OjwejzDmTip8Ju45HbloKjY9ZLZ3YcTFCFTTU4HDvc3EOv9QwY/nG3QEpSPb8QQ+3zf3zfhcIN47HQbmJLxe74iR53vhvZ9UqAO4dlarVfYLANl3LCRmVELSBtEBrjHzWMyL0BHnuWK5hJ7txAjaaDQiHo8jHA5LTlDnmAAIBEq4jf0g+U6AQ+IV3xGh0nK5LLNeLBbLSM3fceXYK806jfX1dQmRiccSo0+lUvjBD34g1pUbiAm+YDCITqeD/f191Go1RKNRxGIxKVrs9/tSPUo6IZPOg8EAExMTeOWVV1AqlbCysoJarSajU10uF+bn56Wok4vCytVEIoHBYICHDx9KNSphnvv37wuV+U//9E9htVqlDQrbMpBBcVLjcuPGDQAHh4a9emq1mhiVTqcjXQ3I/ODnWTXv8XgEM+U7YI3J9vb2wQv9fweV3XkBjMzcZgjN+oYnT54I1TEcDgM4JB8Ah4aGB5/ceHqgHAVM2JKV0Uyac+qn2+3G1NTUidfvn//zfy73Q/JIsViUZPFwOBR6Za1Ww6VLl3Du3DmcP39eJgMWCoUv1RNYLBZUq1Vsbm6iWq1iZ2cHhUJBMH0aS4vFgsnJSSwtLSEQCMgezeVyqFarkiMBDplM+Xwe6XQagUAAS0tLGA6H+N3vfodnz57hyZMn+Oyzz0bqLlwuF86fP49ut4unT58CgMB8p6nPoFAJEp7RlfVk2FEZDQYD8Yb17xOiY/NYwjbjdSRGo1Gi8MFgAJ/PN8LMZDdkGhcNDdNZ4OdpvEhzpofPPFm/35d3xXwNHQYm+rvdLsLhMCYnJ09soFn9rtdD967rdDp49uwZarUaarUa1tbW0O12EYvFMD8/j06nI9NEqT85tr3T6QgClEql5H0Q4mKtIKO/6elpGRfNnBMdABbpkoVGQhWvwefPZrNy1rl+s7OzWFpaEpoyHTTgIEp9kbzzsY0LcxA7OzvY29uTec1MqpnNZqRSKXzxxRei0DUFlVFPs9kcMQizs7MSbnU6HanGZ+U+Fw4AlpeX8fbbb+PRo0f4yU9+Iq3haeSmpqbQbDalAR+VGtlfjUZD5lrT02k2m1hbW0O1WsXMzAwuXbok86a73a7MMKCxOamwpmVnZwepVEpyUqxmZwjLsadUVIRieB8Gg0GKUWlkGo0Gstms3C/rFbg5OQxsenpa8kusi3n27BmePn2Kc+fO4bXXXkO328Xq6qr0IWPkQXYPabr0cgEIFk+GGKEgekLs96RrJV5UPvzwQ/T7fXz++ed4/Pix1KMwzzMcHlTqk+Bw7tw5WU+v1yuemFY6VNYcJEaniB2X6T0T949EIlhcXJSkKn83mUyOtI1n1FQsFkegLt7jo0ePZN86nU4sLi7C6/VKnUsikRCmEeEX4ORRM4VROyN2ogaDwUCoqV6vVxQQYRJGg+VyGclkUu6Dhp3dh3VxJA0Q4R8aI3rzDofjSw1bGf1wXxHloCdPVhNbRmmyDw0Z4R/Cyt1uV3K/FosF09PTxy4CHBeeSUZltVoNqVRqJGrd3d0VFmoikYDRaMS3v/1t6crx9OnTEVbbq6++ilgshm73YLhcsVgUxidZmRaLRcoQ+G5isZjUnhFWI9rAzhu1Wg27u7vY399HMBjExYsXZZ0MBgO2trZkbAr7N05PT2N+fl5y5XTC6RSzk/tx5NjGZWZmBsAhW4fKmfUQwGECkF6wHonLSvhGowEAAv8wB8Eai6mpKQQCAWklwsIqo9GI9fV1dLtd7OzsyAaiJU8mk3j06BHa7bbM3yCcpvFep9MpRpHYY7vdRjablfbX3W4XhUJhpCKaUc5JDzhxaRpUGhcmapnnIMxDSEJ3hR0nPfCQ9Xo98a6Hw6FAVjppKC/8/3k2bJpIWK3VamF/fx/dbhe5XE6SecRuCfdQKeimoYSUNMarPSQypwhznkSePn0qaz87OyvvmM6L3W6XvBO9416vJ+tDJhv3E5+HhkC3Fef36JG/NtvhfHY+J5WZXp9eryc4uslkEmeBM2+Y86CzBUBayXDK5XA4lGJUsojYBfq0oiEr0kt7vZ5EE4Q0uYY6Ia6r7jXzLBKJSOTBfTleoc/PEyojqkAl3Wq15Ps1+YPngXk8GiE6SDrqISWYjRoZgRG+Ilx20lohUoPZFdloNCKZTMJgMGBychI2mw25XA6pVEocCsKfzWYTpVIJe3t7EnUNBgNp7EvqOe9Rd0DmfqXT7vF40G63sbGxMUJ0IMTK9XK73aJDSD03Gg+aZZIk9eqrr8rzMZJnt5LFxUWB7NrtNux2+8jsp6+TYxuXd955B0ajUbpwbm5u4ne/+51YTJvNJjfh8/lkgBg96dXVVTx48ECMC6lxrOw9f/68JIc9Hg9WVlakSp2HemVlRZo80lNgOHr37l05fIx4WJRIaMNut2NhYQEXL17E1NQUFhcXUSqV8Itf/ALb29vS/6vVamFra0vqZXTO46Sys7MDk8mES5cuYX5+XhJ4VCA0tMS7S6WSFFWx9Qd5/zy07DzATs7E6BnpaXYe79/hcKDVauHu3buiENkr6/PPPxcYkklZznqhJ8OkOSGGfD6PH/3oR0in05iZmZHiP254/r21tYVPP/0UvV4P//E//scXXr+///u/h9lsxnvvvYf33nsPGxsb0gvN5/PB7/dLAWKtVhNauo5+0+m05BLItms2m9Jvzmq14tGjRxgOh1JDxGS9yWQSWjChCMKPVAJ0CJLJJCqVihQCN5tN3L17V5yheDyOeDyO2dlZFItFfPTRRzJAjIW909PTMBoPxys8evQIn3/++amKKPX+NRoPCmGz2SwAyCRTrfTpNJLA0e12BQKnw8aR49yjNNY8MzTypBbTEeB+ByDFiJOTk+K4kPnEM0w9AECG6uk8Du8pl8uhUCiMdDnQIylOs36ffPKJ9F67fPky1tbW8OTJE5hMB0MA5+bm8MUXX6BarSIcDuMP/uAPJOpkUe7nn3+OVqsFr9cLu92O9fV1qePz+/1CTOF5ZwRDZ/HcuXOIRCKoVCr4yU9+guFwKA65z+eT8xcOh9HpdKSjCll07fbB2JG1tTV861vfwl/91V8BOBgxwUBhb28PDocD3/3ud9Fut/HrX/8aW1tbCIVCWF5ePrYePLZx0ZWlHNhEtoHmuetkMNkgDI+ZONa9dRhOMyIiBqthFN2PibQ8nUSjlWckwGszEa0b7ukKd3oADLUZXbFSmE02echOY1x0Mz56rIyqdKKTB0YXBQ6HQ4kS+Ow0HJqGq5P+FH1deth8X+PsN3qMNDp8j7ozMimyur8cFco4Y4gJSBbEHUWtPq6wBU6/3xdHgdAU4U2yAOmtMq9VrVYlWU/lwpwcaZa8b16XBpnviTAiqci6eHD8unR+uA8ZTTJKJJzBs6HXjB4lcFiVrp2O0xZRakaYPoc0JppCTKXNz3Kv8t4ImRGKoaFlnkBfkxEzzzvPuL6m3v/8DNeGz897GicHcH9rRhk/x3NPXXVS9IHPp/vS6SFa+nvNZrMUI9JJJYzHlADvQ1OsGbUQNdBQoyYjEVYl25FGiOdUU8zHCyv5DEajUeZEadZdq9WSe+ce5D29SL7q2MZlbW1NKtmnp6cRCARw7tw5VKtVbG9vi3fDzUvFyOjC5/Ph3XffRaVSwRdffCEe03gL70KhgEKhgOFwiEuXLqFcLuPOnTsoFAq4dOkS3n//fRQKBdy/fx+dTkfwahZems1m6eNE7DMajeLGjRuw2+3SLpuUW7Zft9vtePz4MZ49e4ZisYh0Og273Y4/+qM/wsWLF5HNZiXHcxLhJmcrGhZRMnFqt9sRjUYRj8cRDAZx9epVWTfSEtnSgVXhwWAQ8XhcNgwVL40yDx0Ne6/Xk2dn+JxOp1Eul7G4uIjr16+jVqvhV7/6FbLZLKampnDlyhVkMhlJXDJyKZVKuHfvnjBQ6Byw3cX+/r4YZVKqr1+/fuKDXSqVYLVapX/TcDjE0tKSJFGfPn2K69evIxKJwO12Y3p6WiI70sA1/m82m3Hu3DksLS0hn8/j1q1bkpi/dOkScrmcFAOyUtntdks0w24TlUoFyWRypLKdCo5zOViF7fV6R9hjbK1/6dIlLCwsoNVq4enTpxJpk3IfDocxNTWF8+fPn8rzzmQyAA6VINmAVBo6QqcyohLT7V4YATN3Y7UejHi+e/cuGo0GlpeXpVTAbrdLFMzEPB0sDsfq9XpCHqASo7CXnoaS6BBSmLfULDeeF+ohbdROmtBn9Pbs2TPcuXMHdrsd3/3ud9FoNPDxxx/LFF7SvEm4IZ2cSAQAqck6f/483nrrLTlP7O4dDodRq9UwMzMjUQxRDuYE33jjDQAHRCqOxiZd/MKFC3C5XNjY2MAvfvELaTfFTgfz8/Ow2WySQyMrcXV1FVtbW9J2i4755cuXkUwmcefOnZef0GebEYZOxLhpGckU0tZYsxs4C4DtnbWF19EG6W5ms1lav7MOwel04uLFi0gkElhfXwdwUNsSi8VESZpMJumgzBoQj8eD2dlZMSD0Zol10zpnMhmpwmVB4fnz5/GNb3wD29vbp+qNBRwWh9LT0MwLHnQyrTjVLhqNwufzIZlMCqmAOCznRzBHpJtwUqhUaVyq1SqcTqd4JaRKcqOXy2Xcvn0bpf83M55MFmLVnNFTKBSk3c5gMPiSp8RCzUAgINEBW2WcRDTzh7UFLELc3t5GJpPB3NwcjMaD2gpOjiSjh0l4Qk9W68EM+7feegvr6+v4zW9+g2KxiOnpaanEr1QqsFgsmJ2dhc/nk8p8VtazHomwzXiFND1VkjGoUMgyIwuS37exsYFsNit5SOYtOFAuGAyeilTC2iMNWzFqY6TFfcpnGI+U6bAwomKynwnparWKhYUFQR5ofNjck9fQ0Bf3PY2ARgi4f5ncp+GmEaenT5o5vXlSdrWXrgkGJxGeg2KxiEQigdnZWSwuLqJareIHP/gBPv30U4RCITm7NDRERHRzWj4va1/MZrPAuAaDQTqDBIPBEQIKERnmqZlopz7Z2NhAJBLB7OwsnE4nCoWC9DpbWFgQAhahMuYQSRxKJpNYWVmRJsAejweXLl1COBxGKpVCMpk8dvT8QmOOydMmFphOp9FsNjExMYFQKCRJb7vdjvv378PpdOLcuXOYnJyUegNOdQQgMyXofQ6HQ5muxs3n8/lw48YNmYfw29/+VmAOelJWqxWTk5OIRqOCr2cyGVitVszNzWFiYkL6YrFJXq930OWYXjbH4MZiMZTLZezs7KDXO2j1QA+fLLOTCPuIsZ2L0WjEpUuXhAbaaDSws7ODUqkklGEy7pgfyOfz0juNbDg2xXvllVcAjLZtJwzDPAEVM+EYs/lg2JjBYEC1WsUvf/lLOZDE3wnlBYNBabpYq9WQyWTEoWDyWdORed3hcCisNcI7JxF6v5oZRA/Y7/cLQeLevXui2IbDIaanp4VRphk1ZvPBsDgqdCbeCfH4/X5cv35d9pbL5UK5XBb6eCaTkXwPW7vonArbmNDzp0JkwSzfBdeXe4OJalLUG40Gdnd3pTPFaYyLHgLW7/dHumrrZpukG+u6FQ3LEuZifpKIxSuvvCKMxVKpJNRhGkiSQwhJsr0781oaJueaUNdo48e8jS6OZDRGyrvNZpO8DH9XQ4wnEZ/PJ4wzRs2//OUvxbkIhUJi5IjCGAwHg/84ZZT6k1FarVbDvXv3pEiXLDNCiN/5zndGqMVk9dlsNmHKLS4uYn5+HuFwGNPT0/B4PNKhemFhAW+99RZMJhOy2axE0byfXC6HdruNvb091Ot1BINBfPDBByNOBBmWdBZfOluMCUeGhrVaDfv7+xgMBlheXpaBUGxB/dlnn8kiLi0tCVui3W4jGo0Kv5uQz5MnT9DpdDA1NYXp6WkpUiOGWCgU8PHHH+PHP/6xFDmyaMhqPRi4w8jo//yf/4NEIiEzon0+n9SIsPU14Qy24W+325iensa1a9ewt7cnyd87d+5gc3MTpVJJKLgnESojr9crDe9effVV9Ho9fPLJJ8hkMkin06jVaojFYviDP/gDUfD0gsnyIHWbxpcGmC0aGI3k83m4XC4sLCwgFAphY2NDvGUe0Hg8Dq/Xi729Pdy8eRNms1k2KnNZZrMZkUgE9XodOzs7KBaL0iqe3pfNZkOz2USxWITdbkc4HIbRaJThW8ThT2tcdA0Na2xo+IrFIj799FPpLsC6kTfeeAOZTAarq6sjldqlUgmPHj2SCDEYDAptdWJiAsvLy8LgsVgsAtnWajXpKry8vCy97dj+fXZ2VhQMI6f19XX0egdNDKenp6UAWTdnnJ6eRiwWA3DYdqharUr3gNN0iABGO0sDGFHiVLq6+Jb1UIToCI/RCJDpRUr4G2+8AZPJJGMiGOExWc39xHXRTTC1wdL3xf1Dw8q8GPOlJAhRT+i5T8wncL+etoiSjUkXFhZw9epV3LlzBz/84Q+F6TUxMTESvVOHvPrqq1hcXBQkhhBfv99HuVzGp59+KkWOdHqTySRef/11/MVf/AUMBoMwZDc3N7G5uSmGxmw2C5mARoM6EYDs4f39fdy8eRP9fh/f/OY3MT8/L+hDpVLB2toams0m3n33Xdy4cQOFQgFra2uSn2U5A7ugHEeOvdI6DNX/z3BVY5rAYaKTG0L/jk7cUdlQKQKjvXmo3DTd+SjRmxMYHfOpKZE66a37kPG+dNKKuQydjD6pcSHsp79rfKPrUBr4ch8z/Q70ewAOE/vj5IDxtdbfr9eEcINeTw0faAqqpkXz/fKzGloZp6GeRsZ/Xz+fJiLoP/SyNXtt/L705/Te4H4aV3hHraPujMC147/xXsdhJa4V10YTXPR7H4elTiOaGq4T6ePrrPfWUe9Tr6P+vD5/+tn0s+vfP2pf6Gd/3v4ZP9Pjv6/f5fj3jn/Hi4jea7rCvdvtjjDStOg9wv1kNptFN+rzpNdL907T1G29B/nZcZhS61VNjGAUzfvRa8szQ0dD56bG3+FxYUXD8GXs2jM5kzM5kzM5EyUn59aeyZmcyZmcyZk8R86My5mcyZmcyZm8dDkzLmdyJmdyJmfy0uXMuJzJmZzJmZzJS5cz43ImZ3ImZ3ImL13OjMuZnMmZnMmZvHQ5My5nciZnciZn8tLlzLicyZmcyZmcyUuXM+NyJmdyJmdyJi9dzozLmZzJmZzJmbx0OTMuZ3ImZ3ImZ/LS5cy4nMmZnMmZnMlLl2N3RX7vvffQ7/eRSqWQz+dlCI/JZJLZAHpeyMTEBKxWq0xN5FhTt9uN119/HZFIBDdv3sQnn3wyMmrV7XbDZrOhWq0il8vBbDZjYmICLpdLugZbLBZpH763t4disYiZmRlcunQJrVYLDx8+RLFYlI6lHC3LluKc4hiJREa60LKleKPRQC6Xk1bgvDd2EuWM+heR5eVlmc3O4T8c2czOvFwjn8+HS5cuwW6348mTJ9jZ2YHD4YDP55O1dTqdSCaTSCaTACDPwW6wnPtisVgwMzMDt9uNVCqFTCYjM1HYGrzf7yMej2NhYQEmk0k6pO7s7CCRSEjXVc776PV6MvjK4XDIzJRcLjcyd0IPEWNHVuBgbPWLyni33NP2Wz2q4/RRYjQaZbRDq9VCq9U68nNOpxNer1fm84x3mGYLdD0KV3edNRgMiEQiCAaDqNVqSKVSI0OZdMfx593D18lf/dVfodfr4cmTJ9jc3JRn5uC0QCCA8+fP45VXXsHe3h5+8IMfIJ1Oy5RNjo02GAwy/MzpdMrog2w2i263K7OCYrEYLl68iMFggN3dXdRqNUxMTCAej6NYLOLBgwdotVpy5jlem2szHA5RrVZRq9UwPz+P733ve7Barbhz5w729vbQ7XZlOiV/LxqNIhwOo1QqYWdnBwAwMzMDv98/0g34l7/85Quv340bN2AymRCNRhEKhbC3t4fbt29jMBhgbm5OJmZyRHo2m5Upmy6XC8FgELOzsxgOh0gkEvI5tt/n3Jmv6kAcj8cRi8VktHe320UqlUK5XMbExAQWFhbQ7XaxtbWFarUq13e73YjH4zINt9/vY2JiAouLi2i1WlhbW0OtVpPxJNRP+nuuXr2Kt956C0ajEf/hP/yHr12vYxsXTiwzm80IBAIjL7bZbKLZbMrCdDodUWIejwc+n0+GV1UqFTx48AAOhwP7+/uygHqju91uMSLD4VBGKOspl5yq12w2YTKZZLP2ej2Uy2Vpac2XxBbSbI3d6/VkeA4VLVvr9/t9UfRer1cOy2lmQXCsM6/Pe+F8df2dHKVKRR+LxeByuRAOhwEczA3h1M25uTk0Gg2kUikx9nwWGi49iIjPwPkXfGccRkVDwO9h63h9PbYJbzab6Pf7MuuHc+q1UvyqEQMnkfGW+V8nXA86DvoaeugUB3eNt4PXBvWrJvBxb+t26RSuF3A4kmD8/ul40Gk7amYG1/Gkkk6nZaz21atXZXYLABny1mw2sb29LZNObTbbyKhjjiKIRqNwu90yyhcAwuEwDAYDfD6fOB58/zRGlUoF2WwWRqMRExMTACDKi3Pb6YSaTCY8efIEa2trMnyL83Xm5uZkACHXvtvtyjyeXq8nY6o564czn066hn/+538uZ4UzXEKhEIbDIQKBgIw2rtfrcqbpNNrtdjSbTayurooDyPk21FXUed/97ndx7do1PHz4ED/96U/FmTAYDKhUKjJegs/Jc8j36XQ6cf36dZm8u7q6KtMmXS4X3nnnHczPz6Pf76Pb7cq8m1KphGaziXw+j1gshmvXrmE4HOLzzz9HLpfD7u6uDJg7jhz7tHMoDxeKY0u73a54qxaLRRaMU9g4XtZgMKBWq8nEQD14CDg8aJwGqEfz1mq1I+eGcBARx3Vms9kjD6COPDhKlUOIaADNZrNEOjxAjJA4EZKz6U8ipVIJwOGcFE5LBDAyn5zPzGFU8XgcwWAQHo8H8Xgc3W4X6+vrKJfLiMfjmJiYQLFYxN7enhhabSD6/T4qlcrIGnAjawVWqVQkIuP6cQ3058fnP9BTN5vNI5MX+T71/Ag9Z+KkctQcj68yMnyXvFdeg0OnvF4v2u22HFD+TD8ro5Cv+p6vMj7a4HzVNRqNhpyzo67xdb//dVIoFGA0GhGPxxEKhZBKpVAoFNDpdARhSKVSaLVaMnAtGAyiUqmg0WjIvCCei1AoJJNJOcfeYrHIaG46oMPhEC6XC3a7HZubm9ja2kIoFMLVq1dhs9mQSCTQbrfhdDoxMzMDh8OBSCQCi8Uio3u5z6hPPB4PyuUyAMg0TA4xLJVKsFqtcLlcMrCu0+lgZmYGExMTJ3Zy3n//ffR6Pdy9exerq6uw2Wzw+XwADqZ8ut1uZLNZcbJ4vqh3arWaOLQTExOiV7ROM5lMeOedd/Av/+W/xP/+3/8bP/vZz9DpdGTf1+t1AJCIYjAYiDPSbDaRy+UQDoextLSEiYkJmbY6HA7RbDZht9vx6quv4t1330UikcCzZ8/Q7XZlAmm1WgUAhEIhLC0tAQDu37+ParWKTCYzcr9fJ8deZc5/pnKkcRgfLMThXpxip40Kr2G1WsVD56JSMfEzenwuLWW9Xkej0RiZasjDr4eSjT+8trSEj9xuN2ZnZ2WEKK9BRUjjRs+VkxdPKpz053a74XA40O120Wq1Rjx7PQ5XD0erVqui3I1GIzwejxycXC6Her0uhkrDLuOHSEce40pKT68bn1RI74qfG48EOERND4PjmOHxPfKyh4Yd5/N6PDAjKBrZVqv1pUjh675Dwyv6+b7uPo5rWLUBHb+v0xjnVqslM9dbrRYqlQqsVqt4whytSyNBWMTr9SISiQh0Axzsg1qtBo/HI5NAC4WCjMienp5GPp/H1tbWiHHx+/2IRCLwer0ybhqATIfd3t6G1WpFPp+HyWRCLpeT9bbb7bBYLCgWizLNkfcTDAYF0qaOoKPDNSyXy0gmk8f2vMfl/v376Pf7ePbsmcBajNqy2SzK5TJKpdKX9oReN5/PB4PBINNiNRRG/ck59qlUCsPhEDabDZFIRCbN9no92O12LCwswGg0yshxPaRud3cXpVIJuVxu5Bk6nQ5WVlYkCsrn8yiXy2IkK5WKTP6kLqZepPF+6calXC6PTMUzm80S9vLlEfKxWCyYmpqC3W5HuVxGLpeTzaxzKDQ4hAL6/T7y+by8hFgsJuNKzWYzNjY2sLm5CYvFIiNUiStyWpueUCgP+f82MO/bYDDg/PnzuH79OkqlEn72s5+hXC4L9EVojoqV0RPX4CRCYzA1NYVoNIpsNou1tTV0Oh3ZFNyEnA2vcyd8HrfbjbfeegvxeBxra2t4+vSpGByfz4dcLodqtToSaVG5au99XHjw+R61IqNx5edsNpvAITS+wKHjYTKZ4Ha7MRwOxYvjfZxWtAE7DjzW6/W+NAlSR8WlUmlkDz9vhKv+LkY9hFyOO374OHtHTxHVz/si13ieMCri3HSHwyHvPJ/Po9FoIBQKIRqNytoAwPnz53Hp0iXYbDY4nU7UajX88pe/RCKRwBtvvIG33noLe3t7+OEPf4h6vY54PI63334bX3zxBT7//HMAB5CZz+eTHBajRj5fu93G/v4+1tfXAWDkDBNC8nq9MBqN2N3dxdbWFlwuF7xer4zydjgcSCaTom9qtdpILmN3d1d0xUnkf/7P/4nhcIh8Po9qtTqizJPJJDqdzoiO5P0zV+V0OhEOhzEcDsUY8czQuLdaLdy7dw+9Xg+rq6sYDofweDx47bXXEI/Hsbu7i93dXUxOTuJb3/oW7HY7bt26hc3NTTGsHJ1OY0vjwPP4j//4j/j5z38Ou90Oh8MBm82GmZkZLC4u4vHjx6jVami32/L+mXvmqPXjyrGNCxUDD6KGDrToQ0zvgV73uNelIZSjRiEzytCbTG+68ZGm/Pz4qGINE40n8MeVyfioUf7NnNFJD7e+rvZUjroeD5PJZBK8X48rtdlssNvtACBkCT0Lnd7oUaNkxxWyXjsd+XFd9O8zYtS5IqPRCJvNNjJm+KhxsqeNWI5az+N68c/bozr6/rr7exlR12nltJGL3++XPUf4V1+bf/PMdrtd2VMul2vk7PT7fcm5chQvf7fVaglxhrpCjxRnjpXOCVEDRvM8sxqeZt7KaDQKsYKRj74vPe6c78xisQCAOAPH9bzHpVgsYjgcol6vCwTNCJ3frfWJ1jPMRWpImeea98nnaDQaQpoKh8Ow2WwjjqIezc610tE4r60RDK0fG40GhsOh5Bt7vR4CgcDIXhgMBmg0GrJWJOa8iIN4bOPCja3nZBPC0ZADAMm5WK1WiUzMZjOCwSAMBoOEs4xc6KmPz4rmz7PZrCSwXC6XfDdwwNJxu90jL1TnHbgpSQhwOp2wWq3Y3NwURg7xXmKPjKT0QWZkdVKp1+swGAzY2dlBOp0Wb4oGGIA8P7Fni8WC7e1tNBoNBAIBLC4uSqKUxo4HlMnAcDiMSCSCWq2GfD4/shEZzdBYGgwGeDweITTws4TWeCBohHn9cDiMVCqFSqUCt9uNq1evwuv1YnNzE7u7u7JevK9xdtTLkudFGc8TGlsNhR1nPv34z6lA+TOtWJ8nz4tEjvou/RltCE8r//bf/lv0+32sr69jZ2cH1WoV6XRajAhJGbu7u6IECT/bbDYkk0k8fvwY1WoV29vbqNVqSCaTWFtbQ6FQkBnuv/zlL/HZZ5/BYrEgEAgIFJfNZlGtViUHyP3ApDwNAVmjzIMySb69vQ2j0Shn2eVyCSkgmUx+KY9IAsL8/DwCgQCq1SpKpdJXEjO+SjKZDIBD6Jl6wmq1YmFhAV6vF4lEQvKlAAROop5hzkQn8YGD/eHz+YSctLKygvPnz+Of/bN/hlarhV/+8pd4+vSprF+tVhM4vN1ui47LZrOwWCyYnp6Gy+VCqVRCqVSSXBlTD9QdrVZLctZGoxGlUgnD4RCVSgUrKyuii+PxuBj14zpZL5zZIg5PxTG+6emVEC7gZ8xmM5xOJ4bD4QgVt91uS1LearXCarWO0BJJGCCBQCeYAcjneRh05KLxdr5Msl9KpRKSySSMRiMcDgcsFsuIItWUSAAjnsJJhNDROIRE40LlTwNApg7zIHa7HbFYTHBnnVDXGK/D4YDT6cRgMBCjrD0rQod6/RiJcI14TRpbrgMPvd/vl+Q/KaehUEiSlRrr5p+XQR9+WXJS5ULh3gcO2WhflVd6URLC835+WgNz9erVkT2eSqWwv78v75iRcrvdHnEk6fXWajVsbGygXq9LHpBOTLValeek4ZqensaVK1dG8jy1Wk0IOvTkj/LCHQ4HrFarwK7MyRgMBrlfsjk7nQ7S6TQajYboEH29QCCAeDwO4IDUcNJ9SMOgo38m4X0+H+LxOOr1OhKJxAhSw/VmZAaM5i4Hg4HoMTrV7XYb165dw5tvvolSqYSf/OQn8q5IlCBq4fP54HQ6hZhBWnwgEJAIk+tKAgDzPq1WaySio7PabreFBUooE8ALoTcvFLlQAfFg6ZdHOMZms40wyEj3BEYjneHwgJ4YDAblWjQmtVpNMFkaGbLR+D3BYBA2mw1zc3MjIV2j0cDm5qZgnIxIaK0TiYRQlWl42u02TCYTvF4vHA6HUBfHw8/TyLhy4cEwGAxCxdRJYuKeDF+5VowG2+02PB6PJPW4CUg5BA6poazT4IbWrDt+t9FolFoihuSMVkOhkNTdaM+HTsTW1hay2SxarRb8fr/k1+j52u12ORC/b6Gi154j/x53FL5Ovi6nY7Vace3aNUxPT4vxrdVqUmfV7Xa/xDQ7ai8dN6o5rSSTSTl/Xq9XcnO8T81apGPWbrexsbEhxojkF7Ida7Ua1tfX5cwwwmcOkQah0WiI8mMegM9KtILf73A4cO7cOdlLRDCYK+J+pY6gwmYkQb3k9/vFK+e1JycnT7x+VLDAob4iCrO3t4dyuSx0X53r4Xnj2vPeSZrgGazX65KvDgaDqFar+Nu//Vupe9JwGq9Dp73X68HpdGJubk7yp06nEy6XS67PfAz1B9eEORen04lEIiH1OSx3IOwJYAQl+jo5tnHRSXsqHSq1UCgEr9cLj8cDr9eLYrGIfD4vCt7lcomC18wwslBarZZsnEajgVarhUgkIt4GSQJkmQWDQVy+fBl+vx83btwQ7rrBYEA2m8U//MM/YG9vD5OTk4hGo3L/9XodP/3pT5FIJEZgDEYNU1NTwnJhgdO4Z3Va4TVsNpso/0KhIMwMblqGqTxsHo8H4XAYZrMZiUQCnU4HPp9PDEK9XhfvrtFoCMPEbrcjHo/D4XDIMzA5OhgMsLq6inQ6DZvNJoaVrB8e0mg0iu9+97twuVz47LPPsLW1JUqTBViEQFjAVigU0O/34XK5RAm9SEh9EtGHeLymhX+4d7/uPr6OMGAwHNTJvP3223j33XeFbppMJlEul0WRHlXfMn4dRrDHZZ6dVPb392UPBAIBKbJltMLvp5NCR/Lp06eSDCcrKRwOw+FwoFKpiOKj88ioR5MCuD/r9foI65LRNCPqwWAAp9OJV155BVNTU3IPm5ub2NzclOJcsscIdxF+ajQaaDab8Pl8mJubg9FoRLlcRiaTwdTUFGZnZ0+c0CckzzWk4Wu329je3haYWTvFvFcNOxMtsdvtwhqjXrRarQgEAlhaWsLm5iY++ugjidSAQwPK65nNZilCdbvdmJqaEp1MR5Q5MLLbxkkodrsdS0tLCAQCktLQ5SQ0hG63W0gZx5EXilyALx86hlkM0VjJDIxSgnWSicqa/wYcViATdqP3zn93u90IBAJS7crNCGDkegz5tJdO0R4iv1M/DzFRUoSJNfPgnxZOMRgOqrCZWKWXpRPx4xXt/Fm320U6nRZMlhuEh4/3rHM5TqdTDBPZb1xjq9WKfr8vXQo0BEbokHg3IUvWBzUaDfT7fYE5+dlWqyXKSid5ydgi/Pb7lOfBUvpnX3UP2kA973OEbbxeL8LhMGKxmOxbg8GAK1euwOv1YmNjA1tbW18JZ/2+oxUtLJikIisWi6LsNINOQ6FU+IxWotGonK/hcIhIJAKPx4NGo4G9vT2BWfhH5xj02def4T2RTeX3+0c6GjBS5lnw+/1wOBxwuVxCSzabzXC5XCPREJmX2vNuNpsnzv1pxIZ/aDg0gYZJch2d0YnQsDThKrfbLQgKAIHGdbcM3YFDlxhoyNvr9WJmZkYiF+oUh8OBfD4vXUd4brWzSYM/GAzgdrvFUNOR8Pl8giy9dFiMniDzI5pBRcyVLCayIFg8SeNDC81N1Ww2xesgxRU4xH63trZgt9tx/vx5BAIB3LhxAzdu3EC5XBYab7lchtPplLYL1WoV3W73S5imDmFZvUu4joe/VCoJ95y4cygUgtvtltY2J1UETJh+8MEHeO+99/Do0SP83d/9HRqNhkQgLIpsNBpYX19Hs9kUj6FQKODnP/85AMhh4T3x+jrcttvtiEQicLvdWFhYgM/nQzAYRCAQQLvdRj6fR7fbxeTkJIbDIVZXV3Hr1i10u11EIhEMh0PkcjkpvOPByWaz2Nrako3c7XaRSCQk1GZilzRTJh5dLpcoppct+v7GSRdcFypU4KvzHboGi7DkuLDAkFXMr7/+unxXt9vF8vIyqtUq/tN/+k/4m7/5m691THQE/Tw5ioH3ovLRRx8BgJwDGgm+LzouuVxOonmua7fbxdTUFK5fv45+v48nT56gVCrhgw8+wPe//31sbm7ib/7mb6Q2g2yjdDoN4DDHQEdD50Z5PmdmZvDOO+8ITNZsNpFOp5HJZFAsFmEymeD3+/Gtb30L58+fx+rqKm7fvg2DwQC/349AICCdKLgXTSYTZmZm4PV60Wg0pO7mJMI8o1boLBngWnU6HRQKhZH9RgOkGV3MWcViMczOzgqRAoA4hIz6+V0UXkPXntlsNpw7dw5//Md/LFRvs9kstYEPHz7E3t4egIOaIEJp1Idra2tS07S4uIhSqYTt7W3Y7XZ88MEHeOWVV3Dz5k386le/Ojb1/kSlquOeoC4E4sYa3zw6uU5LzxdAj1p7ArSccqP/rzAzGo3K5zUbjB6OTpjxZ/q79TPQm+GL43U0PEBFTeN00o3JpKjH40E0GsX29rYoMBoebiquI1l23LT5fF5Cb4vFgkajIcaZh1e3qeH9u1wuqYMJBoNy+Nh3zWw2S7sefifXUEM2jJLo2TqdTslXUXFw4xGb1e+AlNCXLRryet7P9J7VCvqoKEfT3Y8SJlG9Xi98Ph98Pt9ITsXj8Uj/uuMYg+NAdPrvkwqptDwnrHOhd8+9oL9X/7Hb7QiHw+j3+8Iw9Pl8mJ6eRrPZlDwOz5km9GhIUhfr8tpU1IR+mSfQTiH3uc/nQzQalf5ZJpMJgUBAqvJ5ZtgJhJX0uhPDSWTcQaAO0VR+Jtz1s1FfaZ04nn/RtOTxdef6AJDPjN8Da8vi8TicTqeUB7jdbrRaLaTTaUn6MxfNNR0OhwKZ0aDxfpm7ikajcLlcojeOI8c2LlTEVBaafqzblmhlbjAY4PV6hV3E3kt8EbpAksaC0QMhtHa7jUwmg2aziXA4PFKMyDwJ8WN+NxV0pVJBJpORxpWaZaLJAQwhU6nUSL8xJi25IU6DiU9MTMBoNOLRo0fSQJLwEYvBhsODvkWkGjKpT9iKGKvL5YLL5ZI8kk7oE9fmO+l0Onj33XexsLAgnrXD4cArr7wywrFnP7hSqSTtZYbDIfx+P3q9Hu7fvy+Kh40qSQK4fPky+v0+dnd3kUwmR4o16QAwIfsyIpfxXAgP91HsRUJ6VFRUYmazWfBnLZox9zxj5fV6cf36dUxNTUm/N23cXvQZvyqhr+sLTluEqpXCeGQ/7hTqZ/F6vfB6vYjH41JgGQgEJN/2X//rf0Wn08HExATC4TDsdjusViu2traEkUSG6OzsLGZnZ2WfdTodgbuJELhcLszMzMBms4lDYjKZsLe3J8WWFosF9XodoVBIcjuVSgUXLlzA/Pw8Njc3kUwmYTAYsLy8jKtXr+L27dvY3d09MbytoXIyWgllETbmvmEDWovFAo/HA4fDgXq9jlKpBIPBgMnJSYmQd3Z2JPpitLG5uYl0Oi1wNxU+13GcEEGGWDQaFcSI6wYcNO/8sz/7MxQKBTx58kTa/BDiZm6IyA+NcL/fRzabxc7Ozkhpw3HkRMZFHzxaN0YbGpOj0mM1PjczlYHu/0PjRDaS9t6Jq+7t7cHn8yEUCuHixYtwu90Ih8PweDwYDAbSfI/tVQqFAhKJBDwej4SSACQ8peJh4ptsF1KAuWF4+I/LMjpKQqEQBoMBtre3cefOHfl3JtLp6bP9Ar1LRjY8/Ozt5na7pRXDOJbb7/elR5DNZoPX65U+Q9VqFS6XC/Pz81JpTyLA/Pw8UqkUnjx5gmq1KmSMfr+Pzc1N2QNUqHyH8XhccFvSMOlc8D2SOnlaGY9S9P4bV+r0dElN5b8RgtX1KhSu31e9Z5fLhXPnzmFmZkbaZvDa4/J1ORXtnR4F6XGf8t5OI/q5NKpw1HnmfgMOIlRCqsTePR4PqtUq9vf3sb+/j0AggCtXrsDtdsPr9cLpdMJoNEoSnq1kIpEILl++jGQyiZ2dHfR6Pfh8PjFKLI6MRqPw+/3SGYMoBs81I3e/349msymkAp/Ph8uXL4ujORwOMTc3h6tXryKRSAA4OaVb50AdDodEQpokogsX2eKGeeJCoYBisQij0YhQKASXy4X9/X0kEgk4HA5MTk7KGqRSKWEc8n2RXaYdAuCwnMDj8Ug+iu+PiEM0GsUbb7whcBeJP8y10Inhv3FP0OFnjRK/+zjyQmwxg+GgNxbhkFqtJjegW9vrokWGtbqYjp4NAIF1+GLGFRATXcPhEIVCAfv7+wAOadD8DF9wv3/QpZd5IADCRiNsw0hJ19boPxobZnSheesnEUIS40k7eiNcR7JQGD1pmJAbi3gtK225/uOFkM1mE+VyWVrm0DCTEGE0GsV70SSM8ee02WwCR7JNiMvlkqIv4LB+R5MSdIjPd/YyRF9HK0FGw8wR6AOm8xqsHCckO24Anne/NGJkB3W7XVy8eHHkM9yv9DC18fiq53/ez5iPOG2NCwCcO3dOnDCeXToXzDWaTCYheTA6JbrA82U0GjE3NyewHz3nyclJgXbtdruMwWARX6VSQb1ex8bGhvTgYsPLSCSCSCSCWCwmLV2oJ6jMGUU7nU7JRRK2LpVKopTv3buH3d1dOc8sFtUEoZMIyT3AIeQHHOwL3UGa0DLXjPdot9sFceAZ1ZEQf4e6kvAjv4OiHQHWmZ07dw7RaHQkr6Mh3mq1isePH0seVacwxvNBmuFmtVqlY/KLsj2PvcrEBMPhMKamplAul0dmKnS7XQQCAUxPT6Ner2N3d1ewUibZWMvh8XgE86PSZximK+OpANhuYWdnR67z9ttvS8hMK0tj8OzZM+zv74tFZytqfg/rcZjUd7lcwj5xOp1i5LrdrnhghFROqiBpFKmgbDabHE5SJQkrkgzBw8VQmYognU6P5LIAjEQ4XDt6PTdv3sTu7i4+/PBDvPrqq7IuVDTZbBaVSmWE8aSFnjq9xUKhgHA4jLm5OaEsMjIlK41rpdlXL0O0l0jhIWUBKancNCrasSGUyKiAjoPeQ+NrS+Hn6/U6bt26hWg0Ksl8CqPGarUqlFFG7Lx/ijY6z4t6NEPptPLuu++i3+9jbW0NOzs7qNfromhoWDjXx+l0IhaLwWKxIJfLSc0Dz8Qbb7whESD7rPE5iNszimHzxP39fRSLRezs7IgS43yic+fOIRaLYX5+XlhjNptNruXz+TAzM4N+vy81HDQetVoNuVwO/X4fT58+xaNHjwBAznU2m8WTJ0+Qy+UE5j6JkIpMqI/7i+iHrrejwQYgCE2v10MwGJRzzqiBholJeHao7vf78Hg8AL5cuAlA2s8sLy/jnXfewcLCgjwfnSYajUwmgx/96EdIp9MjkBcRBq6ljkz4+9VqFYlEQtIax92LL2zCaeU0zVd/4VFQBPMF4wdNJ4k1VZHX5PUIo+lCQE1tpjdK3FXj63yRnH2g2WpUIrTILKRkO34ebk0tPKnQi9V0YL0O9Bb4c53rGVd0R8En4y+dXoc2osSw9XVZYV0qlVCtVkdGK+h7IbSoWX3Eawnh8R2/7EjlOMLnP2rz6+hJf1YnSsc/81VRqvY2taLifqF3yD00fj6O+o7nrZUmCpxWfD4f+v2+eOAabh0nvug953A4xGhwTxAypUEHDvc4nSKiAPzDPa87ADCH6Pf7ZVAVc2Q84/o+ddsUtt4nXAxgpHKdUSzp8yzwPM051tEwc45skcN/4/nSMKbWX8Bo93IaCY7+0KQZfuaoMgrC4ySW0MhrfcBrcSwBGbvPey693/SaM9qnATqOHNu48CDQ+9fGgJuAUJnRaEQsFhO8rlgsAjjsDKxrNMg005taP6TJZEIwGITD4cDCwgIWFxelepUGwWw249mzZ/jHf/xHKdYjS6JYLAoNWvPF+XvdbhcPHz4UbPab3/wm0uk07t27J79HWO+4LImvErfbDY/Hg263K0lz1k3EYjFMTk5KtMa2FixIPMprf57S8Xq9mJ2dxcTEBP7kT/4Ei4uLiMfjIzh7q9XC3bt3cfv2bRSLRaRSKYHtmGB1uVyIxWLS66xQKMBsNiOXy+FXv/rVyEZjZKo392nyVM+T511PFwIy3NfFoeNsPw0nUkEclXPh3tfFv9/+9rcxPT2N6elpuafh8KBj7g9+8AM8ffoUDx8+HGFSEiJh4vercii/DwM9NzeHbvdgEJ12tPSzsfbFarWiWCzC4XDgtddew9LSktCWCX8TGvX7/SNKlX/Yd4wQtYaBTCaT1ApdvHgRr7/+uuReGo0Gnjx5gmKxKJ0yqtUqNjY2xIkJhUIIhUI4f/48crkc7t69K++UHjlZkfl8HjabTXIeJyVGsNCZaxWNRrG8vAyDwYDd3V2Z2klmWiaTwXB4MJOJM7DIuKKeYoQXiUTw2muvwel0Yn19XchFHPCmhxySwXXp0iWEw2FcvHgRs7Oz8h4IC/f7BzNwEomElB7oKJ17cjA4bFKp2aG6Yzuh+tnZ2WOv1wtHLhpm0IaAXg/xRnoz5XJ5xJPgAWZ0cdR1tMIiVY9jQsmGYDTCBSuVStjc3JTmlmSfEd7iYdIRF4sC8/k8Op0OFhcXMTExIXkZGhX+7mlxb4afTMbTG6DHogeC5XI56WjA+RRUBOORylFeMTsARKNRzM/PY2lp6UuFp71eT+pW9OwHHe2wLTcnCXo8Hng8HiSTSWnQx43PaIf3pO/r/xdRzGAwGCkABEa75I6LPmCE8r6KJca9abfbMTs7i7m5uS+1w2g2m1hZWcGdO3fEKdDCw6odheNEWi9D2CmDEYR+P9zbVHzsRExm4vz8vOTxeJZJn2dEow00z0upVJLpkNpTJ7phs9kQCARk2ipZk4SK6dD1egftSJrNJhqNhkTSVOTjeRSiIkajUSbl6pHCJxH+HnWWxWJBPB7HYDDA5uamMMGYlNcdSTT6wnwg6+0Im8ViMbjdboEhyfbUkRn3jdVqRTQaRTQaRTAYFPLAeEqh2WxK8l7XeWmHBziElnVZAY0LC2PJSDtu7vnYxoUWjTkUzukgZsfwNhwOCzWQRoQbVQ+fOSr8GldIvK7f75chQ7FYDH6/H4uLi5I3YDGn3kRMvHY6HXi9XrzyyiswGA6a6hWLxRFcXhcl7u/vo9FoYHp6Wlp48ECeFKsFDmGmSCSCubk5maLHHAtzL6urq/LvPCBcJ8rzFBLDdBZQEgceDoeyJs9LDBIjHgwO2Hrk7LNj9N7eHkwmE54+fYrNzU3U63UEg0HZxMCh0qDhByDYealUQj6ff6lGZty7p0GkQaZzAXx1wz3mHLgOR63vuDHn2jD6YOSuR9JqQ8Lf1YpXOyv6+3w+H+bn5wEA29vbKBaLpyKTUH7yk5+g3+9LBGAyHUxEZO6t3W5jenoaS0tLaLVawioCIN24qdQ5/psGhfum0+ng9u3bePbsGarVqnjT+/v7wkLiujFqp5PI6vl2u42pqSlpNUJI7tGjR2i323j//fdx6dIlNBoN3L9/X+pZuPc1GkAHcnNzE2azGa+99tqJ1+/GjRsYDofY29uTlkkse2BC3ufzYWpqaqSEoNlsSk0Oc8yMDn0+n7S6CgaDYpgymQxcLhc++OADdLtdJJNJ1Ot1OBwOAAcISKlUEp1EcgMdFjoQKysr+Kd/+ickk0kUCoWRCIXRo45mGPWxDQ3TGAwaiD4dR14IFqPCZkinG7ORScZ273t7e6jVamJlyaAZj0q0R3iUwmS7h0gkgmg0ilgsJpXRNpsNm5ubMhyIiX9NhzYYDooO3377bUmWkXJMi0xsuFarYWdnBw6HA7OzsxgOhyPdVjV//EWFdTWxWExCeRpFenWclMcohiwxyldFTnw/xF9jsZh4NTTsjDCOWm8mGIlxAxhpyb2zswMAePjwIdbW1hAMBgX6ZI0RYRN6TGazWYzc5ubm7924sNcU71sTM74KntMRz1GfGYfICClqmI3Gmcw/3cpIG+Dj0InZMw84oKazP9dpDcw//MM/yPMMhwc1TGxZz/WZm5vDe++9h1QqJQ1gAUjncO4hKlMdrbCH1c9//nP8/Oc/x8LCAl5//fWRPB0/ZzAYBCGgLtGEnpmZGSFp0Ih98skn6Ha7+PDDD/Huu+/io48+wg9+8APpssziYraLisfj6PV6uHPnDhKJBK5cuYLXX3/9xMW8b731lqAgJAfQuJB4w6JSGhfqJTpk2WwWBoNBJkv6/X5MTU1JZ3HSjVOpFC5duoRvf/vbaLVa+PWvf41EIjHSKZ0MVEaYOn9ICO3p06f4+7//e8k7DYdDeZeMNnletePDcQYGgwG5XA6NRkPIWC/duLB7MT0LevxHQVr0oMmb5sYZP6R2u32E3aMPHheIDB0WNLK4kd5SuVyW2SL8PT1ciAvH9tFutxsTExPS/ptWWcNPNJrA4RwXdi096QHn2pTLZSQSCVHkPFC6My3vgfgpDcJRiXwaaP43PRKbzSZJ0vE1o3JkBMp3NBwetjzX2CtzV3x2u90uLcZ5HXrsfB5+Dydpkmn4Mo3L+LUYPWjn4qvyPprVdhQcNm68uMaEfekZ8zPcJ/pdniTn1Ol0ZOKfpuafdu3oOFBBmUwmYQ7x3NbrdSSTScmTMr+2traGcDiMhYUFccYAjOxfzhrh36wzI0GGpBqupV43HTGyboteM8sBJiYm0OkczHrnqGGiEE6nU/SFjuDpWDDHycLKkwg7QvOd0FBqHVKv179UbMhuI/1+XyboMqomZMZ6PoPBMFLYyGtw31Fn0tCTOTcOozKy1ukHnb7gXtb6e1yfEFbkz0maeumw2JUrV9Dv97G1tSUWlDQ5doHlwhuNRszOzqLf72N1dXWEV82FYtJ/dnYW1WoVT58+/VKRFymzxGI5o8Dtdsumfvz4Me7cuYPt7W0AEJYKAMEa0+k0PvnkE7hcLiwtLeHq1avY2dnBysqKDCOjZWcVOe+RbBA9mOskws3y5MkTrK+vj4x5LRaL4hkwlCZsRox/vCoXgCRXAYwYBpPpoB3GhQsXEAgEZGY5IatGo4FUKoVCoYC9vT0kk0kxrPS+dDvwYrGItbU1gb2mpqZw4cIFvPbaaygUCkgmkxIp6PCaMGQqlcLk5CTeeOONY3s9x5Hxd6FHAWjq8fOE0SijtqOMt/4evh/2gWOrDeBwMiM7B1cqFVHc407VeK5l/Huy2Sx+85vfAIB4my9DqEACgQBCoRDK5TK2t7fFUbRYLDJ7nU6Ny+XC559/jrW1NXzzm9+U4mUaCu6nRqMhyn5/f1+83WQyicFgIBRY7lPNKqRTwP/XrFB2lmZfvnq9jqdPn+KTTz7B5uYm1tfX4Xa78eabb0q1PnMZHo9nJG+5srKCra2tE6/fvXv30O8fVKwPh0M5R2RdcqRHqVSC3W5HKBQSuDubzcLv92Nubg6DwUAc4unpaZhMJjQaDdy5cwf9fl9GJjPqYYTncDgQDAYRCoXg9/tx/vx5+P1+TE5OjuTpWBTNEhD9/mnUdKdlOvKacML7pqM7HB70Ffy9jDlm+KTrF4hvEwqhl0HPeTAYjFBux2mfTAw+r1PpuEfOBCCT9VQKrODn9XVugfdULpfl/tl7R0dGtMw6x0EDp+mBJz3oXDfmAliMyp8xVB8nNWj2zVHroymK+sBq71pHIlwTUjapEJn70X+Aw8RovV4Xw6UT/Wwdzv2h/9CDordKvP73JS9KutCe2lE/e97n6UHqyEUbF0Yux4laeKAJLXG96Vy8TOE+4p4nzM13bzabJdLXRZTMoWpDpxUZPfNyuSzFdrwO9QIN/3jeDzhMPgNfnnvDqMZkOuidZTAcNLxlqyLWrTFi107FOAu12WyOtPt/UWHhqaZH83r8Xkbtg8FA2rlQVxGtoV7UKQEaEzJomcDX9TTcezabbaSDtE7kc+10TnA8hzh+RqiLNW1cvyPucd2R4DhybOPy+PFjuZHZ2Vm4XC6EQiEYjUbZUO12G0+fPpX2DZzuSMPAtgT0RtgzjLkHXp8LxY3FP06nExMTE+Ld1+t1VCoVwfy9Xi+63YNhY7qFPBe81Wrh8ePH2NraQqFQkKTZO++8A7fbLfkELqiu66ChOakwsU7CwXA4lFYs7733HuLxOB48eIDbt2/LRgIOsfCjlCb/nfdJnJVeFPFn0scZhVGxAIfzIcxmsyToGZbTw9FFkDwUxWIR9+/fh8lkkoiERodzKBqNxkghKDf6SUSzv8bzdCdlVnEPHWWUjrqObr3Dcc80qtlsFg8ePJAEPDHscdHKEzhgcC0vL8PtduPZs2cyYvj3IXx3rLhmTRNZcuzo/Prrr4tRASDtS6ampuSscwBdJpPB/v4+stks7t69i3K5jHq9jlgsJjkYDctoCJ37iqgBkQ86kTTmTqcT9Xpd8rhG40H7lGq1Kvnc27dvj/Q3ZDsUGgC2azlNOQF/l90BOp2OEHA6nY44GzTeFHacpjNpNptlyJ/D4UAqlRJYsd/vIxgMIh6Po9/v4969e2J89N53OByYnp6Wru3AoUFlR2j2KaSR0U6+PkMkTXEtSZmem5sbQUZ2dnbw7NmzY7Ptjm1cdnd3YTKZMDU1hUgkApfLhUgkMkK9297exv7+vnTd5DAceuZsfcCXfFSyUisKLhY3DJtMEtvkpqSCoKf1vMPd6/Wwu7srirPZbMJms+HChQuYmJhAPp/Hs2fP5H65Seixn6arL2dN8HkASGfay5cv4/Lly6hUKrh586bAFMx56JfJTQGMGhdi6PTQdCTC/wYOp/5xg/F+yLdnSM1rcN3HIU220g8EAvjmN7+JcDiMYDAIn8+Hmzdv4pNPPkGr1RJok17xSUUbF40V68hOK+XjKGgqved9fvzfuC+ouDhwjY7Czs4O9vb2UK1Wv7KPmr6uzWbD/Pw8QqEQSqWStF3/fQjfOR0wQlFa0cTjcbz11lsAIDlJMpn4b51OR5wZkneSySQePnwoA8iCwSAKhYJMNT0KpuR30qhwbAZrQuiQcv/lcjkhCZF6S/h2Y2ND8lz9fl/yEdwrVqv1VM4NcBidMMprt9vSr4z3yZyPpkazmwCjGIvFIgn9SqUi85moCy9duoSZmRns7+/j0aNHGA4PhruRFDEcHjTGDIVC0pNNrycdTPZkYxRNGT8vhD/JtKOBZ30OnRIOajsuOvBCVGQAkpfgZDNSVukB62pwTkHU7a513Qg9mKMgiEAggJmZGXg8HszOzsoMAr5gJiVp8dl7ixtZGyvS6kymgzYIhKZISODM73w+PwJlsJjxNLkWCiEFehG6j9CjR49QLpexv78vIS4hAHqCmtaqCyq5SXTBE2nVOzs7UoBKggVhESYGo9EoZmdnRyIkrbjZH0mH+zRoNFz379+XgktGLmT90CPmwTltzoUbm39zHY5KulOREpIYjwb5+18nXLOLFy/i2rVreOWVV0ZG3gIHPfK2trYEL6dS+zppt9uS5+B4b66ZvrdxhXUSobKlgwFAzgCVHyNSOnDD4UFhKCcbkmlUq9Vgs9lk8mav18PU1BRCoZDkX2kgNJEE+PLgQW1g9HwiGo5qtYpMJoNcLid0XDLVOD2RyAB1kXYGuWcZKZ30LM/Pz6Pf76NQKKBUKsHhcMik2/Fuxcx7sniTiplIDju/A5CuyewoYDQaJSpbWlqCyWRCKBSSPK3X68XU1JQgEXyuTqcjww7JRNPzYBiF6CiGZ4dwF6MhIhyshWPuZ3p6+uXDYjyYrJrlgeNN0zNmWwj+HYvF4HA4sLe3h7t3744UPj7vgBsMBy2pv/vd78rseN24jsktGhRSkdkEk7APDYzD4cDU1BRMJpOMMGbldr/fx4MHD2A2m2V2NPFvAHLAtHI6iVC5akYYC5R+/etfA4BQ/VinYjKZsLW1Jcl+3c5CX4NQo8FgkALSYrGIBw8eIBqNYnp6emQaH/nq/X4f586dEzbd7u6uKIF+vz+SWCV0yTCbZILhcIi1tbURRUplQeVORcUxuycRvVfGIyAdVfH9u91uOaQ80MytUXG/iGGxWq1477338O/+3b8TYgl/DgC5XA537tyRxp7akH2VNBoNPHjwQJQhZ8GMe9mMmE4j7CagnQcmvMlAIsRFeBQ4aNcej8cFDiTmb7FYJM9itVpx+fJlGAwGpNNplEolSeTT6dOwGNeOe4SGhb9HpGNvbw+pVAo7OzvY3NxEs9lEPB6XOpvJyUmBzhhNENrR7XeYdDebzSfegzdu3ECv18MXX3yBVCqFSCSCN998EwaDASsrK8jn8/L9ZLexIl+PBKFyJxTNLuMUMs6i0SiuXr0qRowGiExQdkDmXiM5aTgcSv9G9kNjeQMdVp5POkF00L/zne/gO9/5DjKZDB48eIBSqYTV1VUkk0lMTU3h8uXLL5+KDBx6E0yc0TvViXRaQuZL+Bkmw7/uxRKCcjqd0kohEAhIDyN674TDSBXWoTc3kN5YmhY6ToMkGYB1IroDscaHT0phBPAlaAs4PORUwBzwo6mZ4zDC+Prp5+T/M2LQ+Z1xMgVDe80e4d86KuCfcZq4PiTsNKCNHT9H8gQj15ch4+yqcWGYzxqK563dcb+LB9rj8UgEzfWkp8z9qBlix/k+vY7c4waD4cjE8/OIHceVcaWgnQztUPH9jxM4NIWZjqVmdXJdmK85iuGon0VT541Go4yHYMcK7lM6Vsxd0NlhBM26Ft1RmN/PMz4evZxENOzG96Z1h+6aTAfXaDSKUSYlW681Izx+llFErVZDIBAQB4/PTUhWIxEapSGaQOq3HinBMzpu3EmWoH5lQTobsOqAgNc4jrywcZmbm8Pk5CRyuRzW19dHIB6GfeRD1+t1ocPxEB6lGDQrjCN/WTAZDAaxtLQkva448vfhw4dCjRtPevNlcTMwGUgiAENFVq3zGaanpzE5OYlMJoOHDx9KpSq9Sob4JxE+u2an6SaRPDCsnOam1eG0hoS0UuJ66o3DnBbnZWsGGDcTK38fPHiAarUq7Up4rzQc/B5ubrfbPVKUxQNOxcDOyRaLBcvLy5iYmEC5XD5VXyc+l276qZOzvF/goA7n0qVLcLvduHPnjvRw4+ePixnTmSK0y9yDdrBI6d7e3kY6nZZ8y3GYYvwOFp9Go1FMTU0hm81KS3r9udM6OMwD8RqsJu92u1IyoKdrLi0tSY+6aDQ6glIQmiLtmkaIMDXboeg+hHo9eA3mZ10uFyYnJxEOh+Vnw+EQXq8XVqsVwWAQfr8f9XodDx8+FIoz8ytESFKpFFZXV4XFNhgMJHJixHXSNWT+g3UsqVQKv/nNbyQ/EY1GRQ+RFdbr9XDjxg2EQiE8ePAAP/rRj9ButxEOh6Vjc6FQkNz1cDgc6VK+uLgIAMhkMpLLYq0RnVHqT8Lc2WwWP/3pT7G9vY0nT54AONQHACQPrnXuu+++i3A4jFarhR/96EfI5/NYWVmRAle23k8mk7+/yIVV+GyJMg7PjCulQqEgRXS6t9VR12Z+RNNc2VMsFArJIRwMBsjn88I2G/cSde6ASpghcb/fl/umEqVSplEjnRo4TN7pmpKTCiMI/f38DkYsmp1FyEBHg1rGFZj2yojb8zu0YqKRMxgM0nZdDw7iz/T1ySijFznOPqHn5nQ6xRCZTCYZkUqDetrcFe/9edehsfP7/ZL05b+f5LsZBfl8Prjd7pFOyMPhAROJe5yNEo8qyPwq4fqxdxMZUUc9+2mMiy5g5HlkRwMAcmZ5DtnhIR6PC3mHv0vjwr3L56ARp1OpmWL6ebXDxhyQ1+vF9PS07EuyvliDQ2drZWVlpC7GYBgdt0BojX9o4AB8KVf2IsKKeKIB7NtF48ZrD4dDQU/6/T4CgQDm5+eRSCQEAuSaMHKh4zscHvRVK5fLUntFAhLfjdfrPdLRYLrAaDQimUzi2bNnAsdrOFgbFr5rdj5ZWVmRqZNksRFyZIT+0iMXWvxMJiMDpqhomAycn5/H7OyszF7hjVCxEBqjt8aXr8NazopvtVrwer2CndMoAAdWuFgsolAoCOtlOBzKwtKia+XKwWE6tNUJRkY4bNq3vLyMVqslyazTJlSnpqYkX6Kr4fWhYwO6Xq8nGC3XhYO/jsKsuX6aagpAGE1Uxowqi8UiVldXJfLTOQvg0LgAh7NyNAuFYfI4sYC5Bn5/r9fDxsYG8vm83O9p5SjWEZUz76der+PRo0ewWq3IZDKn+j5GQfPz85iamhqJvNvtNu7fv487d+7g0aNHI87CUXDlUcJz0ev1sL+/j3q9/qVuFXzur2KgHUdYIMxW+ewTqCm23e7BpEd+vts9GMPb6XQwOzuLN954QzB/0nuZU1hfX5czFI/HYTKZUC6XJd8FHExkDQaDAnO5XC6h9fJa4zA74c1isYhqtQqbzSZlEExos+kqWzvpKIsTHlmHdFIHh7VHdER1bzkq60KhIN1AmJ8ql8u4efMmyuUyJicnAUD6iJFRR/3Ds0YDzjHxk5OTUv5RKpUkB6d1CKFAg+FgtDPzd+l0eqSzAOfHUI/XajXcvXtXGtIWCgUxKhoGI3X/uPJCxoUh4d7eniTc6FUwhPvWt76FdDqNVColVpOblnUnGqKhceFUw1wuh0qlgk6nI8pRKw4+ZKlUGjEunFan8XYeWlaZk0Uyzl6hoWFFrNVqxcWLFyXJyANyVN3CcYWt9Nm4bhwvBQ423Pnz51Gv17G2toZmsykdCYrFolBDx4X918xm88hIWHrv9KLoRbJFeSqVGlH82rhotpPGrbkGR0UCHGug13VzcxMApFPAy2CLjdMqNV7NxO3Dhw/lPk8jNC5XrlwR48LvoXH56U9/Ko1a+U6Z9xo3MuNC4wJARt7qZ9OR6GmNSz6fH8kJ0LjwnfLf6BRyCBxrw9577z1cu3ZN6iI8Ho/0yMtkMvjd736HUqmEhYUFRKNRdLtdJBKJkXfExphsxcSBYFR+7GWnPWsaaxoXwkNkpJISTEIAWatkt507dw6hUAiJRALPnj078fqxYl3nxrhW1GnlchkbGxvSVcNqtWJ/fx/5fB5TU1O4du2aIDKMBqibdJcLFkt6vV6Ew2G88sorCIVCqNVqqFQqI4WjPBNEK4xGI5aWlhCPx7GzsyMNP3Xk4/P5UCgUZMbL/fv3YTAYxMA7HA4EAgFxVpk/17WDXyfHNi70tscVDheWljCbzUrkwTBMK1GdZOfBIS7KTcQwWYfh2vvWyXmdcGdCjYugoSF9HeYOGEYzSmDrDhpD/q6m+p3U+2Z0pZOLz0vOA4cGmArgeR4Xr6kPJWGrbDYrRhYYVcS8B66VNpy8N82wGoc2SLYg9KnbrnAsssFgEGiETUNfpmhIU5M19D49zbWZrOaoh/H2+oxeaFTZlULPcHlROE5HpeP/ftpn4rungedYhm63i729vZEEPI2n2WwWJcNR18x3kT3IannCoaTEOhwOLC8vj6ARnc7B9FnmF1gcHYlEpJ0U9x5wUFfDsgcOLWOn9Wq1ir29vREWIx1Ivhs6xIR0WG92EtFV+ABkWiedN1Kl6byyxoTOH++ZTqzRaJTWT9w3AATODYVCwhCjTiSUyO/U+556oNFoyBwt1iVpOr5uqkrdRj3n8XikByD3A1EKpgiOK8f+JENCHjou8nA4lCRvsVjEzZs3pbW07pelldd47oAbjkrf6/UKxKXZKGxfzYSpps1yRny/3x8Z5anrNfTCzs3N4dKlS6hWq7h58yaKxaI0ptNJdyptfvdJNyajOD2qQHPNdc6FyUfir6yYPyoZTqOXz+cl1xAIBNBsNvHFF19gZmYGf/InfzKCs1NBMKqjR0bFzHdFlhSfXSu36elpvPnmm6hWq/jd736HXC4nGzEej+Odd96ROohKpYJ0Oo29vb1TK0gK9waAEcPH5zjt93Dfud1uXLx4ETdu3BBCh3aQyuWyKMtQKIRutyuU9tNETUc5HqcpQgUgNVQ8C4FAAK+++ira7TbW1taE4EI2Ew3GlStXMD09jWAwKB0JqMw3Nzdx584diapJT67X61heXsa/+Bf/As1mEz/5yU+ws7ODUqmEZDIJl8sl1/z2t7+NGzduCEuJCXEA2NzcxIMHD6SXFqOWRqOBjz/+GB999BEGg4H0w2PUomurisUiTKaDEc4zMzMnjp71+AaDwYBXX30Vf/3Xf43BYIC//du/xb1798Q5Bg56xJlMJkxPTyMcDqNWq2Fra0vgaZ5p7WhaLBZcuXIFi4uLmJubQygUEmPDnC/fAfcY4b9OpyOV+Q8ePEA6nR6ZM0PjwBoh6kId8bzyyitYXl7G/v4+bt26NaLzCKe+9JwLL6it3ThEQfouPTlCXs9judDwaDYUe2Kxhxi/j5aZobPOXeh75CHUEY6m8/E+dLvscWs8TgXW+YeTyvN4/loYwWkWFA3OVykq7WUAkMiEVMRxSuhRa6RhsfE11X+oWMkO0hg5FTLhCsIS9Io0zflliL4fem8vS5jHYt6P3WyBw/XjH7baGY/QT/I84xH+yxRteGmQdSQDHHYhoEPIZ2OO5agzxvvUNSS9Xk+qyBuNhpzpRqMhvcvoSBFiJyyjE/U88/oMEDLi53k/dDbGI1qePc4nOalxGc+fkYTBXEej0RBdM34maRjYnYQRPc8L37ee8cISDLJbx2FWfa6NRqNAWnQYGRWRHUZShKaRa0RI1xfRETnNPjy2cZmZmQFwqBBJN223D8Z5ciQqW4jwsNG4UMmPe7+zs7OoVCrSvmFxcREzMzN45ZVXMDExIZz3wWCATCaD3d1dbGxs4O7du8hkMgJjEfflZqIBZGQ1MTEhiT/maQCMHLT5+XksLy8jl8vh6dOnIxX/wGEDt5MIE2F80TSi/DeG72Rs8cUS5tLsMn34xhUqFYLT6cTk5CTi8bgUV5GBx07GZIPoqnBgtE3IUYy2wWCARCKB3/72t9IUFAAWFhawsLCAVquFW7duAThMXI4b9xeVcaU9nv/Rfx/1u0f9jAdMR2uU+fl5fOtb38L09LRUYfManU4HxWJRYBDdTmU4HI44B/z+50VZ+rqsNWA9xGkjlXEh0YK0VPbmGw6HqFQq8Hg8MriKcDFnixACIiWZa3fhwgU4nU5ks1l89tlnUqDHe89ms0Jl9fl8su5utxuhUEgUPme8sKUOrzE3Nwev14tCoYA7d+6g2+0iEAjA6XQiFArhgw8+EOXOM1KpVATOYw6OUN3+/v6J96Db7R5xLHZ3d/Ff/st/wXA4lLY9WhkTpmZhLdMIHB9iNBqxvLyMV155RdAHo9GIb3zjG7h48SICgYAUfzPxzoGIOhfH/DZhs1wuh4cPH2J7e1sQDfbF0ykHGhKe88FgICUmjUYDkUgEfr8f1WpVHEPSmY8jxzYurEjWUigU5GUCB1ghhcpIb0TNbDAajQgGg1hcXEQul5ORuZFIBIuLi5icnITP55PCLB6ARCKBvb097OzsSDKRXpZOeOqENDc2XzQ9Jq2o+N0XL16ExWLB6urql0LW0ySjeW9cD75s4LB1BGmtrKalQtJ9xoCj+7BRaCTYGsPn84ky4Xow8clO0YQAxwukeIgYkeg1JVWSytRoNCIcDuP8+fPY2dnB3bt3R2oLdNL9JKLvS7+3cRm/vl6r8Z/phOj4z8PhMF5//XXE43GpbNYeI1ldGt7QBWvj98C9ozFybVzoRPC9n6Z77/OERo+wsiar8PsDgQBmZ2dRq9UkT0LyDPMVmowSj8cRDofF6SOUzPwB2Wgm00FhNBUZo0EmxpmboKNDZRYKhRCNRvH06VNsb2+jVqvh3LlziEQicLvdwupkP8FEIiFoBKc28n7G5xK9qDDC4DoWCgWk02kAowxLvk+uE/NGJB0x8rJarVhcXMQ777wjDNvhcIiLFy9iaWlJ2GG9Xk8IC+zpR8e92+3i2bNnSCaTEvFw7MHu7q442jpfw3enI0A6jrVaDZlMBgaDQdIMmjb9Imy7F2r/wiQVh0sxpGPbZ+DQSxsPqzqdDnw+n3i6LLRcX18XJWW32zE5OYmlpSWEw2GhFDL/UigUsLa2hr29PTkgLJaiciQF0Gq1SqsaMjL4shmCM1HIzVGv15FKpaSvz/gI0NOEiBpa016HwWCQA6b7DelnZ4U7DYyG+4i/8jBrBUhYjAqBn9czG8adAN7ruAHTkBs3ph4WB0B6QFFhMVKs1+soFotf6pf1IjKeU/m6d8H71gSGo+qE9Lsd/z4N+wyHQ8Gz8/k8Hj9+jGw2i1QqNXJ/wGGEq2FQvmsaaa4fDzThHzIluaaa3fiyEvqMxtgok1MTyYikU3Dp0iWBSorFokx+ZWGj1WpFLpcTSjsVmX5Gvismmlm3xSpyg+Fg5g8H0IXDYfm5hmwHg4EUVjLBzVytZlrpOjwSSCYmJqQIkE1uTyLcP2zRVK/Xkcvl5N2OR6L8N0bHrLnRaQUOVTMYDFKRz5wzDQH1gIY0iXywtGBlZQUejwepVAq9Xg8LCwuIxWLY3t4Wxh4d8fn5eczMzCCRSGBjY2PEQadx5z5giYnL5cLu7i7W19dfvnHhwnHwjdVqlQTPhQsXpAtqJpMRGIrdkrmhTKaDsZ9Pnz5FsVhEJpORik+r1QqPx4Nz587hzTffhNVqldb8NFSJRAKff/65YImMVjQ9zuFwYGFhAYFAAE+fPpWeOalUSl4Sw/NCoSCzZMxmMwqFAp49e4ZWqyUcct0S5TQwhcaqWTnMiIAJO6PRKMwRbkL2HmI3WN0mnmumw1puWkIr9DaZzNctPDTlU9PDj8qzkG2iu0VruK7f76NYLGJjY0Mw9cFggN3d3ZHWEScVHT1qhstXrTffKw/OOEPveffEZyZjkMYlmUyKB/2zn/0M+XweW1tbX8pRcV0ZHfO9k7DCP6yVYCKbtFCdQ+L9j3e2PYnQoL322mt4++23cf/+fRllzPdKL9/v9+O1116D1WrFvXv3pK9Xq9VCIBBALBaD3+9HMpnEnTt35PeYcwAOCQR0StkpgUaM5/jhw4coFAqYmZnBpUuXRqAbKrlutys1X1S8rVZLSCL0wJkbymazyGQyMJlMuH79OmZnZ7G+vi6dN04ijMDC4TAmJiaQTqel6wTPkX7XOmLl79Og9vt9cYAZdczNzYlx5LPyGmxuyb1pt9sRDAZRr9eRSCRw69YtIVYFAgF8+OGHiEQi+Kd/+iepW2m1WrBYLLh8+TK+8Y1v4O7duwLnBgIB9PuHLaPInHW73fjOd76D5eVl/PrXv/79tNzXClEPSSKFjpgpF0UrFB4WYqnjVFwyvdjihV4R8zVUDOy5Q+IAZTwMJWd+nO7Mv593SLmghIIYRnIxT8MAGo98OD5AH0YWh7HpHg0aw3DitOPT5YBDpcuGdsSkedioPJjYY+823UKCh0NHMOPfoxOPXq9XFCOjJz05kAZoOBwKNPCyktTHvQ733XGFa0GmGOsRgAOIJ5lMIp1OI5/Po1QqHVl78rx7473QINMpGN+jei+/yLN+ndDjHw6HI04T3zmNGHMWjGh4ZnQ0zHoL9p+iDuBZGQ6HYlCYxNd5Tg0TcnKj1+sVhqnut0dyD1mQrVYL6XRaauLoNDKa0WdN16/1+33xzE8iPGM0ACyfMJlM4iAyN3LUvtNrzVqZwWCAYrEoEJXudKwdFCIWpL4zqmDOj3qyVqvBarXK6AO+E+pIAEIfZ06N0Pj4+lH38JlI3jlueuDYxoXVvawW5UFrt9tYXV2FxWLB3NwcLl68iEqlggcPHqBer4uCI4OByVAOr2JTt+vXryMYDGJ+fl4Sz2Rz8RAnk0lpaQ4cQgbD4VAUGcNsFhRyI+vq9VarJbPlufCsCymXy/B4PJicnBRPT2O6J/UedZKXtMh3330XRqNRIJaZmRksLCwgn8/j008/lbxIq9WS+TmkD7OOR9PBbTYb3n33XVy7dk3o2263G3Nzc2JkWLB66dIlBINBpFIppNNpeVbgUMEynwAcKjhGKaSx1mo13Lp1S2DORqMBj8cjHWEvXLiAcDiMzz77DB999NGXkt0vKl8XbejP8e8XYb3wkMViMVy7dg3hcBhutxuDwQCrq6v48Y9/jEKhIJ78uHFhxHPUd1LhMiql4h5nA9KBAyAMoJdhYFgEmk6n8bvf/Q7JZFLqQlwul1ST37lzB8FgUBhzpCTrCu2VlRVks1msr69jf39fSA3aaCaTSezs7Ix0H2BdFSMQtmRKpVJotVrw+/3odA7Gl9dqNVy/fh1XrlyBx+PBO++8g2q1iv/23/4bbt++jUajgUqlIuODA4GAUG8ZAfZ6PTx48ACrq6vw+XzSXuYkQgO2vLwsnv+DBw9gtVrx1ltvYWpqCvfv38cXX3whxlHvS+5d1v/E43EUi0V89tlnuHDhAj788ENMTU0J7Ehnrd/vSypid3dXcjMGg0F0weTkJCqVisDQ//f//l/YbLaRkhCmLn72s5/hN7/5jTjrDocDi4uLcDqd4rjTsLBU48mTJ9Iv8Li1Lsc2LuTAszpXF9jQe5ienpaWA9VqFeVyWZrS0eJqb40bjMqIhVRUdBp2Ya6Hiw2MJtg1I4cHQDfq42c1hZQ/44snE0NDP3oo0mlkHDphW33CN91uFw6HAxMTEwI/8d+5IVn1S0ohn4fwCfNNs7OzEhHRUOtBRmzt3mw2hUHCNdAejobF+Aw8MJokQUyZRAnmidxuNyYnJzE1NYX19fUTH+rnraNez6/7/HGUM9edRpnNEnmYSCgpl8virT/vO5/3fcfp8qD38otGXl8lNFjc56VSaSQfZ7FYpJsFAGlkqvvdEYomHKR7qpGYQrotixp5fmkodcEv62IIk9GZ2t/fR7FYxNzcnEQcPp9PmmVub2+LEiQbkcpTFwUzMqIDOjU1dWJiDh0C9jsk+YL5komJCYFJ9Tsbp/gbjUZp60KyRL1el4S/Pt801jTKjAbJCiWrzm63Cyuu3++PGFfCdNxTyWRSoh1+D1MTmhGrne5KpSK/c1w5tnFhbiKbzaLRaEiimEqGLzidTqNWq0lLaCYtCcOQpcLeNW63GzMzM7h+/Tqi0aj00GGDQOYLNJWT0Qg3J+G68aIk3psOkzXzbG1tTWAd/fJrtRq2t7clp0Ge+WlkHL4qlUq4ffs2gMMeTrVaDdlsFtVqVWAC3jcVnsFgwOLiokB4pVIJNpsN8XgcDocDiUQCv/zlL+V73W43Xn/9dUSjUcTjccRiMRSLRaytraFQKODcuXOYn59HqVRCKpVCo9EQL5ObnJuMhsdgMCCXy+GLL74QiETne2q1mrS8YI+4jY0N2Q8vQ7QC1mG/jhgI07IeZ7x9jq6z6vcPKuz/4A/+AFevXsW1a9cQCARG8gY+nw8zMzOw2WzIZDIv1ArjRUQzz152XRBw2IMKgFB/yRYCDiDbwWAgZz0cDiMej0u3iFqtJuN3yXDj4D7e/3A4RCwWw4ULF9DpdPDw4UNpNUT6ezgcls4NjHqY3CY5gFBcqVTCw4cPUavV4PV68eabb8r7o64gRMcCTz2ddTg8aDS5ubl5YuNSrVZhMpnwySefYH9/H6lUSqLOhw8fYn9/H/v7+yMkDJPJhIWFBUxMTCCbzWJtbQ3dbld67k1MTODP/uzPEA6HUS6Xsbu7i9nZWXH6OBKBdUH8m8/EYtFUKiVwmU4HEG4DIB0X5ufn4fP5pDkl75dOLztRkAijUxrPY0QeJS9sXNg0kkqShVLsAUaqL0d7cqCUw+FAOBwWTjsTWoTTLl++jFgsJriwPvjjkQeNBD12ndNhMnswGMjsA25QHiIaF3Y51XkhDV1YLBYsLi6O5JhOk3PRyfNKpYL79+/Lz0lZzOfzaDabgvlTEbBTtK4XYNdTq9UqzfmSySRWVlbk93w+H6xWK2ZmZgTWrFQqePbsGcrlMr75zW/i/Pnz2Nvbw9raGvL5vCRaCRFpaIybkHUe43k14KAGigSK/f19URJ8Xy9D6G0Do92heX+M6FwulzzzeNM97l/tjHzzm9/E97//fZn4R6U7GAwkEtMFe78PGQwGcojHo8fTCJUFzwMAcfi4X/iOBoOB1IQRruUE2lqthvX1dZTLZSwvL+Py5cswm82SJ6RTGA6HceXKFamVIbmn0WjAZrMhGAzCZDKhVCoJ6+zx48dwOp1YXl5GMBiUyCmTyeDzzz9Hs9mE1+uVjgkcGsgGszR+jFS4f2lcWJN1EiF6cevWLXz++edCyDEYDFhdXRVdpY2L0WjEwsICXn31VTx9+hRbW1syEj6ZTOL8+fP4zne+A4PhgL3aaDQQCoUQiURGGJmaTEM0g7qLcJgm9tApYSmAhjSnp6exuLgo5526XOcaCZeO5wlfpL/dsU+6phqPM4iYHOQh5BQ2k8kkIfJgMEChUIDReFDVqueQ+3w+8cR9Pt8IfZSUReY8KDrZOZ4X4AsntERmFK+no4ijYAeHwyFzO7ipdJ3KSUTPvx5Xxrxmo9GQrq76WehJMvE5PT0tUCObzNF7o3epBzj5/X45yNzAfGZGbiaTSQ4zFeo4pKSjAj3ylnBFPp8XRhA3OBOUrL05qZLkRD1CAc+Dixjp6sFyzxtVzb2j3wPXTc/u4d/VahWJRAKFQuFLePrLFG2E9f2dVuhgMSrQkIjL5YLJZBJYimths9lQqVSwu7srRXyERywWC9rtttCQWdwXjUalRxVxfQ5SYz6KjpaGjHTC2+VyjbAoeYaJ+dNBYw6WeVndwolkEt0K6jSiRwbrs6CJGDp3yZwSR2BnMhl5n1TW/B3dkoUGkWvERL4e2kVCULfblamcw+FQiFVcN6IPuvKeOpc9CFutlhR6kjDR6/Xg8XhgNBol75hKpcRxP44c27jQWyaGR/yPcA4ASbBNTU3hww8/RCgUwubmJpLJJLLZLJ48eQKz2Yxr164hFAphdnZWBt+Q+TE3NzeSWNZWnu3hNc7Pe9HUU4/H86UGbzRWDCnHIRF9gEOhEN555x2YTCbcvXsXu7u7I99xEiE5gZAi8OXxvNlsdiTZSy47WShra2vw+/148803sbS0hImJCczMzEi4SsZOoVBAOBzG1NQU4vE4Lly4gIWFBYG8dJt99v2y2+04d+7clzpKa+YccAhLstg1EAjgzTffhMfjwaeffir0RhZiMW/Bw3FSmZiYwGAwEAPGMF2vIw87x1pbrVakUimkUqkjiQBa4XDNSVXX8B3f+97eHj799FNxmDRs8HWi2VFfJ7p7g55FclphK30iBrwfs9ks3TC2t7dl/hKV1vb2Np4+fSoKkFEBk/2sa2KO7/r163jttdeQy+WwtbUl8Isef6D3OHBYQ0LveWJiApOTk1L7QY+aMI/ZbMbe3h4++eQTeR98n3Rq2AiTCpPXP6kwx8iIiF1KqOy5fzj/hONCdnZ28ODBg5G29zr3xrKOQCAgeRcy9RiplEolicr6/T48Hg9ee+01DIdDPHnyBHt7eyiVSjJkjMZDv2PS32dmZjA7Oysj1AnD8l0w4p+dnYXb7cbVq1cRj8fx2WefSRPQ48ixjYv2HKmcxz0gJpn477q1Bn9Gw8BFpMekPZfxqITJQlpzLhj/1gaHG5Y0Zi4Wvf+jhkeNbzgelHGFoHsnvagclSQfjwwYdtJ7YQKen2fdBT0ah8MBv98vnoauydDfyVwUN7c2GHxO/j+NMsNxKlGG+loJ6N/RnVt5vzyILH47bY6Ca3Ec9peOfr9KOVNRejwe6eWkc3xaxlvUn0RRHTfaeRnkh3Hh3iGer/efjib0GdP0Vyp1AOK4NZvNL812Yqt4dv4lU4l95rh+GsLRuVV+h/bwdb0LvXk6s0f1rBvXI4w0T+MgkhDBZx8MBnA6nSN6iYaCz8Fogs1hgS93p+a6c/00okKHmB0h6GzoFjt8jzr/pBEDjbpoPakRKEar+n3xv0kH53MfV479ybfffhvAIZ2O+KVmf5FiWK1W8fHHH8PhcCCZTEp3Us4miUajiEQiEvba7Xb4/f6Ran9tlPjHaDwoQuNiM8Q3GA6q3DV7CYB4PMxTcFFNJhP29vakIEhzypnI/N3vfiewWiwWG3lJJxFGdwz5xyEZRl2EI9hlgHg08yUulwtbW1uo1+vw+XyIxWIyophMrVAoBIPBgP39fVQqFXz00UeS0OcQJ9KaL168iLm5OWnBUy6XMTc3B6fTiZ2dHezt7cmkPaPxsEV4tVrFysqKeLYWi0VG3jI0p/fm8/lQrVYlgjiJ0OslW47vXgsVR6/XQyaTgdFo/FKeRSsYHvbZ2Vn85V/+Jaanp3H9+vWR2h/ua10XoqOVrzMUWsEdV8j24X+/LFiM3nAkEsHc3BySySQymYwYXzKOuL7Ml7H+gk6bxWJBOByG3W7HxsaGwN3AgYJj7zqTySRdl+PxOEqlEh4/fozHjx+j3+9je3sbAGQWjtvtRjweh8Viwfr6OnZ2dtDtdmE2m5FIJHDv3j3U63U534VCQZqkssVQsViUhD7XkJD9afvbLS0tATg0ipx50ul08ODBA2QyGcRiMSwvL6NareLx48eSowJGozWt+2goNOxH1Ia1RLdv30Ymk5FIPJFIYHd3F8PhEPfu3UM2m4XH48GVK1fkvNpsNqysrAhTs1qtyihoj8eDWq0m+pAOqIaS9/f3hdDi9/vl9146LDY3Nwfg0Atg7Ue73RYqHReFrbgNBoO03/Z6vdKnye12w+12j/TZYQhOr0rz5XUbCBZoMkLig9L7BA6nTdLz5/VZ+Gez2dBsNrGxsTHCPKMyYfhpsVgwPz8vo2C1t/eiQq+d+RGd/xnPvVAp22w2GYjGpqAWi0WGOBE/pQdD9g7zMcTPV1dXBaaKRCIwmUyyVrFYDFNTUyMFqjT07MNECITMHipbVhvv7e2J4edh4fPoyIUFqicRfhcVBHB0FMDoipNHjwrhxw2M3+/HN77xDSwsLEijQK2A6NyMEz9eRMYJB1/1+0dBeC9D+F5I/Sdrk7kS7m+z+WCIFfNnrBjXVHaSeNj81Gg0ikfNhpihUAhTU1Pi4bOXGVmaNCqMptkPbzgcSoJ6cnISMzMzyOVyMr5Bs96okDkUj06nbok0nlc7qXEJh8MADnuVhUIhnD9/Hs1mE1tbW6Lgp6amZAQ7nxE4jPY1RMX8Cp1cjZiwzqRYLGJvb0/o2WTd7e/vSz1RrVYTOrTL5RIjvbOzI/lGOrS68JXrMc641P3nLBaLDGGz2+0v37jQy+AhazQawgxjqDYYDITaqBPn403T9O9w0ekV6aQVPTi2iRlvaQ1AoAzW09DqAqPMMnYNzefzkuRbWFgQ5QkAiURiJB9Ba69hvpMKveFYLIZgMCjJyOFwKDRu3Rhub28PVqtVmC+sLWCB59TUlLR+MRgMgteynsDlcol3STydc7LJIOOh16QLrjsNtIbkaPB1gZhmx+hkJMN5NtzTycyTilbsz7sO/10b3OddQ0MDhHd4yCnd7sHY30qlIu+CYjKZMDExAZ/Ph2KxKJHZuPLSv/M8KHb8c78PIZWd0UqhUBDGEyM01l/0ej1xBugM6Rn3bNo4zjYiBE14kaQTdujlOdYweSwWk35/HFdMyHUwGEhdkc5XAocEDIPBINGy0WgUiHN+fh5Go1HKIwixnXSdOVWV+4eKnwxaQrCs+9FwlUZXCOuxLoXC86fTDizcnpubQzAYxO7uLiwWi9D9O50OHA4HpqenYTabsbu7O1JUylpB5vFY5kFDxshEd1cYd6JYY6O7aB9Hjm1cnjx5AuCwQIk1GRqDZ7tuUgO5cMTw+Yc1B/w5FTw9Y24Ug8GAUqmEvb096YHEQkJa2UgkIpCN0WgUr5obicqSii2bzaJWq2FhYQGXL1+GzWYTLPXWrVtCT+YCFgoFDIdDOXQnNTBkL83MzGB+fh67u7uijJh7YqNNNnrU+Dg9PQBYXFzE9evXpQALAKLRKLxerzB6vF4votGotJRxOByYmZnBzMwMhsMhZmZmRvJZGvJhZMg1IAzKUJ1KQWO4POhWq1XWvdPpYGNjQxT4y/DGdW5ufJMfN6LQSXx6bePGhdfqdrtCJuH6U8xmM5aWlnDu3Dk8ffoU2WxWImF9r8+Tcfx/nFLNa7ws8fv96PcPWsU/fPhQokqTySQ1Ei6XCwsLC+h2u+I88sz7fD5cvnwZrVYLP/vZz6T6nt42n4e1EszJlEolPHr0CPv7+9je3hbKMtsEzc3NYXZ2Fjs7O3j48KGcE5fLhV6vh1wuJ1MVWRwIQDp80MMmZBoIBDA9PY3XXnsNZrMZW1tbMgyQ5/sk8vjxYwCHbXSocOmoELXhGaSjQUXOqGYwOOi5R3YWhbqKOoZkqeFwiEuXLsFsNuPRo0cwGAzY3d2V6OjcuXOIxWJIJBJYW1tDJBLBt771LcRiMckJseM1676YS2FEyuhK71miRszHcDDeS49ciBtqhc2+W5qloZv9aQVkMBjkZ/SW2u02crkc2u22wGTcyM1mE5VKBfl8Hvl8XuoUdCNMvhBGQHxoVrMTJ6cC0Xz+VqslTS11Qo3tJxqNhkQV9KLovZ9EaIQJP1GR8Z7HlaaGT7Q3yLqdarUqhwUYbeVPOi3rYnTiUBtHbXhbrRYymYzUChAq4fOPF8jx/sxms+DxrGcZDg871zIJzK64p1WWx4GlNOR1FHGCoteLfzTkxt/Rjsr4vTCpPN6K/LiJ+6NgvaP+/WWIpsH2+4f9pBjdA6Mzbpi05nsGDvIjGl1gRwPet07G83pcY+Yw9R4HDnJBjUZD6rFIVuG+ITRMJ5T5Cp4X7SzwuwkpmUymkYiHEO1JhLpCoyf8w3XT98Dv0fRpDdnr/ApwSBXnumqFzzb7xWIRhUJBEBUd7bDDRygUkqhPr4vOXZMwNJ5/1DU6fPeaSEFi13Hk2MYlmUzKl7NWZWFhAQCkkrfT6SCVSo1sNLIMBoOBJJ1dLhei0ShSqRTu3bsHv9+PS5cuSd2Lw+HAo0eP8NFHH0ltAVu/0NLzPogd0mCwIj0QCIi30mw2ZfYLFzyVSklCMBaLSVLwjTfeQCaTwaNHjzAcDrG4uIhIJIL9/X1sbm6e2PtmzmBjYwPpdHrkWdgQTne+1YwSg8GAiYkJLC8vSxU+PWnO2Zifn5d8SyQSgc/nQzAYFMNK2jjXTtfdGI1GpFIp/OQnP5FcDpVEPB6XCmluMnrn3Afnz5+Hy+USyrhe0+npafh8Pqyvr+PRo0cnzrnoQzvO1jpKQZPtMg718efawyZWPTExIVGsFkZyhAk1VPjkyRPpM3bcZ9OO0fgzjhtEfv5lGBs6iDT+rIGiczG+Prpeg13Kf/GLX4hHTeJJNBqV9vd8T51ORwzPYDCQXn3MF2hHZ2trC8lkEm+++Sb++q//Gq1WC5988gmy2SySySSePHkidFqPx4MPP/wQS0tLuHfvHn7zm9+MtEQicsGKdQAydycSiWBycnIE9nwRIXlI5/44YXJ8zWj0BoMBPB6PjBvhiAYyPUlgGgwG2Nvbg8FgkDlWzWYTZrMZtVpNOkffv38f9+/fF4KR0WiUFMXCwgL+9E//VBwlnln2XGTjWNbIEIrkvqNRJ5RGaI/GmfO3jrt+L1ShDxzS8IghAhAryAPHxdcJLCp/JpHolbByl3Ox+UJyuRzW1tbEy+fvk/HCGS+Mkuj90KCxx5ke80ulxPC1Wq0KzY6taAgtERrxeDwIBoNinE6qHLkxCQfSg9EKkPfGvzVkYrFYpLCTbJhKpSIDvzQWrVlx9Dz4/KQ682Dz32u1mrSzYK6GkYfuYwQcUifpfRGeYBEnf4/FqOFwGOl0+sSJVC1a8T7verw/fQi0p8x10VRq5gTHaaA8xMSk9XeSpPAi0/m+bg3Gf87/fxkGRu/do4oS+V26hRIAgU9Y16ELIVkMzc7DXFeNXGgqMqmy3O8Gg0EcLbPZjIWFBdTrddy7d09+ls/nYbFYpOtHOBzG9PQ0tra2RqIwbfiZR6Ry7PV6koM4qXHRwu8av5ZGSfj/XL9arSY1QUzom81mcXxoDHlNwvvdbhe5XA6pVEoYfjQEjFCYbGfkx4aVjFT4Xo+KwPmdek9ovcHfI+HipRsXbVBYK8Kpb5w2F41GMTU1hXq9ju3tbUku04NhOLu6uopEIiG8bbaYt1gsiEaj8Pl8WFtbQy6X+1KCn5tWY5w0fMRB7927N+KBsvJ9MBgIfVdP4SMMt7e3Jz2jmCDnPTOHcVLjoiMFbhom7liNHAqFJIxnx2lCiYzytDEiTNbv93H//n0hWrTbbUkeut1uLC4uwu124/PPP8dvf/tbuFwuTE9Pw2QyIZFISN8mUpkvXryIYDCI/f19ZDIZCdcNBoOMRCCJwmg0Ctkjn89L/iKfz4sjQObbaUQfiK9T0IPBYGQWO3A4WtdsNguhgVBdLpfDo0ePUC6Xcf78eUxMTCCTyWBjYwPFYhGffPIJUqkUnjx5MpLv4/s86vu/zhgcxVqiUdMe8MukIlN58TyyYHQwGEjboWKxKFRhtgBZXFzElStXkM1m4ff70Wg0ZCokxe/3Y2lpSfbPxMQEAAjEnMvlkMlk4HQ6JW/Dxphci3K5jN/+9rdoNptYWVlBJpMR+EcTNX77299ibW0Nu7u70l2ChouOLZU1HSqyWtfW1k5sXPS4azqHGi6yWq0oFAojwxTD4TAuXryIc+fOoVwuI5lMChLhcrlQKpXwP/7H/xhxxKemphAKhaRnWK1Ww+rqqqQGOG769ddfh9Vqxe3bt7G1tYXd3V1p/bSysoJSqSSMMrbfslqtePTokSAonHw7PT0tjitRFkZlXH8yVo9b6/LCxoVQAqewaYjC7/fjwoULUplLTrrBYEAoFJIb29raEkvIQ57P5zEYDBCPx4VTTSbGUcINyY3D6IML2+8ftIVnu39SGCcnJ2UUqIZM+v2+tJAgtMRoxul0wuv1ykzukwhfFPNAGnd2OBxCGAiFQsLV19Fer3fQWZaJc5PJJJuwXC5jZWVlJCrSnX35udu3b+PTTz+F3+/HtWvXYLFYsLGxMXKIvV4v5ufnMTk5iXq9jp2dHblfg8EgUQrrVxqNBlZWVoT6Cxzmweg10bicJnLRGP7XEQR4+IFRCMzpdApk53Q6pQarVCphY2MD9XpdRu9ubm7i448/RiaTwW9+8xtpMzIeYep70/9/nJyQPqSE++hwjBcSvgwDw/6ALHQke2gwGAgiUS6XBbrh3uSIhmg0CofDIXRYXUPk8/lw48YNaTXESIewNH/H6XQKW5IlDcw7VKtVfPHFF0LtZScGHUm2223cvXtX9kC/35ccK5/H5XKhXq8LZZ9n/aj+ci8iHPXOCbZkhtFBNJvN0iqHjqnL5cLi4iKuXbuGQqEgET5bOH388cf49a9/PeL0LC0tIRaLIZ1OY21tDc1mE+l0Gs1mE+FwGOFwGOfOncMf//Efw2az4dmzZ/jiiy+QTCaxsbGBVquFW7duCfMOgIw2MRgO+qBpViwdZ8LX2WxWEAlGZ4PBQHTKcUlNLzTmWMMNpLTxhdPT2dvbG0mUU8bpyYRQmAvgwSXMM97Blr/DiGU8EU/Gg4ZMuPlYOMZQjy0bfD6fKG3d58dms0mnZ3pYegTxSWSc4cT52FQi5XJZoD6G1lQ2fBZiy1SSZDJxo+t3RQphvV6Xg1qr1aQtBGmow+EQTqdTmHudTgd7e3vibfK96HYhulKd717j0Po+yNHnAX8ZCX19ff7b866rPV6uEcdsc91qtRqePXuGQqGATqeDra0tpNNpieoIiWmoQ8vzohi+S+4pABKJc29qzHucRKCv+TIS/Tp5y/wEFRAhJ/aYcrvdOH/+vES/pVIJ6XRa2sMwj0HnYTAYYGVlRSKXyclJ8bzZloTYPfMELEegExIOhzE5OYlmsznSKkZDbIS5WLDNOUZ671GfsG6L60wo6qROjo7UeFYJAweDQYRCIYk0dF6OdWCs1OfvsT0Rh47R8O/v748MWuPoAr3/+v0+KpWK5LMJQ7NYnHtqamoKk5OTkmel3tQkBBIFSDYCRqN/Ojv1el2e5ThybOOiaxloZcl5J8son8/j1q1b4nHrl0hcnweNYTA3ETc9IS4NgVHIgiKMNRwOxcjpGhHgsANsu92G1+vF7OwsDAYD1tbWsL+/j3g8joWFBVEm3KwWiwV+vx/T09OCXSaTSYHvTirjbKtoNIr3338fw+EQt27dws7OjoxoZn3A+MRJttzmALbd3V08efJkxAvmxtKJuF//+tdSkzE/P496vY7NzU30+33E43FMTU1hOBwinU6jWq3ik08+EWNN48zDRHIAozwqdt0HTRt13VvuZXjg4+wcril/9rzfoRPBvJfBYBAllEql8POf/1wStFRaXq9XigkZvemcjDYMOpLSDhTZdIRUWJugC+d4HnSifzxi17mXkwrPMB3EarWK/f192Gw2XLt2DdFoFI8fP0Ymk0E0GsW/+Tf/BlNTU0in09jY2MD6+jp++9vfjsxVMpvNiMViyOfz+Id/+Ad0u138xV/8hUCuT548ke+hx8+pkHpNDQYDLl68iNdff11GPqfTaQCjUWKn08Hm5ibK5bJ0ribEx8Q4FTNziNyLPNcnFXb6jkQiCIVCYrw4/Gt2dlYq9YFDKu/NmzelY4nf7weAEceGUT/RlUQiIXlpnVPhPmc6YHd3V/LZHo8HoVAIk5OTKJfLkj9855138Gd/9mdIpVK4devWSDcFOqrD4VAKyrm/WItoNBolV8UuHsc9wy8cuej/13UOTNKRNcNNQy9bU+v4ebKPmPTigefvf9VDHOUF6/vTHtr4vWsDBBz23tLUQH4/m96Nj01+UdEsEhpNrTAMBoPABPq7tLdJw65rc+j1ECrT66dpivSWeF1NH9fPRaPE9dHU3HHvWkOiOkGur8cBUmzjcdL1G/fcxyMYPu9R19dKGzg0Rlwn7RXy/bDdvl6/8evrd/l19z3+30ddgwpFRy6nMSbPE01b1x2gx/OJfK9EGOr1ukQcursE157kB/bBIn7PruKsmdHTDumYUH/QS7dardIqnkaYe1zvSRpwQux0AhkdAhBF+yJ9sY4SRlj6LFJnAId96uiU8N4JbZOpBUCmcvJZ9XnlfuRngUOnkffRbDYFfdC9w3QEx7VlPopCHcJUB79T60DgkHrNNWYt2Es3LuSy86aq1SoePHggDzEcHrZ75gawWCx4//33ceXKFWxsbOB3v/sdWq2W0AaJf1qtVmkJz2Ip/QD0uFixr6ECVsOytQs9/MHgYP4Gq41XV1fl5XMaHb1IeuHhcBherxfAwawUwnSMiE6abwGAhYUFDIdDFItFab/wm9/8Rg744uIiOp2OzKxguE0hjMZ8kNfrlYQ6ewmZzWbpLq0TsoTCGo0Gnjx5Ip83GAwCdxA7JnRI52Dc2PL9E7dnRMpDwkaaTNYytCYt+aTJVG54DU8R7qDSofIa/z3Wa1B56kPF/3c6nbKfqEzT6bTUBHD9GDFTjoKw9M/ooOzv7wOAGG79GTIofT6fTAjl+mkFflrhepG9NTc3h+XlZfT7fXzxxRcjubNcLocf/OAHkltzuVyCPNAYDQaDEajktddeE8jr5s2bqFQqEj0QyiKlmFEjcNCOxuVyYX9/H//9v/93WK1WxONxTExMYH19HZubmwgEArhw4YKwpPheeX7i8TicTifW19eRTCaFAmwymWQEQD6fP1U5AYXnQtd8PH36FOvr65icnMQf/uEfolAo4JNPPpEIy+VyCXGJZ4tD/theijA0iU69Xg/1eh1WqxVTU1NwOp2S00mn09jZ2YHRaJRpoPwdnhEWzN66dQulUklIG7FYTHK72WwWAEaabdJgMf/HEhHmpV+6cdE4Hit6Wb1OhaM9WXoa8/PzeOONN9DtdvGLX/xCkvxkafHaevaB9k51BMIIg98BHBZ1kkoKHBYHEmMtl8tCGJicnITX60Wz2RTcWBdmsh0Ka3L0/IqjGD7HFfZMIg+/3W4jn8/DarVieXkZgUAAyWQSe3t7I5CJ9r5oUJh05iFnLzKr1SpJUK4BsVaHwyFFl4FAADMzM7BYLMhkMtISZxzmGf//4XA4EiVRoTM/xoOui/XI9CMkcFLjoqnT3BsaHiOl86jf4+/qnNl45EjvlgqPBWf08mw223NnwnyVEHf/Ko+PERF74FFhvIwc1fj3cL3o0F29ehXNZhOffPIJ9vb2ABysR71ex4MHD2CxWHDhwgVMTU1JjoVRBpGGSqUCj8eD2dlZWCwW7O/vS96ORBHCOvpM810SnqlWq9je3hZGJwuGeU6YW2Xpg4bq2bMQgBhB9rqLRqMIBALSruWkjE8KzwV77rGLQKvVwsTEBC5cuIBEIoGbN29KnQlHGvOssS2/1+uVPm+tVgutVkvgcEYU/Jzf70etVhPnMZFIAMCI/h1HJMgYY9TZ6/WkRyGjROrq8chQE4ion19EXngSJR9Yh3pUOqyGZ1Ef+e937tzB1taWhKraCHGjc4YGezhp/E8rAgBCqzObzSiVSnJw6XVxA49PVdORCJUHQ0HeP+m0+tmMxoN+RX6//8TGJZVKyT0yd6LHvLKXk+7xpSGXVquFbDYLq9UqnPZ8Pi9cd66tzWZDOByWyvHhcDjCbGE0USwWxYPUhpsGlkaJXRi4HoQJabyMRiOi0agcdLb90bCJJgGcVEg+4L1SaLAZqfG9B4NBcVZYP0VFrQ8gDSf39zhpg1AvKeHa4AOjjSjHPeJxEouWoyAwRvIkSegIncr1NMLeYoS6ksmkFEVyoqnD4ZCWMHrsQ7VahdFoxPT0tLzPXq8Hv98Pi8WCZrOJhw8fyr5g5LC4uIhGo4EvvvhCeuOxpo1wDptTMm8KHLRdyuVyKJfLUvrAPWu326XV1Pz8PIbDoTBQm80mJiYmpKOwLnMwGo0IhUKnilyGw6GcK7fbjVgsJgaw1Wphf38ft2/fhtFoxPvvv49eryfMV11xrwum2eaGZ5ROAHAI3TOv7XQ6cePGDdRqNXFEY7GYtKa6c+eOdNkAIJRs5sl43w6HA5FIRD7DrhzsyMFSA0a5/X4foVBI5nodR16o/YvGX6mkeHM8YABkxnUgEBA4jEpHF2gx2rDb7SNJIyo0TSfVf7Mq3GKxYHNzU1rIlEolgWB4bVbGUgFz2A1DaoanTJLpQjCNgwcCAczNzZ3Y82YtCJ/B4/EgHo8DgBQ8Maqh6OfmnHEA2N3dleekB8TcC2EMtsYnq4SwIjHgXC4n4a/Of7G7NN8LGXOkhbOmiYaDdTSs0Gebdh1pEDLVMy1eVKiIx5U/jYteL4fDgbm5OTgcDqyurn6pJ9h4hM0k8FFGgNCPjqDH8yQ0eEcZl+cpMhpvDeMyuathMEaOdrtdRkqcVKgYmJvb2trC7du3xcFi/ylCplTIpBJ7vV6cO3dOmE86B5HP53H37l00m01MTk4KBf7tt99GuVzG/fv3UalUpABS98Wbn5/HlStXBHLL5/P40Y9+JHuJ+cVcLicQptvtxrlz53D16lXkcjn8r//1v5BIJHDhwgXMzc1Jdf9wOJThZ3SETip8L+z8MTs7i3A4jMFggGfPnqHVauHZs2fI5/M4f/48/v2///cIh8P4wQ9+gF/96lcjZ1szsXTBN8kOjBKoV1mE/Oabb+KNN96QLh+tVgtLS0uYnZ3FxsYGfvvb347oERZbM1/C7yT5JhaLoVwu48GDBzKXh3mjWCwGk8kkCE88HpcizePIC8U5Gv/V0NV4klUnvJjoG08aH+X9Hfem+VkN1envP+qz+hnGk9j83FHPooWK5CQyXh8xfl9aEVFxjSeLx39Oz3tc4Rz1b0e9s6+CXDTt+6j143/zmcZhq6O48C8T4jlK9HqN743j/O5xr30UceRF5XnJ/ecZoxc5H1/3nTrSomHT75vnV1ft63fNPzqxDoxWgHO9xhPM+ln4exraZLTEa7FanNfnNTUpgY4Tv/uo/aq/+7Siz89R36Whejqu4+/1qP32VWdSn3X9bmgsdLL/qEJf3ttR+mf8/fDn42dIr/1xxDD8fZ/4MzmTMzmTM/n/Ozl9k50zOZMzOZMzOZMxOTMuZ3ImZ3ImZ/LS5cy4nMmZnMmZnMlLlzPjciZnciZnciYvXc6My5mcyZmcyZm8dDkzLmdyJmdyJmfy0uXMuJzJmZzJmZzJS5cz43ImZ3ImZ3ImL13OjMuZnMmZnMmZvHQ5My5nciZnciZn8tLlzLicyZmcyZmcyUuXM+NyJmdyJmdyJi9dzozLmZzJmZzJmbx0OXbL/T/8wz/EYDDA/v4+crmctHvWbZjfeOMNvPvuuxgOhzI3++nTp9jd3UWv10O73YbZbMbMzIyMEwYOBpFlMhkAwPe+9z1cu3YNjx49wi9+8Qs4HA780R/9EaampvBP//RP+Oijj2T2iMlkwvT0NAKBgMyJsFgsMlzo3r17ePLkCS5cuIDvf//7sNvt+Pjjj7G1tYVqtYpCoTAy7e3GjRu4dOkS1tbW8OMf/xjtdhsXLlxAOBxGtVpFuVzGcDjEzZs3X3ih33nnHRll6/V6UavVkEql0Gq1ZBDQ5OQk5ufnZZ4CAKysrGB3dxdTU1O4evUqjEYjCoUCWq2WzFvhiNReryezbBqNhgxXmpqaktkm6+vrMqLVYrHA7/fD6XTC6/UiFArJvAyj0YhsNjsyQ8NgMMigsJmZGVy4cAHNZhOPHz9GpVJBPB5HKBSSmTGDwUDmfnAmusFgwH/+z//5hdePY6I51Ei3Umc78+XlZbz66qsol8u4d++eDIvSg8tMJhO8Xq/cj9vtlkFsg8EAExMTCAaDqFaryOVycLlceOuttxCJRHD79m3cuXNnpK05934wGEQ8HpeZJACQSCSQyWQwPT2Nd999F2azGY8ePUIikZDZHcDhKOYLFy5gfn4e+/v7+Oyzz9DtdhGLxeB2u+UzAHDr1q0XXj8A+Ff/6l/BZDLh/fffx6uvvjoyTpljMdiKvdPpyM+mpqYQjUZHpqhub2+jWq3KO+AsIYvFgmg0Cq/XKxNQ2aJ9MBhgbW0Na2trcLvdmJubg9lsRiqVQrlcxuTkJM6fPy/fz/vqdrsy84kzmux2O3Z2drCysiJzmPr9vuxBPVKYEywDgQAikQgMBgNee+21F16/2dnZkf/nnBu2stft/PV4Cz3BlyMFvF4vLBYLqtUqKpXKyHX1vtYjLDjSnMO7+M44XI7nmBMo9cBDPaOK13e5XKJn9FhjzvsZH7KnB9blcrmvXa9jGxcOuzKbzTLkikIFUq1WsbW1JfOubTYbut0u2u02ms0mSqUSzGYzgsEg/H4/HA6HDKMKBALodDpYX1/H+vo6Op0OHA4HfD4fHA4HrFarDJ3y+XxYXl4WxcpRqysrKzI5zWAwIJlMolKpoFwuo1gswmazYW9vD5ubm2g2m6jX67DZbJidnZUxq/fu3RNDZ7PZZAJlOBwemWn/osKXwolwDocDS0tLACDTKTlSt91uY319Hd1uF1arFUtLS3A4HKhWqzIlzuVyydTAcrmMRCIhw37MZjPa7Taq1arMk+AMe5fLNTKGuNlsIpvNyjhWKgROCHU6neh2u2KIqaxtNht8Ph9arRZKpZJMDy2VSrBYLDJdb3d3F6VSSca0nnQmSblcBnAwU8LhcMj964kRjUYDGxsbMBqNmJ2dRb/fR7FYlAmfzWYTVqsVs7Oz8Pl88Pl8Mn6WUww5bpZKbXwuBxXd7OysDMmq1WqyxlQCvK9er4dGo4FsNguz2YxyuYxGozGizPkcu7u7yOfzcqgNBoMMaopEIgiHw6eaR/Lqq6/K7JSdnR1RXiaTCfF4HA6HQxy3Xq8nc9P7/T4ymYyseb/fh8vlkvPh9XplkNxwOJSR0WazGQ6HQ+55MBjICGO73Q632w2TyQSfzyf7tlwuyyRRm82GQqGAYrEIo9EIp9MpUy/r9Tp6vR58Ph9qtRoSiQSazSY6nQ5KpRLcbjfi8TgMBoPMmB+fUfOiwrknNBb9fl8GG+rJphQ9xtlisYzs2VarJQZifN5KJBKBx+NBpVJBOp0eGbBIg6HnxvCa2qDS4OszQiPDEekAxIjTuIyP/+Y4+qOm436dHNu4JJNJGXPK8ZicDEjrXavVkEwmYbFYMDc3B7/fj729PWQyGZTLZdRqNdjtdng8HgQCAXi9Xvh8PrTbbTidTtTrddy8eRPr6+uIRqNYXFyE2+0Wz4ML6HA4cOXKFXg8HqyvryOdTqNer8vEQbvdDqPRiEwmg1qtJhP+6KEmEgkxelQygUAA6XQaOzs7aLVaMiOb3m0wGBSv5yTCzcWxu5OTk5idnYXVakW320W/30etVpMxzJxBfvnyZczPz4uxMJlMiEQicDqdcDqdohA6nQ5arRZcLpe8FyopTtukgqKn12q1sL29jUKhIN4U3yuf3263j4xg5mZ0Op3I5/NyX7yewWCA2+3GxMQE+v0+kskkUqmUeJMnFU6DpFLjodLSbDaxv78Pn8+Hixcvwm63y9RORlKcvheLxcSTTafT2Nvbk/fTbDZlGNVgMJBoRCuUyclJWK1WGafL9eKAPP7hSPBSqQSTySTrxIPKgz8YDJBKpWS6I5UgnZFQKCSjbE8qFy5ckMmMqVRKlL/D4UAoFJLx2PV6XQxBr9fD/v4+isXiyCA2RiSTk5OYnJxEvV7H1taWOEk0LjQ0fFaXy4VgMCiTThnxUGHXajU4nU54PB54PB6ZEMo9bLFYRqasejwecQwY0VcqFUxNTeHixYsySZFn+qTD3QBI5Mi9wcmtnNCrB5LpiIGjmbXDwiFtevQxh6EFAgFMTk4ikUggm81+acop9874CG06BXrQ1/hwv+FwKCOM2+32yFRhfZ7oXDLSOWrS6teu13E/yM3U7/fRaDTgdDoRDodlvroezdntdpHL5UYU0WAwQCgUkrDW6/VKRELvkDPv6VGGQiG4XC6k02lUKhUUi0UAEGXHe+HoZc62ppLjdzPqGQ6HYtw4uc7lcolXGwqFMDExgUwmg0qlgl6vJ0rBarUiFoud2PNm1EPD7HQ65dq8N3oz2oOgYuJGsFgsmJiYkIiC448JZRkMBrTbbXlWm80mm4ebWx/WWCwm0VksFhMj2Gq10Gq1xBvkQfF4POIBptNpAAcjm91ut0Q1fIeE6ahkXC7XiQ+2hlZ4qF0uFwDIurlcLvh8PthsNokOTCYTgsEgWq2WRIY0UHwnVIR0JnSEajabkc1mJTrWUxiNRqNEd71eD9lsVt7nYDAQI8UxyhruoVBREzKxWCzyzul1En6jp39SYWTBveF0OgVq4jhsAPI8fA6r1SpnlZEI741nvdFoSAROZU+4WXu/NM5OpxPBYFD2BsfwVioVtNttlMtldLtdMQwGgwGZTAYmk0nOvB5DHo/H4fV6ZXyv1+uVUb+tVgvtdhtutxsej+fEZ5hjgrmH+az6PVH0f1NH8rNcP/05XpfQLyNinlWuo4apOPpbRxTjk3mPijS4dnpkuP5+Xtvj8ch1Wq2WvO/jyrGNSzAYBHBwuPP5PJxOp8A6PNw8lPV6HWtra3A6nWi1WggGgxIBWK1WTE9PIxgMjswgd7lcEhJ2u11MTk7i3Llz6PV6ePr0KcrlMnZ2duRBE4kE7HY7CoUC6vU6isUiksmkeOpGoxGBQAB+v1+8+cFgAI/HI7OheVB5EN577z289tpruHv3LlZXV+U70+k0bDYbLly4IAb0RYWbemJiApFIBNlsFk+fPhWISV+XStFkMgl2ypyV2+2G3W5HKBTC1tYWnj17NvJ+isWibEqfzweLxYJut4t6vY56vY5GowGr1Sqw5OTkpMCTbrcb3W4XiUQC5XIZpVIJ1WpVIiuTyYSJiQn4/X6kUimsrq7C5XLhxo0b8Pl8KBQKKJfLMj+92+3C4/HAZrPB6/UiGo2e+GBzfZjvsNvtAntks1k0Gg1Eo1EsLCyg3W4jkUig0+kgEokgFotJhGWxWBAKhSQnAEAMrdPpFAPI7wGA1dVVDAYDmcXOCMViscDj8aDT6aDZbGJ9fX3Eu+M77Pf7yOfzMBgMqNfr6HQ6YpwIE9vtdkxNTSESiWB/fx9ffPGFRBD9fh92ux2RSOTE+w+AzGHnuQgGg5ibmxPFXSgUEI1GEQ6H5Z0Ph0O43W4AkLnqAMThKRQK2NvbQ7vdRqlUEiiXOQ46StQRGmqenZ2Fw+FAs9lEt9vFzs6OOKV7e3uwWCwol8uS78xmsxIJEN7hebh69erIbHhCkRq2jcViiMfjJzbQdG51tEkjMR4dAIcjlenY6eiE0QWNB3+/3+8jnU6jUCiIgTeZTJIjZSSrIwvqB+5NRjW85vh4buoBfh44dN7o3OrzRaiUMPpx5dg71e/3A8BIgk1bUmKxhE6q1ao8sMfjgd1uh9VqHZmRreeu00vmgab3Q8VYq9XQ7XZlEWh9+XJNJpN46RpnZGjYbrdHZkvTC+N3GY1GOBwOiaj0RuHzjYehLyI0GHxRhLG63a5EAvSICRlwcxBOYlKXHgbXW8/F1lAWDyI3G//onIDGvvUzazEYDAJN2u12OBwOmM1m2Yj0PvVcb32AeN8vMn97XGgIeF0eCr33+IcwIZU4IwMeVCZBqajHw359j4S1uNb8PKPDfr8/ElXpJKy+1vg8ej6D1WqViIpwECOy8Xv5qhnrxxXuCTo03EvclzQG9FK73a6cFw37WSwWOcP0lsdn1XN9gMO8LNfH4XDI+9Lrw583Gg2YzWbZr1xfrgMAyYPpnA7XlUqX54ORqnYqX1Q0hMW/j/M+dHQx/m/joqNCrjud5XGjpX9nnFDAf9MGZpxwcNR9HfWZF31eyrGNy5//+Z9jOByi0WiIUsxms6jX69jd3UU6nYbP50Oj0YDdbken04Hb7cYbb7yBixcvSmjYbrextbWFVCqFQCCAYDCIXC6H27dvo1QqSc4hm83iyZMngldSMblcLpjNZtTrddk4LpcLHo8HCwsL6HQ62N/fl83JEHt7exsmkwnZbBblchlerxcLCwui8A0GgxhQHqzBYIBwOCwsqr29vRMrx83NTRiNRmxtbcFsNgsUZ7FYEIlERnBoQiiNRgP5fB7VahWBQABTU1Ow2+0YDocoFouiIHu9HnK5nCSyw+Ew8vk8dnd3xXDzcFOJdjodgXXcbjdKpRK2t7flgGoDRwjKbDYjEAjA4XCgVqshFAqJIabBJHyXz+dFmXs8HjidTjGiJ5GFhQUAEEelWq0ik8mg3W4LK4z5BDoTzIOEw2E5FK1WCxsbG6hWq1hcXMT58+fRarWQy+VQLpeP9Ph4AOm9VSoVrK6uiqEaDoewWCyIxWLo9/uSbCambrfbMT8/D6PRKCwxl8uFcDgs688k9uTkpEC+vV5vJPmaTqdPBYsxZxiJRBAKhdDtdrG1tSVQIz1T5im3trbQbDYRDAYRCAQAHEQsXBeHw4F4PI5oNCowFsk5Ho9HlDmZZ7VaTYx+MBhEs9mEy+WCy+WC1WpFuVyWn/M9hsNh8aAJy2cyGVSrVTn3jUYDjx8/Rq1Ww8zMDGKxmOxBAJiamhKjzbzESUTDmUc5YDrHwf/nZ5+3p7TCpoGlofB6vYhEIuj1evLMPFMAxNmhA6edTTqD7XZbHHFenw4BHSeNIPE+G40G9vb2JO83fq/HkWMbF81sqtfryOfzWF9fR6VSETodDzMx8U6nA5vNhomJCTlo1WoVa2trKBQKQrltNptIJpPI5/NyqNrtNmq1GqxWK+bm5uDxeEaofFxYen5utxt+vx/NZhPValU2A2mxpVIJRqNRYAnCEbwWvXO9GZhAJpulUqmcOGdQqVREqfP7iT1bLBZJrPL/Q6EQ7Ha7JPmtVqsoI+AQiqSH2Gq1AAAulwsTExMYDoeifBlx6RBeRzFWq1WIGcAB/EHYh/cWCAQkJ8Goz+FwyJrpyIFRmc7t0Dk46foFAgGBdDweD5LJpLD+GOHqfJuOppgvJPWzWq0imUxKzpB7hNGxTqoDo+wgkkoKhQIMBoNQv8my4wGn58zIjnuIERf3Pu+TEScVLfchjTxwAGec1LkBIHk5t9sNl8slTMperweLxSLKhUaCzLZAIACbzSZoAhl7JAQQniFyoCmuVEg0Wlx/wuVutxuhUEgo4dyXRD6CwaBA5lSIAMSZsFqtaDQayOVyKBQKAm02Gg1hiBGSPcpTfxF5XkJbR+o6x/G83IfObTBS4x7TpAObzQa/349ut4t0Oi2ROKNwrgWdNp3kJ1LAz/Ca3NdEj6hDxskOfAe8x5NEzcc2LqlUCoPBANlsFvl8HjabDTMzM4hEImg2m0IzJdRQLBZRrVaxsbEBv9+Per2OXC4n+ZJ6vY5oNCq8bR4wKsBoNIorV67AbrcjHA7DbrcjkUhgf39fkrIWi0U2HxUmlQwAiXiYu2AeJhwOY2pqCuFwGJ1OB1tbW6KciRv/5V/+JTqdjhijer0u3tRJRENEAEYiMmLDNGSMonw+HwAIW00bQ21YLBYL4vG41K0QsqQBjsViwmxitERvudFoSJ0BDVA6nRZootFoCK3YbrdLjQHXiwqWiosRWaFQkBzT5OQkms0mEonEidYOOKSBlkollEoltFotRCIRtFotoWtqr5BGdW9vb+Q6vD+z2YxCoYAnT55IXouQChU+4TSuZ7FYRKFQAHDIqOOzM0Lk+9AwZ6fTEYp0p9MRBaijOYPBgGfPnmFnZwftdhtXrlwReI9JcCaUTypMxtM4ttttUSisE7FarfB4PBgOh4hEIvL93BOM8hk1U+kz2qJhJzGhXq9LYp2OZ61WA3BQ3uByudDpdBAIBNBqtYRmzr1XqVRQqVRGKPN0GCwWi0BsV65cQbvdFsNMr5+f5X44DbQ9vvbjMBcNiCbp8Pd47sehq6MS7twTnU5H9K6GB/U6G41GeL1ecUAY2XBvEQ2ic0VDT0PO7x83MDraeh4c93VybOOyt7eHwWCAra0tJBIJLC4u4v3335cHzmQywlyiZ8hkvNlsRiaTwerqqtAHyVAhndZmswktt9vtIh6P44MPPpAEHT1swl1k/ExOTgoMtL+/L4eB3hU9onw+D6PRiMuXLyMej2NiYgLRaBSlUgnFYnHE81laWsK//tf/GgDwf//v/8Xq6ipqtRqy2ewLLa4WvhhuCM28yWazyGQykmT1er04f/68RAeRSERgFFK+qRgInUxMTMDhcEhymJvTbDZLYWCxWJTCSo/HA4PBIMWC9HCY0Kfn12q1hF3H4i2XyyXGhRvZ5XKNGL5utwuHw4Fr164hFovhwYMHWFlZOTEkwfXL5XIjdQxkFDUaDQCHUScV2tbWFnK53IhipGLK5XLIZDIC52kWmMvlgt/vh9lsht/vF0VGuI/7nnk6Qkn8N+1MtNttrKysADhwFPQfnXdcXV3F5uYmzp8/j+9973uwWq3Y2tpCsVgUuO00wlxOo9GQuiEqFEYTdrtdKM/xeByDwQCJRELIAPwdRtjMV7FOQlOQG42GOGuEWvv9vnwXHRYN05JaX6vVUCqVUCgU4PV6kcvlcPfuXfT7fVy9ehWTk5Py/U6nE2+++SbMZjN2d3eRTCaFjm40GpFKpeTMcN++DKES1kaG75wRIKOI58GZRzG6mBPrdrtCUuLa6tokojYsp6BeIQGAeWg6AFx/wuT6vvkZbVzo6I/nUY8rxzYupVJJNoHBYJAIhApFh9Wa88/kGr1lYr5kejC3wfCf1pRW2+FwCH5LyIPwDGnFVH70fOgxsdaDBofKg4VYqVQKzWZTDhRhFc3uoMFk8d1JPUeykHjwdPLXZrPJz0gvJpefSo+RBFlLhC1qtRp6vZ54Z6FQCAbDAZOG1Glen+vF9aMCpEHns5PaXSgURDHwXmk86LVbLBa5h8FgALfbPQK71Wo1qUvhz04iDNEZjfHaXFsAYiT0d9DYkNmlPTTmifTnGEUzP6IJCZpYwfqrUCiEYDAIn8+HYDAoCtJoNEqNj1YI4XAYgUBA8oZUABS+axpC7j++u9NELswJaCPBKIv7wmAwoFKpSMQGHDoQXCf+vk7G874JtTCSYy6GkKIm2wAYORO6LiYej4vjSSiZnyXbjNH4OEmBUQJrW/id+plOKxra0vJ18JFOjuu/9e/SQOviSU0MAQ7p8xq+JqzK5+Rn6WATAuV3amMyTsbQ96ZrZn4vOZdHjx4BgGzyXC6HH/7whzCbzVhYWIDf75dqYuAA1qLXZ7fbEY1G4ff7YbPZcPHiRQQCAamcb7Va4i3ZbDaBVX74wx/CYrFgYWFBDBE9z8nJSXg8HszPzyMajaLVamFubg7tdlvaqXz22We4c+fOiCIkPp5IJPDZZ5/B6XTi8uXL8Hg82NjYwO7uLorFInZ3d9Hv97G5uYlnz57hnXfewR/+4R+euEp/cnISJpNJEo65XE4oruFwGA6HA6VSCdlsFtVqFel0WmClUCiEer0uUEYikRB6Jmtl9vb24HQ64ff7MTk5KS07er2eHHCSAqhU9LrU63WhHbPW4NGjR1hZWREPkbkUbuyJiQl0u11sbGwI7Xd+fl4iV1LSt7a24HQ6cenSpRMrx42NDQCQLgLs+GC1WrG4uAi/34/19XWsrKyMsL54eCKRCC5fvgyDwYBUKoV6vS75GuAwZ0QIslQqYX9/H8PhUA4q8w1utxvnz5+Hx+PBhQsXRBEy0iG083d/93dCqmA09O677+LKlSu4d+8efvWrX8FkOmhhRFjY5/NJpA8cRF6ZTAavvPIKLl68eCoqMuEaKiQaSaPxoH3NcDhEOp3G06dPJe9ntVrh9XolP8WcFKnIdBKBQ8otW8Tkcjk8efJE1pVUWhoo5qnYAYNsueFwiLm5OSEc7O3todVqiUFfWlrC8vIystksdnZ24PF4MDc3J9Egu1CwgJZKkbrrpDKulPlv4179eP2IToaPJ/L1dWis6fxpRc7ohwgPf4dFqB6PB6FQCFNTUyMMPtLO19fX8eMf/1hqAXWEyUif+5REFf4/dYTOpR5Hjr1TebConDudDnK5HCwWC2ZnZ0VZ8Yu5eWlxddKT3l6r1RrBlBkSs1CqUChIQo70Zya9GbFwMxG3tlgsaLfbssAsnuML0fReQgMsuqIHSQVLYgEjg4mJiRMbFyooj8eDYDAo+DBhJiYhyUoizMNaAWLVjCqYPyGzjEwwbhIWLTLHwDoketUMn1knwPwP2SatVkuS9zqkp1etE4aMDnmA6WAMh0NpjcIc00kT0sw3ULmS2TQcDqUgjwdyHGbgvvB6vQIB8TloLPk5en9kI9J75Ge4hz0ej3R2CIVC8Hg84lDRuHi93pFowWg0wuPxiDPBqJ1Khb9LQ0bvn+vJd3RS0cpRk2MIWVEhEbIihEQFo5XmeAKa19ceMPcGC6zHmVT8Q2NH9IIOJHM99La59jrHx3OkPXx6/TxD3MPUQaeJ/ijjSXttXI5ikvHfx//on/Mz4/DTeCKezh7XUpOD6KTz2sFgEOFwWLpwjF9Tn8fnGQ1+91Ew4FfJsXcq6Zzs3dPv96Uf0dzcHCYmJmAwHLRvYJJYV+ez7YPZbJa2Iel0GtlsFu12W6iCNFS7u7uSABwMBqhWq7h69Sreeecd8UCsViui0Sjcbje2trawuroqrB9y3OkJEdOtVCrI5XLweDx4++23xRNgK5iFhQV0u138+te/xnA4RCgUwvvvv4+FhQWBKk4iPKikRzabTaF3MgdABUWFR+gnmUyO9Gajl/bkyRPUajXBXbnWZKZxo9IzJG2X+RsWN1LRhUIhVCoVJJNJMeyTk5MARousSHKgF8M1Bg7g02azKRuckBt7Zp10/QipUvmxxsJisSAQCCAajSIQCEjngvF2Fs1mE3t7exJFz8zM4OHDhxIRBQIB2O12XL9+HefOncP6+rrQqgmxLiwsYGFhQVg8jKAZlWrYkDDguXPnZE1brZYUWrZaLbz22msj9TMzMzM4f/48SqWS5Cd9Ph8ikQisVitWV1dPpRir1SoMBoN4uWyVwnulAzA5OSl7hwaC1PhisQiTyYRYLAaHw4FcLieRBZlxjP7oRDJCZHGvpikDkCJUKi566DT2PCf0ykulEu7fv49KpSIO2bNnzwR2ZSspsh9J86cCPg3jjjKuZKmoNeynHV6WPNBR0MpaGwmSKwgFagLD/9femz23fWZn/g8WghtIkNiIheImidq9tsbupLvTqenUpDI1MzeTqZqL3M5fkL8qyU0uuiqVTE9PpmO3Hbdj2VosShQ3cQNJLCS4glh+F/x9Dg9guZsCnTu+VSzZEgh88f2+71me5znnENTv7u4apE1RKgXE9I8jODo8PNTS0pJKpZISiYTJk3leBIU4LoIdH6D5OrB/F+cyPDysVqulnZ0dHRwc2EOn4n1sbMwMF5sWFRkaflqC7O7uWnUvunmkjVSA9/b2qlwu6+DgwNRU+XxeP//5z03xwnX19fVpcXFRa2trOjo6smwDUpkDguPZ29vT+Pi4bt68abj26empiQRWVlb0zTffKBAI6Oc//7lBbxjLbhb4/e7uruHvQBJgxUAEEG7AC6jVyuWyVcTncjmVSiW9ePHC0mhUc3AgtVrNKm2Hh4dVKBSsgSevR/0lyYwDGzgYDCqRSFiU32w2TfbLQUFcQTTFpmbzUxN1fHxsSqtuFvU0BA1EqdSJjIyMWBYmqY17IRPb3t62eqhUKqX5+XlVKhWTyw8PD2tmZkb3799Xq9XSq1evDCKs1+vKZDJ69913DaMGOqJvmpd9Q1Zns1mFw2edf6nBajQaisfjunHjhmq1mvWzo5vAy5cv9dvf/lb1el25XE7j4+Pa3d01mK7bBceD0S+VSsYJwVlEIhGrgdnf37dsOBA4awC5tbWl3t5e3bhxQ2NjY6pUKiYIAXKjOy/ogiRrHgmM5guHka97fgyuiwwcIyqdKVG3trbaDN7GxoYJWmKxmDmzZrNpSlZ4iR8ic/HLq618UOczMzI3lndGvAcOh6CG+4GNgFf1XB0BwejoqDKZjK5fv65AIKBSqaSjoyMtLCyoUCjo8PDQOLvNzU3bw4iffOGpvyapvTj434Vz4c3ZPMBejUZDq6ur2t3dNfmpV0J5ko1olnbNROHcWGAjIupMJmP9tE5PTzUwMGDEHt7eLw41xVjAYwMDA7p27ZodHLKoXC5nRVkoo3hwkPdAFKjgut2YHNBG46xBJQcBY+4VMsAIXHtvb68R42yOarWqcrlskBbdoxEh4Ky8Ei+dTtvrqLEAb/Xfa3h42KJUOInOGhWvVgGTxejTP65er5tq0Efo3SwfbbIXgaagNI8AAFjTSURBVD4WFhas1sE3SuS7YOji8bh6enqsIWAoFNIHH3yg3t5eJZNJDQ4Oanx8XIlEQhMTE3r33XfbOu7SVZp7xvOhkI+Ah2xNOoNkRkdHdffuXbVaLeNlBgcHlUqldHBwoJWVFUMEJJmj8c7++PjYBB3dLn736OhIe3t75hiAFqkngYOjOJVnPDg4qGvXrikUClkA02g0NDY21lYDQy8/zh0ZC8IE35HXZyv8kDF51ae3Hx4e8lJu34WCfSid83QEXnBwb7s8BMYe88/DZyA4FRyD74r++57Pm4QCZLpkxsBU0AS+CzXqMDI0YPxarWb9ysiepO8vBvX/74PLt1kXdi54MyAcXxX66NEjnZycmJSWCJwqfRooUmS1sLCgarWqDz/8UB9++GGbWqFzw56cnKhcLhshjfH38j6vXjk+PrZqVg5nJpPRj3/8Y2tbf3p6qsnJSd27d894n1arpWKxaJH9Bx98YFFEqVRqw6u7WRBpZCKpVMruC0apWCxqc3PT6neAKBKJhJH81WpV3377rcrlstUkRKNRgylarZZKpZJ1/PU1FVTvc5/q9boR22zOVquldDptShwUgSiySO+p2vckNITu0NCQMpmMZYxEkG9DBnYuHKHfIwQQX3zxhfFJ0WjUuB/pTFgCJ0KPsUePHmlnZ0cPHz7UX/7lXxpcgiIwmUxqZGRE+XzeKpUPDg7MWfviSBp+0uOOPYvD7u/vVzKZ1H/4D/9BgcDZGIjd3V0lk0ldv35dpVJJX3/9tfb3961mJxgMWgQaDoftHqLY7HYB6yLw2Nzc1KtXr+yMUNVNgR3iEjhJArKTkxN9++231ovs9u3bqtVq1h2dfZhIJPT++++bU6GzMrANndbJVuBeJFl7nVAoZFwZsE1PT4/q9boVa/qMmj2BcwsEArb/6WTRarWs48PbLp+R+L2MY8A2eVl7NBq1awG56ORcPKH/JudCkTqfTwCOahbHQlaI7SLIBx5DBs7neNWa53b8IkP0MPNF1lt1ReYi8KAYKCAnIChUCtS0ENlykWQ2XvbJF+VQcuBxYHhs33CNyBFCj/SUTea129K5Pr/RaJjH9zwK34vDFAiczevACHcSbW+zfM80j2FyP/xm7FSfeAzXY7dkiWxqr4OXznuR+U3pBRZ8hiesO8lD0m84j1arZb/LvfNG/+TkxGoXfBrtnVc3iwIwsjwfNeLU2A9kzIFAwOSs7D9k1ETjBD9+gBj7k+yOPdNqtcyBeEzaE+QQ4bzO7z84BCTP3H+MKlwRnCLPmh9fINzNYq9wRrivGCNvQNhfHnXg730bIf98+/v7zfj7/cY+QjACtOnhpE7SGBGK72/mSXt6hXF/yZbIZuv1uhH5/gxc5v6xOuGtTvUX98orxPy1e4P+JgFK52d0vo6MZHh4WIODg7aHeb7+c32JAfu/8707ifpOu/MmR3iRdWHn8t5770k6N44LCwv65JNPzKmEw2FLf+PxuH7xi19YaxcOP9H2e++9p1gspqGhIXMKHLZgMNimomk2m8Z3tFotPX/+3CCZSCRifYooAEMyx0AuUvxvv/3W+Apm0rB5iTRRX42OjlovqL29PR0fH1txVrPZ1F//9V9f9LbZIlpgE1CZHAyeDwcCZuK712o140nYJKjfqJvxHASLTYwDZ0NDthNNw0UA8XA/IVjhFBj+Rv+no6MjLS0t6fHjx7ah+/r6VCwWValUTG0lyWpRIHm7XalUyqLRo6Mj7e7uWlU5Rgloia4OKPxSqZR2d3c1Pz+vQCCg2dlZDQ4OKpPJqNU6UyFNTU1Z6xUcma+pOTg4sA4RQ0NDmpiYMKjFtzkqFov6/PPPtb6+btDM4eGhvvnmG/X09OjBgwfKZrOSZNkOw7Pm5+e1vr6udDqtqakphcPn3Rvoan2ZzIVonWmeo6OjlqGHw2HrPLy1tWXQUTabtSJc7iHPgSx4dXXV7jX7IRgMan9/34qrGd2wvr6ujY0Ne0YoJVHJUf8zPz+v3d1di8h5z3A4bGMi4BX5u1AopNevX+vVq1caHR3VzMyMwXkEozzbblZnpM/7SbJslmAMNSOQEkgKDhhj3+moJH1vLRABZDAYVDKZ1Mcff6x4PN42jRcYm7O+trZm3CLcLC22WDghT09w3f4a/DVeZF3YuSQSCfvijUbD2rKjJKEYD4hlfHxc6XTaZqOA8YZCIaXTaRsmRXTX+UNkKZ0XDgFbYczAs7lhb7oxZD4YaPB1f5P9D++DjJTosVwua3Fx8a1TQ5Zv2eBbV2CAgK+o58FwYlSIyuii7CPxN12T35DSeUsUILjOiM5neTg3VCrRaFTpdFq9vb3W+mVjY8OKS1G30SIHabkXXuBQu11ALRhXn9oTAUM+Y5AYqBaNRlWtVu2A3blzx5SO3At4GZ6JL+zj8JXLZa2urlr7IB+VkjXRaw/xAM6wWCwaoZzNZrW7u6tisWjtYPheCCKoyZLOORyCrm5XLBaz7O/o6MhUb3wuasKNjQ0NDAxoenq6LTLe2dnRxsaGJGlmZkb9/f0G2WFUaRXEviRgIyjF4dDvy3dbZv81Gg2r+YpGowbtkKmjSGPwGvuD7K9UKrWVLZCZdfKG3a5Onkhqb+VChu4LSn0/QSTUPEt/Tf6/Ox0PzoW9RuDEWGn4QM4BfRYrlYrZae5F5/Lil85r8N/t38W5/OpXv1IoFLKivlarZb2d0N7HYjHrF/bll1/a3BHaE4ANtlotK7jkJvMgiOYwuJJss9Jor7+/X2NjY5ZmHx0daWtrS3Nzc0a6j4yM6OHDh3rvvfcMsunp6dH4+LjNgZmbmzNC9ejoSLFYzOY9PH/+XLVazdQWgUBAMzMzXUc9FC8SpTGoKRg8a09B0SaHECMHAceGkWTqO1qO4GRjsZgdVup2wHmlc3K7Xq9rfX3d5M5AChgYYAcI1L29PT169EiSbLpnsVg0g+AlocwGB8ZMJpNWt3SZyBvJsHSurJmamlKz2bRCXEbuBoNB6yadTCYlnXVTnpmZUSQSUT6ftz5tHKRisajd3V29evXKjN/Y2JhF66urqzY2u9Fo6PHjx4rH45qZmdG1a9dUrVbbPjMSOZtWmc1mbapoq9Uyyf36+rqePXum4+Nju/7j42MbdkZGSj+zWq3WJvnuZmHwmESJEARMnkBgdHTURC8ISgiCqKNgiiwBTCQSMd6D+Sk4yUgkYpNiadXTbDa1vLysWCym2dlZQyzgQOn9h2CFgAsIzMNtx8fH+uqrr0wGzohkPg91KuKLQCCg27dvv/X983AX/08A7Ls3+FolXk+AwrnubK3iYUFfTAlBD8SXTqeVSqWUz+fNtnL2Ee9QhM6sndevX1tAQYDKZ3Q6C2wlcLCHwYBmL7ou7Fz+9//+3wqHw3r48KHu3bunVqulbDZrSqparaZYLGYV2v/6r/+qk5MT/exnP7P0118ssAZ8TbFY1PHxsdbW1lQqlZRKpTQ9Pa1AIGAblSge4QDz5nEu3377rRHKsVhMf/RHf6T/8T/+h7VU91nSq1ev9Pnnnxvk0Gq19OGHH+ru3bt6/fq1Pv/8c+3u7toM+Ewmo5mZme+QXRddqM/IuKLRqFKplE5OTvTZZ59pbW3NJjh6lQeV+WD5PT091kKcSLCn56ytPH3JBgYG2jiAcrmsWq3WJjOloaPvSItijgibQKBUKml+fl5HR0d2P4aHh805onLCeZElhcNh5fN5xWIxraysaGNjo2vj+PLlSwUCASNHR0ZGNDMzo0ajoSdPnqharVrnaIQIzWZTMzMzCgQCJovt6+vT+Pi4YrFYG/lLU8R//ud/1jfffKNbt27pZz/7marVql68eKFXr17Z7Pa9vT0Vi0XbY7VazYa/IYgYHx/XvXv3dPPmTT19+lTPnz/X0dGRCTD29/f17Nkzm1XEgUZaT0BRKpW0tbVl8t7LLIzc3t6e1tfXrbJekjmGQCBg3Yp9Yaoka3cTCoXsNT7DomDy9evX2tnZsfdASVYul7W3t9fWHQGlHQEIdTTj4+OmcsQ5ATV64UE4HNbe3p5+97vfqVwu6+7du7px44btSwLEUqmkTCaj8fHxrkU5vhCU7JbsFxgYYQmKOh84kzV2Ql6ec5JkEmUEOx5dyOfzun37tpLJpJLJpKkgUSGCJJRKJYNxl5eXDSqXzgl6z8F63pnPJngABcLWX/h+XfSFPEzwe1Je6hjAPynQgXilpxgbgS8A/sjGQVOP56a2gwdHVOMzFcayYoC9RjsUOmvcCA/EHBTp7JCx8X0nVvgaT1h6lQp/383y8j+URtw3Pot7KMlIY9QmcCOk2ER/ZCqo8Yj0fBrtpeNsHs8nkDFBtmJEcfx8NpuMe9Ip+/WSSWAAoDgMf7eLw4Bj6e3ttS4K/rvQj81HWIFAoM1h1mpnw+y8XJQ9x7NAJbi/v2/wC9wW38/j5r6rgv8cel9RHFuv162ND88JhRufTabg99zbRo1vWhRMBoPBtimlnDn+DaVRoVCwTts4EmA0FFpeEMN7+BoMqZ2Q5p5L5zOAPIzGe/PjhTBk0twrzkur1bKREKlUSqOjo2avyPhOT08tQ+82eybL8HAoz99H9zxnzoivf+oMrjrhaJ8pkBlxxhCqwFP5gMmLbNjf9CD0BD/Pwz8Xv/xrvXiGjOZNv/N9663GHAOXBAIBa/zou4xWKhVrBsnfx2IxjY+Pm1PwhwjJJxJL0nXeHwKdTcyX2t/f1/LysoLBoNVuvH792iIgHtj29raePXum0dFRTU9PG2HdbDatvganhcGFQGejg9+D5XaL2TJvHpULPdfgeiSZYeYnEAgomUwqm80aXNhonI3MZeOOjIxYWswPLV7YlMApYL1ke61Wy9rPA1vt7+9rc3NTlUpFW1tbFtFzYJAg08/I4867u7ttHYjpOtBsNjU8PKypqalLYd7BYFC5XE43b97U5uamnjx50mb0KXj0mRPYeDQa1fj4uJrNptWtZLNZ5fN522Ps2d7eXlWrVRtAtbGx0SajxRD6DhKHh4f2jIEbt7a2jPP7+OOPrRnro0ePVC6XlclkDD7r7e3VxsaGtre3DULxXKCf0trtmp+fNwd9+/Zt4z/82cKwVKtV60L8k5/8RPfv31c8Hrd+cmtrazZ6AwUc9wKOhvfy3ANilFqtZsEhQYx3VDh6H7h42AjEgRlLH3zwgWX1Y2Nj5giYgUJtHd+xm+WDYwIKAmDuISpBeKFgMGgFjW9Sm3KOvfHGCfT29raN2Wg2m0bcj42NaWJiwng9MhY4lqWlJavMZ3UGxm9ytDgPio59ZvV9/O733q+LvhDMD4PFDfbRjv970i1PEHnDSWRN2tsZERD1eefCe9H7i9QUT83yG5SCRa4FQwg0ReSGasxHvp038jJkKosDQ4bnnRj/7tUcHmPmHsHLkKXQt8yn+2+SRPr76yNAbwBwJMAWPAOfSXWOjCXg8KNp/XvCv+D0ullkXvSfCgaDpkLyAUVn7ZOX13IvfL81Dg3fmb1Zr9cNwvFS5859SvRNlCfJ1HeQ2UA5GDtgZDLOwcFBq3kiS+a++Qj5smQ0zwE8HQPujTjSY+Azfw7Zi/7eekPdme2TbXlH+SZj5rNGFq99U5TdmdmAjvT391s1v98PcJyXzf46Zbid3AnPDvSBv/tDzy0YPK/s9yS/FyFAxFOpzw9ZC/uefYPQgu/r7+ObCHt+fHbjRVHeZlx0Xdi5kGr6AibaV7D5c7mcrl27ZpAN0dsXX3xhD4LCs76+PitQK5fLevbsmfb29rS6uqpisWhZBkovIlGvxJDOMoJisWhKMB9d+BRxY2PDGkXC+VSrVe3v72thYcHkmScnJ6pWq9aug9Qyk8kolUp1bRz/+I//WM1mU5ubm8YvvXjxwiCKZDJpCiLpPBLa2tqyNjhsFL5nLpfT5OSk+vv7TTJdLpetsDGdTks6hxXZkOCpktpqhKgboNXM1taW1tfXTbkXCoWMZAU/7u/vVzqd1sDAgMmVd3Z2bHYLh31/f7+NlH/bdffuXTts7BGiWT7j7t27ev/991Uul/X5559bYeLq6qrW1tb09OlThcPno5px8js7O/rXf/1XVSoVg9rIwsCZMXZEpdzHly9fWrdfpjUy+0g6UzGVSiU9f/7coDCUfnSi3traMmECbdExhPRj84e925XP5+05e+Uiaja6EIyPjysajWp7e9uGdq2urpoz5AwjfUUMQHEmgRnBGqIIulHTdYNuGfR989M8uQ8YUNrReIiT+wJEj3OjpQ+jOMiIuuVLWX48A+9FZsTMn8PDQyvUBg4jY/s+R0nm7bktIEDa7aRSKUWjUeXzec3OzioWi1mXaJwCewbaYGNjwyTQv88xhEIhg0l9Bo/jwXl5jvIi68LOBZUF1bvo+tlEjUbDlAzcYNK0V69e2WaGIwgGgzYeuVwua3l52VqaoICSzowsmm3IQ68vh0T0mLrfdMBeDMnixrDJ9/b2rM0+zowDAbdByxlG1Xazbt26ZRudUa/b29sKh8O6d++eOQKqnCUZ1OPrfog8UYiNj4+r1WoZrOXlx3AcZGNErP41Hs/l3tGDjWFNbGAObDweV7VatZQ7FotpZGREmUxGyWRSy8vLNnWUZ+Ir9btZfE8aj/rW4chOr1+/rj/5kz/R2tqaFhYWLL2naSbtct5//33jOTCKz549U7FY1NDQkElsmXhJhunlmkhiEQ6AgQNbHh0dKZ1O6+DgQIVCQV9//bWOj491+/ZtpdNp46foKEHmxFkiuPAG7bKZMypPDB7fA9htd3dXExMTSqVSJi4gqwcWhLCenZ3V6OiojbcAIvI91jj/5XJZm5ub2tjYMBXc8PCwQasnJycqFosaGRnR4OCgwUsUVANL41yo0WIBg/JnIBCwOjBJ38kuul3+fTz3zOchKUeO76XjvtiS5dED/29A8WSPNEiNRqNKJpPK5XJtlfnsTe9g9vb2DI77fY7Fw8Z+ZDm/Q7bqW0VddF3YuWBgcAwU+FEPwd9xQ8kyODBUQXOBoVBIxWJRhULBbgBFPtwwohE+1/cXwrv6bqdgnIgHaI1+fHysx48fSzpTbRFlEL2PjIyo2TybMoisFuNFOxvmXXR7wCEtecj0XQJmot4BI4qBWVlZ0dbWlrV48fUp9A/ymDZZSLlc1tLSknEkqMj8/AZJls3wTIBxcNiMM2DjEgkRbaGUovnn/v6+dnZ22ohb1Cd0t+1mkS0Bg3mIluvd2trS48ePLVCQZLVYvb291miV5obNZlOlUskyU5quEpBUq9W2uiAPtfA8k8mkqQjZ73BzvM5nwIgDyAKJBDHufCZw7djYmAYGBgwC7JYv4DtI7QEFzxwncXBwYNJVlGt8L2qx4Ar9+SQ4YS9y/3Z2drS/v6+BgQElEgnr0Qf/hxAFx4JRRWVGhwUicuk8qycD9zC8z3SWlpbs33AAXiH3tqtTvCKdQ2UIN4BPcRBE/LyW9aYsxhP7p6enhj4MDg7q3r171n4HeTiQG4EnQQyzlPzn+fPYCU/CGfo6P3+Nnvt7E2/0fevCzoVIgLT+8PDQhkQhNYYbwZiQ6lerVSt2JIoFPgAaYlOglEGjjaPyFfwomqTzsbHDw8MWmUGyMTtjfn5e//RP/6Rarab//J//syksgEeoLGY+OyONI5GIHjx4oMnJScPVu8VsPXwIFObHFNRqNetnhWM+PT0b4bu0tKRcLqcPPvhAkUjEoBukwGxGj69Wq1W9fv1a0WhUH3/8sdLptNUc+Ps3PDxsnZjJNsGNgS48oQ9JDUTSaDS0tLSkUCik9fX1NvGAh8+YHtgtb4AwwBft4vS4rwsLCxY1Ii8HGpiZmdGdO3fsHo+OjtqwqVarpZs3b6pePxvLvba2Zk6Sw0b0RnBzcnKinp4eTU5O6kc/+pHBqWQ8ZOhcC51p8/m8qX0QugwMDJgMn/1L9n7z5k2Nj48bzHGZ7AXjgqMkA6bWi+F9BwcHFuhEIhGVSiXrMQak3Wg0zBHyXr5VE/dvaWnJMpWhoSGbzwInRTY9NjbWxqdRf8MPBYH1er2tdxhFm/wb4wSWl5f11VdfqdFoaGZmxmpCpqenu4a2+T1sHPao2Wx+h5vz7atwPNJ3Z7tI50pIL1io1+uanJzURx99pHg8rgcPHpi4B4mwpwBqtZrm5+f193//99ZE2H+W50bhFrke+EUyWVAhHBcZKd/3wvvtoi+k8p75H17KSxTiI35uMBeIsQGX9obWa9aJDomQcS4+DWURNZBRQPr7UZ/cMBppcq28nkgS7JTIhgZwGBLEA90uZKBE/Hw2kY0nP7lfksyxBoNBM/x8dyBJnAWYPBue78hh8FPsKP7iviL9JnORziNd6Zy89YIArtNHRZ6Mls75IYxztwcbSTmcBzCol68jKPDGzkOCnSQ/P9QV8e+efPYqJRZ7CoGCF7Jwb5vNpu1/9h9dGZAs85w4K0TxEO9cC4EAPFG3i6CLWit/zQQevoGkrzMBsYB85/r9efSCG/al38+ccbIhxCiIhYC7sRkEKfwu1wAXxb7yWRjPiu9DtM1ZwF51u37f/X9TVP+m13dCY/zZ+d84BIajUSRJkNNp/4DxgfI7M5Tvu/ZO8YC/Bs/X8Cwuut5qzDEk8s2bNzU5Oan79+9rb29P//zP/2wzKQqFglXdjoyMtPXroqBteXnZPOXk5GSboQK+aTQaxtXwd6VSqa2WIBAIWLTA58RiMX300UdKp9PK5/OSpKmpKf2v//W/LPKmdQkt5Rl2lEgkNDk5qcPDQ+vptLW1paWlJc3MzOju3btdb8zf/va3bf9fKBT09OlThUIhG5MLT0FNCA5yZmZG9Xpdn3/+uXp6emzEc612Ng2UnlqNRsM4Ay++YBTC5OSk9ffyuP/u7q5WVlb05MkTg2/6+/stW8HxYSghXallyefzbXBDpVLR6uqqQqGQHjx4oEwm09U98+uTTz5RMBi0GfQeTtze3rbIcXd3V7FYTA8ePFA0GrVMdHBw0GqpgGLJPoB0vJP17Tmk8yiu2TyXVcdiMZ2enmp5ebmtRimdTisYDNqzmJyc1H/9r/9V+/v7mpub09zcnL3v4OCgrl+/bvU7wMOQ48+ePdPc3JyJNy5jGL/88ksFg2eFeKlUygzKycmJBgcHlc1mDTqKRCLWuLOn52wgW71et07GNPr0RgjjxIhoskfuG9+XPcSgP7IUMqPT01MbkEfXhcHBQU1PT+vk5MRaw5AN+yyBbHZ4eFjvvvuuqflOTk60urpqpQ6Tk5Nvff8I3jC0PtiF92Pv+OCRoJegxvMZvB/Oz2dr0nkdDM7Sq2v9dXlFHjAsEm/pfHIr+9h/NnsVaT3vQ1DtaYnvax/zpnVh50KqL8mqRjOZjMrlsj777DMzRERZvsMs+KNXbxweHpocGK8LLgpshaclXcYAcLO5sR6zHBwctDboPgvJ5XJGtm1ubtqgJKpZT09Plc1mNTY2ZuKB/f19qzbO5XKXGjO7vb1t1wJhvLm5qWAwaGQaJDrRHPduZGTEKrVROxEd+82EYfL1Hdxb8HqyIDY7Eebe3p42NzfNAPushcPAvQca4rDB6fjaBLgReBufzXSzaEXvB6z19PSY2osD1mw2jX9jSBSBCPcKaI09w3eEt/IyWG8EWOFw2LohAEGyr3k+7Fmy4YmJCe3v7+vFixdW11Wv181Rca/IEqhtwMkAK1+GkGaGDa1b+N5cN44Fp0JGwTlmfxJk+GjWy4Nx0P55cy8R5fB8aCrJsyCjQgJNC6hwOGwGEFWfdN6t3beaB+0A0kXQwV7vFlr0kb/PGqT2Xn3eWXgeVPpuOcObCH6fQRAAkI37urJO1MbvX1/ky2u9IMEv7KnvXO8zVPajl/pfZF3YUvLwCoWCvvrqKyUSCc3MzNiBIOqgiy4bZ3x83Irtvv76a0myQ8WNR9Hj4SAqS5ElHh8fa2xsTPfu3bMZLxQDnpycWDsSKoj5fTgKBkrNzc2pUCgokUjozp07pljjGnzkgLLo/v37yufz1h+sm4VRh1vyQ36ARIANSf8xTBD3bFai8Xg8rng8bvcBw0pWg6NgcyP1JiqVZOkzh5nGmFwnG9qTgXt7e23Gk8JTqtmpPaCL8tramtUadMu5cK+Qlnt4hejaixq8+gqxBH2xqtWqTVPt6+vT/v6+FhcXDXacnJzUxsaGisVimwiDXmG0OfJ9r5gQyLVw//r6+rS5uWlS50KhoFarZZJS1GUUriLBlc5EH3RrptVHt/dPOp854jMJnCfnFvUkEm+cZTQataADhwQUhcH//PPPVa1W1dvbq5mZGWtBAuHdaDTauiAD8dAaBgkz+xFDi1KpUqkYxOlH+yLMAPZG7JJMJs2ReaVot4uz7+8f9xCVmnde9OnzfKi3Hx4GwzYAK9brdWuym06nrb2TH2fBfUL0AydHAWcoFLLCa/952DecE5wVAY1XE15GxPRWY44DgYAKhYL29/d18+bNNufCjZiZmdHg4KBGR0cNQ06n01pbWzPncvPmTYPMMAA7Ozs6PT01g+GL9+hme/fuXf3kJz/R7u6unj9/bvUYh4eHVj2MlJFIvbe3V4VCQZ988onK5bLW19dVrVb10Ucf6fbt2yqVSnry5IkajYbBbihb+vv77Vop0Or2cGNYwU7J3DwXBcaNg8FQ+Zkb1G0wgGlyclI9PT0WPUNyQriyEeGxqD3h0Hq+B4iRjMmT2JC1tNyHoGVPNJtN7ezsqFKpaGhoSPl8Xr29vfZ6OlFfxrmQfVSrVXNWXBut1DGePvCo1WoWKUuyjBWBwc7Ojr744gvt7+/rgw8+0PT0tGXSPjrNZrP64IMPzHAFg0GDQSDyUTy2Wi0jv6vVqj7//HPrjBwMBnXt2jX9x//4H1UsFvU3f/M3WllZsY7Kvb29isViGhgY0J07d5TL5bq6Z53r+5wLdQ6RSETValWrq6ttGTVtRuAlvVSaPQKCUS6X9bOf/Uw3btxQKBTS1tZWW5sXGnciDPLOBWm2dA5BAVlSe+Tn3dB/EIQBB1Or1ZTJZDQ2NmYcr9/LlyX0Ow0uzoWMy3MgOAvPL/vfI0Om2JNzilozmUwqlUopHo8rkUi0qcMIoF6/fq2FhQVtbm4aN0xG6NGkN6nSJJmt8MtzMDigzizsD60LOxfGggLrNJtNLS0t6fj42CIKojzvEHxBFbgodRGeK6H77/b2tsEB4OF8wWq1qvX19bZBWRgsMhdmy0jnfX6k8yJQPHmtdjZbgtnS9XrdeBhJNvvcS1lJwbtZGBwi/1qtZqQ6PFKz2bRsgPvGxvAEqcd8fQ83CFYOKe9BlO/bp7PJj46OrCW3j/zZRKT6EIgYc6BO7nOz2bRoaWhoSKOjo/Y6orfd3d2unQvBjZdUc89wjhxS6Zy89vdNkvEFZJJkW0RstDAikpPOq9bpN9ZoNIz38RkoP8BJQK61Ws0aPgIf7+7uWhdvxBY8U6/KoajWQ8HdLowXwRxGms8BriZAw0DSBZviR+4Hjoa9gyyY1k2gC4gbyEBofkiAQ2DlIWe/v2nrQ/ZBEIZhRVbPfmTfehL/6OjIiPFuI3HvkPkc76xwFN5m8TpvqP17eMUYzhsYij3qP4fzwzk/PDw0yJxGnUBivh+gvxZ/jd5hSuc9JDvJfFbn//++dWHn8s4770iSHabt7W398pe/tHGl+/v7plKgD5dXFdFDaWBgQDdu3NDo6KhVJ5fLZSPw4CGYEiidF0ouLi5aoRtwG5r7bDarmzdvGnwkySqPg8GgHjx4YBu0v79f+/v7+s1vfqNIJKLx8XFNTU3pt7/9rebn5zUzM6N3331XPT09evHihba2ttpaLPzVX/3VRW+bLWai0x0Y0r7VahnBTNfWRqNhxZN7e3tt/IVX93iDDTYNPENRJe1FGHvMZ7KZt7e3tba2pkKh0Nb2hmyH90WRhUMEm5fOe6LRqZr58JKsEBED1e2CzGbIHEIEOBQifhRVhULBjBXfA4n8xMSEIpGIFhYWtLCwYHNVTk9P9fLlSy0sLCgQOJ9miSEtlUp6/PixjZ2gOzdthAiwcOzFYlGrq6s6PT3VO++8Y10ZCoWC5ubm9PjxYyPL4/G4Fe967uHx48c6PT1tu9/dLgaulctlraysaGxsTO+++64ajYa++eYbra+vK5PJKJfLWZ+94+NjraysaGdnx8aXY+wk2Zym09NTzc7OWm+6+fn5NgUnarlyuaydnR2lUilNTEzYxE/EDBhwjB5F1s1m8zvlENvb23ry5InZlng8bs9xcHDQ4Kjt7W3t7e0pHo9/hwx/m9XZIcGXSJBN8Pee4/DQHkGQ1M63ENyGQiGlUikbK41DwaFj3LGxlUpFL1680KNHj9rGC9Ac1Rdy+u/tiXqek3QuTIA389fo1YUXWW815thHssATYOxefYC2H4yWqBfIBtgHmMMrkrxKh8PEZ4KlY+B83QGdf31xnSS7BvBjKlvx+hgRMh5PXhNlkYVdZmN6aSkqK3gCX0fCA+R1cCFkJj6yBf7xsBmRupeISufRnJ+eKMmyRw6lT3/9pvQb3MshfRRIJAzMxzMCfvNNTt92+SJG6RxS8NkW1yrJ5gz5egAyMN852je+lGRwKoomH0ly/8mQcAK+9xt7metD+kpXYSJ4MkbqrXyRsI9yCRQ8H9ntAq8HxvHPmugeB+y5D/g8H/Vyr33jV+qeCIoQXpDtktF5B+ILYr3x4rNAPZBr8zvYIHoHYuh91u2RFPY28FQ3y18by2cp35cRefVXZ+TvoTL+noJzYElspc8mgLsIrAhCcSheTt95LZ3X5b8DjrCz5ONN1/6H1oWdC607tre3rX/VtWvXrDL64ODAIjiK/5rNpqampqzKGELVw18QhQyZou6EjdPX16d8Pq+BgQHFYjGDR4gWxsbGzAnt7OxoYGBAMzMzpkLj5vJQUKhBjpHJBAIBTUxM2GtWV1dNtrq7u2utbbrdmERfrVbLDgOGEYN/fHw2TtkbURyajxaJzonK+vr6rGUHWUIkEjFFE9JgXiedp+oYfeSjXE8gELDW+4g1wIVZVOWjfqJjK0ZROs9wfNV8N2ttbc2eo6Q2Y4J6CVhQkmV7RIGIPVDiYZyAxIhAcbTeidADK5fLKZPJKB6PW083AimmcAK74ZiYzYJUnCySIlrIaSrl2bNkQXwf4KnLEPrIz1Ft9ff3WzbJ6O9A4Gy4HBnI8fGxdTbAYHFmIPLJ/KgXY0RDIpGwLhSsXC6nXC5nnF1PT8932sJ3wk2IR+AcaAfFtMyBgQFNTk5qYGDA5g1BbLPP4QdRmXWzOH/e2Ho+o9Np4BR8Bw3vaKSzljyo2tizDx480PXr1zU7O6s7d+7YBFeoAwRNIDnLy8ttwwZxpl6Mgk3p5BE7rwcnjh30Dp/v8IPDYkQnTE0cGxvTO++8YxEHG4DIBR6B6tv+/n5ruQFUUq/X1dfXZ/wDqhIeCDAW8ANDcajvkNQ2MZAW0bFYTKlUyvB00j4OFW0jGN1MpE8aenBwYHUuVF1LMiPQzYIwazabFqXyoDCUZBG0qvfYto+MyOR88STfhUgSxUhfX5/Nu/HtQ/xG43lxKFHXwN2QZZG1wF0xTRRVGoeYrFCSKYNo9dEt3k0fM7T7Q0ND1lqde9IZ7XLv6PtE2wyfCRPlkbWi7ecnEAiYGCCXy+n69evW4ykcDhtfBV9HwaTPrsl+efbcX4wPGREDwQgQfOTJd7rMossBZxnOKRgMWvZUKpVULBa1v79vKk3fbQAOD+PDd++stYAHRPjAa+gnhjoyHD6fa8Tyslv2XV/f+dRMOMtIJGICAQQ4NJyVzng3MgOuGWfQzfIZG8GtL4Xw/8b3IOB5kww4EDgrvUin08YtIfaYnZ3V1NSUcrmcenp6zGlTJEmtz87OjorFolXke4jO72GuR/puMaW/Jp9NYqM8vfHvkrkgoezp6VE2m1U0Gm0jojGI6XRagUDA5qUMDw/bQZdkhG9/f7/W19dtFCnRDtGih0H4oTkeRl86y1aQAEqynkLFYtFSSyJzoAgizIGBgTZsmY6g1HzgdHyNTbfGEaGAdN6Gg4fvIxzPeyBFxvEAK2EYIbdRkfm5GPBWSGK9Co37BIzDffeV5fw+0TdGEMgLIxUIBCxbociOKFuSBRCVSuU7GO7bLKBXCu/IOjBkHrbDwBPwkEmvr69rYGBA+XzeskcOFhAkFf8eDsMgMa1xb2+v7fs1m02bLQIEzCyO0dFRy+5od4IMXzofuoV4A4dOpwS+g8f0u12clb6+Pk1MTNh5gMin4C8UOuvy+8EHH7Ttd4qLyVwg4oeHh3VwcGBFwAQ2GEUPeZEZIspgPwLJYAA5/8lk0qazEmDQlgjjTtQPV8lUUvZyJpMxe3WZ5ql+dTqUzqyA88D38VC9/xNe2J8vBDEIZOBGEIR0ZkHsDfZyKHQ2Dpngh2wNaJWsk2vHEfFnJzzuobO3WRd2LouLiwoGgzZgCU/r4aZEIqHp6WlFo1Fdu3ZNPT09evnypdbW1uzL4ISCwaCePXumQqFgBxNFj8eePcaKAzo6OrKhVESGSFNpUhkInA0QymQy1tV1b29PhUJBOzs7Finu7+9bZTqGiZSz2Wxaq2uIr26N48bGhgKBgE3184QfuL2f/4EDROECREWmEwwGTYq5u7urFy9etKmeiLij0ajVFvjebWwaT9wBJfL+fi4Gm4vIU5IZ3UQioWDwbL7K/Py8qfECgYCq1apBH2SR3Sx4qunpad29e1dLS0v6zW9+Y5G1by0yPDys69evq7+/33hB6iiGhoasI4Kfn4JhJ9LDqYZCIRvJTcS8v79vPbPgmHy/NsQEDx8+1K1bt6wDdrVaVTab1ejoqDkQZKBkgMjzgcCAlIHdLmMY19bWFAqFdOfOHU1PT2tzc9PgSrIiHGMsFtPdu3c1MDCg5eVlFQoFLS8va2VlReFwWOl0WiMjI22jy8lmqY2B2wSCxAkfHx8bdBiJRNqyRxw+wVUqlVIqlTKJdKvV0rVr1zQyMmJjEXD4oVBIlUrFOqAfHBzYaJB8Pq+tra23GtP7fasTAsP4k6XA4WHPCJY9TM97sKfoWEAWlslkDIr2nAsZoJc248h438HBQU1OTmp4eFjz8/NtqEkgELBR22RUkP786TtzEPx6yPkHh8VYHC5PMFI4RG8xvCkX4o0o2DJYtZfMeWGAfyg+EoD89t1kfU1Iq9Wy9/fkNg8CNQ/GArIcNREZEEZYOm9U56ODbhffBXEBEABkPNg810xURqbhRRX+sBJ1UBeDVJdIBXKQ94Qb4zq8WAGHwobjv72AgIDCq6r8dXg4IhKJtP1bN4trI3uF5PXQIUaJTNpXexP5EZ2TIcAT8Hv+GXGtfAbqPBpLEpX77+U7ETAviM/nPnBNEOWhUKhthgfPgO/DIb9sISDy6lKppMHBwbZRzxgWvosnx73QhmyDP1EogT50Bog+8gb2BuLx35/9yj30Zx0VKgvYkD3lZfLSeZEj9onXs98vswf5LtTegCZ44YqHpFjf95nYR7g9OnYjfOL78FqeBd+J2TH8Oz8EDJ1SZD4PZ+8FMQSd3gnyvb0M+qLrrboiS9Lq6qqePn2qTCajBw8eKBg8G95EhLi0tGSt4WOxmFUcg7/WajV9+umnWl1d1cuXL006BznMlwAOYJPTP4v380RauVzWzMyMrl+/3lZsRdEkPALZD1FkoVBQNBrV7Oys+vv79fLlSy0tLam/v1/37t1To9HQxsaGzTShnUg3CxklUFQ8HtedO3fsO4bDYT19+rRN1UKaXywWjQj2BVJISiVZhBOPxy1Lwchfu3ZN+Xxe8XjcshXa5I+MjOjWrVuq1+uam5tTs9lsI2tJqTEU1CtFo1EjgImqvLKNqB/hBAO+uoV2cGTz8/NaWVkxbk06N8QHBweqVCpteD2wAzMxBgcHzUEsLy9reXnZrtsfKAINoJloNKr9/X19+eWXBiMRyCASSSQSqtVqNuob+O709FTj4+M6PDzUV199pdevX9t9Gxoa0t27d63d/87OjtWCkQ3s7e1pYGDA+sJ1uxYWFiSdoRDhcFjJZFKzs7MaHBw0HpQ5IOVy2Qp+l5aWtLm5KUm6ceOG+vr6lMvlNDIyorm5OcsgqdkhKyGo8SiE5+okWaEybZdwJDjllZUVnZ6eWjYlSa9fvzbRCiULIBfsO4o/w+GwFhYWtLS0pHg8bnu2m8X3yOfzSqfTKpVKWlhYULPZNB4J9RZO2UPpnapGbEmzeSbj/8UvfqHx8XHdu3dPExMTFtSxF+v1utW0bGxs6JtvvlGpVPrO+PWTkxN7xm+SE0NFEABiX3EwnUIAHKcvbL3IurBzwVihofZtn7k4DmgoFLL02OPYYPUUqoH3Ykz5clw8sk1JVuULtkokw//T6pobSOZCHynSb0hzDj28BhXKVPPGYjETMPgq9m4Jfd8/CVKUflHg/1RlewcDTozBJBMAatrZ2VFPT489DzBbj/FCFEMye3yf70o9i1eRkOVJaotAkZ3CzfhI0ct9USThrC4DK3L/GPpFLU2nHJp7xz6CU5Jk0SC1QL5dDQfKO0veF+4KZ+uzHIwI2Zskg7UqlYrVSKHw29/fN9gMuIPMmbNEcAUagPye+93twiEiWW21Wrp7927bcyQzDAaDBlWTgfkxFTxfgrXOegqfVfJdpfP9z+fwfSnMhsflvBEwMIdHkvE7KEzhaT2sxmfi0OB5fL3a2y4cAuIkID+yShqp+rPX+fu/7z1zuZzGx8dNnQinxJ+dReflctngXq9gazQaBv91BnMEgdJ5tuUdCmemU7zw75q5/MVf/IWazaZevXqltbU1DQ0NmfqLBn484NHRUQUCASsk29jYMD4EmScbioaHtCrgNdFo1GaQAF8wbfDw8NDmQoDblkol6zyMQczn8/ZgOCDASOl0Wrdu3VKr1bIRtCsrK1pfX9fIyIgZaNrYQBB3G/VwCCDsvTadLOLg4ECxWMz6ZwUCASt8BM5is3BAUNCwafg9OBNaeuzt7bUR+tRPIHnt6+tTNps1h1ytVg2/9RuPjUgBo3Teop5UHGeNgeKaxsfHu7p3kvSzn/3MZO9kcpC6q6urNupheHhYodDZbJlSqaSenh5NTExoaGjIIJzXr18bD8L9pi6L50v2RVBCE8XBwUGbz0IBp3RW7Le1tWUHu16vWxaCwyVAQpaP4mxtbU3r6+vWSRhnQ1AkyWDHy8Cyf/7nf65Go6Fnz55paWnJ4FDffYJn6BEDuL9wOGz7ZW1tzQj99957zzLEer1umQtZBAaL/ZTL5drqNMrlso3qrlQqkmTNMwlqafqJjaGIGpUbQoG+vj5NTU1ZxC2dz4CPRCLWA6ybReDixzVzNjjLvmYKw0xJwMHBgWXvZEHXrl3T5OSkNdZl7xBE4CyB9Hd2dvTs2TPjyjwU5h2a50e8Soz3wgF6lV5nUCWdB0/YUd7nIuvCzuUXv/iF6vW6JiYmtLKy8h1HAE7LAUTdBTSVSCSMKOIL+07JVNpXKhXbhNRkMAZ2ZGREU1NTFkEib0WN9OrVKwWDQesFBkFbq9UMF8a5xGIx3b9/X6VSSV9++WUbtNdsNq0L8vDwsLUXv0z7DTY6OOn+/r5FF48fP9bW1pbS6bSy2WwbOQz5tr+/b61H2HzUVPAsyEgkWYZBb6u9vT2D1aTz6JqN0tfXp0wmo729PVNDYVR8pkiWAnziCUCfXXGwwOKj0aiy2WzX9+/jjz9Wo9HQy5cvtbKyYv3faKWOqAP4c3NzU6FQSNeuXVMmk1EoFLLg4smTJ9ra2rJ2OCjFvNHxGSLOZWRkxCrN19fX2/gaHCxRaDh81m/rTVg3vcmmp6etap/R14eHhwbx+FoJOLnLOJc//dM/NYShUCiY4gt4SZLVqvlCOs4qZ4n3wPndv3/fxpkfHx9bhuhrVTj37DPPF9BxnRHWfX19SqfTtrdx2KVSSaFQSLdv39bY2Jg5F2+U+/r6ND4+3ub4QUB6enouJefGuG5tbWlra6tN3cZZ8rJn7t3o6Kiy2az13uN1oVDIhgAipiGTJlPwf0pnkvwXL14Y78zyzgUH4blP7/DgjDrbIr3pfYDR4SrfBnm4sHMhKvNzApiISCEYxZEnJycaHx9XT8/Z7JHe3l5lMhmrs8hms+rt7dXc3Jw2NjYMuvB1ABShhUIhmyWBtM53+wWqikQiNofeR/JEEx56k2STGtmUpLVEOIgSKFwiBe/2cPs0l82Cag2cmYcNbEZ0gePwUYwkizpReLEQOTC+gJkYcCZexcLmJTDwRCqLegLSaKANNh3Gm/fu6enR3t6ePUvqhy4D6RSLRbVaLTPA/vlL532zqH9A4cf9hW87PT1VIpEwJVNnG3YMEYaX++j7wJFBEBFzL/0wL1/XAP/D+SELQelExoQBJNr3qzMy7WbxWdFoVJlMxoINIFDupVffebiF74lTAUrzvaw4j2Q6vn6NbAU+xffOInghW+Qekx2R/fgCzpOTExUKhbbrY19gN7j/lxXiSPrO/u2M8v3i/nEu6BpOpgMcyPsCT3tumPeB42Pvcd7j8biVUtCgEwfItWILO+XEnQ6E1/q/48zyPXz2cpF1Yefyb//2b8aXgCfTmnt2dlaZTEbPnj3T119/rVwup/v372twcFAff/yxhoeHbXRwOBzWhx9+qMHBQf3N3/yNPv30UzvgkqzFNH2qIpGIstmsenp6tLq6qlevXrUVabKhs9msZmZmVKvVtLi4aDPHy+WyHRyvOFlbWzO1CtAeNRFAYqT/xWJRuVzOnF03iyyMup/j42PNzc2ZUIGIj4yB5oEQoBxYSbZBmV0jnXMkCBBisZjy+bzGxsY0MTGha9euWcZBJTARK9E5tQ5cE85ubGxMt2/ftuabXo0yNDSkd955R8PDw9ajbHt7Wy9evFBPT4/+7M/+TNevX1e5XNbW1lZX906Snj9/LulM5kvG5A1SMpk0WGV4eNhkncjPyRx6e3t1584dxWIxPXr0SF9++WVbNogzxjBSBByNRrW9vW11PPw7GTqjDur1umXaYPH9/f2Kx+N2/ylq3draMn7FK8bYYz7a5P8v42BQeWYymbYRD3BryJ+Z5OohOYIbnAbZ/M7Ojkqlkvb29mz2TCaTUSKRUG9vrzWKpOsx95DeevAi8Ir0GCOYmJiYMFgYGDEej1vB5MLCgiKRiMbGxgz9aDQaSiaTun79uiKRiGWXdFK4LO9HVuCdizfeqDZjsZjxz4VCoc2B++cZDAZtvEIsFjMxDdAsTnR3d9cETYODg8rn82q1WtbNnVHQHvryKlefBb9JEca1S2oLINifktpgvz+0LuxcaBPhW0vTaA0y1+OoEFFAX0Q2jUbDuBbfW8sXwgELoP4YGRlRb2+v1bZ4MtVHiEj3pO+2KvD/TRS0t7fXJgmmbgevz2bwcunL1BmwkYi6fKbCRiNi8Km1T1199IQB8Co0H7GQ/npZa6c02xOuXmaKuMEXbPnP9ved36fzsm/fTedq3/6/mwUHBBEN7MHne2LSiwukcygPuIe+Yb7+gsW9933ScDjg3B4e8JkLUm9PgnL/ef78QM6y3yHwMQSdEAf3+jKLeyeprXbBP+fO4mW+G8+YPUU0yz3wEIyv8GYfEcDw3ckm/HfCkHmcn2vl330WQobtn4EXl/jyBJ/xd7s6swEf9fvX+Do96bxrxve9J0EeDp9nzrlHicf4Ci8Z5z38eZa+27HCO79Osv77VufvdGY4f2hd2Ll88cUXCgaDmpqaUjab1e7urra2ttRsNq1nEeqv4+Njg7s8Xrq2tmbwVbPZNJiMC0e6msvlND09bbMzwLlJ/eBXMPjB4NkMhGKxaGq2g4MDBQIBjY6OWgEiESfORJJGRkb0J3/yJxodHdWvf/1rffbZZ5L0nQl49XpdhUKh6wO+uLho8BMtSFKpVJuabnh4WJlMxuAwoi0vRQR+IaujczQkIXNnOMzMusCQISkcHh42J0P03Nvbq9HRUb3//vuamZnRwsKCVlZWFAwG9fr1azO0vb29qlarNvxqe3tbkUhE+Xxe2WzWjDZY/cHBgba2tqzAspv1/Plzu0cUcRJsAJegmmk0zmbzHB8fKxQK2Xfl+TMiAoflnbp0Ziyz2awePnxoRZcQ3Iw0hi/AKPtaITLM4eFhJRIJHR0daWlpSScnJ9a6nt/r7e3V7OyshoaGNDc3p6WlpTaIE14H43GZRX82sH+/fxhjAclL9B0MBq3tEg5UkhHoCHNCoZBmZmYkqU0iDrToa6oIKkEyGMDmuR/6BSIMoXAa50SbHKBXCiuJ4Ht7e42jwdh3QuNvu7hXOE8v5WW/AQNTEoFjwfly3rimsbEx3bp1y0h/OM5Wq2V89d7enp48eWLTc8lgsLH0gKMbgVd2lctlm1LLHvcjIXD4/lzitODVpHNRhOdv/tC6sHNZXl5WOBy26mbIWmoxSN+I9pnHggqFGhXG+fb397eliF6SB6zB4DEa3G1ubpqYAKPCQ/PtT9hgbHxSQ4yp5076+/t1+/Zt5XI5ffPNN6Zc48aCl0u6VHUvrf85pKFQyOaJA0H5ugAiSh6mh60gV/1/e7wceIVnAbHsiWJwbA4bUV5/f7/VxDASIRAImDHivlExXq/XrfvA0NCQrl+/LknKZDKSZDAb6qy3wWz9KhQK5jwTiYTVRRHhYnhJ+QlcOLAei4aH49Dz9z5wGB4e1s2bNxWLxZRMJhWJRPTkyRPjGfzB5HD6qBEOb2BgwJwKxbtcMwacYVDLy8v2nr5ND/Vf3TpmFpk5dSyop9jjOBcyVTIA9imvgyMFbYAnwvHwLHwG7jt0EOCAfGSzWeNRfKsh0AiClc7ed5wPWu0kEgnj+iDHA4GAOf5ONONtFzAh2T2CF4KN4+Nja4eDCpRMg+UJ+nA4bPVisVjMgk7u/fHxsbXIWlxc1M7OjnVxODk5Mak4fBYSab+PaSDL8kgDwVgnd+RhM/ZdJ3dzkXVh5/Lw4UOLyvCUqVTKNrz3nKlUSlNTUxoZGVGlUtHGxoZFir29vTakC+WEJz3x/PTNCgaDxo8sLi6a5+bB3LhxQ2NjY+Y8vNICeKNcLmt5edmupVgsKpVKKZ/Pa2RkROvr69rf39fo6Kh+/vOfW0RXq9X0+PFjHR4eKpvNanZ2tmtSGnw+kUgolUq18UG5XM42HJkCh5JNC8fhayFQwQETEUHT/RjegWifbIfP4vdQ7GDcvL4eaGNkZMSiLbIoXsPzo5Pu/v6+jVwtlUrq6+vT2tqadnd3uzaQExMTtv+I/DF4vo6m2WxaYSoZFn3dgFSOjo7MyeC8MZJ3797V7OysJiYmbMAcA6nW19e/0x1gZmZGyWSyzXmSReL0kXf7lujsTemsMLlUKikcDlvbmmQyqXq9rufPn2t7e9uUbZdZ8D4IGYDsCLhABzDoBGF8J/ZbvV43DsX3ocLZMO8GI4TDhCPDGfEZmUxGk5OTqlar1j+MERnAhzgVzhLcC9wOe4ICQYIQODEyM7LebhYwrIcsPbIgyc41z/lNcLfPkgkakbyHw2HLCuGxaGMjyc4wdS4ETUjdsY2UTgALSu1dLrCVUjvc3ul8fSaLjb3ourBz+bM/+zPTyC8uLur09NQIJUmWjUxPTyubzerOnTuKRqP6x3/8R/3ud7+zjYsaZGhoyGA16Vz6OTo6qrGxMSUSCeNqXr58qY2NDaugBwYZHBzUH//xH+v999/X4uKivvrqK9tEOCs68j5//txqJA4ODpRKpXT9+nWFQiHNz88rEDhrtvnee++Zd2b++8bGhm7evKn/9t/+W1ubirdZkKSZTEZTU1Pa2NjQ2tqaAoGAZmdnlUwmTRARDAYtAqHhIco3jyEfHh6abh7oZHx83OZtj4+Pa2BgQKlUyj7f4+RgtxCtVOijIsJIDgwMWCM8BAE4PJ5dKBQyB1WpVKyymo3r+6Z1s2ZnZyXJesQhOw0Ezvqd+SJZoMFQKKRCoWBqmmg02hZ1kQliAHp7e/Xxxx/rP/2n/2R81t7enu2/xcVFc+ZAPD/+8Y/1/vvv65NPPtHf/d3fmSAEZ4dj2dvba6uLQIUWCARs/01NTemdd97RyMiIJicnreFqpVJRLBYzVV63y8PRngMgAgcWTSaTbdFrqVQy+Tzt9Wmn4gliWgNRZb67u6tCoWAcLJkiECP2YHJyUnfu3NGLFy+siwBZoOeJ6JCB1BsI/fT0VBsbG9re3laxWFSlUlE2m9XExITC4bA2NjZUrVbbRgV3syDLsVkoZr3yi+CjkzfqdC4snAgZIVA2VAJQP0PyCB69Uo9Ah+fS399vUu032SsCUa7bOztfSyedF12+KcP5Q+uthoXh6eh8ShFbuVw2nFM6J3s9qeYJQGSGRJ9AW1Rz06adA0qRFzU0Xi3GBt7Z2TElDjeOSJpRs9J5BhEKhaxgjSxHOlfGIP3zleBEBd0sHgyHDELfk8qe8Mawe5JOOodcWBgrjLi/V50jjdlIjUbDIEwaJVL1i+HrTJu9oIHPGRoaaiNy4deazaa1d/e/061jls5UhM1mU9Vq1Xgqnh2f40lOz0mRoXCocSZkPRwu3+iT6200zsb3Hh0d2XhuX3SJwfWCBWAEnEpnJbon//1zwUDTrZgiOYwwKsZuF2Q5holiTa7Hy5LZW/7eSrJ7DgzIvsbhwpuwT+EQyFawB9wnAg++L3sVBILs1Bs2BBkIIQiQ6CxAlk7E7eGcy9w/Dxe+qauIN8A+A+gUSPB3PtDDqdRqNVPf4dQ9lEx9kA9UPPfDf3slKEhO57X5DIzlv8eb1ts45rfqLYact1wu69q1a/roo49Ur9f1q1/9Stvb220FWVTUx+Nx6/lFFEK0fXp6ajJDNvrU1JSmp6dN/tnX16fr168rmUwaJ+EJ/d/85jf69NNPrU2EN9BPnjzR5uamDWGikK+3t1enp6f6+uuvNTQ0ZDLbWq1msxEWFhbUaDQ0MTGhW7duqVKp6Je//KVarZb++3//7xe+wSwcydbWlt1D5jdATB8dHbXBVoFAwBytj3q8EoUNBa48OjpqXVWnpqYMRvMKsZOTE4M2mUeyurpqBCFdZanUPj091fLyspG7DG5D2UKaXSqV9Pr1a2UyGf3kJz9ROBxWoVBo6wPVbdT4ox/9SKenZ6Nd5+bmFIlEjPRlxDYHBliJ8blEmFTVUzdEJEgHhqGhIeXzeauzQshBlwPek/G6x8fH+vTTT/X1119rd3dX0hk8QeDDLHmgx56eHk1NTSmRSBis4TmLg4MDraysqNVq6euvvzannkwmlc/nNT09fSnjCNHcap1VlOdyOT148MD61HFfkHoTeVOHFQ6HlcvlbD/DNcClIhFGQEGnX+a886wwmGRPc3NzWllZUU9PjxVFEtwRJMHbhUJn4wDS6bQFoAhGKpWKbty4oYmJCTUaDRvQB1QK79Nt9sf+IjPxRt87Dw9DIZbBoZLN00iW4Hp/f9+QA8ZKe9Ke4I5shgBROu+qDhcUjUY1NjamWCym9fV1QzsIsAm0Ool8L6zy/+b5yLdBHi7sXDxxCSyVSCQsusVxkKp5bDkajdqNwEPz/xDYSFaRfZL6SjKcNBaLKRaLmZSx1Wppa2vLeoUBifG7NLD05BTvz0OCe/DFSh77zeVySqVSKpfLWltbuxSpCt5NNEukRgElDsBLC71aw5ObXIeXlhItejKZyNBnRkjGUdHRyoI+bd6RkW5TiAhch3HnsNHqByKdeeUYEKTl3RpHKsfBlhEueGkv98NzRcPDwwY/wb1wyDiIOCOcjd+PzWbTYMV0Om3t8okUi8XidxpyElF6zJ3odnBw0PrW4ZAghz05iyAFMt0LNbpdXLN0PoMJJSYOBGjGOxccks/0yILq9bohAL6NvnSuFsPREDwRQHGf2H90A/b7VJJBtNI5IY2z8DwCvO/IyIgFm9gqzjnP5zLLZ+Rckye6O2XKPkvxHAlGH94KBSIdABDNgKQQ+HUGJZxXPtuXF2BLvErOZzJvchZct7/+f1fn8rd/+7eSzjDQiYkJpVKpNtiKKLZWq6lQKOhf/uVfDAvnB/kgRT83btzQrVu37CBHIhHduHFDiUTCCvakcz7m8PDQ1BOoJnhYXg3GnAlu/MHBgTY3NxUOh3X79m1NTU1pfHxcN27cMMKKjAIDFo/HFQqFzHisrKxYl4Ju1ujoqFqts6aB9OUCWojFYkqn09Zyv7e3V/l8XuFwWFtbWyqXy1bvgzPi8OOg4LR2dnZsk46OjlpkJJ0PxOL3IEBRoVBzcevWLQ0NDVm7FAhwDMnBwYEVuwF1YCwowHz16pVliEBEncqVt1l///d/r2bzrI/YwMCARkdHNT093QbL0IOuXC7r6dOnGhgYUC6XUyKRUCwW082bN3V8fKzFxUXt7+8rlUppcnJSiURC9+/ft6mmJycnVp8B7MDhJfKk2A2jDDQTCoXs37h3vpBtd3fXjHwikbD9ByRGD7OpqSlJZyrDvb09LS4uant7u+v7J51l8nyfGzduKJvNWpZRLBa1vr5uQg2yCBwQ4gMfZJIBoeoaGRlpaxVPBt7b22tyY4JPHBTCFN6Pf0OCDH+FDQgEznoWInJgfDFoR61W05MnT8wBcLYPDg6Uz+c1OTmpUCik+/fvv/X943u9CfryC0fGv3FWQ6GQKd3gTpaWlqwvHvuAFlUUtoLycL5arbNZVIzJJlDm2mq1mh49eqTe3l6zWd7Z+UDTw4XeCfF8QqGQwYwEpBd1MBd2Lv/wD/+gcDisBw8eaHZ2VvF43OSAGDY/3/nLL79UJBLRvXv3NDk5aeS6hwxyuZx++tOfWurrIxLwXI/l+nb5RP6eYILDicViFlWTYlMwOTQ0ZMqjYPCsMvjZs2eqVCoqlUqqVCoaGxuzcQKLi4sql8sqFAoqFotvRWj5xfTByv8/npTFw4vH46pUKgb9jY+PmwqmWCya0UKfDt4PSQpmTrV/JBLRxMREWzfd3d1da6HPRqKl/+HhoWWZ09PTSqfTKhQKdjDJRuHX+MyenvPhb0Rh1WpVKysr1putr6/vO73M3nb96le/MvKe2qfx8XG1Wi1r/OlbkLx8+dKyt1QqZfL2o6Mj4+Di8bgmJyeVz+f14x//WLFYzO4pBo97xffzNUmQsLyWXndcI1md5y6QswPZNZtNGxhF5hyNRg1+KpVKxut4crub9fLlSwWDQWUyGU1MTCiRSBgnValU2pwLzUd7enqMCKcC3HMNGHyq9mm746PfSCSiVCpl39/DaKgMyei3t7dtr/f29lrNFlASzgWlJZ9Fk9qXL19qeXnZREOnp6daWFgwhOMy2R8ZGc/b8y181zf96Tkpul9T77O6uqpvvvmmTb1FCyJUbt6RwV3TuQTnwnBBYFlslc+oOq/Hw3edzoWAlU4DdLt4mzqhCzuXO3fuWAS3vr6uVqulfD5vEAUNKIHCGIWMJM63OZFkhw/DRdsTZmcQXYOzE/miCMLYsZCfYniGhoZMOdJqtTQ9PW2Y6/b2thmKYPCsMLTVaml+ft4ODFXmyEej0agViXWzPBzUbDYNmx4cHNTJyYkViCWTSYVCIe3s7EiS3TOIXiJoYDwim4ODA9uQRC8MQ2OD8T5sTg4GBC9wzOrqqkkgfT+jQCBgbc+BhDisBAQYXRqL0iYEWWW3ztnDCgQLtJPxhDFyZbgTLwCBb0EUwD4qFov64osvTBVHp2Rkt757NT2iMIhElOw9oDafsfN33GvOAIq3fD6vSCRijR8pjJPOO3yDDlxmwXkBscCjwCslk0lrNwS8xFnc2tpqqw3CMFF+EIlErIKcDIasFrtA1A1kQ62VV0xNTk7aPiKoBNbyQhagYc4EWT0wriT7PEZjM4OmW2gW48+5ARnBuZKReijUk/1e7EEA4zvFE8wAR3oH5sUBwGnlctmCHvradX4++8ZDeZ1Beefv8Z241s4x3z945vKXf/mXOj091f/9v/9XX3zxha5fv65UKmVeOJPJWBo3NDSkDz/8UOl02i6kXC7r0aNHJtVEabaxsWFReDAY1J07d5TP582TU1/AHAx4AgqIiJ59P6mpqSn19/erUCjo1atXyufz+tM//VP19/drZ2dH3377rT3YbDarv/qrv1I+n9evfvUrBYNnzQ83NzctQjo+Ptbk5KRmZ2e7jnr87zWbZ73MHjx4YJFHoVCwMQCVSkVfffWVOQfEAEAOVDMfHx9ra2vLOCbuBdHg2tqaGbNGo9EmBcehgN1Ksjknn376qeH9fs4Lhz8ej+v58+f68ssvzUAgPMjn86pWqzbaGiOP9LpbWBF+xSvtMI5wAfTGisVi+vjjj5VIJFStVnV0dKRCoaDnz5+3yWchjTc3N/XLX/5SkvQ//+f/1E9/+lMbjVyr1Wz/zc3NaXFx0SJ9DGa9XtfY2JimpqbaFEDsMfgaSVpZWVG5XFapVFK9Xte1a9f0X/7Lf9H4+Lj+6Z/+yfbb06dPjSeUzvjGy8hoJRlZTr+8aDRqXTOGh4d1+/Ztra2tWc+4yclJDQ0N6fnz51Z/hQMn0k2lUrpx44ZJtk9PTzU7O2sqRSTiZK44MjJ0SabqvHXrlj766KM2PoVqdG9UPT9UKpUMzhwcHNTz588tCCXQePDggXVKh3/rZvlmkr5CH+cCb+adhc8OCIyBl4HJcdhc1+8rNAYBajQaWlpakiQT8qCYk86zk6GhIRvSiJDCZ0lwL51lBdL5iIFyuWwB2dtkzxd2LihnkKj6/kqebMbbdmJ6LGSPqJCoHgeTZIiTdy7g/CgmfMU9nw2MFggE2mA2biKdbSk04uF7Us7LJKXzAiJkkchIu1kYfVQdvoCNH0/CUR/h8VL+nR9/XznwvB4D6IsEPbyDioxnwqYiM4AUh8CFJPRSU+4h+4HrAzbjGXpittuDjWFhc/sN3pn2szwvhTECOiWihlcCrkL9hIjh9PTUMhc4FBwckZ1v7Md99tJn4Fj+/U17mH0B1OajTy/wuIxz4fcRlnCWef5edQTH5hEEH6n7a+J9PSzJdyMC7zRIRMtS+7RD7gHOiczEE8revnglJHvYG37/3nz3bpd3FHznN/34zMg7DUm2Z3z5gX9f6dwx+H3daUd94abnPb1wofPcdwoMOs+RtzP+2nh+bwOJSW/hXPiwwcFBZbNZK3QMh8PWxoH0q1gs6v/8n/+joaEhG9mZTCb1R3/0R22Ge21tTY8ePVIikdDDhw81ODio169fm+wV50AEXyqV7HBjsLLZrLLZrAqFgubm5pROp/Xzn/9ck5OTWlhYsOaDRBO8//j4uFVD//rXv1YkEjEJZm9vr9LpdBuURwV2t86FbKzZbBp2++rVK2s/k0wmdXR0ZLNUMCoYrmw2q/v371sED39TLpcVjUY1NTWlSCSi1dVV7ezsqFAo6Ntvv9XQ0JAePnyoVCqlvb09bW5umtGQZNj6ycmJGVoq0vv7+61Xkcd6T0/PugDn83lJMngunU4rkUiop6fHsHnankQiEf3oRz/q6t5JZ+1kuHfValWZTEb3799XIBDQ8vKy4cFEu//v//0/g6qobZqdnbVMjdd99tlntk8HBgb0+vVr/d3f/Z09C4oCBwYGjC8j4AkEzgpv6cj8+PFj9fX16datWzbieHd311rch0IhLSws6PT01CruY7GYFhYWrLaBWprx8XE1Gg0bTEX9w2UWgZOHUvL5vAVnZICITz7//PM2ZSBQFs4SuJv+V8CIlUrFIEKCAYpxJbW1jYcDYjT6y5cvNTAwoOvXrxt/Q2sp3p8xyQQ6yPi5/mw2q0gkYlXtGxsbWl5etv0QCAT08OHDt75/GGggeDIysnqyK/6NIMFXyncS4p2/6yEz73SAn5vNptVUeRgNaHpgYMAcD/eFLJtsCcUi2aR38mSUUBXeXnc6yj+03lqKzMxqYBBIeLB80tbFxUUbDDQ+Pm7tGLjBtVpNc3Nzev78uSYmJvTw4UP19PSoWCxaXzIMKRGkn83CFwUOK5fL2tnZMRIQEtcXYYGj7+zsGLbearW0uLioWq1mm4CDwHAmMijkuN0sCH3SSziD4+NjDQ8Pa3x8XOvr6wbFYASIuoaGhjQ2NqZIJGL3D3nv0NCQcVurq6sWiVcqFY2MjOiDDz6wgWqePJVkbb4Zhcwiwh8aGvpOZATHMTIyYvUKROBwSPSOg7PJ5/M2tqCbBafHweN+SDJolYNwfHyspaUlBYNBZbNZxeNxDQ0NWZcBos5yuayVlRWbiR6LxTQ/P6+NjQ2TsuIEwuFw24x3ImoGfwHbDg4O6vr165YZYUhp44+BQCVIg0W4PWBLnBN1SPBhl1md9x44mYJD5MkIb16/fq3T01NNTk7aVFggK+qcENhQXuBl7jh79o1vJyPJ2p6Mjo5qcHBQu7u7pgKbmJiQ1C7j5dkj3pDOx68DOfGd6IAAf1UqlawIu9vsj+9Clud5EbIZJOM+2yAjg6D378Xv8bvSuVS+89n19PRY1uwzP+4nzthLjbGbPqD0TohrwJHxjP01vgkluMi6sHPhQFIBvre3p9/+9rdtCq94PK7p6WnD5oLBszb2r1+/tosGN6/VaoaH9vb26vnz56b0Qts/MDCgw8NDzc3NqVgs2s0ZHBw0BVomk9HIyIhmZmbsYCwsLGhnZ0fr6+umZgGPRxGFVBmii7YhjGNeXV01hzM2Nmbz7rs1jqurq2o2m6Y6GxgY0P37961P0IsXL1Qul025xWYCVtrY2NDXX3/dZhzr9bpyuZxlj6ippqenVSqVDP569eqV3T8gC6JGNPQU9fHZvs4IR0IBJqINZs74ZnlkejgDUmqee7f3b3Jy0ow18vDHjx9LkimpUN7Bd/iAgkid68ZhT09PKxKJ6OnTp2b8UPIgPZ2fn9fCwoJ2d3eVTCbbutzSNoVoGfXX7u6uKpWKcXgUs1Eflk6nTW5MYERQw+t59kToZGDdrng8bsWjGBDauHSqhcLhsMbGxsxwMopYOq/XAirB2AKdcw/C4bA5V4Kqnp4e3blzR9L5CAoUhdxzygeAzan1wDDT8w1RDJJ3hAiUSTD87ujoyCLykZGRrp0LRtYruMhIgGB5PpFIRDdv3rRyBjJrD1lJ7VCxh5w65cweauQzOEvemfisBscFp8p7+rpA6RzK5btRytAJZRLoXnRd+JVEN8zsKBaL1jPsxz/+sfW0unPnjvb3960JIpI4XzTEw8nlcvroo4+0vb2tzz77TMfHx/rpT39qEToGisPNPHlghv7+flOAJJNJG7f66NEjlUolS50DgYCpv3CCODCweE+a7+/va2FhQfV6XZlMRslkUiMjIxoeHu56Y7569UrNZtMq82/evKkf/ehHCoVC+uabb/TixYu26nHgG2ofmFyIMgaDdu3aNdVqNW1tbaleryuVSunatWs2j71Wq+np06dqNBqKx+NW+0I0TlEr9S6Q5ERbPPt0Oq1QKKStrS3rITU8PKxgMGhOl/egDsSrATFI3RrHmzdvql6va319XaenZ9P31tfXFQgEzGn4bIpxscfHx3aYMII4hdHRUcXjce3s7Oh3v/udTk5O9ODBA01PT0uSVdJ/8cUX2t7e1uTkpCYnJ9uKgDH6IyMjunfvniqVin7961+b2gvpOBXo4XDYHMvt27dVrVb1ySefqFKpaHx8XLlcTtvb21peXlatVrMuFcPDw4rH45fiXNLptBqNswF4dH3Y29szCAkFIfAj3TNor+R7pmH8cS79/f127yGBOfMnJydaXl7WwcGBPvroI3344YfWpaLZbFq2Njw8bOQz2dzOzo6KxaIFBUhwqWVjPDCQLueCYJazVK1WrXtFt3sQ409mhgOT1LbPa7Wa0um0Hjx4oGg0qi+++MLs4Jt4DpzDm5wLv8N+60QRvGrNB1Je0Ybd9cGk55pxTASAKEx5f88dYhMust66UZa/mHq93pY2+S/KA/QSO18r4MlkonAPd3nCjN/xVbqeCPc3MRQ6bzXvvfybCDKWl/n5KIKozX9Ot4ebTcL7SmqrHO6M8rkero8MS5IZSn//OjeUr+735PH3FX75NJv1+whF/xp/3zrJyc7/7pZQRUDAZ/j910mK+ut+033vvHZPXrP8M0eYwP31+9KTpGSV/l7y741GwyJNnpkn6Duv7U1k72X2H9fYKbLpNHadr/9Dr/u+c8XrPanP8/L7099Trs9H7fwu95Xr8nbGix/8dfvn26nuuszqhIk6nQX/78UOv+89Lrsu8jw77d338Sd/6Lre5t4FWj/kt7xaV+tqXa2rdbUkdQ/gXq2rdbWu1tW6Wt+zrpzL1bpaV+tqXa0ffF05l6t1ta7W1bpaP/i6ci5X62pdrat1tX7wdeVcrtbVulpX62r94OvKuVytq3W1rtbV+sHXlXO5Wlfral2tq/WDryvncrWu1tW6WlfrB19XzuVqXa2rdbWu1g++/j/gjjbJU69CrgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -569,7 +569,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 200/200 [15:59<00:00, 4.80s/it]\n" + "100%|██████████| 200/200 [16:04<00:00, 4.82s/it]\n" ] } ], From 0644cc101b3521368ca9cd159f7196562e3f7d6a Mon Sep 17 00:00:00 2001 From: Shubbair Date: Tue, 30 Jul 2024 19:50:02 +0300 Subject: [PATCH 29/38] Updating MLX Notebook --- gan/playground.ipynb | 96 +++++++++++--------------------------------- 1 file changed, 24 insertions(+), 72 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 2fda8980..2ec46825 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -77,7 +77,7 @@ "source": [ "class Generator(nn.Module):\n", "\n", - " def __init__(self, z_dim:int = 32, im_dim:int = 784, hidden_dim: int = 128):\n", + " def __init__(self, z_dim:int = 32, im_dim:int = 784, hidden_dim: int = 256):\n", " super(Generator, self).__init__()\n", "\n", " self.gen = nn.Sequential(\n", @@ -104,21 +104,21 @@ "Generator(\n", " (gen): Sequential(\n", " (layers.0): Sequential(\n", - " (layers.0): Linear(input_dims=100, output_dims=128, bias=True)\n", - " (layers.1): BatchNorm(128, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", - " (layers.2): LeakyReLU()\n", - " )\n", - " (layers.1): Sequential(\n", - " (layers.0): Linear(input_dims=128, output_dims=256, bias=True)\n", + " (layers.0): Linear(input_dims=100, output_dims=256, bias=True)\n", " (layers.1): BatchNorm(256, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", " (layers.2): LeakyReLU()\n", " )\n", - " (layers.2): Sequential(\n", + " (layers.1): Sequential(\n", " (layers.0): Linear(input_dims=256, output_dims=512, bias=True)\n", " (layers.1): BatchNorm(512, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", " (layers.2): LeakyReLU()\n", " )\n", - " (layers.3): Linear(input_dims=512, output_dims=784, bias=True)\n", + " (layers.2): Sequential(\n", + " (layers.0): Linear(input_dims=512, output_dims=1024, bias=True)\n", + " (layers.1): BatchNorm(1024, eps=0.8, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layers.2): LeakyReLU()\n", + " )\n", + " (layers.3): Linear(input_dims=1024, output_dims=784, bias=True)\n", " )\n", ")" ] @@ -151,7 +151,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -196,7 +196,7 @@ "source": [ "class Discriminator(nn.Module):\n", "\n", - " def __init__(self,im_dim:int = 784, hidden_dim:int = 128):\n", + " def __init__(self,im_dim:int = 784, hidden_dim:int = 256):\n", " super(Discriminator, self).__init__()\n", "\n", " self.disc = nn.Sequential(\n", @@ -224,21 +224,21 @@ "Discriminator(\n", " (disc): Sequential(\n", " (layers.0): Sequential(\n", - " (layers.0): Linear(input_dims=784, output_dims=512, bias=True)\n", + " (layers.0): Linear(input_dims=784, output_dims=1024, bias=True)\n", " (layers.1): LeakyReLU()\n", " (layers.2): Dropout(p=0.30000000000000004)\n", " )\n", " (layers.1): Sequential(\n", - " (layers.0): Linear(input_dims=512, output_dims=256, bias=True)\n", + " (layers.0): Linear(input_dims=1024, output_dims=512, bias=True)\n", " (layers.1): LeakyReLU()\n", " (layers.2): Dropout(p=0.30000000000000004)\n", " )\n", " (layers.2): Sequential(\n", - " (layers.0): Linear(input_dims=256, output_dims=128, bias=True)\n", + " (layers.0): Linear(input_dims=512, output_dims=256, bias=True)\n", " (layers.1): LeakyReLU()\n", " (layers.2): Dropout(p=0.30000000000000004)\n", " )\n", - " (layers.3): Linear(input_dims=128, output_dims=1, bias=True)\n", + " (layers.3): Linear(input_dims=256, output_dims=1, bias=True)\n", " (layers.4): Sigmoid()\n", " )\n", ")" @@ -297,7 +297,7 @@ " \n", " real_loss = mx.mean(nn.losses.binary_cross_entropy(real_disc,real_labels,with_logits=True))\n", " \n", - " disc_loss = (fake_loss + real_loss)\n", + " disc_loss = (fake_loss + real_loss) / 2.0\n", "\n", " return disc_loss" ] @@ -357,7 +357,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -423,7 +423,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -480,12 +480,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 0, iteration: 468, Discriminator Loss:array(1.32117, dtype=float32), Generator Loss: array(0.462009, dtype=float32)\n" + "Epoch: 0, iteration: 468, Discriminator Loss:array(0.657422, dtype=float32), Generator Loss: array(0.469956, dtype=float32)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9WY+cWXYdgK74Yp7nOSNnJpNDcSqyukrqrio1JLUMy4IhWPAAPRiCAL/6xX/Cf8APBvRqwYAAw5IMCN0lqbtL1c2ayOKQzGTOkTHP8zzch+i180R220oGeXGBizxAoopkZkbE+c7Ze+21195bN51Op7haV+tqXa2rdbXe4dL+f/0GrtbVulpX62r9/9+6ci5X62pdrat1td75unIuV+tqXa2rdbXe+bpyLlfral2tq3W13vm6ci5X62pdrat1td75unIuV+tqXa2rdbXe+bpyLlfral2tq3W13vm6ci5X62pdrat1td75unIuV+tqXa2rdbXe+TJc9hv/23/7bxiPxzg6OkI6ncZwOESn08FkMsF0OsV0OoXD4YDL5YLP58P9+/fhcDiQzWZRq9UwGAzk+00mEzRNQzAYRDAYRLVaxZMnT9BsNtHtdjEYDDCdTjEej+FwOHD79m14vV5kMhlks1kUCgU8ffoUAPAnf/InePToEc7OzrC3t4dOp4NisYjBYIBoNIpQKASj0QiLxQKz2YyNjQ0EAgF88803+Oyzz2CxWHDnzh14PB44nU7YbDY0m02k02m0Wi3s7e2hVCrhD/7gD/Anf/InMJlM+PDDD994o//yL/8So9EI3333HV6/fg2n04loNApN09DtdjEajRAKhRCLxTAej9FutzEcDnF2doZyuQybzQaPxwOdTnf+8AwGGAwGWK1WeL1eGAwGFItFNBoNGI1GWK1WtFotfPHFFyiVSrhz5w5u376NTqeDTCaDfr8vz+/27dv4wQ9+gE6ng5///OcoFov49NNP8dFHHyGfz+Pbb79Fv99HOByG0+lEvV5HqVSCwWCAz+eDpmn49ttvsbu7CzZ90Ov18Hg8sFqtuHv3Lj766CMYDAbcvXv3jffvv/7X/4rJZIJ0Oo1CoQBN02AwnB/f6XSKWq2GcrkMr9eLR48ewePxIBgMwu124+XLl/i7v/s7tFotDIdDjMdj3L9/Hw8ePECz2cTe3h56vR58Ph8cDgeMRiOMRiP6/T4ODw/RbDaxurqKlZUVAMB4PMZ0OsVoNMJkMoHNZoPP50Ov18PBwQGazaacOYPBAJPJBJPJhKWlJbjdbqRSKbx+/Rrj8Rh6vR4A0Gg05OfcbjfG4zGOj49RrVbx8OFDfPrppzAYDPjTP/3TN94/APg3/+bfYDKZYDAYYDgcwmw2w+VyYTKZoFwuo9PpYDgcot/vw+v14uHDh3C5XBgOhxgOh0in03j27Bl6vR4mkwkmkwni8ThisRiMRiNMJhOMRiO2t7cRj8eRyWTw6tUrVKtVfP311yiXy7h16xZu3LgBi8UCr9cLTdNQr9fR6/WwtraGO3fuoFKp4K/+6q9wdnaG7e1tbG5uotFo4Pj4GABw584dRKNRZDIZHB0dYTAYoNvtyjMBgHq9jlQqBYPBgEePHiEejyMQCMidW2QP/+Iv/gKj0Qg/+9nP8PTpUwQCAWxtbcFkMsk9slqtsNlssFgs8Pv9MBgMqNfraLfbAACdTofRaIRCoYBut4tYLIZ4PI5Op4OTkxMMBgN4vV44HA4Mh0OxmzyDa2trWF1dxWg0QrvdlvM3nU5ht9vhdrvRbrfx7Nkz1Ot1fPzxx/jwww9RLpexs7OD4XAoZ7BQKCCZTGIymcBoNELTNNjtdthsNhSLRbx69QrD4RB2ux0mkwk3btzA3bt3YTQa8W//7b/9Z/fr0s7l+fPn0Ov1CIfD2NzcxGg0Qq/Xw2AwQC6Xkw86Go1QrVbx7bffQq/Xo9vtotfrwWAwwGg0wmw2w+PxwGazQafToVaroVKpoFqtotvtYnV1FaFQCKPRCOPxGDqdDpqmodlsotfrYTQaQa/Xw+12YzqdIp1OQ6fTyYE3GAwIBALys+VyWT6DXq/HcDiEx+PByckJ6vU6BoMBWq0WjEajHAA6zvF4DLvdjslkgna7jRcvXkCv1y/kXEqlEgDgvffew4cffohqtYqTkxOMx2NxgAaDAb1eD91uF9lsFr1eD41GA4PBAEajEePxGFarFUtLS3A4HBiPxxiNRhgMBqhUKhiPx7BYLAiHw2i32yiXyxiNRrh58yam0ylWV1exvLyMVqslhzOVSqFSqYhx0Ov1cDqdcDgcSCaTsr+apsnzarVayOfzOD09hdFoRDQahclkwng8hs/ng16vh9FoBAB0Oh00Gg10u10xSIss7p9OpxNHarFY5LU0TcNgMECv15P/LxaLODs7w2g0QrfbRSgUQiQSgcfjgcVigdPpxGg0wnA4lPNmMBhgs9lgt9vh9XrRbreRTCYxHo+Rz+fRarVgNpvhdrvlfLVaLXi9XvT7fQAQkNLpdAQkdDodecYAUK1WUavVoGka/H4/zGaznFGLxQKPx4PpdIpOpwOLxYJGo4Gf/exnALCwc/H7/dDpdPB4PHA4HKjVajg7O8NwOITT6YTL5ZLv1TQNuVwOhUJB3vdwOITX64Ver0cikYDb7YbdbofD4UCn00Eul0Ov10Mul8NgMMBoNBIw0uv1UKvV4HQ60Wq10O120el05IwMBgOMx2P0ej0xaPF4HOVyGZlMBuPxWBxio9GA0+kUcKTX6+FyuaDT6eByuWC329Hr9bC+vo7JZCI/Y7fbMRqNoGmLETY/+9nPoNPpEI1Gsb29jcFggEajIcDaYDCg3++j0WgIkNY0DeVyGfV6XQCf0WjEysoKLBYLhsMharUaxuOxOHqea9473hnuD21hoVDAeDyW92e32wWo2mw2GI1G5HI5/PSnP8VkMsFwOIROp5N9z+VyODo6gl6vh8/ng9FoRDqdRrPZhN1ux/r6utgk2t1utyvn/J9bl3YuR0dHMBqNuHbtGh48eCBGrdPpYHd3F8ViEfV6HZVKRQ4YN0Wn08FutyMQCMBkMsHhcMDj8aDRaKBer8vXcDhEKBTC7du35dL3ej2JIvr9vjgNl8uF0Wgkr2uz2eB0OmE0GmGz2aBpGmq1Gur1ujwUvV6P6XQKl8uFXC6HVquF6XSKbrcLi8WCTqcjxkmv18uDBiCIlCjzTVetVoPRaMSDBw9w//59vHr1CplMBr1eDx6PBy6XC+12G61WC+12G4VCQQ7oZDIRx61pGmKxGMLhsBgvOqrBYIBEIgGv1yuX2WAwYHNzE263G8FgEIFAALVaDdVqFXq9Hv1+H+VyWSIil8uF7e1tOBwOPHv2DDs7OwgEArh16xYsFos4pnQ6jcPDQxiNRoxGI3HCLpcLJpMJNpsNo9FI3qMaJS2y6vU6AIhTMBqNcDqdErmZTCY5a51OB6lUShxDsViEz+fD6uoqHA4H1tfX4fF45Nxxb+lczGYznE4nQqEQGo0G9Ho9xuMxyuUy8vk8nE4ndDoddDodstksSqUSOp0OzGYzzGYzvF4vjEaj3I92u418Pg+DwYBQKAS73Y5Wq4Vmswmz2SxGZzqdQtM0WK1WeDweTCYTcUqVSgVHR0cL7x8AeDweaJqG9fV1RKNRHB8fC/L3+/2w2WzirDudDs7OzjAYDOB0OmG1WsUA2mw23L9/H9FoFMAsaiyXy+JcqtUqer0enE4n/H4/nE4nhsMh2u22fE2nUzHM/X5fHHCj0RAHb7PZ8Pz5c7x69QoWiwU+nw92u11+R6/Xkz2z2+0CdILBoIDffr+P09NTNBoNsR+L7uE333wDs9mMP/mTP8Hv/u7vIplM4vHjxxgMBhKtEGyodiKfz6NarcJqtcLtdsPpdCISiSAYDOLs7AwnJyfQNE3sFjBz7vwajUYAgNFohH6/j06ng1arhWKxiOFwKI6IjpkAxWazoVwu4+joCA6HA9FoFBaLRfatWq0ik8lIlG6xWHB6eopkMonNzU08ePAANpsNhUIBrVZLWJbLOudLOxdeAiLYwWAgBrBYLKJcLouHAyCXZTKZyANtNpvo9/s4OTmBzWaT302DP5lMYLfbYTab5eHQM/MQmUwmDIfDuc3nhbBYLHN0ier9SU9YrVY5iHxvNC5EtN1uF5VKBaPRSIy91WqFy+VaGPV0Oh0YDAY0Gg1Uq1X0+33Y7XZomiaHgsZX0zRBQgDE8PNSlstlicJ4MS+ieLPZDIfDIYdOp9OJ8Wu1WvKsotEonE4nJpMJut0uAKBSqaDf74vT0DQN1WpV0OtkMhEnA8wMf7/fRzweRzAYlPfb7/fFaZfLZXz33XfQNA0PHjx44/2j0ycNo9KytVoNk8lEXncwGKDdbmMwGIiz0+v18j5J9dBZ01GNRiM4HA7Zj0wmg8FgAJ/PB4PBgG63i263C71eL1EuKQUAQs3wrhDt8WwaDAYxpjqdDjabDWazGSaTSSIxnq9msyn0aK/Xg91ux7Vr1xY6e1ydTgd6vR4mk0lAhs/nEzqsXq8Lfdfr9QDMjJzX60UgEECn0xGQVKvVAECoP03TsLy8jOFwKK9HWpeMh8lkwvHxMRqNhtw9YGZbeM54B3hfI5EIRqOROBze/0qlIudVp9NBr9fL97jdbtTrdZTLZfT7fej1eon0i8XiHLX8Jmt9fR0mk0mi1ul0KhTjYDCATqcT9oQ2EgBMJpNEhYzgU6mU3EO73Q6DwSCghSCX6YbJZCLRutlsFlaFTpt2FYA8X9oPvk8CbPWet1oteW1gZmNXVlaQSCRgt9tRr9fRbDbRarUwGAxQKpXk3F9mXdq5EC2azWbodDo0Gg3s7e2hXq/j6OgI1WoVJpNJLovb7YZer5fNJ9UzmUywv78PAIhGo1haWsJ0OkU4HIZerxekMxgMxMHodLo5yoKhLh0JnQ6NPw8oN5fIkJfK5/Mhl8uJY+n3+xgMBrh+/TquXbuGs7MzPH78GL1eD6VSCZVKBQDmLv+brkqlAoPBgHQ6DYfDgVarJRf27OwMjUYDDocDbrdbqD0aLr1ej0KhIJGC2+0WRE1U7XQ6AQA2mw0GgwF2ux3hcBjD4VAcGnMNzWZTIrq7d+8iGAxiZ2cHv/jFL1Cv1wU9A0AwGMRwOMTJyYkYhPF4LOH3aDQS9HP79m189NFH6Pf7qFarQs11Oh0cHR3hu+++AwD8+Z//+RvvHw3f+vo6Pv74Y2QyGXz33XfCrVerVTkrXJqmIRKJIBAIIJVK4eXLlwAgNJDP54PP54PVakUkEsF0OkUsFoPf70c2m8Xr16+haRrW1tbgdDpRKpWE4kgmk+j3+wIEAEikOBqNYDab5b8AJL9AilXTNInkyWlbLBZx3NlsFv1+X/IR29vbuHfv3lye6U1XuVwWQ07efnV1FZVKRXI7FosFVqtVImaDwYDl5WVcv35dUPBwOEQqlcLp6alQjU6nU3Jq2WwW1WoVh4eH+Oqrr+D1evFnf/ZnuHbtGv7u7/4OBwcHQlXq9XoEAgF4vV60Wi3UajXo9XrYbDbJ4W5vbwutQ7aiVCoJ4uaX2WyGz+fD0tISer0ejo+P0ev1sLS0BK/Xi2azidevXy8cuXzyySfQNA1LS0vQNE2cS6fTgaZpEhlZLBaJ2ieTiUSitVoNmUwG0+lUzvPKygpWVlZgs9kQCASg0+lwdHQkgIkOmLm+XC6HXC4Hk8mEYDAo4KpYLAq4sVqtcDqdAqqm0ymGw6EwNcViEe12W9gk2rTxeIyPPvoI9+7dw+HhIf7+7/8e7XZbwH6tVhN6+jLr0ieVUQA3jSEn6QRuBA07Hzgwu+RMXJLiUSMafg+dUavVEiPGnzMYDMLLAhAkqCYS+R5Jx6nOh7+fSXC+F74GuVuLxSL5DXKU/ByDwWBh50IEQqqPe0cnaDKZBO1c3BsaTH528tVmsxkWi0WQCSk+Jpr5O00mk3DgNFbT6RR6vR5ms1koCLPZjPF4jE6nI7ytxWKBTqeDxWKRPaEBZRRLZH7xGVC8YbPZ0O120W63F865qM+PSJ/UFBGeSh1SNML3qNfrxSDwc/R6PYkG+fvoOEnRMFnLZ8DIkmeCDh6Y0Rb8Pu4L94R0rvq+1cV/I1WpomEaCb7+oovIdTwey93ge+S9HAwGMBgMkvjnv/G82Gw2uYfj8VjyDrzjjM543nnuVOEPF40WI2r1fvHnuS98Ztyri/vHs8FnqN5rOlQCokXPIJ/1ZDKR+8uzxf2bTqfClgDn51ZlWvi9AGQvmZ/hc+b9UZ8V/8vXJDvEc8M9oEMhOHU6nXOvzf3l6/KzqYwHHeRwOBTbwN+r5nn+X+vSzoWbdXZ2hm63i+FwKPkNhmy9Xk+8OA0WP1Sn04HH48FoNEKj0ZDkoMViEe8/Ho/x9ddf47vvvoPL5UIwGITBYIDH44HH48GrV6+QTCZhs9mwvr4uvPZoNBKHAEAQutlsluQ+36/FYpEQnPTEYDCQCIt0S7FYRKvVQjQaxcrKitAGi15uq9UqFFi5XEa1WkUymYSmadjc3ITX68XBwQFevnwpqI50od1uR7PZlINQq9UwHA4Ri8UQCAQkwU4qaDgcIhqNYnNzE2azWbjx/f19vHjxAjabDfF4XBxGrVaDzWbD3bt30Ww2sbOzg3q9jq2tLYTDYUFVdP6TyQTHx8d48eIFLBYLrl+/DrfbDavViqOjI7RaLWQyGUwmEwSDQSQSCbx+/VryG4usWCwmtBwVdKSdwuEwXC4X0uk0kskkTCYTIpEILBYLKpWKRJ5ra2sAIE43k8lgZ2cHLpcL165dg8lkwv7+Pmq1GtrtNiqVigAXp9OJQqGAYrEIp9OJ9957D2azWYQstVoNhUJB1HMulwsWiwUWi0UiuclkAofDAavVilwuh1qtJhG3yWSSSErTNLx48QL9fh9LS0twuVxotVr46U9/iul0ulDkBwDJZBJmsxn5fB6VSkWoN/VM0yEwFzcej+H1egVsLC0tQafTiXE9PT3Fl19+CYfDgXw+D7PZLPeo2+0iGAzCYrHg+fPnSKVSODo6kt8Vi8Vkj0wmE0ajkUTMtVpNEtc8051ORxLq0WhUcryklJxOJxqNBnZ3d1GtViVaXFtbQygUgsFgkOT5Iuvk5ETo6EajIcICUlWk4GiomeOi07ZYLFheXv41MLi/vw+fzwe32y37R8UsnQyZHEbZZCYASO6OlCCfT6/Xw/LyMuLxuNzJfr8vAKFareLs7AxmsxnLy8uw2WxotVo4PT0VJajD4cDa2hoCgQCKxaIwKpdZl3YuRArk2sn/MZxXVTdErDw0RJt8MMDMY1utVkHB3FAKAqigslqtCIVCQi80m00YjUZRnJG35FKjEb7ucDgU5MXI5SLCUb/o7Hq9HqLRKDweDyqVinDFiyyj0SivyYQcqUSPx4Pl5WVRajBpRzTD/eJiDmU8HouhbLVaqNfrqNVq6Ha7sFqtMJvNsFqtcDgc0DQNu7u7SKfTCAQColaZTCbo9XowGo1CTXa7XaHRKFdNJBIwm82SmKdqym63IxaLwefzYTAYoFarodFoCLcdi8UQCoWQz+d/TT78JsvpdEKv10v0xf1h7sJkMqFQKMje8DlTmeRwOBAMBgFAIpxms4mzszMEg0Fcu3YNer0elUoFyWRS6FKz2Sw5slKphFKpBJPJhFAoJIorVT4/nU4FwFB1R6BAioR5MUaQKsL2eDzI5/NylxwOB0KhEJrNpqjWFl31el1ybjSGFyMKRoDMW41GI1QqFTgcDkQiEZFpE8AdHR0hk8nI5yKI4r0mwCwUCqjX66hWq5hOpzCZTPD7/ULB8Y4waur3+5hOp2i325ITarVaMBgMWFlZkfPGvVNzRY1GA71eT6Jpt9sNn8+HYrEod3/R/SNwJpNCIQmBHe85WRC9Xi82k2AcmN3h8XiMfr8vAoB+vy9RGp8Lzzj3iI6UsmNgJtTgnXc6nSI+GQ6HcLlc2NjYEDqX0cl0OhVRiZp75B2mosxkMsHr9UouVY12/rl16Zu+srIyp+wgmqARdzgccrF5cMhTF4vFOedD6SEpLSK60Wgkkcx0OsXx8TFMJhPa7bZwsB988AHG4zFKpdIcXUFjTSei1+ulzgWA0F46nU7UZTdv3hTprV6vF89eqVRE1cE8C5H5oiuRSMw2/FdyxU6nI7wrURApCVUuyYtvs9mwvLwszoBGk86c9EIikYBer0ckEhHqhsm+jY0NQaHdbhf1el0EDpQl9no9RCIR+P1+LC8vi/KpVCoJIuKzj8Vi0DRNkLAqG2+1WhIdtNttnJ6eIp1OLxy58GwdHh4inU7P7Q3FCdw/fj8NJvMfuVwOBoMBLpdLDHk8Hpc8F/l01gowaa1pGobDodAFDocDxWJRJPQ0wm63G5qmIZPJoFgsIhQKIRgMSm5vMpmg2WwCmIEkRoFMTrfbbRweHiKXy6FUKs3VuUynU2xsbCy0d1ykknO5HJ4+fSocOg2xz+f7tYQ+7yRrM/hcafw6nQ42NzfFONG5krKlsWM05PV6EYlEMBwOkcvlJDq32WxzdDH3hsYQgNB4drsdLpdLVHrdbhfPnz+XCIICGX4unU6HfD6PUqkkgpRFFiOFfr+PZDIpIgzVYfHv6GipKKTKMBKJyPOn8orMzv7+vggZEokEOp2OqDrdbrc8B36dnp6i3+8jk8mgXC5L3pWAgIDU4/GI4+KzY24oGo1Cp9PJeSSjQ3sEAKlUStgmAvXLrEs7l42NDSlio7Og0bJarSJTpZELhUJwu91Ip9M4Ozubk/eykE3NlzgcDolsWFOwv78vH9zpdIoMOpVK4cc//jEajYZEMJlMBnt7ewAgD4LJe1XqWSqVUKvVYLfbce/ePTn44/EYZ2dnODg4EDqN/KWmaRJ2v43ShIaEyJvKm2q1CrfbLcaRyJaolsWkvJQUUvwm57K8vIxAICCHnvJBALh+/TpWVlZwenqKv/7rv0an00EsFoPL5cLR0RFevHgBo9GImzdvwufzIRgMwu/3o9frCZomijQajVheXkav18PJyQk6nQ7sdrvQQJQOAzPjvr+/j+Pj44WdC1U2yWQS9XodbrdbEqt0LrxAjL5oGC0Wi4gLKHZwOBwivyXCpOKJdFo6nUa/30etVkO/3xd6djgcIp/PSy1Ns9mEz+dDIpHAcDhEMplEt9vF+vq65GjIVzPKoTSWKhwqCRlV1Go1Md4mkwnXr1/HnTt3FpbCA5AoIpVKCUikEyF4o4S13+9Lro7/LZfLyGazEj1pmoatrS3cvHlT/p1Gi4DNaDSi1+thf38frVYLN2/exI0bN5BKpfCTn/wErVYLq6urIm6hY2g0GuKwSfUwwnY4HPD5fDg7OxPm4uTkRNSdnU5nDlgQMNGQL7pY4Hx0dIRUKgWPx4PV1dW5aJyiI9Xm1Ot1nJycIBaLiXCEMnhGt61WC8+fP4fRaMTDhw+xurqKUqk0J3qw2+0SOeRyORwcHIhYh+eKQKhUKolzYHEv7wapRtbMMSqnuo5lIYxeSAeq0dJl1qWdiyqNY2TA8IoGkOhFTfyQu2ZhGBN/jH64ITSGDBWZa+G/MbGoarlVpYjNZoPf75faFBppXkaVw2R4x79j0leVMpPnZPhKKeGizoVIjKFov98XJ5LNZoUDZXSkJs6472peSE1M8sGTpvxNyWL+Pn5mXn6qx8xms+SxSPmwxodcL6kASsEBSI7B4XD8GrXCxDpVcMy5LbL4jC6KOACIUaY67OL38wx5PB4AEOfOvB4dOdVf3CsicX52UiCkPOioiNb5PGhceJ74pSI+JqV5jvm7KCXle1DzEaVS6a2ci9/vl71QRTdUsJHu5t9RGapSxowCSUsy8ifa5VKFDyq9y+iWZQH8N/4uu90u1DnBAfebVDmfOUEOfy+fA1mSbrcrKjLm62gwF1nlclnuoZo4B87peGBe/MQkP7+Xzpy5YpYIMMlPJ9psNoWWvihWINCiOpbRGFmIyWSCcDgsf8cgwO/3S5qA0n6eUcqa1TOrPkveaebUL7Mu7Vyy2ewcReNwOBAIBDAajbC3tyfSOVbt0hmdnJzg+fPnWF5eRiwWAzCT09Xr9bkLxiplGl+n04mVlRV5SHwwx8fHos9mvoJcI5EjZbYul0taeBBVqcozFrYFg0FJiFksFjSbTWSzWbTbbRwcHKBcLiMcDmN5eXlh5FMoFETfnsvlAMwQRb/fx09+8hNpjXHv3j15/W63K8ar2+1KWxsmOnkJbTYbNjc35xQ/qhHiPjPH0O/3sbGxIRTgwcEBlpeX8fHHHwM4FwwQ3ZJCGo/HOD09lUtA9PPBBx/AYrEIouPPsU4hFov9muLtTRcl6KzGZuTR7XZxcHCAo6MjfP/738cPf/hDQbLdbleMAAvYWq0WfvKTn+Ds7Az/8l/+S/z+7/8+Wq0Wdnd30el0JPlP5MmcFXCeq2FUzGfIqmXWkaytrYnEWK3nIjhSnYrRaITX65WzxzuQz+fn1Ge1Wg3/9E//tDClAwAffPABgFl+oNvtSqFov9/H559/jrOzM1y/fl3yazwDjPYtFguWlpYwGAxEoGEymbC6uopmsymdGACIoXK5XPIcgHMVmMViwcrKCrrdLnQ6naiS/H6/7PVkMhEK3ePxYH19HXq9HtlsFru7u2g0GtIxgIl17nmlUsH+/j6m06nkTc/OznB6errwGfzlL38JnU4Ht9stgg21nKHb7Yo9onCJzoSsB+0QczQsj6A4ZTKZoFAooNlsSoSmqjFLpRJyuRyMRiNu3bqF8XiMvb095HI5obJJHRqNRgQCAeTzeej1ety9exe9Xg+ff/65AH5Gs7TNaukI1Z20maTjL7su7Vx4aBgN8APzAtBwcxPo6ahaUBPSqrdXE1VqpGEymeSBMHpgIdBwOBSBAFEfoxd6ceZ0VK9LOSijJ0o9fxMiJhLqdrvyoNvt9sKRC5OnpOAoiBiPx1Ipu7y8PPeZVFqOWvWLyF+VFJNGUQsy1YQtjQW18AaDQQom2feKDorUJaWVjLJU6S3RKS80UQ/3jueFeQq32/3WMlCeFSJ6cvlEVF6vV5KbF+WcPB/sasA6FJ4vUrI0PkxOk/OnlJd/RyUQn49KC3N/VaeqSuRVYMX8BJ0ZAFFP8tmx7c7bOBev1yvPhVGR3W6X+6sWQbPWiWCKzoI5DDXJzDulPntVfszfxyiSz5ORGvMspJTU/eIXI0/mRimX531xuVwCMu12OwAIIGL0w6hj0ei52WxCp9OJ2vQiuufn5X6oto1RIM8a94e2h/eYez2dTueiFr4WOw8w2uD7oaOgbNjr9crPswjc4/GIbeH7pJ3h3WUtjMrg0A4xInznORd6YL6ZZrMpXpjcKC8JK5R1Oh0SiQTu3r0Lk8kkiJ1KJq/XK5vACnC32y3tS8hFM6ph8o5Uy3g8Fo6VD5jJMIbLanPFyWRWdc2Qk5vNw0cJnt/vx/b2tlAHuVxODOTbOBedTocbN27g0aNHUojHQioeimQyCYvFggcPHsBkMkkUoBopqjqICknpqKIFVTpNQxWPx4WaorP3er1iCJPJJHq9Hl69eoV6vQ6XyyWUB5815asqf/vkyRNxXqQ7fD6fiCeAmbFk5fsii5eL75eUi81mw/vvv4+VlRVEo1Fks1no9bPeV6PRCF9//TX29/fh8Xjk7/x+P/R6PVKpFP7iL/5Cfg/rOJjU5r7w3yi8oJHgc+Vekt5IpVKYTqeCcEnHkGLjMyLV5nA4RMpLqTMTrUz2h8NhOcOLLq/XCwAiy2XCuN1uixpIr9fj8PBQms9aLBb8wz/8A/L5/JwxpKE/OTnB//gf/0Pus16vFwWS2l4kFothZWVF2towchkOh8hkMpJ/ZDTAnBR75RG1A+cNUalAo1LNYrFIo1yr1YrV1VUAMzqLzEoikVi4nICSfmBWFO3z+eTvKHRgvpiybQJWi8WCarUqohaeAbbL4f0BIK2saK9IVbN1C9vNsAo/EAiIPaOIgEwJnSkjP0aDfD3msdR+ZhRZUAxFQMoejO/cudDAEbk1m025RD6fTzaElfn0joFAABsbG2g0GsjlctC0WWUyDZDf75cwUafTIR6PS4U01T3RaFRyHkQ4RKa9Xk8u+mQy604bDAbhdDrnLmsoFMJ0OsXR0RFKpZKgNj58qp5evXqF27dvI5FISCKYibS3kYGSp00kEtja2pLENACpyQBmfYjC4TC2trbg8XiQzWal+SbREXlvJl4ZaUwmE0ExRBnj8VjqSwKBgDhdHhCHwyHGk8npw8NDVKtVrK6uSgFkqVSao2mA2SVnN9dOp4NgMCiKI1JJar82lSJ608XXdTqdgkgZeW5ubmJ5eRnj8Vhks6urq6LCef36tZwz1qw4HA6k02k8efIEfr8fDx8+hNvtFkdDB0PpJ1WNjDwZHXKPAYjKiolYOnyKAoCZ4oh7Q9RNxFmv13F4eIjl5WVsb2/DaDRK+xev1yvNGRddBEeBQEDENmyQSnDYaDSQyWRgMpmwtrYGn8+HJ0+ezEUher1eflc2m8Xz588RCoXw27/929LEkoCG3RC+973vIRKJyD1ifQ/PZ7PZlHwTuxzz7nm9XnE4dHAOh0PakaiOulwuY39/HysrK7hx4wY0bdaAs1gsihx90T30+XyYTmc9uUjdMzpgLz3Wjen1egSDQdjtdomy2u223COCahaN06iT/WHNTrFYnJMwq5EXu4643W5pI0M6k52Y+RUIBKQkgWCIZxM4jz5p41kLp2maCAYYjb1z58IcCekJJoVJRTAaodSW3D7zMEQrOp1OLrfD4ZAoh56TbWYASNM+ojWV4iCFtrm5ibW1NWkBr9PpUK1WRVPP4jUmbsnVk4YgsucDI2JgBGGxWBCLxVAqlaQwcJHFhPPZ2ZnwqqSkfD6fGMzhcCiHpdlswmq1IhqNolariTNnI0FGh+TtgfP8ihqa0zmqFfsUP9A48kKz2IsS0mq1KsaTSWdGVKRKw+GwfA9zCkyek9ZRq48X3T9gRs+mUilpcU96hR1v6QDZaigQCOCjjz4CcE5HcbFnGJ0xE8CM7hg1EiyxvQb/bTKZCDih4+e+8FzzItMxMAFL2kmv10tdwXg8lvPP38/cjaZpb9TX6Tet3d1dqQsiCmb9BXNIqjz96OhIGtCy8zXPFGkTOko2kh2PxwiHw7BYLHIn+TnVyEellNQuEYxKKTgZDocyYkGtIqeknO17aJP4vobDIYrFojgxtWp90TvMRpuknhn58Qx4PB7paj4cDnF4eAiTyST1OSx85HNmDQmBM2l7nh1GPCpFTrm7z+eD1+uVnA1wHt1z/ygyYV9DCk18Pp/kscl28LyR5qbikqIck8kkkdc7r3PJZDJysKgaYTM6RiL8t3K5jM8//xy1Wg2PHj3C1tYW9Ho9qtUqNG02x4VNIsmTrq+vC3Ii1cM21Wpeh0oyRh6sIj84OMA333yDRqOBw8NDURCx5T+jA1ZPk/ZotVrY2dmRg8OK/m+++QZ2ux0PHjzA1tYWvvrqK+RyuYX52kKhAGCWmH316hW63a5UaN++fRvBYFDajkyns46x7XYba2triEQiePnyJU5PTwEA9+/fl55fg8EAZrMZwWBQDFW73RZUDEAOGfl1Ro2kMPr9PvL5PPL5vDR2tFqt0l2Y8k9WvrvdbmSzWWnVf/36dZjNZhwfHyOVSomen7+fAoO3cS6sa0qn0yiVSlhdXcVv//ZvS+ddqowYJTx79gzdbhfvvfcefu/3fg/JZBLffPPNXENGViUzad3v97G9vY1oNIpyuSxUIPM5RN1sFghAugPQcZD+ZNKc6Dsajcp+0AHTIKfTaQFNVOq1221BrA6HA5VKRfZg0fX3f//3ACDRbiQSwe3bt+FwOBCLxaQotFwuo9vt4pe//KXQr7du3RLAo46A8Pv9CAaDomjr9/u4f/8+Njc3kUwm8fTpU3EKpFOZi+IXgQHb/vNcs43/yckJ7Ha73GE6P34fz7rq9CjqsNlsWF1dhcfjQSaTwdnZ2cIMRD6fFxUfi3nPzs5gtVqRSCTgdDpRq9UkP/b5559jNBrJHfb5fLh+/bqABtJ7BN+k9+12u3ShpkPgF4VFLGymo/b7/RLpUDVJ0Q2LtX0+n4AKnjFGg3SKdrtdgC67H/BsvH79WmbCXGZd2rkw6gDOeyixloA5DCa5uPmkZvjF9ghEOKoUmFJIFlKpkmI12UgHxt9JJETDRWTOMJJyOxo3PgwmqOm0+LuYeON7JZpQBQyLLL6fyWQi+8YDw5D4otgAgEQv3B9V0srLTDTMv2M0wu9T8zU0DESCvJRElpqmweVyCSfLiFWVqFJYQGNBqlJ95nwdGhLu/6KUBPMZjFh5GRmNUo3ES8tEP4A5GScTpeoZ4F78puQ7cB7x8HsoXgEgz5DPlvkIq9UqPbeYh1TPG9EgHRW7AVAkoDoXAiy1MHSRddExkeZT+38xMmDfNeY4KT5RhRqqkojvm5J77rtKhdJuXJRm874y4gAgAEetl1IFGryHlIfzPBKRq7Jj5mJ5HhdVfDJCVcsaCBR6vZ68F54rRsP9fl+iYDViuChP53vlPVXPOz8/qUPSW/w9rDOkHSalyyiIaQpV4MMzzc+k5lK5f5o2qyOjqIVn9DLr0s7lwYMHEk20Wi1phUHjy+T92toams2mFP20Wi28evUKxWIRr1+/FuTC9udUKrGAiNW60+lsOuJkMpFCISJHGjEKCFqtFk5OTkRy9/DhQxnWRGqNw8k4W4RJcBpxVaXFi8zaAlIJlHIusr7//e9jNBohmUwik8lIV14mbdnplAiQVN3+/r5QJrz4bM9ClMSIjzkQta0IQ2leDPLrlFIy/GZXYYfDgTt37sDpdOInP/mJDBNyuVwwGAwyg4aOrt/vY29vTxJ+nLvTbrdhsViwsbEhCXS12OxN1+3btzGdThGJRFCr1UR4oNfrBe0vLS1JWxteSCai0+m0tKBhL7disYh0Oi2CD5PJhG63K21WeEFJoxL4EHgAMyPodrvRbDZRrVZhs9nw27/92/B4PDg9PRUqkyo8iixsNpsMdcvn8yK5ZTEl5abk7SuVitRZLLqYh6J4pN/vS7+0brcrdBnzf81mUzpok8ZjbQVpT95n5po6nQ6Oj48lOqACkW1F2KSS8nCi7mAwKIWrdrsdH374IbxeL7744guJBlVgxrPkcDgwGAyQzWalJyCdIik+lhoAkCGDi6xbt25hOp1KdwbgfOgbUX48Hsfy8jJMJpOUb7BFUL1eRzqdls/MbiQ0+ARDavcS5kNpE+gwOFKA0mj2CysUCtLDjJ2YW60WrFarMEfsWs081Xg8ln0jkOj3+5IHazab0sXi448/fvc5FybEqW5gW3DqoulVqVzgwWHEwjwIHYvBYJDhWJqmSc8m9qki3cFGhZR58pAR7anGtdPpwGazIRQKSUNHFhzxPbJSlehelYdelAzy8zabTXlvi65YLCZtGYg0mGTO5/PSPJIqOKpCzs7OkM/n4XK5hFrhnnY6HdkH9ZITibJQkwoPVcpLQ0YDqiJxDjLi6AOG8UajUWpBWJzGvIzaIZuIjWeAMyNUae6bLr/fL1Gu1WqVSZg0Yp1OR9RKapTE90u6le+bLVxarZYYVVIRvFSqxF0d5ARApN/qjBw2BWRtD5+BmrRllMpaBFUmTmTO/SP9S5aAUuhFFx0Cx+gWi0VxvoxWWHOjqol4V9xutySF1U7kROx89o1GA+VyWfKbPM9q8liNJChCYbNK5oDi8Thev34Nm802J6jhf5mroaDl4n3n++ad4PNadLFpI+lOllnwzACzPB5BL+8Wo0M22iQTQtqLtoZRDYEkZwuRQeHZoB2jSIS1WCq1RqaFZ5u5cOaMSNcSdLPkgvaCPdoIRkajkQC4y97hSzsXFtTwITJRT4THxD4fvMPhkENDw8yOoExGe341E56XicU8sVhMkBAVPi6XSxoz0jAT2S0vL4tElgVxbLHN30ukw4ektqigJJkXhg+dxoAhL7Xgiyxym0z2tVotkWarBpjhPo3WBx98MFeFTBTYarXg9/tFxkzHc3x8PNchudfr4fT0VIrJyMWenp7OtddOJpPY39+Hy+XC+vq6hPEej0dyNQBEkk3joNY3sGdXr9eTFhKZTAbdbhd+v19acCyyKK1k+yFN06SPmlq4tr+/Lwl1tmths0UaTYo+PB4P7t27N1dDZLPZ4PF4pHFjt9uVfCNn3PNZ8Bnx3FOC+9lnn0Gv16NUKknXBRYH8nmz3oYqH74vnjcaAhobi8Ui8zsWXcz7lctlaJomeT/m7EKhkEQY/CwAJDKkiAKYRTWUMIfDYZG0Uh02nU6Ry+Wws7Mjn1mn0wlFCJzTiEtLS/D5fNJmp1ar4ZtvvsH+/j5evXqFUqkkyXACKFKvnMZIOjwajSIej4tjpJqKNB4N+CKLzorOhflLyoFp105PT0UcYzDMJsHG43GkUilYrVahoFRaixQVAPk9k8kExWJR8n7j8WwkejgcnpP+k9FQFbCsyWH/O+4Fi8aZo2WxMGcL0eED54pS5top4HjntBhbvrMpIQCRHTM5z4hA0zT5t0AgMNc6ZTgcSgjrcrngcrnQ6XSQTqcxnU6xtLSE9fV1nJ6e4uDgAMB52wJWp7rdbumfFQwGsbq6Kj2Put0udnd3AUAuKeWnLFjjBjOx7/F4ZOPVjVXRG+eiL2oc6fxIKdGwqNJDoi2ic5PJhHv37mFzcxO1Wk1GM+/t7aHRaGBlZQV37tyBy+XC2tqaGHry1tVqFYPBAKenp0KzqYlvKkccDgdOTk6wt7cHt9uNra0tQVs0zqpzYZSq5rnoXGgkODcmlUqhUChgc3MToVBo4ciF6q/Dw0OcnZ1haWkJ9+/fl6iCdRB7e3sSGTI5yW4S6+vr0ueqUqlgbW0NGxsbaDab2N3dxWAwG+kbDodRrValeR87I/CiskKfUlSqb6iO+ulPfyqGHJjVRzx8+FCMKvn4er2OyWQiYglV5slWKvw7UlJvs5iQ5tkj6HK73QiFQrh27RpOT0+lgwbPUSgUktox0i+kx+PxOKLRqKgc1c4OmUwGX331FabTqYx3pnNhromROJ0aacfHjx9D02bdlDl5le37q9WqoO9CoSARLVvEeL1ecd48l6R/1OLGN110+ET5LEyksCgQCOD4+Bi7u7sCAs1mM27evIkPPvgAr1+/nhMCEKTz3jL3x9QAx2r3ej0Ui0X0ej2pDWJkQopRFTrodDqJpNkzTC20XFlZkQa2ZJnYeZ45S3ZXGI/HSKfTaDQaYkffuXNRpzEysuBsBBpEfmB6YjXJR8oJgEQFlC/zEDPyYOEYv58Uh8PhkPkiRPPNZlMeABE1Q1VKb9WEGA8+lRKj0UjyEfxSw0+iFeZvFnUudJ6kTthiQaVKyEMzbKaj4/6olfus4eDccsoteQF42TRtNhp4MBiI0gs4H1LE73U6nYjFYtJmhZEqo1LuB/NdalKTM2fUnlVUnNBpj0YjiTgWWaVSSQwvI14Wt9JwTadToZH4vtlanpeF+8yzocqXCX5YO0X0yWiTVAUr8EnHptPpuUaiRINMprLgkMZD/X/gvFsxaUWebQBCXdL4vM1SI2DeLRpc1lPU63V5j4ziedeJqGmUCJLK5fIc9cyzQsqLOSYaQt5JNqulKIi0n6okI42p0+mknQoLLFktToBLBSjvGXMSrGRXKdNFVrFYFGqNHcqpYM1kMqjX62g0GpKz4mfmXlN1OZlMRLlFWwicCy7ooAnSzWazTC9lnpQ2gKIA5le53zwrnMXEanuyGarQgAPzVFGLmvznfRkOh6jVau+eFtvZ2YHBYMCjR49w69YtHB8f4+c//7lcPIPBgNXVVUQiETFOqlEmyjOZzsdz0lAy/B4Ohzg6OkI+nxdUrap0VldXsbm5KcktAHj9+rXUjqyvr0vPMLXRphoxcB40kQ918A6HQ0J9dgal4XkbbTzXT37yE2iaho2NDSwtLSGfz8vo4EAgIIeAIa+qyOOhZoKPPG06ncbR0ZEkp61Wq4zHZahuNM66rKqNLRuNBg4ODiRBbrVasbGxIV1f1S7IrGOgs6ER4KRGh8OB27dvy3iFSqUCq9WK7e1tofEmk9ko1i+//BLT6RT/6T/9pzfevydPnkCn02F9fR23b99GNpvFT3/6U2iahkePHskAJXad5bNLJpPI5/MIhULY2toSDpl5KLacZx6AuRGiRrV5KUfoqq2J9vf38eTJE6FVSV1w7rzaBYLPkAZHTdoSEas94wBIfymi+7dZHKPLqLjb7Yrc+he/+AVGoxGWl5extrY2J10vFArIZDIy74dnpNPpIJlMylA1ij5o+BwOBzY3NwFgbnYT6zw4GK1er+P4+FgAKfdLVaRNp1PpFUanwv/a7Xbcvn0bLpcL+Xxent1XX30ljoc0+tuMzfjlL38pSe379+8jlUrhm2++QalUwnfffYdmsynjqJkPMpvN0uWCCX+/3y8UJNkKOmcAYjcdDgeuX78ufdeazSZCoZBQrARyBM1m82wwIPNT0+kUiUQCy8vLqNfrOD09Ra/XEwak1WoJwKYNByAAgbJ9CmRI5b/zhD6TofSORGZ0DOQyeRBUVRcAuXgA5lAYjbdaYNZqtSSZxTCWG8m6BFUG3ev1hAYh9aUiIBoIGjtuJju7qqGeSk2oG01Euyh6JCIkf65ywPwiMiEiIgJj3Yoq62ULnmq1KmEwf477zS/mJIiYuc9qcSR/Lx0vIxNKGJmrUulCRpek9diyW22ZQoTLfN2iNQZUaBF1UyLJ/7L4k0iO6Ir7x9ZBqhSdCVC1X5JaTKp+ZgCC4JhrokNoNBqyvwDEcbCfmipxVp8j/0xkzoiQCXO+ploC8DaLUR1HZFBy3+v1ZFYLcyrA+T2leMTpdM69B8phidZVZRN/ln2+GH2p+0CjxQ7H3D+1GJKRC+887wy/j/upRgE8D2oLeoKctwGJtIFG42wAGe8ecD5PajgcCnjgOSBdT2kxFyMSgoaLUngCQu4VWRbaWN4ryu7JNDCaolCDXQ8AyBlj9MKohfaXNoTsk3oOaG8vu4eXdi70lul0Wrzqj370I4zHY0m6kZ/jYWVPGoaBVGoBEBTcaDSEt2a/I15sek4eDs64oKfmA2KiiYfT4/EITcTDS9WO3++Xi0yEwHkz/HK5XFhdXcVkMsHJyYkcordxLqFQSGTBRDPhcFjoluFwKAWpzWYTR0dHwinTeDOqIffJsa+suGdCnbmsUCiEdruNx48fy/CqUCiEarUqCESn08Hr9eLo6AhPnjwBAKn8pSEm9QlAFCaj0UjoEB704+NjPHnyBMvLy8LhUrmmUiSLrEePHgGYXbxUKgWLxYI/+qM/EiPNnIg64IuXmUOednd3YTQasbS0BIfDgVwuJy2GmPQnnWI2m2XAGzAzZGx5xD9TUrq2tgaHwyFUIKMhTdOEzqBD8Xq98Hg8yOVyePnyJRwOB+7duyeClWKxCIvFgu9973vQ6WadrCkTbTabbyVFjsfjooCkkIDzPIbD2fAu5kRVFSidC++c0TjrFRYMBlGtVlGpVKRdiNVqRTKZRKFQkAiPn1/TNJk0C8xPlfX7/Wg2m6hUKgJIaFTpXBj58ExRXGI0zvr/FQoFHBwc4OzsDEajEY8ePRJATAn9m3T1vbi2t7flrr5+/RrtdlsG6wWDQfT7fQSDQTlH7CN2dnYmlL1al0PHMBwORT6s1896HBYKBYlq+P0sU6Az5mdpNptyL9X9BjAHKIH58RuMTsgSGQwGZLNZFAoFRCIRLC0tyfthgfebyOEv7VyoAGFNxu3bt3Hv3j0AkLqDyWQ2DIsJelJRPNBUjhH95vN55HI5UXyxXxCRCdEznZTaR0zlyNX6FEZWRKe81FQbkRJpt9tCfRFVsCWNxWLB6uoqptOpNPajQ1p0UeBAeoDJQEYK/BwMoSlb5CS6YDAoP8tLRxRkMBikrxuRfSQSwebmJgqFAv73//7fePnyJTY2NmAwzOaIU/Ou0+mk/9He3h70ej1u3rz5a0owolH+PS8JnT2NKmuZSDMB57w+qaFFFkcKHB0doVAoYHV1FQ8fPoSmadjZ2ZEKexX585JR70+nRNVRs9nE8fEx7HY7lpeXAUC4aBoNNfdFIYDa8I/qHdI8NAjkuNWaGOYZTCYT0uk0UqkUvF6vOLfxeNZniwlinU6Hp0+fSsNMgqtFF7siU4Lt9XqxsrKCwWAg/eSGw6G0TFILElU5L6kmvV4/R+Oxx+DJyQkqlYo4DVXqzmiWarXJZCJgEICAVIJSIm/metRcH9Vrqhw+lUohmUwiHo/jzp07sFgsKJfLUj7xJsj74orH4wBm5zmTycztA8sUaJeYD2UdE1WFNNi0gWQteJaMRiPOzs6EhuZ+M1onIOa4DKoUCaJoI1Q2gu+Jd1kFhCycJIWXSqVQr9cRCAQkV5PJZMQRvUln7ks7l3Q6LQU7bNHw6tUrecPqJDkaUb1eL4lONYphaMffw95adrsdtVpNaCjOnq7VajL7gAeNfDC5aNZUqKE1EZBag0H5H1FPr9cTVKP2HaOAgTyy+rsXWaQ+qIph4dV4PBa1Xb/fx6tXr6TjgSpEaLfbUvCnyjo5xU/tLEBlGh3oeDyG3W5Ho9HA7u4uzGYztra2pJcT0X4kEoHJZJLRv7VaTbTupBz52owGWOvC5nh3795FKBSSIlnmK9i0b9GLTeUgxQsEDHwuLI6j8SVCIz3C1yVY6Xa7cDgcWFtbg8Vikc/O30Eagoob5hgoeCCl0263kclkpLcbcC4lrVQqc5GLGskAM4fJvm9qfYfJZEKhUJBnzLqjt6XFKCqhQ2AxLg08HSxwPrsGmAFLGiDmMomQ2W3aZrOJKEDTNITDYaHNVWfByZE0csC5vJ33nkl4MhnswUd5NBP7LH5VaVu2HqIDJ5VOteiiakXgfOwIDTJTAzT+qvKNBh2A5FPUXmRqJMMvUmnspswaO1LYPNM846To1PoxFXwwZ0vq8qIYx2QyyT1mg0udTidiA6r5yAAQ4L7zyGV3dxcGgwH37t0TXfs//MM/wGg0YmNjAysrKygUCshmsxLq0pAy8Ut0Ts5Xr9fLgKBoNAqz2Yx0Oi2Ohd04U6kUOp0O4vG49LlR55VXq1XRdxMxqoVU1Igz+tHpdIjFYlhfX5e8Rb/fl4vCyEun02FpaUmM2dscTLbBoAOuVCrSt2t9fR2xWAwnJyd4+vTpXNKVl7NSqYgxpTNaXl7GysqKhMSapkn3BM6A52H3/GpYUiqVwo0bN/Dnf/7nQpux3ubatWuSjHe5XHj16pW0D2e4zz3w+/3Y2NiY4+tXVlawtrYmldJqpFgul3FycrJwzuUXv/gFDAaDCCIA4PDwUIQLbEnOnBWj5lwuN9eYlMiPTQPj8bjU+5C6M5vNqNVq0j/tyy+/RLFYxMrKClZWVsTBTqdT6efk9/tFCciz3Gw2xXEDEMM+Go0QjUbx4YcfAoDUdLENfbfblQR3PB5HPB6Hy+USldyia2dnZ06lWa/Xkc1mYTCcD3UjzUXqicCRyi3S2AQm/Ll2uy2jhkOhENbX1yUfRdkxjRzpHLUmjtLuQCAwp9ykYId5AtKxHMwWj8fncpc+nw8+nw+VSgUvXryAwWDABx98IN0Q3iahz3ELzKWoqkBGpJRwqzQ7DTqpKJ5T/izvic1mg91ux82bN7G1tYWjoyN8/fXX4gwASH5FrftRC0wv5pUajYawSXwPdCIsVO12u9jb2xN5NelNqu1Go1k3FIoJ3rlaTOXumMir1WowGAyCAkl/qPye2WwWmSp/B3A+l0Rt0kYDwMQpDwINs0oD0WhRWssGcOSpyRerXp6bwhBRVZPx9UkBsFiOVAQP06JLTdapUk4iA/WLeQQ1kUx5opovUveEHXNVpRHpKvXwEUUzp8K2FJqmzbUBZ/TDKJP7qYoA1ChKRU6k7VRpJaPZRSMXnhteaBU0cM9U6TgjJqrDSFVRoUWVFmkNng8+A+49k8UERKocnOeHlJ+ao+LnZIKbiJ+UHb/4XrlHPJekfykXpTF9WzkyzzvPeaPRkL2gyIFLlbvydWk41QI8VczAZ8F/Jz1J2pznghEvC4LZpJbduMlWsA6Ezw447zPHujrgXDDASJV7zbvE+6beqzddPCMqnaXeYbWMgaCOEYeaIFcX94rP/OIZVM8E7RDvEikwUq+U2zM/rN4H1QHzd6oCHZXe5n4xp8v8kKZpwpBcZl3auSQSCeHnJ5NZv6/Xr18Lt079M9E2H3I8Hhd07fF4RH3S7/eF1wNmBV40vOSvr127JqidjfSoJFtfX4fb7cbNmzcxnc66Ga+urqLVauHx48eCMojUOFOaB0vTZnMeGo2GzJPIZDJSmc0xszs7OxiPxwgGg29VYc7XJXfNBCX1+4y4IpHIXHcCJuqn06lUVjP5z31utVpSoKUWFXIeDdv7W61WXLt2DdFoVFryPH/+HMfHx3j48CH+xb/4F2i32zIcKhKJYHl5WXq3UXk1Gs2Gw3GMAZFcJpNBLpdDOBzGe++9B2CGljlT5+HDhwsjbyY7l5aWEIvFpEswL5LJNJvlwTwane3m5ibW19clWU206/f75fypAhRWMxPAWCwW/NZv/dYc1cFENXMJdNYESYwaJ5MJ/H4/yuWy9Bi7f/8+4vG41CRRUNLpdODz+eB2u9HpdObygUwQM6H+H/7Df1hoDxkV1Ot1US+WSiVomiaGSs2z0VDx3pBG4xkLhUKIxWKIx+PIZrMoFosCVJik9nq9IsZR27+0Wi1hHdhO6MGDB/jRj36EVquFFy9eIJ1OS10dDSXpbjoVRnyJRAImkwmvXr1COp2GXq+XDg6kvimKWHRx0FipVJKGmlSzsRixWq3KmGLW65FpoPFXFV+0AcPhUEYicL/7/b50f6Cj5YBFOnbaj16vh/X1dXz44YdotVr46U9/Kr30+FpsbEkgRJZDVaryGas1i7R5pC7fuXOhrp/oYTgcSpt6ShEpB6ZXZJJcHSDGnyXycLlc0kBP7QRKB8MCLBYqsRElJ1bSsPl8PkQiEVF2EalSMUauUJXSUp5KR8hOtDyEg8FA2o/T4LxN3gU4jyZUqTSNDACpeeCBAs47/V5E1WoND9tgRKNRkWRS+szcAVuas1cT6TkaXlJf1WoVZ2dn8Hg8wrM3m03pZUZUROqOSj0W2zGHxr0fDAZwOBwIhUILO2c2TGRbITUxy/2kmoV1ULxYHo8HnU5HLpXdbhfxBs8mfw8BDCNqte0PeWnSQvzslPUSOZPOZe6GxhSAtC5iPopRIikbtYOCyt+zgeTbJPQZNaiREdEyz7fVahVJMc+dGimr3a5pLDkuwmKxyDlmfQqLBql2UpPNdJ5MEm9vb8s8JfYnC4fDwk5cPPukfAhwWJPF50exBHOWrLlbdPGzcEQ281aj0UhywLQV/C8lwYy81M/PReqM+dGL0nd+/3Q6FVCnFoPS4FMhyjY8FIeQAaJTZvTDiJpRidFolMm+ZCtU+T2jmsve4Us7F/aUicVighKIziKRCFwuF9rtNlKplHC4RHMmkwmVSgX7+/swGo24c+cOQqEQhsOhTGTc39+XIi4mL9lplL2BuGw2m/TPikQi8Hg8KJfLgihSqRRKpZIMJWMyEIDM/iBtQoRKw0LES6fFJKHf75+TO7/pcjqdACCFjblcTnIiTLaRfnE6nbhx4wYAzF1IIhUm3Mib87NQ9nh2diaXazKZYHNzE4lEQhCp2+2WA7mysgK32w2r1Yqvv/4aw+EQsVhMZM3s2MtwmKo8TZs1G6XUW6fTIZ1Oiwz07OxMquBJWb5J64iLi7kOfvZYLCbqJ/5OqhYtFgu2trbEKbAfGS8NUTuLwihj5sXmeSDyo7E1Go3w+/3odrvSLfrDDz/E2tqaOGAqxEgr8jKyIzFBGqMl9i+jcIDKQTWKACBzPN5mEXCw5Q+7ZqjsAIEIVVqkXdhNgoIXqpWo0KLcnwaWX3RarFsjsgeAGzduyJkyGGYTZ09PTwW0sg6EndN5/rk37LQxGAxwdHQEo9GIbDYrzXB5v0mZsQRg0cXIiQPdCA7H47E0UaXToS2hmEgtvWBpgcPhEOaE+zmZTKRpbK1WQyaTgc1mw8OHD6V5MEEVXz8SiUgkc3JyIjaBdKJai0YWRu0P2O/3JTcGQGwcW0Sxr9xoNEI+n7/0fl3aubCxYiQSwfr6urS6Z7KYXU1TqZRQWtT9T6dTZLNZ7OzswG634wc/+AE2Nzexv7+Pw8NDFAoFPHnyRBBuLBYTRGe1WrG8vDynxgFmTfhqtZokOsvlsvTA4WEHIK3Si8UigHO5JNEbH8p4PGs7XavVYLfbpS6FPZ84MW5R48iILhwOS/fenZ0debC9Xk8mejocDsTjcamm73Q6cLvdiMVicxSGmrTnwabTYrKP1ffs3Mv5HDxIy8vL2NzcRLVaxddffw2z2Sx1G6enpzg7OwNwXpTJWpVarSa0FFVW6XRaFG3JZFJEBlQYvq1zASCRAimt6XSKTCaDZrMJg8Eg9RtbW1twuVxIpVJyLliMSkqD0YOqMGMvslqtJootr9crr+n1ekW6CwAff/wx1tfXJWLi72TBKDlu9uYiSCP1STRNA14ulyUiUnNawWBQnv+ii7/L5/MJncPO1yweZd5TVTJR8Uk5LetOOJlQ7fisaZqIVij3ZmNEt9uNSqWCYrEIr9eLO3fuiNOhOimZTEokwzPLqJOoXJXHEwzyPeTzebRaLTmTPLvMmVJCv8hS1XNer1dARK83aw7bbDZF+cb3TXk8o6dyuQyr1Yq1tTVRwxUKBfmvCmabzSZevHgBv9+PP/zDP8R7772HTCYzNxGXEmZ2gT85OZG+Yozc2a6IkR07z6ttZtR8L6MUVVVGBuNNoudLOxc1lCJ3RwWYWsdCpQGrUtmLyefziW66XC7j+PhY2p17PB4sLS0JDUREzMQTk48s5OGlYGKPTg44lyDzoVL1wtVsNuV3kp5j+3SGgYySuLE8zExwLbIYKfBzAJCCSobLTqdTQl4aHXao5T4xuXcxMcn/Z0W02+0WFRkr9ElLMhlNWThn3/CQqfJHRnns6sxzQGNLZR9pt7W1NZlTzmiQSWBVVPGmi6iYkcpwOJzT+bPbAqMMOl1WOlOWDEAaL9L5cv/IO/P5c34Gv48GAoDUK6hRL1VzROpqEl/9HDQ8ao2IpmnShogV1oyaSMfSgC66aJBU0QiRP98P6WZKYfkeVVkt0TnpHDoWNeHNs0YDpwoD6LjU1vTccyJ9SodV4QhpRIqB9PpZY1y+n/F4LOCRdCTFATwHbxO5lMtlAJAmtqT+SNOrDhmANDRlF2JS7gR33Hu1QBmA7InH48H6+rqUbDCnSIDIAlKKq/isGCmpOVnWFJFyJBVG6pzPhipAnlMAcrfU+rbLrDeKXDRt1nacaDYSiWA4nM1baTQaCIVCuHXrluRHGo0G7ty5g/X1dZExdjodPH/+HF9//TWuXbsmCebV1VUMh0OcnJzg5cuXImdkaDwczmZi53I5eR273S69xFQVBJtSkpJju4nxeIxkMilGiJ7c4/GIKIB8PVtdM0fBoqhFOW/VMBAhbmxsCO85Ho+xurqKGzduoF6v4+nTp6jVaigWi2g0GkJVAeeKMLUNBh9+LBaDxWKRTrcc8+pwOJDP56Xlt2qMOTenVCphMBjg+PhYktGRSAT5fB6vXr2SCmT2uwqHw6jX6/jFL36BSqWCjY0NJBIJUZv0+33psMu6mUWNI4s+CSrq9TpevXo114CTMtjxeIzXr18DgMi8mY/qdrs4PDxErVbD+vr6r82noHMpFosol8uwWCy4ceOGdEpOpVJwuVz49NNPpZEqz/vXX38NADLGm6IMLhoIJrFZ00Wnvb29jRs3biCXy+Hp06cYj8eScyiVSjg+Pn6rnAvzN4zGKZJhL7lGo4FIJIKtrS30ej0cHx+j2+1KfQiTzGwDQgdIcMRIlZJpRnDM3dABMbdEqlTNKVK6vbS0BIPBIPtEuzMcDqXswOfzYXl5GYPBbO5Rr9fD5uYmfD6fDFxrt9s4OjpCtVpFNBoVenWR9fLlS2iahqWlJemzxtoUAhhVmUa2ZWVlBeFwGJlMRsA4a3ZIYRmNRsTjcaFebTYbtra2RLDUaDRkdDdHWJBBKhQKOD09lfwggTVTC2z6ytzk0dERRqMRAoEAotGo2E6OqXA6ndKQlfnwbreLpaUlrK6uvvuEvqpqIG/IWhO1EplO6GL7AVJMTHKxApW8uMVike7JRCE0mqpUTg0H2TNHlRLzsqpyUHVjGaoyycYvoiSGhPxcFxNniy61zQudCatueRCIDNRiLPUzqbp5VQbLgzEej0Uyq+ZqVEUTozT1i3vEfVP3lJ9dLUZU5ceqeoe0CRP7vymKXPRiEyGrhWBEsmqil2dCTSwTFY9Go1+TEKvKHeCcb+bPMnrlyF1GPxQF8HdTIEFjS2BDUEMnoybS+RxpnKmoVNvtM8dAZ7ColFtdam6AyJnPn1GpClym06momNRCRNJgKsvA/+f7VukynkGeT7Vkgf/P1+L3UMCj7iPBFe+wek+Z2Fel8/ycVGkuegYZyVK5pyq2uBjlqaUL6lwr2hU+A1Wyrg6t4/21WCwSfZFyVbslMEJhN3SdTjd3J3hX1AJosiK8r/xeAg+CdrIkFF2QPbhs3vmNIpfJ5HxY08rKCj766CM5fDQoLLq7f/++qA92dnZwdHSEb775BtPpFBsbG7h27Zp04mXLiel0ipWVFfj9fgwGA6RSKTidTqyuriIYDAovzCQ9wzi3241UKoXDw0OhyIikPB6PtOXvdrsiE6QaTeWRuXHk3rnpPODhcPitaDHg/PDxIg4GA+lfBkBqOEiHUIrInlTT6VS6PlM5otI7zLmotBedDkNttcleNptFo9FAqVSSvBT5/tFohEwmI4lGJoPD4TDS6TS+/PJLaVVDgEHHREeozlWhdHmRRRkr58NwwNVkMkE2mxW6QRVO0EhxTDblwF6vF9FoFLFYTKTwNPT1el2KLini4JA15sdGo5G0jWEuLhAISHEnZw2x6p6Ff3S0Kkhhfy92xSYlRppD0zRJ/NOALLqoFms2mygUCuJI2C6IE2AZrbADOUeIu1wu+P1+KZ7kbBc6TABizGkTKLm32+3SFJO5t9qvRvBSYMDeenS4AOYq9CmFpTHN5XJCVXFfqO7kmaZAhe1Z3qa3mOdXkzxJw4ZCIaFHKTBSm1Yyt9XtdmUsPMsJgsGgJMkHgwFcLhcSiYQoGO12u8zDYc6NrEOj0cB4PMazZ88E5Pv9ftRqNRwfHwuAVWtrzGazMDPHx8c4PT1FtVqVKbuMBvn7WADMCJD5JI/HI4HDP7cu7VzYyoEfgIeB6JWGv16vy7wDu92Op0+fIpPJ4OzsDCcnJzCbzbh37x4SiQRCoRDcbrccBk2bNQL0+XzI5XJiDKxWK3w+H8rlsiT/6I2ZKAYgDf4YBVAySjVOq9US3pLtaNhThweaHlxtgz4YDISvfVvnwstBh9Dv91EsFqXKm1X4jDKIYCgRZZTQbrdl7CznsVPzzgFK5KZ1ulkxazgchsfjkctPeoPCABpDGhBOXmy1WlLQRUfx+vVrPH36VNQzajdnFY0xcUwV3KLOhZEs8yxMcNPZMnJiI1NSNDR+FJsYDAbEYjGpNibPzedSLpcloexwOKQJKGkuOutSqSRJeyZxSYOoM1+MxtloaLY9Ucch2+12acFBIQHrOVTZLHOLbxu1UP3Y6/WkXoU0IClXFtGyBxswaxvTbreFjyct6nQ6RYVJp0IkzQiYf8efY91Zt9sV0EK5rCpdVksGyHIwP8m2UNxTg8Eg81yYz1JrWkgpV6vVublAb7rYG485DKfTKe9blb9zX9k1IplMyrliTo5RAr84rdTpdMp9SiaTODk5kXwcWwVRUUjmx263w263o1qtolgsYjQa/Vp+U+2a0u125c4AM4BDSo7vhXlfKtw4q4YtYS6zLu1cCoWCJOkBiAKLoS5nM9BJJJNJoRImk9lAqe3tbaFq2u22SI273S6y2ewcAiL3qoZlVCiZTCZJahUKBVitVmQyGUG3vCgsLuTcguFwCL/fL5tM3jMUCslrAZCDQlqCUcbbJKQZmdCpcZqm3W7HtWvXEIlEJEE+Ho/FwPGgMvqgZLFcLiMUCglnTapPpQpUDTu/h0aRTpMRCWkDAPL9aj0D2z4wouGFBiDyYD5/1hWZzWZJdNJoLbp/Fw0CIyUaY142/hvrN9ROCERd5PeJqNWhayxEZTLYYDDg+PgYhUIBhUIBxWJROk/r9XqcnJzIZWWynxQQgQyNoUpHkSZTqUN+HxsFMn/BiYBq/maRxZY8zPtMp1MRX6hdj0mLkcplkSI/Ex0NHXo0GpVO3rQPwLl4gT3z2GrGYDDI/aPKsFqtSldoAGLg+v2+gEnKu9VkNPeaZ5DOhZJyAivSTjyziyx1EBmfIYUhFDEwYptOp9Jxm2DC5/NhdXVVfo77SEdN+TS7jTMHqtPpJAozGo3SsZ0J/KOjIwHiPJfsBXh2djbXG49sxsrKitxlfp7hcCjFxBzsx1om1iSyh+Nl1qWdC+ewczZzp9PB6empFE9Go1GRbzJ5zeTSeDxGIBCQQU5UQRF9dDodcQ6qzJDUDqtd8/k80um0GBHVCPLisvmf0WjE/v4+jo+PAUB40KWlJXg8HhwfH+PFixdStKbmIGjA+bDUwU6LrkwmAwCSR6GxY/cAAIISWq2WDP0iNUOqrNfrIZvNIpfL4fr16wgGgxiPx1JnwN/NwkwWDqrVt6zJUFU3rEngPjEKULlfoi02ESUlF4lEYLHMpu+Vy2UprOOzpFJFlf2+6br4cyoAIAdNDpuOR83T6fV6RCIRAQlsbcOK+KOjIzSbTSwtLcHv98sz7/V6ePLkiRRFTiaTuW6/FKeoRcKs08jn81IcTGNEvp77xffPepxcLjc3fz0cDiMSiYixfxtajEP1WA+m0sD1el0AHdst0Zm53W6Ew2Fpac/P2m63sbW1hc3NTZydneHx48cyroCycNqCWq0mURq7ZRDc5PN5TCazefGZTAYGg2GuV5zL5RIpOQ2sWm/F5p5OpxMnJyfSE4uGlgCNEe2ie8ioisZ4NBrJaAHmUKleJRugaZowNFR4tVotPHnyBMViEbdv38bm5uZcBMTOBYVCQQA36en33nsPt2/flg4pzWYTe3t7KJVKuHbtGj744AMppTAajUJ309Hr9bMOzu+99x7K5bL0FeQZTCaTAoQonQcwJ+Z5586FIaHnV5P1WElLdMMvJkdJT5HOUVsYED0y6aVpmhg3Xmq1uIoUDzli9VIwsmA4TpqOf09kw8NFZEHjQiqMKJXGlfkNvj9KdheldeiYzObZyFOqMiwWixgefg5+Pwse1Vk3bFoXDAZFIKFKEfk9NAxq3kOlrKgYUvdQTfxbLBZJYJNCowKIRpKGm5eVP8swHYBErm+SCPxNi/umRlfq66viBC6+Jl+XUZMqCFDHvapfai8qLkpiaTgp5eXFVBPU3DOKNvjembNRzxsdl5oMZqEez6zqvN5mD0mlsHSATo77AkDuMGkT9gBkwZ3BYBCaklXqPCeM+AjSSFuRJiRVydehQIVnczw+7/6r7rvajoR3necKOG/YyLuqnmnaKb6PRRftl5qwV8ULaomAahsZSfBZszCclCDFEoz6CKxZngBAHCRb71A1R6dGEHjxHlBIxd93URrOvaYT4+ei7WVkw/P6/5XeYhcrxtWqTpVD9Hq9UszHCuabN2/i8PAQX3zxBQBIgSX5xVQqhS+//BK1Wg3xeFxyGyrSIKV169YtSU4xKdjr9ZBKpbC7uytyVeA8WcqkLAA8e/YMe3t7sFgsWFtbEx6arV+YVFxaWsJ0OsXx8TGq1SoCgQC2trYWNpDsc0T6i7M0gBmiZHU3qYa1tTWYTCbcu3cP6+vr2Nvbw2effQZgNjgrEAhgMBgIekkmkxIh8MCxzmVlZQXRaBQnJycSivNw0zjy75xOJ6LRKLxer9BAakEVnRGlunyd8XiMa9euIZFIyGCzwWAgAgrWTyxKi/F5kGais1adG/ePwIWOVS1GZd5QbU3D36l2eGYkDEAcPKk+VqXTSAKzxqGkmgie2M2CTpd5hmQyCYfDISKM09NToY7D4bAYUtJ6bKlDCmvRtba2JoKGZrOJSCQi0vGTkxNRxjEvx8/v8XgQjUZRrVbnar00TZM8J5+Jy+US5M7eVV6vF7dv38by8jLy+bxI4tkOiDOTKFEmYlbb7/CZ9vt9iU64z9PpVBpd8o7R6TGSmEwmiMfjWFtbWxggptNpOQ/BYFDyvbQJVCDSieRyOUwmswLs9fV1GcRlMpnwySefwGq1SgsqJs6ZW2IeKhqNSg7YaDRKQTn/3O12YbfbUSgUYLfbBdTT4bB7OnMtBEts+kr7l81moWkabt26hc3NTbnzBAhqIes7z7mw47A6A4SqhYsRAtE0MENLfr9fZqYA50iIxo/5AKJBNWohSiLl5Xa7JYFNA9FsNkWKy4esvg577jBpW6vVEAgEJGwmcuDPUYk0nc46C9BxUsG1yCKnGgwGEY1GxbGqNTg03izCY3PApaUl6aumaZro+1OplNTBsEmeKglVHTSjJD4nUh9qCMzkIovbgHMajzQT3ycNtfreqZPnGeElZtTzJqjn4qLogkAGmHcsqjxW/SLFR/UR6Ridbtbvi809+bsYkRF98llQ4sqZQ4y0iV6paqKBNhhm7UwofGGtFGXmAOaADWlPRhOMnMmXA/OjghdZrMXg82ALEhUgUs6rFtjROfLPwLkhvdiIlVX1pPGYC6NBps0g968WSfJ1GKnwTPLf1UJN7qFaIsFyCP4daV7ee9qvRQEiaSVS5WoBNM8MPwMjCN4tAhPuWygUgtfrle4SBOtUhvIc8M6SZaEIBDgvwiagJ63Gkgc+T9pY2tKLY8xJMQOzSId2qdfrzeWaeZfeuXPheEvKB2lw+RA1TcPy8rLMcTg6OpKLSvSvDvhiroUtVxKJhEjlcrmceF1uPC83eU8W5JXLZelttbKyIn2lnE4n0uk0MpmMJLeI2iKRCNbW1nDr1i3odDqhQThzJJvNSo4pl8vJBDuKFf7gD/7gjQ8mJa+tVkv6IB0cHGA8no2GbjabiMfjePjwIQaDgbQGefr0Kfb39zEej/Fbv/VbmEwmyOVy0nMoEAjA5/NhaWkJw+EQqVQK1WpVnGC/38fx8bFU5XKsLfMClJQWCgVRpiSTSeRyOSnspHpJzW9QwWcymSTnwgJZlY5ot9tS+8T+VIusH//4x2L8KYhgoR3FBYlEAhsbG2i32zg8PPy112OrE9YMkAcnZz8ej7G/v49MJiPqNrUugPNfiBD7/b4400wmIw6JCqxwOCy9yHiOKHOntPyiUysWi1LfwX10OBxyp95msacXE8FUYlosFhlQtbKygkgkIpFYv9/HwcEBTk9P0Wq1RG7darVwdnYmkm4A0i/w+fPnokZjIfSzZ89weHgIj8eDlZUVTKdTqedh/o7gg4orGk4qSovFooCdXq8nz1ztO5bL5UT0w/wAI0S2U1n0DPKZULRit9tF6PLq1StUq1XcvXsXjx49Eukxx1Tv7+9Ld5DJZIJXr17JHnAGDO8k86VWq1U6U18EzmRzRqNZT0LKvAGIkMZisYh6TP0CZk7E7/fPTdcEZumPs7MzjEazpqJ0Ujyr+Xz+3dNi1WoV4/EYe3t7ODk5QSAQwMbGhnhpnW7Ws+jRo0dot9tzjoF9d1TnwoZ9RGXxeFwuN+fG8/uLxSJ0Oh0SiYS0vWZ/KFbwmkwmLC0tSdNHFniyHTu9LZOTq6uruHv3LgAIEi2VSkgmk3MhNVF5rVYTjfoii00W8/m8yGl5UcrlMnq9HhKJBO7evSvJ1WaziZcvX6Jer+PmzZv40Y9+hH6/j7/5m7/B8fExbt++jaWlJcnBAMDjx4+FswVmzoVSSO4fO86Ox2OJjMxms3TzPTs7w3g8a/efSCTkefECdLtdiVbVxP7h4aHQRZRcrq2tiZKQaqRF1j/+4z8KejIYDNImhxJO9qC7ffs2CoUC9vb2ZFYJgQX745H6ourN6/Xi+vXr0Ol08rNGo1FafLBGhQl25qNY9e/xeGTAGBV+pFeJKkkPMo/mdrt/zbkQwDBZTsdNmenbTPIEZm2V1EVHSHk22zcxn8d8SCaTQa1Wg9frRSKRkN9VLpcF3BCds8PDaDQSOm04HGJnZwetVguffPIJbt26hXa7jdPTU4xGI4TDYbhcrjk1JqMVj8eDSCSC2q+mtzISGQ6H8swZUZFC3N/fh8/nw/r6+lzUVa/XRdSwyKJz4dlmu5nxeNb48/DwEO+//z7u3buHdDqNb775Rjp1k8lhSmF/f1+mgJKZodqQzpOOBYDcP0ZmBB7AeVcJlRKnc2FuVS3GpgP3er2IxWIC0ADI2Ayq8wAIZT6dTkXNd5l1aedC3tJqtSIWi0k0QFUY5YXpdFo4OobL3Fin0ykel16XYRwpLiq9SF8A53SASikwTGZ4TREBDTiRF1En/40T1fR6vSi4qBsHILJP5hGowKKaY1HnQkPF8FRNRhOlATMnXvvVjHvmBhgh0LBTb85Cp9FoNKfi4MEn6uBlpJHkc+Hr6fV6mfnCZ0M9PyWwDJsZGnOCJ/u8kV4qlUpCj5G/d7lcohBcdNHwBINB+Hw+eL1eeY6UqjOiY4EocF5hzvwLaS7uPeXodMadTkd4f36PWtBHepe/k3kenU4nykNV1sl9JG2xtLSEaDQKk8kkzoISaEYpfN+kiJmUfZMRs79p8XyQyqPyj6pNFh6yB5bajYBIXRWCTKdTGVUBzBwOG3CqiWFShUajURwAqUmCDjIZFzsu0HAzZzCdThEKheQeHR4eCvUDnCNyCkp455jzUgsL33Qxj+dyuURkk81m5Tk5nU50Oh0cHBxILopAixJ39gdUOx3wd7P/GOueGPmr4gqeY+4jhUnsV8bnSdUdGRC+D71ej/X1dfj9frFvrNVSUwTMXfNzMXVBmfdl1qWdSyqVkiQl+4eRJvL5fLDb7ajX6/j8888BnHPgqsKJ1M3BwYEMpCGvyv/evHkTdrtdEvSksuidWWHLXlNsl1Cv1yWyYDGgGnJSj37z5k1sbm6iWCzil7/8pRgPcvTsPUTDwaiG73FR5+Lz+URWzaJEfhaOJwCA169fo1Kp4PXr12i327h586agM8plM5kMisUizs7OYLVaxZDTILJIjftAFQoNr81mk9c8ODjA0dER8vk8Tk5OBFkbjbP25TxMPMQ3btxAJBLBzs4OXr9+Lfkcp9OJTCaD/f19rKys4O7duyJJttvt2N/fl4hokUWDf//+fdy6dUsog06ng5/97GdC29BZ0BnSuZA6YP6IHSfOzs6k/mc0mvWDCgQCwl/TaQCQWhf+Ll44XrZQKCQSfY6PpmHlWINHjx4hFovh22+/xd///d8LuKD81ufzSXdkcuJUajICW3SRdmLxH/NANEa5XA7FYnFOvq/T6SR6AiAiCLYGYbV/q9WSXmTT6VReg6/JeifSe6qCk6UGROws7uVsnHq9Do/HI9267969C4fDgS+++AJ//dd/DaPRiGvXrkkfwBs3bsypU1kMOxqNhB5e9AwaDAYsLS1hbW0NrVYLX375pRRjr6ysoFwu46//+q+ldqrb7UrHjEQigfX1dcmvqW1+3G630PkcJ3FwcIDHjx9jOByKgWc+rlwu4/DwEL1eD8vLyzIjiPaOvQB5J3imXC4X/vRP/xSffvopHj9+jP/zf/6PRNk8h3Q2POPM7bCy/7L7d2nnQq6OBWREOsB551OiGPKczGewJw/ROhN6aphGFMMwlsgEgCS21MiBP6cm//hvlEaS9lCVL/wZ8pjcKCacGSWp0RP//DZ1LmofIYahdGocWTqZTGQqpsqLM+ynYVSlj2qTOqpnVMkpLzEjI+4FHSgvM6M3tTANwFw/JyaDifSJAlUZ+kU5MikJRjyLOhe18p4yXSJjABK5sh0IANm3fr8v0S3/nnJidgNmlEYjyEianw84n19+UdpMJ8DolEiTe8d9Us8q95k1OHxOlPhf5MnJELzNUj8/E7M8O7wLdJb8PCr4Y05JlfpPJhNRPJHm5vfz+fBu8fyz5IDSftoEng3eO0ZBFF7QflAgQSaD+802KqTnmLRmlGaz2eByuRZ2Lmq3DIfDMfcaPPPs3sA2SEwDUHCg2iIVqDIy5EgJnhGui/eMZ0o9g/w+tdaGohT16zfJwtXiVJ5TtZBaLVF455ELW7az941a1EVVAesGmHzXtNkoYQ6vSqVSIrMMBoNSxMOW+1arVZLbAGTuCYvafD4ffD6fbDQNSr/fh8vlkvG9LBqKRqOSDCwUCsJrHh4ewuVy4eHDhxgOh/L9qnPhgyXC5edeNKT+5ptvRK3CflR+vx8AhG9Op9PY29sTY2K1WqWvlMPhgN/vh16vx507d3Djxg257Hw+jEj4PpmjYK+rfD6PYrEoqrvJZILXr18Lwvb7/TCZTIjFYr8mk2TV+M7ODvb39+HxePDDH/5QniV7aEUiEXi9Xpkn0+l00Gg0kEgkcO/evYX3T40o1dwB80Yulwv1eh3Pnz+H0+mUYWH5fB5HR0fSY440GtFxtVqFxWLBtWvXhPJhpEPpNIGBaixJCzE3yBxftVqVgU3sBkHDBgDffvstvvjiCzgcDnzyySdifDRNQzweRzgcxu7uLv7pn/5J8pF+v/+tO/oC5xSo3++Xu8ViWrZmoSFkMt5isUghHs8b5bKUBp+ensJgMEhymPJ2u90uQhYWVNORAOeAQU0mUyBEyicSiUg1OYsVWWxqsVjwox/9CADkbNA4A+cGmc4gFovJni+yeP+i0ahI7rkCgQCsVqu0uSKdrdPpRGRzdnYmdCBzRnTowHmeKZPJ4PT0FIPBABsbGwDOnQejP5vNho8++kic+2AwkE7vjUZDOn+vrKwgkUhIgl6n0+Hk5AT/63/9L+zv74v4ge1lWAZx8dxQ/HP37t13n9Cn0aVMlYeCnDORA+V/fLDkwtmawWazYWNjA06nE6VSCY1GY64CvlarIZ1Ow+12IxKJiOabkuZYLCZGk+oF0nNU2bD4z+VyIR6PiwSUqp1GowGXy4Xl5WWRQBMZUgGnOheqJd6mzuDs7Ax6vR7Ly8vCuxJ90HGfnp4inU4L30nKoNlsSt8hi2U2hZGcPRNsjAwo1SaSYq8w7iMl0eTbSdWxPxYb11Fnz9oBVpqzavjevXvY2tqak/my8R4ROGmTTqeD1dVVvP/++wvLQFU1TLvdFtqDBsXn86HZbCKbzWIwGIhsk/QE+2WpRZWkDZiot1qtqFQq8ndUual96NhskHkGnlsWuPFsApB6H6JB1secnZ3h/v37ePjwodwR1mGEw2EZdtdsNkWSzDb+b1OISgaBBpdyUzoLSqpJi7D1O/eE9Ch/nt9fr9eFzmFLJtZrEWQyylBp4YsFe0TMXKTX2KCU55XUj91ux82bNzEcDiVfSNuk7hPReiwWw/b29sJ7SNrI5XLB6/VC0zShjelcaF9Yo0Iw0u/3JQdsNBrnWiYR0NAm1Ot11Ot1GQ3OZ8e8HJ0/lXus+1GjJyo8rVar1Igxmq5UKlLGwLoYyqBdLhfcbrcoeslqDAYDEUFdthzj0s6FyeVKpSIqho2NDcm5qI0OKYklzfD+++9LCKnX60UZQ56ZU+rsdjtWVlbgcrnEU9OgkVpRGw0yaiISUAdstVot8cacW0G0QBRE+ok/R+klDbGaeGMEsKhzqVQqkni8SP+xKyxrW8bjsSQf4/G4RDjs+ExaiKiZ9AUN2Hg8a9GdzWYlT8WqXrY0yefz0mn2+vXr0q6CCWYaDlaw0zBTpUXp6mg0EhqAFBO/KLUkF8zCNyat32SRBuWzYcddGiC73Y5IJIJ6vS7NSqfTqQyPUmtjgBnSpdKJ6ixGwKyJUgUIdGLsWs1cDpV0rDNirkCtF+KzprqJzn9/fx/A+Xyeer2OZDKJs7MzoXfY1r9arYrM+1//63+90BmMx+MCENmShgooAhD272PHY51Oh0AgINM5U6mU1K7QyXh+NYlWpUBJY9Xr9TkDSiemDq+jMIVOmvQsI0kmtRnhUMFJcEuASxqNjoiR6uvXr5HJZFAul1GpVKBpGv7wD//wjfcvFArJe67VauKIeaZZBMvCVLWoNhgMShGtSrsbDAapuePn4NA4tWaGYGAwGKBYLAroBWbANZPJwOPxIBQKodvtirprPB7j7OxMKG113yi2UZmgTCaDbrcruZ3JZCLdkwnyyZ78c+vSzoXTIZlcDwaDuHPnjhg4k8kkcsl8Po+nT5+i3W7jo48+ws2bN6UvEaMb8q6JREKmVLLgcTweo1Ao4Pj4WDq4Eo2qiTkaFhZuVqtVqQputVrSlZbODIBI9OgoOWWR/bwKhQJsNpvIMYmC7Hb7W80w58hcImFGCjRY7NJLxQlzBw8ePMCdO3eQzWbx8uVLkY2qlfEcoEXUR4NPJc3KyoqMGOAgpb29PQwGA1y/fh03btzA/v6+DAeiwSHKpNLFYDBgY2NDFH0mk0kSufV6fU4dRCNO7pmD3gwGw0L7SMRMJRoNkqZp0nKc/Dopr2azibW1NUSjUalhGg6HkjtjBT0Hjw2HQ6mVSSaTeP78uVBGzI+RJmXxGfcrl8vh8PBQ8hcUmvBusNMEo9d0Oo0nT54I3aZy54xU1AK4fD4vo5UXXevr6wAgIg+2ozGbzTIQjZXapKdGoxFisRj8fv+c1JwOZnNzE5ubm8L1Mwriv9Nu8PxQGclIhUY4nU5L1AxAHNBoNJI+aGq+VS1SZDsfGm+2HGJug4XQwWAQS0tLCzsXdtRgeYRagEzDTtBTqVTw/PlztNttBAIBJBIJnJ2dSa0RcxcUkLDr/GAwkOp/ni2eETWvyAh6Op3i9evXODk5kS4kpLhZH7W/vy/7QXk3I6vl5WUMh0Ocnp6i0Wjg+PgYBwcHiEajeP/996Fps5EPVOCyoeV//I//8Z/drzcec0xkq/bmIrWkzo3momFXBx0xGiBCZ0tyNdFGVKTKammkKI1lkpSJWx46VdMNzA4jEQ2RJPMaRL98T/ydvAwX6xAW5bzJJ1O+yfet0+lkVMF4PBYhBNEsLzn/DJwPe+LhVhP9rAeo1WpSK8EELENrXj4AgvgYGQAQdRmjIL4Gn5mKHBnd0BCR2qAx5WVTZ4gsshhJMllJaoDPXu3yrIpGKEnnz1yUufLnqMQiSFHPLB0WPwtpMRU5Xzy7Op1OohcAQgXR4PHZqt/PvSX1wr9Tx9e+zVJ/XhVpqEZavUek0fh8WUOhGm61qO+iaIU8v1p5T9TO6JqUukpVsgqeLAcBCqNhFaSRkWCEzYiKSlI+U94XysYXWaRC1WeuOmLV/qnSYZWSZkRxsdehmpxnRERnw4hd0zShFmmTGHGoCX8+C35WOntVfEDApJ45UrtkAhil8feqdPBl1qWdC/k9TZv182KiUtM07O7uolQqodvtSjKPFNbp6Smy2SyAc6UWo41MJiMDwZg0V1vCEBHxwO/u7uKzzz6Tg2MymWSQGBETD6KqFBkMBjIilbkYNczm73O73VI8yD5iHJRTKpXw7NmzhQ/m+vo6ptOpSBMZhbFSf29vD9PpVFA9L/1oNBJUTcPNHBIji/F4LO3Mnz9/LnJBRjWUE+7u7mJ/f1/yV1arFdVqVehMDmPKZDKCvrmn7XYbOp1OBpXxPVLiqLZQiUajuHXrFoBZApudmFOpFADgX/2rf/XG+7e1tYXpdCpzfvx+PzY3NyUCzWazomBUVU0vXrxAv98XqoYgSa/XS58rGnMAOD4+xs7OjtB80+lUivdoUChdnkwm0inWaDTC6/ViOBzK/pBiKxaL2NnZkcI4Gj0KL6jcYWGx0+mUouKdnR3pR/W2ajFWVzNqoEGbTCYyW6VcLgu1TTl3u92WVuyUvDKRTE6eoFOlywqFAg4PD4UeVNWLhUIBX3/9NTqdDvx+PwKBgNRJud1uPHz4EKFQCKlUCtlsFuVyGUdHRxgOh0LDNRoNUbtRmKAW1Xo8HozHs9HmpPXVfOqbru+++w6apiEcDkvOhEKO09NT6WyRTqeFgjYajYhEIjJThtEY7QiZFp/PJzmr169fy9BFSrrX19fhcDhwdHSE169fz4lFSGGxMJd3slarYWlpSQqnWWrAvyMNq9PpZGaRyWSSrgdOpxPD4VAioOl0Nk/psuvSzoVqF+Cc8+T/U6euzgzgISYPfTG5R69JCoZJOhpVJlR5EHixmbsgFcQCSTVRy99BFEU5KlESUZvq2YmoSGWwgEhFtCq6f9NFOoXoGjiP4KhDVxPuRDVsj86/u4iiaTiZo+HAICb4VUTdarWQyWTmJlgSiRMFAeftQch7q0VcfE01YmJEQHTNWhuiKSIeddbHmy72OxqPZ7NuWDdCNMfGk6rknFFOrVaTs6RGnqRnWdxmMBik1kOlYXjeCZ4oBJhMJnIOCWSAc9k5n9dkMpEGq4z2GdkQ2VIWStqOtAejK/V8L7qIgnmXKEkGIFGA+mzVvBkdERP5jEJ4Nni2iYwZUdIBqUCO/1apVGToHSldnkcOX2M9HABJLDNnRwdIhD+ZnHdHsFqtAhYp0uF9XpR9YNsXqmVpD1izxg4WBFp8PToAJugJQFi8yqiLdostY9gUU41wGcHxjqrRoMqG8DX4zNRxFxxj0G630W63YTAYpMuE2m+Rr0lQS5bjsuvSzoVKKRZGGY1GvHz5Uv49EAhIzyYaExalkRNfXV0FAOHv/H6/JLJI1zAJFo/H5eCzGEnTNHzve9+bS/adnZ1hZ2dHFEPj8VicT61Ww87ODvR6Pa5duwaj0YhYLAaPx4NCoSAFdKxyZ8sIo9EoirNsNotKpSIa+UUXkX8sFhNEkE6n5SLTONPZMiQlRROJRHDz5k1Mp1Mkk0mZJMd6ALWpJi8mez7t7u7i+fPnKJfLc9TFeDyWORE8TKwUZuJOp9PJxdHpdPJ7y+UyMpkMjEYjHj58KBFYMpnEYDAQOabJZJIpd2/TuJIoOpFICG/OgjgakIs9lqbTqdRk8d8JbFRHQOdB5VyxWBQkqdPp5CyTKgIgSf/9/X1UKhWhPoDzVvLZbBaj0UhUQnRGoVBIaFD1+5kwnU6nkh+iCIVR0NtIkVVOnjw+E+/pdBqDwUD6TZFS5F1W94RnlU6HikUacEqrbTYb3nvvPXHUjI55FtRZIYxuWXv1zTffYG9vTyIX1tFQ8hyPx1H71Vh13nnVcXLPGIGrir5F93B1dRU6nQ6rq6uIRCLSG1G9w2RtKCigwqtSqcDj8WB9fR06nU7AOHNzVIuSvmbfQLbYoiIuHA7j008/FaqK0yKbzSasVqu0mjEajTKyOplMotlsSiE5bTRzu4zOmecijcZ8K9WrBHCXrRO6tHOhZps1GpVKRRrpxeNxeL1eqahVQ+alpSVRUDx48EAaB5ZKJQQCAemUenBwILPd6fnj8ThGo5Fotre3t3Hr1q25jX3y5Am++eYb6YPFS06BwdnZGWKxGK5fvw63241oNCpOgvQPG+JFIhEsLy9LkzzWxzBsfRvUw4sRDAZluNJXX30lyX0+dDXvA0DGEK+srOD69evSZp/tvwHMVfACs5qXYDCIa9euod1u48c//jFSqZQcZDUXVSqVcHp6KtSFy+XC5uamUDzqFw8ZLxZFGTdv3oTP50O/P5trTsfJ6JOiBRrfRfdP0zQkEgmEw2GpUCZaJg3Leg2iQCZGudTcAP9fdS7M0ahyUwCCLHnxfT4fhsMhfv7zn+Pp06fSr06VgLNjNXMW3A+KD5i3Ac5zjIziqcqicXS5XG+lVgRmDpFcPRVtnG5KOSs7jvMzDwYDcaDsuECHazQahbWgYWI0A8zEMysrK3LO6KyYg2F0RkdFtN/vzyZXTiYTGftAhsHhcCAcDmNra0ucN4UWer1eKvopNCLwuFg8uMii2m5paQmxWAypVAoHBwcSIXAR5VPdORgMkM/npdsGqUGCHrPZjHa7jUwmI5J5Nu1cXl4WOrrZbCIWiyESiUgDXOas2+22dEcHzudHsQiV9WZqyx8qaxkx8zOGw2HptUia0+FwSFT7zoso1YQxJxqWSiVRH3CTwuHw3KYyTFVlqWpVNL08v8/pdGI0GsnI39FoJAeRyX0eyF6vB7/fLwVwpBuYo2G4BwDJZFIku8zDqPQdDQ2pDzbddLlcc2H+Zb32xUXUTH6YdJZKL3q9XpksyT2s1+tCgRGhRaNR6PV6yZUA54oYtdK63W5LcpDvgZ2A2T6HDo+0i9qDiclKNY9AYMBnpmkaUqkUSqWS/E5eXhpMtRJ70ZVMJudyBZT8qjUa3F9VbknagZ+V8nd2f2W/JeZjWC/jcDjEQfH3s0gNOO+jxToCSukZDTBC4tlinoyUL438xSQ784Wkoal4JHp9m6U2RuTr1Ot1Qdf8DGp3BjVBTnk2nSTfE5ug8hkQhI3HY3GgbIoaCoXkPHKvePcZhVJuSxoxGAxKIpsRDA1joVAQoQ7fJ38XpeThcBhut1tq3RZdpI5JtbI7OKMt0nmMlikK4Rhjp9MpjphMAGX64/FYom7uu3p+mANsNBqwWCxSCAxAWrcwJ0LqTBX+MAJhsTtzVKoohpF1LBYTW00Rh16vF3DA5/fPrUs7F7Z6YX1Eo9EQdErO1Ov1YmNjQ9o1cGMdDoforXu9HkqlknDQRBls2+71euFwONBsNqXRotPpFAkjpczsRbS5uYnt7W3paMw8AABRPVQqFfz85z+faxWitq4hjzwYDKSFP5PPLHosFovIZrMLG0iv1wtgxvOn02kpcGK+ZDQaYXl5GT/4wQ/QarXw4sULVKtVZLNZqdthT6wHDx5gPJ51kN7d3UWlUsF3332HXq+HeDwOn8+HVqslyXeiRXZC6PV6ODk5wWQyQSgUQiwWkzwUde1Eqk6nUyqmR6MRTk5OpJ1KIBBAr9fDF198Ic6HvC+NOavB2+026vX6pVHPxfX48WPJKbFDNw0ae9vR6JCeGI1GkqBmFbLH48GtW7ewtLSEL774AtlsVro/WCwWbGxsCO/MC8dcISneQqGAp0+fShv+WCw2VxOlto8hki8Wi+L8aPw4lRKA7Huj0YDb7UYikZC6L6/Xi3Q6Ld2GF12UwRI08A5rmob19XVEo1GEQqG5xp6MCtlt4fj4GHa7HVtbW9L9Yn9/X6JFtW2M2i3j+PhYqHAOLaMjo/GnMWT34mKxiJWVFcTjceTz+bkuw4y4nz9/PtdOZWtrCysrKxgMBhKRP3r0CEtLS3j16hWePHlyaeN4cZEGZA0YpcTD4RDZbBbD4RCBQAA3b94U59Nut3H9+nUkEgmJNgAIyGs0Gjg7O4PH48GdO3ekEJM9AFlv1Gq1hNYms0Nnx55kOzs7+Pzzz6V0gPk+RhuM4FivRBqU4HU4HGJ5eRnvv/++nFcm9Fl2sLOzc+kz+EaTr0gd8IuHj4l8DiNitTtRhKpPVyWP/H8aHCY32XiRtAATchxCpb42uVRGF6oKjIiUunoA8pCoNKGBYhhJLw9AiicZlZEPX2TxQjO/xIvIfeF74esyaaqiFxaT0Yhxf3kImLDlfpHWICXAL1XeyT0aj8fy/ijb5h6r758CDUqrKUMnXaRWXV80sG8SUl9cTFyq0ZnaV0pFaETbamJSXTx73GtVBswkN9Ef94cFr/x/9fu5Fxdfg+eedVLq/vIZ8L3yHPBsqEWYbEt0sfL8TZdqVGl4eKcv1osAkLus7hGjQFUarYI2/h61hIARF7+PIIbnms9WzV3wPZK14NwZPndSPZyuSDDDM8ZzRjqNUy3fJoImNczENuk9fnb1vfNuUsHGdkrM2dH4q/frYj8vNe9F26iq/LhoC+jg+ft4Vnj/eNYo1iAddlFCzpy6KooCIIKnd+5cyJdTf99oNIRbpKTT6/UimUxK1TlDUYa/RID8gKxspTdlLQDlupVKBUajUar2V1dXsby8jFKphG+//VZG17Ja1mKxyMaNx7Pit0AggEAggOvXr6Pf7+O7777D48ePxViYzWbpvUXtvMlkEq6TFAwTqoty3jTewHzjwF6vh2QyKZ+JHZhJwayurkq+54svvpDLNR6PJccwGAwQCATQ7/exsbGBlZUVyR1MJhMZ6MTKXx4qyiUpBaeRYb6MCXi73Y7V1VWJNNl9mheCLchVWoWfbzictQZnh+pFncsf//EfQ6fTSReDQqGA3d1d4etJiZIfXltbk/wbq6LpdL/44gsRKvAMHx8fi2KLSfhMJgOLxYL79+8L3cHWGESidBY0DKSOBoOBjI0OBoPY2tqSRO4vfvELmQ9kMpkQjUZFvKLX60VWytEGzNdx1PiiS228qmmaSICHw6H0AMxmszg5OYHdbpcx4HR4LA7kvaMacW1tDYPBQCiZVquFVquFer0uXaTff/99BAIBmEwmYQDY2oY5CUbqk8lEosxQKAS73Y5oNIqPPvpIOiJ89913yOVyYuQjkYhQVFRara6uwmKxSKfq4XAoYoVFFqks3h8VWJDeYmQPnLcGAiAdMPL5PICZMyIdyCGHavmE0+lEsVjE0dERbDYbHjx4MEdf1+t16ULNiJbD3AjEVfEK2QeC1NFoVmjNbvds28QuB5VKBQcHB1Ltz1zi7//+7196v96oiJIogAiA/CdHdfLPbrdbDgWNCVGIqvFmYos0BgCRsFK6yvDZ5/NJEzuj0SjjWSn9oyyPD5pIhqFlMBiU9uwvX76UXmHkGNVZHDS4VG6ojTEXTQaqSJbUCVtA0GhnMhlo2qzi/Nq1a6LZdzgcMnuduZTRaIT19XVpvcPQ1e/3IxwOy2wTnW5WmUwEzMOm8unMifF9EkET+bACmXQaFX104B6PR7ogq4ACOC9gVVvCLLJYN8OfJ5/NM0dkx3oKt9sNh8MhQIOL1citVkucM2WxwHmE1G63kc/nhSIiomQ3X35O5sT4bJlfofHl+dve3oZOp8PPfvYzUSkyQiCYYEEnxx2zVc90On3r3nYA5JkQ2bMWhLRVLpeTVkk+n09ye1wEbsCMAdC02bjecDgs+QBGPxTuZDIZeL1e+Hw+rK2toVKpCGgkYGWdFHteGY2zWfFqzRvvcr/fx97engxfI7PBkc0UE9FmMIHNc/A2is+LhcTA+ewk5orYQolUK0ED3wMBNHN3er1ehCOMuniWy+Uy9vb24PP58Omnn2J1dXWueDOZTGI6nc6JGFwuFwwGg1D9ZCtoIxmpDIdDlEolnJ2dCZhmxE7VKqXiFBnE43Gsra1d2gZe2rns7OxAp9NJ/oObQn6ah46L4TU3noWIk8lkrgiJHpuSOI/Hg3A4jOFwKON6KbttNBrY3d1Fq9VCMpmUthu84O12G1arVRpjUoAwHM6a3LEIbGVlRWpKnE6nDBfK5/Oo1+vSjkan08lwKFaZL3q5WZnbarVQKBTg8/mwuroqzQGp6iCvS/TDxo9MCJMGAyAFeXq9XmTKbrd77iDTcLFtDpN0DG9Ho5FQhKTDKDck8gbOKVF+n91ul1ZARJ8s1lQdFdVSKtW4yPriiy+gaZrM7Oh0OojFYnJhVKdFSoCUHBVYzDnQIaqcNvls0i+kYvR6vbT6oFS+Vqvh5OREktUsVqWUOBaLCfVbr9elyShwPjmVij5SJ6y3sVqtCIfDuHPnDqbTKR4/fox0Oi3jld9Giky1WL1el2mxy8vLEq1GIhGpY+IZ5B4SBPI5qnvL/Sdtw2fEhrV6vV4AKEEGnQtZEObKGIGsr6/DbrejVquJGId5WUbUbOdCpE9jyvwvv485DALURfeQzpDqrFAoJDJ7Dt9S65K4D0z40wGTvqKYieIeipYIAtQzmMvlJNdDQMW7xZHKjPToXAjm2Q05HA7P0bLBYFDubTwel1z3ixcv0Gg0EIvFRIDF/75Jl5JLO5dvv/0WOp1OKkMjkQhu374tFBhlyHQSRFxMFJHqslqtePDgAcLhsGwsNdiTyUSMf7FYlP5aqVRKKlk5KY9FiWrCu1qtIhwO43d+53ewurqKo6MjnJyczBVekaLgQeSIYJvNJiOIXS4XIpGI6NNJu1Wr1Tc6jOpitTATs1tbW/jggw/g8Xjw/e9/H3a7HY8fP8ZPf/pT6HTnfZ1IKTFcJuXEBD2FDpubm9A0TfaCuRFKgIPBIIrFoihT2CCTaIsCClJjAOTSAufOhU5L7fjLvzeZTPB6vWIsKfwgUiX1uMhiZ4bV1VVEo1GhDAGI2IFKP7UKn3mXRqOBly9fwmQy4Qc/+IGMeOCgOVI6nKzZarVEMcYKcUY6jUZDqsXVPlnMNXJ07NHRkTi0XC4HACgWiyiVSlheXkY8Hpdn3el0EAwG4fV6sbq6ig8//BDdbhefffYZXrx4gel01vKceYtFFimh4XAoDT43NjZE/UWneXBwMAdwSLP8v5wLa0v0ej2uX7+OWCyGbDYLt9uNZrMpg+7UnAJl44zYPB4PEokEXC4Xtre34XQ68cUXX2B/fx+xWAzXrl0TKspgMCAajWJzc1PUaKzeZ8NaRjqnp6c4Pj7G3bt3sbW1tfAekj7O5XLSqp41KhwxUS6Xkc/nRZzEURBUj1UqFXl9k8kkjoqUnnq/2RmZUQqjPv4Ou92O0WgkXStYEqJGzIw+OKxR0zSJFEl1mUwm6UDP8g3KyKfTKXZ2duQzsFvFZdYbDQujISEHyyTSb0qeMvRWq+Xp2fn9qtyVS/07tR5DTThSesh/u/ilJrP4d3xPF98vX0+lNShRvmgI+fOLLOZvVMEB3wdzP+qhV/eOf1Z/F/foYuUx39/FpObFZ6P+3UWhxsX9+n99JnXf1PejvtZ4PJ5rpb7IYv8vtS5FPX8XX/vi+1A/m/rcf1PS/zf9LJOePMOq3JmJcS719/Lv1bP8m17nYiKWX+rrXPz5N10Xz7N6Fwhc1O9Rz8//a38unjP+rouCDlKt3HvaAnX/Lr4nfmb17qrP+GKC+zfZFJ7vt7m/6vpNv+/iXVDf78V9upgov3h+uNSfVXOipOfUs6WCQr4fvjdVZKDeFfX+8EsVJvDPquDkTWht3XRREvxqXa2rdbWu1tX6v6zFCdyrdbWu1tW6Wlfr/7KunMvVulpX62pdrXe+rpzL1bpaV+tqXa13vq6cy9W6Wlfral2td76unMvVulpX62pdrXe+rpzL1bpaV+tqXa13vq6cy9W6Wlfral2td76unMvVulpX62pdrXe+rpzL1bpaV+tqXa13vq6cy9W6Wlfral2td76unMvVulpX62pdrXe+rpzL1bpaV+tqXa13vq6cy9W6Wlfral2td74u3XL/xz/+McbjMZ4/f47Dw0MMBgN0Oh0Zl8q5GLVaDU6nEzdu3IDdbpeRoDabDT6fD91uF0+ePEGhUMDS0hKWl5dlMBhbs3O+tzpznSNunU4nSqUSnjx5gn6/j9XVVQQCAayuruK9995Dp9PB48ePUSqVZCRuq9VCKpUCANy8eROhUEjaTQ8GA5RKJXS7XSSTSWSzWZlkaDKZ4PF4YLVaEYlEsLy8DE3T8Hu/93tvvNF/9Vd/hel0inK5jFqthnq9LjM+4vE4nE4nqtUqSqUSlpaW8Md//Mfwer345S9/iVevXqHVaqFYLEKv18v8mUAggGAwiHK5jK+++grtdhuBQECm0ZlMprmW8GzvPxgMZGogp4pyQBanTbbbbQSDQRmkxvk2HAPcbrfRaDQwHo/nxrrydTmFtF6vo9/v48GDB/j+978Pg8EAr9f7xvv3l3/5lxiNRnj58iUODw/hcDhkeJTL5ZIpehwfG4/HYTKZkMlkUC6XZdhRp9PB7u4uqtUqrl+/jps3b6Lf7yOfz2M6neLGjRtYWlpCNpvFq1evMBwOZcwDZ2SwrbzRaMTa2hqCwaAMeapWq/jss8+Qy+UQDocRDAalbb6maXKeSqUS8vm8DHCbTqdIJBKIRCIykpZzV3q9Hra3t3H//n0YDAb8zu/8zhvvHwD85//8n2Umk9vtlnbrg8EAx8fHqNVqCIfDiMVicDgcWFpagtFoxMHBAdLpNDKZDF68eIFut4t6vY7hcIhPPvkEv/u7v4tCoYB//Md/RLPZxPLysoxP5vjfL7/8EqVSCf/+3/97/Lt/9++k1f5wOMTe3h5yuRyi0SjW19dRLpfxP//n/0QqlcInn3yC3/qt35KBZkajEQ8fPkQikcAvfvEL/M3f/A1Go5FMym232zJYj4PDIpEIHA4HNjY2cOPGDRgMBmxvb7/x/v33//7fMR6P8ezZM+zv72NpaQnvv/8+NE3D/v4+qtWqDOoLh8P45JNP4PF4cHZ2hnw+j2aziWw2Ozd6gPbNZrPJ5M+joyMUi0VYLBY4nU6Mx2MUi0X0ej1cu3YNGxsbyOVy+PLLL9HtdhGPx+Hz+bC5uYkPPvgA9Xodf/M3f4N0Oo1QKDQ3wVQ9g5ysyqF+/X4fR0dHSKVSsFgs8Hg8Mm9nOBxic3MTt2/fhqZp+LM/+7N/dr8u7VyePXsGADIMiKN5p9OpTEfkNLl2u429vT0ZaOVwONDtdmX4VzQaRTwelwmANHacROfxeFAoFHB0dITxeCyzHbxer4zb5VCq4XCIYrEIk8kkw504RIszCjjgiO+Nr8VLz9nVHo9HZqrw8BcKBTFaHG27yMpms9A0DYFAAGtra8hkMvLQAMgF8Xq9GA6H+Oyzz6DX65FKpeSg+f1+WCwWLC0tybA0DvHhPHuONe10OjKoymg0yiAizhnhgKtGoyGDvjiYKBqNyrz3/f19BAIBeDwe6PV6HB4eolQqiRPhXul0OhiNRnktzoSgcc7n83jx4gX0ej0+/vjjN94/OuJIJIJIJILBYIBWqyUz2zlnngY+k8nIOFfOF69UKtA0DWtra7h58yYmkwlSqRQMBgOcTicMBgNGoxHK5bI4zuFwKON0ef7VwWfFYhG1Wk3GT/N5+nw+DIdDZDIZ2VuOteZcokajAb1eD7/fL/vGccsEWZxrZLVa0ev1Fj5/AOD3+6HT6ZBIJBAKhVAoFLC3t4fBYCBD5dxut9wdTo59/vw59vb2YLfbcfPmTZjNZhlKpdfrUSgU0Gq1EAgE4Ha7kUgkEAwG0Wq1UC6Xodfrce/ePRk1/A//8A8yIRUASqUSWq0WRqMRKpUKRqMREokEwuEw3G43KpXKHEBstVoIhUI4PDxEpVKBTqeDx+OByWRCLBaDzWabmyOlDqzjGV/EuaRSKeh0OqyurmJ7e1uG5E2nU4TDYYRCIRmACMxs5mQykfMEzGa5GAwG+Hw+GWY2HA6h1+tlYmQwGEQgEJDv73a7KBaLMo2X/7+0tCQjpXO5nDhgzjxyOp1oNpuo1WoAIHee4905YI92moPKCNY4eZOTaXu9HiqVyqXP4KWdy8HBAfR6PTY3N5FIJGTULUflTiYTmSc9GAzkoa+trYmxq1arsFgsuHv3LgKBgEyI6/f7aLVagqScTiey2SzS6TQGg4EM0iJq1uv1Mk63Xq/LhDuHwwGz2SxRB0fgdjodAJARpDQWamQEQMYeDwYDtNtt2UxOJeRI1UUWDfL6+jquX78Og8GAw8NDOVCj0UiMXLvdFlTCgxIKhWQCYyQSgcvlQqFQkCmZdC5GoxEmkwn1eh3FYlHmddN4MXpxu90AZiNba7UaLBaLRJjRaBR2ux2lUgmnp6cy3liv1+Ps7AxHR0fwer0Ih8Nzo5fptADMORfO6+YwqkWcC43U5uYmlpaWUCwWsbu7K5eTM+E1TUOz2cTe3h46nY7Mo280Gshms7Db7bh79y6Wl5dxcHCA/f19mbdusVgwHo9Rq9VkhDHnxnM0L8f28rNUq1X0+33UajXk83no9XrEYjG4XC6JUjkVETgfuMQJrDabDW63W0bMNptNGXnL1wMgEefbDLsiEg2Hw4jH42i328jlchgOh1hfX4fX65Uxz9yHXq+Hw8NDPHv2DDdu3MDDhw8RCARw48YN+Hw+PH/+HN99951MgdQ0TSI2o9GITqcDk8kks+sLhQK+/fZbmM1mBAIBGAwGmWTJKNdisWB1dRUOh0P+vlwu4/DwEMPhEK1WC263W2bHG41GuFwuaJqGYDAoY6ZpPAuFAvL5vIzmXvQO5/N5GI1GbGxs4Pbt20in03j27BnG4zEikQjsdruAqXK5jK+//lrAX6/Xg8PhkM/sdrvhdrtleiqnt+p0OoRCIQHRBI7A7E7RjnL65Xg8xtHRkTjoQqEgTtRutyOTyaBQKECn08kUUADCFhUKBdhsNmxvb4ud4Lhuq9UqjAcAmSz7zsccE/XyRekxB4MBms0m+v0+JpMJgsGgOBgAsFqtAM4ntU0mE6HA2u02dDodzGaz0DMGgwG9Xg8A5FI6nU6hWoiWaMRIlxHZ0Zgx3CdCJLVBI0GPbjAYEAgEZHQqv0gV0bm53W4xLIssdRIiHRoNcqvVAgBxDJqmIRKJSKTF+eo8gLlcTpzKYDCQUJfoutVqQa/XIxqNQtM0MVSVSkUcPJE3aaWLE+ro5MPhMCwWiyDqfr8v4fxgMIDRaJRRr0TZ6uRGHs5Op4N0Or3Q3gEzYMDpezqdToACzwr3jyDH6/XCZrPNXaherwez2Yx6vS6RI42pGtXRYfJZkKYliuTfqY6Un5d0B38HzwzPJqnIdrstn6ter4vz5uhf0sKtVkvuWL1ef+tJiny2KoU5nU5lFDkBAZfBYMDa2prMieeZzOfzcv58Pp9EeQQYPCcEMXT8NLzqtE3eqXa7jVarJRE4z/x4PIbFYhEwC8wmk9JIWywWBINBocGn0yk6nQ6y2azMizcYDOh2u8jn8wuP2uYdIS1Mp8joiM6BE1OBmX0iaOXEWaPRiF6vB03T5DOrbAIAeSa8/6Tq1VHhfE7BYFCcN88Hfw8dNN8zzyrpO0b/1WpVgDtpNDIQ6thyPtfLrEs7Fxp1u90Ol8uFbrcrUUAqlUKz2UQikcDGxoZcDo7M5KhMOpeTkxO5gDxIgUBAOH2GkJxLzVCXzoIXV9M0iWo6nQ7q9bp4dyJOOj0ap2azidFohNPTU+zs7MDtduOjjz4SOom5Av4MXzcajQoyW2TxsPGyABAnVigU0G634XK54PF44HQ6cf36dZjNZuRyOVQqFUwmE0Fi5G2ZgzKZTEgkEgBmoXuhUEAwGMTW1pbM+dY0DV9++SVevnwpc7M5L54oiQeehjMcDstFODk5kYjOaDSKoZ1Op4KwefH4faQAjEYjSqUScrncG41JVRf3jM5lOBwKsqZjUBE/53/zWTqdTjFW6XQayWQSLpcLXq8XFotFLj2jMDovnU4Ht9sNo9GIo6MjJJNJAURms1lyI7yENBAq7UPjo46T5nno9/tCza2trSESiQhC7Ha7OD09RblcnhvF/V/+y39ZaA+5eOesVqvkkHq9nkTPfGbk5j/++GPY7XYUi0UcHByg0+kIpefz+bC6uiqOfzKZoFarodFowGw2Ix6PS96D0VcqlRJAybNjNBrFANLO+Hw+ydlOJhOEQiH0+30BpszjOhwOXLt2DQ6HQ55FpVLB119/jV6vJ5+j0WiIbVlkETh0u13UajUBhaPRCOl0GqPRCG63G16vV0YRGwwG+P1+OJ3OuVHE9Xod9XodjUYD9XodNpsNoVBInMJkMhFqezwew+PxwO/3z9lRnv3r168jEAig0WigVCoJGBkOhwgEAohGo6hWq9jf38dwOJSfY7TNs+90OrG9vY21tTX0ej1Uq1UBcJ1OB61WC81m8907F/K9RGjcbNXTqsl3GiDVwaibywtKxEvj0Ov1JAfCf7dYLLBarXOGmb+Dr0GDRgRGyuvifHmz2SyGkPwov0fluBnpmEwmuXBEZossOme+Vxoidc4494B8O9Gl0WiUcJvIg1+cr66GzuRIaUDsdru8xmAwELTKz202m+eSzkRg0+lUaBmDwYDJZCJ/nk6naLVa8lwvzrIHMPf36mzuRRZ/F5PEpMIAzL0u9+IiPcf95HtX59Lz91+ci34xP6UiOf4ONeHPZ8BoajKZwGg0zs09ByCRFwEPHY36muqzBSAG9m1Wu92WvBLPGykwvhZzf0TOBHIElARbNPL8M20BnxGpaN7h/9uMeD4XOhrStyoCpz1RZ75fnP3Oe8L3xvOh0+kk6ul2u+IQ3map4IB3p9VqydnsdDoi0uD7492nLeR+8H2qz5bRQafTkZyO1WoV0MOIhb+DYEaNsLk/FosFJpMJ3W5XnDu/n3vGs83fSTvNLz5b0rmXtYGXdi5Pnz6VMJQUTCKRkCRdpVLBeDzG4eGhJJ+JRphoyufzmEwmc/QWjSQvD9GFpmlwuVxCLRgMBknqmc1m+P1+GAwGtNtt9Pt9SeICsxDcZDJhbW0Ny8vLEs1omoalpSV4PB4AwOHhITweD4LBIMLhsKDuSqWCw8ND6HQ63Lx5E5FIBK1WC69evcJ0OsUf/dEfXXbbZF2/fh0AJHJjHocIrt/vS+Si0+nQaDRQq9XQ7XYBzIwkkTTVYADEEddqNREg5HI5uFwucRyhUEgiFXL6vHCkjqxWK5xOJ3q9niiClpeXZb9isZigUiquvv76azidTni9XkHqdrsd/X5fnrvZbBaKLRAILGwgeahJdTSbTbk4jMRolHn4mZOjQaED4B6TkqIzVbl7AGJkaShJA/V6PUHuhUIBxWJRkP5gMMDz58/R6/WwubmJtbU1+Qyapsl7PT09xatXr6BpGqxWq0SXVN9RjRUIBOD3+0WJ+TYO5p/+6Z9gNpsRDoeFY08kEmg0Gjg5OUG9Xp+jbkjh0RDZbDZ873vfQ6vVwuPHj1EoFFCtVnF4eAi73Y54PA69Xo+TkxMRofCul0olWCwW5HI5ATi8206nU8Bjv98XBVO73Ybb7YbT6ZTz3+12hQJjBEHBhqZpyOVyKJfLGA6H2NjYgF6vx8rKCtxuN3Z3d/H06dM5gPomiz9Hm2Wz2bC+vo5+vy/nolQqIZVKiYEmHUfQSxEUDTrZA9UJHxwcCAvT7/clQhyNRqjVaqhWq3A4HIhGoyLKmUwmyOVyODo6ktyT3W4XqpD5wfF4jKWlJaGNHQ4H9Ho9AoEAzGYzut0udnd3hQqj0Mnr9Yr9vSz7cGnnks/nJZSiJJCb4nQ6RVVTr9dhtVrlktJLkz8koiYSvhjRkPqxWq1ieInwGe6NRiOR6NXrdXQ6HZF2UmrJCxuNRjEYDFCv1yXZ6Pf7JYFLbtdqtYrx6HQ6yOVy0Ov1uHHjBmw2GxqNBgqFwsK0js/nAzBDj6RSuA/ADMG4XC643W5xcIxwuGg4GX31+33h8mksO52OOFxGJpTQqpGnGiUxkiGyKhaLqFQqcuBMJhOcTieAGVJrt9vY399HoVAQHpYozWw2S96DiE3TNHFgi+4fkSKfP/lhg8EgZ4UUCmkDUgc0PGazGQDmwEqn08F0OpVoTxV5qHJZ/pcRCy99u91Gs9kUPpyy0VqthlgsNid2oBrQarWK4oconHkHomKCNgIs5jrexrkQmDHfQ2EH72Cn05HzxiiWRrHf78PtdiMajaLZbALAnOiBTsBkMqFWq6FcLstrMU9gtVol2gUgyJnn2WaziSqRET4pMpPJJM9dtTmkeHgOeb9MJpPc8UgkAq/Xi1QqJWdkkcW959ni+6DakrLdUqkkn5fRLu1fvV6XnyVrwaiN9rJSqYi6lOeWUWSr1RL1FwBhI1qtlggfjEYjAoGA3G2r1Yp+vw+HwyFnyu12y1nT6/WiFqtWq+KsaCdIHfd6vTnl5D+3Lu1c1tbWhKJqtVryxqbTKVwuF1wuF+r1OqrV6hxFQ2OmJrgYspEzVZOpdrtdLjXprXA4DJvNhmAwKEIBJu6ZnKZXpyMDIBQbjfB0OkUymUQ+n0e9XhdJHimyfD6PfD6PwWAgkVen0xHFRbVaXfhyUxbcbrfR7XZFpQVALkGz2USlUoHBYBCRAi/2cDgUNV6j0UCz2RTenxdxMpnA6/XKz5dKJfR6PVitVkGpf/iHfyhGlEIHIvTJZIJmsynOaTgczuWHVPowkUjg008/lTNBaTpzXPwvnSSAhR0LADG+nU5H9qTZbMrr22w2jEYjNJtNMUgXBQD1el2oA4IWnj86ervdDqfTKZE2AKkr2tjYQCKRmHPEBFKkWulEGFVRrg1g7kzrdDr4fD7Z93a7jUwmg0qlIrL96XQqUbzFYkE8Hl94/wCIwanX69jd3cVoNJLIgXkP7qVKZfZ6PTGMVDg2Gg0RUPCz8Tmtrq4iFosJmjcYDLJHKysrCAaD6Ha7yGQymEwmc2wCEfrp6SkGg4FE7uPxGOvr6xiPx+LI+/2+ON5kMimUn16vx3A4FPUenU0ul5PnssjiM242mzg7O5OzR/o4FosBmJ1RqrMIrAimyTTQYaoiFLfbLYpSn88nuS2r1Ypr167B4/EgEomIRJy0GdkgRkrj8RgHBwfQNA0bGxtYXl6W58+zRxEB5emkjAnUVdqUKrdqtSqS8cusSzuXra0tOeTNZhOdTgflchkmkwnvvfceQqEQyuUyXC6XRBjMEaiOCDh3MHa7HaFQSIwjZbN2u1303PTy9LR8/VQqhdFoJOEdk3iUKvJgEtFQ1lsoFCTpR/kgMIuYMpkM9vb24PF4sLq6CqPRKMi0Wq3K+1lkMZlNtFyv15FKpWAymXDv3j3R8yeTSbjdbty9e1cMpJooJgU2HA5FJULabzKZwO/3IxqNYjqdolgsotFoSOSxuroqEsp//Md/RK1WE86VnDsLDemY6VxYpEYgQMqx3+8jl8uJeELl0ZnobDQacLlc8Pl8C+es+NmZ6G6326hUKjCZTFJ8NhgM5j4Tf0YVABAVWywW+Hw++P1+eQ3SVm63G/l8XqLXcDgMl8slFFWlUsHOzo7UhxBtEzQRaTLqU7l2Ujs6nU4KDSlVZbEnnwW/eP9u3LjxVnUu4XAYmqahVqvh2bNn8Hg8QmUx+rPZbHC5XCJo4D1iAeCrV68wHo/hcDhgMpnmlKE8H+vr6/B4PCiVSiKAcLvdwiTYbDYcHR3h22+/FZTc7/fl7Nbrdfzyl78UGp3vbXt7W6IpRqUs/D04OMBoNJJnpMqsmYslbbuoKIfKV8r8+bxNJhOWl5eFWifIZfTucrlgs9kkOc5/Yy6U55tRrcfjwXA4RKFQEMrxxo0biMViovjM5/P45ptvJBdO0KTX69Hv97G/v49OpyOCAqPRiHA4LO+/2WzC4XDA6/VKLoW5MsqZKUjxer2Ix+M4OTlBo9G4dOR3aedChM/wj16NhV+MDmiUaMzVC6IqsXiJLhobNYFHj6+G5qQmiArUJC5ln2pymgeRv5fhKKkkGgA172A2m8UYEIGz2G3RxUPF92U2m+HxeAS5EKExYuGlZZRDdMLLQoqM9Sk05gCE2uH7ZpTX7/cl6clnwwuiyrD5vnw+nyB7Rkb8WeBc0KEqxVRUw2Q3pZSUTS+yWJjG11WRH+kIYHZO6dwYudBB0lnzIgKYE5OoDonnm7p/FugSuDAvQIqIgInREGsqiCjV3CPpHO6/0+mUM02DTuqKn0Etulx0MdfESJ0Jbt6Ri4lyVQDB3BSjNr5Pm802R0PzrDSbTUwmkznardvtzoEUdgng+2HimnUjJpNJKC1SUHzWpBR53lTals+b9KcqTlDPw5su7r0qoaYdKhaLKJfLqNfrQr8ScJCKGw6HIg2m82bkqzo9/rumaXA4HHJ3ePYASE0caUXaZo/HI0wC81dUddJZEOzwzlx8TYoH+H4IztXcz2XWpZ0LQ3IeFBbq9Ho9fPXVVyiVSvD5fBJ6kVtUkWwikRA022q1RB/PpdPpJBlPpwFAZH9E/ZqmSQ6DH1zTZm1oVEUZE9gMy1WJNNEYL4fNZsPq6qpccEYH5L7X19ffCjmWSiVxBqQi1tfXMZnMKnhTqRQ8Ho9UDpOKyGQyKJVKCIVC2NjYQL/fR7lcRrfbhdlsFqqQyb9eryfIWKWSGAoDEOqFFAJbPYTDYQwGA+GR33//fdy/fx+VSgWvXr0S1E2KjvmEUCiEyWSCUqkkenm19Ue9XgdwftkWWaQQuXderxcbGxuYTqc4OTlBJpOB3+9HLBaTHAppvU6nA7vdLrQFZZq8UFarFbFYTChG0i3xeBxmsxmrq6vw+XxIJpM4ODgQPt/j8UieEYAIF+7fvy9oNh6Py0Xu9XrY3d2Vti/D4RBWqxVbW1twOBxSvFmpVKS4mOe1Wq3i5cuXC+0d1/b2NqbTqRRrMkfBHNLF5H0sFoPBYMDu7i5OTk4wmUxEHZbL5dDtdvHDH/4Qv/d7vyfMwWAwQKFQQL1eRyQSwbVr1zAcDvH69WvZJ0YQt2/fliQ3W8/4/X5pOzQajRCNRhGJRMQJjcdjlMvluVobk8mEmzdvStEg62ji8bhErSwKZWHxIotKSdozh8MBn8+HdruNv/3bv8X+/j62t7fx3nvviXFmkSMlv2traxiNRshms6hWq4hEIrh+/bp8P8EjjXkikRAhC38HgfDNmzeFthwMBggGg2KnHzx4ILYlk8nA6/VKuQcdW7ValeiGlJzFYkEikZD3AQDFYlHEHQ8fPrz0fr1RnYtKX6nJ2maziUKhAL1eL4l2VcZGWbHVapWQimiOXlBNoqrJZlU2SvTH90NUQCfGZLL6uxihqHJARjJ8DVI9VLeoQgMiDqq0FnUuRO1UTxGJjcdjyY0As4tHlMfPTEN4EZEzwuPn4d5wP7gPqqiCRp/Riiq3Zb8hr9crCUBV1UcnpsrJid6A88Kti89Mle8u6lzUn6WT9vl8wrdzf4kM1e9nhEzjwBocOheCJUZ1anRJsMPIsNVqCSDhmVJzURS6UD7P58XnqErF+ZxYKMw/E3EC5xJkNbpddDFC4lmjkeF+qWiV0SGRv9oFgvvGfJ3H45EcGAFZs9mE3++X86PmYXmfiLIZnQOQ1yB4ZB0LnxdrcVSUr9KZxWIR/X5fOjOoIhaCrrddvDdq5FytVpHNZqWLB8sJeO7pBJkfJogBzm2ZyvSQOmNOiQpMPhudTif7wvtG+lu1dewZpkr3uZcUL5ECox0gI0V2hMwRbeCl9+my35hMJgFAQjxSIuQyGb7a7XYYjUYsLS1Bp9OhXq+j3W4LtUBelMnqly9fimqFCWqr1SofXqfTiVyWm0gpMh8ik7w0qKomvtVqzamyKpWKvB+XywWj0YhGoyEqk1arBYPBgI2NDYxGIxweHqJaraJWq2F/f3/hw8mHR7ECC+VIjTD0zeVyghpJDXo8HrTbbXz++edy+DwejyAgHjA6BkZoROWJRAJutxvZbFZ+/4MHDzCdTpHL5UQgkM1mpeDNaDSiWCzib//2b0Xua7PZkM/npcCq0WjAYrFgfX1dKBFeBv4/BQbxeBwrKysL02Kbm5sYj8fIZDJS0Mnfzepxhv0mkwlLS0uYTCYoFovSZ4wGjPQtVV0EDVT38GKRtkkmk0in01Ihz64EdAw827x4VOyxxQafOx07MF+bw+ib7z0cDous+fT0FPV6XYQGb2Mcya/z/tARqF0tSP1pmibRMR0CHabVasWNGzdEiPC3f/u3Ymyn06nQtrVaDUdHR7BarXjvvfdgsVhwdHSEnZ0daTNEx0A66fXr12JbNE2TXoA0xvy9dEiklHj+KI2Ox+PSeop0EnvzLRq5cF8YYZXLZTx9+lTYkUQiAbPZjHK5LG2aWBzr9XrF6ap1brVaDa9fvxbAqGkalpeXsbq6ilarJcn1UCgEo9EohYwWi0Ua8BKAsCh2MBggk8nI3vGMlUql/w97b/Lc+Hbl+X0xESMBggBIgvOY88uXT2/U01QdHiK6q8uOcNgLL+yFN97Zay/df047HOFoL9x2tFSlVkkqld6QynngPIKYQRAgQICAF6zP4QVL5WIin3d5IzKkl0liuL97z/A93/M9BgljU4GRaW84OTnR6emp4vG4FhcXDVaXZE7mpuvGzgW2E9GXi8kGg0GNj48bIwRnEwgEjPONzAaGEf2r4+NjM7zIO7DRwDakgeD34JRE61xSIiIuPsVpsFyMTaVSUTabtTSRSBaphUQiYXDG0dGRwRUHBwdDX25X5JEIjM/mFoExRslkUrFYTNKlY3rz5o1evHihi4sLra6umnMplUrGdnILs2QasOySyaRBffF4XKurq/J4PAbDwAKJx+NaWlpSIpHQH//4Rz1+/FjZbFaff/65RkZGVCqVjFW2t7en0dFRzc3NWXHSzV6AI+Hdz83N2b+/68pms+p2u6ZA4Pf7rXcC/Jlof2RkxCQsoD+zHzh2V2jSNVLUWdhLqNlQu4kKgQS50EAkkAoIeNCB4vy5xVAiUNfpkPngXKjRJBIJpdPp93Iu7nkCLkQbDZozdwzqL5E/BploHbx/d3dXr169UiQS0fz8vGH8FxeX0jXAlV999ZWmp6d1fHys3d1dTU5O6v79+5YdxWIxnZycmDgkz9XNfoFyT09P7RnSx8HzIEiid4aAttfrWQAw7B4CVWHfqtWqNjY2zLm4DoAzQqA4Pj6uXC6nfD5vtStQH9euBINB3b59W/Pz8zo6OlKxWJQkC9w5E0CXfr/fIE6Cc+wCkk3Aichd0f8WDocHUAtsJmw2nMvx8bEJufLZb7JufNPxWC7/mQ/OAXElyVGx9XguhdhcHj/LhQ1qtZrOzs40PT1t4pGuyBrQQyKRsEiRjSUaJhrEODQaDePK877AdURtLrRG4RwD0e/3NT4+bkW7YaNuSVaIA4bD2ElXGK7b1LS/v2+YLQcRyAxyQjQaHZCEABai1kTTXbPZtIiNngL2HmYPlG32FNl3IqXT01NjsvCciRZhYrlaZ2QUMNcikYgVv4dZx8fHBqXy7DFiri4d8NL29rbVhqjNcAY4V25RFsPFcwAyki7hpEQiMZAh8xxhRxLpu13t1MGQMiGwgOpM5sq54/NQvAVOxDFhLIZdW1tbkq70xXCssDCBvKBqE0hKMhgXtV700EZGRrSysmKMTr/fb8V4IEBJZiT7/b4JsKLHRfDJ4jm7RIKRkStlaZwPsLJ0WZPj90ZHR60hmaAHcdFisTh05oI8Er0kPA9qltRD6J+DBcieU6fBPnW7XRPapE+QM8Ddr9frBrvRLE5LBBRranMQQYAF3WABmjkwp3Rld6jD8dynpqZMJZwCP8+FsshN1o2dS7VaHWDWYPQofNKE4/P5VKvV9Pz5c7XbbX366ae6deuWpXgu9p5Op22OybNnz9Tr9fTo0SMzSPl83g5ou93W2NiYSYJPTEzYpp+cnNh7Uzvx+/0ql8uGFbNcpgSkAyJ6ipk8IEgIKNwy82OYRTEdwwijhn0Ih8OanZ3VysqKCoWCfvnLX6pWq2l5eVnZbNbgMajZsLrQ0AJChPZ4fn6uSqWikZERk5rv9/sDFy8SiWh2dlZ+v1+5XE5bW1vWQNpoNLS/v2+vUSwWlUgktLCwoGQyaX0P9Xpdr169Uj6fN+039jEUChkksL+/r83NzaGp3K9evZJ0GZyk02nLfAk4cJqZTEaFQkF/+MMfdHJyoocPH+pnP/uZ8vm83r59a4YUyC6ZTOrs7Ey5XM6gMHq56FhfWVlRPB63mSZu4+bU1JTC4bDpNFFnDIfDKpVKlonyXCYmJiRdNjS+efPGnIabdTYaDSs886yq1apyudzQ+ydJf/jDHwxmph6BoaPXig59iCM0yMZiMaVSKS0uLqrdbmtjY0OHh4d69OiRPv30UyPJeL1e3bt3z6ir33//vTl7+obu3r1rFPZ+v6+JiQlrwkylUibOSo9ZrVbT5OSkPvnkE6NKS7IaaaVS0W9+8xuDbCEBMMcFR/X06VN7zsMsIKbNzU3lcjnLUEKhkD766CMbBUF2cXh4aCoL8Xhc4XDYSEw41eXlZa2trenk5ERv3ryxmhI2Ip/PWw0mHA5rd3dXh4eHqtfrlmkDs0G4kWTjSUAaXOdM7RSH02q1LKNaW1vT4uKiZeiSTO8QJOimZ/DGzoUmJx4UUYJb0ASeofjjFtcx6KSzPGCodHhaojv+TboqSBN9kiq7lGg+C/9N+u7SBlluHwFMGZerz99Lstej6Po+TBNgleuZE93eRKr8Gwwj2CDuZwYquN6gSGbmFrR5PfdSuaw69sb9OyItCtouA8x9fhAFuFTuZ7teoHwfSMedLeE+a/ZNujqbRGxEdJIGyBnQ4DlDbuZ7nTjCv5E9krEAxbqEBrBvCrREfjh29oE/LjXWRQPc5lVpkOb8Ps7FPbucc+Z5uJpTkBfQyXKZdTAS3f41ziDnjs/PM6eg7WZ1fH/pqkDuogNk8EDWPAs3myfwdO8IsBWQk5vp03owLDTrPme3AZkCuGsH3RobmRf7hmF3afEuSYoM5M9BUOwTyAAZJveM/WQPGo3GwM+z57wfe8+z5Gy6VGU+F0HVD96h/1/9V/+VLi4u9OLFC21tbVmXLobr/Pxc8Xhck5OTJm8BzZEOd1Q5OUBgt/F4XL/4xS+ssWhvb0/n5+emYUaBEFgiGAwOsBwSiYTy+bzOzs4UCoU0Pz9vKTNzFHgtl5pI4RaKM5EjNRA2ud/va2pqSsvLyzfdrn+0PvnkE11cXGhvb0+5XE71et0yISAn+g4oQHo8HpuSWSwWrXELKIpiL2k55AYgIyAz4AcOts/nU6FQMCMoXQ4ze/v2rRUPifqmp6fN6NZqNVNodovRTMljX30+nz2fbrdr0jNAKsOsv/qrv1K329V3332nly9fKhaLWVMYkRyZATBgp9NRuVzWmzdvVC6XdXx8bPM9ms2mlpeXzSiAxXc6l8PnyAx9Pp/NDfF4PNatL105E5g+tVptoBmOBrtQKKTqP0wfhf4pyeAu6O5EhSMjI9Y5jQGNx+PKZDJD758kI1SQueTzeWuKrFarA9M9G42Gtre3Te6j1+vp4ODAJJD6/b7S6bTy+bz++q//WsHg1QCxer1uOnyIrh4fH1sUn06nrQ8IGJszBnGA+tzz58+NPUaNoVQqGZ0auIhzCWze7Xb1f/1f/5dRkqn9PXr0aOj9W11dVa/X0+vXr7W3t6dkMqnFxUX5/X5TOAaydynF1GpOTk4MUrt165apkZOV04Kxt7dnZxSkwyWshMNhpdNpPXz4UCMjI3rx4oWOjo4GkKWVlRUr1sNwdB0Oc3Po/ULU8uTkRAcHB6rX6zo8PJTHczmTa3x8XKOjo7p///6N9+vGzmV1ddUK3Ht7e3bwKRYRIUQiEWsWki4jxtPTU9tY2GUYHiK92dlZcxrUUWiIIgIlEsBBkerF43GbAzEyMmLaOTQggYHicV0qLZEW9FyMt1vIpGZAh/MwK5PJqNvt6vDwcEDCmsK3K+bnRtw4BYqY1Ij8fr/NYsBYEH0QiUC9JatguU2uPDuwXPYrHo8b7OkKKbrachhwl3HE+5MZVCoVNRoNJZPJ92I7LS8v6/z83KAtWEY8P8bbunWPQCBgWPvJyYml9chYpFIpNZtNK266PQCRSMQIAhj/WCxmneluDYcsgGI9ewMJBcz/4uJS4BVIg/oQf8igqSlgCIBsaYIcdoE+EEQVi0UTSKQQjBIGygE4TL4D2TbkHdoQMFzIssCYgtUJg85txk4kEhbguVk0hIxwOKyjoyNrLCYjILJ3RSIlmc2Ix+MqFova2tqy7Ik+kEwmM/QdhkQDlB6NRo0dy/gHYEfOP3uGHaz+w2A+MiycJKQGSAnIaGHTuJfog9G3wr+7bR8+n8/EJoHCgNr47gTaUPCxfdylarVqzoVR59Rcb3oG32kSJVkERl2S8dxjsZiazabW19eNgdTpdDQzM2Nsomq1apeNC+Qyw1xIzBV5k64k3t0BT8Ai7mwKn89nVMV8Pm86PDMzM/L7/TbMjMvh9XpN3BLvTqrv9/sHNKyILIZZqEYjDhgKhZTNZu3feehEw8ATy8vLmp6eVqVS0cHBwQCsw4GjYIyBoNFsZ2fHXoMJlzRUst/8AQ/2+XyWjpOa01Ta6/Usgoa9dH5+rr29PYM9KPi5UBUH2c2U3nUx8Q+aJDCD3+83xWnpkjLvStEsLi5qbm7O5m1wflutlhYXF5XNZi3zI7qE5loul835A3NcXFyY00IgkOZMisU4W7IVDJ5rlBOJhDKZjDqdjvU5AeW5vSHAkmSr7+NcuF9HR0cm4YTDQb347OxMBwcHOjs7M3LIzMyM0um0qUEjrHp2dqZ0Oq2ZmRmDWMj4GCdMcOaqY9NNj0YhRJDR0VGTCEJ3DMkeGrMDgYA5CTJEIm43oOH1sA+uUR0W2uaMuwHh8fHxgGoJ9QuGgJ2fn2tiYsJ6stz3phYKygLhhVogoqv9ft+cF8FTvV63+x0IBOwZEFQRQBE8AenhLKhdk7G4thQHRkM8/UszMzNGf77JurFzef36tRl4ImyiOKJSlInpg6BYzdxtYAkivOvOhQhQkm0eRU2ig2q1qkQiYSwuIh3qIkTh9HAgXkdUA12QWg+FYOh30WjUoiIK5W4H9rCXu1QqWVRMpIiuGowY6cq58Bnv3bunR48eqVar6ejoSKenp3rz5o1lGS6LZ2RkxBwC0EQ4HNbCwoJ9L4YxwaQCS0VEFJiGP9BUYcZMT09rampK2WxWy8vLNoypXq9bjQgWUrfbtfQe5+LWvt5lff/995JkdGmy3Egkoo8++kiZTEbPnz/X999/bxlnIBDQ0tKSPvvsM71+/doufTqdVr9/OfccfTmy0t3dXet/2djYkCR7P14XdiM9PggqUoSGIAKcBrMuEAhYTw1OCdwePTe3D0a66o8iQ3ufhXM5ODjQ5uamRkdHrWUAB+rOPOHePXr0yEg5zIP/4x//aM5lYWHB+ijcqBoNOL4HTLlYLDZAGIDqPz8/r4WFBXU6HW1ubhprkUycAWQrKyvKZDIGldEmAAOP4WpAxQSRkv6RgX+XBTzvsulyuZz1DQFtl8tlU9jo9S6n866urloQ2Gw29Yc//EFHR0dKpVIaGxtTs9k07ULGRKMjBnsVphcGf3t723q85ufnB1oy+AxAxNSvvV6vNbfi+N3aICw86RJt4fnkcjlzSDetWd3YuYD3Uydxo1S385UP4Ba4iITRz6FW49KG3eKgG71LV0UsnAj9Gb1ezyiOQGk4BKJlNKiAhXh9Nlq6OnDoJRF18+84PSCLYdbh4aG9BwbW1WpyHyzOhYiNJk/gMqJCIkWgK2oqZIVAC0xhxLiTotPQCruM9BojyoHjOUpXw8hOTk50fHxszaDAN27hH/jSxdSHXci/AE11u11rSAPPZ0omRV+/32+UancyJj1SjBQmywA+cSFXom6MFAoOnKNqtap8Pm/MIYICYEkyzOuBidu3IQ2SKrhbXq/XmHDcgffJXChwI3fj3j3uZCqV0uTk5EBTX6vV0tHRkTXR8dn4ngQSkuzn6Qy/PiYAJpVLFpBkzbfQs2Ebct4oogcCAXNi7DnveXp6OgAd4aih0IKEDLuH3D9qe9wV6WqYnevwOE/A09JVd7xLwOG+oTBCgIcN5L+ly/NPcy+/x9l2i/FkmGTakqy4D4HIHSQIxA3Jg+CTpnXp0g7i7G+y3nlY2CeffKKlpSXVajWDaehpmZub00cffWTGi805ODhQu93W9PS0RRfg8C41V5LBEpIGCsDQaJnbsbOzI+nS6dFtn0qlBlJICoPBYNC6fIm8yHQ4aGQ6SFyT4QBJUPcYdv3617+Wx+NRNptVKpUyKqYkM/zpdForKyt2yeCfv3z50uokXu9lBy8zGoBTiHqAN7LZrMmQAIsBb11cXGhnZ8eotIyixUEAu7nSKNSsSNMLhYJev35t+9Ltdo3GCgGBzwNnnprRMIvO7YcPH2pmZka5XE6vXr1Sr9fT4eGhQVvoy1E0hzRBvW9kZER37txRKpVS9R8GLzWbTW1tbQ3ApQxAI+iRLlWFZ2ZmjKbdbDaN4EKmJMnqAxRLXfahm5kTrBBk4TBPT091dHQkv9+vjz76SGNjYwOD5IZdW1tb8novZdi/+uorlUolawJ8+/atKpWK/vP//D/Xz372M0MA2u22dnZ29N1331nkDb6PtuDOzo58Pp8ZquPjYxvFjSGjcZqImppOv99XIpFQPB5Xp9PR27dvNTIyoomJCaVSKe3u7tq4XYr2h4eHNvtlcnLS7m6lUtGXX36phw8fqlQq6fXr19bnAURFk+D/9D/9T++8f9Vq1WD0tbU1HR4e6k9/+pPR4zmfP/vZz1QqlfTrX/9alUrFmnFxtq5oKU7T5/MZiQObyr61223t7u6q2Wzq/v37WllZUbPZ1P7+vsFv1KLo/eKcQUkmu+Nnzs/PtbKyogcPHlj2Ew6HLZCgLkZAD5sxl8v98DUXt8jsalJJGoh03U5kolhwd3C96x/OpRjjyYlcXGqjSxslPaWo7ff7B+ZjUNjiort0WKIyXpM0j+iXNBEKoyQruA67mJ/w53BzNzsg2oVlQ/RB4dwVFuQz8V1cGnIgEFAikbCf53tDwKDBy22KYn/JAIkKcbJcCCJBnBA4NN+Lz8zfuVH5sMbR/V0MNpkubDgX/uAZE0W7zWzU6IjugA/IMmjKvL7HbkGU93YpttSUeJ5kPGQpLt2UZ4ATcunK3Bf3u3Aehy1GSxr4nOjHubU+MmnuMIrJzPiggVWSvY6rvkvWSPGe+0xwRhBJ/YogEqiQfeKcAdlS4+J8kymR2fCH92KkMewqnBl13GGX29sHGoBtwa5R9IYlCarjZqRuUzh3F+SCbOf8/NzOKbaOLI9zwPdmcY65dzxbPhukGzJHiCouLRnonkDRtZfSlQjuTdaNnctPf/pTSZcH/fXr1wNFWorJNJPVajU9efLEiq8uLRO4IJPJqNe7HM0J1AaPmsI8BhYs+/T01AqyMCU40JJMO4fUkc0E6/Z6vfa+qIVSlOUA1+t1kzQJBAImrUCRd1i8dmVlRdJl+s97LCwsyOPxWLMnD5ZIut1ua2JiQmNjYzo5ObG9Invb39/X7u6uotGo5ufn7bXz+fyASB7NehwqdNLISmD/uUVk4Mx2u21yOKTcEAYYZJVMJuXz+VQsFpXL5RQOh03JFpgRQzyscfzLv/xLg0G/+eYby+Dcgw88SMGZgIbAgjN2fHysSqVi+xcKhaz2gADh6OioJicnLSKXLguw+/v7lplJ0trammWiBDq8L7UHCrCSrE759u1bff/994rFYvr888+VSCQsq5ycnNTHH3880PPg1v6GXVCv+Z5IKfX7fc3NzVkR+Te/+Y0V0KmNNBoNK/ADxV5cXGh/f1/Hx8eanJzU3bt3FQqF9Otf/1qbm5vWJuDxeAb6ZWDBHR4emmHFIBLoIfEzNjamubk51Wo17e3tDbQyNJtNPX/+XN1uV6lUyhpinz59arWZdrutP/zhD8rlcgMw1jALuRSgo0QioZ/85CeSZPXf3d1d/e//+/+uk5MTvXr1ynQMcUTsNwgDbDFm64RCIW1sbKhUKtnPSDISTavVsu+MAwfevE6qcIVXkXWCQELLAo2/BFqlUsn09mCa8dyYxnvTdWPncufOHV1cXGhra0sHBwdGV4UtxgUkynn58qVKpZImJycNNwYCQw8IRg7RoiTrOiXCux51nJycaGxsTPPz85auuTgjlE1SPCJacHaog16vV/v7+5JkOkTHx8cKBAKW/lNoJYWn23WYNTU1NcB4o9tZuoo4iE4Y2EPvTSwWM4lxIAOv16ujoyOtr69rYmJCa2trGh0dNefu0r1hIxEFNptNgypDoZAqlYrGx8etx4GohWcATOT1eo2KDMyAqGUwGNTR0ZFKpZIymYwpNhSLRXMw73OxHz16pG63q1/96ld6+/atzYEPBAJWuwAagNDQ6XSskE6jrnQJb3S7Xe3t7Wl7e1upVEpLS0uKRCI6ODjQwcGBpqenTRmBvTg+Ptbm5qapK9C9D8OQqFuSBTk4F+jLYPJbW1va29uzc0aWCTSHc3nx4oVJy79PzYozyAICpVeMqaztdlsvXrww44VBdhGFYDBo951O9YmJCc3MzJgq9fHxsRF9qBnQPEhXeLlcVrfbNdYXGoI8I6/Xq6mpKa2urpoaA7XFXq9ne+jz+TQ9Pa1QKKRms6nd3V2DrjCMvN6whBLpqqmbbDYWi2lhYUGSzDgXCgUbT8FU23Q6bYYaZATjjY2SZPXP7e1tM/44X1oDmFaLI+Y74VwIylHgYGFHSAqoUddqNQtqXTvrNqADszEg8qYB9o2dizviF9E6F5Oj8YoZ54uLizbnAwfgFrK8Xq8VZ93Mhc5VFxsk3WUziRyAZy4uLkxni2IlF7hYLA4MliL7gL/v8Xgs/UesjawHeIqL5OryvOuanZ21elCj0TBYBtKBW2CGAy/JIB23aOpGsOl02prXiNJdzahut2u0UZ5Bq9Wyhrx0Oq1EIqGxsTFj4AELNRoNi6A4aGDGHo/HolIyHPoTQqGQSZpQBKfYOOw6OjpSr3cpevro0SM7c5wl6hbQQsf+YZrf+fmV0jR0Y5f3D/xKkxhSQgxmcwvDqEcHAgFNT08P9CVxRqGWkglvb28PQLCuZt7du3fl9/u1v79vlxZWUaVSkSTD3d93/6Qr4grNfZwT+riY6kjXPgYNZY2LiwsVCgWFQiFTGI5Go9ZYytDAbDarL774wvZauhpLnsvlLFMGDoRmDRGD7Jlg5s2bNzZZEiIAmTCTaAkOiPrdFY/Hdf/+fYN4hl3cP+wS95LzggEH0uI7SzIIFDsE5BQOh01lGQg7kUiYTBAEB+wcTp6AD4d7fn45FRUmGGhSrVazmgwEjOvwHlAoZCACU876+Pi4tX+8i0rEjZ3L4eGhJFnhGc9J5BqLxVSpVHR4eKhgMKhHjx4pEAjo1atX2t/ft40B0/f5fGbUMKgwICRZdE2U4mqH4cFpODo/P9fS0pJmZ2eVSCS0tramaDSqnZ0d7ezsmF4UemOkkzgXqIvT09O6ffu2wWM8gHA4rEQiYUXZYdb9+/cN1oGqygycTCZjFw0jSUH54ODAOsbBtXO5nGUnCwsLNkKWw8MFJGsolUpW1Gw2m0okErp165axXmKxmKkWE/3Ttb25uWk9Gn6/3y62x3MpSMrrc7iTyaQpJgcCAT18+FCTk5M6OTl5L+HFly9fyu/3G7X45ORER0dHA9I5yNVAL+92L0cmHB0dKR6PW08L+41ziEajmpmZsQuZzWbVaDRs8Bl/mDY4OTlpZwwnfHFxYYHW/Py8IpGInj9/rjdv3igYDJpjY2/Hxsb085//XNVqVb/97W9VrVb185//XF988YWq1aoRDChav69hlK7kfY6Pj5XP5w2XRx8wHo+b0gVKAz6fz1SzO52Otra2jJHF0DbUkLn7a2tr+vjjj23M8dnZmSlLb25uanNzU9lsVj/5yU+sqRKyB8aXgCuXy+nZs2eWGaKg0Gg0TDVjfHxcn376qUZHR1UoFFQoFHRwcKBvv/1W4XBYv/jFL/T555+/t4MmwyCTw3mEQiF98skn1icWCATsPrTb7YE7DC2YwAg6OGhOIBDQxMSEQVabm5sDs3IIAhhZEAhcKs/X63VlMhndvXvXzrV0GYgythhYD4eHujNBD70ttJJsb2/L5/NpZWVFc3NzqlQqNln0JuvGzgWjT2RIsRQWBCk9EBXeklTa1bQhSqFoTK+KJGMr8XuSrOgMZskB5DDiBMCDKUziQChOwliii9wlDPA+GE8IDG5B630Oplu0x8hA66OgJl2NG3Wbvdx0l+yJKIMsw6WC0pPBArclvXVH8OKU2L9+v2+1GVezCNjp+vdx94jnyyLDdCPlYffQTfvdhjg3SCBzc/cQp8j5IwqULuuHXGq+C8+Z3+O78/05f/xxCRTu3CHOD+ecLIj3oIDLa6DZhlwImQIGjXPzPsv9fZe9xndkL2kl4LthFNk76P7cM2BmCsRk0ddJONxTxhtQi4D04yorY2fcc8XPEYXD+KSW6xJJMP70dPH93gdaxA5wvoCReE6cE/6dorkLz7Mf2DkIR5KMNcb5dOvU7AF/XBSIwJM/bj8MZ41nJl310vGdOAduZsTvsu98F8gtN1k3di4cFD4ATX1sBsVA0uO/+Zu/0enpqVZXV230LJtCBEsKCJwiXWK4Ozs7isViNm5zb29PjUZDiUTCCq/0epCiTk9Pm37YH//4R2tKW15e1unpqV6/fq1er2dy0ghRgpOenZ1pfX3dhosBCRAluQf9f/6f/+ebbpstYDyMNo2awB4cMIw7dGq3GHi9XwRnK11SbkmzFxcXB1hHFJo5IOPj47pz545h1ODH8XjcFIIp4rqXl+jc7YfBQPPavBdY++vXr20gHE5umMXwuYuLC+swL5VK8ng8mpycVCwWM+0uem9g7CwvLw8YSCZXTkxM6OOPP1Y0GrUmUOb3hEIhq5dQxHd1sa7DA1NTU7p165bOzs70pz/9SZVKRT6fT8vLyzo7OzPYC40oBACBpGKxmHZ3d43ujiFjxCyQy/useDyuXq9nciqnp6fWZIxkSTwe1+zsrOr1ul6/fq1ms2l0daRzOG/lctkiYkgeFxcX2tjYUKfTGej2xiA9ePBAP/3pTxWJRIy+WyqVdHp6qtnZWX3++efq9Xp259lvt0VhaWnJFCXQl3v79q3dZZ41AcL+/r713WAc//v//r9/5/0jcCBQcOug+/v7A1nuycmJXr9+bVqBrVZL6XTaJlVyVqEg12o1vXjxQp1Ox0hQwWBQq6urRgenTsI9oJE3kUgomUwaVNnr9SxTvLi4UCKRMCo3QafH4zEaM0gQxX5KIJAUDg4OVKlUVC6XTVvuJmsoeVA2uFarWVMkxhFns729rWq1qqmpKeuRIHIle0DpF9YZHp1eEwToiEiJeogSXfocLBw6XcvlsvHn0caiaRDMEyOB00A2nRqDC2O5EfMwy42cMNRkLhS83UiBQ0oXPrRMSXZogBilq3k7kBPc9wIiIo1PJpOamJjQyMiI9aNQf+DQUTujsEdg4OoQXc8O3dnfgUDALsDJyYnNRBkW2sGwAvmRYUKJjUajpr9Gd/TFxYXVUiQZJMClAusmo+X30E4jK+S7YuDJmnlNSQYxMnm1WCwascFl2bn0eJ435xgj5AY3zDmiUP4+0BiwKSxL6WpGCeoK4+PjRumn7kk9kHNGYyMQK47JZeqdnp4qmUwaOsBejY+Pa3Fx0fYXkgsBzuTkpDqdjpEYXDo355B7zRiDVqtl+w71173XsO34zMMul9Xm1i8hP2CooUtXq1Uz2q5qhM/ns++MTaQ2eHZ2ZlJVkFCAW/lZshZXBZqABbvFPaFujGMlm3OpzNgi4LdqtWrQJLAvBAy39v7PrRs7Fxoa2RwieYwmuDuNQktLS+p2u9YEJF2l9qTnfGnEDSk2Eu0cHh7K672UK0ilUnbY+d1gMKiFhQXTzdrb29Pp6akKhYLJ1CDquLS0ZFGbC/2g6ttoNHR0dKTDw0Nls1mtrq5agY0L+D7OBdhmYWFBkUhEe3t7RnNmOiZih/3+peKsm+rTfEptiAcPC8btMXBFKqUrqIp9d/t4qNd0u129evVKzWbTBkEBXRClUewjAwkEAnaZgEJLpZI1tEoyxw+E8T77J13Nw4GhhgOtVqsqFArGACR6xTjRQCpdNkPOzs4qlUoZZEo2g6Ons5/MEh0wmF+wvIAhPB6PXrx4YeKEsBzZHwICamrSoFqEdAV/ur1gLkvrfcccMxIbliAsJt6bmpzboR0IBHR8fGznjGCO4j1OlwyMQAjqP/A49RscPX1ERO448cePH+vs7Ezb29smdMkzhw4PE6pcLuv169eSZA2rUPFHR0c1PT1t9TiCIOD3YRbPyoWfIGigxgyJJJVK6ac//akuLi5ULBaNyUoWx/6QpUGSIROhyZfv504nPT8/VywW08TEhNW/cOLIbzHmmPNC9utq1VFPa7ValimyV5JMPw/0hJaO/9+ciyQ7UIlEwrIUOothGKysrFiE5+pYYQjd2gMqoOCuUPSOjo4UCoV069YtJRIJHR4e2rAmsOFbt25pfn5eT5480bNnz6xwjNQ+kbtL+yXSIFpDc+ro6EgHBwcWBcTjcSWTSUnvj3ljOBYWFrS4uKhoNKq3b9+aUUREEMbb5OSkAoGA9ZOcnZ1pf39fIyMjWlxcVDqdVrVaVblctoyOgrt05cwwZm6DpEuOYPDSwcGB3rx5M9CvkclkNDU1pZOTE+3t7Q1kS67MiSSjaxeLRWOh/JDOme8Ew7DdbhteT6Scz+e1t7enUChkPQMU9xlxEAwGtbS0ZGwcIue3b9+aMQuFQlZ/i0aj+slPfqLJyUkVi0UVi0XLLBhcFQqFlMvl9PLlywFI8zr+TtTrNsiCf/Nv3BEMD/Am1Ob32cOjoyP7/ygaAF9ubW2pVquZc8Fo+v1+5fN568WYnp42BiJyKzgHGF5I5LgS88DRBCT8fCgU0sLCglKplF68eKHf/va3FiCen5/bMDu/32/jHyDnbG1t6Q9/+IPC4bAePnyo0dFRg/oCgUuBS1QBms2m1XaHrbvQ/Ei7BK9FkEbzJrDwrVu3rG/l6OhoQAw1nU7bKIa9vT17/pytVCqlUqmkN2/eKBAI6PPPP1cmkzF9wNHRUWNmcs4rlYq1MBwcHKjRaJhopdusi6M4PT21YYtv375VvV5XPB43Bhn2DptMPeym68Y/6Qorkt5Dp+PyAE+QlrXbbVNIhTYMLMAX5kETebtyK5KsZgBc5P4er0k6TtSJIcUAkva5aSxpMukgcFE4HDa1YjeVdEc4D7PIOg4PDw2TJQOhoc2lsWKY6KbudrvmQGjKg3Lrdm9fh2vILl12H4QILjpFW/fiUYwmEGDPyLbIRKizECWhRIsOlKQBbaVhl3v+yCgo+gLj+Xw+TU5OWtbiFvExzkBdLmyI8eb8IpXD/pNBukV4PgtQFnCMW4SlN6Db7Rodm2ZIIAnIMJArrqsMAB+9bzHf3UNQB84Ad9olzsAahPWEk2YRKQNtua/LPuDARkYu59O40wyBTqmNENFfL+ITsAAHeb1eY38Cc7skChqguTMuWWF0dNQynGEWzgUncHFxYdk4MKwkg6ZwrDBCMeRucR1byh3mTFMycMV1gcba7badcc75dSKQWzbgvGMzJA3U/PjMPDMgWT4f4qMgKzfdv3cSrpQuNZEajYZ1zkoyKGVtbU337t1ToVDQr3/9a9XrdX366aeam5szWqLX67XeCnoyPJ6rYU1EbUBX3W5XOzs7ZriouSAfUavVFI1GLepyKY0U7U9OTqzABaOFaJFIvdPp6KOPPtLa2prOz89tlsXBwYFOTk6sSWzYyHFzc1PSZeFRuhzc9NOf/lSNRkObm5uq1WpaXFzU4uKi4a/dblezs7Mm2e1meicnJ1pYWNDKyoq63a51d+N8XdYHODlNbfxxBS+JQJnlgMFFTRm8Go0u+mLa7bYODw9tsBEKuZubm0ZjHB8ftyBg2IWBAaKZmZnRj370I3m9XuXzeR0eHmpiYkKfffaZRc1ub0koFBqIgt2AhCwoHA5rfn5emUxGtVpNuVzOfpbGMmjB/B69FxhLj8djowgQ1fT7/RawIPjpBgKJRMLmD0UikX9EPXUL1O8DixWLRbtfbgYKFRgSRDQatTrGycmJVldXlc1mBwr66PjRAyZdTYqULh16Mpm0nrPV1VXF43E9ffpUGxsbpn0HzEJLAc4UyMkdv013OMOrxsbG9Omnn6rX65nhXlhY0NrampEoMMb9fl+zs7P69NNPh3bUCD+imgE83G63dXR0pEajoWw2q9nZWZ2fn+vx48fq9Xr6+OOP9eDBA1Pc5jxdZxkmk0nLDFB2Jzvh+xIE0LdFfyHnGXsKxZi/r1Qq2tnZ0cXFhZGfCCRxKr3epYIz+nm0MNCG4oqa3mTd2LkQOVAocrvjKdbzIV1WEN6TTSP1J/twv6Ab+bgwlOthiQQkWVTCBvK/LrSAo3JFHt3XI6rp9/uGd7q4uTtD4X1ojESFZEooFrsUWvaK/+9mXy533RW+IztwHfP1yNyNTq4TE67Te6//nRtFkr3g2GHkuYfarYPw7FxK5LDLZehUKhUrlEsysgJQi0sf5txKGijQs4iWicrJTNyCMK/vMvpcyItn4fYpkTESmbrRNUaKPSYzoYbjFu5dCrz7XYZZ1z8/z8a9g249FViMXi/3DrCXnEm3XsTzJzNhT9kXAh/OzfXmZDdjo3aFRpwky4qp8UBP5jkCh7ttDZw/anDDrOtZlZulcieoy2ArXbrw9XYDXpPPxH67FH+yBRf+ul6Xc5m4vC7PA0o8Ntp97i7dGNtDYyyBmXSlHYmNvek9vrFzYaANNYCRkRFTPsZgF4tFvXnzRv1+Xw8ePLACOgwDlIaJxmAQIZUA7AW9MZFISLpyKESXsDUoYDPClmLuzMzMQJcpkTdZi/tggQGky2jhzZs3xjjDoAGJwSIbZlH0xAGenJxoe3vbLheDefb29hSNRnXr1i0Fg0FVq1UbZ4wsPDNIvF6vdTtfP7w0UZIpckAlGWUzGAyaPA+RTbfbteY4Zqa4hAyawNwxqMBJRErhcFi3b99Wr3c5O+Tly5eamZnR4uLi0A6GMwabhboQBXecycbGhsbGxvTgwQOFw2G9efNGBwcH9ry5wEA9bpc4n79UKimfz2t3d3cAukFri5pSMBjU3NycUqmUcrmcZaeuNt71/q2joyPTX0ORwa230GyJgSFTA3Z+n8yFUdvogdXrdW1ubsrjuVRboHjOSOcf/ehHxq4jMod+TNOlC99ms1kFg0E74yxXOfns7Mzk6n/9618rFArppz/9qdbW1uT3+w2OnJubk8/nM/beycmJiW1ia8iuIpGIZmdnbZ5KvV5XrVazyBso3JWV+vLLL995/2ZmZiTJqMGRSESpVMoaO2Fn1et1BYNB3b9/377TN998Y6PKJVlwmUwmNT4+boQYlEL4rNSWqbPC7PN4PKa/xnlxHRyw2snJiZUVIBFgG116ssfjMU3A1dVVFQoFo2+70PjBwcEPX9BHrZe6BX/cKIiiaTQatbHFUAT9fr/1c1BfgfGAIJrrdV26Mc6IKIr6C7gwh49iK81YGAuiHzeaJdLk/aCCShoovNHJzesOaxz53BgNdzgQhep+v2/c92w2q1gsZkVRmDwjIyPGJimXy1bQZzASxgqBymDwcpLg6OioffZu92oWCqoGHo/HxBjn5+et9uMymngufr/f1BhGRkbsWfPazGLvdDp69uyZtra2FA6Htbq6+k4FQXcRNfO8icgIOmKxmE5PT1UulxUMBjU9Pa1kMmkaatfrAZxB/j9MrP39fVX/YSxyqVSy6DkSiZiDd3Hn8fFxLS0tDRhUtPS4hGTX1IuOj48tcOK7eTweK1i7QQJ3g2Lx+2R/CwsLuri4sOFPbuF+cnLSzvrZ2ZkxMT0ej16+fGmD/kAtILzQJEtRG81A9gNIlj4f4G0COa/Xa3I+3Gcoy3xnnAisyYODA6Py1ut1jY+P69atW+bkq/8wiRYdPwzu0dGRnd9hFsP0GCaH7A2No9QwaZiEVPLy5Uvt7u5aoEt9j8L9xMSE6fUBRxOUUCukx4rz3e/3rY6LoKhbgwbiBC4E9gYBwVnU63Uj6mCjJyYm1O127TNgf+l1+cH7XPL5vME1KJAiBZDJZOT3+23mBAVdr9drRt2lATK0h2I1UBFRoUsbvLi4sMY4ovORkRGjJ5bLZdtILufFxYUVznq9Kx0yDIsL2Xi9Xo2Pj9vrugw3on7ozBS2hlkwdYgSpUtJHZ/Pp7m5OZtKiIEqFArmADg4iG5CUCDzk/SP0m+Km3RKY4zZk/PzqzHOe3t7Ojo6GmDGIXcCLEjW55IBiM4R4atWq9ZIB/lhdnbW8GK3oPiui/TdhZigb2MU6/W6/TfNkO122/qlOAd7e3sKBoPKZDLGGiO6k2QssKmpKYMgiNDZT6K6Fy9eKJ/PWzYvXUF4uVzOZvZIsuiZQV1kS25Rlr4WjCfU3UQiYQ5x2EWUWigUlMvlTBKHoIk7AuSFoY/FYspmszo7O7NMjzqJqyjN6GScOOQFl6iCPAsEiUAgoBcvXujk5MSaAl1FBejtrsLDdWKNm7XX63Wb2EqPRzabNeo6TcfDLOb2uAEz7EyyeqjtvV5P29vbdi4JqrEvwO7Q2l2onr0BDry4uNCrV68UjUaVy+WUz+cNVpRkBCmQIgKiXq+n8fFxJZPJARKQq/QB6oFzLJVKev78uclfkem5vV03XTd2LgznisViVhBiTC/FYhofz87OdHh4aBAJlw6Gx8HBgR3MdDptqS8sJLDnRCKhRqOhV69eWVRNE9XKyoqCwaD110iXsvawy5DQID1kI1nUihiYxWeDDo3xXFpaUjKZVKVSsUxjmLW+vm5U5KmpKTWbTb1+/VrRaFR/8Rd/oYWFBW1ubto46b29PcOR3QsNZt1sNm0sLEU3CtdQhBGrhHqN82o2myZ3/ubNG9OJolhHWo0kPYcLRwJEyKFMp9OKx+MqFot2sXu9y4l99+7dUyaT0dHRkXZ2dobeP7JmePdARtFoVNPT04rFYkZ06Ha7Wl9ft2BofHxcJycn5hD29/fV6XT0ySefmAoEVHggL4INHBpnzGUC9Xo9g2InJiY0Pz8vr9drmfL6+rppotF8OT4+romJCWvYhA5O1ItDr1arZhzoR3lfWIwBXru7u9rY2NDi4qLu3r1rfU5kUG5tT5JR5GEGsl/lcllLS0umQnB4eKhOp2O0XAgg0IJHR0f19u1b/elPfzIIxuv16je/+Y1OT0+1uLiojz76yM4wRnh7e3ugjkcwAwzkQkPlctl02VBo+OSTT7S4uGjw+bBn8MmTJ1Z7gM26sLBgqAq2r1wuW5sAf4/MEowvCDuRSEQzMzPmOMl86KkiCwGO4u9pary4uLDgZHZ2Vrdu3bJG9G63a+OgDw8P9Xd/93dGEsERAsfi/Pf29kwPj79z60Hvst5JWwzDxsNxC39EtG5xGMMIhRbjjbeEyeRuJl3rFKHciIUvyWbyPm6h0y2uXt+Mfr9vnefu56cOQ1TswkBEl2RLN00Jry8MFgV7UmM3GnULhkQyPFTXuXDRXEYYy/17DCK1Ft6r1+tZw5d0VQ+ATuwWftkHIkqclSRLsSmgo9QK+wUjhZHnQA+z/qmiLM/+etESx8qlprubfeB78ezZR87ndbIJZAGXustiTzDG/C7nibPjXlC3oE89yR02RoTNz9Cv8D7Oxa03Xqeuu8VgghOyXaJ+6PsudZsImz/X75abUUMMQEWCzNpVPwd2BGblzLuvd51iLMk+m4t6AJlKsuK6qxjwrst9dr1ez+yQW1zn+bkN41CJQWjYI2wBqI37bzgxVKvdOvF1+vF1yJiz7AbVBDgusQgyDpk5nwnn7vbDcSaBBm+0X++yuXwoIC23ixdGCAaUA/Lw4UPdvn1be3t7evz4sc7Pzw0+6/V6ppqKUjAemUYqaMp4eKAvjAWGi5qL1+u1+gMRRSAQsEgH3SckFfr9vml8LS8va25uziJHIgkaHJeXl4e+3D/5yU8spWZOy9LSkoLBoGUeqAq4bCHIDUAl0tUYXVeKgcMB9FMoFLS3t2fECfSk4LejoFAsFq0Aurm5qVDociwytFj0isbHx62ISMQ0Ozsrr9erSqWier2u+fl5ffrpp2ZoqRlUq1XFYjHdunVr6P2jux4dOvSXAoGAZWWlUkmFQmHAKUJkAK7h91EqBnPGuBG91+t1FYtF6wxH+Zv56GQ/OI9Go6H19XX5/X4bXZBKpXTnzh1Fo1HNzc3J4/Foe3vbonnmp9ChPTc3p6mpKcXjcS0uLg7AJ4lEwp7BsIt9IUsdGxuzs8MeImjKHUCpIZFIqFgs6tmzZ/J4PHrw4IGRUHZ3dw2qlQaJExj6WCymsbEx3bt3T+Pj41ao9ng8Wl5etn34zW9+o2g0qi+//NIK2BAHMJzlctnm6TC36fDw0ORP5ubmFI/HNT09LY/Ho+PjYx0cHLx3O8HS0pIZap/PZ8V4bIgkCwKAu5C/Hx0d1atXr3R4eKher6elpSUlEgl5vV6js5dKJaOCB4NBq7d5vV6jdI+NjVnvUCwWU7fb1ZMnT7S3t6eTkxM9e/ZM0tU47UajYUE5BI3Dw0OrLULQuLi4MF1CIHrYeTibZDKpe/fu/fBUZJbLDsP4klq5Hhsvj2Q4vROkZRhRV2PHjU6r1ap141NrGB0dNVkUWCNuIyb9BkAabiGeGS3uz3PIeG+Px2MkAl6fCAImz7CXmwmYXFoYaFAp3WIeETWfEfzZbSxlD9xZDXwXnDQEADfiR+6Dg+kq8CLY6MqUEHVFIpGBtJ0eGBcmQLoeaMDVASODHfZiu1RntxfCjZzJgqWrKJOz6Wa6yNq4WYibqfCdiPJcgglNqxgyniGQEbVHAq54PK5EIqF0Oq1+v6/d3V07h2TJLtzEZ3dn5eDE3odQwrmBHQlczXlmD6VLB873J0ig1kSzKvAkbCT275+itPPH1XnjzFIUPz4+/kcMLz6Pi3Zw7jHCIBw4T5zh5OSkQZdoDb7PHvLZOYPxeNzqwtIVrZ1nRWDjwshkUDwDSXYHsYNkXRAigAixhZQgUqmULi4uBzhCvoFRCmUZBAMVj263a31pZFLYdO7V2NiY/bvblM7snh+ciiwNzvLm0PR6Vw1MKysrunPnjsErZ2dn2t3dVaVSUafT0ezsrNrtywFKJycndvGQ5AAiAGIh8pmdnTVZAtJj3h+KNLOroU6iIEpaSuoYCoVsXgKHBJ2oVqulx48fW2ex1+s1RdVSqaRKpSKPx2Mjn99l0RQFrbfVallmxqXIZrM2T2Z/f9/SZLIR6kI0t8FW6XQ6xqaB3dVsNs1R5nI5VSoVTUxMmJPjc6TTac3NzWl/f9+gq4WFBXOk/BxZEnvItE63N6LX6+nt27eWdbrSJrFYzEQth1lAcugfBQIBy36fPXumfD6vtbU1ff3118ZOgtZJlJzJZMw4tVotYy9SV+H74sg4b/V63RQUgGsowrJwJIFAwDrIea3T01PlcjljCbpyLuDfQMaVSmWAEFGpVCxj5Q4Ou6ibutkIxoIeIkgiQDFnZ2d6+/atdnd3JUmfffaZPXOEDGE4AnO5kCzn8z/+x/+oTqejTCZjGQ9jr6nhrq6uGhQM3R7oxv3uIBa8TzgctmyWwWu8N4FANpu1GuOwi4CFmiTvAcGjXq9renpac3Nz6vV6NtXx9PTU7vl/+p/+p6bQUS6XDS7v9/uW9dDPMjExYbJbvDdMzNPTUz179syowrdu3bIpldRc2Bvq0NQVYeOlUimjgEOQKhaL2tnZUTgctswRIghEg5ve4Rs7Fx6sG41gUNDHunPnjlZXVw1mqVar2t/fV6VS0czMjB4+fKhms6lvv/1WOzs7mpubM1G0ubk5BYNBu8hcOr/fbweN2gHORbqqI/Dn9PRUz58/N/YPOCtQEwVoXiMSiej27dsKh8P6wx/+oGfPnhlk4PVedn/v7++rWCzaeNFhFh25RNZEZy6bbXJyUqurqwbx4SjAyonggCvIJtDXui6Bw8GC5k2zGTBIIBDQ0tKSFhcXTcolGAwaPZkDSbaFMQVSmpycNOkSr9er9fV1CxyOjo50cXFh/SD0KAzrXMCYgVDHx8cVj8fV6XS0vb2tly9fanl5WZ999pna7bZev35tYqiSLNI7Pz+3yA24lKCJ+huNYhAHXIJCPB63LFaSOYtQKGQFUPTJeCZg4xhw6nuw3BjS9vbtWyM9oNMFjPpDLHqicGqjo6OmCwa2z+gF0AlGMJyenmptbU0/+9nP5PP5tL29bUX9YrFoETqRPBE6ApO///3vdXh4qM8++0w/+tGP1G63TamAYv/S0pKmpqYsIAGSpn/ken3IdWKI2+ZyOdXrdSN/uHWeYrGozc3Noet+GHiieklGvEBbEbi70WiY5D4susXFRf385z/X+fm5fvnLXxrkRV2IwAW0JRaLKZVKqdvtmiAlQVKr1dKrV6/UaDR09+5dzc/P2/RXnBr1ahx5oVAw1unY2JiSyaQymcxA8+tf//Vf649//KNmZ2f15ZdfamRkxGBvF9m50X7ddGPdC8eF5MNCNaYZEs622+HOH4yi2wtAtgFEQKqGI6M7FcNI5EIm4MJcLkHApd5KVyNjEYzj82M8gAWuHygiCbdr+10Xas5EJmQkODgeLjUoHI9bGKcm0Ol0DNNm//l7LhP74fF4LDpF7kW6wlFxHMiN9Ho96xUg46RwCjUbSAn4CMJFt9s1h0aXL/tG1D7s/kGmcKFTaM8o4I6MjKharVqfEtnbdW0z/pteAc4YmTBjGjDq7s/D8HKpmS7NVLrsIOeC852BEmn243ddIgCBD89GGozW3UxpmIVDlDQQuPC9arWaTXGkXYBMLBaLmRQQxBjuDfVWV6yT701GiMOamJgwWjPL5/Op1WoNzOgBvkJIk3MbCAS0uLiomZkZi/6xO5BScAKu40Ev7n1gRbIPd2AhGSeIDlkDDhGojLoGdwpIn/vNXeJ9XFYo957/hZ7sNi6XSiU7b53O1UwYZJ5gQvZ6PWPzUasGyiNrRA8SIgznHQX3H7zmAtaazWY1PT2tWq2mp0+f2uEKh8Mql8v6/vvv1el0VCqV1G63ByIbPhgXiBQaaqz74F1GFak6iqBEoxSu3f4JGtWoI4CnHx8fKxKJ6MGDB7pz547++Mc/6vHjxxYhxGIxE9QjTcXYIHH9PsKVkAagIhPd+3w+ra6uGl3wl7/8pcFTPp/PekTa7bZF6mQZjFGlkQ1KuNuvQrf86OioXrx4oRcvXigcDptaAg2DjD3odDo2ltrt8eh0Lse5fvTRR1pZWdHh4aHW19dN8+n8/NxwbiJ+agvAp4zWHWYht85gL4/nsrnP6/Vqbm5Oy8vLisfjevXqlU5PT7W+vq7z83MtLy9rdHR0gFkE4wVFWijx4XBYy8vLmpqa0tHRkd68eWNsKTBtGkfpciZLwbG2223t7u6q1WoZZCRdUej/8i//Ul9++aWePn2qv/3bv7UGQUnmJIE3gSHYP7frfZi1vLysXq+no6MjG0tBXQnlAHewGc8cmLTdbltTKpRz5r2fn58bJENQMzY2Zr1CS0tLmp6e1ieffKLPPvvMBrPx/pVKRXt7e3r16pUV5SORiCEGkixy/vrrrzU7O6vf/va3+j//z/9TxWJR3333ndUZyADo3ocmfnFxYRT8YReEIewFrRDctWazaVRoF86GbffmzZuBQJBAG6jMDaoJcCBLEAwB+U5PT+vs7EzFYlH7+/sWyNM4jQyOJHs9j8ej+fl5pVIp7e3tmdYhjZKRSER37941EpWbWZ2cnBgh4SbrnWsuRMYYMy7V9Y5PPDaOwMXsXIqvJNs8iABEOxxSNx12qY4u9srPut33QGFcFJrC3Pd2aYkuDY9/47PyZ1hYx30vl6ZIsRj6JyMLiIxciih7x++yr24DFt+Pn6W4iLNif2BakU1yeCEduHx4XpPv79KnySZ4Bm4xk8/vnp9hnQuZEoQDCvjURoAImSjpPnt+niz3ulSOS62/Tkqh0ZbP7n5vfheDACTkRpf8vEstxwhydsn8uNyuVptLBx2mkc1dZJCcL8gQQFCSTLQVGjVZ2fXmUc7NdQqtx+MZkE3iOXD+yGTZB4/HMzBaHOiU/yXIYS+AYQn2XC27Tudy+mUkEjFVBL4b+0tGPcziefKsXWfP86FxVLoi4LhkEnfOD3eY88cZJ7glyHDvtnSlVkGnPlkPATnBKXtDluTSpaU/nw2TlZHJu/2BLnHoJuvGzoUIJJvNmqwBeDMXAGwwFAppcnLSGA+kZGQdlUrFIAuEBmE9Ue9wYQkgG/BXivEUppgzAPsnl8sN9M5QVAUrppZArWFpack8NcV9DofLQKHpa5jF8CxkKNwaSi6XU7FYVKPRsCiZQjQDsFzFAiJO1ykBVfZ6Pet0Zi7On/70J0mygm0ymdTCwoJ8Pp++++477ezsWJHehR9nZ2eteHhwcKBu91K7a39/31J96gxAYC4dvdO5HJvKxEKaDIddwCvxeNxUWymcujTYSCSiR48eKRgMqlwuG1uIojRZis/nM1oy9Njj42OrBaAbRRY+NTWlxcVFqylQQ2Fy6tTUlBqNhnK5nPr9vulvcf48Ho++/fZbm+ODcjMGGHgOyLTT6VhWTfPl++wf2XM2m9WtW7cso+/3L+eLJJNJM0bBYFDz8/MaGbkc4bu+vq5qtaqjoyMzbF6v10bgTk5O6mc/+5lGR0e1s7NjlHA+L46iUCgYXZbvDh3+/PzcRqJT82FyJUZdulQLYT7Ko0eP5PP5DGZnSiWzUGioPTo6Ujwe149//OP3Qh+I5CnEkxXz3I6OjvT06VPFYjEtLS0Zw5BMB0o9DuXk5MTIJaurqwoGgzo6Ohog6AQCAZvzFAwGTSmErJnhfpFIxFALzhCBHgryOHGeHzNvUHnGKUFCIVDqdDq6c+eOHj58+MMX9GGCwPDqdrsmpe4W33ASdBTTXwG9l6IsBVUiCVI2mAvg1Pwv2Q2vgRGj5wNvSxQOxEMEQ+RYKpUsOxgfH1csFrOCIlEtOLibgcErHzZzIbUkgia6kGQHicgAHBaCArAicxYwPES90BrJTMgCpctDls/n1Wq1DDd3mV4UVjOZjB1MIkFmfsMGPDs7M4G+dDptsh9uTUKSOX9XWhxto2GNI88BfF+SGSSiNjKBQCCg6elpxeNxg/xQD+DzdbtdqyUQ7Xq9XpsayGAsoLB6va65uTllMhmDgM7Pz23oHPCtm90kEgnNzc0ZCQEWIJRld9/IjIgwOecUyVOplLLZ7Hs5FwKz+fl561jf2tpSr3epBBAOh42Mw/0IhUJaX183Yg6KBJOTk4pEIsrlctrY2NDFxYVN7Dw+Prb3dKNezvPR0ZFlaWSbSPm4EvytVkvZbNa+N5nW27dvVSgUTL/LNY4Em8FgUHt7ewZdFYtF3b9/X0tLS0PfYQJUzhvsQbc5udlsand3V2NjY9YfhQ5bv983AoD7TBjqhT0CauOO49BoRke6CZQFh5BMJjUzM2NODqSGjNetf1OeyGaz1scGUScajdoYC7JSCEdffPHFjbOXGzsXUjkae7jY/f6l2iZRIl6OBj6KmEREYM9Q3yjeUXgiWm61Wkqn01Ygo8aAgihyMXDCG42GGReKf0A0bqc+DxvDzIHo9/sWEfFZSTM5GFCRh1kUKoGaiM4CgcupnaOjo1afuri4sNn2vV7PpkUSnXOoiTRwLlxA9pS0mH10M0yMRCAQ0OzsrEFLUJ0pjiKlA1uHYVyo+tLUhjEEVoNSyxmBtDHsxaahi2eOgybbJDpj7vre3p58Pp9FgWjT8dmJPpHud7WUME5cLJzAxcWFORXkNVxWVbFYNLiIGgmkDXouaMIEdnOh5O3tbW1ubtrrkqm5nfvv41wIKJrNpra3ty2gC4VCymQySiQSqtfrFkhy3kOhkObn5+Xz+ezcsH8rKyuanJzU1NSUpEtYjamTFLClK+0tzqzH4zE4FbsAkcXN4sgOudv8PK9BwAlV/ODgwFoauBs0iDabTatzPnz48J33zzXSaCcC9SWTSQUCASNF+Hw+QyPGx8cViURUKpVMIseVmCJz5bywH9dp/nx3HBmZu8fjUSqVsn4roERsoyRr7sWGSBpo0WD/ksmk4vG4SdgALY6MXE70fPz4sfx+v83y+v9aN3YuGFu+EBF4IBBQOp02JgofiNnP9+/f18rKihXsSMFRX6VbfXZ2VtFoVKurq5qamrILdnp6qu+++07ValXpdFoLCwuqVqt68+aNUWf9fr8p4sJow6PjSGBQ0YOAdLsbJR0cHJgEOTg3wpXn5+cDIoTvunK5nLxer81u54D6/X49ePBAKysrev78ub7//nsbUgYUMz4+PpBS8/2gjbpsJ1eCh2jYbcij94LRCMFgUCsrK2bsiGxQmkakD3ozxUDw2nq9ru3t7YHpipVKRRsbGwPQkHshh1nFYtEMHQVb1Avu3bunyclJy1BOTk705s0b63dCmZdIj2mTUDEbjYZ2dnbMMCLhT+3GDUjQhGo2mwP1Gs6QO9qBDBpIEFUFlynFuTs9PdXTp0/14sUL62UgY8FxMgdm2DU9PW1swK2tLXPMqF9MTU1Z5nJ6eqrt7W21Wi0lk0lNTEyo1+vpyZMnBsOmUikbBkfggtJAIpHQ5uamvv32W0kaUDlASBRmEwaO70ifC8xD4BzYaaAbrpIwED3Pf2JiQh9//LHBxtzz7e3t96r7cY9KpZLBUJAeGPuOxh1Cl7du3TL4jOBheXnZ+rT4TjSCwlrFDtGHRKDGXuXzefX7fS0uLhqpgtLD9RoxJB6ILTBpCfoKhYK63a7Z8nq9bq+PzczlcjaO4b/4L/6Lf3a/3rlDH6NCQYooAYPEgXGL9W43PdCJW2iTrorcbBCRM3UXildEN25Hq8/nG2AmSVeY5vXCvdtzwMNyFYNJcXktole3sD7McjXTiEIpmPKdyfrc98Hou1RXt9ZCB6/boU+W4RIj+C7UrzBw1KtwTNTHiL4R/+SZ8uyJFnE8LiuFSA44jEIyUekwiyyX5+s+Vzrca7WaqWRjxHFIOEf2iqIxmQjvQeAENi1poPgN3Iqh4xnymVxyhQu3VatVMxIUvXF6bpEaEVG6v11ardtMOcwiQyfjc7Xf2EMYmdxjl+pOIMn5JAoms6O+2mq17CxxtgiEOO98f+6gS+bhvPPMuauumCfZ/3UtLb6PdAXF8cftYH+fRUYhydhx9Xpd0uV5JGuj7ki9mD6ii4sLc1R8NrJnbACBoWtnucPYWs4g82Pc1gu3wO/z+SxYdBvUKSGQfbv7CGID/Mcd/3PtGv/Ueme2mBvVY+ByuZwODw+1t7en7e3tgVkG9XpdGxsbhrFKGkj/+IPT2t/f1+HhoQqFgnZ2duT3+43G2Gq19PbtW8NRKfrDn19cXFSv1zPD4orf8XDBs2u1miqVih1+6hyMwqV+8/TpU5u/8T7aTqVSSX7/5bhbjC79LZubmzo8PDT5C+QaYNTweeiad+crHB4e2n7DRcfRwkriUu/t7WlnZ8ewXCiiQCJAMGhj0YBJLwy9JdJlx34+n7eCHww0tLvu379vGDNMNBeLf9cFIQLD4V6iV69e2ffb3t4eMMS3b9+2sbNg5hRCOWvAO+FwWOfnl6OJgVFCoZBu376teDyuzc1N7ezs2Pnr9/s2UoALyEUFqlhdXdXx8bF+85vfqNPp6NatW6YS/fbtW4XDYT148MDqNfQRMQogn89bIx6DpoZdL1++lMdzqeW1uLiodrttz4czyL2QZMFJpVIxaaD/5D/5T6yBb3t7W5FIRPPz8zo/P7cO8Gq1as6FuSz37t1TKpXS7u6u9vb27A4CFbpzk1yKN3BQqVTSs2fP1O/39eWXX2p6elqlUslgOog41EUTiYR9fow4849chui7LO6MK6WC8kahUDCnvbKyolKpZM2nKDv3+319+umnAwG36/ggOgCdu8w0pGTK5bIODw+NOAJ6gDQWJYh8Pm91bZ/PZ1L6FxcXunv3riYnJ60dQrrSRCN4SyaTWlpaMpQDuP7/F+fi0thcyAVMFEPvYtscMJgMaFG5UZGbyRCJwzLK5XKWcgYCAZ2enloNgEIu2RIGEePjvrZbQ+GA8LmIzokQoNBGIhFr3qrVavL7/QMDt951QUuUriIfso16vW6ptFssdPedjIB6i1u853BKssyOqJQIBQcLQ4l9IHL5c5/PJVHA5SdjdF/LPRfQPTOZjNGUXXrusBfbjbLdtL7X69nsnkKhoOPj44Hv5/NdyqyQhbAnkgYGtpG5ucOlKJy6z8rN2HBuZEXUEcjIOUcej8fqkXNzc/bciMSpAyHHAtzi1vnILt5nQSQAf0dUtNvt2jA6YDH2DVSg1+tpdHRUExMTOjs705s3byyr54ySkRB5Q7KhPjc6OmrnkTNEoEXQyudzWwvczIVnDm2XmpbLuMOgXg8EgazeB4EAcnKVCAiQJRnxh1EAbsYbCARMgoj6HHfN7XMhmHSDXrIX4FruOb93fn4194nsEecSCASsSZbsg7OKBA+2hXM8MjJixC3siyt7c5N1Y+dCqsTBZ1PYuLOzM83Pz2ttbc3ghrOzM/PCrvYX9EWaIykytttt08FCluXi4kIbGxt6+fKl0VBHRkZsAA44P7g5DwYn4XLwqcegkExmw8+4fSQYk2w2a5v9Pun0nTt35Pf7tbKyouXlZaPSunRnDl+r1bLomREBDHaimNfv9zU9PW0aV8x9YP8mJydNsXV7e9ui8Hv37hlJgoNZrVbtUlPQ73Q6psAqaUDrjSyF2hHNc+7FxzkSZDB+dljn4jKwcPwYRukSnnDZaDCvpqamrLYQj8etkQ7GoMsUZA9hS2H0GPoUCoX0+eef23dut9umxcSl5rNIl1peXu+lasTMzIzVv9x75Pf7tb29rVwuZ/eI/ZauCuFEy8PunyStra3J57ts5OVcI6TJHuNAcIDg8twPnCbMKwRhydQgPVAfoj64v79v0f2dO3esaZcmXDcjJdJ2+8ugK3MHycyppRIIFQoFc+TZbNZeq1KpyOv1GvFgmOU2S6bTaRWLRR0cHKjf7yubzdooAYKq09NT0xxDNfyTTz5Rt9vVt99+q+PjY7sfQLY450ajYSOHPR6Pnct+v28isEtLS7q4uNDm5qYKhYLB3tgwAiaYmigaz83NKZ1OG/nFZfcyK8fn85nT4tm7oy5usm7sXIjGQqGQOQS/32+ZSq/XUzab1dramgqFgn7961+rWq0avAPNEOn4fD5vGK7X6zW5k4ODAx0eHmptbU2PHj1Ss9nUf/gP/0GHh4cGT5A+YxyRiDg4OFAkErGubJdGJ11JsI+Ojur09HQgs3KLZ2Dd9EHwPd8ncoQCubCwoNnZWeXzedMLYm+hG56enur4+NgOaLt9OU0xnU4beYGO/WDwcpT0xsaGGo2Gjo+PLeNDdffg4EClUkkPHjzQ6uqqWq2Wpc3b29s2oMrNRLxer/XCuP0sYM3QFhuNhs0zJ9IkWueQkwW56grDLOCOdDptcI5bd2MOPJ/Z779UKIYNtba2plarZZ/X57uSA4K9B9HDZZLB8Pnkk0/04MEDdTodK3r/zd/8jfb39y1adOnx/F4kErECfSwWMxr62NiYEUWoT+C83YmORK/vG+DQL5LNZo3IgPMAokmlUlpYWND5+bny+bwxynDWMIdWV1cNyyf6pUBdrVbVaDQGVC2AcFZXV03h4e3bt0YSArK8XicB8cAZ8Rmg7AOdkT0AGxHQBAIBlctlFQoFTUxM2EC8YRaZLGcfFMXjuVIjcBltZA/8QSGk0+loY2PDRpRTXiAbI1BD0Pfi4kJPnz616ZrYCRQXDg8PrdZIn+H8/PwAsYm6nt/vVyaTUSwWU6VSsTtNEsB+u7bHDbxd5u0/t278k4g9+v1+S8fwalxsd9a9e0AkGV0TimAikbDeDOADt0BKlESNAUwaLB1ohGgLI4ZB5WGOjY2ZBhEGxGVMADe42C84pqQBOMzNMt51oU5AAyfFO9eouJLubgcwmVkulzNoysVrKbZymKQrpkm/37cJodIVr57Im1oLyrYufAXWC+zAJabAi3EnTaeHptvtmkgixUuMo8vxf5eF0jZd0EB1wBQu/ZrIsd/vG52awiuXdmpqymoEbm2LmTcIqhLBs3dQ1Xn/SCSiyclJ2xeyNwwjkXU+n5fP59PExIQFPvwOhX0Ug4HbJFl0Tlb1PgsdNaZyElW3221rDeC8sU9AJUA3TFdkzg99WAQgfO+pqSlNTU2ZGvH6+rrpkbmFfO4vDp79cxEH7jaBDczQVqtldGV+d3Z2VhMTEwqFQsYwpMEVaH3YNTExYTYGJ+KyBcl0uZeZTMZQlIuLy5EWGxsbBk0BrVGnI7Nmn6rVqjXkup36BONMpyRDBx1ynQCZr8s2BWKmuA/RhDvNfeJ/6YFxlTxusm7sXO7cuSPpMuWvVCqq1WqmB4YeE1EgXHZXQqDdbptsO/MIcEakmR6PR/v7+wbBUBhNp9OGoRIBEVFlMhmDQ8igMKBISu/t7enly5dqt9vGNHHrLcVi0bR6oBPy3YCGXOhnmMXFJpqlSCvJ9gP5+1KpZIV3jNDx8bHNIyfCI5siRSYtd7Fnv99v1G+499VqVW/fvlW/39fXX3+ttbU17e7u6vnz52o2myYCyIAnAgOeI7RJvgOKC0iEF4tF/f73v5ck3b171+oIEDqGWdDA6SGgN4r/z/ecnJxUq9VSLpdTs9nU3t6e8vm8gsGgXr58aWNvV1ZW9PbtW9VqNevsHhkZMXbi2NiY0um0RaH0sTDoi0ZfqJuuoyfiT6fTSqVSKhaLev78ufr9vu7evatsNmt9Yi6sePv2bX388ccqFApWfF1eXlYymTRlhGGdsyQdHh7afvV6PSM0EA1jdMjAmF+CCnCpVNLW1pZl9clkUsfHx3r9+rWpcoTDYc3Pz1uT7dramqrVqp4+fWrNhRMTE2bkA4HLIVQYL2oJNPBJV8VmIvt8Pm8GnsI6Wdhnn32m5eVlra+v69//+3+vbrerzz//XDMzM6alNewdvn//viQNjAKgjkvxPhaLKZFIKBAI6N69e/adaKD9f/6f/2eAQVcsFpXP5xWLxYyu/uTJExUKBcuSyNZwxrDT3r59q4uLC6VSKX388ceampqykdOPHz+2xtRkMqlms6mNjQ2rnaTTaVMGIJjBoRMoMpoEODaXy2l3d/fGZ/DGzgUnQYHNhQHAZNlIovTrlELX+7qMM5fVQbFMkvUZkNm49GW3sMTrS1fEACJ73gfIBvVVqL+kfFwYt6bhFu/cwz3scllxLsYMZg1JgYiN/WARQfN93BScvSTShdYN7g1WTBTD94Qu606pJNukwMrzh3Bx/TC6DEK+E9Gv22n8PotAg+/L53IzC2ie0lWth2I42ez1WtB1tWtwar4vP+vqNBGU8DuwbPj+LgmD881zJ2BgX8jWMfrXM/fr633OH/AXMI0ryc4zAh51yQjuvceg0u3t0o35ORdCI7tlP6Qrxh+ROxknhvM6jZ7fpWDtZnE8J7fxEFiSbBuBSJ7TsAV9UAE3s3KDiuuD+1x5K7IcCAh8Fpdq7MLyvAZEALTZsFXYCZAjgnm3jcBFaNgrzoELKWMzpStGsAsdAseSONx0/27sXLa2tmzD3GIjKa/P57NiOV+K2QOZTMbSZ/pXOp2OwuGwkQNgSgBZXFxc6Pnz55aCI40wOjqqXC6n3/3ud+bI3EtBWk6TZqFQ0NnZmVKplBqNhjY2NnRycmIbHI1GdefOHUvpgVcovMZiMYuSXAbauy4OUzweVyqVMonys7MzbW1tWdMazWr0CkBXdveNeS6ZTEbZbNYkdny+SzUEOrqfP3+u0dFRffXVV5qcnLTDcXBwYHg5DXoej8eUALg8kgx2gML98uVLayCjgRPduUAgYE22y8vLuri4UKlU0tHRkRmeYRe1CldMk2L5N998o6OjI62srJgCNKoDNPryvZDlx9nRaUzvAN+51Wppb2/P6oI430gkolqtZk28bpbtZsKtVsuy5GQyqZWVFXPEpVLJRj6QSTEMj6Lt9PS0FXbpTZqamnqvPcQhMvyJkQW9Xs9GFNAEOjo6qrW1NVMU4KwCX21tbVlN8uuvvzYHDoNrf39fGxsb+tWvfiWP53KGzMOHDy0aHh0d1erqqqkdEC3PzMwYaw0nA/mG0dx0ugNfklFL0ubmpr0mWnZkpclk0toVhlnAShTdu91LFXIoydibQOBStv7hw4eKRqM6OjpSuVy2unO329XBwYHq9brGxsZMrw5aMwPHzs7OrNE6mUxaH5QrEUNRHvpxtVrV2dmZ9vb2rK4MPH3//n2rUx8fH5vC8sjIiBFfmNNEjdTj8VijKGr2N103di5QIokguNxsbLvdNrFEl+HCxDsgADfioR7Q6/WsGY/u21qtpuPjY3M2FHKRfyF6xotCGSZCd6MJiqoYO7jxkmzzJiYmjK1D/YLvSie4m3m96yIyoY4B5kp/ABLoHAiKbxQtKfJC5T47OzOmE/AiPS30JiCQOTk5qdu3bw8Uht+8eWOMKdhC7mwJHApRKZFQPp/X9va2delHIhGlUilFIhFzgHSWdzodFQoFFYvFAWbPMIszR10MY3ZxcWFwR693NWl0cXHROvH5OYgbZF/QLV32HNkqf0cPUSKRMIiUs+XOpyFzp4hLlz6wL4PKOGM0wY2MjCibzWpyctJ+r9/vW0c3LDICnfdZOFQgJAQQJVmghgRRMpm0hknqg+wNvSydTkeTk5PW51IsFq0eRwf5xsaGIpGIfvKTn9jQP5hH4+PjFuS5+lpuXwdnD/o0fUiFQsECWfe7MTBLkk0a5XWoSQy7qM0C3WEXeE5kU2TxaPjhnMkuYHWVy2U7U8ykubi4MFgRQVv2nc9Pvx3BHTVRGKjQ3IGuT09PFQwGLXCFdo5UDeeT+wVRx20MBQF5lzv8zsPCkGIIh8N6+PChUeFgHgA1JJNJi853d3dt1vbFxYV1hSOrImkgFQwEAioWi9rd3TV1VkTyisWiFRD5fbSjXGYaOjvIGgAdxeNxZTIZ494zGwX2FBEUNGW3z+OfgipusqrVqnw+nx0gV8Dy7t27unPnjjneWCym5eVlhUKXM3BgRuHcoFNGo1Fznjh+enZY5+fn2tvbs8/AhDpqKGDuGMlYLGZ0Sd4fZlMweDml0uPxmOHGQbqQSCgUUjabte5hv9//3k2oRLLUP3DW/X7fGkjJ4pBid1UMoC5jENzMsdPpWP+D25fDM4eldHp6qsPDQxs9TG8BEBs1pcnJSdtLAiBgIqAJxAIjkYidPRfGwZFgKFzHNuwCbmYfx8fHNTc3ZwGZ24iKZA11AXokgGKAInO5nH7/+98bg8plFkqyYOni4lLNe29vT5VKxcQmJZkoJvva613N0OHZgYLAwiJzhv5MU7Z02bA8NjZmNQyK46Ojo1pcXBx6/zD0tE2Mj48bxZz3gTzE2XR7ThhiB5yGLBIq4ziQbDZrmQsUahwx9xWCD9Aqd4/7RRMuzg8YGedSKpUUCoX04MEDBYNBI2gQWFFToymdM0pP2f/4P/6P/+x+3di5cJgozN++fVtfffWV/Tty5nwhLjwcflK4kZER0x6iMEykDp5I2rmxsWG9GaOjo8ZuoYMd7BGmk6snFgqFzJO7GCedvKlUSrOzs+p2L/WIKEoDZySTSXk8V4rMLvNtmFUqlQzvpbjPYXr06JEymYzW19f18uVLpVIp/ehHP1IsFtPvfvc7HR4empNzhSaZFkn24VI5We12W5ubmyqXyzYsLJlM6v79+/Z8CoWCMpmM5ufnlUgk9PHHHysSiejZs2d69eqVMpmMFhYW5Pf7rRv4+tmgjwbDuLCwYNkWbJ25ubmhnQuQBBg0ituStLKyorm5OaNSAhOCDzcaDRu5TXofjUbteeNcruPUNObxb4zuhrIMNZ9ACWexsLCgcDisvb09G67kyn3AYCIKPDg4kCRziAx883g8pvsEAkBUPswiYKJ2NT09rS+//NKYcX6/3/rJYrGY1tbWzOm4jCIYgtLlvf/22281MTGhr7/+2u4ORW2CHc7948eP9e2332psbEz37t2zHphyuax4PK5cLqdoNKrl5WVFo1Ht7e3ZrHnUMyRZJjkxMWFMLAaQ5XI5xWIxraysyOPx6O/+7u+0u7urTz75RLduLVZMngABAABJREFU3XonOq27YG5xbhhExvm+uLjQ27dvLRghuyaDgLGFHWIAYqlUUjQa1dzcnEZHR7WwsKDbt2/r8PDQOuNjsZj18u3u7hpEjI0iGCS4WllZUSwWM+YZwQ3nOJ/P6+7du/riiy+MCSjJ2i5GRkZMr+zJkyc6PDxUPp/X3t7eD1/QZ7kFX7fY6xbU+W8i/esd1W6h7vpyvS94ML8Ll90tPkka6Gh3l0sAcN/XLeC7n+v667u/fz0yeNfFe7jFMwzFdWIDUTmF5uv1Cv7d7WD+p/aAfXSjcZf15hpU9pTP4z4/vrtbuHafLf/tfkZ3v9nzYR20+x7s4/X94D3dP9ef4fWL4b6W+9ru310nsvxTtTe+L5nM/1em++c+H7Rt96y5v/8+PS5/bvFZXeIN98INVK7vqfsMMaDumXJ/zt0DInnqpKAJ/H+XMPHnbITbi+aSddx/+3M/755R93fedblnw/2u7p3gXvJ9r/+ue/5c++UW3d3Xc8kK/H/6bUAcuN/XbSPP7vqZd++0C3tju68/R/4NyPOmzsXTf58K4Yf1YX1YH9aH9WH9mTU8zvNhfVgf1of1YX1Y/8T64Fw+rA/rw/qwPqwffH1wLh/Wh/VhfVgf1g++PjiXD+vD+rA+rA/rB18fnMuH9WF9WB/Wh/WDrw/O5cP6sD6sD+vD+sHXB+fyYX1YH9aH9WH94OuDc/mwPqwP68P6sH7w9cG5fFgf1of1YX1YP/j64Fw+rA/rw/qwPqwffH1wLh/Wh/VhfVgf1g++PjiXD+vD+rA+rA/rB183VkX+3/63/03tdlv//t//e/32t7/V1NSUPv74Y5u50Ol0bGYHA5t8Pp92dnaUz+dtUiTzIHq9nsbHx5VKpRQOh5XJZGwGhCSbI4+suc/n0+joqEZHR1UsFvXs2TP1ej395Cc/0drammZnZ3X79m2VSiX923/7b7W7u6ulpSUtLCzo5OTEZKp//OMfa3Fx0SYkItPdaDT09u1bbW9va2xsTHNzc4pEIpqcnLT51mtra/L5fPr444/feaP/3b/7dzYbgdEBzGZA6XViYkJTU1OKxWKam5tTMBi0GRf5fN5mZodCIZuQmE6n1Wg0tLW1ZQOoGEzEvBVmlDPSuFwu6/nz52q320qlUorFYia532w29fjxY52cnOjOnTu6deuWarWatre3JV3OEc9msyqVSiZBjjr2xsaG9vb2bFic3+/X2NiYQqGQPvroI33xxRc2WfRd17/5N/9G3W5Xv//97/X06VN7Rgyvuri4sJknzP5gfokkkzZvt9s2UAkZ+2QyqXv37ikUCqlardq8i729vQEVcFRmx8bGtLKyIp/PpydPnujg4EBzc3O6e/euvF6vjZlF3bZer+vg4EC9Xk+Li4saHx/XN998o//wH/6DAoGAlpaWFI/HNTY2ptHRUZP073a7Oj09Vbfb1V/8xV/or/7qrxQIBHTnzp133j9J+l//1/914AwyuoDvx8jt8/Nzk71nHggjq5l5tL29rXq9rnQ6bUOoGMLm3vHrIwwYGDgzM6O/+Iu/UCgU0u9//3ttbGzowYMH+vnPf66zszP93d/9nYrFoubn5zU9PW2jPrxer+bm5pRMJm12SrPZ1O7urhqNhql+81kZd+D1evWLX/xC//pf/2sFAgHdvn37nffvf/lf/hddXFzo5cuX2t7eVjwe18zMjE3k7ff7th9MjO33+xobG1M0GlWxWNTm5qaazaZyuZzOzs702Wef6auvvrKR0KgeI4Hf7/d1cnKi3//+9yoWi/qrv/or/et//a9VLpf15MkTnZ2daXR0VOFwWHNzc7p3754ajYb+7u/+ToVCwVSaC4WCnjx5Iq/Xq//sP/vPdPfuXVOobrfbNrG3XC7r5OTEFMADgYAePHigiYkJG2nh8Xj03/63/+0/u183di4cEmY8IwfvSjKzGciH89/X1/XL6v7edVnx6/Ln1+dBI/nNJnU6HZMS57MhVS0Nyvi7MztcmXv+XB8ZMOzsbUkDkuS8D+OT+c6upD9/z+e9LvF9Xfbc/RmclfvvLFeWm/++/h7IkruS7648OJMd/yn5cVeq3f187lCyd10cdmaU83yuS7O7hpJziFz49aFKrjy6ex6ur+vn8s/J918fPeD+jPt8XFl/XtMdF+Au924wMuF9lvu+7B/v6+4Lf8eeu3Lx16XrXSl+V/7++nvy9+4Zd+Xk+W8CBV7vz43acEcfuFLxfJ5/ShL++nd418XzYz4UTssdL3L9GV5/9nz/6zbm+rlwbYJrl6QrW+zaX8Ye4Jhcm8lrufeEPWRcs7u/SPC7A/l4Bq69+ufWjZ3Lixcv1O/3NTk5qX/5L/+lbZA7aY3Z8/V6XYVCQf1+3ybTcXAkKZ1Oa2RkRJFIRJFIRF6v1yYtMnCKKMo1XicnJzb/PJPJqN/va39/X0dHR4rH4/r7v/97m1/N5LZ8Pq9KpaKdnR1JGhgulM/n5fF4LOPyer1KJpM2mMjj8ejo6EiFQsEiWJ/Ppx/96Ec33TZbv/nNb+T3+/XgwQN9/PHHNia31WppY2ND1WrVxoien5/r+++/t1HIfr/f5przGUOhkI2YrtfrNmqaYVl/bu5GqVSyKXrSpYEolUrK5/PqdrsaGxuTx+PR3Nycut2uRkdHLfpLJBI2dfTt27cDToQMgVnf7jwYotjj42O9efNGPp/PpuS9y9rY2LDnNzk5ae8hyaY9BoNBy3KbzaYajYY2NjZ0dHRkI2KZ306Wk0wm1e/3tb29rX6/b/vNUKxer2eGlAvo8/ns7JycnNgQqMPDQwUCAY2MjMjn89mZPj09VS6XkyQbcc08erIspjJiWEOhkDqdjg06e/HihcLhsHw+nz766KN33j9JKhQK8nq9ymQyWl1dtTPIdMdut6t4PG6jeNfX13V+fm7ZICOJPR6PlpaWFAgEzEAFg0FNTk7anSE7ZEge2bN7Lo+Pjy2z63Q62tvb069//Wvb70wmo2azqVevXplzZXgbg+CIrhcWFuTz+bS+vm4ZJ7NxcGL1el3Hx8fy+/26e/fuO+/fycmJvF6v7ty5ox/96Efqdrt2RjgbTEElc2HI38nJiTqdjkZHRxWNRm1a6fj4uE01rdVqZmMzmYy9bzKZVLfbVa1Wk9/v13fffSev16uxsTHFYjE9f/7csuejoyM7l3x3AjLOer1e1/7+vorFog4ODuy8MdZ9ampqwMExKpn9lqT/7r/77/7Z/bqxc9nY2JDf79e9e/e0tLSkWq2m/f19NZtNmw0ej8ftoO7u7ur8/Fzz8/OamJgwI8V4T0a2cmkZd8zEPpyR69VPT09Vr9cVDoeVTqclSevr65b+BQIBZTIZ/eVf/qVmZma0vr6u4+NjFYtFHR4eSrocqer1ei2ljkQiymazNpoVaGJ6elqdTkfb29s6PDw0qGfYYVePHz9WMBjURx99pLW1NYt4eHDtdtumaFYqFb169Ur1el0TExNmFBnPm06nFYlEVCgUVC6Xbbxqp9NRLBaz54ATkWQT6HK5nDkEn89n0xXD4bBOT08NCgwEAnYx+v2+jexlsmgymVQmk7EAg2fJXG9GDNfrdbXbbZXLZe3t7cnj8ehnP/vZO+8fcNtHH32klZUVtdttG/FMtOYO2MKwv3nzRs+fP9fU1JTu3r2raDSqZDKpaDSqdDqtVCqlWq2mnZ0dtdtt22/gFc6sOywM+EC6hNtwAoVCwcb3BoNB1et1mwRYqVQkSfF4XNLlhFBgSqY3NhoNNZtNSZdTI/v9y6mHlUpFW1tbFqEPuyqVivx+v1ZXV7W2tmZOj4yo3W4rkUgolUqpUCjo+++/V61W08zMjNLptDnccDis6elpm/Oey+VstLXP59PJyYkFO9Vq1YKOkZGRgeylVCrZtE3m0OdyOY2Ojurhw4dKJBLa3t62c0MwUywWJckc+djYmO7evat4PK58Pm9OiOmLnA+e27DDwlqtlnw+nx48eKA7d+6oUqloe3vbov9er2fD1jgbnA9Gr0ejUY2MjGh8fFzBYFDtdtuCzFKpJEmamZlRMpk0G9Htdm0s99HRkV6+fKnx8XHdv39fknR0dKRvv/1WuVzO7COvT+bh9/ttcuvZ2Zny+by2trb04sULjYyMaGFhQbFYTNFoVKlUyrKzbrernZ0dVatVNRoNm8p6k/VOkyg9Ho/h825ahWfkEnLZ2u22jZHFCGCMOACkfeFw2C7O2dmZzXD2er02Txs4RJJ9SRwCaWMoFFKtVrN58mRIyWRS0mXkiANzv4OLk3c6HZXLZbXbbdXrdZ2dnQ3MiR9mTUxM2OjTYrGoXq9nB4u59rVazS4b44Jxvp1Ox3ByspZ2uy2fz6dIJKKlpSX1ej2Njo4O/LvX61UsFpPf77e599JV6js2NmYpPtFmLBZTMBi0OgWpNVmIe2hdyCMUCkkahDiJ5Dwej2q12nsZR0m2L/1+X+1227B4DGMymTTH2u12lUqltLq6qmAwqLOzM4vcpEtD78JA7AvnCHyZi0qtrN/vW5Tp8XjMobqGpN/v6+zsTI1GQ2dnZxYonZycWO0Bg0PkOz4+runpaZ2cnGh/f9+ehSR7//fZv7GxMTsvPF8yWc44kGcgENDU1JSNPPb7/Wo2mzZ7vVqtKhgM6vz83M6GOzs+FotZJh0KhTQ9Pa3x8XGVy2VVq1W7n5LsM+E8IpGIpCv4h+CSqBnjNjIyYrUeRvlOTU3p888/18nJiQ4PD9XpdMxmtNttC1KGWa1WSyMjIwqFQkqlUvZ8m82mBdnj4+NKp9MKh8OKRqN2B1ykAUPP2GlJNnrd4/EoEAhYkO7aJcYYJxIJRaNR+935+Xmdn5+bDaVW12q1bJy2z+fT+Pi4wXSnp6f2nBjTTGCRTCYteGu1WhaAejweG819k3Vj58KDn5iY0NramuF8rVbLDJcLkxWLRbVaLaVSKcXjcZ2dndnPNpvNgZnO0WhU2WxWIyMjKhaLOjk5kd/v1/Lysjke0meiwNevX6vT6SiVSlkEjdPY39/X/v6+zQb3eDxaXFyUJIOUvF6v2u22PB6POTOgr2azaQWuXC6nSqWidDr9XjWDe/fu2Rzy9fV1nZ6eqlgsqt1u6/j42JwLWRIZCPUCsg4cVCKRMEOYSCQ0NzenkZERNRoNc+hnZ2d2Wd3xuTjUfr+vRCJhUMPGxobi8bhFoIVCQS9evJB0hZeHQiGLvtxiN4EHsB5GmHNxenqq4+PjoZ0zcBTBDRfo5OREm5ubqtVqunv3rubn5y1TarfbWllZ0Z07d5TP5/XmzRudnJzI5/Pp7OxM8Xh8YKys3+834kMsFjP4dnV1VfF4XNvb21bI3t/fV7fb1czMjCYmJnRycqJCoWCRaygUUqVSUalUsjvR7/ft+Y6MjCgejysSidgzXl5e1p07d/TixQu9ePFCp6enymQympubU7FYVD6fH3r/pMuIGEJFLBZTuVxWsVg0wwis0+12FQ6H9fDhQ8t4ia7X19cVDAaVyWTM4HOHgGKi0agmJibk9XoN0fjss880MzOjV69e6dWrV+p0Ojo9PVWv17M9J3OnFgFUJ8kyD7dmyu/0ej2Ddh88eKDl5WW9ePFC/8f/8X+oXq/beT07O9O333479B6enp4qGAxqdHRUi4uLqtVqKpVKRm5pNBp68OCB5ubm5PF4NDExYQX3SCSi/f19bW1t2TPAQeCApqam7PycnZ1ZecHv92t6etqy3pGRkQEo+ssvv9QXX3yhw8NDvX79Wt1uV/l8Xr1eT5lMxs4bxIudnR2Vy2X1ej3L1D/66COlUilzhMfHx9re3tbJyYkODg7MBmaz2R++5oJxIXLmD9GOJIvIwGBJ413DwBf1+XyW0bhFdQ4suOv12eh8FvB2Dpj7+0BwvBdFODIs5tVfXxgZ4JxWq2U1o5GREYuGh1kuK4c02s2YKGyen59btkUEw/64hTW3EIoDCQaDFm1IsmySOgLv7RYNg8GgAoGAZWYYQi4ykSj77h7sZrNp54EMlFSaSJ1MCpbRsMVUsla3+Mzfuc/SLYrifHEcOFjpqqDJ+WU/cMrshyT7XdeRsu98f86K+1mAMt2MAMPpEhKuZ00EOvx8MBi0menv41y4W8Bb3D2eCYEHQQn7TaEcTJ4gkjPCuWTPCPL6/b7dz0gkYkbeNU7u67uFfrIakAvXxnAn3GI4d4mzwjkl0xgZGdH5+bk5+WEWKA0FcK/Xa9/PnUXvnikgYj4TCAuB+Z8j0sB0I1AcGRmx5yFdnV2+O/bU5/PZmcZO+f1+RSIRC0pdEsTIyIhBszwvzoNb7A8EAob4vEuAfWPnwuaQ7k1PT+uzzz7TycmJtre3ValUlM/ntb29rVAoZNRODFY6ndbdu3ft8vX7feXzedVqNcP3PR6PQUUws4iKPB6PKpWKKpWKAoGA0T7ZYIqqwEfdblfJZNJgEorjRFVAIzxUaJlE8W/evFGv17OIK5fLaXNzc2jjyOHjfdiDVqul09NTg044cBwmDobf79f5+bm8Xq9FdxxQ4IFut6vXr1/r9evXmpmZ0Z07d+zweL1eVSoVvXz5UqFQSJlMRqFQSPF4XPF4XH6/3y7069evzal++umn9rkkGQ369evX+uabbxSLxfTFF18MRPzNZtNqW6urq1pcXNQ333xj1Oth1tTUlBldKNC3bt1Su91WNBpVpVLRyMiIZQZkrcfHx/Zvt2/fNgNKRL6+vj7AgNrd3TXjClxTKBR0fn6uk5MTO6dkd5lMRolEQqOjo5qcnBwIFJaXlxWNRnV6eqqjoyN1u10LGrgvBFJ+v1/lcllv3rzRwcGBGdPrmdX7OJeXL18aHFWpVNRsNs1wuXBJsVg04oNr+DOZjH784x/bdzw4ODCDhOORpM3NTdXrdcViMY2Pj2t8fFzRaNTsAWeJrBnHe3Z2ZkQgSYY43L9/X91uV41GY4D5R8ZAcHR6eqo3b96oUCioVqtZ/RRYnbs97BksFosaGRnR27dvNTk5qfPzc3355ZdqtVra3t62Av7Tp0/NLhGQBAIBTU5O6osvvtD5+bkRiiCWSDKoamNjw+pYkUjE4NuRkRGVSiW9ePFC8Xhcq6urRvy4uLjQ4eGhEZfGx8cVDoe1vLysR48eKZfL6Q9/+IOazaa1dcTjcaVSKV1cXGh7e1vr6+saGxtTIpFQrVZTo9GQ1+vV559/rtHRUW1vb+vly5c33r8bOxcifwxxLBZTNptVLBZTpVIxxk65XNb4+LgmJiYUj8eNNx2NRo3R4RZ53eyFiBdnAJ7Ll6GPIx6PG2RBpE7a3m63VavV1O12LeKUNEAhJIJicYHdmg4sl4mJCd29e1dnZ2eqVCpDZy6ukeC9MPouhdKlBHKgYJ+QRrsURqILosdisajd3V3DX13KI0XDWCxmRWeKjK1WS5FIxAzPxcWFEomEstmsQRgumwrjkkgkLGLFwFBbANJMpVIKBALWhzDMGh0dtT2q1+tWCO90OqrX69ZvRb0K5hvnLJPJKJVKyev1qlqtqt1u2yV3mW9AHeDb0mVhFsYezgCHHIvFBjJnIMxOp6OxsTFNTk4a2eL8/FzxeNye59HR0QDlk4Iz9cTrFF6iz2EXZ5oaCsaP4KTf75tzgZBBgEOtK51O6/z8XLu7uwZr9Xo9q9tJUq1W0/HxsbLZrLLZrAUkBJbcTbJ5N/ugx4J9uX37tmZnZ3VxcWGIhEvFpc5DjbFUKtn+8Vxw6DjSYRcBYLlcVi6XUywW0/T0tGWZsVhMOzs72t3dNZiY7A90IRwOq9ls6vj4WKVSSYFAwAg4ZBz5fF47OzsaGxuz/ZMubQgOmAyJcwMUTV0umUwaQ2x2dlaNRkO1Wk21Wk2ZTEbhcFijo6PGyNvb21O9Xresi/rhyMiIpqenNTMzY7b8pjbwxs6FRskXL15YlIFTOT09lXRZz7h165YikYjBS9FoVMFgUCMjIyqXy+ZhG42GJFlzDoeL+o0LGRC1zc7OamFhQZ1OxwqqREcU1dwiYSqV0uLiosF1OBuX1312dqaNjQ1jY5yfn6tcLuv8/FzBYFDlcln7+/uSpOXl5aEvN46hXq+rWq1ak2MgEFAikZB0xcN3SQoUrr1erxXkMFSk5dKl4cDoraysKBKJ6ODgQOFwWJOTkwqFQlpbW9P4+Lhlm6enpwb5VatVFYtFe55AdMBiwIvAQ8lkUisrK/J6vTo+PrZa2Pj4uIrFohnkjY0NdTodFQoFi16HWUTyBwcHOjg4sDPBvhERN5tNdTodM2bJZNJSegIgMpDZ2VktLS1Jkp2JaDQ6kEX6fD5rZI1Go3rw4IFd8E6no8PDQzOEGErOYDgcNpYdnxUDAnWaZ8dl7na79vna7bZlYuz5+6zZ2VnLfMl6q9WqOREMbzqdNqOHUQYS4fdAEaBzEyCRrd66dcsciHTJ0iQaTiQSlhn3+32Vy2WVSiXVajWrMUxNTZlToPGyWCwa2YAgF+NO4Ol+ViBnt3bjNmq/64I0kMvltL6+rng8btlUuVxWo9EwIgTnhwCG7AKnQHNzOByWx+Mx59Dr9TQzM6OZmZkBFIfAe3R0VAsLCwqHw/bdIE9xx4G0yuWyDg4OtLGxoXK5rLGxMaPkAzXSfE2NmSzWraceHx/buZ2bm/vh2WJQJL///nu9fv3ajD+HNRAIaGJiQtlsVtIVfktk1263rXj46tUrlctlO4TuFyIydploHJjZ2VnNzs7q4OBAv/rVr9RqtXTv3j2l02kVi0XjyxOxT05O6vbt2/aApctimNs4REEdA1guly2rCAaDyufzhqsO09XLguF0cHCgfD6v8fFxxeNxO2REd6TvYKBAZrBJcM71et1SWI/nsgMX5tLt27d1enqqnZ0de91kMqm7d+9qYWFBz54907Nnz1Qul+29y+Wy8vm80cqlS3aN26+C4/N6vUqn07p9+7aazaaOjo7UbrcNhiDy8fv9evXqlQ4PD61PZ1hYB0ORz+dVKpUsmwoEAlpZWdH4+LgZIdf4AFtBlsAwtlot3bp1S6urqxYsuVRSggocSbvd1meffaZPPvlEhUJB1WrVIj6yH54drwGzh9qJx+MZYE+SMdAzw5msVqs6OzvT2dmZjo+P1W63NTs7q9XV1feKvHGk1FtQDri4uLA7DOpAhk/mS+8QHfGFQkHHx8cDTEyc8d27dzUzM6NKpaL9/X31ej1tb2/bZyeq5qycnp5qf3/flBGi0ahWV1cNnYCxBPsL1YdgMKiFhQXV63Wj7ru1B7LT/f19nZycaGlpSbdv3x6aLUY2vre3Z1krDE/qsYFAQDMzM6YaAMyN0gJoTDQaVSwWMwSl3W7r6OhIkvT5559rbW1N29vb+u677waaJFGHcIPM09NTNZtNRSIR3b9/X41GQ0+fPlW1WtXOzo4ikYguLi6MjRaPxxUOh7W/v683b96o1WoZisTrYgM9Ho9yuZyKxaK8Xq8Ro26ybuxc6EshAnMpnBgeCmdujwpe1YW9KFbhCIC+gFYwYG7twe1OdWEgis9uAZB+EDcNJmrg4lYqFTOi6XRaXq/XGpm4WEhf1Ot1NRoN61UYdl03rDBtSEXdxkCicb4nBh7D3Ww2zbnwWuDRsOCgGRNNs1dQll2jQt8HlEZkZljsIzCIi7PD3sJgQRSgTsSzfh9IhwVNmP0gsyLrhQFGkZXiMGeN7IIzy143m82BXhkiQQwVmRMRKrWsSCRiWbFLhycjjcVi1gfkkjh4rtA7efbuc3dhsfelcLsLOLTX69kz504S8AB9XlxcqNFo2P3kXvFdgcq63a7JnRC1Y2zdIv91GJx/cyPxWCymZDJp0lDAdzwP6Qpawz64RXOYYUT9GMr3hRUnJibk8Xg0OjpqAScEBSjnLjGH7+o2xqZSKQsaG42G0um07Tk9ZZKMwefaWM4NTE322iVDsFfAtjgSAhfILtLVXfZ6LxsyYfq5pCf3zhDo33Td2Ll8/vnnlv7V63WL1DhUrVbLCne9Xs/wdZxLNBrV+Pi44aK5XE6Li4v2wCny0XXaarVsY/Hwbsc9Dy6fzxv/ngeYzWYVjUYHqLw0Ku7s7KjVaqlQKOjw8NCaLicnJ/WrX/3KaJjj4+MWre3u7qpQKFgB89/8m39z4w1mcTDAXr1er8FPRMEU2SUNpNEYJNgjBwcHqtVqWlhY0J07d3R+fm5aRSgKzMzM6JNPPpF02ZkNbEZj29rams7Pz42WOjo6qvn5eXOm3W5XU1NTA0wW6Qoe5eCPjY3p008/VSgU0m9+8xt9++23Gh8f19ramvx+vzXU+f3+dzqY1xdGgezIpfdKl5BFNpvV/Py8BSsU7ak1uM6SIAVnvbOzMwCtZjIZLS8vKxAIaHV1VR6PR4eHh/rd736nYDBojY8+n0+JRMIgICifNKNmMhmDPIBJcGREm/Pz84rFYv9IbkXSwCUfthDNAl6dmJiwetXq6qrq9br+5m/+Rvv7+0omk1YDAPbe29tToVDQ7OysPv74YwWDQYOEFhcX9dlnn6ler+vly5fW9HlycmL1PBxtIBCw80lw0u/3lUwmzUAnk0mNjY3p448/1tTUlLEMQ6GQZmZmrFek0WgYFDcyMmKvD7mCM9/tdpXNZu35EHgNs37+85/L4/FYnwmOFXgUlINsC3gTR3vnzh199dVXarVa+nf/7t9pa2tLP/vZz7S2tibpqiGXJmrYmH6/X41Gw7LiaDRqThOYEod9enoqr9ere/fuWRY1OTmpRqOho6MjC5LcWm0kEtHKyopisZgF0tQB3QXz7qbrxs4Fp0GWgEeTrvSm/lxUgPSBW7gDu3UNKP8Gln6dqkkxF+yPLw91lM0mciRydem7pOB0+pOyjo6OKpVK2aEBK3cb46gpDBv58B1dGiqGxCUyUKjkwboUQZc6yyHBObvPgkyHqE+SZXl0tV/PXHhPIJxut2u0YjeKvk4FBd4AQqFgT6RI4EE0P+zFdjNmnAcRHBEq1F/+HYiJzAKyAcs9i0S6EEToIyKrwxDWajWrUxERn5+fGyUZCSSotxSVgTbdLIQoEgYmTofv6Rbb3zfqvr6XUNDJbKWrAIizx+ekBwtYhUCBewbdmgDQzWz5LkT6Lp3VdaBuA248HjeR2k7nUqKG+iIOxaXksz+8B+/D4u8kvZeDRnCVXhAyQOnKBvJ9Xco/gRBoAvYKqIzshwy8XC6bw2Bx7wg02DfuLTVu7gE9Z5xBMnv3DGFf6ZVzFVZcmPd6xnPTdWPn8vz5c3k8HqVSKc3NzZncBYaezs1Wq6VgMGje+PHjx9bQQ/pPetnpdPTy5UtFIhGl02k7FGwC7BDgK6LF0dFRq6XAlJiZmdH8/LxlKhR4UcLFGLpZULlc1tnZmR4/fqyDgwO1222trq5qbGxMy8vLki5puYVCQQsLC5qenn6nzXUX1GfgFJf1ArUYlk0ymdSjR4/MobsNg/1+X4uLi/J4PGo2m/q//+//29h7fr9fS0tLunXrlk5PT/XNN9/I7/drZmZGqVTKak8+n0+Tk5MGPUqXeDLZDYXGer1ujZtkW9JVXw0076dPnxrTZ3JyUvPz83rw4IE8Ho9lLpAUhnUu8/PzkjQAkUqXxuLo6MiywMPDQ0WjUVNMpmBN0RgSCLABit0YQFS92+22UXfp0Cc7h8YJXZdCK8aHojwXnroUMN74+LjOz89VKpUUDAYVDocViUSM8YgR6vV6BpmcnZ2ZssOwC0pru90eqK8RcJBZnp+fa3R0VLdu3TLDBayIuvjExITS6bTa7bb+9m//VtKlY0DhPB6P6/j4WOvr6/Z3MP4ajYYRTWA7wU6cn583piPyKUTSfD4CNJTTIbJEo1FDUnDm0NLD4bAFEMPW/ahBkD0TMJNxAiVzxycmJtTv97W1tWWaZhhpGK+FQkF//dd/bU4C4s78/LwKhYIqlYrtazweV6vVMm01Mj6cq3u3CLpoSO90OgqHwwOZRyQSsT40bEG1WlUul1M6nTZkif1810boGzuX7e1tMzzpdNoKPTBh2BhXe2hkZERv3rxRu922SBMoBU+/t7dnrwlOzxclnSSiCofDZvgQVzw6OlK1WlUymdTExIS63e6A5hkQDxkBG0wh7vz8XFtbWyoUChofH9fs7KwmJiZ079499XqXUi2np6dWgB/WONKrA+xAkRIaJ8y0ra0tzc3NaXR0VOl0WpVKxTqkeQ0k2tfX1/XkyRMlEgnTVlpcXNTU1JSePXum3//+9wqFQlpcXNTExISOj49VLpdNXwt6MDIqx8fHCgaDpl2Wz+e1v79vWm706BDxkkZvbm7q5OTENJMmJye1uLiofr+vP/3pTxZxIYcxzCIgIWOg3uNmsjD9pEsCBRTai4tL0cKtrS0FAgF99NFHdoYRQpVkpJRUKqWdnR29evVKkswYhsNhy27JZsLhsGU6nD8gSpxgvV63npZ0Om3iruwl+yldCVfCuKQze2try1QBhl3IqsBCOjs7M8OBcyHoCwaDpsW2sbGhnZ0deTweg35mZmYUjUZVKBT09OlTazUIh8M2OgIJFpiSZJUEoARV1/fQJT9QK3SDClAT1Bmi0aju3btnNF/QFX7ebfh2m2PfdWGEET6lvklk79YlQqGQCXnWajULsCRZQX90dFTVatWCOmwTtgzmI69JqwAKJ64sD5kiqAMZO71MfH7pqp5L1kl/X79/KVlUKpUG2j1AVpDm/8H7XHigcPG73a4VcjmcHIB2u60nT55IusTqHzx4YDIXfDCKTolEwrIe2GWZTEaNRsPeh4zHTT2JACYnJzUzM2NZDP8eCAQMkgNWwrEhGdHvXwq6TUxMWHqL02F+CWl6r9fTycnJTbfrHy0cAw+f9/d4rjrNuVjxeFylUmlAUoMo2SVVAEklk0lNT09bARn5ERwIRVnpKqWXZBEUz5VDSIMdgQKH3u0RcqNdnBHsHOoJXq9XU1NTtgd8hmEWwqMYZJwLTK9+v2+6SPz96empNYy52LurzcRnckkkFFaJoGnIpImYzBcIAkcDcQDCBfg3xgTnyH9PTk7aa4HPY0wSicRAM2g8HjdNv2HX3t6efVfuE3drcnJS0WhUs7Ozmp+f18jIiJ49e2aGiLk+OE6MF+w86rGtVsvkT4ANuW+QVvhOwGswFslqMLQ+n29AYJa/47kwZoOMwFWV4Fl5vV6DvIG5h83+3FqzdKV4wD1JJpM2o4oMkTOCrhu0ZJiX2Ezg1FAopPHxccuuIVJxTiEC9Pt9HR0dmT0hMyPTkWR13UajYa9LIylndXx83Jw5gQ39R2Tabo3YVar459Y7N1ECM9DnAA0W79nv93V8fKxf//rXajQa+i//y/9S/+pf/SuVy2Xt7u4O9KFMT0/r7t27AzhjOp3WrVu3dHx8rL29PXW7XS0uLhoeSFoLVvn5559raWlJz58/1+9+97uBTKpQKCiXy5khomN1ZmZG2WzWaHUY693dXZMLp/N3fHxcU1NTOj4+Vi6XG/py12o1SbIHhEYRkBNd88AvW1tbdnH4/Og1EWnEYjGjf9+/f39AmC4ejxuMRyMh0JRLd85msxobG1On09Hm5qbOzs5MspwDHolElEgkrDmROg36XMFgUN1uV3t7e6ZKi0G4e/eu7t+/r9evX+vx48dDX2wGHZHlYUA46B7PZTf3j3/8Y52enpo2F30HKBF4PB6DvujtYe/JchCXpNcIzSWKtUCu/f6VvAkMIGidjUbDFLlnZ2f105/+VNFo1Jzv+Pi4EomEMezoAYGtNz4+bpkg7D0Xxhxmffvtt/J6vcpms0qlUgqFQsY2hNV2//59ffrppzo4ONC//bf/VuVyWT/96U/1i1/8Qi9fvrQ7zNkk+u12uzo4ODACBOcUNWTubiAQsGCEmgWEiKOjI21sbBj05Pf7VSgUtLe3Z53+boPs6OioQYzValW1Ws2CD75bIBDQ4uKiKX3TYD3MgjLu1pGBxpLJpGVe2WzWziCZw/T0tEKhkNGp6XNKJBI20mBmZkaRSMREPlutlg1KK5VKOj4+thohWnZ8v1QqZZmc1+u198vlcsrn8/a8/X6/Dg4OVC6XNTExobm5OUmywBDnTdOw+ywajYb29/d/+MyFi0yBigiNQqdbaJOu2DgcMiAz0lKwQvjhpJYotEJtpuhMZOMWPPlvvDCvDWWRCB1DRBR/nXZ6nZhApkCai7fmMw6z3JTejXggKYC5utF4s9kc0EWC6UKkwe8ANdG347K5eBZ8r+sHg2YzlwaOg3JJFZLs+VD0o4DI53CJCtVqVefn55ZaY4SHvdju96SmxmfD4HLeJBkry2XFuMVQvjssxU6nM3B+wc+pZ4G3u8vNOoFw6BFwu8957u6zx0jwbFxCB//mst6GPXd/bg/d78HeuZRefg5ImjvpFpipxRB5u4SPdrttRBhgP84exosAAWKOC62zr2R57t7wmdxzSyGcjJNCv7ugPFPHHGZxdlyJpusMSOwO0KLLEnX7XaQrm+rCatRv+I7YJ+4WQQbPEPvrFt0JWIEtyZTYX5cqDhwGZMh7kvn3ej17VpzrH9y5UFDlSxUKBT1//lw+n0/Ly8umj0NdY35+3nSv6vW6isWi0YDJXsgUgsGgUqmUgsGgnj9/rv39fZ2fn+urr74yjDMQCNiwMGoAPp9Pz58/15/+9CednJyo0WhYAxbeFtkUd5DRq1evBrjxpIYUVMFWwYNRNSW9H2YtLCxYPwU48sHBgSQZ1AK7o9VqWcEV41Wr1SwN5vvhQFqtlt6+fTsgXEkxz6WMQ7WFFOHxeCwSqVQqRt+m/kXDIoa63+/rzZs31qns9uRgAGks++Uvf6lgMKgvv/zSRkbfv39/aCN5+/ZtI3egYg2khHRFIpHQ1NSURVicibOzM3sdLhhkj3w+b7gyRJJ+v2/SN7FYTGtra0okEjo4ONDh4aFBYUCVoVBIBwcHliUvLCxY5AxsKcn0yYB8IUuMj4+bU5cu4ZejoyPLAsbHx+2zvk/mwvwPN2ChRoVD4a62220tLi5qbGxMOzs7evv2rQVBzDvCUGP0OQ/Hx8cG8UFIkC6jYxy1y0YiEPX5fBaMsIelUkmbm5vqdrtW3H/69KkODw9NIh6jjYMBpqKn5Pj42LIm9mCYlU6n1etdqgofHR0ZqQVWnM/nM9jd6/VqYWHBGmGhZwO3k+VUq1Vtb29bvSgcDqtarSoej9uIB87B6OioNdfiRK4TRubm5hSLxfTo0SNr4M3n8zanhYAH1iz7dnR0ZPav3++rUqno8ePHCoVCevjwoSYnJxUMBpXNZn/4gj49I0RZZ2dn2t3dlc/n09TUlKWqfGkm2lGDoX7gNgbRfT46Omq1AiT3E4mEpbJEMBTpcQper1dHR0cmH41HHRsbs+l+9HBwMNbX100WBfUA8HQ3g5KuVJJ5P/DNYRbd6W6UwZAkOuHd6NeNusGeSYOnp6cHoBKcA30lUHOBCMHxmWpIJCldYbgunZY+jWazaQwlUvlisahCoWBFTZdSKl3i+UjS+/1+3blzR5lMxhQGhl0EL5zB61T0arVqjDDOGsONXGdElAZhBKkXHCb1MIIJyA9jY2Mmj+NGk5wf9hdZn7GxMdVqNZ2cnAzUGwksTk5OjEBB/cGlBFcqFbtbkUjEjMr71FzGx8cH/tvtFUJZl8Ck2+2axPvbt2+1v79vemtAuhBTuNM4PlfNl8CJ7+9qkHEf2HNYpzhm/r9LGYcduLm5afZBkp15zj/1XOCcfv9yvj1EjmEWdw6Hgc1ysy7OJvVQ2FY4UZ5rMplUJBIxpwMcCg2Yc80dJuhz2XMEJDTAEuzguMbGxgaG97nK7G6fF8QnVFiA/pCpwk5Rv/zBnQt4PqJ/NDWBJ2azWTUaDaO+uekiEczDhw8temMzSZHJNNyiKLIaRInMTqBYjNGfmpoy3LrT6VjkRAGeqAfGWCgU0tjY2EBnPvIleHs39aZgTBfxMMuFNqiXzM/PD/QDkA3QeyPJ+OqtVsvma3Ap3Z4YLi1OEsgNiA+2CVE5xX9GUBNJU1TFaHAwgRinpqYs+hwdHdX5+blpD7m6RW72V6vVjG477MIhMNIZh0cNAerx48ePB543czPcy0jH+fz8vJaWlgZgFIys13spYokWHGcTtg6CifPz80qlUhYBkhW5w7dgqkHaYA+BlIjWaVqkEVO6VASgx+SLL74Y2jBKV2whIBHkXzhv1AQkDTRRUrtwGV707nCfTk9PrVhNM3WlUtHGxoYFHG5/kHQ1o2d2dtamX5I1bW5uyufz2XRGGH9er1dra2uamZmxIBINtmazqWg0ahk0StrUSBjVPOweov1FS4Mk5XI5hcNhffTRR9Yw+7d/+7d2L0ErePYEuSALNDBKV0QLvi/wYLfb1fPnz40hBoGEoDuVSml8fNzuBg2twWBQ1WpViURC/X7f6jGRSETLy8vmbLGVBDrUI3d2dnR+fq6dnR2dnp6acsJN9+/GzoX0k6gmFAppbm5OoVBIs7OzmpycNA0mRB/JZC4uLkzhE0XVer2umZkZm1VPdIIMfz6f1+bmpiRZIY/mRzDNUCikhYUFS/dqtZrOz891dHRkCqBERuCHwHZjY2OanZ01WAUhw6mpKUtViTSBhNymxHddrnOBMQM05TaeUesACmTYGoySZrOp7777zqitYPkuRZioBAeEYZBkRX1XjnxkZMTo2zh2vrvbMEehkGJkJBKxXphms2m6VL1eT9PT01ZPIkiAmTbMImrnAsH3D4fD+vrrrzU7O6tXr17pm2++sa75UCiklZUVLS0tWbbRbrdt4NfCwoKWlpZ0dnZmhVYaIIFxiVIprk5NTZnCA5cfJg01MRhU1KdQpA0Gg1peXtatW7eMCCFdUXRpViTY6na7JuX+85//XF999dVAc+C7LppIwddPTk60u7urbrdrbDGKxRgQGJbT09MWZNCcenZ2ZtkFKhmtVsvg3XK5rMePH1tNCnVsMhnw/Lm5OU1MTBiEeX5+bpTXQqEgSfa5gsGgbt26ZaxA6PDdbtf2jrOJId/a2lKtVlMsFrMAYJjFADxYlicnJ8rlcjZg7969e/ruu+/0u9/9Tn6/39ox6H2hf6XVaukPf/iDisWiJiYmTL4fNXJJZqtANP70pz+pXq9rbW1Na2trA4jK7OysxsfHTUmk1Wrp+fPnZm9QLl9fXzcG59TUlKLRqMbGxkxJHnmasbExHRwcGHmDUe93797V0tLSD88WY84CBsdV7OShe71ew+ZgVvFAYETQH4FRhK7pwgJuoU+SGTi34YeoAGYPWYskq+kAGwFfgA27xUl6CiiYEZ1StANSYZLmsM4F4UwcgXRFg8URAKm4xXGMPFEe/wtbi/kMHHr2Bgzd/W+XZ89+QZgA7pFkETeOGIPJ6/HHLfTzPcgwcHBAmTz3YaNGl52VTqeNTgm8CgUTyieKvv1+3yJeYDSyT2j17vOmSEt0DoRxcXFhmZ90pa7LWXVHC7gNbW7BmqyGiapIevB8KHYD/aF24PV6B7Kfv/iLvxhqD4+Pj+0Z0vuBwgAZFj080lWxn4iaIi8OkwI65xLH7GqlIf/iKmK72T/ZKEraLgOLOwGF1j079Ki5GoEEUfTLucEadw7UY5jFsydToG+MzB/hSRAJoFd+l3ssyc4EPwN6wu+5C/RGkjHvICb5fD6zpycnJ0YY4AySKQKPExg0Gg2rc8O85Vnyv/F4XO1227J5F06/ybqxc/n7v/97eb1eayZsNps6ODiwGkuhUNBHH32kzz77TLlcTrlcTt1uV5ubm6pUKrp9+7YmJycVDoc1OztrhbbXr19brwSb7Ra3iXjh+vPeuVxOrVZLGxsbJnXNoaLzGYZIJBJRJpOxC5vP5w3SIcKQZB2oUFQ5mHSnkgkNs168eCGv16vl5WXNzs6qUqloe3t7IPtYW1vT8vKyHQA6vXHe0EXBc6FMn5+fa25uzrIXICO3Qc+Vquj3+3r16pVFMYyhJoOs1WpqtVoGO6BL1Ov1jIPvMqHIOjEOLuMJGJPsb1jnUigULHPKZDKmk9TpdLS7u6vDw0Ol02k9fPjQjAmOZ3193S4zmax02TtDxzmXJ5PJmIEk6rx7967C4bBKpZKpw4Lno/gwOTlpdSH2hv2XZFkbeldo29FjQnQ7NTVlCsA4z0gkoo2NDcvk/4f/4X8Yag9/+9vfWt/ZysqKut3LMc2c+9PTU01NTVkDLIO1qCmcnJzYvoPDJxIJnZ2dWdOlz+ezAGNsbEyLi4sKBC41ruLxuDlW7IbX69XW1pZyuZykKwYVQUA2m1U4HFaj0dDh4aGdtfPzcxWLRYNyqQfx7KQrKJVn5PVejocYdoECPHz4UCsrK/rTn/6kw8NDnZ2d6U9/+pPW19f16NEj/df/9X+tQqGgX/7ylyqXy0agIEjF+KMEkcvlrM4qyVAN7hcEB/4/Th5F61qtZs4O9emJiQkjIyWTSZPTbzabevHihY6Pj7W6uqpHjx4pEAgM2FsXFXIlZ8bGxt6JMXtj58JBBwuUrnR64HJTsHO1clwhO7cGwCHB6GB4+Hu8LpG+63Cg9kmywpckM54YNjBtLjkH+s9F9vyeKwInXdF4+TOsc6EgRiZF0Yy/5zO4+kwu1ZKomoeLEXc71P+c4b7+HaUr1pJ0JWnBnrvZiEvDxmG4r+VGWVCCXTjOpYgSmQ0bNbbbbds/Im6Ydcy0QJoFRyLJNOT4O5eAgNYaToL9ZY/dbGJ0dNQGWfF9XTquS4umQA21nP0CAqWDHBIFzYUEGewtd4UMn16pYRf1UJd6zn3is2P0OA/uM+ZZcheo7dFBz/wVSBTg+zhpVwGA50ANDIbXdRUH6qOSLHvi93ByHs9V4x9nzj3L1CeAA9+HcSfJWGKu4jCQcr9/2fNCxuJm8zxzN5si4HVhc/cMuUiFGxy1223LUhBAhRBEJskdhj6MzWu321bA53PSvgEV+p+qMb8LrHhj5/Iv/sW/UK93OXuCYub9+/etDpPP5/Xs2TNr+Hn58qU1/lSrVVUqFWPH1Go1g594WIuLiwqFQvr+++9NpoNshga+brdrBT8gklu3bln/Cg+XDYEKSjTv8/n09ddf67PPPrOL3Gq1TBEXeGBk5GokLs4GIzPs+ulPfzpwCaBfwzWXZPWfZrOpnZ0dtdttK7Dx/SQNOG+a2IAzKpWKDTtzmXluQbper2t3d9eyDTqBp6amDHYEkgEGnZmZkcfjMRZPvV632R5khxx+upXpTSAycp/Nuy6M2eHhoREEPv30U7VaLf3+979XoVBQJpORJKOmsmcurZyAp9PpqFgsKp/PKx6PW82BrBvDKMmK3tQEuOA8h1gsZtMD3X6CRCKhubk5mwnj9i1EIhHr5Gafj46OdHx8bFRfl72Gjt/7sMVgSpVKJT158kTRaNQy5UgkolqtZvL5tVpNT548sboWQSNNly7xZnd3V6lUyrTCYO3BPIRM4vf7VSwW9eLFC0lX48WXlpZM7YPvyNkZHR3VzMyMgsGg3X3gas4az7zVaunVq1c6ODhQNpvVJ598YoaV2l+5XB46QCTYJasEkXH7eur1up4+fWoU4ng8bjCUdMkaDYfDpuDNXrEfQP1bW1sWRBEocV/RgyObR/bJ6/Xa98NhJZPJgboztUNo3C4Lz+PxqFgsqlKpGGOv3+8rl8vZfSdzv8m6sXNhjjUDkhCZu7i40KtXr6w42Gw2VavVrM+AzmMiLzpxT09PbR5GMBg0aKDb7dowLVg0bDCyGnhWv9+vbDardDptuLubsruDjIj8b9++rbGxMYMl0MupVCrmcFKplLLZrB0k6hHXVXXfZd29e9cODp3jyKy7WRJDzxhURUGfYi+9AFA0ufTAKhwiN3vDoFG/YSiTy8ByoSScNTx7utR9Pp9FotB8iZRwSjyX8fFx48sD0Q27d+yNdMmeKpfLWlxc1MrKihVHCVh41jCi3CZPFIbJ+BqNhorFoj3bcDisw8NDG9U9NzdnJBOmrfL6sAkJFGApUsMCbl1eXrYZN0T5wA7ICpEd53I5vXnzxkYpIMTI92G2/bALZmC9XlepVNL8/Lzu3bsnn89n1GPYkowhKJfLBjfBLnKj4dPTUws2ySp4fQa1cUapC+zt7Q1kdul0ekBdwv2DWgESJwQoBD/unex2u9rZ2dF3332nO3fu6MGDBxaYQSGmRjLMwqi6Y0cYA4ABZkSHG5Dm83lrASiXy4rH45qbm7P+OgI4BG0Jytk76aoPiR4p7h+B3cTEhI3/JhBz2zNAZc7Pz5VMJpXJZOyZuU2cUOSZp0NPDDUxMsWbrHcq6INfrq2tWUTsFqLZKKiAHFouORssyX4HVk+hUDD4IJlMWu2EjXEL1i5cw2cgOofGyWcBN8ZBkH5zwJDYcIuOXAI+J4OV3jedJmqmcY0iHd8PCISs5nqz5fWaBdHv+Pi4Yc0QKiqVig4ODnR2dqb19XWNjIyoVqsZc4sejnQ6bawxdx85eERcqPy61N7x8XEjOlxcXCgejw+MKoANhGTMn+tyv+kiiwDqpCfq4uJCs7OzGhkZMQkM6WoeDhfeVQcAjkTXCnl9aJ2QAlz4gSmHnDGyPIq5nU7H4Bv6u7rdro6Pj024EhIMWSXFZc4cdQlGLbOn1CTfF9LBUJHJ88wlWd8FBI5IJGKzXjBKGB+3rgKtFQp6OBzWwsKC3SmgNZcCTA0wnU6b8wA2A8IG4j49PdWTJ09MtYP3BgrmDgHtrq6u2nMls4Zy70LywywXKnTJQtCMkbpxxVU7nctxHTBoqUvyHPj/bgDn8Xg0MzMzgFZg/F04c35+3thkNBIjk8UdgfgjSZlMRq1WS7lcTtVqVZOTk5qbm7OSA9T6dDot6aoXhjsfiUSMgn2TdWPnsrW1ZRfg7t27qlQq2t3dtdQVPjasnomJCYvuyDSOjo40MjJiFyidTiubzeri4kJbW1t2+WdmZmzMbLPZtA5bIqdYLKZsNjtweDHK0WhUDx8+VCKR0Pfff69nz54Ztu56abTF6NfpdDqanJxUKpXS0dGRvv/+ezussFXed1EsPzw8VDKZ1NzcnPHw+WxAFAsLC+p0Ovr222/15s0bawR1v28ikTCNKpg6sVhMvV5Pb968sQPH4KF8Pq98Pq/5+Xn95V/+pdLptCYnJy1C4nVdqR16HRCB7Ha7JkE/Ozs7kDFmMhnNzs6qVquZLlw0GrUAAkMwzGKcM85eko2b/eijjxQOh40+KV31dJRKJZXLZeuAdlN69Jyot3g8l4rTyWRSxWJRu7u7ajQaNt8dCDIcDmt1ddVw7r29PXm9l/02RKvUSVCMZqQDlOXz83NrNJyenjYFg5mZGeXzeT19+lTSJTOJTJVMZ9iFg8YAIujp8/mMakwTZTwe15dffqlut6sXL17YuGJgF+qCCwsLWlxcVDAYNEeIrlWxWDTSCtg+jiuVSunjjz82o+WSTwgU/H6/vvvuOz19+lSxWEyzs7Om1NFoNJRIJJTJZOyZ9vt9ZTIZffXVVyoUCnr58qUk6eOPP1Y6nVYqlXqnMb3Xl8swJcOHRDQ1NWWGnLviMv+oJVerVXNSBCEuJTsWi+n+/fvy+Xza3d3VkydPLCjh/WFyIcSKA2a0AXUzbAsK3NDunz9/rmfPnunTTz/Vo0ePBggHqDIcHR3pm2++UafT0fz8vKmU0Fh7k3Vj58LFpBsUBtD1AUPSlcaTSwN2abD8L52+RHFwu91CPFEO2D3Zi9sx73YZu2wpUsNOp2OCdUQUvBevxeEh0gWuIntwC8LDLKJ7YBG6yN3XdKMTlqtEzM/Yw/sHKIs+AulqhC10WpfQgIHn9dyfBbbo9/v2WtKVQXKLuq4WGoVCggsoti58yXN7n5qV25RLgACBBHgF4oH7HSCG+P3+AQhSupJixxFdx/vd30cbzY1KXVIFr+MWwd1MxS3QE/nyHi5NmrqOW4tzi/zvs66fXeoQnP9wODxQtyRypV7lLsgMnCm32Mx3czNtnBHnAKkh6OkEh7DqXCKNdMVIdPfBtSUEB25DLFkA3+d99w+nQEYBG5H7Bd3YJT9xX2mEBq7FPlF/w7FjF13qMDaOgIRnRC2M93TlaNz9IMg/OTkxVijwNnvo3m+agHmv6ySKHxwWA5o5PDw0uhoflB6WaDRqjX50LCMDQ8OOSwlNp9O6f/++Tk5OzDBhXEnT+/2+7t27p36/b18YWf5AIKBqtarDw0NNTU1Zg8/W1pYuLi5UKpUUCFzOLHny5InOz8/18ccfW6TIocRwPXv2THt7e5Zd+Xw+bW5uGq3SLcC+63r79q3Rr2u1mmmzBQIBLS8va3x83BwycBSQz8zMjMmdu0KfKCW3222L0tbW1pTNZq34GolETPYeYxGNRm0PoHdzuVFkbjQaymQyevTokdFnOdzMSudAQjrY39/X999/PxDZYlwXFhas+WuYRWHSpQMTOTIugM9DfeLi4rILf3l5Waenp8rn83bZer2e5ufn9ejRI5MyosMcDS8u/tLS0gD7EFgVY9FqtUy76fz8ciwwTpb+GbIeaoz5fN7OGmf99evX+pu/+Rt7DzB4CAq5XO69DKTLkqPf5ujoSB6Px6Ct8fFxZTIZ1et1vX792ijpi4uLFhB5PB5rAs1ms6ZMzIgM6ljAWL1eT8fHxzbjZnl5WZlMRouLiwqHw2b0stmsHjx4oJOTE/3yl7/U0dGRvF6vqSgQgNJXBERG4dzr9WpjY8P2dWZmxgIgtPrep1eNgMXV9EO/D2gaZ0APTrfbtaZFCCT9ft/UuMlY6/W6Hj9+bI6J16cIf3h4ODAuwOv12rTOUChk7Qj37t3TxcWFDg4OTBImELgcL/33f//3arfbymaz+sUvfmGjrgkGer2etre3rbZSLBYlXQaxwMI4rf/mv/lv/tn9urFzgZ3hCk9KsgfL/4eaJ+kfFZxdZWXSQhgJRIN8ATea5iABcXBRifbq9bpJSsNoQyCSKIiD3+v1LJJl4TBKpZI2Njasl8fr9dpMadhpw1JpoWLTwImxcHsr+M5uwRgs2+O5HM7mZjdkLu5BpoeIaB6aLdkDmSHNbX8uEkcTy5217tadcHBcMno+kBPhvYFRms2mEomEyWAMs9z3h/pK9uRmHJKs0ExdBXUJ/s1tHkWRAXYeZ5zaCk1q0qASMJE0ETpRvKQBo8AZxDHRswV9382IqtWqNjY2jGXGa+Os31dbjEVgcHp6qv39fcsmMNSpVEqdTscaFFFzIFIH83cDSpw2EC/n092Ts7Mzg/dcw0hUTj+adDVgLZPJKJVK2SgDEAzOs9uH4fP51Gw2VSgUlEwmDapi76Csvw9jUbpqzmYarySrP7G/Z2dnJibJiAGQFiSl2A9EaJH64TW4r0BbNJwTgLqyTMjuoIICnM1eEfS0222bqoutcbMbJHjIloB3XQr/TdeNb7qb3uGhaULE4BYKBW1ubprMhd9/OUYWsTa0qmhqOjg40F//9V9bVMLF5+Cj1PujH/1I6XR6oNuXon0wGDSMlwFG29vbNhmRKPDHP/6x+v2+pqamrNiPXA1enoiYzMWFm5rNpjWxDbNgDCWTSU1OTqpcLpsxp0mR4jpwFQ+e5ioyJ9hI1WrVGFsUspmjQiETGnE4HNbx8bGOjo4GiBSId5ZKJWPG9ft9RSIR5XI5lctleTweZTIZ9fv9ASl16OFHR0em5HxycqKZmRn96Ec/ks/n087OjqrVqs2MIfB410UAA20dthckCfaAMzY1NWX7zcXmjGUyGRMhpB7FiAAcPHRcSVYcxaDCPINGi6grsBAXGmdFVkjWxh5gIHFEsKOAjHiOqGOgNzbsWlhYsKwjGo3q4ODAslUMCwX2fr+vlZUVIxUAe5bLZasxRKNRXVxcWOCGwydYQzpHktGUsSORSMRYnRMTE5qfn5fH49H3339v+oUQGebn51WtVnVycmJ7Kl2NiyBolK602Lzey9lTBKg4n/ep+zGNc2pqyggW2D6K4kB50WjUmkqh7rt9XlDTadNgNhLEm0ajYVpe3Bt6uSCdkD1SAw0Gg1YnfPHihRFN+N2VlRUjW+EopUvb9vbtW5PRAZKlrkQvIoHQDw6L4UnREgIfdpvqisWi1tfXNT09rS+//FLj4+NWUHedEfTiw8NDvXr1SuHw5Vhk16DSi8FmrqysGF5NhEOU1etdCmqiS7azs6NKpWKNTtFoVF988YVFNjSD1et11et1PX/+3Brk2FBICmxssVjU8fHx0FEPEV82m7WiLREM4ohAJuwRMBpQBAV9DBW8cy4bf8c+QSFdWlrS2NiYzs7OtLGxoXA4bPtCxsQ+UJiORCI6ODjQ0dGRpqam9Pnnn5sGGZc2FAqZthjjWk9PT60HhSFjDBBzM953XUTOfO5qtaqDgwPT+WK8LZHs1NSUMQEpsNPYl8lklE6n1Ww29fr1azvLkozcgN6SJMPEKWq6tcT79+9rZWVFuVxOm5ubpiuGQ5IG6z7SlW4U/w7NmWyK5wPkB+zG2Ihh1/z8vLzeSyn4bDar7e1tyy5fvHihQqFgXfQIKhJgYaSAmjHU3W7XVH+BYAg4IZEEg0HNz89rfHzcarUwCjudjlZWVjQ7O6v19XV98803FiygdbWwsKCRkZF/FNy5mSMwMuQLj8djqr48PzeTGmbt7OzI5/PZqHXOkyS7D2SZ4XBYa2trCoVCFqRBOZYunQtikAiDktERBMF8JWNvNptaWVnR8vLyQP/a9PS0UqmU8vm8dnd3ValU9PLlS4MnsRmrq6sDjZTYjWq1qidPnphyCazZWCxme4uAKef/JuvGzgX6KTL2wEVuc06v17OIHyNEjQTjwqZIVzAaEitg4Vw+DjEKyTBtKHaBu3NRXU0sXpsxoe4FxkG4F8FtEERixuPx2EGXrhQAhllEddQsut2uRdWu9AMQD1E5ztTlrLspKlEZTomUmMMxMjJiI3ShZQNZuNRPutCJ2IHxoIWDf7v0TqBJ4B1mWYRCIZvTQ2ouXcExw6x8Pj/wXaEJu3pNOF1gRYqTfAZqTzwHIjRek3/j73k9xvCOjIwYuYN6AuwqtwDK+eM5uXACcJrf7zc5Db4DtGhIKYxicGnR7+NcKBiXSiX1er2BhmSmdLq6YhSOKUCD87ssJIw7Py9dNQq67D7+cL5dqJAs1C0gI2XEd8d+0LwJiYTXpHE4FAppaWlpgKACfASsOeyanJyU1+s1RMCFSIHesJH019CP4+qesafUCtlnbAD1UthmHo/HoHqP57LRkXvn9/tNV49mzXa7bXJRPBtKCN1u11hq2D1qt2SK9AayXNvjkgD+uXVj5zI7O2tU5EwmY4O+zs7OVCwW1el0lEwmtby8rFarpV/96le6uLjQgwcPtLS0NCCBT2QNTZXok2IztQ2it8PDQzPKsL5o9pqYmNDo6KilzY1GQyMjlyKJ09PTWlxcVLFY1JMnT6w4ieEdHR21CAEob2FhwWoHsNhI+d8HluDS0iCVSqV0+/ZtS0OPj4/tgFHAu7i40MLCgiYnJw2rdaUmXCdK8fLg4EB7e3taXFzU8vKy+v2+1tfXTRKdLJKIjswlk8loZWVFpVJJ3377rSqViu7du6cHDx6oUCjot7/9rVqtll3SmZkZE74joFhYWDAo5z/+x/8or9er+fn5gcFmw64//vGP8vkudbGABDEoZCtEXeiJtVotg7FisZi+/vprdTod7e/vK5fLWV8HKrqSrJBKkZbR2KOjowPDwqB8FwoFK9CjCkxDHM7cdajUhhjRCyTRaDT06NEj3blzR7lcTo8fP7bAjCzWFRcdZlEf4Gy1Wi3LzhYXF81w4GDB+DH4fr9fc3NzRqlHoRxVZF53ZWXFsizOiOs4Xdanz+ezfSqVSubsCGog5JDdk2FKMiIRI4VrtZp+8pOf6NGjR6pWq1pfXx+wM++7fvzjHxt6A0QEFEZz9MLCglZXV9Xr9Yx5ii1jL92OfrJaSdaDxmh1SVbvvH37tiKRiF6+fKk//vGPCgaDNpob1MOtKdH/RtCD/ZRkDevsfyKR0FdffaV+v6/FxUXNz88bAtRsNrW1tWXw+HV5nv+vdWPnQtFM0j+KxjB8RGNg3xwU8FqiBrcR0i2CuX0oGE4eCJGmdKW9A9WVCJGoiGiCA4DB4A/REJ9F0gDBgMuEMce5cCmGWXwmaLrUOiAYkK6SufG+sGPcz8l+8brUP8C0XRyaKJ7MkujNpcO6sBp7Q7SP4+aicLlgxUCnBFuOx+MDMJOr0/Y+3eWuOjXaXNepwxTVYXbxPfl+btTlNoxep/zy/11IgSyNc8N3Z2/d/yWT5rlReHbrEe59YtFYTC+ES3nlNd/HubAXQFM8Q7JYVzmcs8hesSdkVe5rugwp7rH7O9drMde/N/aE15GulNClK+kf9z3d93bPIvASKAl3gHv0Pnvo9niQffEZ+RyQZTqdjrEPyRK4q5BGCIpcgggkqFgsZlR2sjSXHCHJvi973263rWESW0Xm9Of2m0Vg5vV6B1QYYFxet/0/uHOhQ//ly5cWsYDBAX+srq7q4cOHOjs709TUlM17gCHFZeN3JiYmNDExYRAMuGmv17PoEBozvwO7jMip3++bZDcXBigsGAxawxoXtVgsqlwuK5lMGo5JOk6EBUQRCoWMocLBGHaRrdE57/F4zGBGIhEbsAQcsLi4aHuxv79vB0iSQWD0CXi9XoNMGMjU6/X03XffmdIuc0gIAg4PD03HiuzwzZs36nQ6NvxtZWVF09PTxvLyei9HKqAwvbGxYawSt48AkkW32zWWC1TuYbOXbDYr6Qoflq6cYblcNuYN2QgjeDFqtVpN6+vrki7rKgy6A1oA7uHiMU8oEokYYYSLD+uPQimqC3t7ewOsQjI6YB+3T4MoEzZkJpNRtVrV8+fPVS6XjWlGzY9ZMu+T/THfhFENgUDAInoaYROJhJLJpLxer2WpOMhSqWSN0A8fPlQmk1Eul9PR0ZE1L+PggWHK5bLVRoH23N4VzvrMzIzJRXGOqXmyx8jJYITPz891eHgoj8ejTz75xPbyzZs36na7piK+vb2tVqulubk5LS0tDQ2NQUEn2PL5LgedYUe63a7V805PT3V0dGQEEwJAbBkEh0wmY7pq2LNMJqN4PK7Dw0NtbGyYc+au37lzx5iO2MRwOKy3b9/q9evXVm/1+XyqVCqmxQeZyYXOr2cibh0YRXOy55GREaMn32Td2LnQi/Ly5UttbW1pYWFBX3/9tWHV5+fnmpyc1NLSks7Pz82plMtlcx6kwqTSyWTSRvYeHx/L5/NZ/cb9ObBKDEWr1TLceGTkSoLaxXxJv92mLvdwg51iJKD2obRLHwzFdJe4MMyChgj7B7onaTHSGRhxenyYv41zJG12sxWyExqrYrGYKpWK9vb2FI1GtbS0pMnJSWOyuEKKjUZDkUjEmGR+/6VeG4y8ZDJp9TZSaIwK/SBuY6okO/DQK5kNThY5zCKogDQQjUaNtoruGqKjwHwUdZEw2d7elt9/qXtGAIIxpCMcJ4mGGZkSGRhngICFOgCaT9KlESdrDgQCdlFdlWvGJYTDYd29e1ejo6NqtVoDQ9twXufn50ZXf58ziJYdd4gCN4SV09NTw+PJHIjO/X6/jWKA9EH/z+HhoUZGRkyGh/op93JkZGRgjLTbBEtAkMlkDF7jjPj9g3qCQJHc52KxqGq1qmg0qpWVFcVi/y9779UbeZql+T1hGDRhGYbem/RZ3nRXj+nZ1Wq00kDCAgtBV7rRJ5Du9QV0KegjDKAbaSRosQ3s7uy0mUZPd01VZaU39CbIYATDR5AMrwvqd/gGu1bLjKy9yxdIZFUmM8z7f99jnvOc54R0cnKik5MT0+5rNpvK5/M2R351dXXgzMWthZXLZYXDYYP/0LYLhUK2z9RiOPewWyGVoFQA84wJq6h7w76UZHsTDodt9DXOBXkl6ty899DQkMrlsvL5vJLJpGKxmAKBgI6Pj00jDLKLy8BzoTugcGA3HOBN1o2dCwYOKhuFJQwLkThFQmaZ5/N5VSoVS/kprtdqNZs1QKG+0+koFArZFD5S4ePjY2Uymb4OfNJedJpIU6WrtI9CKawwN7oNBAIGYSBBQzReKpWMow7Uw98Puo6OjqzoSbQAm4Vshcvs9pKwVzDs6NvhoBFNYXR4Hmgx8bnprcFY8V3IJknF/X6/jUCmIa7Vaml6etp6nVyYDCg0ELgSs8SRk2a72PSgC5r42NiYFcKr1apdBAwxbCbOGlnV0NCQReQ41Xg8rng8bng/8AoZJhE7kRyEE+oVvV5Pr1+/tkmmQHHcB4wa+wysQQYEJMKvWq1mMMjU1JRl5Y1GQ8Fg8J1GFkjS1taWFXiJYoFkUqmUZevI1EAqmZ+fVyqVMsaa3++3eUrVatWoywQbQESlUskcA2zJ6zPgA4GAnj17plwup729PespwsHyOQj8eH4Eg2SBuVzOmkJzuZxl5F6vV0tLS5qZmVEkElE+nx/YuTDTanR01Hq7mPFEkFqpVJTNZu2ekWFJV/Cex+OxccQoR3MGsUlAZ8Ch1Iir1aqOjo4UDofNcWGHS6WS4vG4JNldds89Z5H34M50u11LALAj+XzeCFuwTvm3NyXl3Ni5MGVNkgn07e/vW5QYCoVUqVR0eHioRqNhHblEF0BgvBbRbDQatUvVbDY1Nzdnc52BVJ49e9anzoqjQssHLNyN6sCW4eHn83kTF+QBwKVfXV1VIBBQNpvVo0eP7ID4/X59/PHHmp6eVi6XUzqdHri7d2Njw/4bnSyKyjMzM2bMOYAYlVKppFKpZE1hkqwnIxgMGiMEw020DAyD8b24uFCxWLSiLoaNugMy+dAfg8Ggms2m0X1XV1ctuiKbqlQqViwNhUJ6/fq1DSsCx3348KFWV1d1enqq4+PjgfePQjqvl8lk9PTpU4N4uCDpdFqBQMAcHu9HNzm1uXK5rMnJSc3NzalQKGhra8v6KMhIcLxAIFCdYUo1m029fv3aentu3bplgYLX69XBwYEeP36seDyuO3fumHPxeDxmMKl1ICnP6IDbt29b5Em2gCLGoOvbb7+Vz+fT+vp6X68QNPfh4WHruyiVSnr58qUZsOnpaUUiEUMmoF3PzMxYH8qzZ8/MifB50bUiOM1ms6bujIEGJkbFA+futguMj4/b+cRBFgoFczQHBweSpMPDQ52cnGhmZkbJZFLRaFRra2uKRCI6PDy0Iv8g6xe/+IWGhob0p3/6p/roo4+sidKtMSHAi0wSgSKZL1kXGQZyLRBNgEEJgHDCsVhM4+Pj2tvb06NHjxSLxUyQlVqa3+834hWBKhkoWmEXF5fjpsfGxvqCsr29PYPNm82mESggcRFA8Plusm7sXHhxPgBRndtVj1Ek46DIS80CeRf+HgYDdF9gK6AI0jJXX8tNmaEkY2C4KC5cREGKZiS3KCv16zVxaHk4QGtEAO8iuU9EBu5O3QQjT6GPyIYFHZH6EftKcRpSg6sJ5TasupExz4x6FDUGoB2MpwtdsICM3EZXnj2/kJNxa2sutfeHhg/ddFEToe7FM7pe9OYZA2/BBHQL/3x3l+XjkgTYUyA2l0LqEimInoFsKbSS2bvaeEC8vEevd6XHh/OQZLVF6YoOTFb0LoQIPjOZMaQVlltQB9YiSOCzAXO5hBGcLX/G/nDOXCicjn5kYMgs3H11iQycaZcUQY0Po0gG6RI06Pzn9SCXkM0PegZdVQuXkEQ9FBIQrCzuNTR2ZqK4TZ8w9rCbLjnC6/VaHZZn79ZnyZCvw/5kOnxWPsfQ0JDtL2eV7B6n4krkULchM8MO/ejO5Z//839uxWWaCYE+QqGQhoeHVa1WVS6XjSbHzBc6R7/99lv1ej1ToiVS47Wky2zi6OjIqLPQ8KLRqEVVFN69Xq+KxaIymYyl1SMjI7p9+3YfPz6RSOg/+8/+M7Xblwqv6XTaDnuncynohtFC2JF5BxSGx8bGNDc3d9Pt+qP1J3/yJwYdlEolRSIRkxp3m/N4cGQgc3NzCoVCSqfTevz4sSRZJNbr9eywksK60+6gXDMbB0YJhVyPx2O1BYqHOAggQS4pEAmF6F6vZ8VJDN+9e/f0wQcf2Ofg5zc3NxWLxUz7bdD9k2RF4m63q7m5Oft/WIDUpTCcc3Nzmp6e1qtXr/T06VN1u12trKwoGo0ql8uZJAYUdwwwFGvUeBOJhAU9tVrN6lzUdur1ujKZjMmbQKTodrt2D7xer3Z3d63Pif6lra0tg28ePnyobvdSggfJjmq1aqoK75K5rKysSLp0JPv7+2YcvV6vUZKz2ayNHAYCIwvc39/XP/zDPxhlNRaLmRYdqg1uYAaTKhwO69atWya1Uy6X+/poWNStgNGoyaDzVy6XLUspFAoqFovW/xSPxxUIBLSwsNBHHKlWqzYKPRwOG8likPWXf/mXkmSS9NFoVHNzc2q329rf31e5XFahUND29rZisZg++eQT02WbmJjQo0eP9H/8H/+Hms2mpqenFQqFdHx8bLUWmGWwLcfGxvTBBx/09fExp4Y7D3RIve7NmzcKBAK6c+eOoTRA6mtrazZvJpPJWOCAUwRirFQqGh8f17179yRJm5ubOjo6soGCPzpbbHp62r4QhoyIFNobWQRRGYwyCm0cqqmpKSveo1tDNEABD/yc3oVUKmUe1z241B8YSEbUQxRPpMrnf/PmjRmi63RPPjdRFRE5FMN3iRzBVTH+QCFkWe4vN+KLRCJKJpMmEcGfQ5iA6Qbmy0FDjoKLTnrMe16f4IfTkPRH0TWfhwU5g2iIn0H6H4n+dvtSsr9Wq1ln/aDOhcFFdGBLsu9Hqu5+RowW0Cvd7u5nxzi5TWIu8cTNOJC9ICsi6ibTQAJHupJ3AWoMhUJ9siNkfhS4KZJ6PJcKBDwLsnfEEd+FECHJIFT6wZByoi7A/YJRCATNXaOWKslmiQC5upR5zgR3hnoJTYAQbVwldOwHcJLLGsUJE9FjxCFqsI+8z+TkpNWNOp0rvay5uTkLSgdZwNIwBgnS2u12Xzbs9v9EIhElEgmTy+GukZGhQ+fz9St7A0dSgsDmJhIJTUxMqF6vW/+fG1gxAfT6DKPrjEjKCSASkvocDQ6bjLZSqVhGeNP9u7G1/MMf/qBut6uDgwPlcjnF43Gtrq7K6/Xagw6FQkbxRMplb2/PuNd//ud/rna7bZRG2CqhUMgO6/HxsbFu6AT+7rvvrJnt4cOH1rDFA6BYBz+b4U8YRS5wt3upIIDGEu9PM9LOzo4ODg4UiUS0sLAgSX0TId9FfgN9qE6nYz0TrqyG3+833bFyuaz9/X2DIMjufvazn6ndvpTb2NjYMOPOd5Yu02Z6VKCEvn79Wtvb25qcnNTa2prOz8+VzWbVbl+K6s3NzZlqMZRHLiwKyG6zJYeWYt/S0pLC4bDy+by2t7fN2eHccQoYkq+++uqt9+93v/udUdAxjFw8tKjW1tZ09+5dtdttw+Op7+3t7dkZ2N/ft7kk9EXcuXNHgUBAL168sDkxPKN//Md/lNfr1fz8vObm5jQyMmIXj0j5+fPnOjo6kiTrtAaa5M8gl0DQIMKen5+3C/vq1au+3ge3P4SAadBF3dSFT9EHS6fTKhQKmpqa0ldffWVBB0Y9m81qaGhIn3zyiUHN0IYJdlD2TqfTRgShhvX48WMb3QvMwz0g+MGZu/1u7p+59UMyLgIyZP9brctR4XyeUCikfD4vr9drjYWDOhf2D+dJXbTX61kwdffuXf2zf/bPjPK9v79vSvK1Wk0PHz40Hb5cLmdtAtgit7wAlNxut82O9no9m0xL3Q8NMmpiZD5ubxv2wOPxGBrCn7s2rVKp2IReAv5SqWQOr16v35ixeGPn8t133/XBOrdu3bIuWv4sGo0aFx8veHh4qIODA925c0f/9J/+UzUaDf3iF7+wUcawwyh4on7KwWk0Gnr69Kkxlu7cuaOTkxPrap6enlYsFjMNHhgbLg7Pw5JkEzM5rCMjIzZO+dWrVzo8PNTU1JQWFxftQGWzWa2trZn8wyDLdZhEKES6lUpFvV5P4XBYqVTKitP5fN5Gma6srOiLL77Q+fm5fvGLX2h3d1fj4+PWRU66z2XmfS4uLrS1taVaraa/+Iu/0NLSkrLZrDY2NkwhdXFx0bBeYEnGJqB4QANZq9UyyZqLiwtT8IU6ube3Z68jXbFWCoWCaVANsv7xH//RmlAbjYYNWyPbbbcvh5h9+eWXqlQq+uabb1Qul5XNZnVycmLF0na7rYODAxP8SyQSSqVS+uqrrzQ2NqZcLqfNzU276I1GQ69evVK1WtWf/umfamFhwQgDPp9Pt27d0sLCghWukfLBOLqRItF6rVYzmQ1o0ENDQ3r16pW2t7cVDAYtSpauGmdxzoOuk5MTeTwey0jIvJrNpk5PT03Z4fPPP1ej0dD+/r7VX4CjGXfOEDSYgKOjo5qfn7ceKvohMLLPnz+Xz+ezfh00tVBHoK7KOSMwdLMaaoPojo2PjyuZTPY1Bj979ky7u7vWFuH1ek1/z6WgD7p/0h87F4/HY2drfX1df/VXf6WTkxP9q3/1r3R8fKx0Oq1sNqvl5WV99dVXRovf29uzQj3QlSQbq03t5Pz8XAcHB6aXuLCwYBkP5z4ej2t5ednKB7/85S8tKydYIdicnp7uU0Cgp9Dj8egPf/iDNjY2DA3w+6/Ee3kG/0k69Hu9qzkr6EdJso58onCailzlWjxft9s1VgjKr16vV7lcTn6/37rA0dchqidNTqfTxmIYGhoyUgCQBdCT2xlOuk+3NfUhPhtCjDT/oU7s8XgM5gECGPRg8v5IR7gKBqTU1WrV8GSgAWAEJGHcPh1XmYBZ90TcNEghD0Mxllkt1BboeaF5qtPpWNbBc2+1WsYyo3kTg95qtbS7u2tsO/YIp8IoWyCeQQkR1H74neJkr9eziKzRaGhvb69vzjgifIifAtlxVmEk7e7uamRkROfn5yZ0CDSIzIh0ZaC5eNRQdnd3DfalyOsGWVxQGlTd4jksRHdmBnBGIBAwOIMzNOhySTicE56Hq+p7cnJi58CFqNyiOzOJwPSRmCcoBJpy2UUuWYbgCihX+uHMjP2AwdRut4291mg0+rIx2EzcMc44PUwwpAbdQ84eUHM4HDa4FntycnKizc1NOwvUcoFeIT4AU0OpJ+uS1EdhJjvhToNUcO+BCTudS0khSVYTlGTN5S6Vm1oqM46wt9Il/OZCwa4yANDyj+5ceIO5uTmDQH7/+99bIQ/jSM1ke3vb4AFJVnjyei+7vHFQIyOXg24eP37cxw5xu885nK1WS7/5zW+MLTU0NKRCoWDNX8wEx0hibDG+Pt/ljOjx8XHt7Oxob2/PDiQNgj/96U+tgRBoAJgNFsggCwjBZQ0RCc3OzioYDOro6Eibm5tqNpvGOyfiKJVK+t3vfmeXkSiE73udNghMiPGkdyedTluRGoeQTqdVqVSUy+UUCATs80iXByqfz+vNmzeSpM8++0xzc3PWz1StVvXs2TPreYGZB716fX1d8Xhcu7u7evXqVR9D6W0W42z5bqVSSQcHB/J4PPZepVJJf/u3f2vNm71eT7du3VI8HtfExIQ++OAD1Wo1/f3f/70ODw/t8rZaLf3bf/tvrabGsweXvn37toaHh1WpVPTo0SONjo5qYmJCXq9XT58+Vblc1unpqQ4PD41Igm4bEwjBwv/lv/yX+uijj/Tdd9/pl7/8pfL5vF6/fq1arabp6Wn7ntwVII9yuWyF30EXDEPoz+DtQC3c0e+//95orFI/y4zztr29rb29Pa2trSkUCvWNpFhdXdWHH36ofD6vg4ODPgYSzY2SjNiQyWSsi5ygzqXX+nyXaubMP/riiy+0uLiob7/9Vn//939vdYdut2vah7FYzOqLd+7ckXSZETCueZDFuHOcVyKR0Nrami4uLrS9va2joyN9++23pkyOQ3MbnWlGp/mx2Wzq8PCwDxZzyQggLmSIsMQkWaMjtiIej2tmZsYcmNfr1bNnz7S3t6eZmRn95Cc/MXQpHA7r8ePHNkaZnsBwOKxYLKZoNKpEImHBTSAQsMbfH73PRbrSFqKnhQIc/RJg7dcHBrEZqIaykTx8l3ro6ijhaXEuLkxDtIoHB4Jw6bK8t0ufldQXuVEXcBlCXDx6Z4ie3qU72sXP3azD7f4H0nMzFrduBJWbv5Ouohwuo4tXg9sDY1EkpkjrZnBkmpL66JpEhETS/Ln7PS4uLgdBQRd36c+8Bhj7oJkLdF8weIgQnEkgQLIS6L1uTes6NdiNACkMw3zkLMOocmWMKOhKVwwn17m6+3WdoMHncM+SS45x1Zld5hV3ZdD9k66chFv3cCnbPB8CMXB57oFLT+fMudR1GpmBeMgCOQdQt0EiyHw5P+55wVlAB+c9+HscEIaRs8szxD5gS9y9H9S5EN1zflyCD+9FbxrO47q6B6ws/pyslv136d/skXTV7OwiJy4F2aXau/bAZZBez0Dd50dg7/f7jQXqnhPs4Nvs342dC7IMsEnGxsZ0+/btvgMH1TcUCunWrVs23Q5O/ePHj634zGWBbQOUcHh4qNPTU5M5gC6LsXB7NohkSU9nZ2dVq9X0zTffGH0zmUxaCk/zEtHbnTt3+ow+zDTpahQs6gDLy8u6devWwLAYEQyGMRQKGa6ORhuqr8BzQ0NDBp9RR/F6vdZAenJyot3dXYVCIa2srBhLpFwua25uzuQhGPqEYCGRt3RJNKhUKpbNcOhdFpnH49Hy8rIxjV6+fGlGamhoyOjHfDf+7dnZmXZ3d9VsNrW+vq4vv/xyYAcNYYFC5tDQkNbW1uxMwPfnrOFYDw8Pja5KX0AkEtH4+LhR56PRqKnOYvhxLhh8n+9SCRp6rqsz1W5fTgCNRCJqNpsGDyaTSWvc5PJ///33+vrrr42Rk0gk9NVXX1lfAVL1OD6efSKR0IcffvhOsBh0aMZmABHC4JycnFQul9PR0ZFl2H6/3wJGGH9+v18LCwsGOdLk+Od//ueGHkiXDL/x8XEjhjSbTVNswKHzPIaGhqxOcn5+rhcvXpi0C5E02mhHR0dWg5ienjYSSiAQ0PLyslHUYZDCtJycnNRPf/rTge8wAQkM2PPzc/3hD39Qu91WOBzWgwcPLEORZD1XoVBIk5OTxhajduEqhU9OTurjjz9WJBKxYIXMhFodQQhOwrWBgUDARr1Xq1Xt7Ozo/Pzc7BZ3pFaraW9vz4JnRsgTAIEYEWhD/S6Xy5qentaXX37547PF2Ag8nd/vN/gAr5jL5ZTJZDQ5OanJyUnF43GTXcnlctrd3TUDi44W+Cu9FZlMxjBGinvglzC8MBIUJCWZcykWi5KuGtN4oBgeZijQiS5dqcW6MB1sC2iPy8vLSqVSA9ORgRX5/MPDwwYBkGZLV6oBiNEho0NUyGFFjw3yA/05EAHodOaQ+Hw+azYl1XWbWUmpqUGBh9OUBTsKGDIajdoEPKRWiEoZIHZ2dmZyOpAkiP7edhFVowzgFnPJKCT1XTyMPyl/r3epvfbw4UOlUinTWBodHdXk5KRRZT0eT5+SNP+WwrNbZAb+mpiY0OLiotWW2u3L8RHg/YHA5SyYX/3qV9rc3FQikTANN4wDy60flstlYysuLS29ExV5fHxcHs/VbBCgNmqpo6OjKpfLf9SFzb2hGxyn6FKR/X6/VldXFYvFlMlkVCwWrWeKfpXrIwRYQLyM6a3Vanr16pVBOwRmQ0OXI4tfvnxpEBk9RRMTEzaldGZmRiVn/hP09ampKS0tLQ18h8megeArlYr29vbU7XZttAS9eAQTBCc4UKjWICnuHaOfCgiK2ie1K86iS52neRn4lDvBc5uamtLs7KwajYbVclHvGBkZsbYQngH9f5QeoMVns1nNzs6+1f7deJdhEwA1IBY4NDSkW7duKZFI6Pj42IwiopV8eQ5Uq9WyhjWMnRst47RGRkasUMWBR0IGLrmbJlNQBNOkWM2oz4mJib7ibLfbNf0fNp3U7+zszOZIdzodTU1NWVYwaORdLBaNqYPUC3ADWDPyNh7PlW4bDanFYlGHh4d22YDGXNbRyMiI5ufnNTk5aTPrOcwU5pLJpNWg+M4QJw4PDyVdGWiwW5whDp+CM5ckl8v1kQzOzs6Uz+et9oBj3dnZkd/v16effvrW+weez56QRcNkGxoaUjweN2PHCGv22YVhgR+J+ngezWbT/h+5HwgqsPmYAYRDgwUHvZuzSN0E2Royung8rnv37mlsbMz0oaj/ACkSdRMQ8UyASQdde3t7tm9kgNzRqakpxWIx05BzYRv6ifx+v2mwETRKMskbqR8CbTabNhoYKBtGmNsVLslIQAcHB2q1WsbqJADDduC0mUsfiUTs35KpbG5uWraICkO5XNbx8bE2Nzfl8/n04YcfvvX+Yas405wNF4oHnpdkWSfB7MXFhVG0CSCBXOPxuKE4QKFkOWS1kkwGx+u9FL8EjaDLnywNpMmt8/DZQD4Y7Y4NgNUJSgIFnHsMtfpHpyIDS4CxF4tF7ezsKBwO65/9s3+mDz/8UIeHhyZvXalUVKlUNDU1ZTAYjLFcLmcDbsg83IhoaWlJ0iXTgT6PRqOh+/fv66uvvlKhUNCTJ0+M8kn/AFEeRhP2Bt31RNZ+v9/UQmu1ml6/ft032KlQKBgD6i/+4i+0srKisbExU0geZKE5BPuMX0BkiURCp6enBlegt3Tnzh3Nzc3p4uLCOqcx8MBnNOkFg0EtLCyYwB0Nb2SJCwsLmp6eVqlU0tHRkWkXxeNxVSoVbWxs9MFupO4YhrGxMRtXi05TrVYzphRYL4XyoaEh3b59W8lkUr1eTy9evJDH4xnIuTx79kxer1crKys2GA3e/9zcnOLxuNXSisWinjx5YkEMagL0OIDTQ/kFfmSO+dzcnGVfZL1er1cTExN26U9PT3VxcWE6axjqQCCg9fV1hcNhlctlK8zjoGdnZy2r7HYvlX2//vpr5XI5Eyekz4k+ouHhYRMYfJe636tXr8zpTUxMqFarKZfLGXsIkgIkBIIGWJ2VSkWZTEaNRsMYopw97jfGNBQK6fDwUK9fv5bf77fWBQrF1PgwwNxhJPrROuM1OVfdbtdgqXg8rsnJSVUqFX399dc2TqNYLFqxXZL92d7enqTLaP9f/st/+db7V61WLbhDjonAA6iLZ4Sd9Pl8BkMeHx/r8PDQaNHRaNRUA+jYB8UA0SG4oBacSqUs+K7VaqpWq3r69KmRW6SrzNfjuRITJvMbGrqcyDo+Pq43b94YxN3pXE7/RO0Elik1LMYvv379+sdni/GCRPfAITC6iIaBtWCKUVwDSpNkURBDmDBKbIqkPrVjaix0inLRcFbUffgFuwFMkofvdnGDZyKhgLeGsIAhgsLrPrBBFmkwGQdZmlvspLjZ7XatuEfRFeaQdBUpUlgjkmffKNxT7Oezn56eWsaGcZCusgHqTW5Ni1oGUSrRGpg5Cqt8TqJUWC3UejhDg+6fS4YgZXdp3TSdYTxdTNql30oyh8Hr8Hx8Pp/JDtH93Ww2LWsjQgamYH9x9O6oB56HqwLBnvH+QCLsvfusgZPAyinOvgtbjPPL5+h2u5bRkW0CJ5HduN3nnEto0bC/qEXwnMnqmJUElMi/Y04IKsA8C7fYzJnkM7hCkNzXs7Mzy6A4c9QUeU/ODjaKrHKQ5X4PzjljAHjmwFiS7KwiuQQsS/uBq13Y6XSsvwUleWwTwpXA29DsXTUFZP6Bunl/MjiXgEEjJJp67t7DcHPZa9hipI9uum7sXFyWEtHK9PS0sb3S6bR+97vf6f/5f/4fy0DwrrOzszo/P+/rHYFNAU8c40tUWS6XTWYfLahyuaxf/epX5kS63a5BZkTXgUBADx48UCAQsEim1WoZH54IAC0tNs7v92tyclKJRMK+c7PZ1O7urr777juFQiHLGAZZsImQwEYCBuweJeb9/X1Fo1F9+umnlvJXKhWNjY1ZQTcajSoQCNhe4VzoOSEj4RLgsL/99lsdHx9rdHRU09PTFq1GIhGFw2HTSQIyk2SGaG9vzwgYvV5PmUxG6XRarVarD86Tri4V52Jvb0/xeNx0uAZZ0MFHR0dtDyEZ7OzsqFgsWiQMFMvlhSGGlhyzS6rVqu0t9al6va5Xr14pk8no5OREfr9fU1NTVqPY29szZ0ZGQ2RKRoLB5JwSPUqyjAmH4/V6tby8bMrRhUJB09PT+uijj9TrXWqA0azodvwPstDEIjsPh8M232RjY8PQAPqRcOhQ32OxmFZXV9Xtdu1zIfnj9XoNuiSwgQIP62x4eFi7u7s6ODgwLbZer6e7d+9qZmbGAgGc7ejoqOr1upEBgHdw1HS+0/eCOrMbaLTbbevf6Xa77yS5z/ml6I3NceF5VMMJOgh2OLfLy8t9748jLBaL+sUvftHH6GL/k8mkPvvsMy0uLurx48f65S9/aTCux+NRKpXS7Oyszs7OTNnbbSSHfUfQhSp1LpdTNpvt68uamZmxZlhszDfffGMUbtd5/cfWW1W2cC5kHvxONAyvHS8eCoVMP4yCOVEe+Gs4HO67kOD8ZD/QEcfGxlQsFlUsFs14SOqTXCfzYGAWzYKuHAlRGJkLkSCGiznfNNRtbm6aXD9R5SDLLchTGHTpvRSQKXqCTdMFTMGTiInPQdYgXR5uIm8iOd6n1+tZ9zmNsEQyLiaOM+HzuhEfn5G6BrCkS1fkjNDLQ43N5fwPsmBxuaKIwWDQPhuMwouLC6s/ucQPCAdQWMlUIH7gTIm+MWhkj0A0RJM0wHIHKN53Oh37LCyCJ6JGSUa9RylgeHjYIDScPgQK4BVea9CFnpxL+yfyZporzxhKMWeWeiUBz+joqAU2nBscrqt35xIiOJ8nJyd9DXyusrFLo3UbBREN5f/dv4tEIlpaWjLoHiaUy7LkjvC9B1luAy9nkQyTLAKmpHTVtMq5o5HR5/PZz3JGm82moT7u69OOAZzIPXbtCc5OkmVNOBV+8RmxsV7vlbIFDo3vyHsGAgFTxKCBFVtyk/VWTZQ+n0/Ly8taWlpSqVTS/v6+FU25FF988UUfZkqPRTKZtEgTbSciyVarZZeZlM/judTAoXbCgaIgy0XY29tTPp/vG+CzublpRUW604E/KKjPzMwYborzcItlpIoUV6empnTnzp2BjSP6QRTgKTK6/QFjY2NaXV21qW8wo87Ozmz/Op2O9vb2VKlUFI/HbagUBgPIxtW/YkojzVMsxO9oOORzuOJ07ujlQCBgUhOHh4dmRCh0ujRG1AH4t26KPsjiwMMoIvICKhoZGbFOdteYcNmJ7qTLi0d0K8k+H+eqWq0qEAjYKFpGxSLPT13K7f2gX4j3lPqZa/Pz89a7RUTIz9NgC5NrZGTEAh8XeoKVN+hCFVm6mmOPUQQ2DofDmpiY6OtjIgN0m/TevHljQQNZFdptOBxUgyUpnU4rnU6rVqv1KWl3u11lMhmDyCATQIOmHkTQAyoyNjam4+NjnZycGMEHqRK+D8aTLAJG1aDOxWV0np+fGxRKNkxNdn5+3jKtXq+niYkJ0+TDCQAdAhP6fD6trKxYpnh+fq5kMqmFhQUb3by/v69isaiFhQWrJ5OtcM5x8O7I92g0akGhJBujDFIB5Z0m3es9MiAFk5OTlmHeZN3YuWAk5ubmdP/+fe3u7mp3d7fvy42MjOjhw4fy+y8HAYHrXVxcKBKJ6P79+2q1WnbIwH05HHSaM90OqjCGmOFYsHToozg6OjJYQpJFQrdv37YLRWSNw6HDFsN4dnamSCRi9Gcifg4pNEdYMW+7ksmk/H6/FTWJZLkI7PH8/Lw1Y5Henp+fK5VKGX9/Y2NDp6enisViSqVSRnrgMLj9A65zSSaTWllZUbVaNd0ooizS5uHhYS0uLlqtjH4OiozRaFSRSKQPliPqJ/WnHuI2q4JHD3qxKS7GYjEbJsfcd7LiSCRie+vW0trttgKBgF0MnIEbifFz+XxeJycnmp6eNsOYyWSs1wP6sTvjnfPL9EpXvw5ZjpmZGWMNETBBLqBXhsFrnEecFNnuu6hKS7LvQ38SASIZAcSHyclJSX/cMMt54+e5F0DLGDTmtlC7PD8/1/fff29nNhqNWoQMlAtBApYcd3htbU2rq6v2eTiDKIVD2iAggEJPBkbwQeacSCQGDhCZZUI/GvtBH0qhUDB1D4x5u32p/UVwQe3FJZGgy7i2tqbh4WGl02nl83mlUindunVL7XbbhtmlUilNT0/bmIzz83NlMhmVSiVzVmR/LFCERqNhtnl6etpYqpVKRd9//73K5bLdVZq2YYuOj49rfX1dn3322Y/PFgO2YuLb0dGR9vf31Wq1rAbAoZWutMi4eGwGFDqwRnpYyIyIKLl00lUBlrG+GORms2lRjIupw3KJxWKamZlRvV43zBCqNM1VRJBE/m7Uc3FxocXFRXM6Ozs771SQlmSyJbw+7wk8RdaEEeTgAneRXVDwd3tgKDCCM0v9w9Bco0vqzSyZbDZrENzJyYlKpZJx5qmB+Xw+i+Y7nY4mJyeNzogiAtEdhAG3Uxkpi0EW9alSqaS9vT2TVCdFZ+9GRi5nwqM6QIRYqVR0cHBgGWwwGLRZNhREgSFwHEAXkoyaSUTtkhno4ifiw5FSFO92u5axUBd0WVKcOepEkux1qOd4PB7Tdxt0UW/gvtDngt7W2NiYSfcQsLjEmtHRUe3u7hqVlp4MziBGh8Cx0+kYbAR8y3u47QRQivlZqOLtdtvUfonwKSpT+yOzpkg9PDxsUB9OENvSbrfNfg2yyFLJ1hqNhnZ3d/uIAm6nPePaW62W1dygA9OASoaNgwS2A/FhPDqO20UWKDlEo1FrVqWsQPBEjdnNpJCdAo4leOSMAodSG6S/aWxsTKenpz8+WwyWwO9+9zu7rMfHxwoEAvr000/Ni09OTqrZbJpgGoU7otbx8XF9/vnnmpyc1NOnT/X9999rdHRUMzMz8vl8lqWcn58bdZDod2JiQvF43FLw8/Nz3blzR6lUyoxMrVbT8+fPVa1Wtby8rM8++0zb29t6/Pixzs/Prc8lnU7rxYsXxvTAsYXDYRUKBevJ+PnPf67FxUX93d/9nf7v//v/tij9bRfO4uDgwB4u2VE+n9fFxYWSyaRpS1EbODs7s4a07e1tg33Gx8clyZooKVrT4zI8PNzHHiEapqbAQbp3755mZmb0/fffa29vT7VaTQcHB+p2u7p3756Ghy9H1DKmGZjI5/PpwYMHKpfLevTokcrlskE31WrVekQgQhwfH2t/f39gWCwcDtv+PX36VJIsI5mdnbVmOppDs9mspfkQCxqNho1epi9ra2tL4XBYd+/e1fDwsJLJpBn4SqVi7+/SsemD6na7BjEQpbdaLXuehUKhj15OduU6IvDsZrNpgQ9BBf0nIyMj2tzc1LNnzwbeP+ly1DaEkGAwqHw+r93dXXW7XSUSCZNs/+ijj+yz1+t1m8lTKBRMf258fFy3b9+2ojCowNDQkDVRLi0tWR2K2lUikbAuchxQMplULBazzA29rYuLCxv2dnx8rOfPn6vdbhuBoNPp2N3PZrMqFApaX1/X5OSk2u22kXnow3v58qUeP3488B4CK5GdZzIZPX78WO122/QSgecxxnyOk5MTY3KOjY3pJz/5iZLJpKmlo+xAgJNIJFSv1/XNN99IulIXDwQuFblPT0+VyWRUrVb1s5/9zIgWMDsZkIaUS71e18HBgQVF6XRaKysr5kC4P+6AQN5zcnJSoVBIe3t7evny5Y33762FK6/r2FAzAR4hDSUF5HeKoYFAwIrj/PvrcgZDQ0MWoXg8HitMEzHweqS7MDb4f7ShyJ6kKyor6bvbwAkdkIgTqM6NSl1q8yALbw/jwi3EE3G4isd8dqAlonFqQXxWmG5QVt2GVFfAk0zGLfK5GmDXISyeM9ASBUIKv0BDsFp4f96Df+8W4F1NrrddwHMuQYFDDnvIbWqDJUc9hf4Usj1gC/6t+z2Gh4cN45eughugHF4fB8HzuE5Vvb4XRLEYKZ69S7O9Tvm/rof2Ls7lh97T/e7u+Xb3z6Uww1yD7s+Z499LV2ccNAAKrnTVmgDzzX1P964Bvbo6V9x74GKcE5/X7Vp3mYsYTc7fu5Ai3L0hO+U1+TOUwYn4QWOwK/y6Xhynds13cO0QmaxLr2bhuLnTIEHcfX4eJXHsBo20LNcWSFdZFoKZb7t/N3Yu6B/hDIgkaLaC0gbL6d69e0okElpZWbH0kKazf/fv/p0VCWGfpNNpO5SxWEzVatUK83fv3jW2BMUyoBlG3mKgJRm2Xq/XLdNaWVmxgm06nbbpf3S1c4gxIvF4XNJlVznd8v/1f/1fD3wwoerSAIYx5HCS9oIdAzVOT09raWlJ9XrdMjkKolxgLnav1zOIBRgtGAxapggOfnp6qhcvXuj8/NwK+jSexWIxw+aHhoZULpcVCAT08ccfq9Pp6NWrV/rmm2+s8RNWSyKRkMfjsfG8ECmky6gM6Y1B18rKirrdrkKhkJLJpPVJuMV0DKYkzc/Pa2FhQclkUpFIRMViUfv7+2o2mzb4DgwfxwMWPj4+blmN1+vV2tqaNVwiLUKEeH5+rkqlYt3t1xk+wF3Mf6G2xTMDq280GpqYmLCmVUZRELQxAnlQWFaSbt26pV6vZ8EVLDcMV6/X09HRkQU/k5OT1rRHbxQTZaH/j42N2ThnagyxWMzgv0wmo2AwqM8++8z2AANKcTuXy5lsUzwe19DQkKanpy0zTKVS5vAZG/Hq1StJsuyYUeher9fuNucT3TRUDgZ10EC+BGfIp3Q6HSOwnJyc6NWrV4rH4/rss8+M5s85YaBcLpezu8J5cYVqpcuAKpVK2X/jKGgeppmSTJlAhOfJiAEIPn/yJ39ijEUypWw2q5GRES0tLRkZJxQK9THECEIYffyjO5f5+XlJVxnA6OioiR4eHh6qUqmY55uentb9+/cVDAZtKE21WtXx8bHa7Uv9sFarpcXFRS0tLRlLzJULgYuPtwSvxTi7sBE9HlAj4/G4gsGgFa7Rfup2uzo8PNTx8XFf5gNXn+/He3U6HaM/T05O6s6dOwNnLtARwZevUzWJZNBwovA3OTmpiYkJHR0dGYQBm4blUjiJkkulkg4PD03YEyl+xu5ub29bBAgMiUFz618czJmZGbVaLf3hD3/QmzdvbChROBzW0tKSCS5SSyAT5GCi/Tbo/sXjcct0gU9dejQQGVT0VCqlsbExzc/Pa2JiQvv7+8pms2o2mzo6OlK5XFY8HrfppWSMLr0+n8/bc0CPjToUagn0y2BcoHWTtQEzUDOicZeInSK22+GNk5OuaMMQad6lzwUqK1kt0ax7jmAQBoNBzc7O2vwjgh/2mhobChGuY8exUGcbGhrS7Oys5ufnValUbLCaK3eD+KV0GbXTGwOEJ10SEsrlsp4/f25SSETsZD2cOQIR6ooM4iOTGmSx9wTYyNNQlxgaGjJYmedPLY86FQQQek7cGge/XBYj/+22H0AAAl6lmfS6Lhj1sLOzMyMkSdL+/r5poGUyGUUiEc3MzFhGxjMBCSDbcSnyN1k3di4UwnhTr9erTz/9VBcXF3ry5Imy2awkWXSO9hjd4kTS1DgwBBhGtweEaAj9HzaRiYrImkBRZGwsmDVROmlft9s1Ci5pHptItsU4UQ4Kzgg1UulqZMAgi8sM5Zpxyxw0nAXduwgDlkolE5IkwqGISVOm2zsDpgqkQ0RJ4R1pHqJPJHA42BTgqdkAL3LAKMhOTk5qcXHR6hwYCiA4nPPOzo6pLr/LsDVqHMfHxzo9PdXIyIixiDB4bmbNf5+dnRm7hzoGDEKyZ/aw1+tZIRlaKWckHA6rVCrpyZMnFrSQodFEyjOGUUcW7JIayFqZLeLxeIyFGIvF/mgYk6taTV1y0EWWf3p6anW8e/fuWf2C4ITMhT2k7sL3lWR6drDFXKUMzhIBlMfj0dbWlgUrRPHI60AqocDM5yG4w7FJlxH8vXv3rK5CUCHJ6hn0frgK5wcHBxbxD+pcXr58KUn2TMkeCMgISsi4gPioPWMLcUycPYrqbk0HmA9nSNsCdONsNmsB4q1btzQ5OalsNmtTVO/du6doNKpOp2NiuNTz2N9EImHyR5Js1AJOZmZmRpJMvBd49kcv6G9tbVkT1NnZme7evau/+qu/Mrx2Z2fHDicbSn2DCBm2CtGOi+HxpbiszCbnojcaDb18+VK///3vzUFwoWu1mlKplBKJhEXpwWDQplbCmsCB4UzQ8olEIqanRPbDuGGKmpKs/2aQRSGdhsjR0VGbWX92dtYn34Cj9Hg8ev78uQ4ODow+CBRBnYjDOT4+3kf9BnqBbVapVPTq1Su9fPmyLzPb29tTJpOxqBxMnOwKxVsuezAYVCqV0uLiou7fv2/Zilszi0QiBl9ubm6qUCiYRPmgzoVu7v39faXTaa2vr+vevXt9c1aOj48tauSSQ22laO73+3X79m3FYjETOnTrItBby+WyJFlmOz4+ru3tbdPOg9Tw8OFDzc7OWrEWSAfDSz8MRg/s/5tvvtHJyYlCoZA+/vhjK+6WSiWrt7TbbR0fHxvVns7pQdfJyYm63a6y2azy+bzW19f10UcfGbRyfn6uYrFo95T7jE5dq9UyGj8sylqtZg6ZfSfQIJA5OzvTixcvTJSS3iie6fLyslH1qauQ8dJpjoMeGxvTp59+anRuai/ATLFYzM43Iq0vX77UycmJ1a0GXY8ePTK2aywWs9HCrhYYzx04LBAIGFOrWq0aMWp8fNzaO+i3IxAm6HZbFaAa0x+YzWb14sUL9Xo9ffzxx7p3755KpZKePXumaDSqjz76SBMTE/a61Atd5zI7O6u7d+8a6w12LgSPhYUFdTodffPNN0qn00okEm816v3GJxUn4EaGHHS3COS+sVs8vknEcL04SMqLQWezr6fy11/DLRL+h97ffR/++/pruD/3H3q/my6+h1vQdqMEMO8fSo+5tO7+XN+v69/F/cxuUxRZmAul8fo/tD9uYVq66jq+/jl/6LO4Bd53iRjd7+G+FsECxc8fcvy8p/veP9R/4/78D50V/s49/zxTnuP1vhB+cTf4Wfd5S1eF1Ovng+/sPp932UP3mV9/bz7Tf2gPf+j5u4Xz68vdM3ffrv9y98U9S9fPp0vMgWjgElJ4L/f9ORc3tT//sUXmy/NgP67/uv5dru/h9T1yl/tz1//bDZrc/XOfBX9+3Qbwfu5nwMbyOtf3iTOK7XjbM+jpveuOv1/v1/v1fr1f79e1NXi77/v1fr1f79f79X79B9Z75/J+vV/v1/v1fv3o671zeb/er/fr/Xq/fvT13rm8X+/X+/V+vV8/+nrvXN6v9+v9er/erx99vXcu79f79X69X+/Xj77eO5f36/16v96v9+tHX++dy/v1fr1f79f79aOv987l/Xq/3q/36/360dd75/J+vV/v1/v1fv3o671zeb/er/fr/Xq/fvT13rm8X+/X+/V+vV8/+rqxKvL/8r/8LzZsK5fLmTJqIBDQzMyMzU5nXkmhULB5B7FYTI1Gw+aW3L9/34Y0+Xw+nZyc6He/+53K5bLN1ohGo5qamlKz2dT29raq1aoWFha0sLBgEtYXFxc2KfLBgwf6+c9/rkajoe+++07FYlEPHz7UvXv37OebzabN7uaz1mo1bWxs6Pz8XOPj432DvBh8FolEdPv2bX300Ufy+Xz6J//kn7z1Rv+v/+v/qk6no62tLR0cHJjiK2MG/H6/UqmUpqamJMnmk6BkjCpqu922+S63bt3SrVu3bGrn+fm5zckplUo2t5t/f+/ePd27d88kyhuNhk5PT1WtVvXw4UP9xV/8hdrttt68eaNaraa5uTnNzMwok8nou+++U6PRUCKRUCgUUq1WsxkTKMQmEgmNj4+rXq/r5OSk77N/8MEH+ulPf2oy9W+7/qf/6X+SJJvNEolEND09rV6vp+PjY9VqNY2PjyuZTNrIAuZieDweHR8f2wx6pNCTyaRSqZTOzs6UTqd1cXFhg9OYf8GwKaYEMh2yWCyq2+32jSkIhUI2jOzi4kKzs7M2AZFxA/Pz8xofH9fm5qaePHli81/8fr8qlYrdEQZnlUolnZ+f67PPPtOf//mfa2hoSHfu3Hnr/ZOk//6//+8lXSleMyFTupz1cnFxocnJSc3Oztr4cHe2ysbGhn71q1/J6/Xq/v37NnyLuTnHx8fqdDqamppSLBbT6OioYrGYSqWSfvnLX+r4+Fh3797V3bt37TO5ytoMTru4uNDR0ZGazaZ+8pOf6NNPP1Wz2VS5XJbX69X6+rpSqZR2d3f14sULnZ2dKZfL6fz8XOl0WtlsVpFIRAsLCwoGg1pZWbGplChU/w//w//w1vv313/91380UygSiajX69nIglAoZIPJvvzySwWDQf3+97+32fO9Xk+NRkOZTEZnZ2eKxWI2LoO5NIwpGR8f1/z8vCkxMwfG5/OpVCrpzZs3ajabSqVSdqZHRkZUq9X06NEjlUolff755/rwww9VKBT0+vVrdTodLS0tKR6P2ygOSabKzR4VCgVtbW2p2+0qHo8rFArpZz/7mf7yL/+yT4n6/2/d2Llsb2/L47mcZ3/r1i2TLWd4FReZKXfMczk4OND29rZSqZRWV1dtVGitVrPRwsxDCAQCZpDq9boNBWM4VjgctvG+zDmIRCI2A+LFixfy+XxKJpNKJpOq1Wr63e9+Z46Q+R7NZtOm8EUiEd29e9dmlYyMjJhxlK6m6p2fn9v0u0HWmzdv5PF4NDU1pQcPHqhcLuvw8NAm1uGoz8/PbYYGQ5sk2YyL4eFhra+v2wQ8DikTICX1zV53pd0LhYIePXpkhgPDFgwG1W639eTJE5MLD4fDOj091cnJiQqFgvb3922wGQOjmMPDfJlGo2FGgQFP7Pfx8bH29vYGdi5MGVxaWtL4+LhKpZIODg7UbreVTCY1MTGhsbExmxvz6tUrm+DI5cOo4cwbjYaNiGUoXDKZtGFQ4XBYvV7P5sUwf6Pb7dro7tPTU+VyOcViMU1OTtp5HRkZUbVatbkwGNBcLmcjuJmVw/NhuBRzk3BKBEfHx8fy+XwDOxfOQzKZNONSKBQkyZxyr9ezwJBfjFo+Pz/XysqKvF6vjShmSBbTFhk7zNA/5tjcvXtX09PTmpqaUiQS0fn5ubLZrBqNhg1749+Mjo7qiy++0PDwsFqtlh4/ftxn+AhymbPE1NB6va6pqSndvn1bw8PDCgaD8vv9dv44H4Pe4Z2dHXk8Hi0sLOjDDz9UJpPRkydP7DszGr3RaKhQKOjZs2fy+Xz67rvv9Pr1a6VSKd26dUtDQ0OanJxUt9tVuVxWqVSyYCYQCNhZbjabqtVqarVafePDx8bG7PwghS+pb2z65OSkYrGYvF6vTk5O1Gq1FIvF1Ol0bLZMo9GwIJoAhzU2Nqb19XWbwkrw880338jn8+mnP/3pf3S/buxcjo6O7JAsLi6aAZP6ZzYw6pRRr7lcTicnJ/L5fPriiy9stnq9Xtfo6GjfVErGazYajb6ZEfwcs+M9Ho8dZA5wu93Wzs6OgsGg7t27p0gkomfPnun169cKBAI2LOzi4kKtVkvBYNBmfadSKbsgQ0NDKhQKNrjHnbGezWYHHha2t7enoaEhPXjwQD/96U91dHRk0+dw0o1Gwy5bPp9Xu922SIW9ZRDXwsKCtra2tLGxYQOYGNjFJeR1uUzlclnpdFrhcNimSIZCITO0TLFbXl5WMBjU/v6+Dg8PVa1WbTR1vV63sb3hcNgMwvDwsE04dMctk2Genp6acRxkMXnz1q1bun37tl6/fq3NzU21Wi1NTEzY5RgaGlKz2dTu7q6q1arGxsaUSCQsSmdWuc/n0+HhobLZrC4uLnR+fi5JikajmpiYsCFyDOw6OzuzYVNM/my1Wkqn0zZ3PhQK2ZhlsqVMJmOz6iVZ1onxY3m9Xo2Ojsrr9drYWoKoTqejWq2mbDb7TsPCCAAnJye1sLBgg8gkaXZ2VuPj4xZQYKgYNsfEyNnZ2b45LhhFjHin0zEn6Z6NlZUV+94jIyOWibiTQpPJpKanpxUOh3Xv3j2Nj4/r22+/1ZMnT2wgHiPTua+MRGe66vr6ugUvvV7PnlGlUrEJq4Pe4XQ6rUAgoI8++khffPGFvvvuO/3yl7/UxcWFIpGIIpGITZ1sNpsW8L1+/Vpv3ryx8c3hcNjOyuvXr82ukL3MzMxoYmJCx8fHevPmjer1ujKZjM7Pz23KKYMNQUCkq6mzvV7PMl9JNq6bYCmTyahardpoap4JWap0GTQkk0kbOMhU3levXsnj8fy4zgWDFQqFND4+btAR0RXz3xnLyUUJh8M27e/4+Fijo6OW6dTrdfl8Pp2fn9tYWCI1DiajYhkJyobw8K4PKmMOOBEXB6xarZpTIlvg3zBdb2xszEYnj4yMqNfrKZlManx8XI1Gw6LQQdb09LR9znw+r2q1ahEre4Zz4CAwK9sdIkbK6vV6VSqVLFVmQhyQB5M2pf7522RtRETtdrtvX7vdrl0ioBJGPw8PDysSidg0v2azaaOBueizs7Mql8s6ODiw9xodHVWz2VQmkxk4amQfmKzXbDbtGTLpFBjx4uJCU1NTSiQSGhkZ0dnZmbrdru0zvy4uLmx6YCKRMKiILJdR0YzMrdfrKpVKfcOvfD6fOaPr2WO327XxyUTZ7nnDYWKMUqmU4vG48vm8jo+P1Wg0LGioVqs6PT19p/1j2BXjrAmcGKd7fn6uRqNhUCZ3gDvJdFOcK69F9hKLxfqGthEkSbL3cp8Dr890RhZBCfeZ0dCnp6fyeDxmD4CCOGOMM49Gozo7O9Pp6amdEwILpi0Oun8Y4FarpZGRES0uLqpWq6nZbCqbzRqiQqDj8XiUSqXMlnCmOp2OBdRTU1MKBAKKx+OG3hSLRRtFzPc/Ozsz+LDT6RgKxD7xbHhN4PFyudw38AvUxh2HzuuweE7S5QReJui+zfm7sXMJBAIGOS0sLCifzxvOye84IGomeDs+7NOnTzUyMqK1tTUz2IVCweAiSQanuZg3c7UrlYoqlYqNp2XsKoeZB0+EV6lUbO40qb59cb/fRquOj48rGAwqHo8rEoloeHhY6XRavV5Pa2trmp2d1evXr7W9vW2THN92udHU1taWpa/S5cMDduGiuhfv4uKib7Lc1taWdnZ2zEiOj4/r/v37Gh0dtZnrHFyv12v1B0bPSrJ9DwaDZqTJOHZ3d+3zcHmj0ah8Pp9lAeVy2QzH2dmZ/H6/Hj58qFu3bunNmzd69OiRzs7OND09rVAopHq9rmfPng20dywi1JOTE4NViWRLpZLBUOFwWPfv39fY2JiKxaJKpZIqlYqOjo5sZGy73dbc3Jzm5+cVDAYt82GfGbEbCAQ0NzensbExPXnyxOCYXC4nSVpfX9edO3fM8RDAMKYYuBCjxihuInsMSa/X08LCgtbW1uT1evXo0SMb0QzO78KkgyxgODIp4DvgToIwZq6Pj4/L6/WqUCioVqupWq3q+PhYXq/XHDcBJKPB+flqtapKpaLDw0MNDw9rbW1NkUhEhULBDCd3rVwu92W0rVZL2WzW0IOJiQnlcjm9fPlSrVZL4XBYo6OjVuv1eDw2Anlqakqzs7M6PDw0iHZxcVHRaFTHx8fa39//o2mfN12M8ybTDYfD+uKLL1SpVPS73/3OYHO/328BxMjIiG7fvq2HDx/2nQMCi2g0qgcPHthoZknKZrPKZrOKxWK6deuW2u22gsGgqtWqTk5ODAlihDZOGxQoEono008/VSwW0+PHj/Xs2TP73EwQHh0dtbopzp7glOCJzJVM523XjZ2Li3lS3HRHphJ187Pgt2CERJSSDMbhIrtjXoF/SL1dGIPIFY/Kv8Xb82fu+M9gMGg/747JJTplJOj1cb1g4a63dkeLvu0C6sOAE0W6D5Xsj2jQ3UfpCn7kkLv7RmbnjiZlD0ZHRw3KGh4eNmIA34kMgz0BmgRr9fv9dhnAxDFC7ohad3wwe0hGWKvVLJMcZHU6HXm9Xvts/L+7p2RfZBSug3Vfh58nCiZwwjG4GSPfg2zt/PzcLqnH47HvR1RLpsz+8vx4njwDMif3rLpnkD117xR3ZtDljjTmWZG5AKm4n4fnj5EE6uQ5uJCJm127Z9z9O+4URos/4/U5Y16v1yBBjCGf182+gAt7vZ7ZCPc13PHg/Nm7jDvm+3EG3c/CefmhxVnkTLA//Dznz/07N4OUZI5DurQl2FW31o3TdMk/7L17593x0NhufrmjyXne/Bvu2E33762ci+vV+MLDw8OKx+NWYCZai0aj9qXwkhQziUiABhqNhur1utrttjY3N5XJZDQ1NaX19fW+gn+tVlM6nbaUcmRkxNhc9XrdshM2aGFhQaFQSJ1Oxy5OsVi0bApoyi0MEv0ODw+r2+1alEUhe9Co5xe/+IXVDObn5y165GK0Wi3t7e1pa2vLis/hcFiJREJ+v1/n5+eWfmPYITr0ej0roBeLReXzeTUaDZ2dnSkYDGpiYkLJZNLwbQ57r9dTOp1WPp+36B0IodfrKR6PW0RIlifJ2DHpdFojIyP6+OOPDeM9Pj5Ws9nU0tKSut2u5ubmFI1GlU6nDZ4aZNVqNTs7IyMjOj8/NyPMmcQZS9Lp6anOzs76IlyCEODcqakpzc3NGbux0Wjo+PhYpVJJo6OjikajFj3ynul0WqFQSLdu3VIoFNLMzIzV7rxer87Pz3V8fKyLiwulUinNzMz0RaUY3M3NTT169EihUEiffPKJFYOPjo5UrVaNaDE+Pq7R0VEjHbzLVPLJyUmDr8hcIpGIZX9AH0DXqVTKsqtoNGqBCIy4YrGoaDRqdVbgrVwup9PTU42NjSmVSmlsbMyym0qloq2tLauhjI6Oan5+XlNTUxoZGVEwGLT7i5P3er2KxWJ68OCBQdowph49eqTR0VGtr68rGo1ahk3tC3jy4uJCQ0NDSqVSAweIZHJnZ2dW0+NZj46OanZ21n6WYE+S3ceRkRFFo1H7bgSroBiQSmC0Qo4ioPD5fAb3zc7O6u7duxobG9Pe3p7y+bzdrVarpd/+9rfm6EdGRnRxcWHMMOparVZLJycnCgQCRsJxnSUBJ/VZSDn/SZ0L0QiXmxTw/PzcIg3gnXA4LEnGQpEusXqiNL/f3+ets9ms9vf35fV6NTMz0xd1YlhdhlooFDI6JU6LBV2VaBzHV6lUjIYHE2Z4eNggOWo5PPBer6dms9nH7HnbtbOzI7/fr0QiYfURDCF7Rl0CmjFZB7UnIj72imiaaNnj8RgDBDw1EAhobGzMCoHBYFA+n0/BYFCdTkfpdFr1et0cB1kT+wcNkZoRhAiPx2OpMsVvScZyikaj8ng8isfjikajKhaLfdDe265Wq2Wkh4uLCzNofH9Jfc4GRxYMBq32RIARDAaNYklNkFoOBW0+P8/I7/cb5XZ0dFTJZFKRSKSPbTc2NmYZQL1e1+TkpMLhsDlnMH9qk0dHR4rH4xoeHjaHDmWeZ5BIJAxOcqHUQRYwItE90TB34+LiwuoZnJuRkRG7X9yjer1u1G2o7j6fzzIN7haEEQg5PL9KpaKxsTEr0EciEbMFGGSiZp7pyMiIJiYm7Lt4PB4Vi0VlMhlFo1ENDw/b7/w9d5jgA2bjoHeYAAIyQrlcVqFQsBoLBXNqbWQjBIbcebJQ9hSnzbNnTwmKeW2IPZBPgFhdyNTn86nRaBgpg/YAj8djdpfaKZkPmaJLCmIBs0WjUatb33Td2Lmsra1JuvTCv/3tby1TkKR4PK6RkRHj/4+MjPTRKmFBhMNhixzPz8/Nk+O0Wq2WlpeXrTC8uLhoD6PRaGh4eFgTExMWCbLZYOpkJFwQjCr8eYpweGcu6/7+vnw+n2KxmCKRiBWku92uotGoRa3XC49vs/7sz/5MHo9HoVDIokQMJg8sHo/r7t27ikQifXTEfD6vWq1mBUoMfLFYVLlcNpYNhzccDhvJotfraXt724qhH374odWgGo2GJiYmjPkEQQD4isic+kGr1dLGxoZyuZzOzs704YcfyuPxKJPJKJfLKRKJKBQKGWTX6/V0dHSko6MjnZ2dmQMaZBHZ44C5kL1ez6A66bKuwHmjoEntjWIrQQV1GIIbSUYE4PyEw2GdnZ2pWCxqcXFR/+Jf/Atj72QyGd26dUuBQEClUsnqMbVazeAz4EUXhmq325qdndVPfvITK4zXajUzKOwfhoyzDeFi0IXR2tnZUT6f19nZmdVauBdQ3s/Pz42xRrH55OREGxsbZvASiYSGh4f7PhfQ39TUlGUrGLxut6vp6Wn97Gc/0/n5uU5PT1Wv1xWNRjU2NmakgmazaWdxdXVV8/PzZh86nY79u2AwqOXlZQUCAaPqFotFvX79WuVyWfv7+5KuarE4mkFXKpUyAw4cByU9n88bnI994b2oGUOWYZ+As1zWFwGlJKOKAwuOjIxoZmbGEAuYW6enp0bG4Nzt7u7q7OxMDx8+VCqVUiAQsICyUqkY/Mt3ch0MNpu6b7FYNHuSTCZ//Mzlzp076nQ6xtlmM4aHh3X37l3LXPL5vEWyPFCw0EgkYtkJjB4aiIgyvF6vNROurq5Kkm3e6Oiopqen+6idhULBGt8gFeCR4Z7T2En6SoRRq9V0dnamra0tNZtNS8/z+bwV72kGc5sFB1l/+Zd/qU6no+3tbaXTafn9fiuEU1RPJpNKJBIaHR01CGN/f18nJyeq1+vKZrPGVKFnhxT6zp07BjMCDXDpX79+LUn68ssv9cUXXyibzeq7775Tu93W1NSUpqamdHBwYNEoxnhubs6iXCLb58+f6/Xr11pfX9fnn3+uSqWi3/72tyoWi5qdndXExIQFDd1uVzs7OyoWi30Z2yArlUqp2+3q5ORE+XzeipLu88ZBknEMDQ0pl8upXC4bQaTVaimXyxlD6+LiQsFgUHNzcxodHdXc3JxRkJvNpoaGhlSr1dTtdrW+vq6f//znevLkif63/+1/U7FY1Pj4uDUK7uzsGBwJFHN2dmZZPBlBu93W4uKiJicnzdnxq1qtGpSJUb64uLDs6l0WzhgCDgYHpCEYDKpSqVjRGSNE5Hp4eKjnz5+r3W5rfX3demNw6NzfcDis8fFxO48Ectyxjz/+WHt7e/rX//pfq1KpGLORfo6zszPt7++r0WhoZWVFS0tLkmSBT7VaVT6ft/dpNpvK5XLKZDKq1+sGc9M7Q70LOzPoAgWBKj48PKxEImGBHmiCS5CByRYMBlUsFrW/v69er2eOF6iaDAE4j309PT01Q+/1XjbhfvLJJzo6OtKvf/1r1Wq1vkAe5/HkyROVSiVNTk7qwYMHRn3HcZ+enioQCGhqasqyIRwOwQY079PTU0mXQTu9XDdZN95poqqhoSEz7MA5sEy63a51K18vDLnFJvfiJhIJK/JRVOLv8eg4DgqjbmGO9BdDI8kOECmnJKsxSFdFXRwfVD848NeplmCjpLKDLAxUr9czg+1mUewlRcN6vW4ZG1GbWyiGNktn+NnZmUW6FLVHRkYMyqG3KJvNqlKp2PMggwL2A8qQrppXKWLCggKycRsBqYvx3Vz4lOVy8t92EVFxDoFt3MY66QrrdinqLpGDRYTNxQdSIRsGfpTU19hbKBT6el5arZZh1dPT06ZE4fa9QNPmXLqvD1xDtuLCFODxnD0gv0GXez/YN848USs1GZ47NUkcJYvzNjExofHx8b5arBtU8szd/jTqq9R76JOBHOH1eq3/irPk0r9dEhHviYF12X58XrLWd73DEDnIToH7eIacCeprkiwIZP/c8+9CaJL6PjuOCWSHO+iqXtB4DvrB+w8NDdkzCYVCCoVC1kOHowdGAzXifLgEDPbctctvQyq5sXMBAqMIx2YAUxwdHWlyclLr6+v25qTYZ2dnfQUs0vF4PK6PP/5YtVpNr1+/touZz+fN4xNpXVxcWGTvps1gthgImqaIlHig9ObQsIUzGxoa0tramh1MSQqHw5qamur7zOfn531G+W0XUh/BYNAiPoz49d6e8/NzbW1t9UWq1Ju63a5dxsXFRc3Pzxt18+joyA5DLBazSOvk5ETn5+fa2dkxUgUHOpPJ6PT01F43HA5bJrW0tKRkMmkyMTRxzc/PS5JlsDSQTU1NKZlMWk0ImAAcHHbZIAuuPvBQLBbT4uKivF6vRazsL1E4RpSaAJcWhuH09LRmZ2etuAzEUCwW7Tug4uDz+bS5ualnz56pUqkolUpZMXt3d1czMzP6L//L/9JUE8DFMRBkbScnJ6pWq6rX6yqXy3Z+6QuDVoqDImuNx+NG9R10UUx2DSGF+sPDQ1UqFS0uLmplZcWMKEQT9gWnA2w8NTWljz/+2LKN8/Nzu1+QKNwm6UKhoMPDQ0kyxQQcaSgU0tTUlNV+6H87Pz83+Mjt6KeGRuPvyMiISeiUSiXt7u4au7Jer78zFfnw8NDILJVKReFwuO+MUx+jE57+kDdv3mhjY8PaHagrSbKAAoISpJWzszOFw2E9fPhQ3e6VAgFNyjSd8hk6nY6mp6dNDqrT6Sifz+vOnTtaWFiwAAh4v9Vq2T4SUPA53MDTXTTT3nTd2LnwRlwGSRZZHx0dqV6vG0x2vWDlFudc4wI27hb1O52ORerUODDyUG5dtgeGkogbxot0Veh26cZEjbwPsAo1I+ogZEIwi4iSBo0ciaJ4XZh2ZGYudVi6jJJguLg9AO4aHR1VIpGw7m0MmiSLplwKOa85MjKieDxuUbr7bKnZQNJgH1lkXEBKQFA8Szf6IbN0KcODOhcONc+M93Ppv2R/LuWW5X4HzgzwLU5duoruOY9E35x1IFagC+AvGE2QP3CCZIRkqC7VG5gKSi6/yNwxAPV63aSP3mXxXYBtkLORZHUWSZbJcx/Oz89NWQBiA/WbbrdrUJ/7HQnKoByz5+122/TTEomEvF6vQX6uZBHEE96Pz0PthmfaarXMgdGsS8bH53LrSDTbDrLIXNy76fYO8fmh+2MvyHpdrTvOmHTFymLx/CVZnYReKFCGXq9nQSZn0w1Yx8fH1e12Lbt3631ua4VLjHEzKBdl4C6/LfJw49OKWGUqlbJIjqY8+hgqlYpev36tcDis+fl5DQ8PW0MVBo1s4+LiQicnJ/rrv/5riy56vZ6i0agSiYRKpZI2NjYUCAR0+/ZtK5zhgaH9lcvlviIqjgCdLvSLSqWSPRjqBxgQDEG5XFa1WjUDS8aCY4BlNMiamZmx9ysUCgqHwwYvkU1RC+r1epqdnbUI9uLiQuPj4yapUywW7VBgZNFzIgpuNBo6ODiQ1+tVPB7X5OSk8vm8CoWCIpGIVldXLUoZGxtTtVpVsVi0vY1Go1Z7SqVS+uCDDyTJnNjExIR9RgwudPPR0VHLcKFvE0QM6lzo7p+YmNDCwoJ8Pp8VUQ8ODmxPYcG4zCiMG8YZBhd77/f7rUidTCY1MzOj09NT7e3tWXGaBltEWJHPwDDWajU9e/bMan2Ie0In3d7eVrfb1dHRkX1uAjCMhQs9EYCAe4dCoT6a7iALRAAoi/oaTaG5XE7JZNJYgEDOkHAkGdzC77lcTv/n//l/Wp0QWAYDf3h4aDWtZDJpZxoj7PZX0ZzY6XSMpIHzqdfr1hQJ5MgdJvOCqnt+fm6IRLfbVTab1fHxsfx+f59o5tsunBJIiVuPgL3K/R0dHdXU1JRlIpw3/h6oGvo/dHjpioJ9dnamk5MTg3DZWwK8yclJ9Xo9E5/1+/3a29tTp9OxFoJSqaR/+Id/MNafW3uhzkLdd3h4WNVqVefn5xobG7P6CgQe4N2brhs7l1KpJK/3UvSOqA2cnS99dnZm7KW1tTXzomDU4XDYqK7t9qVm0/Pnz03fa2xsTGtra5qamtKrV690cHCgUCikn/zkJ1pcXFQmk9HJyYlBS1Ab6/V6X8pGGg577ezsTNlsVq1Wq48SCaZI5FksFlUoFDQ+Pm4PjkjUhXcGWfF4XL1ez2ARjD4HrVwuWxZAiu3z+ZTNZo2rjqpBvV63y44RGhsbU6fTMRXqdDqt7e1tBQIBLSwsKB6Pm7P1+y/VnkdHRw1e9HovO6t9vssu/FQqpb29PX333Xe6f/++/sk/+Sf2vBuNhsLhsO7cuaNWq6Xd3V1jsx0eHiqRSCiZTJrjY9//QxnYTVY+n5fP59PS0pIWFhasx4A6UrFY7GMwuRcRA0YmBx3V4/GYmkGncymnAcHB5/Pp+PjYIDNYdWRtMPkwfih0j4yM6M6dO1aPIXuBLurq1rHvNLEC+bh0YRg7OOp3cS7AcIuLi5qdnbVgAydTLBYNsiOjcRub3TvMr3Q6radPn2pqako///nPrc4EBIj6NsElz8mtL0lXWQjQqasjiFo1CgvxeLyP9t3pXGoYkoUjpbO6uqpe71JLq1AomOLzoHvImSFwqVQq1l8CauMGMqgYsO/cETIfUAT+vdvKwbkoFAoKBAL2WnyOsbEx+y7AqTgjWg0ikYhOTk60vb1t1HnsNc6RZzE8PGzN0c1m02S+JBlM7AYEN1lv3edCiuymvnxRYBW/329ZAIbM4/FY5MTFdwtgbmMXFwv4g3QTp0E/AJ8LJVy36YrP6hbzJFnG5VL/eK9QKGQwEiKL09PTmp+ft8h+0JTaTTWBlNzvQNPexMSEer2eGaBer2eHmWwMeIPP4l4yeiby+Xxf8Y1CfCgU6iuEs/fANRSeiRCJWpEYB0I7OzszSjBZYygUMplzIACYXDAJB90/eP6SjOJL9jY9PW31OOoSZACQRn6oT4sLSLZBxgrEOjU1ZZE7UhmFQsEy316vZ7UQ4CtJpucE/g986ff7rVZDQAGsR9BQLpdNvZeAhmwZyZlBF8YcWRaacr1er1ZXVzUzM2MMNqC9dvtSZw86MHcGMgq1TJAFgh6CiWAwaJk0hkuS1V5pAYjFYqpWq/Yd3TtMdoi8Pc/oOuwN0YM6gtsqgbNyYaC3XRTBgROBUz0ej8kcAWlVKhVtbm5qaGjInjNOjaBLuiQigAQBCfKLjNjv91vmShYHOxKNNRphsQu8F2cPmRxJppeIRqHbP0NJAPaZ1+vV+Pi4Me7+k/S58KI0gZFKDw0N6eHDh1pbW1MymdTk5KROTk70d3/3dyqVSlpeXtb9+/eVTqf15MkTO8hsVigUUjQa1dzcnEKhkAm1YaDwtKTJZD2ZTEbSZZEymUyqVCr1yaJIskjB5Z67hTPpSubC5/NZk9bJyYmePXumkZER/bf/7X+rBw8e6OXLl3r06JExiAZd4OguiwaHMDMzo/X1dRWLRX3zzTeqVqtG1yadBVJw4TkMfLfbNUgSuqnLlguHwwaJ4KgpZMdiMXNs1Jow4vQMoJIgXRI8Xr16JemqHjIxMaF4PN4HO6KsurGxod3d3YH3b2Jiwi4dUA6O9t69e9YlPzJyOc9ia2vL6OtLS0uq1WoqFAp97MVIJKLl5WXbfzLAQCCgVCrVxxxD3ZtRDGSZDx8+tOCjVCqpVCrp66+/Vi6XU7VaVa1WM/nzsbExzczMaGxsTEdHR9re3u6TrCkUCspkMpqYmDDNs6mpKYVCIb148ULffvvtO50/Mm/UkIG9hoeH9bOf/UzxeFzZbFaZTEa1Wk3Hx8dqtVpaWFjQ+vq6SqWS9WlwJkdHRxWPx81wuxpUfr9fExMTCgQC1lmOqKwbld+7d08zMzPa3983uIgss1AomILE9PS0OS0+u5tZUdODbbm7uyu/368PPvhAk5OT2tvb05s3bwbeQzJMF9Km5nPnzh1NTEyYykalUtGbN2+M9BCPx/tqTxhwIGtgKJfxlslkrDSQSCQUi8W0t7dne8y9I6uBog9ETSsFgQ1reXlZsVhMx8fHFpgTjA4NDfW1X0B/ppfr9PT0x+9z4cO5tFgiY5e+htFiYUQxOFxY/g0byS+XXeamhxw6iv+8NosIkA5UHiTGFZqppL7CPLx1nA8RA1G7W3yH2jvIwjkTWbiUQveCQDd0KYCSrDZEIZGCp0trvU6egCrJd+Y5AsHwucgs3AI9GSbUcvd7XC+iu1pvGDCeL2m3qx01yILpxPPhl8/ns7PoMv6gshNYEFHy7DkbwKP1et0iR/abTMdVPMCAAetwRjlbRPWjo6N9BAsyfTJjXpvP4Ebg7v65+/6uVGT2nvPC3XWJH9Q/yKZcParrRB2WS9ggeALVcIk0boMe38mFqNgj6oBE/byHq6zs/qyLorBH3AM3iAS1GBQW43zxffkO1MvIsLiTNB6yj27NF1vjUoGlK10wvhfOlCwGJ+p+f74fz5Z/x3fl2bIfru1xyS98LpfKfZ0YQ8Z4k3Xjmx6Pxw3SgXOPjDXdvlzws7Mzk4+u1+va3t62xjWfz2dy2kTwFEbBpmmm4oBtbW3p9PTUCqVu4YwDD0wyMjKilZUVhcNhY7LR2U9dwYWjLi4up96h4cOhIVNAidQtsg+y3Nd2HRt0U4q5LgcdfL9YLKpSqVhRO5FIaHZ21jqTiZChwVJToAjf7XaVy+WssN5oXM5uId0eHR3V1taWfvWrXykYDOo//8//c6Nio681NTVlvPnr/S9ESXTvQo6QLokMkUjEnsmgxvHzzz+3JlT0t4DZisWihoaGtLCwoOXlZSNhAOFCC6WmND09rWAwqJOTE6XTabt8fr9fq6urmp6e7uu1ovOezBn5FyCYTCZjUiRer1eff/65AoGAnj59qjdv3ph4KtE77D46n5Fqp4lzZGSkbyYI78PwpkEXmSkwJg18lUrFIl+3D8QNCtm//f192y/gQupWOG0G2DGRkXvGHsdisT5nxsyfw8NDi6Y//PBDq+8CvVPvYQ9paYCN5TJByQ78fr/pzPV6l8rTgy6aOXG+7E2z2dSvf/1rtdtX86XcQBEV7lKppOPjY3k8HstIe71LWSzo25QPqtWqaQu22209fvzYMnHIAVC0JVlz8MHBgQKBgNW8UaHmnno8l7JNPC9gTghBOB7IWbQaoA6wtLR0Y+d8Y+dCYZEIm0iCg0PvAcwr6Hh03NI4hYNyVT/5MwwFP4vXLpfLFoUSwbp8bLfJx+PxmCaWSy9Fmp9IFI/darXsYWL80T1i5gGpvDvcaZB1Ha8k+qhWq9aZzVAzMggKfQz6CgQCmp2dVSqV6ovgid7r9brRLZPJpBEW+M5EMDDDyE7q9boODw8NJgsGg0okEhZFovwL3uxGgDxLsiNqQNJVxEnD3KBrYmJC7XZbe3t7BolREyBYAFogegTX52ddI0hdELFToj3YZpz18/Nzc+7JZNLgWmo1bt9WuVxWMBjU5OSkDd7KZDLG8iP74ZlwD1BZoFMdp+02I0LoeJfFHcbouRksBpCMzK1PuU6Ge0IxmmhcumqehBwgXRFZ3CZNsluyaogMkAmofaVSKRNHdcc/uEbdpWxf7zCnVsmkVtiEg2Yu1HzI8qWr6Y8MJKNG69LxISmgqMHdoe5yXdaH6a+zs7OanZ1Vo3E5muT09NRqO7w3yINbn6KEEI1GTaaGDBmkBpSBmhH1OJdcAEkClQl0Bm9KzHmrYWFkChxQunTj8bgxDZ48eWI1ACII5olwmGjCdB8Arx2NRq0xCM/MIZJkRSecAzPM6/W6RTQHBwfWiOT2q0C5c+l8HJJ6vf5HsA2Ms9PTUyuoD7o4QC7GDmzALHfUi9ljN0rtdrum84WRcHsxmIdDca9YLOro6MiYRsBDLgTC6/t8l3N67t69q5GRy+FaR0dHFvW4PSYQKMbHx23+PIea1+QgQxHN5/NKJpPvxNT57rvv1OlcznE/ODjouxAEH+6fU3+JRCK272SnZL+xWMwcOIaVEdnZbFa7u7sGybqBFYGKC2/RZwFLioI+FxF4iT2cmZnR7OysarWawuGwKpWKGXumZ/p8V2KQGP13WRgOpFKGhoYsADk5OdHe3p7m5+dt0uzCwoLa7bbd72QyqVu3blnLAGQJghAgxzt37lh/CvvOiOBwOGzFZeDF6elpRaNRIwpVq1U9evRIW1tbOjg40NHRkVKplBYWFqwe5haYa7Wanj9/bkV/Mkzo0tSQCJQGPYMEMTC9QGtgMQLJuxAwtO1QKKRcLmeZIc/SVTxxIUECTCaFzs3NaW5uzmwX+8vPgUJAaDk5OTGWF+0AvKdLauI9CQ5dWB2dQPQVyWz+k9RcXBYCaZbf77e52C7MwObCjsEg4Tm5bBx4PLcrFInAI/S9s7Mz5fN5jYxcjuCEVcNwoFwuZ1xv+l9gtUDxdMcbQw5A1wiPf35+rkKhYEYym83aQLG3YUu4i6gB+I7ob3h4WAsLC9ZDQXSKc+HhU+dgb3EuMGTIDBh6Va/XtbW1ZUwWlyHmRk0YyWQyqfv37xuExP7XajXr6OW7o2BAkffw8LBPngQjTFTe6/X02Wef2aiBQdbXX3+tbvdS+C+bzfaJapLZAT0kEgl98MEHls6zX+wZ6rOBQMA61Pn8qVSqz7lQ5HSbGzm7LgMIo4Ixg9HIfrtFZJ/Pp5mZGS0vL5tTQY25UCgYsYXsijqbW1MaZGFEcrmcNjc3NT09raWlJbXbbb169cqyhNu3b1uvEJ+X7wF7jWAJ3bGLi8sx4L1eT7du3dLMzIxpkbljeicnJ/vUjYeHhzU3N6dUKqVMJmPO5R//8R/7UBGcN1AS8Gw0GlUul9P29rbK5bJisZj120SjUTUaDe3u7ur4+FhDQ0PvpHLAWXabS8nGVldXNT4+bjAhCAqkBggdwHjcP1dQks56SE6gCaOjo/rwww9NJxF4121Mh/E4OTmpi4sLm2Q6MTFhEls4ZMgEoBxu3ZYM0+fzmaI99hLnctPSwI1v+uHhoRk2JLgxwDgHjL4LUbnsHBfjcx8wLC4MhdvDAQWZegEXDLFKDODQ0JBmZ2ctq2LCGtEtUeb1/+b/gR/IioD13BrCu9AYiUC4kG4xGTwauRvpqpEKanen07G/pzDa6XT6IAyMJNEunHQcKfsMTEHUQ6RPpEK07XZJcxlgoFFgpDYA7l0qlSztxpHQOEej22efffbW++dOEiU6dYvofv+lLPnMzIyl7mQsFJHd3g32jEgNSI/aQrPZtJkXFPojkYjRMoG3ODNuxz3ni6ZWoBP2jXoj9TXgCXpZgGv5d/RhvUvmLMmkTxqNhj1bjAuf1e27YO/YM/6fIMctbHP+2u22jVfAubrqA9f7WnDCqHTTpnC90E9tEkVrMnbOLJ8TG+OqKbiGFfLOIMulWUNygbmFYCkKH5wtPhu0cpTh3b4v9/wBiWJreCacZ36GfyfJzgf2DrSCP3NHc7twJ5D69aAJW0GWwrlFsPOmAc6Nncu/+Tf/RkNDQ/qn//Sf6uHDh9rf39fe3p5FqHhJRr7u7OyYIaJm4R5Ut8HNpebt7u5ap/DCwoIZ+WazqWAwqLGxMRUKBb148cIuRavVUjAY1D//5/9c1WpV33zzjQ4PDxUOhw3DdlkTGASWy/aBHgxvv1Ao6Pz8XIeHh6ZK/D//z//zTbfN1i9/+Uv5fD49fPhQ6+vr1mvQ6VyOZeaBJRIJgxUpQKZSKcNZm82mSe+DIVNYdQkOvV5PqVTKoA/IERAuIE5glCFF4FC5EC6rCidL34vrUIiyGD5EpEPt4PDw0DSl/sW/+BdvvX8vX740+GFxcdGytkajYU739u3b+vLLL9Xtdi24oNBLDcklVvD3LpNrZ2fHuqKXlpb6gpCJiQlNTEwYbAjkEAgErM5AxOo2vhUKBb1+/dr24rqjB6Zz2XZoSEH9B+9/l8zlX/2rfyWfz6f5+XnNz8+r0WhoY2NDkoyKjspvu902yX0+N5+ZwAEnilM5OzuzhuV2+1KYEnotWTpBAXRZSXrz5o1OT0/VarVMg43A6PT01AhDf//3f2/QOQrpKAvzGd0enXw+b58bQs+79Arlcjn5fD6trq5qbm5OJycnpvyRzWZVKBRMn6/ValntE1JDOBy2TNGtU5LpgA5BY5+amtLt27etpMD9xNHgOKmB895ugHJ0dKSdnR37eb/fr9nZWcVisT5oD1vN2BGyxXa7bbNrsMM/unNhnni327Ximkv7o4udwT+usXabG93lQmJugb1er/cVtl2HQDRMSgrmj9S8dNVVTH1CUl+U6VJpXWoxkYbb0MT3A3oZlC0GU87j8RibBNkHKK4UJ92sxqVTsmd8H7dmRURCxEMmiUNxKYdklPwc/x5nTxAA9dONWF3KI3vPJaHQSf+SWyCEVDAo2wlYk8Y8Lij1jlarZbIzKDO4Bd8f6iwmIpau6LTAPVxUvi+Gf3h4uK/DmjNFIZnXwUAGg0FzYG4ki3HlWXC2uWM4eQwmRvNdnAud4qAABBRSf4RMJE00yx7iWNgT92dduAQ5Jq/Xa2oH1+nObgZDQzHf3yXgIGF/cXFhowBclQ0+m4tIuIFHt9s1IVbIOYMuInmeLXZQumpvcHvo2BucNWcV5+D1eo3mDlriZhUEzxBHrp8Lt/2AfWGvQXg4a+7PQ6BotVp9iJKbkbrEC74LdfAf3bkwGbHVuhwY1Ww2tbq6amyrbDZrhWU6VBGoo3hOCpvNZq0bGdYSGCpeF4yVKB4IhpkXbCKHE8Pf6XS0vLysmZkZjY+P2wS1w8NDwzpHRkZULBZ1cnJiNDy/36/NzU0dHh5qbm5OX3zxhR1gKK/vwtb58ssv5fV6bewtOj/n5+d6/fq1fZ7R0VGLFvhuuVzOdL78fr+WlpZMvuPFixeKRCI2tGpzc1O7u7umisxBdoUUXTIBXfY0AUIxd5u5eH4+n8/m73AYObQYy3q9rvn5ed2/f19DQ0Pa39836OBtdImuL7rlqX1xAQhcCH6q1arRKGHgQd8EGoH2DuzE/g0PDxutWFJfINPpdExjiaZSonOwfUm2f6FQyBSmUeYmMkwkEiqXy/r+++/tfVyjiLwRgQ7MyHw+P/D+SZd3mAgauA/lbEgZYPIEVDg2F5Pv9Xq2h2TP1Fe73SuJeYyZe4epK7bbbas1SFeTRnESBEQMIiwWiwbvxGIxq52k02k1m01rVMWgBoNB3b59W9JVILazs6NXr14NHCBy7s7Pz+3eoCCNoQYGdKFF0Bj3e6EIQYYVDoc1OzuroaHLAXcER2g64mwkmcNAxYMgEFYnjDaIFxBC3PPPKHfqKuFw2J4VdgBH6MpfvU1weGPnMjMzI+nSex8fH1v3MMKBx8fHmp6eNmNDpOp6OYY1kQXAqAHHhmvt4vxEV+g3+f1XIoMuc026PEQccoq1kUjEhOv4e5oG6YHBcB4fH+vZs2eSpJ/97GdGRYa48C6TFNfX1yXJCuuBwOWs+nq9rjdv3tieAL3BnOn1eqaGsLGxoZGREa2urioejyuTyejw8FDT09Mmn/PixQsdHR1Zgc/n85nsBpRn8Hufz2e4NMbFFcGUrhrdiBYp8tL7wIEERikUCkbiGB4etmI/GdSgC6dGU2cgEDB6NM7L7/dbFHx0dKRyuaxUKmWCqdeb4FyogI54vgNOlcjQrSuVy2XrVO71LnWeuHjsUSQSMecCW4coenx83AZHwQ7y+/3GcoIRJclqfTy7QTM/SSbDBNQJ5Rc6N1RqF4fHubiZMqSAer1uQp7hcFiTk5PmDHFEnA/OC8EcDgBYCLFJHAz3FJgH5KHT6ZhkkfusotGovF6v9b8gpMmfUYRPp9N95Iq3WQRHzeblyA+o79TQ3II4EJcbfNPiMDo6agV+ak7cO2BW4G36xSBBsS9kchCSKLYj24JtJFiHPdftdrWxsWEDysgQWYVCwZIC91y6GeuPzhZjzCwfBPkGSTbBMZVKWbQDa4mI3BWbI+31er02X5yUdnJy0qIrLja/XMwRz08XOhEThSifz2cHDyothxeaHWwjMpdUKqXl5WVFIhFlMhlL4Ym2kAgfZLlkALejvdO5nPhIPYCMDJyWmpbXeykaStcyFw2cnBrWxMSEKVWj5cYlR87FhTVoKkWDCOjDbWx1i+FcTA4skbZ0abwIEmiUDQaDmpmZUaPReCdYDHom2QSClS7L0O/3G0zHZ8IgnJ+fWy0FY0MGiRP2eDzGQPJ6vaZ8jBI0mZzH47G94ueIqF24OJ/PGwMMWZxer2cOfmJiwmATSXaee72ejaUeGxvT1NSUBSXvslyVg+t1RyA8IE16R4iSMZihUMgyEa/Xa6KeNOd6vV7Nzc2ZJAyOBZQin8/bFERXnNKFn2GaAkHyHNwZ9fTE8FxcOJsGXyjkGP6JiQn99Kc/HThzwcjiONxaJ0QD6iNAxdglkAOf71JRwiUiQFDBocdiMc3Pz1uQifN3+8x+iPYsXWWA4+PjikQiOjw8VKFQMCZjr9ezvh+QiHa7berxkiwT5bwhieQSD26ybuxcEK4rlUoGf0AL/uyzzzQ9Pa1isajT01N1Oh1rZtvd3dXz589tfCxGkO5TaiVs2OrqqlZXV617GONK9EZqfevWrb4JggwIon4jXcrDZ7NZxWIxLS0tGUTH5lMkp7aysrJiA8codMJAWl1d1b179wZ2LmC9/A4mPDIyog8//FCTk5M6ODjQ9va2IpGIHjx4oJGREeP7+/1+LSwsmOHJZDJKJBJaWVkxiC0QCGh5eVkTExOmhkqEODQ0ZCNggbU8Ho91h6+vr+vBgwd9xpeO6dHRUSMHcOgw9D6fz/TgvvrqK3388cfa2dnRL3/5SzWbTS0sLCgajdqgpkGdCzU4sp9CoaDnz5/L6/XqwYMHJg9OpB+Pxw3G8Hguu5I3NjbMiYDnT01NmWOiGA8hAPh2d3fXitvtdlvT09P66U9/amMZ8vm8hoaGbAQ3dRNGR4+MjFiPj6vJt7q6qkajYbRRRAy5N1BcE4mETk9PLTgbdLFHZAdk5WRfaM3F43HLNDCi1NJoikQNY3Z2VgsLC9YyIEkPHjzQ/Py89vb29P3336tSqSibzZrKBvLvy8vLfZAgtGPOazAYNEi42+1aNgfRhuZsAkr6bmKxmGq1mk5OTvoYb2tra/rTP/3Tge8wzpkslnpJu922Xpp4PG4D9nAWpVJJ+XzeyDeumGuv1zMlAmqIU1NTmpmZ0d7enh49eqSzszMbo0z7RSgU0uLi4h+hAcjlz8zMKBAI6Pj4WOl0WsPDw33Cqoy5np6eVq1W05s3b1QsFm3gn3RV36WOhKbkTdeNnQsGmMtKyne9qMd/XzciFJLcAjTRidvQw3LTceokFFA5eDwkr9draR+FZjw4P0NBij+X1PfnRBlEHWQ7NCXCbx/0YLr74WKmrnQN0RfRDheDaJiI2KXgulGf2+lLdIoTI+vjMvPLLaC69EqXGgn0BDToOheyRLBZam0upAJm7170t11upM0zo/ZG/chVfpCuxvm6tGiXBefuaalUsgvPd79On+XfU5cAloM84fZBAWEAc7j9LpA5yEaIiN26C1k7GcTbNK/9hxbfg3PDL+6PC126NG2XTUmLAfAL99ftWyO7YA+BfIjs+TsCIvYYyMftpeE7Y3/4bC6r0d0XYFEQFNcWvYtjlvqVzdmH6/buOtoCHMpZc8lQ3EX2mO9C4MdzocYF7OWK+QKHcbd5Tjg+SAbcE+lqEil3xoU9oRy754P7xTP+0WExl1ngXvRWq6WtrS3TVQLPJQ0cGRkxuATVznA4bFEwG4RROD09NWoeD3NyclKpVEqnp6c6PT01+ArNpm63q4WFBa2urqpSqehXv/qVstms1tbWNDExoVKpZAq0jUbD+grGxsas4EZdxefz2QH1er1Wv8lkMjo+PpYk/Rf/xX9x022z5V4SooC9vT0zKKjMkoX963/9r9XpdLS0tKS1tTXVajWjujKLhSZFemCGhoZMMVi6rJNdXFzoxYsXKpVKmpub08zMjAUGXq9Xy8vLJvVPxMVYZKLMYrGoN2/eqNfr6e7du5qamjIIB0Zes9nUb37zG/3iF78wyMzr9Vo9jkL7oBecGhB1j2KxaGMRyLROT0+VzWYtqAD2oq8IgwCrhmdRKBT08uVLtdttRaNRK/7Pzc2ZdMzw8LARIlBTIGvmHEciEV1cXGhjY8OopLdu3bIRu7xWrVZTNBrV1NSUBU9AR6enp30Z2u7urhmoHwra3mZhXDASbh0KRhXnH4o5DZzoCDIPiNoB8iHsa7vdVjqdNgQD2BGoDaMbDoe1sLBgOmoMxINgQD0FiB2YFsPL4s5iQDc3N3V0dGRwu6tqkM1mbW7SIAtjDeXahWlpe5Bkf49KyPDwsCk/rKysGATNrBc+E46Jxlm/369PPvlEjUbDlJY5z5FIRAsLCwaTn52dGXzfaDQsYxwdHdVHH32ker2uk5MTdTods2l+v19bW1sWXPt8PqXTaW1sbJhKBPAiFPrrNZr/v3Vj5+JmFS6VsNPpWO8DHbREZ+Da0FLZMDA8vDcOyT1ULoWWCA8KXSgUMg0omvjYbGS8u92uzXv3er169eqVPWgugiR7T4qZdO27Hek0m8FWGWS5r0W0TA8GmH4ikdDExIRJmVxcXGh6etqMIzUkLiuaVz6fzxRMuajUPsCcYZZQXCZIYDAa434xZETeIyMj5hh4rpwBFyKTZDLy4+Pjxl6j6E+9510yF+kqooYYAsEDbB/9MGp61BL4eZfMwOs1Gg2l02ldXFxobm5O0lUNAlUHzjLRJIaV4GhsbMy0nIi6qZcgpe/uLbBcp9Oxmh8Cjnx+Ilaa5MjCBl0u/ZzF60I8wIHyrC8uLqyOASrA/7tZvXTVnAoVmQCELK3X65mkEIQT9hE0Ih6Pq9VqWS2QSN3NWngvlkvSKJVK2tvbUyKRsNoZC+r8oIvMgvPn0s4JWKCMu/uIHXNhfAIY9/O4daezszMbJ9JsNo0piJIHLD23/4WsiF64XC6nlZUVcxII8JJlE5y6TDfEVRkr4AZvJAU/unNBfA0+fCaTsfkc9BHApCE7QdiOtNm9OEAKp6endrCRMWHDXMooEMPCwoIVFVutlk2w7HQ6+t3vfmc0O4/nskMYuZB6vW68dyAcuoIxokysowOXaPl6T8kg69NPP5V01dszNzenpaUlnZ2daXd316I0Mj4cXblctrkQLHdfMKL0CTAYqFAo6ODgQK1WSysrK1paWuobSgTDZGVlRbOzs0bXBld15S0ajYbm5uaMVEDB/uDgwGiZZBPlctlGVROVEhS8S0GfnhPGDY+MjFiznnTZdDg2Nqa7d+/2NdgBGVB89Xq9Nj/DVRgg4CH6I5smK56enlahUFCpVLIoHmMgyRpLoSozr51/g5RRKpUyluU333zTx7bLZDI6PT21AWQ4M3ec77ss0IVkMql4PG41F+pGLsxD5kI3PwVdPgvwIIV16UqzymU5ItzJHBscvd/vt0bX5eVlraysGEzOqF3Umnlv4E3sxcHBgXZ3d/vORy6XMxgRWJMzcF1w9W0XY5OPj49tv1wYm8yGZ0WvHE6UQI3sFedE5s8obBxPs9lUOp2W1+s1xe90Oq3NzU0lEgmNj49bDYZAiMmf7AeMUIbnAYWxl9DoEQt2pbFwzthXl5l7k3Vj50IXKLpSOBIYGS7dMhKJKJFI2J/RRcuoWpxLrVYzz4lQXzgcVjQatc5cnAjsGjptXecyPT2tFy9e6Pe//71FyNJV7QB6nYs5wl5ymy0zmYxevHhhIo6kvC4OPiis8/HHH0uSHXzp8kEXi0X97//7/66dnR2DvnDOPp/P0mY6zCXZwXRnzOBc1tfXtbq6qqdPnyqdTsvvvxyWlEgkzJgyujcYDGp5eVlLS0t69eqVnj592qc2TG9CIBDQ3NycdZ2HQiFlMhm9fv3aDmaz2bRehJmZGVMQhqHFdx/UQLIfCwsLNm7g+PjYLk25XNbc3JwWFxcVCoW0tLSkQCCgvb09K+yS1RA1Q3CgAZPgCcomwdD8/LyGh4eVTqeVTqft0nHZ2CuCFYxmtVrV8PCwyuWyZTQzMzNKJBJ6/vy5vv32W3W7XWOr4VxgMPKZcM7UAQddjMBlEiFsK4rO7utDqOGOAd3BIKP+Wq1WjbQwOTlpNRV6q/b39404QZ2A+gBMqI8++kiLi4s2NthlmPFspCsdPKCh/f197e/vGz3Z6/Wa0KpL26UWiSEfdK2urtr5de0AdGNYgNQ3yLpcaJaufbIFpqcSZDYaDa2vr5u2GGPdv/zyS6VSKdOFOzs708rKiu0HwsGM1sDhoKqBTZSuVMxp1Wg0GsrlcvJ6vRYY4uhBebxeb5+K+E3WjZ2LW0xH2RS4a3R0tK8/ZWhoyNJ5Hiy0VK/Xa81FFIiRxsc74tGZ8+wyfGA5kIZSsKYoRuGJSCUSiRj1juIyjLJQKNQnaTIyMmIic2RSHHRJprs0yGKCnwuLUZuiRwAqKJFjs9m0veV3t/AnXUER7BFzX+r1uulHuXRSSBgYfFcP7Dr04GLldN/TN4Mzo4lLkk1vhE7e6/WsQEuENahz4WyQIQGFcta4PK4yMeeFBrN4PG6RG5ec78dqtVoqFoumqIwjoh6G8bjOnOPcuQQNZsDgxLrdrnWZt1otYw9hbBB4TSQSFgXjWN61GC2p7zO7pJofgryJ+nmGBGBkbQRuZDZAhX6/3+4+lHpgGHcGkFuQ53wxo4fR0NR1QECIrglIfT6fyamQcWGPQqGQjTLg+wWDwT7VhbddW1tbxgLMZDL2GbnTBAXU3lx7QzYnqY9gwpyaZrPZp4bhkkoIhuv1ugVAnEkX3uf8QQJxyVBu35KrkQb7j+fuZp/8HHaevqgf3bnATYd+WK/Xtbi4aA1LRNuRSES1Ws28K8197gdrNBo2HwOpeAwgD8Lr9VrjJgvoIRQK9XW45/N505jqdrumoryysqK1tTXjidfrdc3OzqrT6SgcDisej6tcLmtra0v5fF6pVMpkrYkagXNCoZAZp0HWv//3/15er1ezs7NWV4HeOjc3p6mpKYtistms/t2/+3eqVCqamJgwGitaVGQWfBb+TpJ2dna0s7Nj70XPCoOpgKZI34+Ojmw8r9t81ev1TIPq4OBAv/nNb1StVrW5uWmpO9EYrLuFhYU+Bh/Okc5gjNogi36Gg4MDGzW8uLhohAUE9Wiu+4d/+AednZ3Z8K9wOKzp6Wk1Gg3t7+8rnU5rYmLCZOWBGtPptHZ3d7W6ump0dwbfoUZLfYBeGpw6NQqcNUEUtGaK0hjiW7du6eLiQtvb27q4uNCdO3e0urpqdGUcFYy8d5Xcj8fjBosSyROA0KvjdmKTZQARI7vfaFwOmyuVSlpcXNTS0lKfoC0tCfF4XGtra5YpBwIBFYtFqw9KMqae1+vV8fGxNjc3regM/T0QuByxu7m5qYuLC4OQp6am9Fd/9VdqNBra2dmxLFa6zGQPDg7U7XYNop+amrJxAoOsv/mbv1G321WhUFC5XNbi4qJ+8pOfGIzebre1uLioO3fu6PT01FQvqMGxcEJDQ0OanJw0m4N0liQLlvg5Xs/j8Wh5ebkPFsOm0ghNxnhxcaHbt29bcztK8dRl2WfOF8y+oaEh04iTpNnZWQvG30al5K2oyC5VEhoiHwxvDAML2Mpld4BP8nDdNBmI6npEft2Yu1RbPs8PRfIYMyIwXueHoC3+LVEE/1a6grHeFe8GyqKhikik1+vZQw2Hw4rFYn/USEYqf51x5u4NGSG1GIp7/LmLk7vPkayMSItIGgo0zoIu/uuUafYcbJZmWz4vn5Hv9y6LS4R0yXUVZ6I3yCR8J/B6sj6iXCi1RGrsqftvOAsuccGlm7pUWv6M13d/4SQ455xLN/OBhOF2esPk4Zm9y3I/J5kqTovP4KIPaLjxrIlsOVNkCtfnl7Bv1DL5u+tnlsVdgAggyWoIwJhkhu45xPFx9vj8ZEduXdKlpw+auSDeyCTP6+QW7iuwv5vtuouz6DIW+beUH9hvXpczB3LE95WuiAYuTZrzg/3l3FP7dnX3sLsuNd3NnrALOPofvaCPTs/BwYH29/dtJC+MFh40NRUmqLHJTDYbGhrS2tqaQU8wJohGUqmUwuGw8vm8qXmSGUWjUc3NzdlhpUYzPj5uNMNms6nx8XF7QIwwptGL7Ono6MjS3FgsZp/Hnf3Bw4AeiCLBIIvGJOY9uL0DGH4OmHRJACBV9vv9hqdSkEXBwE23qYn5fD7V63UdHBxYzSAUCtnlc5lnjL5FXka6bBYLBAKWFdJ0hdQEjJSjoyP7DB6Px1QYiI47ncshVLVaTYlEQnfu3Bn4YsN8I/ty6bQ0WBaLRf3617+2MbnDw8Mm6QPkEggEdPv2ba2srBjcAmsOnj9ssjdv3mh0dFRLS0tGYoDJ9M0332hsbExffvmlFhYWlM/nreYC1h6Px208uHQljEp2TQ0kHo+bssLLly9tP10izLsGN6x2u62nT5+qVCppfn5en332mTHjut1un+goulnZbFaZTMZUMrjDUGJpPCXwcGntSBG5M4WAu6TLWm4mkzElYJwCqtPUKwqFwh+NI9/Y2ND29rbGxsa0vLxsqgDYBggqfO9SqaT9/X3Lmt52MdKjUqno7OzMBvtJsuyo3W5bHej27duWFfMMgWBxjtyPXq+nmZmZvtouwQbQbCAQsHMKxAo9GUIKQdf8/LzVnTKZjCETwJter9dYqZLMyRBcYFs7nY4pK0xOTv6noSLDyX/16pV2d3cVCFwOuYHqSpRANAil0MUMq9WqRkYux2XOzc3ZJnGgYJ3FYjEVCgUbswlNFiaPG0mC50Kj63a7isfjfdLldGwT0Xe7XWM7jYyMaHl52R4OGDSeHwfAmNxBo0ecGtLcYPoUbLnY9Xpdfr/f5N6Rs+dyUNMIBoN9BVYiHWaCuIPV6CfgV61Ws8Ipl6JarSqTyfT1HsEmciXNObxQSt2IlmwHWJEo/uzsTAsLC1paWhoYkqDe5TaHuRmwz+dTPp/X7u6u5ufn9ed//uemv0bfxdbWlqLRqPXqEL3BQPJ4PH1OJpPJGGuG98bY0zH/2WefmcIEjW702CBeifYZ573b7Rp5A40+GH44QJh9ROsuff5dVrfbNcZRr9fTl19+adkFfWnMloE8Awvw/PxcpVJJ4XBYn376qc2Ud2GZTqdjkvj0hvl8l9NoubfA5NJV3xLfEweGdhnRN2KOqFpACDg5OVEymdT6+rqNJqfugyYZ78PnHxTajsVidu6o67Cn7GG327V7h9gq7DI3S+AcQPYYHh7W5OSkfS/sAHaJmhUOpFKpaG9vz+4wdpbADvgKggm20a33AJdfz8zd79hqtYwFSYD3o9dckO7odDr2EIFrAoGARfiI8WH0YA2R/gGxIPxHxIOBAK/m7/mSIyMjhiWy6WD9yLy44oE4PWiCHGBJdggoVPI5stmsYeLMkodwgKF4l5oBxjeVSvUNDmIss1vrAXaAuogUCIacJi4o3Rwe9Iv8/suRvdTJoF9fZx1ls1mLgNAUgv6Zy+V0cHCgs7MzK9q6InmFQkF+/+Uk0tHRUZVKJb148aJv/3Do9Xpd+/v7A2cu6XTaMhdXBsNlsxBpjY2NGSUVYxSLxbS4uGgUz9PTU4MtOEPtdtvGMgMPAM3Qd4LBo2fim2++US6Xszk2bpc0vRq1Ws32jU547gNBULPZNBqzW6cCMmWC6rssMicK0dB+CexgeNF2gJxLs9lUMpm0/qnrSAR3GuiPTJ86H1ksxXu3JQCjhkOg1sTZdok7EDcIoAgAYT4ODw8rn88ba5HXIOrnLg/qXGD88UwlWT3O3WPOB9+RoMOFOdmPeDxufSjsnTtKAEiVO0tAJF3Bzrlczph1bnFekgX+NHViH6C408eUTCYtsCZIIBPFwYEE/eiZy/PnzyVd6hMh5e4yFbrdrlF5pSvpDLR+xsfHNTc3Z4UlWDPS1RzpXq+ndDqtfD5vF8EV1AMqwzP7/X4dHh5aTYUCK5AYnbIwjIhiSD3dBq1ms6nd3V1tb29rampKH3zwgRVzMUgune9tF6oDNEANDw8rFArp7OxMr1690uHhoUFj7BEF4IuLC62trenLL780OIB0GJ46XbSk3UNDQybhjVZTqVQyKX+ghXQ6rXK5rEgkYhkfTubNmzd6/vy56UDBCOQiZDIZBYNB3bp1S7FYTHt7ezo+Pjb5cJwMtPOXL18OvH+vX7/uq6f1ej2L9Ah6KIr6/X4dHR3J5/NZ020wGDSZ9ouLCx0eHpquGI6vXq9rb2+vb9QwzhkYkt4PGmDpHZmcnNTy8rJlG9wHoljOKxcf5WQ3ECqVSsrlcoapX2dpocA76OJz0dw5OjpqfV0YrHK5bEYIRt36+rrm5uaMASfJelEIuty+KCDzi4sLC9a4cxg66iLA3WNjYzo/P9f+/r4kGcTqMswKhYIuLi40MTFhDX2gJDDtnj9/rsePH/cxW+fn5+1cDAqJSbLi/OnpqSEiEIuoO7tq8MjlE6zx3XEg3W5Xk5OTBtmfnJzYXcYp88xotIauPj4+rnv37mlkZMT6zSAdubaZs+U6bu4k1G/aHFBbvk6sIjOHVPGjZy4U76B1kp1IV8V1F0rCcGP4KR6TnlK4IirBkxNd87ouC42Nx6CQcdDMhtGEjooRIhV3G8Rc+qlb7HNlr9300S0cD7LcIh4FUqJE5neEw2GL8ijGE32NjIxYRInDJXO7zrnneQFLucVV/h6DTKrr8v/dfeU5uBcEWModV+Dz+YwQ4UqJuIVB9mGQxd7zu1tUduGm6wsIxZXK4Sy7NTV+Uffy+XxWyOQ9cNR8b+Atfo6o0I3GoWIjlcNrEQi4hXr2kOftnj9ea9D9k2TMIr4nAR1wCfeW2gj0aYyyS/jgvktXQ7GIyvkZ9wy6xBsX26dYTaQOTMkZpzYA9MS/k/oJHGjfSTLFA+BJ9y69yx3GpvDZ3OFeZKw8I/fcX4ed3LYM+nPI6sjaYIZC+nHvMLVh6Sp74TVoCneJFzwnai0EOS5KwTMkmHHvP3fD6/UaFHiTdWPnwoVj/PDx8bFevXrV19VJd3kkEtHq6qr1wrTbl5LOGxsb6nQ6faqndOzCxKCbGemIYDCoe/fuaWZmRoeHhzYciLQUuCGbzWpvb0/Dw8NaW1sz1hoQyvz8vFqtlh49eqR0Om2TBoGe/H6/5ubmtLq6apTLXq9nBTei10EvNxAOB71cLlv37f37960mxGWkEJlIJBSJRJTL5fT06VP5/X7dvXtX4+PjpqXlOkr6BarVqrLZrCKRiObm5ox6jUPiwq6trVlhkQgI/jyd7kjEeL1evX79WtlsVr1eT7du3bLa0cjIiO7fv69PPvnEPkun07FmWJoTB92/hYUFSVfRNyrPGDnXYLuSLJAZtra29Nvf/lbd7mUjIyoQ4PjUC6enpzUzM2NNkTT6ksl88sknCgQCVod5+fKlERvoRk+lUjZPBDothvzk5MR6iyBocB/I7pn3QZMt2RdNbYMuSDluzxMZLySZiYkJG3C2v79v0TkOmu9KIES3Od/Rrdm51HfqKThS9snv91v9zv2us7OzSiQSpizdarV0+/ZtM+Q0xR4fH9twt0gkopmZGf3FX/yFGfpOp2P1G8RuB10wIROJRF/23+v1TDUA499oNKzOApTo8XhMlXx9fd16hmDAoQKPsnKxWNTLly+NQAGhicwCZ8/dqlarfQQKPgf1GwgasCiTyaRpDZKxzM3NmXo2duLJkyfKZDK6ffu2fvrTn97YQb8VFdmNbKDVUi9x6XOko9Fo1CIzmEccLjbcpdFdjyB5LSAbYC4ifiideHFwTqk/WoAMQMTNA5auZqp4PB4Ta3N56zRvvUuPBu/D7zTylctlw4LpHYJ5RwQE84ZhYkTC9OiwD+53If2uVCqSZBcS/JnskWwMUgHQnBuNuZGSS2NFzJDIh//HSVIbcfuX3OjtbRdGgQt1PXK+nr0Q4eJUj46OLLImm+XyAAnR4wEcwZkkWwOCGRsb08TEhLrdrnK5nJEegBxdeq8bIbrFZQwKzWmcU1d7ihqdS/d/F+cCFZz94nO7OD1Z9HXhSs6Wq2MlyZwwFFVgRDd6dzMY9oe95jm4cAzPm4ZHtNWQvOeZuTAwagJzc3MGf+KE8vm82Snpj8et33SxD5x3yB1kFaA6tBMQ/ICCYNMITrjXwImcMzJYiBSuOCrZEz1/0OHR8aNe4hIHsCegFPwZATM1MjJkNzsB5YHhin28ybqxc8FJ5PN5eb2XSrIcDgz18vKyPvnkE3Mmx8fHZnwCgYBu3bplxomDSsGVWQ3UWzjoPp9P29vb9ucYeC4Ik/2APdxCFgay3b6cnNdut41Oh/gerA7kRLa2tszgc0GYhvcusMSzZ8/k9Xq1uLhoYpQff/yxRbOZTEbRaNTYSsAttVrN5rLcu3fPYMZ8Pq/j42Ob+wEGDceePYcddnR0pPHxcbuQTLiD+j01NWXwCHRmJClwtBTvgRvAvCF4nJ+f9zkoOoVxCIMy7dzl9um4OlfS5cwhOrbz+bzVRagPzM/Py+PxaGFhwVhcnOOFhQV5PJdNmtTxaG5jdgjOkaCKyxaJRHR6eqrDw0ONjo6afMfJyYlOT08tgwaSJTtkxtH9+/cVCoX08uVLPXnyxLJ2znG73bau/XdxLhsbG31ZBA6l1+vp+PjYVAIWFxdVKpX6UAKQgjt37thr4BSAiebn5zU0NKRcLqdMJiPpavIqjL3Z2VnLQJB/YZQF9T5IKoygXl1dtZ9zG0up5UIXHx0d1enpqf7Nv/k3FlB2Oh3t7OyoWCyaVNSgewjSkEqlrHUBSSaCRWwiJAy/328q00B+vV5P29vbOjo6MgYnwd510gOvd3p6qkajofHxccViMcsUCYyBel0oEIiLzNilf7tUd5/PZ+PXvV6vqQ8wsJBm9kAgoIODgxvXrd7KuUgyBgi0YdK9Xq9nvPnT01P95je/UbFYNKrr2NiYVldX1Ww2TT6aA0Mk6Pf7DTpz8cjd3V3rB0CuAM88NnY5OtRlaNAIR0SGZ4a9BrGg273U4Llz547GxsZ0enpqxhTOfCQSMabUuziXly9fWvTBVMvl5WU1Gg39+te/1v7+vm7fvm3fj2ZLZlMsLi7qs88+s8JasVhUNpvVwcGBpeQcIIwTUBxwJYQB5Ok9Ho8JTOJkcOoej0dv3rzR2dmZxsbGLKKamJgwmRdon/w75M75OxwArJcfy7lQD6EmwJ8nk0l98cUXyufz+tWvfqVisWhRF3BYIBDQ7OysgsGgGZ14PK6ZmRkNDw9rZ2dHR0dHmp6e1srKiqRL1hfillzeer2uQCCgpaUlJZNJ7e/vW/2MMdQXFxcGIxG504BHNj4xMaE/+7M/0/j4uHZ2dvT69eu+bEa60sJ718xle3tbkiyrBEaCIl+tVvXw4UMjYyBdA2NxYmJCa2trkmQSQ8BivNbQ0JAODg60t7enWCxmr398fKx2+1KN4tatWyoUCnr8+LFBNmQyLhvx4uKir7E4n8/r4uLCnmsymdTs7KzC4bBu3bql4eFh/V//1/+lX/7ylzZpVrpkupZKJc3OzppTHWQxnRbmHrBxt9vV/v6+qtWqETckWZ2NTn0Merfb1eHhoZrNpiYmJjQ1NWV9MGTLZP1uSwXwI/A2tW9XxQE7RabkOjmcC8Qk3mtoaMgIHtls1ujds7OzGh4e1vT0tDHiCBpusm7sXGB4RKNRm5vtFtJhl5ycnFgNY3R01NgTkgy7la4aB2nCfPPmjbFCEEckheNiEbnQSMhGZTIZ4+FLV4UrV+2TyHN+fl6JRMKasprNpvb3922OitsPQlc5sjLAMIMs5otTn6Ae4WpHwRgi4gcb52cY4pPJZEw3icvIvlDnarVafSKCCCkSqRK1MlEU6QhJFl2dn58rmUzaaAOixdHR0b6eAWQpgOEwjsA6XBpggndZZF69Xs/owTiYZrNpRpLPIF0Jj3JWkSDhTHS7XaNVSzJSB/9/3Rixn3wnag+cv0KhYM+T18fBEgDw/Nvttl69emV6VGTwvC802kAg0FdbG2SxL6Ojo9Z3gvOHVZnL5cxQAj+6RWDgYbe3CoPJHhIIYsykqxHjrVbL6qpE3cBM7JPf77civVuH5PvPz89rYWFB5+fnymazNnYCJWuoyRTNFxYWLDJ3ZVjedhHsUgKAjt3r9awXDMFPAgm3OdENMtxgyyVTuA4Gti3fnd/JZkGAXMIEATCkKewC9xn2GtkSsj8sIFsYZqBSLtvtpuvGzuXk5MR6LdbX11WpVHR0dGQNZdA4ubDg9FtbWzo6OtLS0lKfrg8XvtPp6Pj4WH/3d3+nVqulTz75RPfu3bMvCHQGdRhcem1tTR6PR48fP7beGgq9rornycmJ1U5QAf7ggw/0+9//Xt9++62azabevHkj6fIyQ9MbHx83yIymQXdm+9uuTz/91FJq5n48efJEzWbTKI7FYtEgML4zPTrFYtG6lp89e6bT01OLFjnojUZD8/Pzmpqasu8MxRG143Q6rVAoZCrH2WzWiqKZTKYvI0Ad+uzszKK26elpLSwsaGNjQzs7O300aByxW/AmMmq1WqYJ9i4LJ0t2icHqdC4VZ7///ntJMoqrJIMa+Jw8R+pXzWbTqPbSZSc2mngYBldqgwvo9XptnMPJyYmNO3758qWJolIzAaKDpJLJZLS9vS2/36+dnR3rIfrwww+N8kszbSwW09HRkQ0OG3QdHx/L778cQHXr1i3l83ltb2+rXq9bj9fLly+tZoJhop4CW8slT+AA2+220cVjsZju3LljjZXSFaGlWq3qzZs3BpX6fD6jMzOrhDuRz+eVzWaVy+UUCoUMTv75z3+utbU1/dt/+2/113/912o2m0Z2CYVCunfvnjnx4eFhzc/PKxqN6tWrV3r8+HEfe/Ft1sTEhKQrQ1utVq3/D8gUui9sUM4PBBIacYGJXcfCeZMus8tgMKjZ2Vk1m03t7OxYfw2ZGyQot55D4EIZAfgaPUefz2dqBsfHxyqXy30Oj1EnwGMEWMFg0JRUbnoG35r0TQHdhYjwfAxrootbUt8Hd4v3rrcFuyUbgoZ3vXBLFMXvQF4U/Nhg1vVIgWI3aaRLJGADYXxQhOPzEWENWtSneeu6iqlbxKQQzt+7xWnqMO1226TzSXf5LvwblwJJjcYt9ruUTpw3xUSXi89sb5hFPENqHvxbniVpP+m4W7x9FzKEdKWKzJ64z9vNXMiiXEaLe8Ywim6txl0YCZe2yjl3MzLOBJEwODbMm/+/5b4ugQHOGXwcAgTwFJDcu+4j7+8q6kpX44gvLi6UyWT6Gnrd+4NR5Jfb8e1qbdF0R7RMDcDtA3L3lWcGDMT9wAlxR6nNuAMHJfUV/akZUhOkp4iMdFDnQgmATIsiPHuKvXDn73BWoL67el/sG/eXu8r3Z09cSjtO/3rQw8/z/wSWLpzPz3N3OOucW/e58qx5TZ4dWepN1o2dy8LCgh12nEgmk7FLBaWYxiH3wICLkibSqMVBCQaDVtwG94tGo1peXrYL3Ov1TAK+0+loa2vLsEkaqKhX8D6oseKAut2u/uZv/kZ/8zd/YxTdkZERJZNJ69RmUzG4KO6ura3pgw8+eCeevCTrMqb+c11iBehLkmU6wFCbm5uW0dH4hnwDUCDD0SKRiBXk4vG4YrGYKpWKKpVK30Q8N3JinCw1hlgs1sfwAsrx+XwGicXjcVMPptM/FAoplUoZAaTVaml2dlZLS0sD4927u7v2ftR8uBQYH7Joip2uES2Xy9rc3JTH47GmOogUyWRSX375pcbGxrS5uWkRPgaSszw5Odn3HVqtlt68eaODgwPTt+L8wajDgMTjcXU6HZseSs2NZ0cAQREXQ0UheGZmRl9++eXA+yddDruCgekqC3e7Xc3Pz0u6rE9Qs7h9+7axlhjCJ106RQIdjJ6b4VArxIgPDw9rdnbWMhSmIOK4gICB0qk19Ho9LSws2DhfHO+bN2+UTqfV6XT03/w3/43Oz88NRZmcnDTyA5APisKxWEz/1X/1Xw0MzaJZmEwmTX0b6HV6elrBYNDaA9yudxofXVrwzMyMzRR68+aNESKA9nAOOzs78vku5xihglEqlRSPx/XRRx/J7/fr9evXOj4+7nMKrloC9Hxs+NnZmY6OjmzcBzVMHDpnhP0mQJ+enrZJrTdZN3YucLL5IIzObbVaxlQiqnYjWR6E2+XO765eVTKZlM93OU64Wq0qGo1aUZ3XAxZDxJEIEZbJxMSERf/g3fS7gDkyROuzzz7T6uqqdZ9TVwA+guWTyWR0dHRk8+ffRd+J2hQRRSQSsdqIJMsscM4UD5PJpI6Pj02ihL+DfQRhwu/3W+2J0cUU94kYYfdABQe/RUOLJlgEGN2LSPaEqCXw58rKipLJpLa3t9Vut62HiM/a6XSM9TNohzSD5sbHx02G5zoFmboRn5sOdxg7uVxOfr/fLmqj0dDx8bGGh4dNSWJ7e9umRhKlYdBh1eFwkfs/PT21IWCQRxipDUyL+nc+n9fZ2ZlSqZTW19fNAXk8HnPOLnQMZfn27dv6+OOP36nDHKFFam3U6Lgnfv+l4sXm5qZisZg5HgwakJfP5+sjiJDp03pweHjYl70BN7visH6/34JAagMIZrpRMuoKvA7073Q6rZmZGT18+NDqwdVqValUSvF43GTlgXnr9bpWVlZ09+7dgQNEmG+xWMwGarGPExMTikajpk4AMQbxVCayAukCvVcqFWWzWRtPAJmGukk+n9fY2Jju3LmjVCpl8DKQ6fDwsI6OjnR0dPRHqJDb2hEIBOzsQqiSZIGBe5ek/uyWrAYSyk2d841PKkV6N4Wj6D4zM6NIJGJ6Qm7x25WHhrXk1mSgyzLvAY66JEvPE4mEyWHgxIi8uciBwOWsCC43Q6Ki0ahxyf1+v9bW1jQ/P6+5uTmLDLe3t82gkobjoHgAFIsHvdzANURuXFqPx6Pbt2/r/v37ppgM5kzUwQVByZgGLDf1RaoEOijQDkYWmI+DxDhqJuixSNeZp46zJRCg5sFeIZ1SKBS0sbGhvb09ozyTdVI4zuVyA1/sYrFol7jRaFhW6vP5rKGPQICImUuB85ybm+u7uOFwWOvr6zbcrNPp2Bhtv/9ScNBtaKVpjwWECHTLPlJ7wnDyOcjMgSW44MBECBa6P8+lPzk50e7urrxerx48eDDQHkYiEYNtSqVSn9TPwsKCYrGYSqWS9a2gjj09PW3TKK9DpDhglxCSTCa1tLRkCAcQG4EibKVEIqFWq6XDw0MrgnM+CULpIyGalq6GntGbxfehb4gMIZvN9hEBXIbj559/PtAeEqS6U3h5bbJd+mmwF+FwWLdv3zZ5LIJz9oGgGccaCoWsEZW7XCwWzWFCxkin08YqnJiYsNHQkkx8lO9LBufxeAzFwT6AALgLhAmIttfrmSr4j+5ciKjYEAy33+/XnTt3NDk5aQJ+GEUXc3fHptLQQ/EXGCUYDFoEsLm5qX/4h3+wqJILDxySSCR0dnZmMIPLEUf6fGpqSslkUuVy2YqtH3/8sWKxmH3GSqWira2tPnoedSUMJMyKw8PDgY0jg6ZoLi2Xy8rlchodHdVXX32l1dVVbWxs6OXLl1bMRJ+JfhdUeufm5rS2tqZ8Pq/T01OjEo+NjWltbU1TU1M6OjrS69evJckcOZz5drtthTnkuDHCo6OjWl1dtS7tQqFgUResGJ4n9aJXr17J5/Pp5cuX2traMgVtCp8+36V43+Hh4cCwDvL009PTOj8/Nx5+OBzW3bt3bXTwkydPLPN0+zlCoZDNQIcJMz4+bh38MGqgpW9uburrr782eNXn89meuVAcxc9ms2k9Mzh6uvElWaZHX1av1zPIkM5s4DSX6calPzg4sHHIgzoXeqgODg6Uy+WMZk8P2vLysgUi7FG327VssVQqGamEhfE5OzvT4eGhPB6PHjx4oM8//9yo/bQM0NSIAObk5KQ6nY52d3eVzWYtmMOA8z4UpsnAMbr0b7GHbsOzO8aDQMjNKv67/+6/e+v9w+lTk3RrHzgupH4uLi5Mzv6jjz7S2tqaHj16pG+++cagU9hstDpQryTjaTabSiQSOj8/1+7urur1upLJpGWgOzs7VpKYm5tTLpczzUZsM+en2+3aNFxsM6xRlpu5cJ4pXXDnETO9yXrrPheaFZE1cPsZ6OqVZNAEGCAez+Xw8zuRHxcMTJdimasKiudFQBDGCVEDmyGpr5DMJlIccwtuRERuNOEaHDe9HLSgCpRC9jU6Omq0ZKJJCuREWm6hze/3m0iedDUPgsiD7wcuzmXjO0jqyyiJuogWiaYRr5NkxAG3UMsB5HlR4Kd2QNDAhWNdXFyY2vAgiwiMz+D1Xumdge9Dk3RhRUgKLsmA/eX78po4cf4N55vCMcy769GeqwNGpkMG7O4ZCyIKP8OfEbHDKPN4PNYhDfX7XWou7nRMnCTBWrVa1enpqdVS+F7svVssdg0OjhUHwJ4jQUQ2Q03JJYG49xBo0M0yKJ5jSwhUXLUI9ofv5DaaEkTixN91YZsIPl1CE1ks8L1LYGLRnM1ZYB94ppwJvsMP2Ru3n88lRQC7so9AwthGzrSbsXAX+G/3+XKfuXOD3Nu30hbzeDzmHZEwJ6LLZrPa3NzUy5cvFQ6HTVWYdM5t8EMYjQ3o9S671L1er7a2tqyrulQqKRAIKJ1OWz0EmIYMiWI1qrHdbrdP5JGagsv0ouAFVMb32NjYUDabVSKR6Iuq+A6NRmPgzAWDCylhfHzcmvRKpZJOT0+VTqd1cHBgxpzotdm8lDz/kz/5E0mXhnpra8scD5e02WzqN7/5jU5OThSNRk2NAONKnYxD7/F4jNpNnQSooV6vW/2LZ4chxpCjHhyNRk05FU0j5klwWdLptIrF4sDOeW5uzmoDfOdUKqVer6ff/va31lUMnZOAAZVtGgAxgGRWMLZoCMxkMioWi4pGo1pZWekjDjx69EiPHz/W8PCwksmkUdWnp6clyQzCzs6OFVERC8Xx0StB1gNUKsmgllgspvv378vr9erFixdGx/2PsdD+YwvKvSvHA2T99ddfS5INMSMLHhsbs4jfpb3Oz88rHA5bw+TQ0JDm5uYMTkS6BGh7cXHRVBEIbFyHm0qlrDeEGg1ZwOjoqGq1mo6Pj9Xr9foaPBll7DKpIEB8/PHHkqSvv/5ah4eHJn806B1+/vy5/H6/Hj58aI2PZAEMPOv1epY1EOBB74W4hDNkgBdBOHJOrggnZwrCDkQqbBhEE+b/RKNRC2J9Pp+NQy4Wi9rc3FSj0bB7XKlUVCwWDZ3hbgPlQThxm7DfZt3YufBl2Rhk430+nx0YjKTbXMnFgjbLRSUlc18XXI/ID7wZqIDCHH0fvV7PNtXNSDDKLj7sRl4uFg83nOiUCAemkHSlCupGCm+7XAo12mXMoC+Xy6pUKmZc+LxEvRhCajVuTclNfdvtS5mbnZ0dKzC7DBK3QQsHxkGj6CzJsFswXmANl6JLtEbECn7vwgPsF3075XJ54D4NV/jTzUz4zvv7+zYnx31OZMM08JKJ8LndqLHX61lzLWoKiB+yZ/l83gwe+87P8HMYY3dPXforxs0lZ7C3wCzI8fMdkQd5l0XtyKWWktmivIGCAPXQ4eFhg4HIdIC1IQPQ80MmCVuMAJF5PhgqXg9n6TYWN5tNy5Tc50UthYidu4HR4xwT/ft8Pmu0ps7lUm8HWbVazerOLovSpZ8TPPN5cByuXBAKGcjeuOxDfufzYtOwldS33IAFyjjBjEuKgLbtslCxl2SDnAf2lHsGWwyH7VKfb7Ju7FzwiJOTk0b5dQ88shrgoTCLcAZE6u12W0+ePFEul1MikTD5ERRH6XSORCJaWlpSp9Mx48GBHxoaMlkJ8MhMJqODgwOLCFutlvWscAhJ9WB1FItFq/kAAVDgxHmNjIxoYmLCsqFBC/rZbNaYJjiJ3d1dywIw/i4TSrqEsorFosbHxzU7O9tH3STb4NISsSMvAxXy9PTUIpLV1VVr/rq4uNDe3p6azaYJ6RHRks1weXH06+vrWlhY0Pfff28YrqvphoEhTQcmmp6e1p07dwa+2NPT0/J6vZqamjLGyrfffmv7hqAesA57Ojo6qpmZGau/QaNuNpt9agaoFKDiDIRBVs3+fvbZZ6Yp5fV6baCaJDNyyWRS0Wi0T/6FAGFqakozMzPa39/X6empnU2/3299RbFYzEgU+XzeZm68iyq3JH355ZeS1AdfQSBALgj1jU6no83NzT4oFZVpGERE2KgEg8e7kNby8rJR0smIXOl/oC2MGsa2XC4bmw0E5NWrV/J4LsVckXcBkqfOitHkPbk/1WpV6XTassVB1vr6eh+VGxvS6/X6xmW4tRgyGLIrAj4oxy5kjWoBwWMqlTLqO85leXlZDx48UK1W097engUEhUJB0WjUAizILul02prbc7mcpEtaPKQbbAOze4Bqcfg+n8/U6N1a4E3WjS0lRmx5eVnLy8s6PT3V69evTa5haGhIk5OTmpycNLYTUcrFxYX8/kshQJgWe3t78nq9RnGm2/rw8NBw55WVFZ2dnen169dKp9MmYT46OmrOaGNjw3BwSUbPbbfbmpiYMCPAxiDpgmRMIBAwgTvpCragdoECMZHVoLAOVFpE72CzkGlx4aFdSleOpVarGTWbIjyfDdZYpVKxy4VED9TYo6MjVatVLS0taX5+3gxiq9XS0dGRCoWCYrGYyuWyMc9ogqWIn8vlFAgEtLCwoI8++sgYRZKMjglDhWgJ+OXi4kIrKyv65JNPBoYkGLnLGTg5OdHz58/V6XTssoB7t1qXUjfdbtdUalOplEn+E63RC1T6/2arw3YslUoaGrpU9qbXqVKp6MMPP9SHH35oWVqz2dTm5mbfILNYLKa5uTklEgnt7e0pm8321SgSiYQWFhYMnqQGIsmgTNhs1DAhEryr5P4HH3xg52ZoaEiHh4f67rvv1O12FY1GzZlCNmAoHcylubk5GxSIhA53uF6vm8IDDY6JREKzs7O6uLjQ48ePlc/nrceIoIDCMZR6Ai+cOZ8LexMIBPQnf/InNoY5GAz2ZdnAdpJsQCC1n1qtpmw2O/D+LS4uSrq8E6AMbtHblbDBueA06vW6JicnNT8/b7YI50Igzp4eHBwon89rbW3NlDRwvLOzs1pfX7cO/FKpZCobwPxjY2OKRCKSZL1cBAlkVslk0iBvAlwo4dT+CLhPTk705s0by2Rvum7sXNyiZqFQUKFQMOkA4AM2AAPsprZw/Dl8UBvpRyn9f/PhyTCAUkiTMRJTU1OWanIp3NSNWgqRkNt/4zZ7MX2Nh0+2AxwGpY+HAR3wXSJvPg80ZyI3Zl7ABCHypraAthmRh1sEdinHbgGPA8sMjkKhYBE3B6ndvtIKw7nhTJDLCYVCfUw8oA6f77KxC+gRx4SCciaTUadzOYwMxeHt7e2B949mUWia7KFLFXazUnSp2OdgMGjMLaAfolz2SZJl0uPj4zbaNxqN2sWUriRgut3LuSbJZNIiVijG7BcijJBgTk5OFAqFjH0JzNnr9WyKIJcbcUkM0qCd5azt7W15vV5rOqYnjWwYw8wv6lucDZiYCExGo1GbD99ut83AuuwnapVkKy5ERWQsXQ344r4Cb/FZcOgu+YZJirDsms2mqWz4fD5jkbKv/PygizPiwonAdECiZO1kOHxn+sqAstyBifyicXRyctJ6qqgR4RwKhYIJygLt8nNAh8C79BbC2iTYoyEW+wm6AxxHzYW9QobGhfBust4KFvN4PCqXyxbhoatDBOHidhgqNvvi4kIbGxuWpYTDYZ2fn5u3Bs8Fq+50OlYQwyiurKzo/v37KpVKevXqlWlpRaNROzgYP4zH6OioCWpiHKLRqKXU5XJZz58/V6VS0cTEhOLxuCqVitFm79y5o4mJCZO3HxT3/vDDDw1KIIXngDHCNBwOa2lpyaA+HDcGe2Njw16PeguXjdoLqXm73dbJyYkqlYq+/fZba7IaHx+3Gk+r1dL8/Lx1G5MiM3xpdXXV9JS47MfHx0Zf/eqrr1QsFvX111+rXC4buSKTyejp06eSpJ/85Cean5/X06dP9bd/+7dqt9v6H//H//Gt948eDxwp8+mpTzEK+s6dO1Y3gcFIoAGclslkrEZ4cnJibCxJNrIZAwrkgNEEIsRIQJqgONrr9QxCAMqiP8br9erJkyemgEDfyP7+vs7OzrS8vGzNhWSn8/Pzunfvno6OjrSzs/NOdZd//+//vbxer5aXlzU7O6tKpWI1NaCYcDiscDgsv9+vVCplGmlg/FtbW4pGo/rqq680PT2tWq1mWTmBXiwWs6Zk9OQgybhsplgsJknGoISm7E6shULPuGLsCiMBaCPgLMTjcU1NTZmOnsfjsWbpp0+fKpfLDeykCThxni58DdkHaIq6k8/nMygXBQmCnk6nY9I+tCkEg0EtLi7adwZ94Bm8evXK6n7A9R9//LHC4bC2trb06NEjQ284s5xbgisUqiFhALFDfUaFGnszMTGh2dlZIyfcdL0VFdmN2MDiidCup6R4QFIr6I4YCCiv7XbbGiyJYvD4wFv8GfRdV9nU5/NZdgHOT1c+hUCyFfjvpVLJKKcu3c+NRK6v/7+/u8ki+yBahNBAJOD2T/DfYPhkjBwO9peok8/FvwFucJV6eTZkNkRD/DlFeHdP3O5rnj9GmT3h2RLJ8d5usZJ/T0Q6yOISkylBPSWiI3NlP4iO2Rc+lyRT6ubssH6o0E0fAXPegQV4TZeaim6VSyIhmqdvCmgGGI2f/SHqKnULl3DyLrAYRXVXcZuom6gWQ08diKiWc8/3oz2A88rn5Zzwc66auttA6j4/4Orr353nwd7RFwISAYMUG0IB3JXdcQvjwLWDnkH2njPnEkf4ri60dJ2s4ZKZCADZO/cuEdjgcK8jFfyce2+5p5x57jHZIWiP1N/aQXDKc3HtADaepmDsxk3XWzVRuhvs9/v76is0RoG7T05O9uFz4HbAP6Ojo1aPoevb5/NZ9lAoFPTtt99KkkE3FLhgWxGxNJtNDQ8Pm64QlFoeNKOZu92uHj16pL/927+1NHBsbMykXarVqmU40FApevd6PaOcDrI4VBx0aj8cQrrenzx5IknGSEkmkxofH1etVjM6ai6Xs25kcF76Y/L5vEmfU8v5/PPPFQgEdOfOHd29e1f5fN7okTiLSCSixcVFy+ba7cvBaslk0vTb6vW6zTtxNc6mpqa0uLgoj8ejjY0NnZ+fWzpfLpd1cHCgkZERffrppwPXrBKJhDkxF8aSrpiG29vbpm3HOUQtOhAImIosCsDBYFBTU1NqtVqmNEuGwJS+oaEhkw0B/6eYyt5Vq1WNjY1pcXGxL+OGIh+JRDQ9Pa2Liwt9//33+sMf/mATMulfoiZEpA5phj4Nj+dyBPOg+yddjaKAycQ5a7VaVv/DqI+NjWlmZsZm9RAJAxv/+te/NjgNmwBUSQEbVicd6tPT05bdZrNZ/f73v7cCe6932VgI2QKHEY/HtbCwoEajYfXFTCajvb29PuiMWT0M0opGo0ZLLxQKpvD7Z3/2ZwM7aIgLNDmzT+12W+l02gghaItBFHLVPag3uWrv/D/qJmQzJycnpmoBVDY5OdlHiADWh32GMsLR0ZHq9bqxLFnUs6hH0eeC44AKThe/JAt+yKZuum7sXK7jjV7vZddzo9FQNptVqVSyYhz4IfAJ7Kt8Pm+ZBRjudbrx1NSUwuGw9X2QLlInofDM5yAKY/wsheV2u61sNqvT01O7+I1GQ7/97W/1/fff20VJJpNaX19XIpGwwUiwrbxer46Pj22GOtDgIMuNTIAFyGbI+trttokmcqnHxsaM7EDWQ1bCL0l9NFgyRIrW6BItLS0Z6yr2/81or1Qq9uxisZh9Tmou/OKSYIRhqcRiMS0tLWl8fFy5XE6FQkG9Xs8K2FCQYfgNun/QLSWZ8WE/iciKxaJyuZyCwaAWFhasxkYESTTGOGlJFogAn5XLZZVKJY2MjKherysSiZh2GhRk6apXiuCI3iU3sqcGRc2wVqvpN7/5jd68eaNkMmmUfpQG+I44NsgbGPC3udg/tKBeu3RcomiaZckKUS/AQRNIIFzLoDXIIzwXSVZc5yzyncbHxzU1NaWpqSkLtnhPng80WwzbyMiIyfCDcGQyGTPgZEPsH7YFu4HjLBaLmpub09LS0sCkEmpQCGHSbyPJ4G4yZUYIoO7RbDZt9pJLgXezb6AynEa9Xtfh4aHJYgUCAU1OTmp6etqcEQ4N6BZyBc/jOgTIntMvSDYbi8WMZIBNxZaD2tAXdePzdtMfdCNFDgueGYfganO5hS5JphHW6/VsNKz7ZWkook8BLw+1Mx6PK5fLWZPg5uam6vW6QQaFQkH7+/vy+XzW8EfBjNoLTCpYQ6TSrtor0y4Z2pTL5WxjifwGWTjRSqWi09PTPpohFxhDjzEKBAJWP2KoV7vdtn0PBAIW+UG/5DvB7IBs4fP5dHx8bDPfeV1JhvNvbGyYw41Go2o2Lwep4USAGymiQ5Lgdain8d+SzGi4kOkgC54+Rgn2oQt5FgoFy1z45ToBDB3T/5DRILi5uLiwbAP5E+o7FEtd0VX+LZkPDWrULaRLo+MaGphiU1NTfVk4BedSqaRUKmU6aBRVgSveZV3PXKhjuJ3uROVAV9QSiIDd3h6yLFdd2+PxGNMQrT+fz2eMJephR0dHOjw8NDKNy8YkuPJ4LgcEptPpvgifIAEIiL9z+7f4M9QCQAbehRSB4wAuJJNgP1BJ5ply/jDisAIhKwGTEzRKsho1AbYrg+P3+5VOp7W/v2/nm1YN2Jto2jEBeHR01J4BytygHQQ/7mfinmHjqaG78lg3XTe+7RgQNoEDx+VuNps6OTnR4eGh0Qy5eGC5k5OTfdkJjVh02iJIyAbE43ETzhsfH9fR0ZG+/fZblUolbW9vq9lsmtGrVqvWt7K4uGivDbQRDAbVbreNBUSEAK3y4uLClJUTiYRmZmbU6VzO3wa6AvMdZLEnhUJB6XRa4XBYs7OzRla4uLgwQ+73+w1zPTk5MRFLMpyZmRmjYNIPQO2ArBHnT53A6/Vqf39f+/v7lw/eab4cGRlRuVzW7u6uYrGY5ufnNTk5ac+TwMCN+HAuGKZqtarJyUmjDMN6gpJOxPYuDWzS1ZC58fFxLS0t2YXy+y9HZANXEKFTGIZAMTIyoocPHyqVSvUZAFhNi4uLSiaTOjw8VDabtcbJTudyqB36bnxPMknoptFoVD/5yU+USCQsc6bvQJJu374tr/dyOuKtW7eMKg7cWSwW7exDF5aulL/fpeZCZk8tMhwOG9QLQ3Bvb8+Us93gDNYbbCSMINRz93W5k+l02uD0vb0909Jj1v3Ozo7Oz8/tjEKh5b6iKrGzs9NX/6Ez3u/3G2RD9sMZcbUMIQ2RGQy6cC4Ef+Pj45qbm9PQ0JD1oFWrVZXLZXtO1IdcjT6CErIT+oXIbOg3om8LB+Dz+bS5uamNjQ2NjY2ZyjGKCJQlOD+gITjiZDJpvYEgEyihn5yc2GejP4wRA9geaus3XTd2Lq7Hul7IxZi4qfYP/VuXduf+O7dzltfgv/lz0jPSdteBuUVJt9Dtfk7387qRrfug3fd1P8uPsa6TBtyCvlv4c5e7n27Rnu/h/t0PrevfgX1xsxz387Gn1zFaPqv7etcL5j/0jH/MxffmvdgDzs8P7R//7oe+y/XiuHtW+Dv3u7l0U86WG8lfJ3y4z4fXdbNliBV8Hpb72tfP349xJlS9AyIAAIGTSURBVN1/f53GTobuFq6v34sf+izX76m7vz9UxAbZ4P7yd9cL+tfpvuznD0XP15+z++fX//9d6lbuHv7Q971+T37o81z/3f1MP2R7rn83Fx1y7Zd7Xl0bwWI/3e/xQ+91/bP80Oe80T713nWn36/36/9t782a2z6z/P4vdpAgFgIE950iJVG2bLnb9nRPd6enMpPqdFIzlaSSq9zkHeQV5CZvIZepyhuYVFJJpTPpVHU6M7bH46VtS7IkStxXkAAIAsRGrP8LzufwAdvzHwpy7vhUqdwtkVie3/Oc5Xu+53tu1+26Xbfr2vp+w8vbdbtu1+26XbdLt87ldt2u23W7btf/g3XrXG7X7bpdt+t2fe/r1rncrtt1u27X7fre161zuV2363bdrtv1va9b53K7btftul2363tft87ldt2u23W7btf3vm6dy+26Xbfrdt2u733dOpfbdbtu1+26Xd/7unUut+t23a7bdbu+93XrXG7X7bpdt+t2fe/r1rncrtt1u27X7fre161zuV2363bdrtv1va8bS+7/p//0n9RoNPSrX/1KH330kRKJhObm5myeRiAQsGmN7nCZkZERxWIxVatVFYtFlctlPXnyRPl8XsvLy7p3717PICmmtEUiEQ0PD6ter2ttbU3FYlFjY2M9o5XdefOzs7N68OCBTk9P9ed//ufa29vTe++9p7fffluHh4f6+OOPdXFxoTt37mhkZMTmKDCrhGE/lUrFJLSlqyFfiUTChkv9u3/37157o3/961+r0Wjo17/+tf7mb/5GZ2dnOjg40MDAgH7xi19oaWnJpNiR1fZ6vVpeXtb09LQNC2N4EsOHWq2WzQthfgPDvPgZRpYyppd5FF6v16Y6MryqWq3qq6++UqFQ0MTEhMbGxrS3t6e//Mu/VKvV0k9/+lMtLS1pc3NT3377rT0Dr9erubk5TU5O6vj4WI8fP1az2bTZ6XNzc1pZWZHP59O/+Tf/5rX378/+7M9+73kwWpkx2wzyikajWl5etvk7Xq9XJycnevnyper1uu3LW2+9pYcPHyqfz+uLL75QpVLR1NSUUqmUksmkpqen1W63lclkVKvVbAZRpVKxUc+clXQ6bYPAPvroI2WzWX344Yd69OiRjo+P9cUXX6jT6ejHP/6x5ufn9eLFC33++eeSZLM78vm8zSCpVqs2e8Tr9eof/aN/pH/1r/6VDUnrZ/3H//gf1e12lc/nVSwWTUKdIWH1et0G5YXD4Z57Ua1WlUqlNDc3p0ajoS+//FLHx8caHBy0WUns6/n5uer1us0W8vv9ikQiCgQCisViikajOj8/19bWlk2i7HQ6unPnjt577z1dXFzo2bNnOjs7UyKRUDwet8mtkmzMNfL27XbbBrjt7u4qk8koEokonU7L7/fbVMVHjx7pJz/5ifx+vx49evTa+/cf/sN/ULvd1vb2tg4PD20gWTAY1OzsrOLxuI0UCIfDmpyclN/v19bWljKZjA3j4ve63a4WFha0srKiarWq/f19NZtNjY2NKZFIKJfLaWdnx86Bx+PR5OSkJiYm7A632209ffpU+/v7WlhY0Ntvv61Wq6XNzU2Vy2Ubfsj0WGbx+P1+ZTIZbW9v2/1l3DFzcpiZMzs7q0QioYcPH+rDDz+0WV5/37qxc2F87erqqqamptRsNm00LAa+UqmoVqspGAyasTs5OdH29nbPDIR79+7ZsCLGZvIFBwcHbYgTY3yLxaIKhYIk2UAbSXYxOp2OTk5O5PF4bMTn0NCQisWi1tbWVKlUNDg4aBPe2BjmdDMOlJG1g4ODNrqVMcfuA+5nffLJJ+p2u/L5fHr48KG9Ft9hY2PDJtjx3fx+v81VPzo60rNnz9TpdDQ8PKyBgQH7WWY6MPGR6Y84llwuZ4OSAoGAKpWKstms2u22TeirVCr2eolEwsbH5vN51Wo1m+keCARsQmGlUlEoFNKdO3c0NDSkcrms7e1t+Xw+vf3222q329rf31c+n7epeP3OeXn//fclXQ7NCgQCqlarOj09tbHZkUjEpiLWajVtbGyo0WjY33e7XY2MjEi6CmAGBweVz+dVr9c1NjZmUz5x0rw+42RxbIyIvbi40Pn5uWq1mo6OjnRwcKBut2uGpVAo6NNPP7X5436/3wZEuVMRG41GzwTGVqtl0wIZwFWv1/XNN9/I5/P17VzW19ctCFhdXbUpic1mU7lczu5bNptVIBBQvV6Xz+czZxSLxeyetVotxWIxO4dMiJRkA6s4m0yUJJCpVCqqVqvmJBhEFQgEbLZMu93W0NCQBa7VatUG9zHSPJPJaHd31wymz+ez8+jz+RQIBNRqtVQqlVStVnVycqK9vT35fL6+nMvXX38tr9erpaUl/eAHP1Aul9PLly/tmTMGOBgMqtVqaW9vT/V6XZubmzo8PLT7HQ6HdefOHSUSCUWjUYVCIQt66vW6wuGwut2uSqWSOQTuTi6XUz6fVyQS0cTEhDwejwqFgorFojKZjAWNTATFFpyfn2tvb0+NRsP2igFqHo9HwWBQHo/HAisGhDEtkwFo2N9/+k//6d+7Xzd2LqVSSV6vV4uLi0qn0zo+PtbTp097ImQu3NDQkMbHxxUKhWz6IWNBI5GI7t27p2QyqYuLCxv3yYxsJrExg5tDiIGv1+sKBoM2BZPo/fT0VOfn5zYSdGBgQOVy2cZ2Mss8EomYx+e93WFjFxcX5oTIIM7PzyXp9wZMvc56/PixfD6fZmZmtLy8rKGhIY2NjalWq+k3v/mNdnZ2bAY40bDf71ehUNDg4KD29/f1zTffyOv16oc//KHi8bgdIjJFjD9jbJlCVygUVC6XzWkyf7vRaKhYLKpSqdiEy1AoZGN5T09PLZJmCqLP57PXJZCYnZ1VKpXSkydPdHh4qPHxcd27d0/dbldHR0cqFot2qfp1Lqurq/J4PIrFYopEItre3tbx8bEajYaGh4ftu42MjOjo6Ei/+93vlM/nNTw8bJP9pqamFAqFbF742dmZzs7OJEnJZPL3hnaVy2U1m02VSiW7hH6/32bKY7AKhYJCoZBloktLS4pEIjo5OdHW1pYikYjGx8cViURskiIBjTutlZHXDO2SLqeEMpHx1atXN77Y37V2d3cVDAb18OFDPXz4UBcXFzo7O1Oj0VA0GrXgYG9vz8YcezweZTIZM2j5fF6hUMimyQYCATNM1WrVDG0wGOwZ2sddw2ExRrrZbKpcLpuDbTabCofDmpiYsBHm7kRKHHUkEtHp6amePHkij8ej4eFhhcNhLS8v2+jmer1uNoZJtcfHxz0TVV9nra2tKRQK6YMPPtBPf/pTbW5uWsZHEDA4OKhkMqlCoaC1tTUVCgVzLrFYTGNjYwqFQpqZmdHs7KzZHI/HY9NdBwYGLFDm33DYp6enKhQKisViFrAwKjqfz5sDS6VSGhgYsPtaLpe1v7+ver1u9gFb5vf77e/i8XhP8lCv17W9vW0jq8vlsrxe7/frXIBpSHEjkYil80Q/fLFAIGDjdyORiBYXF9VoNCyzyefzajQaPYbQjcI5GBi2dDqteDyuer1uM6WBJGKxmGKxmP1dp9Oxsann5+c6Pz9XOBy2DABPjOOSZAdjdHRUs7Oz6na7ZgBwVkRC/S6Mx/DwsB2qbDZrn2FoaEiRSETRaNRgLRcWcWefMzUyEAjY54rFYpJko48xnIx2TiQSGhoassvOazKpr1Kp6OTkxC4zERHGl787OztTrVazYEOS/czg4KCWlpY0ODhomRMz5T0ejznpflY2m7Xzx1jjaDRqGUClUlG321Wj0VCpVFIsFrNzRRS+u7urQCCgdDqtgYEBc8bS72ekrVbLjD7ZtCQVi0XLphuNhsLhsI3v9vl85gzcaZzs8cXFhY6Pj1UsFnV6etozCVK6yso4n26wgJN7kzU+Pm5nheDr6OhI1WrVMlSfz6f5+XkbD83cd/aJ+8D4au5fIBDQzMyMJFmmQMBG5C2pB8qNxWJ2ToCTOPelUkmNRsOCmFKpZM+6WCwa3IUBJXAdHR3VxMSEKpWKMplMz/fnbPTrXCKRiNkK4Gema1arVdVqNcswCIAZyQ3EBJpQrVbNefC9xsbGNDw8LJ/PZ3s2Pj4uj8djjpz7HgwGbeQwTo3Xl67GVhMQM0Jeupoqib12p6/W63UVi0UL5NvttsLhsOLxuHw+nyFDN1k3di61Ws1maadSKUlSpVJRqVRSNptVvV5XKpXS+Pi4arWa9vb21Gq19PDhQy0sLGhnZ0efffaZpcLBYFCTk5Oanp62ug1ROF/w4OBAwWBQq6urisfjevLkiZ4+fWqOivR2YmJC2WxW+XzeZkUHg0G9ePFCR0dHSqfTWlpasvS9Vqvp/PxcZ2dn8vv9Vhe4f/++VldXtbOzo48//ljFYtFSQ1LefjOXVqslr9ermZkZffDBB1pbW9P/+l//yx5WOp1WIpFQMplUpVLRzs6OHRSfz2d7JMkyPWo00WhUc3Nz8nq9+uyzz7S3t2c1HWbGJ5NJlctllctltdttO6S8Vj6f19rammGuOJdCoaDh4WEtLCzI5/Npb29PxWJRkuyw7u7uKpfL6d69e/rhD3+oQqGgjY0NVatVmzdfrVZ/77K/zlpbW7PPHI/HFQwGLfM7Ojqy79VqteT3+zU1NSWfz6dyuax6vW5ZhCTNzs4qFotpYmJCU1NTtgfuUNaLiwuVSiUFAgGLovf29rS/v2/QkSQtLCxodHRUjUbDokIcGqOXidwbjYZFj6FQyKAU1sDAgGKxmMFUOLbBwUFVKhWDhvtdq6urtjexWEwHBwf65ptvrBbaaDR07949PXr0SGdnZ/r8889Vq9UkXQVgGENqNtzfkZERvfvuuxoYGNDW1pZOTk7UaDQseALyImABocCJX1xcqNVqqVAoGCwZDAbtT6lUMvTi6OjIHBhB48TEhIaGhrSysmJ11nw+b+9PJnB0dNR39kwNx81eee4YZJzA4OCgBTEej0eJREKlUknHx8eSZFBxrVYzp7S6uiqfz6f9/X2dnp5aJo7d9fl8Ojs7M7SBufc+n0+pVEqdTkfVatVGvVPHltQDM+KoQ6GQRkZGLJh2nTp7RDaTSqVULBaVzWZvPOr4xs6lXq/3FIwlGb4vyaAlDgpRP3UNv9+voaEhqwtI+r252mDLjUajJ3rj94lMeU0iWSLFZrPZM//5emG+3W7b7/D37rxy9+cpEHKpSPP7dS58zmAwqHA4rFAo9Huz5t3Z6vwbsAmYvDvXmr1rNpsWpbjzuvk+AwMDikQiBj2CTRNpA8XxnXl9Ikw3bWaf3OfNZ8Dwc1AxjsFgUJ1OR6VSqe/55VwaImd3tjqfj8/jPk++i7uv7J37WXg9Xt/NWl04EOiX/XX3j7/jmUmyfePO8Mw4h9IV9BUMBn/PKfHZ+G5vMpWc8wsUw2eUZPf6u84P++sufp6aCfUW6oi8FveJs83+uJk4tTL2xt0/9/fZm+vw9PVZ8ETm1IL5e4KIfp0LWSTIAZ+V73k9kOBzA+O5712v13V+fq5ms2kojmvLeE2QBO4+58Y9H+4Z45zxDNzXBLEAnnazdndv3fvt9Xo1NDSkcDisSqXSY///vnVj57K9vS2/36/R0VENDQ0ZhirJUr2DgwPt7u5KuoJy9vb2VC6XFY/H9fOf/1ySVCgUzACdnp7aweh0Ojo+PjYcmPrHzs6OSqWSjo6OlM/nNTQ0pMXFRWOUYVRJowuFgtVX7ty5o263q729PQWDQT148EATExM6PDy0A0ykeXR0pIuLCx0eHiqTyajb7erhw4caGxvT/v6+MSv6WWNjYxbVttttxeNxvffeeyqVStra2jJMkxQ5EokY3LO3t6fz83NFo1H5/X4z2ECHXq9XBwcHdigmJyctCyKqjEQidpBdiG9kZMSi9FwuZ9Fmu93W6uqqlpeX7Xl2Oh2trKyo3W5ra2tLT58+VSgUUjKZNPgLJh7khQcPHmh4eFjffvttT03sdRd4MsFJrVYzDH5ubk7xeFyZTEb7+/tqt9vK5/N2QbrdrsbGxvTgwQPDttvttgYGBiwzxZnk83nDlbmIMJ9yuZy2trY0ODho2czIyIgRU9hfakGRSETT09NmSLrdruLxuNLptE5PT7W/v6+hoSFNTU3ZOSYIGx0dNejTDSDexLl8+eWXFiDC6FpZWbG9pDD81VdfqdPpWM3DrRHhlNxaJ5F7NBrVwMCA1tfXjbHlwjzAvUDVRNKTk5OKxWI6Pz9XLpfrIeqMjo5qcnJS9Xpd0WhUkhSLxRQOh40sQtG+1WrZmSgWi1Yrk2TBYa1W6ztABGoF3jw7O1O73VYwGNTU1JSi0agqlYqeP3/eU0ujjOD3+1Uul9XpdLS/v69sNmv/xhmnviRdBSLtdtuyNuC0ZrOpUChk8BtZMEE2pQeycwr6rVZLk5OTlg3ynuPj4xb0BoNBFYtF7e7uyuv1anp62tAHzsFN1o2dCxBSsVhUsVg0jy3JIj5gF7/fb0VToKVIJKL5+Xl5vV7t7+8bLAXjDK+byWSUy+V6ImSYCjBzqPdQ1HIjbTfFg2YMthwIBCwVLJfLCgaDkq4cIRBKLpdTpVKx319YWFCpVLKH2s/icMGECQaDGh0d1cDAgA4PD3v2EfYLmDVRKxEurwPzxo3Yx8bGDDYi6xgYGLBDw98RbQ8NDdlzPD4+tgIrLCyop6VSSZ1Ox6KkTCZj7+1GohRzO52OPB6P0um0Jicnlclk3qhmRa2N6LvZbBo045IjgGir1apluD6fzwINSfbZqe+52DnwE9R6DDtZC5j94OCg1S6o5fH9MKDU0LxerwqFgjqdjhnVs7MznZ+fW/YIgQSGGMEAEacbife7MpmMBYiwlJLJpNX/gHrOz88VDAYVj8fNaFH3cTN9viu04Fwup1AopGw2q2w2a4wyN8rG6BIp40w5M4VCwZ4He4EzkWTPOxQK6eTkxH6OrODs7EzBYFC1Wq0n+yRj4Ez0s9x6C7aCbGB4eFipVEq7u7vK5/NW03AZsLVaTeFwuOc+AeED1+P8+a4Ycs4/mbObFUYiEWOG+f1+I2pIUjQa1fj4uILBoLLZrBFgYrGYQYx8RvY1EAjY/pHVYL/c7OjvWzd2LhR+jo+PzZj4fD4ztvF4XCMjIxZd4jkHBwfl8/ksI2i1Wnr27JlyuZxSqZRhfkSYYIf0dUgy6mI4HDbcGJoeRgEsUpKlmfDF2SzSPjKCk5OTHoNJagozyOPxKJfLKRgMqlKpWA9PP2t/f18+n0+ff/65jo6OrG7UaDR0enpqKbZ0laZyULg4kUjEsON6va6hoSGl02mVy2Wr0WCs2AcojdVqVQMDA1pYWDAjzOUDboxGo/a7cPWBAHAkpOkwXqTLTLRSqWh4eFitVksHBwdaX1+3cwKGPDU11bdxhB1IjaVYLPYY87OzM7vw7BkO2eu97OfJ5XLWA3B+fq54PK5EItHDmpmamtLk5KQkmeEgckwmk3r77bd7ngGRIvfh/Pxc+XzeGD3pdFqSbF9xOBA4IL90u10Vi0Wdn59bkAHEhEEdHh7ua+9Y77//vp2to6Mj+/tms6nDw0OVy2WD+YCAuA9u5gS2X6lUrG8FgkS32zVHGQ6HzT5QDKde2+12DfZ2e7ZoTYAuK8nIQYODg7ZPRPfLy8vmXIBesSX8HVASTrxfWAw4E9o2pQKv12uwbbPZtNqo61ww2m4JgMAvHo+b4fZ4PEomkxobG7MAGxvXaDSUSCSsBndwcGBITbFYtPrU9WAhFApZPQ/kgvtNhry5ualOp6NkMqlEImEM01arpc8++0yPHz82AsL3XnPh8AB9BYNBcxw+n0+JRELj4+Oanp5WLpfTRx99ZBEwMMbu7q6q1aoZ2B/96Ee6d++eNUJR8E6lUjo6OtLa2ppKpZJevnyps7MzLS0taWFhQcViUa9evbJovdPp6OzszA4WHnx0dFQjIyMGbVC7ARY4OTnpoSOTFRBNeb1eHR8fW+PTm1zura0teb1eHR0d2cXhYBIdcrhwEPRU0KcTj8fV7XaNRpxOp3X//n3j7+NceFY4X4qNd+/e1Z07d3R8fKyNjQ1LtbmAiUTCnhewiKQeuigQYjgc1tLSksrlstbX142dcnR0pFwup1evXtlziUajmpiYMNJBPwujUKlUtL+/r1KpZPtH4ytQD3UAnKELZVxcXOjVq1c6PT21JmDqHX6/XzMzM0omk5Z9EChdXFwolUppenpa+XxeT58+NedC78Dg4KDK5bKOj491enqq8fHxHmo85Av3D30k5+fn2t3d1dHRkWKxmGZmZhQMBs2YQ+/vd/8k6ac//ana7ba+/fZbbW5uql6vG5zUbDbVbrftztC06PZiEbES/MHKgx7OZ+X/A5dLsmyMBrzz83Ntb28bAxQHTQROv5F0GbzQFNnpdLSzs6NMJqPJyUk9ePBAFxcX2tjYULlctiDTZUJhyEE8+t1D7EQmk7Gz5cJdQIagAjgXslsX4uTODwwMaHh42Go1rVZLU1NTFjTSawXkmkgktLCwoGw2a7bp7OzMCvQwNY+OjuwuUPOBLELGDiR5enqqb775xu7E5OSkZem1Wk2PHz9WqVTS2NiYZmZmbrx/N3Yu8XhckixdYuFViUSIxsERoQyCP5IW4wGBptz0FqMIjDUwMGBRzeDgoLHNpKsGwsHBQfPCQDJkTHx+KHmFQsEiDB46RgKcGwfg4vHXi8CvsyhC8ofDDlmA/z80NGSQD3tBsyJFz2q1ahChm+0A7wFj4GTIeHw+n0qlkjkKl87svgb9GERcAwMDRrF0DzrNV+Pj42o2m4pGo2ZggAw4A5J6yAKvu/g9DCIsIKJo8HTgglgsZnUfMmO3iM1euX+ox5ydnfVEvGDZbnEbw8/vUXwlOobCiXHBaLqUewIzMoRIJKJ4PG6sRBd2hqHW7/5Jsq5y1wDiOKj58UwJMDB6OAk+D/91M34+G/dbUk+B+Hp2TnMr9uH6HvNfjDDnH3jXLWLze8CyQE8QYfiu10kLr7MIFAhY3O9WLpclyTI/vhfZHPB2NBq1Jkts2sTEhC4uLnR0dGSBHNkFe8Uftz+P9yHrw176fJeKEa1Wy4KyQCCgRCJhr389w6dvLhQK2etxf3FOg4ODFnDcZN3YuTx48MAcCPS509NTXVxc6OTkRJVKRZVKxWou8/Pzki5x3tPT0x6GGJg4/G1gl1arpaOjI6O70c8wMzOjWq2myclJDQ8PW+qIk+l2u5qYmNDy8rKRBDB+x8fHisfjliFtbGxoY2NDnU5Hc3NzGhgY0OzsrMLhsHZ3d60wzsMEX6XBqV/nwkOhiEmzEtBiu91WOp3WxMSECoWCdnd3dXZ2ZukpvTrIv+zt7Wl0dFSrq6s9PUbUVoLBoNEiR0dHFQqFtLW1pW+++cbqXe12W6lUymR2qEOgrjAxMaGRkRENDg6agdvY2FAul7PLHIvF9IMf/EBDQ0Pa399XJpNRp9OxnhaK3pKMvtvv6na7ymazymQyZvgha7g49eDgoO7cuaNAIKCDgwPlcjn7N+CAeDxuUA0QkCTt7OyoXC5rZGRE8/Pz5jBwEuFwWJFIRKlUyoIoMOlUKqWhoSHdu3dPlUpFY2Nj1lSH9M3+/r6RMKh/UVOAUg7VFwjD4/Foa2vLSAr//t//+77278///M/l9/t1584d6+ciWPnd736nQqFgKAS1TvB7KMKhUMgMoyQ7Z3TSQzfO5XJKJBJGZOGMuwzSVCplQRtEDe48pBUyKZxTo9HoUVqglkWQODk5qXQ6rY2NDf3ud7/TxcWFlpaW7HkBnfezqJHNzc1ZLw0KD4eHh6pWq7p3754WFxdVq9W0ublpdg1q9fLysi4uLgyNmZmZ0Z/8yZ8ok8noV7/6lUFcQFRQvalJQenvdruamZmxu396emp1wGAwqLfffluhUMh6sCCSNBoNffPNN8pmsyqVSmab33vvPYVCIe3v7xshRbp0LPPz85Z1uzDy37du7FyGhoasmMdF5OC7HdtAOPCzkY2haH89anAppS6bA+NFhMN/iRrdlLfb7VpxkgOMlAsRNMYdSAwYY3Bw0Dq8C4WCRZakfkRvpLP9Ohc+L8YMnr+LabuZlPueRD1uZIiDp6DK83AdIwaMqEOSUbxdOjkFaV4HlhBREBGhi2VjSLxer5LJpOLxuE5PTyVdZRlkaMABbvT7usuNPC8uLnpooWDLnAuYa6FQSMfHx/ZdXfiVbJXnDPxD5zgSQW6Gwf6yH7zOdboucBcEDJ61e1/c4jzZC9kmihQ8S+mqAbDfqFuSGRKyKncR/LnQsUvtdZuJqRm4mbJbtHdJEi4ZgZ8BWQiHw9aX5L4O/yWrHxgYMCfIntNjxV7yfCBMUK8kyuf5vgkVmf0AfuJO4vjq9XrP9+G7Y4cIItznGgqFFI/HrUGW8+2iP5w5+tKq1aoRTrBtZHr0TyGRg+ID+817uzabYv7Q0JCy2aydMZcwgL28fm7+/9aNnQuHi27cYDBolM3R0VFjbkmXhnRmZsZgHyLf4+Nj1et1DQ8PW5H9s88+s01x2Tt8eelKC4qHCVaIZg4PFeiNB0KKDMuN10IChcyLGgZ9HUS2kqwjnS73ftcHH3ygbrerXC7X02lNVMFhJDUmOkI6otls6uXLl+p0LkUbl5eXVSwW9Rd/8Rc9jrLValmBmINeq9UUCoVUKpUMI5ZksCSGBMOcSqUUCoV0cXGhnZ2dHkeVSCR6mFOdTke7u7saGhqyKG5gYEBvvfWWJBndl2y1X+NIvcs1PF6v1xok8/m8pqamTJYklUoZLApT0G3UxYCCz8NqGh0dNcFGVAiAZciUQqGQpqamenoKgHg8Ho9lM0NDQxocHFStVtM333xj7Jxisajj42Pt7e1Zs51L+eVzwIpzYd83WY8ePZLHc9nQRxDHfiBNEggEdHZ2poGBAd25c8dgH/TU0E8DwuP5Iv9E7W50dFSnp6d6+vSpIpGI/vAP/1Dj4+M6OTkxJQgK/zRqus4emEmS6WsRgNLtzrmUrqC6SqViemPvv/++wUXcr36p8JL03nvv2T3BYAPPzc3NmaP74osvTKzV5/Pp6dOnRrHmc1CYLxaL+uSTT3qklubm5pRMJm1v/P5L8chgMKj9/X0dHBwolUppaWnJshbYideh/pOTE52fn5siAhkp+82Zxi41Go0eCBebLMn0Ab/3zAXDTupFnwDLbSpCYiORSFgh/fT0VLu7u2q1WorH44pGo2o0Gnrx4oUikYimpqZ6KIRIPtBxT/2A6D+VSlnBEFaDmxmxcUSeHFa3mRPOOT0IGOOBgQFj+eB0XHikn3Xv3r0eZhtRDcYoFAoZnBAMBjUxMSFJ1pkMN56iZzwe1+HhodbW1pRMJvXOO+8YJu12DmOAiVgxkpKsJsGzpa5DhIVMCZAc8A+YOs7i5OTExO3g38/OzpphItN6kyZKAhUuEMaGZ18qlTQ9Pa1kMmnaaDw/9LCuQy/AseDkLv324uJC5XK5x1mwZ0TTRKVkcnw3nDQXHYMHxFSr1XRycqJsNmsMHiLfcrmsaDSqdDotn89ngROF6DepudCzRD8VdwPaObWLcrmsUCikyclJUyaATZbL5cyYslecBwglIyMjmpiYULlc1tbWltWRJiYmrHYEHAiMRnbOPXaza/ezSrLPyR93UeAOBoNaWVlRp9NRLpezu/4mmd+dO3csc8AhkrkSnOzu7urly5caHx/Xu+++q1gspo2NDXOQbr0Vtfhnz55ZSYHenuXlZWWzWW1vb0uSRkdHlUgk7NwMDAyYg4JCzB/qxezt/v6+nW2YbdJVVt7tdnV2dmZngfuQTCatBQRB3/8nmQveDgkKICIyA7wyG0fRGC2mdvtKGZZD46ayQAvT09OKRCI6Pj7W5uamJPXg4qSGHBIKzm4qDwR0fn6uUqlk8A5RGkYV+Afjh6Go1WoqFov22aBXvwmsc3h4aJRWNyWFy8/BI5qDJUJNCHabdKWMwGGBO39+fm4OlT2i4Nftdk08stvtGgWcgIDPw897vV5ls1kdHByYNhhOKRQKKZ1OG/sHGEi66jUCforH44bTv0nNigtBdIyTaDabmp6e1tDQkKanp81gQXuPRqN6++23e/pE3H4NIBZgNEgMZLBAHtfJCGRQRHl8L9h2fFa33wa1cHBxnBSwxnUolPdAfcAl0vSzjo6OeorafG9JRthweyZgODabTat7cP+B/IChJBk8RTTvqg7g0KhdkfmQpfn9lwKMQKsEca1Wy+RRIOVARXbJE3S7uzAc7xePxzU0NGSacP2ewVevXkm6UgBw2XDYl3g8rsXFRYXDYR0cHOjk5EQ+36Vem/u+BAo0QlML9Hov+2iQXkImhvEgEGjI5KnNAFVyDwlgqdlyviFquGQlPj/oBP+FuEBgRcB103Vj5wLTZGdnx5Rv33nnHYsk/X6/RYyNRkMnJye2cXRswyZyU30iUi75u+++q5WVFT158sQiYS4fF9HNTmgCBALx+/1KpVIGhR0dHVn/Bg6I7Mr15ESNsN2AyKanpy1LyOVyN24gur6ePn1qhAjeixqPx+MxEb50Oq1SqaRvv/1WtVpNi4uLWllZ0cbGhra3t+0QcsiWl5ctEj47O+sxgKTuZDDDw8OmDAzsBw3WVU0A5tjY2NDXX3+t0dFRMzwED5OTkxoZGVGz2dTJyYlqtZoZIjq2IROMjo4aJbrfyJHGNJpZo9GopqamNDAwoIcPH9pnCwQCKhQK+uqrr1Qul3X37l09evRIpVJJmUzGoB2UoDGONLQSLFEHARrEqQFr8DNjY2M984pg2kAmyeVyGhgYMJVaokyXQIFBgJkFlIlGFRA0fSH9rm+//VbSlRRSMpnU3NycZatQgGOxmM7OzvTpp5+qUqlofn5e8/PzxtQk0+HOp9PpHmadC52TvYEUcA6hp0NEOT8/1/7+vp0RgkgyOpSY+XsYTlNTUz0K6pwvCASBQMDmkaDu2+8d/u1vf2tkIjJjl/Hn8/k0OTmp+/fvq1Ao6Msvv1SlUtHy8rLef/99s0egPN1u18R1CdhAb/b29nRycqLd3V0TsASOvH//vjE6W62W5ubmNDc3Z9TlSqWizc1NE7ElUKaTHzYddVO3/kd24rIAqUlvbm7q4ODg+2+i5EAS9bgRHd7WbbrjMmCoeBBcJjw3r0c6DEVOuoqO3FSPiIbokKIgeCw1HjIOF35ycVfgMSI5oh48usvycAvU/S636E6BzCUeSLKHyT5JVx3N7nd1dYD4w/fj5/n/bi3FNZ5uMTkYDJqD4/XcJjb3tdxCLWk0DoULDbwhyZrv3P3uZ/HsXFyefaPPhM8IXEX/BJGsm20TkLjn2s3kiLj5/vzhs4Br8yx4X+BFHB3nj8VnkWTPgTvg9pFAY4Vs4X7Gfhd1IVeNl/tLxkuGCi0b2irP0WV98UzYFz6fWxMh+OTfpSs7wPdynSgGj/othBWCT3fPXFvk2pHrGR42h9d4E2iM7wEbtdVqyefz2f+HuMDPcQ/43HTa8zOufXJZYa7d5FzyHq5tAyKkJs2zJXCiB4zzyWtjm3lmPBtqft1uV+VyuaceSSZ60/27sXPB6I2PjysWi8nv95tyK5ozqBxXKhXDGTForlNA7qFYLOrk5MS4117vZQf22tqavF6vpqambNOBXySZF5ZkRezT01MdHh7K7/cb9TCbzWpzc7NH46hQKOj8/FyTk5NaXFxUtVrVixcvDGeGubG1tWXvg/N8E+PIgZqbm9P4+Lhp91Dz8fl8prCLJhX49ObmpoLBoO7fv28GngNH+ktfBzUGIvJIJKIHDx5YZzSZ2tramjqdTk9Rdm9vT0NDQ1pdXVU6nVY2m9XZ2ZlGR0c1NzenQCBglFhYONVqVS9fvrQpnu6ogm63q8PDQ5VKJY2Pj+v999/vu2aVTqfV7XY1PDysdrttzYqtVksbGxuSpJWVFd2/f9+kNCqVitbX13VycmLDxYhko9GostmsZdjMM8G50NHMxaeQCZ18enra4D4cGZdxdnbWfh6DQFZCduMaZDrJXUNFXYKGO5f52O/68MMP1W639fjxY62vr1uWR1CDEUomk5JkUDCTFHO5nDY3N+XxeDQ9PW2aagRiEDyGh4etqfL+/ftmDOlf83gu+812d3fl9/uVTCaVSqVUqVQsC2LuCTWGRCJh0XqtVjO1BYIboDKmZrKg44KSLC4u9r2H9+/fN6N7ffQHs42ox3CmqFGcnZ1pb29PX3zxhdGIgUeB9tECPDg4MNo58jDN5uXIBfYcqB5n3+l0tLW1pa+//loDAwP64Q9/qGQyqefPn+vVq1eKRCLWh/j111/r4ODAoEnOJk4DhGB/f1+hUEh/8id/ouXlZYVCId2/f//G+3Vj58LFIhIBfwMfhArKGFiYQ66wJJE1HhCsFPhMkg0KS6fTmp+f7zn4YNtupEUzJfUL2DAjIyNGSXS7dd3IKpVK2e/TfU79gwIXBpOIt9/F90frh2gBo8GFow6AU0NEc3R0VNPT0/L5fIYvX8exJdnnJevw+XxKJpMaHx+3g99ut42Z4g5Ggx0Fvp1IJGzMLNELWWkoFLKLXCgUTB2BP1LvwK3x8XGNjY1Zxvm6yyWP4FiJvpAPcfsmiBqp+SHOCbQ6PDxsg558Pp/Vm1xhRjdLcj83VOdgMGhd/G6GBjyM9phbB0DKiAyRaJZaDXcFKJNaCO/xJgvFADJgCvEYfN6HPeaMMowql8vp9PRUPp/PGIXuOQTS4nvRHkBmzOcn4odokkwm7bkAgafTaSMZuP1ELpMUkojbIItDvF574dlgTPtZTGNl+Jhbh3Uzf6A7N/sHFqTnCjl+fgYbxXesVqs91HpsBfvAXZSuZuScnZ3p8PDQJFympqZ0fHxsZQv2J5vNan9/356Nm1Fxd3K5nDY2NhQOh3V6emryWwT4N1k3vumk1OgfAQ3E43H96Ec/UjKZtEMYDAY1MzOjRqNhA3A4zHz4ev1y/gtd9WhXsZnn5+f6+uuvFQgElEwmLU1202kawkZHR41aXK/Xtb6+bsKAQGQccGCM8/Nzra2tGVRCtyub7M7aAIpyDdzrLmpLdENXq1WDVmBn+f1+7e3tWb9Pu902ei2ZCBfeZdcMDg5asxUFPPajXC7r888/N+kHDAoNc0hqBINBJZNJRSIRVSoVIxS4EJ6kntdAUZjmQbcPh0vPgWV403V2z00XRpfaEvsDsw4neXh4qFqtplQqZRIrAwMD1vRLNnV0dCSPx6OJiQk7H24fxtnZmWUPXEKXCktgQ7SP4USKxO/3a2dnR/l83hpJKXZf3z+CHv4AaXD2XJmeN8lcIJNA7sBIBQIBY2RyBikgx2Ixm+ZZrVYt8ue8joyM2DAsjCAZNAY4EAjYJE4cNpma3++3YYDA0I1Gw0Yy49Di8bjBkPPz85qYmLAglXpftVpVOp1WIBCwzLbbvWy8LZfLFqn3C2+TYRJcXIe9sIkYcvYiEokY84p+MUhGkEdAD9rttsbHxzUyMmKji90ps+yrdBWwEsTEYjHdvXvXXgvkARq52ziNgjlSLy9evDA6M8QWAvJisainT59qfn5ed+/evTH68FrClUQBjN5FePJP//RP9fDhQ33++ef6q7/6KzPM3W7X5JrdaXIMXJqbm9PCwoJlE+12W9ls1jaV4VXz8/OKRqOWbl5cXM1vj8fjmpiYMGHCYDColy9f2uvQ/+E6l2DwUm66UChYo9bg4GCPmu515+KyVfpZNEQhVEmREg57PB5XLpfTzs7O5YPxX2qcLSwsaGxszA4V+wQ5gfR7cXFRg4ODNunw8PDQHFU2m+0x6lyCcDis2dnZHufi9/ttgFmr1bLD5rLKqLFwqRkRDGYObNFoXMrPo0P1JoOa+PxEVLDkIpGIVlZWND4+rkwmYyN6yUpTqZRisZjK5bKy2azOz8/11VdfKZfLaWVlRffu3bO9xnDDimJY3fLyco9zPj8/t2mIqVTKZnVIsu5raMfFYtFk+emfcp0XrC0MMkaajIc7w3N7k+WKOqI2QH1tbGxMIyMjOjw8NBFUsrDZ2VkbqsZdzeVy5sTpyXAHndH9fXBwYI3CZHs4ampls7OzPfWcarVqumNAOWQ30WhUy8vLRiYhI0USaWpqSmNjY6YUUS6XjXDCGO9+95HngHNxF3uD0+X/Q1xKp9MaGxvT22+/rUajod3dXRtGR8aKc0Fb7OXLl9re3rb6mNfrtZHhBDk+n09LS0tGNUaJpF6v21gA0AwCyvv375sDm5ycVD6f187OjorFoilNdDodTU9Pq9FoaG9vTzs7O4pEInr06NGN0YcbOxcYX7AaKAwGApcKq8PDw8ZK4LICv8B8IRoje2CuMx5cknl3uNYuC4VGSzfiuri4UD6f75kaSdMgUYZ0VfwlUyGVhP3EBaBewILZxerXuQC/+Hw+E5fjdYmsoWzz+ciwYMiB/18v5vMsiG5dFQPozHRWk4XREAVZguiKFN0t4EkyEVLqD0Spknqi/kajYUaS94pEInbp+t0/mveoE0lXvUw4O4/HY1RkomP21M0+iSLJkCko89nYA74nxgiHLF0Vr93sjP0HwmX/yFi59GTqboGW/eM70vOAICh36k0Wk0Cj0aju3btn0BK1PT5bMpm098QR0fHOOYPKz7kCjaBu5LKZ3HYDis9AfxAt+DkyYJeSzP4QzCCfAyzlkoeAbC8uLnpUPMigCoVC32cQNiakmGaz2TP2F5vkFtjJxNzeEiBE5tqQRXI/qEHTX+dmyfzXPWOSeuRaXJJIOBy2sSNIbkGocKFlAk76ZqCA4zDJzJH3usm68WllcMzS0pKmp6e1s7Ojv/7rv9bh4aF+9atf6cmTJ5a2SrJL/c0332h/f193797Vz3/+c/vw7XZb29vb+uijjxSNRrW0tGSqpURCOIREIvF7DBw2k85WxpqGw+Ge8Z9kDNls1qIisMdqtWqfZ2BgoGdWjXSJO0Pto/DW76KGMzc3Z8X6ra0t1Wo17ezsWA9EKpUynBv46/j4WNFo1CjB4LQonjabTW1tbZn6AE2WaDAxdgBqoisPMTIyYhkL0CDfnYZJdzAX9FuXfYVzRhQTCIr3BqvF8PezfvOb38jn8+nu3bt65513et4DDaxEIqGVlRXV63WjHedyOdXrdcOgBwcH9ejRIzWblzLzr1690uDgoA1Qgp3IzHCX+0/h2S0osz9E0QRgROf8PlAG2RPOKRwOK5FImKH2er1WTHUVJ950/yTpk08+UTAY1D//5/9cf/RHf6Rvv/1W/+W//BeVSiXT2/vggw/0s5/9TBcXF9rb21Oj0TBq8dnZWU9BHyMEDOsWoSnM43wYAIiDpjlYkpFBgsGg5ubmbHBdvV635yDJlM9dB8LeA/khRR8MBk2CisDm5cuXevLkSd9d+i9fvpTH49HMzIwpEKytrVk/FZn75ORkTx8MdRZqNfV6XUdHR5aRJZNJI994vV7l83mT9Ucx2VUkcBsx2RuyDpTNUR9JpVKanJxUNpvtqQu6tH7qO2jBTU1NqVwuK5PJyOPxaHx83BQvUOy4ybqxcwEbdiNRvDOidvF43Ng8LPB7onS8Ozg+zZnALmwgUJV0pXWFx8aTU1xDqlrqHZ0M9ZAUkiKtW0Nw35PfhwpJfcdl8/R7ua9TUqUrppAkGyQEtZLPyzA1DoRLw+T1KJyTFZFh4OjBdYlcpCuCBnvqZjp8X5eWStaD4Ww0Gj26TdB6XdVst3/Jpez2s4iY6LfxeDwW3VOUBnpyHSRKAoyHAOppt9s2coFIjM/H96aYztkg8nYjN5cG69K7ibh5dm69BqcBMYHFe/P3nDcYgm9y/iRZ1hEKhQyq49lCYQUCxjFwBwjIgGcg1khXdTjo0y78zIROd9CeW2iX1EPHZ3/dBlLuK5+Pz+oSEnDCLlMrnU5bNE7mR3bVzyI7vk65J8rnf7t2iv3jHAJzgpLwv7mrfAcQFJyHSxWXrpow2X/gVfaXz4KuIDpjLtpBcNRsNg2huN6mQLDEWUCZ4Cbrxs4FXSKP57L7ORKJ6M/+7M/UbDa1v7+v/f195XI5gw0wghTsAoGAstmsdQWDWeIxHz58qIGBAZ2enprA3vz8vEKhkI2Uffz4sZ48eaJ4PK7l5WVr+BoYGNDu7q49ID7DyMiIpqamDJftdDqanZ2Vx+PR/v6+1tfXJclqEujqxONxTU9Py+Px6OjoyLTAvstB3HQtLCxIusy0PvnkE3m9Xn344YdqNpvKZDKWIrtGxev19kz3xPEcHh5asZQLzYUhM+HvMO4DAwNWl+p2u9acNTY2ptHRUVNiRjQP1g8REirXfH8UGMh4iGw3NjaUSqVsqBs/hyHod7333nvyei+7uakToBFHUyQOxu2r4nyQvfl8PoOowuGwYrGYqRYPDg7a6Fz2RpJR7Y+Pj1UoFHrOAQVy+qtcCGhsbMywdGj7zLQ5Pj7W7u6uKpWKDg8Pe2DGQCCge/fuSZJF5mdnZzo4OHijHo379+/L778Uk/3Lv/xLnZycKJ1Oa2hoyHSlAoFLJWnGHTNem+8GVA1DEENKBivJ9N4gUwDvMVeIzJyCO60AGD5qgCMjI3YPsCV8/07nsjOd7BxD+ezZM21ubmp2dtZmOeXzeWuwnJiY6HsP+Tz1+uVI98HBQf30pz9Vs9nU48ePdXJyoqmpKUmXLRIMMiMQrNVq2t/fl3TJ3BscHLTR2cPDw6Ydt7Ozo+PjY2uhcAMK0CHQmmazaSgEz5Fn4O6VdGmDXDiXcxwKhbS6uiqPx6OnT5/q448/7rnDsIF5jt97QX9xcdEMWzab1fT0tH7wgx/0XDoiPqAADgZ9MVBBR0dHLcKWLil+8/PzCofD1iWfSCRMYmRhYUGRSERPnz7Vzs6OJiYm9ODBA+s3oKCMRhFePRaLaXJy0sTfwOsxvkxyQxKCegLGBnyUKOJNqKDj4+PqdDra2NjQ/v6+7Z909fBdBQFJFik0GpdDgnAYp6enlmoT1UK/pNfCVYcFTiTDYWZJOBy22Tawa8CxO52O0ZChlEqy6NGl6lKkrVarOjo6srnwodClzD+FyjfZv8XFRXMILiwgXRaqj4+PlUgkLNPD4FNbInqFwkl0jVbe5OSkBgcHre8FiAF4FnyaIjSSNy62TYbmCldGo1HrrWq1WkqlUlZz297etsyfzwMCMD09bQVcBpfhoPpd09PTki4DA+a8x2Ix69ymzpfP562/qlgsmgBnKpXS3NycPB5Pzxx3IGuCOmozQNjsIYVluumZm4ORJEthD3BM/CEL4HxGIhHNzs7ac2AQXC6XMzHdcDiso6Mja3UAZupnERCXy2UTgV1dXVWj0dC3335r1HaQFYRuef5AhwQPY2NjOjs7s1oYwRqaYtCxgRapf1GLffnyper1ugldkrW5TdWcedQyJBnUz7MJh8PWt/Xxxx/rb/7mb3T//n09evTI+mNc9Oam68bOZWNjwwrHGGT+bmhoyMbnUvil74TUESoqLBUWWk58UXfaI30ZREj5fF7Dw8NmFKHjnpycGP4Ohs1rgm3m83m1Wi2dnJyYo4Nx4hZNeTCbm5sWjc7Pzxs76k0OZrvdNu001HL5N7IEdJjITAqFgo6Pj+X3X85XwXFiwIAMgB2np6etIQ3qLZADEA2zHTAo29vbNiqBbNBt0mo2mzYSGkhAkvUw8XczMzNWoDw8PDRoA7mM15kFcX0dHh7K6/WaoCMS9BcXF8bGAYdvNpv2vPk8MLeIvoG2eBbUAhBE9Xg81gt0eHjYU7iFxolR5ZlgAIAnzs7OdHZ21tMNDVXc4/FoYWGhx5lD/6S/igWMtbS09EbOxWU/Ui/jPOOAYQb6/X6NjY2ZzhjRKiw5DCgBC3U1V9Wg0+lY0yhnDwjJ5/PZnBBoxkNDQxYo8n7MiSIjdJml1FoIquiHWV1d1cjIiDKZjN0nIEq+dz8LmF6SQX4886WlJQ0NDWlmZsagTVCF4+NjmwzJlE+aThF5hXU3ODio2dnZHkdLfxQUfwIkZvIgKURdETvi8XistuVCWxAo3HNwdnZmDacffvih2RAgM8odrxMg3ti5fPbZZ5aFDA0NKZPJ6Pj4WKFQSEtLS7p79652dna0tbVl3dDg2T6fz+Au8D8OG8qeRCeTk5OamZnR0dGRXr16pfPzc21sbKhUKikej2tyctLgKo/Ho93dXYNJuCCLi4vW87C2tqZKpWIz47nIExMTxtln1Cuf9eTkRF988YW8Xq/+6I/+SAsLCyqVStYN38+iQ57Z2MViUfv7+1YApYZFoT6fz6tSqejJkyd69eqVRdN0GtN7gJYbhIEf//jHunv3rl68eKH/+3//rzkqom+c7/37902J+Xe/+53JpMfjcb3zzjtKJBJ68eKFjTDe2tqygrV0mYnNz89b8bDZbOrBgweanp7W+vq6fv3rX6vVaumdd97RxMSERkdHTXGhn4Vqg9frtZ6Lk5MTtdtta5oNh8NGXd3b29PFxYX1WQEj0BuFo6NRlH2dnZ1VMplUJpOx8/fixQuVSiX7GUkm8AibrFqtmsoERhfxQQInKM7NZlMTExN677331Gg0dHBwoHq93jO/fHNzU+1224q9AwMDRgfud5FJkEFIV/NbUIZwGYVLS0t2fqgp0PszNjamgYEBGySWSCRMmcDr9ZozhRLMfcdAptNpPXr0yIg0tVpNIyMjpjxMFkAWBVzNawMzQXk/PDxUvV63oYGlUslGbY+OjvaIq/a7h+iJwYSj4TsQCOiDDz6wQAtnSj14fX1d3377rcbHx436fnFxYerGDx48MN0/aiOLi4sqlUrKZrOW5cH4qlQqGh8f14cffqjBwUH7t7GxMb311lvGtPV4PPryyy+1s7NjjD+v12ufi2ySnruBgQGz5cVi0doi5ufnlUgkLGO7qQ28sXPBEwIPSFcFH7fYD3sJI0K67HpJFn0K0O3c9Pd64ZoagNsl70YHwWDQ0uBGo2EZFq9DROum2aR4bkRHhkL3MAO5yJL6dS7X6w28Lt+D7+xmBnT0k2WQFVJHwMC53d1uVkiNDKiNrIWRBwgi8nzpaUEgkZ4fCrKNRsOifqAI9pqCpUvnZt/ZU3SO+lk4Xp4bTBygAuopnBm3b4Jn5hIYuGg4A+abuEV0sknUlyGVsM9Ew7DoiGwx0Py9e2auF/Y5gy68yR/3Prifqd/lFtJxhG4bgLt/PFtqZZz/drttNRY+DxH29YVN4HfYN2A2Vxna4/EYjNhqtWzsMpRnMiK32RSar0t9x2DiDN3nwZ73e4fpPcIecOZhkpKRcO5cKJ2MlEyHYA/YmrMHSYazyb65bFUQFVf/zoXWob5z1rCt7v1DUsalv0Ne4m5hxznLMGxv6pxv7FzeffddtdttvXjxQs+fP1ckEtHIyIhFaNLlYZqYmFCxWFSpVJLf79f4+LiSyaRBU67MOF6yWq1qZ2fHROqazaYV/wKBgGZmZqyo7xrPTueyY7tUKmlubk5/8Ad/oGq1qr/5m79RPp/X+Pi4KfLyunShd7tdbW9vKxAIGN1xe3tbW1tbPcyfb7/9Vtvb2/Zw3yTyJiKjLsD34zCARbO8Xq9++tOf6o//+I+1ubmpjz/+WOFwWCsrK5qbm1MikdDw8LBRZ73ey+FA3377rbLZ7O/1qFCrgorMd0HleGVlRefn5/rVr36lk5MTm06Xy+VstOrs7KxmZmasvoJ+V7Va1f7+vhKJhEnpdLtd7e/vWx2GJtSf/exnr71/ECzoTTk7O9Pp6ak8Ho85SpfZBHsJ4wxkEQwGNTk5aTNGIpGINT6idsC+jY+Pq9ls2nhpFGzT6bTVaHZ3d3V6eqrx8XGtrq6qWq3qm2++UaFQsFHJQHiuQ2HAE/dGkhVOa7Vaz8hhcG9+vt+FkTg4OLCmOMZYk1FzLkulkp49e9YzJgHZHDcDgBCB5AnBRbPZVCwWM2o9Z2V+ft6GXAHvoEg9MTGhpaUlqyecnJxoeHhYs7Ozlp3zXIHX6DrHmD99+lRnZ2eKxWL2vHlunJt+ncvk5KTa7bZevXqlw8NDU8SgZhGLxVSpVKy+cnp6qlbrchbPhx9+qHK5rN3d3Z7OfrLETqejV69e9dTxOp2O1eFgcgJd4nRori4UCqbx1mg0bFx3rVazz/XixQt5PB7dvXtXExMTprnn9rY9fvxYL1++NFWJYDCoXC5nZY29vb3v37mARQMjdbtdK9RTpCPKoH5BNIxRodiMt0Znq1AoWFcwWQNptSRrrHK9vBtlwi4ZHR01nPvg4MBqBy4VNBQKmcQJ3HoomciykwV1u10rxr2pdATFy1wuZ9RtHBbd+jBqKEQjm8HgJTBQv99vhp/sBcgpm82aFpDbZwAkNjo62tPQiqONxWKKx+PW37CxsaHZ2VlNT0/3UEUxMFzucrlsUjt0AbtzQtAW49L1u3+uaCkRIdkgUTT/W5JdThZ7BlaO/D3y8hh2YCi+KxlKu93W8fGxms2mwQ7IAbmjHogIcUJAJ2RZnF+MAjAfzEAMKFAFRogAqV/DyJ5QD4XEQk2FgMotwMMIc5sf3eyJ+hJQmIsIEH0DtXEP0Vzjc3S7l9JLwJOxWKynf2h0dFTJZNLk5HltEAmyBJ41tgR4HRjNDd7epObiZh7YQ/pJyIDJ4HF8dNyTPbgoBlRqGivdXhYybIgsXq/XkAcUIAhW3Cy92bxUSTg7OzM0qVKp9EyghFnmtiZIl6Mttra2lEqlFI/Hzb4TcCALdZN1Y+cCRIIcRKvVUj6fV6lUsujAZSWl02k7QOvr63YY3PR2f3/fCluvXr2ywjrNjrw2xTI2Efqr1+vV/Py8sby2trZUqVQUiURMqPHFixeWKbh9CjwkqMAYgEQiYVIKru6X2wvTz8KYE7XV6/UeijMSKUSsFOx3d3dVKBR0cnKiSCTS0+2ey+W0v7+vwcFBo1MTScPmYhYEjoxItNu9lMwnWqzX63r16pURHVy4aGBgQO+++64FBPTkTE9PGy7s9kRIVyoMwBdAIP06l8XFRav5RaNR7e3tmSAlNQF3PtDY2JjBDhTQ+TwYo+PjYyMzMKcClhiECDDxRCKhZ8+eGcZeKBR0cXFhzh/VAEmmc1ar1ayeQsRMvaxYLCqfz9ulBW7B2DJyGD05dwZPvwv22x/8wR/oBz/4Qc/wp1qtZvcAdtDU1JSNW5ZkARH3HErswcGBpKsxxTjko6MjZbNZM2ZkYdQsKDJTk+t0Otre3tbZ2Zk5UmRmyFy63a4RKly5JrIliAZQhnnePJc3aYQ+Pj6WJM3MzGhmZsbgo3a7bcYbSE66GhnCnYWZ6ELsqGS4xBuo/dhB6UoFg72DZk9zNc+XzIdAhRohtXGf70pdHjtQr9e1s7NjjonaH4gA3wOpre+95sLBB17I5XJ69eqVGSl3Uhoprs/n09ramvb29hQOh3uYYDC59vb2jOuPDAEHo1KpWNo9OTlpETKsHrSxUqmU1tfX9cUXX+ji4sJqB4eHh9re3u7BhnEwbtT67NkzZbNZg8jofyAbikQiViPpN+rhUs7NzWlsbMyKtsAgFMuQhSfKBSeFEuoOPkMCHQptIBCwA873HBwc1MrKihKJhI6Pj3VycmLSM6FQSG+99ZYePHig58+f68mTJ2o0GkqlUkqlUjo9PVWhUNDw8LDu3LljNRrIBWSKOzs7Vi+ggZLLIF1NZ3wTVemlpSWDXRHK3N3dNSONXDvPmAtHRzepP5+n0+lYmk8flMfj0eTkpPWmnJycKJlMamFhQUtLSwb9+f1+Y0Hdv39fExMTZmgIdIaGhgzeAhbz+XymMeXz+UzrC2agJKPYogjOZ31ThQhJNhBsbm5OExMTOjg40Ndff21ZpStyCHzofgYibPaS87a9vW3Zo9/v19TUlIaHh40iPjg4qB/+8IcGRbpK0XS083k2NzctWJAuI+nDw0NJ6vn5kZERnZycqFgs9rAacW5kLG79AkJMvwum6TvvvGOkgaOjIxPZzWQyVosJh8MmqPpdzoUg2h2mxuelxuTWt7lDZEtAZagajIyM2ABC17lIMkTJHc7m1q5QDKDNAOdCpk8QgDL69+5coEYSDQMTcfDQ83KhMkmWWkmyTWGzgDY4FBxY0kG8Pml6uVxWPp/vkfKQ1NOLQpTiFkFdyMSVO6cYTqodj8eVSqV6fg+Gxps2ARLBE4lxEHhvLgGOAxiCAp3bGc44WDjt0lWXLmk7GQQ0cOitbhEc9QJqMnDqKTbSrwSZo9O51Lxy2WcYxm63az0xNL3xGTjcRFH9LEQvgV+oP+DA3EI9xXGIHi7vH8IJ2dfY2Njv8fjJdDEKOAmiZElmNIguybTdSNPFzqVLxwGVlPfns3s8HmMAIv7pnrc3gcNYvDe0U3dk9HUCDswnKNLBYNDmvDebTQuCYOu5BX7gROBeN2PlXrlFbcRoMaAEItQi+O4Esm62RcCAM2LqJ5Ain4tM/E2EKyEekKm4s1twrBAkqIdwBiUZ8uPaHCBF4HlJ9hnZJ5/PZ9MgccwuBAmxgD4ll/TB8/B4PNZPBYXeVQXhvZA/QrfRtRWS/t84Fxp9iGrZwIuLC6sjjI6OamlpSbVaTZubm2o2m3r06JEWFxeVyWR6xqzCPOAik0qTdUhXzgja3s7OjnZ3dzU/P68PP/xQw8PDFmGSSrvsm+sb3Ww2lc1mlc/nNTU1pWg02iMfs7S0pB/+8IcqlUra29tTuVzWxsaGzbB4E6YOF5VhW9KVQUR/i34GF9em9uJKNOzt7VmkzeFE2oXvwmsTbWMc6LhmRHC1WrXofWJiwsgVOGH6inhmOzs7ymQyxvpxC63379/XvXv3dHx8bFkQs7tTqZSmpqb6vth/9Vd/JZ/Pp9nZWU1OTqpYLFrNDUfs9h4Qwbly7gQeZKGTk5N66623bHw1GleHh4cKh8OanJw0eAel6Wq1aiN6h4aGTOWbYXWcWXcQFA2+zWbTBpulUimNj4/3FH5XV1f1zjvvaG9vT5988olqtVrPHJObYt1/11pfXzfjDEUYh4sDJrputVoW+aJPhWIyqEKr1TIZdhfudPt12u12D6uJ50S7giQrHNOzBPQlyYIBVrvdNkh0eHjYFMPduUEEBOi/EaEDefZ7j90OfewDEkLUQ2ja5d7RExiJRKykcL3GRbmAPjYCbgK6gYEB3b9/3/TM0HAD9s1ms6pUKmY/sQkQWUZGRnR6eqrnz5/r4uLCAvhkMmnBVS6Xs8Zzgm5GlafTaWsIfZ0gp2+ZVeoefr/f1EIplne7V7pDZDM0DIEXEk3wv/kDNi/JqJx4VTcix3i6RT1+xi2GISDoenq3IOdmDnTnc+kk9WQsb+Jc+F16btgX19iyhxhM9gOMm9qPJNtHl7LI77nNq9ALIUDwPuwzdG7oom4xkX0B8qKTn74gnhHvEwqFNDQ0ZMVi9ptah9sc97oLaMvNnDg/btbC2eFsAIe62QyRGlGdC01Iss5z6kY0BPPv7nnlO9brdSvQAz+RbbpnmAidn3Hp0Yx1oCcLQyBdNT6+ycLBujRkt4ue2hh0fpwD+8qeQhDBudNTwdlBC5CInj0j6uU12E8gIZdW7N5nF9piD2kMvE7dp5nTtUFkpe7r9LNADkBJ3Box3xE1bZcCLMk+j3supKugE5o2e8794t8pN+AY+D7XGyIJQngPV0yYDIfsECfGc8Tx01ztEmb4/q8Dzd7YuayurqrT6ej09FRHR0c90vtEInSHA43xAb/55htrCPP7rybPuV7+8PDQOmxDoZByuZz29vY0MDCgmZkZ857z8/MaHBw0MUwX9uC/YK6S7KIgv4GU9fn5udV7gDtCoZCGh4dVKBR0dHSkcrlsRTOitn4bsCgArq2tKZPJ6M6dO/rJT36iQCBgw5mg6wLXoCSA8CJMr5mZGUWjUWUyGYuyZ2dnFQwG7eczmYzW19c1MDCgyclJjY6OWqboDlAjqiwWizb/hfR7a2tLu7u7lvK3Wi2tr68rl8tpbGxM8/PzPU4O6XZYga1Wy/YYfLzfi03TI5CSJIuwMYQ0UwJpYRjJZBire+/ePSWTSbVaLe3s7KjRaBgkhVGD0QV9HGgwlUrJ6/Vqa2vLcPVkMmkUc6JF6Uq4E4NAMRWDe3JyYs43HA4bCoCWHPDy9d6XfhdFc/YiGo2awjWUfjS5Op2OGWnkaly8f25uzs4pMkPALUivPH78WJ9//rlCoZDu3r2rSCSiUqlk5AlgXfb38PBQ6+vr5lhbrUthWwZ9jY+PS7oM0GCFbm5uGrkEuSKyZQgpDA9065H9LIzt6empSqWSNSRD16UeTIA4MzOjdrttNSL2nT0leAFKI6DBWZ2enloT5fHxsTElY7GY/V2329XIyIg13yK3NDQ0ZHOicHq8J8SGTCajL7/8sueZgUwRVAJBFwoF3b17V8vLyzfevxs7FzjedB3TL4IHvri4MBon7JZms2kibKRnwWDQtIwYNsZsAzBA8NJcLmfidyMjIz3FMPBfsEg3cqJuAV4Jo4P5FVzUQqFgTBQ45aSUHET6AIDeiChed6VSKTucSGhQJGdsADWmWCxmWj+IFSLxEA6HNTc3Z5AMw5jQrCJiyWQy1tns9vK4dR2iavBh+kYQGq3X6wb1ELnv7+8bt9/VF5NkhWsaUD0ej8mH08T5png3Rp/MmaIoTC8MIjUPnm+5XNbR0ZHC4bBWV1ety5/aDfUgGGjSlVI33w3H0e12dXJyomDwcsgW9wB4xM2M3IwNI+L3+w12kK4iXj4nWZkLkVCne5MFBfjg4EAHBwc2kZBaEOKuUP/B9+lHcaN/7mMsFuvRVAuFQhodHVUqldLGxoaKxaJFu9DuYV2RlfPdjo+P9fLlS2sZ8HovJZ9OT09tHAV74tLgE4lEj6wSEX4gELBaMfVGCAn9LL5/oVBQJpOx0QI8T6aj4jTQ45udndXExIRevXqlx48fq9lsGhRO5izJCFEEZjBpcbI4TURoaWiErHB8fGx9KLQquEgImRGkoPX1dX3zzTcaGhoygpTbjyZdZk6bm5sqFApaXl42FuNN1o2dC/M8EK70eDwWSWQyGfPkjHN1axRAL6TjRA8XFxfWXwJThZkPRDWNRkNffPGFXr58qenpaVM5BqdmIqU7ZY/LyYWB9uteXhezvHfvnl3uzz//XKenpz3Os91uKx6PmzRFPyubzarVaml4eNjkVZ49eyZJ2t7eVj6fl9frtQ5lomAgoHD4coohRdBA4HKUK9ng3t6efD6fGUf2uN1ua2dnxzByHH+tVjP218DAgI3+RUeIYj+inyjjouXU7XaNYYdRubi4sIba0dFR0yMaHR1VIpEw49DPgiBCxEt/D5eGDIqIy4X6gsGgOR6fz2efEbkgFx7ij8vwisfjZgiJhk9PT83YwPojuyJDxqAxn6TdblswRDNgIBCwHolGo2FSR3RqY3AikYjS6XRfe8eCyhsOhzU1NWWd8h6PR3NzczYfaG9vrwcJINIdGBjQ/Py8fT+al0Ew6NNwRzLQYFmpVGwqqSQTQ/X5fCoWi5b5wfIDynShNggIAwMDNoOeniqcEXR+tw/GNZxub8frru3tbTuDqVRKgUDAniuF73b7Sg4pn8/bfgMpTk9P9xCZoGb7fJcSWV6v16Aqfpd6FIw+ivgEQTBtkShiv4B0kdIhsCFQDASuxlvz+ba2trSxsWF1RSjI9Cs9e/ZMPp9PMzMzf+9+3di5fPPNN+p0Ojo4OLCC0vT0tLrdrjY2NkxckUifQT1g3RhFGEcYUOmS/YSwG1kN2GC1WtX//J//U9VqVb/85S9tZLJLXXb/SLIIL5fLKZ/P9xT8ELjD6KTTaf3RH/2RRkZG9PXXX+u///f/rkQioYWFBXk8Hp2cnKhcLiuVStnB72ft7u5KuswAp6enlcvl9PHHHxsTiagXksLe3p7q9brh10BAHo9HL1++VKPR0OzsrObn503/qlqtGgRTLBatpvLkyRPrncFQJBIJOzgITa6vrysajWphYUF+v9+K9fF43AQFqQM0m03t7u7amGHmdh8dHWlkZEQrKyvy+y/HLbgNnf1ebDdq5zlPTk5aDwUQFBEfUSRadtVq1RqBj46OdHx8rDt37tgFckkkQAHo1s3MzPTQwOmLOT8/t0j07t27+uCDD+zc1Wo15fN5032CTutKJEEOgFyytrZmtF43IkVhl0i435XJZKwmNDY2Zvh6IBDQ9PS0AoGAtra2rJObPgdgF3oqyuWyPvroIx0eHprhoacHp4ny7tTUlLrdrikSEJwB13q9Xn399dfa29sz1WXqZPwcWShKvtFoVMPDw5a9UMj2+/09wS93fGpqSrFYTMVi8Y2UpR8/fiyfz2cDEzkjZM9DQ0PWN1cul7W9vW13lp9hAuja2lrPHKyLiwtlMhkLHIHAIHRUq1XL4uiFwym8evVKkkyQliDI4/FYLxwyRtLV/JxQKKTp6WlDMRqNhp4+far19XXNzc3pxz/+sRKJhObm5hSPx1UoFPTJJ5+o2+3qH//jf/z37teNnQvRIZ6UiF6SFZugLxK1EFUmk0nzrFwaDg8wF1EgkTfsKPBzCrZuAR9MEPjBXfx/YCIKku6wG7cQ5lJv8e4ukYAIst/lfm9omkTeHCiMo1ugdI0arwP+L6mHxgllm8gbyBKHw+Ak/r9b1IVpxfvwnYlueU+36M/rECWydy7dk0zCPdz9LFf2B0fCchtceT+KolBrYUQBz5FVEyHynb+L0o7xwhCzj/wee+ISAoBPOXtQ6iVZ4Zp7AozoUmfd7N99Vv06Z3ev6ONiwVxyqeOcfQrT/B13FfIBcCCG3tWfgxghqUdBGrUEzglZJeffpfXCuOOe85zcP2Sq7NH1kdUuGcN9bq+7qO/y2Wg65LNBCmHPGBngUvkhLgA3gg64rDaek3vf2Dd3VAmL+9hoNExiC1YcpQBsNOcUpQJ3FIUkOxsIXUrqmfL5OtpsN3Yu77zzjrFc6LTlIiwvL2thYUFDQ0M28pS5FzMzM3rvvff05MkT/Y//8T/stfCw9JFgDA4PD1UsFjU2NqbFxUUFg0FTEk2n0z2idDg7DiXQiSRLU3GKODH+DYZKsVjUq1evjMH16NEjc4QuY+K6QXvdxYGPRqNWV5mbm1Oj0bBGLA6adKlr5ff79d577+nOnTvKZDJ68eKFut1Lee+BgQFls1k9f/7cHIHH49HBwYGpT6MyAL47OjqqdDptsIbH4zElZDBaLg/SGz/4wQ/su7N/EC9gPOHc7t69a0PFMJ4HBwcqFAqam5vTzMxM33j3nTt37Dlw0XAk/L3LagOPRjcNZ+v1ejUxMWGRLlk4MBS/DxQZiUS0uLhoxXDOnNsvw1mE3ouDp1O/0+loamrKZDmYV+8qKeM8gda42CyX9dfv4vnOzMxodnbWGmCRqyFQmJ6etr0EFkskEjo7O9Pe3p6kS4IP0Onu7q5KpZLW19fN0aRSKYvKyX5gEwIDEay9++67un//vg4ODrS2tqZQKKR79+7ZmaxUKlZ37XQ6pjtGzYy9Au5bWVmxhs9Go2Fd//Pz83rrrbf6PoMPHjyQJFNxJ0OmFoeyw/n5uQYHB03+fmRkRPF4XPl8vqemhAzV9va2OVxXGBZnhrMYGRnRwsKCYrGYTk9P9fTpU11cXBjUurGxof/zf/6PwuGw3n//fSWTSTtvjMnmnGazWSNISTKn8dZbb+ndd9+1Z9VqtfTZZ58pm81qdnZWS0tLN4a2b+xc4vG4Op3LRkO6u4lowK2Jdrh0wBJjY2Pa3Nw0GIyI2KXRSbLM5fT01OCawcFBJZPJHtVRIizeH0PjRjO8D41YRBVu1gWVDxx2bGzMillIebvRpBsh97NcijSsDT4Hqsc0utH3Mz4+rrm5ObXbbb18+dKKddFoVPl83sgB0WjU8FrYRtCXObTUPdxMh2ZAcFwiKv4NcVI3wmdvGTdMJgnchk6Sa0ChufZ7sV0GFlHjdz1zjK+b1ZJts/9upzRBBwGOmxW71NJoNNojMcJ7cEaKxaJOTk56MgDqFCxGKbjijtTVms2m1RBcqqqrpUU23e/idfk+UKzJ1CBC8F2JsIFNut2u1fJisZiGh4fNeCEMiaQMd5cMBXgyHo+bbh/fC4o9dVf2z9UhpObIM8V2EFy4yhDJZNJIPxB4qDcBB/ezyPaAuQg2sEPUmrA7yWTSslZYYIVCQZ1Ox5wv925gYMBYtm7jNMEUr5lIJDQ+Pt4T8HHH2+1LgVBqo4iyuoG1JGtId58Fwe3w8LDJDBG85fN57e/v2/f/3tliFJ9JkZAE8Xq9Nr0Psbh6vW5THtfX13V8fKydnR0bQfv48WM9e/bMNHqIbKLRqAm7QSH2er2GTY6NjVnWhIPA6ZyenlrkiBGDjojDazQaSiaTxpWHqTE8PKxIJGIT4NyI2OWLv4kq8m9/+1t5PJfyItD90EWTLi8ScxNIQd3Cea1WM4fMHBj+jihJuizu4TShWHu9XrvwGGkosS4jiQPIoWYP3ZT/+PjY3pfMkMa1UChkY6F5/lw2IrR+nfPW1pbtk9/vN4ZQq9XS7u6ustmsPvzwQ/34xz9WqVTSl19+aQXQzc1NZbNZ+26SegIUosZ2+1KcEvgWh/r48WNtbm5qeHjYJIw4H24fAdkTUInbD+MatE7nckQvzcgMkNrZ2dHBwUGPyjXOjtd4E+dClP3y5UujtiYSCbXbbaO8ptNpzc/PW8vB+fm5NYRS05MuFRNyuZx1qbdaLcvuqBG4MDZzYMjoyJ5pbsQBIRvV7XZ7zm+1Wu25mxhZEBT2/OLiQltbW9bgWK/Xtb+/b6oW+Xy+b+dCAyxBQKvVMkHKo6MjHRwcaGZmRvfu3bNskEyGOzkxMWENu/TqwBCD5YbTok4qXTbA7uzsaHl5WdIlOQPW5/T0tMbGxqyhnOfq8/mMCYaMlsfj0fT0tPX0AW2iOp7NZrW/v299eKAbXq/XCDnfOyxG0cjF5yl6M+0smUzq7bff1unpqU5OTnR+fq7t7W3DlYHNnj9/rrOzM/3oRz+yghLS3BQCeXju6E5YR0TvRFVE2ojk8ZBcWAznQmrowh6JREIDAwPa3t7W2tqaRex8T7du0+/l/uSTT+TzXU7fm5qast4dXpOi6ltvvaVarabd3V2DV3K5nDGkqtWqUTzj8biGh4fN0Hq9XiNesHdE1kQ99XrdCAIubuxG0lw+MigyEiiUjHiF53///n3F43Ht7OxYQXVtbU2tVssMAEoA/e4fg4v4PHTBQ9dkpvn777+vk5MTbWxsmHIs0yAx9G6mI8mCB+pvhULBcGygU6/Xq5WVFSu2cu5cHB4lA8grRI0uG42ol30D7vF6vTo6OtLR0ZHBRhRZodS7tbZ+FucJdYOpqSm99957RhnnfqysrGhvb89YccPDw6Z2zj4xEptzAvOIQKZarfbcPViGQ0NDGhsbs+zWZcRBY+b5wOr0eDxW8AaFiMViltW3Wi1zJNlsVplMRqenp9ra2jL4m14nAtV+FjqFkBt4do3G5ZhjxivfuXNHlUpFT58+NaXzWq2meDxubNdsNmu6fdQ36HUB9aEeVavVbAgjWSP1LDTDZmdnja1Jzx5ZOpNgh4eHre5MVkk9d3p6WsFgUJ988okODg5MBw7a+cDAwGt36d94l4l4XSkHJGGoszDnGyolaSsHgsiZy+sWwIjQAoErJWLSZmCzXC5nESYXhaiHYhOHGYPt1mOIBpLJpLFX6JgPBoPWoARs4DouV5iwn4X0CRmadBn9sZcej8ckRur1ujKZjC4uLhSLxTQ4OGg1gXa7bVgzzg+2nXRpfN2MCFiIvpVMJqNoNGqZCwQK9setGbA/Pt/ldE6v12t1m3K5bJfm8PBQZ2dnNveBXhlJVu/BWPe7iKLc3hyyLS4mDB2kzoEdyHBhWxGwcJklGSyE4eICUeu4fgb4A5vJNWLU63iuGFIo7UCeyOjwWb3eSzVnIEy+I8b2Tee54GB5/VAoZKOwqefAgMrlckbzlS77RIBfyawhqZDZEgW7gR333/0MuVyupy7GSGzUF7rdrrEDyX6BWL1erzV6EtjyWnwHgp6ZmRmTX4F5yRnvZ/FdYWVRpHfVLdzaE+9LkAZKQNDhDga7uLiwJl/6Bd1m0uHhYcsgK5WKnVdJJid1fHxsyJKrGzc6Oiqfz2eQezKZVDqdtmI/gR/Ph94lSFnpdFoTExMm8Pq9OxfmhRBlXFxc6He/+51FaJ1OR/v7+yZ4huHBAKTTaS0sLJgxyOVySiQSdpi4jAMDAxaNEE0jjlipVEymHyM2MTFhETlYNgVTHjzRZzAY1D/4B/9AS0tLWltb0+bmpkU9dF/Pzc0ZVCbJcGCygH7XT37yE7vY9Jd8+eWX1mMQj8e1tbVllGxoiQsLCxofH7eomi5uoji667e3t+XzXSre3r17V7lczmS0KarSwTs1NaWpqSmFw2FrciT6vLi4MA0tNOPArxOJhP7tv/23+vnPf66/+qu/0n/9r//VHBt4fSAQUDQa1cOHD83QeL1enZ+fv9bBvL7m5uYkXRUeg8GgReAoK2QyGf3FX/yFpMv6BmxDjPro6Kjq9bo+//xznZycWGGbn+l0Okr87chjzl+j0TCqOI23wC8ej8cg1VqtZj1JR0dHqlarFjGWy2Xt7+/L5/PpJz/5iRYXF/X48WN99NFH8vl8NnhscHBQ7733Xo/UD8aQGTvXmUKvsxiNQNH77OxML168sMzW7/drd3fXaNM0SQK3jI6OanJyUq1Wy7rUcSIQVKBqU9inUZSabDab1dnZmRnjdrttjbkES9ReXbUIhg0ODg7q0aNH+uCDD/TVV1/pt7/9rcG6BAdoZq2urlrvRqFQsFHj/TZC04Q4Pz+ve/fumSo583wikYhl72SyFPTp+SKLZqAiQQTq7O12W7/85S9tDEaxWJTP59PKyor1uR0dHVntrN1u69mzZ9Y2kMlkrEbq8Xj0zjvv6MGDB8pms/rqq6/k8Xj0y1/+Ug8ePNDTp0/16aefqlQqaXt7W7VaTePj45YFoTjw/vvva35+Xp999pl+85vf3FiG6MbOhcNBtOcWU1kUk10qpkurBDOmiAwm674GkiTIYtBhz3vhyYkgMQBkR0Sarjy+283qFqaJpvkuwBxuduZ+/9fR1bm+yBQoLsNKoumOIjJOksvlDji6XsAm4wO/plZC9zkd1nwf971YLlWY/aMoyyHic9FQ6U7Dk2TBBdANhA1X1w3j1W/U6BYRifbYB2iWFEyvU3bdIjv/H2cCVCVd1V+k3n4UzhqQmEvNvf5aFPk5k+7PufAWkCSsJo/HYwPb3OZBzioNn/3uH4szyEgAnj+1NT4Pz5nslvPK97hOl+b8uCq7Lm2Vn3O/E8+UzMN9ZgSWnDP3vVxbQtDlOhecM7ApDZjcvX7rfi4V3T3P7v3hvBBUSfq9s+HWNt1//67AizMJQQKEx90DAm8IOS7aQz8MsCx/xxnk80OswkmSTbn2kN+76bqxcyHqoSOX1LfZbJp2T6dzqVHksj3AjwOBgLLZrPUZJBIJi1zoheHBQ9mFekjkiGFEKwxYzK2dwNopFos2xa5Wq/VoSZGGz87OGnYPbIRRgNkmXTq8hYUF3b17t2+2E5EocxLIYPj+nU7HlApcdkgmk9HJyYk1vnm9Xtt/GDY4F6/Xa3IYoVBIy8vLlhXyPuPj4z17D+wxMjKiqakp5fN5vXjxQmdnZ1paWtLs7KyKxaI2NzclSS9fvlStVrMRtC6Dhih2aGjIYDE02sLh8I26ev+uBQQLTAhGHwqFNDk5aZEhXeLXnSmQGdkGTb7MLoFtVy6X1el0NDo6qoWFBbVaLW1tbdlkydHRUbvsnHdqUFBRwb2TyaRmZmZ0cXFhek3Hx8c6PDxUIBDQT3/6UzWbTVObiMViNnWUzBS21Q9+8AP9k3/yT94IWpyenpbP5zPpFoyfK+CKkcGocReY94GD9Hg81n3PfgAVsvcuFI0GGR3pQDb0s5EBwjZkiNvo6KjGx8fVaDQMinr27JmNRac/BnVi93xgCHGYw8PDllH3s2iS9fkuR6IXCgUb+AYpgwzd3YdsNqtsNtvjmJnrwxmKxWL6F//iXxiUuLGxYcgFNgebRL2HQW4ExkC61A1xFigvLC8vq91um7I5qtfDw8OamZkxmw5xiZLA0dGRjXr/kz/5kxufwdea58KhoseB/oGzszOL1uDLkxK6WmE4BLwpBxp2A9Fnt9tVOp3W4uKipKvZ4ohMwiZzsepoNKrJyUkr9koysUdYMqT35XJZ4+PjJoLJpEYMORg0izrN8vJy370ufE63nkOEgfYZlElojOCkqK+S1qP9VC6XrXENjJXMh/nonU7HBiphCGimItKTLrXPZmZm7HPVajUNDw9rdXXVir0UIpmg6c6ioLZDkRGOPBAmhqPfqJERyfQBuJRNoKxCoWD9O+DgnCcGOwUCAb3zzjs2XOn8/LwnkuM1Y7GYFhcXLTssFosaGRkxKZHE384wAfpxSRKcQWobOPF6va7nz5/r+PhYi4uLun//vmHeyPBAkaaoS31menpaP/7xj/sObqSrSYUEZG7rQKVSMfKHC3sAe7sG0w0GqYGxb25Wxxkjm4Z8AmuJJj9qZPSKELzgcAkMidxdFhtBDI5RuqoLX285GBwctAFo/Swg1OPjY5vCyzA/hB9h+OFEqJVRewEqnpycVCQSUaFQMLmpd955xwQ/d3Z2NDg4aPOleA4EnfRQeb1eK0Fwl8mOYNviZEZGRtRsNs0G4uwGBgZ0584dY/PSNoBg6aeffqq9vT3du3dP9+7d+/6pyBgQjCDYP85ifHzcvLYk89pEDVxCr9drM0KoZTSbTZvHQlTV7XZNIRX6K1EPaaDbA8C4VZoQE4mEAoGAbTTZQDqdNkopg3vW19fNEALH4aA4nMfHx3r69Kl8Pp/u3r37WodSuhI+zOfzxqY5OzuzpjaYJMBPFPTBj2k4BfajoXV4eNjgQr/fbyJ5GHNorLVaTel0WiMjIwYTtVotkyjBGDDmGLgJ+XdYPEBv7D3RqnQpyMkFAPul2Q0D/qZ9QrwXTov+gnA4bN/LLdq6GYzr1DHgXHygu5GREU1OTkqSvvzySzWbTR0fHxsGXSgUrHer2+3q4OBAh4eHBglBSkkkEqpWq9ra2rLPSO9QOp2W1+tVJpMx+Z9KpWLROGeDplrOYrN5OQzqH/7Df9jX/hH4nZ2dKZ/P98BRNDkSjdfrdZ2enlrD7PLyshWKoR5TxMdp8XxcxV+iX2qWODeIDwSk7XbbSDnUyCCybG5u2nnl2cJeSqfTpp/l811OxEVFfHx83OBmv99v7FW/36/79++/9v4dHBwY2YDa8ejoqILBy2mQKGtD8GAIH0Ehas4E6ASQOIvDw0MjO/HZcV6ujhrirJwRatLYLfqRIK6A9mAzgQexnT6fT9lsVqenp0aMwG5TJ5Ku+rq+d+cC/srmFotF7e7uKhAI6NGjR5qamrLUz73cFKFLpZIymYwCgYB1hcNlx1GFQiHNzs5qdnZWOzs7+uabb3R+fm7Ci/fu3dPy8rK9HgaCA5rL5RQIBDQ+Pm5UYjaXtJHIEwy7UCjo8ePHyufzGhsbM7gEiA4GGr0UHo9H//Jf/svXPJayCYUM1oLmGY1G9ejRI62srFhH8uHhof7bf/tvqtfrGh8f1/j4uMl14wC73a6Gh4etL4BIfnJyUslk0qJmDkq1WtXKyoru3r2rcrmsnZ0dnZ+fmxptqVQy1snk5KQNstrf39fQ0JDm5+fl9/uNEeWyXYCecrmcjo6OevqEWK4sxvexyCaCwaAmJiZMlBKsH0cMPs7f8/40knFxTk9PFQ6HdefOHT148EBPnjzR//7f/9s03zCaNPPBvNnc3LRiPU5kdHTUmlx3dnYUiURMTRaFC4ay1Wo1C57K5bK2trZ6KNNkrXSvezyevp0LkCuCo0T0AwMDWl1d1cTEhDU7V6tVC9YWFxdtDDFaaqVSSX6/X/Pz86a2QYCC4kMikdDo6KgqlYpevHhhzwsiD4KfnB8cVzAYNBTi5cuXWl9ft0yHfrdoNKpUKqXp6WkrkAcCAW1vb+vw8NBo0QTEfr9fhUJBz549k9fr1S9/+cvX3r/19XVJvc2oIyMjikQiun//vkZGRnRwcKCBgQGVy2Xt7e2p2WzafhwdHRnrMh6Pa3x83FSIO51LAVSCzfn5eRuQSOYHEjMxMaHT01M9e/bMai3AizxXAn0cNuSATqdjnxnHW6vVtL+/byxU7DutA8vLy9ZMXavVvv8OfaIQoBy3iAYkxgW5XnTE4bieFUNDwY6NcSM5ImP41hwU3htsmFTRLeahdUaU7TJEvF6vGTtYZ9c7YymAQR10SQr9LH4XmIbvjgQGxehcLmcT+tyOdjfbYLm9N26Bn7oR/yU6qVQqymQyNl+Fg8nnq9Vqv1dwlq50oVyne70gzjME7iQbcDve32SR9XD+3CIv2TTPiD1gr9zz5hbXMRDS1YREoEnonpKM7s73bLVaPYwnIkmyXuAPN1tzyREUYQkS6HMAooKtyP5x/t6ECs8+SFckDhe6qdVqKpVKhiRAmgDGITukkReHC5uT+hDnySXh0B8TDodt71wJfJek4pJV+Az83nUNNoJK3pPzyb3C4ZGhMTq63+yZZwjkBnTkjj/m/HFGOaecL0ZgECCz1zwbbE6lUrGxIsCHoVCoh2kGAuKSATij2EOeLX8IWLjDZCicBff3XXUJ9pCa5k3Wa2cuGGQOT6vVMuhke3vbvDsPluITHZ4U8UqlksFULjNld3dXL168sHpNJBLR1NSUcf5hT5Higbcnk0nT40JTi8Prpt6wYgqFgs2VoMBL1znMD1dhYGhoyHot+lnw9nGi4XBY6XTa+OSHh4f66quv9Nd//deKRCK6e/eudcSS6mOwMfS8DoJ1XMhKpaJisajj42OFQpeDmmKxmJ48eaJf//rXZkA7nUs5HxwCtEfw9GQyabUznArOjChGkrFRGJyF86IH5vz83N6n35oBDVwQHxJ/OxgKKO/09FS1Ws0cZj6fNwgAFhwRLJl1PB43yILLubu7q83NTSv0JxIJPXr0SKlUSkdHR9aHxMjuhYUFLS4u2mfgGXPeUVxwjZvraAOBgJaXl+X3+3VwcKCTkxOl02n97Gc/k3Sp7LC5ufl7mVc/y2Uv4Qhxmmtra3r58qUZtEajYRE1zM6RkRE9fPjQ7i9G8PHjxxoYGFAmk+lhFgH9BINBG+ucy+X0+eefmwPhc8HaJMssl8umBHHnzh3lcjk9f/5c7Xbbiv9HR0eGJmAvyAao8TQalwrNDOnizPSzCGYhIEBcwdZks1kdHR1pf3/f7qLLXIxGo7p3755arZaOjo60u7trjYxAY8Cle3t7KhQKptiAPcrlcnrx4oXVpVwIkfcJBoMaHx83e4HCOmMiSqWSKZfAPHPlZ5i1NT8/b43t3CdgvX/9r//137tfN3Yu4L4YFrIKSRZRIHUgXUWabrEXlghRB9EQESReFaE1GBj0aTD3gUwEuItIAscBH50Ii4PhUo4pJALTke3Q7MShAKvku7zpIhp0oxgcdiaT0dramlKplFZWVqyO4H7X76IrQh926xBnZ2c6Pj62GRzdbleFQkHb29vmbMmeoLgi7gi27/Nd6sax3OiG93W/F1gu9RqyFjIoIrl+FnvPs3cb+Giyg+1HTwqRphuFuwYWeif/n+wRqIxnzsgBdNza7bbVFoEseIacL+mKzlyv100/7HrGjREOhUI2x5zAQ1KPQ/4+aMgYcjdKpejsIhLUjtzvQw+Jm8Vz56nBkLHBjMSxp1IpI+xADiAA/S7qOMVoziDtCTx7SVYHI6AkayEbJGMAhiYD7PcMcv4J6siQOIPdbtfOIcv9bvw886iAVlEB4X5wXnDg2CFQFP5w3pDAcTMg7kun07HWBtoxXBZlu93uUbXHNsH0JegkQHqd4ObGzoXUD9wZZgLeGU762NiYpKtoBLbL1NSUHj58qE6noxcvXhjGzQEjveNiNRoNowzjabnsFKowKl6v1xhskqyYTBGMB+v3+3X37l3NzMxofX29h4J5cXFhs1by+bzW1tZs3sabDAljvffee7YvXBqKamRRAwMD+oM/+AP7zDCfpEsK7o9//GNrAjw8PLR+FPZauhydS6b14MEDdbtdbW5u6sWLF9YkSNEYbBYHhnGBBrmysqKlpSVL90mhcT5u571L9KBHh33HgPNZ+1lQpvkc3W5X+/v7kmSO1Q0KqAthmJELgdvvQjZ0cZPxcN5QP/jyyy+t2E3Gh+bT06dP9fXXX9vZDIfD1hRJ7YKzQ+GXMbU4HAbJtdtty+QZqe3Oz6Em1u+CzTQzM6PFxUWdn5/bqFyGzqHH5kLH+XxehUJBY2NjWllZMeZSq9Wypl2YmPV63TrMR0ZGrPkVUsTg4KDefvtt1et1YyHSyc4Z5o54PB5DHlqtltVDx8fHlU6nbT4LbLdqtWpwEYxKWGbpdNqaY/s9g0xznZiY0NTUlNXLgAbdjnZXgQB4NB6PW6c7FGXIRSABtBXU63XNz8/rF7/4hRFHEKQFCeLMQIji/nJPO52O0um0UqmUqtWqMWFTqZTGxsZsvzqdjlH9CSqj0ahWVlbMRqDLiDLCTdZrzXPxeDyWcmIY+TJELsAMLDzy6OioHj16pEajoa2tLWvgAqYghSOazGazOjk5kXQZHQHTDA8Py+fzmScFBuHgtdttY1qNj48by4mLv7CwYEyRTCajarVqfTSxWMy6Uw8PD1Wr1TQ9Pa1oNGpFru/KHG6yVldXJV2NSiVyRHohk8loaGjIRhu4hqnb7Wp8fFzvvfeezs/P9emnnyqTyVhRmkJfIBCwGewrKyu6c+eOqtWqvv32W+3v72t2dtaGMXGxr8+SKJfLevr0qTGLXFiHnoxqtaqpqSktLi72REFEU2C40tWsH+lKOLGfhYNyi5AEEe7PYPRdZynJmD2wpYg0iWpRdaDeh5Jto9EwtQS+JzL+nU5H3377rba2tpRKpWwoFf1IkDZwxEjzMCzu4OBApVLJhBURNPX5fDo8PLSsD8kPDEG/i1n34+PjWlhYMJiv2+1aA6fP5zPyCc+KceBo2HU6He3s7KhYLGpyclKzs7PK5XLmXDCkMO9qtZrJ5L/zzjtaWVkxhwKTjH1yYVMgHBR+GWWcTqctgwLaoQeEkeG0K3g8Hiu8f5cczessSCP0hB0dHWlzc9NEMsvlsg3wcxW3yQiGh4d19+5dg7ckGduOegaZD8Hun/7pn6pareo//+f/bPJXIDOgDQTa5+fnRqoiK8VWg1zQfpBOpw1KZrAd2nJQ1QkMNjc3dXZ2ZgSi772gD4ziduFzCF2uOykaBotaAUJypKwTExMKh8M9GjiSegrSNKoRLQN/kQ663ac0JJLOS5fZFkOaYKUxXTCXy9nnJjo6OTmx2RTpdFrtdlszMzMaHh7W3t6eUa/7Wfv7+3YR+Izu7PexsTFzrBwYsgFqJDTbzc/PG85L3QPogIIlxWlSdLJLDjDPjcMELBQMXs6F57MdHBzYIQbq4LPi/KBc0pnvzjuRroIDtzH1dVc+n+/JnHlmFJKh/w4PD6tUKvVkA8AsRJaSDOPH2JAtAt1CNOGcgdejsUdAFYvFTEqH1waWIwvn+cHYicViNoKbiBeYiTvG90VyhUa2N3Euc3NzVsCnXkEtkjlAHo/HahU8dxfOY0Q0Yqa1Ws1EQmmqxQYgpMg5pVZDkzNKzAhWEkhx590GY4r6BDCQf9xgTbqszdGGAKxHXdatE/a7qGmenJwYtAXjDYieXizuMpkN0vU8QwImeoxcO0hv1sbGhhl/VJRhbWIPksmkRkdHdXp6aufSDfC4u0ha4Wx4H3e5ApXYaxx1q9WyM3KTdWPngt4QD5PCTzB4OSqYHhSE7fCm6+vr1uFdrVYViUQ0Pz+vubk5ZTIZHR0dKRwOWy8HHc/tdtuotMfHxz2yKEQsGDOgNVgjRIkItDWbl0Oa+Pdnz571GHLmqDx79kxHR0caGhrSysqKjfAdGRnRRx99pOfPn99YV+f6+uu//mtJVxAO3djhcNi6wVkUVUl3EdZk7vnPfvYzhUIhffrpp/roo4/M6BNxoHpKxAk8CRFDuqqRINdNpIWsOpfhiy++6GFF/eIXv9D9+/e1v7+vV69eqVqtKpPJqNls6t69ez1d+O12u6fAzziAftbLly/l9Xq1vLysZDJpGLIk05ebmJjQzMyMstmsDg8PLQCq1+saHBw0EokkCyogptA9PjAwYJACzoegZnl5Waurqzo5OdEXX3yhSqWi6elpLS4uGolCkmUYwDf7+/t6/vy5QTuSLHPhTLtyMcViUfv7+wqHw/pn/+yfaXV1VZ9//rmRWPpdP/nJT4zy+vXXX1tjKSob7XZb7777rj744AM1Gg2TTYEAUK/XtbGxYfXCoaEhPXnyRF9//bXS6bR+8pOfKBaLWfZXKpW0ublp0BejkGFKra+vq9vt6sGDB5qcnLRaA04JSBAldOAxFNcJwDhrXq9Xi4uLmpqastHS1HtCoZARjt4U4sYx015BAEN9iHHaBIfZbNYEfQuFggWW1PFAaMhwcfh7e3v69a9/rWazqZcvX5oSBPVMvsvdu3f19ttv6/Dw0J5ZNps1B8P4g8XFxR52o+tYyHaSyaSWlpZ0enqq3/zmN9ZPF4vFVKlUjAR1k3Vj5+LSGHk4Lr7tpqE4HjYbJgOURbc4TYGNDYCa5/ZPuAVIPotLKgAOg03jFm55yBhIDBJRgyvrzQWiVgNBQJJFIv06FzI5NzpzI2v3D86bwiGflaYpGt7cTuTrhVqX1QcrSLqCOtz6BFknhhQI0YUo2E9eH6gMZ/9d1GS3iE8No9/M7zrVkj/u6wEjEfESrXKGeHbss5stuJ/3eoGZveMsh8NXI5fZv+tQAa/lUmKly7pTLpczOi6Bkls3c58jf9wCa7+L1+ecQyyQZJkgfWNksdRBqa/xe7AG3ayG94DIIMkyFrdl4Lq2GvvkNjADkcGM5P7wWSmeg3yQaULsIUslsIKsAwzfz4IsQHaAiod7b/k39talIpP1sAfUTchayLT4PRQx2CO33s0fuu+p4QIL+/1+y1gk2b+7lHeXHMEZ5b981larZUMBsVk3vcM3di7UUviAsAqgIJdKJdMBQiEVvj5dzq9evVKpVNLOzo4NGqL5jjkkyGmXSiVtbW3J7/drZmbGoA+YUDQo8fDK5bIKhYJCoZDm5+cViUR0fHys9fV1BQIBLS0tqdvtKpPJWD2lXC5b0+X4+LgdQFha9Xpdjx8/NorkH//xH/ddMwCSILtwncv29rZdQKiOyHozkO3w8FCffvqpfD6f9vb2LCNYWloyxhmGC/VhoikotzgiIkNqLEBfRIc4penpaRsZy0U6PDy0wWwoMdOw2mg0tLu7a9+ZYnC1WtX8/Lz+8A//sG8q8t27dy1D4xwiC8JogJ2dHbsMjGSlQA+9FTolWlVkbRTXMa5u31Q8HrdudKJloB+yQ4yL60gphvr9fq2urloz4ccff2y1KL/fb1RUHPzQ0JDeeusteTwePX/+XM+fP7dC+Jusjz76SNKlc+F7oeX16tUrG3tcLpeVSCS0urraQyUGEqdmQF/U22+/LY/Ho/X1det+X1hYsPsnyaDUu3fvanl5Wbu7uyoWi9ZnBvaPTXBleBgVDWS+ublptRWXvJL421HMOBAcTjwetzNBk2E/686dO+p2uzo8PNTx8bG8Xq+RjxiSt7e319MfxM+Mj49bhz5O3GWBEaRIsoL62dmZXr16pWg0qp///OeanJxUNBo1CjQKBh7P5QA4mqipAVFfwQZTp2HGkUuImpycNId/cHBgUDZnEgjydRizr9Xnwn+JYgKBgDEOwBKBHYCsUqmUfaC1tTU1GpcS5mQQ3e6lVAGDfYaHh02oLpfLKRwO6969e0bNJM1jY4j8oCXC26YmsLu7q1QqpdnZWTPSGOGjoyPDzKPRqG0m3wE+eqVS0Z07d15LV+f6QleL6W+Mc0a6AvkKLgNd58lkUtFo1Ar/GIZSqWT/TlRBbQlDSRaG5A3RDtIQHGyyJ0k9VFT042DjNJuXgngnJyeW6sOOwgBA4yXCo9aAAQBTft0FS4Vn42La7mfL5XKamJjQ22+/bQ6Vs8BnYSAdkCqOHnycqJcAihnlRIqcc3D/fD5v6rFuHxLOGgZROBzWZ599pmfPnlnfBwEYUTU1SYbnvXz5Uvl8XisrK6aS0O/a2dmRx+PpEXek8ZFs7OzsTIVCQRMTE3r48KE9V1oBuLuHh4cqlUqam5vT2NiYarWazQR56623NDo62qOpFY1GFY/HNTs7q/v379s5B9ZyMyA342U0MpkmcDvjlff395VIJLS0tGTEIFiJbvZPcOAiL6+7qMOSTUAjx2ExauTk5MRo26FQyCBXr9drkjpu8+R1JIjz02g0tL+/r5GREY2Pj2t1ddWCW9i7SPDn83kNDw+bFhmOwmV1Aiu6aAPfIxqNmm2AeuxmXNjZ1zl/r6Ut1ul0zCBOTk7q3XffVbPZ1M7Oji4uLoxN0e12zTOycevr6zbNEukVDFo8Hte7776rbrerhYUFJZNJXVxcWKQBBxsYBp0xGq4oYjNdja5ZxN24TEQR0mXj5NTUlAYGBow6CiNsYGDA5lQzarVcLmtjY6PvzIUGO/BQDAiH3Z3y5nbWUutiGJjP57Nualc+nCwIpw57D6IDtQd+n+8lyYwHNTQOHlAmF4DMgRnbiOUR4bu1OHByv9+vs78dyfomi74SLiBMGEnWBAonX7rS0cpkMsrlclZb63Q6Bm/BHOM13N4IdMQwEpAlcOCSLOug1yCZTBozCUIEdHIg4unpactOEomEKTJD2QaSJYihdwOJjn5ptJIsOybqTyaTRkFmVDXwZjwet8ZfCDWcu2azaSKew8PDZsTd0dmuowCGqdfrevLkiba2tsyOdLtdC1Y4Z4FAwOokMA2BdehL63Q6RsmNxWKmgN7pdJTP500hWLqk52Os3R6U113Pnz9Xp9Ox4Xjo/uEoYV42m027AzSpQijiO7I/3DuCdRfWR7QzGo32DBLEgVJXxMY1m03TYUPCyev1Kp/PG/kJuAt4E6fOHQJdcWFRPjP24abrtZ0Lc+aHhoYMqmDyGm+Od0dypF6v69WrV3r69KmCwaBmZ2eVTqftQ6dSKa2urtpGX5fMQHAQymir1TLRSYpmkiz9jUQi5lgSiYRisVgPDZPpgdQVOMDlcln5fF7pdNokqIF16Hjvd1G0A5ddXFzUvXv3zHjAuOJyk4oeHx+b0CBRBPAOKrwuJdx9BhwWnCN1KaAkHD/OBagHqrfbtQ8kSde+x+Ox6YQ8M1YymTQIAUwY3Lbf5Yrn0aXNyAS+U71et2dULBbVbDZ1eHiog4MD++6BQEAzMzOKRqNqNC4Hy8HqwiBEo1FtbGxoY2NDPp/PDC/sLmok6IxB7ZyZmbFsAEYiQcDw8LDBsxhkjAgd8ARE7LUkM7Dlctk69ftd0K/JXCVpZWWl507y3L1er2lT4XDJtr3ey2mQZBSSDMrFkRKdE6SQJT979kxbW1vWBe7xeHRwcKBisWh3dmhoSAsLCxagAJPRrDo7O2uaXEjSTE5OKh6Pm8oBrEVgdzLI76qP3XT97ne/kyQL1BJ/O+0SZQ+fz6fNzU2tra1Z8Eh/FFmcixC4jeRuEM0zHh4etgZvWFqnp6c6PT21AYGS9KMf/UiTk5Pa39/X+vq6jftOJpN6+fKlNjc3FY1GNTs7K+my54h6ChAwdojzj20mmGo2mxoaGjKk5Cbrxs6F4qlblHYLwm5BUpJFuhwO13BeX3hrLhW1h++CoFyWAz/Ha35XIfT6H7eJkULYdx02t5EL+qbbU/G6i8/o7oO7b+7+Sr0EgO/aNzed/rv2xSVAuD/P87vOGPmuPfyu172+N9eXm5b/XT/Tz7p+/q4/V/57/WfZv+uEA3cv+Ixuh7lL13Qvm7tn7nu7z5PXc5/RdTLCdfKAS5r4rvWmLCd3H11CzPVn6pIlgKiu78P1n+Fzu2fu73pfYEfugPuMrhM3rn9nt0jOH/cZfNc+Xf8e/e6jm+nzGq4tcc8O/3Z979zPdP0cuft3naDDz7sNzS65g98D4nbP1nfd8+uf4/o95zNc//+vc5893X7pO7frdt2u23W7btffsfoHcG/X7bpdt+t23a6/Y906l9t1u27X7bpd3/u6dS6363bdrtt1u773detcbtftul2363Z97+vWudyu23W7btft+t7XrXO5Xbfrdt2u2/W9r1vncrtu1+26Xbfre1+3zuV23a7bdbtu1/e+bp3L7bpdt+t23a7vff1/8JccBqK22gkAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -497,19 +497,19 @@ "name": "stderr", "output_type": "stream", "text": [ - " 25%|██▌ | 50/200 [04:00<11:30, 4.60s/it]" + " 25%|██▌ | 50/200 [05:08<15:11, 6.07s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 50, iteration: 468, Discriminator Loss:array(1.04, dtype=float32), Generator Loss: array(0.682963, dtype=float32)\n" + "Epoch: 50, iteration: 468, Discriminator Loss:array(0.505264, dtype=float32), Generator Loss: array(0.691265, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -521,55 +521,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " 50%|█████ | 100/200 [07:56<08:08, 4.88s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch: 100, iteration: 468, Discriminator Loss:array(1.01769, dtype=float32), Generator Loss: array(0.685513, dtype=float32)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 150/200 [12:03<03:53, 4.68s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch: 150, iteration: 468, Discriminator Loss:array(1.0305, dtype=float32), Generator Loss: array(0.684713, dtype=float32)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 200/200 [16:04<00:00, 4.82s/it]\n" + " 26%|██▌ | 52/200 [05:21<15:25, 6.25s/it]" ] } ], From 6f7a6609b912b7ffe001795e00e94f8749f70b12 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Tue, 30 Jul 2024 20:01:14 +0300 Subject: [PATCH 30/38] Updating MLX Notebook --- gan/playground.ipynb | 63 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 61 insertions(+), 2 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 2ec46825..6d6c9c63 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -452,7 +452,7 @@ "metadata": {}, "outputs": [], "source": [ - "lr = 2e-6\n", + "lr = 2e-6 # use 4 instead\n", "z_dim = 128\n", "\n", "gen = Generator(z_dim)\n", @@ -521,7 +521,66 @@ "name": "stderr", "output_type": "stream", "text": [ - " 26%|██▌ | 52/200 [05:21<15:25, 6.25s/it]" + " 50%|█████ | 100/200 [10:15<10:18, 6.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 100, iteration: 468, Discriminator Loss:array(0.520561, dtype=float32), Generator Loss: array(0.69128, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 150/200 [15:19<05:50, 7.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 150, iteration: 468, Discriminator Loss:array(0.512105, dtype=float32), Generator Loss: array(0.68507, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 83%|████████▎ | 166/200 [17:10<03:31, 6.21s/it]\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[21], line 17\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m tqdm(\u001b[38;5;28mrange\u001b[39m(n_epochs)):\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx,real \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(batch_iterate(batch_size, train_images)):\n\u001b[1;32m 15\u001b[0m \n\u001b[1;32m 16\u001b[0m \u001b[38;5;66;03m# TODO Train Discriminator\u001b[39;00m\n\u001b[0;32m---> 17\u001b[0m D_loss,D_grads \u001b[38;5;241m=\u001b[39m D_loss_grad(gen, disc,\u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreal\u001b[49m\u001b[43m)\u001b[49m, batch_size, z_dim)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 20\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], From f70cef9567e4ed409dbbb30d09f942f03cbe956d Mon Sep 17 00:00:00 2001 From: Shubbair Date: Wed, 31 Jul 2024 11:25:39 +0300 Subject: [PATCH 31/38] Updating GAN Code... --- gan/playground.ipynb | 133 +++++++++++++++++-------------------------- 1 file changed, 51 insertions(+), 82 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 6d6c9c63..de7187fb 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 64, "metadata": {}, "outputs": [], "source": [ @@ -33,11 +33,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ - "# mx.set_default_device(mx.gpu)" + "# mx.set_default_device(mx.gpu)\n", + "mx.random.seed(42)" ] }, { @@ -56,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 66, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -95,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 68, "metadata": {}, "outputs": [ { @@ -123,7 +124,7 @@ ")" ] }, - "execution_count": 6, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" } @@ -135,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 69, "metadata": {}, "outputs": [], "source": [ @@ -146,12 +147,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 70, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -176,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 71, "metadata": {}, "outputs": [], "source": [ @@ -190,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 72, "metadata": {}, "outputs": [], "source": [ @@ -215,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 73, "metadata": {}, "outputs": [ { @@ -244,7 +245,7 @@ ")" ] }, - "execution_count": 11, + "execution_count": 73, "metadata": {}, "output_type": "execute_result" } @@ -277,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 74, "metadata": {}, "outputs": [], "source": [ @@ -311,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 75, "metadata": {}, "outputs": [], "source": [ @@ -331,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 76, "metadata": {}, "outputs": [], "source": [ @@ -341,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 77, "metadata": {}, "outputs": [], "source": [ @@ -351,16 +352,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 78, "metadata": {}, "output_type": "execute_result" }, @@ -381,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 79, "metadata": {}, "outputs": [], "source": [ @@ -394,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 80, "metadata": {}, "outputs": [], "source": [ @@ -418,12 +419,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 81, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADUW0lEQVR4nOy9V3CcV5qf/3TOOaIbjQzmKJHiSBppFCZodnZndr01413v1rocrnztS1/7wr7xre2yXXZ5y+ta22WPJu7OaDSKpCRGMIFERid0zjn8L/Q/Rw0SDCIBAmh+TxWKEtFofn1wvu89b/q9qn6/30dBQUFBQWEbUe/2BSgoKCgoDB+KcVFQUFBQ2HYU46KgoKCgsO0oxkVBQUFBYdtRjIuCgoKCwrajGBcFBQUFhW1HMS4KCgoKCtuOYlwUFBQUFLYdxbgoKCgoKGw72sd9oUql2snr2Fc8iaiBsn5foazf0/GkohrKGn6FsgefjsdZP8VzUVBQUFDYdhTjoqCgoKCw7SjGRUFBQUFh21GMi4KCgoLCtqMYFwUFBQWFbUcxLgoKCgoK285jlyIrPD+IkktljtyDubcsVVkrhaflYaXO+3F/KcZFAQCn00kgEMBisTA+Po7RaGRubo5bt27R6/X25ebebrRaLVqtlkAgwNmzZzGbzRQKBWq1GtFolLt379Ltdnf7MhX2IS6Xi+PHj2O32wkGgzidTvm9crnMF198wcbGBqVSiVKptHsX+jVQjIsCAB6Ph+PHjxMIBHjzzTfxer385//8n7lz5w6A8tAEdDodJpOJqakp/uqv/gq/38/i4iLpdJrz58+zsrKirJPCE+HxePjOd77D+Pg4L774IlNTU/J7sViMf/fv/h1XrlxhbW1NMS6Pg0ql2vSlVqsxm80YDAb0ej0mkwm1Wo3FYkGrfbxL7Xa7tFotut0upVKJcrlMp9OhXq8rJ/BHoFar0el02O12XC4XTqcTh8NBo9GgWq3S6/V2+xKfGSqVCo1Gs2l/BgIBwuEwMzMzeL1eHA4HLpeLTqeDyWRSOrgVnpher0ez2aRWq9Fqteh0Ouh0OvR6PWazmUAgQCQSoVAooFar98W9uKvGRavVotPpUKvV6PV69Ho9Bw8eJBQK4ff7mZqawmazMTMzg8PhkDc5fBmD3MpQNJtN4vG4dCWvXr1KPp9neXmZRqNBp9PZF7+Y3UKr1RIMBhkfH2dmZoaDBw+Sy+VYXFyk2Wzu9uU9M/R6PRaLBbVaLcNh3/nOd3jnnXfw+XwcPHgQvV5Pv9/HZrNx8+ZN1GqlPkbhyajX6ywsLFCpVPD7/ZhMJux2Oz6fD4vFwrlz5xgbG6PVanH37l06nc6e95KfmXEZPAFqNBrUajUGgwGDwYBWq0Wv12M0GvH7/YRCIUZGRpiamsLhcHDkyBFcLtdjGZdGo4HNZqNUKpFKpUgkEqhUKlKpFCqVinq9TqvVelYfe0fY6oS8XR6Z+L2YTCbMZjMWi4VarTYUp3K1Wr1p/z0Ms9mM3W6XhkWr1RIKhZiensZut2OxWNBoNHKd9Hr9M/oU+wMRidBoNJv+vtfryQiCEkX4ik6nQ7FYxGAwUCwWKZfL6HQ6+v0+arUaj8cDfJkbNRqNtFotGo3Gnl7DZ2ZcLBYLXq8Xi8XC7OysDLu43W6MRiMulwu9Xo/H48Fms2GxWHA6ndItFIjFfNCiarVa/H4/TqeTN954g8OHD5NOp5mbmyObzfLpp5+yvLxMt9ul0+k8k8++najVaux2O3q9nm63S6/Xo9Pp7EjYSrz3Xj8hPQ4WiwWPx4PZbObAgQObEqZbEQwGmZ2dRafTodFo0Gg0TE9PEw6H0ev1aLXa+0IZe/lGf5aYTCb0ej2BQIDp6Wl0Oh3w5T0bi8WIxWI0m03K5fJQ7K3toFwuc/PmTdbX1zEYDOTzeQ4fPszIyAgGg4HR0VE8Hg8vvfQShUKBjY0NLl++TLVa3e1LfyDPzLgYjUYCgQBut5uXXnqJ0dFRgsEgIyMjWCwWgsHgI09/9968W93MGo0Gh8MBgN/vByCVSuH3+0kmk6ysrBCLxWRcc78hclAmk0k++JvNpswpbSf9fp9er0e32933D06j0YjP58PtdnPmzBlGR0cf+vqpqSlefPFFjEajzL3A5j3X6/Vot9s0m8197w1vFyqVCoPBgNlsJhQK8eKLL2IwGIAv18tgMFCtVuWXYly+pNFosLq6il6vx+l00m63sdlsdLtduXd7vR4HDx4km81y9+5dbt68+XwbF3Hq83q9HD58GI/Hw/T0tCy3czgcGAyGR4Yp+v2+3JAPMirilGkymTYVABiNRoLBIBqNhkAggMfjoVQq7cvTptls5syZM4yNjUnjkkqlOH/+PMViURYzfF1EGEOEjvr9Po1Gg3w+T61W2/d5KlGo4Ha7iUQiTExMPPT1brebbrdLo9GQYRwRxhWItV9YWCCTyez7NdoONBoNY2NjsvDh4MGDGAwGNBqNDPGYTCbS6TS9Xo96vY7FYkGv18swmkqlQqvVbgqpVatVUqkU7XZbeuxbIcJt+zXs1uv1yOfzRKNRcrncps+pUqnk87PRaGCxWKhWq7Tb7T2593bcuIgbcmJigu985zv4/X4OHTqE2+2Wse/BXMqD6Pf7ZDIZ1tbWttw4JpMJm80mDcmgcbFarRw6dIhAIMDs7CzJZJJoNEqhUNh3G9DhcPDnf/7nvP7663S7XbrdLlevXpVeWbFYpF6vf+33FYnrwVN6qVQikUjQaDT2/QlT7IvR0VFOnjzJ4cOHH/r6drstC0AqlQqdTgev17vJuLTbbebn5/n000+VHpf/H51OxwsvvMCrr75KJBLhxIkTGAwGdDodKpWKw4cPs7a2xt27d6nVahSLRUZHR3G73Wi1WpmDtdlsMpwGsL6+zscff0ypVKLRaNBut7f894XhESHd/Ua322V1dZWNjQ1mZmY27SmVSsX4+Dhutxu9Xs9Pf/pTeeDei8U2O2pcVCoVOp0Oo9GI1WrF7Xbjcrkwm80YjcZNrxWnw2azuSncIP6+1+sRjUalcYHNIQqz2YzNZsNqtWK1WjdV+YhqNIPBgNFoxGQyYTAY9m2Sut/vS3dZ5KtEnqpWqz2RcdFqtVgsFsxms/QiRUhsGB6a/X6fVqtFs9mk0+nQ6XSkp9bpdDZ5KP1+n3q9TqlUot1uUyqV6HQ6Mic4uG/a7Tb1ep12u73vDipPgzgUintK3KPi/hLJaNEK4PV6MRqNsgKqVCoRiURwOByEw2FcLpcs7NFqtVit1k3GBWB8fJxyuSyN/r2I50en06FWq5HNZvfd3u33+3Q6HRmBuHdP6XQ6LBYLRqNRPtv26nNsx42Ly+UiGAwyOTkpE6kWi2XT60T4od1us7q6SjqdJpFIMD8/T6PRkN9LJBIkEoktXUCj0ShzNz/5yU+YnJzE7/fj8/nka9RqNS6Xi1AoRLFY3LO/lIdRrVZ57733iMVinD17lnPnzuF0Ojlw4AAGg0E+DL8uXq+XkydPEgwGsVqtO3Dlu0sul5Me3sGDBymXy7IaLpfLce3aNcrlMs1mk3a7TbVaJZfL0Wq1KJVKdLtd/vIv/5KJiYl9uW+2E9GPptfrOXz4MEePHqXb7VIul4Ev78X19XWWlpb4zW9+g9fr5cc//jFTU1N4PB6sVqtM9nc6HYxGo/RshMG/t6Kv0Wjwve99T7YSbHXA7Pf7pFIpstks169f52/+5m8oFovPdnF2GNG6IXKB91bj7SV23LgYjUZsNht2ux2Hw4HNZkOlUm0yEKLxsV6vk8lkiMViLC0tcenSpU0nyHQ6TSqV2vLfEk2XkUiE1157DafTid1uf+D17FfPpdVqSe9tcnJSlg673W4qlcp9HuHjIpKGHo9HnjqHiWazSSaTASCRSGC32+VXMpnk5s2b5PN56vU6zWaTSqVCNpul1WpRLBbp9Xq89dZbQ7cuT4LYcyLUeOjQIdrtNtlslna7jVarpVqtks1mWV9fJxAIUKlUAKS3LTyWJ2Hwvr23wGJ9fZ1kMkmj0dj35eGDBlR8ZmF8RQj7ufVc+v0++Xyefr/PpUuX+F//63/hcDjw+XyYTCZKpZLMEWxsbNBoNIjFYuRyOXK5HOvr69JFFOW2D0JUTVUqFVl14XA4iEQi8jUioT85OUksFtuzv5SH0Wq1WFxcJJvNcvz4cer1Ot1uV/Zb3BtKeFwGq6EajQYqlWqTa77fH6rCO87n83z88cfMz8/LB2S5XGZ5eZlarSZDZu12m1qtJkvW9/IJ8Vlht9vx+/3Y7XaOHTuGz+djenqamZkZNjY2WFhYoFwu4/P5sNvtTE1NcfbsWVwul6zcfFJE2K3f78u8YKfTkZ5mLpejXq+ztrZGPB5ndXX1gXmZvY74rMKDFgdnURQBX/4uTp48icfjYW5ujmg0KnNNe4UdNS69Xo9cLkexWKRWq5HP57Hb7Rw5cgSPx8P6+jpra2sUi0WWlpao1WoyOXXvA+1RDzeRGyiXy6ytrQEwMTGxyeprNBqCwSAAt2/f3pcd1cK4aDQavvWtb0njIpr+ntS4ALJKTKx/q9Xacxv2SRH7o9Fo8Pvf/17uCfGZtzKgorpJhCCed+x2uyyM+cEPfsDU1BRWqxW73S49v2QyicViweVyMTs7y3e/+10p4/Q0iFyE+B1pNBrZY1SpVFhcXKRUKrG0tMT6+jrLy8v72rj0+33a7TaVSkXKYQ3uQafTyZkzZwiFQqTTaZLJ5EOr6HaDHa8WEx+2Xq+Ty+VkCZ1oBEqlUrLiQeRWnjYJN9gFLCrRBv9buJb7FXGy2Y5OZ1G+bTabcTgcWCwWms0mzWZzaOVyvs7nGQav7WlQqVTYbDZMJhPhcJjx8XF8Ph9OpxOz2SwT55lMRko0RSIRIpEIXq9XPhTFg+/e9ez1ejJJ/7DiEeFJArKirFgskslkqNVqrK+vU61WicfjMu+y35L5AlGwU6lUiMfjtNtt2ZgqMBgMjIyMyKZqo9Eovbi9wo4bF7GpCoUC1WoVtVrNnTt30Gg0tNttWaMt/tzOG3lQcuZhf7efeZr1UqvV0qCMj49z6NAhNBoN6+vrFAoFMpnMpioqhecPrVbLzMyMLMh5/fXXsdvthEIhLBYLH3/8MR988AE6nY7Dhw9jsVh44YUXmJqakiXIvV6ParW6KeQoaLfbXL16lfX1der1OuVyecu9VqvVyGQy9Pt9HA4HRqORtbU1bt26tSmEKZ4potp0PyLWaXV1ld/+9reMjo7idDqx2WzyNS6Xi5dffplcLsdnn30mQ5J7SRLmmXToC5dWlA/uRFfpoG6ZTqeTVRWD1yCuYzu8o91Eo9Hc15PyJJ30KpVKxnNFzkbEsge9lr2yWRWeLeKecjgcjIyMEAgEpJCiVqul2+1SLBaJRqMyv+lwOHA6nTidTnq9ntxHpVJJlgkPGpdmsyn7zmq1GqVS6YHGZWNjg36/j9PpxGQysbKywtLSEu12e1PIbL8jPke9XieVSmEwGO4zlFqtFrvdLoVTzWYzzWZTRmn2Avt+nosI64hemkAgwMGDB5mcnMTj8WySMGk0GiwtLTE/P8/6+vq+NDB6vZ7R0VF5ehS6ayLu+nUMt0ajIRQKEYlECIVC8pSpoCDCx0ajkZdeeok//MM/lLkU0TxaKBS4cOECly9fJhgMEolE0Ol0xONxVCoVGxsb3L17l2q1ytraGuVyWfZhiQdgt9slnU7LfpgHdZuLAw8ge2HK5bLMC+6VB+p2kkwm+fjjj5mYmODtt99mdHT0PuUCrVbLxMQEp06dYmFhgVQqtWfu4X1vXISnYjabcTqdeL1ewuEwkUhEliKLGGar1WJjY4Pl5WXpYu83NBoNPp9P6rSJOGypVKJQKHwtjSu1Wo3b7ZYd0mLTDkvIUOHpEPN9ZmZmePXVV2U1ZqlUIhaLsba2xsLCAktLS1LJwGazkc/n0Wq13L17l08++YR8Ps/t27fJ5/OUy2XZD6PwcIrFIsViUfautdttGZ0RqFQqfD4fk5OTctbLXmFfGRfhpuv1eux2OwaDgVAoJI2KeEhOTU3h8/nkqb7RaJDJZMjlciwvL7O4uLhvtaD0ej1TU1NSnw2+kuvO5/NPLaDY7XapVqsyjKHwfGIwGPD7/bjdbtn0nMvluHXrFtlslkuXLhGLxUgkEvT7fSqVCtevXycajbKysiL7h4TnIsZB76WE836h2WyytLSEy+UiHA5vEl0VQrbi97SXDob7yriIzl2bzcbU1BROp5Nz584xNTXF2NgYR48elUPHBjt8a7Uai4uLJBIJLl26xPnz5/dc2d7jIoQrz549SzgcRqVS0Ww22djYIJFIPHU+q9vtksvlSKVSsjpH4fnDbDZz8OBB6SEL+aVf/vKXxONxLly4QCKRkLI3uVyO9957T1ZiqtVq2SMkIgfPe+Xdk1Kr1bh06RKFQoHXXntN3vfwVfQhHA7jdDoV4/J1ERo6VqtVxn3Hx8dxOp2EQiECgYAcO3tvP4Lo2xDlktVqdV/Lo4t1cDqdqNVqqtUqlUqFer2+LQKTgzNKlFPm84tOp8Pr9RIIBKSskFAmzmQylMvlTRp2Yt8obD+i52wrTbXBoWx7KSQG+8C4aLVavF4vZrOZY8eOcfToUQKBAC+++KKUlBFClPcurugFSSaTvP/++8TjcZLJ5C59ku1Bq9USCAQYHx8nHo+zuLjIjRs3SCaTZLPZp1aCbbfbJJNJ2dyqnDSfT1wuF2+88QbT09N4PB7S6TRLS0t89tlnZLPZJ9KvU3i+2NPGRcx1sFgs2Gw2wuEwBw8eZGRkhOPHjz9SYFH0z9RqNeLxOLFYbN+GekS+SayH1Wql0+nIhrHtkt3u9Xqy61nxXLZmL4UedgrRpDc6OirHg5fLZZm7hK+/DoNlssqh5enYD3twzxoXkbwSeZVgMMjU1BSTk5PYbLbHmlqZz+fJZDKsrKxIQbsnkaPfTYTbOzo6yqlTp4hEIlKnKRaLcf78edmA9rT/jvi3hDEXSrXKg+Dh7Icb/etSr9dZXV1FpVLh9/txOBy43W5eeOEF8vk8hUJBlgY/ChF9EPPhxVA7UX48jCoQO8HDmr/34h7c08bl6NGjhEIhfvSjH0mj8nXk4PP5PCsrK6yurhKNRh+oqLyXEcnRSCTCD37wA9nMBl8al88++4x8Pv/YN/q93LthhRSMUI5W+IoHqT2I/x4mxNjdbrcrqzPdbjenT5+mUCiwsrLy2KExk8nEzMwMdrtd6gmKAWxiZpNiXB7Ow4zKXt17e8K4aDQaqRckSovHxsY4duwYXq9XDhgTXfei6kTIygiZdCExIUI60WhUyvfv1yS+TqeTCs+BQACn0ylHD29sbEhZnQcl8kUj3OAwMK1WK4c6HTp0SJZui7UdBhWDnWArD25YvbpGo8Ha2hrtdpvJyUnMZjNer5eZmRmq1Soul+uxKxMNBgPhcFjq1wUCAfL5vBzTK2RLBgcEij8VvuRB+2wvV+DtqnERVlfMEnE6nfzkJz/hlVdewW63EwgE0Ol0WK3WLeVOms0mN2/eZHV1lUQiwdLSEqVSidu3b8umI7Fh92MCUqVSycmaY2NjnDp1Cp1Ox4ULF4jH43z++eesr69L+Yut0Gq1jIyMYLPZmJmZYXp6GqvVKm/26elp/H6/lPQQU/zK5fJzN13xcdhKqXsv3+BPSj6f57333sPpdHLq1CmCwSBut5vZ2dlNWoCPiyi4EXs1Ho/zwQcfkMvliMVi5PN5isWiHL0h/lTYzMOMzF5j142LGEHsdrvxeDyMjo7Kk5Iotx18PXzVcd9ut8nn88TjceLxOGtraxQKBZaXl4diAp0YE202m+XURLVaTaPR2BTzHpxIJ4YHibU1mUz4fD4cDgfBYFAaGiEdIxrltFqtXN9msylH9yrcz168kbcb0ZgrCjw6nY4cQ/woBqVd7tX80mq/fOSIAYKdTod6vS73cKvVkoPaFDbzoBEk4l7XarXodDoZddjtfbqrxkWr1WIwGJicnOSv/uqviEQiHD58WM7T3iqWKPpWMpkM+Xye3//+93z00UdUKhV52t6vFWH3olKp8Hg8UuZ80IBotVpGR0c5c+bMppnjQsTOarXi8XgwGo2Ew2EsFosUvBTGWWzAwWl2jUaD+fl5rly5Iic3Kjx/iLBzq9Xi+vXr/OpXv8Jms23ahw+i0WjIxt67d+9ueUgRs0rUajWhUIhDhw7RaDSo1WqkUil+9rOfyWGBSnj2wahUKtn7FwqFOHDgAIVCgXg8vuvPwV01LkIXzOv18uqrrzI1NXXf3AJhfQerltrtNuVymVwux/z8PF988cWuXP9OI8JiYrKfWq2m1+vJpimXy8Xk5CQGg0FW44hJgR6Ph0gkgslkwu/3YzKZyOfzMl+TTqc3hTWEcWm326RSKaLR6L7NUylsD71ej06nQzQaZW5uDo/HQ7vdfuhAun6/LxssFxYW+OSTT7YskTcajXg8Hmw2GwcPHpSD/brdLtFolA8++ACtVitFZxW2RshhiUjPyMgIer2edDq925e2u8ZFVIsUCgVu3bpFvV5nfHwcr9crT9lbIU7uwvMxGAzSBR8m+v0+mUyG5eVlRkZGyGaz0oDo9XoCgQDlcnlTXkoMdlKr1RQKBbLZLLdu3ZLenphz3mq10Ov10sOpVCpUq1UpIaMk9BXgy9DW2tqaPCHfvXv3oZ6LiCy02202NjaIxWJbHlJEWbLBYKDRaHDr1i2cTid+v59Go8FLL73E7OysbCNoNBoUi8V9vSdFiLvf78tQ49Mihrmp1Wqmp6d55ZVXSCQS5HI5mZferUPirhoXkdxLJpN8+umnrK6u8vrrr2M2mzEYDJsS+Pdy7xySZrO5J+KM20m32yUWi5FOp/F6vcRiMTweDxMTE+h0Ohm6gM25FpVKRSqVYmlpiUwmw/vvv080GiWZTJJMJmX4zO12c+DAAQ4fPizLtpeXlxXRSgUAOWr3xo0b3L59W8b2H+fn4CvP50GI9/rss89Qq9UcOnSIl19+Ga/Xyw9+8AOcTid///d/z+9//3vZKLyfjYsoXOr3+yQSiW0xLmq1Go/Hg9vtxm63MzY2xsrKCnfv3qXRaGyLmO2TsuulyOKkI3pQYrEYdrsdm80mPRhhaAQajUYKVBqNRnka2G8Nko+D2IC5XI6lpSXy+fxjNZGm02lWV1fJ5XJsbGyQyWQoFAqUy2U5IbDVasnxzyK+LuZjKCgIBgf9bSfCUIicTKlUIpvNSs08k8kkKyW1Wi1ra2v7eoCdyI2K4ojtQhwodTodRqNRth4M5lJ3g103LvBl2eOHH34op8uNjY1x8OBBWZIcDoc3NU/qdDpcLhdqtVrObhEDh/bzyWYrRELz6tWr/Nt/+29lOPBxfk5UfIk5L4ODlURliTDQ8OWE0O1y1xUUvi6pVIrPP/8ch8NBvV6XfTX/+B//Y65evUosFmNjY2Pfis9arVbGx8fpdDqk0+l92R7xddgTxqXVapFKpeREyVqthsFg4PDhw3Ls7iCifNlgMMjTTaFQ2J2L32FED0Uul5OaTtuBONUMqqnu1AlVQeFxaDQapNNpGo0GsViMZrPJkSNHmJmZIZvNYjQa0ev1+zZCIdQv2u32Iyvu7kWoGIjnwYM8EvH9wZD5brEnjIug1+uRyWSo1+sYjUYCgQDBYJBgMIjT6ZSv63a7siNfTGAcHJ2q8PUYlDDZq1ISCsOPKPDp9/vcuXOHeDzO8ePHZShMHIT26x4tFApcvXqVXq/3tbwWMSysUqlw+PBh2u32feOOxevy+TzZbFbqv+2mId5TxqXf75PNZslms2i1WpxOJ4VCgW984xubXtfr9WRN/KBxUXhy9usNqzA8iOqmZrNJuVxGr9eTSqWkcXncgoK9SqFQeKIIS6vVYnV1lWw2SyqVkuOO7zW0ovK2UChI47Kb7KhxEYKLPp8PvV6PxWKh1+uRzWZll7kombs3HCOarIROWLfb3TTlTiSvvF4v4XAYtVqtdPUqKAwRothH9M08r5EJsQ5CwWC/yA3tqHHR6/W89dZbvPXWW3i9Xqanp2k2m5w/f554PM4XX3zB+fPnZYhrMBlfr9fZ2NiQORjRvCX6X8S8aOEmXr16lZWVlaFL6D8r9suGVXh+6Pf7FItFYrEYmUzmub23u90uxWKRer1OrVbbN9VyO2ZcRKOjGEXs9/sZGxuj2WwSjUZRqVREo1ECgQCVSkWO8oQvN5VojtTr9bJUViAS0VqtFrPZjN1ux2g0KqGdx0T8boSY4IM0i54ntipwEH9vNBqlavcgKpUKg8GAxWKRPVetVmtfl8vuBcS6DopdPu8iqiK6s58M7I4YF1HPbbPZCAQCUixRrVZjMBg4duwYU1NTHDx4kO9973tEo1F+85vfkMvl5I05PT3N2bNn8fv9jIyM3PcgFH9arVbcbrf0ZBQejdVq5fDhw/cVSjyviJEGQv3A4XDI74nKRL1eTzgc3rTHdDodJ06cwG63Mz8/j8VioVgssra2RrValRpbCl8Pq9XKmTNn8Pv9TE9Py1C4wv5iR4yLOO1ZLBY51dBsNssxvSMjIwBMTEzQ7Xa5c+eOlM0XnfZTU1OcOHECl8uF3W6XlRH3qoEKXR0xNVHh0ej1evx+P8FgEJPJtNuXs+toNBo56yYUCslhbPCVMrVWq91kdMTPhUIhTCYT/X5fjpwuFApyJo7C18doNDIxMSEFW5UqxvvZ7TLjx2FHjIuQjWg0GrKqS6PR3FefLU4jHo+Hl19+mVKpJD0XMb/bZDLdJ5TX7XblzJEbN25w5coVFhcXlR6Nx0QURIjha/CVCu5+2LTbxcjICOFwGLfbzeHDh6Wnfa83J8o+x8bG7ptEabPZ0Gg0zM7OolarSSaTZLNZ2TO028q024F4uItBX71ej3g8TqVSeer3VqvVeL1erFarHCbm8/k4d+4c4XAY+Erg9nk3MGJ0++LiIk6nk9HR0ftEfoXa+V64j3fEuIhSYa1WS6VSoVQqSeMyiHB3g8Egf/iHf3ifVyK0xe51idvtNsVikUwmw6effsrf//3fK53lXwPh8Q3K6gzGdJ+H2LZKpWJqaorXX3+d0dFR3nzzTdxu932q3IM9QPdq3anVapxOp3zonjhxgpWVFW7evEm1Wh2a8niRh/L7/bz00ku0222q1eq2GBeNRkMkEiESiRAIBJicnMTn8/Hmm2/i8/mIx+Mkk0mpIvE80+/32djY4Pr164RCIVmFO/h9YVz2AjvmuYhhXqlUipWVFVqtlpSFF7o3ApGLedhDbXD8bqVSIZFIkE6nKRQK1Go1WaKn8GiEZ9lqtWRfQaVSkTNynpdwjk6nk8KnVqsVi8VyX+L+QTOFBr8/OMROFJ8ID3wYEJWEQlJIpVIxOjqKzWaTFUydTodGo7FpSqU4GIrO9MF1FQrBRqORmZkZWfQTDodxOp3ye3q9ftPzYljW9EkRwxDhS0UDo9Eofz+FQkEK1O4FeZwd81yEjtXvfvc77t69y9mzZ7HZbLhcLtxu9xOdRIrFItlslmg0yu9+9zvS6TR37tyR1WYKj4eY4KnX69nY2MDr9XLr1i3ef/990un0UEzxfBzEqILBaq8nDb0IAy1kegYnhe53RJglk8kwNzeH1+vlH/7Df8jMzAw3b95kbm6OYrHIwsICtVqNXC5HpVJBp9PJvOuxY8dwuVzyPb1eL8ePH5dKvh6PR+rcCdVucei02WwYDAZ5GNorJ/NnTa/X4/LlyywvL3PmzBlOnjwJIEccfP755/z1X/81uVxOCgHvJjtWiixOMOl0mnq9zsjICMViUW4cEe9/2M08KN3d7/epVqsUCgUymQzRaJSNjY2hFKvcabrdLvV6nWq1SrlclkY7kUhQKBSeG88Fvso1CU9uKwY9kwch1CIqlQqNRoNWqzVU+1K0ChQKBSwWCyMjIxw8eJB6vU4ul8NkMpHL5dBqtTSbTTqdDkajEavVit1uJxAI4Pf75fsFAgEOHz4sB1w5nU7pBQovSZR1i1DP4PTU5xXRgR8MBikUCtJ7FPqMq6ure2Zkhqr/mL+pJz3RCdf20KFDvPXWW/h8Ps6ePUswGJRejGDwUur1urxRxQCrubk55ubmyOfz3L17l2q1SiaT2ZbY79fhSTb3XkpGiqoos9ksT41ra2tyqFi5XN7R/NVeWb/x8XEmJyex2WyMjo4+VVy/3W7TbDYpFot89tlnZLPZHRvU9KQP16ddQ9EbZbfbee211wiHw4RCIUKhkIxWdLtdWYYtXq/T6XC73TL03ev1cDqdzMzMYDabZThSXF8ul+M3v/kNsVhMVuDFYjEuXLhApVLZlpDjXtmDT0ooFOK1117DbrfLMOTS0hJzc3PSw9vJEOLjrN+OGxeBz+djenoav9/PH/3RHzE9Pc3Y2BgTExNbngyLxSLJZJJyucz169dJp9N88MEHfPTRR1Lgbrfir/t9Y97L4AjpZ8FeXL/tfP+dXsvdMi7iPTQaDXa7HZPJxE9+8hP+8i//Ulba6XQ66V0M3tfVanWTFyIGZ201PmJ5eZl//a//NVevXpWziEQOd7vWdi/uwa/Lvdez1+7hZyZcKRQ7e70eV69eJZlMcvfu3U09BYNUq1VyuRyNRkO6ekLErtPpPNeu8XajrKWyBo+L8DyER5ZMJrlz5w5Wq1WKTYoEc6vVkqXYIrEvDI9er6dYLKJWq2X4S6icJxIJ1tbWyOfz1Ot1eb8rv6PN7PX1eGaei9hcYmaL6B140FwDUXEmKpsG50Hv9qIOw6lnN1HW7+nYTc9l8L3UajVHjx7lxIkT2Gw2xsbGMBgM8jXpdJq1tTW0Wi0TExPYbLb7fl4UCtRqNVZXV7l+/boUtRVhtp3IXSl78OnYU56LaNATzZUKCgr7F3H4q1QqpFIpqtUqOp1uk3HJZDLE43GpYL5VQ2mn0yGfz1OpVIhGo8RiMamCvtuHSIWn45l5LsOEcup5OpT1ezr2guciEPJOWq1WRiQEQp1DrVZjsVjuU9qAr+TkRSFAsVh8JqKfyh58OvZUQn+YUDbm06Gs39Oxl4zLfkXZg0/H46yfIjWqoKCgoLDtKMZFQUFBQWHbUYyLgoKCgsK289g5FwUFBQUFhcdF8VwUFBQUFLYdxbgoKCgoKGw7inFRUFBQUNh2FOOioKCgoLDtKMZFQUFBQWHbUYyLgoKCgsK2oxgXBQUFBYVtRzEuCgoKCgrbjmJcFBQUFBS2HcW4KCgoKChsO4pxUVBQUFDYdhTjoqCgoKCw7SjGRUFBQUFh29E++iVfokxh+wplit3Toazf06FMonx6lD34dCiTKBUUFBQUdgXFuCgoKCgobDuKcVFQUFBQ2HYU46KgoKCgsO08dkJfQUFB4VmhVqtRqVTo9Xp0Oh0qlQq1+suzcK/Xo9fr0el0aLVa9Pt9er3eLl+xwr0oxkVBQWFPodFosFqt6PV6pqenmZycRK/XY7PZACgWizQaDdbX11lYWKDZbFKr1eh2u7t85QqDPDPjsh1lfE9agqmgoLB/UKvVGI1GTCYTIyMjzM7OYjabcblcAGQyGSqVCp1Oh1gsBkCj0VCMC/c/Z3fzmbmjxkWtVjM2Nobf78fn8zEzM4NOp3voz3S7XXq9Hrlcjmg0umnDNBoNGo0GtVqNjY0NWq0WnU5H2VQKCvsYlUqFSqXCZrPhcrlwOp2cPn0an8/H9PQ04+Pj6HQ6zGYzANVqlVarhdfrRa/Xk8lkuHTpEvl8fpc/ye5gMBjQarUcPnyYV199lV6vRzQapVwus7CwwMrKyq5c144aF41Gw8zMDMePH+fkyZP80R/9ERaL5YHWtN/vS4Nx584dPv74YxqNhvx+oVAgl8uRyWRoNBpUKhXq9bqMtyqejYLC/kPkV1wuFwcPHiQUCvEP/+E/ZGJiArfbjdPplAYIvrzP+/0+oVAIm83G8vIyd+/efS6Ni0qlkl7eq6++yr/6V/+KbrfLRx99RDwe52c/+xmrq6u78mzcUeOiUqkwGAzYbDbMZjNGoxGDwfDQD6rRaOh2u7hcLkZHR2m328CXG8rpdOLxePB6vahUKsrlMvl8nkqlQqvVol6v0+l0qNVqdDoder2eYnAUFPYoGo0GjUZDMBjEbrczOjrKoUOH8Pv9eDwebDYber0e+PL+73a7qFQq+XMmkwmHw4HdbkerfT7Tx2q1GpfLhdvtxuPxYDQaaTQaVKtVCoXCpsP5s2bHjYvdbicQCOBwOIBHexdi44yNjeHxeDa9vtvt0u126XQ6MkR2/fp1otEoqVSKlZUVSqUSt2/fplgs0mw2pXFSUFDYO2g0GoxGIzabjR/84AecPXuWUCjEzMwMBoMBp9OJTqej3W5TqVTkfS+eKUajEYfDweTkJK1WSxqh5w29Xs+JEyc4evQoR48eRaPRUKvVmJub48aNG8RisV07YO+4uRdlgt1ul1arhVqtRqPRoFKppGchygwHXV+j0YjRaHzoewtvRafTYTAYaDQaGI1GYrEYnU6Hfr8/1MZlcN3EnxqNRpZsPghxChS/G/GnUs65PYg9LH4ngwzu83tDPe12m06n88yv91kiPrPIoVitVkZHR5meniYYDDI2NiajF71ej2azSbVapd/v0+l00Gg0WCwWALRaLSaTCaPRiEaj2eVP9uwR97vL5WJkZASHwyGfq81mk0ajsav7aUeNS6fTYW5ujmKxyNTUFNlsFofDwdjYGDabjWKxSD6fx2KxMDY2JmOHj3sK0Wq1TExM4PF4OHDgAKdPn6ZUKnHs2DEymQwff/wxn3/++dCGxoQrbLVaCYVCWCwWGbN+GIVCgcXFRSqVCslkkmKxSC6XI5FISO9wWNdsp1Gr1VgsFnQ6HV6vF7fbvel7DocDi8WCzWbD4/HIg0C73ebDDz/kiy++2K1LfybY7XYZzfjGN76Bz+fj5Zdflh5Lp9OhXC6zuLhIqVRiZWWF9fV1LBYL4XAYm83G6dOnpYF5XtHr9TgcDhwOB1NTUxw6dIiRkRE0Gg12u50333yTAwcO8O6777K2tjZ8OZdut8vy8jKJRIJUKoVKpcLj8QDg9/uJx+NEo1FcLhd2ux2bzYZOp3ts46JWqwkEAgQCAfl31WqVYDBIKpUiHo/z+eef78hn2wsIo+LxeDh+/Dhut5s333yTo0ePbnrd4Om53++TSCT46KOPyGaz3Lp1i0QigVarJZvN0mq1lFzVU6BWq+VpemRkhLGxMbn+Go2G0dFRHA4HgUCA8fFxeeJuNpvE43EuXrw41GtvNpvxeDxMT0/zxhtvEAgEmJ2dxe/30263paeyuLhIMpnk2rVr3LhxA7/fz+nTp/F6vczOzu72x9h1tFotDocDj8cj95nwXMxmM6dOnWJycpIrV66gUqmGz7jAlwam2WySz+e5e/cuiUSCarWKw+Egl8uRz+ex2+2Uy2UsFgsul2vTqUSr1eJyuTAYDOj1etmxa7PZZAho8OGp1Wpldcno6ChTU1NUq1UymcxQhRxUKhXhcJiXXnoJp9PJ9PS0PBU+CLHBjEYjkUgEp9OJyWQin88zPj5OIBCgWCxy8+ZNisWiDE087wjvQqfTycOP1WpFp9PhcDgwm82YTCbZ+Cf+DAQCm7wTtVqN2+3GbDbjdDrxer3ye41GA5PJtGuf8VkgHnzCoxMtCiL8LTzpdDrNtWvXiMVixONxqtUqAD6fj0Ag8Mhw+TAjwoput5uzZ88SCARkJMhoNMqwWKvVotls7moUYseNS7PZpNVqsba2RjweR61Wo9VqUavVMhdjMpnw+/3o9Xq8Xi9Wq1X+vMVi4cSJE3g8HpxO5yZX0GAwYDAYNsVb9Xo9oVAIn8/HyZMn2djYIBaL8dlnnw2dcTl27Bj/6B/9I6xWKx6PRxree7l3c9ntdk6fPi3Xv9frsbGxwcrKCqurq/yH//AfmJ+fl7+755nBPJbNZsNqteJ0OpmcnMRms3HkyBFCoRDBYJDp6Wm0Wi1arVZKl4j/FghjIgpXBI1G46EHg2HB6XQyPj7O1NQU09PT+Hw+uQ7ZbJYrV66wtrbGu+++y8rKirzHJycnmZmZIRQKyeKg5xGRsx4dHeXP//zPGRsbIxQK4XQ65UG71+tRq9Uol8s0m81du9ZnUr8nknEPeri32200Gg16vZ5Op3OfcfF4PDQaDcrlMqVSiVKphF6vx2KxSGM0mBwVYTW73Y7P56NarT4yyb1fUKlUaLVadDodFotFxvAtFou8SR91UlGr1feFHlutFrVajVqthsPhwGazyb6j5wmtVisf/DqdTiaNhUfsdDqx2+1EIhEsFos0LIFAAJ/PJw9OwCOLK4Rxr1QqVCqVXX0QPCtE8Ui73aZarW7y1mq1mryH2+02jUZDGnOxJ8U+7/f71Ot18vk8xWJxqA6Oj0K0eDidTtxuNyaTadNBpdvtUigUyGQy1Ov1XbvOPVEc3ul0KBQKqNVqisXipoXSaDQsLy/LkIRWq8VqtRIOh3G73fzpn/4pZ86cQafTSbdQo9FgMBiYnp5GrVZz8eJFPvroI8rl8i5+yu1Bq9USDodxOByMjIxgtVrl534a7Ha7DPm88MILWK1Wbt26xZ07d7bpyvc+arUan88nY9ljY2NYrVampqZkEtrv98tKJ7EXRf+W+D2I38XDficiv5BOp3nvvfeIxWLMzc0Ndb4FIJfLsbKyQqPRwGazYbPZ5Inb4XAwMTGBVqvF4/GQyWQ4e/YsZ8+eZWJiQv4eNBoNrVaL+fl5fvaznxGPx8nlcrv90Z4JYn/p9XpcLhcej+e+aEWpVOK9997j9u3b3L59e3jDYo+DKJ0DtrS0mUxm0/+bzWai0Sher5fXXntNej6irFmU5jqdTiKRCKurq0PTZKVWq+VpzmKxbBl6EYhNJf582ENPGO9arUYgEKBcLrO+vr5rycBnjdgzFosFp9PJyMgIMzMzOBwOjh49KhOnD6rE22qNHpavEsalVCoxPz/P0tISqVRq2z7PXkR4wsViEZ1Ox9LSEmazWXp4U1NTTE5OYrfbZTgsGAzKSii73Y7FYqHZbNLpdMjlcszPz5PNZne1WfBZIw7QonDkXkQa4s6dO7tqdPftE1etVm/q7YDnY8a1Wq3GbDZjs9lkuEb0DQ2STqdZWVmhXq9LuRy/3y/DiCMjIzJfNfizoo/Abrc/N41pFouFSCSC3W7nG9/4BrOzszidTpk8DgQCmEwmzGYz7XZb9qSI2Har1aJcLpPL5TYpRORyOQqFwpb/ZrvdptVqkc/nuXjxItls9rmQLxHRg1KpRLVa3SSnf+PGDb744gvK5TKxWEw2R4qDlEajodPpkEgkyOfzLC4usrq6SqlUem7Ct0ajEavVisVi2fOh/n1rXOCr06b4eh4YNC5msxmdTrdlA1k6nebChQvkcjlu3bpFoVCQXbyBQAC73S5jt4M/P+gZPS9VOVarlcOHDxMKhfjhD3/IuXPn0Gg00iMUxrfT6dBut+l2u9RqNdrttlTojcfj3L17l3q9Lk/SCwsLLC8vb/lvinyLyLmIpt9hp1wuU6lUAFhaWtr0vcHGUpGDFcbFarWiVqvpdrvEYjF5Ml9aWqLZbD4XawdIZQKxHnuZPW9cRAJbo9HIpJ5oxPR6vXi93gcmTlutFqVSaZO45X6n1+tRqVQoFArySzSfDq6B6MJvtVoUCgWy2SzpdJpEIiELJ7ZCJK6fh9JYQbfblWrb8GVBiHjAdTqdTUKpQseuWCzSbrcpFArSO1xfX6fRaMiTdC6Xk+95L4OqCM9b0+q94VqBMCyiVF7kFYWXrlKpaLfb5HI54vE4hULhuerJUqlUOJ1OJiYmCAaD9x0q2+029XqdUqlEo9Gg1WrtqmL8njcuoqvZZDJx5swZzp49i9/v59SpU7IabKuEdr/fJ5vNsri4SCKRGJpqklarxcrKCqlUitnZWY4ePYrT6WRqauo+T0OlUtHpdFhbW2N9fZ1ms0mxWKRWq/Haa69tGU4zmUwcOXKEcDjM+fPnn4ucS6PRIBaLScG/wfxcuVzmgw8+YH19Xa5jpVKRYRtRyj04FVEYi1ar9UD5ocE1HZaDz9Miqhj9fj//4B/8A6anpzl58iTj4+MyBN5oNLhx4waffPIJKysrz9W4DZVKxeHDh3nnnXeIRCKbqmrhS+WNtbU1VldXSafTUl9xt9hzxmUwIS9KbkW5bTAYJBKJEAwGmZyclHHYe70WcSqs1+sUCgUqlcrQ3MCiBLPX61EqlSgUCuh0uvs+n/D41Gq1LDNuNBoyGSpecy8i7Nbr9Z6bnAt89YAXayIMhpgdtL6+zurqqozxx+Px5ybO/6zQarUypxAKhaR4rdFolN6luKdFOHLYDz6wuf1AFJt4PJ5NhyDxXMhkMmSzWer1ugzh7hZ7wrgIITsxgU6n0zEyMsKBAwew2WwywSqqScxm86Yqk0F6vR7VapVms8n8/DwffvghiURiaKpJRGWdiD1fv36dsbExZmZm5DAl+LJZ7fDhwzIRrVKpmJyc5M0332RiYgKr1bqpJ+N5xuVy8eqrrxIOh2U1WDqdlooS77//PgsLC5TLZcrl8nMhMLkb+Hw+Dh06RCQS4dixY8zMzMjG0nw+z82bN9nY2ODmzZssLS1Rr9efC+NiMpk4fvw4Pp+Pl156iSNHjshKUWFUOp0O165d43/8j/9BJpNhZWWFSqWyq8K9e8a4iLyKkNIIh8O8+OKLeDweTp48idfrlU1sD2NQSTUWi3Hr1q1dX+TtRkzfzOVyrK2tYTAY7vt8Quiv2WzKsGEgEODYsWP4/X6MRqNiWP5/hODn+Pi4HKVbKpVYWFhgfX2d69evs7CwsMtXOfzY7XampqaIRCKMjY0RDofl96rVKgsLC8TjcdbX14e+bHsQg8HA1NQU4+PjzMzMEIlEZMGJaFCv1+usrKzw+9//nmKxSKPR2PVozTMzLoNDfkQlks1mkyWvDocDvV6P2+2WpbIHDhyQ0iZCr+lB1Go1qtUqpVKJ69evk8lkuH37tkzoD9sJR+SU7t69i8FgoF6v0+127xtdIMJcVqsVm82G0+mUXt/D3nvY1msrRBNfOBxmdHSUkZERVCoVpVKJaDTKlStXSCaTsrpJ4X7EXhNKBuKhJ3qGXC7Xpr0m9lWtViOdTsseNZVKxfT0NGfOnCEQCMh8QqvVotVqkUqluHHjBolEgmKxuCufdbcQDeFHjx6Vysf3Fu8AUvlgr1QePjPjIpJ1JpOJ2dlZPB4Pk5OTTE9PY7PZCIVCmEwmQqEQbrd7kwaZ2HwP62Mpl8usrKwQi8X4n//zf7K0tCTVmIe1oiQWi5FOp+n3+5RKJdrt9qbSZHHT2+12vF4vgUCAYDC4SSrmXoRhGdY1G0So8x45ckSWIpfLZTY2Nrhx4wa//OUvyefzlEql3b7UPctgQ5/onRL9V5FIhOPHj2+pd5dMJjl//jyVSkXOgD979iw/+tGPsFqtGAwG4EuPpVgssri4yO9+97vn0riYzWbOnTvHq6++isFguG89RRFJp9PZU3qAz8y4iJONzWZjZGSEYDAoT4sWiwWfz4fJZJLy+1+XwQIA8aVSqYa6mkQoTosczKBBEMbcbDYzOjpKs9nE4/HIzfkgQ93tduX46EajMZQGRhSM2O12RkZG8Pl8mM1mGcMWirKiQVLkrATdblc2UYpelecBtVotc6OiP0oM9RNhWCGFIwRkQ6HQfQ/DXq+HRqNhYmKCWq2GXq9HrVYTDAblOHT4SiMrFouxsbFBpVKRDarPA6K4wefzYbVaN0UcBg2KUJcXpdl7hWdmXKxWK5OTk4yMjPDjH/94U7JZaIGJxqknwW63Mz09jdPp5Fvf+hbT09O8//77JBKJoXxAAtKYiDLYZrMpK0hMJpPUyfoX/+JfSFkXIfP+oHxLtVrls88+Y3V19YENgPsZ0Tiq1+s5fvw4f/Inf4LP58PtdsuxuuVyWT7EDAYDx44dk3OI4Etp+Gg0SqPRIJvNyqqlYTcyFouFQCCAxWJhdnYWt9tNOBxmbGxMGheDwSD3l8FguK9cVtBut3nzzTc3hXKFCCN8pab+0Ucf8atf/UpGIWq12p56gO4kU1NTfOtb3yISiRAOhzfJPLXbbSni+9Of/pQrV65w9+7dPeO1wDM0LmIGi9vtZmpqiiNHjjz09VsZhIeFxYTcfK/XIxwOy9yORqMZ6hG+IoQleio6nQ56vV4WR4jZIQ/62cF1VqlUNJtNkskk6+vrQxl+EKJ/RqMRn88nxRBFgYMoQe73+/KkHgwGGRkZke8hGifFSVr0u4ieoMEmwWE42IiQtMFgwOFwYLfb5fyf6elpZmdnZZ508HD4oHv4UTJNIncg+o/m5uYol8syr/i8ICplR0ZGZBOpoNfrycbe5eVlrl27Rjab3VPr88yMi6hoKJVKpNNp4vG4TKgK+v0+lUpF9mMMdtYL1VSbzSbDX4OLLf7baDTKORHlchmbzUYymWRubo5arSZDSMNEKpXi5z//OdeuXeONN954pOFuNptSoiQajZLL5fD7/YyNjZFKpVhbW2NlZYVCoTAUD8dB7HY7f/iHf8jMzAynT58mEAhIr1mtVsvQ4be+9S0sFgsqlYrx8fFN+7TRaJDL5Wi1WnK/ZrNZ2Vgp5PPX19eJRqPyALCfGGwLGB0dxev1EolEOH36NDabTTbxCdn3Xq8n85vi84vQovCwVSqVFP8UIyO28qCLxSK//e1viUajfPbZZ6TTaRqNxtDdt4/iYfJW9XpdNkvGYjGSyeSeK1x6ZsZF6DGJqZCilFDMYoEvjUu5XJaNj5lMZpNxiUQi6PV6er3elkrAKpUKk8nE1NQU7XYbvV5PJBLh5s2bxONxGboYtk2ayWT4xS9+gc/nY2xs7JHGpdFoyMTo+fPnWVxc5OjRo2i1WtLp9KZmwWHDZrPxR3/0R7z++utYLJb78ilutxu3200kEuGb3/wm8GCPefBGXlhY4OLFi9RqNVKpFNVqlY8++ohkMrkvJ3oKAVOTycThw4c5dOgQBw8e5O2338ZisWA0GtFqtZv00VZWVuTnLxaLlMtlMpmMfI1KpeLFF1+UOZp7JYsExWKRv//7v+fq1atEo1FSqdSeemg+Sx7k6QnjIqIMGxsbu3B1D+eZGZd2u02lUiGXy3H79m0ajQY+nw+fzycXr9vtkslkKBaLVKtVcrncJrn4dDpNMpmUg3J0Oh1utxuLxbJpnosIZ4gZHNlsVpbwiYqKYaLT6VAul9FqteRyOTKZjLyBt9qYnU6HUqlELpeTkzrF+hUKBdLpNNVqdah6gwSD6g9b3bjiQSiG24mQ41ZJZLHPRIn9yMgIzWYTs9ksR3u3223y+TwrKyt7Kh7+IEQpscPh4PDhw7IZd2pqSoa9RBm80FYTh8G1tTXZQV+tVqnVatL7FWtULpdlmPpBBkP0dXQ6HdRqtdTJep7yLQ9ChFpFOCwaje7ZOVXPzLjUajWi0SgbGxuk02lMJpOM3w5KbpRKJSlVUq1WNxkXl8uFy+WSbrnD4eDll19mZmYGl8vFyMiILF1Wq9WEw2Epl768vEw8HqfRaAxdLqHVasl+jNu3bxMOh2Wf0FZzbGq1GsvLyyQSCS5dusTc3BwXL17kF7/4Bd1uV5Y1D5uH9yhEt7PYe/l8Xg702krhQa1W43K5MJvNuFwuXnjhBanc2+12OXr0KMvLy1y9epX/9J/+031zifYiJpMJu93OzMwM//Sf/lPZzOjxeOS9Va1WuXjxIslkkhs3bnD16lUpkzOotyaq6UQ5vNlsllGFh+0tt9vNj3/8Y0qlEj/72c/QarXk83kWFhaG7mD4dRFrGovF+H//7//JTvy9yDMzLoNJ53Q6jVarpVgsboq7initOKncG0MUc6FF/LtUKsnhQmq1Gq/Xu2m+iZDsFgKXYoSywWCQp9NhQKytUCYol8s4nc4HngyFp1MsFimVSnv25LMTiD2Wz+cxmUzyISfyIuJwI7zsRqNBKpXacoidOFVbrVY0Go0ccyxCbcFgkE6nQzKZxGQyodPp9nyIzGAwYLfbZSVYJBLB5XJhtVrlwaxUKrGxsSG75VdXV6nVatKbEQgvUa/XS4n4wTlM4hQuPEORS9VoNHi9Xmw2G8FgEJ/PR7/fl9V8WxWiiHt+r6/v4yDaBYTEiyj/BjatWTabJZvN7vLVPphnLv/S7/dpNpu02205R3sQcarZym0W5aHiwajT6YjFYrjdbs6ePcsPf/hD7Ha7lDcR+P1+3n77bXK5HO12G4/HQywWY2FhYd9vRIF4OFYqFbLZLC6X64HGpVwuMzc3x9ra2p7enDtBPp/nv/yX/8Ivf/lLRkZGCIfDck8ODqIS1UrdbldqN92LqKDS6XSEw2EOHDiA3+/nrbfeYmRkRKp5l0oljh07htvtZm1tbU8PBTt06BBvvfUWo6OjTE5O4na7yeVyrK+vMz8/z3vvvUexWCQajUojLYak3btGFotFjsX43ve+J/OBIkTdbrep1WpcvnyZtbU1xsfHOX78uDwU6vV6zp49i8fj4ebNmxSLRTKZDIVCgUajgUajQafTYTAY8Pl8GAwGNjY29oWH+CD0ej2vvfYaR44cYWpqimPHjuFwODbpBu4XdkVbTIQNxPyBx0UYJEBO+EskEvLEc+7cObrdLi6Xa5NxsdlsHDlyhHK5zPz8PPV6nVarxdLS0tAYF9hcnviwAUr1ep1YLMb6+vp9xn3YEYl2tVrN9PQ0MzMzUuy01WrJChxxQnxUObHI24TDYeLxOBMTE5w+fRq/34/ZbMbhcEg1b/hSEHOvGhfhbZ09exav1ysbm6PRKIlEgrm5OX76059KKfdHhU2NRiNut5tQKMS5c+c4cuQILpcLp9Mpq0eFZtiVK1fodDpMTU3Jn9XpdExNTeH3+9FoNPz2t7+VIctGoyFzZ0ajUa63KATar2i1WmZnZ3nttddkgY7oy9pv7AnhyqdBzM5YXV3lt7/9LeFwGLfbval0dDCJ6/F45INg2MYi9/t9mSsYzFfdixhj4HQ6d3XG9nYjJG5EmKTb7ZJIJO7zzoSXVygUWF9f35S0HyydfRwGtbI2NjYwmUwUCgVKpRI2m+2+7vS9vueE1poomOn1elIhOhaLSQ/vQYcytVqNz+fDZrMxPT3N2bNn8fl8RCIR2UbQ6XRIp9NcunSJXC7HxYsXuXv3rryXvV4v586dkw2/ZrMZn8/HiRMn8Hq9fPHFF1SrVZlndbvdvPLKK9jtdtrtNqurq8941Z4eIadvt9sJhUKEw2HpsQxKOolCnFQqtedzovveuAhX/ObNm6yvr3Pw4EHOnTsnT4oCEfsNhUJ0u11WV1eHThW43+9TLBZJJBJMTEw88AGg1+vxer3U63USicQzvsqdY3R0lJdfflnejJ1Oh9///vdbGpd+v086nZbfGxT/+7plr0LbTVSDbWxs4Pf70Wq1smJPHHD2Oh6PhwMHDsgy4UajwerqKhcvXmR5eVk2jT4IjUbD5OQkk5OTnDt3jj/90z+VkyQHqzVXV1f527/9W9bX17l79y6pVIr5+XmuXLkilTyEWK3ZbGZsbIw333yTZDJJIpEgHo/j9/s5ffo0Y2Nj/Nmf/Rl+v5/19XU++OCDfVe6bDKZ5HTdgwcPcvDgQXQ6nWyeFDmqVCrF3bt3WV1d3fPVnPveuAg6nY5svnzYxhpUbR02+v0+tVpNJqUftA5arVY2sG4lKrgfUalU2O12RkdHUavVMuT6sM+3ncoNIgFrNps3hTFE7qZarVKtVvd8EclgebVAjMt+kNquKJ4RFWGjo6NyFK9QPxBVToVCgXw+TywWI5VKkc1mZUhStB84HA459MrlcmEwGDAajXg8Hnq9HqOjo6TTaSYmJohEIoRCoU2n/P2IuCdFnk6v1296Tglvu1qtkk6nKRQKiufyrBD6ZA8TZRx2RIlipVJhcnLygZtPzC+x2WzMz88/46vcOQ4cOMAPf/hDms0mt27dIpvNSq2qncbn83Hs2DHGxsaYmpoiHA5v6tyfm5sjFosNXWWeOKyFw2HefvttAoEAL730ErOzs9LYiP61arXK+fPnuXDhAolEgmvXrsl574Dsrep0Onz44YfE43HOnDkjR5ofO3aMer2OyWTi29/+NuFwmKmpKcxmM263e995K4OIe1K0TwyObh8cmb2wsMAHH3xAPB7/Wvnq3WBojIs4cT3KuAyL3tNWiJzL4J9bIeK7jUZDamoNw7rYbDbGx8elsGS1Wt2yz2c7ESELi8WC3+8nEAjIMJDQHyuVSlK1dq+fNh93D4h7TKvVyvLliYkJRkdHmZmZYWZmBkCO2a5UKhSLRdbX17l16xaZTEaWegtExVm5XCaRSKDX6zlw4IAsQ3Y6nVitVmZmZvB4PPh8PumpAntO/uTrID6fy+W6T7mg3+9LD7hQKJBMJvecjthW7HvjImZBTExMcOLECcbHx3E4HFu+VpScCjf8ecVms3H48GH8fj9zc3MyHBGPx/f8hn0YosnvYYPQthONRkMkEsHj8fDCCy/wve99T1YqlkolPv/8c5msFp3pe/3hJ8Y4iLXcCo1Gg9vtxmg0MjMzw4EDBwiFQrzyyivyoa9Wq2VZfDab5Ve/+hVra2ssLCywtLREo9F4YIiwXq8zNzdHIpFgbGyMw4cPS/l5jUaDx+OR8jGiW31paUnu4f2EXq/HYDDgcrlkX5HFYtn0mmq1yieffEI8Huf8+fPcvXuXer2u5Fx2EtFnYDAYiEQifOMb3yAYDG6qFBtkcARyq9Xa8zf6TmGxWDhw4ADlcpkjR45QKBRYWlqSOlj7FVElJpr0dhqtVsvo6CjT09O89NJLvP322+j1etnIeuXKFf7v//2/FItFKpXKvih7F5VzD8tLCuPidDo5e/Ysb731Fh6Ph0OHDm16MNZqNWKxGCsrK/z85z9nbm6Odrv9yINdo9Hgzp07rK2tcebMGXK5HDabTQ65E6OoRR6nWq1y48YN4vE4Gxsb++q+Fg2mYrbQyMjIfT0t1WqVzz//nBs3bnDjxg1WV1f3xWfcceMibnQxKExofhkMBrLZLPl8Xta8b3XzqVQqKZInEnsieSg0kIS43tjYGG63W06xu5d+vy9PN8Oo+Pt1EFMqx8fHZax7bm5uz4xIfRJarRalUolms4nL5aLX6+H3+/F6vfcp9H4dBkdHq1QqrFYr4XAYq9XKyZMnGR8fJxgMylP07du3yWazrKysSJ28/bKmhUKB5eVlnE6nDDn5fD6mp6c3Vb6Nj49LmRifzyfvx36/L7XFVldXuXLlirzfOp3OYx1eBmcUxWIxrly5gsfjodlsynkx8GVZbiaTIZ/Pc+PGDTY2NvZdU7DRaMTlckljLca9D9LtdsnlclLiab/spR03LiIPEgqFOHr0KA6Hg+PHj+PxeLhw4QKffvoppVJJ1tDfd4FarZwUKCZYejwejh49KiW/rVYrXq+XcDgsBRi3ot1uc+fOHT799FOi0ei+PqVvByaTiTfeeINvfOMbmEwm3nvvPVqt1r4I32xFqVRidXVVxuUnJia4fv267NpeWlqSChBfJ7cg5uMIaaHZ2Vl+/OMfMzIywqFDhwgGg6hUKtrtNrFYjL/5m7/hzp07rKysyD6avV4lJlheXubXv/41Y2NjfP/738ftdnPs2DF8Pp8MnwqPTVQ3uVwumfPsdDrcuXOH5eVlrly5wi9+8QvK5TKpVOqxowUix9DtduW9OjY2xmuvvSZ7ZdRqNfPz83zxxRcUi0Xm5+cplUp7Psl9L263W+aopqamCIVC9+UJm80mCwsLXLt2bUuNu73KjhoX0QBlsVhwu90Eg0F5IvJ4PKyvr0upFiEYeC9C2kHoDAmtodHRUaxWqxQOtNvt2Gy2LV35brdLo9GgXC5TKpWkfMTzjjiFW61WHA4HRqPxscq59yr1el12v3u9XtnPIwRNC4WCrLoRD/zBh77w5gZvbrGHhQqEVquVI7qDwSAulwuLxUKtViOXy0nl7lgsRrFY3Fe5PVEIkkqlsFgsNJtNer0eZrMZj8cjR+2KNRDaV2Ign9AFFPOaksmkHD/wdcPQg1pviUQCnU5HIpGgUqnI0GcsFiMajUoPplar7eDqbD8ioiO8FhGVEYihafV6nVqtRq1W21cH4h0xLiqVSmr+vPLKK5w4cYLR0VFOnDiBxWLB5XLJ0NaRI0c2Karei16vl3FIu90uQ2qig1jUgw+Ku91LMpnkk08+YWNjg7m5OZLJ5EP7QJ5H3G43R48eJZ1Os7S0tO9KZvv9PouLi/zsZz+TRR1er5dvfvObHDlyhHQ6zcLCghRfbLVarK2tyW5u0WQ7PT1NMBiU72swGAgEApjNZqxWKxaLRVZG6XQ60uk06+vrLC4ucvHiRbLZLNeuXSOTyezLA0w8HufChQuUSiXeeOMNmTgXJcXCGIuRBcVikVqtRiaT4dKlS+Tzea5evcrKygr5fJ5SqfTQjv6HIZpTm80mxWKRjY0N2ceiVqspFotSLHM/qiWrVCqmpqZ45513CAQC942EFt72ysoKpVJp30UUdsy4iL6Tqakpzp49Szgc5sSJE5sss91uZ2xsTE7226r6Qa/XS90gkbz/uhSLRZnwSyQSlMtlqa6q8CUi7KhSqVhfX9/ty3ki0uk0N27ckKc9lUrFzMwMer2eTCZDKBSiXq+TzWap1WqYTCb5UNJoNBiNRk6cOCHLaOHLmLiYROlwODZVIgoDFYvFuHnzJh9++CGlUolkMrkvDQt8FVq02+2Uy2UajYZMpgv6/b6s9mo2m+RyOaLRKF988QXJZJKbN2/KCZxPS6PRkAeCYVKTEPh8Pg4fPozdbr8v11KtVllfX5c9LYpx4SuXVkyfE7Hq+/5xrRaTySRjqFu5fGIWvHC/H0Wn05EjfFdXV4lGo8RiMa5du0Y+n5eKt/vJvfw6iBu+WCwSi8Wo1+uyy/lhWCwWwuEwwBMZ8L1AuVwmGo2iUql4//33CQaDjIyMyJyA0+nEZrNht9vpdDrYbDbGxsaAr7zt8fFxKfEu9nA2myWVSmEymTCZTFSrVRKJhBRdTKVSrK6uyn23n/eWUCrOZDJcvnyZTCaD3+/H7XbL17RaLRmiisfjxGIxOQSwXC7vq6TzXqPX6xGPx8nn89y6dYsPPviAVCpFPp/fd71oO5ZzGRxtKuQk7i0PFbLa/X7/gb0p8OBRn1vRbDallPyvf/1r3n//fRkPF41Ie70+/EkRnbyiI3pxcZFyuYzRaHykwXA4HMzMzEg9o/1IPp+nWCzK4V5ut5sTJ04wPT3N6OgoJ0+elGq7arWaU6dObQrXDFaEiU7xYrHIp59+SjKZlHswkUjw8ccfSykTkVNoNBr77gFwLyInFYvFeO+99/B4PMzMzDAyMiJfU61WuXr1KhsbGywvL7O0tCTvd2GUFZ6MTqfD3bt3uXXrFpcuXeLnP/+5VIHeb/tqxzwXsclqtRr5fB69Xk86ncZgMMixxELMbyvjIX5ePDBFBcmgYRBaOyIEIbS17t69Sz6fl7M5ms2mPFHu51Pl4zB44m42mzIp+yjE72I/a671+335uUXpaywWkwKMer1eTloUxvbefSfyA81mU3bXLy8vk06n5WvS6TS5XE6e0sXeGpaH6uAwqm63i8FgoNFoyLWq1+skk0k5knw/d8bvNXq9Hvl8nng8LsO3j3sP7zV21HNptVosLCzIMbDLy8vY7XZOnDiBz+fDaDQ+sGxY9L60Wi1SqZScCDh4kzebTa5cucLKyops/hJjelutFrlcjnw+Lx+2+/1U+TiIh1ytVqNYLG6atvionxN9CPtxIw9Sr9dZXl5Go9GwsrIiq3BE5eLRo0c3je0ViD6VVqtFOp1mZWVFzscZLDZpt9uUy2V5WBnGA0ulUuH69etotVouX768SRBS7C+RSB/2e+pZ0ul0mJub45e//CX5fF4eXPbjGu9oKXKv15M17sKtczqdRCKRRz70RCd9s9mUoYdkMkk8HpcLLQQK7969K5uuhFETBmUYb/xHIZrQRFnx466BWLP9jvBo4csE9SBiBHEgELhPKkYYF3Eyn5+f3zf9KdtNt9ulWCzu9mUMPcLTFoULQuw0kUhQr9f3rWGBZ2BcxDhUEQ4zGAx88cUXWK1W2TewFeIk3el0qFQqtNttKpUKlUpFvkaEPYrF4ibvRITT9vsJ/GnI5XJcunSJSCTC8ePHN5XXbkWn06FarT5QKWFYaLVarKyskEqltgzHilzLfpFrUdi/9Pt9Lly4QKvVQq/XY7FYaLfbfPrpp5TL5X2tlgHPwLgkk0mSyeSmv39S3af9vNDPmnw+z82bN+Uo2UchpjA2Go2hfqh2Oh2i0ehuX4aCAv1+n+vXr3Pjxo37/n4Y2BXhymFZvL1Mq9WiUCjICX9CbFDkGkQMXairJpNJlpaWZAhTQUHh2TCsz8N9rYqs8GAqlQrNZpNSqcS7777LlStXOHfuHC+99JKsmIIvu4ALhQLXr1/nd7/7nZTIUVBQUHgaFOMypIj8U71eJ51Oo9FopEKB0WiUuSuhWJtKpSiXy1Sr1aFI6isoKOwuqv5j+mTP6+jgrXgSN3a31k+n08nBTh6PB4/Hg0aj2RQWa7VasiHuSXWgvg77af32Ik8aRlHW8CuUPfh0PM76KcblCVA25tOhrN/ToRiXp0fZg0/H46zf/m3HVlBQUFDYsyjGRUFBQUFh21GMi4KCgoLCtvPYORcFBQUFBYXHRfFcFBQUFBS2HcW4KCgoKChsO4pxUVBQUFDYdhTjoqCgoKCw7SjGRUFBQUFh21GMi4KCgoLCtqMYFwUFBQWFbUcxLgoKCgoK245iXBQUFBQUth3FuCgoKCgobDuKcVFQUFBQ2HYU46KgoKCgsO089phjZVDOVyiDhp4OZf2eDmVY2NOj7MGnQxkWpqCgoKCwKyjGRUFBQUFh21GMi4KCgoLCtqMYFwUFBQWFbUcxLgoKCgoK245iXBQUFBQUth3FuCgoKCgobDuP3eeioKCgoLC3eJLemyftk/q6KMZFQUFBYZ+g1WrRarXY7XYmJiYwm80EAgFsNhsGgwGj0SgNjkqlkoak3+/T7Xap1+tcuHCBlZUVms0m9Xp95651x95ZQUFBQWFb0el0mEwmRkZGeO211/D7/Zw6dYpIJILNZsPtdqNWq6WBEcal0+nQbrfJ5XL8m3/zbyiXy5RKJRqNxo55Mopx2eOo1WrUajVarRaj0Ui/36der9PpdOj3+0+9MfR6PVqtFpPJhM1mQ6PRoNPpUKvVFAoFSqUSnU6HZrP5zNxpBQWFr1Cr1ZhMJrRaLcFgEJ/Px+joKBMTE3g8HjweDzabDZ1OR7PZBL40Jr1eD61Wi0ajQaVSYTAYMJvNjI6OcuDAAdbX1ykWi/K1241iXPY4BoMBg8GA0+lkbGyMTqfD0tISxWKRdrtNp9N54vdWq9V4PB7sdjtTU1OcOXMGi8WC1+tFq9Xy8ccf89lnn1EsFonFYrTb7W38ZAoKCo9CGIWJiQmcTievv/46r732Gg6Hg7GxMYxGI0ajEb1eTyqVYnFxkUajQaFQoNVqYbfbsdlsOBwOJiYmsFqtfPe73+XkyZP85je/IZFIUK/XaTQa225gFOOyh1GpVOj1esxmMw6HA7/fT6fTIZfL0ev1aLVaD/UoVCrVpq970Wg0OBwOnE4nwWCQiYkJLBYLPp8PrVbL/Pw8RqORRqOhiPYpKDxjNBqNjCq4XC58Ph+RSITp6WnMZjNOpxOdTiefBdVqlXQ6Tb1eJ5PJ0Gq1qNVq1Ot1er0eoVAIvV6P1+vFaDTi9XrR6XS0Wq0dub8V47KH0Wg0HD58mIMHDzI+Ps6LL76IWq0ml8tRr9fZ2NggkUjQ7XZpt9ubTh5GoxGLxbJpM92LWq3GarViMBjweDyEQiF6vR65XI5qtUqhUCCTyVCtVnfEbVZQULgfEcoaGRnh0KFDeL1eXn/9dcLhMMFgELPZTK1WY35+nlqtRjwep1AokEwmWVpaotVqUa/X6Xa76HQ6jEYjExMT/MEf/AFut5tgMEg4HMbr9WK1Wun1ejQaDbrd7vZ+jm19N4VtRaPRSKMyOzvLt771LQwGA51Oh263y+LiIgsLC3IzDRoAq9WKx+PBbDYzNTWFzWbbdDrp9/uoVCqZ/BO5nUqlQqFQoNFoUK1WKRaLNJtNxbgoKDwjtFotOp2OQCDAqVOnCIVCfOc732F8fFyGsHK5HLdu3SKdTnPjxg1isRiZTIb19XWZQxmMaBw7doyJiQlGR0cZGRmR4XCz2Uyz2USt3v6Wxz1lXNRqNT6fD5vNhtPpJBQKodFo5Pc1Gg0ajYZmsyndvkQiQaFQoN1u02g0dvHqt59+v0+pVCKVSsmQmF6vR6VSodFoMJvNuFwuWq0WWq1208lDlCT2ej1KpRKtVgtAbiKx+YrFIo1GQ35VKhVu3rxJLpeT5YqieEDhfgwGAzqdDrvdjtvtRqPRyN9DuVymWq3idDqZnp5GrVazurpKLpejVqtRLpefi3U1Go3MzMzgcDjkPTyI8LotFgsulwuVSkW326Xb7bK+vk4ikZBhn6289GFA3NNarZbp6Wn8fj+HDh3i6NGjOJ1OGo0GiUSCtbU11tfX2djY4NKlS5RKJdbX18nlcpTLZbrd7paFPp1Oh0ajIT2aZ8GeMi5arZaDBw9y4MABjh07xttvv43RaJQbyWQyYTKZSKfTXL58mUwmw29/+1tu3rwpH6DDtOl6vR7pdJqFhQU8Hg/NZhODwYBGo0GtVuNyuQBoNBpks9lNCXfhjXQ6HZLJpDQqg7XvrVaLmzdvEo1GyeVyRKNRKpUKS0tLlMtlGo2GrD55Hh6CXxe1Wo3NZsNqtTI7O8uZM2fQ6/VyHy4tLbG2tsaRI0f4x//4H6PX6/nbv/1brly5QiwWkw/LYcfhcPAHf/AHHDp0CJPJtKkXo9frUa1WaTQajI+Pc+zYMXmAbDabvPvuu/zd3/0dhUKBaDRKo9GgXC7LfTksqNVq9Ho9FouFV155hXPnzjExMcELL7xAr9djeXmZaDTKe++9x+9//3tKpRLRaJRWqyU9FfG1FZ1Oh0KhgNVqlQfNnWZPGBetVovZbMZkMuHxePB6vZjNZvmwvLfsttPpYDQasVqt+P1+SqUSiUSCfD6/LeW5ewVRdixKgmu1Gnq9HpPJhFqtptFoUCwWZSLvUZvm3rBYu90mGo2SSCTI5XIkk0mZa6lWq0O1lk+DKOXU6XQyZCFKQ0XocXR0lNHRUbRarTQu4s9wOCyLJIxGozwcDDsi7+fz+QgEAgQCAXlAFPT7fWlcAoEAPp8PtVpNs9mk1WoxMjJCJBLBbrcDUK/XSaVSVCoVWdAyDKjVaoxGI2azGbfbTSAQwOl0otVqaTQapNNpkskkyWSSVCpFtVqlUqk8drWoRqORlWX3eo47xa4aF1HF5PV6efnll/F4PBw+fJjR0VHW19f5d//u38nYf7vdlgbI6XQyOzuLxWLhu9/9Lj/60Y947733+G//7b9RqVSGxm3u9Xqsra2RTqcxmUzcvHkTv9/P1NQUdrud69ev8+tf/5pcLsfdu3cf2W17b0XIYMhsMAm4E2WJ+xVRUWcwGAiHw4RCIQKBAGfOnMFut2OxWDAYDDgcDnw+n/QMRUizXC5js9nw+XxUq1VarRaFQoF6vT60hlvk7w4cOMAbb7xBIBDg5ZdfJhwOo9fr0ev18rWic7zX68lDE3zZLKjRaPjmN7/JwYMHqVarZLNZyuUy58+fZ2VlhdXVVW7dujUU3p/RaGRsbAyv18uJEyc4c+YMzWaT1dVVNjY2+Ju/+Rtu375NKpUinU7LsOGjUKvVaDQaXC4XJ0+eJBwOy4jHTrPrxkWtVmM2mxkfHycQCBAKhfB6vdy5c0fGFIvFIq1WSxqXsbEx/H4/BoOBsbExxsfHWVlZwWg0yhzBMNDv9ymXy5TLZdLpNJlMBq1WSyQSod/vk81mmZ+fJ51Oc/36darV6m5f8lAh4uDitO3z+RgfH2d8fJxXXnkFp9OJ0WiUkhziRC6MeLvd3hSqbDQaMvY9zD1D4r52uVwcOXIEv98v72uxVo9CGKhQKEQoFKLZbEoPPpfL0e12KRaLQ1Mir9VqcTgcsuQ4EAiQSqVkfuXmzZvMzc3JYp7HRayj2L/iuSkONjt5iNxV4+Lz+aTbOz09jd1uZ35+ng8++ICVlRXS6bRMNHe7XWq1mgzlfPDBB3g8Hunm2e12/uAP/oBUKsUnn3xCOp3ezY+27aRSKT788ENCoRB+vx+TyYTX6+XFF19kdXVVJt9FQk/hyRDVc16vl4mJCRwOBydOnMDr9eLz+fB6vTidTtxuNzqdjnQ6Tblcljex0WhkdHQUi8WCWq1Gp9PJprZ0Oi1PnsPquahUKoxGIwaDgWAwyOHDh3G73djtdrRarfRM+v2+zBWIvIFAFKsMGiGtVovFYkGlUjE2Nkav1yOTyQxNeNFut3P69GlGR0fx+Xz0+32Wl5f56U9/SiKRYGNj42vf2yqVCo/HI/tjLBYLGo2GpaUlGo0G8/PzFAoFKpXKjnh/u2ZcVCoVwWCQkydPEgqFmJ2dRavV8vOf/5y/+7u/o91uU6vVNi1mp9OhXq9TLpeJRqPYbDZGR0dxOBzY7XZ++MMfEo1G5Wl+mEgmk7z33ntEIhG+8Y1vEA6H8fv9vPTSS1itVj788EOKxaIMMyg8GcJIjIyM8PLLLzMyMsIf/MEfMDY2JnMugHwoplIpVldX6fV6dLtd2ZRqNptlSELkxETMfGNjY5c/5c4ici3BYFBWO20VkhVGpVKpbKr0FJJEItcFXxocq9WKXq9nYmICk8nE4uLi0BgXh8PBiy++yNTUFH6/XxaE/O3f/q2sLvy6ERmVSoXP52N2dpaxsTF54FlYWGBtbY3bt2+TzWZptVrDY1xEPNXn8zEzM4PNZqNYLNLtdimVSo88gYuYdrvdJpFIsLCwQDAYZGpqinK5jNls3tQPMgwIYys6bpvNJnq9XmoLuVwuqtUq5XJZnoqH8WS8E4hTsU6nIxgM4nA4mJ6eZnp6WibsVSqVjPmL30Wj0eD69evE43FpSLxer8ytDPYOiZLaYQ1dihCiTqeTvRSjo6PodLpNhqXVatFut2VivtlskkgkKJfL8jUGg0GetH0+Hx6PZ9O/I9Z1GEJi4rPo9XpsNhs2m03mpFwuF4cPHyabzcrqQhHJedR7mkwmuY5Hjx4lEokAX4ZmNzY2WF1dJZvNPrTC7Gl55sZFo9Fgs9kwmUy8+OKL/OQnPyGVSvHee++RTCZZX19/bJHEZrPJp59+yu3bt/ne977HN7/5TTQaDX6/n3g8LvsMhoFms0k6nUav15PNZsnlcjidTkZHR1Gr1Rw7dgybzcbi4qJ0oYcl97TTWCwWDh48iNvt5vvf/z6nT5/Gbrfj9/vRarWoVCoajQYXLlzgo48+kp6zUEkoFouyz2V8fJzjx49jtVplfmF1dZVf/vKXRKNRYrHYbn/cHUHc1zabjXfeeYdvfvObhMNhDAbDptcVi0XS6TQbGxtcvHiRXC7HZ599xvLysnyN3W7n1KlT+Hw+3nnnHd58882hMCRbIao/XS4XIyMjhEIhGb46fvw4//Jf/kuSySQ/+9nPZDlyNBp95HtGIhHcbjfvvPMOf/zHf0yn06FWq5FOp/n888/55JNPKJVKtNvt4VFFFiWdosLG7/dTq9Wk1Mi9neYPo9fryW7yYrEof0645c1mc2iMizhhiKoucXoxm83Y7Xa8Xi+1Wo18Pi+rvsTGEV+iOq/f78smysFu3ufN0xlMdno8Hvx+P5FIhMnJSQwGAxaLRSaOhSFZXV2lUCiwvr5Oo9Egn89Tq9Xodruy23nQYxalthsbGzKHOEwM5ppESHBkZISxsTGcTqcMW4mKsHK5TCaTIZVKEY/HyWQyrK2tsbKyIt/Tbrfj8Xhot9tUKpVN/57Ys8NSuCO8Pb1eL0VqRamw3W5nfHxcRiiy2SwGg2FTr9pW7yXEZ71eL4FAgGAwSLFYJJPJUCwWyeVyZLPZHVfe2BXPxePx4Ha7sdlsAFQqFe7cucPi4iK5XO6x30v0gbTbba5fv87f/M3fAF8WCpw9e5Zr166Rz+d35HPsFq1Wi6WlJVmZNDIyQiAQ4E//9E9lt24mk6HdbsuYtjA2os5d1M3XajVu3rxJMpmUhvh5MjKioGRiYoI//uM/ljdip9MhnU4Ti8UolUpcvXqVdDrNysoKy8vLtFotKpUKvV5PFpMcPnyYb3/721IA1OFwkMvlKBQKxONxVldXZR/RMOHz+QgGg4RCIb797W/j9/s5evSoLDtWq9VSSaNcLvP+++/zwQcfUC6Xicfjci8+Lu12m4WFBW7evMnKysq+D3uLwhyXyyXVjYVBFuKSvV4Pv99PsVgkmUze9x4iRDg5OcnJkydla4fYz5lMhoWFBd59912SySR37tyRB6Kd5JkbF9HV7HK55AOy2WwSi8VkB+7XQZR7rq2t8fHHH2Oz2ZiYmCAQCBCNRh9o5fcr7XabZDKJ1WplbGwM+DIZeO7cOXq9HqlUSsrhCMMr3F8RtiiVSiwvL1MoFCiXy1QqFVQqlfQah2m9HobD4SASiXDgwAFeeeUVecJrNBpkMhmuX7/OxsYGv/nNb6SnMti0p1KpcDgcmEwmIpEI586dk9U5ZrNZ/i5yuZwsJR+2/iGbzUYkEuHQoUN8//vfJxQKYTQa0el08jWdTodMJkMmk+HSpUv88pe/lOMiHrXX7v1+t9slmUyysLBAOp3e93vVYDBgs9mkyKwIw8KXuWlRbeh0OnE4HFsK0Io8lN/v58UXXyQUCvH2228TCoXIZDLk83mi0SiffvopiURC5rp2mmduXLrdLul0mna7TaFQkO6yCNU8KdVqlVgshs/n4+TJk7JW3Ov10mw25Ulzv9Nut1lfX6fVauF2u+WDzOPxyEomcXPrdDq63S56vZ5utyulN8TpqF6vo1KpOHToEPl8Xiac19bWqFQqMmk9TIhSWZ1Ox/T0NK+++irBYJBut0sul5NyOPF4nJs3b1IsFuVsDLF/1Gq1DGEcOXKEUCjEsWPHCAaDMpRWrVZZX1/n2rVrLC0tyTzifn8YDqJSqeTeEw8+MWhukGazye3bt1lZWSEWi22657fCYDAwPT3N5OQkPp8P+KrZstlsksvlZE51v69nrVaTYcJUKoXJZMJut2Mymej1ejJXsry8zO3bt8lkMvJnRYphamqKQCDAyZMnOXr0KA6Hg263SzablRGh+fl5stns1+rqf1qeuXFptVqsrq4Si8VIJpMyPv2oDfcoRIOVkJE4dOiQ7OIVeZlnpamzkzQaDa5evYrBYJBhL5/Px6lTp7Db7RiNRhluHJyf3e/3pfus0WiYnZ1FpVLx2muv0e12iUaj3Llzh2QyyS9+8QvW19dJJpNDZ1xEGMtisXDu3Dn+4i/+gn6/Tz6fJ5PJ8Otf/5pPP/2UXC5HIpGg0+ncpzKr0+lk+fu3vvUtzp49y9jYGDMzM6hUKkqlEqVSiWvXrvGrX/1KhiCH4XBzL3a7nUgkwsjICBaLZcuTdaVS4cMPP+TixYtShPJh97nFYuGll17ixIkThMNhKWTZbDap1WpEo1EWFhaG4sAonluiGKfX6zE1NYXJZJJqGfl8nsuXL/Ppp59Kb29QvPab3/wmZ86cYXZ2lrNnz9Lv99nY2CCXy/HJJ5/w/vvvk06nWV9f/1o57adlV0qRRZmxMCqD2mGPa1zurR4RiT6hjizKdbeSn97P9Pt9WaotxCYbjQYOhwOr1Sob2B6EOLl7PB5ZEi5UEkR8V8x1EbmFbrf7yAfCfkGj0eB0OnG5XLhcLiwWi5QWyeVyZDIZcrkcpVLpgTeiwWAgEAjI2Rg+nw+73S49RVESXigUyOfzO9aktpuIPhQxt93hcNzXeS9Cs4VCgWKxKEOOD9pHWq0Wg8GA1WrFbrdvCgN1Oh35HsKj3slKp2eFeA7W63Xi8Tg6nQ63243T6bzv84n/FtMpXS4XdrudYDDIyMgIDocDlUpFq9UimUzKA1I2m5Wh8WdpjHe1Q19UfQgBusf98MIdHJyyKAxLrVZjbm5OzjuIxWLyYTwMCCPa7Xa5efMmsVhM1sgLQ/GwxjKVSsXIyAivvPIKDodD5gxEGe3IyAgul4tSqcT777/PJ598QqFQYG1tbV97fmKf2Gw2Xn/9dQ4cOMDhw4dlDP/nP/85sViMK1euEI/HHzpXPBQK8Wd/9meEw2FOnDhBJBJBr9ej0Wgol8vcuHGDRCLB3Nwci4uLQ1PZJNBoNLjdbsxmM0eOHOGb3/ym3EeDJBIJrl27xtraGktLS4+M9ft8PhkOm5yclEUBAPl8Xno+a2trsi9uWIjH4/z1X/81Xq+Xv/iLv5BDvmw2G0ajEZ/PRygUolwuUyqVCIfDvPPOOwSDQV5//XUOHjwoCyfi8Tj//b//dxYWFkgkEjJC9Kwlh3bVuIiYogiJPa5h0Wq1Mm9wr4ERyUMxsVGcGvf7CWcQsU75fP6JquHGx8fxer2yAVN0PptMJtlM2Gg0WFpa4s6dO/T7fdktvZ/XUYyNDoVCTE9P43Q66Xa7VCoVGULNZrPUarUtf17sN7vdzuzsLOPj44RCIZxOp3yN2H+izLZUKsn9PSyI0mOr1Yrb7WZkZOQ+uZZ+v0+lUpH5q4d5ggKTyUQgEMDv98vQpUA0/yWTScrl8r4+6GxFrVZjYWGBVCpFIpGgVCoBSNkci8WC3W6X2nQOh4OZmRnC4TCjo6N4vV6Zu0mn09y+fZubN2/uat50T0juPy7hcJiRkRF8Ph/Hjx+XcgYajYZLly7xq1/9ik6nw/z8vOyIHuz1UPiSQqHAF198IYVA9Xo9o6Oj3Lp1C5fLxalTp3C73bz44ou4XC4WFhbodrsyL7Ffy2lFnFqIA5bLZS5dusTCwgKrq6skEon7DItQRRYDr6anp5mammJ2dhav1ytP6yIEtLGxweeffy4T2MM4aE2n0zE2NsbIyAjhcFgeToTH3G636Xa7rK2t8d5777GxsSG7we9di8ECi9nZWVnOLZR7RTVoLpfjzp070lANGyIMXa1WuXnzJmazmYMHD+L3+3G5XHznO9/h8OHDMkcTCoU4c+YMNpuNTCZDMplkcXGRy5cvk06nZZPvbnrM+8a4iHDOCy+8wOzsLH/6p3+K1+uVeYP/9t/+Gx999BHFYpH5+fmhyrNsN8VikYsXLwJf5a6CwSBzc3NMTU1x8OBBbDYbL7zwAi+88AKXL19maWmJWCxGrVbbl8ZFeLfCuAQCAW7dusX169dZWVlhbW2NTCZz357RarUyp/Dqq6/y3e9+F7fbzczMjDQs/X6fVqslp4ZevHiRS5cu7ai0xm6i1+sZHx9nenqacDgsO8oFosx4fX2d3/3ud3LO0lYI4yLGcX/729+WxRLivcRY37t378reo2FD7KF+v8+tW7eo1+uo1Wq++c1v4nQ6+fa3vy0nxVarVWw2G+Pj4/T7fd5//33m5+e5cuUKf//3fy/v0d0Oxe6qcdFoNDKBNzIyQr1elwk7oSgrBjKZTCamp6eZmJjAbDZz+/ZtrFarHAkqPJhB1VWFBzNYSQbIqpRUKsXKysom3TK73S671pPJJPl8ft89OO9NjIqKGyHRIuaMiM9lMBgwmUxYrVaOHDkiO/hFXi+Xy8mHopg+KbTfhq2I5F6EBmA2myWfz1Mul+U69no9ObhvMHJwL6KcW0iVeDweRkdHN5XK9/t9GWJcXl4mm81SLBaHelyBUDEQskK9Xk+ulQjLinxzKpXaFL4WTal7ZSLvrhoXIRkRDoel0u8XX3zB0tISBoMBu92O0+nktddeIxQKcfDgQQ4ePMjCwgL/4T/8B5rNJv/iX/wL3n77bQC5WYdlOt2zRBj1QqHAL3/5S27cuMFbb71FKBQiEonwgx/8QEqYZDIZms3mI4eT7TXEQ05Uv4lSTpvNhtPplElPUd49OTlJMBjkH/yDf8Dk5CSZTIZ0Ok2xWCSfz2MwGJiamsLr9VIul0mlUnJt9sLNvVMIlYh8Pk8gEGBqako2A3Y6HT788EOuX7/OrVu3HpgbERV3VquVt99+myNHjjA7O4vb7ZbGpdvtcvXqVX77299KFd9yubzrJ/KdpNvtyhkuR48epdvtolarsVqt9Pt97HY7/X6fZDLJ+fPnSaVSvPvuu1y5ckWqbOyVg82uGhdxCuz1eni9XtrtNl6vl1wuh8VikSWjQidHqNM2Go1N87TFZhOnz2GR4X6WiLLwarVKKpVCq9XK5kG1Wo3X65Wb22w20+/3H1pWulcZLIHXaDRYLBasVqtU3hVTOb1eL8FgkGAwKIsfcrkcxWIRrVYr5XSEIREzW4b94Qdfzb3XaDTk83npxQk9u42NDeLxuPRwt0IYdrvdLiuhXC6X7FAXvwdRbi96hYYtkb8VYh0Hq+HEM20w/CgGpwmtsL2WW94149Lv97l48SL//t//ezweDy+88AIGg4GzZ8+SzWalcen1euRyOer1Oh999BHRaJRMJsPq6io6nU6eJtVqNZOTkzgcjqFpmNwNarUa165dY3l5WYbE7HY74XAYk8nEiRMn5Mn1+vXr+64cdLCay+VyMTExQa1W4/Tp0/Lk12w2sdvtBAIBqY1169YtPv74Yz799FM8Ho8segiFQjgcDubn5/l//+//kUqlyGazu/0xd5Rutysr4T777DOq1aoMb3e7XS5evMji4iLVavWB+8NqtXLgwAECgQDHjx+XBTpi/s21a9fIZDJ88sknXL58+bkxLBqNRk7tDIfDD5x3L6ocy+XynlV/2FXjsrq6yu9//3uOHTvGd7/7XcLhMAcPHqTRaEjjUiqVeO+991hbW+POnTt88MEHtFotGo0GdrtdLrBarSYQCABs0jVS+Hq0Wi2i0SharZaFhQVmZmYYHR3lwIEDmM1mIpGIjLOL0MV+QXgtosExFArJrvqTJ0/KuffValWWflYqFS5cuEA8Hmd+fp6LFy8yOjoqh4fV63XZtHb58mU52W+Y6fV68jMuLi5Sr9fR6XRYrVZ6vR7z8/PE4/GHvoeYVBkOh+WXoNlssrKywvr6uqzk22sPzp1CpVLhdDoJh8ObVKXvRXTvixzfXlyfXQ2LVSoVEokEWq2Wn/3sZ1IfSyyocL+vXr0qpbkHR6KK5JcYNbsXF3g/Ik5BzWZTDh8TiUXR3/AwFYC9iPhMjUaD27dvS+9W9L6IyZHi7xOJhCz7vHjxosylHDt2jPHxcU6ePInT6aRYLHL58mUWFhZkWGw/GdynpV6vy76yYrEI8MA+IUCGGicmJjh16hSBQGBT2XGz2SSbzXLz5k0WFhZIJpPPxX0t+lbELJupqSkmJiaoVCryOVmtVolEInKMthghHY1GqVarVKvVh1bmPWt21bgISXKhFWQ0GhkZGcHtdlMoFIjFYrKKqdFo3DcAq9frkc1mWV9fJ5fLDXUS9VnT7/dlVZTH46HX66HVamXjnMh/7SfEifvChQvMzc3JOL7VaiUYDKLX66URunPnDp988okUsywUCpw7d4433niDyclJ3nrrLfR6Pf/n//wfLl68yO3bt+Xogr1ycz8LSqUS5XJ501540H2oVquZnp7m5ZdfZnJykm9/+9u43e5N6ui5XI5YLMbHH3/M1atXh07bbivEOOLvf//7jI6O8tJLLzE7OyuNRT6f58MPPySZTMo+IKfTycsvv0ypVCKZTMqIQ6lU2jM5v101LiJM0Wq15EAmg8Egh4Dl83lZ4vmg8kNx2un3+xgMBoxGo5LQ3yaEPM9gOemgIsJ+RMwA6vV6pNNp1tbWMJvN1Gq1TeFUIdwpNJlExY7X68XhcMi+BDFZUdzUz5NhAR4r1q9SqTCZTOh0Onw+H6OjowQCASwWixx+JYayiZ4jIUK7Vx6UO4UYgyH0wYSytlqtplwuS49YzGmKRqOsrKzICIIYdDc6Okqj0WB1dVWOkt7tvbgnmig7nY6M4VerVXQ6nRx21ev1HhhmEGGOcrmMRqMhGAyi0WikHpHCkyMmKArRu2HxCkXOpVqt8sUXXzA/Py8n+A0eSmq1mtxXfr9f6oi98sorAKytrVEul7l8+TJffPHFUIpTbhdGo1GWGb/xxhv80R/9EWazGafTiUajkXOHLly4wF//9V/Lgp1nLbT4LBEagMePH+eVV15hbGyMN998E5fLRb1eZ319nQ8++ID/+l//qxTsFLOcLl68yMGDB/nJT36C0+nk1VdfZXZ2lo8//lgWWjyrmS0PY08YFyHGCHytihDh+bTbbVQqFRaLhUqlongu20Sn05E5rt0+BW0nYq9ls9lHVnaZzWbGxsZwuVyykbJWq7G+vi5/PpvN7omT4l5lUBVB9E2JKqh+vy+lc1KplAxBin6NYUWj0aDVavH5fFIjLBgMYrVaWVtbk2mBa9euUS6Xga+08VqtFnq9nna7jUajkTOdlpeX5SwXrVarGJenRVSOCenvTqejVIttE2azGYfDId305w1xYHnxxReZnp7mwIEDWCwW8vk8c3NzJBIJEonE0DdNPi1ms5nTp09z6NAhJicnN+2ldrvNjRs3WF5elmPJRQXUsGI2m2Uxg5jFYjAY5Jz7X//611y5coW7d+9uMhD9fp9CoUCv18NkMvHee+8xMjLC5OQkXq+XY8eO8Sd/8ifEYjHeffdd1tfXZU/XbrCvjYvweJrNJk6nE4/HQ7PZVIzLNiBmRthsNllJ9Twh8kpms5ljx47xwgsvEAqFMJvNtNttbt68yfr6Oul0+rnov3gaRH/USy+9hNfr3ZSva7fbzM/Pc+HCBebn5+WI7mHGaDRy8uRJDh8+zIsvvsjJkyep1Wqsrq6SyWT47W9/yy9+8QupGj+IGESnUqn46KOPGBkZwev1MjMzw8GDB3E6nSwtLXH+/HlZaacYlydAyHpns1m8Xi9ut5t6vY7RaJQ6R8N4otwqmb4TIRmh7yZCGL1eTzYaDvsD1WKx4PF4iEQi+Hw+nE4njUZDJpyTySTpdPq5qGb6ugjD7PV6GRsbIxKJyJCPyIe2Wi05RCwajRKNRh/a0T8MiFn3QrcvEAhgs9lkrvn69eskEgnS6fQjx4TU63Wi0SjNZpPFxUVsNpus5nS5XIyOjsrcy+Bo5GfJvjYu3W5XjqIdHx+XSrViwmCj0dj1uONOIAQ6B8UndyKMoNVq0el0UihPjANOJpMUi8WhzjEEg0FefvllRkdHOXLkCBMTE1y6dEmGKy5fvkwmkxn6U/aToNFo0Gg0nDp1in/yT/4Jfr+fw4cP43K55EGlWCxy5coVNjY2+PTTT/n000/vkzwZNoRhsVqtzMzMcOLECTweDyqVSg4LW1hYYGNj45HrkM/n+fTTT7FYLGi1WtbX1zl27Bivv/46Wq2WV199lWAwyPnz56U0zLNmXxsXUS1WqVTodDoYjUY55newGXOYEEk9cQNrNBra7fZDpTa+znuL99fpdJjNZnnaFMarVqtRLBaHtp9DGG5RduzxeORpu1qtSvHOSqWieC0PQFTfCdkgr9crh9DBV/Ly+XxeKh0Pu6qBYDDqMPjf4oDY6XSkWvy9fX2DCB1AMe48nU5LvTe9Xo/dbsflcskx0bvBvjYuvV5Plt7lcjkpR221WmXVxH5T7n0Uer2eiYkJXC4Xfr+fYDBIMpnkgw8+kMm+J3noi00pJObdbjdvvfUWr732Gmq1mo2NDUqlEpcvX+bzzz+Xw5+GCbVaLRvURNmx3W6nWCxSrVa5dOkSH3/8MdlsVjEsD0CtVks9upGRESKRCE6nE6PRiEqlksO/0uk0ly9fllqBzwMirFwul5mbm6PX63HixAncbjejo6P8s3/2z+SwOTGVcnl5+aGHxl6vx8bGhpyx0+l0UKvVuFwuarXapmmez5p9bVxEL4b4gq9mxJhMpk1jV4cFMb98ZGSEqakpZmZmWFpa4osvvpASOE9qXHQ6HRaLhYmJCTniYHp6Wo4BTqVSRKNR2ag1jMbFZrPh9/sJhUJMTk6i1+vJ5XJUq1XW19dZWloa+mqmp0E0TNpsNnl6ttls8vuiabpSqbC+vi6lS54HRHK90WgQj8cxmUyMjo7S7/dxOBx84xvfkHJLzWZTTvN8mHEReWexR7vdrixEsdvtu9rzNzRP30G3ctgeeoP0ej0ZmjIajXJ42g9+8APpHpfLZcrlsswJiIfhYHe9CKlZrVaMRqMUDRWndo/HQzAYlAq4X3zxBclkUkpNDFNsXAwNM5lMHDp0iBMnTjAzMyMVtoUQ4/LyspzfPsx77EkRBSCTk5PMzs4yOTm5SdW33+8TjUZZXFzkzp07rKysSAme54lWq8Xi4iKlUgmTyYTRaJS5YoPBwLFjx3C73aRSKY4dO7bpICMO0nq9HpvNhk6nk8rcx44dQ6/XSzFVZczxNiFczmFPsPZ6PYrFojydiCFLs7Oz1Go1WSK7trbG1atXqdVqsuhh0KgYDAZ0Oh3hcBiPx8NLL73EH//xH+NwOAgEAphMJprNJs1mk3g8zm9+8xtisRjr6+tDVyQhJv3ZbDbOnj3LO++8g81mw+PxkEgkuHTpElevXiUWi8nQo8JmRCWUwWDgyJEjvP7660xMTGxqCxCabX/3d3/H+vo68/PzQ18YshWNRoOrV6+i1WqpVCoUi0VGR0d58803pWaYwWCgVqttUscQQ8I2NjawWq1EIhFpmPR6vZS/qtfr1Ot1KpXKrlZ1Do1xESf0RqMhZ0vk8/ndvqxtZ7AcWIj86XQ6jEYjOp1Ojh3QarUy/GA2m6lUKuj1elkBZrFY0Ov1MscwNjaG0+nEbDbLgU2lUol0Oi3H1gqdrWFBeHEmk0mug5hh0+12icViJBIJstkshUKBRqOhGJYHoNVqsdvt2Gw2vF4vPp8Pq9Uqk9YiqlAoFEgmk2QymefWAxSqBEJDMRaL0e12mZ+fx+12EwgEcDqdshxZo9FgNBpl8U6/35fyOUJsVeSXG40G2WxWNvjuZqHE0BiXQqHAnTt36Ha7+P1+Kdf/qLkS+41ut0s6nSaXy/H++++Tz+eZmJjgBz/4gZzYCUjDUqvVuHPnDsViUbrgVquVkZERWRUmjI3D4ZA/W61WOX/+PJ988ok8ZZZKpaHqb9HpdOj1ekZHR/ne975HKBTi9OnThEIhLl68yE9/+lM2Nja4dOkSyWRyqAzrdmO32zl9+jSBQICzZ89y+vRpWdUoRClrtRq3b9/mww8/lKfr5xVReCPGChgMBn77299iNps5e/Ys09PTOJ1O2R8kwrQmk4mRkRFZgNPtdlldXSWbzUo9vEQiwf/9v/+XlZWVXZXgHxrj0ul0qFar9Pt9jEYjdrtdVqgMk9st5qwAbGxscPfuXXmiEWN7B8sPa7UaKpWKQqEgR/parVZCodCmZJ84WXY6HekBJhIJlpeXpTrwsD0MRI7AarUyOjrK6OiojHvX63UWFxdJpVJSkkThwej1enw+nxwL7XQ65fd6vR71ep1yuSzzgsOUs3tSBguSVCoViUQCo9GIw+FArVbj9/ulAREJfhHWBmQHf7lcJpvNyvVNJBKyMXU3PcOhMS4CkVcY1j6XQURHc71e53//7/+Nx+ORCXqn08nIyAj9fp9cLkez2cRisWA2m+l0Oty5c2dTniqZTLK4uLhpfs7S0hKrq6sPHXmwn7Farfj9fiKRCAcOHCAUCtHr9YjFYqytrbG0tCRHbCtsjcFgwGAwEIlEePPNNxkfH2d0dHTTa8rlMr/73e9YXl7m1q1bz2Uo7FGI0Faz2eTWrVuk02mp7WcwGPD5fFv2rIiZVkI1o1arUavVyGQyT9yWsF0MnXGBL0+kGo1m384ceVyEFHexWKTX60nPxGQyEYlEOHHihIzJioSryWSSczOEG91sNrlx4wYfffQRlUpFypoMk8e3FRaLRZ62JyYmCAaD5HI5UqkUiURCzhVRHoYPRnh+wWCQc+fOMTU1dV/5a61W48KFC7KvZdj31ZPS6/VotVqsrKywsrIi//5xnmN7cU2HxrgIyW6dTofBYJAW/3mg3W6Ty+WksTAYDLJceLDXZ21tDZ/PJ3NRg4PY7h3QtBc363YiEvl+vx+32y0fiLFYjNXVVdbW1uQ6DPtaPA3CsHg8nvuUMYSobKVSoVwuUyqVhq7S8FmwX/ff0BiXXC7H9evXcTgcUoLabrfv9mU9E+r1Oqurq9I7EaHBe9WhRbhQxGrFg1NUr7RarV1VUX3W+P1+jhw5wtjYmOxk/vzzz3nvvfeIx+NKddgjUKlUBAIBTpw4wYEDB2TfhThpNxoNMpmM7I/a2NhQclfPEUNjXMTIWaENZTAYNjVwDTPCOCh8PQZHCmg0mk3TN4d9WNV20e/35WFFSLsI76XRaJDL5cjn87Kx73k5uCgMkXERnkswGOTIkSMYDIahT+grPDkqlQq32y3H72q1WikGKMpm92s44lnR7/dZX1+nWq2Sz+c5c+YM5XKZQCCAw+FgeXmZn/3sZyQSCWKxGPV6XTHYzxFDY1xqtRobGxtotVqpLPq8eC4KT4bJZMLtdmO321GpVHJkdqPRUMYWPybFYpFyuYzNZiOVSklNK6vVSi6X48aNG6TTaYrFoqLH9pwxNMal0+lQr9fJZDJ88MEHXLt2jbt37yoPCIUt6ff73Lx5k7/927/FaDRis9nodrtcuXJl12Uz9hMiLJZOp/nVr34lh/ZZrVbu3r3L4uKiMp7gOUXVf8yn734p6xUihOIkuhMx3icxWPtl/Z4Fe2X9RIHD4PsLWY69fCh50mvbyT04eN+JcPTgmN69Fg7bK3twv/I46zd0xuVZoGzMp0NZv6djLxqX/YayB5+ObTUuCgoKCgoKj4tSTqWgoKCgsO0oxkVBQUFBYdtRjIuCgoKCwrajGBcFBQUFhW1HMS4KCgoKCtuOYlwUFBQUFLYdxbgoKCgoKGw7inFRUFBQUNh2FOOioKCgoLDtKMZFQUFBQWHbUYyLgoKCgsK2oxgXBQUFBYVt57HnuSiKoF+hKKo+Hcr6PR2KKvLTo+zBp+Nx1k/xXBQUFBQUth3FuCgoKCgobDuKcVFQUFBQ2HYU46KgoKCgsO0oxkVBQUFBYdtRjIuCgoKCwrbz2KXICgoK97NVeeqTlgoPM/euk7JGw49iXBQUviY2m43x8XGsViuzs7MEg0GKxSLpdJpCocDVq1fJ5XK7fZm7jlqtRqPR4HK5eOuttwiHw8RiMeLxOLlcjoWFBRqNxm5fpsIOoRgXBYWvicPh4IUXXiAUCvGjH/2I06dPs7q6yvXr11leXiYWiynGBdBoNBgMBkZGRvjn//yfc+7cOc6fP8/58+dZXFwkHo8rxmWI2RPGRafTYbPZ0Ol0eDwebDbbfa/p9/tUq1Wq1Sq9Xo9Wq0Wv16PZbNJut9HpdBiNRgB6vR79fp9Op0O32930Ho1Gg06n88w+m8LwYDAY0Ov1eDwexsfHCYVCOJ1ODAYDNpsNr9dLuVzGZrNhNptpt9u02+3dvuxdRaVSoVKp0Ov1GI1GLBYLTqcTq9WKRqNBpVIpIbIhZU8YF7vdzgsvvIDX6+Wdd97h1KlTclPCl0ah1+tx8+ZNbt68Sb1eJ5PJUK/XWVtbI5/P4/V6GR0dRaVS0Wg06Ha7lMtlKpWK/Hfa7bZ8vYLC18Xj8RAKhTh+/Dh/+Id/KI1Lv9/H5XJx7NgxLBYLU1NTVKtV0uk02Wx2ty97TyAMiNPpZGxsjEKhgMFgQKPR0O12FQMzhOyqcVGpVKjVaoxGI16vl1AoxOzsLMeOHdvSuLTbbWq1GpVKBb1eT71ep16vA+Dz+QiFQgDSOzGZTBiNRvnzzWYTvV6/a59XYf8iTt8WiwWHw4Hf78fv96PRaOj3+9L7ttlsWK1WrFYrxWJxty97V+n3+/Kr0+nQbrfRaDRYrVYsFgtGoxGDwUCz2Ry6aIJ4rqnV9xfk9vt9ms2mjKoMq2HdVePicrlwu93MzMzw/e9/n3A4TCQSATYvuPjvSCSC0Wik0+lQq9Vot9uk02nK5TJ2ux2fzwd86aF0u11pfGq1GqlUimKxSLFYJJfL0ev1NoXMFBQehVqtlklq8SUOQOKgZDKZmJqaotfr0Wg0SCQSu3zVu4cIXxeLRa5duwYg7/d+v8+bb75JPB7n6tWrRKPRXb7a7WVsbIy/+qu/kgfewedZoVDg3XffZXFxkWq1uim6MkzsqnGxWq0Eg0EmJyc5c+YMkUgEvV5Pv9/fMhbr9Xrxer3y/0UeptlsYjQaMZvNqFQqOp0O/X5fxrzz+TwLCwtsbGxw4cIFdDqdNEAKCo+LSqVCo9GgVqs3edaD3zcYDIRCIdrtNouLi891TkFEG+r1OsvLy2i1Ws6ePUs4HKbb7XLq1Cm8Xi/r6+tDZ1wCgQA//vGPOXbsmPTeBNFolDt37pDJZOh2u4px2YuoVCp0Oh0AWq1W3uxqtZp+vy//zmKxEAwG0Wg0eDweHA4HtVqNUqn03N74T4tWq8VgMAAPliIXBRTPixEX4Y54PM7y8jKFQkHZX3xlZDqdDr1eD/hyz2i1WnQ63Zaho2HGZDLxwgsvYLFYqFQqlMtluS5b0Wq1WF9fp1KpkM/n903OeE8Zl3st/ONgMBjkQ04gNquIhxsMBlwuF36/n8nJSVZWVkilUpTLZeXmf0JMJhNOp1Oe4rd6QHQ6HTKZDLVabReu8NnS7/flKXRubo4rV66QyWR2+7J2HZHv7HQ6m3IrarUavV4vk/rDyGDOaRCHw8FPfvITms3mY4Xns9ks7777LktLS8zNze2bQ8uuGpdOp0Oj0aBarZLNZjEajdhsNoxGIzqdTnol4sTTbDZptVr3vc9gqeO9Dzrx/xqNBqPRiN1ux+v1UqvVlOE/D0DkFsTvQKvVotfrN+UXxDqK1w6upbhhWq0WlUplaIyLTqfDarViMpnueyCKm13k+iqVypZ79Xnl3ofsoOcyrPfh4Gce/OxqtVqWq9/7va3QaDQEg0EajQa5XG6TcRHecrvdptVq7al7bVeNSy6Xo1arUavVsFgs+P1+Tp06xcTEBC6Xi1AoRL/fJ5vNUqvVWFhY4O7du1u+18zMDC+88AIGg2HLmx++fDi8+OKLOBwOPvzwQxYWFp6bkM3jotFosNls6PV6JicniUQiMglrMBjkg8Dj8chQ473GpdlsUiwWyWQy/Mf/+B+HoqFQpVIRiUQ4d+4cExMT93nL8JVRFUUjz3uPy8PQ6XQ4HA7q9TpmsxmdTvfcFNmIcL5W++Xj91HGxe1288Ybb1Aul3nrrbc2hcXa7Ta3bt0ikUhw9+5dPv/88z2z73bVuDQaDRqNBmq1mtu3b5NOp2UTpVarlU2QlUqFSqVCLBZjfn5+y1+G0Wjk/2vvTJ/juK6z/0x3z77vGwb7QoAERdIQRYqU5S0uq2S7nJQrSiWpJN/zJyX+kCpX5UPsxLJTjixZ1krJpkhxB4gds+9bz3T37PN+4HuvBiBAguQAGID3V8WCRJDgzJ3b95x7luecOnUKAPa8aguCAI/Hg3a7jaWlpZcu1vskSIKa3PB0Oh0NI/p8Ppw/f54WTACgpeOkaqoXWZaRy+WQSCRgtVqP4u30HXJbCwQCcDqd9GDYCamQYp3nj9PrgHAcB61WC51ORx2U4xDq6Re7FYTshU6nw9DQEC3n7jUejUYDarUaRqMRoihCEIQnGujnST08LwORc1EUBeFwGNlsFrVaDbdu3YLZbIbT6US320W5XEaz2UQ8Ht+ztDORSGBlZQVOpxNXrlyBz+eD3W6HzWY73DdzzCAhyGAwiFOnTsFkMiEUCsFkMiEQCMDr9dL/7g1hGI1GeigQZFmmV/eNjQ0kk0lUKpWjemt9ged52Gw2GAwGhEIhjI2NwW6305AtgeQVWEPgdojDotfrYTQaaZ+ZwWDA6OgoTCYTXC4X9Hr9iex36Qck7E/CiMR4kMrYyclJWK1W2uS7282l0WigUqlAlmXcuXMHiUTiwF/3wBiXzc1NAMDS0tK22D6AbfHFvR5c4gkMDw9Do9Hg9OnTmJiYYMblCahUKuj1euj1epw+fRo/+9nP4HQ6MTs7C5vNBo1GQw3Kzs9kJ6QsvFgsIplM4sGDB8hkMhBF8TDfUt8RBAEulwt2ux2jo6OYnJykBrkXktBnxuUbem/DBoMBJpNpm3EZHx+H3W6nxoVUF7L1205vVezO3+90OpiensbIyAhOnz6Nq1ev7rp+oigimUwil8shn8+/PMYF2J4QfRYEQaDepdvtRjAYhMvl2raRe/+Ner0OWZbRaDRO9CbmeZ56O8RQyLIMSZJoN7lGo0EwGITNZsPc3Bz8fj8NSXY6HRQKBSiKQpURut0u9Ho91Go1TVr3VsSUy2WIooh8Po/19XUUi8WBSjA+D6TTmqg9EIO7k2q1imQyiUQigXq9fgSvdPAghkWj0cDhcMDr9cJoNNLvk2IQ8mdPEpIkYXl5eZuzYbVa4fV6oVartzXgPg+9zh5ZY8Ju5xrHcVQhYXx8HKIoolgsIpPJHNg5ODDG5Xnorbq4ePEifvrTn8LhcGB2dhZWq5VWYxDa7TZKpRKSySTK5fKJNi4GgwFOpxM2mw2XLl2C2+2mBRFOpxPz8/Ow2+24ePEixsbGoNfrYTKZ0Ol0UKlUUCgUcPv2bTx48ACFQgGrq6vodDoIhUKw2+2IRCJYXl5Gq9WiTavtdpuGhkh/y3FvECOOi8fj2Sa4uDNfFw6H8cEHHyAWi52IAoZ+QMqNzWYz5ufncenSJVrRedJJJBL4t3/7t205x4WFBbzzzjv0bNorb/csqFQqKnFlMBhgsVh2PdecTifcbjdkWUan08HFixdx7do1/O53vzuwqsZjZ1x6S4sFQaB6Tl6vF2NjY7DZbPTDIx5mb1hNURRUKhXU6/UTaVxI5ZZOp4PNZqNxWJ/Ph1KphFQqBYvFAqfTCafTCa/XC7/fTyt1ms0myuUyFEVBKpVCOBymORRiOERRxMbGBlZWVmhz3ElcS2B7yeyT+jFqtRry+TyKxeLAVOscNeRZFQSBarK9LNRqNUSjUWSzWfp7fr8f5XKZhrN6b8Ck9H8v9Ycn0VsMsdceJQ3lgiDA5/NBpVJhdXUVRqMRHMdRlfl+cqyMC6lislqtGB8fh9VqxczMDPx+P8bHxzExMQGtVguj0QhBEKh3STqEy+Uy7t+/jy+//BLhcLjvi3nUcBwHj8cDi8WCmZkZXL16FXa7HTMzM7BYLFQpWqPRUAPy/vvvQ6vVolQqIZvN0t6URqOBVCqFdDqNWq1Ga+trtRq0Wi0qlQrdkCfVsADfhFJrtRrNJ+n1ejgcjhPb/Md4ccjz03s7+eqrr6DVamEwGB6raHW73VhYWIDVaoXdbt8WPuwHpCiA4zgMDw/D6XSi1WpBEASkUil8/PHH2wxhPzhWxkWtVsNgMMDlcmFubg4ulwsLCwsYHR2FzWaD1+vdtby4tzw0Go1iaWnpqZILxxFSLuvz+TA9PY2rV6/SddFqtYjFYlhfX0e73abq0hsbG1AUBfF4HOvr67TUkYS4dlbvHPcE/bPSq8gtSRIKhQIsFgusViszLow9abVaKJVKj/1+p9OhudDe28no6Cj8fj/a7TYMBsOBGBfSNuByuWCz2dBut8HzPNbX13Hz5s2Xz7gQpVm1Wo1Tp05hdnYWTqcTp0+fhsViwdDQEC0V3XmVLJVKEEURoigiGo0il8shGo1CkqQTk9AnITCPxwOj0YgzZ84gFAphZmYGdrsdgiAgHA6jXq/j/v37ePDgAb1tdDodWtxQKpVonqTdbqPT6Zw44/s88DwPi8UCh8NBS9v1ev22WzG50ZH5QS9DI+B+MBgM8Pl88Pv9uzadvmzUajXkcrltURUCx3G4desWPB4Pms0mla0yGo19z1ERp4j0bXW7XVy8eBE+nw9bW1t9qyQbeOPC8zwcDgfMZjP+6q/+Cn/9139Nu/l3xsJ7P4Rut4tkMom1tTVEo1F8/vnnyOfzWFxcRLFYPDGGRaVS0bG7LpcLr7/+OjUsfr8foiji888/RzgcxrVr13Dt2rVtRoNUevUak5OwNv2CNN6SyZMej2fbniO3u2q1SoeDsZzLI0gV4vDwcN898eOIJEkIh8O7GgvS4+dwONBqtaBSqeBwOPZUG3kRBEGAIAhwu93UwKhUKqRSKbz77rvH17jwPA+r1QqtVgu1Wv3U4V0ajYZ65X6/ny54b7VFr6w50XZqNptIp9MIh8NIJBLIZDLUOz8pHjnpcHY4HLTh0ePxwG63g+d5FAoFmidIJBIoFousj+AZITcXEgfvTboCoEa5Xq/TJjV2c3kE0WLrV2XUcYdUVO5GvV6nTm82m0U6nUaz2YRGo9nTuBDnkjg7giBAr9fv+/WQEmaSQ+x0Oo9V2L4Ih/6JWywW/PjHP8bExARCoRBGRkZ2teRk4Ugiiud5uN1uuN3ubZIjOydWKoqCu3fvIpfL4f3338enn34KRVFQKpXQarXo5MqTQDAYxNTUFCYmJvDOO+/A5/PRSrnFxUV89NFHSKfTuHbt2ktRfn0Q6HQ6nDlzBgsLC/B6vdti5d1ul+by0uk0lpaWaKEE49G8JnLj0+l0R/1yBhoysj2dTkOr1WJzcxNmsxkul2vX87FX+Z20BwwNDWFmZmbfNx3Sa2M2mzE1NQWfzwen09m3GUSHZlx6RxqPjY1hfn4eU1NTmJ2dfaJxAfbuzN+tZK/ZbCKXyyEWi2FjYwOLi4sn8kBVqVQwmUzw+/0IhUKYmJiAz+cD8I2RXV1dpbNF+p2se1kgM4C8Xi8sFstjoVciJS/LMorF4rHv6+kngiDQkc+9B97LPEBtL0hPmKIoSCQS9BaRzWafqIFIBD9rtRpMJhPa7fZjQrJPgpRAW61WCILQVyfgwI0LaTjz+/04ffo0vF4vzp8/j6mpKTidzif+3d3kqnf7PgCaUE2lUrhx4wY2NjYQi8VO9Cb2+Xw4d+4cHf/cbrexubmJTCaDGzdu4MGDByeiS35Qabfb2NraQiwWQyQSYeGwXdgpG9T79SQ/m89Lp9NBLpdDrVaDWq2GTqd7onERBAHlchkulwvlchlqtRoWiwWhUKivIa7n4VCMiyAICIVC+MEPfgC/34/z58/TJNJe7HfjkZHIiqIgl8shHo/j66+/xtLS0rGZ2PY8qFQqalwcDgd0Oh1arRbW19dx//593Lp1C0tLS5BlmYkBHhDNZhPhcBh3795FJBI5Mbm8frFT2mU3fbqXoVv/WSAjRvL5/L7Whud55HI52Gw2yLIMk8kEj8cDp9N58o0LGYdrMpngdrvhdDq3zQUBdjckO4dPkRDETu+wd56IwWCA2WzG8PAwlTwvl8sH9M6ODqJQQK7DpJlRrVbD4XAgFApBURQUCgVIkoRKpUKHCTWbTdpNzozO3pCQK8mx7OU9kpDYSVV86Ae9EQjyXJMEdi6XQ7VaRb1eZze/HexnP5E1JTptu0kTHRUHalzIgU8k28+cOQOn0/lMZYndbpc29UmSBEmS6KKTHA6ZmOj1eqHX6/HWW2/h3Llz+O1vf4twOHyiHnpS4KBWq1Gv15HJZMBxHDUu8/PzmJmZwZUrV/DjH/8YkiRhZWUFpVKJypPEYjF8+umnL11D5LNAdLFIMclu+T0i1knUn0/SPusHveoNO78Wi0Vcv34dyWQSm5ubEEXxxKs9HATEASJDEo1G44GULz8PB35zIZ2hAGiD3n5otVrUI6/Vami1WlR1t9e4WCwW6HQ6mEwmGI1G6HQ6OJ3OvpfVDRLEQ2k2m6hUKjAajahWq9R70Wq11PBKkgRFUajAp16vR6vVgt1uBwB6GyQd+YxHkLJOnU5Hlbd3My5Ej42FxPYPiUKIokhlhNje2x+9Y8V5nodaraatGWS/kuf/aWE1co72Kpj08/Z44MalXq+jWq3i3r17+MUvfoFAIICf//znmJ6efuLfC4fDuHHjBmRZRrlcRr1eRzQa3ZakJ556MBjEzMwMXnvtNdp0CeBENm6RTcVxHCKRCD7++GM4nU4kk0naU6DRaGC1WukY4snJSQDfTP7M5/OYnZ1FuVzG6uoqMpkM4vE4VldXWWji/+NyuXD69GmMjIzA5/PBZDKxXo0+QipAiRoEu7HsD4fDAZfLRRvJdTodRkdH4Xa7MTk5ifn5eRgMhn051r2ai3fu3EEmk0E0Gu3bZ3GgTwsJaXEch0Qigc8++wyhUAjf//73n/p38/k8bt++jXK5jHw+T0trV1dX6ZsnnvnMzAxMJhNarRZ4nofRaES73aa5nZO2cUmMlXSDWywW1Go1mM1mWCwWGAwGDA0NwWw2w2QywefzwWAw0Ae6Wq3C5/OhXC7DYrFQvTHylQGYzWaMjY1haGgIVquV9Wn0mV5ViJP2fB4UpP3A6/XCZrNhfHwcJpMJo6OjcDqdGB4extDQ0L6dIDI9VZZlbG5uIh6P97UI6sBdsZ3XXUEQcO3aNRQKBVitVlitVtRqNSSTSdTrdSiKgkajgc3NTdy9e5cOpSIWttvtUs/cYrHg7NmzuHDhAsbHx6FWq9FsNpHP51EoFOgwq5MAGQdLatE5jqNKvaTUmHTsazQabGxsYGNjA3q9Hh6PhxY7mM1mWtuuVqsxNDQEvV5P1ZKJJ8lgMAYDomqi0+kwOTmJ2dlZOBwOTE5OwmQywel0wmQyweFw7KvCjITCc7kcEokEkskkbt++jXg8jkwm07fXfeDGhajs1mo1iKKIcrmMX/3qV3A6nZiamsLMzAwymQw1OCQ5SmLZvQ2U5NDT6/UYHh6Gx+PBd7/7XXzve9+jXfuyLNMF202V9LjicDhw7tw5aLVa6vU9fPgQGxsb6Ha72zSLepN8arUadrudNq8S9dWLFy/CbDZjdnYWHMehUCjQcuaTIurJYJwE1Go1AoEAbDYbvvWtb+HSpUtwuVyYnZ2lgr29FWNPgkgVNRoNhMNhXL9+HbFYDO+//z4SicTxyrkQiJFoNpsolUrodDowmUzQ6/XI5/PIZrMol8sol8uoVCpP/FmCIMBiscBms9EkPtF2KhQKSCaTiMfjT/05xwG9Xg+NRkNnjQuCgEKhQJOgZIzqzk1BjDoppdVqtbBYLHS9SAkjSUYTsUVmVBiMwYBofxmNRrjdbrhcLrhcLjgcDlitVuj1eqo23fvc7vUMk4GAlUoFkiQhk8kgFoshlUpRdfR+cugZymaziVgsBkEQEI1G8dVXX6HZbEIURXogPg2z2YzTp0/T+e/dbheJRAL37t1DIpHAu+++i62tLeRyuWN9WPI8j4mJCYyMjCAUCuH8+fOo1Wp47733sLm5iXw+/8SNRKZEtlotcBxHS5fJJhIEAcvLy0ilUlhfXz+QaXQMBuP5IIrFTqcT3/3ud+kojenp6X2J/vZCdBWJ9mI8HseNGzfwwQcfQJKkA4nyHLpx6Xa7NEfwPH0WxAt3OBy0IbPb7UKSJCQSCcRiMWxtbSEcDh976XOO42jVl9frhdvthiiKaDQaEEWRNoo+CVL2CQCyLEOlUkGSJHqVrlQqSKfTNBS5l47bywgp+d4rjr1zXAFbt+08i8YVYzvknOsdVR4KheDxeGCz2fa9rr1VeSSnTZRMiGzRQZ2Tx6K2kgzXISJ4IyMjmJqaQjAYhMViAQBkMhlcv34dqVSKzjE/7l44GUl64cIFKqVNJiISI7MXBoMBNpuNyp6r1WqMjo5iZGQE4+PjGBoagkajQalUwvr6OrLZLFqt1rFfs37h8/lw+fJlqjTdC7lpF4tFbG5uYnl5Gfl8nq3d/4fE/zUaDS2LHYSmvuOASqWi4x0mJydx6dIluN1uzM3N0Sqxp7GzN7BSqaBWq6FQKEAURXz66adYXl7ue45lJwNvXEhymud52Gw2eDweqgLs9/thNpsBPBq2c+vWLRQKBZTL5RPRlMVxHILBIObn52m/ELnePk19t7dKzOv1wmg04vz58zh//jwcDgf8fj+9AUUiEeRyOXpzYYCO0HY6nXSPEZrNJpUuiUQiWFtbOxHOTL8giWW1Wj1QHePHAY7jYLPZ4Ha7MTMzg9dffx0OhwPT09P7MizAI+OiKAqtwk0mk5BlGel0GqVSCX/5y19w7969A3/WD1z+xWazUcltEsKSZZl64HsdkmQWPOlA1Wg0CAaDCAaDGBkZgc1mg06no9paxDqftLwBCV/pdDpagjw3N7dtHEGvZDbBYrHA4/HQYgDSbOVwOMBxHMLhMKrVKr3p9crqvKz0eo1ut5uWde+swOkNhxFlg5O0514UMunQbDbTRPSz5AdeRniep8/48PAwRkZGMDo6CpfLBavVCrVa/dSfQfpWarUaUqkUqtUqVlZWsL6+jlqthlKphGq1emhSRQdqXHiex/T0NKampmifRqvVwubmJsrlMtbW1rC+vr7rGx0dHcVbb70Fk8kEm80Gg8GAiYkJTExMUCHMbreLWCyGQqFAq8NO6iRAh8OBoaEh1Go1cByHVCpFZVvsdjvm5+e3edgcx20TXST5A0EQEIvF8OGHHyKdTuPGjRu0efJlPyAFQcD09DQmJiZw5swZamh2et0khk1muTDRym8gjpBer0cgEMC5c+dgs9loVRNjd7RaLfx+P2w2G958801cuHABfr8f09PTVEvwadTrdUiShGKxiFu3biGVSuHzzz/H9evX6VnRm/M+aA785kKMCrmJkAfSYDCgUqnQCZG9FUwcx8HtdiMQCNCSY51Oh0AgAL/fT732RqOBcrmMZDJJ8ywnzbDIsoxSqUTLhwVBgMvlAs/z1CA4HA6MjIzAZDLRv9ebZCZr22w2oSgKRFFEOp1GMpmEKIqo1+tH9fYGCpVKBb1eT0u2STh2J8S4sAKIvekdwds7vZOxHeL8kSIl0nJAxpXvJ6RIbtHNZhPVahWVSoWOSs5kMshms0eyRw/UuHAcR9WQ3W43xsfHIQgCKpUK6vU6kskkYrEYisUiFhcXUa/XMTIyArfbjbGxMSwsLNBGQCJS2btJa7Ua/vCHP+CPf/wjrXg6SSGKRqOBjz/+GBsbG5iZmcH3vvc9mM1meDwe+Hw++gBrtVoaciTl3IqioFwuQ5ZlhMNhVCoVqlyQTqdx/fp1lMtlpNPpo36bAwNR8SY35b0gCt1EOYLxDb3OTD6fx8rKClwuF4LB4Dbnh/EIk8kEq9WKoaEhvP322/D5fHjllVcwMjJCBSifBJk622g0EIlEcP/+faTTabz//vuIRqNHZliAQzAuNpuN3jimpqa2Xe9yuRwymQxSqRQAoFqt0oX1+XyYnJyEIAh7eofNZhOLi4v45JNPDvJtHBntdhtra2vUOIRCIfh8PlqSSGLbhF7jIkkSrQ5ZWVmhUg+JRAKFQgFLS0ts1vsOyDgDvV5PHZrdIF3O/VaRPSkQdQ3iQatUKng8nqN+WQMJaW72+XyYn5/H0NAQQqHQU6f09kIUUAqFAra2tpBIJLC0tIRYLHaAr/zpHHi1WO8ch50GQqfTweFwgOd5vPrqq6jX6wgGg3A6nfSW0mq1UCwWUa/XodVqodFoUKlUaJNkP7VwBhFyeCWTSXzxxRewWCyIx+NwOByPhW263S7q9Tq9HudyOSiKglgsBkmSqAKCJEknopruqKhWq1haWkIikThREkP9goQLa7UayuUylRXqpVarIRqNIpFIQJKkI3qlRwMJv6rVapw6dQrnz59HKBSiRuVJIqmtVovKYpH/jkajyOfzePDgAW7evEkHsB01h1KKvNe1zGg0wmAw0DBYt9vdNq9ApVKhXq8jHo9DFEUqVhmJRPDee+8hlUohHA4fxls4MkiH/ebmJqLRKNRqNVwuF43F9k5J7O3KJ6MKenMvvb9OSujwKCiVSrh+/Tqi0eiJd26eB5KPkiQJuVyOCsr2IkkS1tfXEQ6HT+S02CfB8zzMZjOMRiNeffVV/PznP4fNZkMoFKIVoXvRaDRoGIx03N+7dw/hcBi3b9/GH//4x4G5UR+45L4kScjn8zCZTLt2MfeKrvVCBtiQBDQpl83lcojFYkgkEshms/vqUj8JkPUg2kCNRmNXoTpS1FCr1aAoCks29xFyaNZqNciyzHIuT4H0UZnN5sduLsT4kBHcLxOCIMDv98PlclFBStLo/LQcCzkDZVlGJpOBLMvY2tpCPB5HLpdDvV4fmKjEgRqXdruNlZUVcByHV199Fa+88sq+SxLJlbpUKuHhw4dIpVJIJBJIpVK0q1yW5ZfuSt1utyGKIt2Eu01HJDcTZlj6CwktptNppNPpl8q5eR5KpRKWl5d3bfpVFAXRaBSRSGQgQjiHicViwc9+9jOcP3+e6gbuzJ/uRqfTwcbGBr766ivE43F89tlnEEURsiyjXq9DluWBMSzAARuXTqdDH0YSonka5HCs1+sQRRGlUgmFQoF2Q29ubkKSJKTT6ZfO4yEM0gY6SfT2r5Cxr4ROp0Mb0Eg/1aCEHwYVooBusVigKApkWaZOETE4L2P+T61WIxgMYnJyEk6n85nGsVerVaTTaUSjUTx8+HCgc34HHharVqvIZrP76grtdDp0GtrDhw/x6aefolwuIx6Po1qtolQqoVQqnch+FsbR02q1sLi4iFwuh9u3b+Pzzz/fVjBBxkRns1lEo1EanmTsDhmjnUwm0Wg0tlVAxeNxpFKpE6eosR96k/FENoikB/aChGTJmI3jsGYHblxkWUY+n0e1Wn3qgrTbbaTTaYTDYVy7dg2//OUvmSwJ49Agpd9ra2sAHg85Eth+3B/VapWGvB48ePDY91/mdSTGhRTcPElBuvdGTYzMcQh7H3i1GJEk2NjYwHvvvfeYCGAvpCoqk8lgY2ODltwxGEcB23v9g63lN9RqNdy/fx/NZhNnzpyhGnZGo3HXhD5pkCyXy1QrLJPJDHxaQNXd56f+vPINxCLrdDo6v/1JkFLaRqMBWZYHclM+z2ti8hffwNbvxXjeZ4Kt4Tcc5R7kOA5msxk6nQ7vvPMO/vEf/5F26e9W8JTP5/Gb3/wGGxsbuH79Om7cuIFms3mkmnb7+XcP/OZCQmGSJL10lV0MBoOxE1LoVKlUaBWsJEngOG7XBspcLodkMknVNarV6kA63TsZ+HkuDAaDcRLpdDr48ssvkUgkoFar9xyqRhrJSVHTcTAswCGExU4iLKzzYrD1ezFYWOzFYXvwxdjP+j05AcJgMBgMxnPAjAuDwWAw+g4zLgwGg8HoO/vOuTAYDAaDsV/YzYXBYDAYfYcZFwaDwWD0HWZcGAwGg9F3mHFhMBgMRt9hxoXBYDAYfYcZFwaDwWD0HWZcGAwGg9F3mHFhMBgMRt9hxoXBYDAYfYcZFwaDwWD0HWZcGAwGg9F3mHFhMBgMRt9hxoXBYDAYfWffY47ZFLZvYFPsXgy2fi8Gm0T54rA9+GKwSZQMBoPBOBKYcWEwGAxG32HGhcFgMBh9hxkXBoPBYPQdZlwYDAaD0XeYcWEwGAxG39l3KTKDwWDsVo7b7Xa3/f7zlkoz+sten9VhwYwLg8F4IjzPg+M4+P1+nD59GhqNhn5PURTIsgyO46DRaNDtdpHNZiGKItrtNprNJjqdDhqNBtrtNhqNBur1+hG+m5OHVquFIAjQaDTQarXQ6XQYGhqC0WiEz+eD2+1GsVjE6uoqqtUqtra2UCgUDvx1MePCYDCeCM/zEAQB4+Pj+Ju/+RuYzWb6vXw+j1wuB0EQYDKZ0Ol0cP/+fUQiEdTrdUiShGazCUmS0Gg0UC6XmXHpIyqVCjqdDnq9HiaTCTabDQ6HA5cvX4bP58OFCxdw9uxZrK2t4Te/+Q0SiQSq1SozLi+CSqWCVquFRqOBWq2G0WgEx3HQ6XQQBIFaenJ17Ha76HQ6aLVaqFarSCQS1Ns6Ttd8lUoFlUoFq9UKr9cLjuPQ6XTQ7XaRy+WQz+eP+iUODGQfqFQq+vV56XQ6aLfb1Es/TnvmafA8D7VaDb1eD7vdDqvVCo7j6DNmMBjA8zwMBgM6nQ4URYHRaESz2YSiKGi1WqhUKmg0GigWiyiVStTgkO8xg7M3giDAYrFArVYDePSM8zxPzzKn0wmj0UiNi8ViwcjICJxOJ+x2+7Zz8EX3+TO97kP5Vw4ZjuPAcRy8Xi/8fj+cTiemp6dhsVgwPDxMHxCn07ltoavVKhRFwc2bN/GLX/wCuVwO1WoVjUbjCN/Ns0E20Llz5/B3f/d30Ol0qNfraDab+N///V/84Q9/QKfTOeqXORAYjUZYrVZoNBrYbDbwPP/cP6tWq9FDMpfLnZjDkhgQo9EIt9uN8fFxOBwOGI1GCIKAdruNVqsFlUoFjntUH3T58mVqYLvdLnXYGo0G0uk0MpkMCoUClpaWUC6Xcfv2bUQikSN+p4MHWVOTyYQLFy7A7XZTo242mzE8PAyj0Yjh4WE4HA4YDAZYLBYIgkA/H71eD+Bo8mDH3rgQQ0KsOfnK8zzsdjvcbjc8Hg9GRkZgtVoxPj4Ol8sFm80Gr9e7zbhUKhVIkoRsNgu9Xg+1Wk0fmOMA8cA1Gg2cTicmJiZgMBhQq9VQr9fh8Xig1WrRbDbRarWO+uUeGeR2p9PpYLFYoNPp4HK5qGf4PFSrVfA8D1mWIUkSut0u2u022u12H1/50UAOOZ7nodfrYTAYYDQaodFo0Gw20Wg0tt3+zGbztueq3W7T8JjJZILZbIbVaoUoitDr9bBYLNDr9XTNyN8B8FI7QjzPbzPswWBwW2RibGwMRqMRo6OjcLlcNDTWe2a1Wi3U63U0Gg363B+WoTnWxoXneYRCITidTjgcDgQCAWg0GphMJmi1WgwPD2NoaAgGgwFOpxMajYZuZK1W+9jP02q11FPQ6/XQ6XSoVCpH8M6eD47jaAJvYmKCejbEu3zttddQKpWQTqdx9+5dyLJ81C/50OF5nhqUV199FZcuXYLJZEIwGNyWqH5WSqUSMpkMqtUq1tbWUC6XsbKygo2NjWNtZLrdLmRZRrPZRKlUQqlUAs/zaLVaUKvV+OKLL/DZZ5/BZDJhenoaJpMJTqcTZrMZrVYLjUYDHMdBr9dTj3pmZgbDw8MYHh6GLMuYnZ1FLBZDPp9HPB6HoihIJBKQJAnVahWSJB31MhwJIyMjuHjxIjweD65evQqfz0e/p9PpYLVaoVarYTabodVqoVaroVKpaIi/3W5jeXkZ6+vriEajuHv3LgqFAkRRPJTXf+yNi9frxfDwMEZGRnDmzBno9Xo4nU7o9XoMDQ0hGAxu+zs74429VlytVkOtVsNgMECn00GtVr9QqOSw4TgODocDoVAIwWAQXq8XRqMRwCMPcGZmBrlcDuvr61heXn4pjQtxHsxmM06dOoXvfOc7sNvtGB0dhU6ne+6fSw7GcrkMt9uNXC4HSZJouIfkvY4j9Xod9Xod1WoV1WoVWq2WRghu3ryJX/7yl3C5XHjzzTfhcrkwNjYGj8eDer0OWZYhCAJ8Ph+MRiP8fj/8fj8AYGpqCs1mE8FgENlsFltbW7h37x5KpRJarRb9+rIaF6/Xi9dffx2BQACXL1+G1+ul33vSOQY82m/NZhORSATXr19HOp3GxsYGKpXKoT33A2tcyPWv95fX64XX64VOp4PdbodOp8Pk5CS8Xi9cLhdCoRC9uWg0GhgMhsd+5n5wOp24fPkyEokEPvnkk2Nze+l2u1AUBeVyGbIsP7bhetfyZUWlUkGv19PQjNPphMlkemEnQqvVwmazQaPR0D2pKAoMBgNarRZarRaazSZisRhEUUStVqPhs+MW+ul2u/RGQgxPuVzG6uoqUqkUCoUC7HY7rRbjeR42mw1arRZ+vx8+nw9qtZpGCur1OlqtFqxWK86ePQtZluF2u1GtVhGLxZBMJlEqlbCxsXGs8p/PC7mFOJ1ODA8Pw+PxQKfTQaVSUSeF/AK+cVwqlQry+TxqtRqy2SxkWcbXX39Nc1v5fJ7mXw+DgTYugiDQnIogCDh//jy+/e1vw+1248yZMzCZTLBardDr9TQm3HuAPm++ZHR0FP/yL/+CRCKBSCSCra2t/r65A6LT6aBUKkGlUqFcLj92aO1co5cRctC53W4EAgEMDw/35YZqNBpp3mB0dBStVgtzc3NIJBI0RCFJEt577z0sLS0hk8kgGo3SXpDjdKvpdruo1WrodDo0bCWKIrLZLHieh9lspoUkxIDuLLIxGo3wer0wGAw4deoU/H4/AoEA3njjDXAcB0VR0Gw2sby8jLW1NTx48IAWApxkOI6D2WyGyWTCyMgIzp07B7vdThPzpKKVVCaSvdVut7G+vo6bN2+iUCjg5s2byOVySCQSyGQy9M8cpjMzsMaFxBJJyZ1arYbP56M5BbfbDaPRSBOLhGd9SEk1C1nwTqdDvbFGo3GsvEqVSgW1Wk3XazcD8rIalX5AHkzygO8GcYoEQYDVaqUJ1E6nA0mSMDQ0RENLZK8VCgVa9n4c9hvxmsla9B5wJOZPnp+dN2hiyPV6PdrtNoxGI2w2G927brebls3qdDrYbDb4/X4Ui0UEAgFotVqIooh6vU7/7ZOESqWCwWCAzWaD2Wym+WHiKJNQY6PRgCiK1NC0221Eo1EkEgkUCgWk02nk83kaxTgKBta4eL1enDt3DmazGaOjo7BarThz5gzm5uag1WphMpn64nE2Gg0kEgkoikI3azQaxZdffol0Oo1wONynd3Tw8DyP6elpnD59GlNTUxCEgf14j4xOpwNZliGKIkqlEnK5HAwGA6xW61P3EulGVxQFmUxmVwOj0Wjg9XppVZXJZKKHa6vVgtPpRLVaRT6fRyqVQiKRwLvvvotYLIZyuXxsQrB7QQwL6czf6eyVSiUoigKe5xGNRsHzPO7evQudTkfDQA6HA6+//jo8Hg8cDgcWFhYwPj6O0dFR5HI5/Pa3v8W9e/egKAqq1eqxuvU9DfIMz83NYXZ2lhZCAKBn08rKCuLxOL744gtqYLrdLkqlEnVUyuUyGo3GkYYRB/b0IRU8TqcTc3NzcDgcGB8fp+V4wP68cLLxyNedGkjkg6hWq9RzjMfjWFxcpH0uxwWO46inZ7PZHvs+CYf1hsZO0oO5H7rdLprNJur1OhRFgaIoNBSxl3EhnjppCqxUKshms7s+uDqdDkajkZbkkoIKsu8cDgeAb6rLNjc38cUXX6BUKp2YAosnVcc96cCzWq2Ix+Pw+XwYGhoCx3Fwu93w+/2wWq0wGAzI5XK4ceMG1tfXj20F3pPgeR5OpxOhUAgul2tb02O324UoiojH41hbW8Nf/vIXFAoFut5kXw8KA2VcSLJVq9VibGwMr7/+OhwOB43Rkuvzk2i1WlRiglS3VKtVxONxmlTt3ZSKoiASiUCWZXq9z+fzWFlZgSzLx+qBb7fbiMfj0Ov10Ov1EEURnU4HOp0OHMfB4/Hg9OnTMBqNiMfjyGQy2Nraeqm69snnqygKwuEwVldX4XK5tnVA91Kr1bC2toZSqYRsNotsNotSqYS1tTXUarXH/rzBYMDMzAzN65CeqvHx8W3hW+Kpy7KM6elpCIKAVqt14nMKT6I3RPjJJ5/g/v37KJfL6Ha726IVP/zhDzExMYGvvvoK77///qElqA8S0shrsVgwNzeHhYUFeL3ebQ4PuZ1EIhGkUinU63Wq1zaIIdWBMy5GoxEWiwUTExN48803YbVaodVqqbf9NJrNJu03SCQSSKfTSCaTuHHjBiqVCmq12jbPqV6vI51O07BYbzwZOF4Kr51OB7FYDIqiwOFwoFQqAfgmzu3z+WAymeBwOFAoFJBKpSBJ0ktnXHK5HDiOw+bmJh4+fIjh4WFMTU3t+ucVRcHdu3cRDocRiUQQjUaRz+fx4MGDXR0Ps9mMs2fPwul0YmRkBKFQCKOjo4/10eh0Ouh0OrRaLZw6dQoGgwHJZBJra2sH9t4HnVqthlqthkKhgEwmQ3vRLBYLDZM7nU689dZbUBQFarUaH3300YkwLlqtFj6fD06nE2fOnMHFixdp7o5AjMvW1hYymQytshvUpugjNS6kk16j0dCGoKGhIdjtdoRCIdp3kE6nty1ku91GrVaj1Q+9oa9Go4FkMglZlqmWVj6fRzabpZu394MgKq2kYuc4GZOdkFJkURSRSqWwtLQEt9uNubk5aDQaCIJADzXSJHqc+nj6AcdxtAjE4XDA5XLRfAtZv0ajQfMiRE02kUgglUohl8vRePZuYRnifbfbbfA8Tw++cDhMRQX1ej11lEgSu9VqweVy0ebDWq02MHtREARaWKPVaqnKw0F5yiQECQCpVAqLi4soFos0h2U2m2EwGOD3+3HmzBnaGKwoyrFrWCUVnBaLBdPT09TAkErZXlQqFVwuF6anp+FyucDzPKrVKrLZLCqVysDloI7UuOh0OpjNZrhcLiwsLMBut2Nubg5DQ0Pw+/0wm82oVCr4+OOPEYlEaIcwCXMRY9HruZBudFLRQ6opdt5MCKRabFA+kBeh0+mgUCigXC6j1Wohn89jZGQE//qv/0r7gkg/hsPhQK1W21Wp4CSj1WqpPtbCwgIuX75My4hJvi2dTmNxcREffvghyuUytra26K23NxSxG7VaDevr6+B5HisrK9DpdBgfH0ej0YDP58OVK1cwNjZGS3NNJhPOnz+PiYkJRCIRRCIRiKKIWCw2EN4oiSYYjUY4HA7Y7XZYLBa6xw4C8ky2221cu3YNd+7cQSAQwKuvvgqfz4ef/OQnOHPmDC5dugS9Xo9oNIpf/epXiEQiVMLpuED68SYnJ/FP//RPGB0dRSAQ2LUYh+M4LCwsYGZmBtVqFdFoFKIo4s9//jPW19exubmJ+/fvD8S+AY7QuJD8is1mg8vlosn7UCiEUChEBdhIGCMWi6FQKNDDMxqNolarUU+T8QhiUEulEmKxGDQaDfWCSe8PmftA+oNehsQ+KRHWarVwOBzUQ7RarTQn1XvzIx3N5L/36xWTnwE8MjRE8oT0u1QqFTSbTeqZEq+VKN8SLbhBKhknenVk3/SqiR8UxAkURZHmDn0+37acqsFgwOjoKNXaMhqNu+bBBhnSw0duYkNDQ7SnZbc1NpvNMJvNVPmAOCKSJKFSqcBkMtEy8KO+wR26cVGpVDREc/XqVfzoRz+C1WrFyMgIDAYD7HY77bBXqVSo1+tYWVnBrVu3IIoile4m1V2DYqUHjXq9jnw+D4vFQiUfyAFBPCUSyzYYDFSA8KRitVoRCATg9Xrx85//HDMzM9SJIYaFlKUvLS1hfX0d8Xiclh4/z+2WhG1TqRT+9Kc/weVywePxgOM4uFwuBAIBcBwHg8FA9bfIszEoxqVXFZn86i2PPSwqlQoePnyIZDIJi8WClZUVjI6O0pDvwsICXC4Xbt26RXONxwEyzoA8l/tdW41GA7fbDZvNhu9+97u4cOECNjY2cObMGWSzWVy7dg3pdPpI8zFHYlyIB3nq1Cm8/fbbNJa626I2m00kk0lsbGwcu+qto6TZbNJKOUVRUK/X6a1Fo9HA5/NRb5mExo5bp/izoNfrEQgEEAqF8Prrr+PcuXP0eyQMQ6q1SGisUCi8UGknUfkl4Vyr1Uq1ogRBgN/vp58J8OjAIFMfB4neXB25uRz2a1QUhYpbms1mpFIpqNVqvPHGGxAEARMTE9BoNMeqLw34ZjYLMTD7FU8lOojAI7mqbreLoaEhOBwOhMNhPHz4EMVi8YkNvwfNoRkXm81GFYqJxzg/Pw+DwUA3a6fTQbFYpGqoJLRD5mOwW8r+IZuKPJRra2sIBoMwGAx0eFqtVqMH2qB4ygcFCT/splxAjEu9XkcsFsPS0hJisdihhhWINMrp06dp/HxQbpJEB2wv1YfDgBjqer2OVCqFRqOBra0tRCIRdLtdDA8Pw2q1Ym1tDevr63S+zqCV5+6kd0BhJBLZNuSQFCqQQqZOpwOLxULL5slYECKBZTKZMDQ0BEEQcPnyZQSDQbqXSJ7wMJ3HQzMugUAAP/jBD6jSZzAYhNVqpbMfVCoVWq0WotEootHotkbGcDhM+1AY+4NIi4iiiHv37qFWq+G1115DMBiEWq2G3W5Ht9uFwWCg1UAnGY7j9vS6yfRISZLw4MEDfPTRR4cecuU4DpOTk+h2uzAajfjLX/4yEIlpctiZTCaamzoKA0MqyFqtFtbW1sBxHJxOJ+bn5+FyuTA/Pw+dTke1AEkv06AY6L0gBrNQKODu3bvIZrN0ZMHy8jKuXbtG8ynNZhNTU1OYnJyE0WiEz+ejfVV6vR4Oh4NOoTSbzVTNgKgikCKJw+LQjAtpErLb7bTqZOeDTm4u8XgciUQCiUQCpVKJ6gid1JDNQUKkt0mVE4Ekk4GTrTdGbsYOhwNutxsOh+OxZslGo4FsNotcLkd1q47qtTocjscGPh0lZKga0bkixR+k0/6wk8bklgkAoigikUig2+1iZmaGhu8MBgOq1eqx2Nfk5iLLMhKJBA1nm0wmRCIRJJNJWmLcarWokTcajWi1WjAYDHC5XDQiQcKXDoeD5vbsdjsEQUClUjmZxsVkMmFsbAw+nw82m43OtO+l2Wzi+vXreO+992iVTqPRQKVSYYaF8cwIgoC5uTlMTExgfHycKj54PJ5tfy6dTuPXv/41otEoVldXj+S1chyHQCAAh8OBZDL5QlMx+wnHcQiFQjh37hxGR0fpoLBisYhUKnWkz+ba2hr++7//m+qOjYyMQKfTwefzodlsDoyBfhKkby8cDuPXv/41zbsIggBJklAsFrcpGsdiMdy8eZOOHTGbzUgkEpidnUUoFKIFDqFQCB6PBwsLC1SNolAoHGrD6aEZF0EQYDKZqOXdLXnf6XTo0CBZllEqldiNhfHc9A5PGx0dxfj4OPXAe5Ekicam+11p1Os9k8NuL4+aVAuZTKaB8bpVKhVMJhPcbjfMZjOAbyT3yYTKo6JcLmNjYwOCIKBaraLRaNDSbxLCG3SIWG6lUqGipTv1D3spl8sAQBvPjUYjxsbGqEx/p9OhZ61er4fH48HQ0BCdq3OYHJpxqVQqWF9fhyzLtEGSNJIRNBoN3nzzTdhsNqRSKfrnU6kUZFne9gEwGHvBcRxVIfB6vRgZGaG3AhI+6IXMJalWq307LMlwO5fLta1hMhAIbAsxEbrdLvL5PEqlElKp1JH3KOwFx3E0T3DUxoWIzpbLZYiiCEmS4Ha7ceHCBfA8jz//+c9H9tpehP0402Q+UKvVwtdff02V3aempmAymWA0GsHzPILBIL71rW8BeCSjQ5rOD2N/HbpxURQFZ8+epW9up3G5evUqLly4gPX1dar6eefOHeRyOTptjcF4EjzP0/J2Ylz8fj8cDseupZ7tdps6L/00Lh6PB7Ozs+A4jlbo+Xy+beXfBGJcwuEwUqnUQFdGEln9o06Yk7xPqVSCKIqoVqtULFQUxYEJLR4EZM8qioLbt29DEASYzWZ8//vfR7fbpdEh0pxerVZhsVggiuKhSeQcmnEhTX2CICASiVB5eJvNRgXaSIMl8EiafHR0FDabjQoxAqCJrUHSXjpunPSOfNKQaDKZYLfb4Xa7abNkL9VqlRoVm80Gj8eDYrGIYrH43P+2IAiw2+0wGAyYmJjA6dOnwfM8TTZ7PB4aGlapVGi326hUKqjX69ja2sLS0hIikchAGxdSQUaKJQYBsp/JoDGTyUTDjIPQrX5QkBLtbrdLRWhVKhUdK016aEwmE1U4IIUDB82hGZdSqYTFxUXEYjFwHEdF51555RU6cY7IIJBfoVAIkiRhbm4OxWIRH374Ier1OiqVyqEt0Emgd/TzyzDimHQvu91uTE9P4+zZs48pzAJAMpnE8vIyRFHE9PQ0PB4PCoUCEonEc//bRqMRCwsL8Pl8+MEPfoA33niDGhcSruvtLVIUBaurq8jn8/j973+PTz/9FOVyeSDKkHej0+nQmSOtVovmYQYFi8UCq9UKn88Hv98PAHSe/Eml1WpBpVIhm81icXERfr8fXq9320BFn8+HS5cuIR6P49NPP4Uoigf+ug7NuJBGIQDIZDLodrtwu910EiC5tZAHjzRu6XQ6SJIEnU4Ht9sNp9MJjuOQzWYHcobBoHPSDQvwzbhnjUZDS1N3QjTAisUiZFmmyhHPuz7EaJOSe7fbDY/HA6/XSxs4d4PcXMhUzFQqRefTDzLk+RykaadEO4/0bZGvg7jneweA9QNSZJHP56HT6bY1TJKwLCmoOqzP7NDDYqIoQpZl6HQ63L9/Hx9++CGMRiMdCDY7O4tgMAiHw0G7Tb1eL+x2O7797W/D5/NhbW0Nv/nNb+ikyEGavjaI9G7gTqdDtbReVkhCM5PJYHl5mQ7/qlQqSCaTz/SzSFMhCcN5vV5MT09jbGwMbrd7TzkXUiUkSRIikQhisRhSqRQdWzuoxoW8X51ORz3jQTm8Sf+NJEmQZZmGPQclJNY7BZbsC9IY2o/nMRqN4v/+7/8wNjaGubk5mM1mOiLhKDjUmwuJI5Nyz83NTbpJh4aGYLVatz1YgUAAarWaXr1nZmZoxc8nn3wCWZapDDrjyeyce/OyQmLUrVaLzr3JZrM0PPas4ShyUJAudpvNBp/Ph0AgAIvF8sTRyUSSI5/PI5PJoFwuU0XlQYbc0Abt5gKAyvjU63U6GHBQDHWvUSFhUrIPgBd/LvP5PJ3rUigUoCgK3ZtHwZHuDPJwSZKEbDaLarWK27dvI5fLIRQKUVVfouBLQg5erxezs7OwWq24f//+wManGYNHu91GoVBAtVqlY47L5TJNqj+Ll8vzPEKhEGw2G4aHhzE7Owun04nZ2dltfSEEokBBvOpSqYRkMol79+4hEokgl8v1++2+MKSKbWtrCxaLBe12e2D6R3oLJUguK5fLQZZlKhlFhgoOAj6fj+opOp1O6HQ6rK+v05YLomL8vBDjRQzXUedXj9S4kNsMEZlTqVSIRqPQarUIhUKYn59HIBDA3/7t39K58CaTCc1mE1euXEEikUA2m0U8Hj/Kt8E4RjSbTap6fO/ePXz11Vfb6v6fxXtUq9U4deoUZmZmsLCwgLfeeouKCe7s4QIe7fdYLEZHb29ubiKVSuGjjz4a2PLjdruNWCwGnudhs9nQarUG5raiVqtpyTmpDHv48CEWFxdpuFNRlIG5qY+Pj+Mf/uEf4PF4MDMzA6vVivfeew+/+93vkEqlUC6XX8i4kNwKyTUdtRMwELuk92pIxhCTZjKO45BOp2E2m2npMknuE20dQRBoDJvBUKvVdITxzm584Jt8R6vV2leZKvECSUKUeIM6nQ7BYBBDQ0P0prJXH42iKKjVakilUohGo0ilUtQ5kmV5oAUWFUVBqVSiIReyHr1FN41G49BHNpBcrdfrpaOrSeFQ7+TZQUGtVsNiscBms1F1Y6fTSeVqXtRoa7Va2O32bWXIR2lgBsK49EISXMlkEuVymY7nHR4expUrV3D58mXYbDa89tpryOfz+OKLL/Dw4UPUajVIkjRQm4lxNNjtdnznO9/B2NgYRkZGXuhn9Q7xev3113Hp0iX6wGo0Gpw/f57Kve91OJAG4lwuh3fffRf37t2DKIp0XgyR9BhE2u02EokE8vk8/H4/wuEwHA4HdDodnE4n/H4/RkZGUKlUqBT+YTE1NYW3334bwWAQ4+PjsNlsaDQaSKVSVJNrkCBrRpp5VSoVJicn8dZbb+HevXv485///Fw9VsTZCQQCuHz5MoaHh+H3+2lv11GFxw7cuJA3tnN2/V6QP6coChRFQbPZxNbWFtrtNubm5tDtdqHRaOByueiwK71eP3AbiXF0CIIAj8dDKxB3QkpWeZ6n3u7O/UMeSp7nodfrodPpEAgEaMc98MgTHRsbQzAY3OYlkn1ObkiyLCOXyyGdTmNrawtra2u0efM4OEPkWSS5KVLeTRoprVbroeZiSMWV0+nE5OQkPB4PjEYjBEFAq9WCJEkD2WRNBsORsKlKpYLZbMbQ0BBSqdRz31zIGWsymRAMBqkUf+/PI+fqiZnnQpRenU4nHfz1rEag0WggGo1CkiS89tpr277H8zwCgQBOnTqFeDxOpQ0YLzeSJOH27dvI5/MwmUy0mQ54ZHgCgQCsVit+8pOfYHR0FNlsFjdv3kS1WqXTFv1+P6ampugMGEEQMDMzg+npaeoF8jwPh8MBQRBo6It8rdfruH37NhYXF+mcc1EUsbq6SmVmBu3wexqiKGJlZQWiKNLxGadOncIPf/hDbG1tIZvNHtgMe+II6PV6XLhwAaFQCOfPn8fp06ehUqmwtLQESZJw8+ZNLC4uolKpDFwOq1KpYHNzE4qiUGFJkjcyGo00d9RoNPb92lUqFSwWCwwGA06dOoU33ngDTqcTVqt125+TZRlbW1uIxWK03/CgOXDj4vP5MDk5iUgk8lyCfCQBWywWUSgUtj2QPM/D6/VicnISzWYTq6urzLgwUK1Wcf/+fWQyGczPz2/7nlqths/nQ7fbRTAYxJtvvonV1VV0Oh1kMhnY7XYYjUacPXsWP/zhD6HX67f1dmi12l1DDKQwpdFo0GmqH3/8Mf7nf/4HtVqNyhY9y8ExaFQqFWxsbKBer+OVV16BwWDA5OQk1Go17ty5gw8//BD5fP5A/m0SnrTb7bh69SouXryIUCiE6elpFAoF/OUvf0E0GsXdu3exsrIykIab9DQ1m02Mj4+j2+0+pkpiMBieaTQxx3E0jzMxMYFLly7tqqpN/m3iqB8GB25cHA4HhoeHUa/X6RAkMvxrP5DhQM1mE4qioFKp0CSiSqWCy+XCyMgIMpnMkVdHMAYDsmf2UnAg/QVE2NBut2Nubm6bYnEoFNqmnUXCaDsfWqLrlM1mEYlEIEkSEokERFHExsYGVVomFWnHueiEhJwkSUK73YZKpaIDzrxeL51jn8vlaMjveQ55UizA8zwtM7bb7ZiamoLdbsfExATcbjcAIBaLIZvNIhwOIxqNolwuD6RhAb5RKSFqxkQVQqPRwG63Y35+HlarFQ8fPkQ8Hn/i+vWuzdTUFIaHhzE6OkpVJsjfTSaTyGQyWFlZQbFY7Kvy99M4UOPC8zymp6fxxhtvwGQyYXV1lcpc7Pf6TLpuVSoV8vk8otEoLBYLAoEANBoN5ubm4PF4UC6XIQgCa6hkUNVeUnm4E+KEkNLNsbEx/P3f/z1VLyCHG5HFJwZlp2Hpncj48OFD/O53v0M2m8Xdu3eRz+dpp/hJaWBVFAWZTAZarRbNZhMqlQoOhwNmsxlqtRo/+tGPEI/H8dlnn+Hhw4dot9vPdZDxPA+r1QqtVotgMAi/34/Z2Vm88847cDqdMJlM0Gg0WF1dxWeffYZ4PI4PP/wQiUQChULhAN55f1AUBel0GoIg0MIHkoOZnJzEP//zPyObzeLf//3fkclknjhqW6vVwuv1wuFw4Gc/+xmuXLkCp9NJGybJWOgvv/wSH3zwAWKxGFZWViBJ0skwLgCg1+ths9lgtVphs9nQ6XRQLpefKTbb2zPQ6/31ylDodLoDef2M40dvmXGj0UC9XqfNZb306oER1e1nodvtQpZlSJKEXC6HZDKJbDaLRCLxQsrKgwq5uRDvW5ZlCIJA1QlIuJEYgHq9vi9pk94cFvl5DoeDjijw+/0IBAIIBoOw2+305xK5nlQqhUKhgHK5PNAl3Y1GA6IowmKx0AZPIqhKjIVarYbb7Ybdbkez2aQ6c2QNSTGK2WymY7vJGhFnqNPpUJWCfD6PWCyGTCZDw7aH5eAcqHEhh7/VaqUld+l0Gr///e9pHfrTwgSCINDN6nK5HhuRfJw9QcbB0Gg0kE6nUavVsLi4CJ/PB5fLhfHx8b42ADYaDXzxxRd48OABFhcXcfPmTRo2OomUSiXcv38f6XQaf/rTn5BIJDA9PY1Tp07BZrPhypUrqFQqNNe6vr6Or7/++okHPjkjyKE6PDwMp9OJq1evUk1Bq9UKk8kE4JHEye3btxGPx3H37l18/vnntAxaUZSBzmfl83l89dVXiEQiGBsbgyiKdEoqGc9stVrx05/+FFNTU8jlcgiHw3R2DlGhtlgs8Hg8OH/+POx2O86cOQOr1UqlhhRFwfLyMvL5PG7duoW7d+/SIpMTUy1Gwguk6XF2dhY2mw3Xrl2jC/E048LzPIxGI91gpATypM8kYTw/RGmYJOmj0ShUKhVGRkb6alyazSY2NjZw48YNbG5uDvwclheFlCTXajWsrKyg0+nAZrNhZmYGBoMB4+PjqNfriMViaDQaqNVquHPnzhN/Zm8zpt1ux+joKILBIK5evYrh4WGqzNFsNumNaWNjAw8fPsTdu3dx586dYzN6Q5IkhMNhSJKEra0tGAwGmM1mdLtd8DwPs9kMg8GA+fl5uN1uRCIR6PV6KIoCURTRbDbhdDrhcrkQCARw5coVWK1WWCwWGrkh4bBkMolkMoloNIpEInEkZ+WBGpd2u41wOIwbN27AaDTC7XbDZDLhxz/+MS5cuIBOp/PU6i61Wg2XywWTyYTTp09Dr9dvS1oxnh+O4+ByuRAKhZBOp1GtVk9EtR0JCwDAvXv3oCgKTp06RcM3O0cdk7nrHMdBkqRtnrYsy1haWkKhUKCJeUKtVsMXX3yB9fV1FAqFY52sfxZqtRqWl5dRLBZpQppUKwmCQI241+tFMBh86uFPbi4Oh4MWVRiNRmpQ6vU6isUi1YG7ceMGotEo4vH4sdqv3W4XnU6H3izIjBlSiuz1emm+qXfgHQmPtdttOsLYarXCarVCr9dvu7GIooh0Oo2bN29ic3OTFgYcBQdqXFqtFpaWltDpdHDu3Dlavjg7O0urbHZ7472Gg+M4KmVAmtkGReL7uMPzPPx+P2ZmZqBSqY7dw7oX5AGu1Wr48ssv8dVXX2FhYYGWsvp8vm3NlXq9HoFAADzPU3ViQjqdxn/8x39geXkZ1Wp125ht0uzbbDZfKvkhRVFw48YN8DxPJWHGxsbg9/vhdDoxNzeHmZmZbc5j73O+c5YJ+X9STNE7nTMWiyEej2NjYwMffPABzW2RnrbjtOZE5or04ywvL6Ner0Oj0cDr9cJqtdJcCqmCPXv2LP27wPbBf8SokPWrVquIRqPY3NzEH//4RywtLR3pkLQDNS7dbheiKCKTydArGrG4Op1uV3G/XsPR7Xbptbn3K/mQms0mKpUK7StgN5n9Q7yoer0OWZaPZVPf0yDVXK1WC8ViEeFwGIVCAZVKZZvmmMlkQrvdhiAIiEaj29SJSWd9qVTaNZ8yyLNXDhJS6l0sFhGNRsFxHNbW1lAsFqHVamm1ndls3mZMyH93Oh1qlIm+G6nwq9frtKI0FoshmUwiFoshl8tBFEXUarVjEwrbDeL8AI8GJ25tbUFRFLjdbqqfSBQH9oI8v+RnNZtNJBIJbGxsIBKJUNHOowzTHnhYbHNzk26OeDwOr9eLt99+G2NjY1QIsJfdjMvOUlBSLy7LMu7fv4+NjQ3WQPkMEONcr9cRiURw//59lEqlE3lIkve6vr6O//zP/6Sd3r1OjcvlwquvvgqDwYCvv/4am5ub9HutVot2nrfb7cf22EkzyM9Ct9vF2toa0uk0rFYr7ty5A6vViomJCfj9fkxOTuK1116DVqvdVoqtUqm2GZB4PI5CoYBkMom1tTVIkkQ7ySuVCq0CK5fLtOftONNutyGKIqrVKr788ks8fPgQLpcLt2/fhtvtxo9+9COcO3eOVobt1bQrSRLq9TpWVlaoyvdHH30EURQRiUSOXALnwEuRibdHYojVahWFQgE+nw8ajQadTocuIoBdF7NXq6l32lylUkE+n0cqlTo2Ok1HAQkf9K4jKVUkc0VIP8ZJ5UlVXB6Phyoor66uYm1t7ZBf3fGlWq2iWq3SmeykO7zVatGS296QIXnOZVmmU2nT6TRthFxeXkalUkE0GqXqxsdhgNqzQgxkPp9HqVSiJcqiKFKlbNK4uxuNRoOuTyaTQTweRzgcprp1kiQdubN4aKrI1WoVkUgExWIR//Vf/wWPx0MrH4xGI4LBIK0qI13SZrOZDneq1WrIZrPIZDIoFot0cuDa2hoymQxyudyJrtR5XhqNBhKJBABQ4c90Oo1PP/0UqVQKS0tLx1brql8QuRhBEAZyYNdxoNFoIJPJoFQq0YT/rVu38Nlnn+16QBLPu9lsolwuQ5ZllMtl5HI5Gu4+zlI5+4UYAFEUsbS0hEgkgmq1ij/84Q9PVDMm4URysybpB/IsH7VhAQ7RuBAPhOd5pNNpaDQaeDwe2oPwyiuv0IoTUu9NYuHFYhHlchkrKytYXV1FIpHAtWvXUC6XIYriifRs+kWr1aKDqMh46Vwuh48++giRSASbm5snti9jv8iyzG4rL0iz2aTd8alUiv7+fopvXlanBtie5CfP4eLi4jP/jEHk0Oe5EItLkv0cx6FWq0Gj0cBoNG4TD7Tb7Wi1Wkin01AUBfF4nEo8VKvVPeU9GN/Qbrep3tLt27dhs9kQDocRDoeRzWaZYWYcKIN68A0yJ2XNVN19vpN+lv+S6x6JKRKNJ/L/RCCQ53lq2YmkB6nOId2mR3H9e14xvqOCrK1er4fBYECz2aTig0dxhT5u6zdoPO/hw9bwG9gefDH2s35HYlyOO2xjvhhs/V4MZlxeHLYHX4z9rB/TqGcwGAxG32HGhcFgMBh9hxkXBoPBYPQdZlwYDAaD0XeYcWEwGAxG39l3tRiDwWAwGPuF3VwYDAaD0XeYcWEwGAxG32HGhcFgMBh9hxkXBoPBYPQdZlwYDAaD0XeYcWEwGAxG32HGhcFgMBh9hxkXBoPBYPQdZlwYDAaD0Xf+H2cpKldt9wGGAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -448,11 +449,11 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 82, "metadata": {}, "outputs": [], "source": [ - "lr = 2e-6 # use 4 instead\n", + "lr = 2e-5\n", "z_dim = 128\n", "\n", "gen = Generator(z_dim)\n", @@ -466,28 +467,28 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 83, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 0/200 [00:00" + "
" ] }, "metadata": {}, @@ -497,21 +498,21 @@ "name": "stderr", "output_type": "stream", "text": [ - " 25%|██▌ | 50/200 [05:08<15:11, 6.07s/it]" + " 20%|██ | 100/500 [09:47<38:39, 5.80s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 50, iteration: 468, Discriminator Loss:array(0.505264, dtype=float32), Generator Loss: array(0.691265, dtype=float32)\n" + "Epoch: 100, iteration: 468, Discriminator Loss:array(0.535585, dtype=float32), Generator Loss: array(0.68229, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -521,21 +522,21 @@ "name": "stderr", "output_type": "stream", "text": [ - " 50%|█████ | 100/200 [10:15<10:18, 6.18s/it]" + " 40%|████ | 200/500 [19:30<29:44, 5.95s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 100, iteration: 468, Discriminator Loss:array(0.520561, dtype=float32), Generator Loss: array(0.69128, dtype=float32)\n" + "Epoch: 200, iteration: 468, Discriminator Loss:array(0.550168, dtype=float32), Generator Loss: array(0.68665, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -545,52 +546,17 @@ "name": "stderr", "output_type": "stream", "text": [ - " 75%|███████▌ | 150/200 [15:19<05:50, 7.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch: 150, iteration: 468, Discriminator Loss:array(0.512105, dtype=float32), Generator Loss: array(0.68507, dtype=float32)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 83%|████████▎ | 166/200 [17:10<03:31, 6.21s/it]\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[21], line 17\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m tqdm(\u001b[38;5;28mrange\u001b[39m(n_epochs)):\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx,real \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(batch_iterate(batch_size, train_images)):\n\u001b[1;32m 15\u001b[0m \n\u001b[1;32m 16\u001b[0m \u001b[38;5;66;03m# TODO Train Discriminator\u001b[39;00m\n\u001b[0;32m---> 17\u001b[0m D_loss,D_grads \u001b[38;5;241m=\u001b[39m D_loss_grad(gen, disc,\u001b[43mmx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreal\u001b[49m\u001b[43m)\u001b[49m, batch_size, z_dim)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m# Update optimizer\u001b[39;00m\n\u001b[1;32m 20\u001b[0m disc_opt\u001b[38;5;241m.\u001b[39mupdate(disc, D_grads)\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + " 49%|████▉ | 246/500 [24:09<26:17, 6.21s/it]" ] } ], "source": [ "# Set your parameters\n", - "n_epochs = 200\n", + "n_epochs = 500\n", "display_step = 5000\n", "cur_step = 0\n", "\n", - "batch_size = 128\n", + "batch_size = 128 # 128\n", "\n", "D_loss_grad = nn.value_and_grad(disc, disc_loss)\n", "G_loss_grad = nn.value_and_grad(gen, gen_loss)\n", @@ -626,12 +592,15 @@ " # show_images(real)\n", " # cur_step += 1\n", " \n", - " if epoch%50==0:\n", + " if epoch%100==0:\n", " print(\"Epoch: {}, iteration: {}, Discriminator Loss:{}, Generator Loss: {}\".format(epoch,idx,D_loss,G_loss))\n", " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", " fake = gen(fake_noise)\n", - " show_images(fake)\n", - " # show_images(real) likjmnh jy,t\n", + " # show_images(fake)\n", + " # show_images(real)\n", + " plt.imshow(fake[0].reshape(28,28))\n", + " plt.show()\n", + " # show_images(fake[:25])\n", " \n", " # print('Losses D={0} G={1}'.format(D_loss,G_loss))" ] From a8ffa9cb1845b08da8ead277a66930510f67c60e Mon Sep 17 00:00:00 2001 From: Shubbair Date: Wed, 31 Jul 2024 11:50:32 +0300 Subject: [PATCH 32/38] Updating GAN Code... --- gan/playground.ipynb | 50 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 49 insertions(+), 1 deletion(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index de7187fb..35116962 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -546,7 +546,55 @@ "name": "stderr", "output_type": "stream", "text": [ - " 49%|████▉ | 246/500 [24:09<26:17, 6.21s/it]" + " 60%|██████ | 300/500 [29:28<19:29, 5.85s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 300, iteration: 468, Discriminator Loss:array(0.558408, dtype=float32), Generator Loss: array(0.687771, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 400/500 [39:17<09:43, 5.83s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 400, iteration: 468, Discriminator Loss:array(0.566884, dtype=float32), Generator Loss: array(0.66744, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [49:04<00:00, 5.89s/it]\n" ] } ], From 1ef3ad2c6c2ced437d76cbc6f92f3c94812e26d4 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Wed, 31 Jul 2024 19:59:36 +0300 Subject: [PATCH 33/38] Updating GAN Code... --- gan/playground.ipynb | 115 +++++++++++++++++-------------------------- 1 file changed, 45 insertions(+), 70 deletions(-) diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 35116962..8d9cc56b 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -96,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -124,7 +124,7 @@ ")" ] }, - "execution_count": 68, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -136,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -147,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -177,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -191,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -216,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -245,7 +245,7 @@ ")" ] }, - "execution_count": 73, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -278,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -312,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -332,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -342,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -352,16 +352,16 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 78, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -382,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -395,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -419,12 +419,12 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -449,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -467,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -481,14 +481,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 0, iteration: 468, Discriminator Loss:array(0.527415, dtype=float32), Generator Loss: array(0.672361, dtype=float32)\n" + "Epoch: 0, iteration: 468, Discriminator Loss:array(0.533901, dtype=float32), Generator Loss: array(0.672384, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -498,21 +498,21 @@ "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 100/500 [09:47<38:39, 5.80s/it]" + " 20%|██ | 100/500 [09:40<40:52, 6.13s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 100, iteration: 468, Discriminator Loss:array(0.535585, dtype=float32), Generator Loss: array(0.68229, dtype=float32)\n" + "Epoch: 100, iteration: 468, Discriminator Loss:array(0.546182, dtype=float32), Generator Loss: array(0.691693, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -522,21 +522,21 @@ "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 200/500 [19:30<29:44, 5.95s/it]" + " 40%|████ | 200/500 [19:38<29:59, 6.00s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 200, iteration: 468, Discriminator Loss:array(0.550168, dtype=float32), Generator Loss: array(0.68665, dtype=float32)\n" + "Epoch: 200, iteration: 468, Discriminator Loss:array(0.556852, dtype=float32), Generator Loss: array(0.686229, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -546,21 +546,21 @@ "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 300/500 [29:28<19:29, 5.85s/it]" + " 60%|██████ | 300/500 [29:21<19:26, 5.83s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 300, iteration: 468, Discriminator Loss:array(0.558408, dtype=float32), Generator Loss: array(0.687771, dtype=float32)\n" + "Epoch: 300, iteration: 468, Discriminator Loss:array(0.561531, dtype=float32), Generator Loss: array(0.66357, dtype=float32)\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGVCAYAAAAyrrwGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy953Ok2XUe/nTOOaEbQDcyJs/ObJhd7i65YhC5FCWSJUqkS6lky1a5rM+usr/Yf4JdKllWSR9cJZZlu0TJphjFJTdxlxtmJw9mMMi5c87x92F+58ztF91Ao9EAGrP9VKEwAzS63/e+9574nHNkjUajgQEGGGCAAQboIeQnfQEDDDDAAAM8fRgolwEGGGCAAXqOgXIZYIABBhig5xgolwEGGGCAAXqOgXIZYIABBhig5xgolwEGGGCAAXqOgXIZYIABBhig5xgolwEGGGCAAXqOgXIZYIABBhig51B2+kKZTHaU13HsUCgUUKlUaDQaqFQqqNfrLV8n3jc1M+imqcHTtn7A43vqZi0Os36tnkev0c19KRQKKJVK3k/7/b1CoYBarUaj0UC5XObX02c3Gg3IZDJotVoolUqUy2WUSiUA3d+3Uvn4uNfr9V3voVKpIJfLUa1WUavVunp/gkKhgFwuR71e7+i9juOZStEvZ9jr9WJ4eBjZbBarq6soFos9/4yjQCfr17FyedpQr9dRqVT43+0gk8kgk8n2fM2nFSfROUgUwnTYe3kdGo0GSqUS1WqVhfleEK+hWq12/Dm0/0iRSO9BLpdDLpdDrVZDpVKhXq83KaFuQHu41XvUajXU6/We7HN6Np0K41bXQ3/fam2eJqTTad4LJI+eFpyYcunW6u0VGo3GvlaVeEhO+noH2I1eW7wymQwqlQoajQalUqkjYS4aHwcRzO2UEXkscrmcvSGVSoVyuXzg+2n13u3Qa+PpIMqlFeRyOWQy2aG9qH5HLpdDLpc79Pv0o3w6MeXSbwvRCqLVdBqu99OKXlm5JPBlMhmq1WpH73VU+6LRaLC3Uq/XO76eTnEYr08mk0Gj0UChUKBcLqNSqUCn08Hj8UCpVCIejyOTyaBer+8p9OTy5pSv9LwNzlxrtHp2/bhWn9qwWKcYhMP6G6KFLOYS9hKee/2uVCp1FA4jdCoEDyLMyauu1Wqs7HopPMgrAJ7sb/H6OskXWSwWaLVapFIpJJNJ2Gw2fPazn4XBYMDbb7+NeDze5PVLz5FMJoNCoWjybkiJitc1QDMoXNpJ5OWkMVAuA5xKUPjoKN63n9CvFnyr6yJvC3isPNRqNQwGAxqNBorFImq1GgwGAwwGA+r1OkqlEucbeu2ZPc3oZE8cRT7yoJB1Os/laWQ7dYt+YZqcVvRq/aQ/E99X/N1pSgx34qUcli122HAvKQ6FQsGJaL1eD6/XC6VSiWg0ilQqhampKbz44ouo1WqYm5tDKpXCl7/8ZXzpS19CMBhkD2dpaQmRSATlchmFQqGre5Ne3373dprP8H6hRplMBqVSCblczoq73ftQaPKgXtCALTbAU41Ow1H9YMX1A1qFD7tBo9HYFTosFovY3NxkwSeXy2G1WjEzM4NKpYJoNAqZTIaLFy/i9ddfx9LSEra2trC5uYlQKIR4PM6C8TDX1i8K4CjRbn1or8vlcqaWkzfZKj8jno2jIAQMlMsATyX6PdnZDkd5rb3KY5DnQnUxRKGVeo7JZBJ3796FSqWC2Wzmr2q1yl5KsVjkr71CY6IgJCUkpYGfFu/0qEBKxWaz4XOf+xw8Hg+vSTQaxYMHD5DNZhGJRJDJZADsTU8/LAbKZYBTgW69j34SNnuF8dq9tpfX30vlotFooFKpUCgUdoVd6Nqj0Shu3LgBk8mEq1evwuPxwGazcUFoLpdDPp9HoVBAoVDoyCKnkI9CoeDfUbFmPz3rkwApF4/Hg29/+9t45plnoFQqoVQq8eDBA/yv//W/EAwGcfv2beTz+Y6LXLvFQLk8JWhF65Ti0374TgqtaqVE5dGOSQXgWIXmfsqPBLzIVhItX6IekxKoVqvI5XKQyWSIRCKo1+t49OgR1Go11tbWEA6HEYvFUCqVDpQfUSgUUCgUXFs0YJY9hslkgs/ng9/vh81mg8FgYEWs1WqhUqmYoXccXt5AubTBaYjTi2ECtVrdJLxaWSWiIOvn+2qF03a9BDEGDjxJplORpMiaIsjlcmg0GgBgltVRg4SOuO+lik2pVEKr1QIAyuUyKxd6DV0ntX+hsFcikUAsFoNKpcJbb70Fo9GIYrGIaDSKSqWCfD7f0TXW63Vu26TRaHZ5PNLrP617pltMTU3hN3/zN+Hz+TA2NgaLxcLroFarudsDcDxGy0C59CHI9ZcynqR1AXSY6MCRRQk83jzUXqRarbKF92k8dL0CWczSzgDt1pRer1AooNFoIJPJUKlUmpRFK0q1NNF6XNjvM0V2kViTQpAWQNKek8lkKJVKTeEtsTC00/1IXpNKpYJarW5qn7PXdX8aIJPJYDAYMDIygqGhIej1eiiVyibPjgzOwxI6OkVPlYu0OOs0C7G9iu+OGhaLBZcuXYLJZOLN4HA4MDY2xpXR4iETC6rosBUKBWQyGWQyGXzyySeIRqNIp9NcOd3vBVj7QRR0tO+k99UqrNPq5/uBhNrU1BTGx8ebQgvZbBbFYrEpqUyHORAIwOfzwWg0wu12o9FoYGVlBbFYDKurq5ibm2tpQdZqNWZjHddzoj20V0udWq3GLXH2CkWJZ5++i0wwkQDQ6bNQq9Uwm83QarUIBAKw2WzY2NjgnA+t414U66dV+dDaOp1OnD9/Hna7HQaDgde7Xq8jnU7j/v372NzcRDKZPJbr6qlyISv6sDz6fsRheyUdBAaDAefOnYPL5eKDMzY2hmvXrkGn07GXotPpoNfrUavVOEFHa5/NZhGNRhEOh5FIJFh45HK5p+aZ0KEi4U8eWqu8xmEoyXK5HEqlEl6vF88++2xT199oNIpsNsuCV1RwV69exeXLl2G1WjE2NoZ6vY6PPvoIa2trqNVquH//fkvlIgpgEUe5//Zr1SK9rr2Ui1RpSCv1D6owyZM3mUwwGo1snZdKJSwvL+9rVNB7iN+fJtAZMJvNCAQCsFgsHP4CHq9HLpfD+vo61tfXj61BZs+VC4VmpBtsr/DBfmgXDxY/VxQoZN0To4U2ZKPRwPz8PMLh8IGv5TgEstvths/ng9frxdTUFBwOB987MW1UKhVUKhXTQSlJB4DbhdRqNWi1WpjNZpTLZT6IJpMJDoeDe1YBgNVqhU6nw87ODpaXl1lAnwaIApGUiujNAK079NJr92IZaTQariY/f/48HA4HZmdnMTs722SFZzIZzovQe9H6jY+Pw+fzwWAwQK/Xo16vw+v1QqFQYHl5GSqVapdC3AtHuQfFe2r3OQfN2ZHSNxgMuHjxIux2O9bW1ljAkUG0H+i80+upZiadTu963V7XfhS1HCcNhUIBn88Hi8UCn8/Hhifw+J7j8TgikQh2dnZQKpWOlSByZJ6LGP8HwIcPONghkclkLEBps9ZqNQ5FiIeiXq9DqVTCZrNBrVbDbrfDYrFgcnISX/7yl9FoNPCXf/mXiMfjLWPG++EoH4pMJsPMzAy+9KUvwe124+rVq7BYLLBYLDAYDDz/Q2qB0b1rtVrU63UUCgWUy2WoVCpotVpotVqcO3cONpsN1WqVv0qlEhQKBWZnZ+H1evGLX/wCf/u3f8ueTb8eQpF1JTUwqIuwWKEs0laB5kQ19RFrFeYxGo0YHR2F3+/Hn/3Zn+HixYtsrIjMvFYhIALRQOna6vU6Lly4gGKxiNXVVWi1Wn4eJw1ar72u5yD7ggxNtVoNj8eD3//938fFixfxgx/8AD/84Q+RTqexvb3dcbfncrnMpABqjplMJpsMjP2urV/39GGgUqlw4cIFnDlzBufPn+f5P8Djvbm2toY7d+7g/v37yGazx9pmp+cJfbIQSOjTfIxyuYx8Pt+0CcRkE/2MlIhGo+GklMFgaGLbEMWRhColrhqNBlQqFaxWK7RaLWw2G8xmM4aHh+F2u1GtVqHVancpvn6BSqVia1mv1/OXTqdroqdKQVZdtVpFJpNhBg25w0qlEnq9HuVymTeXXq+HSqWC2+2Gx+NhCmM6nUY0GkWxWOxbmmerZyd6xqRUaO/o9XoAu0M5lJMSwyoGgwFarRZOpxOBQAAjIyPweDxwOp1s3HQLOg9iEWK/hGkOcx5ob2q1WlbwFDkQk8wulwtmsxk6nQ7FYvFA9y7mhAqFAreeIWO2X9bxOEH73G63w+fzwWq17jJ8SInHYrFj79/WE+Uihh1qtRrUajVMJhO0Wi2mp6cxMjKCUCiER48eNVkqhUKBXV3q/mq322E0GjEzM4OXXnoJJpMJo6OjMBgMyOVyyGazKBQKzJufmJiAy+VquhY6uBRCUqvVsFgsSCaTMBqNrKj6ZTiPdP0AQKvVQq/Xo9F43PSPLMtWhyiVSuHmzZtIpVJYW1tDNBptOuQWiwVmsxmJRALpdBomkwljY2MwGo2Ynp6Gx+OByWTChQsXsLW1he9+97tYXl5m4dtPkMbyxZ/RPlIqlezxXb16FVNTU5wTkclkMJvNUKlUWFxcxMLCAkqlErLZLJRKJV599VWcPXsWNpsNw8PDMBgMGBsb28US6+Q6W7HAyJOhkKaUFXhSEJPinUBkfikUCtjtdly6dAlmsxlOpxMWiwUejwdTU1MwmUyYmJiA0WiEy+WCy+VCo9HA5uZmx9dHhkO1WkU8Hkc6nebGmFTxf9pJKgeBQqGATqeDzWbDtWvX8JWvfKUp10Js0bt37+If//EfkU6nO6Z89wqHUi5iaEZKkdXpdNDpdPB6vZiYmIBKpUI4HGZKIvB4gYgNRYLTZDLBarVidHQUV69ehd1ux+TkJMxmM5LJJFKpFLLZLLa3t1Gv13Hx4kWMjIzsuh4R1WqVw0VqtRpKpZKtoH7yYMg6I1dfJpM1hRMp1yImRxuNBvL5PLa3txGJRLCwsIDt7W2uSTAYDDhz5gxb75VKBTKZjENuVqsVZrMZBoMBo6OjWF5exhtvvIFgMHhqRq6KYRHyTrRaLYxGI4aHh3HmzBmUy2WUy2UWhFSvQWyvVCoFpVKJ8+fP49q1a7BarZwf6RSd5iEajUYTTbkflEsnYSXxnJOFLHqIo6OjcDgcGB4ehsPhgN/vx+XLl3nf1mo1aDQaaLXaJs9tL4NBCgr9kqwwmUxNzMFPCyjkSA1Dp6amADSfhVqthkgkgqWlpT0bWB4VulYuWq0WVquV3dRqtcrFTU6nE6+++iqcTicmJibg9XoxPT2Nc+fONSUwi8UiJ5nIqnQ6nTCbzfD5fJiYmGAlRZpaLpdDr9dzkZnZbN6TCUIbT6PRwGQy4YUXXoBCocD8/Dxu3LjRN95Lo9HA+vo63nnnHVitVqyursJgMPAwppGREVy8eBF6vR4WiwVqtRq3b9/GjRs3kEwmsby8jGw2i1gshnQ63TTFMBgMQqfTIZPJIJvNwmAwYHl5GSaTCefOnYPP54PJZILdbkcsFoPFYsHIyAiq1SpSqVRf0sop7EIQlYvFYsH58+fhdrtx5swZBAKBJktbp9OxV+dyuVCpVFAoFFi5uFwuDp92imw2i0QiAZnsydx7ynmJoBCS0+nEhQsXEA6HMTc31/E+PAlFRF6W3W5HIBDgfJ5SqYTT6cTQ0BAsFgumpqZ4f9J3hULBrK5EIoHbt2/j4cOHyGazuyZ9GgwGmM1m1Go1JJPJtvkYUkp0HaSkxXC3SC7qx/17GMhkMvj9fvzWb/0WhoeHMTs7yz8niOSekxpp0LVy0el0GBoaglwuRywWQz6fh16vh8FgwMTEBL761a8iEAjAarXCaDSy+ww8tp5F2my9Xmcr2Wq1Qq/XNzWno0Wj+Hmj0eBQWCvLT/p/2nwWiwUvvvgi/H4/fvKTn+DOnTsnOkdCaqWtra1hc3MTGo0Gv/rVr6BUKjmHcvXqVXzrW9+Cw+HA6OgojEYjfvzjH+Ov//qvmQIrvpf4GRRSoxwKKVutVourV68iEAjA7/fj/PnzyOfzMJvNGBkZQSKRwNbWFoDjq7foFBTjFwUKJaOtVisuXryI0dFRnD17FuPj41CpVNDr9U1r7vV6cfHixaZ1MZlMnOM6CLLZLNbW1iCXy9kzotyfCFJYbrcbFy9exNbWFlZXV3cxn6Q4Ke+G8kQ6nQ6BQACvvvoqjEYjTCYTNBoNzp49i/Pnz3P4Wcy30tnOZDK4e/cuVldX8cknn+Dhw4dNITjxfPt8PpRKJRQKhZYNMYEnLDSy3EulEu9xad6N6NNPi3Kh9fX7/fiX//JfYnJysonoAzzJS1NTUWnh7nGha+VSrVaRz+e5C6fD4YDJZILFYmGuNXkYxLChhw08qRat1WpQKBR88On1IuhvqOEdvZdojQL7H0DigpfLZZhMJrZ2+kVwkoIol8vI5XJQKBQoFAoolUqIxWJYXFzkuhWtVouNjQ2USqU93V2ZTNY0zZC+yFPMZrNIpVKcYNVoNBgZGYHJZMLOzg50Oh0qlQqz8/oJoiAhj4CIIFQTQRa2yBqT5mhIUO0XphItQDKOKNy6sbGB+fl5tvJJmbeDwWDA8PAwqtXqrtY97e71OBUMnSuVSoWJiQmMjo5idHQUExMTHG4l8gytnTR/FI1Gsbq6ing8jkePHmF7exuJRKJJsSiVSgQCATgcDjgcDgwNDaFSqcBqtbInHo/H+VkrFAo4HA4YDAY4nU5WRpSTjcViSCaTLRmATwOcTidcLhcCgQCMRiOHF0Xk83k8fPgQ0WgUOzs7J3Zuu1Yu+Xwem5ubMJlM+PznP4+xsTF4PB4MDQ1xzoQONzFkRMuC6LD5fB5qtRpWq3UXbRRoZgERZ1ur1cLhcHDCngSCtBX3rptVKuH3+zE0NIRPPvkEWq2WrZqT2IjShy7mXKiKloQYDVQSZzUkk8l946hSyi79jN43HA6jXq/D5XKxsJiYmIBMJmPKbC6XO5GY7V6gCYZKpZIFularhU6nw/DwMHw+HzNoKJwqWtMUu08mk8wOowS7FLT/stkskskkh3ErlQrW1tYQi8UwNzeHX/7yl3A6nfiDP/gDTE1NwWw2t73+kZERvPrqq3C73fjhD3+4b65hv98dFlLLl8LPRqMR3/rWt/D1r3+da6fIKBMZjK1ygZ988gn+23/7b4jFYtje3kYul9vVC8xgMOA73/kOvvCFL8BgMMBqtaJcLmN9fR2pVApvvvkm3n33XbbEtVotXn75ZYyNjWFoaAiBQACVSgU7OzvIZDL4xS9+gQ8//JBJGk+TgpHL5Xj22WfxpS99iaNCIsmH9mkoFMJf/dVf4c6dO9jc3DyxNehaudDhpiSd0WiEzWaD1+uFwWBgCjJtRAIpFooJEp2QLB96DfAkOUWvLxQKvGFIGZEVRJbiXgqGLHO1Ws0Krx+SqVLQPYugJn29en+poCWlRRRuhULBzLpWAvekIU3gEwOLkrx6vZ47wUpZdnTPYt2PWKsi3X+k8ClcQ3HscrmMeDyOYDCInZ0dbG9vo1qtMklgL2VMDEaj0cgWfyvlIRX6RwmR/UXXR4bi5OQk97ATUSwWeU3orBNzi6ZMUk2KmEMhejy9//T0NLRaLUwmE8rlMuRyOdLpNB4+fAin04lqtYpisQitVgu3243h4WE4nU44HA42fEgOKZXKtn3H+s37PgiIiDM6Ogq3273rXJJMzuVy2NjYwNLS0rEzxEQcOqGv0Wjw4MEDbGxs4LXXXuOks8h0Eiuiy+Uytre3kc1m+UGTxdJKMZRKJSwtLSGdTiMejyORSMDlcsHn80GhUCCXyzEpoFarce2GVqttq2CAZiV3UhtObAJ43J+rVquh0+lw4cIFzMzM4Pz585iYmIBSqeTiQiq07Kd6DALF0ilfV6vVcPbsWbz00ktwu93wer1MzZTWVlE8n8KF1WoVsViMFSqF0lQqFSqVCkKhEPL5PBKJBJLJJHvajUYDi4uLuH37NoLBILLZLNRqNRYWFlCr1diLarV2+Xwe4XCYQz5KpZL3I0EkB1BI+KhAz9nv92NiYgJutxvXrl2Dy+XCM888w6E7kTJfr9cxNzeHW7duwWKx4MKFC9BqtdjZ2UE8Hse9e/eQSqWQz+d3ec8TExP4F//iX2BkZITZeWSMqtVqOJ1OjopMTU1xaBYAbDYb9Ho9crkcbty4wUq+VCrx86nVahwpESvWT6tyIcVvt9sxNjbG6wU8kR/hcBirq6sc5aCIw0mha+VC0+VkMhm2trZQqVRw6dIl6HQ6FuzigyRLsVQqIRqNIh6PswdBeQ+yoIEnVmOlUkEwGEQ4HOa6C7KeFAoFisUiMpkMKpUKSqUSW97SRCqhlQV7EhtOzBUd96anJL9Wq8XIyAjOnTuH8fFxuN1u1Ot1bG1tIZfLsfDtN8UCNFfaE6HBZrPh8uXLsFgsvAekeT4ycChXRXsvnU5zophCPSTwE4kEUqkUkskkkskk5xYBIBgM4uHDhzz0Kp/PY2dnB0qlEjMzM21zJeVymWn1lEuQCmDyxqg56VEpF9FjcbvdOH/+PMbGxvCNb3wDXq93l3EhUl03Nzfx0UcfcaGpyWTC8vIytre3sb6+jnw+v2ukAPCY0PCbv/mbmJychF6vh1qt5veWyWQ8sfLixYuYnZ3ldjGVSgXpdBqFQgGJRALLy8soFovI5XI83ZKUlLRU4jSHyOgZGQwGuN1u6PX6XZ0n0uk0VlZWsLGxgXQ6feKlBF0rl3K5jHQ6zbH5Wq2GlZUV/PKXv4TVasXk5CR0Oh1KpVITW6NYLGJpaQmpVIqtFIfDwSwx2jjJZBI7OzvI5XJYXFzknxeLRQSDQRiNRhgMBqyuriISiXBozWazwWKxsOUpdeMJFC9u1wvtqCGGdE5CuZELHY1GsbGxAbPZzKG3O3fuIBgM8nMqFAp9eTBpDSmstb6+jrfffptZjHa7HdVqldmHKpWKuxmUSiWkUikkEgkAT1iHiUSCJyzSASVlS+N4zWYzVzyTF060WvKC1Go1V/8Du4e5UW2I2WzG0NAQ8vk84vE4UqlUU06MwsekgI4KdJ25XA7RaBRWq7XtM6frI6VMnXapp10wGEQikcDq6moTk1EEKTNpJ3VpS3hxlAR5m1QHZjKZ4Pf7uYiSDMxsNsthNZEleVq9FrVazflDn8/HRCkx8lGv1xGJRHDr1i3ekyeNrpVLqVRCKBRiD0Mmk+HGjRuIRqMYHR3F1772NTgcDqytrSEUCnG8tlKpYHNzE5lMhjeXz+eDzWaD0WhkVsnc3BzeeustZkuJLbV9Ph/i8Ti0Wi1u3LiBtbU1rgz2+/0YHx9n2nK7fIHYIoQOi+htiRvxqIotT0pgi4SK9fV11Ot1GAwGXL58GdFoFD/96U/x4MEDbG9vIxgM9mWLfmmoSyaT4ebNm5ifn8fk5CRsNhtGR0d5Ih+FAev1OrPj1tfXsbq6CoVCAYPBALlczvkS6slEowsqlQrTbanvGADMz88jFosBABtaGxsbzHSijgHSWiyNRgOr1Qq3242ZmRloNBosLCxwCIn2hkjbb2coHQZimKtWqyGRSGBtbQ1Go5FzJK2IJ0RxDYfDePDgAcrlMn7+85+zoBMjFe1ySWQAirlVMS9DCojaO4nvJ5PJ4HK54PV62VCkv08mk1AqlUin0zxOud/270Gg1+tx5coVjI6OYnZ2FlartYn5SOdzZWUF//RP/4RkMol4PH7CV30I5dIqWSZuLLrhfD6PVCrFf1epVJBMJlEsFtnbyGQyiEajHFLY2tpCKBRCPB5nr0jcoJlMBuFwGGq1mqmHFFKzWCzMSiFXuxU0Gg1sNhuzrvZqoHdaLZ52EJPhFFbMZrPI5XLcYoeE7GmZTS5NyIt7kNhdZMWSlUvhFJGOHo/Hkc1mEQqFEIlEmNFICWO1Wo16vY54PN7ktbcKc0oNFTG0JHbtJu+Efi4SLo7Lw6XQkV6vh9vthtVq3dURQrwfSrBTIXShUGgS4uL1Sz+Hwo9SBl+5XEY2m+VcE60HKQ86z/S8SNnT+4o5NLFYm/5W7HZxGkBrpVar4XK5MDw8zGw9KUOMwsP5fL5ljusk0FMakNVqxfT0NNxuNxeiUeO0dDqNra0tNBoN6HS6prGbZPUAwNzcHLt1xEKRbtBkMomPP/4YcrmcrUqyRpVKJVZXV6HX6zE2NsZ5IWncOxAI4Itf/CKCwSB++ctfIhqNngoh2iuQJUgdotfW1vDo0SPOK1DS+zQlQZ1OJ8bHxzEyMsIxaQr/lUolpNNp1Ot1TnTGYjGEw2Fmf1UqFSwtLSEcDqNQKHB3AjG3o1QqmZIMPDZ0pB6UyWTinE+7tdPpdHA4HIjFYggGg1heXkY+n4dOp2PlRx7CUea8SJFRCPmFF17AH/7hH8Jut8PhcDSF80QvJxQKIZlMIhwOc1hQelZb3TsV71Knb5lMxt4ZhWLVajXGx8dhMpkAPBmvPDw83BTiIuFLJA1SdltbW8hms0in02g0GrBYLNBqtchkMlwDcxqgVCqh0+ngdrvx2muv4erVq9xAFXiyvrR/iU3b6SiDo0bPlAtZGxaLBSaTqamFd7FYRDKZxPb2NoDHyTyj0ch/Sy30a7Ua1tfXsbm5uadQK5VKiEQiAHYXxJHVnclk2nojMpmMZ7zU6/U9PZynEaJFTNZOLpdDKpViZd1vHsteVFISNDqdDna7HWazuam4TLS06Z7FOitag1KpxJTiVqFA0YugDt+tvApqg7RXjoQ6DKhUKvYeRdaY+JnH8RzEhP65c+dgMBig0+lavpY8XpFyLe4X8kha5TlIUUhzBjTIjurYvF4v98OjvzMYDAB2R03ISyEPkMgVpJipO8NJJ7gPCvJuqUceTUEliF6ftNVLP+DQykVkmphMJgwNDXG1rU6nw9jYGKrVKoxGIzcHvHjxIpxOJ8LhMFuOdOA7pc61EzLA4wSYONdA+ppG43FldTweRy6Xg0aj4YR2uxjx0wa6R51OB6vVCpvNBqfTyYOdnE4nU0n7AXs9E6lnqtVq4fP54PF4WNDRHgOeVNo/evQIW1tbnLwnkko7xSpVJuKXmHukCaHiSGqp90HvpVarMTY2xlX+wWDw2NqViCEvcX3ExpKtQG3eVSoVRkdHMT4+zgZKo9GA2+3mLtxbW1tNYcNLly7h4sWLmJycRKPxeNga5ZjW1tbw7rvvMsmB1lAUotJQI60/FcqOjIzg7NmzCIVC7FFlMhkO3Z2msx0IBPDKK6/w2IdWNYO1Wg0bGxsIhULY2trqC4+FcOiuyBQPJeXi8XjgcDi41iQQCHDibmdnByqVCpcvX8bIyAhu3bqFSCTCBZJie42DbgLx9aJyEQWPKAyKxSISiQQymQxXHlOh3KcFJAitViusVisXq50/fx5erxfRaBTz8/MnfZkHhkajgc/nw8jISNMMG7GfHQk8YoLF43E2bvZjSdG/W4WAyIM3Go1cSNwurNVoNKDRaDAxMQG5XI5UKoWVlZVjZTaRJSzW2JByaXfdxMok7z8QCCCXy/GE19nZWYyMjGBlZQWpVIrzXWRYfu1rX+PuBeJIh/X1dbz33ntwOBz4zGc+wxEOyrGQ0hfDc/R/yl+NjIzgzJkzUKvVWFxcZOVympQKwe/342tf+xrcbjfcbndLT7harWJjYwOPHj3C5uZmX+RaCIf2XMQDl0qlsLGxgWKxCI/Hw9TidDoNlUqF6elpaDQaeL1e7g9EmlgsuOwWxEAxGo2wWCxs9ex3/RSTP8kmlscJouXq9XpMTExgZmYG4+Pj0Ov1XKtBpIvTBKPRCJ/PB6fTySxAMdEuhmFoX1CuRcyttAO9l9RbEaHRaLii3W63899JIYYl4/E45y6OO8fVzhPYC3TOAGBoaAiXLl3iHFWj0YDf74fT6USpVGKjjRTF2NgYXC4X18OJg/4MBgNsNhvPdJKyPaXrKPZvo/UU2yN1ej/9BKLQUyiMwrzSKAzdL9UBUuHkU+O50EMjlsbS0hKq1SqGh4ehVqths9mwurqKYDCI4eFhfOtb34LBYOCW5isrK01JvU5mPO/VJoO6/Y6MjGBycnJf6iaFA4i6109a/yhBzUbtdjt+4zd+A1/60pea2vNT64h+JDm0aodC36lfl9Pp5BHCAHgfiAJHnGpYLBY7yjOJtNhWoSsq/nvttdfw3HPPwWKxtA0tUZw8nU7jzp07HII8bsUixucpT0Jf7QpoyVNQq9V44YUXMD09zedPzLXYbDasrKxArVbjy1/+Mvx+P8bGxhAIBJgtRmtRq9Xg8/lw+fJlppGL1rqo2MXrp59RvoVGKmg0mibDV7z2foZSqcTly5dx7tw5XL58GVNTUzwdVYTIrvvoo4/wgx/8ANlstm9GiAA9TOg3Gg0uTDOZTCgWixySoOmUdrudq3GlG0ukD7aDWCsgPYQqlQo6nQ5Go7GpS0Cr62zVW+rT4rUAYO/OZrNxqxRKalOIkhL7pwkajYb7dYneCglJcb6HyDoSv1pBzE20Ayke6hBBjVXbgQQiVZ5TfuAkQWtADUH3avtD60Gt94EnypsUNeXxKFrh8/lYBoifSaQKmUzGY74pzCV+/l7rLy2B6CcL/iAgspHD4WCWG5EfxP1J5zSXyyGZTCIWi/XdaIGeUpGJAUNC3mQyYXx8HF6vF0ajkdu3ZLNZlEolLtTL5XJIJBJMp2v1vmJSTwRt8unpabz00ksIBAJwu90thQEl8omGurm5iVgsduKH+rhA1qLX68U3vvENDA8Ps4dH7dHX19extLTE8fJ+wV5sMfo97T9KpFMCVAxlVSoVxONxTkDvN2pYLpfzQCrRCBFDY8DjflfkMRuNxl3JVymKxSKP66VBeO32f68grkM7JBIJLC0twWq1YmRkpG0bJQKtezqdxvLyMsrlMtxuNywWC8bGxvD7v//7UCgUPDKaKMgAOPd5//59rK6u8rA1aa6Urr0dxP5yoVAIDx48wNbW1i6v7DSEyMgrFBuvSgsm6/U6otEo7ty5w4l8YkL2Eoftfdhz5UL9wmgGPNEHiYtOjSszmQy2t7e5piKdTre0lMWiq1ajien3brcbzz//PLxeL48+bQWioNLkwFQq9anxWmit7HY7rly5Ar/fz6EH6rgQDAYRiUQQi8VOHbmBOi6IVjftHdFLoRk2NBtoL8qwWAMi9XZEGAwGeL1euN3ujnJ9lUqFqbyU7JZap70GCey9CAPUULNer2NoaKij95TL5dztgWY86fV6OJ1OjIyMcPi50Wg0Tfik69ja2sLc3By/X7uZOnspGHq/VCqFnZ0dbkdD70nfT8M5FwtspcW55Jlls1ksLy9jZ2cHiUSi5/RjUbl3u24HVi5ita70A8kaU6vVuH//PoLBILc/p0E+xWKR27+srKxwOGA/ho6Uigg83mxWq5Xnd4+Pj8PhcOyythKJBBYWFpDL5bC1tYVkMsmtaqhB49MOmexxuwy3243JyUkMDw/D4/FwLYPYaqNfIZPJOFxANRHSLsJifVW5XGbPRKyBoA4Q4XAYpVJp17hdERTbFnt80Wvl8seTK7VaLUZHR3HmzBm20MWcAoXARE9nZWUFb775JtfVkDd/lGiV5JZap9FoFHNzc0xKEOvRxDWhOrLt7W1sbW0hEongxo0bKBQK2NjYgN1uh8/nw8zMDLPnqJ6sXq/z5M5kMokHDx5gcXGxqR0MPZO9lDTdA5Ei0uk0lzfkcrmmZP9pUixDQ0OYnp7G0NBQU3sc4MleymazWFlZwebm5pFEGMQ90u26HViSiJagNAFOD5RmCJhMJh7qEwwGMTc3h2w2i/X1daTTaaZ+7ueutku004PweDw4c+YMLl261BQDJgSDQfzgBz/Azs4O7t27h52dHa6ybhVqexohk8kwMjKCZ599FrOzs5iZmYHT6eR2I2Kvtb2mMZ4UGo3HbTxGRkYwPT3NRgJ5s2K9FYBdYQLyWDOZDBYWFrCysoK1tTVOgu5l3BBrTrpH5XI5HA4H7HY7zp49ixdffBFOp7OpHTrwJGwDPAnx3rlzB3/913+NdDqNVCrVUbz8sM9E7KNH7yeGXMiLeP/99zE7O4uXXnoJdrt91+dWq1VEo1GkUim8//77ePfddxGPx/Hw4UMUCgUeW/D888/jm9/8Jux2OyYmJtiQoSaL77zzDoLBID788EMsLi7CYDDAYrFw2yhif+1F5aa1pRA3jQoXW+rQa08DlEolJiYm8MILLzBpgrxN4MlzSqVSuHXrFk/6PAocVi4eWLnspQiopYVGo+GHnkqlIJfLEY1GkUwmkcvlkM/neWzuYanHarWaq4nVajVbrsCTJF8+n+eQD3WeJWbapwEkeC0WC3w+H1wuF9dgtIJYU9BPIHaTtNiV8itUGS/uA7oPamCYSqUQjUZ53kUnyd9WrDDykkwmExwOB2w2G2w2G/d+EpHL5bC+vt7UyoXaopPnfBwGTqvPkN6bXq+Hy+WC3W5vmYtqNB63wdnZ2eF4fzgc5rNNM4Aajcct4CORCCqVCjQaDeeXlEol1tfX2eMRae/ijCbR8xSvlSIY1OIlnU7z2RaLMo8aYsjqsLVJRKHWarWcNyRCiBi1KRaLyOfznLsuFAp9G3k5sHJpF3OmpPqrr77KXWVzuRzm5uZ4QSg2SD3DDgMSJm63G6Ojo3A4HE2KhR5EoVDgmRObm5vMTPk0eCsEWquZmRl85Stf4fEGQPOBBcCV2keRIDws6vU6VlZWEAwGuf+WXC7n5KfT6YTX621qLUJCL5VK8VygX/3qV3j06BEbGQcVDER51+v1mJmZwdmzZ3Hu3DmcPXsWer2euy8T5ufn8ed//ucIhULMpAoGg+x5dXoWDqvsKacpWsH02RQ6euaZZ/Cnf/qnsFgsXKdDoGhFPB7H9773PVy/fh3RaBThcJg9Q1oftVqNcDiMt956q6kdDq11IpHA/Pw8K4h8Pg+FQoFkMgmVSoVQKASfzwez2QyTydSUzKbc7Z07d/DLX/4S2WwWkUgE+Xz+WItQaZomMd4OI+Q1Gg0XoNNoblLsZKhTR/nNzU08ePAAwWCQWWL9iK4C7O0enMlkgs/nQyaT4dnNVENCTBjaIIeB2BmARqXS9Evx+kRrNRKJIBqNHupzTyPEcJE4D4KsS6C5IIuo4/3o1TUaDe7cTCBLmDrkEsOG9hmFwmgPRCIRBIPBJkF/UBCDTK/Xw26386Asmswq1l7UajXEYjGeZy724jpui3Mvz4X2icPh4DyJ1AMTPcfV1VU8ePCADUcxNEnfi8UiQqFQkwdJ957NZrG5ucnFy1QaQGN6qQmlSFumZ0rD3iKRCObn57nzutij7TiUC3mvFFbu9j2INGI2m2E2m3nt6T7onmnAHE0w7fd2VT3N3q6uruKNN95AsVjEzs4O10uQp9Iri4LGzFosFjzzzDN48cUXMTw8zCNtya1+66238Mtf/hKrq6tIp9M9uMPTB6VSydXRFouFN22xWGxKgK+treGnP/0phxdOE0QWWDAYRKFQwP3795HJZJBIJLiZaTQaRTqdZmvvoIqF8o1+vx9f+cpX4Ha7cfHiRfacKT5OSvqjjz7CzZs3sbCwgEgkwiGMfgs5KpVKeL1emM1muN3uXXkO0dsgy7lUKkGj0bDVLHrARKcmxhixEev1OjM0xQF0RNvWaDQ88lwmkzUZOmLD0UgkglQqhfX1daysrLCcod5wx6VcKDdESrMbmM1mWK1WjI6O4qtf/Sp8Ph+mp6cBPCm0zeVyuHfvHqLRKO7evYv79+8jFApxL7d+RU+UC23Ezc1NhEIhthhbdYztBVQqFaxWK1wuFy5evIjPfOYznIymh5HL5fDOO+/gb/7mbw7UEPNpg1KphNPphMPhgNlsZqu6VCrxc1Mqldjc3MSbb76JZDLZV/UtnYCECeXWwuEwfvKTn/ABJCs4m83ymIFu6OdEehgeHsY3v/lNjI2NweFwwGg0NtF8qQPzhx9+iO9+97s8OGwv4sBJQqlUwufzwev1wuVy7WqOSNZzOp3G0tISdnZ2UKlUoFarmzxgAuUzPR4PN7ik+jKaKCsO/aIv8gSlykUstC6VSjwqYWtri0Pd9GzbhezpXnoJKmQ8DEwmE7xeL86dO4dvfvOb8Pv9TSOfibL+4MEDrK6u4vr167h+/fqR10T1Aj31XMQ6lKOwHijZ5fF48Nxzz3FDN7GXUKVSwfb2NuLxOOd4+jHEc1yQy+UwGo0wm83cOVYUHrQ+4uCnfhSA7UDhp0qlwqEDCpMkEgm+J+ohRgKoE4FDoVeaZOnz+eDz+XDmzBnuIC12myCvJRgMchiO5mv0m7cigupDVCoVE16os7PYfkWtVnP3cIfDwYXPxLqk+yM5QHRw8pSJEUdsTo1GwyExMecnlh7Qe1D3j3w+j7W1NSYUUCeQVsXVhy0CbIdeKCvy1kZGRvDCCy8w7VskUYjrSexWYjeehtq8nigXcRHaJfwPC5lMBrvdzo3y/u2//bc8V1qcx0K9dpaXl7G4uHiqW0H0AiqVCkNDQwgEAswAEjseEMGBWDfZbPbUKGM6hFSHQsnhRCKBjY0NbG5u7jIuRIZZq6Jc8b0ptzI+Pg6bzYbXX38dr7/+OoxGIzweD1dPi8Ign8/jk08+webmJocvTiK/chBUKhWsr68jGAzi3LlzWF1d5VANtVGimp5AIACj0YiZmRmuH9rZ2WnK35Hwo3wMTXulfJPZbOaKenodRRYoykDPrVAoQC6XI51OY2VlBclkEu+++y4WFhawvb2NVCrVREogUJgNQM+YoaIRQZ/XjWwhRa1Wq/HKK6/g3/27f8fhQKlyqdVqKJVKCAaDWFtb4+m8x9k5u1v01HM5bNHNXqAHYjQaYbVaMTQ0hKGhoV3tParVKpLJJKLR6Kmb39BLiIlC8lxIUIghHJpeR5TY06JYCHTAqQqcBBZ5MfSzVsW/0p5h4r+JDUZjfx0OB4aHhzE6OspdKEQPUCQQxONxhEIh7jrR78YNhUlFQU8CvlqtsgIluizRg9t1NqD1pVHSMpmMPQypByd9BiRQaV8SPVckQVAuTaSSt/Im+q1Wi0AMR71eD4fDwcWS0vUUyQsU6u+G3XhSOJJy7F5Xw9LmczgcmJ6exsjICB9uqRVRKpWwubmJ5eVlJBKJU/EQjgIajYbn61y4cAGzs7Pwer1NArZUKuHjjz/G/Pw8bt68eeryUqLHLLKzGo0GKwCiiIrKhQ4nKV9qt0G9ydRqNWZnZ/HZz34WZrMZPp8PRqMRgUCgZWgRANd0bWxs4IMPPuBx3YdVLLTHD1sTth/E5DqFw2KxGBQKBTcDpS68yWQS6+vrWFxcRDweb3nGiABw//59/j8ZLmJeihQDMcoKhQKi0Sjef/99LC8v4+rVq7h8+TK0Wi2mpqaQTCbxxhtv8AAw+lvpNZAsEO+tV2t0WKWl1+vx0ksvYXR0FGfPnt1FoKB7ofk+m5ubWFpawvLyMhMWTgP6t9eHBDLZ426hLpeL3UfpASc6bTweZ977pxU0FtZqtcLr9cLv9/OAJtqcNGiIaLL9bmG3A123GLsXq/WlQoGUi9iLTKfTcVGkVqvF9PQ0fu3Xfg0Wi4VbCqnV6l2degmUeE0kElhbW8PS0lJPEq4kPI/62ZDBQTUqcrmcKd9Ut0MhGpriGo1GmS3VCvl8Hjs7O02908TuxRQqpKJXCqnlcjksLS0hkUjA7/dzV3U698Q+I6OBDAXxOg7D4OpkrQ4DtVqN8fFxnDt3jqeltnr/YrHIdUThcBjRaLSvw6tS9LVyoYNF8UmPx4OpqSmeF9Pq9fV6nWtbTlvjxV6ArOqJiQm89tprGBoawsTEBGw2G3Q6HVf91ut1aDQaTE1NsVCZm5s7FYlCKcj7SCQSuHfvHmKxGFNdRaFJFiLVERAhRKfTwWazcWt4q9WKyclJ7r1G67ZXW5xQKIQPP/wQGxsb3PSzFyFGsXjwqNFoNBCLxfDw4UNotVoYDAbeL1QETYWoyWQS6XR6z4FyZOxRyFJK9hHXh4SmGMolZUKhxp2dHcTjcWxvb3MS/7iUb68gDQGK3+keKDRJnduDwSDnqE7LfQJHoFx6JZho05AFrtPpEAgEcPnyZZ4y2Qq1Wg2pVAqxWOxUaflegSzx8+fP40//9E95qp3YYZUEllwux5UrVzA5OYlisYif/vSnHBc/LaBcHFV1v//++9xlW3oYaT+ZTCao1WqcOXMGzzzzDI/rNRgMmJ2dxfDwMHf4luYEWqHRaGBtbQ0//vGPEQ6HucarF2fhuIVJMBjExx9/DIvFAr/fD71ej0wmA41Gwx2HI5EIwuEwYrHYntdHOYP9QOFYWmOtVguLxcJM0GKxiPX1dfz4xz9GJBLB0tISK29px+t+h1S5tFIw1CKLJkwGg8FTOV/pUMrlqPjjwBNBoNFo4HQ6YTabYbPZuNWHNEZJtQTb29tNVuunCdRO32KxwOPxcEdqompL8w7VahWJRIKbEJ629RKJCRSvJ3osFdyJgofuj6rrTSYTLBYLzGYzHA4H/4xab+w1RZLyO4lEAvl8Hpubm4hGo/z5p2EtaSpso9HgMHI2m8XOzg4ymQzq9TpPdVSpVFyIStXhvfaoxBwaJe2j0Sh3VKDPJsXSz/Tu/UBnULwP2ssUesxkMjz+4jTOnOpauZDwB9DzxnvkGtNM7c997nPc0dfj8XDxFvAkzv7gwQP86Ec/wvb2NkKh0KmxZHoJtVqNl156CVevXsX58+dhNps5US0tjCsWi0in0/j5z3+O69evY3l5mV3v0wDKqVBtCbHDEokEK04KvYihJZr943K5MD4+jrGxMdhsNkxNTTGDp52nQvupXC4jmUwik8ngjTfewP3797G4uIibN2+iVCr1JNd3HOyn6elp/N7v/R5qtRq++93v4t69e1hZWUEkEmHPTWSKUT0RFaIe1V7J5XK4ffs2FhcXsba2hrm5OYTDYdy9e5eZjdIxCaflrIshQerjl8vlmkZoU8ushYUFvPfee0ilUqeusBnokefSS9B7Uq5Fr9fD4/FgdHSU4+Ji63DRglxaWkI4HO77ytWjglwuh9PpRCAQ4LYb0joMSnTSiNTt7W0sLy9zPcZpgnRsMSWcgea5QwQygDQaDVvkxCojxSLtwCuCvCBiTaVSKaytreHhw4c8AuCoQrH7hea6ATHgqtUq9/CS9m47CdB5pkmhABCPx7lWRmzd02tm6nGAiAtU8JvL5VjeifVaRJogL/K0oWvlIrIxjoJ2bDAY4PF44PF44PV64fV6odPp2EIlYZJMJpHP5zE3N4cHDx4glUox//20bbrDgMJeFB50uVwAdo9GTSQSiEQiuHv3LmKxGD755BNsbGzw/IxOIYaNTkop7dVeiAQxMZHI6i6VSlhbW0MsFkM6ncbGxgZcLhdCoRCsVisCgQBcLhdX5xMajQbi8ThisRhCoRA++ugjxONx3Lx5E+vr64cSAJ2El49iL6+srOC73/0u6vU6NjY2ev7+3UKULdFolLtHAOBx0+JrpTjKcP1h0Wg87n340UcfYWFhAR9++GHTfms0GizDNjY2TnWI/1DK5aiECjF6nE4nT090u93QarUcS6d5D1tbW0gkElhcXMTS0lJTq43T+EC6AQl6KlajNhkEsTvv8vIyN6mMRqMsaA+6XuJhOInN30ndB4VXNRoNGyU0i0QulyMSiWBxcRFDQ0Oo1+s8othoNDaF3WhtwuEwVldXsbS0hJ/85Cc8F4a6GhxWudB9id+l99xLbG1tYWtrq6fv2QuQcqFamWQy2UTw2Sv/0Mpj7TcUi0XcuXOnZQFpq++nFX1DRaZFJh47fdHsC5lMBqfTCafTyb2waMwqtaA+yvYz/QyxnUSxWEQikeAGgdSxoFQqNfXaourrbhXDcSsVaUhIq9XCarUCAN9XK4h5AgIpARpsRXuJmiKKdR2UXyiXy9yyXxxLTAqMPqube3pahEkvIdYmicSNoy4mPU6QnJLu7adlH3StXESN24v5LGR5Uxxcq9VCqVSiUqng9u3bePToESYnJzE+Ps7V5cViETdv3sTq6ipWV1c/VdMlRdDQIqKLrqyswO12I5FIQCaTYX5+Hslkki33bDbbxKYCDr6hj7JIrRUoz0afbbPZcO7cOTQaDdy9e3eXcqGDSx6uaHCQkMrlcigUCtBqtcjlctDpdNyzitg66XQat27d4llAVMBHnZWpol1szNgKUkUi0sI/bcbQfqCcBK2RmFvbb61O41qetuvtFH3juUhB7Alq5EYPQKzyrVarXBW9V6XwpwUkTHO5HCcFG40GUzhp3UTlcprWrFW4Yz/Dpp2woZ9TLUY2m4VarUaj8bj5ZKlU4jkwNE6WyCQ02VPsZzZA7yEq3l54LEqlkmuXBjh6HCrnchjBJAoK2jgymayp8pZmO5w/fx4Oh4NbnufzeW6rH4vFeBqd9JAfV1+mkwY186MWGzRe2mazoVqt4s6dO01TODOZDCcLT0tzT2nn20Qigbt37wJAS5rmXh6EGGahAVYffPABF+8Ra0yv10OtVuPatWvQ6/U8KTAWi+HevXtIpVKYn59HKBRqqahbNcsUr0/ck+J1ib/b6z0GOBhGRkYwOzvb9dTITzs6KSgWcSKey141BCLLS6vVwmw2Y2RkBB6Ph+sT0uk0zzbI5/OIRCItD99paw3RLcj6rlQqPOI3FApheXkZpVIJjx49QjQa5XWncamUdzkNkOYlSDF2CzFMVSgUsL6+zqOgqZiSRhfT/nM4HLDZbNjZ2UEikYBGo+Fq8U7DYdJ7ot9LD67YM2uA3oSOLBYLxsbGmG4+wMFxEMV8IqvcbqOIFlsqlcLCwgJ2dnYQi8VgNBoxOjqKkZERJBIJzM3NcZPAdlbdaaXwdQPy0sjzCwaDuHv3LqrVKsLhcFPtAiW5n8b1accUEqnTxHQUFRb9P5fLcQ0CDcKq1WowGo1cC5NOp7G8vIxMJrNvZwOxkab4//3agEhZT2JvtF5BpFv3A3W/1Zr0kjhCFPynwXOheTV05o/LSDxQuUKjw6fW7aZuRbPs5PU6nQ4mkwmNRoMF5szMDKanpxGNRnHjxg1kMplDxby75cN3s9GP0gIllp2YAxAFUasNcZKC5KjWrx3JRKSxEhGh3SERWYvUv04qeEVl1EkLlFZCXExUS/evqAhJsBKlGngc1uwGonIFwKMGgM4Hah1VDQndM9Hbj6KcQByV0E2frn7yItVqNSwWC+RyOVKpVFu25EHlb6fo5L36zj+kUIDYkpsG5JA1SbTR09hv56ghMqIGODhEa5kEuzjw6zhpw62EWT8JuNOG4+oufVw4aA7kuNGx5zLAAAMMMMAAneL0Bx8HGGCAAQboOwyUywADDDDAAD3HQLkMMMAAAwzQcwyUywADDDDAAD3HQLkMMMAAAwzQcwyUywADDDDAAD3HQLkMMMAAAwzQcwyUywADDDDAAD3HQLkMMMAAAwzQcwyUywADDDDAAD3HQLkMMMAAAwzQcwyUywADDDDAAD3HQLkMMMAAAwzQc3Tccv8o2jqr1Wqo1WrUajUUi8VDtTFvNQui02twu93QaDSIxWJIJpP7/k2/zXPpNY56tG6/rF+7+S/9jm6fyUnuQZov1C8D6vplD3aK07h+Xc9zaTXQ6KCgueOiEOt2uI3NZoPX60W1WsXGxkbT5MW9UKvVkEwmoVAo2g7c6TcolUrI5fJDDUrbC5+mee3tJlcO0FtIz/kAB8NB148Mp5M0mg6lXGi6XrebptXwnm6tZpPJhPHxcRQKhV1jffdCrVZDNps90HWfJGhKouil9SOOamJhL9ELS/Q03Gc/YLA+h8NB108cJHZSa3+oSZTS6Xy9QLeT/nK5HHZ2dlAul5/6CZVHMQK21+jnayP06hr3UzC98PIH6D/0c1i1H/ZYx5Mo6XC0Qj/ciEKh4BnplUrlSK+pH+K1pzmc0w/r1ysoFAp+Fu28SIVCAbVaDeDx7PaD5ARboZc5l0+r59WLPSiXy/m5lsvlvlMw++EwyvFIcy79hl7kH4hgUK1WUSqV+vrA9fO1fZrQaDROtaIfoH8hCv9+j1S0QseeS79ajr2CXC7HmTNnMD4+jlAohHv37rVN8D9NlvdJ4GlbP6n1LyWliPHvXoTFThNbrF89o17tQTHc2c37iXtGmsNWqVTQarVoNBrI5/OH9nh7iU+V53JYyGQy2Gw2+P1+1Ot1ftADDLAfpAdNKlBPo9U5wG60UpTdhsLahShFhheFU+v1OrNDTxM6Vi5arRbAk5jx0wR60FtbW0xNrlQqJ3xVA5wGiKELQreklKcVT8s69PI+xLoVUib1ep33klwuR71eR6FQQL1e7yuvpVN0HBZzOBzsnpVKpaO+rq7QrQsukhVEGnS793nawjrHjadp/RQKBeRyeZNCOWpG2GkKi/UrTnIPUjmBXC5HtVptMtbF39Xrda4F7Df0NCxWrVY7flMRnRZFinFpaZ3LXq6n+Dd0yOlwd3qtA0tzgE4gl8shl8uhUqlgNpuhVqtht9thNBr5NdVqFdlsFqVSCYVCAYVCAZVKBblc7tSxiQY4GpBsarcfROP2NMukjpULFSUe9ICIQl8aThMVA1mAarUaSqUStVoNlUoF9Xq9Lc1PLChUKpVQqVSo1+soFouo1WrscrYLXQyUygAHASVYXS4Xnn/+eTidTnzuc5/D7OwsvyaXy+HBgwdIJBJYWFjA8vIyIpEI5ubmTk0HiF6Azlu/1oGcNKrVakuWoah0Tvuadaxcus2z7FUlSr9TqVTQ6/VQKpWsXEqlEnK5HGq12p7uKCkv+iJFJWXmiN7QaX9oAzTjuBhJarUaRqMRVqsVQ0ND8Hq9mJmZwYULF/g1mUwGlUoFsVgMhUKB97BarWZj6Wk3ZloZc8f9+UD/G417XV+/X3snOHK2mFjFL91wZAmOjY3ht3/7t+FyuaBQKKBQKHDr1i38+Mc/RjabZS9EXHBpuI0SXgqFAlarFSqVCiaTCUajEdVqFcViEZVKBaFQCJlM5ql4eAM83gdarRZKpRLlcvnI8oFyuRxXrlzBZz7zGbjdbjzzzDOwWCzw+XxNr9NoNJiYmIDP54PX68XVq1fx8OFD5PN5RKNR7OzsIJPJHMk1niREo05kPVE4/bggRj7K5XLfn/N2ivgwBrD4LEh2ngSOXLns5SmQchkdHcU3v/lNTE5O8kKbzWZ8+OGHqNfryGQyLa0R8WdURCmTyWA0GqHX6zE0NAS3241SqYRUKoVCoYB0Ov1UHu5PK+RyOTQaDdRqNRqNxpEJFLlcjsnJSXzxi1+E0+nE9PQ0dDrdLsGgVqvh9XrRaDTg9/tRq9VgsVhw/fp1qFQqpFKpp27/UfSABBpFEE4iGa1UKqHRaFCpVE5NG6hWIcTDkDZE5XKSkZpjqXNp5bXIZDIMDw9jZmYGZ8+ehU6nA/A4Fkl1JjabDdVqFfF4HIVCoelvxfduNBq8uc1mM65cuYKhoSE4nU7Y7XZUKhVmuY2NjSEWi2F1dRUPHjx46mjVUshkMmg0GiiVSthsNtjtdhSLRUSjUVQqFaaWn4SVeRBQ3ZH04IkK5SiEmVwuh8FggFarhd1uh8PhgNFo5FxgLpfjbg71eh1KpRJWqxVqtRrFYpHzLKOjo1AqldjY2Ojp9Z00LBYLrFYrLBYLpqenodVqkc/nUS6Xsbm5ibm5uY5p/WNjY7h48SIAIJFIoFgsYnt7Gzs7O03hbaPRCLVa3XLMBn1RPpbyrv3qwVAqwGKxYGZmBmq1Gg8fPsT29nbLxr6tQMp8bGwMly5dgkqlYs/x/v37ePToUcfv1UscWxGlqGBIs168eBHf+ta34HK5YDab0Wg0UCwWUS6XoVQqMTo6CrVaje3tbaTTaf5b8T1p41DBkcfjwW//9m/j0qVLMJlMMJlMLHiq1Sp3TP7e976HpaWlJqX1NEKhUMBisUCn0+GZZ57B5cuXEQ6H8dFHHyGTySCbzaJYLKJUKu3JpT/pOLZGowHwuIeTqASpFuConqNSqeT9OTo6irGxMVZ0hUIB6+vriMViqFarqFQqMBqNuHjxIpRKJbLZLKLRKBqNBi5fvozh4WHcv38fy8vLR3Ktxw2ZTAav14uzZ89iZmYGv/d7vwen04mNjQ3EYjH8/Oc/x9LSUkfKRSaT4YUXXsB/+A//AQBw7949xGIx/OhHP0IoFGo65263GzabDUqlElqtFvV6Hfl8HtVqFYlEAqlUCjKZjL1Z2tv9CMrjzczM4N/8m38Dk8mEv/mbv0E0GkW1Wt3X+xJJTa+88gr+43/8j9Dr9Rwi/ou/+Ausrq7y/uz0/PaiKWdXyuWwvZToojUaDcxmMwwGQ5NlShZ1uVzmJKj4dyJUKhWUSiWzxTQaDSwWC+x2OwwGA/R6PSshstB1Oh2MRuNTzftXKBRQqVTQ6XTwer2wWCwYGRmB1+uFUqmE3+9n5UIbURxTQB4BPQdqP3GS6GXdUScgAeVyueByuVigAeC1oToFWieiIGs0GpRKJT7UpVKp7/vVdQOj0cj5JZfLBYfDgVKpBKVSCYvF0lSzIYVYXyY1PjuBRqOByWTi9SVZ0c+eihRarRY2mw02m4332MjICMbGxpBMJhEKhVqeO5VK1SQ3gcdjR0ju0T6k4veDolW06aA4sHIhyjAJ64NCrEkhCrFSqeQbKRaLyGQy2N7exp07d5BMJpHNZjn0JVrQCoUCQ0NDsNvtrOVtNhusVivMZjMLAvo84PFh0Gg0MBgM/H6nZSN2Alpfu92O4eFheL1efOtb38LExAQsFgvMZjNKpRI+//nPN4WRarUa/58O6fLyMtbW1rC6uopf/OIX7D2eBEgwH9ezor3pdrvxO7/zO7h48SLGxsagUqmQz+exvb3NVqXVauXalmKxiI2NDYTDYT4j29vb+MUvfoFwOIydnZ1juf7jgEwmw/nz5/Htb38bNpuNlQl5FsPDwzCbzajVaruME4VCwTkr8kZXVlbwj//4jwAed8vIZrPY3NzcVTaQyWRQq9VgMpkQCASQyWSwurqKWCyGUqnEz6Xfa0VkMhnGx8fx4osvYmJiApOTk7DZbPiTP/kT/NZv/RZ+/vOf47//9//eRECi8z00NITXXnsNBoMBW1tbSCQS8Hg8bJyTMSMaQAddh8Ou24GViyioe5F4EinEAFhJ5HI5xGIxpFKpJrda1KZyuRxGoxEWiwXlcpk1NSV4W+V5VCoVF8LtRZM+raD11Ov1cLvdGB4expUrV3D+/HkAT7xOsiRVKhXHrYEnnmO1WmUrqF6vQ6VSndg9Ad1T4bsF7RG9Xo/Z2VlcuXIFWq2WezxRDk+n07GXQnHuTCaDQqHAhlMul8P6+jqCwWDHQ+xOA2QyGZxOJ2ZnZ3kdZDIZ9Ho9AHBuRJycShDPINV8pFIpPHr0CACYyi1ldpJHTfvcYrGwQUSFqiJDtd+Vi81mw9jYGIaHh2GxWGCxWHDx4kXU63Vsb2/zGonKhfKAk5OTnE6gn4lRGvrqNt9y7MqFLtJgMMDlcqHRaHR8aGgRtFot1Go1TCYTrFYrjEYjb8BsNotIJMJKhTYkFViKyoFeX6lUYLVa4fP5MDQ0xDMWRNADomFilUqFldpeCuakZld3kuNQqVTc2K5cLkOhUODs2bMYGRmB3+/H5cuX4XA44HK5AIAtmFAohOvXr6NSqeDFF1/E5OQkfyblwwDA5XKhVCohFouxF3hSkK4H7QEATaHTXmFychKvvvoqhoeHEQgEoNPp2MMmmrtWq4VWq2UFTb+ncAVdkxia6FdBd1CoVCref3SexWdEZ41IDdIWJ/R7OlsAkEwmsbCwAAB8rqXKhUKVer2eQ0gWiwUXLlyAy+XC9vY2QqEQAOzq2NEvIOOPaOvPPvss7HY7k5pyuRwKhQKy2eyuazebzbBarfD7/RgdHYXZbEYymUS1WmUyBa1bPp9HsVg8sXvvSrnU63UYDAZMT0+jXq8jm80eyCLTarXQ6XRNyoWSb9lsFuFwmBeMKuxJmOh0OrYogccbMhKJQKfTYXh4GD6fj5O/reKGlD+oVCr8vnsJJrKQgOO1nqXEhVa/V6vVMBgMrDTUajUuX76Ma9euYXJyEteuXYNGo2FaItX7rK6u4v/8n/+DQqEAp9OJ8fHxlt0S3G43dDpdSwvquCH1lhUKBQvto2DCTE9P4w//8A/hdDoxMjLCViF9tslkQr1eh0aj4f1oNpvZclcoFByaoL3ab0KuW5CC1Wg00Ol0rFwIdJ/VahWFQqFJwInGnKhcGo0Gkskkcrkcs7/ahd41Gg30ej3sdjtGRkZQKpWQzWaZWBEKhZqMpH5jQVLExWg08jlVq9VskORyOV4LcV/LZDJWLIFAAIFAACaTCdFoFOVyGVqtFrlcDnK5HKlUCvl8Hvl8fs99d5RnumtztFwuI5FIAMCBOwhTfB94ksOhgp9QKITFxUUEg8GmimbacPRZVNOiUCig0Wg4xuvxeJo2uvi3pVIJ6+vriEQi2NnZ2TMOKYbqjlMoiEJevAfxZ+KaiY3vGo0G4vE4NjY2YLfbWXmSe7y+vo6VlRUsLi4iEomgWCziwYMHMJlMcDgc8Pl8bI3K5XKuGSDFcpKQrj8901a/6wWUSiULAPLaaP9ls1msr6+jVCoxoUSr1cJoNLJHTcXApBTJgn8aukNoNBqcOXMGLpcLIyMjLafUijmSVjCZTJicnIRGo+GcC+23YrGI5eVlzrVKQQZiOBzG/Pw8yuUyNjY2kMlkUCwWeSLtQXsMHhc0Gg1mZ2fh9XqZoi6uIa2DmIsm0N4iw9JsNsPr9UImk8Hj8bARVCgUOJqxF45ybbrKuVB89O7duwBwoJ5JRB0lgUc0OuDxpvnggw/wD//wD8xkEg8jUWZJeSiVSrYYZ2dn8YUvfIET+qJFRHUuqVQKP/zhD/HJJ59gdXWV3XXpAvd6LG2nEPNP9CWGBWljUYiGyA90beVyGdevX8fDhw9RKpXwhS98AWq1Gvl8HoVCAd///vfxt3/7t8jn82wY/NVf/RX+7u/+Dq+99hq+853vwGq1wuv1QqfTQafTMVVSJHKcxGGVCuVqtYp8Pg/gaA6IVquFx+OB3W5n5UpFuKurq/j+97/PawgA58+fxyuvvMLtYcgTp+tLJBKccD7tsNvt+Nf/+l/jxRdfhMfj2SXASLC3Eu7078nJSfz7f//vMTQ0hFgshmw2y9GMjY0N/Nf/+l/x8OHDXZ9dq9WQSCSQTqeRTqdx9+5d1Go15HI5VKtVKBQKGAwGlMtl7u7RT8qFyDZ//Md/jJdffpkZiCJTzmAwQKVSwWg07lLcVDRsMBjg9Xrh8Xjg8XhQqVSgVquh0+nYKCcP86QiDl17LkSx7AbihhPDTvV6HalUCsFgcFcravo98MTzIQFMtDy73Q6LxcKxeNHbyWazSKVSCIVC2NjYQDwe39ddlF5rr9EqryL1XETigxjbJ2uaPEBaw3Q6zUKQ6LHpdJqZN4uLi7yuMpkM29vbiEQimJiYQDQaBQA4nU5m8pBSaWWdnjSOwgsgK5JCPeSJUA1WOp1GPB5HKBRCLBbjv/N4PMjlcly4J2U2Er3+afBcVCoVfD4fpqamdhFnaJ3oq93Z0Wg0cLvd8Pl80Ov1yOfz0Gq1XKOxF4WWCCfUgZpCbI1GAyaTqW/DkKJx6PP5MDExsStKAYDHrLerS6FIBoUmNRpN2+jGSZ7bAyuX/dzd/UCsBr1eD6PRyFY4AK4Sb9cFGQB7JNTK3GAwcFjCYrHAZDIx+6lQKCCfz2NrawsffPABwuEw7ty5g62tLY5FtgIlyOnfRwFya4EnyUsx1EObhMJURqMRDocDwOOEn1Sxk6VCyiYej2NxcRGVSgU//elPsba2hvv37ze9v+glPXz4EH/zN3+DQCCAP/mTP4HRaNzFOHnaoVQqMTU1heHhYczOzjYJznq9juvXr+NnP/sZkskkNjY2UC6XoVarudD3vffeg9vthsVigVarRbFYRDab5Rxfv87m6BRkbIhCTeq1lEol/PM//zNu3LiBu3fv7opq0HpGo1H88z//Mzf/9Hg8yGazCAaDWF9f37MoVqTPS9ezWCx2Tb09KtBZoxBWIBDgOjupYimVSvjZz36GTz75hEetS2nYW1tb8Pl83AlBDKuRDMnlckin0yfaAqcrz+UwD00mk7GFQkwblUrFrvReHpE0GUiCT6SNksXdaDQ40RcMBvHxxx8jHA5jbW1tX6+FkpFHCaVSycqFmmpKvSTRYyF2Hnlt4vWJm4/WMJfLYWdnB+l0Gj/96U85hClaOOLX5uYmNjY2MDMzg9/+7d/mTSrN6TzNkMvlGB4extmzZ+Hz+ZgIATy+96WlJfzsZz9Do9HgAy2TPa6QjsfjmJ+fRyaTwbVr1zjHJ7KlTruCJuVCBcut6OnVahW3b9/GD3/4Q8Tj8ZZnWSaTIZ1O486dOwgGgxgaGsLY2BgSiQRCoRAikQiHD/c6o+K+p3+Th9hPoDMmhrK0Wm3LPGalUsGdO3fwox/9CIlEYpdyKBQKHBYUWa+k5EkGFItFNsBPCifCLyWhJVbhF4tFJJNJFItFVg70UCgvY7fbud8YJe6uXLmCQCCAs2fPMkOHCrA2NjawtbWFjY0NrKysNDEwiBYNtPZOOqECHwaUM9hPkdHviPNPlGy5XI5yubyrCSLdy/b2Nt5++20Ui0XODYiMHVpTyq243W4EAgGmdlJLjUwmg3Q6feLV+Uf9PIDHCn98fBwvvPACxsfHubsuMW/i8Tiy2SxkMhkn7w0GA+dZ3G43hoaGoNPpOKEveoinHX6/Hy+99BJGR0cxNDS06/cUgs5kMkgkEry/RajVamg0Gm7bQns4kUigXq/D4XCgUCjAYDDwmIK9BGS7/UAeFoA9IyHHAQpj+3w+fPazn4XX64Xdbm96DRlz4noQc06E+Jq1tTXU63X4fD5YrVYAT862zWbjOiCtVnvg9i96vZ4jJbFYjPObB7rvA//FIUHClBQK9QQKhUJ8eIEnwkShUDAnfGZmBufOnUOxWEQwGIRarcY3v/lNPP/881x3kEgk8OGHH2JjY4Nd80KhgHg8zhY/hZAofNbKYzhqYSay7dpRjYEnlphCoUA8HodarYbNZmNWDeVJCKQ45+fnsbKywh6c+BlizZDVaoXJZMILL7yAb37zmzyrpF6vI5FIYGdnB5FI5MSVSy8Kd/eDSqXCc889h29+85scjiwUCtjc3EQ8HsfW1hbi8Tg0Gg2THCwWCxwOB7xeL6ampmCz2fh3UsbYSVK5e4ErV67gP//n/wy3281eN4GKb8mYkTZeFK13s9nMozBoFMHm5iZMJhP8fj8LRb1e3zIELKLdeiqVSphMJgCP85AnRaSg3IhWq8W5c+fwR3/0R3A4HFzTQhC9jWg0iq2tLfZCRBA5KRwO4/bt24hGo1x3RTkW6sxNLWWMRiOHCzvdfxaLBZcuXQIA3Lx583QoFxLq0nkDRH2loiz6t0qlgsPhgF6vh9/vx8jICIrFIrvlTqcTFouFq4OBJ1ZAoVBAMpnkeoNWgok0PYCmuTHHYWl2+qDFEJVIe6V6nlav38/io/AG1QxoNBoWgtRvLBKJYGtrC9Fo9MSVy1GC9iTtPRKctO6UxC8UCrvi5JQ7oy/yWkQiBoUtTpJtdxiQ56XVarkDcqskdDqdRjKZZDaoeI4ojGg2m+Hz+WAwGDA0NMR0b9GjoVzXYb0NMiJPcr1lMhnMZjPsdjucTicrVilKpRJ2dnYQjUa5vU0riIawWLgrRTe1X+JaUeoB6L6+78iUSzsmFBWgWSwWKBQK5PN51rQWiwVjY2MYHx+H0+lEIBDgdghOp5Npd2I4aGRkhC1FshLIZb9x4wbS6XRTgk/KbFEqldyHjFhVQH+NGKWDViwWodFoEAgE4PV6kclkmthfnYKsG51OB4/Hg6GhIcjlcjx48IB/LpPJcPPmTdy5c4c3PHByeZej9ljsdjtXSdN6U4Hw3bt3sbS0hHA4zIQR+r3L5cLExAScTidb9GToiM1UicBCyf3TBGqnRO1vWgmzZDKJDz/8EDs7O9win5QrnXmtVouXXnoJr7zyCsxmM8bGxpjuTkWxer2eC6iJXtwJxGsiYgvt2ZMsolSpVHjxxRfx0ksv4cyZM21ZcBsbG/irv/orrK6u4tatW23fj7wZg8GAmZkZBAIB2Gy2JqNH7A4tyr92oOck/j+VSuHWrVtMIugGx+a5iJYcWShyuRyVSoWT8TRF0mazwePxYGxsDHa7HZcuXcLQ0BD33qGN12g0mBQgvj9tUspLSAWTqPhkMhkXCvZL36dWLBLgCTvGbDbD6XTCZDI1Me06Fb7kJVLHA6PRiEajgVgsxrHqRqOBxcVFzM/Pn3hiEDj6XIvBYIDJZGpKUlOoJ5FIIBKJMEVWFJrkRVJvLbHglF4nFqP2I6V7L4j3IBIcCCTsCoUCtre3sb29zeeI9rHoFbrdbm7QSFRmYj1RKFKlUrGn3o31TRb4QXIMRwWZ7HGTyZmZGXi93rZFjZlMBnNzc1hYWEA8Hm/7fuS5kMI2m827iBXShH4nskHaxLdSqXDIvds17Ily2atTMl0wHUaDwYDZ2Vnui7O9vc0Dh3Q6HfdzIpePwg0KhYKThaVSCclkEvV6HU6nk4uN5HI5CoUC7t69i5WVFY5b7lXLQo0G5XJ527jscbrWdBgpTCUeUCqsOnfuHC5evAi73Y5z585he3sb77zzDhMiSBGQYCACANFHdTodXC4XVCoVotEowuEwdDodzGYzvx54TAoQKbQnfVB7Ddpjfr8f3/rWtzA6OoozZ87w76lNx7PPPouRkRFEIhFEIhHI5XL2cIrFIu7evQuDwYDFxUVYLBY8//zzcDqdvH8tFgu8Xi8LzNNUSEk5UhrJkEwmed0AYGlpCY8ePcLOzg7eeecdRKNRbG9vN+ULiNVZrVaxuLiIX/ziF3C73chkMk3dycnLI0Xe6X4jL5G6UVCYnQT5SdcX0Vwfs9m86zponcrlMpLJJBKJxJ77g0K1oVAIb7zxBnw+H15++WVMTU3x+pHnEo1G2QhvdX5JZup0Ovj9fm71FA6HuX8bAJa5B8Wh57mIzKN2loaUUnvmzBmcOXOGO39WKhVMTk5Cq9Xi5ZdfxquvvopoNIqNjQ1m5iiVSt7kxWKRm9OJ9GPgMavq3r17uHv3LisXEeJ1i8oFaM8aOw6mkvhZRGKgeKp4DXq9HmfPnsWLL76I8+fPI51O4/bt21haWmqaLSK1rlUqFcd7jUYjhoaG0Gg0cO/ePWxubrLSIeUik8maWnafxlzBfiCPwu/349vf/jZmZmZYINH6GQwGXL16FaVSiZlz1BmiWCziH/7hH3Dv3j1W/m63Gx6PBwDYuxSVSywWQzKZPMG7Pjjo+efzeVYuFHm4e/cufvSjHyEcDuP69evIZDJNXYmpTRPty6WlJYRCIYyMjAAAj8egParRaLhXVqcGDSkmKnalz6Sc5EnSwBuNBisXavQrggxyMpjFrg+tQOHYcDiMn//853C5XPD5fLyearUatVoNyWQS0Wi0JWOPQLKbhpVZrVaUy2WEw2HOdQPgnDX9Tac4dJ0LaV7RQxEFOHk1dJC1Wi2719QjSCaTYXFxETqdjgcsxeNxbG9vA3jMXKDuv5RoSiaT/FlUTEltX3w+H1epb25u7lpQ8d+dFIUel1Clz6FwTL1e5/VzOBxMaLBYLE3K2u124/nnn8fo6ChPliRrkAQBCUS9Xs/Kqlqtwmq1skAQOfNUad5PxWi9hFwux+joKKanp3Hx4kXOu4khLXodeZG0v2ldK5UK1x2QFUj0ZXodhcFEpuJpA53xaDSKjz/+GGazmQ2Q+/fvIxgMIh6Pt6X80hkFwBGOcDiMhYUFGI1GzlPRDKJuerDRPhVbzlCu5ST3L8mrfD6PSCSChw8fwmg0clPYzc1NrK+v486dOwdiZFUqFZ64OT8/D71ej5GREczMzDTVC5LB2S7nQuc+mUzyKAlS0HQ9J5rQp4MjuqLA4wNKsWixTTYJrmQyiWAwCAC4e/cuqtUq1tbWEA6Huf8VHehWPXb0ej1+4zd+A5cuXeKQhlqtxuc//3k888wz7MW0gtQjERWiVHkeJ+hQUD0FNbCbnJzEn/7pn8LtdmN8fJzvX6fT4dKlSxgZGdk1u0EUkPRdLpcjEong5s2b7ILr9XpEIhGsra1xzoqEwNNQWS4FKYEvfelL+LM/+zOYTCZ4PJ5de0y07CjXRRZ4KpVCLpdDOBzG0tISK2IaGkYNLSn5n81mkclk+q5Dbyeg/XTr1i2sra015V4KhQIn3tuFTmq1GjKZDCeK5XI5tra2MD8/z0aSXC7Hs88+i6985SusqA5yfdRhmfap6G2ftHKhMSLxeBz379+HzWbDV7/6VQQCAfzoRz/C3/7t3yKZTCIcDnf8vvl8Hqurq1Cr1cjlcvjZz36G119/HX6/n7tRU+t+UtatvCa6vkePHkGlUiGRSDTNKwKaCREHWcueKJdWsTxigNCwIEroia4qzXug3l+lUglra2sIhULsebSqPxGt9nA4jGg0CqPRiFwuB5lMxo0DbTYbD7uijUcCWJo0F5WLFMdNZxRdezrYWq0WQ0NDcLlcvIYkDMkj6fS9KSbdaDSYSpvL5TgsRpYkbcrTaG23A+VRtFotvF4vxsbGeI/u9TeiVUyDqdLpNDcFBZo7O0iNl6eht1gul2tK1gOdCxsx/wKgaaw2KStqYLlXa6Z2aKVE+mGtqc4sm82yEZ7L5RAKhWAwGLC9vY2VlZUDk2bq9TpHeWKxGMrlclMtH+3PdoqFrg0AKxOFQtHU9uqw69dTthhdjNlsxpUrV2A0GrG9vY1YLAaj0cjJ91KphHg8zpsonU5jbm4O2WyWGy+2spYpHCGGdRYWFpDP57GxsYFYLAar1YoLFy5geHgY165d4w0sl8tRrVZ5HCpVwUpdPqkyo2aRh2nU2Q3oOiicSAWfh3ngFDtdX1/HT3/6U4RCIW70d+bMGVy9ehUajYaT0W+88QbefffdvgiN9SLvRYbH17/+dczOzjbN0WgHUhi1Wg3Ly8tYXl5GJBLB7du3kUgkuHMv1TIEAgFotVp+VvX64/kc1F6nXxiJh0Uv9wMZe8FgENevX+fOECe953qBer2O1dVVJiCVy2VoNBqsrq7CYDBgaWmJ61q6vV/aa1TAGovF8MYbb2Bubq5l3pkgRoQoBNZLz7pj5dLJ4SaLmyas2Ww2FItFpFIpaLVa5rqTZqX+YNRcMpVK7Sk8yWuha6nX6wgGg+z6yWQyeL1eXL58GTabDRMTE0gmk6yUSCuTMOkksUqUXTFufJwgL41mVBzGzacK6lgshnv37iEYDHK+wev1Ynp6GjqdDk6nE3K5HPfu3dszXnucaOVldgO9Xo8XXngB165dw9DQUEt6rQja09RF4sGDB9jY2MDbb7/N7YSAJy36HQ4He0F06MmY2oti+mkGPc9MJoPV1VUm7TwNoFwVtbcho3l+fr4n7y/KA/KoKfx248aNff+evPKDsPM6RcfKpVPWBnkIOzs77AoS24uUycLCAmQyGfL5PHK5HFPd9mI1yOVyLnQjAUnUZGqPIh35OzQ0hAsXLnA8PJ/PY319HalUCqlUigXnXvdGm+EkBCwptHw+j+XlZfzoRz/imdsWi4VfRxRlAFhdXUUkEmnJkiuXyyiVSlhaWuLNPjw8jEuXLnFdER0G8iL7xXrshHixFxwOB8bHxzE8PIyRkZFdLTjIy0gkEtzs9NGjR03t3dfW1rC6uopEIsFNGUdHR7nNxtjYGBwOB+cVHz58iO3tbdy+fbur9hmfBlBelggCdK5Puq6qlxDZc53sX8qzUhPVcrmM+/fvIx6PM8GHcn8qlQpnzpyB3++H2WzGnTt3EAqFuBi8k2s7qrxUT8NilCgtlUpYXFzkYkZqqkbDvlZXV1m4U+JtLyFP7WJ8Ph9mZ2cRiUS4MV4kEoFMJkMmk0EqleLiIZVKhYmJCQQCAVZC6XSaG1hSS5O93EASyMedcxFRKBRQKpWYbmw0GnH58mW4XC62uI1GI/x+PxqNBv7pn/4J169fbxlCE5OdpVIJJpMJs7Oz+PznPw+bzYahoSHE43E8fPgQa2trLZXUSeGw1zE8PIyvfOUr8Pl8OHv2LIaHh5sK7sgoWVtbw+bmJt5//338z//5P5sanYqEiVqtBp1Oh/Pnz+PKlStwOp1cK+DxeKBUKvGrX/0K3/ve95BMJpFOp3u0EqcL+0U8qCUM5Uy3traaJs4+DThI/kIcSfLCCy/gX/2rf4VMJoO//Mu/xP379zk/SDJNp9PhpZdewrVr17C6uoq33nqLPaV2EPf9UYa8j0S5iHkRmppGLiEdVLIG96ILikWAFJqiBKpU4xLdj1g56XSaZ23QpqV4JOV1On3gJ802IcFHsdlQKNTkSYm9sCKRCHscndwftXuhTdtoPJ5lTqSKflEuhwVVh7tcLu7/RWtEYdlcLofFxUXs7Oxgc3MTyWSybWdfh8MBk8nEdS3UAFT0njOZDOLx+K5Z6J92iGFIEqZWqxX1eh3xeLwvwrAnAZKZYl9FyrlarVbY7XYuhC6Xy9wZwm63w2w2QyaTIR6Pc/ucvXDYSEAn6HrMsdSVIkViNBrZW9HpdBgeHobT6USlUmHWRCgU4uQyDcORDskiWjM1p9Tr9Uin07h+/TpKpdIuwUfN8nQ6HW7fvo1KpcIt5Ofm5vDnf/7n2N7eRjAYRCaT6YqRchKgdaZxy+VyGffu3Wtq+UAV/QAOdDhlMlnT7PdSqYREIoGPPvoIt2/ffipyBLSfXC4Xnn/+eXg8HpjN5iYDZ25uDv/lv/wXrK+v8xx2Ytq0Onxerxe//uu/jqGhIbzyyiuYnp7m/VqtVlkpBYNBBINBfnafZkhb4tB3rVaLiYkJTExMYH5+HltbW09lwe5+oLwwFVBTtCcUCqHRaODMmTM8B4ZYnaSEzp07B6fTiWq1ikePHvGIiHY4rrU9Es+Fvqh3lcFg4LxIrVZrcu1o05ElKVUu1AVYq9UilUohGo22dDNrtRq38I9GowiFQrBarXA6nYjFYrhz5w42NzdRKpXYFTxNG5gUMFXf9gIirVsmk3FRYCwWw87OzlMTmiAl6nQ6Ybfbeb49hQfj8Thu3rzJTUD3yv1RjoDyNz6fDy6Xq2mCKtHoqc7g0ygs20HsOEHygnrlbW5uHqgC/GmDuCZkPFKRORWuUtkByVZquko973K5XN8Yzl2PORZBG4LYCuSViDUtRHujtvEajYaFl8FgwMjICHcmplnktMCUXM5ms3seVCoI+vjjj7G+vo4bN27AbrdjcXGRC7OehomAvQAdcBpdEIlEsLGxgdXVVebL9/M6kaUHtB53K0KsUaFWG6VSCXNzc7h37x5be3vtLZlMxsPqzpw5g2eeeQbDw8NwuVxQKpWIRCJYWFhAMpnErVu3EIvF8ODBg4FiESBa50TA0ev1TOOmVjAU+v40eXu0R8Wak2AwiOXlZahUKmZzOZ1OjI6OcvRIbGA5MzODr33tawgGg3jnnXeaijJFj/G4Sgt6OuZY7MBJHXZ1Oh17H2azGdVqlcM4VHxmMBgwPT0NvV6PtbU1RKNRbldCdRnUomQ/gZfL5XD79m2uXyBWWiKReGos8V6BDrtSqUQikcCtW7ewtbWFdDrd92tFsWlg747QojdM+4dm+zx48AA//OEPEQ6Hm3pitfs8q9WKQCCAqakpXLx4EV6vlz3gRCLBrVB+8YtfIBgMIpVKDRTL/w8xIkGRDZqCajabWbEQ65EMwU8TaP9Rni8Wi2FtbY0jNyRHh4eHUavVkMvluCjYaDRiamoKtVoNq6uruHv37i7lQvLwuAyenoTFpLUnYshJZChRHHBiYgIAmNJpMpngdDqh0WhQKpWg1Wo57k1VqJ2GsagiVqzCp/8fFk+Ly04kCaI8UmdUp9OJfD7fcjZ6v6HTZyGtlCcFQy124vE4Mxfb/T0Jw5GREVy9ehVTU1M8l4OoyvF4HCsrK0yooELgAZohzdMCj/MKCwsLXLN20mOJTxJSDyYajXJ3E5VKhVAohM3NTW7yKZfLufPx1tYWHjx4gO3t7V05F7FG7tTkXERXV2R/iWg0GigWi8hms7DZbPjN3/xNTE5Ocrv3arWKYrGIWq0Gj8fDian33nuPe9x0asVQHyNR4R0kFNaOOinGik87aAQsdaNVKpVwuVw4f/48JwxPA6RNJltBOgWSSBGVSgWRSASLi4t7tt4gNhONg/jjP/5jDuVQGDafz+Phw4f42c9+hlQqhWQy2XMBeVr3X6t6K1oX6jF48+ZN3Lp1C+l0GrFY7FMbuhYNcZoEm81meXSDSqVCsVhEMpmE0+nExYsXoVQqEQqFUKlU8N577+Hv//7vkU6nEYlE+H1pzxx3I8+eDwujCxdviIoa9Xo9DAYD7HY7HA4HH5Z8Po+dnZ0mxURNE7vpx0QCRSyS7MWCnraD3Q4i3ZEEL/Vqo1b/pwGd0CnFfZjL5aBSqdgIIkKJQqGA0WjkFhpi00TReCJavUajYUJANptlhZJKpZDJZI4spHPa9p+oDMnYIxlAOReZTMb9BfP5/FM7O6hTiN61SIKiM0l7lxQwRYSoEwoVAUuN/JNYz0NLETpk0iQRJU+pw/Hzzz+P3/3d34XFYoFOp0MikYBMJoPL5cLq6iref/99hMNh3mjJZJL52gc5qDQGWKfTIRQKMZXvIPfT7udPizXVynOhWpl4PH4qlAsdPqCzg7O1tYWf/OQnMJvNTdP7nnnmGahUKp618f7772N+fp7fkwwVhUKB9fV1vP3227DZbBgfH0ej0cDbb7+N+fl53L9/n8O4R7FPTuP+I4VMnaU1Gg2effZZXL16FfF4HPfu3UMmk0EymWzyHj+tioVA1HWDwcAhsaGhIRiNRly4cAFXr15lozyTySAcDjd5K9JR1N2sJxEAgO5HjPdEioibXqxmr9frXDegVqvx3HPPwWg0Ym1tDZlMhml1jUYDy8vL2NjY4JhrN1W6xH6y2Ww8p6SXVtDTsumpvoAUizh9ksZN9zsO2pInmUziwYMHMJlMGBoaYmU6PDwMk8mEyclJAMDi4iIWFhZ43xDLUSaTIZFIYHFxEW63m+sQHj16hOvXr2NnZ4dDu0eF07b/yCNWq9XcIHV2dhavvPIKNjc3edxGsVhkos8AaIq4ELOWhs4NDQ1hfHwcuVwOGxsbyOfzXDhJLV965eGKyqUbHFlYjECHLR6PY35+HjabjV1jqqC32+3w+XyoVCrY2dk5UPU8Hf6xsTE888wzMJlM8Pv93N6/WCwyOeA01rccBex2O15++WWMjIzA5/NBJns8uC2bzSKbzT4VLB06YERpr1Qq2NjYgNFo5EFfVMCn0Wig1+tRqVR4IidBp9NhdnYWdrsds7Oz8Pv9qNfruHHjBnK5HObn57G9vT1ghu0BlUqF0dFROBwOeDweHg9BOVcqOn2aOkL0AuVymYt5AXBdSzabRaFQQDAYRKlUQiqVQqFQQCQSYSITycVu5d1BjbdW6Jlyadd/i8JaOzs7+Pjjj+Hz+fDZz34Wo6Oj/HpqmiiTPR4mJCaj9r2B/7/dzJUrV/Bnf/ZnMJvNbJWStRmPx7m2oR/ax580hoaG8I1vfANjY2PweDxcQJlIJJBOp58KlhPF+6m9TbFYxKNHj6DX63nO+OzsLM6ePcvtWvL5PBf90gG12Wx47rnnMDo6ikAggNHRUSwtLeGHP/whgsEgFhcXOfR62sJWxwWNRoOpqSmMjY3B7/fz+STmE3VIH9QENYO6vcvlcoTDYSgUCmxubuKTTz5BuVxGIpHgIY0iuUUsUj3MmvbNPJf9itho7r1cLkcikeCKU+rFJGWIdLIgCoUCLpcLFosFPp8PVquVraJWOaCB1/IYRK6gEBhNBV1cXMTq6irXH51miPUtJPjpINKIbKqtoGI+sc8VgQr8HA4H6vXH43nD4TBisRji8fiRFfv1Yn7NSUPsKkHtn+r1Ood6qL6Fmt3SALHTfM+9Bq2h2AdPqVQ2Tf6kvnZELhFJESe5lseWuQ2FQnjnnXfgcDh43svIyAj8fj+y2SySySSP3e10QbRaLX79138d165dw9jYGJxOJ2q1GjY3N7lpYKlU4gSZVOE8DQe4G1AC32QyAXg8ROyTTz7BX/zFXyAajWJra+uEr/DwoMNIjDDqgF0qlXD37l2oVCrcv38fVqsVo6OjeP3112E2mzE2Nga5XM6zbxwOBy5duoRAIID333+fiSf37t3j6am9xkG6D/QzaNxuOp3G6uoqisUi/H4/NBoNXC4Xrl27hmg0ykp6c3MTDx8+fCo8515DHElcLpeZaKLX6/GFL3wBFy9exIcffojvf//7bPB0olyOUgYem3IpFotc07KzswOdTge9Xg+Hw4FcLse5kYNsLPJcAoEA7HY7CxNSVkRtHORadkOsAarVaohGo3j48GFTjPe0QyxIE40LohpTEaVcLkehUGCascVi4ZyMxWLhZqzZbJbb49B4h6PCaaMdtwJZ3ZTPozWr1+tQq9U8lI5GZkSj0ZO+5L4GMXMbjQZUKhXXpLndbgQCATx69Gjf8SVSHOU4kWNTLuJgr7fffht37tyB1WqF1WpFIpHA3bt3ua9YpyiVSvjoo48Qi8V4FjwVUZbLZSwuLmJ7e5tzLeJCkuYX3c79cNoPPFFqc7kcrl+/js3NTfbq7ty5w0y9p0kJi2MexKFNAJiNGAwG8cEHH8BkMvEcd4fDgUAgAIVCgTfffBP1eh23bt3isOFRWtdiMvW0PwtS5tTWiRQ30b9NJhMWFhYwNzfHA+wG2B9utxu/9mu/BqvVikqlgl/96lfY3NzkGiLyXvbLuRzlevdcuUjdLNFCzuVyPIZTim4OUaVSwZ07d7ibbbVa5SSuXC7nZpetvBYKPZCmP8i9nVZQX6dcLof79+9jc3OT6wsWFxcP7DmeBuw1ppkUazwex61bt3hORr1eh16vh9vtRqFQwJtvvonNzU1EIhFEo9Fj8YKfJiFLLFCivOdyOfj9fnz+85+HTCZDOp3m2qKn6b6PEk6nE5///OdhtVrx1ltvsXKmWUX9kHc59mo5ihMqlUqeGtktyCqiZmykXMhLEav7W7WhOGg8+7RbkcATcsXOzg7XIBFT7Gk62J3GkinUQGtBiigYDOL+/fsolUoIhUJcIDkIrx4cYiv54eFhXLlyBTqdDpFIBIVCoa0BOEAzZDIZ/H4/AoEAJiYmeA4ThR7L5fKuCv6nKqHfSoiLLSBUKhU8Hg+MRiNX5He7AI1Gg+cXSLFf98+DjB4VP+80g+45lUrh9u3bPFOnVqvx9MqjjMEeJzppL04CrVAoYHt7m4twFQoF4vE47t+/j0ajwWHVwyTXD1sxLX2P0wCREqvRaKBWq/HCCy/gj//4j7G6uop/+Id/wM7ODoLB4FNl2BwV5HI5XnrpJfzO7/wO9Ho9LBYLj45PpVLIZrPI5XLcNuuk69WOxXMRFcxRvPdhhCH1lVIoFNyj52mFVqvlpLVGo+EWEk9jruUgIO9F/L/YIaJX6/K0KO7DgJrUUng8Fosd25kTZ0SdZoh1afl8nglR5LkclaLW6/UwGo0dy/KOlcthKWtiEjUUCvGmOunD5nQ68fWvfx1utxtvvPEGPvjggxO9nqOCXC7HhQsX8Nxzz0Gn08FisaBareJnP/sZ5ubmmpo1in9DVb4nbQUdFO3CoftBDCf0em9K2yQROv2ckz4rB4UY86fw6//7f/8P9+/fZ+YdNVw8Dni9XkxOTp7aNjP1eh3vv/8+NjY22DOvVqvY2trigkqRGk855V7tm5dffhnf+ta3OlbQx6ZcCNRvrF9gMBhw8eJFjI2N4f79+0+ldUmhCY/HgwsXLkCn08FqtaJQKOBXv/oVu9CtSA+nLRRDOKmq5HZodT2fljorsZjy4cOHTY1BjxMmkwmjo6OnVrk0Gg2sr69jY2NjT+NHnDrZjTxr9TcymQyBQABf+MIXeMLwfuhYufRiMxzFhhIXsJtFTKfTeOutt2C327G0tPRUHnRi4SwvL+Ptt99uGjO9trbWNEFURLfW/wD749O8pid17zR6mhoynkZ0snaix9jNWrf6m0ajgXv37uF//I//AaVSif/0n/7Tvu8ja3T46f1qwdLozoOGbqQ9eCj528l7dPPA+mH9pO12KNdw3MnUfl8/qeXWbx7Gp4UQ0GuIbeS7odx/2tePRqLLZLKOWL79P7ijAxwmlNVoNPp+XnyvQJTFT9M9DzAA4TTmDvsJnRrfhI49lwEGGGCAAQboFKc3+DjAAAMMMEDfYqBcBhhggAEG6DkGymWAAQYYYICeY6BcBhhggAEG6DkGymWAAQYYYICeY6BcBhhggAEG6DkGymWAAQYYYICeY6BcBhhggAEG6DkGymWAAQYYYICeY6BcBhhggAEG6DkGymWAAQYYYICeY6BcBhhggAEG6DkOPCxMBLWv7rZlO7XApt6Z4vwBhULBE8/K5TLq9ToUCkXbyYitWqSLP6f2+mq1mmfH09Q26evFIVniNdHPurlfek+dTsezVHK53L7dnPe6Z5VKBZVKhXq9jlKptOu6DtIqXqlUQq1W88x4Wm+lUsmfLc6I0Gg0MBgMqNfryOVyLZ+HQqGAwWCAWq1GoVDg+z1sy33pXjyK3qu0/8SxBN3MC9pv1pBKpYLdbodKpUIqlepokF6/tNyXyWR49dVX8dprr2FjYwP/9E//hGg02tPP6BQ0eqPV0LtW6GYNpXNgOn2PvfaByWSCyWRCuVxGMplsGgUgyiHx/qRnjV4jjhTodB2Ax2ffZDJBqVQil8shn8/v+zedvHdfeC57bfq9pq3R9/0mJvbiUHXyOYd5z36ZFdFuUFC713ayyY7q3mgMc7+sXbfP8TCDnU4atVqt7STT48ZJf343aPfsW+2jve6PFAsZo4e5nl7hUPNc9hL8rSz/vV4ntbrr9Tqq1WrT39NrZDIZVCpVkydSKpWQz+fZ85C+P30nzV+v1w80wZIs+8OArGC6Hp1O13RtlUqF562IfyOd6U73JXoT4s/F++pkQ9JmLJfL/Jni9Uo/Qy6Xo16vo1AoNF1fK9D793L6X6PRgE6ng81mQ6PRQCKRQLFY7Nn7A4/3Gs286cRrkcvl7OVJ12wv1Go1ZDIZKBSKpvnn/QiZTMYjgmnvraysoFKpIJvNIpfLNb22U0FFBgLtpW5wHFNT9zN0O3mdNMJSLpeRTqebZJJWq4VKpeLoihi1aPXeSqUSCoUCRqMRVqsVlUoFoVCo7ZmQrjedZZlM1tM5Tz0fFiZOdwSaD6Y0TCMKKvHn9G/ptDhaDArXKBQK6PV6Fvok7MT3puugxaxWq/yg2s2YbmVF0Gjgw1rJdChVKhV0Ol2TQsjn8yiXyy03a6uwH02UBJ5sGHKfSTnvB4VCAYVCgWq1uuv1rQ46rakofFutCf2MrKleexdqtRp2ux2NRgO5XK7nymW/wVLSUKqoXEQrvpUwEPccHezTAFG50Lne3t7G9vb2rtfR9049W1EOdIOT8lqkxmu7591uuikZlOLP1Wo1dDodisUiK5e9FBaFcI1GIzweD4rF4p4Gl7jeJCtavfawE1gPnHPZ64NEYU4ehE6nYy1cKBSaNhAtGglv8kiUSiVqtRpbgPRw6HcKhQIajabJGlYqldDr9ajX65yjIWUkKrt21y1eTyvQFMfDCkn6DFIM9HCB5tGr4jW1eo9WP6P3OojVSJ/d6cFu5amIz4jyQ/QaOjjdjJUVId1/1WoVmUympRFynBCViNST3O9vCK3O1mEP9lGglRfd7nUH2YP7eb9StMqpngTIoADAnkcr7GVotPpZpVKBXC5HpVJpawCLf0+GZD6fRywWQ6VS2dMDka73QZ7VQdDxJEqFQtG0SNLQF71GDA3IZDIMDQ3BbrcjlUpha2trlwClGKFKpYJCoYDNZoPBYECxWEQ6neb3lcvlMBqN0Ov1UCqV0Gq1aDQaiMViyOVyfD2VSgWJRII1Pv29Wq1mN5SuQarY9ponL27obhP6IsQwmxizJiuYwn6tPIrD4CiFFil/UvCNRoOfHbnfQHfrR8l1Ohjiwd7ruR0VDqsQWoVs6cC3Cj+J6PbZ9UtuqhuI60Veuui5HxTdrKF0/Sj6AAD5fL5n51Sai+1E+YqRGqn3vNffEA66Hp28/kBhsU40nPga6WtJICiVSl4EEkAajYa9ElpUjUbDIST6W9EDEQ+lqNikiyZez34PqB16LYzpWsS459MCca2klm6v1lH0WPpl7Xq5R/rJYxlgbxyVbBCNjE7+5qAz7qWyktArT6Zjz4WsbNH9k1pq5InQjcpkMuj1emi1WrYy1Go1AoEATCYTYrEYotEo1Go1HA4HZDIZkskkstks9Ho9zGYzW/hyuRzJZBKJRAIqlQoGgwEymQypVAqFQgEajQY6nQ7VahXxeBzFYpEXe68ckJin6NQC7oXVs19eSlSioiLqF0hDYO1+1grd3EerMGE/ho66wUG9oE+j5yKiF2GxXp1h0XumqIM0NHwYdLvHW6UBWoWypb+Tej/t0FPPpdXGbPUB4oI2Go9rJqrVKifEtVotXC4XHA4HGo0G8vk8NBoNzGYzFAoFkskkCoUCtFotDAYDVCoV51eSySTy+Tx7MhSXJBdQpKZKiQL7afTjFlCtrqlV6K1V+LEfIHXb6avbMMV+6FTIdrtW+/3dUcWl231mPz3rfoNUCZ/UWjUajV25jU4NrIN8xkEg5j7Fsyl9z3aki16QK/i9OvVcKOZNykMsciQB3yr5RAKfwlYajQZer7dJcdRqNWbMOJ1OmEwmxONxbG5uQiaTwWazcY6F4vmpVIqVFvDYciiXy6hUKojH41wIuN8iiUKylaUhFaBAdwdfo9EAQJPrupfFKr2GXnou7bymg76HGJZsh1ZkiW4+j57/QV1/utZuP1f8eyp4I3IH5X7EPV+r1ZDL5Y6UZPBp8lx0Ol3Ts6dwKJ3tvSi6IqRyqZs1pBCVuJelheTi2ToqQ6sdfD4fpqamoNVqYbVaoVKpsL29jUgkgkKhgEQigWq1yga/6KWInpfUYCQcdP069lykD5FowOKBbyUARdYWFVytrKxAoVDg3LlzOHfuHFKpFO7fv49qtYrXXnsNzz33HN5//33cvn0btVqNPRW/34/R0VHEYjHcuXMHhUIBdrsdRqMRkUgE29vbrGA6PdzSa24V6muneA4Cyh+RUBI/S/w8aXis1+GwVqHAbg5Bq3WT/l+0oA6TfAWeKGcKd3YK0ZI8zDrKZDJYrVb4fD5Uq1WuTRA7KJCnTod3gMNBJpPBYDDAarWyUVmr1VAqlZgR1cle6JX3LyVZSEkZR+29twNdh9/vx5e+9CXY7Xb4/X7o9Xpcv34dt27dQiKRwOLiIhOlRAeBZJsow9udm4OsX8fKpZVr1WkdAKGVVqzX69BoNBgbG4NcLofH44HZbIbdbofX60W1WmUGmUKhQLFY5C8qnAQeCx1SLL0Uxr16r70srP08l1a/E4W3UqnkmhlSrPR85HI5M+zMZjOMRiN/Zq1WQzQaRTabZc+vWyHc7r4O462I6IQCu9e17fV3IltRp9M1FcuKLByXywWLxYJGowGTyQQAXGeVTCaxs7NzKr2DfgGtNUU3dDod7HY7rFZrk1LZ2tpCOp3m/d7JvuiFkdarvdwNpMxC8ex7PB5YLBbMzMzA7/fDZDLB5XJBo9HA5/Mhm80ikUhAJntcS0eph0KhwHT+Vjisp9d1EWWtVmPBTiGxdiAtSZRfOqzVahXZbBZDQ0P46le/CpvNBovFAoPBgEuXLrEVSBsjmUxidXUVyWQS4XCYi4WUSiWKxSLy+TzXx/QKvdpQVH0tzUmJ2MvKFpkjpKTVajXUajVMJhOmpqag0WgQiUSQSqVY8Wq1WkxPT8Nut+Pq1au4cuUKyuUyEokEstks3nrrLczPz/OatvJCpZZfJ2tBr+lV5TTttYO+T6vrlSY7tVotnE4ntFotJicn4fF4ADx5HkQLF18/NDQEnU6H0dFROBwOvPvuu/jf//t/n5qCyH4EsUaHh4fxR3/0R5ienoZOp4PBYECtVkOxWEQ2m8X3v/99zM3NccmBuMekIflWP+8WUgPxoO/breEhRgBIdlI5hslkwre//W1cu3YNbrcbgUCA0w0ymQxutxsvvPACy85CoYBIJIJsNos7d+7gvffeQ7FYZEO/VWqj2/XrSrnQh7dKSIvCsZ2AJNoxtTkwGo0YHR2F0+nkmzObzfB4PCiXy8jn85xLyefzyOfzTeEHCu8c1mtp9/B7sTH3ErKtrBKpMCcXViQt6HQ66HQ6WK1WtlRI0ZdKJS4sdbvdcLlcGBsbw5kzZ1AqlRCNRpFOpzE/P49oNIp6vY50Os3r2KrlTCvvdT/0ysrrFd1YavmRt2K1WqHX6zE0NASfz9eUiyOvplwuo1QqwWg0ct4wEAjA5XJhYWEBer0e5XJ5F9X+tOI4iSRkLJlMJtjtdoyPj2NmZgZarZb3NeVaHQ4Hyw6x8W2ra+/l9bfzzjtRGu0S6OLv6UssuaD3JwOHyjUoWmG1WhEIBDA7Owuz2Qyn08nygdaUIhaNRoMNzkwmg83NzV3lHa3ut9v161i50AVQnYrUQ5DL5bBarXA4HCiVSgiHw02FjGJS9Itf/CICgQCGh4cxOjoKo9EIv98PjUbDCsNms2FmZgbZbBYLCwvIZrOIxWJYWlpCqVRCsVhsKjA8TNhERLvEnyjwu4HYNkPsGkAbgDy5crkMtVoNq9UKpVKJfD6PYrEIp9OJsbExqNVqLlb0+/0IBALMtpPL5dwKha6XLEGTyQSv18shBp1Oh3K5DLlcjueffx6rq6u4d+8e8vk8QqEQfy4VnVKug55Pt12CewXRk6N77TTZTwp6dHQUfr8fPp8Pr7zyCmw2GxwOB4cO6XrpORENnwwilUoFs9kMrVaL559/HlqtFltbW/i///f/Yn19veMuxwe556MGtQNqNJ4keY8a1B/w2rVr+MY3vgGXy4UrV67A4XCwvKF2Q2q1Gi6XCy6XC6VSCQqFosnw2KuL+FGh0WhwVGavrsX0WvHfJAfozOt0Oly6dAljY2MoFApIp9NQqVR8hrVaLbRaLRvpGo0G58+fh9vthlqtbqoTBMDKw2w2w+/3o1QqQaPRIJlMwufzYWhoCOl0ms/1YUNhIg6sXKjNOyWCG40nDAOy6CjGJ1rABK1WixdeeAHPPvssPB4PvF4vC3QSuoVCAUajEQqFAul0GsvLy2y1hEIhJgbQ33RqPUghWmai5UA/E9HtZxBEpon4+dQ9QKVSoVAooFwuQ6FQwGKxNPUys9vtmJ2dZfaMSqXCxYsX8cwzzwAA50toPTQaDedarFYrvxcdPIPBgEajAafTiUqlgocPH0Kn0yGZTGJxcRGpVAq5XI6VVSqV4gTqYRRLrwSkNFRA73uQBK/L5cL58+cxNTWFr33ta/B4PLu6yrYLD4q/B4AzZ85gfHwcq6uruHPnDrLZLMrlcs+Uy2GNm05BIZdOe9MdFmSVq9VqnDt3Dt/5zne4vk18tqQsZDIZLBYLrFYr4vF407MXr18M7x4lSC6QUgb23oOtojm0BnRfL7zwAp577jmkUikEg0FotVpcunSJDR/KP4teR6t8LPDEWCBPh4gQSqUSdrsddrsdABAKhdpeY7c4cFiMFk5aTCmXy1EsFhGJRJqobh6PB1arFWazuSk8Y7fbodfrm4Q6WfEA2CKRyWSIRqPY3NxEoVBghhoAniUizmVRKBTQarVcAyM2hVMoFBgaGoLZbEY6nUYsFmNFJVo/0oN8WMVC1yoVUnRgRIuBaoHo++joKORyOYaHh5kBQtRsr9cLtVrNir5Wq0Gj0XDMVafTseUnvSdSMiRMXS4XZmdnkc/n4XK5OOFHuRuiMz569IjzXZ3Mo6H7FdeyFxCNEfqMvUJnohdCytlqtcLtdsNms3F7oFbKg7w3MgKkIUu6J6VSCYvFgmvXrsHj8eC9995DIpHYs+/UQe73OCB2Iz9qkFAdHx+Hx+PhfIEY1qH1zefzSCQSSCQS2N7extbWFuLx+K7CZzpTvShgPAhIkR3kOdP9a7Va2Gw2zM7Owm63Y3R0FC6XCwaDAUajkZu0Go1GaLVaViriPpSehXZKh7onA489RkozHKRJa6c4MFtMFNhiAkihUCCVSiGZTPLNqlQqnD9/HhcuXIDf78eVK1dgMpkwOjoKk8nUtInoBgwGA/R6PTe5lMlkWF5exu3btwEAVquVFUi9Xsfm5iY3lCTl5HK5oNVqkUqluD9Zo9GAXq/Hiy++iKmpKczPz+Pjjz9GqVRCJpNpYp2QNyZdzMNsVrEJHYUdaCMWi0VmyZhMJuj1euj1ehiNRszOzmJkZAQ2mw2jo6Mc57dYLKxUSAnUajVYLBaYzWao1WpWslJXWWrZAMD4+DhGR0c5bEfXR7mYjY0NxONxfO9732NqIz2jvdZFFBK9BIVtROt2r75wooVIazw8PIypqSl4PJ5djVAJZMCUy2UOhYn3QoKMEv9DQ0P4gz/4AxQKBcjlcty/fx/lcnnXKIVu7/mo0U0dUTegc6DT6fD888/j+eefx5kzZzjkI4Yia7UakskkHjx4gFAohLt37+LevXstuwYf1/WLoL1I/271+3YgYzEQCOC1116D1+vF+fPn4ff7ATyJGFHoXBpdEZWpeL7JoKT/i19OpxM2mw06nQ7xeJxzre3QbTnGgT2XdnkNEkbigVcqlTAajXA4HLDb7ayNyaKWQgzb1OuPpysWCgXeRKJVbjKZ0Gg8blyZzWabrov+TcKV3k+n08FsNrP76XA4kMvlUCgUDjSDo1uQByQqMTEkKP6cDpharYbBYGj6opY6+XyeQ2nkfREVWbRu2oVyaM1p3akoVvpaYuPJ5XI4nU44nU7O15xEXy9RWUmf+35/J64HJYlpzYi6LZfLWUiVy2XE43EUCgWuaxGZjwTRKKHYuN1u5z0Wj8ePXej1M2hva7VaOBwOLkGQlivQ88lmswgGgwiFQkin0ygWi7siDsfpqUjD592EiWUyGdOtHQ4HnE4nHA4HDAYDn19xXIW436gLMkU+xDpCpVIJh8PRckQIKXX6/MPWn+2FjpVLu4fYaDSaihZJMJIg9Pv9nHCipBOFIERItXE8Hse9e/ewvb2NbDYL4LGWt1qtsFgsmJiY4L+Vy+XI5/OcF4jFYlCpVDhz5gymp6fZulcqlRgbG2NGhc1mQyQSwZtvvolIJNJSuYhCox2r4iCQfobUgxHbSZAQI9aXw+GATqfjkF80GsX29nZTxXi9XkcqleJQjxhmEA8CfaY0Zi0F1cmQ9/SZz3wGHo8HH330ETY3N9lyane4RCXai/UTE7YHaVxJxg6Fb2u1GtbW1nDz5k0uzq1Wq1y3kslkEIlEkEwmcf36dUQiEZw9exazs7MwmUwYHh5mZUyHlBQuWZmXLl3C7/7u72J5eRn//M//zF50tziOnIv4OUchrOkc6XQ6eDweOBwOXLhwAc899xx37SClUqvVEIvFkEgkMDc3h7//+79HOBzG6uoqisViW0v6KDxlEWRgHCYvRedhenoan/vc5zA8PIznnnsOVquVozIi6GyTYohEIrh9+zay2SznQmlt3G43vv3tb2N8fJzlR6vPF6MTe62XNGXQKbouomz14dLwg0ajgcVi4UIo0sjtLpAEUb1eZz42zScgV4+8D4/Hwww1o9HI2pf+tlKpwGAwYHR0lOfVKxQKmEwmaDQaFr4UYhMPVLtQTi+SqlKvQfwZWcsipVoMpel0OrZGSGGmUqmm9aeBY7RBRcJDO+XSDnR9xE5TKpUYHh5GvV7H8vJyxx1bW71nt6BDKYYB9gvLEcRQCwBkMhmEQiHo9XpkMhnodDo+vBTjj8ViWF5exs7ODoxGI1wuFxqNBtxuN3fhBsDMRbEuxul0Ynp6GqVSqaVX2I84qjCm+P7EdDKbzRxBIDKFmIukc5tIJBAKhbCwsMBMxuPKC7WCaGh2u1a0j202G8bHx+H1euHxeGAymZqIM8CToYAiqSGbzWJjYwPJZJKN+42NDczNzWF4eBivv/46qtVqyzPayuPeC1JZ1Ck6Vi7SCXSiyyYeWnroVBNAAl06dVEELR4tUCwWQzAY5O7GLpcLKpUKY2Nj8Pv9zJwi+q7H48GjR484wUd1CTs7O/jkk0/4M1QqFcrlMmw2G9LpNOLxOJLJJDKZzC4NLk2IHTRZtx+oAEomk3FYjtaAOjtXq1VEIhHOwdC9kXCkAWyFQoFrVcbGxuByuVjJ0mYUuxvQsyMPgCybVu63NI7rcrmgUCjgcDj29Xqk6EXYkZ4BUavr9Tq2t7fbVhqTYqWQoUhTjUajUCgUyGazXA9gs9lgNBqRTqcRDoe5NVE8HofdbofT6UQul+NEK3U4MBqNbLDQ+VhaWsL777+Pzc3NrkcYSxPbR42j+gzaK4FAAH6/Hx6PB88++ywrYNHopDxXoVDA3bt3cfPmTaytrfF0xf0Uy1Gvk9gbkNoSiW2d9gOxQXU6HYaHhzE+Pg6bzcYGSKFQ4JB3KpVCsVhkWRiPx5FIJJBMJrGwsNAkOzKZDKLRKHQ6HdLpNPL5fNtwN/C4bxt1o8/lcvuOOD7ounasXEQrjQQWhVzoOz14ypeIFeQUzpEmpABwSKFQKGBhYQGPHj1CPp/nRJPH44HL5cK5c+dw5swZ2Gw2TE5OcghidHQUAHDjxg3UajUuNNre3kYwGGSPR6VSIZPJwGw2IxaLYXt7G6VSCel0epdrKLXgDqtcpNaCRqOB2+2GTCbjQ0PrRwPPisUiF4zZbDbm+dPmpnqfRCKBR48ecX3Q0NBQk3IhS5paP1CYrVVeRgxfSRUHse2sViuHFjtFr4QjGQEmkwnnz59nQUSh03YKhp4fKRq5XM75uq2tLWxubnLHbovFglwuh3Q6jVwuh7W1NWSzWTgcDrhcLuRyOZhMJqhUKjx8+BDb29sYHR3FmTNneF0VCgUWFxfx7rvvdj2GWUpWOAqh2cr7O6pwmEKhQCAQwMsvv4zx8XH8xm/8Bux2exP9mxR/LpdDKpXC7du38cMf/pCNwV7OeO8W9CyI6QXsPYlSChqKaLFYMDo6isnJSY5KAOBzGo1GsbKygmw2i8XFRSSTSTx69AhLS0uoVCoc3hUNYspzp9NpNpr0en3L69DpdHC5XACAcDjcUXeJI0noi8lm+j/dWLsaDgDs3lIMVRRi6XQa6XQa5XKZk3Srq6vY3NxsCg+RMKU5LkQIIFqpwWDgyl6RwUQeEQmVarXKeZl0Ot2k9aWHVwy7HAXq9ToXO5JbK1bx0/3TRotEIlhfX2clKZfLsbq6irW1NbY6Go0GF5vKZDI4HA4AT2ZNpNNpRCIR3sQUFgSeuPqiQGsF8oLaKaDjAnUZoH8fZNNLySekeCmMQASSbDbL/67Vashms7x+FNqxWq2oVqu7qKK030RGU6cgL5Gu9bi8lqOCSqWCy+WCXq9HIBBAIBCA1+ttWivgSQQjl8thaWkJoVAIW1tbyGQyu0akHwRSw65XEGXgQd6Xck5msxl6vZ7DzmRERCIRbGxsIBwOY3l5GblcDhsbG8hms9wXTJSPrULoZNi3C13TtROT8SiIOV13RaYwA1n3FKKi31PSq1gsMj3ZbDYzI6fRaGB+fh43b95EJpPB1tYW8vk8VldXEYlEYDQa2aqhugSdTscN7UhAms1mlEol+P1+XLx4EalUCpubm9z2nMIRNAo5lUpBqVRyNTwJmVZc+V5CuvmKxSLC4TAAMOtFVIpklYRCIZRKJSSTScRiMb52ANja2sL6+jr0ej18Ph90Oh3HYWdmZphaXCgU0Gg0sLq6ivv378NqtWJmZgYGgwHVapUVFtFxRSqo9Prb/V4K0RI9CsEYj8dx/fp1AOD76wREBKAwrkgTVigUCIfDTcqd9nm9XsfW1hbvly9+8YvweDyw2WyoVqscFqP7pvelmPhBDi8ZUQCYBt1LHJWwbQeDwYBr166x1/KZz3yGjUIpA6pYLGJ7ext/93d/h7m5Oezs7CAYDB6K1UTh+14xo+iaq9UqcrkcgM7bE1HEx+v1Ynh4mJUuRRdKpRI++OADvP322wiHw1haWuK9RB0y2jWYFRl4NpsNbre7pXIhWUN5xf2oyN3iwMPCxFCRGGYAWnsu5L5pNBpmbNENJ5NJbG9vI51OY319nZP4yWQScrkcFouFe2pRYaFGo2E2juiaEuVZLpcjGo029R0TWR10zSTExe+drkEvQKFA+re4fqLXRc36FAoFgsEgFAoFK8NwOIxkMsmhQ8p1EaGBvBDRUhdpy62+RFC+Qvy/lDJ9UqBK424hsthEOqfoRZIgIoUKNIdE1Go1GznU5w0AJ/YbjUbTMLuDoBfMur1w1Iwq8XOoS4TD4eCyBLHNDIEiGIlEAjs7O9jY2ODIRi+u4yhw0KJJ8iwMBgPnXcQQfL1eRyKRwNbWFqLRKEKhUBPBZ69nRikIosJLG64SaL+TbO6kJ2M3+6Vj5WK1WgGAe06JwkUUjrRQJMzi8Tg2NjawtbWFhw8f8sIqlUq8//77eOeddzhxVavVuD7A6/ViZmYGFouF8ywjIyPcGoI2ps1m4wOu1WoRjUah0WgQCoWQzWaRy+W4wlz0rEQGhnTRaAOQ4DkKQUrrQ9aGQqFoKlAloZRIJDj+n0qlmoSOWq2Gz+djj6PRaHDVudvt5mJKejZnzpzh7r/SqnT6e9Frk3on9XodmUwG2WwWmUymqQWQFK0MjX4L7VAokAQdUbxpP9OIbarPunTpEi5evAifzwen0wm9Xs9/J7bikNLWD3rf1C2cQmu9Rrv93GuFQ+ugVCq5bZQ0twKAFfqtW7fwxhtvYGdnBwsLC+z1HRStWJi9zFl18z50xpRKJUwmE5599llcunQJExMTnHCnJr3BYBArKytNrLi9PpP24OXLl/H1r38dPp8Pw8PDLRVLtVpFMBhEKpXC1tYWd0ffz6Pr5p47Vi7Ui6pSqXCoSbRgxbgf8MT1ohxAsVhEJpOBXC6H3W6HWq3G/Pw85ubm+D3l8sfNBO12O2w2Gx/iq1evYmhoqKmVCW1So9HIXZb1ej3C4TDW19c5p5PJZJBMJrmITVQu7TwuUbm0ovL2AiJBgIQYrS8dPPrK5/OctBbDUl6vd1dC1GQyweFwcBM8cTaJRqPB0NBQkyUuHb4lTX5Lf04zICgG3s5yk8aB+02xAM2dkcViNQrzUuza5XLBarXi7NmzePHFF2GxWGAymbiOSPxboDl/1c19EyHmONGKaNOL96S1FRU4gc4WhX1WVlbwxhtvIB6PIxgM8piFbu5DSlA4Li9tr8+hPaXT6TAxMYGLFy/yeHcxN51IJBAMBjuOEND7jo2N4Stf+Qp7h61AdXChUIgJLZTD6TU6Vi75fJ6FnlQjioKSDibRZ0Wm0traGhqNxwWSarUa4XC4KaGuUCjg9/sxOzuL4eFhnDlzhttFk7citabJGtBqtbBYLACAZ555Bn6/n+l8Gxsb3ESQPo+q/1uFfui7+EUHpReQfh7lflrF5kXri9rckJVMbDGTyQS/3w+j0chxXKI5SxWnKPRqtRq3fzAYDLzRpQeTvKxKpQKVSsWFhp0oDumkxl6tXy/fiwwT6iCt1Wq5Fx71cDMYDJidnYXH42GlLe3xdJrRSdjlICCarsVigdPphM/n48iD1Ksj6i1553ROD3MfJ4F2ny1lYwKPSSi5XI4N5ng8jhs3biAUCmF1dbWtYqH3Inmk0Whw+fJljI6O4tq1a2xUSmUVneNyucyeUTwe3yUT2l3/XvfXDh0rl1Qqxf8W4/j0oeLmlMsft3im2J9cLkcikcCtW7dQqVS4R1M4HOZEFTVdPH/+PL74xS9iaGgIU1NTzKQQmUwixLCE0WiE2+3GyMhIU1zx1q1biMViCIVCyGQyTD+WDhoiSL0aSva2qnQ9KFp5AyJNVeoBip6WWEyqUCjYm3E4HLh8+TJcLhecTidMJhMnhEXlKc3BVCoVrK+vY2trCz6fD9PT07zJxGdKuR8KWxK9cT/BStdKNPZeMFJ6aWHTeqjVajgcDphMJu6DNz4+jmeffZbzfCIDZz9GnRT96LW1Qq+uk9aGOhn4fD7Mzs5iZmYGbrebzzCd0XQ6zYxICmcfNp/WTxBDzxQNoVA3nYv79+/jL//yL5nQ1O6siN6gTqeDxWLBt7/9bXz5y1+G2WxuWX8mGoiFQgGLi4u4efMmNjY2WK6JHVakMqhbAsiB2790GuagnEahUOBCRUoekdAh4U4CUC6XM+uGFJMo0FsdZukCEM2v0WhwYtZqtcLj8fC1E8VU+j5Si138Lt57r9HJA2vlTVD9jl6v53Y71H9NbI5Jf0vhGtpkRBbIZDI8kI2q30UqLEFU7qKS328/dOreHzfIKNHpdHC73bBarfD5fFwtTeFbMm46USi05ifRmbcfIBoU1NGAPGlq70L7RZrPo3U7jlb5xwGpUqGiRbfbzbPrKa9C3SCSyWTbkKhM9njcgMViYQOP6trsdjsbQVIGHhmHVDQeDoeRSCSQz+dZrosKnyCmA7qRewemIotWY6ukLQk1iuPdu3ePZ16Tl0LUZGpVIoa23G43JiYmdnHgD2IlikwfmUyG4eFh/NZv/RYSiQR+9atfYWVlBY1Gg6nArSC1HA4bFiOPga5R+t7i9bd6jfTaZLLH7UXOnz+P4eFhuN1u2O129ixkMhlTFok5RzVCqVQKjx49QjqdxuLiIsLhMORyOYaGhmA0GpnBIn6WmBMSGzySMpKCDpbI6uqFwOilkqLw1+TkJL7zne9geHiYR0SQwhYVSid7kKjftLf7UakeFeiMOBwOmM1mnDt3Dp///OfhcrkwNTUFt9vd1H1aJpNxZIKUzl4kkZMGGVx7XZ8YtpIWKc/OzuL111/nfHKtVsPGxgY2NzexsrKCWCzGJRRSkIx8+eWX8cUvfhFGoxEejwd6vR7T09NNXeYJjUaDawmXlpbwk5/8BJFIBAsLCwiHw2xQNhoNzs2WSqUmr/Ew4dID9xbb60NExUMXLS4YWSVUlEY5BjGGqNfrOfbfqacgDeVIlZ7BYMDY2BisVisWFha4EK4TK1S0+g+bc2ll4YuC6yAPsNF43PWZeqtJx75SfJWEHXVKVqlUKBaLbCUlk0muRC8Wi2xR0WcQxIl/Ure53b0C6GvrnWqorFYrpqenEQgEOMd3EIiWHSlzWvNPC0QrXa/Xw2KxwO128+wmMRcg7nnpGe9V+PQocJCzSvJMVC5UX0aDAOv1OpLJJNbX1xEMBnnPtDJsSf54vV5cvnwZFosFw8PDPPdJ2uKF1pFSADSqgBL5okyma+11ZObAdS504dKfiT8Xhbw4jEZkQtF3UbHI5XKUy2Vks9ldnsteIAFKXWdpoagmhhKL9HCy2SxXeFNoSNqvSFRYAOB2uxEIBLquPxDfW/Ri6P+tXtfufehrY2MD7733HoaGhlCtVrlIlfIpZIGQh+H1ejE0NIREIoH5+XkODyoUCpRKJUQiEVQqFdjtdrYoxe4LZGlFIhFsbm62nDQqvQ9xr/Ri44rekhiq7XT9CDKZDHa7HVNTUxgbG+NQLNHa9wPdNwkDOvzRaBQ/+tGPsLa2hlu3bh1KsSoUCpjNZmg0GhSLRSbV9CPkcjlPP33++edx+fJlBAIBTExMwGAw8JwWUQmTATQ/P49Hjx5hcXGxrxWyGDIS70Mmk7G8oloykZ5ObFbqLFKv1xGLxVAul/Ho0SPcuHEDqVSqZTEweXfU1HJkZIQ9FlIqUqOXOpEUCgXcvHkTt2/fxsbGBlZXV7nnmFjrBmDXd+k1tPr3fjiwctlLWNCGEYsTad6IaJFI4/UivbZcLnPVKyWl94KoxCjMRbFdkbpssVj4IRG1d2dnhxVLu7469P5utxsXLlzoOqkvzXtIE2eU6Ov0ver1x4PSdnZ24HK5UKlUYDKZ2AOhtjFyuZxps5RUTaVSmJ+fR6lU4kIumltSq9UwMjLCCXu6X7n8ce+4jY0NLC4uYmtrq6WVJb1fQisyRjegvSKul5gHPIjwtdlsTcrFaDR2dHhEA4mmVFKxbzQaxQ9+8AMWGN0qA1ovirFTsWw/KxcKMz7//PN4/fXXmRYvMj1F0Po9evQIv/rVr7C4uNjXM2/a5Z3JW9NoNCy4yWAmpaLVapvmWMViMaTTae5SQl4EQfSS1Go1vF4vHA4Hh27JaBbPFf0N5XDS6TQ++eQT/PSnP0UymcTa2tquglTxb4DW51aU9UeiXKSW6H4JXLHKWXroWyWIyH2kee1yubzJs2n1GY1Gg9lfW1tbePToERqNBte+jI6ONiWmyQogBpBGo2F6rRi2k94nfc729nZP6MjStWvlxeynaEQBVygUEAwGuf6kXC43VfaXy2VoNBpEo1FYLBbuVk3CwGg0MoNP6spLr5Fqkrph8/Qq59LKW+omtyEaNe0+q5UXXiwWEY1GuS6hWq1y8Wo6nWZBS0ZSt/fZaDTYs5Q2Kew30Jmnzt1ELhHDLaLxSQZdKpXiSnQa+nfaQGkAmUzGIUGKnCgUCp5bMzIywt4aGYCtvH9RkNM5HRoags/n4+7JrcJYrc4ETdql5H2r6Mx+99YtDjXPpZ11SgKPXtNOIYlxWjrkND9jZGQETqezKR4ofi6FfqjB2507d/Dmm28yO0yn0+Gzn/0sXn75Za7NAJ60uieBCjwuxCRqr7T1B13z2toaQqFQp8t1oHUkiF7NXi0ZxNwH1arcunWLw0W05pTPEodkpdNp6PV6uFwu6HQ6Hp5G+RhSzNLiQBIKpLTEsc375eGkXu9h0K7JaDfYq5JeNIxIACwvL2NlZQXBYBAffPAB92Sq1Wq4cOECXn31VWQyGRgMBvh8PpRKJcRisa7vm8YCxOPxpj3Zj6BiX+pt5XQ6m4pTaQ3+v/be9Dmu7DwPf3rf9wXd2AECJAiuMxrODGdG0owWy7JVikvl2KnYcVU+pbJU/hKnUql8USqpVMVVLkeJLXlRPJIlj8YzEjlDDldwAwlibfS+73v/PvD3vjx90Q10N7qBBqefKhZJoPvec88957z781IrDvI0xGIxPHjwAHfu3OGEn2GHVJGhrK9isYizZ8/i0qVLAF48q0KhwFtvvYWlpSWubcnn84jFYojH48jn83uEBCl3VFxtt9u5DfTp06e5/5RosUjjzvSzTCaDQCDAa1g8I+i79EydPm+n6NktdhA6WSRiFbTBYODDnphkaUPRQStuePo5pfBFo1EuyiyVStDpdJwCLfpDaeLVajW7QaiYib4rCkn6Q4Rx/UArLUVcEJ3OMX1OJNATr0XXpxTjbDbLufXUx4F42eiZpSnI5H4SfeSd8hENCv26r9SaJoWF6i8oIYKsk3A4jGAwyIShmUyG1/n4+DhbFwaDAXa7HYFA4NDjG+YYhBSkgIjxBnF9k6AmBSUajSIajXJCyTAnfxwEOpdoT1FyklKphNPpxNjYGFKpFMfNxLnSaDR89tA16Ocmk4lbXBANUauUeJpfaSo3WYmHWUe9KoddcYuRRdIuD7sTlxnwUmOk3tFutxtvvvkmrFYrbDZbU1ZZLpfDo0ePEI/HEQ6HEQ6HuVqdNOlKpYJAIMCbnQgy7927xwWdU1NTkMlkCIfDSKfTGB8fx9zcHMrlMne3++yzz7CyssJjbDQazErbq/RuN0dSiId4L/faz9VGSKfT8Pl8MBgMHG9ZWlrC2NgYL3bKJgNexK70ej0fusR2sLq6ilAo1OSDbjfeTtfEcYA6HdKazuVyuHXrFp4/f84UGaVSCalUirNuyPVIzdmIat9sNrO2bjKZkM1mUa/X8fz58656fRBaxSeGcQ4JpGmTciLGV0mzr1QqCIVCCIVC2N7exi9/+UuEw2Gsrq723eUnavb9ElpS8lIpGo0X2bGPHj2Cy+XC1atXYbfbYbfbOS5nMpmgVCpht9shl79oc0zlAWtraygUChyoP3v2LL72ta/B7Xbjrbfe4lKBVmsDALvaRAUQAKcZi+1HpN9tJ0BE957IfdgJOhYuVJgocou1QicvkTR0g8HAWVhXrlyB3W5nokbSHnO5HNbX17Gzs4Pnz59jfX29ScpTII0C2WTRyGQy7OzswGAwcFBRpVJxhpTb7caZM2dQq9UQiUSQzWbh8/nw9OlTyOVyTskVW44OIkVStDJIo+n39QnEB0bCg94jZZmRhUMmNNW2kPZDQf9AIMC1St2OYZhASgrFkEqlEtbW1nDjxg3upUFM3WLRLR2kKpWKCUDJ3arX6+H1elGr1XDt2rU9bBadoFUA9SRo9aKbUTzEKCWWCvmCwSCeP3+OX//618zS0e91LwqXfgnmg67XaLzop+T3+7nx3MTEBHQ6Hc8H1ZBRuwsqqAyHw5yBSenFU1NTePfdd+F0OjE3N8exHOk96e9qtcrChdy1ZEWK76PT7Epah7TWu31HXXOLHdZM1+l0WFxchN1ux6lTp7CwsAC73d5UwEeZT5VKBdlsFhsbG1zsR+nGZFKaTCaYzWbux02BQqIqISFEhXEmk4nTdimgL6bqnj9/HplMBsFgsIl+XRQCvYISCpRKJR9sojtMXLz91OTocKO/qROew+GARqPh+1DcizQnom1JJBJ49OgRNzGi1quipdXJs/cjW6xfaDQaSCaTWF9fR6lUwieffAKDwYDHjx/D7/dzKqdIESTVzMkq9ng8cLvdzNCtUqlQqVRgtVpht9s51tWJgJBqkLQ+ToJgERtUSYtP6Q/1JspkMnwIdnpo0fU66c8iCvR+zV0n8UWz2YyZmRnY7XZmYif2B+qfks/nuZ2ATqeDx+OB2WyGVqtFpVLhzEXiWKQUefH8Ic9OqVTCkydPEAgEeH1qNBq4XC7OhnzrrbcQiUTw+PHjJsLZVkqP1FUMYE/Txk7RNbfYfm6dVgOUfsZgMOCrX/0qlpaWcO7cOVy8eBHAy1Q4Slskv2wsFsP9+/dx7949nhQibKMCuPHx8Sb6gmQyycE0ikXQ5qfe59T3pFAocMrgwsICrFYr1tfXEQwGubKdstYOczjSd6nvh5hxRdeW1nD0a1OQ1kLuRmpW5HQ6WasCwOm0lOlDYwkEAvj7v/97BAIBPHz4kDX5bsZI1x4mBINBJJNJbG5uIhwOQ6vVIhQKMe8c1WfR/Gk0Guh0Ona9yuVyuFwuzM7OYmpqCmNjY3wIVCoVjI2Nwev1sqASXQqt5k20WKQux2EXLpTVRKSmIl2O+FzU/oJ6wncTu6PrULIJeRVaoZfDsJsxSH9GcLlcOH/+PORyOba2tuDz+bC0tAS5XI54PM4ts589e4Z0Oo0LFy5gbm4OGo0G7733HrfRsNvt3K2yVUZjtVplxve/+7u/43q3+fl5jI2N4bd+67cwNjaGN954AyaTCU+ePOHyAbFZnjhfrdBoNLgHVLcK9qGyxbqBGLw3m82w2+2wWCxM5U8WBi3KcrnMVeSNRoM5nuiPwWBgwkHqACiTyThoXyqVON2YXhQVVZK7hwSHVqtFvV7ng1+lUjUdxFSdfpjFSi+GBAdpvvu9sH5prOKm1Ol0MBqNsFqtsFqtTbnyIjmnmDyRyWQQiUQQiUTYd97LXPTL+hOvd5jr0Bog4SFq3+QabTRedFBtNBq8yUkRoqQQyrCj7CjgJcedxWJh90QnY2r3zgdlvfQjk08MQIvFkuK1KQ5AqcfUv6mX+/YalzwsWiXiEEgpNhqNcDqdqNfr7GWhdGCK71UqFQ7MWywW7rtEf9PPxPbHdH/al+l0Guvr64jFYvD7/YjFYlCpVOw68/v9qFariEQinDAhloUcNqbbCbquCGy3uQ8yFykd2GazYXZ2FqdPn4bL5eKFSC6YYrGIcrmM7e1tfPLJJ0in0zCZTFheXobD4YDL5YJWq2WXjs1m4zRjEirhcBilUok1SuLhIXoU0kIpS02lUrH7o1gsQqlUcmrh+Pg4TCYTEonEvmylB4FeaD6f54w0CrSJhzUdQiJn12EOG1HTc7lc8Hg8mJqawuXLlzkDhWp/aB6JTTqXy3E/8zt37iAQCHCCQ7eWVb9SaWkTU4yoF9CaI2FgNBqxuLgIi8XCzNk0JyqVigksg8EgB/kzmQyUSiWmp6cxMTHBfXXovcjlcoyPj+ONN97AxsYGtra2UCwWW+4f8Z1L2QeA1jQp/cJhhRaNWafTYWxsjEkqxWLjUqmEQCCAWCyG27dv46OPPuLai25Ae4haTwwiBrofSKkgJYysI4VCAYvFAr1ej9OnT+Ptt9/mMyyfzyOVSiEcDnOmnEqlwle+8hWYTCZu7CVW8JvNZuh0uj0xHorpZLNZrKys4L/9t/+G3d1dBINBpNNp/p1Op8Pm5ib0ej2i0Sgr6YlEoi0T/H4QlZ5u5ryncvNuFqToJyXNhrJrKF+bNjoAfvh8Po9QKMTZE1qtFuPj4/B4PDAYDHC5XFCr1dxbgw4vajxUKpXg9XoxPz/P9xbHTVoodcakilc6IMiq0Wg0MBqNLfPRewFZRBQkE+dIOmftBLn4+058+HQvKvCy2+1wOp1wOBysaZKvluaQkiloUVJe/mHcdf2ywogctZeDUYxviQFLylQkDjZap1TARrxYpIEDYOZfslyk64OUqUgkwvfbz2V8kBAZhHCh6x7WcqG5IDYI0Z3XaLzIukylUojFYggEAj3VtIjW/3FAnCNR+RNdpkR7T4kg1WqV9w5BqVRyj3tq9UD7j7w7onAmIUbKbyaTQSgUwr179+Dz+ZrONGq/nc1moVQquXMsuWWPshC3a+HS6pDbb7C0IEwmExYWFjA+Pg6Hw9HkmxUlI03y2NgYLl++jGq1yq4qm83GFapkVpIwIK2gVqtx+qzb7eYAY6vOkiKoniGXy7GLrlarIRwOs0nbrzoX0SVDWp80mE8+Tvojjlc8FCkTRKz0pc+T4Lx06RJXCFMzsbm5OT4YqQ6IWBHoeW/cuIHbt29zTUcv5nSrOMJhIJr2vWRitYJer8fs7Cw8Hg/m5ua4ypw0SWpnTDTnsVgMDx8+BABYLBaMjY3BYrHscX35/X7cvXsXfr+/ZTq79POkBEiZgQfpBjrsNelAc7lc+OpXv4rJyUmMj4/ze6GWzU+ePMHGxga2t7c54aaXtTQMkJYMyOVy2Gw2OJ1OZDIZXL9+HZlMBisrK028hSIdzPr6OpLJJObm5qDX69ldTezQouAlyy+bzTZxhaVSqSYrhM5ASkSSy+XsfdiPB3A/SGN+A4m5iKDDq5s8cqPRiLm5OYyPj3PmFk2kqImT68rlcuHcuXOQyWQceKa6C/EhyaVECQDAi+A9BRhJi5JWm4vXoMmjlyMKl1gs1vTch4X4vGLuOxVSkUuq3f1E7ZYOQLGOgt4FCV6TycS9ur1eL7xeL0wmE6ampliokNUok8mYODSRSOCLL77AX//1X6NYLHKRWy/P28rV0yvI8qPnAzpPNZVaBvRvnU6HqakpzMzMNGXKkWVJYydLeXt7G6urq6hWqzCZTEwqKLUoQ6EQHjx4gEwms+edSmMSomJFMUfpATzMwsXhcODtt99mIS0WQFMA+9GjR/D7/U2umW7QbXyoH/GkVpCOXaFQcM+oXC6H27dvIx6P44svvkAmk+FaKEpZp1hwIpHg1HVSFMlVLgqNUqkEn8+HcDiMjz76CD/96U/ZOyOOhTJlaf0A4KSlXvafdP669dx0LFxEC4P+LVKVHGTiEguxUqlEKBSCyWSC0+mEVqvlgYsPodFoYDabIZPJuJaFtGvpBIjjqVQqSKVSqFarTYExvV7P9yDNgKruY7EYNzWjmEi7g70fkGoBYoCfDjSyIsTPkZCkhUraDlld9HetVuP5Jebfqakp7q1NVqPY15w0zXw+j2fPnsHv9/NB0GlGj2iBtjoU6T79msNetXlaK3SYAy+yIePxONxuN1sqlNtP2iClJtNc0xrK5/PQarWskNCGJpeEmFknFWziWjCZTLDb7chms5ypRqAYUD8guuh6Ffg0fovFApfLhfHxce4+S0ojgc4Iyr48TrfqIEDrkFzKFHCnZ6X9Ldbz6HQ6ZuIm177UO0Eu/mQyiefPn8Pn8yEYDLZ1b5EHQ9xnrbgdD/usnZ6DHQsXkqhqtbrJ4qjX68hms22FCw0klUrh8ePHCIfDmJ6eRjqdxvLyclOmlyi8yI9N92zXb4CEDWmxxWIRKysriMfjmJmZweTkZFNAn65DtQfZbBZra2tIpVLY2dlBNBpFJpNpsm76IVSkm038Px1UpNlQwFhaUySTvUgCmJqagtVq5doecpGRb7tYLGJ+fh5vvPEGrFYrlpaWYLVamzKhpPNJRZKRSAR//dd/jXv37iEajXKl+UGHEAk+yqwjTV2s1O5nnQu5Fbv9DvAyICs2BNvY2EA+n+fCXvpMuVzmdRKLxZjNluJSFKwlgsJqtYpAIIBUKgW/38+URLTJW1F3AC/mb3JyEmfPnsX29jYXFxKMRiO3sD0sxFqrdorUfhDf9dzcHN544w2cOnUKs7OzPHei1luvv2BHz2azh3ItdzvOoxRGVNidSCQQjUY5fZesdtpf5XKZ4y2Li4uYnJyEw+HgMw54eeZQcpLP58PPfvYzPHz4ELFYjN+Z9PnE/likiIt1ep1AqvTQz0R0eq2u3GI0aLFyu1NQ9ahGo0EsFoPJZILb7UYikeBMJSmpGqXh0d+tHpJMb9IUKasrFouxxVMul1lY0aQTJX06nUYkEkEqlUIymWRNkw6CQUH0p5NwIVeX2OlR6qOn3tkGgwEWiwU2m43jATKZjC2v8fFxTE1NwWw2s4YkChUpKpUK580T59N+SkMv6Jfld9gANNDsSqtUKkgmk1CpVEzvQvcpl8tIpVIckE6lUlwHQ9ooWXd0oCQSCcTjcSb4FNe01C1HYxGfrd2666eAPuy7IOFLQo/S2kVuOnKxUovzow4oDwqURSgyhZBlRlauNAZar79sHU71QGK8k7wp4n7L5XKs0NAfKmZvNYd0HtI6IUVPmnl42OSNTtGxcCEpTHQqlLEgNqVqBXoQ0gBLpRI+/vhjmM1m3Lt3D5999hmmpqbw7W9/m6uZy+Uy+7xJQ5L2USHNNRQKIZlM4smTJ/jss8+46jqbzcJut3NL0bfffhsmkwkmkwlarRYbGxt4+PAhtwAVsypyuRxnmNEiOSzEw0UaqyJ3C3XhJHeN6HelQ4kYZymleHp6motJxTmjToCUbr2fgG40Gnj27Bk+/vhj7O7uYmdnh4OA4tgPer5WHFr0rGTlDgOomRMdgJVKBZ9//jlMJhOvB+IWo83aaDSwu7uL3d1dZLNZhMNhqNVqJJNJrt8IBoOIx+P427/9W2xtbWFlZWWPYKEYlxiLokSU58+fc5dAqYZPdQr9ALmxe3WXEMMDJUKcP3+eedXENbO2toZPPvkEwWAQDx8+5Lk7qaAD+/Lly1haWsL29jY+++wzlMtlZk3X6XQwmUy8JiiRQ6lUYmJiAhcvXoTNZsPS0hLcbjeMRiPHVRKJBBdHFgoFrK2t4fPPP0csFsPOzg5bywe9MyqS1uv1SCQSSCQS7E0Q3cmt3j/9rNU5IfbH6gQdCxdajFQ4JmpsnX6fNL21tTUolUrmGVpeXsbVq1f5pRSLxT0+SClIG0in04hGo3j+/DmuXbvGh0KhUOAEgLm5OY43UMxhfX0d9+7dQyqVwubmJmd1UPUqxT/63aBJanaS1kPPShXzYqBd/C4VkJrNZrhcLkxOTnKNAbGoUtpsJwuB5jESieDOnTsIhUJIJBIdL2TptVp9ng7nYdBYRSFICgq513Q6HfR6PYrFIoLBIJ49ewYAzB/m8/mY/6lYLEKv13NRHPUmCYfDWFlZwdOnTxGJRPY8M8V6yLUktnYg7bQVyKXSDxw2uYIogqgZmMfj4eI9kVYkEong7t27zCZNsdDjxGEsNnpn4+PjuHTpEuRyOW7duoVisYhEIgGZTMbMFzTH4vPa7XZcuHABVquVSyrI9V+tVln5Jtf806dPcfPmTaTTaW4Wd9B7azQarFyazWa2Hsk1K7r793OXiZ4b8TsDES6EXC7HLpNefaAkqBKJBIAXE/t//+//5YVqs9mYZVas+qVFG4/H8fjxY6RSKebV2djYQCgU4mwvCq4B4A1Prjiz2Yy1tTX4fD7IZDIsLCxAqVRibW0NOzs7ewLT/XTnSOeDXGFidlulUmkqFqzX61xvQ5xs8/PzmJiYgMfj4eQHCvpKuZ32exdkeSaTSfh8PsRiMQ5Ai2PuJMGhnaneb46nflxHHBdtwFKphPX1dXZ/kXCgpmtkpdA7oX5CVAxHdQXi3JGLgrLAxJR4CvCKPxsW664dSDgSozkljVASBLmpSWjTOibX73E/32FdQo1GAxsbG5DL5djd3eUzhrJcy+Uyx1xEthByV9P8Ec8h7XlSHqiGSlqdT1mk7eZPTFIxmUyYnZ2Fy+XidUf9cw6Kv1gsFhiNRra8RGtZjKV2gq77uRBpoRg8EnHQyyNNHQAikQii0Sg2Nzdx//59GAwGfOc738Hly5fh8Xi4roDyv4kp2efz4Sc/+Ql2d3fx4MED+Hw+DpiJY6DCIXLJqdVqzMzMwGq1Ynd3F2tra3C5XPjggw/gdrtRLBbx/PnzPf7xfgT1232fgvQUzNdqtVxkSTUsJFzcbjfcbjcuXLiA5eVlJkakmIuYGNEJ6vU6Zz+R9UfxBbLg2vloRfdeq8ww8f/DYLG0As2tyKSdSCT2+KrbCU0AePbsGZLJJJaWlmA2m1nDFLniiNJDDLCSEgS8JMQcBDtwP0HvXK1Ww+12w+v1Ynx8nJl9aT2Q94Hc29Ikj5MKUgAePXqER48eNcVKKdFJTNsnN1Q+n0e1WkWxWOT5IwoscvtTvIZYC6iQUppw025cpKTqdDpYrVYsLy9jenqaa7Wo6Zw00UZUHuVyOZxOJyYmJhCPx/ckFUljQgehK8uFtD3RZys+IP3d6YEi3by1Wo17PRQKBTQaLyj1s9ks9Ho9s4Cura0hEAgwSzJ9Vrox6WcUeKvX6yyNqfaAfJ1EliktzKMEgH5qlaLwonmgWh16HtF1I/XZU0BQLH7sRLDQdeiZiUI/m81id3e3SWmgz0uvKRUkovBtpRW1++4wgd43rV3RVQXs7Z0uBR2e1GWwVcGaGNiVZvDsNy/9SBvuN8R1SMJDpK4RY6TdMh8PM8RzitYLCVx6P/R+xT1La4p6A2m1WlbexHVHaysej3OiESnI+82fVAmmc448TCLxpPgc4vjo55VKhamvDrtfuyaupIGKPxPdMPRw3fjryUVQrVZx7do13L17l+k3dDodpqenYTKZEI/HEYvFkMlk4PP5UCwWuUCo1b3EA5qC5pubm5DJZOwOisVi+Id/+Aeo1WpkMhno9XrWMmQyGftFKdDf64SLL5AWEc0ZCU1qXCbGBUiIi8JNdBlSbKqTLCLSPHw+H371q18hEongwYMH2N3d5ViLtMVAOwFDf0gTozmVbgKx8n8QLLX9glSIS39Hf4tKlEwmg9VqhdfrhUwmw+bmJjKZDLMgi3UOtGdI+EjdcuJ9CJTAoVKp2GUySAEtfc+tDjSaA/IoiLQ3VKJAXRjlcjmi0SgikQhbhsOqYHQCqdJBcVnxPKF9Ko1PUPLRrVu34PV6sbCwwE36yI1I17p27Ro+//xzpNNphEKhpsLqVhDdrzLZi9bGH3/8cZO7jawn6VqWKobhcJit78PGx3qif2mnnR7GhUQvJRqNAnhZ+avT6ZDL5WA0GtmNRpPVyWFFm1jk5hHdeXSgi5k8oqAkLayfQWk6lOkeJECIz4sObKnAEA990e3SSdCetBJyEW5vbyMQCODx48fY3NzkRdjKMgEOjr20Gkc/3YpHif3esfR3xOVEsRlyKYprRbSG6KAQ56TduhLX36AD4eL76UQIiO9cqgmL6e5Srfkko9UziK7hVp4G0ZNTLBYRi8W4uSEp1NT+g9ZGKBTC+vo6J450O3fUkls8H8S93c5yAV66NPuBnuhfpJCaduKh1OuiIusnn8/D7/dDrVYjn883uYw6hbi5pQuAfk+HvFhr02g0mGusXynJBJVKBZPJBADIZDLMlCya2sQ7RsKNMolu3bqFfD6P+fl5LCwstA3gk0BJJBIoFAp48uQJnj59ikAggM8//xyJRAKBQADFYrGtpdnu0KO/ZTIZH3ythP0gu3i2Gle/+MY6Qa32ooupyCpdq9XgcDhgNBqxs7PDRai0YVv10Gi3RxqNBq+9QdeHiHv3IOFKqbfFYpHJYYktgvisKCBMwWFpKcGrAPK4tJs3OhfJ+qxWq3j27BkikQjsdjtWVlaY1LJYLHLCyIMHD7rql0SfI/eZUqmExWKBUqnk2J6Urw7oPnOu28/35Y23chuIg+llU5AmT1L4sOOTmrQi9rOAqKCu31CpVDAajQDAQTypqUrChVJeyVx9+PAh8vk81Go1ZmdnAexlUqYDluhtUqkUvvjiC/zjP/4jkskkNjY2WKhIn1/63lpZqqLm3Uow0e+O0hUmFp72y8psB1pT1ESP0sOJYVkul3N6KgmJbsdDB8ZRohOrrVKpIBgMIpvNYnFxEdFolAWrXC7nYDDFSg0Gw560+lcBdEYB2KPc0f4jL4TBYEChUMD29jZCoRDkcjnsdju2t7extbXFrvhOBYp0HKL7lar9NRoN8vk8u/OlNVfSa3SCbop4DyVcRNcR+dVFfyPQ+uA5KlAGR7sCIinEA1Oq+RIlf6/uHZvNxqaxmJII7H1houZNZjFpH+VyGcFgEDLZC14njUbDlCVKpZKzvSgDqlgsYnNzE8lkEqurqxzA348W4qD31c37PEo/+0HvdxD3I6JAAByopXdWLBY52E+KgzRZYj83I/BSKz2KTp6dzlm9XmeF6Pnz57h+/XoTywYVAfr9fmbUpsy4VwFSlyahlbuJzh7av/T+KTuUMgi7pWnZD/R+xEQm6b6gv7u18LsZX9epyKLkI2lNtA+UTkc/k8vle9q7HgatDvZ2DyuTybhvDFF4SAuJpL5RkTKBfk+fMRqNcLlcPQuX+fl51Go1BAIBRCIRrmuhg0NqcZBfXgz2UuxoZWUFa2trWFtbw40bN+DxePDuu+9Cp9Ph/v37HEPJ5/NMRJlKpThxQErpfxBaxQc6EUCihTOIA19a5NWvzdkp6vU6UwiVSiXuK0RNmSgVlxQuaYZYO2tPzLYilxjVOR137Iq09Xg8jmQyiXg8jmvXrjV9hp6TlCGyoPv9bqSWwlGB0odbudtF65nWJcVTxKQW6vvi8/n6TotD70dcc+2UyG7u2e34+uYI7UUD7jdaueSAF1qCzWbjFGTSLKWTK3UtiSDNsV/mPcWUgP3nTnpgiloJpYI2Gg34/X7o9XoEAgEEg0GUSiWms6GeNOK1ezG9240V2N/MPmz8rRsc9ZoTCypJcJN1Kh44dBiRBnuSQYcq1Z2Jbpdhx2GEcyffbRd7kZYWiAwng1C8unFHi5l+rdzkvULW6PCpWmUC0d9i1ghdjrTKw1TltnqZoitBHLqU6Vd01506dQrf/e53oVQq8eGHH+Lx48dN7i86FKTNt8TrezweTE5OQqFQ4LPPPuv6Wex2O4AXWgy1OtXpdOw+kaYa7ifoKKtNr9czOafT6eT2zGShUOYS8YRJraPDupCkY6P5Ey2jVtXnvdzvuDX2g0DuyUbjZQsKOlTMZjOmp6cBANvb26xVSt1iUq+A+H5Et1ivccBBzOFxWQ+9QGwa2EtGlNhrRXoG7adMiW5OChnYbDZoNBomzD3OudPpdNzLKBAIIBQKNf2+1brp5Ew/tOUiDWrRphhENe5+C1kUcvQ3+TK1Wi0uX74MrVaLL774As+ePePNTcVNndy7VT+ZTkFUN4ROCT/p3q2+S1oyAOzu7kImk3HXThIuYrGX9HqHiYdIXWUkzEV3znHgKGM8IiqVCtLpdNO8kHZPRI8KhaJp47az6ER3C2FY64SGXaCIoDXaq5AVWcr3O1zbvU86myghYljmjuh8TCYTkslky8/04n3oWbjs58PbL1jZC7rhXqIXKWrnwWAQf//3fw+VSoWtrS2OY0j94O2qa4EXnGqBQGCgGjSxGrfzUUv/L01rJY2MirLEWARBtDAPej+trKf9/Ldi0aB4L/r3UWQMHdeGpecW50r0ue/s7EChUCCXyzV9p9W/vwwQi28p5tAK/bSMRFd0L6AxEuU+JcyI+0tsMif1foh7p5+xyMNeq1KpwO/3Q6vVIpPJHJis0PG4enWLtfvMQWms3UImk3FBIR2arUBas3jIEchlBjS76faLH0izxqQaaS/PcRAo7bhWq3FGl1ikJbVm9rNupM+w33toNzap6xNonr922kyr64nvoJfMoWF3ix2EVu+x18LcfrkxjxMqlQpms5mzy9q5qURvSD8tt15dszKZDHa7HRaLhfutiGcSUTORO7rdmPtJ69Mr8Wk7jwaAA8fVyfz1tbKJtOdBoddrk++713seNjbR7f16Qaux9dN67GZcg14HJxEnIdh9lJAebCcJYlx3v890co1hsFilCk+/3kvHlssII4wwwggjdIrB9fEdYYQRRhjhS4uRcBlhhBFGGKHvGAmXEUYYYYQR+o6RcBlhhBFGGKHvGAmXEUYYYYQR+o6RcBlhhBFGGKHvGAmXEUYYYYQR+o6RcBlhhBFGGKHvGAmXEUYYYYQR+o6RcBlhhBFGGKHvGAmXEUYYYYQR+o6RcBlhhBFGGKHv6JgVeRAMpgsLC1hcXEQqlcK9e/e418VRtsXtlNJfxKvYSVHEoOf/MPNHFOzd0ou3gth++LCth6kXD7WwrdfrUKlUUKlU3Jmzl/FSN1WR2fuwlPv97CUizmG7PvByuRwajQYKhQLlcpn7KYnjko5nEGtQZPzt5X3vt4fpPXXbeZe6t1KDRSlD8X5tRJRKJTdFPEyX14PQa3+XvlLut4JKpdrT+pYQjUZRrVZ5wclkMhiNRuh0OhSLRWQymY4nq1UPlk5RrVa5K+WXESL1N7VgValUyGazyGazfTuE+iFgu+3rsd9B2o8eISqVqklAifehw1bsjdGuP087iO2o+4XD9Fpq1Zr5IKFHB2er/uxyuRxGoxEajQbFYhHZbBZyuRwmk4nbdhcKhT29izoVjqQ8KhQKOJ1OeDyenrvJ7ode3hP1YKGurdLvi0pPu7WrUChgsVig1WqRz+eRTqdbnn/SXludzBv1XzqoH1Q7HIlw0Wg0KJfLeyYqmUwilUo1SWq9Xg+LxYJ0Os0HWycQ+4532ifhMM2/jgOD0OakLY9pser1etTrdeTz+Z4Xl3iPfnWibNe3pt3vWzWwEz/b7fWknyOLhVpPi9dsZV3ReDqd00H1Eepmf7SaU1FAHXStdpYh7Vm9Xg+j0QiZTIZcLgeFQsECp16vcyMx0aoha66T51CpVFCr1XC73VhaWhpIR9ReBMtBzcL2uyZ9j4QzNV7bTxkUG/51Mj6ap17X4MCFS61W4zam7bRH8d+lUgnZbJa7FXYqKMSX1OlEHGcrG4VCAbVaDeBFm9FOXB6HHa8ogMW5ooVO1kU+n2ctkzrrud1uAIDP5+M+250KO6n23g902vW0l8Zl3cwz9UaXtjiWXkO03IalhZLdbsfc3BwajQY2NjaQTCYHPjatVgutVotqtcoWSbFYhEwmQ6lU4nVSKBTYqyEqn4RuFB4SbMlkEtvb2/1rhiUcwO1cgt2Anq+bfUIKoEwmQ6FQ2Hdeuhmf9IzoycptdPitVi+kk83SrX9X6j6h7/XjYO2Xn7lXd4IInU4Hm80GAEin0yiVSl37a7sFadlif2/RHUbCjjajwWCAXq/H7OwsvvWtb0Emk+HHP/4x7t+/v6f1cTfox/zJ5XKoVCoA2Dee0c/33m48onAmd4XUP65SqSCTyViROMy4en0O6Rx+5StfwZ/8yZ+gVqvhz/7sz7CystJ0OPVDGIrKoUwmw9jYGMbGxpDNZuHz+VAqlVq2/KWf0XgoxgCgKcbQzXNTfAMA8vl8T88iQqlUQqPRAACKxWJX+0DqHqXYlTSG0um1+hWH7BSdrImBWy7dbp5WPeu7xbBpiMBwjKnVfNIm1mq1MJvNTYeBXq+HwWCAy+WCx+OBTCaD2WyGRqPZ45po5f4BhuMdDHoMjUYDKpUKWq226UAslUp7gtfHiVaWXq1WazoUD9N6t91+beVGk7oPpZD+TKFQQK/Xs2VdLpf3BLz3cy8BYNflMKAXi7odjlKodINDCZdBbtpeNU1acHK5HNVqtSnO06mfeRDPRVo2bYJyuYx4PM4/O2zcp5PDXHS90eI2GAzQaDSYnZ3F5cuXYTKZMDs7C4PBgEKhgEKhgLGxMbz++uuoVCq4c+cOEokE369YLMLv9zcFXQ+jZXYKMRAqXr/VATqITD26PmUJeb1enD59Gmq1mt/148eP8fTpUwAvrcFBZvUcBOkaXF9fx//6X/8LjUYD29vbe/bIfmOUWhYUfyKlkH5Hz0vWXCqVQrFYbNqbIsSsQNGys9vtuHDhAhQKBR4/foxQKASz2QyHw4FyuYxgMNgy8H/QcxwGtVqN3fc0B9245MXPivM4jIKiFwzccjlKiIFjSgvs9Tr9XpCUUSQmEQwikWA/vz9ZGKKbQq1WQ6vVwuVyYWFhAQ6HA5cvX4bNZkMsFkM8Hofdbsf09DSKxSJcLhecTidfI5fLIRwON21kqS96UGgXLG8X1+vHe5W6w2itmc1mTE1NQa1WQ6/XAwACgcCe4P1xWnLkiqFnSCaTe+JnnUIUIuI7F3/e6nAvFoscoO/k2vR/nU4Hr9cLpVKJnZ0dRKNR6HQ6WK1WFItFRKPRPfcbtHAhi0kc82Hu14kCLH1Pw+AZaIdXRriQtkzmMx1u+5nB+x1E/Ua7lMJ+odPrigcyBVNrtRrC4TCeP3+OQqGAy5cvw2AwQKFQwGw2Q6fT8fy+9tprMBqNCIVC8Pl8SKVSCIVCTW6ger2+R1M/LFq9q24382FjB2fOnMHS0hJ0Oh3cbjdUKhVr2C6XC9PT07wGa7UafD4f7t69i1qttqdOYb/xSA+qfq2ZXpJG9pt3MQlETGogIQN0n8ZKgopiEHa7HTabDXq9HvF4nK0hg8EArVYLhUIBpVIJo9EIhUKBQqHQZE20e4ZBoN9xPQJl1KlUKiwvL+Ps2bPI5XLY3d1FsVhEMplEPp9HLpdDKpUaGsvnlREulH2lVCphMBigVCpRqVS4MFOKfmga3aDfwqWXDSN1GTQaDXZ9BYNBrK6ucr2R2WyGzWbjGqVyuQylUok333wTly5dwr179/DJJ59Ao9Fgd3eXDxHK7um3b1s8wMSfic81yPcol8tx+fJl/OAHP4Db7cb58+fZQqHfk3VKbs+bN29CrVY3ZUt2AnIxAWhK8jjs8+0nXFr9bL89IrVQxDgKuaVp7L0cujSfXq8Xi4uLyOfzCAQCnFFmMpmg0+l4nsxmM9RqddMaFIXLUVgxgwIpeXq9Ht/4xjfwB3/wB4hEIrh+/Tri8TjW19cRDocRCoX6VpfWD5xo4SKXy2Gz2TiryWg0QqlUsqZdr9e5juaoLJR26Pf9DquFk8ZJmjaliNIGpQItyoAiS1D0hVOsSKfToVQqoVAo9OvxWo65W792L6DnI3++Wq2GTqeDRqPB6dOnMTY2xpq0VqttGh+BDtXx8XEsLy8jmUxia2uLD8aDxk8CShoIPyx6uVa78baKz0gD9N1aLRqNhufa6/XCYDBgfn4e09PTyOfz0Ov1rKkXCgXodDro9XpUKhUUi0UoFArk83koFIomRoOjBNX1UX3OYawIi8WCsbExdgmazWbMzs7CYrGgXq9jamqKharb7cb4+Dg8Hg+KxSISiQSKxSJyuRwKhQJbz1IMUuieaOGi0Wjw9ttv4+zZs+yWkMvlKJVKKJVK+Lu/+zsEg0GOb3QTsDxqHJXpTveitEy73Q6DwQCPx4OJiQm43W40Gg3OnSdqHMrKKZVKyGQySKfTSKVSKJfLcLlcsFgsqFQqSCQSAxmzmPbcjVunG8hkMmg0GqhUKly+fBnf//73YbfbMT8/D4vFAqvVCqvVCoVCwRlz7aBQKPD+++9jamoK9+7dw//4H/8DkUikqaZpv2c4LNVLu+v24/M0vlZWJADOkOtUgyaB7nQ6MTc3B6/Xi+9973uYmpqCXq+HTqdDuVxGJpNBoVDA6uoqQqEQyuUyKpUKSqUSdDod8vk8KpUK8vk8B9uPer/bbDaMj48jn89je3v7wPhSK5Clde7cOfzhH/4hnE4nFhcXef1ZLBY4HA6Mj4+zV4ESJEqlEhKJBP7pn/4Jfr+fk0qKxSJSqVTT2qMUZmAwTBCHEi79lHrSLJGD0uvIt0svc2xsDLOzs5yqWCwWYbVaoVaruQ7iKDTfXjCIbKb9IJfLOavJYDDAbDbDaDRyVTQtWK1W25QEIC5AElDkiqxWq9BqtWzpHOUc9ytQTynZer0eLpcL8/PzcLlcOHPmDKxWa1fp8TKZDFarFTMzMwgGgyykO/3+sK3RVpAe3L3EiWgfKxSKprT3+fl5zM7OsmVNRZf5fB6ZTAYAUCqVeK+XSiWoVCq2KEnwHJZdopPxi3EmjUYDjUbDlFK9gJ6ZFBu3243Tp0/DYrHwZ8TEESlisRi2tragUCgQi8UQiUSQyWSQzWb3KDbSMfbzfOxLKrLU79otFAoFdDpdE/VIJpNBJBJp8tvyoJVKaLVamEwmWK1W2Gw2qNVqZLNZ/p1Go8H09DQuXLiAVCqF7e1tlvDDkr0j4ijjPxaLBRcuXIDZbMb4+DisViu0Wi0HSUOhEHK5HMbHx+H1epuqqXU6Hce0JicnUalUUCgU2C0RjUZRLpeRy+X6GlhspcmL668bOhApSFBqtVq8//77uHDhAk6dOoUzZ87AYDBAp9N1LFhE11A0GsXTp0+5WHDQB12noMNcTLygNOLDuJO6fTY6lL1eL6xWKy5evIhvfOMbcDgcmJ6ehtVqZYFM7ldyA505c4a19XK5jEgkgnw+j0ePHuH58+cIBAK4ffv2nvTkw0C6R6k4VqfTYWlpCQ6HA6FQCDs7OyiVSl3HHWkdnj17FhMTE3jzzTdZqOh0uo6vYzAYcOXKFZw9exaXLl1CNBrFw4cP8Rd/8ReIxWItqbikf4sMIhQz7BZ9cYsddnOTm0Gj0cDlcsFmsyEYDCKRSLDGLL2XVqvlg85kMnGmiFqthtFohEqlwtjYGObm5hAKhRAOh9kaEidyGC2ZQcNgMGBxcRFOpxNTU1NwOBxNGU2JRALJZBIajQYmkwnVahWZTAYymQxerxcWiwVOpxPLy8v8u2w2i5WVFdy4cQO5XK6nCuj90EpQ0fujNdGrckOHnE6nw6VLl/Cd73wHdrsd4+PjbJl1o4XSGFKpFHZ3dxGJRFpmix0H6FkpUYMODQqg96PmqhuQhu71enHmzBm8/fbbMJlMcDqdTa5H8Ryw2+173HCxWAz5fJ7PA61Wi/v37/d1zqVp/iRc9Ho9FhcXMTs7i88++wx3797tmWVbqVRiZmYG58+fx9LSEiYnJ1m56RRarRZnzpwBABbAH3/8MX7+858jm83uGVsrRZu8G3QNWhPdjKMvwkV0mXQD8vtrtVrYbDb2d9ODkJ+fBIDX64XX64Ver4fH44HJZMKpU6dgsVj4YFGr1TAYDFCr1Zifn0ej0UAsFoPT6UQmk8HOzg4SiQSy2eyRcCl1ikG7kuRyOU6fPo2lpSW43W68/vrrMJlMMJvNMBgMSKfTiMfjyOVy2N7eRjabxdbWFlwuF2q1GorFIrRaLb75zW+yiwgAa42pVAqlUol5o47K1UfzdhirgCjhRWuYUj/3c2VRZlKtVmNGWqrJkMlknBJLGYxk5VG69nGkjNJciXFIoDkIP0iIyqHD4YBer8fZs2cxPT2N2dlZmEymplIC0d0m/i2+EzF1mawxcpkrlUpks1mu6D8MI7L0EKZ7FQoFbG1toVAoIBQK9TSHJKSMRiMmJyexuLiIsbGxtiSbdG8xOw/Ye/iTZSeXy2G32zm4L2bUtdo37YqUu0HfhEsvG1uj0cBgMPCEarVadh+Q5KSURplMhq985Sv44IMP4HQ6ud6A7l0qlZDL5VhQ6fV6OBwOvP3228hmswgEAkgmk/jFL36B1dVVbG5uIpPJHLqPRz8waAFHGtZv//Zv49/8m38DnU4Hk8kEuVyOQqGASqWCra0t+P1+hMNh/PznP8fOzk7TZlYoFJw0sbS0xOMulUpYX19nVxplsgyC1rwdDnMgkiuCmGXdbjcmJiaYSXc/wVKv15HNZlEoFOD3+7G2tgalUompqSnodDpks1lOirDZbFAoFEgkEtw7iIRPJ2Ps5xohTVS8Ziv38yBAVpPD4cBrr70Gu92O9957DwsLCxgbG4PL5eLDspWrvZV7UozbUJaWSqXC5OQkstkstre3UalUmlw9vUA6N/V6nWu7vvjiCyiVSlYcugHFajweD2w2Gy5duoR3330XZrO5pdVMmZrZbBb1eh16vb5tTK9cLvM6nJ2dhUajQTabRTqd5meQPhu5R6XZn93EHIEehIvogjjspiZpTRJbpVKhVCqhWCw2saHSPY1GI6eCmkwmDpxRXQFlqYgptpTpVKlUoFar4XA4YLfbmyp6X1WQUHE6nTAajZiYmIDL5WIXJGWFFQoF5HI5zgJLp9PIZDKsXYuuFEptFN0ouVwO2WwWxWKxKRvqpLgcRcuFrBEAfBBJn4E2bLlcRjKZRC6Xg9/vh8/nY2tbr9cjn8+za3FsbAxarZYFL1kwxzU/0vsOMgZJ+5eYDGg+KN6n1+v593RA0tyItTTttHPghcCkTDExeD2IDNFWtT1iAXEv16LQAMWLqQcNZebROZfNZpHL5XgNNhoNTsShdiUiCWa5XOakB+qp08kc9GOeuhYuVA9Bg+7Vxy2TyeBwODA/Pw+j0YipqSnIZDKEQiFsbm6iXC5zGh81ZPJ6vbh48SIajRccRXQNs9mMSCSChw8f8iEqTrJOp8PY2BhMJhMuXLgAk8mEcrmMe/fuHZsvXNwsg9AYibF1YmIC//bf/lucP38es7OzTE6pUChQKpXw5MkTrK2tYXNzEw8ePEAikeCURfHAodTOra0tPHz4EFarFU6nE+l0Gru7u9je3sb6+jo2NjaamH/7/Vx0ANGYDgMxQ2x8fJwpb+7cuQO32435+XnOhBPdM9vb2/jFL36BeDzOwiUcDmNjYwMAWJN8//338c4772BychJLS0vI5/O4efMmtre3sb29jSdPnnT0DIM68MW/B7EG6V2RZajVanH16lVcvXoVVqsVc3NzUCqVXMBbr9cxMTGBUqmEcDiMfD7PtVcajQYWi6WJv4xQqVQQjUaRSCRw//59fPzxx5y6LCaj9It1nDItKfWXrt3Neqe9TxaXTqeD3W6Hw+FgC0ipVHLrgUAggGw2i08++QSffvop1/YA4HKC119/Hb/9278Ng8EAu90OlUqFcDiM9fV1PH78GCsrK+zCBvbn3ZPGl+jvbtZI18KF0k8PGwynTW21WtklQeYeFT7WarUmIkq9Xs9+w1gshkajwZNIC4wyIURthw5TuVwOp9OJUqnEzXWOE4O0nMitaDab8cYbb+Cdd97ZsykbjQbi8Th8Ph92d3exu7vLvXRaaba1Wg3pdBrRaJS1ULHuhWpfpM/Y76AqJY/0C5QGS2Sd4XAYGo2G2xJIyTfj8TgePXqEUCjEwiUajWJnZ4fXrFqtxqVLl/hAnJ6e5muXy2V2jx1HoZ9UsAwSpOCRh2J2dpbjfV6vF41GA5FIhOeRYkHULFCn00Gn0zHli2jdEGq1GgqFArLZLCKRCDNGkDChOe7XmhHrvkT0ki1H80OxZyrMJWuFBBgpMg8ePMCvfvUrVCoVZtNwuVwwGo0wGAy4evUqrysqKk0kEojFYohGo4jH4wdmse0ndLpB18KFzFWRsK2bSRVN5Fwuh1AohHg8zmnH4XB4T7tY4MVk37t3D3/+53/OAVQAnMbo8/maCibFg1T8Wwz+HqfLRnQrDmIcVqsV8/PzmJubg8FgaOkvpTFUq1Xk83lEo1EuRGuFWq2GZDLJ86xSqRCJRBCJRBCLxVAqlXjT7RcsPAxIyB1GuRFdEeQ+pUzDfD6PfD6PUCjE80UU74FAAH6/H6FQCPfu3UMmk+HGaq1Sr9VqNUwmE9cklMtlnDp1CiqVCslkkt2Kx2U5S/3sQH9r1kgrt1qt+OY3v4mZmRlcvHgRk5OTXI1PTAYKhQImk4lrMq5fv45IJMJuoomJCbz77rscKxT7oVDsg4LV9HuRbaKfsVXxfKL13muzMBJU1WoVPp+PY3ikQBUKBcTjcfz617/GxsYGHj9+3EQnJLrn1Go17HY7zGYz9w+qVqvMH0huNxK4oqFAse5+omvhQtXvolXQrUlNmzufz/NBRZu0VZCdFtDt27fx7NkzlvJKpRIulwsmk4kD+kS1L9VuRD/psNQbDDIzx2q14uzZs5iamuIWsiKkWUO5XA6RSGTfRVav15FIJBAIBFCr1aBWqxEOhxEOh/m7op+4nxDdN+LPehEwtHYpaC/ShlAadbFY5BTiRCKBQqGAmzdv4osvvmjqkLifIKXsM6rPqNVqWFhYgNlsxvb2NvvFj1vJAfZS6B8GotdAqVTCarXiO9/5Dt544w1YLBaYzWa+N7nCbDYbSqUSIpEIgsEgfvOb32BrawsqlQoqlQqXLl3ChQsX2E1G36e1ViwWWbhQzJUO0n6nxVNfGGmCQC8CRowJ7+7uIpVKIZvNcnJCPp9HJBLBRx99hDt37iCfzzclgoj7mIQLkXiS4kjChaiM6PymGh3KDDt24SKilyCguBEpbkMZHu18onRQUfYCSXrSOovFYktzWXrfarWKSCSC7e1txGKxoWEP7Sdo87ndbiwsLMDr9e4pwKINWalUkEwmEQ6HkU6nD9wctVoNkUgEm5ubyGaz/H1yaYjdLY/bMtwPoiVLabHj4+OsFafTadbqyuUywuEwMpkMEokEdwyV9sYhyOVyLrzUaDR71iQdBsex9lr50dv9vxdI+eqIG2tqagpWq5WJJqUeBbVazdYHWY5i8FkM1NM1iHm6Vqshk8lga2sLPp+P6YcoRjjIuZZ6H3pRsEkAkHtMLpcjHo9jc3OT12cwGGybWahQKDA2Ngav18upyyJTtUaj4YB/K49TuyzBfrjGehIurbTIbkAvPJvNclJAuzx7WnRUN5BMJpvIKUOhEORyORdMihQkBLp+sVjEzZs38U//9E8IBoNDU9jWLygUCrjdbtjtdrz99tv4gz/4A1itVtYUgZdCtlAoIJPJ4MmTJ7h27RpSqdSB80Eplw8ePIDNZoPH4+FGTXQo0GLtt3XY6lqHvT5pjS6XC++//z5sNhuePn2K58+fc1A0m83izp07CIVCSCQSexh3pVCr1ZiYmIDVauXgLNUqkJujXVxLRD/dVARxHNJ9dlhlQCwdoISGCxcu4Nvf/jbcbje7Z0mjFuMNer0eGo0GqVSKXazkmqXGYtFolLm66OAk5XRjYwN/8zd/gydPnvAaFIPtlKHXb4WHslSB3t8TpYWTC1Wr1eLevXuIRqNsWZD7lTjWCBS3fvfdd/H2229jYWGBmU6Al8S+MzMziEaj7N1pNBrc7lx6/oo47FwdC3ElDbpTPyg9uBiYExcn+SeJV0gaqBdjC6lUijXRV0mwAOAgu9vthtvtxtjYWEuXWLVaRTqdZquDWGYPmo96vc5pniSIarUaWzGicBrWuRVdNtTa2Wq1wuVywWq1Ymtraw/NPRVIdsJqTIcrpcpLLRfRFfmqQHSBKZVKJpu02+3MAEGFkWJRIM0L7V9SAMk6FOMlRCmUzWY5U5QOy1gshmAwiGAw2OTeI0u62/qMbtCLS5YsCtH6EuNI2WyWm6GRhwd4mTUrWn4iv6JY3EyWiZgQJa67o4g/9yRcjuvgEH3s5XKZ+xwYjUZcvHgR3//+9+FwOOB0OvdsaKrlSCQSLMWHJfYCHC6riuIHRqMR3/nOd/D+++9zUWorl8zm5ib+4i/+Aj6fD7du3eI4Vyf3p4VImT30LkRrZVjmtBVoM+p0Orz77rv44IMPOPmB6ngo88ZqtSIej2NlZQXJZLLJN93KhUh+bLvdjrGxMQ6uijVB4jX2W3+DmMNBJJBQkFisuF9eXsbExAROnz6NS5cu8VxqNJo94xELUSmjKRaLIZPJIJfL8ZyR6yscDuNXv/oVMpkMyuUyswATn5fobhIxDOuSEkgMBgNee+01uFwuhEIhBAIBTqohd7/RaMT8/DzeeOMNtlwozT+VSkEul3Msb2xsDJOTkzCbzbw2yVKLRqNYXV2Fz+dr4hMT96o0sUNMEjgMThzlPj04TRQVqU1PT+PKlStMHyFqK2S+isWCwyZYDuMGoUNNr9fj8uXL+N3f/d2WmhotmHA4jH/4h3/AxsYGMpkMisVix/elz7VqV9trgP2oQBo2WRaXL1/G7/3e7/HBXy6XMTExwW5Xs9nM64vYI6ScXFJQ1hOl2JOAJ2tbTJEFjlZRG4RVSa4bg8EAp9MJs9mMc+fOsYCZnZ3lzCW6txiIp2A8WcRUwEtkqPQdSuOWy+W4fv06Njc3+Z2R61zKf9Xv5z1ojx609ikeZTAYcPr0aczPz2NtbQ0AOJ2fXHjUw+X1119HKpXCzZs3kUwmEY1GAbzkY6R1arfbOa4iugFTqRT8fj9isViT56fd3Bz2LBJxIoQLPTCZ28CLCdJoNHjjjTdw+vRpXLx4EQaDgfmggJfZG5lMBtvb2wgGg0yZMEwHYK+bwGazweFwwGq1Mivr/Pz8voVRtAGICaHXFMp2GKZ5bQViehD5w8hdQ2mzrTKQ6LuUDSc9SFQqFbRaLex2O5aWlnDq1CmMjY3tcWGYTCY4HA4YjcYmipOjAN2nH4cHzdfs7CyWlpagVCp5DrxeLzweDxcyS7M2AfD8lstlph2KxWJ8HdrD5G6NxWJYXV2FTCbjtHcSTtL9TO9HdMH1I8nkoO8e9HviRHQ6ndzYiwQm8JIvLJFIIBgM4tGjR9Bqtchms1hdXeU6NBIgVKV///59qNVqWK1WuN1u6PV6Jl2l7F4qbBYtulbnTj8F8tALF7EuhiYPeBE3MJlM+L3f+z184xvfYO1JXMiUMhiNRnH//n0Eg0Huwz1s6MV3OzExgUuXLmFhYQF/+Id/iLGxMRgMhgO/R3GSftPi96rRHSWUSiVsNhvXR1EfdhqjTPaiD0skEsHGxgYnOgAv3Y8AmrJ3KLBKMYb3/3/afpPJ1LQeKXmAXGcULzwo/jKIeEE791Gn31Wr1VCr1Xj99dfx+7//+ygWi9je3kaj0cDi4iIWFxdZcNN3xO+TqyuXy+Hx48d49uwZ7+FSqcSaN9WvpNNpvn4ntC4kXERB2s9YVy9r2mq1Ynl5GW63m8k6A4EAzxHxzQUCAeRyOWxsbOD69esol8vMhUjPTm60crmMn//85/jiiy8wPT2N5eVluFwufPWrX4XT6WR6p3bZuN26D7tZi0MtXGgDiEEwk8nEaaJE/U4Eb2JhVaPRQDqdRiKRwO7uLnw+H/d8oM+cdFgsFkxNTWFiYoItmP1ePrmyqGCQqoFFdw0t3H5qMMMw12Ign8hSyWUlDQIXi0Wk02nOXCIKjlZaMl1Xp9PB4XDA4XDAZDKxFS2F2GBNXNvHMUeHuaeYRkxKHWUgUW0KHe77rUnRpUuN2iiDieac/lBCRTcB+n7Oa69CXlx7NDfieiMhQecWJS8oFApOniGCWQJZL5SKDYAZTyqVCnw+H4rFImKxGHK5HLdc3k8g9/v5h1a4iORr9H+Xy4WlpSWMjY3h8uXLsFqtWFxcbBIswMt02+vXr+Ojjz5COBzGgwcPOAtjGA67w0Imk+HChQv4oz/6I27Bux+dDQXynz59ivX1dSZSJA00n88zGWMsFmvSdIYhGNoPUIbY3NwcTp8+DY/H0+S2qdVq2NjYwPr6OtbW1nD9+nWk02lsbW2x1igNxJNVPTU1hQ8++ACTk5Pc91ykjafvEOebSKx6kDbd77nvx/sU3Uz0R2zEJ2Y/0edFkEBWKBS4cOECZmZm2C2k1WqZAoYIacUxH2S1AC9dTNIxHwakjJGrrlOIBLrAC69LPB6HQqHA5uYmnj17xsSXpBRns9mmZ2lV50LWWCKR4Dqsra0tGAwGrKyswGQyMW1MMplkWqxuwwKi+7YbS3dohQtJevHflN7o9XqxvLwMq9XKfENS87dSqcDv92NlZQWxWAzPnz/vKnA97JDJXpB2nj59+kAacUrnpKyaRCLB7jMKVmcyGSiVShSLxSbNkdI5+x2bOWqQ9kgZhna7fU8Tpnq9zvQ2Ozs72NjY4NRX2tyiK0nUSE0mEyYnJ7nfEB0kUpDSJCpOJxG0Fkh7Jh4s8f8AOEYlFQYkgMhFaDQauYgyHo+zBk+xgl4EYr/d32K8rRu0iv9QUSiVBFCGF4Cm9sydxHmo9qdQKCCVSkGj0aBYLEKn07EX4jAu8F6t6751ouxH+hqZyOLGpEpfrVaLhYUFnD9/Hk6nkyt1geZFlEwm8Zvf/AaBQACffvoptra2uOL3JB+OIkTBS3MuXfC0yePxOH7xi19ge3sbOzs72NnZ4YVrNpvx5ptvYn5+nv29lOpYKpUQCoUQjUYRCARw584d5HK543jcPejVjUTZOhTQJ7oXqvvJZrP47LPP8PnnnyMSiSAajTJBIGV7EUih0Wq1UKlUMJvN3EUVANODkBChWg7KWuyWbkNaI9JvdBvkJ+VjZWUFwIvnjUQiaDQaCIVCmJqagtfrxeLiIrd4UCgUyGQyXGnvcrmaWIHJJSlmfnUzpk6e8TACnSyLbuM2CoWC3YS0v7744gvIZDI8f/6cx9YuPfggtLLqYrEYZ/JRK4n9sN/7p7V/rMKl3eC6AcUCyPqgHiwWiwWnTp3CuXPnOGtMLKAkky0Wi+HDDz/Ew4cPsb29Db/fP3TZYYeF6HKgZ2slXIir6Uc/+hE+++wzDuw5HA5cvHgRDocDV65cwXvvvddEZU/EeE+ePMGzZ89w//59PHnyZCiES69rjQ54hUIBo9EIi8XCwqVQKGB3dxexWAw3btzAL3/5y5aHiDjvtPaIWNFsNsPpdHLcq1wu84Eqjpu4ng6q9JeCKuAHZe2IAf5OxkSC8dGjR3jy5AkajRc0LTKZDA8fPuT2Fr/1W7/FwlytVsPv9yMQCMDlcjE7MlX0U5+SQfW5kVoQ3UKsju/2niKRZKlUwsbGBtLpdFNDrm5d0LQWpEXmlKItk8ngdDqZnLLTYL30M70aDX1zi+03gG6lHn2WtBqVSsUNdKRNdIiojjJKiGU5kUi0DGK9CqC59vv9uHnzJmw2G+bm5po4xAKBAJ48eYKdnR2Ew2FuFkQLkUgbSaOSptlWq1UukOu2h3wrUEO4fhyO0vfZDekiFe0lk0lks1ns7u4il8thd3cXyWSS2blbgYrgqA5GrVZjbGwMZrMZHo+nidepFYj5dmdnhwlbu7EUaK0PCjSWTvarGGehz9O8FYtFKBQKRKNRPHv2DHq9npl6qZZFpVIhHo8zrxbFoAwGA0wmE4xGI4xGI7M/9GMPi9l+h0E3nhrRTU8MxzQWUqJJmJInhpS7VvekFgTExL1fHxnK6jMYDHss73Zj7edZ2RfhIpr30gcQXQKdDJ78tbQQiFmWKvGJRoIySeh+lBe+s7ODZ8+eYWtr61g7/Q0StGA/+eQT+Hw+LC8v49/9u3+H8fFx/sy1a9fwp3/6p4hGo4hEIkzvQouYkgBEihLxDy1+yuI57KFG6ZftYhHdPLsIcnVRYLxVuwBx7JRJo1Kp4PP5sLW1hWw2C5/Ph0KhgGQy2XbN0EY1Go1MdPn6669jenqai9jIumkVUykWi/j000/x6aefckV5p8pPPxpddeL6EA/Odvej30kLQUkxIQvk4cOH2NnZYYZiYu212WzIZrPQarWwWCw4c+YM7/WJiQk0Gg1MTU0hk8nA7/f3zWJWqVR7yhV6gdhSuRNmC4odUQMzIpZ1u91IJBI89yT4iAiWQGtcoVBgYmICU1NTSKVSWF1dbarDavV5q9WK8fFxRCIR+P3+ttbXIM7Jjnd6N64IMb2TvicGQvfbUGLKHuW9W61WZlWV+p5poRM1dSQSYYbefgT0es2UGDQajQaSySS2trZgNpuZi4hAHT0pWCgNqJLV1ypmQ++N0iTJAjwMKAV3v4y2w6DdgUE/J3p0aixHWmQwGEQmk0EgENj3OWnDEm05Uce73W6Mj49Dp9Pt4X6Sol6v7+G268Zy6WfsoRP3yEHjafdvivdRAg3tZ5objUbD2U3EJ1av17nqnLwT+1mBvUAUnv24VqcQE0AKhQILZpoXYhQhxSubzTbtE3KtkeUsprLvNz7RFTyofbcfOhYuFBQSe6RLQQ9EGgptZLF5F/UOIVNX9BfKZDKYTCaYTCZMTEzg7NmzsNls+MpXvgK32w2v1wu73c73I82hWq1ic3MTP/vZz9jUtlgs3JujW4gvxWazQavVclZHrxu8E+EsLvz9rEG6TrFYRCKRwIMHD/Bf/st/gcFgYA2RGGJbCfJsNotHjx4hGo3im9/8ZlP7Arp3pVLBzZs38eMf/xihUOjQ2iN1YOx1Y9PGaycoRU1aBFkSDocDMzMz3MOdNiw9dzuuL9IoaS0Q6/Tp06dhtVpx7tw5LC4u8ljomq2CrOQCKZVKHTfbE+erX8Kl1XVEZVBkEJYqHgfR1tD+F3u6k1ClJmy5XA56vR6hUAhWqxVerxfT09N8HpRKJc7YE1Nyu4EYXxE58NLpdE/XEyEqZd28E/IGKBQKdstOTk7iwoULvJ8pK7FSqbC7kJ5FJpMhlUrh8ePHBzJs0LtMp9Pw+XxIp9NHzgLfsXBRqVRNWkk7kAQmXiby9dMEkeuCNjNZNDQZxFQ7Pj6OCxcuwOVy4erVqxgbG9uTctxoNNgnS1X4VCAopafuFvRijUYjTCYTqtUqkslkz9frVLhI2wW00rTo9+T2KxQKCIVCTC9CwrBd469isQi/349SqcR9XKQ1CVQX8+tf/xrlcnkPj1i3oDbIvUJMaZWuv/2yWUhJMBgMmJyc5OJJ+p1ombbbpBRnMRgMTLlDxJQTExOYnJxsmqNWtCO03snt240l2EumTrcQBQutQZGri8Zw0DoWA9jEe0V7h9ZrsViEUqlELBaD1Wrl1tikzRN7eTwe77minp6FrkvxoX50pGy1BjuBKCyI+p7YDCqVCtLpNPL5PAKBAGfNEhUOPQt1jN3PJSdaaMViEclkklsR0Phbfafd73pFx8KFDur9JpXcWNTZr1gssgZDJGuNRgM6nY4XmOijVqlUOH/+PKcxLi0tcTaJePjVai96ZhcKBXz++edYX1/HrVu3WFOnYKvYv4Ag1SbbgV5eJpNh99BhILoHG40GHA4H5ubmAADPnz9HIpFgvzOxDygUCsTjcXahiFoKbXSp+1E0g+mQkB5kGo0GY2NjcLvdXO8iLlbiIyINexjo4ffbGPuB5ogKbi0WCxwOB1czT0xMcIC9lQClin6dTgen0wmPxwO73Q6LxQKj0QilUsnCjawrsfoeAB8Y0WiUE03ExmoHoV8bnnz6JNzEMdMBTLxX4voRq7yJXJHWMQleUaicOXMGU1NT7D7MZrNcoEsMyna7HcvLy3A4HJiamoJGo0GpVNrT0qFXiALgqLT1/QLr5JWZmZlh96xcLsf58+exuLiIRCLBzc6y2Sxb45QwQWtJbHHc7rlIySS+MYvFwoSglFbfLm7WT3QsXDrRXI1GI7xeL/PjVKtVTE5OMkOsy+UCAF48Wq2WfdVEmfH+++/j/PnzLJRaFZxRB8RYLIYf/ehH+NnPfsY58qQtGY1GLioC9hKy7cczJMYkYrFYx5lI+0FalzIxMYHvf//7qNVq+NGPfoREIgGtVgubzQaLxYKzZ89Cq9Xi/v372NjYaGKApQUhBo5FzZO0HlHbp7HLZDIYDAbMzc3B4/HAZDLxfNDf5E6klqqiz/i4EiQ60ThbuZBIW3S5XHjrrbdgs9lgNpu5+yEA3L59G9euXePiPRFUZ2WxWDA5OYlTp05xTYvBYGCWZACcKiy1sJPJJO7fv49QKIRgMIhCodC0yfdDP+ebLDZKhRbb9NJ7npycxLvvvsvJHI1GAw8fPsTm5iYLGdFdRl4Cipfo9Xp89atfxZUrVzjLMxwOc/yPssEWFxfxz//5P4fH44HH42GFkzI9D2thtLMu+hnDkV63nfZPa8Jut+P8+fNMXqrX63HmzBksLy/jyZMn+PnPf46trS1mJmjnqj3I+6FUKrkwlSiJqJWBSGVEXqRB7elDZ4uRK4v6iVA2Bh2mFLASawuo7wAtYLVaDaPRyPxMRqORF6YIcimkUimsr69z//Z0Ot3kMqFUSHHipH/v9zziZ3otIJJCev9yuYxUKtVUzUzahEqlwtjYGPR6PXZ2dhAKhdi1SD5pmj/yaZNluR/lBmmjGo0GTqcTTqeTabrFmEAkEkE2m0WxWIRarWZ3wnEJlm4gviuKl5C2TMoMWdLAizmiinoxq5FAwoWynEhRorVO8RVpppWoGWYyGfh8PoRCIe6dcxzW4H5aqmhZU02Ny+WCXC7HxsZGk8tMPEhpfikTi4QHpcumUimkUimOIdB5QH+oGFoawKZxnoQ1dxBoviiFnQ59SrmmNUPeHtGq7Ypu5f8P9pP71mKxwOVyweFwAADsdju3HGnnMu8nDi1c1Go1FhcX2dVgNBqRSqUQjUahUCjgcrkwMTEBt9uN+fl56PV6poWmnG0yp5VKJWeFtYozEBHlgwcP8MMf/hB+vx8+n68p/TSfz2NzcxMKhQLlcrnp4G7lHhPRSvsQD4zDQGqi7+zs4C//8i/RaDS4R0OlUkEul4NWq8X7778Pr9fLLkBy8YncXzMzMzh79ixyuRyeP3/O/UbEhSm60khge71evPPOO5iYmIDT6eTqfKLe+PWvf41AIIDd3V14vV728x5WmxyU1tgOcvmLNq9Op5MZo3U6HTcLI6FJCo5Go2laM9T75eLFi5idncXMzAxmZmZ4DavVauj1es50IjcSJbFQgebDhw/xl3/5lwgEAqz9d2MJ98tipII9UciI61wulzPZocFgwOuvvw6j0Yj19XWsrKygXq+zG432hcVigdvtZq+FyWSC2+2GRqPB+vo6Pv74Y2QyGUSjUchkLxinp6am4Ha7m1xy5P7R6XRNgr9fGPTa208QivFkt9sNp9OJy5cvY2xsjOOe8XicLVtyR3fz/DKZjGPVVqsVV69ehcvlgsfjgdvtRjAYhN1u5+Z3wWAQQG+FoZ3i0MJF7I9BRY5kOZAGpNfrYTAYYLFYOLBqNptZe2nl3hFBG5HcXIFAAA8ePIDP59vzAohOHuhvps1hN7j0u7lcjjOwRAFWq9WgVCoxNjaGiYkJuFwuWCwWnlPqGw68YEX2er1IJpMIBAIAWrdCJYh1Q6I7goKd1N99d3cX29vbyOfz0Gq1vPFPAqTzTIFlqkEh7U6r1fLGov9rNBq2NkRaEqfTCa/Xy/QulAVFsQb6PL1D4mSj9sjRaBSbm5sIBAJdu1f7Oe+trCXR6qKEG2IfttlssNvtzN8nDTDLZDJuvCa6Csn9ls1muY6oXC6z1SzWq4nKHN3jsLVQwwiyXLRaLQwGAxwOB1wuV1M8i1zR3VpsNIcUR6T1SnucaHZ2dnagVquxvr7e9zTvVjj0W6xUKtjZ2UE8Hmc/P2UoVKtVbG1tIZfLYWJigqUrpXUSM694EEoFQrFYxObmJlKpFO7cuYM7d+7A5/MhlUoNxF8tanL0/0FpUI1GgwudpC5Av98PhUKBhYUF2Gw2dp+RJVOr1WC32+FwOJDJZDA+Po58Ps8uho2NDdy+fZtp9huNBl577TVcunQJMzMznEpLWjuZ4sVikQtRiQdKDCIeBoNycbSzLomIslarwePxwOfzoVQqwWKxsLDRarWYmprCH/7hHyIYDLK71e12Y3FxEVarFa+99hqcTienyRNturT4lOqt1tbWkEwmsbKygsePH2N7e5sD4d3OQT/nTEw1J8u2UqlApVJhYmICRqMRNpuNM9/y+TyMRiMuX74Mk8mEZDLJdEqUUmu322G329m1LZfLUSqVsLW1hUgkwlYgnQ0ejwdnzpzhQ4+yG4kxghSBVnUc/VTujhJijEr01gDg9s6UtdnLeUPzdebMGXz/+9+H3W7HwsICK/Ak7JeWlhCJRHDnzp0m99tB6FVJP7RwqVar2N3d3eNzJi1pZ2eHffh6vZ4PNAq+k1+31UKizKXnz59jd3cXP/vZz/Dhhx/2pVq5FaSCRfxZvyD1y1Mmk8lk4qQEmUyGUCgEpVKJ2dlZvPXWW6wtiumM1Jsll8thcnKSc+TpmqFQCNlsluniX3/9dfzgBz+A1WrFzMxMk0CjTLtSqYTd3V1sbm420YAPUwGpFNI5JTQaL9q85nI5BINBBAIBNBoNTE9PczYNHazf//73kclkcP36dTx79gznzp3DN77xDY4htKMNEdcKFQRubGzA7/fj5z//OT766KOmuNpxQkyRFnv3qFQqeDwedsOScCGCzYsXL+LixYvMqt1oNHj+KP5E7sByuYzbt29jZ2enqbUuHYAulwvz8/McaNbr9TwmsiDFBm5SnNQYTKPRYMtF5JwjRbzXOhRKqtBqtTh9+jS+973vcYGvWGdIrCZUIiIlBz3oHqQ8dYO+2J8iHYJUOxM1pGw2y9kp9ODpdBpqtRomk6nJNRaNRrG1tYVEIoG7d+8iFAohFAoNTLAA/Yuv7AdpYJ82nNfr5RiJ0+mEXC5ntw2R3pFfXFqoV6/XYTQauQJeJpNhcnISb7zxRhOF/pkzZ9itQ4ub0lIDgQC++OIL7OzsIJlMHorq/KjQ6vCRxsxoflKpFAvMM2fOwOFwNBVRGo1GbturUqkwNTXFLp5WjejEP/V6nbntotEoVldXuTndMCVCSOMrADiBZGZmBgsLC1zk6fV6ubaNXFUUiAbALaJFrisxa06n03GBZK1Wg9lshlarxfT0NFwuF3swxHHF43FsbGxgY2MDhUKhbfbVSQLFWjQaDafBE1UQKYmH6ZCpUqmwsLCAiYkJLC4ucrKKeJZSwk8sFkM0Gm3ZG6bVuMX3Q4pwN660vsRcyKylqlHRDKR/53I5BAIBznoyGAwoFArc3GZiYoInXC6X4/79+/izP/szRCIRPH36FMlkkqkTBgXadHRgDGJRSw9rjUaDy5cv49y5c6y1kcWWzWZRr9eZ1ZTGSIuHNCEiwKtWq0wNMTU1hffee6/p3uTWEUkqqZ7lxo0b+M//+T8jmUwiHo+z331YN3arlN9WFgytF7/fj1/+8peYnJzE8vIynE4nALCLy+l0otFowO12M2OB2KmS7iEqS7Rpq9Uqtre38fDhQ+zu7uKv//qvudXDMNQIEcQ1RF0jgRclBF//+tfxta99jYklKTYCgLPsSGAAYLcgxVap7gwAB/UpwUetVmN6ehpmsxmnTp3C/Pw8W+BiVt2zZ8/wk5/8hNuRUwyolVUqxbAKIplMxoW38/PzWF5ehs1mg8lkgkajgUwmayqq7Ua5JTfb9773PXz729/mZAGROkdUrh4/foxgMIh0On2gkFAoFE2p67VajZNeOkVPwqXVBOw3WFo8onZDlbhknlHxIE1KIBBg7S8SiXArz+PEoANgVFwmsgFIzVFx7smFQUkAZCKTu0faxlfkGCJtiUzyUCiEQCDQVxbaQaJVZh/9XIpGo8Gp38S0WygUeKNQsJXmr91BJdYGUK0W9QoKh8MIBALcA6dVzcxxgwRwK4gZTa2C96ImDLwULjQfNDekDIkEkUTUSGSpxIFH5wL5/xOJBILBICKRCCuhJyWRpB1oTZFwpt425I2gedbr9XA4HJwxelBjQ5ExgpJ/qAW8qAwVi8WmpmSZTIaFklhr1epe+62VTtCVcKEDilxgpL1RUZbUqiA/LElPOviAFxuVcuCTySRWV1c51bZarSIYDGJtbQ2lUqmp50E/0E47EGNF0t/Thus38vk8Pv74Y9y/fx9Xr17F+++/D71eD6fTydpzMpnkIjWqxZDL5ZyKTSmOGo2G023pQKDnFf+uVCrIZDJIpVL40Y9+hBs3bnDixTC5cVqBNo8YBxLNdqnlSc9CjLTxeBxra2vQaDQcsJfGC9s9P1GShMNh3L59mzMXqY1sKBTitO1htPqk2jH9SafT+MlPfoJbt27htddew9tvv81WBykprYgka7Uap6yLoCp/glgxTjVF5AIulUq4ffs2tra2cOvWLdy/f5/rPWitd4JWcy26/o4adFaqVCpYrVYuWBbpr5RKJdxuN6e6U6X+X/7lX+LatWuskAN7FajJyUl8//vfx/j4OK5cuQKXy8UCiz5fq9Vw9+5d3LhxA4lEAuvr6yiVShgfH4fH40EgEMD6+jrHeqXrgwSc2CdmIAF9GjQdsmIfB6ozaZdGTIMiVw79vFgsIpVKYXt7Gx9//DEikQgvLOmE9gviQSu9/n73E9Mv+4lyuYy1tTUoFApMTU0BeKHpUYEjpR6LTLFU2EkprlTkR2wHZM62Q61WQz6fRzKZxI0bN/DTn/70QM64YQGtP9KSxUOSrDRp4SttkGKxiFwuh2g0imAwCI/H0zKJQ4S4WYlJ2efz4c6dO4hEItjY2EAkEuFrD6NQIYjjEueuWCzi/v37WF9fh9VqxTvvvMPZW+RmFTnvaD7r9TrS6TR2d3c5bkXFl5RBRjVr0vR4ujdlmz548ABra2vw+/2cZHAYJl/xLBp0HLXd/em8I9YQrVbbtM9kMhnH+sbHx7G8vIx0Oo0vvvgCN2/ebFtsK5PJYLfbceXKFczMzGB6eppdmARSsHZ2dnDr1i1uJyGTyTA1NcUZqH6/HzKZrKnbqvRcJ4jsIJ2gY+FCm1e0WDp5YeSioVoY8j86HA7WzCmW0kvx0H5opY2KroGD3HvSzTiow5deWCgUwv3792E2m5FMJrnGhDQ8isGQG4IaT9ntduTzeaaXINeGdHNS0eD29jb+4R/+AX6/HxsbGwOLLw0CUquExk2WmlqtbhkgFb9HAli0RKUxG0K1WkU2m0WpVMK9e/dw+/ZthMNhPH36lIt6iVJjmAWLCOkY6/U6W62rq6v46KOP4PF48M4778BqtbJiSK0KqPK+WCzi7t27uH37NvdioX3udrubrB3pvsrn8/D7/UgkElhdXcWjR4/g9/tZaFEyyX5um4Oe8TgzHEnYUlyFKuJJYNO8SLMQTSYTPvjgA5jNZu7KKVrolFwxNTWF06dPs1JJv6c4KqW/b25usouW3OTkCs9mszCbzZwZKJ69/VjHXfl5Go1Gy5RK8bAWNycFn6nojMgSPR4PxsfH2V9IHdUoq6lfaBegF8cnHa80QCwGhge1WOna29vb+PTTT2GxWLCwsACDwcCHZCgU4uZAxHhMftSxsTHE43F4PB42waWUGhR3KBaLWF1dxQ9/+EPOnjoJFgtBFCr0PkgrJqFBjAPS79EaoEI22vhSq0VcA9VqFdFoFOl0Gteu5v9pNgAAPSFJREFUXcNf/dVfIZfLIRaLcSC2V6FynEFoqeJEQd5bt24hEongzJkznH1Eqay5XI6FKdWeffrpp/jVr34Fi8WCS5cuwel04tSpU5woIU0pprnKZrNYXV1FKBTCrVu3cOPGDVQqFT7gxBjOfvtuvzmUupKOcp5FthGlUskKtJhqDaApVAC8yML7/d//ffyzf/bP2Gshnl30faVS2dScjp6X6Ibu3r2L3d1dPHnyBIFAgBkUgBfJLaS82u12tsj77TEaSCkscQiJJIpiTrzYNKqVe6NfkAqXThfYcWmfhUIBiUQClUqlqfgJAAeJi8UiVzzncjmmhQmHw6jValhbW+MiLdLMRfcH1Q2lUqmBZ98NAlJFgX4GvHTBHmSJidoxrQtaJ2Q9Z7NZptkJBALIZDLY3d1FJpPhAPRRCOWjEkDiGkkmk1wKUKvVeC3SnORyOWxvbyORSHB/FplMxqnXm5ubTB5rt9t5r8tkMhYgwWAQ29vbiEQiTMcvZf3u13Mfh3uM3Epk8YneBwCcsEMsJbRficWAXOIUn6JxU+txMYuRGCGoEV0ikcDm5iZCoRCTVQLgYH42m+VMRrKq9osxd9sigtAX4SIGRInyhXyuNFCn04n5+Xk4nU6mkyAeI6rm7/eLp4BaKw2olQvkuN0asVgM2WwWSqUSjx49anIpiEE3MpXpuZLJJG7evAm1Wo2VlRVOF6X4Ay0O0gaz2SwikciJEyxAawtSdAdIm9ARxEOaNMJCocC0OkT94vP5EI1G8cUXX+Bv/uZvOLOsWq0iHo8jHo/3zUXayiUrFSbkWjpMLUQ3IEbebDaL//k//yesVitmZ2fh8XiQyWS4c+fKygqi0ShnIlGxLtGLOJ1OLC4u4p133mli4aDP7+7u4le/+hUSiQSXKIj7T0xB3g8H/b7TZI1O0I2gL5fLCIVCTX1ZgsEgVlZWoFQquX3z0tISzp07x6S9YlCe4l3i/URLhcIUmUwG+Xwen376Kf7P//k/SKVSHAckqn2lUolQKAQAXBxLrmQ6U0jBajQa0Gg03JgxHo/3lFTVF1Zk6b8pR5rqMxqNBmeKkDZONCY0MYPaONLAHnC85vJ+IB+rCDGJgP6WUrFQGifwQiOSxhIOSjk8SdjP/dHJASwKl3w+j1wu15QgkEgkEA6HmT6nH71FuoF0PYqH41GA0qsbjQaeP38Oo9HICko6nWbhsr293ZQVR65IKv4lHrWZmRnOXpTJZEgkEkgkEtjd3eWC3XYW9CBir0cFMYZMTBeUTCKTybC9vY1UKgW73Y6ZmRn+jvTdSwsZ6TmkyiJxAt6/f5+ta8pMI0FCbq9WhehiXQz9n+JBvSZWHFq4iOZro/EiHZRytcvlMmdJlEolPH78GEajEZFIBHq9Hk+ePMGDBw8QiUS470o/IPp521X0n5RDVhQInWhfUhP2MEHRkwzpYUzzkM1mce3aNTx58gS//vWv4XQ6eROTcMnlctjZ2WEOt6M+lGi8QLPb+ChA8Y5SqcQuq0KhgI2NDWZ7IMtGuqZojmnvr66uolgsNmnjpECRBdNpX5vDPE+/LPRexliv19m9Sm4r4EVaOyktcrmcG/eZzeammCLF/ZLJJCcF0DVJkESjUWSzWaytrSEej3M5B71LGvt+zdOkYYlyucwKa6/MybJGhzPWieZEGoJSqWQ+Jo/Hw33o6WfEb3Pz5k189tlnfbVa6P7S1Ml+xnUOE7wdYfDz10rTF9+71BpstS6OUqB0G1fpdWzdrkFpog7du9s9JN5XLOSVCtCjxHHsYdEKpRDClStX8Pbbb2N2dha/8zu/A4fDwWeVWGS6vb3NVnS9Xsfa2hp+8pOfIBKJsHA5Sg67TuavrwF9MbBKGkk2m+WgllKpRKVS4S6Ag6gEF6W+OKZ+Bgj7jePMGjopaOfSlP5M/H87V4joJqF1chLjT/1EK9dRKz41+n83aBfXHOY9eVhQuwZyRxEBLNBcDhGLxfD8+XNkMhlWwOkz5PqqVCocQyGBEwgEEI/HObnnsAK6X3EpEX3PFiMzjjJIarUa0uk0zGYzgJd9vFUq1aH70rcDSe9BTNggQJp0q6SDYR73UUKazipmy7Ryq7R756JlOyxsxUf9jlvtC5HdgD5D/v5+ZsaJgqrfzz1M+0WtVnNJQCgUYteS1Juyvr4On88HpVKJv/u7v2ui2hGTdsg9S++OYmOdpGsT2iljtCfovG5XuNnt3A6sKw89LHEEiYU6lAM/aA6rTq5NqX8UiJRWpY7QHxx1YLobDMuB1ApHYdVKk14GvSfbWZr9AAnJVgduq9bpg8ZBwXAxiSeVSrHSRM8gjfmJSsBRu3K73bsdCxepidwpKLhEnfnEfiQUFBwkDrq+yWTC66+/DovFwhQURw2pC48wzIdet9BqtdDr9T0Ll1bpx+3mrR1ErY80w2Gxavdz4bU7LLsFeQ2k9T3A3jVIWqz4s36gnwH2VqC+9MViEYlEouleMzMzOH/+/JEoOOVyGcFgsClL6yCIAqPd2tzP5d/J9dv9XKTzIkjjbMQr2Sm65hbrdqGJTLKUKz0Mm5lAdOBOpxM+n+9YxjBM8zEoEMdSPzd2t0FlcQ13K5gGif3mpJ8WXysiR7puu8LUQUAUYP2G2CpASnxptVpx6tSpI2mjLLZb7xb7KTy9vKNO64VaCRbpdQYiXPqhbYg+w2GJhRSLRTx8+BAmk4nTBEfoL6gINJvNHptbrNU6O+61R9hvHKIg7GZjt4LUEmklZMVeP4OOR4lCph/nQaPR4DguBdBFwRyJRHD79u1DEWIeFp0c9NL4Yit0M0+9ZsaRpUtckq3Gt+81Gh3eWVrIB/S+OcWA1XFm6UhTAzutaej1Zb0q6MYv30rr7iU43PGCHqKg7kHoxhtA9CAymaznFhTSFOBWIDZkKgI8iv0psn2LjMH7jXW/9yxNoZZarQB6iq0Oynps9RlpNuNRQ6lUcgvqfD7PDfSo31EnVtng7cMhx3G+wC8TTsqBP8zox+H2KryHg+ZBTPUVP98v2p6jQCvheVyKU6/rrmPLZYQRRhhhhBE6xfE5H0cYYYQRRnhlMRIuI4wwwggj9B0j4TLCCCOMMELfMRIuI4wwwggj9B0j4TLCCCOMMELfMRIuI4wwwggj9B0j4TLCCCOMMELfMRIuI4wwwggj9B0j4TLCCCOMMELfMRIuI4wwwggj9B0j4TLCCCOMMELfMRIuI4wwwggj9B0j4TLCCCOMMELf0XUnyn7CYDDAYDCgUqkgnU6fGDrsYenn4nA44HA4UCwWEQwGuRd3N9BqtVAqlahUKiiVSj2Ng/pPSLsZtsOwzN9JRa9E5qM5fIlhWYNir5nj7m0FHL5lsoiB93Ohvsv1en1PZzvqFkc9vXuBXC7vqsd4q8ZEJwHU71zsP5PL5Xhee+0aWK1W285dq3u2gtj7e4QRukWvLdRfBYhdQYdhHP3EkQgXpVKJWq225wCsVCo9dYQTQW1Zgc4kP42nUqkcu3DpZlPRQU+fbzQaKBaLKBaLhxpDtVptq5F1I1xGGOEwGAmYVw8DFy5kIfTjIDcajexGS6VS3Ja4U3cMjadarbb8fL96eQ8Cg+yYuV+7WBIuJMDFNq3dzPsIwwU6zMX32e27FDsjqlQqmM1myOVyZDKZA5UeuVzObZsP47n4MgulYcehhAsdPPu92Gq12nFv+v0gk8ngdrsxNzeHRCKBx48fo1AodC249nMfyWQyduEdt1UjBbkPjxLkcgReWHwymQxKpRJyuRzlcpkPkNHGPlkgpYEO+EajwS7qTiGNs+n1eiwsLEClUmFtbQ3BYHDf7ysUChiNRshkMuRyuZ7ifaLyM1qDg0UvLZYPJVz6GfzpFO3iAwqFAiqVqulnB8UiWi3M0SJtDTHwOMLJhvge+7ne6bCn6+t0OlgsliYlhX5HwqXRaCAYDHLsb7T/Xh0ciXDpBxqNBkKhEDKZDCqVyp7MKLvdjunpabY86vU6/H4/QqEQGo3GHvNZpVJBq9WiXq+jUCgM3M3Tynwf5o1EWmmlUmk6HEhYkzUqPsMwuxVHACtf5IYS13y3bql6vd6kzZZKJfh8PiiVSuRyOchkMnzlK1/BH//xH8NkMsFgMDS5Vmu1GkqlEjKZDP73//7fuHHjBkqlEorFYldK60ggHQ16meOBx1z6iVwuh1wu1/J3Op0ObrcbSqWSN00qlQLQrHXTJJGlU6vVOHtM/H2/MShtcRAQ54rGSnMoHkj7xWqG/Rm/jJDGywAcytUqvuNqtYpMJsMuU7lcjvHxcXzta1+Dw+GAxWKBWq3mtVUul5FMJhGLxfDJJ59ArVb3NJbROhtenCjhQqCDTqFQYGxsDEajEWfPnsW7777LC7hWq0GhUCASiaBaraJUKu3ZDMViseMU5sNiWFIOOwHNr16vh1ar5Z8rFArY7Xbo9XoUi0Vks1mUy2XEYjH2mZ+E5/uygg7vQaz3er2OUqkEhUIBg8EAtVoNg8GAarXK8RxRwVIoFNDr9SiXy7DZbHC73UgkEsjlcqM19Ipg6IRLK9eKVOsnwaLRaDAzM4OpqSlcuXIF3/ve96DT6aBUKlGtVhEKhXD37l0UCgWUy+WmTXWY2pBecJI2DPnOjUYj7HY7p5Gr1WosLy/D4/EgmUwiHA4jlUohm83uEd7S652k539VMcj1Xq/XUSwWoVQq4XQ64XA4YDabeZ9J3z/FXOr1OsbGxjA+Ps6u7+MsJjxJGHZvyFAIF4VCAbVazdkrcrmcrQ1pLISEj1KphEajgcvlwvT0NNxuN2vaCoUCtVoN4+PjWFxcRCKR4Oymw6Q9fhmgVqsxNjYGvV4Pj8eDsbEx9m2rVCrMzc3BbrfDYDCwkCdrsd0CH8aFf1jQs7tcLphMJpRKJeTzeVSrVWSz2UPXbx0nDqMMyOVyOBwOzMzMwO12Q6vV8t5u93mDwQCHw4FkMjlKGukQWq0WdrsdarUaZrOZ48fkkfH7/VxkfVz7byiEi0ajgcfjgVarZQGRTqcRDAZRqVR405I1o1QqYTAYYLVaceXKFbz33ntwu92w2+1NFfhf/epX4fF48ODBA/z5n/85otEo8vl8TzQpg8Zxa/cktG02G7773e9iZmYGCwsLmJ2dhVKp5AOC5ndnZwdPnz7F9vY2VldXkUwmm1yMr3L9gUwmg0qlgsFgwHe+8x28/vrr2N3dxdOnT5FMJnH//n0kEokTmdhAyRu9pL7L5XKo1Wrek9PT0/B6vdBoNHsyOQlKpRKzs7PI5/OoVCpYWVlpW4c2wst95Xa78c1vfhNjY2O4cuUKZmdn2VW9s7ODH/7wh3j69ClKpVLPtE6HxbEKF3K/KJVKaLVaaLVaGAwGaLVaFItFtkBaaTNUaW82m+FyuWA2m6FSqTgVUi6Xw263Y2ZmBpFIZF/t6bhxnNoa3VutVkOj0cBqtWJiYgLT09OYnZ3F/Pw8Z9bJZDJ2L5ZKJSQSCWSzWahUqqZnaJVA8SqBDlGdTgev14u5uTkoFAqk02meK1JwXsXnbwVxL1ssFng8HthsNhYs+61xo9EIh8MBq9UKk8nEtTfAy+LOWq2GSqXypZlPgnTeaJ71ej3Gx8cxMTGB06dPY3FxEYVCgdcgzeNxKtLHIlxowqxWK2w2G2tL1WoVyWQSAJDJZJDL5dhnK27UWq2GQqEAjUaDfD6PfD4PnU7H16brazQamEwmaLValEolLrocVhylD5XmyWQyQaPR4LXXXsO3vvUt2O12LC8v87sxGo1ssYjxMI/HA5VK1bSQxaK6k3qw0juQEgqKz2K1WnH+/Hm4XC5cuHABp0+fhtvtxtTUFHZ3d+H3+1Gv15HJZJDNZo/lOTqFSClEf3fz7mie1Go1LBYL7zepG1sEWXS0F2dmZlipee2115q8FNFoFPF4HDs7O/jkk0+QyWS6Gpv4bCcJossZeJn6r9PpoNfrMT09jStXrmBiYgIul4v3qFKphFKp5L1J6d/Hgb4Il15eokwmg9FohNvtRr1eZ9dXqVRiV5gYIxGvTZpzsVhks08arKQFbzAYoFKpmPV32BfaUbrHSAMymUy4dOkS/viP/xhGo5E171YHAx1GNpsNZrMZuVyO41w0/n4wMhw1RKECNLuHpDE6g8GAM2fOwOv1Yn5+HpOTk3C73ZienobL5cJHH32EaDSKcrk81MKl3cHfbUyS3IQmkwlWq7XJBSa9hyjEaJ2MjY1hbGwMCwsLePfdd5uslo2NDezs7OD27du4efMmstnsiVtb3ULMhtVoNGg0GqhUKqjX69Dr9bBYLBgbG8Pp06cxNTXV5LEhAUOEwcfpremLcOlWqNBD0wRUq1UUCgUujhSD+QfVU1BgX6nc+yhUy0JJAlS8NWxoVeQ5CNAciNQfBoOBXYqlUglqtRpqtZotlXaIRqPY2trC06dPkc1mOd4ybIJFTKu2Wq1Qq9Ww2WzQ6XQwGo1cJU7WMa2/TCaDaDTK7j9xbtxuN5aWljAxMcFxPtIwbTYbLl++DIvFgtu3byOdTg8lnRDw0oJQKpWw2+0c64zH4z1dh6BSqaBWq9FoNNhtSq0dSFmMRCJYWVlBoVDg9eb1enHq1KmmYs9UKoWNjQ2Ov4r3EYt7ad29apQw0vo7tVoNo9EIjUbDwXt6VvqsqDSWSqVji+cemVuMNjlpORQkpkMtkUigUCg0ucA60aC0Wi1r2+I9APACJ816mP3gRzEmEsRyuZwPALfbDafTCb1ej0wmA5lMBp1O1zYAS3j+/Dl++tOfYnd3F9FolDWrYTpERUXG6XTi3LlzsFqtuHTpEtxuN8eUSJhUKhWutXj69CmuX7+ORCKBJ0+eIJlMwmq1wmKxYGlpCd/+9rcxOTkJvV7ftM7UajV+8IMfcObTs2fPeG6Gcd3V63UolUosLCzA4/FwUkKn1gsdbOKzqdVq6PV6FiJqtRpOpxNarRblchnlchmrq6v4r//1vyIQCMDhcMBgMOBb3/oWFhYWoNFoALxInfb7/fj888/h9/v3eB5IqIsZpaS5E7vEMM75fpAWMNN+oucwGAwYGxuDyWRCoVBANptFrVbjIlSaA5vNBpfLhUKhgEQi0XSNo8KxBvRrtRovNoqtdJsqLI0HAC8nUSTok/IefRlBwkUaTyCXIblwVCoVNBoNtFotNBpNE5M0zTVl88ViMS6SO+6NTO8YeKnxic9KQtVut2NsbAxutxsulwvVahUajQblchm5XI4b14k1GvRsouUnWnei4mQ2m9ntSwdlt8SQRwmy3Gj/dQtyQTudTjidTphMpibrt9F4SYyZTCaRSqWwu7uLcDiMaDSKarUKg8GAZDKJcrnMbp5arYZcLod4PI5MJrNnbOQ2EqlsSLiIbvJhrwcRIfViSC0XMd04mUxCqVTCZrOxO1p6jh7n8x6ZcKENKvrkY7EYcrkcKpUKWy29uNjUajW7xaSaFAW36KDsF/3/SYNMJoPVaoXH40GxWEQkEkGxWEQgEEAymYTRaITH4+HDUC6XY2lpCYuLi8jn8wiFQqjVapxTv7q6ips3byKVSiGTyRz7QgZeJHDo9XpUq1Xk83nU63UWApVKBZFIBEqlEmNjYzh79iwnItB3K5UK7t69ixs3biAYDOLZs2colUpIpVLsqs3n80gkEtja2kK1WsXk5CRvbuDFvNF13W43xsfHkUqlmA1iGFEqlbC6uorNzU2ujegUJNCnpqbwr//1v8bMzAwmJibgdDqbEnWCwSAKhQJ+/etf49NPP0UsFsP29jYKhQLTxiwtLWFzc5PXWKPRwPr6Ou7evYtisbgn88lgMMDr9aLRaLDlKT4TeUEosN2P/lFHAfGcFIWLTCZDLBZDvV5HLpeDRqOBw+HAlStXMDc3h3K5jFKphHA4jFgshng8jnw+f2yK37FYLiSRKSC/X4+Vg0BuDzFwJa3up/gCxV6+bCCLTWSppcwuqvuJx+MIhUJQKpXI5/MAXpCBTkxMIJPJIBwOczqo0WhELBZDIBBg5WAYLBexoFPki6ONSkkier0eNpuNU15FrZCESjweZ+ogUoaq1SoqlQqKxSISiQT0ej2cTieTONK8kptMr9czxckwW8z1ep1dJ92ChLfZbMby8jIWFxeblD3gxX7M5XJIJBJYXV3FZ599hlKphFwu10SimUwm2TVL7yWZTCISibQUeFRASO5YsQEgKRYA9rjKTgJa7SeZTIZisYhMJgOlUomtrS1kMhksLCxgfHycM2Lz+TwKhUJPCns/cSjh0kugiPyIdLiJ6au93F+s7qfrAS+ZV+kl9auvTL9AyQgAmsbV7/FptVrMzs7CarViZmYG09PTKBaLOHXqFFsuqVQKqVQKn3/+Ob9TmUyGeDyOe/fuoVAosHAh3qgHDx5wNt8wCBbgRWdTSi6gcdHf+XwesVgMSqUSDx48QL1eRywWQyQS4eZz+XweN2/ehN/v3xP/azQaXIy2sbGBv//7v4fT6cQ777yDhYUFWCwWuFyuJjcQuWaGYW76DXIDzs3NYWFhAQsLC5DL5chms1zbkkqlEA6HkUgkcP36dQQCATx69AjZbLal60av1zNXoFwuR6VSaZmoQyDLhYp/SfBTkNvr9aJSqTCb+kn2WJACPTY2hrm5OXi9Xrz99tuw2WyYm5uDwWBAvV5HOp1mIUNJUseFQ1suvQiYfrgHaHGT24uEidQXLubtD5NwETvxARjI2MhaOXfuHKampjA9PY2ZmRk+hPP5PK5fv47nz58jmUzi6dOnaDQaPJ93795ldwK5S2huxdTuYZlTit+JEFsElMtl1Go13L17F6lUCg8fPmThSUkJ+/mqKe09n88jGAzCaDSy22x6epoTVMgVNEyCt98gS+3UqVP49re/DbvdDgAsONRqNfx+P+7fvw+/34+f/OQn2NjY2DemSpRDRqORte/96jSMRiMmJiagUCj43SaTSc5QMxqNKBaLSKfTiEajA5mHowAp0QqFAhMTE7h06RLm5+fx3e9+l4Wq6IUoFovI5/PsVTguDAX9S7cgoSIezvRz8f8U+BL9r8Oy0UnoSesr+jU+ysYzm82YmprC/Pw8XC4XrFYr0uk0AoEA0uk0C5lisdg0R3RA0t8UkCWrc5gEdSegsZdKJe6SGAwGkclkUCqV2NLo5JnIvSImAGSzWbbkyAVDdByFQuFEzdVBID4wtVrN8ZRarYaJiQkAQDgcRrFYxO7uLtbW1hCNRvfwrVHyg0qlwtTUFJxOJxYXF3lPS/dFK1A9HKU4i4K8XC4jGo1yrKaf6bjk/uw0o7Vf91QqlbBarZiensbY2Bg0Gg33r6L1nc1mkcvlWNie2ID+cQ1coVBwpSr5zUngiId0JpNBIpFAPB5HsVhkCT8MoJoKUSsRzfbDChu9Xs+knt/85jdx+fJlXoTPnj3DkydPEAwGsb6+jnA43MRBVKlU9mTYtJq3k3Rg0rOn02lcu3aNqTHIhdLNRhQz7CKRCLa3t6HRaDA+Ps78eI1GA5FIBFtbW6hUKkfKwD1oqFQqTExMwGKxIJVK4Re/+AVmZmY4U+yTTz7Bo0ePkEgk4Pf7US6Xkclk9lzDYrHAbrfj3//7f49vfetbsFqt0Ov1ADrrfJrJZLC1tcVUPHK5nBXJRCKB9fV1Vi77WftCQrFVK49BgASxVqvF0tISfuu3fovPP+Cl4Mnn89je3obP5+N2GCdWuBwXqPjPaDQ28RZJXWGlUgnpdBr5fH4oUvOkEJMOFApFXzUhouOwWq2cIiputHQ6zTUdxIog3XzDNFf9AAkRaiJ32GuJf8SgMtEWidbMqzCXtL+ILt9qtTI9i9FoRCKRQLVaRSAQ4GBzu2C8UqmEyWSCzWbDzMwMzpw50+Qipj/7zZtIaitWpFPNWyaTQbFYbMs2cZh56Of1OgG5+/V6Pex2OyvV5G0gZTWXy/GcHLcifaKEC03w9PQ0/uAP/gATExM4d+5cE/1IvV7n/i0PHjzA7du38ezZM85MGbZNTtXjGo2GfaVSIdNterZcLsfMzAx+93d/F16vFxaLhV0/lUoFmUyGaTVoAx7EhjDCS5CVTJrkO++8A7vdDqvVimQyif/3//4fU5YM45rrFiLDhUKhYG616elp3Lp1C9vb29je3saPf/xjKJVK7OzsNNU/tcL4+Dh+8IMfYHJyEqdOndrjzo5EIkgmk0in023HRQzAOp0O4+PjMBqNOH/+PM6cOYO7d+8yKzBBWqbQKw6KzfUblIFIBdCUfReLxVCtVnnu1tfX8fTpU0SjURQKhYGP6yCcSOHidrvx9a9/HTMzM3A4HGy9iJk6hUIBOzs7uHv3LoLB4NDyislkMmg0Guh0Os5IOsxBT1qa2+3GG2+8AYfDAb1ez64ZIv0MBoMIBoMDb+/8KkLMUpyYmMDZs2fZbRGLxXDz5k2srKwglUqd+HkVU/mJTslgMGB6ehqLi4t4/vw5F+Du7u52bH1brVZcvXoVs7Oz8Hg8Tb8j6zIWi7HbshUKhQLq9ToMBgNsNhu0Wi03Dszn85yW3u8iyqOulRMTl8hiKZfLXKtG4YBwOIxAIMD9q44bQy9ciN5cqVTizJkzTC/tcDi466RYbZ7L5fDw4UNEIhE8evQIOzs7SCaTQ+vzbjQabDkcVrCINB4XL16E1+uF2WyGwWDg4J/I8yRWtB9lcPKkg1r5EjeZwWBAPp9HIBDgRAnqT/KqoNFowGQyYXJyElarFZVKhYugRfqVTtYt1Wv4fD7IZDKYzWbuSklUPLu7uwgGg0yj0+66tGapSPrJkydIp9N48uTJHl6tkyroqbun3W6HxWKBSqWCTqeD0+nkwkkqEI3FYkNz3g21cCEN0WQyQa/X47vf/S7+6I/+CDqdjskWSTsRC7H+8R//Eaurq3j8+DFWV1cPVTzV7ywuKSg3XYwbiZu00/uSBXT16lW89957mJubw+nTp5nUk+qA6vU6jEYja6JiAeHILdYZiPzS7XZzHxJK5d7e3kYoFOJmYa8CaF04nU68/fbb0Ol0qFQq2NraQjwe7yrtmiyJbDaLBw8eIBaLweFwwG63c5JENBrFo0ePsL29jXA43PZaYj2TTqeDVqvFJ598gs3NTc5wpGzHk/wu1Go1Mx94PB4mUKVsPWo3XiwWsbOzMzSdUIdWuJBWrVKp4HA4uEjNbrdztobIFUZ1DNlsFrFYDOFwGOl0+kSQ19Gm7CVAKM6TVquF1WqF2+2GxWJhi0/KrUbMqlTdLLoShy3pYRih1WoxPj7OBX8KhYJpN4hq/1WaQ7J4SUEpl8tcUyHSi9Azk+JCdDykQJXLZZjNZpjNZng8HpjNZuj1etRqNf49ES0mEgkkk0mOmbSzXsjiLhaLUKlUyGazSKVSTbyC4jsahlhEtyBL2WKxNMWXpW4/svyGRZgOrXAhd5jT6cR3v/tdLCws4LXXXoPJZGqicKFFl8lkEAwGsbm5iUePHuHBgwdd8yS1wiBe0n4bRfzMQWOgGJROp+MalrNnz+L8+fPcx0ZK1kkcY1euXMHU1BQKhQIfjOvr60O1OIcRMpkMk5OT+JM/+RNMT09jYWEBKpUKfr8fv/zlL7kifRjRrRVOhzMJBABcaBuLxZDP5xGPx5sUOIVCAYfDAZPJhIWFBbz55pvI5XL48MMP4fP58MEHH+CDDz6AzWbD7OwsNBoNEokEbt++jWw2y6UDd+7cQSAQQDQabctmTgKtUChgbW0NKpUKiUSiqQ+PWq1mF/GzZ8/w4MGDE1epr1arMTU1xU3pKMZMBc0kXKm2ZVgUxKEVLjR5Wq0WMzMzWFpaappYaTYV5dInk0kmbRvmGMJBRV2dHARiXxadTsfNmsi6kwoW2owqlQpOpxONxot+G6TRqVQq3pTDskCHCaQlmkwmnDlzBrOzs0xVQjUGorb9KoAsXa1WCwDszw+FQlx8K2Wg1ul0sFqt8Hq9OHfuHFKpFK5fv45IJILx8XFcvHiRGwVSPRC5dqLRKBKJBAtpsjTaWfWUjptOp7nORfwdUcN4vV4unj1JEEMD1IdI3NdUQEqZoMO0b4+tE+VBIG3c4/FgcnISk5OTsFgsvIDJNKR7BoNB/OY3v4HP50MqlRrIJPcrr/0gS0T6WalFIyXgFGm4KbgHgIP2ZI3s7Oxga2sLOzs7WFtb474djUYDZrMZb731FvL5PDY2NpDJZHjBjmIxL2A0GmEymeByuWAymbhKXXQXDbNLrNtxkaJBnF1EZU8s5tQ2nPakSqWCXq/H+++/jzfffBMejwcLCwtIpVK4evUqF5neu3evyZ0dDoeRzWaRyWQQi8WQzWYRj8c5drCfpd9ovOxfotFouMEb/b5SqeDp06eIRCIIBoND+25aQfRMjI+PM0cgMWQQA8SNGzdw+/ZtPHnyZCgC+YS+WS79FjCicJmYmMDk5GQTNYToZ2w0GgiFQrh27RoikchAUkDFzKpBgawQoLl/g3Qc1CuDhAYdbJQxQpX/FOwkgbO6uspz9OzZMxSLRQ74T05O4vTp08jlcsjlcgDAjYiGSRs6LshkL9tyUyW6wWDYkwJfLpeH2mLuBGJSiUh1Qwc9pbMXi8Wmwkri8/r617+Of/Ev/gXvGRIu09PTCAaDuH//PvL5PMLhMNdpyGQy7t1CLN1ivKUdiP3YarUyJ5mYTFEul/Hs2TMAJy9bTKyn8nq9mJ2dhV6vb3KFpdNpfP755/jwww+PnahSiqFzi4laEKV5thIq4ueBF4sonU4PlP30KBan1EoxmUzcrZMOfdJoRFZp0mJ2d3fx/PlzbhxEv6tUKnjw4AE2NzeRSqU4gEoaqdlsZk3R6XRCrVZza1mqPD9pm7NfoENybGwMFy5cwPz8PLRa7Z42D51UlZ8ESMdPlgvtP7HOg1xPGo0Gk5OTTGAZjUaRTqc5sebhw4dczU90TORhoKZqlF5bqVSgVqtRqVR4T7ebUxKEVInf6nCV7qmjrKw/DCgpgrrCikzShUIBu7u7XGxKe3yY0Bfh0k+3CVE4mEwmjI+Pc+odoZ1wIZ4hmuh+4yhcQ5RaSYcZsRF4PB6Ew2E8ffoUtVqtqZiKhEgsFkMmk8FvfvMbxONxBAIBPH36lAUIuc0oI4zcN3RAEpOtwWDAuXPnoNFocOvWLWY7ELv9fdlAFuWbb76JP/7jP4bNZoPNZmsSLuSmeBUsFxFUDS7GPmjdiZ+x2Wx4//334Xa7US6X8fnnn+Pu3bv48MMP2eUlFvISVCoV5ubmYLFYYDAY2O1DVvmdO3ewsrLScu+Re5zaJ6RSKeRyubZeFNEzcBKgVqvZIiNaIbIQw+EwPv30U/j9fmxsbHCriWFSbPpCuS82n+oXnT6Zg9SWl9hm24GKEKkQ8SRDLpdzb3az2Qy73Y58Ps8ajNi6mTY7uReSySSCwSD8fj82Nzd5Ttpp1LQR8/k8dwTUaDTs9iGeJhLYX8b4Cx1iZrMZ4+PjbE0DaHJFvqrCt5PnouxOSgcul8vw+XxYX1/nglJx7dBBT/FCEjhi87+DmvtJezkdREx7kqwW4OXz0RkopnwTaWo4HGbuxGHbl4cWLgqFAk6nE3q9Hslk8tDFY6QVUW9os9mMarXKLiFKvxO1E/IND1tDMBFkfe1HKEfP4XK58I1vfANOpxM2m41JAoloUuy4R8KdKvCTySR2dnaYX+igOaGfUxEgEV0CgM1mw8WLF5FIJLCxscFd7oaBWuKoQHOr1WpZ0NNcV6tVPHjwAD6fD48ePfpSuw5jsRh++ctfMvuDXC5HNBptKVhE1Go1brVNWWni/g4EAnu+R793Op2YnJxsqqOhzKlWe+wkdaKUyWTc38br9fJZQApmOp3GysoKtra2EIvFhnLdHVq4UJGS1WpFuVw+dI6/WIil1+uh1Wq5Dwe1jwX2usfoYB7WHHaRWHM/7arRaMBoNOLixYuYmppittd8Ps+teZPJJLvPgJeWjFwuR6FQQDweZzdEp8I2n8+z4MhkMjAajdDr9ZicnIRarUY4HGaN6aA06lcJFP8jASPGAGu1Gnw+Hx4+fAi/3z+0a+8okM1m8ejRI/5/p2ukXq9zJ1SRpYKUyFZp3SRcjEYjxsfHm5QtUfmUjuGkWd3kFiOXIVHsA+Bq/K2tLWSz2WMcZXscWrjUajVkMpkm6+IwoEOSKMsNBkNTUR8FEOn/5Mel4DdRwAybe4IOeXFcrXzDYoqmSCmeTCab6gooa4ziL8Sz5vV6YbfbEQqFWCh3QwdRKpWwubnJnE5yuRzlcpl9v1arFdVqlWsSTtJm7QWU/TQ1NYWzZ8821RhUq1VsbGzgiy++wNbW1isrXKgxn5iwcNB7b/V7uVyOCxcu4Pz589xaulQqwefzIZFIcOIA8DJLkuaU3OTE2GEwGDA3N4dz584xzXytVmtqnnVSQevL5XLhjTfewPj4OGw2W1NbDkrUIZf3MKIvwiUSiTT5BA8D8rVSwx+NRrPnYBQFDMUUiC2ZmuYMm/krdSWJtTq0YcV0Z+JGIiskFAoxfxDw0l1DrgSn0wmdTofTp09jfHwca2trKBaLTfUqnSCfz2NlZQVyuRw6nQ4ajQYWiwULCwtM+S2Xy7G2toZ4PD60C7tfsNls+Jf/8l/i7bffhsViaUoVL5fLuHfvHn72s59xAHqYsZ8ys182lkaj4X1Iyk0vB7hCocA3vvEN/If/8B+QSqXw4MEDxONx/OM//iMePXqETCbDgWkpVCoV7HY79Ho9zp8/D6/Xi7m5OZw/fx7RaBR+vx+lUgmJROLECxfgxbxPTU3hd37nd+B0OrmAnNzqlEBC9DvDiJ6FCzFzAuhbfjUdrhSgy2azrHVLFzRJcMqGGqYuk51CKlDo2YlyXK1WIx6PI51Oo1gswmQyQaPRsAZJrLz0LiguYLPZYDAYmoj9uhkT1TMQd5FIp0GL+1WqQt8P1KDJbDZDo9EAeFkVTkSLg8hOPG6Q8iOXy2Gz2WC1WpmehZ77IMWCFEWVSgWXywWj0YipqSnYbDamIapWq3tqu1rBYDBgdnYWZrMZk5OTcLlc0Ol0nMlGCQWksElZPPqNQRSO03WtVisMBgNcLhezmtMckUdDrMZ/5YSL3W7H+fPnUa/X8fDhw33ZSw+CGDug3u/ZbBarq6tIp9NsPovBcDrokskkkskk4vF4U9XwsIMOa7IQVCoVL5ZCoYDPPvsMer2eK5U9Hg/eeustyGQyhEIhFItFjI+PY2JigvuFy+VyzM3NYWlpCYFAgCk1uhUENC6DwQC32w2NRoN8Po9cLscMCCdlng8Dkc5Er9fzwUUunUQisW+/kWFDuyr3VqBuk3q9Hu+99x4uXryIra0tfPHFF8hkMvD7/ezrb2cR6fV6pl75V//qX+Hs2bNMmdNoNOD1ejmetV/Pd5lMhoWFBfzH//gfMTY2xsrY2toaPvnkE05cIcYEykIblHAhYs5BJAio1Wq88847uHjxIi5dugS3280ubwBcJEo0PMO89noWLhqNBna7HfV6nTMYuoU0pZZSkOmgzWazbBW1s1wKhQJrL90EsIcBIn2FSqVii6RarSIajXLwPpvNwmq1wuVyscswl8vB5XJhfHycq+objRfU40SpT8K2l03WaDTYz03WVLlcRiqVQiQSGcBsDBfIYqODROwbVKvVkM/nmcHgVQS5XXU6HTweD06dOoVarYb19XXIZDJuSCWmx4ppxtRu2GQyweFw4NKlS3jttdc4Tkgs3jqdjmMJ7eI01P1yeXkZExMTnBm2vr6OYDDI2WEqlYoD+oOEaM33G3K5HG63G4uLi/B6vdBqtZxpSmGATCbT874+SvQsXJLJJFZWVgBg31ak7SCXy7G0tITl5eUmPq1yucxaiMPhgMPh4NoCcZLJ57i5uYn19XVsbGxwk6Zhn3QR5LsXhWetVmtigxUtOr1ej6WlJQDgYr5EIgGZTIZ8Po9PP/0UN2/exKNHjw5Fod9oNJhGR1QkTtLcHgYmkwlutxszMzPs/gVezMvu7i5+/OMfY3d3F2tra8c4ysFBq9Vibm4ODocDy8vLWF5ehtfrxfz8PIrFIhcrP3jwACsrK+xVkMvlmJ2dhdvthtvtxtzcHOx2O2ZmZva4ragnCSWKAC8ph8hlvLCwgLm5Obz22musNAEvq9WpOJhS9AuFQlvrp1/CoNOkhl5A2bd2ux1Go5HHTS7uGzdu4Gc/+xl8Pl9P5243OKzrr2fhkslksLq62jSQTgdBVsrCwgK++93vslZYr9cRiUSQyWRgs9kwMTEBo9EIj8fDFPLAS+FChVoPHz7E5uYmM/yeJG2ShAvFOYAXApYy7/R6PQfSqYLe6/WyH5ayeKjQ8cGDBwgGg8jlck2Mtb2AAqzk9x20H3uYYDQaMTs7i8nJSeh0uqb1HQwG8bd/+7fY2NhAMpk83oEOCMRG7vV6cfr0aVZorl69CuCl5+AnP/kJxzzL5TJUKhXeffddLC0tYXJyEufPn+dCR9GiEOMxFNMqFotsxdRqNXbzvvfeezh16hQMBkNTEowY90omkxx/lUJaF3dYDFLJkslk3LaZ9pwYX75z5w7+/M//HKVSaaD1ZmIsuFcFtWPhIrbDbSW1OzVFqThSr9djYmICExMTTcLFaDQil8ux9KZANZm7jcYLHiEiqPT5fNjd3eVA40lyixFapVnTv4GXwVWqtSDmAmrWlM1mOS2R/vSjoI/GQK1nZTLZ0GXhDQpmsxlzc3OYmpqCTqfjID5ZzPTnJCkynYLiJbOzs5iZmWmiuhEPablcjvHxcbz++ussXBQKBebn5zE2Ngar1drUrI6+B7xIAvL7/YjFYojFYpy0QgcZfT6XyyESicBqtfIaJMFDdXWUiizSzgNgK4euSdb/sIIOdK1Wy3xrdC5SiIAyYQd9zoln/MAtFypgJI2h1WDaQRQ8Wq0W58+fh8fjwdWrV/Hmm282+bPFiaMFTMKF7p9IJHDr1i2Ew2F89tlnuHv3LvckGebsiXZoNWaxWJTSQc1mMywWCywWC/R6PXw+H7a3t7kHRjqdRjabZRdBv8ZGJHkAvjTCZXJyEt/5znfgdruZjJHcL1T0N0iS1EGjnaeBYhxOpxPf/va3cebMGVit1j00LLRf33jjDZw9e5ZrqgDwwUg1WOK96KCPx+O4efMm/H4/Hj16hM3NTc6CEq8fCARw7949VCoVvP7662zdqFQqZDIZPH/+nF3hpHgSwwdl9xG3nl6vh8PhGEoKGFIglUolrFYrPB4PW8zlchmBQADxeByxWIxr+waNw1pnXbnF6KATi3k6+Y4IhUIBi8UCt9vNKXeicCGTk1LuKMhPWnO1WkWhUEAkEuFe5SI1/EnEfsJQ5BfS6/XQ6/XcCIwC+1RdT+6Jw2o1osUk5Yw7qXPcKejZtVot7HZ7E+UGZQfROnwV6imkEBNrTCYTLBYLH9KtQGuS3NSNRoOFCl2PIC0AjMViiEaj7M6WWi0AmD2Z3LzlcpndxCJo/4vpudKzR0wcGlbQ+UrxKVpz1ASxH911jwodCxfSKHQ6HdNhd/ugMpkMWq0W586dY3oTWnBioE/s+U4/A16Y0sSB9eGHH2J3dxd+v/+V4nSSuh2cTicmJiawtLTEHfzocEskElhdXUU0GsWTJ0+Qy+W4aLJXC44CrZQNI9a3vCpzvB/oYLRarZiamoLdbme+q1KpxAddr4WEw4JOxk39aSi7az9QTBB4eYi3yiQjgtSdnR3cvHkT29vbzCYhumHoTzqdRrVahcfjQSaTgU6nY8vEbrfjypUriMfjePLkCdLpNAsVEmDk7QBeuNiIzWMYIRV85XKZCSp/+tOf4tmzZ3j06NGJWXMdCxcKGlNnNMpO2g+iBkxQqVTweDyYm5uDzWYDgD2aBk2yNM5DaXiRSASPHj2Cz+c7MRPdC2QyGcxmM1fojo+PQ6fTIRKJoF6vc8OlSCSCSCSCbDbbNibWzT2Jz+zLlB1GIJcLteo1m81N9S0i5carvPZEF3inHgppF1W6jvinVCohn88jHo9zV9R2xJbkkq1UKshkMmy5kFVkMBgwPT0NrVaL9fX1pu+3Wrui221Y0Y6l4/Hjx7hz585AGiEOCl25xSiziXz69PJaaQLtTNNqtYpwOIytrS2u3AXQZLlIr0NZIQ8fPsRvfvMbbGxs9IXHbFghanD5fJ4L9iKRCBegkeY2MzMDpVKJp0+f7vl+t6ADwmQycSEraeknZUEfBkqlEmfOnMHMzAyWl5fZggNeHFZra2v49NNP2c//KoIsVVEg0EHdzqUkxgdFiPx4z58/RzKZhM/ng8/nY/66Tli7qYbFbrfDbrcz1Y7JZMLS0hIcDgei0SjsdjsCgcCJrMNSq9Ww2WxsKdO5R9ZjLpdj9+FJQdepyKS5iZqGdNHt97tKpYLt7W2oVCqYTCbMzc21tHDEa5HGeP36dfzwhz/kwOqreOCJz9RovGjUFI1GEQqFsLu7yyypKpUKY2NjWF5ehkqlwvXr1/d8vxvQe1KpVLBardDpdOzr/bJArVbjypUr+NrXvtbUbZIOuDt37uDP/uzP2P34KkIUJqKSQxlaUuuEPt/qDKhWq8jn84hGo/joo4+wvr6OlZUVbk/QSe8lUbgQ/XwwGEShUOA26NQS2e/34+bNm4diCzkuaDQaeDweuFwu6PV6nnPKEEulUkNJyLsfuhYuB6WnHXS40QFGPTHoO1KBRFpPsVjkDpO7u7t7rKZXCeSSoRiHOA+FQgGJRILZohUKBXw+H0KhEOLxeM/ZI2KSBhW10T3FVrZfBshkMk6BpxoDgmi1tyvUexUgxkaeP3+ORqMBg8HAFCQajYazskQhJMZKCeVymVtA+Hw+BAIBTh3u1BqmcyGXy3HHxWAwyI3t1Go10uk0d2IddrdXO2g0GkxMTMDtdsNsNje1dSDBTuwcJyVDsaciynZps60Ej/SzRAs/Pz/PMRepGQ68KOCLxWLw+/347//9v+PRo0cIBoMD43Jql5opDU4OEiaTCXa7HZVKhQUGZYQFg0HcvXsXCoWCiyQDgQD8fj9yuRwHM7sF0ZsQTUe1WmV6jZPEm3VYUIaUx+PB6dOnYTKZmqwWqm8RM5teVTQaDWxubuJP//RPmU7IYDDAaDTC6XSiWq1ic3MTqVSq6XtU00IHIWnflUoFgUCABXM3blaa/6dPn+I//af/xGSu+XyehVmtVmOl8yRalDKZDGNjY/jBD36A2dlZLCwswGAwcBZoqVSCTqeDxWJhqqeTgL41lN7PopH6ZKkyF3jRP4QCdER30mg0kM1mkUwmEQ6H8fjxY9y9e7fj9OduMSzZI2Q9iFogHWz5fJ59yVQZTu6ydrVH+0G0WIhDjDLRiAR02Cnk+wmaD6LYofdAFgsVpp7UQt1ukc/nsbq6CpnsRZ8kvV7PbBnVahWrq6tNjQHFkgHi+KKfEwdgr+up0Wggk8ngyZMnkMlkTa0n6B5ibOwkgdadVquF1+vF5OQkTCZTEzkmZdMe1PZ52NAX4SIN3Iv55FItJZPJ4Be/+AXu3r3LPlTgpfVSKBR4M1PBms/nG2hQ+aDrHoXVAoAFCBWk1et15HI5DuLR5iReJ1GL7saFpVar2fSmYrfJyUmcPXsWmUwG0WgUqVTqxG3UXiEeTru7u1hZWYHH48Hi4iJyuRw+/fRT7O7u4vbt2x1nT70qIBcYrUn6d6FQ2PM5yiiVZn6K6cC9gtzB9G/pvemdnFShn81m8fDhQ2QyGZw/f54tP5PJBIPBwJbzSVL4+m65iGnEUncS+U6vXbsGmUwGh8MBl8vFi5U6HEob4Bzngjmqe8tkMmYxFkGLiXzXQHOhaS8WC7VPJRoZlUqF6elpbrx0/fr1gfh1h8VClIIsOJlMhnA4jKdPn6Jer2N6ehqpVAqffvopVlZWsLGx8aWwWqQQM5b2a2NOB/wg1g5Z7+1w0t9JoVDgLMSxsTG4XC7U63Vub/ylFi6EVoVQ7T5TKpWQTqe5+RRVo36ZNENCJ9YTLayDkio6uQ5xFBWLRSiVSuzs7ECv13OR4JcJYlyFMnOi0Sh2dna4ijyRSOwR/CO0hjQRYoSDUSgUsLW1hUwmA7VajZ2dHbYWw+EwYrHYiWMhkTU6fPuD0Dop+AfsLbYaZvQyvn7MXytall7HQpo6vQPy6dIBO0jLpZcNMmirhzKPrl69ijNnzsDhcGBychLJZBJ/9Vd/hc3NTQ6wHjcOk27eDaR7s1NQB8tWiTrDguPaw+2gUqmY9ZlYIshDQUk2x8VE0kpZ6GQcfbdcusGXsQL8MBBdj4dZZKIVJLovv8zvgg7AQqHA7LuU5koZOyfJJTEMOOw67TfUajW0Wu1xD6MlKCsU2KtoD9McdoOBC5eTdnjttyGGJWbQz3mkArhOF3CvLg8xaD6MoKCz3+9HoVDgTonFYpHbSp+U+oJ+odd1JiqNw3QwLi4u4sqVK5ydOkwghU/ci8Myd72OY+CzTIfKSREs9He/X6xISDls6HZMvc7PsAjndqjX60ilUtyEiQROJpP50hB39gPDOk9Op5NpfYYRJ9lKaYWBx1xaWS7DfNB2YrkcJmYwDM+u0+ngcrkgl8uZ8rwb9CJcRHqQXiyAoxBMMpmMs+cIxK47TFbLUcVcXjWcOnUK586dg0KhwI9//OOuvz9M8yeXy3mdHkfV/rHEXKRuk1YH8WED0t2Mpdvq+v0+16+xis9/HNDr9Th16hTUajX7ert5tl6z1IZRmRBBNR3EnTfCq4WNjQ3s7Owc9zD6Arlczuz0uVxuqJQfwvA5H78EOO5AJ2WLSbmgRniBkWB5NUGlDq8CTsK+7dgtNsIII4wwwgidYnjTd0YYYYQRRjixGAmXEUYYYYQR+o6RcBlhhBFGGKHvGAmXEUYYYYQR+o6RcBlhhBFGGKHvGAmXEUYYYYQR+o6RcBlhhBFGGKHvGAmXEUYYYYQR+o6RcBlhhBFGGKHv+P8AX+pEuGa++egAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -570,31 +570,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 400/500 [39:17<09:43, 5.83s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch: 400, iteration: 468, Discriminator Loss:array(0.566884, dtype=float32), Generator Loss: array(0.66744, dtype=float32)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 500/500 [49:04<00:00, 5.89s/it]\n" + " 78%|███████▊ | 388/500 [42:56<2:56:15, 94.42s/it]" ] } ], @@ -644,10 +620,9 @@ " print(\"Epoch: {}, iteration: {}, Discriminator Loss:{}, Generator Loss: {}\".format(epoch,idx,D_loss,G_loss))\n", " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", " fake = gen(fake_noise)\n", - " # show_images(fake)\n", - " # show_images(real)\n", - " plt.imshow(fake[0].reshape(28,28))\n", - " plt.show()\n", + " show_images(fake)\n", + " # plt.imshow(fake[0].reshape(28,28))\n", + " # plt.show()\n", " # show_images(fake[:25])\n", " \n", " # print('Losses D={0} G={1}'.format(D_loss,G_loss))" From 4d17f80efbd27d6edd0d9179d5631993dd3cd97b Mon Sep 17 00:00:00 2001 From: Shubbair Date: Wed, 31 Jul 2024 20:23:57 +0300 Subject: [PATCH 34/38] Updating GAN Code... --- gan/main.py | 38 +++++++++++++++++++++ gan/playground.ipynb | 79 +++++++++++++++++--------------------------- 2 files changed, 69 insertions(+), 48 deletions(-) diff --git a/gan/main.py b/gan/main.py index cd1a6ff9..1ae1abde 100644 --- a/gan/main.py +++ b/gan/main.py @@ -120,6 +120,44 @@ def main(args:dict): return gen_loss # TODO training... + # Set your parameters + n_epochs = 500 + display_step = 5000 + cur_step = 0 + + batch_size = 128 # 128 + + D_loss_grad = nn.value_and_grad(disc, disc_loss) + G_loss_grad = nn.value_and_grad(gen, gen_loss) + + + for epoch in tqdm(range(n_epochs)): + + for idx,real in enumerate(batch_iterate(batch_size, train_images)): + + # TODO Train Discriminator + D_loss,D_grads = D_loss_grad(gen, disc,mx.array(real), batch_size, z_dim) + + # Update optimizer + disc_opt.update(disc, D_grads) + + # Update gradients + mx.eval(disc.parameters(), disc_opt.state) + + # TODO Train Generator + G_loss,G_grads = G_loss_grad(gen, disc, batch_size, z_dim) + + # Update optimizer + gen_opt.update(gen, G_grads) + + # Update gradients + mx.eval(gen.parameters(), gen_opt.state) + + if epoch%100==0: + print("Epoch: {}, iteration: {}, Discriminator Loss:{}, Generator Loss: {}".format(epoch,idx,D_loss,G_loss)) + fake_noise = mx.array(get_noise(batch_size, z_dim)) + fake = gen(fake_noise) + show_images(epoch,fake) if __name__ == "__main__": diff --git a/gan/playground.ipynb b/gan/playground.ipynb index 8d9cc56b..591811fa 100644 --- a/gan/playground.ipynb +++ b/gan/playground.ipynb @@ -395,11 +395,11 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ - "def show_images(imgs:list[int],num_imgs:int = 25):\n", + "def show_images(epoch_num:int,imgs:list[int],num_imgs:int = 25):\n", " if (imgs.shape[0] > 0): \n", " fig,axes = plt.subplots(5, 5, figsize=(5, 5))\n", " \n", @@ -407,39 +407,11 @@ " img = mx.array(imgs[i]).reshape(28,28)\n", " ax.imshow(img,cmap='gray')\n", " ax.axis('off')\n", + " plt.tight_layout()\n", + " plt.savefig('gen_images/img_{}.png'.format(epoch_num))\n", " plt.show()" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### show first batch of images" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "X = batch_iterate(25, train_images)\n", - "for x in X: \n", - " show_images(x)\n", - " break" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -449,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -570,7 +542,31 @@ "name": "stderr", "output_type": "stream", "text": [ - " 78%|███████▊ | 388/500 [42:56<2:56:15, 94.42s/it]" + " 80%|████████ | 400/500 [48:13<14:39, 8.79s/it] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 400, iteration: 468, Discriminator Loss:array(0.566545, dtype=float32), Generator Loss: array(0.67279, dtype=float32)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 500/500 [58:22<00:00, 7.00s/it]\n" ] } ], @@ -608,24 +604,11 @@ " # Update gradients\n", " mx.eval(gen.parameters(), gen_opt.state) \n", " \n", - " # if (cur_step + 1) % display_step == 0:\n", - " # print(f\"Step {epoch}: Generator loss: {G_loss}, discriminator loss: {D_loss}\")\n", - " # fake_noise = mx.array(get_noise(batch_size, z_dim))\n", - " # fake = gen(fake_noise)\n", - " # show_images(fake)\n", - " # show_images(real)\n", - " # cur_step += 1\n", - " \n", " if epoch%100==0:\n", " print(\"Epoch: {}, iteration: {}, Discriminator Loss:{}, Generator Loss: {}\".format(epoch,idx,D_loss,G_loss))\n", " fake_noise = mx.array(get_noise(batch_size, z_dim))\n", " fake = gen(fake_noise)\n", - " show_images(fake)\n", - " # plt.imshow(fake[0].reshape(28,28))\n", - " # plt.show()\n", - " # show_images(fake[:25])\n", - " \n", - " # print('Losses D={0} G={1}'.format(D_loss,G_loss))" + " show_images(epoch,fake)" ] } ], From 37bbf3ec548c0bfbe20a24c496aad107e207ef36 Mon Sep 17 00:00:00 2001 From: Shubbair Date: Thu, 1 Aug 2024 01:04:14 +0300 Subject: [PATCH 35/38] Updating GAN Code... --- gan/gen_images/img_0.png | Bin 0 -> 212637 bytes gan/gen_images/img_100.png | Bin 0 -> 145587 bytes gan/gen_images/img_200.png | Bin 0 -> 114274 bytes gan/gen_images/img_300.png | Bin 0 -> 103262 bytes gan/gen_images/img_400.png | Bin 0 -> 81318 bytes gan/playground.ipynb | 38 ++++++++++++++++++------------------- 6 files changed, 19 insertions(+), 19 deletions(-) create mode 100644 gan/gen_images/img_0.png create mode 100644 gan/gen_images/img_100.png create mode 100644 gan/gen_images/img_200.png create mode 100644 gan/gen_images/img_300.png create mode 100644 gan/gen_images/img_400.png diff --git a/gan/gen_images/img_0.png b/gan/gen_images/img_0.png new file mode 100644 index 0000000000000000000000000000000000000000..be8bd6375579323e37befe6896639cc0ddd0ddb7 GIT binary patch literal 212637 zcmbrmgtN5%EzJFpi_yl_)zL+ahsW;! z`vqUpGXUK%AR? zNmPDMRuw`)`d%=(ySTgiTgr61&7bz?10Tg(sh+>9NfB?tH#>Pu#p`3t$<&>6=ukw09rTaQVPt$Dx`9&v?^rQ1pRs*W2St4ZL%{$4 z1MRXlU3B-YbCxb??-j@2gJ&g zqS3>vOYii|OwM$Tjk(s)?j`5@lo5X?CbVlz^qXd$R{tA)&a1_jqQ{m{ZcP;0iiaI| z+}mKP`Sj`2ucNPM2(XPzO!TBOpE8mR9355BM1}maPMu7!ldgBOQ`JkFl5z)q~Qdd_e?LmBXDt)~YpO=zC{j$>VQLZ)} zJ^gxH#O?dZJ?}dfKBcEW5uw%RpwM9@(}shMj(%7_sy(}GoZtHi4_Nu`rHaexl}!I{ zno_3<=^9FA{+CtLjlM-Pj9E1`qIbz|5@KUk{j)PJZD^2$8wpP=9eDQj_kSIVSs&z{*@TPs;xTf_Mq85s>tPNx0c`tf!2 zt5Hc3>)Omks{cVCayIiK!Jk8a34c-MtC7`qn!=-_w{T?;5zoxbibh`*>fJ9iE#;&o;!NnWadXo@ z@_HsNE)HwT;;mIQ>gwuhDa`=Of)|{q&i0{a30C2*%B7zf#LlUYsj;!~d&OL@F6VO3dpdFlJi#6&rMstPVXIQRzK()IOq z)sBviulhytc{A5nNYvt{UN1Mrv3}@zxwW%X1Sd!z1L1s+EPQo-Ue4Rw`;`FAr_@wk zvGgClxY$YypZuCibqe#~0n2B?T>uXm#^=Z{6K~dMXJuAaR^T)tR8eoq9UK@Oj8n~z z=SzvqknqgO&%b*M??!{qsZQGq?Z6fp^^$(8%D;d94D|L!LX2>8bC0aKx+1rqN&24Y z?Rl6WG9-sf{V!h&(hwTEXGoIZa-^uQ6JPHVADymba+2VF(c<``QwWdM9-gL=f7K4R zAaD^Yj|+rSAB&%xvP}f~pAcVXv)Y=Q%ewDOkHRXOHu;q_ofS3dWNQuND#aXz`k#cV z77WAA9Npgj_N}z^Nr^t}JXRId?;juk$Qk^y*4OgEhR{nO;+WLTc}3d|7QyqCH~qa$yG-oAaC z9}$5+y75+JDB?Dc-!8p6%b|bhY}kc#+_jcsPYmamLiHt~#p^Z6kKNaGd}~q{{=N+U ztLN9DIWyP(T?(XUuut;L^PJwkeQDYYrwic@vF_E7@o05u;Ew8&EJcv_feL+99xmlcNe%NzxAQg|g9eq}JRUl>|V^C&eVW2|}flSi2ut!=NXLBiJ zX=SAt&*cpJ8+Q4pl$3`G^Jiy9L%gc*+g`wvaG&83Z+ZSGZ*!cH0&hZmPc%TLIb&w0 z1D5pH+-~O%q}o0Nf-^-uS^^1&CJPUO)Z7inxc>lEi5whM4GF5}=)4C~r zq0}dktRREt4wfD0aVMj0v3^lL>>SuEkTU$595TL3YgRKAYnP7eLc)f33eZ5N)~zu~ zVl`%v@angQr&!72SRr@81;GQ>^Z_^b*YOQ%F)Y369J9ak+g~NK3 zatC>Rhu2)+OvwuT+$gSL^>%Y5M!u^;rMl(i&yZ{T`}_4cDAZS+#*IsoAdE-1++Z^Z z3JVuN>Ql_kmdnn1RrS@cNt(>?pxRJcMU^dK{m2Uz64DQZ8l2MEYHp0;7~Z8D+y{+< zTzC)UIoRT=`7d_p9f*kc!9meH5$zRUP35%XP0Dgd{--q0+d~ z199RsGpStD(tp$h!E$hrW6xs9Pr^Y7?y{QY(P>Xf?j0v1mb^`WX0E1caabb$*$8YN z4Aw!W8-4X;&e0%TLGIw-z%2ywhFE&^{SWUSt+qTLaD5PFAVL3>J9+rx;^MbAZ=CEk zoG_~jxbi~rf{{Ha=SH6hFfpYsmv?Ul1qFHUV7sn>+aWs@#+C_?ZIa)CnFSONdPWhSR97e!9>TYG$ z93QDt_!}0)sKjb_xV!s3^$+-=<#`sQA#X))qS$kI?$=zIs8fl4&vDVet@Xo0J$80> zY;zU9FP~fyP>>+C!Y?eZtO$yWzgEpaEE(FX{j4`J>NhMm80qQ?hpd!;;}2$k<5R{$ zy>8l!swzQApA)S|CP75vGn-_V#G$^u=M(3kiN2j&@~>0f{5IiDKgdx z@ETMth$gjoxH5=o=D09=Nv}L_Hzhprn5k5;PL`_wUo{6VOb*s+;<;b0F^V z(kD9z?kCil%La%Xz56c*8BD2m0&yO5r-i|`Of6?F$mp}Gs;GF;9%GG+yJG!spUz)% zzkD$~weK^8qNpGTmBb;SBxCoT{QZ+uYePb~l&!5df{*Nw& zJTH~N2=0Pv^o&yF^i8a1OylY5Y>z#&R~v>}x?};U!j|9??l3L?EESAJwr~(kMa>$g z%t03Zr-t3=m(xN6DFvst*vfnN-(Br-HBsV>UCd6-S*sY4PavV=(sWGTaXrSvAy;4_ z3%9Yi@Bb+lAR|*{)R)6GRy<|@ua;EuhtUJ5^rRMD^ydxDD!(T1LtCvVZ~_Bhfqwk> z(c9G?FdOaiIowZHk#|yp1-qN&#^!__*6qo={kS_SBdU4tzokQ^N~Z`{*z_TtSkMc= z$i|WR;HW;RBC@W~;3H)%@j=xVN;>Q*Epjb|O>_h=6@lWFl!j8#Xoc@=I)uJx7(~;$ zTb-D=xNd`KH9u}Q?oKC8WSsKv|Dsi1G6!nx)5nzQ7frP6wj0)J=fx`$eUF*FL_pm= z;AV*n<4ftq?NX2TbZyqz^O&r!g2VuLx}>DU*3Hc=h@`x%EKA&dnX9Tfm~KWrt$r>y|N08o2m3tN8r-<=+nATn?R z;$mThs4EM1hjq?vZuTB0wstT53VWd?g9D}KS*?x0D^lsEz_>ZucfYd!IDUnkosY>& zvdMy1tzTs8?mn&~da?ae{y)b(`{CGJgNu|SYg(3=fRB*E0xldePNnYA>)-$?O={ft zZmvDJhD&2I+w6JHTZTBqQcz*p_+3kePMYr(T0dwL*&JPC(%(M>d5d*|y2G$p`yeyM zsm1drVLuM`S4i)A_a`P4S{4}h-lSpvF7S5j95DQ#`UohWE z63P;U+Yb=Kiq}UA%@&_!J9ioI9V7`<+7As46%!HR4XmlEdZ`HM?9Wd8tNAIo-d9zh z^6`HTQ%&wA{vjsCkSLXxVHpg?qB6xPvzlIej=)_MS-|yDsJ%&2eruBM7<(n^oFt-6 zuV_?{ixODg=7EUPq%rZZi-WH!o=7Ie9BiiJ<6~CBK!qXpIAzP<_9v1pr|5$p_1O4U z{r7JBGpQu8zd)ZLVDLPZ@BqXCwX`!8vwufb{^K1FHu{*?c6N^eHnzQRQaH_(SXo~F z4(krJ8!9-YJV@KprwP)7023fnLR`R!9PZA^Uk)-{#yQudT_LY8{l_7zwlD)eb1Tyl zlX@^qI1k|fWuv@ayPpFRr>&Mms!)G%rk=Y;}f8uT$KC^v*xl|81-sI1HXR# z2OqXYer|C8gW|p}}W!7GF^!|{`42=S%v1CEEp_KG=LHZUuYVxcKU~UNsZXzo?jD~;69H`@P+G-jc@ zxVS9;d65{d42iqkKKx3V?u27$e_sdQ3RtKc*vRy>J|hWW!U2HU6u4NCPMSwpiirr~ zV7ZXq<^=SbPYRA--|3W=mMRgrLtW=f5eUvuXHzmb1u_O#ZDeNll$UA*YJEQfVMlCQ z?_pm18fsXdl`e$feF{8En^~=j+w>380DeH_24D)A6gCW0KFE1VNl8GvU7ekCsvTzj zP6zUBZ*8S8iHeI4udNm4F|k}!BBT-o2);%~NB7EjU=d-udwPog`e6P5Qb9>`gZuX6 zX+Khi20jdmsfMPe5=kqdaWSmR#e;!WkC^p$l&TeYH+9lv7O^a^{E+9qTd2=Jq9xfR zIqMeBoiz3!g-jB82@o2X&kYaYBKn>f=X3?{1Z@OpSSHa9D>dIvyaT7p%3mOB^SfuYHDkTpc(<1$QfJ>;~%mS z=#7hLdjXrAGAgm><$?ej@i}5eeQ(o5@5)_gPXkl&Q)gh+e$BJ7Ffv73Tsv~QV=u{t zw^4w6nC36vE&50=z+#S90uaPuKEP)N2=nf z=|3jH$2i6Kh><+uy%Gk~BD$G3J55LQPPu#Y_r##M)OJH_VkoeWMpl^-570>G3?(Mq zA=88_{34-PV|&zGIZt&$VbNeJEH8UM{B55lAH-x5KhjcVn|miLa1Qani!V-Dy&gy5 zbXBaMvH#}pA3#_Xm>+60NSB7*_y4|cdYJx9=us*SMzpQ*W z7%Rp%jLPq6IOV85|( zQ*UvCHD&Ji&49k`Ttk(R9Fn)Br_JkkpVGy2l(dsu?M_Uj+Vg;?L=qAk=w8q~Wl7;naE)D*Qk(E4W0_3!$XtaCl)#>7;f zN?x`sWF!!lP*;;2;e<8{oaj}RQEh#_KtFaG(A?|~A8rAuyu;0a_Qqi`hS4k1_3x+XyD zW8~e8LC3)CWr$L&s;_^89-*1(ame;TbqcSQhQ9SDK;%!`dttZQi30I3-m|Qx>pIU) zdT)=x{SlQJeKne67OSio8S*{sgfZbAmUXf~){2!=$Csi1d~oKzn{cOEq#{<}G`Z{) zdBgcNes5#8{8Pr%upH37@VKUxs;A>7xQ&+IuDDw#LzwZW8Cy*_d5B;6o`X%55sT-a zwzfx?i|o>QqOV)17tabo*5iA&fBWN@R5DNm0M7*6ILqxdbIfs^_4V~5!ZSX( zJw0k5C!!b)WdGXQTAgwO0n3)wpfq%4w|WLoML#y0C=|^A&L9|*0Z_2@y3u5FYyB?(MErFr#Ege3SRjWPQEBtZ->$R@WU9>GIJ*oK(bNi1DR zfS^$ccpqr9_dg7QFbAR((7mW?ZSLff79HTQV`EAAGRjUK+`l2yZco-&)U<;LYhV4E z2&dl*s4Exca00vL;cN>gu-OLx>*=qO5NIVTBrEx*rN)@d$_drkop8^Uju}6wLXF=z zJREWU8PBy8$iG&@8c(qN4Q~B_tS)1x6I=La+a%1t9aF7kL9KIfiGSdTf=_a^@mASv zlYwSTHTjzj+UW6^)(=!#BV2ubOF;kdk>arpi%iSROf~Pa<!IvLcUOhl%8*KC+mx(#cgHk`S(1Rr&2%oZ84=B+}y^TEy@(N zqdDe4|L>V2ADp#x+;cLOpcM|EP0Q&F_cNzctFXD97v8{lJB$q7&%(jy9?>~^VT>>H zXuu%Oy}8SP7v_?cIK`pvIR@^>qsasqag`x?`Mfp?!IPeyUpHBztJy2hn#99T&YZ{Q z&Q;52Yj)jzKSh!0Uq!j>6uDib?BTN3zPk=)M`NL3`3ule-6Aop+1Koy-u-;QeXv~` z8XDrBx3ZYX)I;(cVo6iVO!$luRM&G5STUtYbuASzIk1Gt7U%j>g()Y-UkM(pdL}#9 z6hn?M*0uxzHr|qi4=+hRU7595a9)H4BX_Kn5Kl9{>Lsgxw--niMdQi#G{GcYEvrD) zw2Mahh*|-U$d*o*|H5Sd>V2}C4bd<@0 z17e8Bfl+;Zj{~jPF{FzZQ?bz>-2EhL~Foh^(p zz14RgiAU+vG*d0GpXdAXjVp(3MFbCU|=Pp^85lk_MG}vX!t6q z0N=l@H>IIhG1hc) z`&!Qb=&64`C>f}J0to&7U!Xez_gd2XxVQcuH)G~A;6j@d{0-j7{*NV%i$o&lM;qf~ zQ?JM-rl*r!$!k0jKgRC}^)Mk9b06wp(Yk4p{Tj>~_lC|J$cCUg0ah>8e5lPVYMbZ} z#{`KTNYIi)mqWp@ElcC+YP`uY2#->ihq|cNi*VCvREDJYXJBQSSBC{>U7CJ5pkg^R zU5Bx9rB^6gZI zu#hT4`}-9r)f5&H)Z~Uc5XBlA8pTexqUEx+$}V=`9&MrXIzZ9GVerY4z8sc@F3d3K zi9oeQYk-KeoCQ>dyR6-GO~AG8E_hxv`W4vKmQN13gqYlOZ0FUKEfKNF9Vnj->klVI z4l_oH6*N2brfYb?-KChMt`X-?i?)?>KKEH&zR z2Rr@pXaz@(GvovRTB>*);`l6LMV2_*TEaL(@JM=RJoW8vAzdcMff*L7!q}?%wdv*! z>+xLcc&=da{%$0Csr2n>t5ZeMgieLb<`(R)!G$W}H)?2SY`b~ButuoATP@T!g)Rq_ z1Va4))*$n+winp8I2hN$^M%=@y5uA85-2Kwq0o~&TES%5YQ#0 zBx$r-kst)!lbrQtJiolWjH{Emf5Ti7ns3UD8TChb7@46mHw!RUDo00>tk~(4Jr8=8$L*bnd8(gG6xlcpud7RQ5#2?TQZ~ti?tp+Dhw(^F;x=4v$9!dRw zpHKV4sGNpkG7>|l7X43C{Z~rN47oHZcl-DxZuXjSUyDnv5E0yoX#4)-$LEe124hT| z97kn(E_G0(gi=RC8T`J$9SYP9kIj_w{kpYfm!6i!K}BFBZ7pUWhkWS-s;g|GhZZ#6 zDQ(lz(mu+XnVOC*bi_d7Rix3@dfkOCB`#h$#QaHlAjd@~J5(^2S5{CfhxSDzdetYm z!QIP0N2GRW@PfaCyaYY<9(*f4YL}en1`8ht*r^SM-Q^eJPgkDRj_E}#XAj9j| zJ!2&8;@+EtO#)m|KFIC#26pTQSQE(Ahq7Yn^tPhiD;^ZhN_KH>5^ub9}>@OB6)Z*R)K> znS6qsPiFkiOVSg3q#Q_gKtvSung1qddf0hus?X6?B|zhT-X}1g^y#7HM=FN8+_m9a z7`{XAOs|C39`|%CvOfW(iBU#a2}{_LTm`uXDxO3qh|s`p6OvJ^mE{0sDc+Fu9VRCXBnOI^-=$ zKh|QqYx-aiJv0dyTYe+lt2ve4YLPmCrLg>Pi_?=*lM9o+RqLdxnQ1R>J#W52a_8fT z?_Q+otZ+uAATo%6I2jWklfPVZnxDQY(XUh#bD=CDwEI+Q`lphp2M+Ds6QWJ>oh5TF z;*JlpGacJ6=|pj2UxLcBG;Ux`EEqj=r)jzv$2#>(dgZz{ByDQAjU1sdn6&S)s<~}F-5Prwfn6a9qDyLl&G%a_SKH_wC~7D3c?4m z;&pjYNnFqWdJ`GYw1JR*J*SernWAZa;)@J=LTl!Cni74l2+40ZBu zpIN!ADV0j^YLcXOBmv?oVAhXqf6%-#4?FI_gMyH3hnE+PEHTw`OmW}YHIG;em_pAXnR+!rGr54(<%%+pqJX=#W2h!O9Y z1pdMUVk`{o@p2pq3n2Hu*G^9Uklg*)a#egV9sefrK|5PQ7geOP(YwqJs`G4>MT`7Y z<$@`D<8}P-wijL(C*@#0fOhU^z5IL3w~T#3*;s;%cLfV$*?#RFoy#xtk`_Pxvr1dK z>)nt6lI;@?3Plm(?18d4dqCp@ zVZ@?tX%9#=2$=810=5Mg!c>h*hg2#(u?Ta+beT0~uh)!T;Xk?`!=FQZ$XaaVe1gi_ zr!dViR67`*Lu4;x3c_OV8kV)2f;DIO(l4H|7P>4Sua?}y9Gv%e-2=-`0M9)9rDZ%+)UjeAOgrydue;z4HyA zW`JfV^dXaZ%wGBXn{BxnL*gTv1VRE3P~F_Y!NJ(x7v4$1qTLFJ4;rLG!onpf{|T>7 zywL~h1LlOY`3RoF(WhpH)%Ur@Y9gWQTT)!S+Lgc#!tmdjnQ<`gkhY4%PG?~bo=Onr z5i*W|!dy~X3ZjS}w3!E6T3T3pc-BIeh_v(mZM_0kC4IT3303^9qvLZD=KglD0e}_n zaYC-97dRSx540tIq31Ow1&T;Zmjde;9@d5G5H~%rIHpZ6;zuPqQ;+%adN5ZBECk@i z8#`D*^yRV}-T$CEHev~~fEXXB>b7vPCHiVh&Jz?oHIF}*93DzRU*d}!nW3>UNF!5a za3)|3%=9}e1a}m`*{Zs_*JVPAiT%1FzXf#nG3|%ez6%KnDb}{CR9J~Bgv2guQ6=Ks zz-X1)&SUu~+Kg2J{4~(Rso8g2Z2R^OwkDRv<8k>vTT9M{(4e6U@NkOn5+@^cuX_d- zLgT<(l_1(LN|b<=T!C5_{kPkyix>P$`8p7wW4;IUMxk^h{mPXfOmvt6Gs>g|eQ{7Aiy`;-Rl^pw3sHdXjU*pGzeT1dHETc5C8p1%7!l@L07PK~ zSHKFuYrBv5VUNIM04t!3Q^#;$DarZPW9 zb8Aqdc8V2s-@OI4gS{sM;hXXt0<`rD$Xgi9wZkk-ybCFJ%BreRAjn1Uo#;_S zSd)i)eW5ZK;$J=eH=VkPJpb$(?)J`3;`_o})85VuC25;{p#s)I?2pj$lj@k&@K?%D zJlyIWJm#79cGP0fsP{eVOWA8Zj=x$5UaE>kpxcn3==Y>U z6kKVUJ4j9{iG}RbWlXH}N+_&mi`Bbl3|9u!xD*Rxr}M85>s|GdMmaLHH%Sz4n7=R+ z7H_QH>=xI)tc(+>IjH3*X?MJqM?<3_iqrD;@IP*AC(1;;Y9_;{);n&rW6RUhX=8vtEzh`0u?Bh@ZT9Wb0gN~o4X zO1byQP$uFH;&+ECveCXdo08u|8$|p3_wQdCCo(9{aULAi7{C6z3yw<^KL%-?mv4n5 zp=)(-p@U_Sb!Skm0mE#*w2@G~- znyRstM3Ov~Wdc05xV=xZsT#FuNQzGkk)x6G}hZFF%sAhfnBkpIc7w>nwL9#q-(y50T%&6 zk=!$pg1Nkfbm&fof&%xu_!vaFb!ZCmFKGTw?pYEL78ZWN)zCV&addcb>f(EOG%n<5 zJ(<1Z7TSQp*lGS{^>^q(@bvR`apVygcwbe8kmEaTIu-*+1NV}W7n5TFm}Zr{_O7)8 zmZBqF49YOE6w=5Kee0%#eEF#eTz!1rkW-d^`$k~M5+y&fq3dRP?IEv*QC-|4k!cE%H zp9RIIm+AS(K;hMNjSfaCqB%P%*B!$b6z~3l`{N#;n6bGG?<(zc|Gj(vEGTS1m_WH} zfBdkTz8iu@!2(gTHe6uz?Aa4AP5|ixJp<}iR4jDtSPs@6>Kx8sOUaX3@=>FdY+NCa zUxx>w#CzLQ;<~>SOcx!y{!KM_KmDNEw!Z@%36`mCwzxf7UQ(vyGf?pf#D=eJ(th)M zYzJp>M06t}ao|J0U5-6!ljwF1n{aeyqvh%!|x*bal-`#TNmuD&pXo z0XwsE_ku)rbhIM?HYk8#P3D*C+!!zIn`54mqsbcIFsuzcu6ITA*_~}E`7YCbLP|<{ z3I?~LL{CtHAh&~D^bM#}UvIAg4HpTn!Kaw^CnTn}UqP!sB))2q9?QYw0I4)OY{+dcyu@mI!A zxZsqB?XM4K_fUi(uz%`ia0ov}edX}R5rl97Gz*Q_K8DF62iXwK6EZP6WD%8^wVf9M z;5`Nt0H;fleo<1!{^BEqerUpf3t(m+v9B(%VA9|sBFC%%)o9OlAT&!@#1@MeC|m77 zi!@sJuQGCzS()MI_uz#8*Oeni{bEF=LH&NUPAGR2Q3&!kL*_8EoK=FaZA|EV7Yj!6 zo;X)UY55X!EN7hJ1Y!}7x-iUqHs$mUvC0_*S{Yr&1Kxtr@Ke!i?+e=LWs!P8qTp+- zJzh%X&{EEoW^Y`)JzMld#yqf;zTVJ$6@)k<@K7DodY3_sIGYdl!bl6f4zrQu+R>%0 zXSZbJ{x0pXP)LW%tx&jd4};i3<9_4&7A0H->6E}-&B_y`g-kf@7q|V@D zVf+YfWd7|xX4i?#Kk&h8j*z|{db}QMO7MIR8^1R&$$BhjK2g?i6Nh-=Thrp`iqUOiHtsM?;ZpjSJSgvzfnqPNRb3~nk81I0`-V0gPG-O2J(|2{rDwKxQ;2^jta z zN}L{jC;xMCW)t0-G@e-;d znwlY0?3;$ys1iWudj+eDg6oi8u11^Ao{o{+Nb;?mKzV(ZO5r@f%CqET8^#yz7zTEt zqmw-g(CL7%Zk!&h08<&GtoXO}$-1i+`dGoxi0$M8Nh6m~^U$2`uA!fUpP%W!fB(S0 zAb``2ELcH`VqRXAg%f!0LX#an2YSG!kSxm)O)e|ZaoW7gi#H!?D8vfTfP3(>ghlyB z7#c$1tD|#aLS}$Bf=x`dwNc-3G*ClE+cQn2puGc1dJP(oO#H)PCq1n{3jd(v1&t$p z`z7xu=k#N}&)BD0Xa*VxEVk1bV=NEPTWjVH=}YyCK6|vzm4SXQEJyGm1WD&65)$D1 zUNJO~13X6HX$9Mo)WxnmKOazkq26F_+bG4>ZhZDziA=sNmmUTV1HSg@%VNA)fh}40 z%#SISU0|4|ZfXon07v^vYJri3^t0Ap4XNe*RL);T9e;zvuB9W(xVO>c{1|K^-@ccZ zn1oJv@yIA_Z;^F~VvRmYTw&7ETVJw}Ah@o-~n-=*Y@@8?; z!GhR6zdTal@Al65Eb*)eH$@+5r~gSBt`;Y`jl@5?kLeP(NEio05waENogx$r;R?O4 zkF;ubhB><;@5EszceZX`HArr5j z=m~m7Pv~fA|Mb4$-h|E+YTQnv;K54&a;0q9UYBP**e#q77yDPgQidx;D$F(T5_Q=r zgvvZoAVzh1cR}I@4<*+twR|1ynRu&RPnly<=1G_p8f9tKVZ%U|%Xx^ajA!S-6qKHx zUTDDe7wch|2PkF(5rAIUH8YfHglw5UtqlFbEvV@L$wSZ%4gI!G@M)i^$Kh%mjKS#Z>qnY|Vz$j#KbB;xdXMj!91-6-B&a&d5+pJ4JwxD-08;(j#{}9Q^jo2y%pW2;$Zq#pRwax8 z#Po;j;RE==|2?)Y8sC63Znv`16d_)1f>umlU!NiQ{q@;!J=ykm-6>&VPRCq+uAINs zXybqypj@`#49-9b&6+;<-Zq9ADMb66yyn3ptw(`8e`Ua%2znpOZEHU2qQ%`Oq9iK$ zsqq3@`qFa*3%!OP!52yq^l%EcB#esy+Z4o!J@c6{A8Fn3BL*wFV9NSYNS_09+?=Jt zSxsO?`8L*_)!!&fH4z0)5aHxpxW=1k1l{}xjDTN!K=Yui3yWN$+Cqirw$@ZOnyj)+ zlo5{_JP#Ck%o@M1wkpkU9rxkt*6*C2dU8q{nwgCQ(|GH+U(*3|LL?esROw0Pv75#3 z)k(wb^j&mVU3tbq(Hl11j(yhH*6R@3Ku`{&cijYZ^w~RBD=u9EHOj1HwUEo7u(2kn z=$d+@LNbP_IJnno!UR{)UWPIQqyn6Uf@ZsyZ2{H?r}f*@4X-irc!_Y+@Isz8&xhJ- znpvOqBusZMIqO%w8|$B ztwItu2{Okpl6|7(n>3i5KO&Sko1?+~0OMCY~mw|)F^HZ(W&kL5IzQuFbUJs&i zP~aIRa5v_q*1v@cJ3XCo`AmmB0q-6^?LB`=+^|`9N4HtiU57|EuRQ&tl$M1w$5I)Y zc2dnN?nvYwnUM3$F8G4*>i!T$EWjFX^YZ1( z#VH`aZ^wRPPqovlAKqNN5kM&s-X*WSz}LTjL+Hk@<6?86*4B3yl1*iAq*z6`@5L5` zs!9m-wh?28O8)5LB+owJSNLZ_<*&toet;b^iQ7#<+>h{RB6Q=43pcBF!bmYQBfgvu z#y~H3SKz&(>lntvm5xbhf2pWl@uTchjRbwp5m82H-|qYTJ8}uG{0^QM5{?hUtWJDq zNZ(jlwTGNfw%>@if9^f>;7U@|KaGJnA&2BA4u_rD-C4uVP4rArq9t!!2EBG+u05hD z5s7~9lSK3t{Lo+*O`}L$KiVImHaJh)HM0VP6mGS7gpU#5B2L+_5uw_|S2T%lz!Z}m z>O|~{UinWvE&bRro;eGXcYn8=L7z=`%A`DSAG`MLzgyeR|Mhg=^2u~MB9v8K%~F+C z(nyu)T1cDBUqe|lUSDRWg=x>W7beE>G!J(Hj)4P+Ak$H~ANAE9J+ zHo~~W81VQO#1n)dyQ^-Z>mXN$#Wb$)kXpi41#>8>`7>VG(i0u{JE1v ztyu3qNWL|;4!&u~2jzZh`SCC#?8(WB``2nn87l;}#XMUSOcY2=_(*PXONTvznLvQf za=2O_chHHth&bv^xc}AaViHn3P8`^Bi@N*R`ww`jpWIYn{EmC1WeXh+{#bRks`Bz| zm<9uEwK35Mv>95GsRtEcXVb72Nr_bPgWObQB?y>##x`V6K8V8`Kqxf0U_5phT7e+p zL|Xp%`P0UlUJosp0T=6Vb&v(P{vD^DmG5^`;@Ip2q;Sx__&GRe2FuBUJ zHw6d4Eb5hr=5Vx8?RN`k^RtARFqpAC||Fe#ufL$$6JF z=i`w9^NXliUO;@%FaKUynVXx-!q3~df5W$HCcBGBVFYNo{N1^ulg33T6kvo0#bqq$ zE_6L%1`9;Die;^)izObyN2|zl)a2dSSuM;Cp*lTaT;arec6K5EGk0qba2#R36mV6(2Q>ud%Cb;c^Bul8Su-P}c-LVAY%;3UU|~M`d~XW^1wtp8 zS|+{|o*Xp-(oka>`)Np^jaO%{p&0^0?ndq+3{xKek+pxaVWp)f@?g^WZ%S=}oPfT& zgTEMf9oTSSz}!ZQDkMUY2MQ@%cdh$Q2KY-N(IpFaB?QD}v?=j|<1z*ou!M4O>wRZM zuEd*Gw5cM)+3U2}6lyJ?1d8#%{OCq!5=@Z6d~GH@%zqVs=8^{T$>v4Y zp^vqA$WJs2IY$#1Sch?rr5P$~{2l?A?t#mPzFe@}+?X29L?~3K1?EK6yD($S*>Z>_ zG=x<@1I{FHx-roz@D*Rf*8UI_ov_;ZmVuuB6`X)7KMZ~emNWTxUs?15k--i$XK>5X zj=Y7Pej(CNwsX__6SpN8(SV=87%s{zbTq$A4}E7z&wT~B7aS@R+=Z4eMQ_{rnN*_S#z{p)z8$5F8y?!S%4Uyy< za78l)iPY!4hgMxxS=sZcc?dO#5LD+bA@f23$Tk!nud9oi63M|exO#vxn-abZ@n<`n zGTT(kVAY1v5E#&dg|mC}#>UgrGl&@Gt-ixfgk}|RPw?u4TR38Da6;z5RDxZuR`#AG zU$-xQa7a`SDqRG=7wL&rbfPNL%-aHS^@;mQyoFzA)~%7y%AiUZvp{)a6yemzq%v2I zIp$d*pgMZ;1wtR~N3m*QQ@PDX?tOVy8{Y0jB=Ti(y&XJkb3r)p06fL>!{57l;qnYDmUt}jg*T88A`b7C$&zs~{SvodV?&BUI z>8&gux2sj7CP*t)ZdhQrDyPhYMY}Kk_zNatzALOTE}q>Eea~5`z347>VCtt=Vfq(@ zIpR4wIr2LL`vjX09l2-;jH>r%eCYiqYwi$)2=2OCS`z={tY_CIY(EzALXRv+)f!X3 zq$%Z|-EqmB)6=@G?s8X$*>vq}S%<@!@re!r!K-~=G8x?b)MZI3RvqH2{ud`cE=;)9 z^f!*~1w)+}ZnfdxGR~j>*m~ZwJB8i)iL!C^^;q&g7l9x`BExO>$(<|j3zST|e(g(P7+gpJ`n?vL)Qcxjw$9vOWIuav!k~yt3E%-QPdsU`HbK>S)|dEuJn6 zzLx_CFG|Af@BfR%Gb@{UZpG5Y4?6xqBum`fNnLAeYur6UsTVxSJ!it#%QLH~4vpn1 zX0es;JOZAWm*+@4Tm_5g=OPe>P);M1kYsf`_F@P4!l>za*W+dmKo_NEO+QG3-q42L z&qTntCct+mZ0zo8f#R4oqY_Nt%gcR!Y3{I$kUCd~-2>h|#YpC4dCTU?oK9YKg&VOH zcMbdQdMkccCiI6Ev6tM#S$$=^%_4`1SR`IU)}d?tw7PW6>ZLOc5g_Bithz{ z#{`NwgXAs#S^^W7WG9CFdu{D2UjjB#DHi$|WAOoCz?TdD7cuY^9>tg38$mBRvf#Qw zL$F9XxELBR1b+)Zy&PM@!-9Yi)GU`E=KL)YYsy62pRu@UiQ3>1dAJHiV{9^XrLBB+ zCSRvZ5luMtvGFi`odioKn6V-mjd=G98&{E`M}Mjx3XxfpxqgMOjQ|C2Ax8SgCwIj^ zzogn{wbJ)NvfFrs-rZVzk|x+N^Kcc$3l9mrP!qU#^MJLXVTwv7fO18RM83urKA!?B z5X(I|#-rbShj_dK8W%9U4{|_0gDf`!f#^$t;b`#I!YohH4Dwtc{9^ugQ!Fbd>dRM9 zB~4|`FrqW^2s`){lsy!{KK=EyMvG689%aQN8-xPw+fRl@%BchzZ7~` z4y-8FqI%UlOGA>E+xBG4^AoNyh7L*PV1i-C|JwVq$p5HRk@+1s76Ls0c2JWu+&Z(K z%K~VO>Rac=NDU1Q#RI$t?F6o_eAZWQrHg8jvEv(#W1*p1&}VxqI&^S8~s~s~F4O&skCcmm-_Y zN>!FXF^ade{s94-iP(T9K3FMWXk`SN_=KOAxxFhgLcjTXQRGnsYHDG(n$d`f09s?Y z`+oJ|Cqy$L6C=|zCDrfn6#@y%oc0nE@h*`GD_z0#0lRC0SA7i&H4hK5k`lTVu+zW1 zZ@Yn)r_j~vEj2#pBIl8k@$tV7xt=HW;!Aq_YmFYF(l@U6Rt>Dbn3>q@_d! zL_$zNkyg4J=~Cp-B?=-UB1lS$l8T^ogGhJ2+4sG_US03G=j{D`GqcwEjeV5v^~n-b zK><4A1iiD?0gC*YvnVxo&XW9Tg}KJ5jjVfY4?7DVG_v9Nj3~~&VK`)-enQueDxs60 z67tjXjHZ|~8x2wlb2gA+q0HS+}CTmWrAF@#1x6$1D(_no|<1NGJyW%P@S30~hY9d*Zzva*8wNfHMdiRSj zId!P%W!x{1wjTA+6oS&)_XH8v4MpXkZ-evgs*5vq>8`G_P@X=!^M9GQ2+ zE2htez;A#=)~;GBw_`(o{jR0uZ+ja)SNF_!oedc1OB+QPm6ldk zSD|T)J@0Kq4)}ko|dOZI5i8pi~mQiG?~6+W@c_kux!sVYifg3QCd+B{sApK9~7118y6MQx?YrV3KlCWO}+ISvG*df7t z?wxmv+XkV;fZsT7pNx?%0@H3?o7@SHyh1|fLkr`cWD|U>dcT9Wa0_Up37-x0xEV_A z0VNC)4SG;_q&?=7SnK@^c?p>2fz|$9A+LmuzlyMP+Y3YI*?1NB$zYb^lQEf`XGGk8 zrH5gjyv`mntSvUHX?f?g0Wl#6A%MHk z+|p7iyBhTR1uswGIdKOnY>U6t3JX~#Ooufb@emBRYy1|28qCehZc@r&TZF+J-H$cu zfzQ0^DP)M-ytA`YtC@5tv{tnnuAvOiFoBs(?5ouydDSu}GB?321uqBT8$d*SRANJXe!)G;XNA}bo=326Az z__BMW3qF%P;D0o2qu}Vt#NJ6?>D|CvZ*T3MbY^a?;y|K+kLw~ zjN`z`D>|HoW{zWLjn8;Bv@w4+F29BCIDhn1$(jIEjt1)%6-L)-w&p4!G$7F)thpM{ za47fwf}gl<9hH=)K5wIFhmVe?2p$OI2(z0HBAsE`X_n}~#N>D~cXZj+L1k7Y4077( zy`o73nsKlGN#$v@m)>c>zVut9Pi)a%w4}T+H&nxui8M;n_)$4MKPm}hGK!CyH^Va} z>L}*5nM>uR!Mm;o3crfrLaE=GRJfEb_kGcoRH5%q^_awH*3yjgcqhv{mdUbRQboB) z4_wTbIwab+s5_biYz5XrH78yLwkD8s<#(Mvm-sP-<37$lB+-QPU0FGVzLS|Q@U)ST z>PW3?Zu!``Z0^f%JtTQ3)k;ab*$yo-60Ki7Sf(f0jV|rMa-D|z@#pQ!HAw6yclz$J zJMPyokghzRK9x$*rRNncuc%ldJD(;?>s{~!kq*3xj{r%c@DJwTFoj%(l7y4{5|pH3 z1|oDOP)62H1-=18hdCVI$2-aw{{>_vXUXfXK76b#8H^QtPfvhJ5FG{9y>~)?d*wuj z5}EiX6$OoyAoFLgDalmcuY6&V8+3l8RY;?a*k)$g_30LZKoRZcp1&%}hNymbTYeu( z5E5Mq!;&Qk`$uStn*H&G46iNbep00tE+)x|S0l-_MUOFyX=tPnyPbmJDoi*ae+zuK zPPKJUxkx39vl)WnXUbGWD`1B~9KDjnn5+E@?)#q=!ZtQq0+WQ{KOls?J9mbmly412 z@t|bp>Df7}a{Vzm3qF7%k4#YDG$%@HnuCT4x{(@>Rgz?3FSLnkB+MZwvtXX~2@~lmQhq#5gky=CX?u!$ybU;?R%5m4stcs>O$swSJ zGJ$8q4P;*M#OkUK(jv|K$V>DVl>LZ#AC5>M1{#B+Ui~@@W(1$Hmw#-P2q>F~j5m$< zmTCtaf%D230E&V%)la|Wx%m%na)TG9jmP*Aq@6fX_GHz=K=|5NacXShK){C{_H8ZP zyOoB-EMmn9VTvtnxM~2b_yz3rqc_#2!P zKfKhFV5Tv0fPVEn0MhlHQP%w`tqNOIpE951kD!+aD6fxQSt(&;ppg5?xJfq3i1r-f zYoMgKUTjR?)9aU#ni$PP-G?3N2jv1hwI$DF#1*QAPp|?tG!2tOW)F1!JP$d3jYUq+ znxEh0-zbl=*vGm?rn5K<{J`-=_tak`5zaiyU%qBUM%sYu2NFXj;MoGnp5zkP)CXV$ z3v!-d$1?Mrb_XS=o1VxE6UoC}R;@wc%WT;ytim-1;0oDovvKT~#z*h%nMOfl23s2^ z*AVJbSB8xs8ngK}i~Ev`8XM%zKY09mQ}iw(vB{zC1uB!2@@yKa58fv`s%JIM2$#@^$fU0GV&D zdK48_GJeFfK~g-Ik}1r}?K4OzgA@48nA6K8z1{Cz0)aG~SdJu>=|hy$+V1z^Y&fUE z%Wk0Re0d2=87oqPXh8jyh2cmS;}x6^KgL#VYk|_fNJy65w{t|^eBS_C> zf2>8NzfR+wOBf7>6nGjw>W^dh1p*2ca!!O%5c}p#kV*Xx9)D`02tE8k%*#vRUb8;Y zmb}!SqK>plvg@p8SD=1_fx~yFji;Yq=H^PLkxEc~4h|zdzzOB)BXD3T<2L^j`rG$T za3FRas>_f+c$3&fNaPnwBkCrWRk`$4Cjdk(EJCd_p}o;^@6zbst*3p;D4qv(>QbEe z-O(+O=Y-!eV0Taxa1Tgd`Q~;dWa=N=ZmH$l^!|W@6edy+0|M?sr768H^Obyq(1rEm z^wh;kkX3HLekQ_@1FOoYjLLRNw>Qqf!ke119|(RRGlR$)E)#TtGhbl_|Su?xJ|dY~X6 z78horv?;KLR1Mv}b&L2iUI{ZXUI`sUz5WlmlyRp3PYDcP0T~Abo!9Vb-@w(f;r#H2 zQ34#)FpC9o@V_H}gAfPnR#~uGn}hdz3JRrgoqgSuh1o{6-N?4;S||l6&Wr-px%Qy< zc?HHplQ;_A${s(TeMyII;BNxz%=T);pMN%2enQzlN0evbfVmo>v;w*=Oti^Z6y9Y# zm-z_IPxJX+<2&=%UW%b_-DK3DYq#~i&xXhF_=2xZFovYG(Y7z`Tp^kIHAJJza0ZNZSXTbEMo(+mjgqDtjTKR9H71jq z-M#x0NDwy}(An8zM~*e-Bb{_#=HPlF{)wB<$&Ivm{osi7gs4iNbb^@(xT8Bv+U`|3 z;Pj$6Y&`VXJ|>TFRuGTF<6ZsLYimSn%) zP`8Gt9QBK*aGPp*@Oh9*u_)e`PpWn>4aVGW$36#^Z}*aQ>%@_rmnT)!6^8-G1{k?)tZ*7V=cxeZ9x$Jj+S;&6fj? z&eXSjOKLp}4_!EQcrT*EK=z3X8F!Mpx?RkYnbD(Eu#~Ox+VEUPFNN5KJpz*ftB!>C zDo|j7{|dd;K>mM(!i8idQexLFziC1zJtxlF(S;qp8ihtDg6Ko@3MsLu-)-lpx8%vr zsYweFk}Y&miFm572z^(T-nUVdLB5XMlW zACzPw^@OYPZnwS%{EJ2SwlOKeK z^Ek*0}htO!oLiUrdB*Pw#SmZfG4GDkT$QH!MUN|$85}g{Z2G- zW61sZh5{9OH5p(!jF@5?pudJ%i#WvA{`tp{Pv*^P%CZ2ov+^i^uFIkvl+RhahHB&Y z`q-YwGR+sMmC7hM@25AI@uUud-ya?m$uv5sl#JDVDDpKqC^)yOf^rtt-|#lf?hFdA zqymv(fR~7s?!%vd=6`>IWfP!YhPF~!H7SBR3^DIxuv8tvg$9V>dkNS{Jp5QM3pZKN zK?MtcM0jMvWJL0A%E$qeu%zM0QYV}UxaAE8gyC(3iEEzDeFa4@=~z# zR-_iL|M}6g~57;wo!A_);0ZX`)mLG&NNqCwIL zMlSSBq&QB-1sdB)sYI5IE=nOb@D+Wv6N9dsGoVpEI{`)$h-EMGrPQk&r;hux!CxY# zU5>^b!3Uz%FtzbVLZX1YKF{X?|F=CTdO$V?#SVr650n924l+61nI>TQ;LY_ffFU%H zMgva%)&8ECNasQb$pHZYTtr1j-yos{#m7QkNQVrW3`;5zDXzv)Vm#ymL24fA58M|= z%tx%gRN^Zn?m;Pn2bUgVDKvmG4zv+?NB>T>O!|4J=WPG@G}KK{s1`wBpP?`Z!yQQh z#F7KiqrijDQ!59}7meTqRXUu;4%qJD1#dF&Nf4h8&|CKgHCb1{8JNM#OLlQGbuqb* z!Bq+fYygYG-339EBmeVT`xv$iq*3vy)AXy5PeR5*k_`yzv2<8e%8$=;*b9cNQX@xu zl|dCCSmmCr+22xb1U~^(3GgYInVH8-O|@byXW)&1!u*9e*(tH_@WUEUXlalSq%n=; zdv7{Axwt@Pclqa=+sFT0g1{PI3?&Gn&4Q%}!TLP63M>Pc5+;d}58MUtGg_T5SgnF9 z^`pkj<~x2wPpW9}aCBU`g?9}x?+gtHF)=auM_Eh3?d(8ppX~802Y%#{cdv$5UU)3r zh=nFlBev~TX#I3UYG9rOc+m!5TdL4DimUEXs4|Mk*vFiOlZBGly8PcaT8dPx&^e_t z4(Y3`L*!$nJ^9j0U(h+xMl~r%8Nizb^{U z;S-2A00uWv>A3r)@@6%iejKH%LR26WQE>J`+D97q61|fM9UWDwPVt)c7fiMqsM@LH zNuwSB9guPD(lCvUVsNoP^BGqt1s$)Q+dFN0III8aw6nu=dkd@$tawrwM_WoNo4c{4 z2NKHa=RZ=Nt(&p`xF?I2v^XWL!$Uwag1I+yk|IdUM?z@Mhy8NcdO(&jCuDWT5H3#H zGK`qQaIGiglGyp+R|~7Qk-x#v@p2}*HD^B^Z=TTYYc#Pp>$L86qmoPfz1i`Uu=^V! z>g=a2iR_BV6c&DfKk}G2v1TA1lTgm>zl7{T?n-Q_;MMwWNmf8C!cvMWZjY?!Wi&;g|HF>kO)FCkAF=!y`yV0fba z5#K~kORNYdOyBnb^g-ay`p62(p0Slm10DK5Cg0CHZm&nX;9&K6Wc7A2bGhkXxo23; z@vAHqx6||4JlnWILVrB_I>@zV@=!Coz8|=x^aR&8#95=ZRdzdskBNf36pCLkAM{ov z{xvYtr)L8(E7wHf%M9#N_PF)@sU1M!cAH8|}m;mFmg0j~g`qnuh*3?2Q; zQ80LqQGNQurg}K?@tn=w+CivQ!JUa@dridQO8Qr?w9B;Q(F9A~;@OIXG3+9A4@P2? zw%&c*s*f2ldTnu;Z3Qk9d@`07H#)dp!{0FAbgQc*DbqGrzqBG(CErkFJJV%+Mm`nh z*ybp?7{fpUX`HB73wOYifUgqFdC24G>-(_olatgV=5Es)R16lEH-6d@8$D%Hh5#gI zzzlbMo={5^O0X!0Pdn9_ibKbM;ma%KqaK4F4{HF6{tpcr*eY%FVMJ)Fjd%tmXnL8A zGjy!*>t}5cce^aYV61f~I~8>Hq*%%rM|?|gU)DJO^OOVp_lJ~sAYUScumTCIkCCda zt@naneOH#1MP>ppxabu6p?BiReo8%{YWj~rKg~cEa0QBir=#oCz7n9=BGEBU)NMJQ z1Pa3>1FO4tYu<(_2oG{LBxtu6aw*~V`h{2?eZ3S&%C!XGR{=rSf>(9CI*~rY>jT!ub~NH zp++GJ*@P7;*S_UhmpbIMz#fl)^a1?@Mim%-mlraTFF<#~?3(6LDUGg)H?l5Ne0Bs? zUW4IpGf*UdajXF=44IuF>j2^>>R^Vn$rZ%QlE`RuiQp|H^8ovSWX?fg1tbp`;9YPC z*noavO>&>@bfzZxO%RN$AeRk|)Hn596Khj(sg!XE(i_0(&XRV~>!G|pea){@f}BoY z9%^W@Hq9s)y?cNo_1QP;4y@bS3}!Cd+jJNN3P}EAT&N->;4S0<$LPl4Sv_lPJ~$BM z4Fs1u6hzT_Fm>MuJdh7KT6hi(2wbHjAgjW&1Kx$hnVb%~yUAkW?0O|fc{Z0?PTYb<))A?HexgN5Z zBk-sg!R$Tr&Qp9p+EFzI>{B_z)CGgIJm&f*X zn^JCOX4Oa~h`qm)zYw+#g6;mj79-UvERjH(H>3e{fRF?D;eNu83~e|I1VL4-N5|*E z!3WOaTZ8K7lLoT8olN$m@8P;Z5K9mqC2-?^z45}_SVAU;9DbG%#ZxddF#Ft?b)JL!9K z%CzR9;Je!?h&f-$)bkRIqi`k2kHZ4>WKz_Gf|%; zRLbU#?nLvWCQuzYFHo`!o9{I5Xjyr4u)05@$(`Q^z zoXl_0x_p*eNQM`N#~sF@g0(|&^?A;vZoQK~qu5p)ON_iB#)szaNdyW{9+VuMoF&gl zq0IPbI1HJ@_gQeUF=NEZ^t5m=?XkGpG~IL1k!lgyBt8GY3fg4QvxtnNq3c{BCFdZ} zN6DeN3oOY=IQq21{hnUYL)&OP6Ph=!Ge$Nwm`Wq3uplgBvTW$>kUn zbiJZOq{%jH9|Zp$M2VNeNEV3fyPyj0$ee8wjP^0%aqv#xQJ!MLRe*lqS{*c*;tr%)3+EfwQsqLOuNLf z;PC8I&ys4;CQ>@QFqZXQ6;Ew~jKGg8{V82DTQ#|K;ZUl@-ws}7W5asB-9*0SzZyaM zFi&N^fB8M09bUaijDqj3))0BstP>P5;PKn(=Kl%cVyS2j7z&y~KQu|L%!|(WJik!P zc#Y7%w;!@zx_2zBtPp*_TOV}<^(lZssg!fSPtGaKP))nqv_shr2x?*ma2#c)+a29{ z0r3Nfn%-K(HX`Lr$S)0~qkCf9^PoCKq9ANpywz+W&I7+Fp8~=4ab2$Z*eZf9lK@yk zZKq~V1Azt9ya>Lpw@XLNE>wb}K7Y`G@5}|?5FB`O+DRp2zkiDvGdWW5M#I*5`3OQ)Z)|L!(_h=42y04IUH5;O-RQ#5zls>%mUIamzfd%RnQSo3p!Lk|Vsls){QO?+fF1_wMmNJyGlC;Amb zo4%|jtZI^q{`b_cC?veUH#a8-slpfOeZ^>!aczyec24+o^4@}f3z_ACF*6CrdO;g^ zIc7T!8sNu|pgRIMh^M!=gDh-xdct`e?C(vMX70HpAe}?bgYC70&D7p+?D=iz}_Y%@?!(|DLf=FSA>b0sN z&R`+0rnm=}k2-_{*&VekkZB=2(>0kzlDzG$(7D0~jA(0%6og4)$+wlo$T_|q;#^Ph zyv|=c8nDRb@#7WnQ^LIitEvWJOx7r`Po=?5MU*Mt>jNDcvcUc&LVngwJFR4u=q~1Vd0; zs!Tr&z5gSSf412M*VBOqOkLrff`BCQAizMJIJwPC892B+@~w=26OHi8{=gGY6HsGb zLxuSiA19_e`yoHW2Ak6C(h?wF(p?I?U|9ncB2B~CxOcU=e}NqW9K_)Ms33|kKZ0&v zoocX*{Layd!tmqk%;@esKebTl#T*NDDt%{r(6nfXx5-$DuAR=^CnneSFQekt1Y-qE z!)azH6=%(SN;t9z1@Ux()kEA`c#%H&;!Nf5HvQasHp|(A=_G!z5 zw^Q?o{TXkqWB-j0YpZv2J~O*d=1&w`1B;JJf=8!7PA0F`yy@>}8B}W)G$hcnjsC11 zA>MMtdk@QeFZ`|!rgn&7C%!`8hHI{m*T##gry}UF8-4p=ZEl@c;?+NnI$LxK<8XC3 zVyTamz|7{=7CpkdLZ{2|WJ-)ijQfD1akZI;T8=1Xm0gAHyT%hr2Nr(lUhJq1n^5sT zE{8Bv6S*c5yc~UGK(N0waeFrI56?O#0mH|(zg|JCjc?POy~Xp=P!~yRX4t!28=Aij z>Z>SgDT)nt2?y4;8iMa+3bY?668A-JoVo=#ign^>?sa<1gh|YUL$)o%haERl z^uDP{Nc)yme8{4U%_ot8A3UjV?gbcr;=7OLmlFWm_OtRWx#FxD0@NTdHC|J8KOQU! zXD|WAWTy?F&~MeNukV5H?SZN3jlSnx&p7JPXjXHl?T$Jy%TzHjl_hI;wAGd`$OMH8 zv-N>v%HmQWUQ}Fk#40JrHLBF8@fa#2wQ>*WEsQcvSgey=g^WzlWNAyFsX_Tge0d5G z+)%hi$L^Axm9KP0+?#j8sIpaP^oY85AbYCau4%*PFF;6uXDXgV(&T@W^n21NEvcaW z%Nni?BKD^ubfa8fAb1IsSA>gc?JkE8L2sCT#EoBH9|2J=-Ffp{bBfNKURNfPirnTMoZH0RC)qNpHe>|-@t$HuF>x)x1-MTe#WLUZ z>lrBZ2$3A{1X@Ey;|)fgK4H=L3>s&$sZ3el7q#j$_A;CwR8UF);gce}GXTc6Q?Q=} zkpkV{I?u5nY4%r`whR$O<58M~-*f#*aiZY_LB?sy7yTC=Ao7^stvzTk1tX60fDf0L zQ^ir%)G5?$QRw~y7T)_;ru=u}Nra|7z}zqB%jGikk5oPtYHZE_BO65dq(QI&uq#L( zAY@8O0bz;@FiFmP`N)h+RyJAUtK_E&U1XDkb{m>mmbHKfkYqjQzg`_&1x=bN^a}bPagndyU!XqX%;8+8xZuIc_ zF&9vS6obw!5VpxHd$1}z91i%U%ppN_r{Y$%`Mfsn(!Fu)gH87Skg({saB&Rn1TQwL zQP_~??R}W-U+*>fNf+GH1%*%jWEPXF|NU_vnjO+q-SeFoJ^m11Tps(|iQ_k5TaXSv z-v{oq@D3PZbKha3D%XWgS1*1u?*54;Rc!nHoOD*tmDcd%T(~sasO}L&_WUY;pNt|_@k-IK)?y9VVj3c`TVa1h=3&&iMBV*Z zB|b-WE%%w^rX_2CTQ$4VeKo3>U){~B*5t&Y2b)JH{&-6v(P0-0UjAQ09R`9DyF1zj z(O1dhL)%qWXUDy5zgByHTz$+Zs>Eo+d`5fH>a!zKej&?oEzvN<*)3?4?80(V#AETu zM+duWSlho}`MLeVoQSpIp_MXT%F^6{&)Y4c#0~k>@{p)AUJ5cRUk9e}$Yya%?zv%C zrE6{W$9{bqCpB|-*)AXFjGHtcw(_pgYWyq>JY>269=YPa_JWr5@{7dvQy-PCZT<73 zfYshyXoJ1Bj_(e6btj&q52?O+<9x4A64*(nRS-T_sdpqJjU`fRIX*mD8ZIb0XfR^7 zy3(v~=@QJL%Rq0@9>l1*cKXZvW)JM_0pWx|>|M9)DU(=k+h?H0fZO-Fsxpj02n61B zOf~ovLS9OMobF>Uc&v?YQViCE%yu?}P?58nedMxl zz#J)W$|Tf%f9N|V%k7pX31J`sWZixl?u`}0in+=zp?8-t)(qHQ2LTxF77p#aUDrvpJK3Lf^@s#0ALKIha6mE)UuO)&sH;cf6#7c&E#f#PNFA@4ka{&-V<_PAjx221~i# z5P>_Bfe4af$)1c;&5#X$dwjVXUKuUAGg1FKS_fv-A^`o;)6*%I?$)c0DTH5tnP3eA zqjAwqx8xrhD8#_`Kgo?i;wAc5qEux9bU?*h~y~B@q7Tq(H6pk zWSW&QwD8NXYwxe|5vM8FsVh&WQY02#b6p%IBbB3l2#8TIWC6eEMJ``pANhA1Q0b61 zB;X@59X7k}^Gha%c!;FpI{O09qmmcNYAG_ASXuuxtKv88e3|N~x_9AtKnGQ(U@6d2 z;A#F%F{c2#Idt88@QH6pbKc?a<$T?e2LtUZnfcfZClYkT<<%Lyi@UyxAW`>qK7oG} zWcGsSBC@jdHnm|yDjBKHaf07fpa?Gi=Lpq}cLrlIPRCnl6B*e_(U$2FV}2y!13@;}SK*5^9SuIVD+EbBZa+9- z*Cd;8cW>HGmC~~EYq`_I2~bynyQh0q=<3z60JfIZ(5&E{d{}Gb_U0oi#vLbBORJg zcR#X3B`0l!35D2k$Dam_Jo8Xflt{jMa{Y%G9dXl*km=lCZI95p?kBbP2O76_V{=}G z9_%fk=Qbt&ismG2I?$F844JJh9iHtB%5D&@eGNRx-E*x@jF!<1Jf`Lno5XJKQ9kk3 zM|&(Bgg=>~chU9Ni3m!(J(JYGXr`)nYPMOXwo5i;OLporKXG;z`2p-A^2WYBw1ZqH zQR@u$3WYbKi36_n$@s4iv(ELSBys&@&&yMZqG{)~Dj5S_V{dtNls-ITIQ&thEN)rq zox(^U=r6EKzmZV2;NgloGk47}(=-&v(hYKH-1)Y#<9xp18tA|JZ7S?f3arM9>N{9o ze6Q7}dH`O>I*9o`_43*S>>0qNV1}^ry!o^k+CfB+{PTy!KC^kANMg8lxTa zi(_klq6fChSIRZTGaq=!{Dg%D08i9~`+e0=`%;7d(U38<1evU?tSCX|NF#9gA*KQY zPRO)KVYD-D!YRSr0UcjWcO0;+OJ}Gljpo*TA_G8}gGRXK{rwA=4c9a%Kt{iAy~R@` zFvOj{6En2!^og}be_*zW%#8+J5gEG$|1Pe|X*i&+78kGBCVRZ$jF5uL_ zkcccXi46qkB>+o(V+(6#ei6%nMd;&GiGEPoU;sT*L1x#^_*9!_P<^}D9tEy|>^%rF zJrW$=Aba$ur=QZvo8|JnCK{Uwmu*QqVn#4W8cVeXTyB9lH1^p8HAUW_%hq`B`(2_+ zNbNUke-$>L5_-qNLShNRqvk~S#vM8LG)NUe(*WB8B*kDxK8!FKgx#q8OJz3FRO#+l z1muOZK`ahD6ZYvhaA=DXdDHKRE+deDT%gp!`s2UAB4iENO+Ft~KGp0~ z%mpBWgv>%N_JYo=N{Wm=0`(1~8(6Vd-4M--qy653X|~aA1K?q>YbC`QEg*-20ni)s z3S=t{VhV%(lDmuF8R42}79ZW2oxRuYQ-A~8r0L@#l1q-Rfu#X>{(47q$siPGF^xQ| z5o}ax`V7xAlP?ExT)d_>INsn;D}=7IQ#FPEL#y>@cX-Y$%v>XvF{(8=+SVP{t^<+> z+N*0P68&Zt77gjzR+HN8!L2oX5RhCk2zsr27^VzV-(iHth;#`)Hh7q^zR<4u&L~uM zf!v6UiNH&Vz*E+LlU31Az;nxdQNYWE8!1Wpau z)PsDL)jV1)D@mttYa-tbL=u3A1=ru3)4X~BhBM^0dHDIiE*@Tqqbtz11LYz`V|zsA z7*ZB!rw0s>dth8uvHmhm=jd?yj>Mm*m2v4OC4;J~_H`I6>9!dUhTYKp9Wss2i*#|# zhaHfRlPOS}p^sq1^P9M1d_ZkgfpCg+v0)Pn8I@)~~rME6R{ZGLkt> zqtTL1B8z?T?3sOHZAawX_t~?1%bV>YBT3)jVB=S+EK*oov5^*vi84^Iz?Pq^X6&+Y zBUNNcj|vF3B|p!K5|4>h!T5Ao%ic6(jrQsFu#r$iNs`JRPi<{To$pw%rOC_sayVXC z=C}zu;xyR>oYm_V5<8Jy+d42(3(7j|e~>N8g(7arUh66n>wAZHUyV>pOv}%o?3LnD z`QgrNkIN9rR;+yc)Q%3J$)nTEhE3_ijXBxdWYT^b01gAVXkq`~6Zz$s_h_;t2G&Lc zfvE%fq&Agjr_8(Qd^n`z*LOP)Ph4w9Z}k6Q3Bn87pE=C?<8Q{~C}yy>`*-6B6F6dc zb9zdJPCdK{#!6qD_9wJ;*0Rs>YhL7x`%Stjd}@6fm#a)RQ>|?2b@cmq>ww-seQWZx z>4Nd%ttZpefmd4diqV7foLc_#6D7rOzYrJAh44l1g>j0L4zkaJehT_fQ1$}$e%^+0 zwur;CGHHlQ^y(t$OuRE^CnrAW{tixoMt9#(U~(Podf;dSW796AZgv*CKZ`iVuiphW z1E{oc+=2b%xDOY{_q6G|Iy+?W0sqA)NG40zz36g<*`_+CiS7-w$?=<_Wz#0Gp9cN~ z&A6GzrRfrwEF*ktW@h@fbRId&G0K~eR_A=>wq^7b72h(BOd)N=>3U!goFs;qwxRBB z!zxnm-3+@GLD{Q)Y3WPUQk4|h=@t+$Aw+TV*CR_N6#5hf4S*#8PvXuqi{DfF0xY5h zzp!lmGkFf-(}V8@-ULp|W2RCoGGkuU*yL7<9YqU>bE;_wW)6lp0neSOKIih$5Kn%4 z!5g&3n7Jva$61t-QSbbk_g>WtP-@reg4N+_-tjA?Fu^EgwsSDXvF$fCl^Eqo@8@o2om_38h5lp-oc8@Q-g>4=8Fz zUVh-~tJNk?_EJNq-9rs#*2$!ef%a2iUes8}guFP`QqBWp(-7Rp`=l(YVObHjUyqM= z$i&vdl#^)dBh>WcyXG!zP|Ft`L0eW@De;w8FWs11=h6pUtIp*hv=C)FkK%>>bhU~UG;DFQ}i=SU?IK@?zQW6E`2 zrzPXEA}|T)Mh&QvUBfhqX16nE_6bZw_n(Q+M^F?2BW@6u7aM+}rI%Zm?7HrQC54zamZA;I=CUo)m^ofCu-@GpMzuny8Jtm2ARuzV#DrwY23M%+ zlFMKPMTCwIg%Pc%+f_5Mb*Reuo$kX79qzjF9+xB3f^AAnE~#%ylP9FUyFgO}Ps@Ka#mr=S{XkNnlMZ ztL$mhM!4<3v6M!?0H_qWsx$1P()2uai4Y3T8s-UjG|F#q(+<7 z1JXh#X$u)S&!+QP$bq2m1ukaPd#2_V3)Af@^QH<_q?NJu>;`I$g2}m26 zo-22#^os6Fdb3q@)R6+J*W5N(@kUnT&Vf7nYG3A&(&&hCn6$*X!eR5m)SlFS%WZ4& ze-t)uG>YxLX1n}ER=B~3KX9iml)TY9()!-GEG*J!bU;paf2*N)q;xlaeRtcxx%%$X z_nkLF&xJOfYOC;-YC6rmcO%4?lIe5xrxhD^zADAx+svgioU-({zC8YsWN@?PX3OUL z2RU1P;)jyYHL|>Ym}j4){E|E;jVp~-RNdP^QyolQ99%ROvB$lKsX~p9phU&yX#3W6 zz*s@?2F6WM4aq`0aM7?Rc#EXWg_4|txBe9nqolL6xIQ#CJ~s4*dE;y^SPdZF3}x1b z=4O|#N$MnNe*k^{Fs%rlwdJvDd%Q5jGGi^KrPks#nWt4qAxEkYW)=9$s=k%w=9s`% zCm!v^e7vw$3aJ&C=7W6m4Fj9Z_Y=V)x2y18C2BcoR^$+F2{^{3x?>xQ5^{CbzZSrP z@Tm=;7tkkPVTd=s-o%SO)Cq^X$M!9jsK?XbICdhRFGPK~?Q8~I9M{82L7km|g?q?g zqKL8hl1&Q53xK`DJouLUH^ogn^uYr~hkF!>WSYH~t1u*4SXr~!msk${WweNVP9TQ? z;H0sp6QXp`m-$II&>qUs(`=MF45IgBsK;@c9x5gFA0$`X{}QLXcXGTm9jQ$Od*(2ao`8r#~`%;HjOx@Say!ty*{~-IN6_ zazs3w=52}wnq>p!rVP<4h?1`P=gVv7d&)5*f#TqlZIzebrUmD?QbXtCCNzYDV~CG0 zc9qWz@InIj$LvQ4BA+8B5~Lb5E|U=RLSJL2J>KeK{S)Vz_f?O_mV_ON0w}vf5EvS@ zv#jq8U=~H(q3{_R{g03(!VtE;)sPD*KZuBnP~l-LXJX@U?L&fN)#|)As0>bf1PMJ| z3(u7UOkAj59gqij&UzH6h)B%lW&H#S^-Ed9r#NrYk|U4+IgBae>k^iL+)xP%M(ehV zi;FkXijwh}Zi{@A=Cz7pXJ?&{;f2uSw?%mBz)(`PB)V*&wa*D#_JE(h^sEZWdV{AE z9IME}i#ZonvQBM&CFLGhIsqOy&tdfdyc*U6f4S6Zn*dm0D~MoyU>_gkjFImGu^j#nmc8A#`lZ+b{{ z2&S|f;0#AhQ;b)BLz8*8w14KtEgB+{-s>y*&G6oqsVqvo!(+38pB;>2wI|qeZHlF9 z?*T`h^&L2^y#m-=^ik2%Q4SxcHvR&n9fWR3$c-S$KlrQ3A9SUF92u>tMa`2i9&tEQNVs{>aKrXR=+xBdSYpCLtNW%YWF9ve%W0M ztjS*+n8}QmpLxj&*1GR{Xf}lId)c2V94#d|yZ8S1n-befKkbKF9DhuV5d=>E-}XDz z;}Kha7^&F}iW{rLggG|KF|K`Qmb<=fB{E5DA#FbU4ia)=dzT_~cjt9Ko03gFCm;?B zRTs~BI=fL&>7T$_C^#X}J$oeTonzg3Q0BRO;PP;)IdQbp?~Co`PqJlR^6=*P!Ltoc zC0y~QS~N)_o13uXUBQX8z+;KvC8op1#VHeDA&DCcDc$6rFp2fIij7{{3HntkdOEfz z_Xz!5@_b5Fs%xW&Hg`W01(J)BFtK(%EK%*ZBZ6iw?^-+*guwM2Q2-oT`|rSGRlFSk z+4xH+Nh$2*cd+s>&K>GMIB3AVa<;{KQ3c7P8f@6oG}bL6uTTyKzjs_~t{M|Cb3&Zz zPe*fL?G#9X@K=D)Gm43Q?~bYIyAqa`tCMciimv`V6w^BWHlO~_tfeN6f;X!COknSW zhzzoh(GVb!h&K*wrJ9||_e>g-RU1;VzI^G=pAQxb*>F7JpI|zMHLL)T|D|P%>|Uyg zLzUeUpoWbj{7ft#J1p+rm2^n##^Y40P*C;&X)S>%fFQWXdQqRldt~>hWMKjEuMbY&)0taU#MOi~KQ(NCti>%M* zR8)#U8Ijt%Li20|w!gxi#-jab8bjqH90I=}&hanRYsl;w65IuOwU4u+z{nZJ1M8+@ z;=DJ&!wVC&|BQUe*(y;8?F;sJ{kN%9@oyBMiQf1ftn>eWE#WOy4|ut1=39zUedQFz zZh6LZ-U5Ll3O{t4fmD#0kB0AL4uoC=+tjH46l3uLrf_+jp51yMF$x&LA&^%p{M8aLYvM3W#pmW z#@V#d4N@bp_XGyMMLeXi68R^rCENQmb$+Y)_-7?D0D9yK+g1v}fdh>P7<%9*T74$m z1k36T!Q`z<0<(kZ<5GiM1d6=h2No_)JZ1vM{VPuTQjB5ijo-AxOE@iEOH{Czvm0Pr zp7L>_@(`TQ=c|?HItW{u3L_SW?>SBFe4VMitDgy@?L3^?~c%Abv=mR6aZ&=^riHG3;j}ZH=aY_W%f$FEQ2)s z>ooBEeN-G)436Ed@A^oiQ3xfLtoQI zj5|oq0+gy{c+Ozv12#{v55Z%08yZ6eC)o5IF%Ezg$f=w#^3_6r0}sy%ERL>Wxd7q3 zb^2YGtYh6DHY{yvjrP=Au=NS~ze3;rhjEAyEbx$I&%pcpG%Db;w3HOAsE^my$N4^1 zcrWkIKd`NS(dhG?<*2{ZbiL8CwvH4>5$<=O8sgP}$?47I7)Zef)WPoV6Hbz>OM^zP z9v;KnD@8w48X@Q@%hC6~zp}8#;$*8b`9U|0n>LPS7v*~eafV_RV!Ze|GN+}n z_rRka8NAJOc(&BDGJAl>ZBvznFE8chU^A!FH#G8lvma3l5rL$Qc_%!M~e2fsOFUE4uGP&qy=D=sd zCfgusnP z6CU6HueSaEA|Z*FE0ZHTD+}f@gV1PPmC14g#!X{5JcWC?r@R+2P`)*tZtDWIWh75{ za@g+z6fAf(ShvP`(?J}&BhT=#{hnx8GcY!;%Okp$PZiMnp;CcKDUy9hQa~?LapE>e zxaN2v?F$_JiV6Wd5C1$Y!@MZwo~5G(8NUFyLdx$F<9^jj`S*m63fbQdGXTNgC-81w zz3L91C`rlk0_2CU3)@=!zuU%_G*J$Lk0svq5Vq5ro2m(%H3fg;P zl}WkyH{H$IRCfh$a_NM;5$aaB2e>C>?!0pcCu)`B3jTUlC1AKMleO9lZqU`!DJyR! zJfw{48!k0~J?f7~TKD#90wH$As0K^0knx@Pr(IY4CofEtPS(V=+g_~$0pTU{%!i>7 zNrrfEf-Y}w4-qrAw*&G4aTOWL`dUr5km6wjBA5vY2y4#{D9X0MuG0!^H<$VxfZFj9vwBSNvUaka$RvLGW5d zk*#6hSMd@Ld$;da0ynv$KGs~lB4zH5N-?&Ga(ow;*~8?o`LKJ}UnGaHNR^@FiAoJ` zGPE%N-^EgR1W^KHd|0j~Em%M;1x_j?^9|jS={HmZ9Y(Ii3-2{ z*Lg~*1(J$n;-zMy)xg2ZpA+;kID;=;ZXag~MHyF+-tl4p8;{%he zk@gQ7oOtbp4cpOR`x|9HD$?}wWdO1At;$Z(pKJWzQ)I*j4+2d6Vb*x11Ge``U;7AK zk3BxHV?X&kkv!PC8_rW;bJzvbcHrRe?Oe;r$mf{<0lptIZhI!|h_K5b?*Osz(NlK_ z^z2mDe*B31{h?(;(ly?k2%AJF?Oqk=gb(=1(q8d8=yQNGIEf2EvxB_|6h5h`;DD$& z(=rnTkbCQmr11=lV=G`H;(3Ve_L+51>UzunSbGnDuJ`|a zT=rh6tPnyPW>#iolo_Y!$cT)n6qP+9BYUJ|X0=mkDO*-%l$Gq6?7e^2^SnRb|KNAK zxpg`vyq>Se<36tYb-ym_PcP%1UU(zo82UhhaRqvK7~uueUl*#L|04%$qK2tSK!LV35>!WzHiu4kOy z@N4VJx;bW`14{0fdn8x+0~;wluU=2-lWcS!>GKldyh_bfGdiLa&s`HeC&EuXz0d2( zzn{%i(^>g0jJVdeuQ^m(iuP2{F^^YPR@RX0=KW{Uvw~8-{xYxd;_u)LxzKm+_KGTu zk(Rgm{#~MDzdO2YE7GT~vpc|xDkPMZsZ+`%Ajz;#`EY6PVvebA?+Qng++wppf&7s} zA|%_Xr$+b5@E`r0ZuD6B=}M8-zLnEQ40aEClamIp2pu(|CQWGAJL42s@ijSLs!9hGK`=)mCjFd00(pOr@bCqNtQ~c8Pmr;s(R9jxzS{q42itCq{mjarW zqgd@z)+hH(POr~-#x~_#5AeDzHTL)mfaOz>+Hdu<$PKnEGN_8k0%MoIIy8R$>Lp$) zww=B`x_v-L=69W!m^m}!;}Y%|ZbF#s5%kdrMIEp$z@e1A+C%W(MjS72Pj?q&fp&z_ z$BBEe$Y#9iX^maJ!23@q5-)uWQR>Ia0~Djc_llu+b~qAy)?Jym6Vekv>jOW4W1-8j zk{B$0czv_@1W7jKmB7$BRHHhwt7>TsKgzcEM$qipk(8SH6MHjzXW%-+QXTQ0LMX@g zp$MJK62N4_XVLH+vIp)SYCue2>yt0PKX;}*jFn{fLRGZT-V9ld56rJZE&gYZ?l^dU z^~-`rZ%4=Lr`M$A#@!Uo{5tkjyzSoF0DJ|AvUeh{M5ZHhbWXlNGfQHw9+@vLc$sV^ z4yEbqBLsL3n*w!OnmKekXKbRrXFIlH0|1jg4(}9FZSM$?CCxj%3<&3#(UY>iE|AtO z2zar=^DAw!1dC)ZFZhU#65`m;l&pNAuuWLPX}SwE1eN*APtLb0|H*wCcgtm?<1D{o zW*2I8P;QgEM&yO~LRF`z)u<;lzSh@REs;Z+srtpb(9Fm!=zjTfLvtmfQ+j1m05is@gu@MF zU!jYP2zm}9T9lt{y7ok=QUc|`7QO4eT(09){t@|~3x1gM&Fu!ojj$`dSDxY0=?_KF z)?1)8Adc8cuHTtiWo8p$p{US-Jtq++jm5=(5`&e8ZZpGSN0sA*@7MJX7fG-WxkFII z4ZdXvdx3n_wSg)oh8xA!)D85Z?<8urnCD9Xj93|Fx_Yv&ABF9rfN{VRv60mAB>F>5 z_DkzNPJOJ@N*h|1o!9 z?f3nBM0zseeN&m}<_kJt~t zw;P5WgeS-34EEQb$Y+5i8D>vRZlS= zxp~I@2U!#}cRwzRSIC);JE3I#a86oIH9HQIu6v_8vgFF!QrXGuhbp}S6OPM~ z*)6}{=85cIm0KTUj?wV_0N7h?`Gt3iN>6l??Iw=Hdo09bJ(JjNt&oo9G5Am6j8^lJ zJ;TYh9%?u4#<{=B2@LWgP2{8bwT{dlo}&Syv#ZSCuAt@t3bGgYwQcO75H6-}UJaQJ zb?L3&of!X>9^_Wg8QI6`6Xo?Rp4#G|p%`V0O4f3ykIDI`CiU|}W<~QS$jfq6jYy8Y zUH;1uMZ0>*7Z#9RZ6x+oHrP939v5)qO?^w{-c!sLGs@?gnd*S<_L1U`ck>)Ax3v7X z4EJqoCu{R7jDLyrbCFx&F=C&fdt15gC8TV`6~%gsfkNo_Li~MAvv)7VVm}IZu0Bax zv^DU#5#T4Y6jM?=%`zJ=EOeaW)$*-hQUk)fnn|_K{HXU*zsr0A0eM`gxiqXYY2o4t zc6Cb$RdP*#|JlB@=(GE0D5U9L{52A7+__z6?$X%)>B!uzvMfvTQzph4A)ms1iz~8k zt3BQ&6-9F^ZF66_(B@Ibk6t~bP7z1$Us*UX`rz2WH0`QG=5@a|_uUH-O<`VbiZuea z0y3(99W``FQCH>-@x*2vbssJV_YQ9H7H8$3ieb9SNypz-?H4iV9qg{?FJ1@^mSW#? zE<*C$6=25^GL*L|;8x6Wpjp_jW<+w*0re*M6$AnU-W=Fa4M(@<>cn2^r&Pk2P_uj{ z=NRt9xkD$jin`rqB|77o{lsU!iE%qEByhe(z2{o+~+@(Q7lcA;^WLN7Yg!rgR!==y1 z+CEK#SQaQl&prF-RVlr(cjVLi(WNl5@TYg&NNNCvJJmRY&k?z2$~F#eRyJp}~QPzRVdlx->0H|J1hzv=a{ zP~>KWfnKehDOuA>XnP403%x$Mx}Auz6*vE?UZ#XWO_GVfS53T!Z7G+l<2yRm)F*43 z{ZDGHeUNCDxp*_~g#F&%@|&JXZ+4&0<9iS+uVVuD&>|L+A6|CJh#g}=TDly`UJ+-{jwImN?W z9rTVY``|d`-oOWex2q)hSaa24w5$|c`t7sV*ZcM=PI3ALDphgp;P8NPAIEF7Hi+@C zp#Fnd2yIA6em6Lxe-9A?O;34VAJz63KEaPkZ8IDFBk6CG`|KwKR7t5)YOpT;ggY|n z!P%+3N9kW$8b3SiQf`&G?n+ip{!RtrIonD*+NJ~Yj;mcQKWc4qw5;+nJF}Qc1Q1DR zp1B%^{?M7VQhh3tY0PWSR1qc>;ra@RE!zX*s3M`_*JP94!^{3tYEpRDGbP3Gs;pByiSsc$`fQAc3(j1hDxKE|RgDITP);!A z=oEF7|JgOU_(HLChRkxaN4wcW0;K4=2L82(8?c@hzf#oGU|Wn14PdBE#=1PIMih@{ znufpWzT=N%H$Ia*w#hKc=qaeGA#75h!7AVH8XEEC_bbeLak+m?FmOrrvw2(zb8B_3 zTCSrC#*W8``N=E+IUNqeFHQ5S-G`zyVF@GH+AANO=|bsJUhQ!-o_76j^3H1?TrQk` z`lE(#w@%`>!MbA!aeoi7R2sjkN?P22yOsSIOTAlYfUghDMze77L%S5Y`czJX-+XfI z8o$SGGMib3q@B!xK5Jxed1qgtzUWRzDgLt=^cG#WG`N};2_1}i51iB{(-BN206YA* zqd#P@r4hFtQXkL{zXsy+&!tVoY_J5lQ-BIAsU>H8@bdJ*9F0YAES=yW6ePmHaQSzL@z>T$v z{)uu4LGwP08qm=Hl4^Dz#>yD6(@Gf_0BNB-AO%uUV7=PuK2fV$fdY}!HEIq~?&2hF zO|}YhNy_17Szax=GnYUPh1?P@@}%n+$-&y!wEuErUBaOfP z&Z?Y%XAHEcUp!(Brh3f$mS^Vmbf@aqfu?J4tifW?-)*mIV$I7f$dWGY2J54iQZ5mu zi=KASwEB>La#LP^PoyQ-pk$I)^3g?gA8lX#}!g|)a>Hq{tDEPF>MVbN+KA%CeYxNcJHO|*XP z7s^02n*(0Ts_>=23U}FkbHNsV=D;V1t6~LCl=m*&$VBiW6libCnA5JXwK%MwvZ{vI z5uloIW$mZ0i$(s;sJoUsizh_LGRM5%-hgNq`={r5@FAKjiqS0Lmv88L?Fsq}t+~ouzo~HN?>lD)K}-f$)XXo%puAcBoNJTYzHR zsf6Y9&J5nP>0x>8zXFZv!l7@qx*IUkKzneonw%x~3 z`>91w;*(H@AdO?TfC?Cu0W39$C$^uJ2GeW;O~M51A)p?78oUVbIrzYp1nz_n{06Nk z{sdN&C=$>k;$6U4;a-Cs)MgN*p@jMp3pAiO0hBm)u>O=EAWaA&`>h#lKNZAJ-L(b_ zr~j$cb}i!@;43~bO=++Le+Tn9d<9r!AqW%r0@A(?6poA`K;c^1c||4}^jm1ILbU$} z-W>>XgY=F^Loi&FJhM@zqb5Vg{uHFEpO=VVe@$Kjs~g2OUN#1=rv+J!5NL6V{->t= z{v5O$h;BY!*Z^{_yu?r%R`fUn_(nJ__&{ccEj|7@N0N2ZXBenMwau#v5EU4=u){eS zw^hA8>$g$nHDkHmzWrWseDc@FwYriG0;iAMSjL$^VTzU?6lCyvy--rJ(Np4K!2l}* z@r&6@|@+5HN-REV}AX9a(R6TQx<&S zsV_8bb*i+cZ?C4KO+3E++i$sd99s+aTIfKOl5#>wSEcHxL_MiOvTEmcv0m6a5M0m zm-WlSn%4UCRtlJG1Uai@bMh)^+XVeb;cnjlXb1#Bqu|K>I)b<0x0b&3cny*lk51-f z`mKs>=lHJw>b(TFK0*Z+uZb8iSZ@9~ODq}S5)wBSRhmwV-+J%XM_l1tmNk>D)Ns5=63Jg$KQF|rc=K)SUkV{ zP81AR27Zg%g3URsnGn2?muH}Ndx$eaGYiLTgaSrXKySm%Lmy)Be!>Nvq;ei26o@QA zxA77YcOcq?I(Ypr)ZB2aU^?F;Su$EwikFHT{~fz#Mg`_)aKd2=#Pqgz`g!X(K_?~W zfG7L6fxS31c;vWpN)uM%hQQu#U^*Uus6-H2)7o+PDK_#)t+z<`_hBH$8x?S;U9 zBlWh@y^}g|@Ls{ogY=Xv)~2BRvJ~heaQY%s=n=uE7I{#+#wFbD{kwTKI@>I+Crsr? z#d~U|m&ORic43Ym9`Kayvp*6{zWd85e-btSUVq*|k`kJ$OIOqmz3#4Tbg@rWc>aRA@oo_^5!1~3c>YPTF z5#DI^AUh6hc(rBx27{Ozn}TN2O5BW-MKvLU5b(mqhguPSO&-Pbo^^Nr#!)a|!+JM< z6x+tq9CUY%BU}J&HbQv$&+E$sLw{Vh^+?UEn@!$A|HW$&*02YE`5$XMNB1*iEzL;; zax5Sgp`VN|0xcU~8ERV~A}-4#Qc#lk0zkAJcUPL)c7`QFH1S?e-o!h0`LI@2Y^^iA$5JV8OK?Um`~uyC2n<-h z#22KGg+Lha3y6(DGwUpFY=OCq*>M$}_Si!L%+&aSMN;*_T?Os&DL@J$9_+gY!xoG^ zq2`InCulA>Mvy1MufbjQ3aXrHyUY7$f>LgNIj=5VG>It$F5kx+*d~t4#>InvoNF!T zk4s0fH~~Z9B;8YIJs*LDwZ;*tDa`x^;Sf&%1Q?{;|HX3lI4*ihJx0~*RfBKvF|O^# z=lSu!b8-+2cT7K-YY;sNF9nF-WPR7hYygG?Sj7w85M-qRrwjKAZMOQb9fuT$+ZB?F zO0u%T<0os-=HNmi0_~zEuNRq**A~PBukUbGVmpb%0OuqDh9J6k0k`e=#=bk4KwLIr z70D6ti|{5VYz1(Bf#vlbOxRDUgbIe6(SUs?`R#_DOYd>N(U%icd|X<*it&YoAAQGU z&Vyy57eW@(U`L22?d&$Abh!wQF(FB!ncYLrp2>?;7LV<|acsPeWx|(3NdaVf2 zui?{#wp8$pKi~7vxW96=1A2hi89{-YQN2xusT6>0cO@I<3-IiyUl)M` z(-`Eg5)?UvzfjI&D6`h;!2>YlQ|q{{V(YEFIQ=Tt)c>Lgl1!35;a^S-?Sn-?h~ds* z_1O%hq`9yn-JRB<63|u@8q{D_^%nFlpyeZblFwr8y(t6&Ah#oQa($RDT2_ z9YlSnVP0SZYm^CwpaD6&Ah>jQGbN6Q>}o4jk)8PJ6U^!@EwRoro`|E#dEpKVKb3LIe$czqN15BWfD z&)-pPL4KVN7JqN}Dd~))L|5A^dKPg7NJU3S?>{ep2rqTSYQ=kgVHsH(^$LOc!o2{Y z2-K>ny{mRt#KAhT8F@x*Gb~`*me1@4 zY78MnVmXaCrU+4}?;0E{57YuZ&6Uo0ewF^@#d0<}PDh218|Ut5ywBf5VV78gcF z(wSpTCNIwrGh-K;VD63=h(xEKvXi44(ha=@=)<&8GBi7PG(`K8`H|-)qMiBT)fTY> zZtnX>9%+^c#nGQZ0h_o*@@SS>Msrt4xz?D-d+^b}??|Q=c9G*2WewAH=4ta(dsm8vGE#`!;+X9SMRKp(_c11jhNSaSh4d|~Jd+!*$R7K94O)%}B*OIDkHTE38-{)}LP9yCaKVDaDfbfUouSae~ zC^fQpQJeL}?-T!e9if3#+*IwU>rZu(^LQ%dhnb_&p{O z00clf+_hWIQpAJ*GItD$8ko-kC(=v_CAYsf+S}QQVqHf5JiN%zenQOxL!nb>U=dES zd_88cHDrJ@wE)jk6EydUR2Mg|6$&P?QqJceUSc! zQwp3b;66&;b#y{C7~3qDqqE`x9w3eq>|LA$0&Vtxj@9k~x-Dv1F4I18eHk#U_ zCo($D<4RNh?AV@ldi8<5HZlCC4N%{${dt~8zmMF`P6=NK)dzu#&{JYo5&3);Y+DpK zooNe+XKqm_Kt*Sz4s! zy2kz>=bd|bQ$YWxF6Hl0X%^2yE=4J^6=!n;c6E8L>7QD6%q#rbyqdik-DC8~vri2D zNey3SITgAUDp-?KK~ef(CRM~(<~q=SCZ^0pVKes&_d_D=_m-w8R|l8hw`HXJ&fE0o z-k5al-PJk$2e;lbE4F>(7j*8Ac0T((5hXbb4jDKWRDl}BA@}l z>3{~hIK3z)wxi!t@Tc4$DU)ncy{>#(8&b+LeBm1Q3En5$V;_ha9q)nNQmtI$;kVi* zBq=@PZbHAEwP!;@44<`< zyC#>u_I?uPZiIU4TOu)IZh$O+p<$><~|y%d(k@^yToi%nrWE;0aD8BSHxj+I@KOyOZxw5@8Q zdOMWPF)muL?K8KlZAt3%Mk5q!gKGtr`#b**%{*}D_3+H9_=*F9L(QoH z=7M86gvO*SXpqkvebX=U5n`=&LxyI8HBEeQu3D_PGY0}8b3rkx1ZARGL zdt4(!Z$fa$dFne8>Y-Onih<8^TZy_4!RrAd|JprU{ln(bgkQ~_L7ivFDwlw}qIg37 z7dl42Kv(nPKOuT~Kv)FFU_ljuFM<7Q+>eBiF?*scm5~Vk(msJ#4p$u`1T!?7lr%;{ zJKhCp(bTc-59PPt5wPh^e)sy0snp|MFLB+nK*k2 zUwg&_Lm`B-LTmaBcg0Te9P=Yw9%In5CCFBQN(mM>peV?1If6Mrz)f#TlC=CRkq9yV z8!-~#61hI@P_M8NENr0H_!cQSP%x9hFbF9eOC~y>qqzM?R89MsR=lF&wTFd2>=2>L z0h%-(JgMK%I|2%J?z&0-%(l5S24ymC_y$^ z&vuf|0tSL1#o%m*Vfy#6XSJx>;PlptHJ%$-s*2P+t8wa?J03MEo3ahywP$wCD-Vs9 zxOG$4{nqMc7bou?wKNjy5wIU*?$noZHY&Do%wpf1Ft1P-=uxlocggdeQzb`@^s^JG zJ6XIxXNS+}HVP9?z-e{EgbkbKU2oR38R?(~pL&JD0jjwwsYP*KmJ_1)-g?c=S6MOi zP;C}pUD-Gm6(_vLe9ex&QhbPaZRHRl9kZML!-0PhuV9O3jM#R zv~UCo#6epSO)Rj!qwMB4;sNrUQ3L!~eDA}KBMa*f*Ri8bx!=p4$;{tCYGUR9NBZ0O zpCt8*ZujMU?YH_QR>pp{cYFOlZb?%U{Fj31SN=%$KuwZC#hXH5YR;7Ek)V1u( zGJ`oRD6bh=P%|3Q<{VR=mgYP!!QR zQ(Fx|S-eS1cl!kg29rV+(C4E=<`AX6F7h{-J8kn%EVQJRjAX_}Js#ehxOiK8&!_tv zip*)Zs^(TVG>&k!JQZ}hQviUaS7)yZZ86wkD=Qrl1ONn7{^f^mS59|*PrkmDsOqzm zF<}u_zXW8_%>ryfI0uAr=Bn zD^OE0=AX{+dnZqT@FPurXB|Y#?;vm0Uz@!7g+Oo$%s)`?m2RcdwFv%1MPGqc4Bxr< z^e3<$adM94FU|5-)fTmDyLSCL|MMDE$$3<$?D;BP%2b+qyL^J1PY|t9&ckZ8TZleuyp9Av31;o} zrfUsV*~Zhglna_wJN2_C9-dsA;NS4h+g1s#_VP_zrC)%G>J21|G#=Usm};c`8cjz6 zCG_T>$C7gZ5=GN!S1LmFnI`y)+xZWgtq*~l$P1ZHLex8B5=xclERO6B=h$d?AS6A& z%-5m(r~g(lRR}-)>@g%El%)W;Ych)LO4)I;6VM;3dyMq32Y^-2HEm?jwP7*8r|BC* z!jyTB1cNIcp+mWx4>Q=!h1vsJSw?`li0yIGd69BG_e%PQH=6ya?AEc*0d}^GTKPOT z^GKH#W4%O!sNx?19gI*3+XTs^A4Ebx5UTgJ@<@wZ=Zvlf`Hf&$=LF3KxibHsXVPG_ z${7e&5feWhVyX#+4Pwm#l@R6^7%C;lE^qh)aYM>+?J=cWYqK;re}cFQV2%Kyk*6h- zQaq-Vswqr&Exi+7c_dZndY3i0?_0E(Q~3e=sIVIC9M$83es@{QOj(Bv&xFqvgR;A| zsf z+1Y>P#j96@6c-{kCa_0F5U%q1*R4q4l9v$!6ao<+2!2R%l z({3juK+KyV7)kKq!0;sZ@M^mz5OYkB-KyD9;L!Pl;)O?;?Dfdcq8BZzE(pV`G&hxmy%%X=_6j~{pJo3)#QGe!wrQa+qv`w}~O|#S2pv3OQlrizCx@y~$cTANaZLnTR6myTLNE ztjD;JsdYWZYlP`{858AqS=av64bRzb^3V;2twaNR50i_ZTWCzKDLfN;kNMQgtHJH_ z-Dp{WJ-7Xw-ciEaf1}iOZk#Ndvq93X#ZL7iit45`CBo(h=^CvJns9NojTw(JbmD=! zNpe?pU6?!A+@H4gWH+6NITi4ua^0WLr#QSt^7?D#$HDwF;)+$6>u?T@v{E2+;~mAQ z8N)GYq5a*3-;=1280=BKIxwr+YG%GRw zR`i>7_KgZ1E562W&B98@eW{+`l;+f{VLd;Ay7R_E090*k!Jo~ak;F*w+w|$TFk+IS ztjPy%vLTXt&MBU#Sir2Wp!Mwk!6Cj8keB(F_4i8J@T%f^M9USLr8j zRKS|EeJ_Sn^tn|}hUPt>uP@44pzzN%cp22Vm}L4t^WU%%A!JrS?L8yil2B8E7< zBYcr;ANeNg1IXkVf#-urQh$x&9t;7n$k7_@yFjoMfYcL3XjJ0c3dhHHOyFzT+ST=t z<+JHo`lL|-Jy$O~4$z~!;?CJ)G`fdp|kFu~>WL)XHm?^?2L~^|1-vuKo%G5C-Op0D}9xx^u zf%}dzXf3EOq08rC5tHCfdA(9qE1&*z>T0Mb+Aw?qMiCfA63R&z1F0q+X+5l+>2^Mp zAUhGTZ;9tfAmf?R3eZ3ai46T~ayLcZV@h!GG_zX`LkVn#Y6LZ|Bc^?ZMitICJi}?@ zy~V#C`6kktF?`*FbgJsq$fuuXRE5;NB(+!1(R+e1r|_?+igpp+TH{09&qx#Q#?OHc zH>m6kYd-8hU-v;|!?2|b%rq^EGlwbne)Z2)lKc3#0-FLX%)u$|VeFdNR87(vLsJnX zVUTm0vSiS~UlEfyLIlgp>(@7T?|Y@U_JXmP=$3QU;T-9}PH=2snSSisDzQoXkGpD6 zBzzk?ItURN!P<@%&~gap1<-r}trB(-=Nr&6uyi2yqDW>~3$`p(b!4I>BP3q^R`2@} z7J%WV6N{fQXU69MFE8HSoSv}U2={vg4DM?2s%FV*!&NAIED-J>XTBTFL{J|A)7#mX zfD~*?9iMP@79ObCL^6#NJQ#WCeqG}23ch%mb>Luxs)D`@WvY~%V3P6v+Dr$xW6pDv zlb1m_B7_SGqBjXuavx3jg6CD4WKH&*eH@gj367xkfjU97IT+jnq9HJj#{nZs+>aP8 zX)+V&E7g@n$*Wgjf0#2MPw2z<$pN}~T95B(o#!!vk;ylzxC)NQrV zQON-)Lv_@%M{d__t8FX=Ptel-%X#cKzV_~ePIzbG)^O&r6>LtQ*XX4Q{vBw(utu-+r0goS93{`*Z^x<_)Y%fr56pbwkdGL7jXGOWj zpThe}NA*rZrF3V}`~7-yZ+Kn__tFi?P0Y+w{~5Br+VpoxveYZdhMT)Yztw5vm+pL# z@02Q8k+X|fMgPx7+#nR*tO}a`TV;<97qt!I$)SPjvKfUC`x(hnrSfmfjbG9ylC@V? z16=<+Kc@Q9)N3SNK1C=|;(m)QS(fAZJKmnYfzw|@(w0)dDv(v{+5d9LNV_D;WG@aP z`q6l^g>e`6-`{@r?(D78$u$3^^0@bY>w!+Qs>qZN!S=UD4PIKmJd@n9p!=zp8+#Op zQ3Uf0O>=Cj;a`my<;O#^>2CYA-5EA3&CQHA;c zkn)2!J>rF8T4M#&pslwEW8Mx;V`%9B8yT6^zuJdU`kCh!tB8b>)raoh z`KtcQ=;Zqc|I!OH=E>gec_et&{K);QL)l_~RP@2R7h(H+sbt+?dt4=zug2rTIb;XmdmxqloH(Bv)joL>covaPSQape zL@K&>8W)9-3*FjW$J5w(*mqxdobsdhN4#3N+(IwDIQZG@^O5)k!T#i+ZpSR$uAN#B zKd+)4z|;^qMxf3!Dta`S?-vdkEoEL!!$Nn>==@D~Lu^L~2QOoNi&(fY6wzhArv7N+ z$U{hOFb>cD=EUHOG~oHS1bmeV7j}9J**CW{=$J?br;HjHK9o*tVul=97c|snwiB49yGuYnkco9gSNN{fzHaO zpsA_pa_=E{XcMA=bXw)7DM;+e69N>|wJHroU-#x5wAm9~%|NPz+2Ik=90%yJwj4w< zM{z~yh5ST2@$uthAc;w>w13BI)%mDI%-HtC?q}quEHV+*b33;2Y7i)3+^ei>Y~oEg z?67B&wEn8PtK+%&jP)#8GB1>)E5r9-7PK}|vgNe7Qmt|ZdI0T~e#9oXYsE^ZmbI6xv8|5nwK(Ar1!DO!u6r@Xg)l#>BZzRT#1 z+(5RC#2C34?$=06ncwZ#5XX9tof0jlL29o+a7(1Iu=S6+Tsyhfi`1*9g9W(4G!9i( zagqm?UA;&B_U!kZl3O*u)oV8D)b-Vm@l?%kFUNinu6B>(CY5Ah@o-3f;;XQSd?O&h zmv;x%{uyOCw#uP?dBy7~^h{zN12igIX1OJ|+WJR(n3$|R>3JSoP8{T3ub5 z8;@mNiV7L{bT;!4-*E%Mc}KdET)8i4&GHO6>(kZD$lJz8hH@%IW`a;?xHF^U|Z&V0oPWRrh>|O^_ zSP`mQzSpXudAe2c(fBi}med-Oxj&1_GBl&fMdC%v8yl-^uNEfRsHYdlZPHJE3X_Oe zTaKTWWw<@$ny9>IVAl+Wv;bK_91`+m6v(FTU#QADbo}9qZMu*O&D)szYkHcRni7Q! zd_W`R)WePSnF7g3zA_H}tQg@r?7tv*UTW6pibb<`nv-JjrR*7E9eZkfxMbsguLlEP zfFWhS5p_^> z98(NBlRV_+LqXD8;j=?3kc4Fyrj~7KOqA~6q)pk1l!J-lq@J*iEpOxO?VADhK)p51qCkXALT|ew_|k9|BaymiKc=tzk`#I(Ey{gkBT+Z77;0lj_MA zbZ9uQ2NW8Akm8KQ(31Y)VvxS&O(}@lsU>VQT=mVenz?&J5eJvy#D?qO-&Vc4TR%UC z72NM>qL?XY7-!>Lu2vrQF=;?*usKQ*n9|=+xOc28ruk8ChPdiqntZAFZJ~uwT32g&HUU_(pig{=U`x*i zVX2g%>rfz7-=Q=$J#8TE67YK?kat5B@e`N?K{k=|;|kRGb564X z-N=K=qYPjSCJl(F<1p&HtMMv|zhQJ93Y$y1+0>!Wav2mDbnH0NeyI)L*7CNR9SD6Z zjPc5_d-dR(*ekim0$3QPFtOHBS&PkKt|=h94^GjsTsGm|$C;F#$3}xHsZ|(9JO7pE zQc~mr0gI|>%rIU@*=RO1SpBLdbjluauAAy!t>oShaKCWpZ@x~PX;b3oyQNF+F< zr({7DMfN?$7m_xG!tFLa{Tjec%mXo!B)S~BGf#fpmi<~hT+k`Y{Ym{{(6@L{S2hk_ z{eel?`7$xileCq(Q|4&Q$swxKebZ*#6D4`k1oB;riHKj z*bAf2hgq$zKL|DnlPn^eQ?{Wsaob77@1jR9%A#=c8`HF)o_bO7S*7nUdKXj!(mIAm z8&&e8buw-Aiv+5cv4m#4#7^JqSQoFY$igJQ!)|mvV8C4_{dj*ttdh)-9>Y}FQTr=} zHj;-`lp`e?C`UX@$(WKnmplL>@wzj~X=L-}?z?ieL&&)_wi=dtqSX|x|zn^B)&tmA->h`cb-fA_%p!)jNzf#)~CCl8Nj|^knZaDW4^vzmZ zXqrCn-CFwCrWvQRB!9Fw<@jeIW7U)xp<@n@nrm_fq)RO{3p|>l9b!{pEZe%r()$rA zA6Ul{X7F%A8My;`7HFlouBKTGHJ3FG4taX((;g2NR)ZXPc<_eZvIl1L=8sM{jMmD`9MFS(Jr4-eaAkX7MKJRE#d6SvuQ~|*{DMR#|cgbP?zl53NuCL zV522{P>z4X-rX^64p0c%q4%bL|J#BfZV|SaV^_o#-A94Yww1Gz@rG9tu2qqdkzrBp zHC&C<`;XuZ7XCG(a^eO*5r2j56O98x+5AQk>#{h%r0ObNEU#@55k3F*7J1pif|^m`}PVZiZ5H#9~S#Y*~cv5{+e^jGrSItJxGC&7gSkJkxvO_W1^bHaWX z+I=y7RVx(vCq+2nKxC@6TD^jcv|{132amG7p3} zzbK}M2IQI)>?Ft7d%;%vL%0SJ%q3!L;HGzmv`%h$pAajJjo4|SJLPCA!0Q(x=lM1> zZ0UR?Q-WUMrMeNj$R{9y1YJ39VeGrW=4$$O0kNG3@5+CHO20()4C^LGaJqm_XQ&lk z%oHeekAOc%>)P6yMm{ZX5ln!OQCKA3DE(T5GvK>1$V=>+m23=)MGBM_o@)P{2%aQ3 zIz*ug+7S+K$7(U?#Vz2Vit2dIk3_;=`!Q%{IdX3K53e{3p1M=RC1LPle}fRhy7I=1 zx)012FlCl;^G_k<@IeFt3=F{=a>r+_<5*T|Vv}Q*sltlRPt#)VQ(@dIKX%+>l)c7B zdQy0IIHtRm8BJhm0ukES5$fC1s>S1d|2dl4^B>(4`(2(OM5EUIe+$mIlnm#D&qkdd z3~dD!Q`e98{fc%-=#Id~qLnAg?1h)6FtL{AiGKg_qy5Do^uR>h`J(Ix;CScs7|MBv z(CHu4U;-SZ&j1VGH+EcJE2RXe=o}xC7F$1l?Uzr?`yOvtmAQ zOm_Mrbxk_uskpygJ;AY8g?|r4%9r$-{2AB0K2|!C5`Or+y2w_pQvK1%NL}^2Jr%iy zE(rBP1laSS+tc_vt#WCy*>NKbB9q55>&asvVRyBhyq_76T6>K&{m87 zPAO_L2xhTOjAoV*>JylaK84*O>Tqqhn1A?Gd%k{8b^Z!w1ECtgUid0yM)Hrqi3IB8 zln?LOQ;9!h{-n_2>gcG`@(($A{TFbZihB2Lc$}!R2>4sm8^$^QkJ8JO?B|#6U==+4 zL7(i5-}qg#lK1Z~22XgA!ZC}cdyNnePtyH^ zPlUdx#QA}OLnfRv@@`<;rmhNm7ipJVHL0iVnp!;?f5P7FZED&SIE!MB*n&eU z%;ER1aa2}6N%}4iT6f*Iy;m0g1&Is%CZ*@MtU{|Gc}1*Y008-q!D0*PmxI)I!IRZg zAV07p`0;To=&2w6tbsRC&ZWrY0Ef~-J z#wL;q5*)E!#OLxemLL&(C;gL~V9wwIz>v1% zZ)tDq;*vMj$(m!)a?hpB@eppR{56QmhuCE+8rk7;v$HyhUFd^|!U*Ng;?u{0DQ@SP z(%}rWX;)yL#wXCD5!C3js@;&+ghGRGb9Y)&9~WT!l1&p76kz<;Ga#L;?o$h^nq~J*E zA8nRyjWwof>M6Q)l59AvkD)igcpgOgM128@<6Zu=K__!A{JoW~X>HK|BgS)PGM$4U z+=9`72XHyhB}i1w4#y6=Cs^9V;>mjynAj=7k{;;3`)|s9z@rE8D*rCG{yjy==jWgD z{uYoy`GZ;OmalKmH(|9S_IqVpOev`w>5c_Qw?-MVw=&0sy!PE=F66WRK*4dYLp|?Z zX!bt#I~8X~2iJ0$VmQ1T53|v77;{ro=0q$@Pa3Kw&NdBLYoSSTi6>{H)DIL+FB9vt z@c-Al2$v10ngVQMy`Y(I-Ox{k!1zr@Gn zVq6sc-Jkv(o#%7V$Sh8{>t$8sLmNUV1ujGLo+YlPXx+YM&!H=AJ1z{lw$zIqNF65$ zoL;2#KG)X!INJ1V36DlXnN{=29^ed^!%{GDCy4^7Tn^~b@8E-_yox$YVn=Fn-w|Md|V^UJsul>o}y7{Xcl(Qiar(<-M(GgRXiIj zJTbfK$Vk_u#+mqjaR+(3%`3I@rtRZyrR%oB%+wFIW`}+AqqxGFt-H#5g2`j_AHOv4 zEV4+qqLuV!cy~39Z~WhH9i!VD6KUM#7ht`Gjy*}35Y+J?>5>NN7#b0!dluxO>br9nw)#6Up60Ac7- z8U<0LQ$V`wJI}k{Ui**hUc}5i_kGSU;~zW-phn#!p>rKL4kwWZUpA>R8lsA_wDAY{ zcmEUH0-1#nlYgF0L}J9%#O$lg0Y8T$9hu&M!|Wb_!(^wYgiw4_jdLHEHIT>be9;1o;IU{hU6L0-IAD7e6oDeQz|zuEt7}t_ z{gC|UsW6yyLJLMYVUpSvj_`s#gJlmavhJ-;i#&IpRj85|nS`xP^|P3uQDp1N_RJG! zr+a*NJSk^=kl_F%w}7d`M+`i$E7UxLmftreMuzVC<&ZB9T&N8McLh^&bFBz~Z}76; zeD@bHH?UUH(fGh+h)jQw@c^zTFx^0%%7y>R1|b>*x&Ec9lFJ70G6{4>VgrWvV2gTg zGPQ4?aD#>z=AC=((;nwcCh2rHo4NI)N;Ut9Ech0Ufqm-zW%oD*emI!4rRXPW5+8 z9#rqP_5dl~`AxE+U&#`z9Q_MU?$+wMJTY+I&ObowY31GL0^J2RHm;?p!RNhoG+>O9Rv--7@5 zCLdc-Z;{1#rHE%K(}`2&M8tK=~%yV^#Ry427|y0+^;!I8Darm#>Fh@ z_C-p|cawLsv*kMzBu5=MM;mK4dVlFts}(a-$P0`sYqt2pSts6^;d6KM$I!vsJ&IKB zSf_HAePMwQASTE(=3euH9<2!0s2Y>kNRtfa2m*{Q($~uKt-{$nhJ>%mbZ0<~Xq*kVr zPZQhpaI+`Hu{n%pPS!4jHqN4USJ!t&2Gq^WiEy~z<6K*CMg3GgmClfB;w*8H1hE6r9D*P`{qfec zy{uSf&!buw^F2ieEr4qqZ&R=m(V3wi(>#fhJs=mbk*~F;Yqo16<*l_VR7P(r;-bac zW!xt-g8W09E;5_}oeW9`h_1ZwyAN}u2fp)cZ;AlOi`PkJ$EXzrx#e#$YNppKQ(jG$ zTG?>Fe1~q~`0#LG$pgV`k%GQKshbh*O>5M#F4Qh=TpI_qF7d;~bwmOX=EF30P9*q) zIx~{m`tRQ_zeGwL`;LtQ`V9ax;e5^Vroiq`pVLWs_-d)?6kB%h^bE@q{FjZIqk#x5 zlZbAYP5ZV4lRt3ql@XeV1;VGdS5w4@tFaycz5h&@y65&U2Mif7HynAWa3@u$dHOBA z2(-v)q3bdGofXxe3l(8YLaHxqZ6H1fwgC_)y;EZqk2cs5exmcdeVf?8+7z7;ixdB` zgH03O=v6PvemU)j7&j^am1mnm9Y6g>)|F?t|5jHsEPOZ%{&tmu>K+zBL{nHpd`I~s zAaR@jvq8^|>(u;#a~>pV=NGw@`G3pMtL*=zA6MqSUFVz`8xp)t^o&CH0?7c8CfVbH za)(wDm)zN$u6N&;J$b$+D)laG!SV(0#)QqHtyO17h4Cocm;^8H->nQr>6OyZIPGml z5QC@C9_Y|h_tWn;p0!L#!( zLz3d%O%*S+f@!iw26>cYj<)ILGz$O54T$zYK86|Da}Ru|nAMuM;`Gv=P_g<{^7cOU zplHZ1HOIGdJCyO-6`q*8i#Oinfq$L|jh~SD{t?Qcv7|J?BTi5>a?taRBKadqDX1uN zUU@PRv;8tEI_GnHz@G6t4|Y+n5~7nCPwHF^PS=S}S!3=wn;h2ASoauqCz8!!7|?sK zL_tPH;(lHSs~MHdR^aKJxqlAR^mDD2&k-`?-4tQnS=zq)i$8PMqmF%_%NoCaQu>m| z@+_MmSXPCAYLN)bSQ7q*Biru*t=m81^M-kj90q%da<5~T=n0SFGQD=s$6xNnp(qf1 zvMt?1Tu~L9@xLelUVVa0{2wvnuaYWb-~I;2uu20HG?={u zf%H>sFkWcW+e{0FS$N!b$q_kOT=;a?!WNQ=1?VjFRm-VZDO*9cJ%y@a$q*t1hr-Me zP`iP2+nzTG&~du$E5&X+54HSHE{V!tx-ms(6|`|9Lkryu^Lg&w!hVj&pe%%&0~)g` ze>tYV6{L+%+Tl~ZJ)ssSncMUkI+C-}zP{XD@nylw-{&IO&}$q41ZZmgy5$0LRz8>{ z%!a{;BjMIe6qpo}=t(-1PD;+U70PjUHsH(tCrydKh*E)u;iYnPo)@KacYQ37f{11Z zPHa%!WUgoDGa@)oXIvy2#?1-|z_W)4hIqZ9)a*4Ic58A{ z8ES~0^QO=h?1F(Oa~e--YtC<064Ff&O<;Ue?&(r)z=BjG%GXwJcGWVi?8+Db8L%>~ zMCqk2d%OvXq8_w|0l=Lb@H(XT8=w-TWXY%iY^oA@i?smDLs|qVF~04={0T1uSkLu4 zWqdQ&O2)ny+QSi!Q4?AME14vNoJzuz>AJ!QYl#0o9N)v1KuXsddXJp5VgRLAt4cG# z$fQS7i#XXBo+5=34(#!vS_UL+pE>UT*Q)mx02nX;l3s%u^k>ex{-c)%v@qO3O=tCR z83E(=`HdRqS=_=t2@tE*gOGE!6w=JBt(yk>C2tmn3+FEF9cgZEWtXiXTm<%QmP3Z` zAUP3>HVOVyfu*D0KHS+JFUkw9#j-I*fVBQC*wO4%Y@-eiykWFpiG}JzeRJHFp^_6o z5y?e!xc0uhe{W5$z4n6(P*8oC0l!wsKEUm306)f__{0O{Wab)k;*rTjVgpxrj&B6^ z)!FI=MWVt6@aXL?#Pa;YaRTOWHc@S=b*=+% z=hkRSh{IL4=qOT;z^-cdw}U#LDu-BIVd=M)PNqdOct z;8B+10EtozS6)j-LYV73$j2@`D&Wv|!iuP%s72?bm)F(B=2PlpT^$gKDkN=kBxK=J z1rHK)Vaj!@HJzUtEx!5v2OvecTYi>8&%|ZZ_%Y!1k!LWu0yzLk;;aT!k3vTq*7Bd&(3@9*J{ws$)cl|0#xyDhY3`d`_fP>mza`^UZ)1~2yI)NF zh*(*w_jLaj#{^LZn>VNl!V=`RXr8>jR>?0tbbNWdBZnMlq;izR&sSAdRngVL3+G*2 zOd?@+I+MVcD1!3rnDLL%phS!LG8iIvfUfUAL+py*(tF zARwwdXfx&4OCEI>@Cl0!twkWb2*T^CB+VbSN2pZ<&7VZHD*MRlXQF*PpEpSbb^1$C zp)b)e9!UbKNrpoC0lGXZ&YeG^<7x$z_nTVY` zOY*e}JOiom%2SkV)g}mVJE^#Z`h@pN19EMq$IW=Yx+OB&u@kmqRgyvlC!;E~MD1j$ zw)w1bqHl}JV@r){G@n#G@teaFhl&^Jq{@S`mQSDOzxea8<$eq+QNO@fJ6J+icX{sS z3h9J-e5L8MlRfbp9FC1&7uL^48yb)O0ILFtfiC1zfmi%Nv3rpo)Q9 zv#{(KvRL74ms}&U4TQN3)OVne0GTmp06`=V01Oy!n8^wJ!i=~1gdY?Ea8ct$&Jg%* z&h7Dc0iw2rXAbP$wqU{mD?Pw!5MGc(6Re=)3l>L+4}5*&EutX=n+o_(;Z=Ppi+W&O zMSdIr@XD&0iSbnS4b29;|~aZXbj*fgMVQLk!pq;31Mg9HQ(e(kfhGA ztvgecpvtStFb6!r0pX$a|<=d9?Re z_7CtHETf2YCL+YDl#zjfKkurEQ#QWXa(cvA3A<8`Wo?W-3}p6XOx`8+qDL7~arbfE zQ!sc}kWL67WWdn*&W^ry7MdergF;{wfm}Zu|AYGXCp+bV58ZLjaHPw-^mG4CrSi^aHZ)na zrC*ugx9Sx?exHZp#h$VfPX6vLh>d2Nlnrw8vSDTa1hXxyJUv{yyt)ZK)a<(AqjQ;p z6@VoI}|$Ae&EZ;$3lOh)y$*9D+}Sj6oZi6NS%1y3xDM zVtBGbBCxaGXzv)vsxN&e{)aeP*gyJ0EyJC!<2bKFL|o|(NwjDV7UVt$T7J~L-T|sw z_>e+sKx~fd3ktmB3 zWeD*X*b1d0J>C`m5#XRRLU{|Dy;84WyGiwZ#yn|={V8?P-oT$v6F9gyI6CSo*OD@i zCyeTtc%|nguWo*!tW%PPXylxzuc9I9>TvJ?8)bjZ7*!n`j?!{sCtj5VEh-xu)B6Y$ z;jfRuR`@J>Ka?-X{#x9Y>TBD1w-bGH zD?_$$L)sVoE;EQTE|Olk@9usT2KHDP0)eQ=!Rs2aPaHFzkUR%XjYbYnkn7f!(UPrW z{|fstk=&AMYQ@Hb-|8u|PnSjvC}jD95f}nOTVNuAM6-A992YKMk*?o#P(;&`&?i`^ zMkKjXwg)F_thY)eTQm){O*J}>tFu6cp823BmZLy|x;BvV=OXMfvVxel#(G;VKe7>t zKmPav1&_8by|_4_2nZ?*WqBq!&GA&8cS)`?F$dLFJ9esG7JvM+tw8^$ankM1Vh?{3 z+WRhauS*aEM~`AYF;$n^6Tu3QM*{=^uBE3jVtKPajirUL9)H}!k^zRp-n$rUj^mK_40;M+%BF`}vm6V96dnlIdIpAL#Cgx#9W z2?rd%@6#^o6quu&@K{&`X)aJks{NLL>^(rHzdE_vi2BU_Qxr=%ov(^Vx;B$}?@w#6 z-tZ9B9CMdV*XlcO^$?}9m5u$Eok~l|VCTTb;lmCEHlRzq2EXa>;@_Su8M-=1d2nd5 z00BCnaPTHckpmxXFXK{8!tctBGHC%GP3XD!#$6Xk)bmLz1=U&g>F(-p)(aDL8zk&} zL8kM%^_}>T3wo7u_S{C4e}H3VUPykJSez*X#9qNK1!DE|PgfFbIr9rwqV1!vfk>A5 z34PyMO#eoi7k}=TtpS<9Ep=h;?Fo(HgUk3)4uH2U$m+-1{=0A$uZ(Bn+?5bhT`~e( zK5hkh`AlWr_2i|AxT^VE4-QG{N0vvq7=XRwmNP7aNR;;C#?O04{_x@WbufXY4|lLj zIlxCL3;3}_O0A#edKz7#2Cw^W(1YNepLNNx4$9tK5f4R~^r*8%RhgJsguOi??awcH z{Nhf5@D#^54|X}okI;=)ey~N!A1_4Bom8LDUqb4;PJ~K_>=7mz`~^mb`k|$tHM@xw z#~WQ$(b$h!2^T`c=^1O>m-%Az9uP{ zKZ{pw#uUVfuC007%NXxSrl@G4j(b3Xc`MOrF*A4&*JelH*W`KM&wqSJuoszQaGBUm z2wsF5VK7g+=3D!{(_0rV8(T4586R5S5gw7FcyFk-)=kLzkVU*UTAyGH5;EV-u$Sme z`Bg-FaVp8OQojjmF`ifVOcs_|^roqh66>DDg3pLOr_q{QP@n#pgS_qt`7juW##cek zED+1~jQ6+T7$a+@epe>$9H{-Z?hjG$W0!IGaN|@*C(R)D6xPrya9i9E=*3P3bX_10 zZHgW$2_lNF{K@I}yps!B2XubJxjx4zwz=(!zEwaz;+m2g5h7G2e2l~Caj-RwFY zb@TGV;jTMp3!*ynK_Uhg)NO3idsb~G-)1-I`lpxg+ zNzo4-4c;2PsQx|si*f?NHkEiLc!HqF>y<4gH`nF6>+opDqT$lbU2_2)I+e7@PzUyG zr=TXgK<{f**J5wi@GfWJbVT+YC{AB}h|>GXM$X$rs!6A?1!q}SE)s0Q%zMYwdE3WS zE6?YpAFN<4y((w|&7#*X70TBAcNbak7~Wj;!%=l&-;`KR@5(zeA-*zz&Yt_`dCU(Y z55yf0s6Xk3oRrgG)~>Nal2k<2qg$XqKt@e?Q4k8pb`39jk{xfys}*O4iYFzUFe3P; zbbYj6QQV}pXLqH%vgg7(Doar(;>-qG>(^jpR=u{j(ZQk``;}-cSYwsznDDesWPd5{e1|m`aDaAlZCKw$cHXw`EJyb z%su6RVMua2ES19T&+<+wK92!YKjz^h9f5&5Bqsg+&mT?^xdDf-RT=@=;mMRxe%Ru^Pw&&1qUU^%LUerP zpUK5&2SP@ddPrl`18Pg#f02=sVr9Yw4jHO-T(n{R(>&J$ABN#+ijr$ehbJ6U8(7XP zQG7}GxlwwcFtNs-l67x~xHQI^$bM5@@HD|%EC0Q{q$PB)Z5^W1oFCwdtCoFDV;8eb zRez7cqFYCN+!DIK$f#p?gtLg+Vn8+d@;RN_6qh|WyzH~$gLJ2;r)%;q42g!=P=^k8 z*g_r$NcZ@m-;-`f%Bg$Pc@NQLv&knt0YB=sE})sEmT)(<#9WKS0!x&n+xwoxsr4#` zjVN>Kkqm<;)DPc3ALJEV{X&^4s{dGd;4{WeO;Y9sM~WS8Xc6i3w8yWQ z<$``!KiEr`SmVdgKyrf996m8f=bX+6`|r*Yx1xU=8ylZug_mJ&UYTUVBea~?5Q;$& zp3HQ;$J)^`w<(Vk+-zf+jLJLb&5^B~=lT!dB8Ye9hS$m8u6JkwgOGCG;Km5GV87vI zPf&HieZ(UC@9NEJGybTSvPptzoc}V~GXJT!a}7ea+_$V2-{o;U8oqY(00cS{azD{jHurSgL{DC8xo@{Nk$13xz?(E2-# z11yel&kGuD1`0mT)+}&NWz<@pZUph6!o9Rg{@fv84%=@9(Szdq65pimbFTHQ`a?Dz4FqNZS;Nh`fnLV(i;D)&lQM#~bA`^5G%i6{vzAic}x&XxjuPUOx2T@3z z$I$9yin5|y@$m&j*OqPx#SIYKy9hM`AVqk5jrV{eS16HR=6$)dy@YOMr$%NNjbe45 zLr|Qvjb6&Mk@}dDu^BjC_-IIO?})s7%(?%3EMA7%s|_u)&Y1W~$^C_iN|eEngNAP9 z?MI-g+$|mB6g}_0$XpH-73ITG$UA}OQZ@hW*3+fj-YNP{ny){!>}SV;Dv+Yg@I+N% z!clkJ^$>;+l#np{0>X`C<-^Di<2EZR>y3|^9+VHjM2P&ofMJfKDAVHhwnxDVsXE?w zf{*SE6Egeh^u+Aj$_76LN;xAaO_+|lwZahgc<**{7jgTGJzEdRgw*(&h_F+L4FC^FJ87abk*yevh4WZvR1uAqbin6*Xlpy8d4>43YQFh*D6s(79MlP1dKj7w(Ej~^HWH#x2m&3(XV1YU zqD>V|`=&2BX?>Q2S72@M_D3Z>y#rb_5OV3$_qUs^Ubu>)O?d)?nE|3>ZjNfW2EY}C~Gvv+V2Qz zAbdCFMA5oV>dkKpXgr*no+pKBlrGANSxfdPiwM`ur)>oq6S7*^7nfh-0~D^Iu1AofYp(FpX1}PSo(O$ zO0w;z19(p4u;eIvDQS*vJ$C#!hfl#W2fTs#3{01eqXl?#{F|RjFF1(~=RxI_PA`v( z@)YL$qOoQO-R_EH%Zt2$EiMv!m-a+b`J00|Srf3*0Nk=9XEy|9qMMh~F0~O*5wH`n zgy<7I3+hvuIMm~pn9>X8Pa(@f;Mk3?^}*R7MTJX8AoUU*#W{a8$9>4A*bGg5q@DS5 zpXshMiSan#qcCE8)KPrxZ!8OIIsl)R|S8B6-2MXqIh{mSTR-qg^a*4 zd8FD!9hKn1mHnyHjd{_aD$3sEU8#m851){Fz3>;)oH2|9}(kO@Sc826ifuQ3ZkdikQfjUk>L809{FYplX zV9-YW_-Bh!7D`mgYlV4f*uYK|x|3w}N!J=A@aV}-OHQnxFt}*?y&)Vl7xns~ zcnORc#CL=loOxB1e#VkHB9IBFgtJa!$fEfn)0aRuM`R+L?mf#wu%*X^+`gyY)lSy}ja4hKnsgMD;T4)pXqil}U zY~E!QW3;*llm;XChfJt=3ViwdF=}!z${E{7zmSIhEA(^oRR5Z|!^>Q?1K_%St1<6` z2W*_&R0j57V>>+EYbZw&#()oQfVLGR91Wgt|IID|ALw$LTM$jpW63j8u7Qsmz$h|= z$n7|-aan8yUM_pRAd%wx9+7LPhwea|Y2%SSKk4QGjZZ(AsO9WW(MN0YvXtHsGDAtj zP0{i?Kvo0uLbK(y%l_XLJeIu*t)NJ!`Dt&7YxYKBxRyADqL6?3Uvxk4+9eXr#<;@{ zh80?$%K`8B>Do~-3Sp@1Fy5cN-df(uMo`zmjqfhnYd zLC16%3$SWEX@8CED77?KBGLr_mcJOya)aDLCnyWZMAgymgm45`HrWW=jl4>rXE-Ul z`d~ml8{fl)Qk$x1$O*tRR?csxZaSuvBAe5pMoTO@9C2mwBrivei%rC)#r@?`NvGpH z9&U2VkJO1~7eEc{dB~hlt{`S?FxN#rShUH%X=Ak#YzjD#x3{u{x=iEcy7>3g9L393 zzQK(_mfj5sIVJhBskmXZXe|cnKBL;+8pEpT;Fk{U%5j+UK_R$r6oGF}XP67#XtTzZ zvlcy5{_U02twc$-B~Njuiby#b<2fahy+9wd>BUgmz^ScLWT>p-_kG&^RNbspuB9r< zx!`t3UzVW^*Ttd&p$PBzeRb- za(6dLnx}d0xl}~Pc{eyX77DojH7{HWZVG?3Si|RHjl%IQDA6iKfof0RooqCeK*w*F zzrbCGZs)fLHuU%_MuWeujPP#`l&{vw*WxR7-Np+(I&g^hXGuNS$>z2Tk=uRn*xA(Y ze4O)ec)V7FkyGPIe&oJ|k@$oIVe7B0c3%JcYXKwR>DP+(b*zECH_I6-MmTd+Soj&n zRf~oI2u6Ld<2QcP=DV?;CKG|_2vM0{S%GbpSbu-)ArvX(8yUfj2o8#!n-Q|OM@%=0 zofXejWv$t`@|mCO0OEr6SK1XISa?4vZhzm+W-eB zSZ|;%{1-RU{RrhKh<<#lPstRFrpSb518J#NN@eDdS^TpdS3Ob3x)Gcozqo`!;0Q@5 zy&6!*RmU6o7I?AybAP`T8BM18xr!vdcw|HIQAq_ACgx7OA&MFz5zc{Me0f>h@DPH2NC6ke~rpuVK9NBg#+AAX|ab zL?bcexakMVv&;R@wNDt!D@3%xT(%rKYk9=V*ATPn-Iu9lTmrHr-JVc)05+1^w8&Ohmib$r=P@G4ay8}-E9RFS;`C{P!Wm|@?U@{z3FVPGmisN8AxEW zN?0`2g@{+)ndt|2BAgY-IC&vp8!|E{C9xf>9+nG;rR#5`(lKOZCBongzDp2VJczYe z62jyD!_`HpF$(7UH#8GZaU8xYAOs^4@rfnTe4Y*QVNmvkG_S(|4}AJI2v%?TtboM} zYUv+84qEevL?}q`wtbKW&5AexiZ2yXWmv+2H@`9j|^`6zsl6$Xyy9?v&F{ zb{Le>3ZmDBUj&v1xZDNgZ5vB)XKN-qChpqH%y4MI0* z`wOXcsSo7YqOnm9OTOFq#ZwFRJ})MSy-(99sj6_dd>rG~Ho8xi7K%=Pw)}xq{%w$j zn9vS-7V>JFj*}cLY|cGfA)Y*3l1vfEEy!Ccio&zkSL`;ZwW=kEnqt=tq}W~3r^s$w zlH{ONu)W#0uYLb8;G_!Y4_@04DvIp`XU?C#Gym$ooI)EMue6!C=)bOEUYKlAi2rcp z^<^c_Y4A1U__MS(R~qVz8@`bwT7IP1xF-=PYi$uoM?+V!FUjf4QhDLf>*k1ld2}wL zb7Bp{-RxAXwa0srm4>t1Z{n1R!dlln%SGz4$6GOWL1)5%Gh>s=VhMlIPr;!yv_PhDO%5^4kF6l>jAv}L8K0pnqhok zF7C5UAQ}UI9Pm7k`+Fcnze`jDgOU9YJd1eRlwV|#T zeDutcv0Li4)Y6<=D!fFmleU}m)fZ7Z9A%;A3LFUn@`VGRSYEk9aADNV>fW*6zaQgHOJYg8TA`3rq`%>GSsTW7n7(r}r`w+J*h%KC zy1y;PMO!ks2m!piyswox9Sd?F{SVlyir%=kF{x;bOUUa~5H7^pOGhobD2S6MTh|L0 zevc@;ortS`Ig|cW{f?0sj|UZCZ!j9lmJDc~YniZ~o2= zN+^p2iTsl#Mz$8slLBV~cRHHGzQ9v=ok|ljw|&fy#4fv)H82a1Yri*3_4whNb-W4< zB8c@L3@0F&yLxZ?t^@w=k!gqhX<^`Y0@8{I#-P6oN@q35B>}VR)p=lNhlwYs3LM-5 z+H73$@IXC0?4_Cf&`8JLYZ7nrnQvGl-JH>6k*f=3T?qz!n@9Jjt_4rJxI_Tcyx&5l zgp@b}Fb4Vwb_MA6MsgKwTZfMPYmfhJZVtwK-M({2>f;*RTZn?eD=~R`0t9`afQC82 zVD@uDe0;3obi)>Ss_1yNjBwLCV77-hR3<#V$DYDIvO2AAL7&Ta@J%^S&Rwhidb&O< zs-c$OrpCg+7%vT#fbJbZ=ERyoc!aof0YwEsPQm8@BD;RU2YNI^da+xf_g4pJU?~#m z4;`>DoTTx7a|o@=yC^#ok{3+d4IDcBOlmFKmXoF6fD6rs8V!KsJ^%~u6O??d*JAH5 zQ*ue4Jg`h|t7R+6^d%?$0u@dmBN?Il8xndzFp*e$0BVp}c~1ZBB)G2vcB^ukX-VZ+ z{6l8Q2AjOMA$#+=r3k}Q=_j2S5>qgnJ7$oFe8yrQ%_Y{2(3QeF4*R1gC?4TA_#bZ! zfeD>2Qb{ibDvFCTkqfViF2g~T9l2ekvyamHIbZLNI!ATho#Hg1;N>08cb378 ziYe67nQIq??|kCiX<;=(f7@#c!F&*<$STN2rxK&px96>2LyF4jHaF_#8JZ+MG8T4_ z{(J|nEy&V4n&j$qVQc5=N{w4nUht;9?T~3UJ@Q+^)n7i;fna?5s}0NGUf({}d(Y{a zd89+qR&25`+2Nh_0>hcaH=A4Y6B3u;p0PWL+Sk5n)qSBj^f=62{kN$Xd$&}16_u!2 zr|2Tl0J@XWK+Is-qjhQ|N^VnhPuP~lX5k4{_~C>Ki&aTV%$6fcI}c=Bw}r@Z9d<@` z`lXju44!%K3H#*62e(G5*!B9oeoJN0U(!h>E*9sruBiOuxWZm0|7pMoi=JBd>39v5 zGpk>ucEQ76=R>8ze5K2-zs%4;gnj)yH&BFik;jgWGC|<#;nc+PS-f6Qo_EdGlF;@W zOYm)9MuIq~a(Pe=v8LVl{mEiXbvCkU2AlZWL~X>?P*M6$lgdOL8eZnWTuyP=#sfn7 z>aol1O?0|JIaVD|pN8z#IXRg@dJAEGSccDOY!V@=r!jE`qofrt6O^58`VA*o1#)~L z-vpL+2)+Bn&s~IL#kA#@-3*x&6gM3x*15eOy}{*0ii+W^hi~v5;rk#&11M8i+mZe$ zm6&RxtS``u+6Nk+)5U~Sc>MKXbQnY;VITqB5`T@{tK-|kaGl#m$;FLhn%`wwE0cs(nS0F*A+IeZTUk$PCpD!>5d}mE(GE^{NPSCI;<4r z=7~~GCa?EipKMZ>R81hvj)yWR&pwD$frm5~b&tl$8KPVvz{vdwBzFS$^3?JZAx`yO zpFVkl9~b9o9)l5W_Bf=GLb7O`ccC&$bfB`Zz5)%V z(3@A?= zDeFqsaX9>3NR{m(GGzm3jy*lR4~`(EDzwxrl@}oiqp)74 z4Ydk);`gUWz78AP&!k8|zlQDIz+w-x>|gZ7XI}{tLXuxYmJb5Q{4ZSs=}tMDQaUEK zHS^u}U)dAn_4if7C4s&6xG8&D?(9;&Fx}QoDga1+jO{zopTF9(l{m=FWWn>E^j()Hg z5#8#Vs@g*|^~kbe!Ejj_?&sazkG$rs>a+OKooP|Pzg&boq0B#FVoiCvBL;Xqx#@fV zmCM2sdcQ!eSp~GRSPf8sxgLl&*nyxP-7e_4 zf;_6sWkiCbH2{f8hz1IA7nzwMV*+e{u5rptuBFBIiC;K?RAvxbc7ZvqzEm6OFkd6L z9&?YC#iyQ1KgI~d!RT5tFM z(-Pqq8M$A=bB>DC_h-t&G>2br=R&`Cd0+s;=F4C4*aWezW#yGdLlh_VP~FuH4AGmj zKN1BhEb9grUTjnxNQy;JME3g_p5J`xJh41gu}9H2xT8%rF*DM6QP@N(#~8h=jO!&` zoe)yAtf~0GYx0f~Cx_78hbV_+Qw_P$AhA!9hSmlz=YH`pcQd}eNHw>)w^!WeceBym z(hK7(`f{W_P$?$)2pc^$XD9z`!E*2D)Iav|S?xq0R);d?cZr$RE-~H+MaoN0+@%Zh z7b{EZc)qTk<|xt(mM9+ko>Y1NnX#U7VxO9uz%g)?(aFZd)EOVww$t^&SW|6PAPEx_%r6hhI#}ib zyKN6CX#=a+N88IF2mk-7c6iv+dD`n;MaB}GCvj|oXci)?RYkqpdfTHOJa~YZFlDZE z9y*+@Z^%BTM{uAeJ?{C<`(V9MWS3iR)-e-Qh11g-|dHb8P#|AS-yFtMl7a!gGLZ;Fwn0d_{43cLB1xPH;eYQa9s=2?c|G8?Xc^yE znWaXgJhbH2jTRZ}OD7qti5{@%0DN+<*6O({50O91uC-UfP!%IUKM)K12EJiUGkm=g zGD5uI=plziSpj_?S;4@wp+}!QU0w6xo>Hg|AvzOP5nJ@woU$Sg%#q$(+Y-+SYTnxX zveu%HUH4D&7WDXm0f*34IN6~owdnq<0alOA+?kCZ8Bns&Xw3xr*LWG;Uz0U(c7ni! zLdc%tWtV{89ujY}SG_0C5*K?(FNLu0(T>YMz>1)V)&mae+vMc6PZ&fOvlaBBQ;SHq z+c?*o{Sp5zgqaUUat1h(Pi8qP94ehAoD~+mjlqXA2qU|dwcR3FEqLcbC0JuYK6e4& z=M5EzkAThXL+330r9R@Inx|FId+eX-@y89pLxQlyaB%x7xf6Bkm5q+br+m#%Q;JAT zDR%s=%M#OfNc$cB8s6ZGYuONoRYeErps030z!c|xC%H5_P7j&ZLCbF?`f6sz7F-SY z>D3PC_s%Uevmz8V&=Y?FdOwUjTj%_>*PPz24UTgOyJYfr&B42TpJeNbzQ}4mOU>09 z@(b&27}C^EF4jD*lgZK#-G#Nn!2&zO2|2*{ zGf=s1mFUmyoNLoP=XN-wbZUDtntPG~y3)CKq%2)MLxd^yA=t_F^In>rd^Jx3wQ z)Q7I()@%!k-w&cJ91N2Xlf@ju`41e-M)!SDh54hiI48Ue(=sNdJQNi^S1M3WU%QKz ziMV2y>Ov!Jfs*pH)5zt=`9Nnp!MdY!|7g8$d7-UEJI7mY z*~*~aN~~n4FVgC0VWFz~T(f*V(dm;jz2iVgx|ta*XDnTCBKnj@F(DSWn{_)dvpDu@ zYsBW362*XT)SyIU4JONHcE2fuIu9gmK=HE`&0xthN zC+ekg%a5Z^EvWS3ng-^xWkT%++O;8C#lDz%SL4)X|-ZyJ<=fcu;PLKDdw9&2VuO*Ix4z_&tGrv=mHfW{3 z#MiKVK}&A2$1*9E6SuIT{eem|oi1C?&cX%52(b)~=W_>{W8AKv& zOedI=?W=GgflCH~pa-wBzZ4LmQG5hrF9@4K@C!b|8*nkN;Xev~*drE~vn~B1H_a|< z@S@JdE>$ovf0}!)68q4(>Y+wP_QZ>6EbQC_K-nBBW#$=wniUU}c6QTV|@ zh(#M3)F8q!oOhW34Q&ahAay+!RUQvrAxq0ky>s~3r~ ztPb7rMdoXRjg+Di!(2EzGae*zZ2Tb<>&KMD4n8XaI{R&~fRw~?qZ6MfPH-U=p|2wK z=X(=%@SDL^h>S+0Pu-~?1kYZvdSli@X*gEyXg0+V(ZDqV9ZvAo_ti}+1D#u`kbK$} zFO&doRshmpUl`;^5p_1gIEKVrLK`<=T(^GPI#-)VI@vwFW(HNI$l;tf5gHnrF%lG9 z#*;ihK6#!z(lpZDb)4w+;J{+clHn|r%GenP*4!S3qc2G)xE!juofi!ySw6h9#ypG+ zP=2ZK;%$lmku=~((NF9*b3e4+ft+jev|L%`Y`?F(9!qe{6veQCV*TeXk;@LEQE z{r$>}1R-qS{LZqzdSvR5mtC`#zTjhS>whC7=EL`-zB#~dwUlCrd0!_@_6Sfl(BBhL zKsS*#mXf^|{}oF% zH40(|#j0zHRv?n-d+nKGz_A(RO`=LVh~WgVQ<#bl!T$BGu&^*=q>--fmCbr5S3Kww#RIO&vPu6LgV1R} zeBjCg`N!MLq_Ws0Ag`Y_SfhuQw!?Y_8k>Wa&rE0r9VLbHkc?t`w1;?@@G?#Dl#8sZ z@Wy|sFT&yi+RZ8g=YKj%lG`Uh%-GthG*Nu7`&l0b6ogPF}8=MmyMroeD9{ zxTA)psRmBLVI^XVOU5ad60w8^L6SNo8(Xu?ADL#B_|*a=DsD8U-9CHr{z|>dUX7Wd z%~t!w1Z&^w3!Mnl#~x{F3=YggdY(#V_j4_6$Lk-st|eZMzNyHZ zM(RKNN^`03URt|ja}OfuHJ3^proKj<;!i245MIWSGb%IzY;=bBp9S-JiF zuEngr`n~!W*)O}gx>~vR5=BtIRO0dG^R6{5Sid}9>TxHzom+Rr+pZvxo-X&US7^)# zBMAYBHo-8kI$N3LcrRpN*Z7%3MWGQ~_Q)v#BMuy(Jbtm7JkSjWP2^xGZnHm89rVxNksvccP84vHZfOh!_?uS!B{d>M>4%VvdYDg_!Il zeR%<>`_`#669&=r64>xTcX9(C#Nkj!3spGuPuqkqg>$!5z!1e_cthy?$?m6y>mdEH zNWX#)BJlQo?-?hT^*c+To%ZTO=ZU`=-@A**D=Y+<- z5sR#gLZeJODHU1z(^mN04yY4Vbkb**0?1e9ZoZRto$M2~1u6L8&geQSWs$)Io!|ds zlpLw@a*>s6rTx>xWd!*A>_bR5|0Cb+VR9W#XDqS5%7o9ZB?#4HSQDw|i4>tA7(zJS zUHQstL9IS$g$xBS%cL?Hd?**4wm^-7G<4{slNk5)0w?r^i7)2tx3xHkGlO(g3p8L~ zb2~}%WBo2k-l>CO8TOVYubiGGE_1_xt;lA&X9v3h$-*&O1N&&oBB8JrR<^bCS5kHc zPqp>RmS5l-j&qBsSum>h{QdhkZq`|`u5}}1cEjrii35Z|9m2($+GU5Vp`bxE52cCi z0(xJK%ZU6o{z7cKxH>8Pa`c*zWRQFzTPXI;o=3_5QTHDHSoiPyxOt&uL_#(hrO2ks z%5EU3C>cd)DJpyK>`@^rBW*>C%#@KCA(a&wDSOZF@w(ri-yiXNJg$eweY@|=^}1fK z=kt7?=W!nAal}zh2P4_+GwZ46wl>4{92dFzZIg4w9KfZ@csce;gFY*jSB)x@EfV!r znQa+-W?Xc%OBx}$Pg)fi2T{4+@DcWaRxxI8hrWWw5>f0J9Da6C6{TwX1@x^A!RH~^ zP=s1#`Nm2)!9_^32X9U6^NrdWrqGkTe3~~v+Pd-VH1sGyiolIza``*vIB19A9!{^v z8V^`+nUhH2-k}XI>^nO^q*hcU;b~=KcbsTan0INz3rEY<- zL5>1d2*l%yTWLg?>?4+{9#wrAwuc-u?gUydclJ`+9pGPFoyT3f_378g`}@?ag>Q@2 zHOWz|z4o3N{#rua=Tda(5`Vu;GGFwh zySrIP&+bIgaKZG_+PQtdyf}8sc}w}&|30+=tv1)G6|z+?e^GdJalP=8=!DY!F!FZ)*XI{UqMHX6 zU;1dQue-BhbeP_N(Lv_m9TP%-?f8@Bi{>m|9vTw_AXK!)E2#dtpr8+%fJ`68F*B z{FnLVP*2fp#$3i-(fu|a?{3>K9OsG`HB=Uk(p)I_D81rt+B|LlOyghD{xW{9N#_AO zdk=LDliB6=33XB&(B##dK>`-Y!;_{4YYg%6+7)t#q@WY}GVjDGR7N z*>Ux=P`8TmojXOEQUx3WAw8KcM~0%6bspr7$!+nJOEY`|$qIpA$6}St<;;E+6aHB$ z%t;V^fAi)6`ZPd+S~gFPVn69`qcx(5ijC0~jvyszWYh#E7Qp@Qng-ceMZU2@U;IMt zKE4hC`99U3$hQ}69r*CD?*{OVu|~9E_Z*yEs6RhbG&q{-ti(fPrTb3Wb6F6+*~Bai zv@Bq-j4i^NCvceuUNeNPnS^Pv1eDTGAK5?>z%o;i*;ZOXyk7B zYA#_)4JReL!Y-$0Fu{9CQh?eJa4C!*Ry*r`c{v_iiw+>KCWLFE91rjEn`P2PTNjk) zn(t0!xB%UGN*Rsx40rPW{r5&VxFCdyVVfsbx>^l6Q|HRCP; zgB4_hC#;qC-0k*!etv#XC5^;g^pCgNDwdvo33UruSr2g^9>+*wrp>BU%WF^GWJ8Xm zs(C$D&Muyi6VxrH0@NN2c0@|rX50AKwpSy2^RIG(?P&`AR<=7+415KphC?dzBl7@ z9vzvakZ8a+HUON>3JHXnLI@p&79nD^J>>VhmHd#WK#!l%ohmOWm!(Q;rc^nS@vCv_IElV zha!TQwJ7yG3Ddxv6fVgeMnjcC~6e+C6NlNq*^L0((1E1~> zbCpJ?*uly5VEk=5Pkm*aBil=W)v11E2ua#Zl|JQ0wrOFg^?T7J%sFeAmyMg?A~Lc} zw?9382===YS$I@&D)MXilJhyk^RphRhv*Jg|d5!pH5ez}_@1-oOFG+aV2ki}3 z)_b<7+~TDEyJK(5xM@nmOHU(Acf3>0W}j%=h&poXm$21eVQZu6{$-0!tsb}TvN-Aw zgLTI&?@u>y%9a>4M-O^?ZO@ghNKaRGXAATceA}Sv7EJNbheE0}}@Ezx}VJlJ|d~*wV5) zOGAxrl(}0Yna@ryb)zBueO>=dQ!T45W!Fd6PiBE1-MeO$FRkl7zNLJ&2^C-D;;olM zG<(!~9pu=fbQ}HqRm%Rdcn{r(iD@Whni*^C_1^T?yP%PKD?`G8B8I);%oZ(GBZubi z_qO$XnZ9&wJgp+a{(OE5w>#><*%pwePokRN>j@Y*c9(6s!k6_H?n{~&J^3J{GU0kH z$Lsf&G5NId*&|_#`}cfQt;q%9v`==1yJ6bql)6dHEx)!!>P1$E=vwGbnqQXb5k5fj z->f;eBpfCxr$@Lg56|e*2Mi8g{3MvJ-+6Vn_TK3-?VQ-zhjygLLt?O>qb_>!Lcjov zt=e>MP?kd(q=Tlk{e&Oe|B=%2Dway7Bm+mJ?=`{#!EAtsvsZvJwihXW<2ULhn~Eu! zQQs{z`rTqInrG~?u-q2r!9!r@RVO$KA1aCV=CdN5PA0+oA*cWTcqR<<~C7|W&zp1+7#kN zBSmeA5w(Y#Ht~6Xm_r4EUd5HcP5?Y#L{ft>hYDKEHwy@g0`5Kc>74b^MV5!)4nEt~ zOZzLRu#&H;|5M$x#GVP`Xx)?YGfJES)P+pFqA5k0R`jV1EeVc3>cVT4 zYmbFUsu|6v>$`vyl)6oQn4L!Ou(u3Me#IsE59fC^&nLq?g-nHvh3tyngd~wJ(&Wdd zjxmKeeg^N2R0qWc@X+y)7=Nkilx2u=C+=~pwJO$SEpfeLn78HBFIBIYleS*H7@feK zf|pztln5^bu)4EV(>%Ba;7;EjtC)w%kK)U0z!lS{l(C$Xo?v^|(9bI$7&B1fJeeXX z9iuiJY%@i}nr8Wf#Jm#fVi2P0G&Vm<4A zJF{(ZiVf8lIm;95Q=U%{d`^4P)_*^k;3z&JCrjl&_COR9z&Pm8V1;pAE1IXE5Gb;~ zZdUQi`IGI^yqNJkebRy2B}Pm8dYGpD7BAD$V*+YAgIgYoZ7xv67&z<#?UpR{PxlDU z81C^8p8Xe?_3dsZ-P5QTM(bx@WG1QrhUpY(s|7t%scN~?Ai*wIGnW;1vhigM@R1Ml2} zV3z{aM-(QW0VZ7tzXar4$?jXO3|{3BxGb7b5)?YNI%<^Oz2(yGBUi*lH#^l2zy9`g z@FfmYiJJ3&Hqf7enVmYHQoN1H0^=5 zqa~rN-iB?8G*hEnA{~$iqDVWIM)bvz+Rz4`e6}N8+DXVMSX1xjgZ@(nY|Z_=LZl{f zna}rG27fM=OLd>?QB4V!?eFBFjgYM@NeH9~(B>2PyHCAMzNa?zh1#w(r(8G zj?9j4Q*8e1lVa!AHLK1iGj~-bI@MRSIee<I_O6~xAFpqUS?7$s1Zjyob3baM{nT!NMq2mPY&e#1d24wFb0+Uf-JABW8ZgjV6TV^(lr zFfKefTl-+bPO6UHRyzTm1WfpIGlde0*e?sbcM&ovjr(W9WED9XpNihm<&aDD9|Y^< z*#z}phmLZPXwWS}c75}YS$?N%XrSl(QE7)7(1j}B_PB#@-l3%i6@@X&3t{%WKK$0T zBacIDY}BjtnS&3omA)6ee6aIbs=;f69c{%Gqu@Ue%Hh-tiK>ir3 zj(}a}1(JyAbzV}CvfYM<{WtZ{>)W(3I0TXV40YeV1`pVz2hk4eh@gB$De`%YZgiQx z6~kMjMyV8kKchAQ`Wy9|iNRE}C7Bf=O|gI8C*2k#7*rM7MIFGT}#tSV*Y#IRKP|c z0on6zb1Ko~kaP`JGy3&h1G>rW>Gu|D7t_eaW_vz%FQ{U@#vzNP)+PI=<6hY_rzaRLKMhvY)xL@B!NX82!2sP(Gd+>~ATM6^ ziwqXD2Q>;g50=JmVQhlZ#ixi5I*+JoFyuzCWpN4;&(3Em!pZ@FyYKq2FF{7cfm(`H zs+*-1owswt=;Ofe>fJXIpXs?uOIH+P&d%h-q$>Hd&U)u zCft?c883W#*=KgR&r0BA>rG1^E=#EwT->qEuAY+^}qY@?h=J2)pN1Z zI|p+mb!4IrxUKz;6PwS<5O!)v78|V48viNmPurQj#G%5jOtq{>x5%?Pk@mZ3Xf`%3 zgPwhpr56Sl9&+S<2sqdoWt=ls%`{kVepNKpA!e)m1?xPQ&^GBi3x=xf@>>E6{P>S%oO0unbgXaa z{=S(<|8D*`sFyQV_Lc9up21o2wPK~$pZ6bF4;`^lsTm(r*>|4vKvp6SGhpxF^#oVh zzzrw2&GE;jON+gZ99Y+)Q)_#jxrW_bxFrPp=@$g;B)WQhpWsp2VIq{$yrN4 zOO3_iHXo6DS8glg=<@G(;;l%HzCSc-Sr%n&C*M`jCc%Ti;eyta0f_P(ePVQO>Zjth zKLTU=Dd**iRV1mmZapd-56N$pzjz8J)Ny`k98;V4>vljuCctu@X>KKUdw{;uZneLBJX%>ee!+s#ceTd%DQLNbv6=cxS2M=t2<;(UilJP$z(&-UJQ0zt z;SOL?678V;&cfw>Oj2Av7#=1t@ba3&W6F=wu7;aJN)$tEzxQDWe+zNv7x~S*=UWdr z5*<~kBMZQZW!)~jx^`ZebqZh)J*HE}G9A%eK5dask4=1r7(#?+OGj(l3|*3|KyhFo zHOM90ri$EW?qDSLF_yJ(FHKNvx2`>L%?)ABY9OSqC)D4&)}Y zOT!tbW1Pl6<#Wx|W%8HxZ>gERa_N!-25ce~AIWAM5KfxX?P4DC`0hW~WLNIn9u)SK zx451y)Uz}_uEEQ5%rSdBD!lWWKs0E1H%;dxscRbOF5o;Re24+(!WN1U2p7(yPI+io-AgH z*MEQ3OI0ysLhv_z{7~R0$Mrk;6^o^BeSVX?f&v61;R4EC0?}b$_F#&`)&|T+VhJ2k z3^Vm^vgck0B?BK-;PAq9m!tH%E7BSwdQF>if2(GXI`A4b?O>S@T%qsY;QdO$N#`75 zq-?ESYvdB+cC&0-KU6!HE}h7-H^$|2gd^B-0n9kTnf*g4>BoGkX_rGi?_-ZOP`0C;(2SH`>d-=iLkNdE>`E3D!9pW@eC?Co6>*p5+Vl=}@%hop zl~q+ky^+k_wSIDrPkUWeCzRZ{I2oVcb8J+RHk=H9K}it&i^lu6*{T2Jq3m@>;hdL{cK2S^p>h|H^*h=$F==eYX18# z6u|M!0tCfA2<%$2Wq#^->Ug{~8Z$55&w$cS@9jKaALougxg zU8b;D#2Q4bgq#IdJ!%Fpuh9DiY)W8Ea=4Gb3qocK>EOR2SPiLpnwuUD|pJ7JwW>og&kV&m^?w{OcV@K z<*O!`2*qhcNR0r8MeKsT6y`PvDLtZTRv7pfsR#Dv`n=P|31Tb>Z-s&;t{yWw*!~zU zMzM~6#k)oRW97M82Kvr8tw)KV|9(N5(?N-cu*(5+9oqpS0dO6I%{pHA2ZX;SF$}bT zB#29e(+naDUU1G>UY%*4`+e66z4Fl-_4Sv;m?6+KfBF9>_#XvcV9V)*+AGl z#OZ6}H~5o~%|jy)Kk*6pH2g$pSD=H^q7PVC0KOp!iHUf^J_|)F!WKr$anvKRhu$D^ zGFA6!ZDP_00s#np@IlW9fp}xhccXW%-fG;A%(?vpP!#MmE_nK@d*M#Xl;rZ zY}9W|mwN#@%UI9bFc_FJLvIUEG;T4zJ6bysE(gT8r1(J@0c{F zsZgA;Ofq3P>PA*DFD)rS$Fx9|mC2W#S(S_Zi3 z10-O8Z2RR`Y}PXg&yhc);xgjgmrGs4sehT0R33irT%0;{?W$}(6w zcwrdR32aYy0V;Du2NbkOnIh9<)7=rO{<88?v-__}=%P08iH zKxU$Y1G;;&`i2Fj^F;Ml-@kpkkk;AfyU4#zXFzNutP5Ny);?BKw-cTiB-z&dePF9V zd>?E!*zGp*%ame$p|c3iAtp%w$3=N;CJAS3M`T9mWMjF54v*FSAPIVKX2#s@!MKYqP)W6pQ2>Ea|E@BNKVr9Zq{i@kqV5U7_H zCoc1@yU5I0or~1X-gwaKy8p_R)rA)~H_Cqw9QpfYqi24}H)7whpq@(#I}Px3F$Ybq z$Ff1Riug9^Cjv%2VQ1MkD$dD>C-LaVzsJ3Vp}SSLsnS!7dw|T2qZlTGg!L?XCuIp? zSMWIHxFs;-hdUDwnu9!d)Zh2vHz)6eR^8Y6svQBrPcrbeOiWT4sV!;8qiv0sWB?-# z6-2Nuygmi00qR`^I*dw?7crrWdxlMo?TqspG^T^`cvQvR1%z4bGX`7KC%h4_2tMQqP~|{qh9k^HPo|Dr!#q*C9G53my*eG_ z3TnCKL~kGDI#B5$bO`zz*hmO9XiVUeu$J(Of1bs+j#B%d{LtGIPrBrZMXHY_jm9;Z z@9y>B3)fZBK>yKG2GHNKb&#p+fF&X=&I9CM#7Bo~H#|gZ6kp)+kAL5Xfw8Xbfq_~I zaoxT+s!?aMKQwvt5cm4_LCkL=W#EXC#@ei-U}Y^2ynsFv!Wqtxgf%paG8%t7D|BLr zE@iz(s zL4q5Zp^@nMxYV42*e6Ja=pshMV+0SY9JZV|hHy)su{!VLi#g(Szy6)rJln$Xmm}k8 zOW;kcL{sUVu99WoA!46WWxwQpA(hUf?V}$`hhSpbW zV#^W6RGmS_;I@f{f0lmy{%+-j8gKGp9R9cq_b93E=nZjl&OpEKB8(aSa={Wx`Rd=@ z9Z6qXK&a8dxPpk|2gcKO(0(D=e{umO>Q00I z+Qr7W8N^`|Q*&oiMIW*~+zX-$NhA-rlf`K)yj#nI)<&H|Z;`sIl8g>m;76dTc{%y?=9Pgp#fzG$L1;M{aZ! zN6y~6h4wHxm0kNfdj0Fz9MXh_QP{Mck1%US?)f9Z>#pmAoZUZM;p|1?tva*!E)KoR z6Gjv5I9X6VgL4^O=E_k%mgKl?Uxk|Q*bFO9Y3Bon-4Fpsi&r;NAju zk6C&`^P;$TnjucxV5Xn2{F@O$(frtNJE2#ERv&y$awUDto2KZ7hV*;E7JU8f{Kd6O;0FIPKjqK2{ zRvh?^`!?NE*1GF95KeXziL@t0Y1#{I{!8n&jqkPQ-Ge8YHm@+5@4&m^zyliu+#?L6 zf%PHju_d(XO&PLYcp%J6S2t(d_1?%-B>xKC2ZJuQpOm8q%k^cH2a`*hhRUvyuR3?V zO<(DcGqCkr(q_7P=UXh|lmMc&_OE*xP0 z8MHU0E>qYR6FrP?a~M8F*8~yR0|)61f1U2K*wx`^8yF*h;%iR`BuIQ%Kb_ z_vIsRK^lWI7+d0WQl)h!Fjllua26q7fpr!p%<&Ie6u9w7p#e}Ko@Sz}hTkKRKv%8V z8pyRoEO7eS6Ej>FKruk4 zDo+2SfO`vf2j@dByIVpOj+IsRfz2}i>37lJspW5K!eK_3{X~2sdPBHgm({RIB$;&# zM|a=aV&^wNv+2N}ysk^%zq8c=TE~vQ33hzUhTAs?;r8 zYrao&H>;xd!-zb_8j(DW;`@U(F87Z0cT}7Dm_R?<8UL#xzkgy}yqg z@6qqPATLadA6lE^hCx)AVTHu@#GwQpioa|sTSxdqiOo@G+e+W^bF(LVXjOuhYL>>V zI`2=f&V6mW&K^D*i<|*L9Ca(l@t4w2{~_C&-COrZ%7dDdVG+^#$W4WN?HQPlG0$^TM?5Qiz3Vt(aE_;a&%L{Gf?n<)jZPFNT|ypEQ!990kUekQ|_w3 zts5RCtFG=u;u;*l7#*REfs`-%%L_7Q`=Ji^;^+Qmnx~-wc9*X@pXY^{d0Y-daOFZs zl?^eBM3iNO7amb)qAWrFK^ny>B1TLI4R`nB^Hg#E8L~Xm&d*R-q7;Q|8wj@N`*0Tt z)cfSg+lF~aSc&C{jyZn7NUqgvEb<@6S@Ce?AzQZAWB9$Gh{Yj$I_LwR zSjG~vTX8eOC-KM^!XPDXhobdbhojwp&~6v zt2BqD3Jr)~ny_W?KeQIETzGMpECj|!)ZIQ|=a_;IvO@o;RR)*DuAUPy|9ql2 z`jz+N&87@RXE*!~hg9{4U*Jy7a7;W49&&ubVbMK0eHmCFb$uQ@?k2(wbcTWp6f$9L z{)|6^j>)%e^D_+dk=Xg++yWcT;azoE8YMi_C$%Hv*RAH)FTI`HQ$HO@w~~G~uk6Q~ z+8H^qY)y{715oJyvAyj1m`7mo0`+3gT^|Z{e}Ae?juprC#e{@}g@0+MUdiZwbXWWq zyUwk&Z$8^+oi4=NhpG<>MqQ_UMPYOC(ARSFi_g0vm4_^bo`Jyt`5*$K#)8bE5;`m7 zAsR(ny>duoD@Rm(v)wg3$lLwaA17PisSm1^h57{uRkhufJJ+Dfqhh3_+2Y=*6H=~F z#Ffq_g^BPaO}g^~Y2NH%QD)(rW@BiIoO8vX0Wa@Wz zmV44x+9XJtqpSW!Ro7q2*dLhfg5F*Mk)_1?Eb0RsE~1Xr=D9h~%_N(&1(YNPFG)PI z;T36o%FIMHHa_ExD^{bHtMkb+m4im02-P(#1%eTRNzd~+NqYQ`+_*H|yL)=LO&dKt z&&C@0!%jEQzm#$z=%G%?$qQ)aY2+2Epx8nvBJgo!P&1_+7Cq67KJ62y^0kiIZC)>90l3DnYLQ1Wh$kJ@5?=`_@L%0W67~C2SQx5Z#_pkkMZfjci>yPUJ6#>bC8y^3_V_|Xe zn~(|ro@Mf?jPcg2^SdxHIx#+eI6e7dD!1cfdri+4bDvT--FZn;?8S2@zYSxSgHAup zRoYBZKL%3Cz|?^!DQ=ZARFF776mdgngZabQk`%d<{HSTn!06PO>ykS|(-DDD0m8Zm z#|p$XI4MaANYRgjysD4zXEqxkpfR&xyf0m?T+C?4reNIbf6J2A5F>yl844((|Fbf_ zA9c}84hmHqKFAS(Y$0`+o5|Stnc|_}M!WLoN&c+S#;nnaWw^IJ0=zLccJbm>X!iiy zI2@O7(ibM31n7ys|n`zh6S2 z);(1G9Z1-J?MiH(>&bEb2TekT=4|Z#J zz;BHA;l2aqA~=GTsbYMDW=Dd7>?vHTwgFaG^{k$9+uy zV2y$-j3t+aW%8q}#-8LGgtG2>PU+14PQTl z!(Zj=d=IuGo-qNrt&RDvb<$7HfwYDVYVZZ>vAD2Dy zoW7)GXC`plUQG0CBrf}p7a0CM)AH!YkJG2AuhX>C`ZNfW1o+G98i_lF6b7j5#dMuQ zA$sqTJ6I}!4s^3^C?jKLuc_#7o_66kb`N#s@=6be3s8aIP3!Pq?QSRT+fxj*yX80D zrPE*7K@}6qK+QpI56R zO;0`ueMV-D3Qk#I7Yuk|aCe_y-^g@ziMu$rRNC-h*VHZlS-(3;_K|$L?OMk*0xC>O z_zV0ioVV}`t`x{V=Ea(9zn9>H?U3*d6XR5Z!w2 zdF_<;Nd@QtwPx$PP>0@Q7F`#2e!1ol`mPx{Q%iaR{M`zg57I!?WsnmZ=X&W>e! z3Cr?ojAE0dK<_yv>zi19#Kd5$H`^U_vEvl(9WKrf){Pb50e&TXr-F%glO+2l;12*B zK`O<-ZOA4#R@X-zTiw9=JoYe$kx(U{pFbaF(CWRS-TXoCWx_ydY3W+}wI#tSD{AI= zeQIINM=Z_$XQ%(|8FndG3&1&c^KzuJHp_R(4>^XS3Ft8aE|N7CP(HoLi2m@KH<;5& zsQVb{3d$;|6&^l}G>_Pmp0t{}U)^JHV(jqXup;N6x>>mrdj!*kBIL(6U0wHtHm*su z&uGhc1jKU;Qqk27mxu4d_ELUIun>KLvDL9dNx1s(=pi_EUZ>s?iza{|B_LH43^+t< zZ^{J#_af>hJ>nf#mA+!z zgNbn%lz`~>xa-oNp`q$ORl}!^4#{lIcbyhX2%l2(`xN&UWigVEw*`HGj#f%FrGAFgy(8lyRW42k;u_csHp5VR@V9wxH;$QsKor3?-WTS?oN zeWKXG2W|VH*19p^teH_lwa!+Dy zLu^1Nd;1vQF)c8R1eGQXG7*Iipw7>h@m!0jyxId7yRe>q-eHTIqUz{z^cKcW7R|p zveE#69weT@)F1*lPE8yb&zKSp1_A$>tH(McI;MC^B<&Zo{^ha4kE!skoJRvD&rWQE z6A{fdrPTRnqPKt97^SKY1&A{!%w`S1Yb%}z&fc?M^njTtHse(KgG0m@aH8b2hH~3g zD%#M38Py(}uB|#%Cl{f01v!tkgFyPsHr~E{%Mpy>JD0=v8Xu(H(3ltnnu-n~$XbN9 z1(X3nX*KuEt4cM1;xI@@1Bq=x>| z7?)62)&MRiUa~#*zkx{HYI57_%|R?hAUY5-+d%!$o!n#hD@uN*+N&T`^?RkjzZVc8 zLcnigX-o#*)R+kq+5IP}v}t(Vff`^D9TltPK8mz;H)VKc`Z_wTxK3=CVjSanEObXdnWohqZV6NJw9jVRTfJbAKuYBF_Kha_Lj7=%;_gK#{L z^~D->^d6dW*c?C776cc@>Wf?|ZH62jJ{97y1x7644W6YU-LA~qh8jfzG9I3O*`b#g zw~Kvx>F4&ar!XzFkmanAnYGqRDpLr*f*5Is6Wwryr-7T=t0%JopQ&DOx;+AdMeq6| zs7TE+DfF5@n`&ZhbJ6zd_={g|wrDw!-->lh%8)JU<}|4M{|K`V6Jnd5P-Ye|Uzhm_E0@Ottp*7drfaPgXP|#}+H2NuEGNYTOlQ>@AYewF* z?ya~pU)ujtsWDc0piJF0gOn*^p#OEk&b;WOk2=R5q_&RE9!}@8nQWq}jy>kZ!OM3r z?=W3%U@1OZ00!kSW*hy)S#&)Ay8;Hu#b_)-nUd#N-^ z`OyOg(R`&;8%w_cMPY#L2+`=TEb{+P#BSJ9H0zN1KgM-Ud-`&t>yG zJNd6>R#tcA+I0{{Il7mR`Kt^0kw?C@^VK4G0#Zi0)tQw~Hq7wJ&>E=M5We zWmJz}M&SnJZ2Avb*bYh+S9I?^I>vsCv?hF5Ew&W&jELanw~x z&N9h&elMo7$Ih-+^2~_n@Z80{K?Mh!b2tJM9}!(R_|DMCuS!`Ue#Uldhb$*!iqJXP z2W^h0nca4vsYGj=Rzk2jj#CBva9^io!Iql&KoLzDX{&q)Hr@g*5dr@@h z39%B?ejGD+=EQ&kxH&J)QXe%;c2jiK;MV|zp#g#Vfi%(E-Q9Kc9Zp#=qu8fqI6J^7 zi+`~450MtACVGmXgcQth#>&puVHfZ`YR*5n@bDbEMgx2HP4YQTIqLG*JlA?m?<_{I zk8%a=KAdFNgccbY*N{jM`lCEdKjI#l9<`=1JJw1CU_V^@02&O0=Jf!T%pYFw^o(H( zU4XO)#?i}$UeXN-+tSkPD78oJ7f3}biC@WoI3YKcQDrTibnS&(J{q!X%xIWE5cd^< zsWHv%arf?Z<(CtBGU+v<{)@RoNI>V!i`|)3C9

vNnL}uiiAx$2!i&3s$L#5#;JS~ zcAe2@7frAx9OM){crmJ@s(Gqus}0o(V@k^o&UF#7!S^V1WTC;$)bE;nE3*!8UVbupl93 zd#X$4!wn%Bjf5=j6BE%bv+MI_bkER{;$Rrdt`SJUmZ3hUV@$~+R7Ap5ZgYTwhC)`< z3y-%0^@ptnl)SS8A4eqTsW8mY1{eWR!p+4k#z_PNCt5f=?S|CY?-Cp$7Si2i8E>|P z-&(IJwc58V;#j-7EAY6TpU27aX3B%~9_uXoHBy+71+13boFr}LdMx2UiZd!CkwpeG zOIh_%d+G_-gtm$E6~Zdn*B0{Xlx^Z$?uxjVU5HL zBIr;jE~XQl9~yr@Gn7~ymG=|Vt<n?5mKU7XCC>>?62cD(_%T~r%848dwA^p z{O-%Jpeq3S$TA%F=c)c8o+LDgaQXse2fx6)jIh65Z^7dm*yk??HYHG_z0|(w(+MYN zNLlsyZoWJjJ%6gtt+gcXLtjXeZ5~tT-XfQ!^l!FjyC?7#eRrRdL|_`cFek{jeyLN*_F2NadeN5ur0iJ62pXJU>B^DW30m(%PIqkWUO)FA1 z8UYR8TVSx|x0tBSc2T-ICPTVQIHty?cfbIleZDOtvT)i&5RurEA04hI+64zuo3Bm+!*1#*?#m#vTWr&gopabwy+&RgPgEYf0?+ zmVS4n12$)~(N{~H;T)V?t1!oU-v%Fzb;)Don^n7l#Rk!^j& z9ho$raTsD%TC}(8DvzH>2vWIW&kx=Ebjsni?I?QX8*5WD7-#Do9gw?OGw}ECKrkTy zMk50nfb`#|7tQV(esoUMG$l_4YeRC>-{pRc}&y}n^F zvh{tg)wmd4dRbcFktyk$-;5tFy}tg7B91|EB)!?qSns42m&(lx$!*E6yS_8D)JV)` zY>$y*6R#_2el#q6qQlUf?dD!_3**BhO9}Ga=$5@WVBnFu6Mm1XUaW(4#^F>F=0euue79KnXfThe)?n3L4TyN(!ey!#)1yEL>oKQw8dsuHp${iHC+(h!|% z*Rguo)i{3zx(pDXTxrmvDixx_`OC?yxAb{&vv>Giwm=dVa_1Zr7W9rhW4Fwx%~iz$Dh0emj7bm{vv7(o+Lwy zDZ5?-tqmTH*Qe(CL%LsVYy<&ihgO`vl}+nt-A&wkyi(GhP^ zw*>nn{1y;|jsAM9P*x~0}nMDN5ZRox))kBv>0!9In|E(;FM;e%(cn> z`uhQ%TV$sXv}1&{EHJ1`np@Qw@#u)?wlINULQXX`(;z3IXcEvCHsD6rugm*AGr4BP z_H%A&PoM&71W1Np03LUDxN&25pn|b^<4kJkOFXG$zM0@OaasAaak6pQ>?%CmSR0($ zWFkN~`eVvPM~7(~RA30LsfD9<{4J1dM^E~%47(0;y!QjQ{ z@L1*Om|#w@;CPfCi*-%ig$fU9fc7eN-ebmhuNtfkTE5LQ*7A5fNLxaWPf z_U-7f{a)e^!uYoT3_Q@;<-{h)c&i)f!%F0tmTQ({mRTKLOrUDB`_-D`pTmRFCG}(~ zoXS{3{cZz*uj80>BK`Es6;e4oB~(c+Sa@rt$=N$|U z9av{fZz~*ze6VkEWd=TAu$Iz&I*xLCPMIn*VZY?WNYe=1+zFcoofr4PF2>SLiSlkH zXQ^kq}@S}xQ*Wb<@kNa># zHRqx+qx{@&*9U#zhsnw8)N6&d1-WnBP7C#}Hcs%5n*Q2b9F!mIt)M7BHXnPbVlS*G zVf~6YT-&$uMFI5w8Hctc$;uQjpP~=T@0lJ>uz$Fte65_dg!xO4e5r>I}r!;Xhf8=SqdXf*&zi^r-uvdvUh$dbD#Qc&DeFU=JrOh zHly9&M%B+G$0;X6+yYvs*KIYq2^NFUm8S|6O6A*kwB~gRiUrPPIFC%wynMP6zU<|= zSIH#kpVUHj`Ch507@6<(!yPQSm#j0k-Rl_JZ-$--c5yI4r!MI2jFVLqPfjxsh}*j+ zzP6ZZ@{$5JFop!Tbw+Ak5z0QK1t=B28IzZKemdgHR|1?u@Gn85OFFk5AAY+Q5rs+k zB!H&}CnaMXWSE{KDENIYT%y5THx0K(9HPXA8e#?R{ekYV-G#ytjS^O>*e;-ZBE>ad zs!1&VW=n9jA{cyQO_S`T9g{#0BU5xw`{Qwg-{Y(*9wz(f{k5*mj?8UAg`m4&VFa_JJwN8*b_ryK9)1$|n;|>o zxw9D$m_qi^I9s~KydOP1o5?Kl#urzvmtKy0)N(pX)yUo+#}PRc!e9mA7vOw2!H}8e z$p*fsOj7Hfi=(VY+1tX@#`@Yr6Sbw|ckJCt&-E>enl`9JEv52|?@&^f&P2Pyik9k? z)ccDP|M~gjm?UzeAV30f1}7BObFwR$`g{WuIptVIr#-$5BS$>Wh87kUwKMI~_nS;B zPfeA0doE6`GhwSEHw2vWs^^;Uzm6I`aH{m@rX=e(Y(G=78`~rH7dI{GYO_Jhqc{p` zY7Owd)>r%bI%EA0u3y!VTluitaS~Z^te5Rs39Q%!SRW zd1tB7Fz2Cz2TiKDl0L$5_FFZmyC5v#vV(wwFZ#gh%)kVZ@$fGaW(RoBKU}=Sd}~!` zL@dkP=NO#WfeNGfq4_xdC7>FkI6fTyFz(hvKxZ<=8ByfwL0?w}!XTg|3t6@Y+bjH& z*z5CiWEriBZAq8b$9DnCvd|0Kq@7uMH=9D3ITN19h!l@4}nmQ%l5 zS${C>p4UaqJ^T9GjW2fZ2u>Yp_`Z91;prCCGJh16RTwYJvD4s^O_PJLb8%Vc@7j9O z0A%#iYLH|Re;bA$|Ms!>xT!msX>0#w`8bXQ(dwsd-k9@TZy^L@1QO!+#I)~BjojkV zX*|c1N5x}C1dH|z-2P)MI+{LqElc#?pC@>+kRd;)Qg~)e80-Zk?Ltz!R32egx3#f< zJMcM&+rY|EwDB;KrIyIK7Zz8$(FkyJZ5$gJ`4PF}l%wN}WcX3lp^r@;7-0k{Tc8(V zd)X|`?PfINZ~-Ib0h-0+3wn74;zC(G~eqoXG=qK@%cGt8~$@j%K`pjM4 zcu-5EDW{PKSuQGy2duiE-`G;Buq616BL=y1!Ey!$+k%~Sl)64i<&gi%j+6SH=VEGp z-r^}Vh z4-z=p+)Iz&WNXArd_YL$HXPjeuS4a3Kb`5%SK^Jle>`(DG<2@nl(P<(C&07y_R~05Bq7MjD zg?_7}H2y5iTifC_eMHyvg=gPCsfa#i*7@Ytr;Qf2NXu5&4}i)6-J;>F-iu-dOr;N= zZkYRTt^PepM7^NbMXg5=+#{{rhgS*U+*lIf9Li zW8?vk5Pe`SZz7f{3@gb-oz|PgT zpQ&3z<(Bm@kMQQ&A2Cbw*iu2|gzxF~Lp$@+Ir3<1ix5*GJPO{DR!_CkImHG28~QoB zP9rU4Cg#T~1vsc=LGwu*G zbmgd)Qrn1`N5a@SlG%T&MFJ&>i~C3vci^5xz1Y3p;km4l+@-rSn~C)2Tw=-@_xB5K z8|!xn+TF1uOF>F^(Gr*cIQ-K>_nD{@zs2Ol0Hc?E{j*?=PSNZnCtC>@@&QBg&)0C0 zV%KDBRiW0FW#+6+&*uS=keo|L(U5ZG<|e0Z^DNa=|30#ExtW5Otr`PC&yi}~5v zp$6l_A!BjlvA*A{bOIDBOy>uiRR*Kj$IKpIa#nSV^C=|**8$2-jGxcE0xnbr;?BU6 z7U%-pATNDxu#(SWXfqed%zWjXN)ezlzHwrE!XjQAq9+3P%as|Mw70h3h>1+8^Vk5C z>x6!{4DL@zcgnoe)o4Apq`oX}HB$NO^G9cyG(q>Y-4x_rc|}wH6foQDzlD9$QsY2P zFg9=$IbFO5=-GET#PY-?K_3CzTa{fc%iuFE^ui{`ONVGBvjP+~v^Ae6j}V zY8FRPK#2G1G)gkD$NPckC$bWonHoP9sN;>y%l-Ec6@ zlIYpTG&~=|&n9z#X%~f7w)|+^N|4+~w4SJH#F)da9Qo@UpQDW)ozrn^jk7Xzp{M^C zj2zqMVEXW5GVMi?BIK0+w5ITuzP&nALm1J${o4M?#~g7RRRAj2yEc}u-um+^N~r9o zzBB!uKVSRuI6OHSsn7C7PCG)C2^+S2#TT8VH!M5vOH(bxn(CF?$~dL|ixi@sp@+)P zE^&5gbx$tUtpmdp54z`5Qc-xo1AurHpI(asRTAjN7GVh+dGa_C1$|`H_Y&kxYnwK| zK9m1?=;yf0JFW;7m}NzH?z0_A7zj$wQ65qLVt!`lHN!WNL&K~AwdE~t8XG4n-=_GS zGZJHbGAqPu{>19;xu?pnHY+UVp5EaWE9Y7p!_nh)l;)%Q?U(a?f<~SceSX%}^GICW z=Nr2czPHuBx$AoFH%0#k9b>ocT4tGrHM|?4Eav;hmidJ)6XId$wpogvV5YSk#sa!w z=)spRo$APro~Pr9(j5!+tH=6HCifY<5E)$k+H0Jqy;A(JOhI9yCnRjA^OH{#%0Fjr zp-|&2Mj-lNZ*kbb%MRWg*3K>Zh+zwgwzlKlUB`3p^IjU!OBe?JQvj*j|!jj;hJ0II|G7zSbT1*bvy95aRjXs4h&Yjokc;d9* zl<#Fju|gT_Y=bex{~JW(;tqV#-g)3U?jYPfs!!{5ZWZ~e`N*)(oGY;TI`d7*@DR9Na!GO$VddH=(NU<^~Uw61-W;h{iu?IPrKva&8Qw#CKhgn%Bv0AJU`E9c`~_ z@Sy%>qv5M?lfGeOj_gP;y}^mg)DV2zT)PNDJ=XlFO5pM0)nG)Q1{SF!0YzhWD z5Wm$GIZF7v`r>7cNEkxmRC$d|$=eT!;_xM7PecVJB-a23YjDB+^HQ&FJ2`PpxTJdH za96Qin9;wz8Jyz)@%Z2mOeY;=<^Hv~#;=xAVQ|>x-8W3vG9Kd1Y|LAWg3rGEzNzK< z(MY(ltL4DZINJ>8J)qN>Tly6J=j_K7q<-zhLYVNd#rY#^cxi_g;GxnJ6^-FKw(!F9 z@uFs#`;2OZQ{<1I0WVyj(rRXOaXc8}M%<&0*RJdyKEoK^khEw96*Dq$2~YsrWbkpL zl%?m-G1xQL!l?#*L9{S56GJ*(dInN_(!ml)Vt>^-9_dhU9B1i8})bj8L zUp2xSZm$KdnMaQ1pw3+KiscI-3FKy@i z0=AIpysN~BQBtDs z*y0yG?l!2|gUaA2k(}+7&uS9jc0?%gS3^Ve=MIT86~4neU*e2I-$$4<`j89`y<5jH zghw4;7M@TmZOPW)2*>j5(&ftxr1S^w+q^&2_O4$a-kC*zfbmeoW%=g=WeQm8oaZ^3 z8Hgp_*r_ukYAO66@8YfAgn<#d9@DXiiH(V%%PI9Y^Hrm5Y^WF7x~y$2)%<>zMO6t~ zY@M20!hwxE-|6O4Q++M#zgmd=dO0@9XRSjHNig~XCV^cTe3l8M5+?Zo(59P2fB1PB z^DVJ+#!k!#O^qiffAt%u5x8^Q>4@%GTLY=U4EW>IkAm&~VYBw#Pn_7Q!T*rhfxhUZ zNmpdhCQ-zxE1K$n{sDUOjubbj*l?qjT+kWf=M^}8L2-m6FjCOEy-gW}m3A($$#%3S z#~nHy{$kIIIm@uGy3fx6{(uM&Cjz2h(7#9um32MF$^xP2tO$;W4H^bUnqOmo-f{XX z$SYi#xPJP_PP%!$EYl^&-$U_Eg2fgU%CAaYsa? zKmueJ1JEUj|AP6z*ZJ#Cw^0Np<$MTX<_C zlA{UFP*8YC6-+m;)`*9sbStO4BO?>rt}G{gzD%(0rd_m>41)^|xpTgd|3pV8L+qu( z!a_eHDCtJ&!ok_4lJj99v^BN-2`$)C5>9Ix38&?;Z42krKoC#|i?@Sb(Xl5v-$zW@ z)mWlhRBma!)TN+SjBNLtSX5d&v&{u!N&>XK#}M~O=fzfV4De5MM0xD2p|$6H%OGs7 zev7qf!??G%cT)VkDUV9tbJriLaaeg-WU6j+2;NWf7kj-AZzLhN5}m(s$kH;h9^QagQFCPYu~~sz}*1TYqF; zjrAp+Yo29Q6BllQa&YoxdX|&G!szw%KluUQ z5)(eQF09;`x}E9aB8#gQvX@uacpGFJE8CnfW_2!185EXm{ATX)LZ_&6R4s zErX ztI1!2tPCBP+cbv@19k-`CFBGp?}3N zP#ESDtU0CbFUR^fPijSwaBd6D*8=kcJqcmzg@GbzFU`S?m$qN-H<&oQRCjW6{t{-**gq0F^O1APk?9^pHc)RB8 z;_{oFbwxTOoYm?IhdUlWFI8`uQGvcQm$fZ044W6U@#sCE)Dw&lGEY0f5XbL%JxD2E zk1WmM^v;roa_7m3=f&n~DqnQ#e!J`*YSLvkQTdNDhYrZ0DE9ieiGJ6|=UZRD)tESA zaGvkf^2{v>ft;A7OW4;ih}tTRd*jhKUHaW(zgWv%$(Nb)+Zhtrhuu2Nz0@ND=dJ`h z#6LYN(qg<|E0kP4vBgk%Iq&Q4^pulaM~wA?W z&Hja|mWdgr?+wcmCy#52Z2OrFoQJKNf%zjuN26Xi4Bem~QYGBoDk3wR><5 z6}rx)aq%&Gi*qu~Ojt3>*S;>MUN`9S+pHL#z*m_uF{kl*Yf{TdB|>HYqrv6kjl_G^ zz?wcSo;xfBNo7fc{twrW<9F~r5Qy}DZijeD2=+>gs$QeSBzp@Tybd@$XE~7xI~gLa z!A@iJ$s#}VQ=Qx7;tEaZ>u(l0U9x(&ly>N%0qWs6pjmM`bFY zW9;OPgp@A}I^2g!FFNhWvK6b$XhAYJpf@7WonX%_>+V?sbC+;t2E2}-FQCpWzg%I9 z$n_93Rp#I52mr9)4R%oP%W#Rky>I>U+pvXO60^)|`yW!j<)|G~5WA6lt?Po8(6F2a zy!BC|u!u*+2mch1(X*yWfML@u8%t7z26oF)x?R+qP9Do+>4dQfi20d;uQ3IpxIr-t zZYy$vA7C6kd*@W0na2>tl^Zky+KP9u0%J*NIZM~1OQP6IX`C>K+X{WIiei_!UIAlg z{JR7DrN&9~H+OW!Mb^18x3%01YfA@ z1~CyCVDqYdEu{u0AkZc9c?esO+3zcBm7)2#*YC&2$D=myBBX=N{{^=mml8#u`49!u zt%3$R7@#K$fK0VHGN!algCQy08T8->2g$B-)$u@>jYlT)yvq0|;f}`+S_b;O!h#M$ z*K(EpJx+%UnV7`#9Y4OKEu^~lx!?gaOEUpF7Gt%|n*pYR8XzN5JU;0e8T!Z2k%s4l zr1^F+t=XQ$j;F8KdYhYr0#+n;KCd($Um3K10ElnQ#@1sb*~od9%_T+g@nJJnvnx`( zcN$TBPj}p`lZR@DWvARL2JzuQ8^T*lBY&8Yu_SDwYl|U0%V}fMCY^oT z>MpXdR?hGIu_hmq`(h7MAL=bs>f4LDv6aSZHcq|4={@i@wDWlT!P+5Gay-g6A_iW^ z7{N@jY*V^!!m;w}-M=%!CY96sIZRvCWJM|CMPg1*J2pPTGQ4DCedUs_t~8P`v5!WT zQ;H9A>Cv7pMcedwSf4hV-~kX#0^pWw;Vqucno; zg+uM$4hnCA_U{3!U&4(LKd09jL%;6kiA~gsd$VDhTNloW90{d`)j_ z`k0&$b8KDV(}iPC-QU1ET&|<7FepPP8sh9{?u@5KEX)+x z0(CUYMcP+mU_5V7gGUIP7E)YLNdtT{8eK>f61y8-Ir(JYhfemf2Na{pzTeqvuatWu zHy)NrU~FK=RaAqa1U)NkBQf3K!0>N{S0isG!hMzdfa`)xpFZiXQMmrPtB`vi@8vv! z-jw7jO{sxl*yRD_KET$jY#ET)y$_Oo-7*OEInE+r$p|ezh*Y6UCg$2?l|HmFzhC9; zdq;)sSNA-7)0O!pRg$mmYkkgZjiA}#?qD*mni$G^D|7fuzE{hWkk2s`i&x$-)^va| zLr8Go1ck!B2SJ6rbW~p466%0^aQwLGfAdaAc&AeKLDwhz@DARN?(}B%tSz%1Z=i5r+EBd5vuM@wXu{~bZ4#N)Nm{#t27;9%Z@5w^Dfy3e) z*M7{1$FmNh6a%J){o~Qpw*zN*E@)Xtc#D6m$FM?sN_H1NGU};U zSDn`IX?~_FR2mc6*W6l0=Z|zx9b-soBfE<@uN^&*S8P4W;$;hIAHFFTzvwfv&mS;H z|A-fo$d8_(xi*8^92gkLB9K$204|)l#BN7o2M!>l@7k>Q_x=6ufFSA(#s%+ZkK-2a2>`7 znI}HoDO?baUpRVIL3>{s4aZRkiSPpnC_b&UbqYFn7W5bxtMEn2W}bJuK0j6v@I+H{ zb3^)f*AXU*qxBA{nzfNZc3&JKZB(=L=GFD8`@c9m7W5|T%UH-fuvdBHN!I>_4B^a` z$_}Nluaygp;xl0I*QYAILCQdd(BX(6Q1U<}0AioKfo*F2kO0sqUb)hNKfAs6Q=A}U zZ?PT!CaUaLHX8q%b1NTuOO#u<(Q7f#yRt0T4;vLrM0u7^x{cRUksS439%iTGi&Nie z4{IKsWOLikD4m3mN$VyW!jBmz`1n+8SR(dsd;MxMcH~oxH?y!E?Hz#X;4+RC>|&%p zDq~~1^Q^6tf&xj=qQ3Cbq$#_4TibTgS>3rLPJcc{DF2Nbn|hf=Yv4gZY+JD$B|wVT zN#C8&GSMtLGCr;k<9^*;6X}SOGC3|$-Fmtne0{dG5y-y19q5Ne2VGM!Q=Zx7T4>R9=9I-d8E4+>NoLwz7 z8QmL!agWCRo0P)>>YI9&MKzmeC&67KOqr;CVKbk_BEY`5Mf;piV0NQO#Ym`fzT{_z zXB2VPf6g2^LQZA=REoe2aXRCoSM+p>XJQkx`oeP|XIf*uPHNNLB+|LhN5`Yy`gj5J z+S8bQ_+`f!qh&Q#(N^=XL+tZ4EXDqf>DLDY|CFnY^JHg9B_$h&rbykH^Of^vTHT{|Nx2ql- zxr22blrdXpmcqB24M%z9G1$ErHRy6C-}CdCi|KEdQ{xN8)6U?}!c^xdm7zK_yJn!V z)`DFKBoIK{fo+%waCdxYTsmZWI_^PTzuoro`*&8l?QQjoM|lR1ErWbCU?#OfhZEQi z#7t>5JgR{B9_aJ=V#IHl)sf`ZN_l9ed$#v&nzpcd(d_oPoe#xJaQ=YA4?`WoSNDrQ zhilWs0yg*8M#XCUcO11$lI~JSP>8yI982k0BaX|RKEEyG)I@mYJr|RcgOd*Vb}m&P zh?|Sg2&q#xoV>t$W_Ih-*}mJqUo^)AcVxtH$7m|t(yuUUsSQ?<*|?mb?Wl!`lCZBw zy;ZyOlsqkfp)R-BV?B$>|Izlq)H*q-$<@2UzBS_`IyJ3r2m4)qzl1)?|6WW}+Mchf zTo(^(l%G;q`o#IGxMtEp@6edx2cMtrrSbZ_iy4!SH=aE4_~Ek%5gML_SFc{(#T8?- zJrzd{stXuCLP>3%ls(e#{FsFk7TC3zE?Txm4X`!{f#O%X_+1t#H{?;csjoWeZ0uy8 z7WC@43TVIdxIuq<9Squ|GB@6S#h@hfs?}PPSyr(MuL{lwkyqWP?P4jzy9}8%csY0? z>|;A{0Rgz6i6N*Dpf~ExOQawCJa1{f{QP=sS7MhJ2fKxtZEXClBYWNxN=CwIC{CTA z;?duKn#pL>*gXxAACXB6^Pks|eBtvcb6s-Od^{2qXRjdRFyOsVogI72>qoRPBdCzd zS)Gt{KMoP`C}s?Ce`K*cD_>aeDa260HAksx8DAN2V$68H3raa`(P$Sy9T_+epYF#w zOSj9CR&%&}`u2^R`4%2m-|lb?zL( zw@FPkpKtMgWAVwHre&?3%}J&c`&n!r|6votJ~Ov&oA+&^OKmdME;b5$c(;YMCxl$l z=N*)o*neRdFfullRiXc@HQ(zL{{ypDs1lKVipdtnbhGaJJ#I1@*&2~VOqpZK-;Gv- zDf+i9*u&@W+NdIYj&WIO1z6p@$9uycEHsl}4Ag$<(0*tyuZhpI$H$x*Iawh+nt5?` zjdEl5>iSttp~lj20pa-I2jOE7t2q-+_t0aX%e?w(IabkO19e)PHXy(6@iye2_b_tYun9gp#S&9G9eZd6VX6*i*u zt^zG#<6nqkrd#rr{#(81Yv7Q3kVsdBE0crpomfDdI2&C}BUFYO?M{)6@$z%8-5jEb zYXe^)@&TX8EgG7(YHj!AVO9yX$F@g%jDP+(=H1tT<4d6R{c8L{8C#!GMQPmux2T#S ztA(kWTya`yumQor1roj^w~9xltL4Hz)#`}K5!Ytckt=MROdb1~GNW3CODYEJC4Qsx zd!P_AzL=O$@LkkNg*W2iuXpy`t$BVy?KQ3vlTs+JwFw7@Pj(-S)D$M`XP^GD>>9nd z*x+mLAvcd@L;gKs$s8-~xt+}c54v5gC4a=WN^VTwu^Rns&6=99O`dfps- zB%dkjxjfHJSV&l0-6B~?so2M!Lf+X2f}*SjD~@`Xbc}6ZDTTe+jrHLh(-%D# zE-G<^|7|E=JxegV>9qJ%jxYZmHhT8@ddCB}tU&jQr6J*=p7;>-@PbF|1?Ik9%%w&C zV%9#7eB<9dsNxul3;JrGc+wT7%Bj4JFE$n0=hyuB?V_1^9(1f%#l;Ud)_-iAVm^J_ z59FcWaxGv&+c_NIEMU60*@!2%VNaex_w6a2E~nlCI5hqvXc2ls=vtI=ET7m!QIs$+&SoGH_$TZ%!+)a}F8-Enw`ue} zHH9zvh0*iSd!n^CIr{S8k=5pLdM5J#nTJ7ayAl+ggxq^S72D6M)c!P!>B3u%M!B)2 z6-)SLXFD1-}1Ot307{DlC#ag^`z+_HU{cTekqb zWcO_MW3yn@q_5}rk!p~W@{fUjRyM(&yQ9nACc#P4DPN7HF>B*<>zmVm4EaO2;yht= zg6VjaHEo}B@L!C`&3wvvdXalKwc4GUn~)=i3+)m95)lst#TtoW`<6PMD=wNRJN8Gi zEQ_C{C4xhbMQypzoNyvSg(m87jn&UZm>1-JsFa`TPj;}N_!gj*zn69wb<9ZuX&Q1M zg1cc*3Nkh#BGZb3T`OW!Y^YYSaKLGc0- zyA*U|azjuZLP-FSD0J%80;{BiLN9j3;7~|`)Jx#LurMJ27NE(mqq4@!YYL7y?H9D*sU|wMxa%Du!O<{4xS9TA<9|o4dxnLhZlfmVnU#}3J zsvb>yvv(@!-8P!Uu)0(sl2QD{;0^ZB7nhD1p})kAn#iB&?X7|U0l-M=X7%Fu@Ils> ze+RUTM)oqNcUrQP%PUDUq}nTpdj1Y zIbyT(^W)Bj=lABmPkj0H;Zl%;N*jNng&$C9;?;&ew3{Cb6I^x-p{#$(*C)!WrB*AY zl&FN}#*3R+yQg$UrWRKqw5<5C+VrFLQR9$pWda%#_BG9!8opP?JAxYg}=YpVA<|m|6Q}GToZ^um*T>TXlr| zFC&1UI211|9PZARF7@<8^S=$YqH@*>1u@`aXACfB&)$wpdwR@n%9Bi1#i>LTMbfpnQ6DNt=D_gWic}5I zDlnVU%pho}?$QMtCFk^dP3oq?n3!{-T6_(O9hp&3iok>N(be_YNFys;7Dy-?6=1|B zzW(RN#zD}0_p;kRhMp6&(!LR?4RM?_9&<52zyTSlkS$iFt8px*dGbyt!!1;k4wJlB zZboXMnE0!BCUh!4&Y2~IKPJs_!HS;rG&lR4dsd?w&FKztmATzaA($%Q&l7i-uM)oY zvDH*bn-q^(DR9$Iex|rru*kkY{&Q=bj(Yf^64j{l`4)LhdrNBTnJ?U+W(@W4+Xdkv z3zbMrQ&R13=TPO6@{T`O`l5vwCFioD<(s8^%IXX``|GVY8!yDuR*fp0adXO4@86_& z;LQ8IT}q-)+OF_NjWb-(bYRRer6G;;bnvr(%#{dPgfRWV9}1iI7PCuEKff3)Ionh@ zW`>+1>o(V~B3TN;?JZB_xqd4UNIc3~b8*l|9;@={Ez%S|`)y)@bfQMJ?qDfMwYVg|0cd#?O``*-(7zZC3r`>~bHdHhyYjYReA+BYI$>GxZL zuk{{xkyq_W{)c4m4s)T9mJytcc5n#*i$c4={8K?iIpxW&p~64gfX3?&7qixy<+5cYZ2YG);gV|I|& zOYx@g^Wgq-q;bX(V|T6##iDYF%44FP?J52?*kq|2uX@bD011|ty(p>uIUqAB7$858 z8CKUNrrL>gSjyw$>=4{coU?OyG95J&QOp8-ga#X+$uF@xBZ1ILa%Wpp>fN9c|OhnUJDrR3zeLc z)@ETBr%k60JOcwCcW@kv=@m2cBbVZsQI?}II*uT>lbdq=UQQe-6=dG$xxdA|;17Ou zQ<~IINd~{szoDtoouDR*dVQJ z(=wXN7s*dEB6wv%8he8@_?ek_v*D6{g)Gh93d@6P=T~p1+mu$YV8O0^3XN~vw1Qut zK&dLFj}R&C@3-m0$2VxZ}SlxxaU~Ey<=@ zFCn3B%dgV^HU+Wu$b+ASp<}h=k0lE6V;?2UXV0`297aBHg;(a#PmX)Hj0V#x{;%@h z)u|AU@W96Gb{(O0tM5Xx!NJ!)ZJb)DZ%asE0OdZh=_3jx!REn7uXpP_0F8jM8-=Vu zl4nwiEnel5+Ls^ozzM=h44o)sH$X#Cgw(IC!Yx&bX#3q97a327%>x{~fvOkc|Ko`P zZUv#|I!L7<1v|6ZeS~&lGAChLhqCgXc)`A_DYXFa=|`Wq=dL#AZo$yGn&ln!bcc|o zvlcgG+>pw~x;Nx#TY0IfcP&Rk;H9|YmiR&ge8xZkfN*80nLsu;Gdz_NB|@P5FI)=> z7>HE>bT!1@6ku_Xyc!*t>mF$4ybnUpv4MmHT6*$Y0ykT5(3OI&)>Hw)ioGLp-|r~ z+-Pr-W}C6HT)l7isyF6LY2`n)c&mmXt%1_gaBmv;5x2=EWu8|LFJhl!FmI`geB~$G zZjCMNFKz3dHU@4AAXf$FX0#UT?GTC7v;BIm`$u6JVD!1fr;1#qmW^RRvQMwC z6Y2ek^F(q4&OP{bV7#j|AP)nXg^b_zA0ihKRiwTcjJ_X#rDgQ|{R>Q8Zk+7wlG{;U z>HI6^E-_oK?AXk2e$k|_Z3lT#Z4UQMguGc0uP7B*qXU)WK|BAwz#1!zF`qD~@`{~! zf-zh8=35~`1@vY_(pApb;(&(C(h4fMzGYiGsQm5&L=?-VWPG^uB5#f+R7FNsw!OQX z9AqIPeIHMbca(@M1-{hM;QH6O#zZ_>KpM=_n~(zyIY`fbEi7mZ(^gEusU#HIFJ3A7 z;cj~GlZzZ2MtWL4WQ2beG!_;murUHVXNR&=#H@`en?WiDq$E6$XdHD4e{h4W@fKfN ziQY(dxAQ%rkhrt^**vzER|x2Rw*k_tHuREp7NueZ#*W_cNzvS&b8~rNgMk9J(1Mv+ zO0|%&xCvug%^;vC&~ zWRj?+IFdl!3W?C4c6VhUl8W`M`6kj=q&7@nQ8RyK!`HA_WG9Wfwa+Z(!P%sY`B7Tg zp=|DDs@W|-b1t&5=rIsrjCg!c6#Za#u4vq81<0jd^2$z0~J*0eh9U-7``@Ahj_fC)^9d9`xxUpu?|`FDz%nsCYP$-l2uKU@#bZ=zdaD zQ_EdUit$Q_IY?(`=j5~nD?&|s{*WV>H;Tx)lcaXowmyl(Bv57!4GSvCPQ>qM9n&`U zBd|D^=$H1U5gdA`8fgAtP;m&HUkC+aO$r6}@!^&(Y-jEBTigjf1+Qw7?b`u31r-l? z#^9L%oPLDz2iRuZCM!W2^-KE)56ye!Y~j$B@^TWAh}SPEEv*Y)OrYk;vQ>g08wqe_ z@RtxRTKTu`;+UdQM%#itQt(~y%zOCzQ?^c(r3M4wzX8Kj?t!EfI1Vr*uz-RwCMJe; z%yd?&N8UJJUvKX|<%rJZ+`9$GM?2PF!76Z9ko{r}aas5>>*9eYFVRdfqMd0+qRe6j zR3(haSc5`CL;qk7QU{};Ongz&8|@vHl|iI`X&U6w(Y~mKFj{+WJpYpHqcBAoYBizrLfcL? z`)a{)>6TxZXSV%~1}>@3c{^!_??e7fv|RsE7O*L~Gr#Y{%!pf@H_5i?90_m8%{mPwa)W zU{;5;K^j&h{cPHc!|PDv3mDcvBCumG@oPl-rlGZt$XjcNONDz$h|9uVi_yGgQv>unb}K zmV>-9K(Xxeui8j-WtDCU3UAMTE7dTU9>2C6WsJ0RQZIOm;dY3_)Gth={}Zp~ zhFh55O3Ku$l8ic?^(x)X1v?7p#b$t|C^N9xpfdd2)kVzefQcZ5&qaRMy*6=RLpVRr z)BCb~pECBoJRWihVORTW*KB2?n)`5857oO6%r`ffz;;cUjylIdo&g;}GINcK7D9h(1EfP;m)~=iu)G+XK*>B_$@EM@OXZx5peg~;5t0ds7*kj~k$^?5YrL3mf#vvX@eJ%R)nm@ol&ZC)ti5@OTVO~t2$Q`Tl%&gb*^j$+7-vogG~w$UMO1u zjl64Z-36KyHvioxp~hFI&7xBsY7Pms1u z-%Y$yN@g-))T{lrtg0zP5 zVmlyP#eHp3VOvoqj~}EekU<}+l2cOKZ?pAz6_=#q_M1Xu4*i!$$S_dUQ?9ZyeZ@U~ zu$qHA|HOTV{5QHwSX4_dnG>IX0e32%}KApxCHinD_Zd6?mq>2Io5OD zJ%7#xBuA!y{LHN{Nt$O1uozKOIX%q{yMtC1j^WJu85X7>li!biUR$ucr589L>Vy{_ zMTkk0+1E9pP3e@4`z=KA;z)D-HH_9gh{c>tW^iJx>KWpnY2?_~ROdr%5j@QD#i}q% zno{-K!Q48czTA$yKH<|lx9{jC0mp}6>jTi3Yg9X7RLYo=?f`cXOZQ zOUbZq2M+Snh64{^(UM_+>x3RP(VqR~t;9h$tjuiFfWv5_$p^fOZZryk=-k-2cD%nV z2A&{5%mYr2c7Q`70{W9pe#9K`eDap%Hgga!r@w!m_6SdP3+f)e7K7_35nPy zAEx?vWpw|^AAH)YA(ld&pWfg3E;`OVbm_e@X#ftaa5}EIuMa>)xDLVuPXvGn#c=r_Q8{W zF%xBHaA@Ul!r@9bR+F5m4sdXbdd!)bnHdn7L9+nn8xTt9b0Rye&=fBN4N-IqcNusN zj&;#!;M;T+IqjxyCFuPwrP&T?(S}0+nwP)0IRbkjd@vu{bFktc!MA4dq zOfM8d!Jf&*#Wm9&a*oK^2r@c}vw}Pn)M{J-yX(p|C!Abd#a51e`<;F0xi0tXBuNJN z=<`RW>z+b}VSo0j0_XbeyWbQ>p?74qsmwS3-KdMW7k3ycInJJBCc*?Ep&Kw;kyr+s zlvx?oP!VRuBHk~u7_f6SaU>N{JJ7wkw9mT9H?MqsEj@cMB};GJqX0sWTvPAnJ?4?w z6BQe*a%0wS$NjY3uz@&0h&&Za(oY&W;t|_V!wDfTBRC^_2;IhVoVkRR?Q!8)&5)=L zIlwMp_leNiyeslO$;DxlJ@HkOXlz&R?o46%SiNhYL)@9S4r)|#XAG)EGT+I^ztH-w zoNRyP?=Ah-cyE1-i$1E>V2H6z3jxUkB8a!!>FlSHRok>AU3eXET2m8q0gjXAOZ^Bw-`pxbZ1 zcgN_mX9P!h88sF1M?!pR?wdlR)feM_q7w&65!Dk&w!TV3eE7KB=HaF6ODyqjarNjCUI)$-B9^{d{LWn>M>QiWHCw_ab1ps(+pu76lj( zLKAq_Y_uhKc~_(_g&)n%@)5`4LNX7m_ogR1wDlIQ3uAv92G2DcF3|f>RhxH@#MtQZ z&9`4-Y+w}H+*_=g-Mhiu{AWVa`4qck-rI+l^D^`=qr*j38)(gJQbz)@h!ct7nHM%e zBacP;^bH2?j%#9)eP-k3>F{*X;wgQ@*&_MDBDtaxHC-C-GE_!(us>Hn0~<+HHvseo zniY^*7L+$;sH6lf+aZ0vMJcn@X0)yP2y0pT1mP~dwTR!Lk=zWW&K)Oh_&E?0KHeh= zE;=KPq7*vU)E7V0o=u?eXPzb4R9OW-_e?FTK&(s##{^R0d~lBFTI)4+T>+^lnP1j? zoHTlDtrSj5pPcCT`1~97eL3qQ3s|y+l7}el%s3*^2t=l3#!aPfE?!3Oy!p?mUJuEi zApe4=?n3y3qXF7gKtOmrr^{(G{L9S=|9Q1Amv_f4#ZvV5=QcQJO&i>(tE9p%F zSObpL+2t^)%AwM1@BOh1Eo<)v+Kjr`2YAsT%?6$%mwSVKXB8O)7S~jiS|l;s&JTZ| z**Yk}tyo|lgv~Cce0lBvgpCB@-vSjrrDk7G{83ndz`RkV&Phc~dyK=aoz8HNRym3; zL<0a5pvMNS1M8iS?Psg=#%g|L^v6Daj&7DyaIoL0vblb9B@k;l(Ao3EvFizvuI1gG zniyqE^VS^;u_$^@1C!tW7tO<0j%p2XU!yFJrX2D~2N+zYH)ND`PFQlOIy2noa zUYa|iHY?0B39K;)k@|8l?kH1=i;ay1G=wC;$$^hKl2fUksESk!=mB0DGg|qoJM->AES?s zP4PSkc}*8`q>%{vzV3c@gwO#C{}8?-`$6&!eT*r!qzFR z_;aqd_4VY9=U<;bxN)k$>8Wvj{H6!In+XXC00j|ka6(B==P8?2uzD}7d_T^gnjg_t ze)pk&aaux!DLNw`gd0-$U%6^~ULe;+Ox%g5$eVE23B@z-en|+ZN^lL|Ho^$swdBTi8sX=_R ziGw^-4O?0;9t^s@~d4K?u+C5ckGAx^yNNW>{8+KAUL(l){W?hK(K$^C!1aaXCQ W()qzzE3-)wxHQ$!w@Ov+J^w!oml#I? literal 0 HcmV?d00001 diff --git a/gan/gen_images/img_200.png b/gan/gen_images/img_200.png new file mode 100644 index 0000000000000000000000000000000000000000..a3f9c3c6b4bc9cb0e4b600650ee63a9d77f93bfd GIT binary patch literal 114274 zcmbrmcR1Gn`vy#eWQDAR6j|N&-g|^f60-MAME2e!E6LtF+1Z<{WRtyw7HRps$pZ`B^u#oz@hagzmt4;?YKuvIP=IKzctLbREd}zKtv2o~D zR#*2vCx?M2No8wi=YDi|`utAYqV0Fl5U*zTBj;M3-LnhZ`q?$7dW%Z!wL`bRZ)TjA zMDG${H|Vi@h|!{@PrlBad`)n1S+gUki2Z8+LPa1&wMGYlCQ&jjT|FJxw%GFR+cgah zjfJMVh(dG^2R8@%D?&GW${>jCpS!Cgy|&GYgFqf&Vz@J*amE_y@<+=RWH zXpiMqz^GXA3RT!?Dou}8CtL ze~6W`G8au`*Zrf?sbIYla<67u)jX0Sjho?e7>#;6nD}Md!G@dd1IelnMQ8|h5ajUJ zrndiul$(6>Sov(#+qmf*gv3))8)wkrRB!h!_3M)irMb7;6fv+YKw=PQhmuyv_Lr3HTSAY{QpZw%XzfEB#$;11`^26zyfU1SP9gV3o zfgRC^nDBAr;}|h-r{NjJ#iO%Zp&bi{ZqG`_pCRIgY^u>4s8*S@+ntBCYi~c=K033g zo|f9I2>iviVEvYLXKSUYP|?eUU!@R^y2*gj8m^ysP^ zcY+_<_4kG=g4P7v4nlccqQbp8Wtw@Zjb%M%G)lozjRhd4y6T7@{f78{9CgtT3Cs zV;gOw65C{@2l{yC_UTu{%?EalAa~QXi&B4-BHnsvOCOzG-~_ip+G3Q6W>F-Lb%rR8 zzn>U`$(kr=HP9yiK&?1UV?=yu~BSv#xO!fX? zdb!6H*VMF)H&iFlTBnx(y}sRu)1iJg zsx^Z=+^IfXDaQ}Kx;1)z!@H@8{XQ}G?M2Fn&eJx7%f9S~1YJEXk|pCe^F{;>xynU9Ap8R~#=~{`>OV zxG(8C6w=uJWPQlXlyN-n=?P9oVy=Cn1cXJ^F79*nzqSWyZO7M$vz z6=^(Ui3uosg=EuK8a0#A^QQW&a_k{iGi$SFoEYF}Xoybhd2nlGWu>&d+#j2eCS3>7 z!~5w6(rhGvjTHADO(X`|-xHDd9ho_`+gyaPRlhAd1;boYIt7@LT^sd6SQ9>F2&bsJ zG|r({OF$(aSS3+OzUOO3;*XepB1yZE>>b6JjB>nP2&yT-m+3>iP>En%JOxF&Sa#`zl6r~ zX!s!5zI)FeKWIp!zn=NCcETd>xmPn2d5#*=fS|Hos_VhwnI{~|OpP4|t;a69PzpiQ z=>{ulXh(j{cxOi-*MXuzr9ia7&)l>F4jnARO{aP(ym&cj^uT;4o{s0Cd>OphDlXp@ ziq8F}Nm(Wn_Gq)z3Cho36m8#P`r0Xw1iYmFb zv2l^-q%J3s-vR|w6(0C?bjSus-Ft0qjbDS~N^n042b$&Jx&u*&3>F)j#=&-G`o#j{ zLA@1&^~5FTxUYC+kL3JxviT#;q@$m)3bff{iT_?{;rO-Et*ovNZ9Cn<4Mfah zdOPN4_%S1=UG?!(@~j*djg1MIXWE-l%()?mGQmAqBhDfG9LH6e5C&EcCkx z7a$6>!ayO>ez(R5sSJ)%te5zVk}Kk#{VIl0o7ovf4LFz>y}7V($F!vh z1En-|bY$p=C@2aD(p4T1uN~=Q`7;pTXgHd4|E$ge`KFLJ0(fO&db(}L>qz*(O_Z93 zCUuuP>DqVGl3S}o>kjmg9#r9|0-HAQnD1H_u7MAk6*-ChrJy*e#h>}+$iqWN=*?w} zqnnP|YRu{^x64X*FG+oj$|!#A30(6BYIqy>0+hf8hIII@bx~6aEp%$HqW)w$P{+#XN!r*i^BI3pDq0s1?U0S zyj+XC#1X$b8Fg)J z>|7E|Pfr`Ye`q*8HFa%Qt;Y=05h_*2Q#3Tx13aD_@WO&4)W13%e|u$F$ujoN@H+1? zOHnO(<{)l!13;V1w2Oe&=xE`o}XdFBS>nxJ2 z*Ok2)r1>im&+B=Q;*odvPCPUm2m)yb$0wFX2u%P$i_2zF_26s1Tj6pjjI{3Xv}7ER5>)eBcvu~nPu8`u9|cO? z!}M?Ueg6vLCQ1SG@#Dw4ZjDB2*`GYA5Yq>|_!IXgEHgghJtPjHBf`PsU3yiU9Av7f z*|D?ZTMX&_m?u=%aAR$jDG>m^SdxT+;m38jH`&)wa{C zenmjm5EA+7RHvygxAE3$S4HfK3p*`~Nxbtybhy_HINptpzL=@C$A%`Pn)kfW3&2;c zj%wjM(v_N69agOAx>*}Q^h1LQFPq`|)zhL2a}XAgYk5s)vU^pmt%JO+HERZ6?F`3V z5c`dqvBQhDVPP!17!wE0wgO?OQ;mJwz;81{BnQc|u;+qBpbdD7iIkYuD@X0t$Q{p3 z6M|1oFEun|j$QVCT}Pvf>p^b`X^A&1{abdC;fwh=$?L*P98wQLi;SE+FyT2jCfzkk zT{@wXQ%Ap;0{`ac6qHrtMeh>@s3Xw*o?uCseXXbnfEWo6$A?5dzVLcLe1o%N+>*Cq z+8Th4v8k!-N@{+t1OK6$=+8~ZZjF5SK%w)eBxw)6!;X z6ojA>sC8*iVb{EVHn!z?DvVW;4npBOO=kq~@UgM69}X`c)D#&Us*Y&-!$~@-HJfe4 zHLl~-D_`b%Z)QpunIsYvbsBIzj?Nh9>sw^M{Kek>={v@fgAgY_KR?|EXnw!gVNJoFVTQfEnUZ{+?k_aN_*_; z``%=Yk0x9p)75W!5^XP_wI)mB>QVQYo?Y+qy`7P5YiaqjSBkUJp`Q}XaLP@^0{7wl z$gU-TmGDAcoFghG=JsAb`=dwqs0kp6f9>uP#VB2;iImrQay|>iHm=9e+nW{=w5zL2 zE$O@?lzd`lMkZ@WqEU}_mp_suE<=||V_g5Y;Gzc^?sYi2jK>w21SC?&qLA>L<0VV- z;-|Nu^v-!6>7trEWZIsK&KF87e@Qg<@l(`Kq33^{WTO%Dc=wtw6#AEl+kwLQ^2`p@ z8)(<@g5|jX{{6Fcad`(Jq0Ykl^xY<#vbMfBK8^D_-dzF8MvF_Eu154twd9gJLur^x zHhjA6e%g0c76Hk3n-D|K!YI2=5ZuP~D;eAW+MVYsJPHQgg~)4GmD-R6(8h@Iob?-SwB!H`1}X>4Od(9_ccOLjz*2N^2S8Oqm$&zDFW;#ZsN z>V$}rhzNoiz6r%BEp|sggdR9CKTkV&&UhEwTZo!HtM1KQLkRE{pOhFxyf3NO9o&Ac zYD&s~h*M$!)Q*qipEpECtn1(+5OFavxqS6+b8|FRRaMynk6{pWmVCrTT&EGw%*9r@MQ>nQv~_fbfe5$Y zd2hkPqQzHGPyo|ojq?sov3@hcs_*1ZtWBq=ZoYbHZEeW*wlyTbF?5g)BfAz^g%wq+ zvfNp`sr${PU;l>rbuG2R%m{rF&@|xlFQZ?I_TAR;bjc0N{9BQ~miJuX02cRLJ}5k} z-5h%aP|T!UYwOP+r5~TP8roIYezBci=5e-{`?X6xo?ofQi+-S}4s~&CeB5qlP824h z^Yc~lu1N25;}Dh{ZJV5`AXBaPgI6pmgzYg5w^8}xn>otXNKj1!BuV$byIJW11L2?k!PkhQ=qxDk>S4pU{j}DO|7|e8X%7*aF>M z7!}`Dg!;#vZ_)qBy%TgbE|q~?sV1q5|EQ(DQeijprOP|aHbRE}UDr}9o+vdz+V}oa zBQp&%4}0-{XP#wLd`T*M3067g!?iGP##Zue1;pHZVf<5U->s3}N1pyx!WooyXj8W| zyW6|UNI#Ns(l_cL9t*J-scBSr&FtI8q7tFwT83+`ZfRf!_BC{9lrUsM6<)XHQL$L> zU4DCy0`J@AA$^p>!sW%8rjE|13hLARiNJjAqW6@cp)-JR*vN9imM<^GoSdBlDO0K| za$;9LSQdp?UO2H=xaMrr!C9m%g_4$Fr0`G$6n{&bF%+a@1Uocklf@ zIhWaSqOs^}(kmf6{+`Q_E}QiXD$0FQTty#}tPaP8yc99Z#9-!zxhBs$P?9xYz48bC zs!Wsm^LZzM$w40@@eSzikSvBYtGt_P!o0%w$1Hh8Tz1hWUz0&9TCO-P#AqF^t>M(_ z*ra!!fA(R`8)5dcl~ZG9XMY@obu)&;$S#H&TWf3U^vpRV zPsl*;>b}eF0(wM51gbii52W6UQ3`31aZA6>SikCjWK}&40}F%-ywti{`+0$7DJd#~ z0p-{6vF5b|<>Z%VRc>0R0c+%mX=(CIq~F5t@bB(iT{L&Sdee9v;GP(T?w@C8iWOHT z&d%fmY2xy=I-TVD9=r}SM3G%~XaB5c znmk`oV6JYmoov?X5Hz3kz1dx8#ef2KKdCQuHHPupYFyYkTl;bYgny0ql^6keXvW zFs~&j{}7eqbm(VTeRuttc2O+m@cM?i$%fMnZ{X3!T7R?)s{|DrldIN`E$yKK^|<8f zuo=1{VGZkN4oe}P_xaD6`pn9Y``&o@?=)Z0tUFLe(u&Igr(-LvO9~g{8Cu*g$qp)3 zVI#k>{V*qlkt!TYmMR|_gNuN-zV8J0kQqJkG;(jlBj8Y>t3IgBOviYWlxtY&mjojr5 zcca!=|NQa>L05qpZx$-D}$TT=JgG)`B*>Z-3~%douY*mG=5NkNef!cOr7IR{x@^&Py^usKR^q-tTSwX zaaKVbg865r)*l9R2qvhW(9$7*VL(!yp?|BH{=LF5rnu|Mxn9?Vi&Dh(FQ%^q8k{QG zJ}p1Bzna+T+Wox?cmqJ#&^72lT+l%n+uM^sD}vX&$38v*At8{-Ll!)UEnVKiioeKy zcj&}z!GvY?^{i8ZyDU<%nBV(3OLuW@OajOCK`E!SstQF)K_`aK2QXUo-SoeIRhX?Y zN;$q`^{aPjoAY=*iVXFBd(q0X{v7|C2HFA-RbbarRN^`u+K)GA?c-Dg!BMJtW##1< z5Mux)hFB;cw)i})6HFCx^#d|$9PSx_{d4*iMPWzoETm>^ulrP=y7Kl&*!|MF)Oo`T z$C7c@u_1Ukpl3J;;lpK)=DlfQgrf}dqUO7K)B^MNQ|V^ceMYg%V`HEp+1S_=NVAbFeEgjJ zS}?+KCCG@-#7W%i#DLQTwrFyg{;jrH!LxxSaaN-u$~q{8d`Yr=Nw;4DS=0IV?^hn9 zjM%xIX61R8%k%#}7~Cp~2XOiOJ0$*vqtBwOaboM6wx__j9q%pqrVA`&o7g;D%gQCv zE*Xbe)$Z!j^ZfTiaX7t>#l?F~$G>ihxc|dD@$jOni*xte^h~Y%MID`yB+HLT%-G~a z;*or&q*E9VnBMLTC1>CL)p1i0qmGLr2FI)irjwaQ_m?cxL2ZW6Tu4J@QCEUQVb^PD z5kGGeH+b`g5N2pVuPDktuBXOnn+gajb^nnuJmG((x7)@XY^f6KMiZ^Z!!DDmou9>pFJ? zG5r(!j)@zuC{A6^tDSuA1e|0n+EVyR7^LUb>a`n&>0WW~KfMzk6z{x6eI(1BWVmq8 z=wb*Np(TMGnp5x^gL1A7Vpu^NYxyM7*cO9eaY)>vlwzDPkaTp4&8uD2Ig$nMda@VWHJv-mm#hf6|bYq zeeB!!F&o}aMvy#ApLfBqJpi~VnSjoDQ1T^!A4&3jLNtyRm%5fy^D z2V|Y<>5kPj?+6$}n(P-$o!Un7oi{HkVlB)euT~kN6+^u4YM8rF$Zq78)94`igSo2OU3%;Sv*3B8i+itHoFVFKu2#mZG{?dm)8#eG4)Qk8~~1?ouiyW8<13T)LQ%d31~#!0-#_6+xLxRiDn`=m8!Ywt7bypfDn1b zSXgHH2;K+ozLBi4^pW)i7_nd&$K=pVf4@2Ons0CPrT$|5P7?-)X54%)9p%eAE2*5b z(o@#CF{MCNn{YAjn7;V<@@AKge<;ysL`p^)IgEqA7r}r9g38App@s*-%E(4z5?IZ|`0djF{kxJx~)!qVf zX#eEFwWKh~qbzK!zQd6g)50jPwDPT(av~irA~GqXXS664RKR|`k7kCk+^ob;ujHX@ z>hVCBd;+G1*meO{dFdxXvtjz}RF15puInYs$XaNFTk|wk4X3p0*ve7J*ulzpz3rN!t5C#t6I52&92U9Cz$w9HIJruTfRvFy5 zJX?%kOxi)ThQbJ>smp4Lb9MoFy*(6z8@c#_QfmDElDZXmXzY&+_xJY!ok8T#^Q^uV z%pO_iCYR-^)EMD^qWs)Sq+q~B=j9YfphfbIRZrl^x(u+qKYrkzdx>ux)*Wvod|TUd zv0d%IJJak|?QMQ9M`PT1hq}mtX7G&{PTPHOQuds{z=)k~ai7Os{nf`hSAmHV zpk`OO`2fKGvc|?o%z}7TFdeiPy{aY(ms@lY+H1w8MJweSv7~*6ND}D2_JN`S0rxm8 zUIT##&~}PoScg~j79nf=7@=QGeQaFZ;@ev2@a-nuoao*H%I>5B-Y~o0xpN0_=Vb^U zA#noe0DlstlQ)?(TPhymXW07>up`vo(R$ z&>OLKbT(X&>Kn?2*|s9H8p2C8F3PK-ljE6#G5uM$%ZM|dQlE)5o0F6^?9@Zd<9x5{ zc$wWh1o%A^PMr5TE5Z~sE7!X5x`JxDls8^3tlO$%5NT%K#Y7g)`FzAe2&@91$2b3$ z3|S~-P*`7nHTqRI@g4xj)b0bH_7^5hQ!mmlB%*!x6|GhCMw3mSZ?s5r6Frme5{@T6 zG39u_Z!{%oSlBPem|^vP^AsalJf*cYlbSlO`&{37&B9waE5%pxWuU74=oM21_xEsd zPcd4l3?dPlNc9ttT)#=w17EAf8aEzQFxPxohraI>e z%{YbPfuf!iWAP)MTqiH8t<=!*pbTMZ0#wUfPrGDB4e-zi7Wz|!F_oznb3m{%ayd%ppmbR_4mbq<&PxB!d|lxqA!KO z3zq_E3puFM>~%Lvp`D8^Oi~l#9|8d69B=`UI)Bo;Q+)U$e%j731|8TNqR@`t)PN>l z&FDOsnAtDvS~xn(A!}V+%ot3Rq37gi{-2EiBqMF@ZxA1{f_rBdXnMJ=oV)7e=YpGw zcqBg&meyHApBq?pZ?XM(d+QH{?pkm$!5A(|qyVWB=7ORalZ^J+C^+y4kjf(Vq^afY{@Pz2!r$tyndJL30} zxrAyaUw>P7FhU{~S3KO^-CO8QwdM54H94_UG5T*LaZFzSa|Qjqtxa07a%z4)PGnu- z0lhMn&tNo&H^3yZ!Cd^x9JjVnkMK#Fm~8d*ZSif_qsZCThCI<84^`;*K)gU*fFcLe z?VtsZYRzOWFJIzVLMnA=hm4l7JGUEu^2YtbCBV##~O>WB-ZSnM|%fPf{PZ_<#pvny_{JKn;$y!p%|*&y7mO z37*@-Z|>j*=JGX#21Vp0$hm8NcrFz`pEitJRc>tV}&VCB>Ibg0-C}=L0wPI~yDqAIwhdxIGY-+ppjB8&&`N z4KWP!2@o!Yg@p^9;dem5qvUw9ZU-U_M71vcI4yA0+C_|_L!vZ`iP^AWpBokh{D8>zi+O49%j2L|oYFIyZ(8>Dw>0?N7A5=#%z@9!CX80_rC`ZL#f z6Nt{fJ{1(Xdg$i4kg$Y%OPd06s#97@Je)hD)$<3gsrKW{U9FOFJ0Shk@&hg|JgKRv z7k~x5a>xYoinPuGfanas)(DU*04{aV2L645?%4xcUoP&r0G6{yj zPypVX#LCPf*5}%s$yJU+eE6Q!BmJ(*;s=t}uU{)H#kh!wRs2YVBBcEX7>5emZSGpH z3n3J=f*|JXis!gLoj3!YLB8dg<*IH_E>)IF^QLw7Sv~e1)93LF&~S6;uO_g ztsRXBt|b~YsZRB9gb|nWpl3goo*#DQ)zfY9&2`ju?cO{@)e6gNYn39AwX;7}HC;M@ z{9+v%XZ9S#&271ZgNb$7e`p*l$3{jnfA3-iPrwwr5!i;MCF3DW{XEZp&kb9F_Czc^ ztgkBXM|3Q+DFGe=W4q!BIA`nF+!C^9ki0%m9_;(rh z`$+H4Cm&a5-zA5^LqyHt-h1TUzJON`4-cb`ertj{1Pyb}b@eVA0$~KcnWI0mB=dsz zCxR98>iD@vJU(ZPV4e$cJ1T{@u&Stf7xO2#EmC|?8fe2jyAT7MJ~lQ6!C6*XN*9#_ zSPK-E58nvFc1Q7zI&YY9?HBi95EBIN&AIOwf{O#lMnW2qmZ71cg!yF_pc0pWLvLmG z+Peun3%JJ6T{^y>UBrzpT8yG%54CU|u@{kB-0Es_3KmUy7|IVf$8+A!gBFQXQs{pR2lK)GK=a7f2Iv69gzfe& zsbxv?doCi7-clnD1@np=H>49a7E-Iwt`SuS&hMb$lHK+c?=ytLPJ)moBF@w%{;x>! zhk_V!uGbe{%B=*L*D(4_7z3@T>Rx>MdN(QzI{xP7=JA3*VY`lF;s*)l9}q64rq=b#Vm7r2wtSy2v>klMS}*&kRlDw-Ymxa!4x8{v5h7@b5PWW}iolZ+1Xa05O-3 zk1u=W7?3DxI0Up+RP@N>Xx5o{R5ggJ{~p)H%E}?YzyB%frN9UAX6c)Q%842-!RX`5 zLE^Xh9cLaSz5jF3)J8}hx3;1imBnY9dYvrCVN6n&gf3X(dXp~~T-WR4H>QFp0F;?y zhN4HZzs%O!%YUIulziJb*OPb_hG)LdBxbC3C4TlCS|3z9=GXRG@lNga#W|{C%TD!W zFhPT))Xj$j2g73m?KIsY%!xljI@H1R+4BkD--ko9LGcy$R#R>ttQ2?9G$68VQn5%> z>NHFTjxtlx^)pFGKsGCfksY<1^2lBCXlv5GYuBO|zFxof-1y$!cx>qYN;82w4dHc$ zp8yX8Ye*|BXvB)-zK&j0=J<*q)`PgK$of^9z6qCN%uxAic6C2veut3MXgJsSQOm~1 zxC^hV%KZZU3Zl#+EzmvRe}aeuZxN=yBov>ancC_@xAi?CYJwXzi9AyJJJ=T@WZw*p zqk7sa#=9M+k&hD2k~if`n}LJB5k{jmk+m$nzYS&x zC8Y;qZC~ovSD*d`pbJtMRC7pDnUe8ne>0kF!y`++ByesL&-Q=1zAc}suGXX+)W4S$ z@Zdi~Bf1Yyyg<>rey!9=%Sy0E0Fpzw#W*Xm{Uwnq3iG!^F~T>icfhqM$s|P4z5EtT zmrKF4ULVLZfqlw6s>L1L5$N4$ue-Tut9hEaUw=vkblhkeXlhj9LG6?}d_&^+ZNC^1 zziNM0fk_#BQ5r8_MkzBw=|zUvDSl$K0a4);uM}Airc5GOufxKLkUN$Hn0|aQ13M<~l+a%iKUYU5LSyR}oOj z8rwyNf5DS%UZy<4Zp(!;utE6=q@3kKZL!uLZ%ux&Q5N{$XKXd)c38-!TY*}chG{@2 zI}m}97dkQ+S>4dUHt^@@?AIJj_nG%nmrt|>hF+{|zPUU;KCUDT7#YNyRayX_?Kj(l z!xd3wa+0D4d9}I4R9ioLpX_h`-NEBpnhcT4B1Y?SqX>&<+@~;mws>!k5OxjoWGyUX@1LekuRs@}?x33RhX6Nri!i4^UG54FLRXE7b zzOv0d!hO@m2!q!+^>|+^K6eiudPKPp8b1I_DgC@w12Z^cvORQTMBS+h0}}UVj7hB* zMTR~#ef{bOwD41=0LamG`DQrD7k7-yP*yyXi7?_%Oy`Ndo=ZONz6)nbW~)7#Pe!h{ z>`ii#HJT-^Sgmn`LkCFcY?VjP@hLH1mW*T5&kX$fLHSQ-OlpC5YQUz8dO|}pi0WG@ zSE@P9#8tEln2`baf1NChzed?$urh1OjMEYlZe?o32(bW+51dS5UoI&xGXS5zzi<3K zX;A2iZh60;$4E^Od=PWwB0^k&g$6zbHd62{eUvH(*a&e6c5slz_P|7&<4auBvLGy% z^{nCI-!!zG7AV*qy~UE9*BW{|MicY;mwAMrlnLL_eZ*sqPGOO!$mo50<+1@q9+iuq zai1S|iG#^u|CQ&jXi8IB99 z6gFd-iQ@grPX3Gpj6FR(-`E%FZgj;`#zHPfAgiaLsexzkBb7?CD=^eR%4IzLpnWP7 zVM2Xs_`>v)`#a^7Grz#dEnBO}&cVZ*6OQ7@#-$W@A?<2QH zpr&8|{Aj7XqRsI&l?`i5`mm!B5sL39qPmAYKiN_wC@`k?Y33euTdL05yu<`sE;Da@QXeB& zdBCjzlXhu!b#O|`-SuIU;L+9xWN~&iHDW;HoXZ1*SDWZq+QUM;<-D3Vd zF5|>vaE{&0q1n=c(E3y|Y{KBYKo=eM@)R(DOavw%EZLZ26uWe0CKUTV@<_hkZ z5VfrRqRI0e-&ph3NDb>+a)IMQX~7_HKn=(rExw;C7-2_IYbFD`6M&(?Vj3G8|QBkdT;7ijiUP{MvJ zb8#hvSpem&A1{F6GJ!Q}nFZ?-LtG#MSiD6;X`SrN=frSt!otEJRA(HAGRu58nK1Pf z=u@-3l^)wCvT}#trUkl`4k8P>#$fvo8~jM?4~&=u1O(YwPPI0;v)g>5CkHH-Zv+A-h;(0^$*h=2AeF`J@c)+Isy;qy6cl=%P zEA7mTP&U$!(wFObX}@6IA-34&HH%3{&Eaa>idwxq93G5mun!XeLUSeN=Sqx{Um?d{ z9`d@6BEQws_@DG5HQsa2Pj3inj8)r_(r7PhdK_KKR7bKSmK)$=l~AD z4D#tR`?f!}51uQKCg3JOsoNmF0TdM-w50>k-s+D%jGZVZ^#>oFvC9`~JAi)J;U?XN)-iATEaD4udZ< zJeI+oBa}hs7N&(O6(6}1_kO4ka*QWoOJFCnlKpN+sxo6)RTbm%=Mvp|KE7@4qm-DS zJfvQwwrs7AT)`-@>2;S5HUUPohlwiDaF(Oawa1aVDp@w!k-phZV?a zkjZmvG~sS#Z+H= zi;U70A+10Nu~U|(J=g4IE5f0 z5*3bvz?|9yIq@U6=RHc0=HBsAF{y+g`kPNK+P=&EGRx>DcIY0R%dP2VXLk#j6fmm+ zDul1}Y!;nQeAD(RaRam6=yeOXo$f%ygT5{U-nSo~W<;;V(ojrTL~;fF#^LBUl)jqW zA16uzL?R~f^oxdWz93bS$QZ3<5gCa*>%reJDwj1iMVN325_w4Vg+_nQVM%n?N(f^{ zHlNMz*h2n62LPvwgm%`(4@IYhi9^OF97$iy*As3WO3rq6&;FX#wu0{;P7bW=#}<^6 zsDxJ9!`pUVF5f(?Q%FI}7QCLc0e+ju(RaBFM;-`)^ku;#WT5RVpvOmeZ!v=%3ayff zQ<l_-o1-)svK>q?49@(dN zNUpEItpGL?zZenk03^@U5$E8{F^g1MW!HZZ&-m(6^(K*(L%j}yc_kxZnj^P(AP!{Y zN~`f*kVzh+=NeujEt7=Yw5&2_dZyeuD%Tx^P>e3S_eqbh*9PVQ^>_i$vPaEVqD_~l zR-oH}EJ+fkq0i@WjzNm*`yMhRWA#&MGje0&kW zV%WVL{BpD5OZfnIJ6im}Hw_4;Zj-lk{4+}X>EaOq z?{hu>`I%`c_w}CWqG1HPQ7($BhLK3-NT->EAQu88VE~ zk}NUb78e&=PE0Hr3qC~oVmz!=oJ|f+(|v*d-LfQJ3i0U9lq~1#G%Zh6$@sFHqLftFM0>keCKr~$PlOFj~{`Vr!g2Dc-3=mH(@)V zg*6Df!Gx_>$3<6%bfz2+XT+S!$3#FNrQerknaYjO(o9+okhyHnxZh6>L#g@5DTBO` zTO%cA+8&JeCl8Mty|3#%v7)MMfSn=Ky35;KKsuWD6qYI|&oalNjYp+&M%LSZ{mQgx zDAIWRFX4|Fa?almBpv6{vNBGhFbdqjQkZ{Xp$5`XhW?)QS8xVoms4N-0+)03n|Yx1 z+JH~uK`zz}zwe--L)m5v{CA|q+ArEaHiMZO{OST?VpzK@3gfY57R8{kH$xRf}KFMVwd#XvhF-jivwZgOW!#G4{;kC zr8Dq^+X_&BJ3xE)=0nul){^q(JEY^nS=nIFf1APbA~dvX=N;}~hzrqAW`3E=BTT@( zD%{uCr#Nzxi?>d7V&lVQ{&+$@)Q)al|Zbubo!zG&BB*o^Wx!|8+ ztE;PJ5GR3w*TJ=(A?ty|TJ%v;vx4WVWinP#gh$h5UXg{m!y4<3Q$5PK0=yO=I+#St zDk~XQC937_b`Iv{6urv9g)l+EZ*ZtwSpmlco+yP}-0SSRc<*-}>;HS=^_S%Q1hgdy z5A1aU%0EExQ-x!}z5_}tHU?%9&I-j2awXuQBq{NeXz?h46u2v})S$Le0ntGKWBie= zyNbV@vZ-c>4R!#gvmOXwS#aE;d^TXgdMDwi{W@0HyvGTD7GW_Wm?Seu__+if%RQZt zdvBN9@6xqisaEfL@=C$OC?iavBrd3?_b!2GQPwi~bRZml?Xe+av?7Yk{?G6qI$t-w z8B+B`t~lYlR_l>5F9Mg4r|h}=;>4Oze760lsULHI(7PzS_r5Z{y8R|xu~Uq?q^P(O z8q;}c`PVG3L~*tE$48Tg4$auCFQds^kk^*ygA*K)sX2EPuq{%}WVz;}{BkJEin|o< z!JY^6qSm5k#r5bgdJ4SvJ`$|dS8|3CJI0p1BV-Omg>Tp}?nZWjH7C2Vq&9v4G&?r>|P!5>a*Lrl6N zJE)`C9Be1$Q{p}(iN{PFxQRn`&|rvPwwy$C7#W#q14qV{@G05+0x#NvD<@b=8r=5tJG9>; zM@5%;7c1#o@*25S`VQ_xmD#hiECRA%X|B;7^#n7XwtxYyw7FUQ5>x*c$B56ZF&LR( zAMatnPv}yilYc={ALeoOnseKHR9IYW1YQ3fg)RvMHr-qcTakwz2OTd39xOyBLpp=UH=mz=Kr=W0eVUTc*8km2n_>--{>BE9@@h}~ zQvQ68_KGuA+&e-k=dU)HR71h!55)GI*O|482n}$_9>9)Em4dewmT*wAAK2l@!GWsp zb;1Ay8t{^KOP%;o62Kr$2!*)w^t7%Jd-vl#8mOvj`E+Rmp^<|GLH)<5)d$$}fz^i@ zr=WiO*UL6s1JnbVwW~b$n*OJH0sHnu>;x0VkXr<6Kd$yeGGu>vywY)zZ^auw&r8|p zdIdX3AlkqH$|)2Vkx} zSG6Kflf8-Moo6-vERimiTyB)i zc?79inDrVUfZq+2hxK=v$HLTYH;FYBT}_m<-BZVeb$EgrBMI1sRxB+ELS&5SWJ7YE zC$Jau3)y~+c{JYrUdw7dZi(AFF*fGe;7+E!^9fsS_6Nfb(6$i>*i1^6R5GWHq({IGHA-Yqjn!Ndt>2zDHKKV|0ucTey_7~7SG(=zM31S(?!GRMZJr4W4N>R*@Dz@Hp0ED$ehk~2i&4ZaXoLb zw%dPFp1OLN>o6sDpjKd<=UnBp3&9^f%yXgbR(7~wGdOdutTjD5+W{M#GO|xFga{0# zh&epF5pj>Fu4&(nT6mJHQ=$DR-$hoO=Z0UgU~1%(A$L*yT z55>{oVVNQ(Go!`Yfja_xQucP}ybH(auImN-!ujP+CarwdlZsKS+)XCU`NFfy!+lGmI_rbOH0?^YpKG#w4dz0DaU%$Vb!%>&pL!UxK< zVi;@+p7_AHC$rZ5XG{f?$`X)3^78WL3B%mJXHgaJw6INrrqYxbBYFqfV%r6ORkC#y zy%OBSqxOm$Smjo9rr_wdi}&!aoT0n{Ye%?H)4EtHI&2%Nb9b}aR8MER4q+R~`EFpy=c>V; zF4GlEtME@lFt*x_e3M;Hh40INNNk7$iVS^tm&e2fv(G-C zta@LXgFv6DgSa1~q~dtDLe4CY2&in7FLG&pBo7EFKqrZxewi}*fd&UoZ&(&biCPdu zm7lp2!m=@5u-pbLfxI;dk99dt|5wS?X-VK95YqSjqU&I_j|@mhu7qBRu~wcI&ue(N zrCG(R&J+5nvL8Sp&GrdXy?ZAvVY58lJ!#XAyMhV1{jrR$qSGP>Q=%VT7yg-+mvs;R z{LX{UkbMx1~8r+#QxRjt&VtOUn0k_cJ>%0j;0^WuT1{%;vlQuq-z?77l= zcq1LMD@8Z?@ZH(Pp5GiXVfi`LZISy(9ogeAC}&XWmnfLFa&(}h_O1lx(vx$ZoFpx@ zDUssmzbr&KFbE4qHzcqXbFY(y%7Uk$+xX$#Md3jzsY{dGd_ii0?g^H-9wWnwJ0zS3 z5_D(=rQf20UeL8NS%~92C(-N`qltWMNy_kwi%j=I{_Ou@?!Di+{@XubnGq#Kgd|BB z*()nb*+mHXM!UEljS?myu^j*ic9{cx4H z*ZcW;p6B^kr)J3?Olx4T|9L9_GB$+o*BEKz`B2w-O^@6vxHW+vPPNF-`3ZLtz1%t7E;{>;d8 zhLe9sas^Qw`YJaiXo5%~fC&YhN{{&%eC+3;AyxSAF^JtGDj@u|1YlJ8x2f{p@(JFh z#c4emJ~;uoFrF9UZlq)5<%v{Xrnh4AOIzV6C0KLz)7$tW&fN2Ng;A8{n5h}uH0ZBT z>_*GL#}TcCje@=H34R;dSs8PsZ1))af}(BN(Jx!x z>-##>v@{F#&a_xVluFbC-H+QVp?injbvv*(%^6pj zPL5(QNzlY3J+&<~ge=Iw!v0KX(H&uJ`t?6|{r*sSZ>~-rKB{%j=|7|jph*}wl*ra zq=+^POj%}Y_qDe~*F;h^Hz%~Ye0_@fmag0J# zxaJ8_=hnL4*7XkQms*`ab8mCL8x*1m3M|s>`B0ZzBtRD#V&J22AR0Nwx(5X!AWtp+xt~Eifarxu?(g#3$~pp%3wfj+x?fNqGufXp#Z7|g za~#R!S=jb3 zi~&j!zomNm}ZUl2(zndcp$Q(KvI$n;dt#%AoSLbBRCeLQ7Vtjm9v`f=-hpTU13>!z4bkFAoWlK@4 z`4l}mwXNQjzn$sKL<`rUt83#vOKpAB86DiB46PA8??mmwnX?^=(G&>YipdRui|Rs6 zc1oUF-rlBavmEZfLc`W5!OKrIesKE&NkDUK;35#r8bA+-t`* zHPhEK>RSHD{aB0;$y}vpcwVx13t9cUXYsXzsdy~Pu$>%^4!#MG3FlZwRhQn) zO@+K6MtUOU4e z0MTD?OB1&M`V}`8sIu^WAp+s>LaT2dF5J%Twz%RzYerv$=>x==ySuw~^w)kR^p^mloFAe-fG!V-m!k<2sAA1@R&Ij{QI+Q%BQRYQsy%IC;J8!HsE%tOl##Xrbc91G+ zUs?YZq8olF-W7v%ohuH3J5Gv0irs*s>ARG5`CCWo>CPaBuWG3jRo|RwKTu7b-*Htk zCb+m}r|>?cglR0kV|Kuo1e%5*cb%ztuF$>^?Tgy?)MgX$Sg`MNJ-Yx*^ObJYU_Y_M<>;XA1P7&?ht1O5DKN*qA|9n-FB zCqE^mi^=AT#A|C@IPEY;JIY;{G~D|y*$u!k3p`Ps<#+nInB2w1I*Mkvdja-yF@%iZ z+Shdsr(w;>5cpGfUc|TUesZLw-M0s9;$N=D?fz-iS!B`UP|Vn|940ohVYivVpt8*o zCkd)H+q~Qk0`4TU_EmDN?1Cx(}kEa8GV=XZuK()t`05sD?PN21BCtEG|nhQ@g8wdGWytV z*%6U~*0gA!YPpNI?9%CQt*!2oS2I==Sp^QG!!t`@_&-SK@-f{>?vm5A$#b!om3x=& zwJ0k5Fe!KC)t*0`U+>!7rjKemr0LHl`eg}51+?(Q&@StGpu@OryIt3XhQu(>`IU8s z$+4C7Q%+ZljmRF{`*>0_u~?yYpzI~dy3WA}GU_xQNX7dcutOG=Z`k{nS- z&vjBEu>m4pf@STooa6T2wjix#j2d@uAphfam#^t+CR;7tKQ!xKZsoE35Y_sHPG8fd zjP-$nQg>0nMXHDPju{V3_H#$(|8ikq;-ud=u4VoAdFCN@mWErPx(L%}ptphftFwG( z9&ro`>Qg;wv#`!oyIm<>-#=Mm`i z=eMPOrZ+x4B&q}(K)^FkEDsH4oV_3vMc|NVnp1I2IT~nP%1*GYYhNl$m|z?IIwcQ- zJp$gyNFLWfzWzO|Vrz39T@!%dfD)bTsoj>3KEJuizA3&l-PB-0jw*^a-X=mdmB?NI zkTr&$gP^scbFe7*?0*hck_f#~zBAXPja)vM>4jJh4Nd&DK;>MM~nTysD_S z=yeA8txQah=RSMk7u$YBZ@{>2bBO&|Q-YA7pgGv@c>gLU&#=WeqSLtl1MoNBAw9YHnJ zH_cm%OB+;MsN+dE61vj?aYWaqG4-~U6-d88U5*H z@%4IRVUh;%tuHb|&gKqTW5#)jX>Ak|ie<8PZXGrkdb(Rw{WxW7 zJ&C4cJjbn1;!B-I=?AM~UNucdO8#&xx~{)I)lz>Z{gm^-hb#R zZSIY4-O?#k>aZW9qP$&IycEt#r%A`-b4Y8PO}O|x{~q_806}|4eO`(zN4MS23Wezy zzM&3)Er#(2ejhHx#`yaBaz&4ijF4RR{!Kxc2a!*NaFAYe7im-XCNIQUy~z3kP>Eih zzvcOWDIAWIWVi3GzY=x}j5|!f{frUSZC#-+v1Sj?-FEx5?TnSYOY^0iXLcMA3y->I z>Sqx$nD3D~M3@Q2q!8bpfn1I;4i<4YhxA*qtOK7$(QHt5Mitdt7#X$7)~lJ1M_S8% zw@>d34Sc$PpR`Xxu>BYJwqt@~FOF%-7@L|tTcc~S(fcnR+*kKtUf;~?1_SM$`4vl$ z@W9#utbFe8KOq^%AzXQxC;F{caLcPF!+v0fS10ySKS{G5ha3c%6OU^=cCYtayC7i&{LT*fgFIQ2Cy^}d`5dC|D~B?H$0#`v~d9oz0tENE(cd0}I8 zJeh2NX$G=gpnipA0o=i{1+|<<>#=ibXZd)17>Vf_W?jr6z|TUtnxEyeY-^P;37|Ee znAb^=s~-N_GJG%SY5%eA)?<&~{3uKdI?F#^)PKbSt(z`ACL^FneB+r}J+F#ZO`*Vm zuJ0$+#Q2v2$|&Y>U*^I%1=oQOAMH#X95lPyt*P2XRYk3?K9gvfVjFnk*TY&uO=;2o z-R**KvvqQpTDG`OY?9iay)SD5cWVxJ{w9wqxHfQ7>fx^TA8Z>kEwB9LZ7v@-lc1b! zEj<&cdDS8M!db@2CZ;>$XKwSA{Gg>+mN$EpwYhWhg5!#-Tl-^^E z$K99qA(3_GU{67)7ow&3e3t-+f4?Dvhh+(uVUNR7a{%SiO%v{8ZYGXe_ZCasIKN*I zxkz?6bU1on(A|4sK^I=;k}i5KnVa7|MDmRH?X?x_OJ8B>fe_;DurF+F;Ok7^P;MX{ zAT8mIZ|f;WYLf@e%_RAxf^_L5*?xU1B|qiu%F?8-ne=@Tn6jYCw%hqd5KQMelIF7A zVTTR~eNnF~V1b(+(8G_@PHmN*zm;$FcTF!+&m3s^c_pgp%(78VFe(dy|5?mYaw!LL zv={|n^Xbr`KV`UGA zr-v1$o9uoP>$zpm(B*t@)o@-a+XRUVZTq4<_XsyHZ7ZieYF-!yt{wJa{8E{%ZhHjz zK3rh!6Hi_l6yIL_)S6_kz!j@GKhsnbF53{#MBXAtO6kmPq|zrQr+lf&NugRLOj3h0 z76NP&8;3axE9OgF?A9_aQ_&Va+x94W_hzbcidR?B$dr!Lig~2s!|9-QE%G9sSNrk- zNo1aGRT3XGxyupkN)pr`?#>RB5_W*hmF9K2Ta^pi99rg!^95JNy^?}BCE3hOOJ&?C zc~MnDR7$SYNC;_L`lHYB+nn@!sJND@sEoWu4E}`H6yGnJi-`Mo%^!P7@7UdWVb=A@ zdK``DIZ4svkiJjl(v5PDf~UjJ|Jq)Cr>dU6Kd4u4!Fso0{xF3$?iHh~QW9ySwsC&zaYF_?^4B&rOpb!n|xE9lo$4wo~SviWV_jp!S zo*N@KV-3j7;xM78Y_b=o4&fNtc=;gOCDU^E%eomA@1Du##k!a=>$?>gN{INc#Y5GSul7 zH}+57(y!R3r!uJ+J45pPvp28ar0qpkS$e9flbWYa&vZV?O7rwF0eA=5IHK4ciepQd z>II!{#3XTzI!RNm(J`9ld2sFWK{gu13}lI@AH zmwPOm+u~xr?dyH?3kM9f)YlpEethi|-)?Z)_pOm2ak6iwItqq8&4>GlNW$7!a|2@c z?bolfH_u#V`q(Zl+2S;G-l_6(cj3#HA6(K`tGkMS8Ja)pv)l2>`nF|KyVhHZxcnzg z_bY zy~81G*!bMk7^!8<+)f!3KsXVv8Cp%R+~cPmEwNvtZ)vN+M)kJU#j$gOGnuL64@Xx zO}pyw2}2THnU*{0bxg+3wKJaZxkpxiz+d*=>B;&8mhs?<&tBdp88N;>J8l|B zUK#1?RbnKg(GkC-=gC&zo>^`DhFZ6h%t`j!5@2Mw7chh(We?)pM{SdJ*XvAwWXq74 zanp5bYczQ!IQCU=9v1bA&9D8wlUDUoWNE?mV$e+prYttv6P#OkC3rT+o(A#W+vwIR zrhTnkcIoTwljJq}{!+L@uu&Ij))!+9MO5t>T0Eb-n7PpnHv)^mE`*i});)&TSTwWx zUx*(=iWhO1;KD$d_lq8pK~8wmanN2D`SY`nYtvrZ9;>q9Tgmi*)!J7sZ_h|MZ%fuu z+OWW$cQBnIbtl<)Q9rm;fmvgc zge4j>xA&&kvv0X<#{b(50pJmq9vmaA9Wbt)X0y_?96wxWX{_it{)jiC+5!oImz%EbZ$$C`@fF;IRW0U-N1jiUx3aA7|r z&yPyQ`qaW#iVETqAIOS$!uD5IA9D12Q$V+xKfp{W(4f*)kUlcuX{K4T8%2|3+NEPDOiT85+JNFX<`O?)pL|4sD?zabL@sRJ3?RKFv3HF z35S;NOj zSvKU}RXNZ6);ox#cPIeyPmq{8_|CfD%J%44!G!_LIYkBxNyHVMONH0oh61fM&9hy- zk~L4;^;dh}3QuqHg0f;mcYdoFW!91$U6CnV8=zqk-yh>LpoYA1-c3``CHM>5xQetBKf5Iz!UY`YLYe_#GWN?xB| zp^H5G2KAg|WZ2JYam@$mG6Wb2>o*fkHQ;FdEO-!s6W4>)aP~E^m}qPbC6Sx%2j@P{iYlz;BbQ4{&E#P4Kz$7w{y?P&kt}k zI^s~EnBjnzkZSea>xqHU1O)+)gv1|NTcr2YLXCy`{GC##Uzb+$8s5%ym=ZIV)6Ds_ z7=H7;>FXd)CP+-vy;BnUOz@?WW;WyJ0qU_D<+lT3+TUqns9-xcZ+GAs>ZDe0b<`wvTo+RdZ=08xTLg;fX=sV@^;_MQ?c)^ zvWL2=x@$6DJQ7N%dzE6ct#+BM<>yW9qFc>jBGKe;9HuT-cZ<=CQ9dYtxVPb}d#@H; zesxl>4jHEh{$g8Ly~&F5P^(V{^v#^&VF>s# zt127+Mo#6X&Vw6No^OIzQKiw}6S8#`&@k>9)0j|QHIJd{QHLm8F z=7mz)xEskWeAuMUl=zO zq(HZd(UZu2U=Gc2*hptR=g3=Y!I2(dK7TVoEO}+?Ldx|!_76&FL%XGM3*o+HsC8lP zqpXpb#eK{DEV19{4n|LUDaKCeEVxY1Xe}g4#w{du`~@{4kot8s`<%jxd0XG( zO0P4`>&}XwtGgSD6~cDJ->hFMv0ul9$7NhIY5lRi-9f zm(tsBlf%|<-gFCndUxi;80HecqNaIqr`&xHf(_JPeF}T`ErCZX`bofl zzTic5m5X&xJm)ni{&KZ(djbFQ_XpeW7k1iBku9%!BPLL}1iT>mjraD#A$>3IObVp) z@lRaM4Y5g)`#e_OWa#wFBjLjf#UBYDcwDZ}jW=;O$4-TjIUFl`T~3{^(Ur*CTwq*R zdRR<;SAECJoNU*>#yjRBbK^4e!)`7MYidMzUu7*@j>P>(#0`K6LKT1rI*=PR5v3CR z8gMxx_%?gug6yNNs*?E(sSE{a8>>vOy@nPM*5G0)E;m#eHWw~01glj^?xjF#2H%hIu3Sr zqNYwR(ETyoJZoNdMBKcyFYNwYT5u~R1=M+HwjokLW(Vv-q$E&e9$17zv&bjbW>(g& zs=uo?osNIv*1(XM#BkS~$I~Q zLEb&T0#7@5OCos(YFq+DXAW&72P_9uE0Ljwp_4#Q;psa1^iy|(eQ#;SQPf7<#0;OS z@44idz~oKM-d%mxI|IMaagRAOOG`3DP$Ep7NcqG_2jxFfmEcpv@j>?mkOb!qN;g8e zQ@cws3GoE~M8S!T7ab}1yWSqjHyCfwAxj_D4p&=`T1uAMr8pTMU|q|dqh$fxp$_>* z%mCfWSpI+SChMeEUh}tB328FqC6B2THJZ#Pf$n*qX926bVU!VnJKe;y19~aGr znjDc-iugK)Iq~5oIlsc0{>bcA>DXLm&Ob2?V<))i>61SdF-0VIO*ZI0*FSVLBfx(5 zm(V*h^Ak7E-tL-g`UE7~vch5E+9A8>ns({Q^OtY!{>|(CP-v&vT)#|~ny+zrFKs;h zAGp<1LRQv&sDsC9K!F~y`~l(po#eP}qFtX2Y9-g~+lXuq=1@FSRF7x8%2~D%XGC7d z7gylMf@-o^kX2TyoK=Y-_Jj z==nQuFnT^6Rdb|odfM97hTdSO_uI34W`2JAfvtZsnEhFA|7^F(^HcoHHfC{#x(35- zM~52j`%bU-%lEwqcyYM->07o2K3}sw!&{bnWiJiw2|Y#f$V{3+2mNsD>M0S|s*1pE zwPxdr9FsTWYm)Z`M0dXS^8eUw@4!v05yFIlcarR6i?>jW&Ohf98)iKy!R#J)ab43t z;nDT*B&X`j7N+WjpSx&IGsV6P5!1Fp;0DtVLcY%U!bteg7^~P%iH+NN!lwTrC zYINDd-$_Zk%3T)$z6uMvaKKIU(mcx8S!O91q25c0D^9|}E45zig?~t4!>^duDyWbAh3s!DOM8sRN ztezF`u-)UIQ=yYAiE)M@B&lyk?bsCvrDo8~W9JPP1X3$Rk7}?cj(cC6cKtp+(SkwSl)`w>8w+(>x!02HxCh}ltf+&B8*yY^)O@}!T zN^HVWssSy}KL%n^XN#vd*WO4>Nd0(UT4GC5nsbg((cG%H0uj}UtM1>XA83Nd(({oI zgkPS(_NW!o-r0jeMCC!iF`zonzkfuqgsnZ_zD!2wQ%|+6-GR%OUKI5P_c`K>()#uK8pSU|eci+XYcz|`SVZWb1&=ct>&3)ZR;%uCrt!4vM zCp!Q66==JVa_}wgdPPK$cHwl}%=SW-xAyhLfeI|;R3WRtA$|XgOdPRQTxW&L1v0Vw zb)){v%m~gx7|Y;~y$xsK%7-`=vMNGG0e!_y=kWUz2}~@dzD9rg>LM1)q_Bf~=YC^AqjsqCR6ZN!Aw}9^0|HQpN z)e8S)O@DOV#@?yz7u!P*gORw+p%;_k!?w>K=^GV24IYzh>oT0^nUnCuot8ESIrY}M z-_|igUWI>;@GgSnM&C|iD%2S_@I1(jM=WjFx#j1Fmm`Nzg^}8ULX5|QwMXdD@Lw2R z63*P})Mv;!^5)A`%<&KhVWy{UPYJS)CEpSdA+xQPj@^>(e8)`laXTV32n`m#ab)NJ z+q{D$Jqqkm%?upKv)$7se4l>JTLGO;=AQ<3pX1GU(H9f(vnRQ69D!t{Z0Kl^h$gp` z)zbJ)$&BitQX&npaW7Hnov>~IuMXjT`UisUf%_6FQoO)unQ*D%f8cksNa#6o2YaZz z=OD|5M_|}zg@cg39f)e`*TE7{Ja4q7yOq#O=d|SqKI}Q5nG@$DrFqJ~pAEnb$UF2V zRT>m2KuLd+Hu0e8U9D)Hklqp5Q=Lw{Ypy6M z@vPaCQvBN-YgAv#<9-HzCv(`{F4SrYyTOp3qbu=?J9(c2t=QX3rC}%oAoPFtUb>E@ z2%{{Oe<&0-7P|ue>@F*ws<(7W!SCiNClo_&|m^vcDW2yBcAI%Ct&v`lwV) zvJRto(6r2pt$VuSy9yM{tmewPIOZAu1wNi?DtKkIQZ|-7uRMC1t`#5w`_53W`2KAq z+7hP|mSP4dEc#@=af%e4^$%T`eR!~h!P{>+1mq}DtyEJ{!nuFiRmW6Dw%TP;3-2{P zO?k43$&uo7jENbgtNrYPD2=1N)3qXd4rx{an&)BG?TLDYwrjj%GOeAV?|P9%?Tmxtr|e0wDh!YcezdZ| zM}r}8gR9S-B|Gh_Pt=kYODBTNhG3GQo6PLz=qPXFL+Y{$VFT^_${6xf;7>RWyCgyi z!-*;fi@STe@9xL1IVL1pn&AT=3nU!03wHZ*4s(_)H< zx-k^Y@0tf4f(DatakM>FTsvFJ{PEy;erjQru2ni<`ZjF>OzG)iJ{6p7m+apR}$jUi;G5Q`A74Gg-wg8KGu zKgivnu*IB6$oq+79I51C{f@8vobiL$1F4)xWX@Tl4D?oNy*5oi0v4fT*xMVQ*Gh8{3jSU;YT=lLI zF5bVMl4IWO4`>k%mBkxeW0HcmCKN{wsa(dEIOH=@scXW8@j^GVAX+BqEkIsO4cJ4( zvbCzXWec@hQ+bRCpKOYJWFwr}aCySH^=*B=GHU&@s{6-%b?pJwTFoj9w3M(kP^r_k z3bXN!_3ksu2zvC0E>7?2oEX`gm+v112#;6|&>F-k+%%E~GE?3p4(4xW!bL+B{5#~E8@1(=CHd`us{A8$48S|ipL zUXjFgNU8hdr@#9x;4k8A4+4}WV|Q!sNUtOJJf%WH`=?Z)O#pH zd6FLL?<^dBo^I>?%-z~q+x1ht+76tPU(qmGuQ-(&GblBbR`OL(Kd_tvc}C+vKr4jy z7wi}$ko+d^Hy=62PUN0YOxYYn#7f@1#E$=xeJteY zj?%w>wcOn0R)R`%Y1+IT`%Vq9eMWNZTgSMvK!=#-h4Uz5R|+VAZ83geMB;WOba=}7 zPTUH=$t!WtEdSbOelxYpbCfU0w1hU%>@lJEpi>;8#zO2X#NdMM6iSkDb;LGFV%HcJ z7*-L2flF_%(HTfK%S;X_LiC;@DhxGJg^5!-tkQsoxOafYKp!&{%-^n55#|=3ny_ zg=9Wn8ZuHV!%r!@an*d=^Lg)TJO#+$Td(q^de*)#jH?>ee_ zj)itvJ#4}h50B3kDr-#8Dt8Kzyh{){QncrGh4I4+Qsf5;QR$&TMK#pDi1f?}p9Y`1 z=FJ<~dzX9wi9o$=-)YGr&L|%)(K_os2EX>7X&pZzbfT`V4oh;Kx1qNOK!SD3)xG{OofAvFG_JF6U-eF6XZ0`O>cEs_&_+}p~+8mxY ze?m$vwSzuVzWC$0_8AZTfTkZtZxY^E(iKUZoIjD}ubzHdSH)JSG+hv*cDAuIRRh#&y*y>ET7jfB%t=i{{R!8pCeN@1ZonywbL5$9a zML<)-j!&FPNEFf*o?rtYN}xhw)G1%aBnczEgL_%h6ECcPTB`nTV}f02M3%af#lQob z(d4ssNjZmG=ChU4V|MX>Fr=vdOs76sBx>9Iw?(mptLsTAcZW#UqW$Gm z=1%FTfjiQ)==d6~bW^?j9WB^1(7Q4j;%^pesH=fP3rbK@b7Z=FBtX$lbolc_p# zvU?n$dcc1X^F&yJk@114_y0V!{ptd0^OJp`VB7v*oepX&Bsm8&N|Syj zd0Zz~>DwnyznzFl!A(;KJazPUiTF#%rghg>UPUFav!sVRJ=QWGx0Kk?eb&xmTp<0H z-F}%gJCriB8(qBKF6Do>4Ec}8ugG7%`(G+(qdNqMXduArw~u+F$>ZSI+fMD%hL%Ol zAN-FUcS)5XanhLj*T@(~b_wU1e|2w%4E1_m*5#N>iWtJOl zEYLq365K40ch~u!h!?e`5K~oA-0#_Q*o4Y5oMF2STUlW3H~RD%e}3%dJo)g#y=I$3 zkqY~yhXX&Ge=5=|6PwRW-cS{n`Qi8XUF&;^mb2+c9^gE%()e!<2aD`iAd;Wv~#PW~}qo zLzA%NVOjx18^v|5ll^LX#_9_6>iD{e^v+?quz;zh)O?ci*OJqf4{p4Rb}@hZZbqOO z+XU0er$jvBwpoEQ6TfM6yxC9ok6!J0dQg$#W1q%vq_jtPEgbIi@8P#sv+79Z*+I>tc)LPEsKor(6ZSsQQhN)s#K@wO06 z-T9-3!iF8%rhL-gMQqD!RkS>BXOh%uAuywgMz3Wh-=YlaFk)#Il7X@E`i0~z zp{QC|++ZkirAG%$#>z>%vu8bWWxU_4AlCSQd%%ho5NKh40Sc#cSv^?5d!IFi$x=bN~rk7Nowe4sv zJ}dE)ZK0I5s^Iu1lkn4wO@%bqc{Ih_Iv1PPr@!j=CQv$AC@y0)xVgh~=jZ8-I^5z8 z)#gv8w?sRji(G_e&B!CepzQ2qFX z*AJvVwSl#^wBv=dPTzd{+G$NL=37yoz(QuhK`e*jGJ`q=(Swy+uWjTUr=e8|@OV9t zWwneu$9og{c&6v*XNR{oR}N2D88vS_FvCkDChs3nEgl6WhPfopk$=C=nsL_$w`cPM zv$Y&=rhoFrT6H1{Tl@^Vp3TFvD&i71vPAS!(s%t9X#QJN`c`ydA!9D;3QN)OukyRS z-QvL8l{^kJxaY12JBHi)k~=A96_9ErmXUDutvTv+Qlpbr-%6vQtKN?DVVAcD50mWC z=e*~R7jmfP%y=zRnViN;f*TG!qx?B(%KW*;D?_2zXmifds$}&%F25}Ksi5g;Z4tNr zdCTFTEFdbkA=|~}kCP9FnDcZ_P7YA}Z6rh@806hTik)mDjz^=a8C81bnOLecGoQP~nG#NKb$KG$6}zIinHXG|te(w_=%j zJ`fZ;LUjNLLQw=T4zm%t6^zPiCSBvMTG0brM9)lws-jR}fp1l8T_N(0wG9{=Rm3AX z4=GIzAMq5)z4!hk-y=J7KO+JNVS@sFRUG+loD z@*G32TV0Nsk;GoP?kkcFI}M6%W}M3fyS5p=?V44^tJt;FtUD2J)93 zuMWHt(R4IZyrY`xToY*Cus+S!KepY8cDHx$s?6jwBi4f- z5j+Gz2(jEwWFeNewn)boj@xOLP7W*>Ur5XDqDlQ=e0mT)N-c99i++AtMUwoNW&!J5aX`Qw2J+)A}X6z7~zN24r zAKC@mGB&+^2E38H!s>6X=(edPkn0Cad79M8ZRQ9GQ0E7W`ew z)Ym+p*}m|a&1T51ctb}^vHn|?Lue~i;Mke=VEHJU)3Jg9 z)qh=PFG^L~wm!Jv-}NF^_R_i6Gkq6wM?O!xV)?*tBqyL%hBfy2uU(E)DI(q7uGNpv znUU(h3n1Fo&P!2=;e&nQ*pFRdOtXlXmzDHuAoKNqQw6M>GNCSFtalI?zY=jYrH&Vv@ zF)ZO^3&PD`=bfZ^E_{&Nh22d5L6$N6$3}>v4dCK2G_uoo3ZgOmOtW~j;8Dy7j0#uD`cK3zbg5*#9?F; zY8!?_@A2BhTtnnZA1*q1^{U0uC)yF6&koBguF(QJKJqFhs0Eb^q8z|V&Pq(V{WgCD zXyY?ofEbcz+Xvi#V*h{(IOEBHuA@-$ruB$^A$L5{fX#SYub=$HMUF3qD5nry)tL|r zDnd@;7CAXH`E}vv+0PgP|7CKaHAZ{5OW}{%_w{Kpl@rBKrR-9KY&@0u>Y=V-+W_|C z6_BLyU26MF2-Z|o~zq=`luEGUa3~yvaNt{K2w5!mfN3^Vs!&K^W{+x@>gJM+PWFsncuPGt2|oDMTHg z%@sbDE)8j8Qggo80=A&9ILQ_@MFhRp71c z886;r>py94%LolVI)vBukox;5gNev=6Un}0cQwj3AN6!BWk%#6cWEE(&M~&Bo8tqd z4GT#PH+v@Zy0#@~i3(%V#rKL`>RK_o56)4v<|D- z2x5+wlF0QUpeMMF;C>^f7wzuy_WP8RzE5^NAG5~*QiIJy<}NOJWw%~03g$^o)@yHT zau2@daKEdaS?hnn^dwcIqoe-r^&#DCYdmAGMOS{UGzIVE{B{6!sD|e->%rlkY}LAT z(JJfn0UQk6f{mRkPa#Zqb#;BE(`NOf%FH$A4THh^JXU|JhE4I17C!S)0mr0Cq$-ah z*?{O}@L`FqBp@wFJ;!z1w_yo-v-87~+?Mhh7iUt&Ka^k7b(*#7d{gUTH-0gmoOcYW z(d%Fe8Eh7iXbZwj-Jh=w3x=NxUG6S(%Ofj`L2MCXcNSxbo)l0xAWI@dfIuCZ&OY0a z;HNTmi$38e_a%GZ=)x+2zv5;gNU~$cERg~*Q1%}ijc8S4k+y2{Jmk>`Hy|-}`wxrP zhy`H)WMDracBf&a^8Q^%fG^4j_Py14q0Rs`jXTrU#+lWpw{(uk$=F=W+cMH++z}LL zwc8-g-eKr`R!?s3E|a(u$4HG09C-BinTSQGNgVO{m`8e$N_)b;v-}kAF3p5D^@(d9 z45A$E?y+ip;^##CXNnl2d5d<@O3Rxxgc%iUq;h7Iw0pIYHheVufc83o$csgLuhtbd zctx`AXA{>e=Y+K4MYZ)C;eoyRKg;%;ZFzNnc-u7%$kEcz?{f2po2`q!y=>Ag_1Rjc zIr@h<4>5$m!DuRb=bWB(@0rw&M-MHuGhDbBzrSivIM-gTbZIvrtLSc(WO@iypi-GY zj_9|@IYtqI)Y~qt-F?7dK*FzBnwh}Pi>LJC$5CwOz>+X+rl+Fwww>aFBQc9-sdR8n z6g-NMdXQ4>o^U%;*!B2-`fa3QBQ-oEj}b}~Cl zHYVcp-<`!u`mINqL%}%#kSR3M*^ttb4$dj;{Zve0%V1|=c|qq3`;1|gh`THYkn%B{ zFJc_M+~hCyjBMN`dbQeBM~<(o7ww%dQc8)#z#%pORZDa;V+c7u zHDzZz> z5WJFv{)!=lU>0ID@00$AwgIgd$TI@mx1iAU;FNG#=Cr-K+o8GnEs$^=QN{`FZ6_}6 z^sj#1z!auc*L~gsnOk^nFfb4~Np91nLyNOw2dh6Fwc8`$Y5KXf{g@-;blErk(4<4t zYR>(4t@di_@tTFxTPka0g$ZOZHQ#K~?`h&Q%YWSUf9bR^|3=uHj>)2*@RqW$FbVP&DR-_}oa)N%lsf%> zMckaGoqZTeDc|3rm(3tQ5!eg5jo2woL_kBr_S-A&h{-^6e4`aAB{aq#>RwPJ0fofZ z0`w<@H>2mI*tyLYj(6@;Yt71jj-IKez2~=<;irtGO$3?{*&tq(AT#<8%KEewS?P+r zPL=$$Z}+%%Sm(!#7)P%?X0fh9HI=H3x-0&iy%ZryydQfbY-e?@r+H0z?6-;U$k!0t zzx>y}Bo2|=CtIMW7Fm5ABuLHe_&|(L_u{Oj^JDXBdEVcZe0}|=N+)e(dwGK3IdSC;V(_++bwld!O`*P+duX|b3llavw{gKs_HhL21 z0@xo$O>1g)#Nf1x;PReGi?(H>Wd= z2B6b%2<|8+2mElwRxeaeh^Dyxk%EXom@|pX7}t& zzf*78E_e(IH1*Fr`Gu`)c^?bX#v8F|44D-5n^4s`TV(ZMwYSvo%FVv58f+ydmh-vF z`j}gm@fqwE)w`6~YlM;lE>@%Z!5JRWDsoNAEUh`bI*8HO9@i7xt2-ln!a3ScW2;3y zPD(M6d@(4t2D^ekgxyaY`NZ}a=o`URBW6sfr$Bl*wxBC8rK#bD);Qo?^JuX_hk}bN@~wQonlaw;3P@!kvk>5}}nZ9@wPmM$D`%FXtm33=JzH zEFeWFNN{?O|HCgVKdFNI9;z)o1$+mP;V`U8W)G3I4OojVob&yQi3;#6QfIm8w-f4+ z7;^F<$QVHU1VH-@;kU6+8iu|7g40RiTWhY7LqNB@APG(A0KM>F_W- zc0a@41jQDvXGojSLDj8Y%IizpGY1JO($a(k-Bz{B{DL?eq+^b|chFthTh<$v{&eET zz(V7Prg70XZ{K3`GE#X2D{`9l_MNJ=y5IGQx+K-a{Srq8X9Jwk?zx?=^_=r+H~)Y{#oJ9p5>_uVC1@m?@aSFNDfY33Xhn) zYoA!I??DLdWpANSS;djPN68LlhKOYE$SATyg-GFhzs~vm{(|3i zxz5#57w`A${Tz?S{kTW>3MhO?+ddS-@;C1nL`bsmR=1`}yoW<>etzCp=J0=ZE&nC- z?L{$&3!Xp+LsSTslDrZE3IQ6y_96WPAC)wY7J{M&Z$r>35tO|@M0eG+-|S*znjY6^ zVMt05BLaNYyh=gO^h--Db+Z9W3YpGXjkn$`J^y^HLgZUa_t0%FZ6K=RrzQP5v;;yAbA;_K ze%a$k@%_aWYnZW8ngu_MCSyyxs^{N40R!XM^A1n#rZy{8^~IP!UlqQJ3-|b_r`V;e z%T~eZk-AKuN5LW>9K&%-;6MSrV!LZo&YO*2*9qqbcJ^Jly`)i1N^PuXgm<+(dN^5x zfMHzM5cz;JcL!lTsD=R+dLmMf?$*;*(~D&0vr5;8jpOqSbWid<4xa>}2#Xa<7H0n2 ztN%_MBgQC%R8dIiJdKmqQa8UZ0Rhiu=Mz!U2-FGOec-&EXr63$_xi@>Llwcg{n-|I zA-R_qqMC$D6blBdDZ5K^rhhd{U1I5W&yzeVa?t;@x{A~Hu|-|?NiSDErxzj8cW><& zrwrk#V=?(z!pg|~arSo){n~p$sU7TsFZ@%DR=ZVQHKLcYrvg-G1RSr+w#Rm^r*BM0i;Bc8QN1G##|wl?-FAB&(^O(UQxo67T;R@d)IR6dIW<{KC$t66 zYwnXw?HnIpHJ>p)C1>m`zOR=$!K`k=p5VN`q*yx!9wfdn{Xo=`qr@#kC!}1-B&Z-J zgVD!=yR+CLTFGIrYi@U6>0W#ggj;F&JUB?anGvYf$@27sE>?XAS3hp_y-VC{Rg2=6 zVDMs2dl!$3RzVjzYs-&IkDR60Gi&Ql2vnl$Y0tbfl#8jomYgghk76{R z6?;L`gC~P{!BXC$1NW|~hH7!By5zfguicfrtAhdIO)-o!8&0HvEpx%=CjKc%Mp;)_ zcCJls#Mr!bFn4lRix+1TK8ZfJ(dvj zf`y8bT|5#@D!G=-0Lw;)vwurxveYhht+>kZ?&M;YDY+wxYE%4DkX%xG-P{Uo>6zk- zF4~dY4zz2YzpnJHH06#o(q`thW{+Q~>~4Sk=#b)tN;o>7QzbS$Mp!`T3B$IgPE4NB zhl4nG)5b4inT;JR%UKM4IeN{d^I9?fW`3puQ##M6`?L2MD;w2^* zuk*I0;fai1`wKNMTgz&*BJUUdFyY_wWk zyomx;Y4o(^XL^yb_*nXPIU_M!Q!WxGx-~>3>@DLxkFnD$KKd9N>^10cdqpq1{h7_| z*TJF!YLbCPYrzwl!a4oEy@@4sf(=H_&#Iy%scw9giD7zmk=NhCoBfwHCIO`VLqkJK z^Y)^Q***qG`C@{bJsAyTUp#-vVEHY8-~7pp=y3S9IMX;CO(~XN-dckdZV9iH3Twjq zKB!$fYuF=q`1{I6am)>>tK;7`x+g6N%D(sZuuZ|_DE`4$(|`DxV|kbc^R3^u{T69WtmoUxh%7PcDlx9*usnJw$H-Cy)wsRo-jc;)BVkM#US(Cl~GMAvpOaM4aP-{+plco+PIv9X`ZjXnVFuZ z;tVyjjJ{KOEc18!L`XpJ1vni+Nu}YXk~tE|qrQ3j5~(z0DGplYXnyDM&w58E7o=;L zZV_kvI<-*u4|glCP2XTyXv~;{1vw=dDewv=zFaG<;%|uScr}mgiD8mgm&p%aUUQWG z^~dYnLx`cbllql$Xcf%5i0~U&1>~t68(IdX(pO1IBMrlFaJxHZ9QW)bQzsKPKXB~( zqnQHPu;z(y@d&$OLykl1S2J@ZtQ@|a#%+8Pk`~4F&M=$~2zBQ=Ay>ZVVN;7*Yv|+* zl#PI{(1HQ)#qD$M#o0qonD)Gf&kn}y!d8KGA~nly$*pW(j2w*n*Do0s(CuF-%1OL! z*1@x6%lxoe?tA7X=Wz5#8;154{|tR&e@sHICRoIvDoRwux-+%WRwf251;@e&b_ckqS88Vt^nnaF&vRzki1Ni z&aHuH8?#zbcSJd*e<-Za;fV0&rLmC~o-+JbO2QPs|A<;#?Pc8Wq^|+yM!UFIjVKA_ z@aQfVKK6|_d3)?pnE{Ww7_aUInef3&KkkTng-}FFJZ3(DHiklvr!LVfbTReLlXe#J z+%I=Rovu{8G7q_Tjwx4iLRZ8sVtRwq_x$|@-x_lpo7%1cD&3uFbPkCtosU}h=9NLWh1Emk%%b_RlI~p#N9c9j;$v>)HoH(r=ko{Sv%Qcr-2KKe5NU3(* zgLq0A21-2i7}y}^%9RMr0tAmb6_&+NbK>$NQr(a`=of_KZlYEvE(ypO|Fwj^v9;cR zEqpCn<9Bh*A50$Q+;-R1{iXh_zTs%q|wc=~RApRBiolw+*tOeF)Ygk!Oej zA6J%DouD}g0s!wPDP5(*@ZJ#F>4U*fQLUf4>N8`WZTbhFwdTKi(IW0hoq1V={e+m~ zj-76D97J+U)#}JeOlQ$v6OJS3002{fWyT4mJ`pIq7`8bb_C0B{`>r1@Q2fKGq`N|` z!g+K;qV0*MUGOb4grN%TdFvpW3W1>PZ2OoIH9M2)UT7Z(-VF&o-4O;i3}U((!G>-& zD}PSrv+uOb8e76^|N~*)WIji4j)zlC;G=1&ERX22> zu)_aNcsLU>kSYU4-IJWEQJ(TPLYaj-P-XP*YkY5&)XwXxVH&YVEW?MYU72FAvF?GP zrT?{eIqn07!l8NpWOx;&8OAoM&csrLSoJTia^H?@7rz%B5Hl!L_mAt<6wR(;o&KIn z@9&f)4vs2>zA{>gao*O_H_q*Nf=7#wmEm@ZMbyGIBa=t3=|WvY3<87d#mOXbdi!ll zL^3txh4>=)PkrS9uUI5lXpE+1$Rj;{s^=DN>qb{uyUanl*lPF`WdS((sE<(-qn5UC zi)x-AK4^>yIu*1>H2QN)YqtT>2aS**hVlZjCaQCh3_TO`txw{O=R8ghlO{|ncHDpBKYJ=b(Z1$xM^e7+ruko}0kCr0kxKpnax&w) z<^u2!1(imlHrT=3^gy)3xoZ^tPt0x)E*$hiZf)tahgh+MrxU@E1RW8lgWO}^lXp~+ zV+lKK92-P@ATjp6A|TQ6Yx(>4J=GiYx8Y!bsl4#x( z&2uj&VHyDnDlOrU&FzGV9<1l7I}{z*8$^mOdT9~o<{D335T+&L z)#-Ubxj}`q=MpZ>J+IuWya)1+OET@Tzucbk@P$U!*qP>bg}7b4VQ-T(O*>`yzHscDz9{ zz?+$>u}LthnQ(;T9<~O_00btm;@60X3L+;AOSvuCAYPT{@M%>j+6V_QP)5*czwNt8 z)!lIVz`@ud7iZ`6`x8Lwh&fnrJwi}ZH_G75Sv43zd@nM3fjT{;U)-I}_< z-P=gu*AI^C;h1ePk*_|+OEPv-pJ(22WY=)<&5vcy5S7ecDf(+B$H5pCo(PI?AaKuT z7n8=Or_WNZ1d|fYb_|vh&HXkf$TDtNX3wf7g@5t|57zcZTSZh$WJ{7t# zo@mGZu2mwLb@q^`Q}MacTdt-@*DZX6s-V}w8UbuPqt_@;%+8U1g60{G!oLL6A%~|a zy{EHUUcTdDVr%?ISM`8sVgb60$V;fUbeJYwu{GV$ltn^~r~;wAw)k2w}g#lt72 zY=bOm{Q+hVvs7-S{Vt6gT92=N^kTsU7=UUKhsfVS50N?3*MjLShU3%L*JBRRl)*_ z2`E0Whds7U9=vkZK)Cn-Ce`JB3LE4}>%ixS-5Mi5H+KFM8eF#JR;BLlXfXfa(~xX?-;b)#2iE>A>h+I zgDH`-?&>PlQP+2C+Q*AuBFal!hy^tR4oKj-kb#mA$ofH0aVJ~jFm!=%4U^ip-w!Bw zKJZjHHrg4?#$bFaJO_@5% z`h%lHL=O^47=R)D;C2VJ_92^@rtlZV2$G*JYHTG94$R~(Qr`RA1sNrTp6)f-#~*Qm zkPaU-@fj0V%#BR0m+oizeY$j?`lkw0=ept?a-8Rc9t%Qrus)xh&j4#l>T#koPG_V( zAiddul=ck$Ff$L+>_*JC4Cd(u6z+#L6q`4M}RD=oK32I-C--e|wDy8grjKUgB^h0D^ZSPYWEshikpT4W5i7Cu2(AEEfDq94|eYx$Q`5 zj(_52lfw0kka|Mm)7{yCdBWHl@Q2Q`ki^(9m0K_<*TG*_$vO zapTxIX&Y0~58TNQbDFHb-PtJE`B2DgU~x6${f+G9cu@bFX=W7r$@E%>UTD^GwLp=)H4@W# zf~w2y(ZZeEpWIC6YaoQYK@nZwNgKUQeLT3f(mQ%mqOGc!If{k`X>4b!GcP` z>5n@6!}to|$hU`kcJSXRl&nji{26q}UPkhBWh~z)bIn7#5@%RU5w^}S-~(Vp zcb2>|b{qiGUpU(m?0+P;9JDB&RCx8M<2B`nvBhk8<9Zk0J=K4qZGM}tgQmw0ZWH@wpu(a)vwRz@ynpXEtG+(fbhl3a1 zA;BywHsRhIVRt!OT;zkQ6`l0a=h`9;3eC0w3f3b5tyw%I<@Dc6mu{OV_uWm~RSiPr zzd_;$kY`n=8^96<1$(g&-Cmdx!Z>JdSwQP0hSyI#dTPkG}n)^Y~fUIF}bk3yx zKYPsI1X_4;YIemkOSmxTK+fMK6waQBNMw_F&uo{MEd2#P)b>5oF>YYKH$%$VB3Tfz zo(kF(CU0;iSl>{g&={v{*=T1KeqYp*Kq&ZNJ)&=6 z>6Bp}{50T9Nblc2!VR{kiyMt51y?W342LSEbT6d*dAvI)RsQJJ049mM?s-g|7yRnj z;COswCLWcIef;a!uZegV0_|U0(^mbFCQjQ;Zy0LKR+OhdWyEy2Z^>I%HGm_H!4Kwj z>GFk-KDsrux_vM$TAROpHwewpXK=}}wlV9&o+Stw*v`m<6vf?Z)4Te^SOYH z)|^z675O7Y>FV69jEtO3-Baz#tTpe_1uQ~pd(s~o)f;MmZsjAb_n7hY7JW^yMAKjN zzUUz(>?;7u-?NrH;_IkoEE=;Wd?IN4)u$X;>bgnWXq|QOTCIC;FI6iVg!y#C4;!)b z+`%$W&cf&8Gd2*)n()~&NTiNx1eT?=H7k9)^%b8OLzbN|?Me2inOO&Qp1dGdorK@8 zC^GVx6f6je*)A5aN#VQ1_H;=_^2YuEi-l)ifh`lMOl97$IO=o^GklkLOD^WpFWvU+ zN5_dmxbPA{k*wr*gYyH{&dDU*QcU!ZEf(14&5A9pMQEm15^o)|x;rQ3*JQCkfAl*8 zB{@pDv)9f_hNb>79@-)O%r|m7n!#nmQc4Rg9>mmkL8)!G(`I?+e54GFEp@c&J33*wTK~YP> zV6$V=Q`P=`PG3#SZ%O8L9SO!IF;m7%R_R*_r*DamQ~%fEQrZo)-i8{S&>5lT^T(>Ixz3pT8`WzZ&Zd5X@ zd#g~F`YbTvdiEUTvKR|-(J#Pn(_i^ZeTj2!t(nZ_4Q%>H%?@@sU z$uF7F(t;ao3(2d-CPpFSI<9R-k9v$G!>aT~v=(lc_mxy6@LwFXM0>Yg%`xEJuiS+* zM|_L@0@yD!gP)1P##vUq%;TY-=oKk1witCkd0zj$LTf6!f9{TyLApCb&^!IgzOhBac_C*{}w{zWbe@E@rgBl*%5%@cn3f=ci8r_--L$zNGCNxX668FEkNO?SJsMtl?S zh_{+wr46-Lkl%5p>iDznU1-^1Gw|7E(ou%c?~U)?{JeV)lB+t;9QZ;wiGXPw>bN_w z_W7tU%pzf32J{ExQD8Fo6;f;}$k6PbL8LtNil_4XAy__BWf0gr0gQkY@E9idgxdl@ z0XX^i&P9(m|Cw?huMkUWhDl`@exMW^%2E}`ydZc(l7*SQOhR;Q?AveO1YrjW+C1jM z69(~ZjK7rf`&nHZD>J2q)(vv{2DozXEs^F;-OHO8uiV~7VbFgcjy-?9bfpZGo5iBpM z<&pnF41cGV2v5raYfQG-=iU&Gh~%$7(cl?_!+|;&{B|v}eo&DDFcYd6R)Iqvm9Il3 zremLJ zf*bO{4sg2nzb-tUlcQv~wc^C`C+3xR2}Ks{?Yd`b;N5`~Ayd;Gs7SCM{FP5k))sh3 z%FDrL1S76Vy8c+VZv{&~*p@ASXm{7$awkz8aM&~8yuZw4fAH00t82;5H>TTH{UYZ= z^P(_quzf8n$@urVUb`7hntNYbe4x;zeHrzC_JS&DBFnD$BOn-@1$eh$pu#KBa`D5w zb5NXqMYn81=#VCs2~e~s*~M$OPeHbXGKmE8-)-MU_LN%0a?<4f)wNM4Ipqe*Hb&jh zpukEf)pfc=H&<(d{X5fV|DR(k?x&xONj&d?!{&hDZ|N-txHlrz6wY0I`+s>hO70-% z+S>iOhO;F?cek$FlB*opGQb=`4NX=0j7W*wQ9I94+H%dJN`i4TW* z=jDBq4c`B(7z)&9hPOJYysNK#6PglNsA(IXdG*}f(9{y1Ur-VQ6ofEla`?oeU9?>1dH>(+ z+3maCb2r||K3bJ__RX`qay(}B;(SJZT z)E?O%?Y=!V1utI(EWkcWV;$q z>}s`08p*UI<6dM7k?*9U)xxj3@D^Hk_000#9D+OBP?l9jMKeHiL$q}qy*B3 zSqi@Q+jH~E>Jj;BzS0%Bu~C$Wn8rY!K#4;ddKrTpqrU84m%dk`Fb+{MuBj`&akg*y zN=)N-v2NBHhuOQoUGlb!IL7M&>O${5*|oeO{&-xFME$$C8n8S9y_MrL7DQ(6#8zH_)$wQESCQ)=)gM$Ua)t1()5*nsj3U#ltEpuM^h!wVL!h8f?4$1^K>L*h!U+g1p#Uhp?RSZmrKt?-R zWr4?yVxflW&945yvcz9;ylLTLhhKLzvj08sj+Dij*7ACt2A8!eLn&X$<08MAOtwHX z3LioD?x0gfmhRrg$p@TA9WOgLaOOzzZ!8wHcK-D|My{urVZVr|Z=Sx(nGlKKeH3NK>7=IL zGOuo2>>`z;RbTS5>S`5U%{3?KefckMoYl>2Cto;#KrAgJa_$IEV+8KkC0`R zk#<>!TK}7XHc9CgCUeGej?sIiEGvKe-i}^zZ==f@`Chd{sNH`m|GxN&vo=d1(2umd0v~_>;tM0i;&Do=lRVn7HBNjJ5a*;Y; zRMMq2^>kocy>+@lDySn*@AFrxpTa9v`Bq_{=)UfNUy0qs2SPxF+h=!uWuT2RS>(3) zSh9odudh+YDU4WpFTNI;U$xF`JW&z&(1?})?(0JoiKoA1NO6!~%Qtv;V{7Hc_|J*v zwTWYQA8xHwZ!&^71b#0#A@>Fbbas)Ws3vGOL|jgXxi}>6en1kJ{~S}k_^kB|)1*X~ z$Nj{6nM$u?6=e<^=S#_k^@?~nBw(_DSthJ1IlB=pfQJNn;(I2`*JWC%xp~=QiY;az z+dG&8shOzwZRyB+PwZF}tRT6#@0mr)#kaEKD>`0BVWBv;vcUSPbLq)bX-%)vbC)iK z9y&e4H-2lv^y`Kt3*d{8*3Meh%AO3xfv+;ZcMq2qS62%8?jS;G2XY0k~Z-579TOwOfj! z-F}oQ>-|h=xkaRyXPP4G(@AUYQy{AmKK!aY6qf9JibrDn!_RURU`&Yd3PqjPdD2@X9Qnx3!?f{c%7I(HKU2<b9Kaw%P_$lHF=g)j0e9t?8a#QVO% z7+3k`n+=1R0NxNgx47aHb~9bve+QB_nDY#(2rDTJ9zg;cBWyi;v#$|O$ASz<5kTJD z_aBW1#t&?MIRMf*OoF)7y7y219k9A6doD%Mn)XhxlhcW!0xHG+0nWeu0+rYmKOof| z2WSa`Jt*ua#aSYkNQksj0^3EmqE~un+wH0qhRn=N!cq|D6mWMC0PsMHKg~Z0jr?V8 zak^2U{|*@frpns0l2#V(co~4LqdPaGx~$<8VFPATIP9jwgx_- z+L6KIdAYe*uMZoaX$x{ZZ;I@V?_Pad=B&}sB0P5`(5m>eMYa4^_Ps6uwIrXaGCgLcD6)XnagrOH<0R-&+>wQMA8$M1cG^}O^JgUwtCCuGq znrx73`BXS+#9T`HI&3cZM~xa^6Vy*iG;xmc$kty#g^7BO$o2*A zQB+A?bUge@GAMjP29 z6|L+hy)Sa27e-~+j;%`(TtgHd?(QtND}U^OKZm@MclT4_kTR%nLBhu?0PKq+8q4`d z0m!h}c9`!G5#}i3bxY$KW6p&y3howmGSshl`2fx+WW0~XKT@J_ekK?^ruR2N zx)Of{6J*pukb>Z9MoEV|8jlzK0xTnc-fXlGS)5XNX}4)uzB}-VN6zHig0%$t)p|?g zXOU|CQdOGPlyz!PSj|9UW?Khd@iu`JD)WOesyDH}V%yDq)vpz{PZc?G#y;gr3h{Sn zqjJoVLs$WlL1I+VqJd*auoju9b)DC4j&taKL05&qG-dXh@8^B~K=J*EyG8kQ1gXtu z>Q9Vn_h?+38gUwJR~*bvA793@04GPFVz1r>)Vn|_@PCh1rdgK8$wG$4$F$9aV;)k_ zx0KT^KOg!g^OP>E5sl5AFK@|lt-3vQl(pYyB!|q0y2VwhTC;x`%3t-V-fVPZn5|Q$ znPS$`+q02aHc(VRuAghVF>Sx?h$;b{k0i{Rby8+ov?T}YnG zq@ieynD~))=$5$)HTg0?1yGItM^Fz@p^%g<|D#jj8#^p@|69RBuS89!ocG7_DO=Q( zsP;8%L|;%n_N1()b?HZ7oEl2lj0;hBe*ZMFyNusaNC~$sFqiPNKrY)MDu-zikUHX2 z4r_$S@fcSwc+Pf7XAV8tb|f_MSVTw*{227q_Zz=lBTOCk8x18Wzv-TNpmf0BL|M28 zehAzOY8ift=md{kThYNLof$T z(9YXc3#E%zujTXGjU9jM+kBaG2vOc!Jh%$19@tB}5Wj6tM;!Y=C|2uGu$Jw<&7@=Q zic#%ufxQk^*9!aRhD&}}hU{Y+NgDWI?|Rj6BJWeX|1;+A#SG?7-8M|%r-e28>!~#J z0K`)jeR38ot%s4yjIs}Hu+H!WFIw+sO0@pU6-?9XZ}|C`gL~UhtEiEJpnMHE>9xnnvy-Ol^tU1HXq5u-*AW3ickdqOLpreVW26+Fy3A zcg_iOM*u$OuF5{GO^-|HtDH#`@2BXeKDrKQ62ttM80LQsJh?fCe++ zHAY8nmW%QrqUDH#9b`5!F)>#Rwc!OMbuby-IvQwv&>+zNYf}eTWB7?7{P{GTrT#OQ zn(BBvJi8evKYA`tVoAPhu+O8pAVA@7{8FgHz>A2OO#{CDZ+m+7Ltcqx!xGY<6#X2o zj2HBqx4E0CrLxPL<6-<`96tAJNs5iE?pDk5k?umWbpzdZd>oqxiC7l*Dnjw8f5Az^QH{#|>1bi>seH=0A-P^Y*5V@rNs{~TT^ASVqz ze_LbkBxA`BUN`e8AM@^=eDQC}E#dg|Z+*Gyy|{V@oF9^7Nl^8C#?6bvjF1ffxVyEu z^$w=#K32m5b4K}gGB##^kmN%CAs_SPm$*iJUo@&Sa|jB_|hzSr-feK{Q#}h;#apR z)yiAbI{9#p!0Bm^?D!8UXd1PJ1Yf^6es-R+-@!dP>d|@fexEl{8;0E9bN4HE+vJD! zZiP}lo(@$@PWqZUcER`s(mIv+_LGv> zy*8)G1`v8hAO$2d*aKuwaA``b>lSq0JX{z1O$Wdtwn0WlhA+!F1|I~=aH2U1&dJ1Q zp;zg8S={<%9D!hcg17+;1H8ifB~68yD=D&RI%TWvhccf%+g5qU3!GcKqun&>=2S7P zxwaGUX=c%e5%ftMti-Y*Y9|yKD3G=bIVNfzxjFRM=LGqzaN*y&2Emvez#$1^ZQw8{ zVPO<-iK~8bwOLm_e`O1fkKW5^2fkovSdV)KL}iLnUKEPX2^gE;(&|ywm=68IhsYyvL3{dLq4d>zB7_6MSbKqm zV{nT1;ZMR2%yY%vL=AW*@CD9rQ7YdI=aMMjj~AE+f}+TRpOt+(%2%Bx4K`P5&ywlK@;q_dI<)~7h+VC{#Hu5_xZ{s7M^C@YI2*kA_Uic06Z1~TI0B%tz7GJYr z{y7rY%7bkObFD(CGjDAEjDm+{qFx~PQ72#ORvp7&OW2qY4H%X%5hV;h8h*K|ni^;1 zc|!dP-Zt(fdgTEwBs-A07S6P^wCoJ@vAe8BCaym=^u4569z{Ahe5gV!`KXItwYIj) znSPv_9Cgxn2{F2Vkn$0rICK+0s+!JBRUoeKB|lHZIlR5Xww2X(s&nCsTK#Ru=?lHL zPRF%D5kEecU;R|o$Ij>XytrjU0>|^D?hi{vqgAtuv#!Sd^+6h%BiPFt$nZKH}KQB$S7s5WNUEvQkoMOno+h3lI z*E=eF*3zy_55(*Gzysb7aC+W;^Lqz~UZ`Ne?W`xZhsAXrotU$}ZK+J?TJgHEm?!Mr z4$__tKe+4oq~FvOj#~T;-loPQr|ACagA94E+<(0sbXrl_s4^PuB`y0eh69D|$8R!c zhT)nF@D#0--Vf^E@w`TD2NHHzMy_AW)gp-cX!L0A8>)n0kYrjU{q&HiM=kY4^y0@W zqH6ZBBZs8|qr<lUfe=Tqw^ zOxt)NoHf^Oqe6Xt+zcD0loC>o|44Ei1uasUYz{?wd=i?J?tKNBHJRl3=ZqsLL-(HC zts2EVIV(;sa$KmP(}`ovd%>3S=15(E^7(c5^{vWAh)O`Ftv{&$_g3}XQd#REkwNZ@ z8eIPJCy(X`9H%wk{a)(m6?T=+Z;V6l!m;j38z4D2);grMXxCEbv+o#E{CJ_}R?+sy zUVd6)br|h2!t3iF6)y$*2ij^+KD>xju61kPlic)f@WR8s59}n(UP_Ay{#xL1iIO`w zeSXUCP{flN1rjb^t?Me~pD?rYjQx=rao@SxD)a<=)L_Ah0FcvPohwXK(Likey1m74 z;O<`$_;Q1`QxMbN-|s(Q)9|6p)v^6{_%)*B88Ax%q`v!W{v6GX#wWbF!U?Wie>3>3C8_^}yUxGh zIBiPXO{L{ik9VgwdLsS;)z*e0Cj=%oA%7LrS>5xdEA59Xl%56Y?D7=&0U7|ZhFC0H z+uMyHBZu4;X_qqV7RJF_3_+(6Cv@)o(Oq4T8I(d6OW?<-ur2t~>8e3b_I_vK5^m>=V(VM#RGucKwAn>-itXi((Htqcu*JLaM`3ICEd z9SVbn-75{ULcy`Uu2-fXW*wz$@Sb70wQo0vrXa(=Q+1+JJi713H96U72a98bxi361 zxKx!Ht4$}m{iPo!`Hd5YM>1_p;%iZi4zP#_D6umr0+R z`x8Uu$PLs6Xa{+6rD5Kk{ydPrSn0Mn3vOn6A$JFDp9hb&3qSwtUuRUg(s!M};8d0l zQBNy$qdHLyvfJedY~YjzJI|Mow?X#(R}HZgH;OdD;PkzX>3;1wA-oGEKQU@w9q=E7J76&(Zr}kX=+8aE0f`C zU2?8dcdspn*~*qtdVk$m3zZ`}S84+Sq{bl+bX-6`?QvwpxVsN15T>cnILKd$`Xl_=FXOnsCq<|Sf@R=N zu;&-{G)&7eD&HZHqehoQb`4~upx1T%t(`0_J8iB>~l zj-~wgX}}}HixMF-jW{@U-ykB#`&@HuWtb6V%BJcw{w`zT;M%-MHbY@Y!2JLHhvJw z>QSz-amyJ|ia6gnY}EF}^@*2KrYjss#GhN1$k_RL9=j7dGu10}c0>AjDadzy56Zqc zY)_8!g0aC3uN8XWF@Rct;6pw}_)cLw1ha^9>uR9I;HQjq&dtr?`4L?N7z>1pB<4fs zA`jmlJ7^S&>-1(JOdCUdX^ra6DtUSXcmPs{+uqbVhHCjx2rGP;@~eKac(2tRI6uVU zy4Oz!zVO76GjE|`#UD({m1DtEIvFmkn8Ze9>K)C-OsU;U-*ih9tGQzGX=HNxTO^90 z;7D($&>a5jy`>bJX_}yU;`3-+>ttR*>MolEtHj;aVybRpC-e_+8U+hrFk->=r;@w@23qE!5xng5e~8fy8~Lgy84q3K8s8Ekq0k=A9~(q zT}I`t;sXt;f5ugAQhE)aI^BMQ(p_I8G7G!&;s>KH6D%;3eOz_rDALg|UgCRS21@M? z?EZHSqSk3&RNy;7Aut}JIQenLNvy{vA!pP&vIqOds zqOTk6_ZY(4+}I3a>5LN6e~VVspHnZpH(fnHOMZs&U7KO-J6F2sD}Ib8uGs)+sUB^F z97#l8J_Mf>G4hAGrEh5pt&FL=pXQUBS?@raxx~k1b9-iXbYOt_!Rd>KR9`de+g9EV zU@U!T-h7{xgi3c>=yGflcrFkea_W#{OJG65&Aux}P3&vXyF(n{=UYq47SzJb3fI=d zqk+nts3bA|Ft)SXn|0;RS>AGfvcrzeYF zsIxTK)#xv>R5eLO?+gBnRezolihh95GPYg&lwR`2vCcSM7|%oOEL3^MQB}&p@uOeu zE`RA|kco6W;-6Gq{gX6dI|O&>;Jn)<2Iv#zFVb*a`l7$8> zFE$9$+P9(GA%viC?I2+*H}?+}nR{6YJn_Miho_VUSBfqjs0j|UdL8G?AHI?6U!^5! z@x>yg(e3;Zgj=!#w$E{-q+>|^@)x1W#LvJDD)|@?o}~XgJM|9#(`;DrX&j5S=cAWy zxKlb_zf$DvOTV}6k*A}Uf4SDzY5gu^hMi;(7T-rtQEmolYWXh!a43F2T!J~sRO%b~ zle{wZ>7z%x1+%`#jwpFYStb6kq1>pVrjTDC(D})lgVG_CQ8U}RMXaCh?O*t1)Zf?N zOIfZ(QcNw{UtiEsd)Y3NT;_yYp0*(6OhBPhHlLHzm5q zj4MCQI1=4976ncUZ5-q<_U|}*7%U7*Oz-;qiYQ>3wR&hA;HM= z;JV-xllk$%cHAeiU+eDS6LQcdf)3e{ztCmoi+0E+dc}y0=zw-Eqo`` zFtaJf`{MWS^ctMVte%*p0Nwpx+5;Mk$Ruc;Fc&{Q;<_E>|60>U??bl3bp}Dyt3-<6 zqQ@w)-nk}sl3=V^l70&?tIi(xTC2Qzi`uWZq8A4Q$LbcR)xw0F>9V{x=5AmxL)fgb z(SiXu)|qxj+rU5tRX6-2Aed7T!qNc$qxA09n}UxqlikR+5M)42oKeh8{-kY((VJJ1 zV`P=8oHv_BiAD{@6O4?us~T?T%S(ds1W@Yu?U8!;{DD9Z1z&_%OoZAyE|!p+rlzLJ zJACNT7Jg6KTDsd%{l{gC7XKV@&1`5sX3QAekB2EXT=f3A525z)9h$+rJ@(cXpP5Ux zovO?EfdcYFC+azayBh=yeYWoK$o7~O_hHn@avr}_l{r-<#K))W^0M7duP0hm&E?%I zj~#w~2g|ay)@U|#bdk{}SpH4x@&T>TuHbn)!{`oKi(H`bc~WU_6jAaQ@!?OeSnYv_-o)nL(2gRD~eJYt~z{Fc2wQ0 z5vn{`^l)}lxFp#(JFx5pDHa|9QQp*d{0?5%DH$6>@-qZP5KqsXHrp%6bJ9QPPw=ib zf6OLJVo@)TwJ_io8}V<#s2EJ z_L6IYzlE*zuaD+r)ZF3Jyrnjv#5sap3Y-Y#9ZGZLlAWyD9?-JGM%BRdHm zmKdc2zeq2V7Bl%oy<6vJQjNNi-(QD>jm?>)&0R!rhh&`m%jR}DMG@o8^GM(u8Y{)OZ4Pd17CsDEwRtrgF4dyYK)%HN4EaxG5J4T~nvD@CP%9U~s zMHVq>!wq!kFMo{=W0G>h%5R;^LWEILhIn%i9oy~9y+8EtB6&i&qx)%-u+hlBsjY-h zjGWgxvc~jY^0u)+k^3)jd~x&Z#rxY|CLLF&a^YwWuLe{@EOjorpCj7$RgCE-|9F2^ zsGXANpEGE`^SH|4;_so9dd!97*s(eEd&_pS0{dGXsN{sT8Jb&(jocMkgt^IDj z@vp3{ZEcuwQ{v176xs+Zns4mNP|Qo&^T9pJiaDR0u5?&CCD7f<;MZ8o&&m0WUVf5bxf`Q;}mH9Z!BWd35!&+I&K>fY5aeEY>O z-d~LF`+Y)hesH+WV`yZA!R6119O02`Fy4`jBme$Z(_!L6r12Zyh(HJkaRy>eG@r8I zyidzWa+q5X=C!WbFt1MVE83CgrXRCUs`A?W^FRFl*}s%K`My-U8^G=X``!@#7~Yir zZ&SLX%c=`Gk=nBV4MToLyP4#7W^xsQjuoH8^n#m$LI6B$8qd0i{ADeu!Pc9&lR)0A#>rShwLk+7kd2{dp z{0+vi$Iy6o&FMTFjA5l-%o?^eM%8lU$Pr~J(WZ1$*QQyQ`3x8ppfZy$I(>C5Z&{3e z*`qvBwow?}&-KxD22gJv;9Mc{XK2Oe7B#ct{wcdnF8`W;C|Xn}S8LU4w9!kFJ==8K zf$ZO{5@*!UV^*Nvm_v zu>_@jcc0`rx$2$PSySb)`n@P=gUG~0XmEspffnZ;&6G}7NE|>1`gd;b{d=OR^7&q$ z_IkT1CSeCdMGzn3=Au0#@Tvce+WL6|hbXaw{|%tS^r}$%pPNdcHN>czrbZrgS7xWB zz#vmduha*t1HE1^jau+qjb5QuxLR^@2hgbbwv9>tXGnk=9!7%UZIwxdW-KS&^3f>fsR`=2csUPbRu$>Zf}4B}VEAm*%XEc=V< zY~$1JqMAp{Y|L&(ADoo$AT`=DYIst1u$3+(f^^Bd_|h|_sjw{bScdH+dplxlPHOBn z{w7x)8fNv*PfPlHYRxXq91N8*UX{4DYZ*8HF+H3{L?tRJo-Kc-HC=q<>1v|-v&KGg z6TQz&F$UpP$*au6+^T>yjNt=TLzUWx>1=%wa`$k*aCte<83h~weLCF|a1$nl`}p^t zj;avqxdjPRY`019ISzR~<~D(P5Vm%_t(Hl*qI6<;lji=+c<(gt(HxYjM9%>dt`Y1o zV-K58GX#JGeNf#aJeur;`ga4zFgTG4o<2ut^^J;eyzyiPgm;LKDKPb2#_-$ntwJ~X zq8)O>_JWOP8!TWMvge!N&w^_r0d?P*19lap`Sj6|zhd}Gado6cN`jvMC-ZWtLtR%T z1?3-bfovTGPUP%tq%=W+!Vz}H{==UQMw+8JJGHNT|CkZ7Xqs;-?eT6*+CbMg=E}Ab zMp)PbLxnNmyX|1=bXu0we=v@cjfg(m4=3?j(4DdB1MW!4)s$hIlsZg>em(6#Qy}y^ z{hpOiLKi}o3K|;S)I?jJWo8l_AMkK4gxO%?{clbZ(}Se$7q9%ZdU7l6J@4vyd{s90 zzZyuj5*z)VY28965qi(jKO?K(#}8~V0knr{L%#^d|0suv0()RU`Z&$rP|71#|Hs>V zhhy3Q@xvk%kt8FdC0U7(k=?Qqk|dODN@n&dqYy>1M~GyvGP6RG9ZEJCDI;5|@~RcLssPxq%juPV zFiV?HyG}uoDQIENmtbPz2LGQkRTvHdd=jM+$OPUkSyVVdR(02yLf1mRVUjxA(;P?U zcE>*A%VRPP{`ie!_1GRZ>$_|h%4n9I3;uctGM`2c7MdmKa{W{kYFbImiH9o$EBDta<-A3(Y16#(ePqr6C%5E$XF8>yE^}lLCog;Ri ze^&FiIrF|ROaA0kwXXjseRC->^$_PpYbGY9=YOknJ(u~w*&}Fsg`Xd=ANwJZY=(s( zv7xDM=Jn$`yC5aP56dc$bZ3-HWO(z2u>7|Z!haCa)@u9?;Pe9d|Ff-PD=R+In#IUFk6FMKH-Z;F)Dl*oei!-dQ{l^{3n5lVb*k4#Yk{hvoMAsxg z`K*auoEB71rf-IGkqV*4CwMu2$1(J0xr+iUh>ni-nLiC4>kiUNmg!l8rGruN+m|cz zT-hIl#z=T+QO5^{zEW)43!(>aMBp}^r=uou#Au7^hGkkklp)+_0eiP1MhE?k@s*>h zOghS3;pN{HRF5yYk0l)E|9IlPRp;@v%a0SdrA_1RfwfpsjEH4Ve-_fd#Wd+hZY)f7 zd)aoSaMtZQ|1;eAwC z>%&Dgdg5_Rea`kv4D`S4tpWS~ze^=b!UxFZo%(aSlia=XSG_4E?r8n6 zEB4D7Xj(t2Q#rN9uDzdnD`}YPsUU9)Q}q7GA;q>0I<&~M`}#jPJW%Rle@F9lIwmI0 zDCENHFZh*D%p%qrd%)%8WgpMMIw`v}ay6X=axR{&qC0fu9=~m>73cr5cL&9pg$;Z< zVl9Qj4`g-0eCqEPHv3=Odh6pQxz)Dg&m`fGN9w>GKP<&DkI&iJJ-{Xcy^y_PJjG% zE_SyY+oa65HJ)*Y=2kqaP*{P&Oe|Z=`_*Hz(yk2jS92$=NhhomB!qo`YW5A+`cVTT z!n{Ocu&opa5)PrK<(Kvu^L?K*6$^d-dbotS=e0-GD)ZRQK21}N9VcEGdcJ8Kdu&&Z zD8EG~{*uJOvQ zpc}itFNC^}*Qm`IP$WJfS|pN5O79@(F*DiEUyK6m-Y63eYbs$6ODeEgC^UMdV zFLJa@c<)K&=w{=?yi0Rpn6Zgc7i+w!`K(FZoznPK7nRW=wlE3%(*E|f=XiL zWM3`FgAtql7SdmrO^ZhyKd!XdrrwYe74;(oHYpk-U(GMD1&QT1kV|am4>2B${S^#5 zN-T@88@27VQg}IQB*ziVWnh0yc!iQLwBAgk&#lM;12bysnLwadC4;+11H(9ubOeoYozp9xE`;?sxAi zrjWZ)kQQ-U*GP92d|OC52+`=!9J=|do!udpyAni1%2 zzS9U&T^a~GF7w0jt|KD8Qw|NKz$r3A;n3ugX04WK%8N@Tkqk~glOfTZLA*vd< zGsOStE;Cduc|14QHcqFoRk6b_5@}}#K0B7{6So1#HTf^*9vUT8KJ2q^ zGT5=#p*d6`U)o;4sf;69W)C>E{ZIFPysvXWEpm}HJ*oTH(-qqU!#!eyGjkK=qrRr* zrz6XxsEy2?S48WP{mtYnSaX-j5N!C!NK*b%*W&Pf1?&!+8rT3>b`MTFjJuO?3gl*L zPTR)}q&vh_>Sj|tPz>MQGI{b_)bzR}H2_=9l=7iDm0Mfm!^UmI3A6jVVlL9vDs4N~ zcIno14+=C4w^+J2mTr!fm7aT$BDIs8v#VC8RvfHW7K;}B>-@3N!Z*3zN|IDi>TZb8 zey%o$;s7h?`!BP0*4T^-o~`)XG2Uxv@1b>kT6Mbv4C?R%1Dqctz|qFBaz^TTJDaJW zH}qy+oY$cxJMY{fz{q;6##tLJAr6!4#a*ILn~dLD#ygm2>y?XSE6@-m4g_H0=^$QE zKhzO5KbuV z+Rz`1ewmz{Br;uK2FobZNJ(<%&K+O*&99Ny0!5v*ell0?_`MOrsy$Lw$-hz=GUC3I z;vPY^BTUn53y;um|9r}!M-gw2b>CQHD5yg`hjn(tX(r$JH$TmN#0!l=ol68X5Dr`b z+R>)xyYgE6p&iPgJ*qiv{rXFJ;LR)BXEpX7ZKR(%a?1~?@C1bqXQm|9xPqdhhhriJ zAC)`?#dg|7?RdYE&SaTU*kJX|3g4bMmYs*9jUn{|&8ab`*h_P`KV{|qbIE@Tc z&NF!}FhOSf^a-Oi#dk4+pZ<^hl-qj`D{#D2A2Bccel*>pr8&fIV5~9^8wy)?}?Sq}qAC zJ@6!TtzMn`N}5~vtb*GO``s@Ui+oP0Mj%X|V<@deh&9oRHq+T^7tA6_$-?=P0Myw!O9?peIPdAY# zJDnA)v3UJOv*S4Iv$c31W|`KOJY@On#_;@o+^MuLF{yQkEfVEdyk1CUyM>wg@_V|R zJ!uWcKX(7P14Grr42=)!`<>R&NWTYXPkJ;3UVmXK|+Sv6h~=k{FvCS0~p`6^;~FQwP-1r-(3> zPN=Hh9iCifxi}Wru0QTPM3m0;s!ccW)d&kJ6orBs`xK;|l$8{M4@2C@Bgr`7fH^_{ z3DA^;jvk>lk2sbgJ_b<+G&D4MWZ9NVPlf$N=DxtW`WctCbI}LK4_|JYW!BNuU4K)h z(M{Suyb3m@1_}UR zRHUw5M-Gu@mYQ40zO4>MR`O{PuPe7!W^h`DJP^2kW_C-ZYFUFH&qwwUrlSdFW@hyT zrd`|~w}|^C6jy6|lL-BT`#Xl+mt89fw*7ph*IFcoyVak~$83S7U(x0}t{m53qK-2$&2v|X*&$kvpS!!l*;dVp6dbWt7 zXY0_kwNU75p>2FB4}A|%(KYPzkv|xj^U|SDn* zdw}xZK)d+?{EmcxHC!qGlY<{GZ$*&+n2M(OJ>Fl>rr@P9y`n7r3X?YYj=aehPC|+2 zdcRKiXGZAo?TmOsp;8rc?^gCu6Sw?j-a3~5crOP(6kmS+#dCiH=*we8r$E#ANNVx zS>I8AJ8W=C_-9{QP)AW;3r+l_1a;35+ebD&TuB|xHAQ0B13h)dL55X0Tt2{P7&@Qa zlloz?PA+t};hvWrjXQULkR%W1NZTkl1`FN z$I!wml&G{==Krt}8z^j2R+8U1Bk3yaK}`3yiWhDl{I?OS0bnSV2C|P1C;2t~`6C4? z_K0065il7M5uvZ(@oBAflvK*%(RWcSMA;vc>~Plquo~UE(qs6ri{tju@on*U%^DuA zvFp}hmmCus_gM|K~O5 zI|JJK+k>*-`em|(OvLX7CS@$y$SiW4CsWx+S;5)*d&83$yb=Ek(mz9x+cEPuisEb> zHa=v`Is~l~##Obl?w9L$1;XZ)H7#M)Qn!$Nk+blk!!2i-BbyiM2OK&=4@$Xlk-Ngi zF|!*)u5*ISY*FGM;t_lFpX1vJ>O42YTYcw8pE!yOF%eb#{XLVcfBWXmZTWuUR;-~jc541jNoi+%T=Q3g0}LHKy5XRJ_wR*k-M}><^Og2gyBqc9>BQdP zPDzRFQ<~WfQ$^oO9;bI%fSRP-to0@oCo6aj_?v`A9cfs*N3QoYiU+N~_oT@!@~cR! zt#zp_>H*D=*x*71Tn{H2^_}s*o^+l{&b)6IS9$_OzHN4UJ>45)jFN|fqD^WSySkFs z$lSI6UJE6ge3%nzrx(ZLV_inpLS9`}tb5e(_cyIL!*D@{0FSl?^2bafA4zzXW zkRQ)xWM^z|b9mI=>3LvV*TGnaC|0+B{x@u&{=iLFXUP^i|6L@DrXmNAst$F&|&<8Pd(>I{Xq5z}#D(2y0*3 z{6$^=L)0{&CYo+ao0aTZ%oTng-yO8aixW3|3qravV&D*Q|Jif|CkHn2ds$s3FOfCo zVVqbPBl28PavITeJrAB{y|we>5P%Dky2GX&b+Gm8aP z>oTLMwH{qmYHXju})E^emvC@VjOf3DZoBg1`a0?tk)K?tB6k=9 z&`!R1BNy$2%{;+u^N<0-H;*q>#0*Nhf@#By7uuN93x_qrpHa15EL7m06t6sZ)9Nai zI&f!LNVe6&#tPwJ;50Ul?TYTad14`U=nsYL=2{z8y~MCc(7nMj(i7M@uT<1LV7xIC z=SXr&|4%@D^sXsw($Bowb&)Uq*5sQjJ81w-gNDW$B1KI?Qdy^TT3##v)hkn`02VUt zID(z&X99$W7M(w4&i*$ZSAX8FTAPT~ACtA{`QS+!|CX(+)iF*@Oy}85{KD-YG0@JB z);fwCXvLL-qY48Sc)8CjP3fAYZ09>sz9)(u+DwA#fEW`XFgxj(iXZh%CX4Ox);S`j z-CH)n9B;CvK{^fJC}C&`HXV;>8H-qVn<9DO+^4aH`+^b=-bZj{t#XW&g+yF#wA?2e zp{hG5IRVKR;WPjcR*5WCML)nUO1`=@o!m9En?AP-a(Z+){Bu53>3~>JT!9B**RkKk zUC9)oy{q2~+va6ACpS++9Qsa9aF4#{34Rf|OwZh?4MSV5t&-1_WJ!D-PR~E*h|s!W zGX3SQyHxuQOLp1O+Al%(MJ-6>sZ}ydBsNX0?TV&iS|;T7rX>V8kazYCo2DDt?9iCX zxh5H$zb~b7Xs+4xvOwhF%|!d5z#2EYDC-W}Jl6|**~sWONbVPyG(2+rz+5f2CAv#p z`GRYIXlBK=-KJq_2tJ<5CWRET0E-q>cSPO( z>3V`cZcV>#masyMK=5!L>LNE>jh-zyk@YgR`_sIPTO|kBf&cDIoEWgMJ_}t5t%e?T zSw$vePhZ&ax~+dk+(pKc!qu6llG=@Wf842$&mq6N-IbqvNg^%X5LsRo4Sp%yUTL-G z{9fZk-IA#Aj08Op2zZYg8Y+g5E-FzmZJ9qXo8qVU^TGN zzZrJUijuW5%%%;EAaedI^}w7ie`i} zF?vsd!!|`X4w28AR~H(5?E_jZ|YBj7iToyVWW4V)ByX zQdCrX?NinXB0G=hlnbwHr?xqiYNalFkMWyslGXEu_bN4uafc1nqVhW`3yu~If210; zsD6J+B*bdIKVUi7a`cFoqMlLs9y>LRcewC`k!06(xHrNW9}8d_Bubvv;5E>qMS!r* zg6ghu7kz=qZ8y`xkHX3VA{8tiuwp;=T$4aC<;<02DQhIGT^U>2Nd-%8voV<|C&jwF zf-!JZO25>92D69v{SuFvzf#=#K+6{p|<>xR`KM>TWy#G6;eN7w#_mf}r##~?6 zytN)dju;mDLCpYefxP}2+rF7~*@|USoH@rrxxr@2^%;^X5rqiHc^u%h<5Ih|E%s}RKU{gM6B99S^vhR3rZ$0; zpAyPCR7-yX%pM&Ls=onaKdrz+DUs(7n)?6%(O=FwzcQ4!ASk9!zw)W%?t9;+_F~Dz zR{}-H>%58;PR)_GS@7~s?ntXn$n$c8e#< zN5>|#yd7N(*(W-Wniq?m5AbuoMo=Q!y#CtbLyqJV6dS$8jq5Urv~Iy;>~Y(D)Evt7 zANT;9BqAfKn;lqM6nl@&3zDVl2ZkqK*+(AkIkfajFg?8cb?5X_yYqM|?`6(&Tgs{5 zksK>LqBz>YZ{r${t3)J4z!wc5I9>q6dkx%Z2%VL{1%{{?(d?PNMGjiYv%fvB1np&3 z)#z%}iNDAq}imi*zDX}uSZMWyUEHbb8;&SGt5wYk54nC94 zZwX7K%l)bS?THd>w1hQ~h`ymK+XIK+{gfVoY9+z#MR_MK<=2)SE*Mh2T*D>B*RAo~Cp9=7H;O2hoV z%q$Zb7i#I0->wus=bcfWDJc&5QaHT5>+_UH=Rha(D2&^-`6&R|3fucS(a}VvYFhiF zkbTa%!AaXXGWaSQD%i6Ljy0@Tn*AN%d=fp`*%+OWRL5H|;Ss&^BB(9uJ-49wtyn5D z8ivgIF7dka=>qLnSax`8O|dX08d;pFtg+9_3R~I9_rzj4HZ@UWgp=tb=e?k(5mE4# zfEogtRq*2Ge|@=KH)8WI;Q^iPot6hmtS9x)zvrD*Jx;4+%5an4wC0b4=W9Iy75+T< zXu#j*;1igZKp8J^?M*Pc9^mKz>5!ZHp5nCKkzOq0>cJM`MCLDmY(i|N)KrRqL&E3~ z%>&jh-(A)04|Q7D_I7S-+25wUGaPo3dW%CckbU%V~}3FfO^E6LmWBA-v2jF}Z_PCeT%R@*;(%SXm@Dz8zA;eBWA z!(Oqu#{R-(X-y8DUB&?{?g5pu9@i#39u?NlSo!2sWlF2Zt&gYVg>Gs76Vuzn6PHq( zadnEbsDpQKXWa=FX$daTo|i&RD|hIx%bEiq>qFOp28sesD5_lcTvY2il`4F_iw2Ed z&0D`S+QfY+t7R*chF=^APg(n@?Bl(V)qVK&Q=XHM0oC8octTa+8(n*X|42_@ocY(k z#^T=RjU6_ZHX2$RYy_WD%WWN$PpW&A{!H%2azab7q3J{O!yQt+FD7^9-sWX5BmZ4j!9QY&{=w^qi zWYxLrAxn){Ble@%!(qaDphX^MJas-|Z<$g-2aT7=YX67GuXBG`5iMRHuV%f4x+5=M z(2twk6Y*`ux@SNzIr#X~*Nyka$3an!PMw5wY5U?E&5ZB5=S)|4emoZJeTj_)klEwW zPpB-)Cd%2xWTkNTBW(J~p`#JXkl#@D&2bz1^E^zc&ij-XaaZ!YbL;M|drG$jLRlh` zZ->OUermTn=cP86tR1%G5_PLy{n;gxYS0QHA|cXoKv5x38YJd9exH;MJcg^vKdThaSCdXMoG}_4~Jl%d+GrKIt;!b9SRonQ@skY_PqV;?|0qRo~ z;4p_L=*n6ZME>)$#M!)+)W;`{4)Vdy2{0)Zx-VaQ;LSYY$gJ(tuDnY5FB}PuSH{Pq zeX73949^oVeL6|CT*F&=o3N*)5$C?`*DhlWaeXtbaCA)jY}WYW2+B`^WVLPn3pLx& zXu~RquwjM;3k1|1iU~6x$$tyRt&nfNY;54<+s(ruZ8-+q@}j8hXz zNx%N-)35bo@4T}zS~R0$;>f?pTN)eDjT^Oh30bi3Us;T!T`aTQBJq8Fy<0(C;1~6S z=)m83T2h&dy6kl?qp&sxbEEU@?-KFdq#j{hKWvlq!_)Sxyp&Hr_Sle0XKv&5^i^IV~&+gX7?BXmB(_wgUdU$c|ExQY& zGkrKo$jQ=e;au&aCkI|W$!^Wg+;vH$a z}^_{NfXc}mvi+(r)>Q7c7`}TzYqW!Q26$Pw^2-Y$_{>>BkNWUuHbPK~N z01Ogw1gdVBRn1(D53nl!@HC!JkYU~rgg{Z>FE61d!hso;_|BB-MMJq zJ-*M(E+?Qo!UGM_V<^Owq zbmG(|y-k!Zc=yy|pzHhbO7EI%=9*M>(qU^3;f$vP+}YV(1+B}{pO~c$y7PbBDKEH# z*ad*l|Cz3Smw%fl)alk}F!*qzVRgS%kXxT;?_NqZ*N`dcMk+)bfvpADhR`r$cfGo9 zzyX3SvW3V=$}8TlOCJf9eNZ{CLmDrT05%4+S5V7i@-@g68~#mVP{x4|N-S~D{H1Z0 zSX(la@=EXW!LRtwQhE1*^IPC?Kzs)?%i}TbJ`PSc3MkI7-Pnci8Z5?x-v_K$y!jC2 zJy&-5FL5O5eeEMxYWHX%f3E*~tiiCqWp7H1Lpskp^su?L>!OLFZZP=q>zzStG6BGV zKnj^ezK&FTNjrD@fs7P6>Zy(X%1VPdx!J+O9Y>wAFk%oMHbemLKfmPnLq#Jd%O0>- zhL0mGthF;8uYXl!O{i$Jy}`){fFDxlT~>YHn2+`s$q9SCF3^*3hDRMCx><0QpEvnt zbw`rDbl?Bqp&1s8c)`^p>2!M#5lvuOO!0(1A@**+yTtD|E<3eJH#luOZTVSGv!*}*s^RYi4tza_0Vz(*XM#}!lO$uG8U1@)gbjK43Z4Tr2G_KEfx?MO@ zOu0`b2{|_;#|B0@%QZ+&vW09(RsawS(`twUvNg(&0h^@zp~$#JaDP$p)n?dXcFMTu z|Ft?Z2uo*Zil89Do{#L<{UPjme`1@$4jJ&})Vgr~{1)etK7k13a(-RQfFgB?dE*MK7(QVO zg?9mG2qmD~(os$#i5wh%^u&06F)6}83>TCTIOg^`m9FvVIkEwCxF3XU_;(&NGr)5} zsKJ1R$_)1|JVP#A9GOPHf^+e-OPDgRFL7@Dc!lY1%8mZ3@l4|DWA>WjR%6AH#f}W- zeP5ezF5Rnz6WytVie`;0EO;q*OkwYk&78N8(e%L z7IT^W_r}9fy%V%M?fVUi*D`xWSGMmZov_t9?Z~XYxxv{un`O&RJNg&K5FkU7`H#HF z$y~AZ*Me#hZLLY5sLN#((-%7=mGC{l#)gFMcud9>TN2e4wCPm#dS0QY{h&h&nH1#W zmNilaWqta^AAj+9}gWH085YLxR&W!JBO6 zAGa{i3((<#OfR{q|rxgOrXd8=i=l{|`YqygP73QKAzzl^I(8yv|2x&TTR~ zp}cRA%epO{r_Gpoi7HZ!vi)v-@Hrg|%f900)OAxv#eUZHr^TcxIc3yWVJVBd1g8-R zVPgPl@BQ?P8A-n;;LQ2yk3;vm`x~D&$EVdALc!OaAN5*>&@_%!>^94?iSt|K)!6`_ zh#<2Ok&y6ocKeB6TNOhTrkxeo$n`C4R-I z{??taWq3DHDd>5Do}!MrFIz!gTvfP8li$B|^sHZYix>n{|P$Y?J}E7iQY;uYKk`<>t7w7}6(wd+adILjs0G zk4_l2n3`v@C_(4=22*y|RBD=*m=0 zv3=x1#+wy3}--dcMQV9xLLqQ-(Hc+8>f-R00?tU!b zaGT+CBB(YYX!D!1OtbWza{XO@f4ge07{3{}y)v0gwX_;-!0z!O^%jL0JFL@`rR*#7 zhAAS}3uSTxT-HMDXzg#ebEIx41di3F2At*6xF0JhabqHmh3hqU?9^wDb5V;rr20%p zNep@J z;&st1#c1sn(f4jHd*nlD?X9oGJ+Kjf zMRKg#s%IJ_i~0ISY<8rUXe2GV)!mq_ZjQ5^ID$Z|UAW>nYruel-bh}GqY)r5x-IA~ zu2u&KZ3Y&FZE^c<`@@U?)dLz%2ubRmf*fZT*Ff)w>o6t;7&bqD)-7&0+cD-Z;33Upf66}P)6IGj3OGwX z*=@#SpSj-apE2R__{%BMR~+{6t4b}YtSxG+Q7p?Al4&VxC~|O=ciW&#+s`SU^oRWu zduaPT2xad<5D$cuSoNl8fN+hUt8(QNwCHdMsFjA^>mJh^J>l6&yHZ#o!X?ILLR zSnEZdg-*{|O8;S*>QVBth=w6_9RiV!X$NAJ$@c`<9(VdI-uUAV@H~Q81{agy5~1Z! z^8tf&uIeS*O5~ueB^)x$MX<;Ng`cuk5D3zLf>YE{Wa&c9%TeMl!4*^Dq8S_eKq=HH zhNGx5t4GO=!un+vsYJ+=gZ8cX%!KzKaeKl~4LoGnaTC@zpluwa+xAW;O_K-vSKw^K zA{3b8>grf1e%d+LP%a(*pylHY7V+yFo_H4wI&eqRF!c_nafu!rhOa*O;W!4dn}cum zgT}jtT4gnuCI}MRxlj(o^wKcfh;T-Cf>40Nm7v)Xq)rk}HkG>Y?6S+++5`&%=1Y%g zj=!ul=Oi5%u~BsQ*FL(>HzT~T-AW}OX!NH_A%lhcw3 zKdpPzP$FX5Foi89p-S7gx!OoDXAjf(8KwG3SP2sT)Yuv022N%}3b^}n_hmvnfasa| z)deFI5=AL)fCAQ+3FE)c&M=Wl9tNs%5vxqE()M%bNBeHq9iQw^-F}*cEU<*LRi_#$Xw8!JPE zI}UQv0Yf84HHw3MR;zuT3*RSyOO@Ac-dp;01L89{b=Z{CCu{E@NV zo}PIzuSGHEzkk-e#cZD>gg-9nZy7qj(rO^~a?>-4vNPw-@wU1VL0n7JJm7p4s`%o1 z4(W4fKdsW{5Mg~h)D;uW_#}-|q5Mn0Lsq{&mn~wsP$JQdCaFArPfLCa>qGi7lpEaG z3JgnY?l)S%d%`6k?ARb%j`pS6Q@UGHy0c;A*}!8QXyAyw=eW4Amy7L)29E?4ZHjrc zKS`xG1m?%hKU6+^e@LkeCVM+}L^g~5>R$<0uIp;Mbw=u>Qi)!U&v&j@EvAYPfd@7E zlE!b^$=-0ez4vtgO!UBitku&cC)sGxEq@*o=a6a>zj*K*{oCiw(Py-$JioRqGSgEO zt>0asxNftngQ_dv?AE1eW*V_)C=F-<@Hl`E`jo<`>|=knZ>fLJcb%gly=iHfoe{BC ze*?c+*tK{0f|azcwxKUohdtYa*EPbcm)60QBkZhgkfJ~^aA6q_f1g4JaHYPC5gGJ{ zQhQX+Sb|_RSFuP7vt8@{5+8!YsUS77(lsq&R~lDRvQ+VzI__c$7bp988Kv|ct@gld z7W&ailxAF5Oqo(#xNuN85YCNw3q*6$m7aCkOktyB+-OgTyJyhFX{YPaE234>XfyZB zd$5@dqY>eq2ObdwTYz7oaDd5~ZBU{K{s+e?k|&x-NgKunK2xI`McpUvI;=iXiwP_c zH33f~{wV(3bVY{rizU*=G272wNL+pkAc63>n(56A`q1>%uHXnXyST>z*b?U>Aw!&8 zeEMuc!!VVU-8otTNl^73^3UG+kW%=i4c=TWynO3Uiy9kOdrHR(Zbqqu+W1K!!?Is2 z$2x)#x$!_Qz5Wx>>jBjnjn@~8-gn9JoR}B)eM&KO4Y3)ot2S;C{^8)L67$2f^Wjm)jX9_4=#2Ituhjae^EOsNR;b+Q%o4&O6@xd#X95IiO35hqXw@d*5i z7l@Ece#Wot1u{~n8l)1|m9n*Wk3BRPhWd95JkUMIjX^@AQ-K>RtX{D3lv)2S%n(%n z>{*0{-~O`)+m~C^>ApSe|I=anBt@aTblS5wpXTrR@}`|Lzl9=b%Nmvx(nK@tX`9&F zU9#DzGlfnD4VOHkgRZdt>$|=cuI7P1Z~n513H|U8vX^j?($^obzU=$afIY|HOw>pk zoMY@e`EADWt&wNw2WUNNVTh~iC$kNkGw$#0<9l*qN8iOuxxLR{kyk2nE$Ji{OL+9H zsH~h=F=Q8bt^r&C8{a!D5kTvZR|&suaW&oH@RS+`xv~W^A8+Gd=AY{-11~8z>N{I- zMvRIm?kCCOdly}`v-$GA6Ff`)Z%Zx##6gpZ)71QZ*<@MwS!3M|?co)jCu#p_T~uNq z?LFa%@es`s$?2f$Vzex8lf$TiaYKX(95+^gN3UUhOzs z1wuQQp6D5f`2vNW7%`A!J#F54tJPzmqq*TPNJj*l8(%ioF4&L3bOH`_Fp$OQg1nT| zHihwGD+hD7(^n|HOw)9OWjJvNqcRYzbV5%ReX)$`K6+vp>YSXbxCbEswmL+!YGPv2 zTh6wp?K(f{fa(Lm;`5$qV#|h&7KgnzC+{LYLO~%K(P+5NIx}fJSmgieFAEtJpBOfEQ6wALUqD-(+o zb`WFXPxf{IQRS~*ouF&{x@LamTj}OY1|Jr3q)TCmN+@BKnB0h?Pp)lpk#JB!9dMGn z!6v)~mIKV(4*8JCz@Te4QJM*zwSJi|;R-A=1%8PXEjTSi3YozuP-%P8Rnk@{FN(SleJ2H+JrHHRQcg_?e+bg*siGdxuEr zGr5DT-B}ckzaHRb2RP@wb(!~6`pw5K&5yQ4=ut6|jQ;F?_&~&k!I@_~q?6^FRDfJo z$pPIaPK!c#S$)2FFtVA5AHuc5T8!T=ZSL3lhW_B0fwNkTJ-2jDU2Slc?KvR9tB1~> z*Q3ChS=xhB#Qxfr{b$)ud4i!^@UlqE&)S2XDy!QPsZs=3NK?_^^LYH(40Ex;Qkh-I zV6{(VkUkTAM`G;obs=q-`1%oLtTp~*vINMEEb4Ex;;-hAS4Q8xUN#|`{~lB^Qzv{c z=tS|tLDY0nm6QJ9TSQ*Nm<~WEZU()?wr7pACGE3cZEwXHyLa*}ltUpzSPc?u1elc( z#xeu$mTw6kwa8{1H-xG;I6z=n?m!JN;#nAt5&#WR)6rjLkbe4cXJKjjB4LvONg%WacuBo*OV{qP51u2Xk^f40Jine?JcnHemWX$|=ShMcB;ZxH~v~&tVxdmVe@4 zzf+C@K=ejirS5-qW30(fIk*SU>&iM|z!Nk^a6hEH{;~lA#bJm&7A_l@rO5Dl>^S2f zN$f$~S4RTCW*8kn@q)E22SR0C#a>|9$(MYEWJ4v$JK06t&hGhwGOcz=Bs8-v* zu+l+mgB6`JBbmhEB@#jD$DB5UlqNe#Kwtf{F|;WSC!gIYGLRtKaPwF*Fkdlb$9wF4Vvx~g5j6VJmwdQ6?#vD1;aL85siWata=ILmlS!jK_0;q^r={la!D6?^vPISa z3UQVir{DvFSP$=YOoW=J594-nbNdpu)tpzPv0kYpvQ!5<1%wHB&fnWNJhZv)B`f!< zeeO-Sr6GV8ED`W~*WtmT#>z*ZV8S6F3T)wd zd{F>yB_=aVMl4L6;5G)CZYP_s_BD98gTDz{+rn$F_1DDHj1Y($D(ILYd4=MDO!-J` zAhC)oW81o;GT!O3P_GmCw2#h!D-L}rWJU{4UMo(-d~~M6j6cqey-pbz3t_o7xA}LD zFgC+v4||tUzcTnLX>qvinOyZ8=BWRbYFrRrC2x{=p!8pqjC7J#bdpI6v#ZG7JuU>i z1iv0z`|Is9DnS!^2B;|HD2A-o%N0s#4&U%uZ+?n zqlGLlK8mSz)cGWLb@{i6#(Z8wdB~TUb>T#nWA8L}9cUmAIec^x+8mrahH_S~8I3-F zSBq@^`u1MUljCKD&TPdu?4_1IS?mm?Xw+(KxmN$M6$*jJitqekR&;o_Wl4sL8C6VA z;0WuUD|0cCg29Te2KtkYJ`>^Ug7$442e=ruZzw9=J4@AN&BBEkk1*HFf%)9yvc|`z zCWQH!>-rc~%}gHi{dJ4d-QQP8t>a|XRRAk%70aX2jSickyAK_zUpUKBH8!5oEu#8j z?(p?u)_Zr6CIWP3!W$cK4HK5QGxN^T>? z&AZ76#@#nc!(-C%MKJ2d3a&KpFptRiN(@5_{;%`DuQz zJQFX&!qKt;szz7zvuU|au)q|BVRZB$B>&+46SjNk zr4Njv77(9eIUGPKUj`9vtZNwWME_V zYI;n^*xTY1C7W?-C>T))33LnnJ=hUgh-!Xw(&_1XAxQ6&BW6}6t)sHG-}vxG*!jql zxu?!YeX;gr%^xrig_{M=lqZ?{+}u1 z^@*G%hC+>h&|20fZhTJMZlUZXKE`ZPc!hw~+^{ zArY=p8~|AWH~_xe&SyJxeSs&l^n#2!khP_yCAp&kh}*!nP>Wae5vjQ4>-86d`4K^BUzNx^*hOMD1%gKB^&runl`^Iu9?t^Q7d=%!E4av$-G+5nqSxP28-E?) zg#P=sBRZr&aken?$H;LV6|-r{F$uM?6tBL1U>7aJGo>TJhFwSNJKc1vr)tEGM1~|r zrHb=KZIv9*JKe~($l-fDFJ ztPQ)ep>m{Sseu*?#Wt^`gu8O*yK^IZQ%)wju}4g5 z+|YTqz&*(_xt3k+aqn=c(ze4c50@F0pNDPht(@JHXT8?4-2Tshm6-QoKZh|El6+3d zzbK%F#lroHrGjeM?_8_$WGA5rTTqfiMAT>?vPXYj&zh~@(tYX0YPIBv_vZuex??_t z@CzDb!r~js&Y~IWt)yhN^3=O6FY5+De-hS{GS?)P;CEqFVJ%FF`K1;wZdSaGyR2sI zkeFI0<+_~IRY#AgUn2Ima%B*mbTt&El&*0XqhK6|hk&@6n@blqeL*rO9C^Tg*(O() zWf$U;V|)jPLB+2=tAkln4=w(sYSxxb+|AI=%#AxK4wJC9%|C4mm2)0Dfl@ln_V4l+ zov*bo0{qS+sY`cJ=uY{-KNGIeV}D6e(8HeAkx=yPbJ-az@y62V7CBbBfcs?E!ewi! z*2Ff?4*E>AO??#3CRthcxN-q+3FhR#1wT+p97!5GL~>zNZ3NLRsz85z%ANAinaYru ztywiCrT_UAgM2SAB4;Y|<3D#3IHjL~cMtv70P>Xu+~0(IE(Dx<>wuU}!D7$>Jv$*ms=W{!`dcypWp61zOu_9G3Keyod;I_q8Dv+ z$jt$i5hj#Qj5pe2jvr;Xl`%zo-B=-}mvVpO;+ZKo(*5tLz20p#wa&HZp6c&Z^1WjQ zzfL`T?fX1e5Bz5!Bv^ee={Z(!#H|9Rp*wuU2vF?If#ZCyXv(>aM$t5(>LJn*^4v%7 zP5OsFZGZ5UWxCJ3+ZTp$4Q_Ll0ad>|MuMpcK zxPKa9d!#F2HRIlYWgm3AAMc2Fhy-0^@-hq&|I#@9AX9(5@Ap_*^4Nq_fL$(`_y{y_&D+t9}6yY~%T2#$1<;>b9ncAI)n20SV7f)5BX=iFtE<&P?{ zHEY}x7$iI$(|`5YGzGb;@_Ux zbU({KO8L33S+z%Oydah{CF71SdW|!#mVQR^!)DLi%5%<}@Ct`m2RMgAR0{t`|I}YH zp}TPfq23}9RHspGY(-cUX1~0_Xn{JWuc&S^eWzI1z%k&4QC|+jsg|-_pk# zv1I!>UtwnIZYipMp7-qRS!(^l9z;HYCQI~lO+IRz^q3zsmlA`n+Hd6&qHSvWfi$w2 zo}(4GbBM?LhyZGGA-?{&~LV-v^%za>c2#hU&EiChe(d>Dy#^vCkPr>vWP$ZoFP9zAyg$p=Hbn`v4nGG(X4<&)-kFiu+iz0~i40NCXO7NR*@+wFp9-^W4$`!K4mKYn!Yah><#lUmq&4bL#xrE&w zbWf6AGMFqd%Td*Vf6(;i61EgQe%h~8S>)#O*IXcR!af@`Pb5gdPX&x5ELjnNN%70s z|E5xK+!V7b9Pk7`QH9@CW%Aihac}hL9HfQ%Le^^3-qy0WSi0C%UKMiH3H{A^;8@4+ zm?=WGAz>Ic!u=_OCY&0NAM$FjTR=c0CGT?~-|JzEA(}FaoJpU@;LSi_@Q;xX3iCtl zZJ{8|YX0B_SrrN}Vm)qh(?OYXpxpg3tZtkqB)$iS8pgDh6ve;yHx(TIxu^v>ikRtHbwp&S&5DQ0a+H z*u?4-W5?=LN+?n2AXzsT`|5%fW+RTG1sGiEbn>2Wj#=lZ^Nq<F!*eRB z_N97&ZXxp9YpSzy&CfBa4^H!_NyN8$^g@&C7^4Bg5_sLVhr%?Iz@5`1^Uj`WnkQV4m zob-<^FKB&#u_`olEq%-RKAn)g?#IgBlx+{MKI?SoB8igZ60)@t6C-W>4Jcj5I@Y@C zUd}~-<}uTF!N#cNDj}QQKOXapgEoKwhm~TJ&p6}jEF+fklCdkwsrkzLRUVEBsO z9l#TIe7pGfvaif}x|9E{Qc+=^d_2z;j`G&YaG3r<5?r3@As=aW!vSAA*Xanlm<&Me z@eune;khpkiB@Yhn=>DB!`+Xe92I31%XR0M5Vh2v-pZjbGUS+WYmNBhJ%>QmQC9Wc z{s-IxtPF~ddB~8Eu|{^+cI4X?EEivbRR`_?X}g{99Ei>Rv+az$OO7b!@zW z9t8_eQZ%3V`CID|0C|XR1M8EGx#OG+TSa6-crJE{l+b?K#tDZYSOsBT;<-E^vkd=Y zEDOq|E^-z@w@9pg4&FH2ZZXh)v3h0ej$9two*HRCc8+KdLr1oO5|p&n%&Omfe^wi1 zIdnF^k2*eL5HpAjeB0m8Ht4>1{(v5OkNc4`{B%sA2jBTbPPbuhA>19_Y;MdErooxH zZ)&UlG*@k7^2xU|m5xw83@Q}%eK?JI`s#A--F*K3V*!y}gMl?HFz|zRXM4Seh^%t% z9y>O*+Lj!lFx}ahh#Yc~qr4uKz@;kHzH}CYdvr^0uxDU&4@dk|=VZV&Fwf2JGgVZH&n_!qdWa;y@`+cBMxf))PyGVMAb1M1lI{UuR#)Y1% zw}1T9`({LIkK8UlbQ>t^O51E;#+PC8tPq3hUYih!qp8?c&6Fo_Qnxz!&41tH*y_2;Hgw z1WR(^nzx?Bs1mYb@iE1 zisldt{`IE6Ul_g>X;1y^6!07jl_(Xx(#9zR0E}4cYPPMGwz5N?MPi_Owv3DALT;@y87ePtmK+)Q$S8{K{a8o!Cyi!QYjt zP~xd0#66>S@gqOP%RiLwmjE$a~eCDIuh&!@kX5(U~$BKDYnS z^z-9}X?EZdo0Mdmq$IQN_Y*a)>m1FgGr!=@6U=hl`u}0=tAo1CziF2Io zIP@L<@N`X4(063DJeJc!=qT$n4qq$c>rYw*XA+G+$@d2m(Vu1+@L8Js^VwEJh9)Wh980}5d8)=m z{bv@Eh)1q;8acauoZKjfA{~<@mHwwqb~bjck2{c^2x!D4p`a{5QT~Xfa;K6zrzsw= z95Cg;d@*}N{otZ?kpEVU^^4Z52;zOX!g(N?31QB-xPw0~WVSp^(Dn2p*snj8^0(An z^k)wkXfb;yZiIG~eRdo|0SvJO>3`%Yy>7QyGub=#K~A-qnKYsgw_}1!-Ej^e?u4#S z_?DHhGmlk!z?D!yja)=HCNeFy!FnC`JOE5EbzTJ03*qAhPqL<;JK-fybmzl`M@|+@ zXaxU^vIj_MlTnuJPW`q2Ag|uKQa9h5Cm&`4RX)_*a9zUPfhnDi8_%ty5)FZo-)3eW zGRDP(hp6kUqCHGb{rHZ>{xc<#>*RM1cRoFw{MWhyAn0hU3%q!x1E})={f1g#X^+?N zLp+o8lTo?Z@Q+;FH7s(%gSjuAb@wgS97S=i0ht)FD3C5U(A6csJ`7e_0MI~v8`>h> z3x)GP05M_4cSVLdhBu81S8I1F#w>{~f6<5>V(UHE_3tRpSl<>nV&EOCg~~HZ;^aC4 zNx_H$30=`o>$h;PK9}esqjtL&Wx5^JCv6#FO#RPf39rJ7N~gHTo6AStzW^`1Gvujy zekUNYz*&Sejop(?8~Z8``Cl^u9=AtQtyuT$hHD!d#DCoQ;k=)x6Mw|ZM4b89_LwQ~ zT;O>lC96(~j`Y>g)Zn=`W%ro5w`(_ywb-0)eh6Rp<~4{ocp81Z^ZVZ%J+$!qk0`om zVX7z%jv^-SE{qE)Y(=>&(`=O!KcAd`5WYZ;dB z`5x0H?Xmb8ocoi^qtQ*e3Q@&I_0L#I1pnc(Vhg4hHcXYy48)bk%cZ=`)$`xB6yNh5 z?mqyJ5r8$Vm3jjoz%7f&4T!Y4N`N)Yv4Gp)K(=25i3~tX04y)}$17syKF>zL0AR(M zp0Y{?(?OjGBQBUdGiShP2s!z`e@}^4ncflr@(oy>Al z1$^81$3PCcyYS%bm*xEjFy{p~vGVeA2RfP;C?^PO$&m031*2Wq5RT^?L^BX&JSXA1 zt-ekEzTmZP;Dcibmjz?FZ%}I^{4nUJ!1WZ#XY9J!(3zYdBx)`|5rJ-q0u2u(8S@Z-!nan?&|LBAS(nm59>S6?S^_Bv*mvGp`C zGBJs>g`I=&z8%mpw_BvZ2MNa%tOP9yTx(EN0fYjE8A`%Wsg0I*z%xw3e!ekceSJOK z(W7HvUC|FhR^X}SYBzhnS{EKRWc@tNVXX+?;0wG%#9IwSl4x|s%s=yyMXUc`0_X%qx!%7vhG9Af z!V2ktQSe<1xyeQ}!&oO*GMsPeKV4DTxLa1z#f;hQCftZo9FTP2TtPzcfJ^1K>h5<9 ziOsM`stjCE`I8PqN^W3r!5jfeP{9cV=$3x}?#=62v-V1l-znztjNs8X40JT?M9~w> zx-9JFuV>^-E-H=YURUwRDl&MVzvoO?=~2I~!Dq^Y!g;L~9=Hm@l(8c@{K8u&K-I>q zAl|ah3QJPNn9WQnm%9@tZ1Mg^?QvJ&Q)lu<-h2=4xPS!$n@@Jhr(jbIl5R}0V)ZN~ zL!KK;bR;6Zn3Ohg>cn4(JcK0cO z0CaxW-nz<_G~t=#1EW-6K!a=9*Hx{Hi!m67X+td`mb-8EunAnn*8UoZrpK} zz~H3x0cCiBTnm+B)t9ij{X?D2Xd?(47CSU7W6GEUd_;#G3k`;jm`D7qR(G9DuGTWj z>T(+-Q)EqrqG2U{?&Cc;J^$jeP6)+p9*zdokx6ucrHsnu(-dV&9l}>Dk|jF&!_P-q z9CYQJw!-q@oXFe5>#=uRnEW&4!E1Z5=oT(2jF3LxTaVs!KgXT z{Xsi8Od<1jWC=iH9>~55wK?FUz(Ikj9NzUk_~`)mZ{BiKvfC5$dKihh^_3y!6T-B- z=ao@e$Pjq>pFSGozEKbz2xOc&?sOV2n$=pYBS(_EixPcEk{cJz`6*8sTzvjgkrQR;b=PX07cd=CWupz|08n<3*dCNcU`unTS zV9USZsQhen57;f7fxt&xL5u07FCB8`4#6<6?P_&e5=MatC{Ws%t~KE6_fXR25aqm} zE22ejGr_8$Gm3Wc@+|Z66;NT|`+XDWNs~?9z@EDVE)ivud*H$Wvu>n}pZNjB%uJQ? z)hl$icpe36_W|;PTt^Q^_J2;&cYLlv{R}5q%qc*i0DgW&5HjHQBGGbiD`s?kY#c@O zPi)-4?Df5}{mAQnZdiu24^-Gqf7>~cz^fqWKN8(Ca(d>HT-2sFN{E9^j}Ux=H=O{$KT!CuyglXX)kU91c|<@@g+$5Hh`933Y@Kf z53woI_$6b@r#S{ynHt_{z+mg zpkzTGx5di7rVTmA?q}HR{9w4up4_kL3;X2v|b)o8=!imvgs;68{XmV%M*^XFg?1Bz3e zn0`ex^&dmxIs0Rt93?;2ga&i5!67Mg{{!8$2uy*tKF`bYQB;fFCuYt!jaSSI=>IJy zUDvfPJvMXIS0D6~1YKN_UFEh8>2M+g8}ms*UH|Gn!mxn4lt8ohynJYLr?}}cYeuH; zpXArOE<2c&qf<@w|ArLi%-Y{2!r8*9UK7D9!w>?qb7DBq0k8i_7}aj_vw>SzZo_ST!L`5 zL%RuuZdh+(F8kI*?oY{ul5UDKWlkNAHhybULhc>~F#rG%16|1Z25tvQZemrC0`zN6 znC;XZfuoh-9tIp=lK;pjf$Mfl>mAq_pR3^UOPdRgmQ|yh=^^au!2WVAHh;GJ?rC*mjo^lq$ zTL*hb-IVG|R}7zJ_DW94BHVS`%#fH)iQ{Yn2{`YDKXA<`un#ZmVT=DgF?UcOV#ryH zup>0pdZ$T1zms@XL?_9}-{^e_I4iSAwAyl4_qwE7SJIW4&mDcps=hxrYK{9KxD_2t zEntKRXOf=4b-;x*ykZKTD=!LfozjwiWLl?}#C5W^Rw$PBVRQQX~!z`o#cG zy{4+dkU7OK@K-{lH!zyN+3O1ieo(ITEdT!2xthC@uJt!=a^kl9_T%Eg7T?U%j&cmm zvr-6DhGO(#DGVb*>}p)rW65snm9F`w9vwotfS4*FH3UL`)F^N<+w?5k`PE)PK`c8# zkj`ygs{+v;ZHzP9q#SAx1*&@VS5qT7t68Dy_o*Cu#1A^Do(}27N(_ZPxZ#V+pTX=wPcl z0BbUtiQ@bs>?O!$ltd;P`QvML%u!EDn{ z2ltXAq@h{^dJ{521*O5!ygw~6U8cddTR%Qt&CJxn>Qm?w-TFT9tjcxp`u3Fa15+(k zzX5>))KTvukPwj+wEFWu(}-=g!vY4hihKtnj*gErtVZ^sJKjYYQ=QPpz20#^O}12A zsdWoX!p!IANjJ5KJh&F%A98|3*|Q(b!=)z*YU<0z(gW+K7%i4OA2-R8N29jWdf&&j}ifAZ_udBU>~z@ zI!yOix-|d8uBx~A_N;$9x_`%jiyIG`vw6e_jH8xIpW0kSYbWQn}py;ZV z4tLIR@+Z~9-cO1~qh_BBcVx74V0MBqUVw}TFqTO+6CpMnp}=el@vS(exGL6*wef}i z!HpSq{>6;Tl*831+%4If%Zg!t{bpT8skf2;SXXOAUb5eZv_`V^3UIX$;M zt)R$95Z7f)xH-`QRRj@h-O}c;6#CMh2jroH91THA5%xVmz0u{5p)UmQN*LTnMt;w6 zdwaO*Ak-#_K^IuAic6ICv8{iX@d(|^0(drNLMs2J%PV{sD8|}=Y?}6|WhdacDr&cY z^RKlHN)`pS@W4$2RdVhE3IZPhjLJKna16&*c`J!pRo|Ku=d^Ux}BdO zOsEXet==)C3e#GEmXURikTM4yJD;9$<2$w;t+L>v?kD9A@&OTMd8bq;tKck0QUDPi z7O*33#-f02_mvq+e1ruWG^8&12y~`I?LYW%$A4*gzj`RNRinfh_w!yRq#L(~k>;hm z-yTs2D8-HI@9Tr&S6(D_eQ#*O4<1vQ|G6z~`F(#aOMo$pSWGwU5 zUY^SlTUGp~>2x6rr`I}o`i-%fz>Vz!kzSe4i2?>YVusq(<^n_|roIxa{4?)y12Mpy z71YxQ?*^BhI=xiclATlFb~iFIy0-g{F03Hp;M5nXW}ZD$7>)N3!$&i@QMIAPOcbkP zv>He7s^HN2s#M*AtA6x&AWRWJ9ESAmaKFQ>bEd&t`?rj+u}*Rk02^=tb*rFhbTt9O z0ZjWFDTR6`1dC+;=Z|1xF|t7`U_3IXIi0rDi|1C zzJP-@_v(B=i1R5RoOtl_4jk{Wg};wgG?h$wT9Wliy^A)ZDf^VqvSh9D7!!isI)MBQ zVv7ox^g=vz7U%|UD#^%9tJ!-=rxeUZkUXgC(;xFpAWte!V&;3 z;{8#KbH3SM6i_5W)I-OU=M4<^%<^k~1DC@ThQ%;b0gft30N*e2FF{GcDy=W)9{e!R zQ!Mfpd8R{-^}Y2N#*I+bwE`>;@oYLqMsna?0n8Q{hl`2M?f^UqJjsOP4OSeNXCF2OJm2rpL^2Gy4$b%Ue(llsoeo9C z;-(8MXjr-s5Diprut|tD?8_I*Sz6QSemUA!aYclKQ?H4!=uy)T=okP^3!jFT#G;Bt z`3QOpV9%TJ2uBazz#}nP=;bs0Hj~>`y!6nRyaNU!$hJDUdEf6$=fqAk!%Bb_g5|QR3!vhiN_0jb40Og2;e-bG; zLkPyUU0fMa1x1sa@NqB@@PNE_B$?+YSmfSm>$hM9Rm;ET43w}rVkyw;!=uU{6VGxK z&jS_>YS$%a(7B@;wH(Qd{$$Iwe3@zx!8397Gt9&gr-{N%o$SM076)M*NJWrK0Qu>c zUPo^DsVIN7a3}oH0h1_DxFRO)3y|TS9UTmME8_k};P3zxw*aUfgx*TP>D57qCGtU9 z$R>?sG5ud29aLtO#e?YeKcfD{>yQgrai)A9JsN}g1;4+QMsxJt2wI#+Mc!j`%Cl2o zF9S^{xL6>(TqB=7L^A^SU2eAl*J`ym>E2JX28IPD_1G~HUH;n@n*AMhh9Ki zF-eX?*Daf5a08kj$cO`ni<*k|+g#^zP#V{_Sb1j8uemmbFPcYrRpR%O43*xSxX!fh z2>d{xC&D0=Bo)iR#^tl~aQd=KfdWSI7Q1_aprU=&p_f6*Bd#m_1AF&x1UOSr7JlMO zerKzaBFn)M=e!TsbG=yLq1RCrFrPQTQ?6CBch=Z zhq{DCnLkuwWFVLYv87i{l2cDTJJumc>0}V2KFpAP@$a zH6Uk$STOpA7qekNzt-8cz?ByG48vC-$KEmf)>y7rVggV-64SKpO6?A)<;Xeo<=NnM zq{ALs*&Gq`y%Hu?mJ`B1>S?KaC)=NWd`i`x@BFR1DziOzr?(K7sG9|dQt%`YEgizI zzAe~c!i@xX+uPeu`XWB~pbg}JWwF~%Y6M0PJ5IN0uC;z4DZ}}e9a^yuSQ>WAkwQS1Wpsc&eCC3WDSw%?+F5B?;$M&ZygaV1gn4;8c>1OO0$9FnXA1 z#6^mLX#k==H^~c1=l|LldoL1B4l`q&;R_F_#4{1!n>9vbXC+S zKR!&^*4|5BmGasYvz4_~BC$A~a@YyNlv)U;RgAcRE_podx*=0)|4$^&88Hh6!&I;< za@yS0`sXJFd|{$OP)CNAlB^XcUV>SYj>Y?LLSjOVK<|9%eWk8qdEXN*)nhxdKUICY zA2tE~LWo#xm{p%Xx&2(X(#<&j)v(TEeT6^7p|uK*#+eafc&aHB8In`*zFz zmD$ynzKyKOQvG|qhWv$Ciax>MZ!(fE|6SagY9-}+==@;Hc(w`}CN=vZjR1a;M^l5B zj!yg8dDf)JJ-CWNBZ?-;7_IB2g=_na0q_n5@*dbgb^^FR+A*I20PkVk&P($yUT$}y49yQI(KdMnhf+;|mMUGV%+eUMRMhqiTJiyk#f*EQC@b61j#*dZ- zRQUCkqe7hh)-M_a7+^tsjxas-?@hkAg(+DHQuA=GilfJce{iGrD8TjsoR<@8cLB!v zXV}q^tSbk&-#-tjNDO~mR!dIyyr5}P$31}8cwmA-_D${)F05{gDY1?y7rQ5uJgf6C z+=3PyEa6}-OiyA^g33Fgk}7(DOZE6oigXtd>zR8Q_S{Yrvphs%yBo;iermY#c^qTL zmOF#wi-*f|lhN5c4##uu2(tEudmC=J68--`H9cx(zzu2Dx&~a@uc^F~StAHdrM2WoFu~?{N$|2k|Ferq8IU%fJyVfLJvg!rVkpTfG3C%d zZ1j)zICm_c7qSVEz;>mQ9U-9pCaTqTMyb1P|Jggy+bSunwdb9{wP@*fMek`&5}7q; znhsx+_~*}nl;Ql{bL})DVtoapyfciuQ8YD zCbdbDkD~UG&k|P29{48UFDTU>Hb=~(D69%YeYn0M4d?;HoI`mJqAH*`z^w&rU3!K+ zxaDE^0=_1VpzgD-273Xm-%>{PQ$O5&i;M7V)r`&Zet=E2k^j(c$2*KWd#Dr>Sm7$kpTc6b}jz zM1=ise4oN5NNs?j9c4L~flTM$Jx$mCB|}6RWQ?ly#HYSUeO==d?K{@SW#3j%HN)=` zu0`-k0Uw=ig67g*uU(|HE>p%H-hW9T*QJGP#`(YM3IPfcCku`cW0fZ zE4$CSClRN>{)E035H6c)3Yd1mvXxnjV)H8!zs5dzTKF>I9oWir?Rtz8r#r#{g5)Fs z6`oMgvc20u2oFpwpeGt1AJ=9y*yS3uBL1_qidv=Y@DyPqBRNTD#!WBX^z)BS%3u6Z zZ;Wy_ZT#X%bu~lPQfQ-fLm^9dx(z4-=wv;F6Q~+b)%0zdk#8R;uZB~)G&v9N3G4iY zPA&)TIRi9-hiJvv5jihVZ#|;QScOQS=K|nWL@C|9g&X@Rn>lKkcaOF4RclAT>$k_5 zi(JVMEQ#|gJgJ~W+f01gQC~8W;ZpV+X$fsXm1g6NVnD+NYHqQ5$MvJit^R}zKbC_V#178y$ewQS0^!GJ_rNo zki%ZWlG<9bT@5;*1pyom02uh?uWRzL%gToZW}`XB-92dgxdTN%{FHBr6T;068`dv| zrGrp+IdlknKfZKMn6*z~l3Hl?>hqC^tk&(k{GzPZ_}JnB7?P^f8=42;*OwDPdS$NI)DY#Q=qcc^EhZ0Ax1WuF}RkRI7*J@t8ifE^gnr7Z!cPUE!R&LyiIH}5F$oUg$ z5mO4-A^)Z$`{|Rl|NW!zi~kqL({C8F|1)O2R(`b>J{UgF5&tRf|4)xr2inzMyNB~T zM;xhDpyma}KTJ3wz7nB<2|7XAsa7@Bb5j=q4jdz_>xul~@z8@u*=sJD+O=QTs%XrYT`jYAjmAkLOKGo@#DbS># zJ_o=CSO8mY-jhdnW3I!I0yr0Z5s3KA-WhLW{&VNNOk!SYz&Fh?lb%XWm3lS#8Sejm z3qlEjjhT#6xXoi@%Fn!FtIHJ{1u5eK;HSq#gPRH15>P|5kF1=nyVaTSkJ`4I{&jzL zYjk9SB;%8z2i0WKg=kan4z*c&3RhYC=1}O$;lX_0{w`Ik1TAS~RTI@pU2Ac7t6m=J z$MGL8|8!Nk`rBznoekT}%{7i=jzS+8{J-s|Y}%yJpfyOS5<)~h3bWY2>qMyGX0d+Q zVw>MR$@3{8!%yQ_mWy_aI~UtKXlTI11kXFL@_Ws@s$MsXg$5Q&koyJPWY~tVp>GB0 zSgN&S*>4iO)mszzc9(( z85WE3i&TG*Id5}0g)4I9U6XC~pkpz4?U1RnCPUAe==^&5t`f+a!F$L1r}uqjD`$P7 zLN$rvCl_?{3l$9(Mj|{LbL!t1zZ`!ZFJtW5S1!|(nQy%uTIuK~sg$+}s}#*+f#O-U-W`1wyL441 zABjw#C{(>$FSrjU^KQ9K#|p`|6qaagVYrK=JHQ@N#3&Ks_yAxQtY?w*$h5)DL!4}A zJHhy1JEaMfLNrm9%?yK^BQM8Mcd!0nzFKE}ovJ-gr0xWaDdMl?xr=^CkP^%I)Nk2Z2Rg1wnxf+zG z`|(-}mlQdEFu)byWeX->U=lWd6qN1^PQsqo`cwutyi#Td{RwJ6JTvxlzzb7XrSLEU z#>f>4-9`B3`YoKF-g6b9zEx=!0i5|;UPRz1^Z1Gl5O08R2{D~y*J^K7*Tvh$bOMVM zCZ=##z`6pqhdRw0Xn2lFIg(-G4oEXJK+soMRE5A)ar5=$(dqfxq1RWR_cxvDX6vr> zUzRm+KC@>NE|Z{>`XwsqK+NJK^qoJpBzez_YMQk(UQ@VUrA zM2Vt=sGXYrkMG@pBh2|xuc3OZbVbQ;BR25gd3liW!v+ zP1f_hagizJC1FZe8fhp&Z9c5k<`MYkpMQEj{QRp#KGEyDFSNM0sAzcPwe?DpB5&l) z*r0bTm0+kp<@tQqizRoV?bw!BS?63 zzV;JuP_wr%Y?sjz&_+)T9FNW*5Qo)JO7vxWSYa@XMp){$>E~&{BSa#zai#rGNA=5= zI#>*WUmEcXh6>DA8>PHg!opjPh@UD{ht$#)U$N)Wi>&i`bYX9X*OS@sS~9%xT7BZ_ zY`t^Qa&)6%Nwf?mi%XU4&C2X{1xzJah5+BeN_72YkIBsR&WBmHGhu#s@Hxq1_U^|i zJ4h!8rGSi&!hi>yD7Vj>pD|{wJ`}w$W_3;x7Xda9Xr%trpfyF}Zu0#{!@m%4ew zj#hb9#RsSC=FDY*9iNE@n@2=kW-GS@BxNso_xl-F!sO-{rIvScScn|myuT2G~rr=z=g)$=@ltR32bUr65W zM0hug6JvcHT)2U&4!0MOT){*sKKiGF(2zZCwGKPb;!s5%=O_Gd5qsI|7Ic;rzaWlN zi=s8)yDf^B#FFAiCyq1nD>f*xCpqX2aYaVGDIe!rjoN}+&J|BTXtN+5yJ^1c?E$=T zMn=XTE+Vi!5wk^MVeHf`UujkrXZW9hZv@@4Q%$iBX2FcGU!_=?VOh~&FTJRz|7y&$ zSzI&O`)oJ^o8SA)-tqOJnFek1P4+$PFh0awKh*16T9DyCQ~hckF2%U1yNAbK_CWBR zg59T_B?@r$PVLWUmafS<4bkq>8M4Mh&#|qV-a^>s5abQ3Vh=E}pWtQya3%GeEJ%JJ zKo7LBO_!%lU>I9fBrW)ExkR3jyDro3sqCVGs}4h3u9|sTifNA}duj(4%AjmgtN1(f z`-hDk9UUMGCR$d#Ed~xVP^tmv2WDT;Bf*RTs_^b^1(09CBL=h;*y~ypkP-pBU&Ipz zDIBQqj!dU*GTe(h_B>qL?8dE1{;c1ukj}nFsd!24z;+1eW zW$CcHG1u;^vCFQ;E?P}oU*(%r2)wsX7ZhS|{0N&@@tj90=vAFKLGnBgGrRVh#ZVv> zY0bqxUwKd69dFn{pb-G;am2Xi_}CM!7*`scVt5S|72J8h`kyYv7+qN~f342kOp&DC zduGsRHZ`Ge*iJMTUNy``LrWVxy|t~jkvo!nDixK+$?6Ke*U%O=&Cjb-jN1u7GYKym z+}4TM96UU}sh3(jJlBZXclTuvHzd7k1}U{N21SzZdEP>q5SGRK=(iQ;@2WLYr;8`c z@;79%DY5wlN{0$$XQdORrD>k)5C9g22w~y!1dXzeuC6-H?3NoFx?-7?sVOF>VZ9{0 zwUreMxhJZ3*Y>o?wd=3rVhhnUk}bIWNb0V~WwlDi!;)m^jfjW<<7!a&Bd01jW%>Iz z*)oUnmBZbPGX>Z-Oz(j91(PVmwudMAHONPS83T1QRL{TML}7FWfCn(u5!1ncDFrv8 zI&&)5$i04hh!sA92+;=xni?gt$u*Bs)EM;?Qc|4twSVwj_{U73@t&Yl?dzNxkUI7E zn(7kA38rw)Mm{t9fH(RfRy8d-%{Vf)-(vG=z`gW~?Y#bm; zK@kiy7R{&-DMv;c5mFIRwdCQ=+Hua3L}Rs@fL4Y6Y@vV4?~%QgWVGKl_;7?`{rj-Ac*|8yX*N02K&_ewC29WezE>?-J#MQt!js@z4oqCAUI@KJ_^tB8PxmhF z^>~$kEgw(5er%VA_ZB-)HguqGy#m9MT2+Xp{?0!7Njh%q@xuITnxfBBb~fkbCLzwr zdASx^tSIS96I4k+08wq)hxZNEcbDD1kDdE*I3DjNixGi<04Gr7)2FuyA9Jsp6Jj&H zw!gYD+41e2`e#lyx+h8*?W)pDEq!#nyf#8}PWT6pJ3I)zvKb!XS|1Ge#`S0$QKor= zRalu(Q_!q^Cva(NwOPH$jV#G2R)6*M-~h`82!Y_h@U&_Qmf?R9>fs?F*wFTjo2JkC z(i5s*y+7cA;sGHu7S}D^+-{WlEt-MXcsq)*zkhiC%h0NGN zV1p18l9JY*o+ZhHYXOpN27w2|`$m86Wz~~wR*;e7X-wR}{7p{DAQkJ`v+PtpWd}D> zzG{Y_e)n0q4Gggg2g}_t1(kp9xYbdErx$$Y?y(PbkUnfiFcgFX9hCVeC$)N`4Il69 z5CaAZ&YF<^%%JxKd6ko#54pvL30=lEZR~$&ELbFE4h8pF0|@7yyi92x8^G>>m=3vTNX#KsMD6LgUEr; za*9kLLoOrAc?M3K)c(RjDE5iN@_%GIwtBXjeFAe%AYLG`J3Xz}(BS-pT;a&$j!ez3 zhGm~0WGj7-d8wW7cHD*^Dz5PZ12%lmk(J!|zAFI2+pQ64VD;$`U&m zjO`>aecI5$U{Dn7y%xjuYIb#>+LpZFIocg(F%Ny=&WM%5gIp`Tt}9J`NkWmYsB(I* zd)}v#8*pbOVH6E&H3p~+${Sd*@O$16svIVwkf- z6*vhW{rKN)nEeho3op&e;~M6je?*8TyDE+?Fs;sMJ24MqK~ezWAM@9NnKw59k;&=l z>9_fLV55N<-CEXXmZiU+>jje0**ne1zJ_aEd4HHyj6{2g(P)Qlv=ZD0!^g+C1ZY5O z1rPH8{d@0!HbHj8iGY!vvnlUL3t;V)M>J8+52gMDaL!l3&6yP>#Is2t}ywjCH zzhv^yxR#4<-$6lMa@%hL!h1-<06{8h)ARZPtN<7b!0!9vww2PO{nRw;)ho=uK8=xA z*@&$bNO8c= ztw7U;8OKvir&2iV*7vQWJvE8GI01g{)9|UiN4To^K$wMaXDEBYV_S~J#fuYG*Kefw zN>8UoD2gyC@%Hxac^unuU7YDh!)-})8PR6OUA7b^i(0Bs_92BAmg9pR~egVkl z)hGqE63xFML5+>2l^d0%(+;qH7-RfCJ_|&xd5zrI ztRtt*dCw+j!p-xV#RDu_G(O}y-;H@wNNrg^^dT+WkY-T3KohnGq_Ds_OqBOLSCarA zUxdgD@@>97l{GB8mFqB}i}jV+bGJJuM>{Dktqo|byP&%Q6z2nvN-1%V)p2;5}i+2BH zI10*v-P8F?8Z^K<_Wo==0r7{a0Sza{K(XCcE+y@s=B{hZ*4)r5q&Thdv0OE+*3)u) z$XF%M`j1e?jO9vTnoQq@SaV?41oXsUCEawlr5C`;og)w(xG*26G3RdNfvOwS4sV<>X0iP|P9zlmGo&7ZAmWz6) zf%bOnEn|;YP7rA87A`t(dHprctlh5&!ty+Ixz<|XYTdm4fl!U29W`KFWh=%JR5--& z%yrI@7v2EiH_-cldBD&8!TV5WepJ*M7JaD2N({#+7-|4T!xR`Qunz0$>R`xKm=B3a zZ0O&h2D~QxespU1Ufh@KE{o-Krs{+TSTM{%RB|3-rC070^nw6mysLBFg>}aa4sAGJ z;1oy*zE$jnWk-rrpScR>1@KZ7yEmraIB^X9^S0XwQY4<~_UuLiuN$m85Hl9|L7{0O zo-`$g0~>sCrSmk@X=vhRtTcz|#&2M=NP1qt3=MAUTOI4;LaQRNN1e`Het3L*1Gv9o zEahYNBuSDis#8m*FUs%WE+T$_7Y9cKoKl6=oSEjFn+6mjc3aan)nme>q@;V@Oqq0G z6$U1KKsEKPw&CCJ31$gnri}Q8&x@%|QE|}qe6BtOrrdz0!?s;ULqhCfS=&SmVMk{h zo;P;)sV$^N1nB!ixd*x?AP-2vRRwO**-9ztA@{-S12~xh8^QyBJz*SsaUlWYST}cfu-g&knFikm;A$(j@f6Bu@4kDl z!y2z?QI|n9iMw>Zj_nClNe2J)RV?Oui5kX&8EjS;iD2mDplpXTd7)}hq7`t~j8;^sghhuvUtMW5%(wyH>SdKOXyOMNS_58`>9O7cS zM|RaeCgb&*q7$msP2R`c*})p|n>h|wc!fs*sx5Uq{hj4z=hSvQS9uC`zegEm^Jm23 zxejy1>EuG32euZ!(jq*&+Sd0ce`U(ff{wIYOLqaBXpN8qiv;Q!!S{fu50%nA8L28k25J_IUc8z-45BRQd!N6rL(^RD& ze2iP!kTB0Q||IcmN;zuf9X=HNMiO*_!G zfWEKQ<@$$k~=BOtZ8`~?0r&XJg z$PxXwzf%QIj10|Y;Y(e_8w|QjFrsTg{JcPB_%9I=n5GiuySSoHUj4G14pc~wP+Y5uX3Cd3Kc1(mEAP)GZ9GY2Of)1XcwtWIhh z{nxu)i-m|-ii_;^!k$ecA#;5^Zb zHn)KO2r=r@xD`x{zmFoR zOfa4TZ6~Znn{dy1V8DTx59qRBs|TmG@d5q`)f$x^x)M=su6)T$B7t+7#FxsSOmpR| zA8IQuJSjoNKqm9xs+L>b!B^Kp1H&VkJi-zT(m*Idfv3zxrm3JeWB5sPni_ji127VRY@DLBA_ftzDb0$VY_ZI`k{|3Hg&{9|%8%){PZQi8Zz- zGgM!rjfq9QhUDaicar)qACMKx+%75$$ z2aYn~AYjn~2*7Pp>ytPrT^hK*w&zHpBU__ntE9RuweE!0iFHK3n=NU~d15JNfW7ZCb%^^1?58J;q&)e4T3iwmU>aVuAxV4R zFC2K1EGI{ZU)=WgJ=pBX0)*>DnK9>s-bituVP5P4uW3J@Z5HP%X-i)&V%F4Pvi9jd zqPp-zXx6B~xAqd;Jl{a!B*{QP!Ov;KM*;Sn9>>4)Y(#tV$>9J-VSQa%qKErNahr$N z;yB#Ohd4|I!Z)C5c&nKAc+fl}c=2}UZNiWr&|HGay!beGFgAHG1B2>=(1uBEZSD9@ zWtj&FuNCWopXu#Q=?^H*F2JCXviINe!s02?_O|*B~Gy|Az9&n4@Mt>AB-t@ zZJZsJ`L_cC22w7*YNMGUS!#uzRZ>tG&(CKzdjS>xXl zZY(FS*(S}$X?_AeC|FZCtPZ4Sbb2KX#b3Q~v&K>esKrnhK+|GUkz_NenEX|54nkdJCCBeb=n|{c+fwu~c7Gl^6 zW)3{D5i1<4wvZrz7+oheon3_#RRj`+X40Wv$c?HAI+|roxN87?9#7G>Xn7oy+1B$% z6x9&)c3}lbT7>?!nBJAo6JlghfEjLl9F@eJY1U=y85PkxYw5e+5$9v%yD>WcFLi9Ih z=R5w_(9Wit&Zi{@jn%pwhZ~d_tKsMXIxhgQ_6Gs--C!E0GS8>C@|wKwGoc6qOE!&kjDm|EW7`6P}!8%0Eb~9IR1BKX5IPUG!i_%A)+Z9yc#}; zs43*AV{iZZ1vj+*w|*TLHL~Gp6KaXT=-is+v{B+(pYAsP*>dwc`oK*}TL) zk5)(k^&aoP=`sJN5Hw%@{TJGPJWvT0~FkqQhOAUN*U>nQeih8QUuEU8R zK@)2dtSYcM(kg&F;TR17I1z~uXX9V#K*gHv+H?Ys%u#eS;Is3WL1u~ue%ddyuHCSD zk|J?eHZsy)ahIH{b6fd&GVF1@xi7`~vtX|Lfo2OVOZe9Xdv7kkGWM~9&J%7+l|sJ` z$)?L*ob_z*6$Y*EZ8)^`z5%QgZ@LRjd^PUd10iU;0p%DQcpSdm^F?^ro|ZpzYJOgO zsvt4IDUpV+fl1*X3Qu3j_tJ0qKC9>8{qQ{(5RZmS0;aSAS3=rN05B@Fj?L(w>rH#R zfXVyd)z^VFZ;Q^+0+YyYnVBCifvriMmpo(ng7`Y0X7ZBkM#5aJZc?NHo9<d2yzo9-^}k>OG;XfZce={`-cIY9-l5}2!@DpX92Y2^5f&FH zNw8sKf^P{jr-ssa{_=eO@21fu7zhSWmKhcC&~#i)1kvTcW;BL|9ZO5OHm5cTZ@+-? z)BW@HN3dws6W?d;3|t1cksVz$rv)2A(eB zG=qnQn05m08Sgo(G@~!rW&ZOHc|vRJ11$-r)N^@L{igdgiKnP4F_nZF?na+mQh_u$ zfnyWR2<`@b0VE*8V4a(rI{+zxr9OW~)E;#S2C8s9uHL^C2GI;Smw#}(&g(5}_wX@0 z$+)U5X$>wzGFGLqMWrf1nNz8DkrtE+kO9Hg`u0d4V%Q)qZxL|G!cLhQ{q2Gl+|T-X zkqfnm%NF9$KdzCW#Q@A;Ep`}x{sbiz^oej41Vy~VieE*oVJZ=elyK*e9V&FjVBaCy zK5wIk`v$RbMFfmc_xd$m>S#pQ-_vXQb?*R_3rM`E>zhr|TD3S+`b+O`ZHBm$JquY94(qinIwLc!9D|oz5wq`0x(;=joDghHc6Av_N~;UJDFV=KK14 z0_DcnIF9ve11Am~hfU*9L*cD2a$hzWmVH-$=H~V(=WXa>i!Ti%NCa1yBCrdXk0LoL zP;cbV5@Iukg4eGp<+47#yzYDVI#KLe4PZLKV*xLk=5ODU6yLIug#G<9{d^Bh6xRW@oz?$o?kk+COy9o&2|*C0TcxC>L_iv8 zqy(fpq@`0rN@+NxNO!lAQqqltfPj>T2BicAf7jXX`$xPxJIv0yv!mxc&wXFlCyBGk zuPFpJTeh(Ha1tUz-ij1Vy- zYyMVFwQ_={Na&4p>zA{vj#E;lhReJfwV1MTQYng2JVuU4)~d1H3sv4*`54HDlSj2( z(g!_iV$nPmLrgZ`2C+r=PSq`Cg)_AIxruS2Q-zn>mx4R-@uhh%wb+tkM)D#XRW`q- zF$ts(^Z|5hR`UjqCJAt;ZjI-;U!8|E(O#{9!j@jrC2<{lo}6T7lq zk%{!gZSqxyQ!;tMWC4(qH#3uLD=UeYX%tSw(Bx6P3)m0n2v8FaOoRX#1HR0%ox#%$ zGbtcmsK6P(+i7l=)hg#zJT7=%enTLy(iy(ohq=1O#^Pi<$;%rjJCr?>*FlM+=*(9S zTwT)3dX1c;zxQ8NlBea4%>ucfM8nn%#*^FdTkbvx_~)B+jb3T~xW+2rub0SDjZ*r} zm^~O#Gex{nIp%wNdoh?5{sd`8eLMVd$awsic$$sILth#sjICg_REC?wXcyYPmF^{tEyQz_tskl9nlc6Jh<*_cwh-Ces8jwla?Vbyiu=kTX@r zV_vg4_nYYG=t}b?WBab5iSD7z-tbXZEApPvF#UBQKgY{j54sh<*U&fsOB!2PPrnzk z#_OM(K=Y!wZWau!0PJ=@nQ$D;T@WQy8aS@=@a6=QR1#u>J6j!kTeJ!~ZQgS(z9}#Q zR@C;9bS?U1hh49OhGK(*G7Wd);ESlkt!7Al3GNXnvBy zqC?Kh30Q$mV3YtyGdP$Be|@Q1z^}EBB$n}!mc{So=2$ZgdJSY8Dnk$Q5SBFu-h4`V zSfR^yO;@?6cepeGU&Xh_;Z&hsZG+55x5^jubv zvhh<88#Kd!P{6kXq%9a3H?TmNQ9|Ge;sLN^V*&1RLiv)eTFx6_XJ*8f3E_rl`l9DY zU&oINefVRN;|F?^Ly!PpsF9uDVl$QbflVr9#GaW?Kp+ejXTYkY>JnHXt*cZ!qwV`2 zp{m=%7CEHwz7M^%)6BZhDtPr&o=x#o;XtO?RRZ8Ev8&(asA4A21wG%x7{R0=h0m=M zILbe%kK}n<{D%m4WP1xT&~gtbiMln5=;}m-4Kh2prsu&HRJO+f&FVS0acSQ|`DPELd%2k5=J`jqRZDlJ4UMB)eO2d2=K zwDPhM>AbZe()RjSR*j2e6qbZTTu;;I8nFsbE?xE?^6*unE*%(^AW9GP5l~FN`Lh4( zI&;d9J9qp=+xFRrtIN~D2B%|=X4ZdSx-CW=(5r6!0Te zvkMIdMRWG0DldVx2O}Efd}-G#7>x~88XfaCvWCa2-!1taS=o<^7xh0O$p$CU#Si}S z=?$giq5)*ZazKH`){8|iO5O#g{P0oChj^HI)+0^X;nu&!eKzfXXjEvgoc%!o825m) z0Az^~pOR8>@r8Ahc66dJ(!FeY+XO9D{&TaPkEjOsz`-xN^%Hpp3Fa_E&8XPeGL9D@ z?UJ}Vey=J&9A+nAk*EH;HyM=LEyD-~TVpu&BS#S6vzZU$^HXf*So2agxLda~*~uc! zXPW^<-d-cXc(tTZ6eBG0K!5+aqoQ@fn3bQO0h207@_IxRX5P~IFeB98dJ!#FDxBKK z?HINPlyz4nv$~1ysI}`V3{kd?nY%>}plAFvz-xHHUpjwZmi{)W>Qq(i4G1Y&-TG1l zkFwXFQ%;ahj4iAx1hF7EQnxriVkez-q!Oh619SY8ZNn1IZyHJINU~aWgJj)oAcw%{ z1CfYYW8n^5to`p*ihO2J!1jg<>f@(f=~3SN0HKm2C=Gx?&Z|yBANC}lCi^VI=88l z7jL4wu~1Rouukd(zBh?zRaOAVjgd28Gnmp<=0AN{bOb*wOmnDv3s~9G<{(jA>>!#H zkR8|y*fk;UWwpfPuuHDR(lw{u+#)y7cY&5buIa+Guo`}0p$Fi(2S#VG^vqv}a00H&8OC-GK$oRxUd7UwoYl|3;QmCj_V+jE`d+l^@0rfJ1Xz}rC>MxP< zH9rtSf-(F`dV*D1VtYeUVNm0Aq3{+`=g$cR^{*S3+`I`Il?Fl9Wo;in3bGq z3N(@riZoaOFe?_ml4r~fM44q*He3xQfSXp3j1 zn9P|hTi3JB5V&__h?3eSYv(*KT+KJHE)8A@_Gzn3#i9DeuMElz|G#T@)>gX1X^|Gc zUuRi*3Jvn`0Z9#e#NYF=02sY`p??K9+s9Nh?|&FIM?)}r575>CgZhYBJwPT7zgG_p znY!VUNhS0;SRymaAzpVLdZR%Up?L>w%V2T>q;$`Ab99Tl`vVi3KPy-1cxQza{K**# zpV@Q$#V4!SPA#ZQv3&IB()PQ{g2R-#HGu)jS&-G8da$<+T++p5mg!dfNE@)q>t|4 zSmeajIU^1CW$(zPfBQuxDfWARr(mBg17wuz&f7{}&!Ao6EY2ja_L>QgKd&+g)6?+H zHa%_}#ow+a64uXauQEost*gA7y_Bf!p5)$e&EuG9+k%G{h9^I}>>`be?Y_?n>Gb`8 zn$U)`H$iz8V+OE09FghoA4a8;m5BToH`~fviPGDi{aN|xrD-D%Kr9TKK3v*rZ;@D_ zi$xnO&Z|inu+Vf6B~7dUg-(-RCXoKryA4e<_9a{iuo%I1{v&HYXXsp|I}q2tRzFuc z0&(2NFXkNstS}1vjd*It2a+ui@Kp|q!5cQe=h3IfJ=n|qOje+;Gyt}?H#?vBSgC0@66yE0ljAfF7JkyhhZ zqr{G%9r<(%FbF20Q>uiA%_)+)c}AvbQjgw|+-H4p-ee@E)cM)#7>2?B6iPt?HT8j}aXUSQ4qi<9~YUA=gB%uQ*87 zM8c)<^-$0PL9sRj%w~WCS{PnNv|g$*NMMu52X4iG3wr9IvHr6$29PR7q4HV3+|@) z6sfckMZ^>O9GaVT8n#>Ck8>NNdoQKb_htD96|x@Xe)B!QDeA^{0y88a^GqDL85q#| z2`?b*n6_2>2(q@@(Q;J?TpG;#Sofn;R1p!$eXYZIi`V^#abV zC2{a79M@wJo7RW6Oj<{`Oa zGDR@F8&)z5-!14FQBe{gb%!`okiIBRFuRPi;HMQQ0)B{3gUGzmVP*~J=Cm;&4!y0&Q&SKKG z+6$BkAQc&jMC%%5$D=*@(wsJQbl?rEaQh_pAoM92tfN!R#6>mhpvVJ!8PzlDcXf`0 z{RD-J!@`zS(=ql_=No^}<$OCTsim^A^eD?s%v+qqE2?OqkRtyyO>p9A4t4ab7Wx4z zlwF~83GmXQ0^s%TA zyfxT@nTJ-GLMd)e5hnJr4gJHPEUz)l)u=M}C`9Ny%5*2xYZtQ_R{Rk7U;vvtA48%B zS6E3>hNVjNMvpbB)LjXY~wqwF)}O_caoFOWu>7HobpALlw^oBVS8&mA(s zb{G>-GkJA&Hoo%fodWH$5;eIJO)3_W7bFq!%BS2GnH#$M2ACIEN~QC~D(L|`^;uuG zKEo&n-Ps^>iqZe*SaM-R*@8eK%XBza;TK?#?A_kp=FtXVNk*kp(Nr6V`u6s!kcv;} zVXe&Bbw933g9eOulgR*q zKde9hp4^2o^V+~C0`lACa!YU{v^WEf1#&&$4*~Knv0nS>HPtroA*v^AK1{XX~mwD!K)WTtO}_kMtT@GvW|gD8{B z;GiN-1N*(CF-w#T3cYo#IyqBloSK+{lpjsT+7(A4hSRfhEmG=DSC%ZppBmpbBbmA# z*VuxPMHVR^PE8DGUj;2Cd|;>=LlScdNtv;P5lz?!O5KwSoLnANL>7;q4>x*B*64s$ zNdhii&?3Oh@n2Ol7Z;mlXWI=Rqkdfp_F2wl&z(ai^Y%zAEG&gZjj3O9N z;3fpbt6;nU-HeoLu-Qtw3N9n)=YHl8$B=f9SDB;e6=YEXmo6-2*(R~X=Z@aZyW7(l zSAOMPX3`|}C|J`^oEj+A1M6Uj9oZnX&dy$f@R&aNfnetn~W_|FBZ^cg|kYw-@`f|@_nsCl=Yg~Oa?OI!xx5L4W2vYtLd`d4aLl%zOA__Le}QWa7|I$ zEY(|+<0L-qXxRIEq=LcZp=EJYChl0@*?`B1uq+ZwV~1ZGFZ8t;W!)SH!2FPe^lN-> zM790C&3an&L(f@=M+C8Ja@cJ_@~_TnV@cKYyUvs6V{1YSdmaGu!OYr#9vT0Wo;|m5 ztS?)X$l`i#I*&EesB(@{zoePCA@jTOQe$9y;bDS97`0cz&fahyKJohQq9F@OH3ay8 zp8~}rRH(BjDas9(rQk4;XaD`HKqyOR+}jyNcCLjk8VD_muu)Ch%j5z$YQ>%+T4(tB zOfi(Lo3HsJ*FEz|F!Op3)$&I$Iq`n}d`lI8m*Vik@xou$kF7>c=lrk&dEZ$Y7#J1N zxjOMvu}#D{*g)4?pV)-UbB?*2$aI<*-G_RHilAwdI6gS zm_st=!}uuhOADEfufsTPrZqgu6kRCU?doGB3!Y}SB#i={Zv+WP78JudtzmWAKi+=< zEalFtide5;VXaf&OiU1WEI2@BORvsRj&i3~qEBMtu#^o>b7ySd_R2 zuk5YJo+&B7(BW7|1@Mdg`|B$6aI%&+GX2?gD_%-eYB(zPe}BI+B3!NbSlBrlllm~z zaQwhH;P?B_K3QhD>CfFLL70OY6%0U_0iSO;$ns9pKu!}KO#p;CTpR|?4jLohPkhiN zYNUjtq&O4eslXcrtRD->YtU4Z2uQ1FVnsefEyF82~b*_8#PBY)h3wSIv8hhn}qDBj~|PgwFWcSwGT2( zk||zk$GLJ)MXw@M#s2FuM4`70ig2L8Nr%b~0--4I)=3(hMH7}6=LK@3FH_UZt(n3m zFHZP*Y@2W~9-o22tReWFaxuMOQE+6CRJj@pTzRFR3H7prHFRY0bh27y&-~+AWy&N9 zK=1XmjZ0v502Ju2f7VJfOKj;gWAyPwL`(6JbR`s8(I@RIe2KIs7ZjSQZ72&-4qJ2Y zZ)~bWTlbr>Yf;!5+DYsiZ!enF7;-oJFreH%CNX)XE%l>A?d#E}-oCzRE8+4vq@!J; zxD}oh`Ejt-hjbx4@QNqiZn6FKHs+2}LCLe>7fvO7jeNOD=4P6u!W{1-!&P#mhXg>f z4%v&n(bT^Wy9rm0&Y@EyyA{uyE6;V(_j|CZwy#*$ofrR1x{6t2S_$)hTRaFG(bAI# z%n~JxL4_K>6ttIj*gH5_gZf7Xh!z8Fi_I37J`$Hr)8py2Y~D|ERvJDX8eT{Lb|Xih z`mO%_%@Z7`@2=4VTB0O#=*mqBAGI6Te}$o@@2|1xY?SW3F>GeN=fg-8w6NC;k0f4J zH52E;2<&y{g9^-1yiXw3Z;FbR1fD^hL$Pv(xjUCj7oo@Y1?0>G9BF^LpT0;n9QCHJ zk~{r|{CZONlx=LtoNA&+J35&1*zuJ$=dxg|c?|_>*GC15f@&6ouk$>j^sds4c`%I~ zfJW)@OI3WsJMT9H@$<+3cn2of=A*4LAAwP!Tl{agICMyL?3}Q%so~M^g^o6=0V?&l zB%Xfvk@iriQu7z9I(H6%$%6Ws6X#9YlAZbmOL$efGah>$e#yG3m##rS=radIvHj2D z!66WH#kcyk0xQS+`udWH_-%>VTHgJiPP^`^*42bV)65Kjv_8M3n*NbbZab&AeizHVL?n1WY-3i_W98LwttZDna%zS&P3vTg#x24=tS zFbtGB4P*hQ-1HJp8@mReC7cHztFCTwzoHdVb14YUM*KBBJf zdX+J1D}_5SJOBv+YFI!ZD+(GK$gv=`yCYtm!S@4SlLDSTYxzlqSII44hJNi9#62Lv zgKGlC_Ma@1DF2NyD(n?}kYxWcLG}BkpA!f-78g;4F`CbqYjIKHGGGP6_-1hqY|P9s z;GO`1HV6lS%Yo=v%Pyq{OL$Cwfe=Si)34pe4GeVOiCw$RfFh9Q5V3)wmmkb?Ck6SFy3w) zUQMwdy$e^iVIQAKl+hp&`z%f0+hboK9L_pv-T(vyE-KXCO7U^R*{#5zs)v4#yiHN^ zfdYTRoHodGMu)09k6vcQ-ud^t4=!PtMi0I&OSku;N_A!fF3C~+B20aN-r_#XH%=K% z?zf}B9xXuAJR@=ECUR|5{T4;?3WPX&(Hx!ba+8$NaBe%NPH`(dS0hXT)ya zkPV}j3`M9EX{}Ca1@rT6_%3GFIie}XdDFLz@R+aCtmXf`W2{lKX*aw}Ik5Bn0?|@9 z@xoGwbT*}&W`ghgiTR+ges?4JGL{a9%+67;9|jU>K8T1c^kg(9^1?82N_@JUynI zBFt3H23+e$-n$0}`bKtmZZp2TVeB7Q)?F`9BtL+~(^5yJoo_VweLe{DbuTsu#!TjA zYnc5RsHw>_#9MUyX!~UCrC_3II)JvqK>!T1yn9}GuZgSRC&wdK(KznC@&39K7vmd5r`63KB4~y8l+k&9$hMy7Y z=IoZA5^0+3BkZn+t!SGl#|82(0A<59m{Qt=%&1?Q28zds$EWw2NP`VQZNvasn) z{XQ))_bAa@A3TL}LqyqJyu+B)>Rh;O26*=sBoWM(-Nh%Clrzm%gfswsVxd_&4D%NObWwgZ{L0G zFiP(O1DyXcWzWP%wnw152PAi>7z@~kV8VR36l_Fj`nmsfwND4=XbN z@VEk3w@v|Tv;toN_hy-<#Pj`26}0ne(D|lNGZUi($>61;8tmV@Uhw>G=!kccs{tcL z&zIpY!Gw{OzbjrEHMMT`@Hn6NwB_B@oAKl8#iLpNk$5?mHm&0H{=k`&>LFr+Kugz^ zi?|`*CFRU>n#GJ#n9(ig!7NtayWL)!@f(j>sygMd4GVv!97PDRaNJm@yVG3$qYO+> zaMrYmG9sL{xJg1C`EAyhHT&(!6@of+u>TP3^r0>U$nHn|LE%k+Y<$$A^_j9FF!Qq< zAxYpb37;Iz6LSSy$5a#5Rd5+64sGOkAv@IR2d%SSg#nmg3gNgw*V87_AIwH@y;^*! z-GtlL@!}@M2=1lKgS6wved?nQ3RNykDT++s?SSd_gc1$xZzyN{>QAq}qr1|*!nS}U zfv{p@16;XK$w!~02s+Umy^7LG|2+?CNZ<~|vq&SOL>qN#Sp?(PbH(=!{p(gOSGl2V0h_mH((D$NmW}~7Ss{ToU@&q_Yark`OKt? zuUjr*5VV>KOJAH2Vo(;Eiid)s$?xyaKG@jdZ`!k`=iS^}U_!e3mD2tl1(Yl=9|-;R zOhC6dKC_|3Ewh*%7jYAczkW43Dj(Iv>m72yHv`j?c=!O(d%4xOa}PH& zi$n4Yaam0Yq*9hAlpf3#Weg^t-=DMBrd>Ncyak^-pnroee#|Gl&KMisa-&Zlp^uk` z|1*3P&wI$XE>UWzf$L|=aZ^ z{47piUT~Q~_n+CsdeaiRSiJtL(u^R}_V)c-_l-Eeap}#p}HOa!#Nnfu|8#>)q`8 zr5=Pzh0IMxZDfSLp0epeh)6Lo6fPjcgX*~HENE26N|E~>-^$n6y5GzsPG#-CC64l5 zu>TO_zs$R9@kDj#>)G$$joS(RHP*WNATI<9$k)_2zI>{1z^cZ(wb(ylFyH?5Zup{h zhySsSzrS(Vbd=N$>re##zW?0=Bz$y$Kb`y00kgM3)!)={(wS0Du{m3|V=1!Xp6R}t zt;KCd(Z5}bC+&#+nGNGqD%*5H=^AAwP6rR!U@>3uZMV6Ob<;|oGRrkJ0qgiKL*~)L zqHk?r@y!8S1UjVe&cw44w5qa!`WSWKpqTs1@~}~k`h~rl5r$#c-8y>@CN4IR51LOF z2;H0zQY~}#puAm~E_;q5iQ$a|FY0*Z8vS*Kj2X=F_$gMblKgSVa{~!2oF|npp5sw# zOiubHyw-7|@8Pyf=7_9kDuWVr4Oe2?Y=)Zr8F1{&0ci7}f3x`&sD& zabmdvuEH-i@P?LpRq776Ewmka4|$t0I$3;``N5shAa&=n*Q%#QQ8xesFkFE63mj0u zW1t+A@Kysn&KaX03biu6WwpD>pFU#CSw=kl+~(Jv@K5bpIpGP3&Ok zfGf(q^zBh2XE=c$M`)UrB%={s|h-gdtl0=YG6zffv9k+3r@uX^qwvNk}U6NsQ zkY-c)IHyC;*tqZF;zA9-DiUurU~bmX=R=2Y9uSUjTxlnT?CtMUO=ihv2I9-b_hM&9 zt-$yrl{2pX0h=bY1+JaXcJs9C$vH&G`Y)qyY}3BnM`OoJUUROMUGHXQK`R=K&f^9xZKo z&zob6LNcyejyo(^AuAN*yOiz95+`0F(B#av64Pfw+nRrTVm&P8HL(^<{tiB>WG-zG>Te6Jf<_Sb54D;dA^7YCQjd~#e@Mms1V zP^8?eSB86jo=Ke))%@!gtN3-0hSowA2`+Q9nqrnm$+FwDw@=(n$g&U^iq>_25utL{ zfR}_}8Uhi(vzYt8IP5ulsKKUBQ)atphx^_)?yW_mriSIsqI zv?AqkKtfpDTd`(KAIijBlI#nmRr*PTw!pKl=218rU=#vbhKwhVuMcp)-d@(~Yd#Yu zPcnw=oki7SxCcd&7sTJ4=nKA;Ou)+=i^YggOrK`X|9bxI__H=ug-gg0YOtd0*>2VKV{|lT{`(s|=maRkYy{vL64l~QxJVoP9r=P4Yb%N<%S^e|498~azT022 zF;PC6ty6ZtmjgYZ+%47$`f1+C1eJuWI~F*#b;>NON8mEGJy?O9u&gnh@0XWJLzeJ| zOv1I@_;mcs=Xe=MsPAqh7tPIUURnJLwrY+y?AK`rwHs;lOK5b4I1$6gGuh3iCQrtO zPI?6&J@U`Nk%r){59(3x=~&RFYvPTFV@F1VfH8g;7k>uwK?sw8U@A>>($RmCRKpY_ zI6~On!%i!0O4yNxLxP0>{J=B^KS7HJB~_*Q2yE>~?=JIwlLaff;xiBL{xR7c>v*w$ z=7T>c5jNYCvBwhdKhG1S(oOwkR7zE51|t{>%Q8XF?2si-n~(%>C5Q*_=7H?~D2sA3g;SdAD%vrz09-jDn!Ps|)^h#-q-)_p+T7 zmt0i}SO4o_e00OtHu#m#X577I^?|h zIkJ+EGQUY z-OGpQwpi5!w5LEtAiaXY_kFh7m$i4i_6(wyRHYp1h*zICcs6LP4Ghj2OHu)H7^Jt7 ztFx+`i)YC8J=HuOW{ta72){GMpyH@7hp)fhS+uBqayt38C2*&pYwxU;_f9T(;R=07 z{_)N|m1eT7*0h@2vJnfrUxP;<@^u#*>*j|)E%y>gx&P*I*L8*{ZupUEmd$Z?Tb9B! u1b(cTnXKo;qW(4f8fl08|HuFQ@7gCn+SWmfI9@dPOF>5ENu`v@>;D6!rLgD# literal 0 HcmV?d00001 diff --git a/gan/gen_images/img_300.png b/gan/gen_images/img_300.png new file mode 100644 index 0000000000000000000000000000000000000000..c036a48e3d548aea5c93b838bc24bcb14104212c GIT binary patch literal 103262 zcmd3Ohd8$8Kj|Kw3xod% zAf$8<>JH`zcOz#rG({tXqpbtN*2w<=cZ-n|6Jy$Hp3Jo0%O-@om!y|dCe$|CyB96hg)Y~lHoyo(W zeoc{Y!ZtrbZzFoRK(*(co5f|j^j2Dh;n9%&R^jP4q5Y%*{>1h8VXarMcBcXcf4AsGK_HA&ZbE#la|_vg0Pl-QssJtO!ZNLF*iRJ9#@V#K73Zea{U+lQnzTN;M1{-& zONui=_nM=buTpcEIZ?iP*GnlIyEnh*Ocm3a5K4^@lJ-A%_ zT>tnd#@4DxQZFNO9QHeDx{brLTlzCy&9=NP=4DN<*weKNGSu=85Kox?3g_V{h-J;# zXBiY{jaWOy%iK2$VNXD`6JAqdd-#pcx4TUXRArn8^~1XiNs$D zDiFp;2DZFnuZz!{+)gBD;Ir*hs-5}m68mrNw(K@t-JsH=_{+~{NAeAnHy6)$;z~J4 zaoEWtUQ(CFdWJ-D^{%+p65?POmFT?hHIJ61_xxQ2s}$RHBWqyXs0V|vUgtVT#aAD@ z8n(rArm$3DIR7BO(nZ`FSuhFNsvb))1< zUePK3bp^&drn+z2j3x3kHcp#l-e!+jr<^{Ed-r%Ze^jwA=IC|i&I=Y2Qk=J6d3I;| zZF%uq568O$>?`zgwF-(aFC;d01rdnrDS5=gp{v3F6b?x`%=;^lq?8v2_4d(NPXzsa za(a$y-llxDD4ruMmZ~!dYlJ66frn|TD_t=1R5T5lpD$B0yChzu^^7$kaKcs^F68wM zMQO8~^XJFWnQ|QG9JvD*z9mB$QkeSiK&thBhe)0K%pab6j*FBGP4>@W`cUtYOJ&W4 z`xGqA!+Iw_+SDZbqMg19%adtPykFLk##OB?eZ|k!d>LfIu{L8*E=4zq2tTrbn;*mS zYT}*i?cZ|SMm#y#9l*#ahWk}ePyW+`TY6w4rBJ?W&?a{xUg}_dehx-WQRQi zZg^WW68DlNI~3^}xP3IOx@=H97TvvqR>v7+Og~hBI8$0{|1r1YHL!{%ICORBdD&Vk z`Ad*q?oFF3?p#$B-x?S2%)pem9|8MP$;?ZbN`v{XPSL1I!)(iZdfr5!aj{}1kILdsa@&Wb z@0wEjN%nnLPCJ1ufB5!}B?Em&yIFH?Iz=6Bl2f#&A90paeRsCzOa3U~P@zZh$c>AA zxg_+_^wQfS5leM6wuuGej97HcMtb(Ffsm&e{zXMkhOK#W^F5jI_$+2=Xj;{Nft z$;qT)b<==!l!x?l=LOT)Yh%JQ2|23{Tu$Q5fpozSqv`HmDxr7v^ECL+(@iY4Rvzp~ zQcbOUq29mxFrOMPq27bM)<{gOY;LRFUd&~jxajB*W91u#*4jk$Ov#)VUA%6%hvtG5cqf;>pv0wolbl%B?$G1i72y3A`9l?_wo=U1r={3lLw!^CT2EzgmW2L7#;P|DKM(vJTwUVq1gCxZ6AZ#BBh zRHaCZFhaVdzCOaUe%9T~ga-Fa6_(FweUQPU-e9`M^|si*y(mJg8-jIQ9GQh0%onS* zJ3m?~=X`H#Y7SU(zgNncNDpsio5^jsLH2U{a$H&RLCh*VFQFHU$CAH&tM#R;^=Iz| z9??7MC(W30J|MuNA;3yk%X?*Gv&o}X28B*T;NP-1&q1LjmjpfY^)Fn;;gK!I;4MsC)I>4 z39No8i~9%L^Yub9&p@ScUIBqnSkU_!Dpu&-R$^O!&MR4pFM$Y++%R>RD&$tnM<+o-zHAyiMbM@}rYz*C@AK#?6= z)%T54Z+-uMgmh$0SINQorDL^z6=I#}X$FBU@BL|eKKM0(hUq5>C7m02U%~}AZBOz*IqTPXL?6dY z*usQZ5HYWuQY{#HRiYzkkd@}hh*Lu^$M61!;@^_rMO4-6eMYFkEjOX?85R8M(cDa2g&A$yyXD4g+I)~KOo(BOQ@_`(Ybp<)h zUKcW^m(vb;-?HA&TE~PvN$9rZCZ~AGpQ5CosJPJgZ>w+jcann}DK1RToS_K`(&6|x z=W2?@J$|^!R1vSY#SQ<+tM&0pbl$z-%DekM)oCW38qatYx%O(rx`NBgAer&PSImCy zM?_bbTu)EWE2uNpgxhFUy_0|z797(DEFIU2smH8xacc%Fm&>cBwxyYfo7dJXJH$x{ zXEuUp17tNqvr;YOjlv2~%AETLnm#iWgd&L*_XMpS3O%kW@{G@h?6%LGhA2rESBH-B zV#}5s`RDgM1QBILT95Tv?@>!;N<8f7u;ncyeo}G8LykMX?WV&*;`Vb*6kok~Urv1b z4&trK%rdd-WW>StGquEp#m7RnoXj5oKn@J3>Q_78%urdY z(BkHJGdwEQiuLwi5fe6)f-){MF*eNVZxgnpWMn8T!x$@(p+fo-Aw($)n?W=U|M<^L z%k=bga~nH5vAEQ%a9H95Ex8MMImN89eyH!9s!C9x z3%(+cknVVu>|BjgI};fkd=t&TW2tF+n&Mgjnvlfe{>*kwm+D^+;g6}Qzm*7Jlvr0_ zYicIqeCl2i+=5TGao#=pME+LX83@ZbB01ECUj4{MWOw`Ac4ZD^Vqv~>PR#5@zh&4ia7?)+?z`_t-Ng`TX(P zzhTL*6A{WHOqt{-^87qWCDvccubf@}!wVd+<%Mm{Z|3zOFbvNx|IVGVS`Frm0ZYWi z0Oz#wzQ6F-<1bh#@|26a_dWltUrN~p)qh2Lj#$mCxl0)n?8zeP@S;sEEA&ncRINIf z_8I}zuQ*Gn5?AT7!ZZXVTQKtTxC*F6A*BG)SkgmF-t!@P%@`szboC?Y_{gR!Kp85x zkz$LBXdF*5AErr_1xM1ktAEEFTwH;$kf@t|;a;vvk4B7rvvtYo&rxm&Bly&Wh$D3lK+h zXt?AxH#Zm5Gi%$5SW8w5WhKVWP+ptzXH0 zW?Gi%3{$EVjJ%hnM@>OV+5jDvQP)Ntu~(L~2)%cX{O`mrhs4^vcIq(;MzAZVW+X7K z3AS-+XtuStV^j)7e~Ry0UBcC5jvMECo--tytp@dL+iz1rURgL`gY&pE9rGGG+|6$y zwBkQDB|5Et|8kCwjg{2Zy;I9W<~(5~pwY1{ zsUmW8cDPyPzC#6|{!2~{fC-oo^KP|9l~V%FbDMhWKj0Dd^!3q^ggY(E9=_&WTX80X z<}7q8@~^)D?>Wu!bI7mI!CPI@N=JLIMS18)pU@A2WQbpsirewf9hq#4t_c( z{d)0LVwUI~dXi^-{89^e$m{l%Npe~rnrHe%2QrIf2xVU&J$>GNW@gJiu^;XM=56Eg~@Syd(to~Y(s^8?{FwoGGvI?9b#&;&z#jMadEv@n7NGE;a;oqGSM$;y zng_^6f+>{PG4xW&u+2+K0xY@1Ua@1P^{;X-G9#opN$lAjM#phpo}GQZzH;aQI* zTu?O(|NTuEpPbwX*S#5tQ#loJ`yOlK=Ap5@JziKQ+L~y;EY1aBjAAP>V>FU75 zL^34@Phl$J@V3bEbM_Wf&L;Q_TibV2$FKx|d>&WW+1nfY`cfJC9F9a|WD_(En3wHQ zL(hkAMH7d~&6$YWo@fVgtG1kp9*xhc_5To13gVdRw$IeM@2&d%TYYav1~smfQJ$CAk9d~9${#b@e(t=o0<+yN-k&#ganvw!zbl+-qRN~LO z%a&?hlhAS=E5|f3Vv2V^Nw1*iw9ilxrzdJE_PgACwy%b$yOGBn84+P*ZvLC+@7JTm z&rQl7^0pIPq{CCoi_mkHtiqq-ey)AYso;K%@>QJt%{+}T{KxWXBi1}1YA||7JMod? zP}*9Dw_StMn_uCk;%Jli!#BY;AbvvFP4=PGmYdxBJ>}89x^FHLN9&!a@A@EO~*C3mI{%TrBFSP;`P z-Q0X^xfsBfjxeA|rU()nhV7r~Ewx+=qbT1}K}+VPkC{|WCX92nO1yo+OL;rBbG> zteDx_*-6Bkp-79H8%Zfk%Zf8cv83>GU|lddff}j}+V`;(G2kw)AD?X-^v4q_?O%#e z;j_N137V>O*gvxb)(5jaS}6ymKQ4Zx=8H7#S2oee9{(x1Ww3!HnZhqmCzmbK+LSE| zm&~_cWMBLOn3pBMszgVncuc5#x^_Jrf8+NihO<3HHlv#KsY5Et(qoX8L zV!l0FHqeR9%WgsIN$cylK}t&ynz|~kCsCQa7db<>l6o;>yMjzPL;J+8C>}q4tZ$LS72fHP zr-27c3NzNUzx+N#}yj;uu&$I+TMf>6A*utS_ zZCF=7l`f1n6z+UL6iP!9j@#-Z79%0HK6;CDZQ1JO4{x%ax_!LOa+}2M%!jE8jC&*6 zhDJ_KgeX$(7zh;<(o3k;q20H7P;YLl2KQO&e7kpgWFK0YKc z34V&mu@f!gIuHR`jXAu}w=2iT$4NihZi<%|5t98hE^*wk;HLlq;?2W0=? z-lSgJT&5W%`VOc!AgKDR9fS;0>=rj^$y80{!VMo5c};TB-jXwY9xIW_qMofrHo2El zj=7%x8s91^+OkDF zeKts7NWP~J6~cgZA_|q1c}_#-=yc@Wz*TTgX`DE^jsU6esp^NXuKUmop(LRnnsRn= zZD8K?ap<>-uZ9nxA!x++J9$=j`a5YliUK?M6>rjmZchJSS|x{vt{2;L|DMDrBoIb* z?49hHm~xVRC8Hw#5SB&Gkv-$DUF66eioIsLlgT}q?%_$x#6{~ysA9LX6eZTa)DZ>E zZx7ID$=Xe;r5(%waev+Bd#w76_Z{lcVGfj(aKzIv6zu^%f)5hCp)54xt45Q}zeo%M z6eDJg>O(pZ`d`apkvTa15g_x~XmS%w@%VQk0FQg@HF70&&`611N>ft+7q5z7kO8t>fc^yW_mC{fYPsGcDj9HLba4Ex|>L%ZQA3rP!LPK>W}4Li7kBX&Nb z)S!eo0aEim7?AO1A7~#Y@?{eFhpO9um*-od)UExN64Hs|-Np#n%UWWdL5ZiBtds zmx%1_zN$pzk)!!kb3f;arX%BfyfjU6XvE`kT*q~@#)wo^qSo~dMn*~2r z)Y3qfjBL)3$I%v9s_^UP!LJBqs~xouGRK+}Cz8kShL2nI3hCt(EI%JkKatIZ-Mqm5<;#~E&MBDcpl1F!S-f3XRP-QG0Z(#9UviEd!AYf2keZq*%}?=m zY;(I`7o+h|Jgn}Knt_3VG;h+%!IsgG)*@3E&>+}l#!49)~nE0^A4UQaIbDZ`#! z*C{unEaAy{(SiB zk&_cl!T?bJX8C5US6egEZLx2e;1Zn;rr*cGh))Gc_@qnO_YJ=237S$)tc-LRQnN(I z^tUGv6_`q}b^xAGK!0S39W(Z$y&FG;$7+iEZfx2`kWExrCMXk&U9k^Y@@dH_lw#fNA*8eU3F|l5kmiBFd+nfk8jG*AV`M0Skayg>QT1Q0>doH$TNs^Zt8F zOH0e(xt-PAv+xvNbi%)uDlI4l2HDbtk3M3uap;N6m9HG5TN1TQZ+WX{Vaa-Qbi^B# zD$==1`z8!@)squ`)PCyf>WWNz5UBV>H$UHvqULgoeq!4V$`Qmf@ZKZw@UL?Y1EGfr zmux+^K0g;Ff!3&g3mqYQq{V#K`)oaDi(eJH#&GA*02DZYIyyQ!{%yuaxPgJ@G@Uvz zfzR*MGQ|uDmK(=QE_3wTSovx7q=txP@ths-$&Fu|FH<@fwV=d92HrIF7Nyo_)z<#| zaE8wbtDDA+_#j(?FR2$WQkBOZ?VBc=3tzvn-+uB=aq^%MgZ%3Va-@l@EuQP&xJJ`jfhJOGmysv$1ld0t^i z?mixoQZsg*iii(7z>>Xo#GWb|N0&=4VZwVX-$sRTPzZGl!2^K5R3HS~*c1dxPWE;l zl$l7SPx1;pLH6$U`*0>IfXWB-Oqe0!cifP!cu^tPJfPI{G49O{G(K3o5lvBuRpRxQ z-hx5y&5ZpjNAtGZxz5{F9Kp2ylhE6zeMt#=fNn7XW!^foxQlMgL*%7@6fP!pq zZwCQPK+zT??b>@X71oqDRpVXyd6VKbBquP5*a`9Pot@6`qC3$7f%=su7L|6f{P5$) zkB!UA^v9Ut1U8Xy3sg~<&>TV~7saI&6=u>j1Ub|CmY_y~e)lZ!Gr?#DxxBywkM~3evvT5<}UxZLj$5Lw41-Xe}65RZnii*2G@x^ckVpB z@0yRjlq$Q3NCW^Z+O$3w^JmG+zrp)i`FZ!MbPkyzTavdEOdIt{+>6SnYV z9cyQ7--q0gDW0;^i#kcf7)ZaKA~<@0#B)$B_ADMlGl*k_rGV-5`}c20usYb4(F zo9UXzbNV#c&s$Qh?l6Xw~#oKiYf`p*6Ulo(v z^+6{rvFdhZ6QD7GVt@@={)QE*b*=*W?t7jyCcva*O&M8(*=x?_{$1r(MeVJ7)c7)8Y=3xg@9W zci2~g5?)%ykjh0*Flx*DI-fjx0WVf@^Bycu&g)inb#>V6AXwIZAt@MP{{H>@x0;$T zfZnMjQb=$r+rhBZ)E=QMn&7ACK%`JeFlv9=;rlav_cO6?LRnRYDDU&o6QycO*N=@o zjw!cPhFYYm;{v6m)_sRIw(FIT4<#@%XyBkP!3)eKAOUNn?9T63FX+eSbI+AkiR;e) z)Sk=-;`du}1I`WxrNUdZj}iw|=qa|2_IAgG=9?&80CaH|7nfWOW{z|1K-{8*HWt0lIE$@sIN9_ZG&1tC-%heYSzqL7i`l*oJWTRdq}#EM9( zn1ffffb^QiwT!~B8G9MgwAG25AdYMvI&W%=2}#$#fvSLU`_-@^@<02qg+Vl| z->QdGWR5rk;0Ck>#_v8bO7(xzT7+P^d|>>-lT$(a#*8^`5h1)CDnV5+X`><#RQ`l% z1`qKQ?T!U=oV<~p9WFexLKlu)e%HXSlxI$$uA#R7wSbrSFQQ!)eKx`Kfu}=xZLje` zmzJ6{T}GmZ@Gt2%yk>mCOt6i%pC0_H(8FDEPDIxAdz<{t#l)3Fqt9uB4r9yfl2*Xa z8^e#4iH1|s52zkMFPA@TF(^cs#N8*8+ecsPuIs7S9M1^idm0IMdK_{U2Mh+-*w{eB zRM?%^+;`_1UG`V?jBb}0tiMai4eBHrCunX!aA2g0GQB7wxzFre^S!cCAo#UP{BAmF zrgT;SSOTkkX|N$pyu4ucT!X9Y_Ti3+e|M8`5)3rJjPNU%?CqWlH>|@MWaj^_bc0w` zEZ|gb{#hrnZ#6MPgz0#XpC`qNAzq z-v_gsLIwlj-=C|fdbb-wf{;5|ao+Rx9K`>am>AHpWYh%7xwk+LP=Y0M$<&#ed|D|J z{V<&y)d4g4G=9boH{>%)zJGtq_T%IlOy5!#6I)wbWf|>hI&q77M;wu-IJ0Q*m zK!Z!W=t@I97Rq)kw9RXPN*D^d7gKz!*sq$Nnzgf=^8q_4&E~TY0cctgv?)S0thz|0m+EZWi%`qO!6}zEw_(*1KQp={Zez z;obooky2B40Jw#e4k~pdpG^?n1}4zBP6&_KK+Bz}o{&?e9ygAsIoG4dd$^6GX)lJF zjYvDnNdR`9H+MOzFH1-Vc<$!K^(^hN7bJv4aJM9zyNqqR0tQZfQmyh2ex}u@99!SU&UC%N|z(h6Aw)E(0bnZ1uV? z8gDqrBPdr0i|&l}MGhK4d;lfChqrm~3Z`H#j;n9n0pS&ta+qOY{Xp((WwmbVlJL3W zV&cP5AFJ~T6JJIc=`=i!DI*9^V)Zpvp9LG5mqtEc64 znKlpQC>!x63EY*Q%j(S$acrH{GuBsk$dk<_z;6d!tSoj(+;Gyy2EH*E%5Vdx7D~5~ zx|kak4;dIdt5yL_o*!-FA*Ig^5d6_=Hwo{oi{5EM%7!fyhd%Lz)qo;|cxV)rNOMk_ zZy0a^;NgE3?gks>w&hINx-khIa^b}q*l?4>E`_}cp)WLo2x;A6Q-~Yo=Nm(hfTd?j z=mtV@K@k)EaB0@Q^7X6>-;C4zN)0&X!XRWq<_E$*39K)TRq@Iu-a!CbHN(=|G7VRa z{E`MrKBUdKhv}h(+VuTwwa|$j#@JA=J}XONffqt#h%?cV`RCbc9o!`6 zevorDDvG@RGA&o`Tawl(yMJd!E#*IY4zCZ#{n8tVtAGSE)JjNaHBH1A)s3CsOnCuu z00{1(*zJ{J_aoYe3B!`mlr5+*w|i!9<=FQJq~zcaT;=(^3zE0I_Mr-EaffbVJ zo{3v+{j;12^Rfpd;R~_Kq5%+(JBB<5v~J@ThA)5JJ?DJm0vIyyXBX!Vi+?)QTYB^r zUqE;njWj~~L$}#16NEzW88kIv*PK{{w$*|&1Pc%Gmcqh9U`$E)ZIBZHhaNh@k2urM z=d?$=;Vqp0E#WyKNTHHEkp4k^_}KaE_}x!pVi9V_n@Sb3y78~w0^IbS$|fXfqZ=0& zX#vs0OQ^wkLWcXV#mp`R@$&n-;Zkn1XpY~*v1$X`wbRRvnEC?88EwiYbe40cgt7J} z9>>W;0IMAw5BxZy9230jO1YZ%E9SSAoLI z7~2G&QaWLa>;amE%Bldg08`l!R3vy;konQBcJZ$ox9LpF!Lu@~O`G(+@Bcee=nis1Hl|hSngIKU$cN_Ndd;6@ zsQ812V;)!PTUxwQR{>=OtGb+|qXbYongCSSnDI`#ddC4Ma zOHZ5pQI}Sw>v2LihtqQwZPke{V=S{}*Yq5mgUT&TD|Lwj-(;l*WU4DqOxX)=-w>S2 z4dzYg&d_0@vf40cSR7XW1I-3l4Rm-)!F3_2Kw|U|*V>jkHaonH*Oe2tu!CXDy#@Wm z=oT8k;3JZ79YaIEC(LtfXFQj(NErwgf)));cfq;(Rpk^6g$yQa#)l6H@sL7zBqeWC zyH~1;V>9K9)zn{q)+;LImn)lS-Cym49<93;6ry*4?0kLT;B@er>6zE$vD&-l(C6uP z;liCY;g?6I8h53dK>0vfCZ6@bW~hd#7_cKL-j+O$uRs;d<(VreW{}xOD4GrS4SA_! zhITHJT=`7eaAWmmjA`Ng4$jB(#gzA6@xdE^DEzbk( zV!G(>e3S|lWm&8K*5i9GtnL?h{nJ%WSuN@AT)z*})fE%)z6JhZ>+dqh#|W(Qy%Yq! z2ZeLtB9sKchAr270{FVKv?ovk8YSL^_#paN6ya?Fa+tRO+kl4wjqhA>hUEiR+<~O_ z#cG)ATQ?gl)YiNUR16UONm9e<{pkij>i=0=pd6@Z#@#Iiw-v;F;F2({IK;%FfXje0 zZ_C?lENp!G=AYs(iAozWEWD(%S=_|~fsK~Yzw~&{DH>5EHzVL0?Pu#kVRS-vpi~Ks zOieDPYG|GvBZd2>Eao}bA!c3LcFcD?q<&?RDALY{VlID+UG~J~aEvxfJp3E_VY1gB zKSp&Y+eGFimv*s18+Zh_i^szE_MBLs^?N});}^EQg99CTgj>j-Wi2rVrASmizVWw^ z5a}DqDY8@tpNtW1{fIkcPR=;8=)V>mzww9tmr=Cfd{3G&Y5P5LAO$JaAj)t2DM@E! z9YGEj$SsD+>z^|JfLab44_vtHP)GirN6$W4%JitmcD3qV*UnUzZTmaL#(Uiv1#L zjlqo|VY7X?Q06?c@f@n7nHsHe3R6khuV z4-e=`a{G*8Yp^v7q|Z?k1gZckY?Cobfe~UMP>8^wTXv33OihC(4u+K~s;fg!PhX>O zc-FuVJ{FmPkG_D(P(t3uLzPcLv0d{Jt7?Ks1AM?kWG zlk*K^nRZQ!!R3IY%H~*c%Yq|gygg6S# z=%^CEJsXv~`*n)qm8W8uBM6)z%DH;Ri{* zf8WO#1(Uu6;FEfs3<2Rm9q!!4A!V_)9p7Ui7?~t2=>DK|0gwSd1~4!9HXsfxl6RRB z4Oo82+Q0mk?qx=C_WC+V#t_N@39e~rZ@vXztQFsPHxTcULBU8Ev>T9?AO{CF0$qyI z^+p?!bD?@9y&Q_bMEPBq{NH0gV9G83!H`lFl$C}}Tdf}%R{;sb-NP|MuIk(u8*0ye zH&)MQ@nJX!hrVA0X2 z@~%cq`aiu-%C9&R1w#Tq*Jz{u`g$uXT8T|S)g$B4pAggCIfnK4OD&~ZLvCz*OFaQ| z8}k$C_n|Y~7dH^eG@4S2PY^>s{F^ko_Rhkg+|09Vc8@|39I~JDUNBneI5K0r^lAyE zEI9n+uZ@g`V@;6$M#Ucxf^dXo_u|wAsvU1#`%FNPz)F4u06w(IsX)FM8GCyt z=PZERPWASgogEwtF)=Z@s6okjwKE{;wxTkMKoq02ZF=O23f1!F!2vrtS^Cd42GGmu zzI`--H#Ga2FPf;l9v?5 zN+FEWa9-Q+j5AS^IZn`J=@z&cEZwM?Kn&?PY}mk0tM%Ja!Nb4t?cz21tf+7aP==@M zq^+QJ!odoGY^D2QttKJqgZOq9GHptUj3xCB4NBpV@6TicA=S3O%U``49}P5`Upk6P zO3uUjMOwN=QOWAyhd%X*7g%k&Aqh&x{E`@E1to1 z1hQ~TiS)o##0qxi|Kf3=M^oOay3Ds2ut5yDLsIf%Qc?>lL=5|rcWqKcr(gs^11c;e z0^zcWQUmGuFW$T5KXSMG@MEYqyDifVPYX2Ei$w7 z?bmF;5oqWY`6(+cp_#VwB_!B4|7?He7M5#QL!#|+)+;@7i|NTG{%5bgQ)AS>Q6eK? zYh@UMjQq%n*|_dX>mit;1R)f-8aU(wv|{x9i?8|F5}Z@Px^cvfO}wtM9(r^G*Khrp zhm_m$Iqi)2Inwlb-?dh(lt~8gvp}(`%nQw?bh_$KRI+QC{622fl9xRlpxq(@L7q*S zaBTG%U!-*jw`+)`d`Pur*#v(t1X_eVEpIJeECQ7DK3z!wXE^x_oWesXFA%5b?!jAH z+`%voA;-Z0=?0{((pO>m`TCm-1GmHI8RVX3s5G`9@r}62OG-=MfFSE+o%$tzTiZT5 z_2$n(v|@^2-zFtHH>3bRBuXK71g!_9oh>v6N3Q!AZ!$>jg9YlHZxrYr+R^Q4C%7+@?G2 zjL}4AulXI=Cw-|RfdIFlKj}P(669=UCDe_F^93#WZ;hi^t)BGPXXP3sWlpc3fi4PD z`1dMG$btxQ(@I|1jgs>fejM~7vJ?|URK?B^DDbFVdC}bfTM~%JnaX`c^zs%$5FGjD zjbPZqEXT~)0-<4{nI`n{4R7NJFb@LaYuz5m9?Da!P81bu7OX3(r5pd07cK|G8ai>u zFtZvVt)ey2IDyUkmYUthKX$JWhE~}32^G)~2Toy|(pk6i?4{Oq!-%7n46Jkfai1;A z`mB659Z_7=VR@#@LZYQepY=rW`(o8Z3Qc@{u7VnzM*UBR*XeQ~{j(!M6Lt||I&1Lb z2h;4cO&UQ(NrlhO3Aq_!J*#&lV(9V6Ta6_2ej(!%82%zc=y(dF1r{`d%xW&}ArTV6 z0I?%_wLaPPI@!tsUi^zcK6vzN3Ds^sr+1Rga}{yt3~OQ6qtc0VQgIz+RUJIu?v zT5BaR%!>RI)?Ei%b7BHdyob)ZN_(;yoIX4z+e;bT%nXpv84~{P1_C_lq2}j9ZX3n^ zAdb4Y=b?NY^f6$aFQg2Tc94jaD4STm6<*JY-8#+K!JXFkEQUUnf84qPq?i&AJOEk3 zxg}dbu4#S82ZBo2GrxYDJM8Bcd zO7;v=0^bI#71$M9K3%0auU6NEC$Y+=7R29L*x1}|I2$R3YH75!QMLOzV_(K`&(C3; z#+<*r`GMa163A9k`A<_*$=`;r#>G{;Gz z_XVnrYjK_Kwc5t<#!4BEy}=W8rm*ybNE|)UEdb5{`ex}mw#Sc5us^8P(c?c+a;F!4 z?}#Gxz{{a#t*epVrW&h@KXiK$kR!ykEeX5*zjCtGMl~-3kviY z2Pv)4#yn!A>Sw>RAW2amaW4yLUta}n0{onl06G0+clB?%)P1N2V0fB;?WFtWIunS2w^L-^HrP9F#=$McqdM9myB$`tilfWd8s{nXoQ0EbVih}mgg|-=k zg$K_2L*t%+f6F5OGp|vg_7yuj(*JV~j2}=t`aa)_sAcH}__}&40uVa*9ff)j)rC-g z$$#f%=c1e7WD4l3sMEuwIB=pZ0K715L!aO%v45nA3K)Q$ZB{Q23U@G(y`wxyijc@e zxfW}noSVcj-FjqJrb`?y1+ilzE2~>5vf%U9*Q-79c87I;sLE5!#3O&2krK%N!NH^A zvD=V}t$<(;2AmhEUpDTJT-ysP)&(q4cD%RLaZ=E5_E`A!-_L;uT$cA2_}OvR9}Zf7 zY2vu7`8v#I&rT|c=ySimhmk7g7pazqI_TD&z*aW-K#oTJMiq6Sl35Y78Aw?Ia3X260Y{gF7b$pLTnd_ z0yLyJa5@{98l0{J!EGKeiAb8y@K3p)7Knd#wzlaLwu_KY18DlsAHr)cYO``n?3;=g zA7KYTnh)G|Q0m|$RJ>odf&(0D7N+U|9UrzLJY`QUTCy7yUO!*be|0^l8Uctxl9Sp= z7cNN)Q`b9Pb&f0a77Q(_1Gp17R}ZBP1y1sc^dJI`p(h`i&ph9i_C7kYX-# zNJ@_ztIpNS0%4NXyUy>F}l``fFheQYD2T*d+1C?%0tMLAy9>|;P=MVXQ z$A3dt)TD}Y=F2;v6y{KSS@@k#{eGzWFxydPcm@9+`~9Hctqw)*5Q1B=m`{o*%y2Ew zsHL=LQmbb=GtL8Y@nkG3rzp3rjICd8irb`67A@>x!WYSkTQ{Ux<@jXP8y-x8(FdmS z)zRF)7pVLu3>MTiGRM6EX7$3MJ{SnB%cx}Xg_Pe=!_Yc6j3ST5;RHk9P*cuZumg4D z;fxdr!|Y;WeYQuj*wSaGEJQ+x)?*^B#>rJL0;kVDjxi2(V|_OFf_cAGRj)0K9(@ao z9*}#oY>=l#`7nIur%*?zeJ0za4gUs@6>j<3IMMz~oBpW`X$nF*R=@v#!vGUn(z^mXQknIcjH)}(*ph__=al=P+ zTSOp2WUiQBEy!1mDv<>7K2*$woQmxAAGAnrjPkVlMTr(8x&;GCrX9IM@EJtTy{(C|$Q^Y7$s`8C zG$dq*AQsXD2ZZ_ifUeAlz;le2y#b7L&!f&JshC7E z3$x3Vajn8^(@B$z(6kAvICKX!1kR1ZN#oB$R;a)_L{})sWLn-G-Jw_cl#-fllq!^A zal_ye!+8u zgBZeI>1muk^^=%LpZfa$!`yecQ{Bh?9~2Fs(#kck7(*`Hc7bwcbDdk~SvEG$wNg43j!i zQD#<~jU;^O_YGg0%2w8@|8?>3o3n?x>EP$aZHO+~B)_xcep`*E^zrNK#WG>!a;Fwo zKEQtCg*Ec;4#@bp_0iB&>u?XMG#Bh)UzH3x^DjAy+~RzmUEoK-e>qZQG6R{Zl1P*y zw+L@&q5D7e(<2-|;%(Ea!!y4j6-vj84*eToH_opRJK&@x02E*ancJ%ahSAf*9SM0D zsIdP{i)!lfjqok&cjO#p4WLk8`b+Kqt)Z}pvn7#k*(e~6-z@U2Gn)RP7E zFOn;(J*#Vfoo}QhtbWy4`Px#G`@c_#ja@*g%XuDlC0N3sO8ysg@y6C%&pZR6Ajo|} zDiF-=e=6S=PSzhF{DiIFxYUEH-)Z)TUZ@(W{(F>pG_|hyT4dLivOb!S$Ox+ae+Kkc zHce+`fARKL)T%(@25<<#94L!%i@Q`@&**YuC;wpulS5tJVdtJD&akovYZb=;6r6X} zhD({((k@2MzkWKz)3}F5^G@i)aQ_$eTtgZwhycrGSml!SnOngh-%#8`22@a1@tm>cQV&f1WQgBG}*kYjW zcfRIblCRNU@56J;>}21sYA??}Vwe0b)L51)o+(o-e^;G0 z9kcdUw==-knz73eVO(y<#CETa-5Kka^BP@nXA2l&rZ-YYirZ%dq&+Vvr`>frdxGen>58CjWo%}>+cn?RH&8<$8J%ShhE<%@wU>d9iRNT-F>4B#2Ms2Ao)3Q~6_;#9;caBGIfO`@UHXPHi zQ{esuGLNzx`46vQ@&UYzhyw#bSQhbU5eipgk}sOz+eKFyu73vw`UXluL<`On*LtP5l8-B7axGsTg{V34_F+yXn99`%>po#k^)pZo6ez~;tLza>P?W}odw zPFiXz(21yX@xs@A>q^5dR87wp^sY<+RW(-%#dJ`P2AX zGxs2bAE)?l6Sf^lc>&M^H}~(G{FzGiDk}Mmeij}7eB9?Qn@*{d?BnsxK3~Z3tjGsL zKoLLq1bX~o>~S|4#3S7X4i8BxT2{}azP<5Y6KO%M&^nI)0SPQpmVVY?(~Y)TynTF{ z?c2A5-s|h@J7a390;~&a4D^OAEN+5?7K3P&FH3y<^l9kx!{hi039}{4D;rRoqSgX^ zq*WeL`pf9?MjS{Wv%TvqMbb_3Dai(W%ycUkkbdwVb-lFCe1m-_E`Vo33o4CY+tEuU zJk4-UYf{cVDzj*-TP2)YI?9nIdX9gsiVbituu*J$1={6b(NkO_w=@Ky{LmkT<`6IV z_UODMgZ7l#e1QrazYWTx=JSOHg39h+=_tudWqp(2NK9!S#a5v!f!w6HXM)R@Zfo7_ zEglWc{1a}+N^{MM+IgOp{U;Bw&W1)0=K+kmr?x(9@yQ~?m;MTe7=A>$*rnoXBkgey zHT#-JaxnsITxx%+I$9vZan-APMstsnpKW-?6Q2_x4qjj@`ZiaF`)BO3UC8YxVtpVu;;RJ-v8p&wi zU_`@G`s;JBuJU5h8I?ov7yUsEf)V=#66ZQ#eU#O}hh9Ts=-I#WV-M}NN{&4%&IRwe zn()2D4HF1yHJ}DX1`Fo>kf(Xgk;@OQ8vrcr`Gq$DjW6CHh!j9}e1sCWq;E2uS(N1v z0!N^v{qoX>4WVZo*1B*JgXqG?mS33=B|IXnHo#lxRru@*FYmSL1geE!gD@69Vg9H3 z038QJ4vdO{;hnb8+qK`mN}SBs<-2$?KpaRMf&14FLq~_R37?O+>2QEAxi_S>75CbR z0g*vaAd!LhFV5yRIOEm@Xu+Z8$0wD)6E6D~yyz^h;z5pyv3pvAFFSMc7iU4ApWJZFYB;zMJfU>RO{YEk5w7v)uR z*#)3D+b_b-6Tkl3dHdS)zmFs)CtkEgZ>%pmy=#{}a&@7msPB+h!;MLNcBXYti4#%Uhhh;)gVm8z%V@ zj0ya$X;)>pgGIqY=FtQ9*t1bLX7DB>*7Lb%_mHTVDrL*#63doe>1t!QSOsPyB3om3lq0{>o^!d$F^9jgyY() zLoYaY%zcz#rE`?szBgr;Y*G8$u8gkChH|q)QPBZhlEX7j0vGrDJBlQr?OA$4)AD+J z?+T722t>+%9vnM#>T3OkY0bkt+D4sjldM-;m-0x=sq79H!!I;=iwx`E6x>wq zqS!b0TNOuw!C4efI0rgisZEib$Z|}WGV40ijVcg zB0d4tEDlHc%UkbI5>{X$XzD?eg}b}E&AflZgY=bsYVCD1jG}7oA!=5t+*jnh<~FU* z`mO0;UlNgfTMn6)-#{FM^AXqoVnuKy4MV81627Rtb!eosv#8X3fA*uE%h(qeTwP-_ zJ+MrWYxIy#@PVB)LXFdDEt@hg;Ne)FY1|M zeXag2$TtK3iH2o@ow3eHPwRDRoTxXxn>Z^RqgeTn>tAyCY!S3AF5^QiP8%3Y1N~+W zuWg+0@DAMdTkA)t2Kf;t~(xmn@W-5!Lv z97cBdGjPzQ-UKs91T_(^S;2cBqWZ2aZ|vpQ{m7>qk{nh^CIwgj_~VsK=Ym2R2NWezPF+Gf$s-toJ9GDLj;m*$R(&Qwx|ZN?49&USAbRwRSW7fn2vv3=9il` ziL2^NLlhj`QKMd44&lhGXEBR9SlG{*QQnNYy}+z`xz{?al=9VheyK2WdE4Jtg3Txm zR4$vox}uySbWo6`HM#c~$t}Oh!~5{eAT!65)!*P!q<{f!loH{7B>3>`C)TZ*s}!g9F*B>77-;(*%aFSe*${Pzp!D&c#gSgIXjhFP8R?A@?;6nC~2S zobDquP_R6WynLW9Zo|lNGRkTI%^Cs@VOuz|TS{hE zeLCgWk;Ej#ANJ^ugZWE($o=~qE{;|km3*U%ds)5c-;Nl$nNE7hy0TUVU$C7F(3op` zIb}SR3+X&=C-DHRl#s2aphEjo9hyxX^fY&D>TFwcI+e688eAE)eRPOL zsB)*w6X-sjM?P_Y*}xhaLi~pH2QoVA|7^{uM~L``I4hjiU|!)7<%-hyO5_2+a*fzC z?;wr1%!Y#hGINoZt4S8>Kbz)yJF9Q<9p`E*r*Lazm^%0mM2+EQ+)B_>moIb0yhjY7 z>hPRo{_6_YkzZ3))6a5Hu}lYbqO2l3A%!oOL%ME@2*OQ{G$m`rSS*mJMg$ua9(Ly9 zj%u*)65o_2{-3;$NEsqRMv)$U5q6Ei>$7yYoEsUYt=d&v5)6>hTi7*&f18M405-1( zDi8#8%ypW35or#q8Nc(+xST~Pb=Ys|IC>5O%74AOQznbx})JEp90Z|0!VW88`;P5$ZSzUbEOXqzr+ zVCHT8qi@MdABfcf8hmDHB$Z)D=2e9>`C0S}@cp9db&=)<$IE&b=je`_wLgV$?SG<= ziObj8BSMP13A`mqX_{BR zTeFJfY`CT?S?)F>la<) zC$W572?R$-uw#okriW(5aW|vn{!;C|%eN-A(Ac}6jRjU!{2d_UkuWKx@0xfppnl-F z+JH`(OwjJlp|)4JmvJL%x9ZJtv7V+>U7ACeb}yVc{k~B;GXslTv{_c?Htq(2kT=m` zZs&TNRY$*rd0hCDKTHx}zjkyFq?`YtjmQkarH2C*`pI17gEScr6tfM!JN7fx(rQMh z@oNPNJpx&Ta}IUnLVxsLu6@WlUD~sK@HV|v)P4&X(q}TzNB{0UTW)0DQ_F1KZrs>La{q$Q9#_iCwA&=mOzHtm@C40{-te8251Y|%!7n^( zh1~cIe)f~wPY1KB2sWWslNaT0J1cmv{KU41dN5IV!cZupYKMMl`jNdT>)lg^JAi;8 z)2;D z7yIdl%LNaQxE~r9i*}>8LH!B_3zeA@VY3epcdU-9H2G8rHrc+4+$3?Zci9| zNM;?9|Ai+wFHD_V>%juRJN@zFN85|iz<>_Bw|Chjf1&Ci&g-{~Zke%td(};DGO?dxG*Mil!~s0z8mm1ZUmcK_M>wXj5#bs9gjGY zclNndR@Wf^#U(Sbr`me~g;kZAH9#}a>@WZRJ`TJF+S2rer<<8)zzRUN`xU?h3P|KF zstVq-*jHRp@&3i8R@wdj>DA`UuMdR0Nv11l4dAd482P(2yZD;H_Z79v_3JPEqXulm z%Bv$ju!7m_2rh-eU`E)wS3YBOAXpDxXfiRv~M z0GOyYvmR(kyChkX_C&9&uuUE%Fd;R9dJ~aT&8V9F!Aq8-DMvXSf6V z2A}p6^TW(!wI}=3xS4Ry;qTQ}2(k5uN-EmUKdCHarX)FihNp|^_0*GNme-??a+lhj zva~MlSv=3ZkLP)yjd_HY!1tw)@K;Y^K7Be+-8Nc>uKIY`=Mn*}gf_+Krc3C#6Z(%k zpdQ2-$@%(xT50@+?c6Y~0WZUoPsYer3ZyFsGh=K;P zttn;~73v+aELlq%Ec&)vks_9pKBsK{2f;s)xY`-ZSgN=?c`KR=d_5;V@f@PDGNy1# z+H2t3!8%uc%u-J9o87eB&L5t-TC6*HhkeU=>x%<0wB!lmNGmf+-Z;GPxjZDqkYs#= zw!rj5+KGDHXi)Tcw==ieE>V~44Xz^cuqrEwl(Iyp`y9NL@z_I1(cI%ZU!01)dL9G` z8d}u3z|+__>ovQ|B)=n4MTjI)^zHyP5dT16Z9p^%&Q(zZYsN-H?}kg1$&B@7| zS9%Tw{YI;BO1wX{MIxLPR|e5P0mX1HsY~7%#9}aH3E+Y_9^eRvslFc9Yryo&75cks z{>jHhep?1(g>f`52?nq-|bN*+Zt;h`QmD1VnW7{(NNVia=Xs7L$6ro0f z21J(KuV3GkffDhVbNqOntsKIwMJjyA{kHui@P8m0MQ4tRveA251>w@h9fL2VTs_{6 z$|md*Y*9eT^YS3w;1Kk6YtA_s<)s#UnK$}J0Fy=HD!#qs0LH@B?StI)Y zQauo+`f^yhwC6GrRFBMeA_W#Sh0&|T#6*kF+(q8GlJQ>20^Cf+6zwD0fov?7bp5`f zw<3a&aOxP3Ah!}G$+#<>og*|G+n=j#P@us4$Awo7Ne#lyw z!4J^uvM2vAtXAgdY^|vslI}sY9ip(xdq8eER>bH)@ z3TMo!9Vl>%EM;Q(&3vcv*+*9TNskBn-~Qnanh>Xc14k7vAe_D{HE)q97ixHFeMDEk z7}yZ;Y&q9wIKd$i=}R1Yq<=;CtigmaTvoGs5EbA{Bw~nuliOZLXDyOIM4;j}BlI6% zeyd-$(N!xkJyd*Zb4R_vIn@mfxY+>kd zkVA2O{qIaYarFWCb^KC(lTFg`Y4-=5hX>X$ND2EDVCkkB1dSW_x<+>Diye9O_egj zXDALS&;oEDDRZXl*9bK+um7rLAhga8Ly~)AuvJm!p~NQa&8ksm*cvIGBY(Wi^)Ctm zhD4MW>>Rk4dA5yu`dBocer)*V#kH88Ng{L)ts3cu`f(sz=naXizmIhbUe)Y|Q5x-7 z3`E<8Xu!)7vZuy1n=3SK>@%7LG>e15qUemySl^sHjP$slL8T~OjhyPy-8)6ceQTTW zcF!GOT5m9KVbt)uxxqKw#Uqk@Cf8tS&4t@tFyt0`i+w2q9fy8vYqL>ZXxYqM5p}vV z)F2iNT!kr)RiMa8GR*fv8mO`>gY)t}+8sT>rhQ;c*l~yY|r;?B~6;gT1S%wn06DOTP#0YqYV+26uOhU4&Mq}YtS(VNZrI>=X#FrqC^@E> z&ocDPT(m=SvVt~##Bc$Dz*`%Nm<=Cyl$*xFT^ZMZfF|e}Mf>ZR<`J|y3GO=HC!=|$ zRQ3i&bn1xx+Ru_io20nwtc}-eAq4XhWiMI;0&PXDGjm2cWT!wSbbGjWh**huZ-uSm zHY!{P8(eovZ*133d~biC43`(raMI1mA=k0NHxE{p$9!-1F-M3HmP|f)72#x&8*CFEDBZwC(*^o;Z!V*E@zMy~dEa60p0el9?|+q+mVQ5b0G%vI2O6(|iH&-fhR=cZ0kXOMF+bjCn%CPyAayZ$U^FtL5VE3job=!t#rdD8sbi)ky0 zwx!_7fFUB094V1Mq{0B?&@CbJ6MRrt($$cbQKxJTZy%pzjuSE)a0)G&-19$mMz+|FjUa#8AQxeYkhvC^@)y!)7D{{XI}hS8q|2Vs*== zNk9qn*|7DGzHhP-d&VQBItIA#(3a%cl1JROe|U~KQCII`l!OWY4Nf||`7&DFYBNJa zzJ0A>Qy3sZCB360&HwVp%~`+s9&LWBX}01+cgyAra^DvW7@lo<@0d0xes7me`-CG~ zN`~nSLvTZ+zKZ{8EGdF{NG3v5W;~Pj%{nfmeBj5UhGIhKk5-qucG7+MY>zyp^j85v zme!h9y3ssnREZf8JzrPT+PS6WzNQdEoqS0VrcOXsLkKD) z(qTXio8&{732pZOP^DPbGe6?Zk)MXa4V>j360~el^sc>U>e~4{s?KDPD%E#o=&?&1 zKp^=Z%opaK$t3?YnL6?YL052AA^!brqeti`O}l%{n{8X@Se!w^QyCEi+0yszI2VB5 zpqFy0mP^*I`56>a+=)mW0^dRihVv+xR%dTU76%u8oWZg#bKj^Zq95bLBwEC?;Ep>xTJfVgZXVek2#HFP2Kxk>tT6PQQ(IT5rMyGj zxAM-J6NusD6We5os4P^u=wX{|(p1rXBbMML{tch(p1>V*j3K%**YdcH!_&maEOZ1& z5@hCdNjUSYWuK%yXCLbs45cm8zpec)mfH=&C__VI;Ua{Q!1qCP=i}-AhDfhKpT@jJ zcqTSXu7xFCUnaV8TSK>gb#iCR^n&Z)Q)K2kEmCh(@yJ-}t3FY>UB!0HG5pt4HL^vV zo0k{sKN>%h^`yhu&!cw!B~+nEdqw9v<#4o-@$9D{v1lX)&yDJblWj`AYt!nu z#F1Y8C&@N?T&nD69{YvkIn|SXMPNalPs&H@gwk@3{XP3{06e|e}tQq|9YlVEG`!l`Jp zrU%)Yu9ioFjkRUAAOZ@comJ4y{$%!|Co0ptpG0%1la(`~&cX_n`Kd={g z7!GYBhp5!#uDW_?Pkwbl*)Azp>T}UNpgzATtY)v@CLFlv{ot~`u!2gi*oO9`-T~$< z%I_-&7*vd8<-+QmVD(-M^joC4zP2=C+SZ{Rkf9vJ?JYtHOXC~DJc!K>Y!t7~>1?uJ z|yd@5EF5I2CR7%l12YbxZ2wp&O@=qupp6M8&9>Z((W zq0GcPLU0*@&jdbh*?l2I=0?1KC>A{dFG9mybG%MX#&ehm@D{@kBd`rv7&biA%dHjI z!<<U%L)BSD>)$y^}CC?B2xEKkRG)^tNei#52(TO7^u-r`N-8puW@|d%~ z3xg^MIFH@$)AX)lKH4#aJ9mxW0kNI>XJr)y6PkwFE_1)8&xPLZ+AXWQ?v0SePx5Ua zFS=@fb0=NpeIJ*9lWiv4KwzO)p#hhKKSczH!?s3vZ(&sR_?XvW7dY&cWPkN18ef-H7n(_SynKdxqm>9toOee7mB5TH!<1sid2CWptL|68rT$Z+SDXu? z7jxOkKgK1@5S6YoONZ6G@S^a^lcyi2xeBw(B{GVpFfDTO25uhb4BeK~1*QlY$MG1@ zHfs5XD@sXKY4^QjHVkxvD%R>k{kpjUo9?;sh4$|R+l|Vv!nEL`hgzAn*7%Jm#q1N@ z_o5o4GrE`xHBHTj{R}SwmH!nk+Qk76CZcG&0N@K&uK9!nc95O z-Thv@9=)C2<9M=~%XZEaMN|7(c^xbdclzgcCHdCCn$c1n2tNlDB7Ns2 zOk=Pr5DheDC0^Ws%oXIcAk+yL^KL13DW;*>vqC!&%MVpR#jXUg-B7JxP{G?L-Ph+< zBjYD1m@#1Mn+ArYKWSQTttop_!feAXXn|CBSO#GxbEnL72wuklJ1sC$?mSi19|38uiaf*{{7~qFd&Q63?OLepakW5xOT0)*Kp!J&0%x zJ=^(-yE5OtOnl&O>%inl9rH54EYV&f#1B~;I4^M@b#9=U@9GltgmdFwB2`T40aQM>`u1QtRVpNBW=wKF`4`-^7d0N^ox_Z*RSy76ugfVpl&mH9xoQZ(Z(VTtFR#+7PML`UU zLyRyml^5%4E9KXhL&p6N)Ex=aAel ziYKc>ADp}X2_-jLKqP^FSROH{4`wIXNy4FYxxxGG(?|9hZiiICHWXcac@;`9c-+{o z=Z*iIT?#jl&1aKt^#9;THkwb1dRfgE{bXxz(3IbG8WqF4NR%2Z$8C|`KLl-ptVg-q&>cM*zrI{94vb!hA3> zwr80sdY7~B(&)d-eWsTjdu!isR@L8@8ffLS4K<(tNfY?f4|xRP2;yz|NNGZF|NeoH zPePT7YXWxy5%ABV8TR3A^cJ6!N6VM59d^I?jF7HwFT$_lZnmn!ggjL0Wqtj^D;Ewk z?z$Paon@=As?OMT=G#F(@)RlafptG=b}a5Wf>z3Y4r-IY7g!+BWd0MK278WaABVe`}-+8%*L!tL&G9q9e6JP5Y7Ihm3$_7zk|Iz9 z9GtN~z%MNV&X_^!`3Cgs<0C^OkN979*u9?g$n5v+nP&k+1gIm4(d8x8O;UV{&5iiQ zM7IE7m;iRLxFL5I_BM~^*|Yszz7ar?TmOc!MflF`1C;uWNRWQQHdoE{NFI9*y{#b)_tGB?sx;2@a0>L6H{Q$TkEp%p3tkUh28I4bU#!ZJudo~pO=R-=t*~3s_iwE zMV@&tK&lw33>rM~CR1{A_4k|Je~crx&Y8vT_`P(UL-2~l0Y2$NmMxq3g z(ex6?omf~AMhC2w)-Q6{h}_yXP|U| zMxa~wkosNy26NV;j^eT*_|KZ7T%BkFLRHvW zGtCY>WPN`O9OBEuIn3@%$aI-Gg@6FrJTs=csQ}-1j$Jk8pR>F5|Nfi8@Ied4{Fv+X z!QyAfzWD*ILp6ev1(t5~T2O_A9OG(f-S)6L9;?9b-9P=Yn-iy(GebDrgoytrZht}WDHD)xUdY(~w~vn{*bWS)Y0 z`Zc}2T2qfe%eM4SJkg>^U0K1N`(?h?==U0Np=em3*%k0hj0wE&adgyczv|sA{}X$j zK;Q|8$J1|($p3#IRGKuuy> z)<y-iSy^Lh=MSPaw?6`NNL>W4uE% zQV@qlYKemtsW2sA6`{t(vB!nKMzd21Lj$0Sa<4yvczR{pQ?UZuMvl8R-VYj`0W}U_ z33}I};%DXM4NMg|PkJCM1N<8A zw-mpK$)D;eWi9r!cNO=0o_AW8oteb~xrHpNxISoS9xs zJF_QJmzo5TI{=Julgw7+Fb~bwLOcmp9|}gCCNtxj(YNtm&>#TK6*%v3=|-pOiCxq8 zeom`L3iIwy`80t)tIZc&i~#}YhEh~PHJN$uxmjI&DAqZnUFzXDwg;{!EH6-&;NNS% zofl?vR+w;06`(|Rsc9nj=5fcmF&JgwZKbjfr&7MqQf+qlyiovHTc zv0~@bor?6d@6Drixen3XNO_(^QE2jwxD%BS3k+&g=Xu5+ld%W;clwGX9E~ctF&yA| zWTDcEAH^Jj?ql8~O>3lf8)6n6pO9W)9coKLZ-}m& zPz3yNxyHpZeaw3K!Tc^VJ}%zWx^+^Gt5t2h`e=)$KofX+ z%(z@6XGTB{NwjK6dP_Ykhdeq=)LKwuc&1AsQ+1@_+FoH6hXW@HxwJ~5HUT`2uNp73 z(lg&Bwbu1Vb1`Mx!69Gy=%rKBH5wv)$7%ki0cv0Dt64oul&BmIUa>zP`oCaPum*!q zWSydp@%=l@i7=l6XqfUgn+qx6*e~B|6B{ zMh!ZDE6;EnQ^N2;4!_G1XKAjfdehYgIF3#XA4znR(!B;(JWdh39GlX&(a<%tnhmEZ zkH4B96J_cFOystEX7vV-B?70x6ah%V86TgN)0wEj18rVf-q`Dd)Qj8KV<|$OTO)Os$K2oEA{}ob8N|yN#l|Jrud6o2BO*v; z-_mr+HSl9f27h7HfXb<}6uG8MuPq`qcr|4R}i(U~wD91u9eD7|4QLEA5ek=FgnsRJTSyV5#OZTUi2k2%*$_A zsB_|vz6AUt89kQ)HA1?cVUq7*QxWP-mb&%urZ~C1ZP%s^pref2Imvr;g9Z}v@=jQE zPv4ywx$Al+h`RDY(WA>WJ~gLl(h;!6!t#1$x`uG}JT=+*YwX6pD+z0~jjPj-!ZyD6 zJx4Kjlvll08Oj)22Q z6(v^mye4(|%iGt&Vm?mUrOZ2qf^4iyO^7izVyuKn3_^I9c`FBpN%4!m?7U5Y{A0}| zA2fY2BjUbXDrD&Sv^0Zr`*1+-x|ut#&9tX2NHC!lY##&bhAGx6CWf z9WfD9G&3b{$to+w^@b*C{$Z7yu+wEAbYWjJ9 zuaBC)0_H=cY85}eNLE>Bd9~Y3)2k<9iO@JeV2E+aG^P-r5ce)XjQCp*k; zq$Juj>8e2_VfeaxY1flnToQve2 zY@{2iWpA#hHOoHYs4JC2~6oy(o#&m%1%#`L-4h*yQQ~4^bU! zzV^7|4Y+nxYFogWp^fKa+~js*c*CnG&r*}O;031!Ya;%|5H*SJ$03gE4-^g#bR;6c z1_G5fIO6-|>Tg7Eo4FW(cy7Be0>L(r^r6fM`Jtt9%uH3@{1{m_tZe{K*J^Nt6Jss` z6rf7$x~N*wRJg1o|ZI{wp69ez`Tn<1`P6j_gbG6(&9asaeMB@)AJ;{QD z-4SUn6mn++@7j1fw2YQ&Oc};m8J(Q?$sZiZ&N7!7XZ-0FtRhbE004)Ejxe*Xnsym{ z7;p!4OchoBGF;Tbk=>6IpYD!|x$yAyq3=gpD|A#~qI`$OUTq(4cEk>k+<&Iio}sBX z2;~vl{KcMT-vCS^!8e`ab4c5pIdg`X-MKzlvnq)^rtndx631vBLdjkTdIv(3r-Ycp;MJ>^cWl@m8kk+mg0lf^GBRyLcQJ! z+}-#hOeys3kiFSY$F#eO_CGzU069tJtNu~?U7%?*{DkiPsJnx~*{jU@cTG-3IASPv z?=TljjPK1>n+d1e0?`v{@{@6&I<_p)eqNpCHCJMLt@r5G++3+CrJ!z*F>h;vLs=i( zQb#*uxfj8H8^__VFJDjk#JlWUwd#^aAH3nm?6uCJ>37Q8HiwFx8OiE=HceLvqY8Ky zFj7Peqnun*N@BmGHFuO$@;FgiG|pi3CgyI_sto?rROYb^zO`G0w!(Yiko@9TDvfAj zyf%t2ydW6ff*ZWQ>%Q@jEY!=OnCOYB5`Qa!WWky>AcSZD$o_~RcOs?|A}S&oL$a?K zLPt{gTv)IYTXl}{)yE2Y`KJziZgZ?*KD!JR0TFok^|k-aD-klbEk4hXGz9307zTAl z=-qV=7o*ZE2hg2e<^$ZB&@)bZOBblYbN~0&j|Yl~6K}ytD7-41RGeyLjmmH6eJyk^XA6`BkIx!EM25;BP?e5ozsZ z*Jzd09-a~UUBj@F#6jb2EJkj>#V^<%{AU(*@TKQhu3X_v?D36L)cp#0kI+66Z~-w0 zSFAFJT7zqc^g$*^#^wVKanm_!$=r@#AI{nH#f;|Uw>5v}6lBs3NqO|J8t;)1{# zkAg{vPtW$j8d9_loJBgRHiw>rJ)>kjmd+bpV}CDUfe#2mF>Ty}gmb1mxvZczkZ(Z3 zp)A3Vo_euZdpm?eOmT#u+1z@RcH85!(_KB|%?DUrqgy&W{7(tSR4S0y7%XmgGY|uR zkRr9BHgXOEHM==|^- z=S_BVTQ$0TP=x}}hg}5oAojfgi}gb(gp9;u>(_XXJvj`$)zX`rC>#!?Et-A5tv4VRP8FNS(nI1_KZP)R`67&9mA@3sx>ljtt{mI83|j$N(qX z>$y2Gc%Ax6n>LeB8OpED>HqyHS)&LLQ}EvBePJ9=+o~V2wm^_SGt9ZZ8wt#iE*hsi z6B51HhQUvmqyDof5^5m!Q8=xE93vW<3L_xCP#v7NqWl{46h%2Gu-VyJLP+t}f`03}XA`=xK`;n@45|`eybNG)I8!DQ+C!1GIPZ znUZEmdq~85)huBJ&51vkql-<@x=TDD&?{wK{uQ2-<9Kj55->>y+6f}m4J!@JUst0* z4CM=}p3J=v=skkLxl6e}~QlhAD{+u}bOfM(}q1H+pb=ytKyO|HbLCe3-(7 z29&vmwQFUACN*weNh^2L83|XkEHmQRq0M{6`=*# z*zpd{8o*i4^FU&oZ;;y>@?2nsUDZguh7b<20>7Zaq{_P18?%r zmf=Q+eyje0zoQc(yZPHnaubGnP)0iF?8wh?wWHrJ9(N7S@qPo=~ z%lo+uvyh#s<{BVj7M2@-+}(rIBXeFzhUl=H@1(cf4F% zwub>6U4SF!XXhi4*3e56URXq#p@Xb{E?m7&rg~ zROKWmtqypgBTyi)aQ#Y9uO-r4A!3R z#pN>0HsP>1zTYs9wa#6hkPLyI&g2rTX%#!P-GQk`%2Yo_oralpR|NC9yAqL79w;lMl;Tiea^VAewB95&w-$i z=6cx~t4cI+QWt$Ar~PVfP1SU7>6jchp`LeEzN{}dsht+%Wj?tQlpv_PNv&#^N0mH6 zN&xD^|NfPCFGllm4hDA9EWb&MVf}&{4vw9T2(Ja~WdVW5$k%A4$PT+79s;`YUW{Tj zD?7NA&$Y|1brkyEfi8Y(MJ(Y2)a!&49(FtR62)i4GAG8qn3?@tmStjr5MygYq(+lw z9zVyf92F<_ROO=+46GEb)0hH@V=nyK=M2bcCwT(YZHfjf+Wa?thz_dFAde4;X09eX znoskhUc8zgsq|HIT+U{?UK1){VpJGT+-u5WZmO}a{e%mZa5rE_+yz!fOo?8Y9#ojC zo_H%yW+SYnL}frkGa#EBt*lvL{KgG8wBH1Sw{EEJyMC5qCD10wCI(sXM-kNoTkq5d zt*QB^BQDa~7Y-ggICJ47lZ$+QUOO=04bMDgMgiuCQU|NcH*^GY3cFG5XLy=U04)+U_UU25N_hw+J zi3u|Qqs1irn;1zLSearrdGqBF^4yJhEncKtfir|fK0KDIBk?~(0GEqwcdNfz7V8G~ zpHAti5BFJ$4-X(0xrCz{E8|EpuLNRJYBJk6MBLbLg21mHM9`mLKQ&*=-(XBqEUd>y+swb5z zPL4C_Vm+Ryr#2`X#CWo-n){#j24-CKsyza{pCbjLWV3uY|4TZ6a~c3QA%*ersm}Hw z^V_#bGRcrqEU8|!TTfG)bodqei?!4Q7pBh=lBfzLzRlz)bSAU8X zQZ%5SAaPjTG)r25_!uK0yv<^|Df4}F2#?nm2!+7L0K+$TwdE^2Jd}a@fR< zaF>3s+y4{KMoR%V9~O;#WnOAoOg#K^Qi zUKd0X78wXDIIhc=scv+Zv88JFUJ~}=e->ETf?69f*m+(f?ggQ0kiNp@j{jp<`rB1; zy}&>aWs50gTJzqQ*%GCyxr_aJcKv#9OzLmECnwU2_=z3LO5dgaJyOABI}%tiSi)bcY_xDmO)E2@1ksOBHv>bnFb#e92X-qPqx)C zP)`1_Q+OQy?GBkMh4-Rwr~I_D@<*|G(di!=)X5pI%wi}jtD7BdU9lS>XhN_U9vmv8 z)-M-=odOjVgr45_pfpoU$;)%;tg|R0dD^zT*9g&lY%}*>Iy2DtL~>{vO_GQ>cTdp!=>bcbOhojc(t#}zRQ5li6xKRWCLFspG}0SneS9aoD&-War1#4NP*w9+ z&~bnIY%RBmUTLZ$Zk7CzskzLzHj1{=GiS;uw10AC<)%$+mFj6+-|$(X(*q!ZmH^Dj z_=i=m*@&&&SJO-n)$FXGI^S6%v4Xkb08vOJ7?AaHk45v~!4>$~)1@!Ive$oL@e^Mk zOwaIiArl2P0{#<5ZGi0Hd2xqAPlxXW$#)PK<0Q%x6#Wx?Anjb2qq|QfXaAYi-pVry ziV;u4!+nnodC}GQae2tuR+&~Re*X(*^AP94tjwPGX{l=852(eI80Tn10!1Q0on=2| zElrt8KI8VHF0snyV@auJ<<)$n$NM&Fn@=0fK3Zsx{#3GIn->F6M7;220C+^Y5mM8b zj`|E@@#*C{$<*|@bN)1*Sg=->99!M&bB=nK#qF1=?##{4%`CkmWY78W_`l?2f16|H z*NhLP%Un=P427WUoAluGL3|iK7r-AJH?xVpHA=_%smxS|dTBJoUSxC`7j_}0h4dn< zymZ0?RbOFOLq z8?}@w2Fl5DFI_6${Qr}n(ESnc@5n5?jl<}NYTvz6s~1P?14HUPk?)4-s+~BtJuDf>d&o4|;k8N+Y{xo^vlL)%?ZD)OMorp)~LCQixbFeh$|@@s)Q_z?VXSglyLkhY=C1_XeLJyV9e zzI6!pv(}0Rm%-p~Rc%yxh5>Dlx`JekC!E6R}(m1&AbFAeGHSHRE%v4B%E{BAb z0c02-!07QE0C?D4_&@*RI*7s_ItJZ}p3BrEzLC+E*6Eh1eff%Qmp**jqTRM6Zxit2 zNSf$kmcm7I7Plht5U=K&r+<6l{Sgjfct6q4q7Onm4|*a1Y1plJfx-u(2Ar8do^8Z> zcUe*woqTfI)*|l!RdUu5t%H-Detr2_L~1cKH6%n;U}FNogJ%&hXxa&j6TlJt<-{Nn z#I=Bbka$4w4+T-%?W+w0tND~=g@tb-V0LC4%XKGDp3!4m4;2Y zh89$lV!NJPJks)b_U5M}#&K}5qD~-GUceKaq&yX%w)syCi@1d}SlSFb(ho7E+}XCl ziZV#$YV^p*qTO?~S%&<}ne)7Gt1%fPTn{)utmKn@WkjAJityS=50GxYNO-;jsKrtw z7+^aj0RJ_t?3#_$ySO4wPK;08QOx#M5jr9KhHvlvRYnDJiVoy)aB$(eBc@!S{Zm#D z7N$UZRCRTF2p$oFTTsRf3_?8Tx~sv7s_=9C(6V0El_R?WDk4Y)qiujyg=g!eBDu^X zb_}wADPD-T&`h#R4E6m-RQ@I(8eOPMW1;mAz<4U-~An%{H znf?p-^%p_T67%Nta@)f>*lTZJSi8I-D(rf6YFQz-TPry@gWHk|bp=EKn3McZmNF!7 zB@zo^IKDjipkZm<8T#;whJJ6X=V6mal|F}rDZ9r_>blbA#f;-B-1f41W8wW10-%dt zf6`&+bFfJ#koA|K=w4R08P;4i?XauP{clZXULdj*3<(vdxWPmAK1dLbfBVct^wNBh*n>j5nsItDDRLGRZ4p#f%p zCHwd1Wy9BnBLn~j^f(Ze0Dgns8g&EVEPg-Tshr2V7Hq%wnNGxk5c%MdyHn%NR;+I9 zd*)1a1A%rARqQOG$q^TWX=wS+ILB`)D+n} z)9o__dr5PQkiY&nyM?e`E5O$c@XQ&ruz+6EEAPGa!Xjk8j&;`g7Psaydj?bMyl^6t zr7lZca^>7;;(v%%9aL2rECM97E+b5h)i?j6i620}v3OkvmN;x!c<~gS{=q7CMNyVcCeVk%5SH8E-P0lOUkd{`R$^J_U z`IcAvrm5yE*XGz0PUZUMs`0JG3SA*9aFuu|5!7&a0*>(2_O_F(;$ib?n!bN0jX&GP z7oFq8nX^OmAp%LxqI5GzM?%%{(>Zo}@0(-2mB zFmG_MLYED%G{KqI4Yn`3aU4(afC%Jmcq^8pyLS2`-%#`*khj`tKKIuGp=Kw=bUu|9N z$<3dw)dTT&W9lm}d=HsJ>c=Ht~eGT!=ljiR>1 z=DfB>gal$q0t;oM&1!Sg-=-fWFL&!fuDr#~w}*|a2HQ|79FGJQi~{F%ak0OvEdSv3 z`s&T4B*TV&_Gy=bH#!_wk4O5_9!`_Da4YNh6TvnvVh%7LN0v(3Q^(#f<~bHyle9;q zM6kPK=p(@r;AMACLyZ90CTd2&&G-Q5A@Grmfg8Oyn)*P&O7;&}l!~Xuio;tc(whHE zp@W|cnJj>}k1AXx-&U1m{>p@ZZ@`|d69*#Xs{3tM$1UWl{!`rGC?zblNMaX;xL73i zOTuyI%V&0%sx}6F!h%I2h74ZUPi)j;45sD>tuCOs-QCmSE?~l_D=OWOGBbg3!009UWB|xP&kzTN@jc?T5#@C!Mn^b&G6h zN)OC!VL2@^ed>a4)0pXAI-Wz$NqTRrXy$WUfAXup%vSgGsm^TTAMfJ#Fs)ykEt{h> zVtso}%gd=V$0sW{|Le2cl(h%M%kExas7j99DfRLC8=X|wmRtGfIMS3jAL2`gmmE3m zmLfb~9OaWk!enjBt+O5ohF?3sBJeob+VW$<`e?)i_gj}w9<#^jcY7(mZf6OW{RSW)op*e5l?#_P>oOC6%AY2mF<l*7-x&5 zzSX=I^JtJeYIK&J6CE@_rRU$Dzphwvp?;A(tQd9F@n)EfrAq!v5f@Iw@Ta2h+ykqx zRsJY-_`?L>`os6V%zf4F0!%knPmp$i16WyE`HP|>Rdw8|l)+uh&#x*|L}F(><)!{f zWTAi?LNP}0wUAC-Rje)QxiE76Xu3yv;G8}a0!IfC zjfFVMoCevd-@kwR(Mj>05z9Abi`lGk<&Ky31rpglDRJR_Qg;R^<7W@XIu$KDN9Ry^ z%g?YmxR5FraDXC41Oi6LMr{xl+F5k>T=$90#TVI^cQH6W#w7+{K}0WN3rfBqao1j9 zl9lJ{>|Ar6@5_BLht&n2(;*s)n5?}q)U(Qrr93TC(DUpO$CF24tAf6m=1MRvh#}H` z!Npz;Njb(B6WJ~p!>X>1Lh)Q?8HT7dc&z7maU&-Msc(&s6r_Y~!s$LMS6I~6oI6iH ze{n?7WI@^{obu=dJ?bTBB78p5Cm%RHFAZKovMjdQfcX5%` z;vy3)V&*wVFP1S-Fw>nC%nzP*KfB32_;3$n_H3pmm9SaOVpHa?_NUzRSU@|ra)zPn z;1W5nIC@Y;^Q>q+IlCn}&pzsv1sW4o-#ujqwsDsftiLz9;LO9&LM?J$M9x!VyG*?g zg$%8q($|PS6}39jwO~b3^LoDi@pHO;y3H3ojtYF<-o^dmDo>C>f7a8dGPg(8zH-0n znT$+y7t+7;Dp&9(i|OFBW8FAJ7PU<@uQ=f{z% zV+jMiYF9Xp21%YKlSy_NGH?5t)^>wpc9pZWrWO7-M*8P8Y1%JI``v3wn5$|#?^Dvu z&t?S}U!^zz>l;)eL>#t^B)8Z^6Q6To`i;8w>{qW0PZ-kg3%WJ@*`-+n@14DL*>}%i z@4DnK9|Z}yhX>uTi0}FH`XF{b643!Zo7$dc)y5{$Y?nl;1qOV z2+=r;6NGdO{2P*5pFUOLq{WVU;$rZ1QpScD)Apj4L5J7B`rEisJR-4s)+e8_bF0L7h|Ni~(+_T0_Nh;XLN!iabb0cv^=c8% zn_h_eWUd(O4S$Ce8?<8>D#PJ)`A6N1%fDy?9PRdHDX+yZ{?^mIxHPLiL#?!Xv*DtG z`Sw#~w;0%@XcnDFJ?@P)l(Flm+XbVR_iVOWbtuk`ow;xn%J`BehJuQb^+k??;gD5w zR)^P`lAT;0P4sSD67y->se1iex077j*D!{2r+OT`spHh1S?fBtmny_JUC$$Y3jade z5eQAFdZgL>$TmBY>f6SPSK^Nele(gAF>O1#tjS{^Uyjv}P3f1nB~7;8E0rtN*!WNc zT+ic4Q`H`O@%{kv=h=eKRz8{gb(e#VHAa%6X1fKa-Sl#v-2tv;C#m*K32MC&f$aK_ z8v+b;Gju!c=Hi~+FLclIVl*&~}KA#p? zlMC>Y^vgn7oh3nO9>6D}YlLj_;} zmk_Qiv<7V6s4@mlyG^N!StN-U zKp_XF2Ai9)j_?|=Gvo;)>+|$qn^{1|>=&A2&u$eD*s8508!Jmk0b_N4{6;k0xCZw>vF@pEoRXB`j|7 z@vK(2gm@V^1n5~ACBKM{Sg1T4hc)2PlSgs8Soauzc=umUZ6D+fkP3rxl#rID+rkrl z9$+BkbOO|``r%Pul z3|opw`WY?6U|1YpB24>!UCL<-Gn`(V`KY-003mCvHN_#Ex~Ji_mnczX={fl|nKy7-qn|N+;Woy1`V) z$%?K>O~xSgSIRxh@$+r`Un&nPySTU@u~6aCh`DjEzxGJRHnZ&wACOprM-PH>0P3b5 zIXPyy0EkV(6G;fsq0QR@>;N4Lyt*dX;COJV! z5`nfuLp%57-JtJ|0wQlVIkLVpFL*ls$=&UvZ{Vqm{exJKA22H_8;K&*fp{#CpE)8Vv8N)HWqKH z78Rryb={)JVG!nJc$NB_v2`7`8{h{3;1I}9{vy(q_QyNsl?m(M1o9ijT@ivwoZSXu zCOZoB8!isF1fRPXAjlvUf7vq{oy2bOHVe-u8cYekzP@PZo(7qzywiTMY2?qZ+Sk&F z;dq@kg*FDi(_W8WDVK`;n%kY=PTrYmi(7;20dg)xni1UfuU{!4p7$@a|HK1m4DkeN z0U{Nf@N%PaAK=x~s8`tUe+KIcDj}E^nF}2L#LTV36hMsr1ztq79xyz>ze1QWBkPo@ zvNilhPBBoPxZ@my)8W6lefI?}tGDM4aSE6e9@rLNm)@Ihgi-K>YY|vk8XL}{&G)_R zkA+iEQ&SV8BGHVY`b3ig$)J-PghsG@12~4n@9S4;qKg{iWghr>$sj-5?+%_2G&VqZ zms|}~#M^}?&T2~X+)Qcx_4c9Zdr0|QLGw1#+z%ab|J%2n@QUgmClX4xZ{IGI6?)Uj zZ}^@~XxEfh^gOA0TT()aP6C`W&II_F=62-yd+8qV^nWN8X4N_S zGP*P(xjR(5GmehF^ti>^h~kn)27`GN})r!k+mMylRy4A)G0y_iE4wnns)Iev*3s`vqG11 zoHf!J(eJs+UZt@v!Z~^A)bU879fwT;w*y-baaixCrU^lfL(0N3E=wWHkKNI z4-x75>+9|`#d`M?Q&V6R5h`r_nL!ZB%zgm+E5jRi9xY$`MiaNxx_55cp^eVB!w2Ng}I?Fil~w z`uqrag{$hws#VB^`16M~UVJB@CZgy=$dQcH{XNE?3*iD%NfWZ+`l?%aQc<6YCjN2t zsJ#k_lH$nFRk$Z$k)fucN#od0|CM2=F=D^ml`ECb-xAElV!~rDoD}N3!Rgqv<(f_b zuH?r-p`-QT#?vUfAM~%Z{1+~vk7rd)67N`;6ccRpy z6&WB?`g0;tIPpQ&*f$rW-PJcE&X%1|Vn6e=6NLayN?gF^(OfTD-B@+%&EXOknLA@m z%Y}J$kZ#;CoK~GZp?L3Gk^Ycqv85&H^GlxhJNQm08i(oMO}q83bxzXaDka1sc7?pD zqMr?gy9Bs%NmcfT23edG+Mo63#m}wyECnd0G^&TzalN>(*fyA=;RuB%kvsZ#Jg32H zRk7}~j{BCRkLQdZiL(VS?)HqjXC)T&a#1@3E7Fi)FZOI#=sz30{N zK_~G<&9MtXPbxA`1VkreGL{yPvirTCDh74YFBakgEG{0i7%C$*aTAU7@yO{a8acT8 z&mGQ;w_m^SAn@~-v%9+?dHG20BiREYDbYQxYsx{D+zEBwE+g#n1x-3PpcF zdrd@>y?xt!(J)=cmde>DH&^G%D|*c~c~9Of)zi7AIY7>UHrKM+ ztw|&r2rC!Xa8{1KJ!x=-6_^q@m7F$C`s_riDkGMIRRV`SvRh**x&p%PF;)zJLyZl@ z>6Lbxncz9{*49>dB3wR`$Tziqy7s1bYHBw!{6M(Obe0-s*PjtE3|5mg@GhL8-!$|g z+P!~i+(JT#RX*r5CiPzO(Qp{mI&x9rhP%C^<0B|h*(>5r`MxM6%Otj0nKsSme+&RXW{@$HeWHGTW>1V_PN$PyZUIm)0xgA*t^WlM?S zC)fkKx(tBjA#svDwDwWnjT>qe<+1NAwW4G)H3n|34Em7IOIzs+od4>1jdx3PqSg4@ z8tvlxdq8olo{a$i@;eP=JWW4D@iaHx)1vD)8Cw)uDP$1v3`8zmSwSSR&KG#o#MaJ{hd-P>E$s0et(PSi5Y@hN{+u7klrFTo}_t5Nf8Y=_ErV4SeZ8! ztLHXZ*xyObXp(47l1Ei36MoQyg^Dzu@f6ZgO~yMs6kN(vIwgN zTnP49p)hY%O?Wb)qjX_2%xEDju9mq< zk#Mxw;ml7lU(&hRO#a3dzCvk8tStVkWpt#iCmXyZhj{KPtqA#aK4@L>Z0*2frIx|P zdj&91MVz)H~A@TaeD7~%C5FkeuYL;gLgl)`)DJr*n7&|GGL4(}Npl|=ir*yF*^ z_V~%_5Y8YFkD&L^(n8Y2&Ok}bJx0hyvj+F>9VLCIj?nIOovxrB{u?zt4ZDLNSc}!@Hnnk-6%*R<3>qt{hqf?8=f>J|7S|4Q#PN?Y^Hx)u>i>4jm z8CZ8EzE^D1R+NmPHfcL$KPd0qRTJ@Ai^05W;Omx;2Kj*Acr zWG*&al7R{Y^zWzhdK<@-)M>?sI|Ir7M305MUSBs7_}P-7@B6#B>o`&cP%j)I-##{^ z%p`0*=AtWO|4X83Dz!CR_q}0uent~*14V68h4qi)u{-zqpMeZAIiH(#pPKbl+`6W9+}VNcI3sCBJk-mB?IWvD9jMwYK~5m@b;=Wu`r zSNyt9?_(zV@0#DJ@jO5#869l8Zt@(c{7sp{{$5j@+;ANWS*o@QCAp zQ4cO29X-8De)s8J#3O^8UC=jsBvS>G1NGAn2Cv9+;7}yXTSEu=8U;t0hrObO=w--T$@{s#EPyH229(Hqriji^rpIu_D_CgKVWz$@guRIUz;YFUm@(_Y9^E|J>Ce=g~MPE{yrztW^q85L`$ntMylWVNZgsHsDgO}b0RXG1-^$1$^^zw!44k@CfrOuhaX#!{!R%EJSECTlOnQa@Q49U$upIdwIIvA$B%TqRL-{FU~(_CNb6woNw! z3<}QpAX-52SzjUJcJ45B)Z)9=#k22IEx0Z`gOkOIJ9Y6k9wJ1Upc6ppi9^I!$bbDN z`JyXM&HcrSuMMN0q}j@B^fsmzpsT}~jM=$b=FTkiwaumNjDCj_KO##Egut?Z<;e9= z{D1T^#5fvj>#@@V7rF{>(e254a?C#GLX!ErR*;!DZ(^t~F(3oRjVE3jj1RA^cOoJV zCVbo;jC~{ghsgAD;k`y`6q{WokS%fXG~JzbS@z0%r-pW8P=;B3>*f)5GmYq}S#k|i z3-9iN8j*+5Z=sRG^C*uIQOJJaSXJe3g~}3l=B(WE9>VH_dKGk#=;&&Mh#-dl1@yuv&>6bS)US%hH=5=YqlNSsZ#GY4oxD9u>pTs) zlnUBd-WIX#(qUFJDgsORagA{g=0`QOd8~>)#j~p&0urIrT_2?vvfH^&I6SdOTF_ENpD(9s_0O zOp;{m)5GdZWJtcU+C!cS;x@PeV`KJ=gHg8_6cd6m4G30O1Qgs~T3TY`2uPAWm}m;9 z1745tu;qjgEo`EbrUMjR^|9Z-OwphULI!#7_k+Rim9bu%eOzj7#AhplSMm>wMydJ> zQJm{{W7zg=LgZt^kjpabkAAy&i%sR1T`VAP@f}t5za-olC}}S|YEp}_E+iv$+RTmDq~C@Txg!ElwGp^gFK$sAhJ>TAx0p<(Ad zXAhO!$@w&T>6Bdc&38U?pWC(x?)TqmVT$B*NXGhXbPj2?leP3sjoA6MEnW4ySR z@rOlxvHW&J@j4LggrCB}!GY}LOuVA;88~949jD0t(@#vDGDZR+uqZZms=H0`8T)x5#2y6_I5 zBGBPIoWM3~5NC4!={}doV>|p4gwNZta%|zeVdedGQ80gUb_sCF+9k|KuITN9J;qpD-!eSvmpq z{%2E>Bn{EWgN#PMiHBc#$>77hVfAWh#BKA9j0Vid3sDOP-by5xd(~BG_ry&h!pQlN zjp-XOLWGm)e>nn(Ye>CXD==xrAQ37rK5MxB!7bL$eYC4AYr2YDpUqbRcQgl>Hd?o+ zBrJW(@uCSdzUlm`X0o}}Xu*SYUt{W`t$M>P1Ei&)!M?LhKFBc za~?xdVge^i#n@e=4x1U<05+*QBi*-7(J!RGrZ#@L^@x2MO)z$1d~)buW6Kt~t6OPq zFjeaJB(-MTd4uP+$&!wYD0Y=Nn_IT}bmvj4FRti2yTk-~d~=KYc(_+_=?PWIkv|W{@Jl{4DtRra)@VrVgk9yaW2J|zw9l#-jI9XFD18JN>irIX*5G# z9Jy$fFK~a$NtB#ZCUv-7qAkwJAy9m%GLR(u>{IjU{yMK@-_FU-LQg^nCqtYD8}sGs z^y^g~e`!)01D#?|(JSma`sMI&*elXZ*XoIV_8Bb%jxTTyaQ5nINm%2kVcU%a;{_)z zN2&AmdYUF`v&p@C^Z-*}E3sRnY%L93GE!u<7w5qk4ygUGHv`@^v9r^Z;8twb&hMxOn1rzS z6T11vzVr>difY4-(=b;rGVJtOW$WS#Dkpj$1B2?iNPfgGrVdUxRlYnnq-z|JBFzuQ zEVyWF9ng{xy9bVCq>BmU+d0;$l4Pl@Gzyr_T&z>Hr+Gvm0 znn~{kO|ZZ2h14{WJc!8*&_Mce`x|>Xa0f8H6Fv6vcZTa-wJW|BYwqPNiafFgw;Z&N z8*Zq%WSVD7s;6aDjkeQT6vVJw4qg88@}heXQD>&`x_NC0+$48&mry-!pSijoG1i_?`rd5Bw3Yw1wl}-rFbhwckkO#)HwM5scjmtTe6MQ7S&-)QQV`0?0>?29cK8(q9EUes4)9+?AnhOaG>f)VVVJr(){F zQE_m+M8|>CSf&k$X3i`!F+iH`miue;e41CNT_@qM}iVYMuq4*@qltHQGKJ>t$ze>X6AcV=( z$HZ&Gwu;ztY#3nmKTl;q_EX-|vsY$t_IiGYW)~^G5Y7YK+N0I~rEBqXq=;UAc=X)o zM*k0ubW#c>#PyTgXxO+Y598=o9KnF+g__1wlV0sqF&S;76H62GL#p(LhLC5Q zT*3#MA09ci@_^BakUK;Y5oZc!BJD9w_k$#Z3T%q+PYYM_iep?QP=nzx!+e>SSy?E8 zcU4%^puOPO@4v}0tux!8_;7p_cCG+v1YH7UgWQVjU@MNcgIjdLBrGU?((>&JY*n7T z&vpUBe-O%nXbg}lriVJtIPR{n^iBw(9?cAB9Se`kf;6q0%$)Z|mcgMXyFC}43w0D` zGy3^gUxPSANZ(wCB3^N?UxK+%P_|W`9s=9I{4o6!vVt9w4I2~i6g(sPdF@`e#p5b1 zFd3i#ruf&Z%PWWv3EG|L;BUpnu_&G;Q##iFUxa&0%kQWsmDpE_MBsnWF2>UPDt*a8 zgyI>Gx!LZ9F-A(&k2md$}Kg~wAWqMy}XbP0Ii4EtDMzD!z7QbowoU$EUOWI=o zej{*GD(9oNV-!rY4tLJ`ta_! zG&YE;dBV@{ynlOdu6)KcX_0HuPq6;eqUMOL^u(oGoF)TrEGq}OzYb}Pr4}9`-q#uB z6y|;Q^OYT&WlyBHMkU08F$0gHe?0ON^BP-vBKO58^9p}_p-N{%m4V^p8>7PZ7G$>mwK-j^o55#S{iHr zL%5EDPlxBxbTzYKSV5YN{?JZ^3u}kC^`157kTPTh1=-~v_kBR%fzhp7YBjsxW{d9Q z;j<9xxVv|I7GtcOfN6TGMtRV7FU6f>nI7QUQ1e5{43HUzXqZacF80Z|{F8SJ^@$1g zJ(C3UXkQr<8!ODWXv$Ee{i0S@+`8$+j^m`w#zzyrm@_+fw?h;~_Zyre&imV8+MBZ% zuR{R}Py&=tu)g%J+%3i;?kkLymv^H2Vpmw4=&EXNro{n?5GR`Qo()A3=R+S^R@pU| zh3cPOUDYVxfLs$p#-e$D-pa3@PTD(SBSFNz|I-ZgPxpV6$>y@iOw|9rC(l?WHko_Q z{rnUZo=%5`xW3x;#jBmI`DWXB{m_&9SV4z5W8xx^SB|Je2>O%2+PJT_sLNHO0e$%1 zNWGwY)c)~hSy1Byosm5VDZa{9`Lo;RlE1U<@i?pQsO9@ii)WML-K4gQ29YB+EPRZU zT1nue;Gbw-4>2<(${^kA-dWahI5R-cb5>*67Fs%gLh}Xg*0*6e)aFDhrDNCoo%aLw zemi{@ge59BC^oQ7A7Y?f-8F}zf`O4{xDc>odI1AhIv45EEC5= z#bf`L`+EBC<`ngT;;)6yNA zgj?m)4{XuhC7Z5oPhCG^Yss#tptxv1Oh(yNG9su7n^8__92I@V zT+fpVK`$04fD`Yn9|ca#Zyuy=@#T#A&9-$}>VbHM`)`E3I2kpv1pF{nintRW-ShoUp{U561Y<_h_N)zpEYWysX3f$d#ltep zXr-wH61}gF9kLoMln-}ADeU5}q_9`7+$-)PK=cnEyc|d1ErL8?+EM?|5yceN*=T7p z;QHtuEBj2dmtAFRy~j$T%Ve|i%FcpvA>?X(Ht0tCf<0DAlw`ja$CSQykWXy6nag-$ zd{gPt0!aAPiF@T$c-gXzbrfBgqvA{(c%fapcEK;DdDtq9DyFAOpRdj& zx0hv6$|M`0QHm`gcRTrPK(9v^9^?0v+jnmplB|H z3jAjh)E;8$IvxYNukZ?e>y#j+l~a(H7~h|GmzC^V3?%$?8f^03~L;pcIhAOmNui z(+4&*es-D`66Pw5p?apJQaOeXEPeUQD*3_W>k+AzPeZhum-{SJyw=M##5fv_4>QRw zZ;;LDp9R^1#}|h`dI{)fO_$@v)EpDFUYg2;UT{PPj|LN((201b+kf`__Eg+|!X@bA zH9_o+%JHv-LWKHMsKiD^4zk7GM&wAycMU%0}azzb+lW z#POA*wEENbLW%$h+pF^{?j{t$-?wIzntwT){KlPj;%W4Ix9B7@;nw&W3}wI=;5m^W zza6d$*Xa(zApaV@Z+7{*-tw^!&M&)*hD@R#2))3!#jE)X*K%jw+IMR|ALD$&)~qP` zR0ngf;K2xy7Pv=3t3q&d6y5_DnD$BSGsO11UER*h z{0h0}DW@o{U%4~(_qaK7uSxFWPR%pRY*q3N%+<7*-J0LQM`D3A9(;QDg^?H=koVX+ zft;?9zxg6jcy72pu<@bq7YpRvswb3bzvx5imEB2XuE1yoxbI+sw4A?}9JVO*dDsgG zZM87O8MJ<0`o(ISqMlTB??;$G%s5KR z2-DSn%BdKmb};Rx5&AYNA;4r3ktjn=y5aAl9c2(1;SdD%D0f3D zX(d>7aj3O%t9ts7js}TjFFib0W|e6U z9bJyDpkZ6eN-n4TT79m3Ipt`m@KJkbrTVME%RVFfa^xh-dw|9}IWZyf$X5F^0d(W7*J>68vnQKb^BH4WFn_XWn}44IED`WE8WjZun1(E+)F z7}F(FcvmdK_((CJr0rLIC44W%h@u=Md+J-3>Hf9PhJgsAgW~WF!deOL7fhwd+$O_p zH-IVhS6v@KL82;H!$A4Z$VxoBDA@_Og_US!)OF1BMoa;eNt#Y~^b|rTlUa-5gdVad7_%J8p_NLCd~LB`xlhzyiWRLh5fK4*Ae`j7q737tezD1<1)uJX%RyvY4%NX~r< znb2A#|4;rWAzu5>P((!df^vTi(pHJ{kTt34PZ?9_vaj6gDfy=+-m(%{hnVa@1kqW! zn$9&Z$8YDEbCvb@<(kiEzx+E_@x9pvMa7YsIv`MRTkJwBe!y*R58*=sg=^JYS+ox0 z0mT|@*9xSj-A>miU(sxdy!q$r%SI>RVbKo{e0};V&mV44P!i-3lo$T>MRu>_AnQ}k z4~6;lqKh2j3jdBqWyY5&S}2 zbd+=HAO9*;%Rji+)ans#^rmEjO5MCTx-T`kA# z>{gC4rtd;l7^EFjBTXFGX$TkrOifA2DTQOX5mvn{-<@tUuq{J!NjCRd>?n}9Vx6qB z-qCpv=DvvcB(>d85mDINjZcqmow&-F^y6=5!9it^V9dK|>%no11tQ>5AP+DNBUTA{ zECv$0=JbDF(GO+T6|0=`K*Tq;a(o|=!ps=_*}>o0`RS9ZMn9BBM3BBtK2=mY;^etl zwf+ajy+d>LDHlY(fr5h~Eo@x>`?Kp6OR71|J;@xGi+F$V9#ZTNl~YuA4|7fR@0DUK zzZ!Wne!xvC<+<6DiEu<_5X~ACd40%N3g5v-wL070y4F6Ka0DndfDrQD@YV<=P9IyD zvkzN-{M=!L_88DKvbl&+7`Eu@-t>~2-O{WOja4Pa&JyFup;g2-@oj)<-?B#1zAS~g zv!x3!vFgYUE^+YKXSW_pmFtTCeB+L_*#?HLmbflyDsF+124DmGto(|zQ`62dfbwSLif{M~}z4R<^G=MT)SoTvMlM%(QjDD>gUP1Af2I~vf|>7JK5$>LNw%$&7tXmb!T2wdn7t1_7Zq^p70|3HuXM6ZHo77Y48p2Fy-LJ5moLSZzn_`0 zquE34*mc938G$Rmh`hG7Ne@g12?R0-pskHlixOYX21P7qTzrbA9|(>+=m8oc8`&9+ z8Jh#MO9_P|p4`H223p^s`OfMBCk$UMlJ$KLxD#f7(7C|l&fA!%9*phrkr^L}BF4!jIj3Wr{cyAql`Trz? z@F<>kr}Dh(Mt59jMrhH$STZ#}RDkG<7efff5=oCJ;$JhaqwjI8AKDKe1{ zrri&Fuj8$f(O1opeoSbVx={D-=r`T>2_1S5n$8X0V-sDg-C=m5?Uy+*+<;xC!@|O1kAF2-3$H)S zm=zBBK7=X6_LZFtRIe_%Zg>`(B5(lu2d%+w*Y|(#bthdIj9Ub_C7N!&WCuwj_xkfn zG&k<(lEJw;yh8NAd+B8YT#rYGaApGqFKThCUWfhrQhy zy^^W--IHRq+9<+24RA2?LwcujURmRGL^lhY6F0xX!?f@U5dCmrd6Vc0vQFhBoDpz54sdtEB!@hu|d z)noIYKlMNm(()bP;>&WuKepWkHyXzEuapNp_IvIp3!vaH|HfcBL1d0toqPVi(;9L* zR2A3_2Ofw@o)O-^RNTUI#*ifYsp_C<)1f~Z3|8YKW0JLQ3|Bu&?=S7ZYPlh{3))~b z^BTN8?kjwFrLeRonVRUezST_qw5_Z!xUF;Lb5+Ai(|Lz}8Orwd>E|bh86_j5jwyz#%d;YYMWiqqXb zZcciQr+VFiiV^@cf=G8kRX~7IfS138ho62q+?pfubzc5bBz)2$+{SBT;TB9A~zp*uzap`PSYFN9=Q#&Z(% z>}8}?X02*IuZY$Uc!H#`?}m?*n4JwpIuvo(-IF{1P`rsyd&ri(8X2@}y76pbbe^4D z-M!J*k~VKg9!{6m^n`AcrKBMyqdYYrNBJaNfJr#e)p*{Gx>_dm~j2| z2r%yi`>lBtlPwdpvo5n%g<#5N<5`1H@s|xh5`xz6giMZRoctG4fh1^YwuTE?d&!We zOw6gkf(6FeOH^WFv8;cc&+hD(0y1@-<;jJSdFSa?kG0mnM2t2XKSE-1#C@^2XWntR zD9oQr!Q9H%STsWN_Q=}`pp#JO615&sHuAkzDexY_Nf35ecARoiEMznPt~psTDZ1O9 zZyC4E=?*xV-rkwmaHMbsjWS3BC_WIV{|hLsBfvwH6&QQklQ|}LJB};7ev#VxS687= z=hE<{xd64XSFsQF_MvQ#&i3yC%SDLz0rFOu=imVxr1ExeO0xU$+4VwykV-v7vhnx2 z-fsfWddS0EHysXZ_yshxGOF)fg@TssO z^L+;nk{@vrV*)dapJ{|!VB$WJhauH+h=6Am(w7l?ffSJtZybsrUl&@;8*afRdSadvxwWKaCxL?TS^xHkI$wd z{znwLlnxhjUzoNz&aZIlNZW;yN!$n=ov7i5#(pgxU}GaDEZ`J;@|5%4`GHv@8hew> zW4m`8r1c}aUr)vM<5bg+47L!3chZZBa^BXQC3mG*SC?DM2_Y|0$l~@1oMbSUd#*tx zHzu^hi)6IFsd=dla#x_s(23C{Ur@3efp7p+5prBIo+(SkPxy6~e0i)koD*!VBT`d+ zO1<24D-yTS>s-T_Q_wEW=4iytZ|M72I7iHy*vlVJ^SxCw!%1H1#Hv01QC?1cWGwyt z=H73q!V8xU4CTFf#hE;-sWoDLrvmL0jG6FN5{v_5 z(%d_dP)X{V3qu|93CJ-N=y~8D@|<>%3&1 z*pGmz;Eza8;`FE&3#cNm+R)S8#GvB%&f7x%pnv?{(B$}b)`irW!hn%TUop@9 zcJt0_N)4Sl?^^kDnP}#}P%o#rdM~ux(Gf()Xpte5X=hKlg?ak8A1+WURBw|^?ut4|}sHrjUvuV^`E%)Pmx5UIcPzI3P zU^o#p28lz%z3H5w6N!Mr3|mI+VHY!gql4@>eBtkdi!}|BbxV0|H*R;1StTCLZoTEf z#ReM(V(gw}2PQsyZ+)jwAI?&IAOuZfdO}&9?6j@jCC%3)zk};})eg=4 zj(xX3j7v^20#)~8K~7SFjQh846R-OkFU)hSe%o3#sCn+$_J$4ir!?6W(&{06cfvl=z9o~h~;Fg0R&dGowgA~H5Y!Gd`A?BBWP8atE7{b4rq0Hs| z-?%wvysH)qToVMz!J}@b%J@t`Uhc@mlN|Z83Jh(6?idNPjSR_vkS8SU_~>;1?Ulsn zx`*x!zj=DkQ*>dbgw#pWYRk(g={Q_{o>?9(LDhlx+VEibfvnYzxkD$}8yX|r z)jX^om!i???IpwRipw#*vqeB8@U(_@0)QueH5)b5EvCbaQOvsNQnlc?ckR z1I3+UV#S(#*HN_>nn~$*8K{!t_m4nB!v|Qxla4Cm3REv?``&OVopBLFti~E28aIK8B#$0E0Q6?U1t-RZ`SkoxHZyZA!G1meHYp;@> zsD`jZ1Dhg4=$0GDaNRr@JedXzqV0#L3=tA%5d+W)a7|-;l{zPn=|h1e58uhj*apgz z!P7TCXzY3D@1v2P5XmdRbZa#}NIw3DAEPLsJKtAvK2~pN_8t+{4q&hIFH1Cb9AuKB zeBu2-P{{b*`<2of-b%ZK(b$}dai+VszBwkYP1F{Umv~U@r7d3ec3E;6DhaF+yh`+5B0&mj>jilLLBY{A}R`orsYc^T$&n;*2YMQdLml;BG@KbYxd zho0<73|fdv3k}%#F?@1E&d+X{S5UfMzy)0of*3F~p<#IMLoERYNRSDC`|-%JC0@e= zZ9mq&CQiFv_w3IdHlx#E5GFn95g)mWn0NqFZ7=$43Wo3GYK++xqAA2jLP7UW5enZJ zJ{UeBXlSqAPYomVX9Stb*C?}3ks>1F3tZ^Fu5?--sn`*J<93nJ>HRI|LX)^jPNhGrM>6(GnL?XvhP z&O!~AB0)P12nawua9W-@ieU)8Fh1G_eDp^vTFYA2UW?p1Eufy26lgZcS*s-NJ@T}y zVbFHpXyRx@Yxn4^Qta{L^ugZ>4whwdOt(4y^Q(4kv+XqLyOHHf@8Rup`y|r})BI$y z*)Ioi*N0Mn?_OtUV_NBN5_@?i?#rnQ^((_mCueo$z3C}`tdeA#yJL6jP~~;aTP^X` z-{Q{lB`9rJ+JX{`)hM86h~x3Ms9};6hwe`u4(zw7EoRdaV_Ez|I$HcH>!YOUUAFZU z&^x?dh{F>_F?kDS6g&y+OaLnY%*BpOA?X!zU~z_UqCh%!Z?R94boVG|m+w9^t}`D{ zt+zwWLA`AyK-J%a zN`95y9uezrAA6(l8lrjdlu+;qs&?}UDxufUDe+DJ=hm%3QM)-h3ko{1D^p-|_j&Z_ z5vy-Gh6^yBC@|dcmZ@jCYgF0H*^+kmh76RrTT?!m5q~ub+pY}C9B|OO!tE!4vg05T zx<55F4(LL5hr>k_@G97)I5hZ0M1=oOWe7zHUBJhrP|;+Q|NK?Xos5YnUB^ZKNN{ZC zVp09KJKNu?KUlU-TzOPCNQk)cUqcv=K@9K3ivGdLIwUOtZUyZ`a{Kwrqd1PZ^x#R0 zvxpy*a|nts!oT$h zp5LPuVCYxksFU4po}!Umd9zTl^ux0~f&I?y<3Xt0f1RgDfRiBRMJEE7636m9!`yY- zwDaP;8L9)>@p*0U3eony(&-RW@~@cd4@xY0C`%dL=;4Gn2gMkwA@~#%7xq>(z!yCD z{}Y%#3XUYH)xIE zd9xMuAM@Bskd##OJU73+L1)IAMSb2P`zqw3LC8787Bbz&Q@P$#z zS-vqd84n`d$YZ(D;3ka8h>$^KW2@~)ZGL*y9h*YJt`HE~M_9vvO$)d);}~*4K7t+r zw%XyHnxJOa3{;{?;|S6#$^6EEz7KFUesD;uYmjY7_&>oxL@srT#9bwO=r9$pwcgE7 zYDPx<3?kjho^e*Cx7godSE208wE53Ld>F$(+Gk6pCwl%1D*`Vtx8kG15&bAX zdG{SYLlEF_`^cRWKVCd~*76CXlee7fLGeJ<5X~6JX+|vQr+*=D9bG9buki^JoJHuT z-|8Xoyl63~Uuoc@In$y$0(M{|f}a>{Lm?I4+qEgu<4lyZ%M8h~Z@&BXTKo4;9t7|t z_iZvRR+?(3cgJ#2??7?FPq7=?FD9MpjiA>OX+05z@%GX2wa?Rl<2 zcC#h(g8wqoQabk?JQ06t|D4O%d^f2z#dYn-mj$%yOA@OFr`aa$}iSlpYDU+OBr{=k$2}V58apAz4{Tnlt z2u$;7(VLLW)f6%1XY!}}g++|=`!n-R2;Tai_WPfJ93BB)5EK$PX&_A7#O2`PlMMkm z(H8@RUkb5TfldN90sc>fH!`U0XzO5|0>51#qO3>F0u`SeOINSTE$RcZzp+#&eG^bM z0-`Vj+SDImQbJkhmMp=wCcQBo^2@?s?r=5>LJ2Ue;;;Bl@yIobsNYB5yT$XtV>_QG z7{&O)xZ7tE09E2S|F;JfhV{hE@_UDaLyUu?%&DGPvt_lTGHHG-6ltOd+mBf@{B%Cs z$e48pTo>2pl1s}gtr7a)osGsEvGL;!OK>P`EhX16H$M!%G#13$P?fPFAEMLg0YHMn zc^LfbrGxmob|)Ye3t^S4e$(#}05B3gpIG|0$C({WoRc3fZJJme{yy%I{w@}#&xvR6 z*}@wPjBOyBgrC*>y|DZP%m+dMpg8ovSggsVve$-Q8H=mTC?leEoLiueK?x>4i@Gnn zY3xpo?ns-ilC+s?T5D zCIQMSvp@1QWH@TrqHE}A=X~z_dJyvohBIJ+5+i8h5y^|TUTl|edhsG~BLen9taV04 z25U%+x>R&dVcGLA4gts(;8_OCD_Hno8~|=g44xnr+PxOeN>9GoZTGPI`J-SR*3O?J z+NPg=@&3wPtsAhN3w$AI-S_dup;p72&rD+(l`{Kp(s+HvsI%|g8=~*}wASB-vh|5GZ_I7YF=OkDo&@S436@j-%sJ|W1A&C$t!dG*1Agb_GdTclzp(HwA+)GPSzo(M~}zqHPs z-By2e6~mc2Z;OBWPz3*42!7Ol)yi;gMj1cA64i5^lK0 ztVVhwxy?vN1u(da>A~IWO^)YcN!=z~r`UYKY|%^Vyd?s92^nxUSclu&7H<`KEz`yC zLMgFVM+UkE;tWWzVj79PGz@YxIOd&E7&=jg)1x>H)Lv2;jM|>@xpZzKmf|;9?HIxE zIuf@8*yF-e?96Ad%*L0N6Am8=d>d;x=O}VrRL=ivpkuzmgT>rrBWOkbThQ|Sf5#UB zZL+rhg*CQ|Nxbj#r8UeAK%ya@LM$#^Q`iseT0j4y-r-_fr*?H=>=+=!L0pQ1QA@c zyz7Vy#|?m*hP#J*@zd){1%bYKXNFq)pNnwH15Le=ogoV)y_Y*K@IfhYV z!HJ~#_vJXsczq!LMzO-1TF-#i{aAKbSy`FrdtJZ}ikw?R>Ns3wU6g5B-&HhZ+-tQi;;f+qSvntkg)Dzl4CApV27hZXkvd|FW3M6)P zL?0DWN5sS;p=NQYO=)BN?mIM_)v6h7U2^DEC|pax?LvDcYSTy1BjCt`&jp6EpqYL# zl8is5>V7IsLyPX5j`>s%zng31=j;n2$XCMDfIoW*!I~UQK~Fzh5(b(7#nA8D{@$#p z^@|ljEQ84^c3nUg1ztdx)S7Jl=KAmF{--(O+9>X|^^tqKakU-i4{Vlik}xg$W=`=H z!W3LmyJ%Q{8f;E@B3CKljDi)Q z3BPLK?u!OiDREqXzBX6!IH1bFk6J7)t!Ynem^WHqOyde=)&0yAgM}X@bMT%WxUz5(GyS6V#BS z*Ezcx4*15By$fXa@r&iso$e<~XUT)r>v9YGVya{-W;*CCb}4$kp_cvKHf^GtGQl@2m6B3JoeLFwHFs zyOLyVy25J1q?mJercPV%N&mT8WE1FN9%}HkW&qZnAbP{8W@QgccW#csryRBw-+%o( zFJTzE*~JUV6;lv26!_39q2n;bJ@%2uMELjf8$1+x_b&e)-D1~y$y}&Qc4t<5c=}cx zYRq!s@5*uf(afdaA;JE?s0V8x%=O;g6Cd$lgu5^yAue&!Q1CZZlek0gm`|HmZ1?O|IR%Siz~V3%)aCP7$_uuh`Pe#QDv~%Giwc^02@4 zpJQ#S5Q3>o9T*|p`g-Dt^dmw!doTsTG~mu)EtUF9met+wt@l~+2?=eKC0AJpe__0X zx0^5yJ(AQtaUhzX%0*~{Oxm9!vOTTHD_IXdA5`b6P4T_J_l|92Y8O^AgenH(9o6OQ zc?C>!FK+&XnDrxA)j#dtrbp#~^Gr;O5XUsucge7~X+E!AaS*4pe)F#Gn&dzI5_HG+ z-C6<;o&wbaO}(q%<`c;Z*{J33xot*;3{uNO`!WA2+3b|61BgwcfLp#H-c?+8r}W>; zyww%C{5$4z14EpgD6cUG&x_dan7fghf%2j7dOck(8Tb{*Y>+G%5$0}$HFaEEcDWs*D7&h#Y9(5%q$uCf%*k`pqDU z6Jh8=gh;@@1{xMH=ze*wg={|P-`rTlERdx!R+$sJ+L@&`e4|kGrO4f9ZQfNs73ChJ z@jss%9Upb;n&o%NHZ92eZ0WSNBmjf$qZj2lVsg)Nv0O~cHK z{;@|yn9{YdxrA9(OOa~TSS!Dm{wBY2=F+l??>KEbP6GNijqL4M^fui|Yk%4)pUX|- zU$gYnn`TPXb5<0e2E0r$J$u8Z5d)Rcx530DiA~iVs)HE@R24mv$oN5hCMyU$fcF=7 z)-4g&A)mLhtrE75wRFkE#Yecm6W4LT1N5V=PfwRt8v~7CS|_W-B$gi;BPATYn)2nR zg?{TcnJscQy`!`9P8>2eQpx)BDar#S-Qx)d<;4J{<9Y?6uU~L=dw#j8-}%$u=Oyf~ zc;}w>_3yQg;XiVG+t?kr@Jv&xxgKhI7e5?appkF6m*K#x*k2NsY{aTzx1KmnPJAW$ z`F;N=YqphzZR2G&Qm!`-9J7-CU2e{2b@zq9#hZa!$9~K`ODbxK*ji>q%D-6A;Bo)0 zKw6`1>`Yo+vyegF6_Y0c0vYvUyJ|x>QWk6MvwK!+>C;WSt$jR1Y`$xE-nbkAl;uB% zkT6qeY^Oiby^?KY6S2D4x<$l}$>)+ABY%hWR#R3*bXDr)oc^)HhqfrLo{RQ>5gf5z z)S!|n5?oZx z;i5@ciu=LhmM~KU;Rd6~|0#SJDzv25&QgicsygmE!z-Rw>5zYA^wGRFMiz9dc4cw$ zHCEixzN-QH5<%~ZysQSH+I0cHAH2bOkBnS_0A!Nxy^`~y4%VE}^+)9Yp~lYSg5E4i zc&$v+Hl9*iFm?%k8E`R9)g{Dq=99U^`0uTK2cr@?$LY46iy71_=3}DA(ub(#S3T#i z5-~Oquup^b3SXfsXJ|-Ldpg5!70U;Ap?|{2W}>5iGUnZ!vO5ML(t`|93ei~8=&d8C zzpY6g5I=E)m6rFM5WQsC%;0;r4U4-ayWU<6{|W6olmpnmgsN~6nFpYo5gDF99oo&c z#G8ik`95uaW}EOizgxl8TGwVI^8VFUlp^fKl#>5+^5`V8ExMFRZa>OPM{$WFLH+og zA+O_Y70Xl?t>BrG_1abe3jMqULeT`i5{zPqd`LnWnf0B0(OrOAbJNq)phLXY+KMzbDznWW;#<=< ztB=n$Ivm!tz${ISa@_`=Cw{Od<_xb0U92PLVEpX;NA~ae-?Lcrikl+0(Bu?y?49DZsVyCoO_BV8uhL|c_$K`Z zztM()U+6)q{eCp_L;SCkIS1OlvJa-G+z240p-Vc_CcNZEQqQvSGnCpU^x*9C*373_ zZ$3Vwc^BW#Y*Z3kM(<==QeNA3TUzRo$d^}UX`X?kmjb!j%iGen2JIK8;$Bwem2&9< z&cwuOkrqh0h($7LDsNP{J;V#p^=*;)R`b#w-rJEvbkzQ8x`$G_XV3IJ@2`=bFBd2u zeID`4{DtkAYyTxyMAAJ9J}FRreyh+tg~{o}-Fmc6m%o?|9lqDwm2QwYquyuyZrw70 zV@K!gXluq5Z5lmx?=IN=o;Q8{;9c+4z-~|o$B%q`K_uG{{rvXi!GA&LV(i`qj(TK(c!Ryw-LL&-`8W+hxyAJh$E z4If>rR=c-&pYX%4QHYuEtHIuq5R8tGkF&~0Tt4lIqf+?tr5COl!l)0VLBPW(5$HN3 z?_eMS>5kCLytUtjl2cu=J|fPbc{6b5OP?!O_cL(B`*`?iX_Xr8*IvF_R;a?hw~{;A zjj-1vyqVru_l8p(BFV*)EZ%&_7OgVIz~hmz;IUQs0>jb+uq5W;7>CKrmwu0CwuOjS zDy*}eFkEMM8be2tv5#_A$9U6n^21m!E=IS--g}Z%whUY*qS>-3k3^xCBgliGk{vbc zwtVHHZ010IMYOkse2j%F58SM8Zy&SV@AonLYvBC1 zTC1#^nF{hIE#;GBE?oZOJI|$UFYs<_-|9|d+AZt*4?f(4854SZ|GL3_=M{bXVC)Cp zD!BMRuU4!?QQrQwsImOJ)C}bn2>_TvfVB{US-hQccZL4#9z4w?9ih)X{5V!_bb>L@ z_>}9Ql=z8;dBG|y;fQ96z{+5=LD;9kVX*2%%JfTk-xJm(F=y_MJLn|vNzsr_VjW&T z)fgPc>%j47kS|$YE#CRW-Hbs~<1)cnt(Dav={aNcHRQ}_6l!Fb`UdUd>2B~{H%c<_ z7g{~fb#lLXp=MiA_SQ0fzwc^$^3w_o;wgrx1!ETxlztmG{>1@XV^cCKN4~dR#rAGwBb09BO{r@_YI{I zyF35hCBo4#B^7?cp+MhDV9Nv5gRJb_g46csy})T7uKaDsSjMF@rO)YLE%ZNn874u( z6cL6lKFMd?FZ!#itw@UJTFsG4dryM-PpB2Jk@*SMpXB_jt6NG{0%3fy=TW?_TH2Ab z0VzMt#^{TLqXD9T#u@-6JuYb^)z1rG`Zde{aMX7PH))VH*M)@S>ZFF-jc^Xu4P%(+o5|>M++aBP7iGm@@0lFfTdGk53 z8f+wUZJS$P!aD+vM=1jz?ci{;v7rHP20#P`E)vH}37_tgw{IU2?C==GzM~U>^04)= z*zYZN6yNb-xB|0Mz2F$9a)`D zOH+sO>Axs1Kbgi~Kv6t;Ayu`?5`1uP4sE-yh911+E(3q;L?8*c{>EC#)ri)oI4nng zY=x1{q{~i!iI`S^_>Jdg^h~Z%GKrR&e#h=cd+3FR+RE9}JZsJMH<(1?FKVb^{D-s_ zV?*?eFq1JFHf%3~c(jWcCw$annN}~cjLK>f%^Ty!2dTXZ`!*cJFSO>h?eoqFrTMpu z$r7j$$m{>ziWutQkz!}7m*0tYPE2;@*e>sWDv(^6jg{QAlU9|6T`C3bq zFr}4Pj4VFkFw=iH#4<7qP1dz*b4kTfAOBs!SP19IYq@{e9q1f-A@+`JQU7x>pQcA$ zzsh9Gq_0&>vnjy@#leCh_k@ei7W6|t?HJno#+tUvJk-h1XmBu{H}StRrsKpUKajR{ z2UXSs0e=Pv*l%6D$0wwDgrwF=skJ@fM9a#pL9#t*0y2l;FW=h0pDgq)Ti~%7%e899 zj?FJO9((PdsON5L4L`8sM-I1uo!Fsp4qHZADb-k^$;JlD+^1sJ>q|ZFX_$7FPAW(r z={52D_m==&|HtG818H}|3#>QeUO>kQGgACilxj?2b-hA4c6iEr56|1b4TS4fcPgpK z_SXx;H{Xf>7%0zpya#+G=XoET=vmG$7BG^Y7icFZAHLOtm0gD{v9#iQI)oorTcL>!y?9oVKoV%@Bzheu1xN`tFJL)3*VuyOnHF`}V z)lC7`Elr1b1_D&rOGqZmS5E@HA|O)G&?{dRAx0A(xl#W!lO@RFm~@bIr??+E4Ea00{bMzTJiK5F(+42$ zM!DoYcG2jcw`)r`#xA%0&wmRj*4ztA=d$&GgHLZPxGmYVTzP#>pNcG1>Y6i_QUFAK1%~4^x|KXulq5cf3MaBUE-XL|xgLExm5kg)_#9VDG*ld0g z)-u0)qBinMR_AzZ&&5mQMKpkF_TGGQg}ip{bho_!Bmd8bREZ^VcO5Jh{ zt|cAC51OmcUg!<_+j*>=ork>tX#TTr$*aJA35aVt&89l5cp4K<2sRS9nyN4JQ&$Q^ zXyZ8GNOpF10to;}IOFM(tWWybMFXb=z&anKH%B*hNhzuqFV3I4f-+3-x3Q+cvs@by zt*C;asZa6vp&bFkmuc3aC%{w=%9B%B--Z6I*wyK|rj5Qj=1^b5cO*q2(e4-1>g-GF z#Lc_niN6G}(Ad89L6Ss4i3m#{`H=D7Y8oCx5YW{bu#0`p2+c zgUiJ0fJ&=WxoAtY+7P0>)s>n}75l`)EW*Qi(#w1Zf}ou%0J)ofi+r#15pemiDLOHq zZ=g^EE)wKb)qn3UIxQ#+hXw815@aaB&3l~MfBfDd(pd04i9v}yl{sc{0B9>JLjGGQ z+442&_8$!56?tyh86m55MVN=e*GtRmiM#Z0AVf2We8A?jbKIwH(Ah|OY`%oTLY68s z8mLgcEiJXSMI>nKSo8v^9j8BI{%T)$m=($E@Nv(R@3uH_`Krp^Wo4EdEv#1-&JjRZ zBY|A0B^d%M^25Bf*d+C)=N1flD*@|>C#tIb3v8Qz4O%A=y|6K!yrIP9f9UhtIaeh* z`k3ZYqigCBZ(F`i)t+H71mcU19$1*%r7j9%43o)jGrKXN5)-C6Lruw>Su$=R#=LuJ z+!7R^qO5&3SU*5$EddGLymLpLJjirA-=PtaD~9|XDXZ;P9|3&(Ln(mi8gMOf$BP`GRYzK(NC=mvev13BLEi3|y1403hrN^}%m&DW4;EWRV2AsV=0&PLw_JQjQ z1r%r8?P1KkVv2xk(CH*R))-6i}!<$0)q;N6+$H?)+nhnqu@UZRPRiYxIo^vV=>phh2mvb%?qDexK zN#R>9lf)TSN}m)%rL%8*rMc6K(nc^|K6UTY_A%z$jusO94kL@JXvY-34SLYspz-n8 zY7{xngLOx|sLiiB>5alBCsUz=Kj+g=Lu28Cn&Kv39d#5+fP@k_OeE)dVV~d_A z`ZTvMF?fnn!t`=(?R&|Hf+VxuUPYOl&z99^vAreCHn1l>{^Nn{4)LCKR1VUKQzuTu zl4Ms>;RiVD34g6rk0Sb}H5IHb@gpH!m=N@c)-v>U`}JP-0yji1;chty$anAEBSt7( z#Kdz07eab^bb^lFgrTuJU(O&b>_Us-2=&>-?)8rrC&u~r@3y6^v)xPnu5R3qi?l^P zCo0Gi!#Dqt3&0tVVgLg#D3e2GRd4n(`RBd0-Yt%Tjk`J@9}NqYtAWfOrw@AvkT4?{ zdxr!Vu0IwWf>em}?;U#ckdI?Qfm=t{b(M6CjHoih#tenLE+gV+d#Ed<_KmLduZk?s zMPw}LVM`jQ6HSI)98N1?+0<#F`SC}HlBCLc54zw_YWu~{XVv6TItqE_GuKm6pkSn( zO=};M>HNHufZqAPK6wZ|OAORw=p`OLw& zUahN9u91Ue({sKZf!ce?>(zj*f*Srtdq4NbHoDT-9r*`;^ReQLP^FlYoFb(8Uzo6TpdS5{f7#RkZB0+}ND^Wr5c(DVW<1Y+($Ch@`fl>7S zzHf?#XTmGYmLjbtF^&P+2ES;rsVH_;Jmg0OBU~i;qOwSBout@r_GK`%F z5kPRYauMkF;m5y=K2}V$zlNp=PYKlrzk$^uS_d1aDpJ}fo`X(YetEi01dOX(w7lQxVqo;&fBy(^5nlZNX`#aB z_ILa3n{tsHPgPS>8${aRcu_Wc?W zl4IUoTPL3HRV!(kvkRg+Tf9hc8bj(}&A{o8mVofGVe?!Q0E*`#70+Q5^v7!90Qhof zb7<|Po6851(xwqDrqJiy(qtsQC%6(8zBr>1Ftmf|C!AV#vMCH?;oS(y-T_VY8QTe`}2(#&&^EC$N zQ}^7Tv{D?hjL^4$mazNPVk4C%xt$=>1eF2O%P=^V~6y7*poi(c(U4`8%Zx&XHr>dqXVW z8!s@L_O_U7wI9#gcUD^Z)ca5{DUBpFk-KR2gyp`IP|vN`S(1N=_0{d0)cc%);5XfZp@ptgU)kr8s2R$no767!gamHbf<6S0l~Q1pHVt3L;E$rsaA zTBzlOU>X~K1k9Z{4B~RuLR)N~(cp90x8h{!dD&ptsfD`>1}cxe?_e|A62y_I*`Q=8 z%tSy&$V-BP$>q~b@Cu*bmvKtVa0l#VhK4vLSVM-!LCFT1Ob}V1T7drrCOWY_qX*WR zx65me(S2RHZ|6BQon+j@OdDtjF8y017iGfSWz+EG=t;Kyj;3BWpcSWSAJ4%6LOEZ4B@ z8PFF#aI|x>Cb|fWbiV7&XE0zHaA7(X?8g>AkT7ce&SN|?O;OuTQqp8ZjB)MAbu{pDUyQ|ume?<`@jn#d_A50CCJ-QQlUk?Hl@L7doA zL1~NejN$$t#!9+}0uG+BQR44vPVn)OzkLnQMqnWTx(;~E=NLe0a?{>^R?#^%Em&oT z3%Cw~b8uDx5ORE+Hd?&D%=I7;0<7;UR(mJYxn*%1X>vCk8a-nzz2i;2nsQhC&~&N! zUl22P2Vr)A#cV^-7)z?(YmFYld+%_V;!g-e1-)jTMosglz*u_a+n~(hD&6DuDRhBz z;^5{HQ^IZ9GJTuYZ|%%kdqu6TD?NBR`G6T*E|zfxMgsAJ zEj=TyZNdN#RFD2kd&Q;ovbEq!@qrzf2#ALuQ|vbdPYOmw5_HkGw}kFIggYL}4T*AK zS$)z6o_b{J6fz4~4wx+@{%C}=r1;YKtj#N({~6%yKoW&xQ|=Zv;lK+=e$34kuc1j) z_Nly8Fjn+bat^Qe_^rD?SUYwOfRP5qD2zKmIlD)^^=(GhB0%$2z|X-M4rGS5)*#7^Kkp9igLmB;*wP<=>Cr-ho>ei+^TjT~f;G zB-7WvgOd8tM%>53=k=wC22R5DH#W)P@<<;wg-A)tn-jAeJ%BL)?NI9oi9MyBWE>AxwC}VQdihz%>D{RbJM& z2bgWJ=?!CK`l3?yGFdvFSC2lBb0|NRru4O{T6{oe+o_mF5Cxx-*Z=EMv0P7NDwS;} z5_l#zS2yXmQZP?doM^j}-X0)M(Nu-uEy?XIhyxf-|_Pz@?Iy!;8LFM~QVi zNu2EcNbJtvZ*Hv0JsfnIm^92Ffkw?qTZNps{~4IzgrD1DH9##Rp^lT?9DPPDaVK%l z;-ev)U$9kT#6>zYM^g1EKS`p#f7OCM`fEE6Tdjj6iEi$hPFcCutw62z3q>%INpFZ9 zm=NQsSLE#UdxWVDH#Tyx|J!-7h758`FF%?)$o)n^!N6Pw(lUa0_dk(0l;$`T&1dPF#B;G1+<^Y|~vF`2qA&-%xy)+b|hEsSSG(^Hk4Gks8ASmN-b|Oj*;cE>9 z`0Xl;tR+|p0Ov?f@xD0a42ZKqQ#u({&R|jB`>d&%oH0xNx7Ht)C!m(6bH(`oIWx06 z>N>Dnpi2ZEsl0K!S}C$*XE)G~fEgn_uCu~-z6PCi?5JfrFaZYE|0vE!Ly)&=A|>pb zPhH2B)zrK|TShmM98~am^ULAChBYdwj1@5z-B_ONi=PIM*WxkqXmCiOyS=zrB6V=C zt-ySR79aKjQyj=Sx_F)=C3##2LY~3O*(9BOm-jGjrYV9&TIwG92qF4ez&p zzg3`VF&TPM!eo6rZ#3B?mA;b z!!5u-1V=s4mmN8s`(ogXHPf{O&B}>^MS*#^|Mj0yI7o2izg*UM$UsxcW7CEDidz`# zqv{_&5_le`RX=;rsxz@xWU!cFI3VoTXhK%DANcdDC%H!eW`V|0O`XYq=M0P7B}1A& z#Jv}$h;I$XA^LL0i7h#@>}cjl@=~4~KZFlvCLg0YSP=Hd^$Te>bi6RB)^ZQlsMq*i z2G*4UzW_;&JYOiQZ9F)n=6=uK!wYIaBm@sN2P#xsbq*>0 zW2SwnNN?=DkK$hRquvTnHo_1SBr~HYLB=v=)`47O)2-rv9q7hPiWavWcY{l>S5?ZN zD1h0ix+jsksdQcI_FAGy*=Y(KaiVSkqd;r(pAT7oMF^5v{c@#h072oH!{QTAf8&c0tt zIk782J+*G|4q2%9)gq)^yHoAKj6=X{9*97%oLn>lk|1ZU@Hy_@y8=>XIe3hU{KZWn z-@axIlbOrjixaM~xO1gtYZ-$%|EbyUVBrhK_#P$yg48X!B%87TL?GmFP{xHLJ+^QFfA6*Q0Fk&n( zz*u?v)NCLi-0Fy*_rfkIsexzvP&A$U*`b(-&!ZtmJoBt)k2j4dqb(;c5d83H?FC(B zrMcH##JN_Qprgf$v1fL9eX+kT@A?~;Psba$%zWCOwJpn^&pZ3C@J|SpMiWCeAyLt(WZamaFIk9hu=t(wUmbc^AF+Vt6Tf=M@Fh1r43qIgYFe z{bysd4OH$}m0IDyslI$Q0dpy1sYQ%FSI(_$gp^hoR`Y!*aNROCIV@Rtm{xKaricf2 zAe%$dv8&QbEz&q2OXG>9nc+s(9m+OO`m^P0wSIb3RQM0on`Kjxm)9{2w=EhD@!2NM z_baHA%!R|BO`UP(i)ozSJL>SEmQOH?<1k(gya;IQi2Pfe{Jycf&w{oW{oa}PH9K@E z&6%S%ygW_jCWEKb&SiOG@o5~rupneoHd445lzF9POczJ0t z!fWfpAmjJ?Hfp1V9w}EVYZS2uE)+)`vnhC_0iefg38GQ?K;Cb*zflCMp|8wU(D);`UN8KydUgsm zuAcn+clWWVgdHybYV`+8sgr#a{$;Bl+u!`dO!6N1XVCW$p7CUaWd^9&A-U%5V&A}e zwcuh3thM$xwK%|W)ywYw_%Yh;Jq?0;$rZo7=wF#Ss~ukJetx)a!pOA)moYvUrR}HT zdVS9$c1cc`4Q_6o0v7klZ2p;$&8#3P0R$?Tk^!i8x~|F;WYqnnrwybQkq${+aHTarWylKQpn{HMR!zldqECd zfuIxt!kTt@IQ#;dRXC)Fn(Gj;*;H{Ptu{BDmNIsTv~I zx8q7i9R=?14+{!VU166D{yp)yaahLLh)>TX;QeNRpGeZRi|8Ss8*-&9RrmXLO9XSc z#a?^-WWZf;i(fb)Ht`wmZNz`OIkCA?K^VH+nR1}0MHgE5`|dm6iK;I8x4f9C@hqaa zF4zRgN$=h>n{K#U$csu;(7r^x!fat#2hbIjItxn)5)W5{WloQ@^Kd@A`)+-wl2Mx@ z!>btUxdd)xb^#bU7aMW^utp}rZqEKM?0Ooiz$2m0KR-Vw!axm$nWW#r#_=a-g~J~d zKOhZPj!|+4f(rqxj+m4HmG(u@7eNTx+9fou@OGh;{@N&9AN_@&r*zAl3OBqB3GdM} zYlp`h7#7mnFa>Hz)hwjf+QJk;-{iJ<&nzd58pNj0IqYZetxFs_Umje2IfiehEKYdm zduqc@MV2VToFH?-mE}XXqR!Tf@k=pZxjW^|aOk1O%*CwnrbwyA=4WHeJ>o}i429Y1 z#U}0EzE$vKY3KOE!fNZ7ruc0Ifh|{ZPKW;v?yTmqa{P3^ZTwKVf2~xfdcrB0o)2Y> z3%P(vaT5aB^v&k`X(kx=L5nZ#CS2$17?_GDMx1XxGqEC>WSn5LR#`WzXk~X5pnWvw zlZ-m|5B&~MOL&9bxO1n_j5BK=C+U^W3Fv=tJs5g=vi(me1l|HI{b?_+9`FIJt*KEt zB?or_q|`5WJ7(eU(H1@Y?7-XUS?9VchcQ&4trJX+|8x7UE|{@1eDIr)OWljv&6vCvFE|vH z!+ZiOvIAMOl`7qB$yX#6L{4+nw8qsuX^JEasD4&jJxd%OHU=i2(v|CvApD zq^R}Iw3|C!l8N2l1Re0B+b_sIk7+$o`302@9C0Rnud`pneek)0VGz^WGE5!pa#c zlQDL2^DDVuj?o7I(ZfemxUGJIQv4x&H3>gclN! z-co$UGP4`v(8CRewg|0yh~#6J0=Il3vUOpBP?MlKMv61Ak=wt7v^%NOnI#2mYIMaA3x2&Na;#UZdDJ$Mk3PWX;|cmbKzQsP7coFBm;02!GvN&d(ld#&0vhQ=)H2nk@Dm1=ej{fyjWLxZg^oq8DjubkZ# z5vZKnJ>dwW6^{m=X zhDnkbjVe~}ZBm2Vu%9NecALV!iBXlwe27y|R=_O{pj|cgcgMmGFxd#p-0#y65m7rV zpG2aVEW$#*D89(+!?8YZuI*d-C3lgIUcirsJLDI(htM;WxUY(!Pxjp_PQK+U`R(oI z&Xw6H{hD$sA8)EJSOdG^iEJFMhGdCQXV1G3bT{31cQ0xj77l*0kkZ|{&@5j43ZcT( zpPXC7$9C~*X9kr>Ya7A+Gyr?suri=!fX`{zq&~oT0^1MhmHn|nL5(K1nu6kYk)N$` z!!)R-MD0objpE1ZKR{%Gto#>&D&liz*c-?0qHSxPXRyWod?pQD)b@rW0QtF-=^mZ? zpxJ5I=)oQlC$IF(C+G8XC+~GjDaVqa$G(o;DyJ_!WbqB~`1wlbHqTbgJ%{rgwCPO| zvv!d$-jBcOd0sziqxx1U1EZ4~{uh6FEl`Nena;W%S=d(?(n7 z+ak8er(RMM6^WLM&3GPYRnYAtrcH5=*J_4^0B&}XEz>ZS&hr&`*Fwxodp@yonDb(F z(wH0Tdy-3o>3#~v2ZOU>&uu;^r7S)WID%j)*Osa~X5pVg%4#g`Gjv*Km67zfB^RhF zIZLn}W)NIYP2X^*c1XEUBbH2<{p{kfcDR*BSW(38tGM) zZX7j}oTpxL#RP!{uob4KaGLyUfA|H9BQ-g11DYS*3J<8PWNK4?Q{S##zi3!9HGu1k z5E5r=o%^Y#qC&16S(FwN9Ze+rCg)Hc_S(6%H65?et$(_2Z_M?QpC)7DTOE&$-HUpyCmC0!v9@%ZY2cR2y~%+{ zw+4;_r6Nag%_2N35JX2r;1NqVP*U8_ejm4j7)DU{!R=i=^~qwa6j>fW9;8t>ntUhs zu2xZ;S+*-01s^W{;zVh?Is0Dn88K&*72NqXCt`DPOT zFC124XMU=DNlq$;>b%EFXYwx;F)U?JFG=is3EgamFj;1DUK+a_mE<3^>q&cE3yRiG zuuu;Y(=dTKJQV#nN8w7z&)u4Nf~EJl>pmR5*O@C~W1}~H7Bmc#o+=@DcTC8G zRKfCA{UpPtsy4h+i2NV)d5??>b9oU>jkOTSeu~yWuvX~X>P;fg(Hu)HBqRhhn^QE^ z9^Dk{f_vYYPZ2d9WU4=p*uUN?7>O+M=^UNiP2-z5jV2Q|zYiePsA=X89}nL4Rupo0 zpaZn+gd2%QcBHUXX|C$GdeBu3S)};<9+VuLH$LX~?pYh-hS9aQXM30R;utej1p2pl( zUS-_P6sLFbQl&*faMYeZe_KaRz;s_jn=o|ly7b8Y@7sfZJu#`tzgXzBSW1=l)b!V# zrWwy_+O@3e?s4r^RmTOgjyjqBKI4aH*4h|4sjit%37#IGb|Op3dY4=t+?bM5+Iw}_ zFs|gn+gA7NR{z2WbjM>E8pMNAZ%UYfbc3`v7h}qfkCR6PXnpg2W2sL}PwG6Bgoz80 z%P{0~X5`<>{Dekn<>E}`mNI`o3ZGjGL=k{K8y_nX*Y*OE+Qad(nN9*9YM6eY0Yn^@ z*iY>Ch(_1DK zmlK+DTo)EU?R1xdoo~=)qCIHxOG4x1(SSV{T0tVGQ@^ZSc#G(@vr&FR!4GnU?`H4>+G?&Wo`VX;KQ%?kbe>({Se zz(s_$biwP?{=kX)PfWav${8I(em&z36o+3MtZ!Hp$ST|zPna5gc}`TA^gES#^Wu4# z>UgAf5p()lZ~uCt&-S20^-ns}qMF8anT$uiAe!06X0W?r<8+dg`(vzpQ6jQyjLE0Z zAm7p=ljsg${LGl6xOG2GX@0@y$?om~PtVU~_oNgy+P=e02B|Ai8yh;8n3&}*E%Cpp z%eRF2N+1`RWKx*=8O=g|<5oX9G&|s2R@r#WG82hH5ii9ke9{8*I=v_o!`LWTM?@`p zw?Upoc(`#S)~%dR2!!nkVr^+}zr4n$L2_JQaU@K0ptiBF*bP^~ZLY(nNhdB)UVxV@ zT=hZB2Wk58mXT>E0uCjnNc4p`p#*F4zg20e5AP_1)eYRq2t+|lHL;#ppsbm#`IH*p zdywPS+Pwo zhC)R6V*e>~MSSh)k%fE`lPVV7#_WM%2~OG=^x>3|&Kae9T>tE3)Pa+g;|=vB>Ya;w zIqvIZ8<0-9r;9mISQ{KHBa&Z&hA%UiLUWi9wjd`O+yEw=d+G)t_acTqyqbxgU4!Z#yBQ{ZwD( zn7flWk9_I3e;JRI!AvP}Y0og$fjg-thjts2$Ipy$@(YdZDw7&~MdrluIQ7EJv$6TI z>3KKPKp%5ohaQQ>!4zit@t4}4jQTii?Mzg~YK3Vv&pVuS7;bT%rxQCt%4|cA3)EXgKoO^xO4%$?7_ePwcBpZ3~jiz``pv7&%7`5sz^@>`J0%}HySb@ zh>6u06@r);93ir{Hz%G?uYWTa{HHePIKDaP$hc`uIlpypNSv77%d**JiTC;iS_j99 zIT|@*AK#q2pwR5FqvP@&k>Y{u`3HTC+|Vy`607>{idW)a6r})Bfx#^(b7%K%{w8ki zmh&d#fsMlmk&1q#K(O3Tc`jdwebDaeEVfGWaTzeBJ77GKT~+ zZx~+-wqW|=kp-(6%o-gG<5)&2sqK&TNRi9BX}syuY{Vb#w<7Cm$EjEtL&TwAYV<&? zAwW3r%oIP}p8$P`nDe0in|D$Y->#CsC&=eN(SCpD!JAK#TGUBwo0~kpn1*3nOh0U` z^~qFOCwVf0*I{tA*sgoh=)(t;{M}pF6T6-);MEVK@WD-?{QTVU*-n?@gS!(OMOG^! zs&5wFz|Tw=t$@Jb4^&hw`OSzlATh>7~t01hRg-({~DRKr1{DjKFi=2PjB7TFvT&O4y*yU>en1yk z`uu0pu<)bdF8deabZ%i!8cElNd|>3W;OaZ z)jzBAtyJ^6#Iyb9s~Mwm?bfz0)nEU(I?mm1@lstLpZLO`Pt~m>y^V^rRHFKW?b}jU ze}hmB+b0gDYBJ+QB|+fIu!uc!P{~IqfJ@(W$7dR|GE?^!hg}N2Lk%|z$!&ZtTAf_g zq0&pW+EIJu37^v7Gim>t2Z@P?KtLN;XkJk>8hzn`C?BGGn3@~c{4+VZr^o0TE2D2> z3){9av1h=9u>FMh;s?COIJ>=_xBLn?!ZMOgoax*4Gu_pWMtU{vGf@6O233kzlB97b zR$jxm^yN}Jtlu1MDhIK*tV}X{Fx~E{V8>xSlI707pG=w#F>Ts(v6hAnw>a!yO`qVG zSUm|lC@j9+7JAGG1C4u=tc2tGvDv3DjgnpcGq(bO@ z`m_x-z?xL##3~)mQB&BDal|wZ;0ttUM0dMimit>nW+J$mo?sYvih)wugq(~p0#{3x zf?4(l416Y=`lf-ox0-Jj*7I5B%zys5g4XHStAYD;WE#(FFa2eY5A;6bvHHEA&@0EP zPz$f$zI5s9rNXgNvw-0Pvq^({oPVOa4s9$;(XKm0cpF+%xLDNWhu~&@#gmwv9OK+a zz=5v{T-=_E=%0xS;Mldeu)uj+)|dK;zhIDm5Px5ccGuw3hc>1vmYMMon0y+38QJwB zKE89DaQ%jcN8ynZM3Pzl^DTBNSGIysi_URC1dDsHssTd|fZ57)3Drt+vwlXLo^{Eeo_ zUlvouAbFOI@a3-of`UH}uUgpFLXJqi(R04HGkn!a1{V4A-1U%8b!0~v@&<>%9SgZfFq(bWnb<8{@vAx z%AtOakFP1M^4W(MqAX$*lx$$r0Z%yc|C;*}Z!Fh0YDJ{XBt(ReBvZyz<{=SLNXk4^ zW+ft0=2=PRSrkGF87gyR9x6m+N=Qf%ef#PBzO}wT;XBJ}opUPQ_j&L88uqpKzECga z9^W{Cp{Av3#r)}QReP6TJI&%~phZy5kLUi z>ITNkb4A8kbEjwN_oX!W_o2;7?nrYFhGKXzE?ZNzi3qnYIvCbg) z51a{!o$+uS;3jJ_I3{xBd2KE2r~%nGVl6_kR<4rUbONR&CH<(}u^OF&n65@{72Gf` zAcxHM{{8zYQF0_RHBHwBFx)2)W!MG+QLaDF`_Ki1RZNY5X<)_28~!ocGe#0j;VXX~ zFHa9cpp+FBOU}A&QeNlOso<^u&E4*wEz#07*=9u(7B%5u;)@UmOO}*$w&jv{Rc-~% z!63H5Hv{(v=>;ni3H`;riKnlscGz$oK75!k4FNR=oFk9TKQe&EiN*|>X35n1{f&3l zEd5*9RHnp7-M7cQJ(8?l2iHo_0|;Pld1TBuF z&sT0Nx0q7)bw2K-ymsE=;UuxV7h^fCKUkGks)N`E;ntrmP#zI}aRkv54I0L{qqwax z2dA3#yc@&zpOy&vu>MK?BirN#fawZV5_!#!ZOu70kN?V35mLpizI%-zWzM4P;8GUZ z1lZg{b(L-3&B(o{?C%^~2XVSdPQpbd%+hGw7$fVvFc0X>vrMAJsbSErb7V_LxTwns zrQ2_lTzmd9+>`kpGX6Tc{ff^nxNqJjt4dgFR!}BX-9K6nThZ-2xTA1K`_-HId=H!# zNtVCt4-?X1$eErHt17RpjU@KdKYU%sKs7X!u+1b-zkY20AiYOv+ZSGnx_IsKE29BL zefDG9(BMN}2lyVR{-?ywEv5(EJU@U6lp~k?Z2$Pvlw2djTlyk#BF>IayQl-#ZTqDz zDs_NO_BN});l;smYgSonnH*gW&g&zYcldbrx}VC-ZzlP~-fk}OWMy?$)j(D=Jw05f zAd6z(b9<%GF3pWLft`^dZ1AR@32AZ8(AvjxgJP|+%|o_v$4-l{pR-D41^rf4{Trv2 zsuhN^7vFW;tG@K;FJw^t*vjEiT_F?Eiv#C@-j84|Juw;%^OyMusxMT%1gje3F=7J` z0W)C&33TsF<5#1?L@Qp2y_l{%i`t*AGPU(c1cSA8d0S#ORFx?P4?Ix#{Av38i*s?} z!Ns3n+E&CnCp3v&M82sLGRam2sx4+Do*K@oI#FJeoPQTNKQDS%s+Q_LwNHNusWhyc zb|e=KSgB1_U)R<%zt;cgt=+2*>&n0%%Cy{{WlL8isC!L>R|9VMnwEE|%eBZZpJe4| z*uTZ}!E@1fKA@@3QupiSDAgg$t354OR{tp3JsZP|Ih_y8{k^ z@h65U%Wt`Y<)YP>vownsRP#GmR3~m%nh4JvZliu1p8as*Sq27h#8CzX0b>)QcEY-> zu3-5Zg`z~w5YrrVC}Iz9`akK@d3C{hzc+)(mqLEdEk!?K(7DNLerogW*|D5K+wf>t z8gqvA=L?hW?gh@ZWf-pzCaJs(@~O_zEcIS5r!V(@;%m|VGR*RN2bt%quo^q6gS8_% zs_ZXJs~qBTMJF1pPd17f##ArYWUx6E9- z&222{Vr0UFy^8{!0$n|PAJ*W5{7wO2b0SWui(@th@# z63A~!f1r_*#5AQCGJEZ%UhccewW0XRrTF=ocU9nI)xmot{BZ3b2Iz8)pGL4PHySB% zVgcfpCrW9m6Ozqk&O`jI`wPWXi+@M1A04)OdQtn#!42I#xBmPgY|d6L{yl;TB(XG* zpgZj9&S^B*#Vkv~v7PLWNquyoYWAm&QqC_&a<_RIJ#|gyn{?KBx@Yg;&Wmnj8vgWe zz+kg*LZ764@~&^kls}xK2o5Q{t9GLezY2S+ z2Pyo>(8#2i8<11#egJvR`J;A>Y2_7`e8uDT`)n1u<*ZUde^XDkK75Hb8OlrmRw2*9f&j9Q8+v@|VF#~(Of2#u1e2n&52((k$KFzseBpdtgi43} zWwFE$?)0KA5T`y|5q`jUx83eO+BCvv;IPl)PDrv4vxp6Y{`Yo#m54g~rP1b92k`qT zpW3M{44;IUPj-xQQU4U~Jd{u*7?9IRabY`0H_{5;40Z@ZMj4gzO{fdZk{>V4V*K0+ zO~hw!c$2wiSXP!w8b^{&cxk^G&8B0wo~vrKqSl}#^;{rv6x6h+oI1Ktt(Qk^RfKjH zEIh>;36mSu2~k;1`9CV(8NW9r3%i`RR8To)LHA}{cjm6y4&8trcizr#M{Y{WD!(Jw zBguNvppwiHac6RLpDL-*{`wa0%a<>|SrwfPbTaV_JkY5Sux4T~y>e;oUe+7k6^aUh zu&f7iPS3cqPZSQ!5-TvfW~%Hj#-g(y2I(?P)*(7e;=dMjZ>QD*ctDTy_uwC&S}JKX;d_kR zz=?`-T)v~AS`bgmkuBC``nXY7m5k?dQrRnYV^}xMH2LUdAN%HYMS=~FG2_?tjhTfW z^4R%guttKxjRA!R7yv@Cm!-^4pDx|Tr)omUO?WkzmGxPCvA^Ng z%T}8H_K{_m6$ytp*s9UGvZ0wS`NBJRc2;oin#>x5g}j)^7LWVy@sgJ27&4U8ArFy<3nAlSo`f)hT8HU#Sei4JXspwuP>_qj^~s1M#c8mml6a zDde0uOpky$;@xx|A$W_pN zM^Wa{7Bk@zn$qc{o3-qm)k2=rY7>hxMiK9J!r=B+y4H?1ewbtL;0zg14R> zn3$C>TunWzn5;b&&cK^?Yv*~`ZVgbGFMk(jeP?Dk{N4jwo2}Zvw;|jKc3S4J@Rrc}H%p8_4HcUzXqQ*6JJ{dhbD9W8dr*vH$Hg zvZ&f}ay37}?tg2GL<25;`~P_t(*L_`>C*AmL>WsT7L<)(oi%~h3|7#8vzAcpT=8cM z(-hdL5!!Iu;l)n*Q*o>n>V zN(vJ|EJwf>3VzI1uz)RR_NAb7t337=iQfvK=a>KMNGjYa^Xp{e!}iy7MgRBlHI{Qx zy;I6H_}>mBY^1^Fi`8|r(hry|5f0o+N0#njV>-y9`1#mu6I|5L*1C6jZ`&vF=Beo; zBI`nr`*r~B8|cHrrJLavCRd#tjfI$RY;Ism1!M_oh%XBdIAD%#6M3=z)85ov(MIV^ zMX7)aybbu)y?1&ti(9HWpT}IDd{_Hs<^D;XxJ)ll_L3Hqw6jHNF*N z5IkZ<5V0Iff(>*g?}x*{GSKLPY)10^?~B#!j;odfD-`E5yGYp9Ril`s=DKYq9y)(3 z9=9~PA3P_0KT_lOMXia@GlloWBVGj0B`mgiWOa!#G$fNyn%i9o=cr%s_gVd#P8oG? zyB=3(?hciZt(0l&)z@FRc3`~#ekv(-CCi*%!o@f%pqAj59g~!i#|@XG0!J2aujqca zRL!KFLf+Y8ABQ_FLf-4r3tmof3?1d;5~*_%9ipqR2Lo@=emd6fLaWM*`QUIsBs52M@By3y*vv_yU)8#+vM)D)n(cil0o935t4aNYUB9# z7)!qXkD!1f9M!B=FDS%W;R$*irHO1JsKc-w!MoKiVzkp9aEDaOHX#568Q2)ZVf0iF zo+OqtBdkCm7T+l~T^cpcZN0lqV&fq0B9Kq~N<1jgo*^R#z=G?J`;T6XC{YW}dJQ@b z)YH+m7{u_Z$J_x+n-F|prbUtpr%E1&&VuSvuq0~z%HF#2|4N5 zNc*3p1g{9LvA%fZg@oUKr^MX$lNW?2^&j`uNXjjp@S@a+fufdgaZX;1~YltZvaF)=vU!v@hICc|0qdJL`7Arfz=4GhJYZ zXZ2pTaB>{I{{*OD1OmQCBH2=9`4&=Xgs^LL>TZpnot)(MDBR1(n&c=e;^Y127{CB; zS8(I;QL|S#VgxZb=fdoJtVrXI+>Ve=Qa=*Z2CbvdjSscooUU|uz8Zc2gj$?_Ske;6 zH%ccZ0|Rgh!&^_`kuG{9_3eA-5*w`X%Gum<+_N#VJ}s0k_-bxmYN);Ogv-OSp#$MM zgao5Y zEYX1~^>uqY4RSY9B-TX{eQU&*8F7}`Nq=>>@yhM(j4`}~<0lBWn0?>ZlsJXmO-ktR zsMq2ZV|bD0@I}Z5e?dl0V_<;&L*=|V`GVjGzX(gvYvSYEVu@{PHdVh^)RIne%62+_ z(O&=D!1~$T_yYSTm;Eb7jlk|@M7N$>%D$P2+^XNk!neNCefj8$+5(n*{m7C=I#kh> z?i04=X`xuARlluBW(m6)#-Fz|lE|~{CWrKM%MKg=I zoAn)su@XgnCIACh4hy`>N{jB_EH~pNzo2i%^M>{66&~mLtb5zCKkQQR6KZXf=$LTv zo>@lZJk5>IUTJgVKQ& zkPtU0;|q>S1!pZ}2F>UvxpJ)&zRu$jGKZSsoOapXV_iTek7JUjAF@yoymc)QJqS5-aEgM>?)L zohvjU78arM7x&T`+d)-1qdb)8hExGNoP*~I38SkCm)F*%uu6j6D<|}(;3qvWpI?>m z3;O|M(SIBUkW(O4b9j+x!ymO&^Za?h#f`7$z+oX?$>oDbKFsrdVh)&zr}6^oibq>d zm}vj!vICc|6?N3?B5HW(Y6IPxHwF2}vk>t&d6YCzo6V2k*t>^e+(A(X~I9}hM#rh9NfvrY>jIph7nA=ISWlcH8bFp=7;Du}~+~Nef=WRpd^SRKW%ev`7V?Mm)xy~|`gscZ$dr?fNpDYP*=((< zatz4;0TlkCu6EZ=L>T;q*__ixo>JRim7~08ovUzY*{gTw$(W+v=Q#p9us%xP0M=u0 zYf->;@=wvsUd#9cF9?j9K@vrzq(&u%IWkDQQC1a^uMj0 zpSzYwUD+`;d$J%j`eks}s6=;t?uMMc=F;z*c-!7&=?di4h@8W|2x)ny&*-j?2G zKO;6x=n@w*IX52Zyx%dsFrB^xcYNe%q6pT@Lj{ZlsAJb_*Ext)TSWu8lTV}%+J*hqrh6 z#;6U>u3(b2#g}$>Oy-p`<8NDHW!b6C_T7Dmk{Bo1Z#yE5xwvk}mUQhW_XAD%=}n3~?EyzJ)tk9dLKa zU)z_7*^o)gzDygKMdd?u5V9PT9H`$Q2ErE!eEcoMp0XCu2Ix9zg;ln+NLcGr_|1!M zyVY2$Q?#$9Uz!M@f1>VXxUoT7GIs1IV#Kny@TdVbaw(J_qoBigN`N6Btzun26`E>LCEWNk#SU~> zWr(#9XuvN^(&mrl4YpMj^yX`iC@nmQxCDG^sP+~oCRrc=OwC6rXtR1g5JH;ZteSJYK`j)xp8z!8%Lfh)XCN5^4A&5SurF9CIxadarT`&(Z zMWc|cjb#`wHoDfGgvq^o11_I-yj*aWK$PF@j@KLQ{iqrk5>Jy}7nEfJRu}Fw7P2v^ zDDX1Kym_88kge|pLSOhEDLgTPp->Vi95NGBd(h#N9g|KpFD0}aiyrK-4vFDi%*og% z!}r_fCU%yBE7PPkf=8h(A0onbt?N-}p4A(x5TO=nyc|Si(5g|npk&`Y%%w2pfZ?Zhq0dLixEB$t1(+72m#C3lD7Q|xE$U%ah^TqAPl4ii_S?K?%>UMqqN~BG5zs4sv30%HZcJ^b z<58DW(i-TI5f5S!bn$4GVac795vKF!3u&IA$}LmBZK0azG&HiOS6+qYV6su;vp>?8 zaGa}7Ol2pj?vA_HFkL2apI^1P(U@`A$^2M=;yxnMAknf=l{B~E(-~d*U7qVh_gejE zv)cvEc*1_$`RJ(dj$S?%nm~kXuV>0zyCuSZQ}L;WDsZqg{>=?+8aMmV32H2{7bUbI zf~q~8Z2?p+a2nQYaqL0)nE0u*Sk`D&4LTxZc;nTppZxRlkuou}oxOY+R_X+s|C9IX z1%VLkDs5V0LXDH3@A6hYwPSVeYJPT4885#=RSm*CfMTzMyr+Eqku{!vkS~0g^E;hV!>0MRN456PQ>@0|tD0%vgAv1Esg&?+0;Hf@EgVGeq zSxQH9e-1>t(A14@HVE-}DfrR~AT>>K&Z02_SpXC$!tpGc-0xgOm2D@k1^8tV$SY_? zuDyJxO`6BQRc+<40LNi_$#{=#m8uf^#8G7<{+kvd?Eego*8SOEuH7JzDve{I7-w~@ z6NNScplhk^aOC-Gizbb^G@7*3l|lYKK5SGjEaddl^=@$)0w^1CKhTn(F+tiIO5tKl zG%M0bF)lW|lVfMnDl6>GlXEL<&bxZLRAtLwW?pFMG>LWkU6lLrOafY_;FCb^vg7GmGn81gWj z#pwrnd_tEggo8BpRxBNAAhjka?iw*5W5F>6n?4~uzKw-FMFXwevSaJn&xGFj zUc@|%@JJ>Z{V5)us#HtiyR8Uhg*}`Jyc+v!;bJ`sKEb{hkGB-H@68|7K7YcA-O{KL zfJOIL3Hd_4-Oap6E7hJ)z1L>KdX`(O%pORxH ziETGPp3oUC(UlXXGj=qyOYh%v|30P5MA%y*77#xYN?&j~wiOL{S>6-O{zBm=*@v>Q z=J({Ddz#sdXBxin;$cM4sE1wZR-kw&-R$q<@P$>YZlzp+g}S`!>A?`ZkS(CFc&*NV zCS)WKvE6VQa2)(SGecBiw2ZHy2EG(vvHy`g~!DfTB=g zt>5lz8FO;xcs;u?x4-yRmS;W<5^@KG0_x15a>9>T_nW^Ty{afyh&PYf7JkxEp_vk2 z^0z>6j->_DsR01Q|HQ9HNlmMmQ9`#0aFq0WH#4B7Tv5`@)tk;oj9iPB z{kP`8+J1CmrN=$F>`=sPTDoxsuLco+(2@VXnbej2gUc%Qd;v4C@7C&wS#OpKh1_k2 z%uiSUIVv0!Zx7TI^k70&L>OY=;NaT)x>-|0+CF_`&&WkI>fj3yLmTviAVTb2b{X#@!ch`YEP6&CDkXwc=GFqhQGxB~j}F?Ihq()ME(CQz!5|P)?yAE9*dE?SAye z4>H1$q$5Q7v7X_};mOyMS%|&IR>dwXEZt!#hc=MdWdPu&&wlZeaAi&%fEhy2k53&G zrAq({a5YZ+eW)z|4cgIcy&3iEJ>{PfahEj%KXX&d+_;LMawarC|7UO`mBnP}!nr4N zx?cC+dpX=}cc$aXaW)~D+VXXZ*EzzhYoy#EM8o${$~0DKN=Z=w<5cE;tzAGrR+;0* zLoE&4`A&(eLJbn86wAK_Tppi&3}~^_J(+brLt5*_pw%JwkoHG+Bn2tFJEJlb9zKr! z=$^ZUIrMJRxgOb^`JFBywqHk_)2R4EO` zgeEsVwsq6*E6&Fa01?+*0TBRTiBhJkuDTtfB5szFG`sbb?^?fx@-&!v2oFa&v(7#a zKeUfVI#Yp@U*|3jf45-`>Ngx`5K)ir?dTj4Rg{pv=g=iVjmV4FX(C5Y8>k@CFV^I~ zC5hrufN%sClUd17$L`+Gh`@#dlgZaVy~Z#Tmi9zzU2w8vH+7|<*jp^&n@n_sehOJF zvQ4&Ji*8kJZUI|OZXTmGibEXP{-CwN^1$dWdI!A0-#1e}Y-EPD+ih=4%e&IJdVEe- zb|r;y{;D=5IXvY#UDJ!N{V-*)+1=wOK9d%iPP0L~LfcUK9 zv!RZ`G~Km3y|!HM5Hxd=lI;%NKLHF6j>UHP7c>zO1@; ziqv^Hnu$-QOn;3|Tus>{bJ;vw@AExwt6UIk(eUUBF&}nswSxFybMqL0{|7W-bhNJa zMnH^-ygodvl74zr^qtMN;ho51xFjjPsy1=cmKrgjW;O}U+s&)xiofi$ch*em=eLRs zDA0v&S9a{U_w0zLK?!R;L)s16HREIBl6 z?6xjlnGx*qq7N1(8XseQL|&|TUi>|k3cDb}V^+xVM#3s@e_i7#w(s00WZ|!poPELX zT%vOVZPpS=!Bt}~git`j3sp-rg{IXZwh{zrW_3X9BeD%jFWhJ39FT7&nBQTo&e_Mr zMnoLKlB7v#s|oE;95qlKJC3bW;XBVhY1E>RPDPWSV@LQ{;t3H9rIF2_F94O{+1QxA z)ZZ*ME`Yny8)8dJ$~5zKvP&-pE4~cOuAo_YicvAPdNqmlzAsbo<7HQdhMm8 zaUX!91akq1Fgpz(_+s|av~RvF;jvQM?u;SE@OfK=HtxQPg!=AZS^9F{L%wk59L}X= zTAZnDA3(6FlP(DCezcFxP3$YKFlheh8^ zrA#9@|NN_iN;-R7*oxlW@TEc_a8&Y_DJvb;V9@#GIV^B0j0W4YleBF{Do(78_XaC98tZ>sTHnB{fytdxv0;+E zzwqtJ2bU8X58Z0ayN*<3bq)JhLB>EU`amko#vNNnf$&2gO+!P|Xsm2a*KXMvPGv-| z>M!}WUoz&YiIEWqgvzkdI{v5b_$c(J$k#`=-Y5SAo4UeqfZiBL;dEvg7nInNw?NTY zlnG{ZY|HmFul&?K8cKDaR_$1ZV%aO?lC|OT1L`S&$rRH8jLfmVvS^^f)awIJ?F;JS z`tfToi>s=_fZ<}I*k6%jcL{|R9{VlmpbZbqjgI>6>ISpl=CMGj81)4G$K2kpYVK!0 z&I0L1H>+k7Qra6y%4!MZ2jLzO9H@HnnZ7HM1O&3w-*8PPVc}}&ho{e;kpVK>(&$e? z8!=a$;uiH9HaxgHHVP@KnXhRWlMkVm1(Z4D?g|rKw3;bT4#Y*F3qk^dMdcen@`8Slb`}pkDV&9=na~=K z>VsveAXzJLY^E{T>e zogRv~_zVAh&d|KR>&!mKu@&ItXe1uxhoEbN7y0wYXIh zm7Az6@%9F{qfrA+4&ATo?#&+$YKaB1KnH+EoMy^ixZcqJ z+)irJoI088Nl-S1eZP%$9cvLL4tSz~dwnU&rZe_XM$HOhv1axgtJkgSwtIv1lD0?N zoeU(6KB4{|+~Q^GgyV;twRM?>s%{V!wGtMO1akTWK^5hkkX$9MI}=D#NbE=>q`?II ziM097TBbm~F)^b_H-}9nGPT>0*Hk2rA{Q<)5VC}#HH>O<*}5@zi*5%S?cah*jB$GdS1?65~T0B)=rF;3{6a4ax( zK|?&28F}nBug1{dAq=Un<8Lm$9ND0Ox0Nd9>%grqV1Tknb!~?r2A+6gKq3hs8)TQx zQ218U`g|w-Gg!NEK2;&tRVgOx*!YnGE*gClv6OyUY-*XsyHpS{EQNO+2oMap?Ihin z#E|%|(dgig$wy2oc|Tj9?{43(D0NIgaW|!XozH6db5hMxxTQITejFMyxwuTbtP=zp zp3s7Nhz{>_ojs>`E5d$|vpsAYJNjK?_+GC&3hHPrzTYBS*Va1^XRgW#rzxeZ*&#VQ zt$Z~gxumB5tq;5d=m3Jb+26nX;q2r4>-G5K(tBWX4;wcO zv@y-=nAndQD3lQhKR`>F`S+#JMAIM8%oTssWqTsd3WInm{V_&=KMi>)?VWFb1Y1hV zS_rs4&KG&Fs`P6@Z1z2J=HrmU7h@x+unRrGsqimI5f#KhC5YGwn(TVi@drD#Lv z{t>hmzl{m~9mLL^3X@5rAwE+@s(4GIfPdqPKU`Z_- zJ%V1HH8R);f~MPNDRBhWf1d{(YpZ)b*D}eI-${%drQ7~$cBSN#T)0!trVraLE!HO> z-M|Xq4}uSY@t}wmy#ID^)6g+&=bqFZRH^OOme*olsPs4?ITNc8Q%3h|FaSRR{XmQ~ zo8ic*I^=0YzCCUXjcL?!0-i^Miv{CowHe}AuN~ss_|BB8O6}r=K56I5>A{5HafO+) zZ}o?(Zp1c-Dwpi@-o;vzkWMjgT&nj1a zTQ}z=AGZB&`?_M-Ax;c64EU?q^6q(1#mzk73*_@P&y1OkF@OcHZz%@527YU%Y$Q|%@2t^6#@H%OkCRF#8 zAz!b1a%LsLQCaa!4h{qx1=$$`r#IODU}*&N=gIDv9J`y(JL}>bn0gw=ywcY5W@X{7 zWY@VZN<3>;*7t$y#6W*P;YP9I3Cx=w?!(*3-cvH)iVUCu;~9Fas3!A^*TUM;La7{# z%TeT?D>5Z8N&EyH#7AMw#s5*6>OPN}D&WKto8@pHE?H+Zjn6DS#m61lmZ{Ga+&~vw zJvb*8dM<{yP!2-|VxkQPU_7a*>5zpBM|m5l)l6lI59KjS+Qx>Yx^}A8Y>zr|7a+ae z;F1UJ^6&b2l1lQ7o=kxqn3ATSmhQH;9oyBsNSH;060;llm)CW7Gw2)0i^(OX9R4(b zP6NI(TVciV<$zgcSX)E2G$lnkeFh5RR@5CB596zLW6rT6NqId)b_c*cbka0%X9Oyq z@3kz|P)kcS@4dSt75xeHUx0z2_S6@=pC>i#HitKc`;9ZdbK&$)d!QGXR-w}mY8pqK zbEORyo+_o(?;#x=5$3Ty_{uHDI&ih%ct~K2g*#JvpDWYsDjpPnNJVS>@S4(hzO-JM zZQS+iA}PBYFCR?d;h+1haFly|wnygrhb;9D#%j|@jjno~G_fZc0>GF7?5aR~0{&QC zeJo2GG)#%K3Vk&w0VP7KlzjBNQQiLdlveUBOIm|ReA+*Lgh}*_aXyNp;&i(RnX)Vx zlG7ev>xz`l&y{!?9i>`!ok1wwwBzQn4n}v39}ymiE5ZFx%jHlCFMG>xbmhO6QvbHO zgk^Mz$4m(vh{T9?fg1hNsi( z?u9$8M1#+Bw>PC7!BrQ9K?-zR;KkS`ShKm2PABo~Ia6>JCns%Iw)6u+GvU_<5gzC` z^C1aYl4H@?LllS1b)P9pwDnp8mPr%X!D)!L0;S}`Z~pdA#%6<}k8N;9j|ebe6FDdf zK!Gv(!F1+{{(!@a8{%DNcKShk?(Gm~2-Pn2YjE303#+>^#!X|I;In(jUFjoQMOWER z9(evOo`uSS@ACTu`ktUN<8ZG(c7OO~(k9FH>I8keVsU-@+<68%*;8@W3Hwr7&GVu+ zBTLGW1^8ZNxqnQWbz5pv3T~jK~l`i-CUdNyiXuSjEK&A7*H22@(Xr0p1*Sk4(~N$$pgV zkqHw0Ju_aKq`HYavX9M-#FA;!o{XsvWTdAk{UC(E02joOUoCc#-^u+-bj;=M3AHM5 zm|PerMga>(2bcq;z^4q(!nluM<}*6#h0?U0@>3DLs-dT{Ia?v&fH>b$>57<;r;9YMgz0C@)~ z2}&PtZw_>w=sn?%jPf6$3YLOONB0H-<0bb8nWST9PNfTEy(klEmXa4v^hiL~3YTz3 zwC!j~@PwVQ+XAF){BfYd*c@hA29v>obF;e}cG}L%vR;p_metr3Lq$(d>-T`h@IP1! z2huUaj-};yPTH(GW4Urey#j>~%yx*SV?=01>jyb*+xsINxh*8`^!VLnExz1fbxNVx zzD;-RrvJjtDY;)nS&rd723MgCZ`v0COz9R4@aw&|&m!L_Pvldb{*M-k;$&gfwP;P_ z$`xm^h+k>Ong8aGM-2jfR5zx^M)-1(ReuDv7#B328AM5e8pM3J%4en-2*gPXMNhI&kWwt((A6S50xy83yBLSmH7+m{j&bTT5BE^Ci6VcIc(a3_g^R?950~&4#$U_ zr=p?@C%eE)BF*lukxf0hbe2~{_dTx^Y6YuKMTEst<{bo~ZnD&P$0cF+$S)Wgj_%t5 z?5N;uXy9Q9w(y#dx$0Nwi@LH@rW-vE%P1({0fXjA)qeXRowrk*+nOoeWRr@Ym{Lx2COK~mK$T{hZP2=ANLvBj=TTj00E)iTTGoFAU+nklssE`v_dAlV`|a# zz&q`AKDO{TQ%h#ReZj296qdtGHuu2xBz>BW3a#^*z2b+?j%F(WTxWNWGIfw(n;4Oc zSXQE6LU8~`-8ZV6-@ixkb00$QrOcs6&ZcUgDJv;MI_&U3jVI&~E&Afp?OB(uqcohq zkhLbFu{|bNJxgR!KIqDZMqYYo>g9L^{$sbLnd+5~KjO_2*g;qt+}aqpb+=<`+)RiY zWD?Z0kctwv+~^d6MJ%S!h5xpaUCyOhGb&~Y=89UhCSyizvUO1`+ayDUd&_x&?%mq%!2{U6n9UO34u z`T`pHl`I`W)lbi@nLq}qHZ3A{G0eD?kZ6F;FfcnO?%;gE1 z3DLLHY$uN(QlQl%mUy6~mpHZOy{gRHS)ps9B$t@0gG>FkQgY9C%c!g-O=kC0&1*0y z$Q%r#aTZ}A_@kI7oRzaHTUb~ahx5@BDX~212REj9Jx|alHkg|o4(7|gtGExlpO_=l zr?1fo$OGL12WDTZ*zB|GvK$fZEhj=heqBzhsN>C4w{!7~eD#>}B&c%0WI$Ur%T(r} zO@-;?#lLF<$i8h?I4wIZidj}oVzsLtiAhm%`D^P!@-W#IBjJvzhj{5TeZf<_rOT&I zC~GGaS7X)!?;aQGPQ;g&Y@Ho1|2HTD*j8Q?=akaUEd%!F-9A=+t3$Piq7-sB6lboB z>1QYmxO-=`N9y_|y#u%e|G1QkBS3LlCx|64u8$M!I!8zvH(j@~8goa_RMLRRYnrRh z#~92#7O$UhRhvAS8%u;Dz+^z4KKr*4H+zA2eXYAer4~k2-z+phi>x$*`K}ghS5Gbp`sv?&d6mf`fC{E_R6a z8EO3WrMV$`((Mz=7q`%eL-$LxlJ?%aD-olj(jIPTFX7B&K6Ag_wS-4vCYG##kJUzO zn(0Hxn}fZVwJBr|DXyV4YQpNS&Gp*9i4&$HpeSI{+~x9exDms8TusnKRz+VJAF2^$ zT7(mz!(AQ=#gWi2;+j@nUfeSJ_DYOuRX;uD$+m96klN>Xucyk#Wh8CF+y-S;`m8L< z`prO|Y(PLy-nvw@Q3&@vxMcDo!Y`mAL-tMox8dF2@%1FGM4R?c4yy7eOiLX}o zw(#bLm!H5H`ZgWhBXp|D<<6t!uPzlR6Hq+Kq+P~hNtBpaJb#`0lo;@3l_OHJryt$* zrP>$mE+Bsym@I_xr+P5E>YQCc{;peU*{`7pE(B4#fsm6jTLm*@^cm#I8C%$XDbh9F zWox<-(vdFEJ-Y%PJDBFeJHft3%{;G>dzZ9ILSJ9p2Wt%%V^ja!8Pu%VT)PbM1amh1 z%H5Xu(1>=cK=fol(Y^zZcs;%dNejM3`QXYyN!OiHk;u;F)P>7u;%eSMhaKM=n{oA&Lr)XX`VkPxGRD#OiHav z!<<*XIV~h2puwDAn4zD@JG-W38P%+irbVg{!}|{*fx!{Ddy6n4{650Qo5G#*f#1%I zUg?}rDcq#tBm`Jy)4sp+qF=uvAW-~i>^-?r-IXu|iVv7$fN>x;#|grr1J()xAXs6C z+v4{O()pcRfBa7q;WVXDZ1`nFd|{;}tpt;DLnEWly4_6oNjD0f^O=JC3drw2u@gR5 zN=%~A?EE(-O2}FKn3Uyuoki8WGyHfav-qMJySgF;FtWy;T%Abu9JcEGp66phLhIux zN&zVuKJ>k7s;a5mZ>mlK@AwRR|GD*{rs^h*(EbC8xtrdivix&DwfO4Z(Cpr&Yf8?J z%}=KVo>n~-Xg?#wOt459zdqB{o+`W=E9r4{Ws}JQ%^i$8-e|q~8{^?4!nBy*3Nwg$u5Xar6%p znpiEIbIPT6tZ>VBE9@uLOg!`Dm@U~vnu?f%)UTr;dSMic%52n47UW$3IZ%cC2hgK& z1d`gOWJdy?bEAn?-I>RHGV$iW$1(~tLDtIPp_dP|s`mZNt;a|1-`!{)*J>*i=F&a( z_Y{wEIAeZd?AAQp&Jg3fx!b1lnfO)TG|DEGbA{X4E!sHlRQ{fB+NlsYtx?vX0chY? zUy;vUew~!%Xe`^{!=M0!8DIZa{)Mo|*4eJfErv%%c2X&kT<-D=yoovD_CWAHJDo5vfS%EMl;*tC_)V_U)luEw{PpHCx;XpetlN~smTV-= z-fY(`!IA}{(jj>z7{aGYsvDT3TpTvB8yR@;h2uD}EfQ3>?=!inV^X!hsh9L}sNFVW z9vM}e+Uz@QpL_`0-{39*!5g^y)uy*v7uLqW_SYVtZDwJkNM#W%+!>uk8hlf6j)vP- zfy3sJj^Lqq5z%%!l_*Sc9`h%#$P0+&&K|lwPZ~^nUvoc%h;OV*PZ{*ukzEjf-1k;9 zn8YyV{D6DE)B$X)IihUKOP(BGK@vfAMf$)YdF`$z(H|V@XW8tQ=p>wt6y{QUu1E`S z#q<}mcVL1c86a~4@Q>33V~@yND9^Ec;-Q1uU#%!ejtdG7p+BCkq=9!6JdI%cgdsG6 zb5)uG?#U_^4k=}sRrJ62##WOiTgR5GVNelNT7>hO8^u?Z|9CPmUc8riB)l@XmE3u* z_A0-Zo`Rniyj&M<{q+LV;?F3>@mH8617AZ!hzpOmOyn=Z*@Zn_r*iLaXF7LP9Qc1z zEN}1RV1M4v$t{*1L+EO}|Mw_A&0SlsHwsf^_5X5)(p>&aM&_2xgg)o$1%Ik#XNu$- z+Y`#4NQXocYQ?X&vZx6?S30@)lt6y zsQWcF<~ltqVfC=xz%W2KN4mW#K_acUs?$Ntumh zm|5pXP~87b@|4L59xAwmC@9cVA)Mq2UcJdsUuM}BK*KOSGZs;;IxlT)G%Kj4w)r`9e@t8RByDW*(V0tPKOMW>B)H3x znX>orxY={=^VjwlQ_pKb^Ly_IBVQx+_@iL1Yj@)7jMqd3_E-HgGOT{_`?>Hg;a1Pe z<}ye5-v{`#;zi6L9dr)NzHT(c4(TlM-}R^C=_@J!{fFol5$gZ1{`J?bSKE$QC8X?K QBEdfzD%#40ikEKx9|h1BMgRZ+ literal 0 HcmV?d00001 diff --git a/gan/gen_images/img_400.png b/gan/gen_images/img_400.png new file mode 100644 index 0000000000000000000000000000000000000000..f4bdea812bd573d032f5e9c9afef537cc78d573a GIT binary patch literal 81318 zcmc$`cRbbq8$T=x$tHV~m5l7Y_nt`-C)wG1>)2!$*?T4=*_4@VLbA!q4q3^4o$u#& z-+$fz+<)EYagv9_Iq&!DeZ8*hc|D)c>m8+|rHqF|g@cBMhNr5cpofNb?FjV`8xwxg zKe-SM|B1RQ8oTQ|S-E>zxIRPEv~YKJaB_FBMKE|ib9J+Ia^&Y0=H}yKuyJ>Hb`#^_ zdH(XGp|JYKSgQc1q@6zWlB&K0e;QxoKOVTi>Gg?BQEZ zU*h>Y8ca)p^mcod5nR<@m}H637NX1(y3sA}FZfMm`MoQe+B#-n{NICbQfKHKPvyS{ z4gFZI`v1PwKr56@O+Y=;&{UAz|NZK<1kA^Bs0RX_0k0_(_2{}TL*;%G^@zF|EU-cR zzXu7L?Z_P#)Poi6|N9$$^30U}Xw22=OTSLl`^Mb9&g4uKQ!>6AvFWE#KNGMjcv~?f zpZ%}*LCw)=ft;aX*NRJnDfhQ656k-~Kl4(C0j*>_%C|MnwK3MH!sD%=2p7$| zWbC*k#j`Jd&VNLPBom05x*A_dxT8+%c5n2^oguo2gS8F53&}~x`p!*vbZ??EIyRFV zW)zx=x+3B-RWm!D)46n(#vC2Ry$>rV+ae$R)wl@YKHR%UcFRGCng+j@TKRAC3phlp z+9=2RTb;adSs|3y`TCg|8C`r6FfVCjBtBqKimG**aFH2Q7}}(JZhy<@Tryv|nak69 zkLvL9>-D3#zc*TV)#e<@Tg~F}YAIXI_HLKR>XJ6hIl_}7{B!toQWrg?nhCo+lgbW6 zP43JN{#+TOGCtY@GhDOr5P=O6+-MsD-`EMeu<^~%ZbZntttyI84hnoIK(nB+5ie z8-6)|S25wp>2NF3vR=0AMD|Ju7b7}9)41uZrPJRD7G8^BELR)5tMo_aFH-&Q$XL@> zGv(T8IO-+RkK>zNFR6w1SLm-On%=FPv|mZ86%kKO^|6c7;D6uo)C%%ye*E1*$SS#h z=DAIJxM%ZVJYyuL$=_CEw-S}~Oss>$kzvb`6ZL~=4)gQ3Ke^Hh{^@>hpi($&O-V=) zkyJrS$%=3-4aCZN*u-?dkYNaZ^M(?l?$lrEU3@yTdvsTK5e4xvt{osiwPe$7!~#jg>nKIAwz-d0t~PkE&D zueM>Q(T#7qH^jgBx1bTo-~ReE-6<*iHhuk*Gnv1*$bSn13G|qy^1;3{1p2=cHul0{ zlZr?c$_C*nxDcBkF*nI#j@i|9th&nTraZ9w&LSeeX}!402+>&6+#J*FwU<9($C%v5 ztN&Oc_)#UyWAU?N@|Ng z{~>xyhkB{>wImBm58hbrEyAr2R`1CJ$O*P}I|GlOs>NgwXpJsL9^2lRX?o{2m#Me5 zR;nhDwzi%-B_OU;5+>_#p6pHVlY%HjdwHL5DjV|00R!Io6|x)gd0+sS+pGn~< z>Q>cM|M8MzeT-2>SZ_T2(`V1Zn8#P5t1|^uR21N>Sfu)}BjgxQF9XqJiu7dRSv4hJ zFlvsR-*ityBac!b#KjzStk>lt)2*1uWyd+mZZ_qHJmKAHmZEmY!NI}#>%R|{N`v>F zTSdsZi^SbZdVfbR_mnPf>kDpDbrz}4YpXG-)X=VnvQ$S`ScBh`#91040Q1;%iS^6 z#$4X#M;vx_RAO290-Ex*)7STz40l``7ms~ic76zQ@$eKFRakg<-1hVHgZ!jpc$+)* zR$x1Qe}6xAnB4c78TleT*q1hSCKouLaj6ls3$yy#aj~6CiyP-6rBhpfTd?YeS~>7L zmxZMRjjIC27?Sc~ZJkkTi@{Ocjo@QRR@Knfei|6qHk_NPcIP@$_B$lMJBPUUe_76w zDlS>DF+ob2brj|zyJgBvE*-9*()FQr&SrH_rud?HW}~kUxtv!TDxY`+3t{PM7q<%+3Q#&F-WZ z{i_|5lVp>VlOlJXaHm?-PA?vwIiLN0_F?8ZBt>|l@f^)p8r}UHC~aUE2FC|~Aimdv zoT+!}w5wwx#QwDETJ!Yhfp>xi>ym3@!k|@6Z7tHN{gSNFbhqnWXW+IMe@$ZMD_zo5 zqKnFHQY+d!?(<ViA+BvcX?K$ zDR*e6g#r_i(1s<=CK_`XpV-@>AEo2h?CNKh4!q6lXCR);MA>gEe(vZ%m%2RCzm9(G z?-D`Kr}=rh@(Ipg$70dlOqp72a(RSg#}ktE?hIxy6h)KDo`_X;yetZq2Bu=0?ge;}PD_r%`9KuH zblX!LBDHCbn+6|CTpT|F$?Vo-x-XTYLrzM4r?lAkjzCyPB0~D@Sj>(T$9Qnfc?7f+X^59;00_;*sl#i zS5mw4tucTqoZ8MXC+uzyTDh_0i{Do}3WS)2d_ez+1;W%smz{LKSNb23XEW_^j&y_t z1t6HnZbXCU4i%gw9Gv^(_2D&08SY{=A3lUmPd|iYX4>d_!_Cbt)8yphGILU}zgF*C zRXHbwgUk95Eu8dESJAhXm3c-LSzkSFS_q<3Ms1#hQ(HMxM7^q(6kJ>CA ztn@+@%r^^=anA3w!NPNiG1YDjp_Ffg0OiWCVP~2aUlx&&mNbbo&LqkPKo9v{^ZEk21 z2BG*>@K>&lf7PlEO3kHJ^=r!?)tM+Z&(Vp*k;>5D)cGb^f}N??U~qR~&!=mu#9pni zQ>h>XU~1J=4D5>zLAF+(jn*_p7p2<@Us+l)4k|`%s;!_Lh7{Xs#FFBP2Dc4!xynK0 zO!bGP>I&7dm6zkRFT}$;v@a|OUk?pRQ` zkFZ(3D|R{e{hg788vrM?R%6Auhl*rN%xob7Zjo~@&Ur0#fBQz7KgvE8JT*0SP$GSK z^UR-)fL@9wD*I4YBywL7^9Q2lh;L!j+_ruOidg4dvzJAkNn-yh613DP}$ zQ>e!=^f&egoe%B6H1$`#7H;IzxHSk!tm|e~{Rg9$w;0`)b0O+>ahuX`4!tF?BRV0^1OA{1NLZiP@q9C_b-lr5#yCPXXzZ%a*S_M#1FR=vD;=?Zr`l_ zwL>eXRB#O~AQMw_yurYd0uwM*$)>9I=Ot&}vzOU1N7n(Qw3zWEZ$_G{a(MyP%^CJ$ zSP95vcx_o4v*@wPGMd|q;DhsmfQ3X1PiWzm)gVc~QoCVP@#=&cPml@8{kqEiv2v@~ z`k@WYs_S@J3@9K0t*v8Qw~kfiQT`YK5mJ+p)$Nusa0p z60CJbD0;hYcO%~hEQhZz6&xvmOCc0w8yFls?#m|DZ!xNXf@hQ7Qz=={^d_$JOX090 zQO2n$Vxg&jb$Ls_Y6{hwK`nvo02K}3QmWMT^8!`AXSRWXOy6}CzS#)GWsVW!oiT)v zbn+(jS(>RjX`y#Dy~}5ZbMZdiXS~&=^HX)lsgN24jfLjFy;qfv!ErlkffgMg1z;k6 zetxLfuqIV4@h;aYF-+o9>MjoAgJQ4FpIqHFFkBrY>7({*oo^eu<~Er1?tuhdFVsQb zRutIODf zOnz(2KxkgXUq3VFwZGLAhp55U9QT&#W1&622*DS0J0D(h-e)StPG!2?$qTJr#X4+A zG8w)ps_v;g8)b>i0jy;PtVK-*C2cF$(ZU7ord@-QqKi8ptD?~5Q)u({+&>YCXW(W{ zyU@7DD<1^=k&H;?3d&(-{0YuyANVJ&5rMU@cNNTZ0sMd#mn097OIbni8fquD5m*UI zM+GJze?huZVIh2}M1&JIvgu9;Umb)V`j;71)Hsv9l2Xv43AxW~fS`%s4vP}ru*~gP z;spTxIiML4Lp2eTBOMgCaP{xx%c|??zl*)bE3XtjT#P$P9N*3ruD@4c`s~pTIaLT7 z_B<@ks7=a5S5hAffZf{dP3J=SD2kITtq66>52|0jr`c~Jg%TRg?!FJ(Oep$ukCP)a zVngYhYl%yv^WRzU-j{$v&l%4MRD_qflsIEFB_Jg$_qKdBy z{jDi_z7&56zlkWvxLm~=)2cT%(;&^v$ml#e5`fm9D83gi{P%ql67kgjgQZp1#x#0a zzoJna=ZDcIH9Zr#7>l^1&oUtL$2J9^68lR%p-(k$FZI_^iZ)TUzIK#S?_5W`pqyx39kvdp{#{SCY%_3!j4ig$QQpHpI1#hj=jGcF+EdxVYZ z-i(Zl%-#s2=z}%A#K!>Ods3eSMmY$@tPkh7dBuyQ`+S?cXyn~Mr0deG-fUqABdTpS zs>p+$6wiW^ji%@HjVzYvJx4vNg2=&@15|yz_xfMBQkmWd?&4>g4E(rASok7+wKRND zriZY{zS#-Bp1<8E6Ona;yLfAuME?5#EnxDut6KN0@gp$w_4Okan6^Vl14v#P)J`iD z=`CqtQVqyIfqDVSx6u^8Nbe><{Ovzq19Ls}D<%@OO7gbEQj@yU8&ACtnolpxs(L9Q zxuwOb-m6C33~j(c6M3Y=oqBej9U=I)n1P8|^|n3(ldBT+OhD{GD+y1?P07KV19wSr z0JpEcPwD!+{Gy9WUVoEnio{vDARlf?owuYuAUt+ISZQjfdzzY5q_kaM} zG6S4x2T!i^A*`k981+~yj1V-~t$vkVjyc)cJ->h7SDs|)kgIEl<^_NZvmQsc=8AFD zVzDh1;A-_`J+TJJ>{A|4u>bx}Z4b4eU?+?5PjGzx+~Vm|q^e)lmQe1nT$x2D?{|(F z9z#)%N~2{)dHiVzq`-fNIZq)OVl^c2YTSQgsrn>IjO+{#4rsyu5D&HsROLNNwRY<8 zkgE27RHzgyptq+2a6QN$%qOmtqsyldrvAyLISJ=N}`0cIXiBTx_H zn~QzPY^TRnL4%`9A}Lo|)R1F)v3c&@gH2JbTYOPlUmp>4UJ}$nApJKOuqQ+fv}MQ7 zoZ2sT#R2}DUjCC>fBlua=^a0Z-ZwUei03J4j3iDYwhfWP>+?^IV*}*vrbwds;kW+wMOkjt+D6kl*Firmva*j&gSY68Sd**yDJq zb8PAJ(Rgnz-nn*Jj;DM`Jub4Erlx39?g)6Q6``m0hXLXQDFoOV37_BBQQM@1QF&8G zoEt9JU#(=Ro;CI60u08QTxDj~LyihaF=^2W~L%IY=(~MCp zX;%pn5MPI9b1ToqNmK9=7w;(M+>$e@&m_c#uRtfYjn&WD2mt*8eLn>Guz%sYEmGp4 zNyGAIg||Vl3yhUQ`J?w0cAOI#ooc7gu^m5LW0%z4^skus`WWjQnF96r`r+qQR~KJ1 z%W0A>gTugbk0T$Ynl%qn;JASpZ3|qMWWaiTbgk6u^*?&=SN0ZGl#ywvzFY+LW zav+1MYijr=(eW>898WGJX(a$ZLc-SHVcC}x`$k%4o8FTsN{KtBL{9n3z^e%3K&;Nv6iLp?C$0R8cXhT{-G@xdh=V!FR0d zpqt7VTt+oXbkc#b&>e1XZ{yCMAnIRuw{LoVvt!4+lX6KCm0J)RCAh)D>wJ0cfuboi z(3voq=NQy@lIDMllzcSvQi;|r$3~otec-;2v*Sq(&FdSD;$h~Z4GFRsMhe`H^+Ud= zsb&#lk!T|5d0T49Er7~id|te}7lr%b-4;|%hXhE3)C5fthze@TdnMz2#Kp_UX`$>{ z_`JZ59RD)>yKOBETy0uJ-HMQPx?>@0RR-8rb zwzY}53D7iqeq{F$|4P)9&z?D$+u04Zo-D?~&Mvx0F{;p}&DsgQhFQVT5KtQ$&n|7v z2i5b`$uBNV*fx0S4_A_LTwh1}Xg=f8T}w;bUv+&`#dBHNRY5q#`D(Lt_ugynE+Kwh z^Qb^pT09(u4QpRqG^?)}w*{5)NUTS)wAdgq16{bbw#LiPkA!3+g!>^+a<;311$fozDV)0?94h0>FmQEYxn`2cdlj zwuEw%lGqwgEoyjhaA~sgk;ca&K{ftcHZRdPGHe;Fvf=QZ0ggaR4(tGYa_5dG^pUwb z?72X#!Jc|sDgE_fa@33}Y2po}EL3D8AL2*pU*wCWtPz&<)`w{Yty2@vBW?oCyx6@Y zV)OAt7E_%i6o}{{lgMLd-z+Es=Dc5evc5dG(usaNN7?f0M#V@qgCHYk6_YOj78U*6YdX3$sOMr5Q9)gyN5fw9HBhX-2JLiaskU2+Y zLTqyv7ox!S_NqTxU!$N`4Uq{}{IJmof*GuN$-eURXgW4h>jjm-`N2xObkAUh@WWFD zjm^Zu1*gD6Y6pN@&!0bMM-mKlRg5#ilHNu$R}!u{?f$VQTNYF^sN~R3c)L6@8Cv!? zXB;10({dv8%=4|@8`l#*c_h%4;=+rI0dWolK8WazgwQfWqw#sQKXnu|Q&3faOJe;q zVJ8TRlTm27QHA%>1`%L;-0Z$MuCa!1j&l?70$={ z`h(Q=zc-qjo8R7$$)^!^oLxk6C93RKC)fylrF`q!IKZJ&qov&?Un7}#ex>+gE|5X- zgD$sUCTgir5erP=>guyNuER44RNn+3$)IAwZGD3VQ>%moa!6O$EpkHqh?ElCL@3gQM@@EZMWx#3i?AZ<2`li;RQ77(Hxsm!TNwgEWk)xt$aRX6) zGMnX>OztK>5zkXh#uOeZ60HS+&JLQy2a|h_pYySEB-UZOqDap3_XeDN1i?&Fu1di7 zie;_+5wGFmi_S>W3lVr36D!UU6Ln(L@^6i&lNWLlN}huy=V|{-teqnj2Af%cDy)B1 z4!}v287Qj6QAcH|qpcv3!nN8ul98rN#8x16i9y`O5=|R`4@$R>G zulp>A1`B(I!v?LM^1T5j%;eUmm?XtK9hpj_6${;zJdoRrO-wqP_u68BAf+*OEcp09 ztzN$xLR4$3fbQng=Oddkd67_q8G#b|Y9z7WrTPQ_3@AAhc6ISLd}z|hzt|EkqqPvz z5^Q<&CFmRAw|wUsK5I zKIo|-8QI?$ap#NPcrHXu@XJy z++BD8Q85mU<(wlZ zPfX4ueR;mcP`szOu5OT4kXR375qE0LR#OUJE)|O?y20Tcx?mBS9>B&>rM!Y(=l&5G z%P)2p(p=2{qkb;2Ccpmg^5XmV@8)Dzu%Sq*A~RJS9;YW2v!j;4=)nUYZ*?v*05;xN zmnR26I=D6k!L<*!fVLmgYj;+*)vTBNiT~$kZ|v&6zKIte6_(a!cu|(m4!L=@RmR?M zT%hgAeX$_PjkiF1K!uY9NmxA(3;i0|79(4<$tNlV^2e~Qq|P|;VAu@|5Ma+XF@ z=g6K_<=SQ9g+)IBB2?=nERf8H*s@FU8f8s;{mf1qleoRr*xl$3k6*fIMfGJ<*@4PM zn9B@=HjfjLO^uBxE)}I)-@SYHqAkui^^P7p8rV;?p6Hb)F}Z_hg5*S{+sVz11eO`Z zvv7-Q+0?{U^AS46PGbBB;4OUKwWK|yQdAw)#fVZ*WLChJE>j#EVgI^4D(XTg|G4EJ zL^Y(U?>~M}Wq3$_#LU9?wu>P4>*v5zLC0vFzvVM7mxuOv>dklFfee}z6 z<>RjCk`KJJkt|c{&u%waGhNB$(-*dDpFE^_o}cpy?=zQkM8AesurZdf+O za(iP(Xf5CJudAJ?*}A7Y4dbcfi0yW6dASC9ehvrI@cQAbugr6G0b-}L(MpQVoYfwI z_CLC0`49O9)(>4ok>_(cl75)bU6z$`gv#Z$`R?fwu=7Q49{bJ`RBnl#w1e&f9u7Ei zaD)W%e7M=oh`SbgDyTo{C+6`B^q#{HSgb}8yf0X8o?#eEi>5f zCV#RxTA&P69MCvc7KH_#4p3@5BLUO{5um&dOn7wuQ5`Sws4h(h|1UX7>zn0UnCREm z&LWk1Gj(amF3$9euWy(W-7BGg%fPx%?L6S7_PPR;dB!(~<(| zkC=}wG4#`u@ZDXgl2n54zEa~7b0+qX;$xzJh1@BnMCYGL_q75ESY7|4$vwc(A51DA z=a|DMmWT>tFf$#*Bmj5QIRIb$yFwuV!3}A_jRl@X>rT| z6^a>voZ<;2yE~uV?$L6!u6hqO7T{Zr~OHhZBO|2S38+ zmk}?8W$PhiH;47)KTTQ{;cfIp!?SvSSP5@F0A2;!w?viec{-8IUVH&6oQ`XBhXuhx zENI+iAoY}ML)C}Soc;k$j;cxSHYrN4ST?#RozWGh;B^Uy1-i zS#nL`H;vL3`P?BmA|T{Ix&w2OX^S_}l5^S}FV!Fk3f$$dukOOCqX>FPSk^r(W?|5$ zf=#Wux;hvHN5IN-Bfo$4k$?sQGTM=Cvw91T-J=+#0%$^6IYaOj=MlE_^8 z&#uN88iY~d{xg>O)YF!d8ooiXU%dg(&zs@Efp~$n-sGbC@*W^WSy`DBtxJvJPD4(_ z_fIL5xniQvjHq5>0`(8Uc>m47rwfkP(h99!t{Yv$zD9&udWk$bRa1?4_c8_%9v*eW zy3E!w?}VTIC;|!C{1s|&H|JY09-%{LWC>?U0sft z$gttTMmg}N$?^Yvb3WkYG50gkEG>{;{r^l`8$Wr{J2W(uC`!0~1L#KReHwg^Il-!f z;uV z5|a?vfglSt63)8qAELa&zp25$5@q`%ZK?!RPGL|&{CxD&Zkx2Wml zEG2viSUly4+ezotkC2mv0BD#JKY_6ai>OLh92fPGwh#*2QPN0YOPC!frw)fMH zCtzb4Lqo?BhdL8f9R1m*++Apw-fskc80D6GJayK>px9$^oxS9xzVJq;mNigV!K{%58Pch6Io~itR(01c)b8TkFR|fjkPWTA@ITW&k!9>@W{Qct~+%4JXW5`2Uer;u=5+2++%?w+vSB zkgut$o$}*jOrR;Uh%(h=+Ry-V5Z9#|<-IY)X(#=^VC8r^;E%agM@vokOLyLUxc#MJ z-2UaG@+{uhm~%9;#0SquWHqrEiwM+<^cKE!ShSFLJXGL7;-0(UzP6!=^3k;QM6BuE zOTVrN?6AFt{xIg}0kH+1CZQnALyrJ`*2_T37qxMmWig+YoU64yd_Un7vnn|->z

gMKFZpYM5Vm)Dy8+|#D&RbQPR z$~bJJ%>Ir1F*t5Ewuk)w%MOXm-F*@nPZrW{k%J_=Wpf25mMq@dUs`z>OW)yiY9n%H zlMNqfdX&Z}_H^}67iM+x(-A@bjl(metOBMRz9g5!pK0u*o6pwNi||suzx#SJXMg#5 zjXIxyUjGWL_IHF1r)Ag=1-l9?FR~04GwKYv1YEkQzgHvuMb7X=n_-)q>g3{}r*893 z5WNZ8IwUvB;Bp1z3Ky4uI&_}5hLb|8);3fR^c|JUck$95%jnV?Ziv~~FEof*?sj&yxj(-< zg_C@owg$yD3CsVUV_m+*?jJMjT}*9087;7K$N#CM3Wv-{g;Rx(_DyZ0G8=jtk>)=z ziPq%_nANI*TkA#n9&w3L9~Y{2XPSr2#{eGSwBG-Mg0z$REUV?dbivINQ86*CrJbZi z?bBU^a>$lXzkt;cEiEv?O(>C)0h>CcoEluovyYjq_?eQ9Hn;b}Ybbr#N*XZ_?8{59 z_;7wR`XTLXv`nFGBtc}>)1L+>!5ENVnA{Y@Q+(3llE&z|#wL3Ebiw)=eHkV8+HZOk zm$a9e7gMfh#GJmqDBe5FIGQ?=b`N7&NBLy}?pM5+R0Qu~&cl01yEFsxk|#DMF0P}y zf4l2NwVYHyj`qib!oqWdMozJ4_S}9ds0IEL>Ihj0`HT+D^GXkCg?MCs@AzWe_$#W_ zYt!FQCT`NK=0U3UbaBNP|1JYFm)J|K?;@gu8CCwO32*4MA;>41&$XClMlrP;yeTWCA&QzB4I-d|IDVU6wRQ@_wM=IwZ_BkE{R*; zRH;2`8MMzxG$F*eua-SR=Uhfs@G z0OtuMrm|kv@z1U!+H`fXWbt%wI39L%+{rx-64l{Kudv=JEfR@0m*MTN!NHF#o49AC zL)S}-NYZ>0+6RZhd_cMJAM*jTg_t@>&SK-qk)7`WB^FgYR171#)AdDOy?=kvk&1oL zLGH3&n}gh?Mob!?30<~sx};H!Gr9eJ!Ve2L6vrn#UJW2KAPn+8Cp0LN>G%Cr5C4YxB#5GOZ-3Iv&c;h_Z z-(1u(xmE-l9aW#W+_M%WIyb!|ol7m>D!ivTmCicO>kn3f{Y6O?a#kI8+bhUP5KQV~ z`VV^6y~}=Es{Snz@)YRdRrSAu^dB!2v7S-$JDx1l%ZnAVwPLv{P~VW@I$b^Bn6ZIn z_eCzFw5Vtwhq}KBqCG*H0~riGGdcpyL^eVQgyFmb;!@qRFu6Z;1i_*8Jl~rcX|@)b z9i)eqT4NP&(>VtWDAzYCf;jgyOV2j$T`ckC;6L(0I=yksWnNs7xyB=`VK~!UWOZ0b zmAPmNelJ$KUEj%<1_ZCG-%U@BuvucEbXZsQTBaGNn%w0wWV3U_qGv$2&Sqq-q%ps8 zb*+eQY&_#ku~X}>ncw_p+ndVS4!V7*R0SJbP%lHsdP|9{NO!{7#k82|zF3xEeVLt6 zWXkP@<9`X+Ezoizt(3%O<|-;8l)RKUm4d+eVPq)?T3ue4l$qew?^x54c@tSF`!fBn z9gBQ(|CEF{zunAVz7+e*LklILb*lW7r9->L7kO(VdSz)CEqe1phwgVRePvweS0VE= zN$J*(sh3X-9dnLgVvZ>k8y=q0TItR^qxMSdooM-j%+L*q(fiD~e^!^N-nyJAcUqHe z$lL7oy*{6EG#7&c2Q)vj?MiIlHjkLU-90*?cx{B(-!#; z!!-1{TDaTqzHz%BEDkco)5OSLo5LEXOYYWNc%I$yA*x?*lr1hbE$vbFl^tL8w42sY zi6M4Ao5DgOChTt|9e(i7(*LKMYw=6;(vNZCB2+#LhHBr%0tJwF$eeoOq0d9}W-sO& z3gn!0cd!Syu*+DIKfZ>zJTl&+=WvLgbBr4WV*`2!sBS@W0BD-vSR0itTToCSqa{js zddG2xdtl#!k+(;_;O$#6$6_(5y?Z5FDLO2$k)WCd*n<#nMrB&v;yQU+S8EF?grzEk za%SXSGnc0ri-J4&B%A0b=nu)Tx6o~G_2wePJO_?0G3G|b8hdAWHtn2zb~Ns^2@R5G zC^0JpQZghSq!v0XaL!knL6`P`xJy;Dw^*YNT@8Kq#Uxk;(ff>?>UE|0__46deFO7k z5?_rSJeWSThcJi0NixA_WBs+{f?vX@pUTrrP^{ z7{@`6WrG)ra{MGj;aazTi{{HJg0%IOBN$jrq!>1qQnBV1e&^M!tJz}w0{srrKF-t2 zh1r~5?HE#jJ9bSYN=)eN(}%ysjQ$)t5W6k?_ww@hproHlw_cuj!j%nu3P(5?&|6~_ zpu`$VoFz%50UJfPz{nzpj^Swz-wsG%N%^|tu1(DH?NWh$70&jT>EAv zMWtxz+R-tlAf`w?E+fbt1D6p^2nUsEuj8pJA;*HBzPS75&6}sUe`5v(bXwpX=cBcB zm0_B2!PWI7(q%&52!mWaDzTG*uF>&8zZukq^VL6g7uwyZJ?r*0(pPg|%TY$BuNthz zP$RD7sxT04@Bd=J^9V_68aD=1aBxmB}3r1)h= z8bvU*)`-;JZda0RMrHUE&2#rV`_;8VB~_$HKt-6YezCZ->*(vjZw!f7bw$i?d6JVf4wJOy3J71wFC6a`uCQY?r1D9rqUdg+Rk-o?DsgGWqxRSiS*KHZgb3r@|_H^ zTuQ66l77^=E32DZ*cNK`2P6gF{dY*jZ+NLktC3G;n&n4mP?cv?LxlaRhyHmkTLI?o zB~#KP`t%=nlkWEkP%NjWT-TXs@l!69)lnAHVt() z-qrT-RxFRX%INiKB->5uu8-6TJB9AIv196a>&aX*GD;hsR!v27Py1)r>{6dnPBc>w_50-pLe~VkL@5X{JQGKJx4xAp@ z_Rqx*XDaF0+aH(D<-3T=$Mpc9`9%AJ=u|(ufAU4FKMQvxzqUxUc+SEiD&?`3@QD`p!PbS!vn0iB>g3vG^aou!#->vY#37c4+<}BEw!0QP< z7p$m|908&Sf{4Br5bN_7)CZ>Cr8Ewi9HjIAS2{4t;5YcO-(>NpQqf$U?b$)zp{+U% z=?_hJ>3&6K`-T~55Ng4?oh$!94=FAyJAvU6#6oae&hzZekP0!|9`Whv5*_RA%f|)n zYy`l#L<!u8|ycJX3GW@;{P8DXw4SYTA~wmx&-G>E4{OFk=L7?pF6sHu2#3e#j4`{PYbpT&y5pP@3~Z3v z(L}dWSU>K+`aOFE2sWk^zxdAdt}3F#aGpiHVd3vt>(h+V68;D7OSd%ykxkLEw3cqc zJOshdHQgnj9a~pL9rf$T!1e1Yy!9(*534N=vitWn^D;9H;Upl4(2G==-=1HT>)<;w(_nqXthZ#mfGs@|j zA^WVA_$ML^|HHZew9~uPQqi&wK@mM1AnpLN2%aObw~Y1Kyye+8qxP}6S;C4OQmJp( zs>)`U9QY0P)@QnCFuQD`F`OfjjEbFt*ys;GIWJybT3lS973>wIL?6`r_S{cFrVp1V zX>=m@xSkRgTVv#_7&>5W)3*cGhhAxigmLBrO8lxG%&wY_csm4aZa)FxzF z9BOveIA>*mLgJXli=36F8|m~R6-}~A?h4FKQYv0`iN0b($BXrh)n+9tty_4ucQk69 zv0U;HcS-lJUs+z5Cx!cZGsP4wJlf%V`5X{`|rdyxu!(wz}gE#X21o@69 zg?{zk>Z7I&q$AEFt`A3df%Bdr+1vGq>q_cikLTY)X) zClg1TdwxZ1tV}DEzg=BV2|cmhoVw#=vHFKQ@{`ly_tT8{8;6s;Qz|xAn{!RxDR{=6 z-~YFANp&>sY{spARq{u*422XU)@84vPRAKfYc=_SVJEIC^+MOrJGol>CnkObXTL2` zn`s_v%UF#VKTvaMAv$g2^n6FjI2G$;bgP#K<7wLa6I#noK1@Tu!~1)+QjQ#zRJr4< z6p@qMWX5?cOwTQj-WtqwWK!o9+z}y>fxsT_NOGnzl8Jw^Uz?Y8L?${XjF{hppQ4*` zz+H=!Wlk~qN@}f=&7S&~U|VL0Lu_z<=a_CE$a}iiK~6?sRB+zfF#Y7o?g;w8%Dx3A z(xTu1BIZri#67mcCAwL=dg+SMs3WXJhDOn!x=hNPoLXFeXco4EUOa@ti9L7l^g5Lz z@aOLytVeo5a4PA#@LKXS#q=v?4a`5$x8lt6;9i*E zccs4={GMt;g@Qxf_&p}+tDm2E(y^(?GXF;^$0piCF^eHbi6%-q5o6rQJ4yeKrLzo+ za&5aX_*0VYiA(f5wmJR7#uj zexMS~-7h{!RK%f{l4D+~F}QjGzX+fBJ#x=cJ-#424Knmk8;66JsQNnbh0`oL{Gq8` zK^Pq~i>cXWg$KzFUW1d2H@)-KzzPR@srYKWB}Ws*SZ%>5dHpMb%Wz7FUQP{t!tflY z5~wP*exbkv0Xx_iD(e0;L28`wMhaCgVblp5-Ajsjb-FY|DzQW8+l^?C>Oj>O?Xn9f zH$IOq(^V7^8la85*j9PZkVjc^-YWEzfK?17g`6ia@BtWvDQpaeCxR6}fm<4^!ZJ5` zSugHvAb8roy2=}SY)D8wgl*o#N6c}!_}z9!s@hdsAcHPP4;hx+-@}7cX3r--#8bDr zSv$!ow<=DTEVnL!RD{N!n70Uyb0{~`5WOQXL=tD9x;YN@Sd?T+d0NEBIX9bzfDKGy zvBo*;yn}bXbG2hv)0#C{1vB9Ecxj{*?Nc?qqR z#b_@p$JvX?#A!i*<<{26-;F_O?N~j`^i`YApv_o`%R7vsAKJP5Q(ybi2O}IKiXOs} zkLX5$kr521-vAx$?!`M>bRQy?n;mvAqG55qk527$Fe~Dq>1=Gsl2-;mZYYV44+q(b?szKGw&l&-mTnwfl9cDp*0$Yi{uc1 zX+57{p+|qMZ?w{@Udm<3MrV$cKFd)k+$PnZ3~%RY^`W|RY;0`6PNwq9wOpR>R`+XB zMoT>UcI^#(A6llY`JJ+2!_rn}{3cWVTtEHL{knM}LE7P~@&UO8N_b_5)TRA6*Js)N zCQ6)D>(3Sb-WJqh!@`=lEN!OM4em)NIb|>QI7}bj#(O^K*vHbUuk^8MtLa(-J8tGp zfcv9yq53yP-gzbjjX2E7(cJ@ls$9g1?{2nFuIcHEwxK2rZD+PTP1X3YxVh1R(lTH9 z?N6rXlcx~qt$@ZJsfdH8EjF`OVNncm4AXlD{>|r}L^k}!mwz-B?QdBr&K}dV{3o+W zr(F{f1cAx*J2}G*xwzB-K}tOj8IQ)FuF8v8vs1#$T?jetOw65VIj9;OOhz>{Jn89A zAf))trn|qta_T3HHEF9v7iXcbt{+gK;Cule2dL`*TZ};>Ib5XBTHOFs%l@G~&<|+@ z!D<1UE{GEW@0Q7C_-9J*$Z7uKp`cOec{X|Rc)r?7unOzy!ton*we|k+>`f)g?1eGC z?%ZHt2NZ(03P?R*$N{_K5>avm$w;luP5I(&P{hG-=7Pbq*q$pL=zIr0X&VDBd95dkD%IvB#yz=WzSphh@;2#8Sh7d-lXqc(l>8h4h z2sceI@)-k2E@4l3vL15C_ifR8lm29le!qq9*gBcY&|}hrG#x*sL%ENUJ>~RWv)bhO zY2E5Ur_A!*+A7?YfR+Uzk7H9#jV}r-y&N<-LXqgx$~k@Ka{4&4K!*q7xgQ>{`L8dR zz>mHhKfRfJyQy=g9CUue9u%4s;`~DSN-!qa-k0&e&tCz%F4#3)1&ahU@0%pTI@{-6 zy*6u2gEW=f7yh|@;SKHD>c6mug>ez6@!=vBYS@T8w&rzD00AA*01Qz4GrRxA$^6UF)g0l=Kx`+^>714=^@4Ke>LC?XW^7GGuMInCj{f8y^pn93NKfGj%S z)okb`p*E=(AgMlgtQ7%h8gf(^yf!U(0yRy1F9EfWXFGP06Au>)qP zBfG5`CGN$d{Zv8GaB4!W`qqy|DX<=%8HfV^=csdCJ1Hd3ba?pCn5ZcMwGco#oEYW5 zh*nn))=58Y?7aQH3$#iCykH@nWO zIP-hIoXHP(d3dsf!u9(2!%JmzS9$6|dfgWV{(4xv@f?1L3*INn9)+9@clZ9fg}i}I z6XtA0R6U4Zz^w-4jd^$LG1OcL6xCo3;n@C*;(+Gl9z2QayLNElk0qcHUC+Gg7nSHT z?0}1@cD(+dCWz4#%xY4K7x?VmnjP1;BcNh;2CO8}Zl()Ecw*GxF)?uf=9DmM`l>J$ zXp0NCNL|?xM+(o4*-Mp6p9SxyVbTJ_BH^`SJl`{YKlyN^TkW{YAx|wyIDMR2R8*%s ze3MO^ec~hLRI-e`gMuFFtyuVxacT`S@v&^wFW<4aroMvuS9E4bAPK)&{LY@kJMK1& zP~h$U-D6PkAp>2ZnLR(5bz{mVVYWPGLy0CcsA;_t=997|>5~Sel>`Qr+E+w7KU}h~ zz%sl5^fq{2%SkLam9Ue!^N*-*Qd^Es1-^$~woN$Q-*xph0gq)y#JGE3z_U&J8Qa@-j?uD80ClW*JB*{5>??EqyH?q$GFP7o&llA~KP;8+rdB zSi&P;-fNhjioHa@tt4NVKYdE?jaihBkw>H1#k-gz%uuNzd2#!Bfi$)yO!8WdgQ=b1 zHPQe@)>sa^WlCJM?fB|Wyp<-_nft z(C?T3%eV8=>n`LxA=8&N)G}asTxaR_@<}Z?PrpPDnwZ4>Z zQo5LS)1l|cDVCe^F8{k*ohz*6eyD11OwH}VpiVbK_dYQ&l6orO>on+|Kpu5lqUE80 zqOkGr^9q4qa5r4_r_?kCyzXSOo$MU;H7JTBHCaW=%~PhA4nmDU2LRDDJGM#;f!ccRk4Kegjp2@AY5*}|Qz+~1G4$!Omue4r z>LQ5Q5};Zm%AX6T1L7}V(QyZK0FDOrWkG#FU_yOA+#NySLWs6UrD=*W%cM}6$q~rC zaqUIN+?_m>lp?1-@iS-3+o_umN>Odg7b|oorFg@x3$$CHwT8C3SNoxu5-qClsxZgi z(_EI{Nw7nObA}oHxCB%d=NLOlC6)iP%71iR1opTSJh%E} zJ!$w(3907&Ba9}0-3b`fYk&*^Nu-ke!h=Z{^NTTR;m`ljCd{@?ryGh4>nu~R1_GH^ z1wXsLe;e8nS@CO|9E;?+{Q$QH3w|qSJP?v!Q6WV}K{~rX%Xi|`-$Z<%Fb#TR2E%5e z6jcfw3rm+EqoTKqtZfq|w1{2ON$O&|CNw0m+B;e!DFgd(v3XGWV%2Ko7bgb@XJEM^ zs~PPGDw;RI(+wIjSD(X5BeBI1Y&sS9zK{Y;g@`r*wFOu!z&R!TYE0qz`Wg#@NP>9$ z_*)?l>So1z)E;t|_8%!fFDvpD1u*Jf%A6d%CMkm=a}Nr73p+SX;fYV_o3!qpzhV8I zt?c^np*VZ38YO3>?pNxkt!xP_9l~T@s0r<$v-m$}%#%MXtKL{aasMGD_!C{nMCacSX=x5qXrTh zcx&J;gU6oU-L}iL2{KmM0T`O@uP26-!^Q!sAL1L#M)bi0IQKX66U^R*u(D)Gz6Vw> zYPi2)66?3IENClk@8T;eMq%|}Hfx!o8np*os+&2g71qvw5*>e2KOPDyP)qH(0SM2- zONdAHvTR9G{gi$lE0Keav;Ov7=+0OTP69Gs?nmqo{3o-uM$1?vg>!v7GdZPe>rc;> zivu_Kr7qloe*s`R(qCHFAC2S0G}RQaV@<1QMmo}Y|KqG65ptT;i|%5EnIGz_qYvEC zw3P38xiV4|LlmD)`LYk_P+}h|a%01W4essAT+C%oOU0EP_-S~oN3L%kG~t=UYWJ2= zGrcWU+CKGx7$w4LD4`46n(6EC1Qw4VS>mNn=^YPW;Dj)biqXe`fv${+rV|oHY$WY5 zkCWuIo^I$S*OUykYOSe$*@=6AliNvV$y+Z~I>Y_GfyzkVMxdcr6fGx~CurY6@KhH5 zaz^Zj5N+DBU;tsCQje9AE`hq8;$D3xe{_LupSx=bDN zlKkhn6_yxnTAH0vtdFH1FB$!aC<7JyID^SEQ|GXiU-`R_wHf#ELF+Z!x1TF4LV~5x)ZT@IJ7VT=QJLrESV=Vp%Sfe_!Tbi?U5L)rW5nIJhS9 z(}A-T^5?LBU@6J*h*^ndFynC0ZCr&!F%|}f^F~RlI@C#=$uGHRXW3%3<67}WmGmBB z!3$&K&xyX!d840{2(@iM0~EhdX|a%j zOc*4+l|s>r7pCdZ9Rn%P1UkefxO5illPNz4cX29C{QSAVce2iB%$U$&d$d`q_Cml8 z;1$Hd%zmF+u&oQm*7WwHLGz0le``E`PTTWe?!0uM#*O6K?6E8;i?O0)R;1w(Zq7jR zLMSUvz{zX~DGB7bAHRJZz6Wp6KtrUxj>X2?kBfZ0L+HORSEISD&g7 zTcS;I3|&9DsGZ@?gu$C{uU}Z`+m?aT8-(LpDU~|K+fgmfZV0j)7NzB+eV-0Vbtr;{ zTy-cG*!BTiml;t{8}Pnb**mSqo3AFdr_C1{Fx=PsTBDS&`|$+8W5cW0ekT3pKo9uo zY4?yeBH6+gJH6we5mX6DPeHQM6eh2#EDKmlhSsm71`4^Zff5{lgUNnB<tAWLND9suX^5uUq>iq(%a$ddaMSgi-#Ap{BFI}DE&@8qKIThf2^a#8kRUHukRtP z%LPm>(BP_ylqv$H*vF)+kNN2>1m$jmp!x%Mo|;6293`w(TeXhOwN>#6z3xW~`L#M>7y>&EbI#DzQH0v=IyGBT)`sL&|0 z({cvpz>X7~gmc6<^~GtW;-}t-Vx{PE*fIYn;qF!8caMgxkkLhUM^53Cd@A8HS@-j1 zTS1J`W?xQo@5l|MEsC;@^%6CHgPzu!8Gz0nY${s8M8WvGd`IA>l#K6kF<2X< zKWky6qj-5u2#UIHSM-BvA;RE7{qVGt++Q*u4-bLGdIRQ&8eOa~hjO$@nxC)0XpJnRkco2kKS z6)X%F6jrzn55xkX`ATuf#xmTyFDEqwcMT}xS$R^cgf){_#$OEuz4@twanp(^AoC=M zlUQ&9JPLZ0T5D|ADD}Z1a&#NPKuJUXYv~;0S18`jUnNL2J>gTv$fkUj+E&> zGhlh1YcsM;XU^OWb*NkseR+}RRct4qB_X+Ta;CCXT$p9R5ofi?o+^i#* z{9cHO(aAqxSUpNe-m2EuCWpbP8fSt|OB+nEJ#*alvIbD>QLuG^Fq8|Td4q=RTf(Nt%zOh|1tMX;R_H!JFK z5Ny_ETnnM#5$K?XE*2J?j2r{9dXxJp%oO8#IYV;YXf?G_F#CXBcB{bg?L5Bs{7wDD z_epi;#q(1tiap&tnn)cRDN}e)w!I3i{d*}RG*W$XSqp7_X#v9n_2kQipcPidF@+8d z^O-Tbs#_|mj{!>`si^^gJSuZ`L8>CfcVecC#|vf#tR762?%t~t6EDDj5g)5rB_ucp zodTdm|I8+;{gX;vGqM_T5|GnzvKMlk7qZ5=i&Dd_FrKnw$vn_v6edV#8G-g=dDqdb z$nO!k)9KR3aQfv)SlzqV$M6YwPQ*b3$UGUB0XGA<9S|xfH^8#s+PUZD(j)Lwb^gu` zc$g%g>TH`UPh6NV^yPTqh=JbMl}F>M$89vdC}3Q2dnp-@(H_$pgTlA=2=0p2*K3zU7LUy? zth)AEonYcXtvFb)^Q_Bfz!jT)B`+ivV&W9YY0gp_darifq_Pu}`NpVX!7*BS z?v%CBN=sGp=~`Ts$>g6QPW512U1hoj>|0l66zYsjvb`iOGs{@x8ogRCZ(AbF~#NX z%sGAYy-gxRb*bPNgeL+y@3h-(gKbJy-o8V8t(WG;nMeh~!m&w{Ya1>9{+jlG+TBAx zsID=JYL^8RN33OJwkp&g^#w?7Ox}J z1kKS^d);!GZrITsRiG#Qz3xZ3-B+t2nklFgs*&NKvT3kmau*=ILmJ!K;99S|DOa6Q z*X8I=8$GGPhE{T$TnLxP1O-=Tu|2=Ks)k$MchADoZIjN$h2rgJ+ z*B%${i1%`Zwv-4V5p7BRc5@kAj8`7`=JaqAOcEWl1k+Hmx-89H2pqo3<9%Si*%yUp zVj*!9IV`7;YGKUJ5(k`fHNM+m`8y7)#49Q)`joV#`7dKjjLE6e#GFZ;N0gp&&l9ZF zycv@BgQi)sMVoDUrJiZ8^fC&oA;o@u!P1jK^Gqn|}!-V-(&)6$A4P8^%sk1+=6$bVi7qUR8{ z@M>jKt4qVCYTrOzAgx8zU2DG22e`&C@vMTHlZcvtk0>e&&5a}yeTnRil(?+!MueBkDWn=gVT&`pW#mLXSp zM?oI_cqoF~o6nvZgOe+U);&E`0HlG-*>bto{qT3VqXQ-C^*<13JdrjAyKn4GJC_=Z(wG31Q0-`B{wp_~MI6t5?p=Y>Q! zsrWrR@~wU0OHE`Uh|BFeHvl5D;drYe-g;zd3y_fB0Rb+0;-Y7$L4JMHuD%y>c_?Ua zDsYwBY9+D=6blc6q(D-!uF$zf2*eI_ZE2)BUG;wa*#0i(e4>^M>M%j;Z&zuW_n;7W z$JH--7VeGis8=bWYx7yVoqSU*^eJ|CxpF0N=Wn%h!lD4Czi&K&P`PaaFBg=;0CxaI zvTV_k*H=PrCgj2CCGsu;pofzdK@8r4s@~!Cef`zYauNcj#b#IyS|;ub+aOl^&|Lz) zp}BwI(D{k5%W?rco^1QF$gWzF6*WJ4>gmxl2{4SGA{#zy49nGf-8E-m)*f;w$|#Ub z6te3OcvVXTiLgZR{B$T+uP`CM>amr8obm!|okk(0%HV0jek#e09(D-jSR+u08d&PTPU0Tt=U1s zkxXWeRDY%&EXMigBsw+Eb$C?G&wczEOM7#rUOrFbDJV1nkmtm!FVT^{o(0jH?%3l^&x6%KmVY?2c6PK{>d{oeDu;E7K7?zsN7W>I=f62 zwR~R?+|MgrsRttotgPQoGIj2P(d+w^#XEfij`DdJd2W5#WFaw5TFKhRUi}XzF|o&s z%a@u{50msWwGf{32Gu9X(j+cbb$+g`O_LK5E94K`6M@(+f=b)7{{8bBkDhHDQ7UPeN2=r&7{s_l3fKn3TMxM{Z{ph+qbR-=KGwR@N z0N4`YP9I*fH|+Jffkc3)SchF?pY}hXmjnRT6IUUuDlhxiQzC203DXxk4JSL%@}_pO zhkK60Klbt}f{YV#SAe)f(ui+dt$#Z^+mT3wB?EJ!;pCuU z^oCW?r6O&3`-#DRK|7$mJz4(y_kzrktV^gshYH2nEpzr~ZA^o(M}buw5u|b|V%YyX z_%M6E71V}4iJ{dk8l+tfd&!|5LS$Tl@(Y?~5aPpp2W0NVG&)D`)H{f?`cI1Z@~-*azkG?oV>XM}f4=xZk}M&al5C`Z?Gm)hr{UWRQHS zVA(0an12ogdN7@bIcB=gCgULpOyHwACWIX0_P*8u3%5iQR2QtC;$XFQ`qyWw3N~urm^s?G4pkwz!Wy zeexqX@1H!&@HrcJE=EYF&O^@xwVoPeqP^19IuxYcuX;C1nzRha&DSR=p2jnE1E7RCRFeChv{z*zFA+jHn*;UYE&s5KDGXQ??7?NB&Mi|s&lv0 z3K!tdO~isNe%_3XO5B-Mq-7IM3PGfHrCvJX!# z4AY0PcBpqYcFd7L$)cmLJzuWUu(ai`>r0@>SGVqNFRhMt%J$*^Q0k*pCUbJUtjBE- zt;c_(C-f&?;11%TW%Oi!lh*vrC?8>|XTR z#o6SQWJ=Qk+hDW}APaE}BsLHbOEs}@1=-mm^CfLYYQKv4&?|uKC(0SA)JSUo_tg-o zO-U8Exbf?=POS4Tf5q<*zR4+e@RDIf&%|g;i2S}Yr+K^WW>qkSN+$(QorNud%`@um zI(Hg>c<@D`&v0fOq==(@aA)i_b|sRoL+D+Vr)^~>;|KmRvtLa!0_-W)?zdCxYigWD zY_(I5g=iphCBLXjIEgZ<7$a``Nr`DG2yj94>vSA0sbNl$4`k-6?W; z2NUi4a;vZ<<76*TT9|f#dW3wEG)k16_I6g5uuHsH7s`L+`OaoPho5yCOTq|zl{Bi> z7(#oaGp+A2y-f-c4kDwCmu;__o~as~zL*p|qa3MegUDJJf^4;~2l%)qH6Oa@uc3@# z#qd}rA}06O&YS&$Z#3+M5PDaJwB%L@&5F^J?rYd(gE$p&;keg0**r#qIsf8UOy8x(H`~%=Qt)OM%=FmsXP@V1=;-A?9Y9lr~=bF_MHxj+Py9Sn1x*wn&@PJ z!uD_KQ7|Mn=~l0JD?jOEGtN5{Ko?)j3>aX@Z2&$-*3sf%@}QHQeLSc`U-PQ#dGveS z{!cJ*({D0oOB=cB2ZNU-AE=!9mIyetPbn-3_C}!I0~HO5ca&&2YiMw5*1bp+umK_v zRx|$K=K%nP3ycK+UxAR?r45G$(GmwsV}H}UjKZh-DV6*J5lz_?kQ9M{Va~vhPj2xx zM-ZY-oL&P`nE1C`$XEN4;@#MjAxR8p3vUsWJTJ31U~r8=UH$ahTvsV5OoS8}?IGGo z7k&hQC=d-F7@=r?vHP3w1nwG;@uO@!jUe3m`?+5?q0@m$QC7t7oB-dp6aZ;$igP}) zKGZ;4FU`i0K){`N&J|k30!e?gkBQGZx?|aQr>T}t~%`}@a@sO>qtghzBs_T$ZuG1pO ziKfV}5g$ZK^{)Cr6{z=SWa+W3O@LN3Q{NFVS3u7}#5vz`i;}G0)g&gSY;azq>EX9E z7_vIqvbvo8w-gLT-ay->;Z2KnuqbAQq3Z=@iaP7yAiI^GTHhxX%XID7ry4eFJ7Cu&E(;s=R`L!Mk1K9!a)#6UB+mf@kZn$-fBne&cK zr-lv4_=y;Emxx~3Gas4$ralmq;*5VOs{4z!{N1}hppr_F^KxSQpuf`!BpT4&z)HZr z>K4Et0ov*^MT>WY*&;V6Mls%!%c@pAx-j=e%$jdM)esf!CnL$4?qZy<5L9PM0cW5R z^4R2yTD9Gz)=sMkdyH>_da5f$t!^Fx*5~ak{Cs${2}Q)A8kzBqsQhAKL}03D>KYQo z=F)^V*AzRqOQP*7rcO&`_sQ=AQy$*;ww1WLRj}bpC*^RBtz^M+(-AU`wRpS0x3%6= zu_SGgKFf6SbGqHv=NXIbr7y?Cf&IU7LF86&ZhsK;)x^t2nQt(RW<6x2D>WUJGphHS zT_;y!e_oc7pZhA>%miT`D;EAb6x^@+q}rcm-2LB!IOtHl@YF z*GNlTL&Ssk&{E?O-o^`;xoxL7?Y+&GAQ^)9BJ{9hzx|Epe8ulYE=aM@-(^9eKBPF0 zy%|%x_mz|&#cO(b2Pz^E6!D_{?Gm12ng4U(}oL_DnX>&$alUmlH94kPyV*bJAYqEZ?RI8PXQ1|X=%M*x}t71 z>~LkdXk#i~92MAtC@CebQNx5)@f&_$YEyj(o5A1J{mlKU)V?-mjx(&e)_kMJZR5T# zzBdaqTBkvVb+B}bjTuGpwShh_qFdTT(R?n^`9XL}!FJjvNtBoBpM8M{?^E{(p;w(N zpUDEhZrR8q_d1mUm@lDPOtC|AM&CpY(z;>2briX;gJ2E3jDATg0k!0-vqk{+kDy9E zRpFkc^}sG@Gu)P}EB=v_)Ng@!gDWr0-hA5xRP1cgwAsM?)qO(EYRF1{JLh<#uSJpR zGct0rFL3HzKx^No44N}X(VOGw1syxDFwjZUPzbBixx=IY^D+Mi|HEX-`CE0fGeutS z7Hjlp*Mo3WeAWe+BoXdACs{g_foZVK0vDp}cdTur*X%-sre7hSOoD8vDgnXj%e$F; z0EkD~_v}IXFW0W`qK-)2t+U(&?ep4&D@?3OhdLLt7H-!M5EPLM0oaGCCE?^X3pe$1 zW>|(%t)rQ!<}Z*N6aFVm=nk zDoUnKj(4CGthP|%cYF#>#1eoph>=Rhi3)mEEZG{MuZG*?XjbjG==VRMA7Mdaz}Ht! ze*jt9mr@IgqXPxDrsis(;)jXEavIiNBVN+7Hc2?59=+G2S0^S&(W&5NQv@03D);Cr z&frp&w8|WwA8|Ny_H;-PIWfRK)>#1Jw{&o)SwEuCsU;0X-WbMEIR$))_ zFTHm@N-mUZxanORa$=dX?5mel3hHdHMjQT4pL5TLVEzwoZvbasxbe3u2a;U)o4{pl z*AKkYvSg?t>0&$GX4eGid7rO2aso0^#e=TJ_+uj&R~~=R^7GTiL&=@asve_}Z@UW6 z|HVIl9=vom1}88az0e|9c;abk<;oI(vbw^Ff!9{E$$s zm0}pKu?{V~Z17;nb8|2;Q6pTWh2g zL?>NPI+x|5q1b~b%3O zIlL7Nw!&SW?%KD+bfewUBuK{3+#)LtsEGBMmgPNb>1~~4rWl-1Jl>)&)u?)g;7-3Z zciD)Y3az;(Aism+Ugh}gilS%4F>T*;)4zpcYAKcHPkKL(eWjh}G=kvRq#_aSw4bA| zp?^^cH}Y1;S;1c@Uke#UqiUY{`~ts}OwlKTJH6!3;*LqRIr(LH$u_+fxLT#u2)z%e z3b97dNa4M_UND_CQcfC>q3k8-HIm}VGvdM#vD50jyybuWgSOes53E0PvUli|mgUPJ zyW@hoHf6?mSxW4Q>`5e2V{|a2kt@`%na8Ek-`AI?g<8V68iRD8U-L8FC#+U?T4O!z z)T!$pt!Z$0hA#KwK8Bc7PzK5^3Eiz2p0A-OKegY6@A131O&TrGNgY6qo*$(Yrn<;F z+NA2Mm*9dEl0Tjz3KJ*Jn|CS>$$2_9k14_^1sP(U95Ze6PnA2nOJz|QR_NOX{WNnBV zpIVpZjQ_K}J%S7>5Mac$eG%#@7b5@tR5q?^{)PJXj}H&>oxjhi_$Q}liF&2TG!H5( zD_ek|#^99i?pLpSzHHGIce(UgvRVZ+6V0#C4WsgK=Ruqj9*HD-y<>OXEyBGUwB#j+ju~P?M<;eGvMQwfsF~=oOfz3oe?R%T6yh>{9uQq|%>K_jQp9)DAH$RDb zvVjR28>SsPzA#Y-AFU$}%Tc==V=h(?S&*(zxWTLOUH#Gn*z{&z&--h*g}tO*2eid`(Pg- zE@2&#r?q1qtJWGGkr2HbHm(NvQ^4iIHBtu$ILONTZ}2~#Ik-dkRL>DDEPF8@iAvOS zGi%%n3>H6PhyCi`$xhLMe}vETXhvn8ez05CtuY=T+{N^-R48^grYg$z^elHhl7;P< zHWsk&Fw2JBz#{CRVP<`dJSN{M5gyg^<(=3pNnm&54%lS^H36(5M_`Bq^ukR@4a=68 z0jS3D@#=}?P!Ro*MVXzQ(|mg>+WDd!H}c_>b+kvTd!V{GS(vl9i1tqy;-06DkesEC z0l+hHTGkSGadz$!pL)_SP1Zmm!EmE+!vSVoi%q-c_!Z^rXQmBGHP}tyyzlljyV8)Ml^_FlE%3QQ$?tETYD1@_3qt9wC>RlbVxmzv5pxcGjP zxJGMf{kW^IRL;amk9?PS6Los5C82jbu$ux;`BDXHh@{2@cBzpE!Sy0RZb5+*I5hg? z{@{#@Z=I#4o75DF2{(P7XP%Mkq)yb%ub%|hpS`Dh<1S7waPEOL8Nc1t)Lm5F=$l~Q zG;6GDlq=&$L7z^_qe;XU6`ZIG!K zu2q+W{}ZVYBp5{O2Ws~Vu-7Llmtnf>zK=zH@6@5Z^iEM%Jq)^1L6lW<)UTo(My#ju z3#_<`P`2H>z+sy1Wb0Ec7BRtSePCF(#^7~ zaURAPwN>kj%41&a&fA$&iM8j2?WP@)PMfp|XLnE&C>;%CUaX$acgmkLa0NoFiQ}e7 z^?zun2@4T9XQF@Jn}VBd8@Wodubb_n`nW0gmr?RXsz^-$%tp}+UX$fb%z1d*myUJM zmY1aBO7{E~*a097A>KaLQ;_Wd=H0}YA!KkTo&XtJV8W1f^l72pl;W)MFZ43>v9_4^ zRI2k`Z}#6O%I3mYecjZRRmsBXsH@LU1iVwX0eJlv<)-^DrDJfV(AUN)oBLx8vfw0y zZxX$Hb4DF@JxWAZ7u!4lik-ehWH1u&;7FpQhAO?1|=_j+t z#fmU5hrS82|A?*s-g%IhFGpXEwky_`;>YSWDJNSYx`iEkIeO&SHdcRvRT@yzP<}!< z8sKB^cqQ1E5MetpYTA9dhrpn}a078ZWB)JA*`c_Poot?2jPW35^EK=#oall~=cEH{ zLcP_+Pb-&I@{;khy8yxcmUTwmE!yl6_YZ2+-+wn4kFH3Q-Qk&K0fi}WH{ddGnP!nN zRv-H$#|FTFCsv%a7i6N>P`~g74vhn8+B5pQRI%+U?B1UJie$?V=Od00FfJlGyTO%Y zTRO0AS^c#RX50|X1BzAHJV~u)`D~Z!k&fRW=u?^V;Z`q?QN8-y4+}k*csTZ}s~=12 z$0GUNsJiRR`}Jm_RPXng=80Z$ZYDd4cH9i06}$s_`FeU)Wzi#IM|F)K-Z*4ja|{_v zOJ&<4eytd;)Zv7TSKL~-+A{;bc62pDV&LBbe-=O$K3<9k8lGlhQbFx%< zj@#fA?2lX`MN2Brqpe0Fce1P~)vR34&bNo~+T`U~6(0HN4^{|`ZrAwnpT!QJzhhms zceM!>`1?8gQqY=}1XP+BCz5PY<2f2K_7T6GnNe@-D`a34yOq~1Ka6Nwauk-lG zy_aDKb2=9(?#Z2$JPgKsgEuQ>h0E^!j+Bgc`Q-H4t>AvIb##PSHkB)fepjBXKB0_c zCGnU2J=Aj7ae*ggM=n~UHIbC`ai>F-?h`@H2-?#hqLCDDb4;!FBpZCxHmmlgQcJO> z1$*5*pP2|0efG=blAkPtYc01{mu4LE>etu)p??>c-BLO*FYqY1y-xjIZSCdkL0sTo zXtZOtV^IK4N2ZkuwnJ?+P&xCGdU|@Y|LyJ>32@^~{{U1FsJ73YiCKW7tI&r3vEWN+ zw>~yX<;4^)ZkY@-%TpV+op-dB;%xXiF(IDX)ti>Y*fg9jo74AQ>F;D131SAD_Hzx5 z3kKai0Jtt7(6!I-NLgQSHR!chDdZT(ZnE)!G$BQfz$?ZvgsjIXcRyD;9jSSpi8IE? zl$w~weyaU!cq0H<*474?nb*p22I)QavASiCl2#(QQ_f7vYp%wmHE#Mg1>IIv0*!5>_{Q7LZe_}+(4~GH$)+ir@Coj$=*EU zt~hMM5v5v2o_lUvkTA#dSqGz+5qcE>Ax)nEWC;#0nBGoXdZ$eBiP_R038oHReFVgL zo#=9=1n`4YZWm(H;I)r$q`r+Q!toNs)&6`9;^1sY6wM7gA1~aUs>q#n7I60nF?lwJ zPM6ld=TF7uow~`z!qF+UPZ4a?p!QIdZiDpxA96}=U{hJ6F9ufkJL)rmScFRx{KAi- z--|974D;IpLYz1YfOv<;V3}@dY028kkedzF-zjAi)Jo|s)7`GC+qk!WI7wb|(@vr- zUv@9;-&!yb`)3z1C{}RjK+p6FlyGnf^?XX{F$T9Lpc-P?B%zern(&!gglwkvH&1hg zjM>P1-%LC@epqL`ou`s>{4^Z~qrm=MK+6>2%muj zBA{yzfNd3Qb;J<}C|1BuJzVLDs&~`XG^DK~nL=nK9v)n2hjr^)H!w$lp0;37iMe24 zb9oO`+jrE`{Qn1qfzZ>wB>vU<`g=pYyeW2j)9$|hV$^kCXAVQxc0I2Qg!@sDuzl5Jq3WKhamD}J0uW;w7vM_yNnORz2?TiKP6@+~^+<_xkUBPwJPg8dN&HS|6 zqelQw>67E%I8uaZWij8$E)n*!FM0C2VF8dy>8b@CDC40dN+dZCQs9=i<$ zfhNkAHui8GRUVNvo1CPw_CC>@{u3fXBR06}^7Qz7CxSZ$b0@6jP&WVl9+&Fs__sz$ z-s>|2US51GN-(JiQy&_HzKgdJI##3aaIet8D4Y#W;81-yBP4Lri=C0|laX1ELZjMq z)zb;_!l6QFxl=y(d0*zSS?2}Z=MlR>fwf;zrFgjK)LDA1)^T;J1^=Cm$&6%kk#{4FkV-caB*oZ}JQw7{@Siq!hU_+NGjnX^ATC-wCGQdv)WB zUP|=!(0|x?2+kt(u`;HLth|3(#Wo}Y{p^=^qO7j0%nmCAzd&!E-hllNoyHn&*?zpV z`EYGjj(*2KA;Hvs_v#etu?}AILErc_%;3XjRUZNtI!1 z3=)!{pxGkYH_j0$<7Cv4n!5f)l0IcuKP(hOveS>hw|P)>)S2GV$|yjny6uv9DKKR6 z&Sv*Hd|TZiCT+pHK{yw75vVDCJN2y{83SpCA|Q0Vqe}OS&5Te;Zm)mN#?nBmcB7-r zpG*&8i68k99Yu_UXX#XQt>GgvMAg~Y7@*gxoG53tuR;`L9P_VRb*|wMSOqohg<40l+_dAr*ev}&7`auw3FF9O>PHuBe7>N|ITG#uSA7%p<0`j0>dNz@J< z35Fle>cXL$W&kTsF)2{iH!(QUv+sZ!UkpAw^y_;*NK}ErC+rm9OI@8-^|?-FQzKN5$~OuQ zT;X~^;Q&$-1ZOV%I@MdSa)NNtlmBjW?pTpzBEHQ@&!Ut`4>zYbD1$Yy={9924sQ~Sai#vjn zGon+#^F9|`UKdJY`fRQCtLa_vT`W-7p)NFB+o}k#hQAQ)}r`gCjW7~T3XUm$? z0n{>I8+sj1S&*(Qrkbiszxq+}ubUK%b>G^xGnE2T(<`y6sw#`Mbm(h7TdWRb3;ZwD z7jlJvoW-NfzaRFdI)<*8&9j$+K?mg87b9;y(>MVg2&ACh|9ubW7{F8kNfVK-uOu=@ z@BD}n(gO$rW|uHoQhepIYDKI5$}dI|gExhUsR1BJ0Tt~h`6|Ur+L90rH@yyHn{T4D z+yoeeT&5)AJAt|}(&)oK=LT2M@4lc*6y0Ad$QkTD{rCpfrvKQ};I}(n5tew2%IeDF zP@7ufv+Y;fgul!mKYUk|ArtGeV&mo37tbyjtataEDia5j$V zp3s~6A&3yYDT2`xL3J?&cf!bqXwe6gmhGD>*zU=Wvh5Cv7Te}MqP%{6y>d}xo+>Rl z&iPM&oDXtxh#IVE>|4@8Mb=@}AotR0VnJX#Dug#cMUkFWPI5K*u_mWZ1+)~f| ze9>8GyAd;=<(O=Thy~lhwO052%@hT7LKz)SVke}5*5W5-dTCE?^w4pBD`NE2f((MN zBM|*qHF9qF3~w-A*>bY(F25{lD)3o%>7C+(cj*-8g4Ooxe&ZwXI`V;+zv)ooR#q4B zJQM0k(-_kL!MxhU3{y#!$*wSd{hGptepJ=OlIwP;skn`6P!T(JqBKLKuRI2`cl5oI zvKE<}mq=f7Gq@AhJ4f4}8lDTg*pWTm1q*G&NOY~4I>RY@Z!09p7Kh?qc)TA!)UM z&h3GkvmDus)8Nebk^1mtj`koDDXO84qK<)cUg z(E+5~xa*U7xr@;^)$16Vp{j(x-smhuamZx##%ZCT#``xJcB1_Uz&W^){W-W&(}!Gfz7Ps&Ms$ zo|hpirJN2j99o_~{%#xPk>s8EmA&9%@f7RQ)RnEsw6wG&8}IFl^CLHY7HN3SUq(2! zD=Vmm$h}Fmg*$UVG%xV}`&Ce0JnypG1aYf5aSQ}gU*fth(78TRWQ`UtO8y(BQ#giD z5KvuuvR2}v$lQ3pF-~eM%nGE~(xM`_ZZYJ%Xh(u}0yKg|)db9!iFGeA;ssLFftTNB z#3oAnMRdky00P(_Ymf&uQke_YF64hD-FmE-93LPqT=t6|}K}0eT5HrC{$CB+`9abj7Ay9Q6sV9}@@~Z`0 zPC8$*;iY*ex9~ueshfUNPxdd3k`+NgOo9%4Zjh^Yl55}h=PzsF1(l;2N}9pThjGWh zsi^phWEfhyc&2<)mqWGvk7>;WTc+FYu}+=x!up0o!fdwlv70L_zJEgB#1HU$d9{Pl zhvki4!i{tcG(MP|-O2>kxqm_UQBT2&k4q2bZNU*N>90PcdB04nhjUi?{(#nqdkb9a z9~Ny*+IK-2)-K6AWL)LTK>b-dlC3tO)&G~iI6D+;|5^gCSJHJUXHBQ>B-1+Tr|tJ* zs3J#}ost%|6UvF~ec~}Ja?Rh`Rd9fGuU z^pTqN$o0QWhCQ(|qGW4nH@kZhXy`KB&b@vz^-OGq=8Q6+e7?^j=q-O3(O+ z;tkOHnJgxV5LX-NNL&Z(%vRpfHY)6T-+k-Go_7&&y9tY&nBdD zIWAG6doy=E)gEe}Mcr|}?KpOw16QsGo}Ux>GUP*8^xAxh@}{k%UO%`a{Z>@CJ8~1< zK9vb2-a6|lb@fWkcL`Z_Yx`?;Wgu2xZy%bC(4RaMI$YD!nkQ}C3p=pImM;3&ut8( zX(#laK)Za;#Nm8l#wfivB7{&nuiXose?)Z2XT7k73yligAk4FQyFAL~90YnYfk3e_ z5C|006Y{L{7xi7*LJR?CXMF=KrOPtk_MV4t5z3S3b?rCr9j}{Am{o~gpx8h}i4B4k zH%hQkaavft{@citV=C1xR<+RggO18$2q_ zsW2K9%Mi(O_-{o}RLX~i`i4Euvgbpr{A)yo3^TOf!z%l#$&TmHD+2Yw`;JVv7Ao4u z&(?7~?a70KB6)O#Oo%D1+)fT|z0}+|GyU&p`=GqwOYn3L2<;_n|(SQ3ncO_=G zP@Mk#cwWiNuFrZO9Nv}Y@+Z`sVu4N%T#@>q{fVs1de+syV>8Ve8QbX2h=% zfF}uaV@*z8yd-5IV{CjPo$~EurGnc8aSM(QvR;Bz@8Xx+ld-h^Fn51$Q%5mu>t`;M zdu(Ah9a9M%Pc_e+X-^Cj*rcS-w=NBND7_QmMU$$!H!Yz=g`Wj78u;|NGuY+LL07vw zF-lK=d!m`-RAArHP`ekbjOz8&rOn0hc@E0SJB$`-T=UwuI(7xxmDaGnYn7>eGM{>H zqz3H5${Y%vG}U7$13sOf8au)-GshIbd86Jv>tM&#xvf6_Si}IIa=cxq)*B?%g(hlw zTcyvc3;qZ}xHZ11oK#%0{=tob#W67Q9eWCl?cj;sgf&VoZIUkSXrH`>=H|^uL=<& z{raFL+KvcBzR-idyiC$F47)xkl$}$_6?{6s(q@>fE;AWrIdsFKZWZx`jU#zYvZI1- z+l!n+#a{j-k4vx~U-?p~JR~T3qbf6bN=`{I;6wkfJnlUc~3a&!N7!S62eu7gUv%-~331G+@7 znToN}S@e_C&vNTMdkWD665yKEy^Bbn86<3kxq4DLpJFGLYo8Vtc_*y~Ku`QoqXuDn zqfvBc|Bm_}@FBl(R)T{dJU!rIps^4#;J6tY5O8|$Q=k;c9xBijx)2mA(?9$D^O_@# z=WYMA`12jqW9LEnhx@0TYIy62$Qt-(Vy~x}fZw5tH)xI!dE49&6~ZLJDtf9xtrd{ec0Fz%F;Z?De1lMK#Oa0ps}+(KFxY&o z=$E!bfD^B2J1Q;05SS$fGtgVb#bV>t%Ju{A-zw!C0&f&z4dl$DIUff>7xVgzv*1~w z1JzvlqX3-fp5>jeX=HAv& zF46BF!#Ox4C8P4XskW@R?bI#J>sG8Ddw-`YPDU*SiUzV#1hX>t2ps;f?}vKRQ}ZqP z69Zig?^AX!VTYe=RS^4 zU!#1q$J!1ylot2Cy3Kh=D4uN|;%k~pf(HRAEQL4Q(M|gbEbHS+Rp=8onAH#oA%r;_ zGnrKx;)L*h88LzvV38JcuJs^aLj^t~tOKEtJUU$ClD2i{%P8gTjWZmx`Ygr@6|v!Q z(|KVM9<5J6pJp1t^8*9up53F+EOTd~5#NRw;bmfP$K3ysCHdgue~++HodhDLWI57pI(%jtkH17kft@ zY@H{Gvexkx|9(4A7-lVHo{M031!+*Tqw6UCPC_!o&ExVR-O@pNFstPl@8hF>UrumJ zeo`oxyiD1VXSg$k*_e))n~X0Oe`$ z8HtQu9&wxCvY&#Lh#;rFaI+Rzk5-B%)`D>s%DO3V-(QmbdLF7sEv{a+_rfjvF zFSkP*W=4ZX30O|3U%D}ATLo{!Bzp>qp&!DSod_?JL99g5C zXfPP~{HKJ@#>4xM&ihdT!I7F`p{ml$yM1JyhA%&V2P6H&4*UA9_Hr?{T=xbUd6L1S zRmuMM5)sl%fobEV%?XR9rR^PQ9i<0l-w0arGtvFuunMb*+r~Q*Bb+f*{xf2mBa!;t z>7<-_^R}l-`L*+%)3Q~McpYUN&56{^7PvlU>e7i?x+VG>=6|2@8AwbvTk;=N*-&^$ z$=fI9y1+a8ew7qlr`b2TMi!ZiP?_oSuUlT-7pXsU&hAC)gZn(U3k-K%YaFbpiN_pn z$$Nx?zyoabmhB!g=|iO^N7m-#DNx*K)OZtZtmtT{bcH@r z412*L9@4OlE^``TS$jbP8;VH1_n^p~7FRbO4%SVx_7he|d3I5)8}8DCzr?)pF6u0p zNnLMsqVYHy-Z$8Fz$%g`xsb`ycB%xY(i!JKUti}*s(U%NBb9P~a=oWp*lDi1+bNu) zi{U=I#HY!S#eK$$hFgn_yd{KHo>Y4Bn!bJmKJ5+>&jQz>2Yqs+*YGxK+nCZ?WhKA^ zIF`;4NvF^rAI;Ns(f7Ne6RR&8Fgyf}P&ZlI+Ktx#h+upTLY!aalX%^qdM*N1Ub9PzeDqD$hyLMXIHz2xa z8U|*&dSVAD%o}yQ3@2%M?ZPj5QRU>H;ax6xTlH^XGXitBGPmJe`1bj{I-gIN!fdh7 znh|U^3F~TOAQ(c)=YOWSmUq51t3LM|r(`L#IP{-GNWb4Z+maFA7nS9d z`*{#R&ejRcp`w-J5~mt^IGuPuOfa8HAP#H5z! zg!4(@Y2U#WiEWac@otCJS0`EBv&a?BuMh_D%f>O}pnSbBuD7p|h8HA~jS={)$lKu@ ztS)$>ICp=2P?RR`p=9AT!fy~XMoF*%#vfHFsj$4*Q%AF%^)#Wxv|kPf79VWwV;FSef z&Er4A7)%m*ewITb1r7{azu$0CPs+L}vmi=+OU+copflf4`yuxSA;!y|romASf&C3e zWy~JdgAf>ZFW_^c;TaQH*lNJ=?&!-OM?_Q2_hc%}MN1@yQPmy;Jk^24^Ci9z?cL+lP>r0;qyP9ahe;>CETc)WN z&H1pxJnn?s`V!ypmI*rlGsC@ne&_l6hW=R^t61gTW;_;KY~gr+HUvq0;I>}(c7Z$B z)2{nB9n>F14LY}vJtJnLpfutxL9~7AfwHd5|1#sQFqv^3-E(CVCH3cbr;0sAPJ*E1 zoJZEX!@!eo_-aHfp!~dp9!-X=B-^;Usz)V@AKZv$2KDXKXJdTM|7^zyV{4Kq<)`VN zVXjR1^1?+6vUl7sFH2mna(xhVE@z7}tE-MU)h#j6RF}53Apb29iBHAPOL+{tXbKx8 z-);t%Xifb@CcnVb_W`6d)~A%KBO~W{Qa3SBb~E@_!D|5spVvzHtaeHClj#OB@ z_njVEL<_RGO<069-!!|BdSzye%fWRxs%r3c)-kg^gYjp=l8hI}UihEN7o`6gb75xt zv3QmZ^^hv6=VHz&Wvv1#$M5IIL}g1=#?bfQ_=J>cSYM4tIR9z4>!}VCEtthmDX*mz z8O`oItNFa|_^Nu9A&0g^n198dsW<0%1~Jn6{Zleo@5P;f0S$+%dRO+_`Cpt1b6?x4 z<7{Mn2Pgh!&2N*TQ1L$5T=SlH#syP0Q_^RmGmi$e3q(F`dzfH(GgK!1JR=`s6S z9o#q+Oa{Sj+4*|O^az|O3EA`$*5I*lnTixQ)}FqTu}SFbHgV=D>zY#Y=U3Ug6zK1} zk%Xv#C%c1-nYlmW9D%Me&F!EK>6o#>X?+G&Z-#+b#rU8-@b-w7B77B%I)%lsrY0(Ze*#>Ea8c>$^?n*pVKzz+Klv`gAEqHyVKNlQSZ(psW@PY)OBt-l?4?a)iyYVqoznC%+<-QeE8o z6i`d++93f8OZ|{E6P{v*@M&)+>zza4wxW;6f=*7c@<@bS=bEn6e6xRIv|TX%gWKJG z|I!romTQ-yn(N+fi7RdQAasT}3V-{lscCAy*y~(Tp=WZM#+3Qf7T@Hg;*V~c$xU2s zD*2b+$J-XawD$cjDz*Yh^djSTc_uZoKZGmL?VY(BAy(5E&p$Hm+f5TXl&jI0yjU%f z_H;iBobCx9!@{?KP*)ZwnNwZ+8d8)*FPZMzBrp&d#a1BSX&X~R8a%`0qE<(*%7Nc8L}cUp7&J}yylH!`PWW1IYxP+@YL2swtXa|gB0(wi zguGP^^<}-lN4cOqnZ|Xo79kNM9h1F6FRxh82lRaVCR-S`w{e*6&2%b#kN9Zh+-{_vK{*WX=oOSWLe0geN+ zT%sH)R2d=$dC#-mAB$Qw@BEnDyHw5@9m`C4iBfcXUGC59^DYsq|J=63Gd)sC`HP7; zp3%PMn3a`=)Yo&=61jCM8OFMEAf*_{M~qF*c4_LGm9}3ys_lPKO<=r={PUCH&5V%n z^3?eHO|BDRS2ZXbN2b>_bvVDtR7Rb_j$fwvl4#>Ld^tES2yPztE|;cf8%BSdU9XT; z>XCI&cf3u&d{a|ix0KZ+=qagYKdE`!n{ki(sU7VPEB-ytWFXWNZDz5om$54N?p1p^ z1lb6>v9SwmtLf2SXww@#7W)?2^C8H#Z!z9K;T_`bmlc}3+a;Pher9Ra#CX>!foAW} zDaNF&rkvzIuSGOz!w(^$*70`uo;{PCt75 zt${(xJbuwuBX|Ekbt8eHIdgq|e>+v@EaBs%+i|yUyzJDB(W=zfXD#-nsyy(LOG#-L&*n-h zq7$VHD6;+VNHXW!2LC|eF@2S&&%x=)ChVbdOeaZ zM^Y@=J-zAg#kbc@Zk6VN0h+D*qo?PZ_`c`A_3rGco{ILSs=S@=sx(g~ zth;sdtZU#XY@}OhtBMp)*YTSG1yq$=Q{bN-A%s!zYcvaxkBE7!!pIsK5E!_kp;z%g zI@rNC%5~E6CI&k;k<)A}3S{y(Mi)zWnxc?=fV>TN_xkc%@$vE5M~evsc0Y7mbq}$_ z%w@S1U$L>WUcRz5ywt#N|2l(AkHUmSY}4Iv1Mb+nVJkQ9IP2JZ8#$25WK*W|*e!W& z`VJjfG~|TJm(OaBFw0!OwnITeou6?yq2;=fct(rcHpI(XcaG1aB|R+733e2b1_rqJ zU>n<$t&)xn74JSs2_=^@hsVCN=Ih|!Nj(zD;M5lWj^fScm|8+d0UWXjTG@)=m5!m5 zw5I@@q1;&;+NlMK4Ut1lSXaX=AMhWho7D_H8-GJrdQW4b$luf$(AIHv;Z{QrOgfb=GNaaq_I8NOs+_ZQ{cYX zm0XFdtGoOs%ujt!?gxDJe62a}+JuFAQP5Z(pPuhsSO(7rv=;~8`9}hh@OvL{0@KtAgnTh{7vb<5`lQY3twI z#H3dF^)!)xLS`sBYk5lW`HTnIw6qxK4+>E{0|Kx>@6nD~7V6$@EM`AKtaS8#xWI+6 zwB488`jS}*)8$*PQC<|pF3msj7*emq{DB4=1^2BlO!lhK}WHXzN zd&DMR5C4G6m4_xnn6Ih!1GgJ%=CtojS7lU_p5pp!Jj;0#!ajBXzAMe8O_325DbIM;^O3`)Nqa<8BkW*XHQd&c*Xd%VRpI_i^3qf$weN*QOmd89r&XE-ay^+dJ4n6*7a3h zQup7pAA)#kV(1N>LxM@l)(iN>Fc)YiscW>-&(+gMKK`}osk+U8#Z@7-YkJQ^xLKX! zoOu}69n}+JrpbJ)D-%`g>{;sf2Wm;&tb_mksr?!$wpFO^|NTK#*tEm{_y3dKZYX(U zt!iU2tpp*H(EKyU=*_PLqcg&4L)8k|{pDK6lXiB$fgs|ce{_*Y#09`W;#pz{jyn*f z54re7+a!xIiO~=#h``4=EsEtEFSt- zaY=rbALOh>jHfU|M9>V13=FrWvQ6-=e#7pG2w;Rd{LW!ZwHw6e!%xAffFGd=p&Cq3 zp#VN$AG-GZ?$_VVzR>rd0!12!5XSs~ey~Mhr19VJ4$?89o?ea#{YQ_s7JNCpfNU6p zJa8Cc7cwE!n+bpCBk=de??YY}`gX0=TCLG0nJW0?Adk@sCXNV6x>SMV5w1C~8xkMG zU#`}id0bJk+Zg-lvsvh}6~1?%D>k6|Jc7JwzRgf*%zk4$^a1?SQQ{H(G{QVUO}n@O zu^KVU=Zq(k-+?J1b{IYTX{8+eEk5^G;1R$$3Amjoz_EnDASMh)PbperT71DZq23v8 z9w`2yWWv&+jkK~4QRMB~NBHnz0T3{3C14K#Y7o=t<_9lig9k$>39n_<_j~=9obaC; zp#*0<@BoP|amam?$Z5GAbilHz7ZI@LrR^4YI*@s|tE#Cj*PNMJ8p%JHMx;){uH>G% z#OUa#QPsxUBmtPOU=lYDD-7bXCmJC99OD3xP$2gpt`m~_QDHW7L73 z!6yx)QOHi0{}Q|`R=dcJDWUa9aWIR3ui%OtotiSQTIrsIUWRysYXe+Wt=N8e?}Qc~ z^#IywNVZTdVAcmEf&?NhVeQEC_dY^?J2CqN`v`Yb$m*cbIPMGLOI1~cc|7KoAab?C zOG!hBi4HI`%x1s*=V6F|T#h(>{1ZYXjzojM;3Vk-42BAG9U*Iqu!*8Gvcy)nb2v?$ zAY%P@lS^cqz~PGcfcWQ@xGWR6rsfob&x%7mFsNkY zvUUF=ezIdXw`31my;Qc8bBQ*YK#su8mwgEi~Z}Y~aFz9cH@Xyrztd43f$IesA8| zi#`@l=4QJG-ab%GJU^m>v(5K6G=&)%zNobc$no(1#x)!|e=OA1mmJvB(?f`$TZM;c zlMyR;7q8yQgK3y?V}b5Sk1JFrt<1LlVdcS{Ux^e$P7$_w*hAugF}C8#ymgzwf+_NL z+^I9_f>_(P+fJQA96cTnzNLC#U(#vQfhpnY`o$I)`^V2?9rh5!?%z0viurc5mIIiCyIQLYD z#q8@06u9_+xSlW&!H+~uD?;=0U>b@yJSrUC`wP?ltfhvdYJ`Csa=NhE#vAO8yC~)y zGPVki&}5;D#B~Qw)0GcS3xZJWbvWBylB36EhF2QX8m+%kX*;eX9D28U@e4#u3!Z;o z({vF0hP1Hnt*N*XFdjP76!=&R!w8Xrf{@X6EJ$c8Q#GGP-=FnVKZuX=C2VE;mN*`b z8KPNPgRVHO+5EC@AtZQNe!KVv_{oz-*l)7C}Q4|<~(@QvltKs9OC>&$pybx^am|9y3-Vn z##a4{b+lO%aPnAQB8NW2N8FgPUymo=05%zt<6*qr#V?kNx3Pm7hbunCjxV0FL)DLj zrldbkqdoutO3v5n{7+m6ZX1Ts#P7kZ7IOmJKnRifdhX?+RNIp$@m1aXZxsBQ=^*Yr z6d{uSOrDuEclZGE3zIWt=l%F0BJw@KV^$)r{afw{t z`f^l7ODj|Hs)c1C9tPmP;gp#W&HZ7u$$BL4Qh`KzNOWwAMBVZH#S6Fbfd2{R#s%W^ zi2z2JjABX82qYSS_1P>5>J_r@@OdzryA>}xQywD@&3zC52SC$~W;lck3sKlGe_E`Eqv7jM-y$vuf}g$rsB?5%5^VBVtG zdy$G7Q@ScK+~egB+{RYOD4uqSZT9BJ_V%xUpP-KfzE$EYMYMhAINmtcVETZ6h*HC9xW~&tlwBcAMKhj7l#woPM;%ghvf68_{YAb{^`=vA z&wPsqVDTckHA|srPY<*EO$=HOUorf+8euJ~-0X__3dIG2dG!(oxsvPmax=ld_ny9} zqkQxh!Q^^86e0r~*nesJlYGJ;i*F^i!!RYDNhTQ?H8|+w^xwH87^Q^Dy%<`pNKJLo z8VP6?TVdL+O%s*sBEZ94gaQE;FiubYX%r{xwg0{N)l&&O;cpi*rm??UBv-b%Curmt zi4$?0kV9H*4YW!VksGDSOTFzK930%gw^|jqGfFiOu@u<%ve4ZY95>6@aj?D&j8QDZw_Gdf ziwrTf(GpL0iep5vXzfB8;ik_El5eni+l?r~ml}-=BgCG^C_|%q)O5vgR{Ee%ibq7SR^LLjjZ-_ zJI9o%P*74(80+gCW}t!B35pa{Y9@t<^AjtWx|}+O@>NUNcv1r&3$2cVIzu}S02hiG znjZPhfmroN@9m|gFT8D`7|%pQE4HhVNmLNG?H4ZMW2KPn=nx_>^PTRj}%fNqx)TZOYN9 zYwtF^l~D5Vgk$d$E@_Oku&6^ly|VP5t$)5nK=WR@52X+BR1iPAjq$P@2YV{>?C&@y zP#iA)g=w)kM!e3ZTw`>PgpsnEnYI8E(QAsA4ZL@(*$r1hF`a8Gs+VyQOZdV}601-2 zPp2Uqmpsfankf0fR0rJ3OWM` zyiYq$QAFhwybeTjqC!T!VFwS@awSoL8A(*zX)bwU?As%tz)##HI++E!asY%P7@`mh$d7c4|c(}k#* zOL9A^M^tosS`RF?ZIz$&-Kd`8?gf~JqX+mQV4}NdXnKTf5R493>>JC zLZPQ4vT`P3F4{38M*d+HsvN7#dF zHAWX#P~ZXd;G}pmS)Lx=W0+rkO#9sSuF8xFb~3&JFsAt4XeS9~yWe2YZ>z$vimDtA zO#9;YQ`9+8lZ;YnBQmyk2O3C73yB+p(k~Gv?UGc{VRm z&-MLXl%P5`bFqtjWc)y{pRi@oOM+a%l+090LHR+#vWPl}MW@wJn!yztNIn}q{foqR zdo^^B${yK(mL^l zH!$k`YFEEM8RPS-(Zw>`#I1j?@JG7mHL?Mhe;sr*mu`>})LLmQy&n|ysoddu{-D3u)B2u8aXAid_FFNDTs$g*>YGQ| z$XD9QDxuXgG``=Gu*B=@JqmA7c?ZTnMuv=+VP31$35_%RG9up`In9Q4g+57zb59Rz+ zWa$%yDh)J`-+e-uq=UqF;HErv@YEi#9bpg1c?as6rcJ3*#-;5rg(i$6{L~0UgOFe@ zhmD4fiwsDs34Z|k@t@`A`0NkOnaGk@N@lu9fG7&SG=9nNrX(55orf8ywYlVlVYmYM7+pOdB=xctr8NCp7H2Mq`7f;!=x3Mzl zbH4A}0=E_H+Tl6vYdL0{p0f0Gy_W#UGq_>2xEc+>0Yxq@1zc7H?10G}XFLHELi`$S z9rgwIhm8!~Q0=}|?jZ9h#2!!b$jr>7F+C}?5rM6;&ip4)U&>I|wrTiA89!~{=W$ND z9Wam`yvJYj?|_Bn@QuR`1WhWqM{-C5hw8k6wv6r@>S4Ehc^Q>$Ou3c|Con-@qhwcx zD%U$nHA!ET@E|;piuS=*rL61E;zHu3TU;nP=5Pucm#O+aDjDXA41YHX=Z}5++TUK9 zbh~~8GSOeN{!*^GB4~fXG$oQL`dXH5C*^YIO``XNRVMnhy}bpSY55t{LofvEj60W5gxZOdXV{#ftGPy75ymqV0if+ZgAYK z<|Tpt1hdDhM&b$6W4;}vk3)CkI5Y-%FGJ4jKC{A2Av$pJE$Ww>IK^?*pe%6Cb1Uo0 z&d|O0)e;jP^l$jWU%Y&|4Wn}I4mAF}Y_PQg6baO045vK-knUC{{LFf0fL6*m!nYGZ zNa7L3xpL6RB)J_9mY?EhP#P4a?y8oRv*-3BKch|C@zu-Q+p#Wh$)KiRyQn<2&f6N| z3su?l#%JYYEjh~IpvdnB?wQbByVtREE3NTjAV)nc@rmYu2o337|Jw^BacpB%Yr_nQ z*K0T4bU%dC1wQKT(0$xYDBoalSc<68?{BIw=i*SIyAjU6M=T~OVt%_L+ggyM16nkQ z$De8A!Mdr=N{7txJSFp{$Pd`DeL`6RFaT_~3%G?~!Nptx7;$dge!~XU%fcl*dJt?M z*;QDIrnce~07Br+C9D?$9oq6QnNW|GYXl0-J6(ndTRA!CwpEaZV*(M>-AyRES4IIwu!lf#Dc^ zBJFBDr~ptcoY=1ej27@Hm{bp>&*k;*HIr~2P#OS(VP4GviCITNr!jw4EAij zf@T^k>V8}sz9n@1u%pNH@WB@N`Cg>!K2C@^8V|}znp7ssmM`{eY|$K47I>cVS;HjW zaOg74_Fp_rY0Z(;yK2nk+B{8)j&R7nc4d&#fA;edaIw4_{EuTaw)050)QP0kSkXPD zdygX@lTjuUr~i-HTPL;OiXyD_8!?$b-vEgi*H|q zn_t)0Ov$u9ks)ru!oGLO&BwJm|9-Y|3GN#RM{@b{4>+WxS$FXMW8hU4-=)7Wy=)x( zucCU&{B6FBgWeDW{Wrr5)R(CGa}8A_dvs?1j4Z9p@KoX{;s`2R+PRYlx=S7Bf@&R) zzSlMctei8t6z}YrO!pxk7#q4^tgJf;M5ZJ{=GRU8x+8yO>#P4=$Rkn@X)X_AET+TxC8pG%xz*yW#Ag-3&FW8l7%ujmhka0fro13%^PV zlxKg+`|)3_PWIQB(nE&*8cw^PT*M3sNJa7C9V zST;t0U44vD6hacD)P^Rd#x>94ZG-SmdexXyY&WUC*UU!b;dJ?r0_MfwU{7_P@O+rXC^=LimP;-ENp?$ejp&l%wjrPvLWv|>bA3;wugA1YUn z$*`e`83xGvvQAr?ComNnR0@0LrNQw)Sw5br*TEHkdFSv)re2czgY7X(2j}{h7%N}X zjz_T@9EEc3E;08O>YECCq5ZL|yBp!avY$m;4rQImNEDCEhb$590fZwIU7vE*QsVx+ z`>$hedp{&iUr5OWX%*ctjS*`xLQ~%B6SEW~$tDYG$UE_vd#T+}dLN};rugGe z{Z_AFe-U3;Nt~4#{PzbI+_Q{D*1N7gD=RAoo&$sfRbCDoh)1t%+IHYHK9UBV|h zob*N5Vz+$5>~aBhcUYd|gmG~|ee@U4U03DnH|^p4$w$6XE#kggqbSOhW?q=t=-I?; z%Wn*REaSS2JY6%)54?7ft`YX0Ye4qXq|FG6Za~tJfn!tAGu2|A7|ZynDcFgAq`4fW znVB`?L19cl`mXYXs_GIDij82>ejY#_!@zIk6+% zW9)K_wL*4+Zec5vUWZf{#_IUu(dG#7^K-ZNj+k)qU~HG>Vq(fc^9j^OLWUtpR|%U3 zlbS$LE?F5mZj}`*K%A|xLc$r@*Fe$iilH?xE z4zU{s3kjYy2WJ0GJFl&dXdOek17I#gw8u7$WP3D8fP#O2y?0EZ;;zTcz(KaSo`%}p zV)8m7p6AZ}=dwhy#2v5m( z2eRbYe_{LmJ)XidQNH*HV5&(9@%E#= zYi~nKaj$Hwg>LlDSFN4j$U&`2$QBS?FM(R7EEKa)z*M0D598ZBU;Y5>j=Nm8pk!<)l_|16K>uY=Q$?`Fg9;de3NO3|o?IeC{Z>umq3JvS+`jB*z11fxKO zDH>^&YaxAE1Jcf(8h7Cpl8~>vNpzI?lZXn{U^H~q&RZT+pjwL^g; zTb#2c{dw34Yg;p;)CsQ6THhhH;j8R+BHLX^hlHFob-lo}1qbP5Uf2z9npY3!*6Jjr zU&ZKYq<>2{4a+s>Umfqd8_#54uTFlvAj|3>*g@qu-}4~fiZyaYk+w=K|MKjwD$*V{ zE}!b5npG|aro|~A(e7j0TU8?GBORH>1UMS7+>QoqN*Kn z%$5on&i<0OscC-1>Ik>k@V8Q*up8kiI-;u=3$TStKyq-1P9<%%}Z8uY-nZOgeo|HhIxhm&R-)d7nYTt;JKc2Jn zjN|FY?*q27-vXhPO4t&mpR%=;rU-+gr97%ii_PPItW?&|wAEbjKToC9vvtJi`k_gZ z-^WtNRdu<4{x5&*bq^MF9UQ4#xoH;DQX240d0o)9e)71zK*aj{%9heC<$nkLgAP=e z>S-i<^zXGEN=87Yh%wzh5IjJi$60M`70K#(5+ZY(Me#Rii#1{^xDp23sKR#!OETG| z__406lyj$k#|+O+M%H%PXr$fx^bQBYh0Vn=8lEdS zOR;8gc@bR>ix-9t=nF7PR7h1f7s$J~Co^5~@AeH8HW=VwU}F6M<|_|~|ZWT~G zx4zJJDKBdZ5&dj9O{fJBHHXOp1ig9S0iL;Zsk6^9g*uP*m1aJf?|Sw6fXnW?oWfTv zc%F_H1W=PQ(jMa$I&<0f&S5uGaTgg3i0?Em4_BhCXWAi5()T(g8d&t1% zgu!$Az_?jKuLzR;Tpnv{N!I~-gt_vRa`<4%hJ4$_1JRd0>BRh=Up8Untfbn;HMFF$ zD`6tbWJgDRExk$uwW+*s4E2~Qx5{D7Q8Dg09eZ`b4Pl@E)fk3a%c&(RTf%WgoZ&iP z%9^|Y1r%nk*SJK?b~QFon@FgBLw9Y!^9b09)l!fhFmynJJM=w;IjI_M**y5}C`p)W zt+OpCFw+CNM^B?F*7MK5IQB`j<0ikj)ayHipM=L60r&eAm+9ClcVB{zVXx)XyL$IdEo<>{kJmeu3nI3LHB>*KVsB|Q;cOeMpTaf4WPDH3noY#mdHu{|obHu3r2XaEl0 zQ4IS94(Wr#X~H7eCf}b_b2~qB@jg}3HIb?E0`~|y=%d>sB1$_|0{S5$*rnu9;jF*O zDfWx?nOu9aXTHg;8+A~tVJY48d9Ci;szakKjVcGl{M=Y+K9GRpLf*V=a?0HP2`YD9 zxvC!dSzkK{;PtYu4kko@XlCjwYj(h8mPifUD(9y!tMXUPD3sQ-CCI!!z>+G_iaw1} z@=52oWVQ+Ka{o#~pGlx1b@wl7lZ0j5KKM0mY%1ifpv}H8Gs;=A)u1CnoA9PLKdP}r z#NDsF7%BCfKsb|$T*~0d@erhPqo(SD$n@>4Gq|@1YYrK!?gY=`l zXC$wKUwebXe*QToLh)4%FeS6HS_ky!;a1%~!LmdpGsEyv|Qdqle-r!&<~IsG2p z^xUVc&O4fLaMEI};SX(uB%VgPK?=w zIS5kIQd;@iSb*r@tb(t#g7dc3FKl{v(EDCumA zIBymRow>{(1LwPo1O81oNdtKYto>zT- z=5kLG_}`4^_Svp(d|N3SHfWd9;Hs2MrqK?gsgY~UE!%bE?zyWazpn-S=uVn2j}rSM zmcP`j^+9v4a3g#p;&0N$mo{h5oWAqsz+I6MIPLgT7*o(_H-Dr5**QS9YyK~p*5LNb z2s4_9Z1J$g;Cx5s#W$TcC?S`EdR}o=9_LtW{t0vr6CU>4C(=G-rMedg6v$Oxy`yY` zlAK8do~^gcZWpqKbNI-NkKfR?Jloh>%^iLU!4VIPjzg_Bt2<_Q_iTV4lUR&SOH^;* z?n~cyA2>!89Z~@-6OLy#c6LfCSD6`UBu=uwm?{YGC9yW6#P%;Eb!8|PPI2Clq0?5Q zlanQfU?~$RD8IelUsONbGL)W%#lXBJ-6bjqXb7eyh^6q}f8R;^h>{Fj@7&zna}M7E ztE*L}up))8H*2RH>q7DI5 z#?7s+!z~S9tf+C_K#b!47RIrU6s07BoQ9(OQst}wKu{dqqu>dO#q!REzuRBvJXg>f ztdoT{12ZL{e!KVV`Te7J{RQd>Fz@UMm=w1Pu-Ys2GC$PPizia|kZWEAue{LdAUX;Z zaJx-|!NxqiYp)Mk!ta$6nJDqo_39$L1e?#^l9x{DrJDan#=sQ*khzQro?_4OUr zC%une+2O|QdFWMw=eEg)R5iqV67)9m$X+e2^Fcd)-zuv*@t|pa>cP>b&jP8T!e*nF z&n-S}V_#E6`|@YKL34CIfO8-`YE$X^n0ndk&QHEIEM>Wvl(cI6_@VG`>b5$Ej7L;z z+`C!Mt1-qJlr4Iqf=UbK>{skQ$7brdi> zTb>x}ht$I}z2R3|cIaq3-zHge4#tFk9krlk?V1S@s=u5a7jwn6i68Xm()|3xVzmuZ zXKH>1ayLJs4vYpeub>%Iae*s^TkYR zNN?;p)f4mJ_6-X0zZzRw0PTtBTL-I!5F;{HT_O;+S)wIFqU2rRdXEHtrB@inj!^tQ{3n-n$~&@;=ceLr=e z`%(9WsJvC~kt?LGkwx{Dv$h?}7iJdYC#J>+6EE4**SbF=ss8Q!`DmK-&nM`7SVKaL z+-qgadpad47e;kL1xY*R3Ru}q!;j%_}X zIyo^PK=)kRt9VTyhJ(BO@UG*wQO08STeDD!j!@D>W+r$PoW9bMGAMcSNL|{V3cdS# zXUs&B(cK%pnK3CjSTiDW_qs@dVobFVQ#5n_e&s>W`@l5LR>j13 zuXK|vjtL{>J)dDndWB9@G%&~AHBYX(A&X)!tZ1SSo2u=w9PJTX$YK9wvPv1h={!%C zE$?<}3d#e=uKmH7kiq_qE_YcL6ckK)Paj7~Rcz_H2Vqa^Yb*FRuHB8WEOCezk3V6mwyG{VrxCeh2*}mzXh}G2s^8s#;K;<>p|2glLkvTzn$MtE7-uI_b7mS@YmhCqV zqVu4u(DkIWDIL}nKNuy$7z|wc_;KT-xg}pud!S*#zu?xrJS>Z&4K@V>R)=X2seU~# zucJ1G^%0CWb?5jglQ~G74@NvvY{X9TM!87m;$nCrIO#EcJ~=@6S;@gikIW^qstbHX z0$E*W2}-cFG%<;RR1p0?ULBUt(6xAY7-LF8!<-nrn(g)gLj2HZ`Xozz+~i-DNr7ppbA@!nx$3FwINUAjx@reo)BQd?o=f4QXAJ+9{brD_X|v2a zc}2akx;9j>PA`kyuV518VA5XwR{<)SstdADz)+p??C_4wSS-?(8%4_~ zDQqS&EBO9`_QX1W--EVwANAb6eE;0F&BwIU3U_G!8H%&k{6MbF4zd5|JLnu;E~G0^ zC1xi0g^9I0|9J8(|H;m+!F9}BTHlKQ{1`Xt&M?q(ouUkq+b*;)p!ttKket7nAwSBa zZn2crl_Ji{5^zqz@sNs?6Snlutf#U9r_MA5r{^_Q)lbHem&`{d8FxQn?R_3v**GQc z{wX{rxBgKgbsx{fAYJsx^3;8mWIL{Z8Y8uP)|nEkQoc6q$*ak?s@gNi@{Qn9_tiFp z98z)DEcx~8A=!wOX}YXs7ip|%A}~G8{iYX`(=8FkNR|FmW-U=p=A$ZiFrboj(xKdT z;ce#MKMuaSe!4Z{TQ*5){1)i~MNu|kgT?xz^%dX@M;#)^!6{AUE;)9}`s!fRo)o64 zww(eblI+Kd%mgaEr6MNb*HGr#*!2JTbN{l4H5mn#o+RdP1ce=AMCkh;SfYBr@?jwM z*cBfqp}yCB0?2BU$_Eeu(DuF*2tC9yN_AM((9@sxUsF&}sGI2d@xuxOM=VejPm25Y zor$1O*=(kT3Gptuv4Wnp|3lJs2U6L;ecK^>?=2LWMLM>ulu=pPBeU%6z4werMo2*WMP4C0THlPR+diVv?($f)bpo_~}fKx%ZeP2Uk4PWLs zh;JD{TOj>P0Arrl(Ff~gH^+wbr#8zI`_3XhpyUU#HVO0@bn zztyT|>p;?eW5fT>^@O06*LC$JIM6==pQ|kLTw)EeWD|n+vyTuoD{z9PT}RFjM-i6m zM-v6Pq-N5l0oU-KR_ljM4>Q7{b{eHpRnb~t!4dYLH&x^MZlxV*rRUwG!4=|nxW?;8 zXG$FON8?(hvdlu>pb%3wcw1$vt`6k7sxo+43n2E`tSkADNGsDWwa=;q>o;yyIonD@ zD-`Bc8klTj-y^o)mt4?k9HH-bAz~*YHp#{Ot?~s|2&j-DxOsH=m1sLG;ciD#_xd$* zeY6RMDTJJSUsiyC%syyGiS`4$kMO!7K~A7V8hCR@=T+owMv@3TXYWtY^83U1tqm@* z+~!O}390mPv-c?E2pVAGpWc7i6)=K%?(y%^?*e+sM_|17KON2a`@1h4q=lS&TT*h8 z5|~fY`>gJAq&KAgTOYhs2OV_N`ES8E1rZsU@{W$XSJ*N7e9B305M&eKiD0dQ1xi_2 z8S1f5=R!#LTku(J{QaR_3K@(*UkRk{RUBKaQM($Vzg+cDQEng3Z$tdd2$Dh`KiIdX zH&f1dI(M#$zvANUZ7_Q}{u%i+I7!Ph9#d(vX1^)7CLy%|*af-w?1B47oSVWK!5oQ} z-^T$HlRn>8_*LiHMK=oZ74V*dB}n{kyn1sYXu|PY%u`QiWfbq*?>+j&d^FbK$%V#eSKc{_I z$!S|@7Oj_u;w^-s@!4u9f{l8QAR%xlQ${0{3N}i9A5%NK-b_j7XR9MgTx*N4WEmJ5 zj_vP%f|eXNC?m??1xc<*mV^ZvnOFSks%=U!oBpHO)Q?{tU=2Pjb_C@hd{zL693OWd zaTee|a{lu=ZgDhIbDQb8iC9aQkrdI!R71NK+H#?Mg;YdC?1z(vFU7D z@33F>EDLv2^pUShpTa6qhH=?dCrASx((=|Ea!3rB5F3Yw_Nr z2K$aKt4-@znVD6;Tr=ESd;zlnfQXPJs{^d)0#W5%mS`oi->D0-}e@C@x#SpQN8F=%-24!5_k(ji29Yd{(*rX^ZQN`2TAN+ zLsD^)V{X&fUpiuzO^0gn1U+8780UBDRv;tWA%T=>u+D|4+F(Of(x>`*hi4{5@80!O z;uYRTqs8Q0jD+1Hv!L+qzaRU6M*T(WUZaMxHhQLriU^@lHhmb~A!irtqL+t`|8$c1 z`T<&_ly{=~tRZ=-n@bf|BTZ%k}33o+1JtV)u0z$M?GAAczqQ5_uz<=NYoTRtIxxY!CFj*wRnuZi_DLsO5`IyFqllyLvg>Wk0 zBT!-=03j->O$zE2P>j5{2H~GhNvc9vmTt*+qF?#(Ed?PQ_j3cmb<*u2J45%i+rrU7 zEnNg)_Mi1oxfc*88q$IhO&EOl_EO87$mchSG})C+hht-@$mMkNCK7j2;eRz{I0T-$6XnU9T>QY@voDNu528 z?P(zPK?1)K5}B1;W2M=Q+?BV!>QFx2p#SnnPsuZxN|gP1tn#wdACL*$e0?8ulL!wp zVq6=rU>wwJMZ5+kG_dp_^?ERG5>d`^-D2W%YuD4fO7)q2Ag<`n>Nepo51+l0t!%Q6 zS?E0Z^_7Phz{DrdRx&c^*Q`j?2^G>j1z#t5GMkYRW@xs6k%-O}RpfMBrKt?MpkT4~ zoNmkJ(H5Ivw{Yhdpu>WEwY!lvSPC}bEBPN?0QiKehG@?elH~??1>mlDC&4Q1`yK=Z z$Q9)1n9%OhP=uL9vgjWWU;=YKXe>WnP!fhI;fVNBtPV`E0 z7U)vEeL|<$1$IdV|m00T#`vB@;cQx0XSqMCb_`RW&(zl5|HFV1Rt#a zVAOc+ut)?;-p_`4U#F+4QVsFDUu8S#cDk*ITsQk7sL|exD4bGn4r^Z+$lzOoc*d^& ztRMF@mD5K~Q}(_DzJxTb#J>lN!;s;})Vq1%2`+xywyA(ivw?GTi7&}Q{8 zbE({o^1xu_M58Gg<}sIumz37w z$jhRjdCW|#^J_g4c#H2lxZ2vf*G*y#&HrnTm(CBYTdMc8aX%+IzPam5g}2fip{@5C zKDd>qz@-UsDHZdGiln2C;VD0Rty_N{-+<1p31si77C!#xd8@M^?q2Al=(xCTsi{(lytHSz7&Xb7v@XmUjK&YP4Xr--B1r|R5`2?Bsdg&PZnv>sYK|1%RSF_(ny;QJ z6>i|ehiX7EI3K`}c{Ra$@Z|GzTR5gC6PEk| z8UT+W!x-qr%V3lB0jrIa@9_{7yGk1r93xToWSZLhaJu|GZp{J7gbdO7($}`rg0=*_Iv_~)`jGt) zYqv#uuU8B{iA56VCDktYS-5*%^<@jGD24Eh)5P4p%aN3XUICjm_@`jzvf+reA#Bo2 zR7|E8HHQwq3b_0b8KNC1k$@pV)QWY6EK$GD$he6D^&QfdEf>B%Kbsb7li}PfblFN$xj!kY2z*n(jtWLna=|&KRZ0PmF!* zc5nRnn*z!t3cS+mM&ui0b07`8r3P_naX`uIMQt(I~d0}ZQ26+eLTv3*?jb+p@$Z+$Fd2Mh2^g*;u zpo0oS<)PFmIrxy46&w6itWr^hMPlPTH2a_}06>cR8E<-@&f4+%x&v3^-(kobCGf_R zHjd^JRgsX@TgaXoxM=YN0qTFC|3dr;V60ZvHQIrHsiULw>C-36jvFY(`y#TjLW){g zpaaLVe#n{`&Q;17{OkI?MC?J+bj!!B+q**Do-#yhKxI#GaGJqD3~$R-I(QZ#h!?pe zN}S_NPx56>Ii=wJ1id7z8JtV#Z0bv_A;E6^6>`Celv&?fC_YmvyG*y-r9|Q8FA})Z z5gIpJ-^=z4cVpuuxvEXR1rHH_Yj;=#*4WSIpASGSjr7aG9fDUf@&{VlU$y+Qs{!}= zH@#r4FnNHMK&D)ydBqHgoC7x{Tnmfhnwl!fH-URxfr+KZrhXF2eZVgTm$bg8!$=DY z*!0F((ks3}KRe)4?~00))s*lVLSblwc&)!p;?j7MH_<<^PtVDG zLAHQsGbtcHwN|6)56hPw_P{lUem=FtYcDQgp0grQ+Kj2o%FGloQ&3sZvfuiI_*h~vWM#7V|G0lr|)QcdYu8!>Q%J3JoTMo%ec7sqYa zlRV|aMvXGEg62Mz&0f(UH=!#@gxi*@^G~0aH}_VU%-$bdBA=wSlW50M^6!`EQW=s9 z(Wd0}OqO4m2BGD1F>kg(EjPYHxJdR0x7}<+4mu?8npfaxA&d}wU6Oc+5(y0IYvgz- z3TW?xMz_b-*uR5`c5p3@H^GEdVlA94-R&;i?K>IN5V#Y?8JL2ty*zP#cI zRI4ll{gB~JBCFfDj;IDut;2DykIA_lY`v{7c}^11rZ62U?pKSWj476WV0vHc)1p3a z!GsI^zCneeA>NhgJf+J!qD~SCPlTgTZ}Eapy(iU+M1EttG(^uxhC}HN?5Ra4%Tw}^#wAB z{)HqBdmo=Ch;URQg+p|#`jC%W_Ll4`UXF79${)gNfyo~!pIeJ+wPV>FLfrEgK*C7?u7&9bhMP6mR8yOw0NO!Z0#I|9bGcsxc?-h; zA~iyYgYmtyv7CSBE6J9fHbB|#c9K!bfDJ0-4Qxp2^yb^z3=A}$ARPM?bn$2HAp&%F zb|Cg-fT}^u1U~{KT4qpKNlTUXorG8nZe?fShq-8wj6;njh37?^<9K+_5I{J-VdbH)-rk)B%DmH2||_;0`46@&6|^Ve6f z10#7Q@bCNo>>6H473@yn;v5Q>ProUQiZI=W?0n9SJg2GIZU#+7lpC17#l;A^p2O_m z)&t`K5b^hQps9?P=Bq=s5ieE0&8}gwa|o3`QD>OO9!_Cyt_Ea!04@eEiPb5PVA_A+ zolL%gdoB7u@HfM?2z#ixc0r<0P_ut?IIn`rV?E)qg@a;Dhb5Te0qd|cGn0cI41Px4 z8iN`!VYc@f85!g;36e{^@+3BFWJAy{i*$AyC}2=U@>Hwezn|gUEO*3zS3@3}L2d6k zydcU|jj-N?=H@W@bg5Dxd63Mm;zy+b{s>x^)f+mkUaov6rxb>RP7iCD@NS!~90x!XY2hBy{@&@L%gn8}fsSXp?XaBT3ZXezE7Cq;blY8vD`5H{1UGR5@K4kM){ zi`dio=Pt|7BC_o5*~fcpPFy=~Qt#2*-Nz}gJ@+4TG|^bi3uu>H29amDQjzoI+w#*Viqa_I%%igD?p*_1Ihud49v8@~Uc?sM~Itg|bQ2TSnn$%Y}h zDn_O6$3BCKzMerP4i@^CTz*?VvuB<5%`9xG?5gk)0d($ZtZ5+Ju4(mwxOK@NRieSM zUT;E1I~Za{roD$p$s22}<%2z|&`ETR3s>GqL1Z4Jpr7%hswRxCx9whApb&e~<)fcSA_LTYrEzJWBa?P@a@_#Lk+$IA6AcLpPsN-gfe=^^Oz{tqm(_!#;ktioXIJ%|+qda$IU}_J)z1XP2kg;aIZQw& z-g=w*%2k_YC$`%e+#FyHXEIen615WuvS>&y@le) zb%=d3c=&Wn&aU+g7Uog#2tl)UDf6{X4Ojw%Kk$Bz;fOd`&+7!0I+W9%+Y9f5`3vE& zVNr)DjQV;w70RhU2jM8u&xeKK{%Q&^0dEaNMd)bwzd=NZ?h|4g=cfus@r6>$6UYz6xas6&J)*=>5T*GQN=xK@uB= zqaH1^QF)*7)*zz7yoN-`>D5oLmjY*%A(s6!NWKVH+&OiROsl&;7UrT(ozMDT;dsRqma4w1b&=3TDN3Hpg8=%u{{q(64U_WUm zPEcKZHZNIfzKOj{Z|g`qwUf&94-_u9=ZFA6#lc%J`@@FT{e zn_A*_6`(qWJYS!O1s_Q}ppPHd{3t89ZgD%*Wl%{{B9^Ty zeJy)9H$!P+5+Sz7Za(oORfGn&yHDX}_H;|Nyox!c>#UG<&{Hs@i8K2*W(eNO)rbo8 zT&DkIJR}9Z2ptQHW0Vhwb^}++vxk}BXwJe4BJU)r)L0e6 zlQXiJV=LteOcoAPPs3`qV!j(HKO{UP^daboENV6`><%T}5t4NbBo5k~OZOZk-(~)- zlyNHReGgOQ5vn(Yc9dWvcpiUxlDX};KSguDT@j{#{;SC?{kBgIdvqd?R%tu za8$ZP4kcHxHKIl3va*Ik+}uB^)DQewGL;&%mk1` zrLA`7Z=LW2dkjp2TUESzLbjh~#jN(Z==pb^3-jCf=V&(KQJeL-OKt}&RMac!$=4e5A$L_LR2T^%h3&jBbTysF5s z`hM@$kX3D~N5%og2Bs+F90lOrT$c@-j;&ufI45&M@9ih_!R-{FxZvpjF*Q|Lf1mWg zLTvu7>-}E#ciMdSZW;of>+5ldorrcmf)5nvNG!}k;$>g#qvRl;??ovU<6Eb808Lb~ z1^P{?Rtm6FL*H^%{DJy5^-9c=lLn11MG+`qE3UnarcWTN*|uXrd*%WV2Q1CE{(c*w z+G`>YA-NBriR*n=6r|yd_CTv7@Zx@vNB-E$Ybp`99)iE^4vzd*`*%LEvH98^bLvHL zWBC{x8X_-KD#5JyYM{-l2Sq^s+`=lOWLaPW%m-ely#dYhPXkMJ>^0;AA+KuSM0oM_ znfsa-Yoc^Cg91u#ru>fZBtTf8$3j#@;5hIG!kqfoZZtXP8iWABT%p9)VfqWU1Q_zb zXA8sWUQNB%>IZrPO<`-Q&}SnpSw0Cr*06~lQL+BP&7w(_v^DzF^wP4}XUTIGSkS}| zpqJrXl=t=n7bH7rx2ehI6ytx{%~A9BP-(8R*F^F7)R+t87`Wx2dIOl_%%VmRxu1Pw zyhTSl@i@VZBkb}c<92o~t#JVXyoV(Z*9ADxl-D+LsmLtbnaSNyLiJK3YA}8RjavfF zHw#CFp+#fOR=oi|jiq~w0;;-vC|LhJ5kTnZH=N_zOoqE%3Q#Fy0tQ+ zi9_c|hXJ>>cJwxS$J5WM4y0^K`DS@Eo9T^90E`h{80!91Y0`~+b5en0Pcn=@hJ*S} zdF%Fc7WSqnOTrp3u{2izrNnzk;nMu1nKAzw^Ug1TrE92B3R;miKt2QOtHTCmtqc^) zdB)j&oT7A9WOZ|niE8+76Tyi$j*aSc&%#{oRUpL+0jDXXA1FoV$79tju{WOV%UcHX zFo(CLpR7@-wvy$B33QV5GFXNy$(!h6rATj2R zc$Kg08(9n|OW*(S?V~C&GjFbL+m@kol-IU3he`X%-3Q@mX4jzm0CPn0jW{O>;=aB< zM0IS#y3YYwe3VE;?_MWMyH|cKDPF_TP?EsN%OsR!-%Owwe-9C!YNu2%j_T=EpB&MF zn-}z7;!o1AKKfI@hrxby<`?2wtA%zmzt%QCq;~hMCAp0{@0AVlP-~tlcFo4*{?q55 zf5Lz!p4T;>DAsCsSa_?L3L^LJ^R>{uv>fcXYH3#KDdijbm?XMc)Ko%fo8c-mN`y6{ z?TY#6Y3q%}bsuQ}*Y3}2{g*_=yL%wa;CtVE_o4xVG)(^K)G7A;MO<@r6nj03NfE1= z%H}3mwE+<>>>}5|f4c1CbiDmQ=m*(!Vte5J$2L*SY$bLd-prH3wA=F8$C9mS$A1BL zR;j#7WGHEixx+3b)Y#3%Zk1>s6dFV|A4PdNKeJjqcm1^GicQUpuiX$^T|C=V8i`xn zD=kFZZ+|KoCSijfeIa4G2YNLO6RYetX7Ed7QZQ{tm^cAz0O*{xU| zLU=%HM5M!=eZNG@Zr@z^#7@3GlHg>Fj^EhSh=x8W)(Uq|3bsO|QB^vJ)vThrQi$eH z6?RbR&xZ9+qM&0=B&hT^ujHSEc?M?Ar2fcz4Sla$)bNb24xq$tuWlD}$m&3T4kVxY zTg?bpYN;8SZ&VitN(F^KpKUCI4^lUN{|MA%fx?wi2gIRp#w*dty-&V|!cxfi2AeL+ zQ;5ez(zqdi0s0Pp0-+}~LU#5RR{vk;F!h!^0bGMfr0lz0=f0GLLQp3J>t&j5f6ZWxc*0#$OlKdSLf;b}RxT$ME$1`Ody2Q18{ zE#C_C*w29;prNHjwAw#>*dvu#B1&tr~q>L zw{6UX3G1w}4olRXSG}>utl<6{HxCGy9g^&RVMzj+SAN?q`2VrWo`dZlwmx_bWRf3v z05<~*5D?9vxB_3U{)-l*poShrK$*Rek(5LCG&`TI$MT)-^dJ0ji~=*zp|E%Z7O)jn z|9}P+BMNus^#`m^j%?A*YqHKlT2i0Z2wbEgnx|*^-8=D(Ep%Vj5y;2xjOkf_636|E zW7ky@Hic@5Suss{JJeA4P3p{04QH^xV)~Bd4b$l5J+D2Ig6sCI+AN(U!p}`D*fwAp za=x_?gLZ^irI0%hXj=Y8n8gJJzPwNT59CuXTYVX5_XyNLFZ2P%*F~v*2*&jMLw9w| zBPS!HGL{e>Kq8HW?Kmen-mDOrtQ1ThL0Ru@2cILw`;tv||HF>Gr z&JLf2i0!D5vE*_+df$r8QWE#X*V_4=LJhM^ZIT35%Xai*gFeEVFy2FaHn`*oXQH(%qq}h}3bliCW7yzU3 zMM2vU?#dKeeWOpUtp_7ae#Ysl)Q^zTj_Y`3DVElZC&7z~Hf3OyqCsto;|cmOD255W zbzF%{y8B8ixnm=wWlm*HCt<+bh|?&K44r>81drY&UP`?EYQ*NKm_&QKQtnzcFUvsi zoAo?4oZ0|AoGyv#)cc!xa}deWPL6}#(Nm$%MM>A7B1w|(aZwCIP8)X*37+Q5a*EL3 z@jUGfuDm_>o({Lp_leXtm!**03R1pFh7~H#7IUJoVUMri&^9*-Q8K{{LdwN@w@AMF zumtJaY*W+0)w7JP;OOkE1&R>JTEck%nkSHHQF@AXKt2<)=P*YDSaR>?+iK>C;0!f7 zTy_Gk0A|8p<(MbM?H`0O*gu?zDJ)d4YncSaz7^gQk*vok&>MhrtPFqqZFvy}IVFb$ z__@@viI`*c%{vp{XTX=|uh^Lhc{)jAfb#;~8D-5kz_jcOv^Uc|j(TER|dqPEW zBw7@p$!x{XVkg2uyKZrv%quvikc>EKO(*ga+*Z@|rQ8avAm!c05(#qYaJ3!`l*9{> zQ&90diN$jx+?FvcwX2aF5o}qbV3j^N8>6JUFx(|_Dx5nQ!iYNAroYi2M2fwz4-yke zRZwFmTlSL45uO_X(29XtWdh@)iWjWdM8(f_{{OdTLfVC&t^7bO2Fo-ZaEYLB#$P!^Z|b*rJsj*bp;7YD!x5IYACS(GAT4zVAOap{N=C+1WYU(k-8I1b(n-TR26fo+^WiU4dw znjVDpxC1;1;{?PQhvW*6fjq(u1YTukh4)$z;1Wb7wxK}TLw?I?5ov_NJ)d@Oo<^uIA@`;xJ1bNeeO=5Y>;4EZPbTmFJ zPOX|+pGYLlE+1V5wd;(X$HVt{63i`INq4o4h4D0HsThLCRKA*#k$WpN>mA`JY*8;f zW&VXLCaSZ^aYPCBhvaVLtsc38Ti>LiuGB@(!D`!m_{E5-q#s_?y#ssT%p zrxJVmtq*6MVih@FDD6y6MP&E)pyT$;=tAog57vdLM2nwov$J8HVM()ig-;*(91X30 z#P09Z;8!qBf;aI^O@(?S_etD3^({)(VItOm!`DxeO^ujbfw+`BZJtHUTma~ zb6hp~U}0JMd<7C^3w2>cfqAB6IieDSk5=bqRa_#zRc2uc(*X#X_N4v7lK!B-o!&){mfWdan?3Vv$Ski9WkBR# z26p508br;>RrwFawo!%@T<7k99^@CLiQVv|b?6CKR9upC!7V+b;2BegHH=k*nS^x% zU#cyzU+yr++vBwOB<$y#a|Yb?5Hn z?xZto1J)Z9UBIH-KY#uJyut9%st9K1b)U6?(4{B0R3Hin2<)4{dCp7$qXx9dCrFIb zywk}-h&#eWWIqHf`Fli>1pS`Kg;oh~5v;?oSgfB{EYoEOZK&oLfd&#%tARxFzXE%! z3zPU}L5YNDh9DS`X_oU}PXklD6AxZtD=PMUts%DOxvUabAmK>+y(fe!_qe z;UsyU@D)-4qc}aB=>Kxvb{zD5S#!1%iF9Nl@GyT{M6>j^{kZzyT~)<}o4jFgGTc#= zWp4i4%mUVnzs(*XUxALh<73bElt9b7&ZH!yCtGlU8(eSY3v}qhY#`}=b95w|vH2R)M+WRA#V}BKiTq3ZtMHJV3A$KR;-*s>9nAYHjQ0r z6W9HJF}(=g4q1;I*0C&u2Xp*M-{kd&AsbmfaH-BuosKl)Sbz}4$#8dpek#{Cm!SVn zC3kIZxx#4$OPQ56`NTkpl_Lb?C1PJL%29wj!^C+2o%4wuBySSsvqh>0B?m_ zxL)NE1uy0r>2nCI2E{MHt@2{he$iV>l}@H8{9H0wLWuH*&k+CS3n;n{!=L0Ov-lYD z>uW^?+v*1^b}VeUSmAbtq|7wP$A-V~{a|uZb`2h7^VNFvDAh6K+gL3PAu>9?8PKH- zvEC#Mqze)c%7w)=Zb_+^Cd~&rV1Tl2L9QQ2!Rp+EY#4Ylq3%JnioSx`o|Fg`fcfI8+}u6Yv-lNO1ff-ObOMZ z8Y1Rl2!W9=j{Fh?9N^Oh05pE-4=0lr)_HuYSnNy4M*BrPZ{+lRG63}ir_fER!^(F( zBmD@0lOcWB{>T;dIqqL|%VG;l#>7+t+`4yPvWK+v?SFIx^3fjYijfX)cLRVx2N{b5n>8 z`OY)p_{TLvkHrTiOozP=ZN#A8t%~@BZc6ZdNawR$A*Z)&UV{u%y1Ns;j8Py3b{1nQZ=(+;0I5E95k&kGyQX5+=|2o5qYT zqHR72i(2Ss+k9V|w_ZPt<%PGX1cV>rP+(zfQ7mGV8-Ce8j!IzfCtv@B{kwvKr%fcd zMNN{C1($_JEoiOH@a4yAij~a{YNhV0*E%5~Jk~^Lwbtk8<2M3%I^1xIyKGvXn6I25 z$flLbc#blSjtCF$&d0Jc{T0qsIheB{$JiZKZ(v?mOUfHZz)F_%h4+A<0Oz(NT>GiM zAPNW54A__KZF!hRV9!VNd1?Bx#P;1>ki`Sru})C~NG;$r;W8S!?&`8iNCTWiB_fL?DgHAVe^ebN||Pfx3D*(u70$klRPfFQh<-lxQ3 z^yG=?Wj|c9NvkMa&-fls!wX4m{0ooVp`B9DoY{F9Vd5`T6V!3*+JpWUMM=x$eDGe+xNkOgHzSJ^U#5+g4|aYkc}0E+fN ztvfLIXEk_A>M7=q;7cHWt1R~3anLTsc?iYUImQwVOl(P!GQXlZWK$dPC^XBTqc?qg za{f?bra9y=`2H8|aF)!MA5pin%OXu*Dm8eTr=w&VNd;$oDExC3E4u6NMryUVwk#h$NPC64^C-xJoUDUB!jls21fJ-ClGKQY_3bZP;@al~Hmy+qclRV9GbV zExS%jb;Fh~(Sp|vYeas6gTx+ENYv~aNp9B6bgj^|1mgFxbA0qMYNI@lRDIY+-`*XO zjaF_EFEeGE?7_BvJ{2%R-4hoq=_v`gz&I&(_bjVVNcHHJ$#=7&!u$yJ6P8et6{;Z6 z)ZVXf5g2@MxN1IP!?NpM8bqq<=|ZK+7a#5xWyjuJoY-|6Lryllq6iFuWy#$9?gNrl z{7|}N{#)NquZ40tQ8Y0hp>`veXHHm5=sIby%H8&^3p3nHtXdHuTMpXTP!LZcsW(J# z!Up52)I>7Gm-QbUOZCKuQR!CecjWWYjI%)#eO}w0H)SsRA~=SyyG2@MFVFnwLTfnP zB8IUza9_W%SCIaF;@h9&Ll<$$!wmWl9KP0^xK6wsK6&G)Td(iKF!%F}Tv7TEdyE2w zqoh`Vbw^c%opiXZ$WKMr*@T2_R#^duUoyJWG%CpjBQzej2g|2~Vwp2IGY&Ood(w6Dha6^Zk@1~Yb${_-zJiD6Q|XY{$wNKVJ;9iYj4)o zGco!6(T&%6R;JPL#_Q&el6iizJLQlq27(20!Jvmz%Ih8r4YEz30|qw{O-bQtP6R)^ z`ZbM>&nvDo;U~U>bwi0DIOQZeBSQ;z6on+a7&dXbqfm0xQLe0B#M<@%H@#WZc85gW zIODBc2220IY|YG9LezK;(718CRdSe;Il~pMGu$#>cS*3T0*$R%=2o~51S9(mU~xG2 z2rU?v0+aibl|B@JxZWO+tTzKz>31T(vQf^gVSDZQeHU&-7uhDyXZ$u?JU=&tfApV> z5C^yZ1Ib?P5tSY0!)x2;5SxG%R1zP%&H75zgoCN>ZYRlJVA66N#u9~fWF3;*Rs(`! z9YJn7A~-3=E{Xf3D5CU|coIGnAJx;bRf zf+c#3f!Gg{fnNkR95q5(C@e^DmcdZ`H91mBl5I*WmkChakDz5RC12) z`MZMFbNmxXJ78A0Iw|qc6U6&>O?-F4K#&5f3zRGo;XVCWOv(xsqL09ydT@ERh2+(w zaKX)Q2UR}fjIErdR%ojqhTb?~)|qZ(UqdT5UWSSPnTmh_1rTh49s?Ljp)|J*i$CNp!`NDzBCxga(vDG}tC^E0kx=$^c4+ z_y_?ph2fOH-R)@82o6wXSib))2Aq>3X&?>8gRzppE8>3Xa>|#qY?=lA+YO`2=_pD{ zngvIpZhd^qa6!Ap63w@f1ch;~k0q|t31&}5xkNnPWc-*rG^`Ba3WM2FV4M=pV1W!M zc;SK106N(gs0feEX)XBXz$n+aLt!D%pr0Meq%>k<(_ngntPGKe3xz)z*t?Rg0dQ25 zJ}5swmTLXRGixzi!G@9<6xt`Ge9AFSr1mmw+n6srG$LD~f2KO^;~f7kPLThkIvsm6 zn*&8^&MbOHb30(sK<_zBr8#qGNq!c4^X)eAn+yE^PYsBZ<9Mzly<5i{I0nd#(RY zR3pjW%pY8F30i3m+;?yvpWV8xfpfS^IDT5Yvsx159WqASuroMt;Y5>k(rqX+L;d&S zD)`DTKeqBZXqW2hEkc-eAzLUcZURIzdDh*}pFN}Jy0;!5)k@KZJpg&Iu=l~k{y=SM zUt~VjGL#9A2+4!h6qk~E=9SEHdz%q@C@tFqAvlyX@mh@1M*&8~5!9+p@_gRCNFTs@ zyZzv1i(VMBy9vz|na$u{u9lE^hV~@$*kWg^)*y*@fSiga<2kw663?JgsK=1X75zB#B;8#kaDT z!W?PqZO7BHp-YhtUydW1-4%sS6ldq*8PP^-MAiUWB@lA)j>4G-Mm<<^zb`cf{A+}6 z=`AsTU%J>%Y1uwNw!@#22gAp&`UkF9Q?o=1Bi65Z2II<8iA#67$8d%wTh3!GXTIeN zZJ`T&BSa(oycp97vIJlcR~6wX65kcR#h0g^ch#ZB@v zHz{QtY99}f3Jq9JM{)}Kj2V!#!-#S!Y+5d=dQj+^CkfS{dw-ML%L5$Shsjb+ZuHOD z_;1e`XIOJsvKdjooi_wQBj?p%i57+V*<9H~Wk|ZZB`&^k$4iH>FZW^MW9e@RyFJ~> zNM5o+5Yg{Ti4w~=%|G~FYLnFTa%vnt$!eiM;!;V5X?dE?G1J6cPPjG5RVH0g_syca zZAm@Z0IFZ8`x+__xPbB;0m@jk1evhf=V2SL;UE=dAd7^Kom-^e6`G_kBJL{NR+ASy zvcz=6T16+`rAxA4iBm!(JOcduu@$^hW53H2D(d6w6-e&!x=pQ#QxO(x^4dUlW2TEr zRa{sujIpC&bM4>bHnISTG{`qQpEVEd8sFJVu)5-c8N%`^;}u0B+P$4mD>@0oIoyYH ze9ivy;Ue?9YsHWC#-~YzMZP#dXcy-MIg}V)8_!*lq&fvEwdwFqEcq7walPe20h49I zq$!y;CDWmh8TM)~BRtqc3I6+>NX84&ZW3_j`0qXls+qh70ZFI6vnxNHPe@li@;FQD zi+V$g6L(n5q);aubd_W3CIkt|?`C`sjOkGA?sWgbq09O2s9l&$cuQ`fuxi%#F?5eP zZkPdr=YQPB`WLVwys$Rf;P=oswEt(A6RzrnM*<;>!y7MZK7A_K0+sIHdTYgX;G2MH?^lb?KN!X;Mt#g1S5{6RJp+u3>vG z^>a2zNP_wj;u2ulMclB^8Oa|OpNLVFv|?KRa4zbMn@ zOexmOGoCxXsIHv}cm8bF?8#24YUydpKREK=+vcT-=GdJ}E!bqY3WbXN8`0AVk7LPN zI65D0XAqn}XVU3xGnLYk&n}Z{yo$yTzLJ1%)?(mVo;?)l#@@G*Jf!=^Akx+j0G5pcD$jm&?8J0pEw0W(=CwMr($->=K;U@dU! zVh-))#b#?+mciIG(U5!;PK`zT-+#I{77L^g$(?OYy0CuZc!at1CjNJBjk5KW$gvI# z5QQV~Xr1`6M#X_jyopJ`gQU9iOUdpi310sIAFl|Wb*nH^>J#^!&Z}#Sc`puWb2zh- zAehCjMrnY(DrU{+Ho9^4!sCoqI3P=GX3+3VsHDj{o7r#iVBq*5V2ec(Ka+9eNU($! z*sgAux>a9AZq{2Q(>uKVmUT8rt+Cv zn*bU3`woTOWAV*b(a;Qv*z7@J0rqTY=II~ZZWqV~=_b;VLHIpT+ezRS?F24EmfNuy zhu%xL*pWjC{4i9vd(rYrrI2tjJuP;e?tKae`iBKvtn`yFz??`5#pCq!{*SDu3B7@!rE`WvK4p3s^3i#WHiLVaLRiJO5A!Hr}TZub}6a>)V)=)z6 zz)2Ws#iYr)Vl5E3&cnR5yIcH?45~f>wFkn_{*inGhWV%F#>8n}NI37TuZgpmn%vtx`rP5*(-?b%Y~8ESWMsPs66uIzM)ccr%4%C3F;gd+hIg z@o_!DT5(et>o!iq)GU}ZRi8pE_%nwXW^uAY!4sYzf;<_`9dXVEiFD0O=#Pu~E?KZnZc-I?D!a)53_6`;+ zRWOZe11<%4IgHL_wYb6$*{-i%qZa!ADl@RGBM+N-i;mR*I)i-6x0e2z$n1Bg`s4APgR5Uv5drDm`2I%x!*5cL^oBU+Y)Lb+E#6axV-FzX}7 zbR*cl4D5BHaViD%g(QmP`uYMdbF2uR9 z)ewKP`Tg$u+@tKx*`{*jt|VX*Jaj|6`;f&0VFB>_11+Nj77-oQVaB+& z`EC0RO*seDO)P9myFh%QRkqQ zz+V3b{EnzM>Ilo)LgFlzF{h<>V5s{cmwI-L6ZV?K z>UO^_DQ&zpsVC{{8ipJV!LbaFL-w;?%04~i$ii%+zLWHb0m@G0vdTZ^31ZQpL zoFilUHIxf}>N@eYj|xPtBbYf|CSBzMA~+NRAzmFJ2YY>c3LkKGc897W#=V}iKHueK zG4=rH%k?%337z<5QnCNm+^;Wy29FIy;*p@$fBNN1+pS| zw)o@wIOOF^Z%^Z8r8@5q2JqxblwYrxKg65gBE)nOl%8IsKCQjnvzPOv7t5Szw-@S( z08;^158YV9j8#ty2w|%&UF)(sZn0g{TKoCLii{Gm&4&tKBLOCjbNp_8`kOCcf=0wd z;MxX75PV`Eo8 z_T{&yNCWokCRIFqXCXSh=ln|wxqd3P8!vvk40kO$I84GsEd}k5wJo!H=ZW_3jhBCl zVTodME2#B7t;VbK8NX)Bk=miiyU_7})P09L)_?oHy|c4tWJFnIWs8tPgqB^}S=DXt zRYbHzMrkXnL7CZQrGd!IifnGOe&_r1eE*5xb96k%;S;*=_x&2zbzbN2R*Y#+PfNR- zMdPIxL)pTW5a)kuXHxk7Ao3+vtz>LtfUR?8;_Ld2sN$kTD4+OI(^pbkap{K@Jc)an zpv@X>=xQ_QS?;&+NsB%s;{aJZ^KuCpi2k_P@fw4=Vx}DWmf>rQ6uZMjD%vZkC2VSz zPbj!4r<~<*)BX1)LDCdvtHdlXzFzuxdJ~33MBD_>36%5z`)v;h^!wv*vd~@o*25Lu-=)@~w zw052QM;52pD)nS!*nWT|j%S+@*-f}Mo$zNA_pSM>61-YUUF@9@@xXFD;&h@vhF70X zTRWX424he7bh#1^c6WEbj+Q+17*U}%Z=iR?;kd6?zY?xvuA{Rn;GyFZmfLRXX8@Di zy`q8H^lTz`_kMDgxD-k|Pivi*G<~3@xtYaJT>6S4AHu)D&g;yY?@?>KaQd6;42@tM zw@VGAR+x|2eqDuOKs$^Qq*H=YrA;qyoO8yU&#Z->xwJr_MHb@OkUdy8C1l^+O-)!M%|#C#*t7nxGvo1QQw8Gd@m!@#-C z$9Hl2Uqfl(o%J_%Y-aMmwv28>ajO^7zOhF3?Hf2;+8UXNsfzJGRjy>IfY8h=H#vWn zr+hWB42cP91U*8uoj~Uw%gOT*?7YCn56vrGN@Exf1YpM31Z9747fmIkTy~l}t ztmev=qvh)hxeM@i7ht)X?}Jr<&tw}|s~8WrZQY2NObo9)G49U77L=e*=P#U{@W2W< z$J;`i9e1Fsd08$0{h!!8mNs8`l&^cj1Cn+uU&?^CZrppE%@BFYo$&&_PFTFuKy+`L zx*Z6r1i+5#6&~~F$pOOQigu+Ac9_!=dVa_BTi*)6FJEB@j|viT^CwXYhu=x$xhHeM{bfJ%0vtU3Dk&u?BqwX-fJN-`TKVjbO=*mZ5wn&mps||W+zfcM$ z)niM3U0UrQ*8irYmRYj+S5~>T9TE=y5jCZ686PdHMf2IOPx#+mt@dffsih+Y2L@Lr zkIzl-ulwNSKN&s}<`l*5QttQk=7M2I0<(9E0J+hrd`DS7b<2LftA6Zd+}lUE9>S*T zdabil#H9M52<>k}nZZ2rhp0Oom|=>WT$JV?WR2GiPxD^n zYZ+;&Tq>*7ui!EcCK)z4wnY1`ibM~Ft73ymU(q&F8%P-mt8H-2BgbH zGuX-<75@ZHCGNg`DYsp4?DDW^V>$0hA9)^?i@!$7|0Uf~WCn}pRzdZ?$C=cdIBQ*Z zRX3D8iQ$cT!sKHv@;2d3L2>N9ftULP#wK>H#|@@86p0;1gN*PFAQ%8@HoM$)3s_$s zQJwnz8(a1dY6tM%AWF~odcok#%A30Vzswtc&U}>G27Z`nm7Jy#lwUe9@;vaFLgDDh z1GonR8%N8BSuptgB4b8~jc=@)>Evu&0K`(`Ojr=16mlq5SPBmb`y4`LnB~h#Z9v&m zlRXHfeo{`F63_1C$BFDSi+4qH<2t9{p9-s^wv5$=j8p1DXIxzkp}lM!OHw-LO{5Eg!eJKh-C;cq}w1yiW?C7EYyiuk7DXfw|q(j2YN)6emtvHHx^ zqFdT7#cizjZhUx2nN@`8ms`jGML;Q%hm0CR7i&L(Xnp(kZOP-8Zdch;Y{vTJamlj0 zX{XxnL6SUwt8~B2AA~#1_Msdyfw%Xj{_=99@mdY$r2q`3af&dk88-^?v6z|*)e zu>wi&g)!2R3dRy_htEurO2QrSoUb zn88s_G;sa~3flh?^SbyCviH37k-dp717+xbSp;p#A$uM=d~^tl4#W3+p2DsZzAm_v zF?J)Ai5~Nw4JbE=HqK_7EPIi;W0oG{m~F+`^**>vBB$_K?^MD!^B`~$m1^>*OAYoW z8ia)FMMSqkwUKgcuQUI)tNQbmcOy)8HJ2=wSA7n^xSFd1HSfpV#8)(|Zzeg2*@y9uS%o+~b=kB^ygq9IQhhhG z2nX4uoR+~k!t^PN#@Nz_@|E4DcbqGt*+g-WKR>qPEGEMD=wIgMruNaVKN4s5kKFkj zm*6NNOu!?@kN}LAok9+mc1y%3Yq-9o4-aj6=JVb4ezDUl2qFF&Hh;z>7Va{QOVpGa z8X8K6^MT&Lh5;`B7;GKgcV?<1#4>YKsrjitt3<||8Moi2bk7dUI0y-7onUA9y~W?S z&7`XrWd|4l1P$pQ{%LL&y7QZ|Uj)h>k9_Shucw(PJIeC$oVw4qTYGb-S0g?w=?HN7 z(zM!XZh zY?_^wdTZ3spU&YyCSgOm7HSio%JD4O^iZ;gp0B6^I|b_vHs^}gTd$Z{d<|I1&1wFl zKg-!DwXV}SAJcE0%i_^Gs%6azvWj86&dt95b3X+2o3#CwZkArR8`hS$uoR4D!tC%8 zrovvoi$y1lSPm(~t?~=86~~n?mGv&@ylOg}W{Y^gu;>bm55DGcVV7v-F|9#|5fShVG5ey;k% zG{cr_cYT&x;}S$y9$0oiX<6^PSa0*^bl$57F?-jEr6u0{pN}GjJn}r7fpTK&XG`^N zigA%Xcj~F4wj=}eqb-=bw;5U5mbxejcwnGQx z+k#^8=8OYRUJgmu(>k!VKXQ{J8{{Kx`-i{})&6+!pFyL0VbKzjM-m>>WJy@ zB^Pd)nd>{SK*idP!VM*?hMXJi^7Khm*!Y@%wBD|T_Ceq{!E?q)QsVTtE#zko-ws(w za$-V;Pqcuq9iMg0rBfR1;|n$3H>9|GrfJ+p%7Zsx-#5ZAKX|=+ zK!r~PK~kt#ZSlL7IOVP0t77%3AB@~2(J zy^yXFak|QdIE7CZY9vwWbHqb-7MO{T_}1>4KkmYiH!V!}SKXizocMf&gDl10^Wwx* zg$tzR2)QHVNj1voPZ@)+wk_pV;`jvY7yp4mPJmWr@=z8#REXey5^ra0|7!fmo~H?h zLyZaK-_z4~6>=L(-xtW*3I>>A^l`~1@e0gxcIO6bt z;hD}`&%k#rxiYuPWhJ%G2OKpQ-o z25&+6Ge#6%H7>;P0Cxv)I$WjTkZ(05yf`s^*tEaG1V;0=OY}SFpMA|Pw2Fvbm^0~D zk2tXT3rH5M##?S!!d29e@zj0aI=&{<=qT#nb-~8-y2jhGN|st9aQHz=n@I_H%+#LZ zgVYWylfejzoZuYSfzH9a8+Lgh*4?WmJ<#D15=@UJD=H+?-sUujy~!QJSaCRgjG^KB zk|;a-GbWLr^Q~K2BBN^tJX(tvmoDjVenst7XBZtn#(Y3gQ9a)gF~^*6w!>j>msV;>f(h=yU;F1?Sp|W(^Mktc z@5opG(t0Y#gF-3&;(o6dcEt2Xch^6i@eX-6*=xZUadvqZIZyrUq@iiH>%&y7Xy$4^ zElI8B53^pU|7)yYy1w|XoPYoW{@Cb%diY-}a%5|GIdQO_TLRrOXP)u?&MH2K8$w%Rl(Kx^2u%^=xCIp0*5X;?c+k5>Op1nnEJCV2jYxDB5Owd-+M7T*g&KNy*NodV7n z=>35(+cp}C&BN{b_I>mEVpU?e>SQh1O+@{Nb6kXQE`hrCysK26ZQn0y%LA6&F(gbS z?}2Oc=-`)Yyb5uh+6^7Qe%=DQgl~wPH!aZ30?!2D#hR||^ezWgFR;i`TfA)=VQEV1C z5m+h_N*U{1QT%A-e(p(4)L~|xq(J*jJwN*f`?D=wQJ2V^lt<&Q2lYl^{j2&pGsSnaYAEbYCDj44u&qcO!jhAU4Go6C95geu=DtqZA zMtcs-;9ZQdd$tf`njQ6Q)O}A1Hu% zRhr?)CgamWZy21PP-3@#$h640?L-u9zE?p=N!FNYGUP?gb(c7~a$n}Lc*H~>vSJBZ zx_eZHTbUV+@pY0UgGL6^@b+GG*OH80tcOpjGS$*%>@A|C^c`(AtP%P6J5PDFymarN zvv12%-NU-DY)#IYHB)*TW{V<&8&q;h-eXzap7t$;H#mMaikFWpTM5aW8TggdcyGa& z%iw!(M)X(3W(<}NcScZ@@Wxy*zR||(i_)!ll|g$8QR75iHXsF+O9#e`A5Rf#J9L>sVd|N8da-CTL)x_& zk52XS2=y&=EVYU)-ojz$glx%S?VlN5)iG;ObAMiI`^6?n>0Wb(clg)}XHkIk$~E<} zXuHxZ+Fq(xiEO&dmJgzRwFLz`N+7-footdrd!6nv!}R~y4Qy0#VhvvY`HiKKAL$-eFlQ|E?v*w7+M1%+C#ZwK0wNNi=Dd0< z(z8r1!^NL&p%x^9pc`{tV?Od~!uvF#_Soso&l|#^q?+wsJ0N^eKDtU1gC(5B*u6xG z9b||oO4|?qTWBv|fAgyyhy;!>VzMdx`7TDT=WcIH-?9-c3li9QosQRyjzH}ma5usT z?)k;b4|EcH3>ajh7b# z_Yp#LZiJA-uLF&R+y$ymZ}1b*sYnfmq-oHr?|{)2o*uZ9n7O{4#1G;E@>^ZXPipvG zUu>k$m1^|NNs&a`JLWTwZpqb+>&WlkiV5=Mudf*EB4ZidI$_EhzMM-vc|v!ojF(Th z`-9pd?!Is5REaP{^5GZXC)OMuD|?tprdZdddDDsMTaQMu3oeh#w0Q2h+%0RkKJQn` zQO4IyU6PJ#F^=zC#F@^sI*n@3OJ{!v?x3=$e^QDdvZ_*s`6?Ef?*`AQR)_2hx!Gizk`FTExIt<7J=$bLp$;s~%c*ov8A8#ai_y%K(16h(!RZ4O9 zlp&>`ftWdwFLdn?Gzm~PnG(+ma`3;Vj~&|%{prK|Lo8D^fMZCapvw95+>K+-*}*sI)lG6u;{_e?KiPPKfSDdW&V@J)74KQw5m}c_(oPg7>->zZRBs zV}}NnjN{dNCU+Dw%FCpWdG<~VnzU0EQ(n#R;YKELK`}z&2v>9ngV5a~dp*8pH>Rs7 z{*fpOWCw-vm24&+e>ijc?a8uc6ER}>L-n)ov$zU9Nw)2j?2)ps(MbV6DC_GHAL7N) z+kYbp_iGGmzT?!GnXqQ16NR+`3~Z`PK9P;~jL(ZQNC#;9mYc({LMPGn;Lsz2Y{#d*G4>KR@mX$-0?Kt79IKn^BxK-F@+Rb7!)mLW0 z$t;OHA8Dt|1aH1-iweA|=+7z9ZP+$_QC&CvGiBUg#=Gj?1ksT9#`-4_vGmC*u2I>^ zSd~F5Iybgn>IV#4s-{fc!}CloS*x>V?tn1O^6EGrm+U+|dQA&h511$V+$yVzdg!n{ zc|e**F2`Q}xxM^Psa)F^be%{*{cK2Y1~B3WUeo(upZ%&653NR#jcMDRDLW+@a{Nj! zEPp5M$3OpRA-@yjR{pKkFVRuQSB^F8OU$>lXV`Dzm&|J7DWlKA7+k?I`n%WcVT8=5 z{;-{j3OZ#CD!%G`Q+KEfa2tL6n4F`S$gW5lN4d%q29(k2$yX}`QiO5c9KE@t-<)P! zEwzXQ87^}>)zs8nv%|AfBXT9^f8Losp$kMwB`KgX0fvL98*%?g%4=0&H&Ugg z`O`3*VyLQnE3R+aR_NX$d3>mPgQ* zVhP((LTkt!@9@@Q&2HllA>|weAHw+YJ+~!RcRtSF$$PhOeBLI0Y%rdig(*>#Z>oH` z=_276h(lW<8Ki&atv1^>Gm~4tu+u7HRyNM-&D>2~hk?l930f@7fN9N&TOi{Qg{lAg zwJXP*esa|kCPTS57Dg|BAaE}*-X=>UtFLp?~S>`f%)lVcTAeNqk+j=MlZAd(8GE%|!l>s*<7G#{7SujwnM zQY(Z-#Xk3DV|5{-SHc;%cTs>}4U}#`P9Q>JcBb@=U+0@7aGd5%-^Sq!ekfI_x0=#K zKvlLHy_KvW}Gkw};^DmbM2yg5~| zJx?*#+GT-bs!nij5A%Rmg}IO<+ZPK>nbDTvIv`(nd_xb*o|d$Yj~q*BSWR6P$`D-F zAwZG{?h?LWUn<_>_YvAAzSUKG7%OV(hrAy5Nyf`O@npO2kzhgntbH7%a2}N?!zH$B z2Q=BE7;YhIG5Ru?i*KeKB;?N-2$VWp%r0i7OUmX*=sW(sOYB$wUr$z))Pz-|L8M02 z-5Dj4md%-?E9)(M_3Ot5JE>L*9gy|%N!%Z_0zxJV$|IV$f7i;FmAI;iY+mpW~mDUWTEn=*4XWEXMB$E!&h^$gJoa}Bqf zNPR4(P@D^^wc6J{kyM^hMG8}$bI0I7cyBcE5wyCGAtHtm1Dv=CN|slt)b?647fn_@MqS3r7CIz*bOzLUaR z(vOz_QWD2NR&;-$RDNW9SZqq>JU%2G^6%f2+EX=HQa9zxR@z%YDGL(eKnvR=0HxfPS(jOKN4; zDXueDMe`=Ir7>zgHN9if3{f#?VTfySrR_tomXs;(a*s`w~2pZ!OwPAyt9E?5D*p>-C7I zH%-mxiN$y%cKpUq0~91GW}T%zwCX6^aTWa4h>axL1!5|Cmgl1|kD}mhb%~E#5tj-! zH41ewk6$+*%rmvxk{CMb^4nRiEIN!!$H790ms|TIbNE+(7lxj3%TXD}IIC7EKLL5< z55ry^@6!){dqHdCj=;+gvH&@M2YQ}O=W*C%Ca z#xmp&m^tV!C+k{iiL|44Ay8Cwv6ioV#ttFU8;3ET=F#&s>AQHY9lr4Z00+i}*OCox z16sm?WC`Iiv~h2mhr9@$A!lrLj53ZYf^>{LKh#acbTtyv&;hl)1^V!PZ`IgU&UTI; zS8h;BvwY1rxc0QU?Kjm@9gCT28FL}wuoMtO;-#Ij@|9A%oX0D zk|8Lqa8Q2ld*wWPe?NI^j%@<*Fi@}T$hH5~b1K!R@2=TEkgC!aP z{exzS^V3r+09i^&?#&}}x35>Ls3c76rg_MgOo~Y%yL9($_G`PVYnOI{CPDJ-D{9JC z!OeVINTJ6vf+b`$F19Oa4TM{5HO06@%fK=o6ZxqO6h%ZB9a6Gj$bisnJ}#Zqrk^^G z^$6?u`|cZRVzZz~{>=oV{m=#I?rvXTu6*4-4x8{Jm9izi+|2&IFxo$;pk&fF=#=JC zg87!5&$qu0Z=WnaJ1(QbBHLVbi8RXnDU5xj>Kq>_;@i`^9cSJUL4CAtimaUqe9kr< zuoEC0%AeV^IeB!xro9lKYen^Gpy6Q-Uuaq@mgY>l<@OIHckX!{Gu}9A=W=F@(U)4MO+HlP5t- zL(&fX^(9SFqH1bs*`Ppua|A{^)>vRfdOA@MptmP*#M&8*ozUb12nVwG(smz~BEAHr z4ulbm{P6$i`=ND%wLK^``12#jAqnU(0BFL62RIAP5fIlfts+FzgrZD_8?is3h&LxN zZNgh<$Bu1ad=W4Of)5DFGLgXxW%ogRCkl3e%9s=qa4BkiB3smKEBFkiN$dY|H~tCc z>O;?*0e%Et4GKQICA@k3uZ_qgLXr*83seH&7C-HsdeJ*2$IbvlwKMS9z)Q!Q>7O2Y zdrCF+jB4ti1wT-5fIVA5Vh))hq3nPsGkzGl4T2K`6^FXe)$1jL_kD5Apkf8MBZ(oS zNfMMuXd1#QGtuuLzXlCHJW+sl;v4W^z-$KveKS)eH;cp12LQ5>ZwVqE5+6_!02{); z{gxgmHD;kizm$*w=;IZLGUxyx4(OfRUst|C-XKyj5y=eUINl#VSx~|V(hx?vz>+bF zzzYBwvQOK&&w6^Zj=&il5HXh#H;{! z7-3b8(HC$Bg4=w5Dqt^&ZYTpW2|S49f#Vv1G$_uoieNy33;Gd0Su`xTlL0hz*`bOg zz7-Lz;HCfPf2a5q5I3BG<&bBsus)zLA1=D8hh>UUF)Z4NS0B8VyKzW&eI{Wu3mue~ z$j$ja=0n_mc=rDr*y2~4w%tJ#V0?RD`Rbhw7xGG{d&U@?px~ah7PN78C2L#**m9Lt=7d z4tgM{>e#o$9~vq`Mv7IL+ir~)fKnRE4m$)<2a=`$-iYxiR3RYW1JK7JyVc-^2Z-vH z_;_GPk7Yo3)kE%pdLEne?c=n+_|)(>*g<0h0|wyE0%ye1!uSL$6X2d7Xw6tiD0v8@ zWBdZbUw{ZaMMr-zXiji#_D;DCRsuFAyqmG+n}WC9Y9p7Cwb#CguH9&8#dPJ&o9Dr+ zb-~}zq~f#z&jKIpgouA>Iu0Q$RjeS%u_wA~V|e4S-2a-2gw(bVZS>L`%x8RMprP83 zpE?^5*E^_7UR!KgTVJ=R-QZoU+pw$K7}HrEdCRlWJ-PRuC6S6?dJxmS@j@^p_*f7r zaY~U7X?y#U@cZ$)AP>O4#6~=V7~?UWxZ6P7~Cp4OPhpotCyUZzc}o#Y?8#={oZUp}H^O*@4vwoE8fR z6bme^IWcr!-^P5nkm$nq9%NY{g|=|9MmMRzRt@e$ z!}@dYaO?Uz4FAX_qXvJE5O=%g_j|T*U<>27f&n2XlJEiRav8-sPKdV`@t|?&y;SfHLhpsAgYAc1hs{RJLYpD!I|%C`6pzao zXyTj&75FY`6Gk_ZL?#AaHi#$^r)a{pTPWiDx>XY3L71*||9~8lHpxg62JK@vHS|S` zlK!E)5P^3HS&qvmFQA*jXN-|qmL|NN+4o!4z$fE>3Dr22<1!hro$&`pEp7)~V>s}U zvx&oyIPA$Q#04qIiDQ(QIDYu`c6?>3_|-0Onz2s+XyZbQV(_b05QqnB6V|M$jo6L& zF??)EJ6ZzpB$0XwTXyg#@cBY>H^2B7u8-S^Go|Z14xhQ(8q{q=zF;^xe&q+Puvths zOye*Z0@%yAvQ)597wWK0-j;QreewMuhy=b3DoWVgm{Dbk2L($en|4_*_^loJ;j|_4 zdXg)JH*gw+rC@rD2iqC1+=&|xcQO7SgHHf1wm5fju~uHkd&T8~?Tp=x+}7KYM@bR; zH1EG%APprdrAm^844Ou9yX;L$rwMh>f*-Ffsvs~r+6NpR($J)cYhTp zCMS^+&6ifw4~Ud5zqzSNHo3uGhQie?sgiE&@&{Z;bf!q04Sx<76&63q?usMR!a~OD z&HrZa%P|2PDtpsW(SJhF#R+ zEA5sr=wMFALcl-;#KHeei^0Npk`eUW5&n`=A&QoYMeK15*CDt874nD)lXxvZXhx{} zrKVL<;s|veVk6>aiQGm)bAavqx~%NgNJ|D9G&p?!)WHQpjC0WR;A!iVv7jEaivsP( zKX)%lx&$|6xzygW20a}_xf2{FC}l5Rv;Z~qt+XQ3S`hYAI}R8et52A6eVTIOl?_X#obkYk0HO$r_|K*ld;qHZe*A`AUU=ZFSB_ZcPKX?A|-00fq@68O3o#~GkUbIuY#q> zv=-mgbX4;`LW_T(@JDra?gBB08DIEz;T-{kwP<6afU_M30LCg9Yv4BRN@Ww(`6jwC zBl_a|nX%xFsg0Ke-YDgNnELlSwl@Xs*qo>ZQJQGP;;iLy(8g>2A5Wh6AvrWYAY5RH z+Tv6qx{&hK&*e7gPC+{wdybap48+7($EfR2T44V@7Q}`6KjGm6++%R+N%oG2lDl;k zF2}hiHbL5YF5qG$PEPBIB=ft=OY-Sr`Cri(rgQNq_w4>O3kTDj@A#UDj`p`}k$qPW zXWa+DQr20Piq{Ub#kg0w<3v1PfHS%9a;db@>f5fr@Eo%z;+*J(<$yu#jNRk1C)Ri0 zWGZU}7rAQqq#@Z)8y5;HAVXu4ZF+gv-{-$B92L5{eC}P>@UNw!OUMp;)K_Xvm+p;* z_rLUvFfiV52<(mH3l^2x8SL0IchgvWN6_BxMBmz#>2Uw*LFCn8WfPbCpFe-xm@}>B zL7nJWK#n1*OMdB|)Zx~Lqa1sJ*s7SFCc#_66Zt#WBQqUEQGRi!z}t(lye>4P*Axk< zybfe1MN9mvL^0fS5}zaCvDoE0!Prc!9YU;prP&F0!;U-FIHc8uROe%~$F)Z15JwGxa5)s!U4?$(@&fVK`A&khbJOU_ zSN<6>rT6L?_}r2jx#H^vH9-=Tlt!J20V1?ZCC6N5>%T*R2uTx>O@c*_jiutvQ#yc< zTd60nn72Orer9nB5jO>oF=Tl1=+}jW3CD{a;b%OeZtO)Vi(LTycV2OwrO{~#!4m8K zFUmje2aXHV{_gZpx5=`!#Gh@q5ag-KEd>LAFvdY4Q1-Qk+klUc8^flk%V3A>WSRN^ zvCWyLLf0J9FJ&-9AByb>xp|md3YyQ4Vw$Soixwieg%62LVg$)Re4PkbSz7V$%N?vPd3tPCn=8WwX`D{M?Qgsn? zvom1lTS#Wj3`mz?XW*;6q%MShLvV(3D$ySrkyk>qFh z(?88{V`u9AuHa1f9srR5|Pia#2HdNmls5GdO1z++NTXOzj*l?-V$M6CI5}{^wBVT6%g` z{c&wF?mGB`f%hWA&VW*J58{G`XYxDN{N`d!6V0yf5#H7Sw{Ivh=42UMP>dkxQ<{r52|~lW6rRkyD_q1141^z zcv4eChq>_gV(?MXprtGvZm=U{3EN}8TjUmARm1kWe^&n{lotP@WWtRG9S`UnjV2l>Mv+uv5jPc6<09ew9MCIzD+otWHzyy( zA@v@Kw)keHoc?2ZbSSy<+3BycZH+xh=;pA8Ty9-YJhMRpBp(N3`=M9*MwIm7PjS6NO;@{d;{9+ zkEuF4L95w*vkf|$<^w#e@<9dZ|H;kR&iiFGZu$3(N%Ux4*KAlFSE%J4*sc!PgY1>F zZ%UkMpKnVoS8<64sA}QzY^o5-Q5{lYA zvzJI?*xWy;vZ4k)DlaI$N*I|r7qow=bfba%FemU+YIKQK_vd>9`YTg2x@&0?6hKIP zJ9_LXuDa*?jvsv=_O-;BabRFd*o1%Fw=ML_XsiXPS0sP-DR++$d0d+=CJ2p0jBX+` z_QQ5_qf<08AoVU^+VWEB&gT@*YoV6%Ji8F6jS`D*=hc251{&PT@pB%4t6WUk@tRB%y0W~pTF zQjt!c+F7!FEs`Bgb&osHdi(}h_Sl$m*z0m8^ z;WlR}2f_6jzfJVcTAUgZpV56_4H_2qsd)RFIVur&s zVqqP1PuHf8(GLHrdeQTcTrRr7sPCN#Za-DCiijT&(EoAn|Mv39s)w^&6mohE{aM!~-wUn$A9qX` zS%itO(4l!*Jg$B&^OKBUK^{uP`zi$@IHmqpfUNc|ZUyG-`_4wfj zxCnqj0%(IHe$M`bdM4NUuaLg#2#52|=nda*U%FSi&vUNFv!K67dEsg~96BN11s$7p z6#WVgY#2-s{$zN@2-h8RT)h^Yg>EExDLS|n4{7t|r9#~m6^!=R792N-(^c8PV6MHq zd6!dWrs5yqs_}_6$6j}x=aSKB!ZNvgV@&(PN1KVGajGtt#0(r{y|&*J@a#YhA-Bj4 zY9Yo$>=U?XbylYhafp3*;*k4W@8^A{fQsD%(ZZ3*GQv&Q~+3SL|7QM)ql|g zG;Oz9%P~Q`S~F1XJym*yg{k~b!)->ISM@RJCV#%jU7X&M#vegl=h_E)c^kk|AdN(j zIOaxZu166Y3q%AkV6D`MA7Bf>8%`@&x9FRJydc^PQMk;PN{~N4nZi33)1x7ldJ+?) z^seZ}rPv&k|55>kd}}Xi-sOtpSh7yL6lWR}QZdoCS^sw91FQ)ppG2#R_F0xQUTfar zEMB#GVq%(_9<`GGmB36Yhq`9=3+jHq5WuU+vcvH z$%U&|;tHRX(#O`(JF}^?{tl_?a}ILar7B~|PR$U_$J0YWa|;k0d*>z6NZaP_asGZ1 zYekvJ`aFGTuYYJ?WM;;==g{Zr@;S@#4`K^5y`|&5I`0S?EOn=0HgILs5Wtssj6*pb zVBz=2*wZg&{Ww{Btk0ia1ace`JHBUP)tH+&%gFEUDhsr+RhimE8%v%DcXET&zZ^#GRFC=mZTpr0TcfYY&d;pc^aQQ%l7Q{p#td zz8}RG4eZ;h`OHRVN(c$=E(YM*ybZk3_i0SrMg%7r+1 z(|YCIKHm_&K%r~?6um~yTP-ROuyd+TRJRXMMZWHrcnqs$l>kAb z1|qZ)uPU7~QS5$rf-;}z3=cl*SkZ{>L zdteOU_#q6f}Uztozz9GWR%ymxt$E!qn6hBFd{XjZJM2AYGN1mZ4us z_A&joWlA0DQhWI$3=yPBpdkFE+43$OTUvpByfRAkl?YvWE*+uVTT&NI+4&+px6%PF z$+kCXbBi2u1*0q4_rp+4;>0zjs{z7PLTqhyeO*iJo1%VTP;z4lyBfm`d0HQJp+ATb z;c3TA<{NgqI6FKd%T;Wzf2CYz_3>&8Jti(>)-RhNZ=yVu+A^|NIXECLW$NSII;W%^ z3kOhmKM<6BkK#Na0XhO2ts--eTpWj4;%KEmeR|t<-mn^FaHRF4eQv01WN(>01N#jc zU+(wve~&z~!I+JR7)9C6EF9KTFsbvaJy{VS)xl@q-bAEhg_JP~(f3vzws%P~&r+$Z zerbH6_6C)uGO$yCR=C>pA}Kym4xqxl2mB5V1%U{GAN?akTGvyr;qTV{F-`IBKCW0= zGBAuCtUzmaR=q^>L0obL%9-zt*K1tBGy*W4^h(Q0wd0bEPis8#_x2`;5L^$!&;y1> z6Ta+Q>=)2O$81f!P}08TG|iT|s*PW4aoc~?CV%I1Nb%2#HHvd_*`!|7GdDqAAuj7k z0rq;BsEBVa8AR2yyCmYcz4XOX$D&=_cWCX6D4x&DB>#!3dhv~CSm0r8@>8tL`RRT` zYZiv>W3I-an6klbE&=R zJCYi$YnX4l)ziCImroZdj(YA;)EgNdCS-FCKe3|%c}E$9#9bB$@BUf+U9n#a=*nvS z05K!J^XGc+`r^Bn(R7`xxPsY4v|8DMrm5vhX207xnkKzesTHqv!}PZJ7}29iB^UEl zw@T!@ZRjP2%Ut!Qz9-jUK%d5u#u}H1ET$C#&w_CPF{A??>#!NKADAVA`4x{@j<^uM z#LYdNLs|9Y>uI8$go_CD_GmhIy4)Qwxse?L4~wA@QVhZd&$P|XG4Mpz6G%@8oV5)T zjG)=%41!%4#hI58ptR-rAurak48<=3=CjTg9y5`0wORX5-;5mXH|`mvmFr<4sMH1F z3BUZjnAkHngs6=^iUXm1>(O0qccw)2L`6j#bvnGBMw-@qWgpX*WKK?(JRpwXwm%Ho}!K-yV2}b4YK+oFOR?;vxeP6~IMr)rcUXW-VPP2;+`{fAs zCiG!sarwNd1XEkC_AYiY(dGG_af%K|d`;U+WcvCuyU@lgo{%dB(6mQxpre#^bUc33 zk}*cCrAcR2(?H->%Ibd^3w3kzi9B(86av^;NRvRT#Fz&JWK2vY2zvWz*j&|HRnLgo zniNz~X1PEgo6kHDC^Lhl;qi!mdDZa>K&E6OHL%SaokJR;`YnrCUlXh1Qz!0w*m zL!#Sxza{4UzayUpJ@sG_Ty;H&w6$u)erks7vf#DfZ0Nynt>5wuKduFaRaCO`tFda7 zU~I#kB>A~`M6s#4`8g!VXuU@Ivo23*xUL>+7a$ocd}6w|{m$pZyOc{J!Iy{MZ|awk z@dI3+nPEo1lC)A+VN{>&tc2`~2uZVj|85qbsRFMrWoDdzrn&%Aw;TquEXzF0HVnJg z$1>JUacvEGbru|htY|0~$piQ#25@+e?e}Et`^*qbanZro+GN0!4_G2ne}1k3zk$f%EnS*|vVha`+*hye z&C*@HsG9n(>0*$?nDWZW3m2Lf1rO0+lF;KnrOm8?!J=VvzzKua<{8qYny}2V#XRXM zRyykNcb@7UBbc?gk#Y5c2(R?nYEfrD;z^D+oMft;F2iw+9&UW{j=9t(Bj=_t%F zY}({o8G;hWHY8dj=~diCAHwmG-=Gd^*{3YYI~ex*y=fin;|l0$ z_?>*77b=xl-q}H0i=i~8b)eTazOQ+)m?{S7Fu4I6J(a>h)`ixKWZ7nOBfLUytB4oL zs?|QI`aQnem*v~<#Z*p7ihVx~y({K)%HP7|)qHbD%xt`kI&^`FaLp#B7a!{I_%2P> zZGP_)t4v|!R}lM-Ge6Pya?ftomVI{lp96Gs4-S73^y{GpctoVK->`1G!8cxHKvwF< zl>j(@Q}mtU3`|sPoiCuE75ELN%8i2Lp1Hjy$LRTEG#(twSCG&YayWS+@yDK-3?LVO z_XS?P<#Wiew=gj9z2MXg6Z6HDFAw(;(5nU2U~)^P&4`E+&(l^TlTRZ#4}l3^CG3jM z-fKF!>HfnBDBNG)f3FR2)mJqt&cdNLJG;`Rz@#9~K#<`qqM@BW$S{uB z-G9?nY;d_CtWPli1l$9rP*=xtqy6rqJ(g1&#H7>9pF7#|0OTGcZx8#sLuin2IdVo0CbGrZyBa6J5Hr3 z{@WkT<|-x~aGQ%sTOj^tPq_P@XB|kjgW;hpUrFPi3XPfX^TWf#1lEK3G&&>z#~8nY z*8rf|J|;r>WsW{3_UMstgx@bUmr@CPj;i4(FAS1`+34(yFRLdJkg=WOZ826cMU8P0y^X^mDt^ch>&2t;ckr@*PU-^huJ^$W?F`=&>3 zyUJO1d-h?q^qbKcYud|qqLX|R5}LgB4_6fy_&)Y5GI}o(QzOB`XC(7{!_h<8_=oz$ zV8h{Zx!Q?MLL0kv-3K#7dHG6ut3KzfP5G5?uuQpYYX$uM!nLtmG-x{OjwwBPBIDPF zV9T#5jWH%w_ltA>i#coxO7tRM`Xa9+v^pnny;~%Qwe|ZmSUAZ$|Mq$nV6=Cjx8g~U z2YHWa^OIibsU*tsYiDQn*M4BJ*zg}7J^tvpMxD;Xf#Y5^y384(((_dB3VQUguh8Uo!C9UYbG2-Q zvejM!L$FeLRa4CWjeIFiH?s7K;7xa*@x zc8Klg@Krec?>*HpdrnTyDX@Mp5l7wqL%UvXj{=K5^TvHZW@cBn2$}fKw!0TvOVV0! zjwT*BKCzwcMxpLg+GaB4{V62-sg=EXbHX-1;lvCE=>I0Kl)pfWZ&5-QkuDj}eL+8S zrQrR#J5EgRzI}nih+Ji`qCtfZp&gz3$}|t{u8s^4&;0uAk@Q+p0uHS-Lsk1%pGOeN|UU3+YGGya5yrvlmwcye5+$F7QPuZTA9t?5`) z7UpjWOuv6W%6{<-&Oq=skqW>Hw(Xc0Oi9P`YyIKW3*jrzWMR#$IA-G26w%Jzj zHZa;2V5!auSu>-ix1e%nU22BhBHStW;pM3h2iHvmXJ$Hjhqe=AV))5#%sQ^`!w;=h z>8^(3W{C3{*iOn=nPA&Ix0mhQ&7Gb~8HS(M{#^}#S50jRD@GTV?qrhBR(Hi8`hqgt$T7iS=;eivxGaZmTla9& z1weeUq!>lbbbnsw=$`xbN^>Eu44JGwYI|cOJO4^FVUJ(9;U#M#|=&@0Z_+MbS zPUrpGyCU$D!fF(X4fqUUCf~KBG?*shbUBe%`Kn?crbkNO#~0pXm@wZTEqdnCrSGJz z)4LP*Vi&Twacib=3=EEnsat2iY~P9v zo9mYDQo9j0wW+;%b1A*MmKuw$gu75G8|wKMMEaayAw5m@pC&i?2ObkX)ohpU;yQa= zM(ySkcliXv77^CPHy@<=9ZY>Mrt~IktR45>^gFU(CPOg#dEMrRqU+1rDd&aE++GE! zQjq&yhtjKuJD)QkRefsAN7Gn+Zedf;rIsls!GN#*{S`AK3t21)wj|Px z90y4hTA~J;H%$0mYltj5H3y9DZ8N#Bv!(K%M^I;Onz%(b_4nD4pN@5oqS^7K3a4rA zmA%?E-9EP={h0YRV;XDNM?QD5Ya(Y^m1*M6wu*3#`P0`(=Yy`_6?A+N-lC!w@I$V` zb9p3q|7V2=`(ZQnbxwC=C!%LM#SOwYsA4^{yR#n=)O?T&^yApz)!$ z@C8o_HuD0C+>~>Z)+?+wuXObA&F4Xu+T{&vGS94qHkHtpuPvQ7w2plHEJb9n^6$RO zh~?AzKTk@-S9q>?-CA_ykqO3_Ml&#jk3S4*bz-RrPa zw_#U+Ky5}qEP~R+!p%0l*E|^^F_xO7PC@>Z^h-E}Il|op;{_HY*h#)XVpCxc~_FYYY*>L)&$)U;@09Wzntc#$N0gmFRzChed_rDr*=O|T! zXKF&-umNhn&5seHTkVi+1|CeXcM(bf`f-VZd?bkv6>h9_xCg#>5*Qt2;_XwTiV4H9 z+EgHh0#M+F@4^XlYXjMJj9KvQfZaG%|a6&T)rHFx(bu#_YQ8By454;<`K%oWs z96+{aLIvaFlpJ7~=|GWmIQCgP=k)mW!DRsbpAC83S83eq zs8Fm!b0J0fxj9maX6_$(zPT}gjK6+Od%kFKk>cgAb|!{M`SR_S|?|yL_b2FCIs0 zo8F1L>Mm%tS<=wOb=Uxx(vWb#v9{mwVoFlpEj;zOlga$V|AUr^iGc+AbDS9PzdewPKcLf@Ggd7V} z=GobtOnDzfmIYrM+&S&8PdO}sgd9zO=k{%rD=E|XQ_lA-ED+*PzUGc}D8v5e_;^GI z^Qv$8TBgqP7A<^R!s9@EJdFt5F`%?S8qZ@)L183?6>g>H%gfMO#N0cB&8gF{LLSPhG1*t?L61(Wd?WDf8-2 zes}$QiB_4~@TiIrnwXhTyyr@GK2Tw<2!yv-b-m&Em-;kE=23UK@a44!w2RI2hx`zP zu`zlb^CayOY5h)QY8L}G!-U=tkS}vMNM(QLm1W*!Wc?2_e7ip-LOifXSB#%Mn|vb* zcYB+RZoJ(KJ!}7mXjgYh=Fz2)ja*iSJNpy8bP8%K;dt`RR?kZM57!PQ$h6`kuC@hS zfMpIjTQuKN=&xwqJ#HR0jrQMcMkDjHOa~bn^i%sJpnAQDuXFtj?K4Pr7@@nr_0cGX z^~F4^DC@DptAfpH$=;iXE#_~>M?Yd&4 zxceuPHab3ejk!|hn5U=veSdQdor=AsWOx6n5+}U)DYBKrxj=h{t$S;UnyX{;)TP4i z%=g&qF#MHg)W?#0a&qqn0x0UvE;s$Gudy1FWljkDFmwvp6iR20%|(BY;dnRGW0g z7HT2jW594kvP3)|1EZz1c4&1BGu$93g~*_1cgE{jVRqUbLlj_(^@-_=|DY8DCidPZ zi}TJatfI9uxKdazVbA!V4gXz5nOktH3*Hw#J7x+d?4ZmUgY*a(BO6X@8pL@wvjDt6 zILv;253>AEieQU}aPSejJRC2C0t7lM0N56tPB}>-i;pDi^G+C$lD+QLYB16UD#eX9 z3FhO7jiR#bEf&83Xa~m>)p?isU{eQe8k92i>}E_m z2}U{_$d&=ckfe=VA-nvLpD~rbNSj1kYhH+#nrwMMt^WL9V96q-37#c*3XK>2h=9Ns}+0>x;5KF-w|X1n4f67^X-p(P;%WYu_7gF^Qw~idvVxtlqAPz?VhpQ zLU_i*lfTsNW_9M$oF2g3tvy`tIDk!Re8D4*nA-h5)p;#!6T}V@Si^{y7-+Pb#2knO z8FBLXA~eNPnQ(DpmgPywq)9AEhzCb3nHs?89i$x4BEy&X75xBx3KWDDz-0{y!qe3^ zMYW8oJ_8UCrqc9r#)}NIrR7gDN%jbM{j8K;td&-P2@c}IfanIxBBmEfZNwPl*kPQ) z`_@8nKtyeTTS#`5X%lk+_Xe@}J7yi@9>8?pWd4uP8nAB^kPnUM`2wHf0D!lMq8hec zE6^EyhF2F#v`rfxM~utteBCd&IN{d!At%*8bK5#=nZ0Knr-kn`;uDhDs$IrSa{?QV z*2+4Sf(~5pv4~m$=^|pT4>%RV4Fh^FpjYRu7H45_6FuAFVqio2d^45AlbuqW&4Gs> zJrLrXAcSz@;e3{qlnA`N_0hcalWEDvp;gony$mQoOo5&9ii(1VIR)@JdH*wGSOvc- zbbrkPiKfY9G}j&c*4j=vZ5xr@uuBlMV7qXIr$bn&b(E^cXq#qzqjyeUL-iISKfuF7#^G&P$+m}D%6s)c@PK_k2uFKgRGiaKh zTW>z^?S~(*cJ6(lAE}RcAR=-mPj$MJkjs~}RexDiCvER2s5n@|_Lm!z3P(8sWAx!a zZQ+dpO|I|xU;H@Y{}BgZ1!zsns*8$7+n5e&=IVJozbF0arQilP1{FJDFq4!;V}sfp zjZd3nqbTHU#}uwSr6bJTwQ%*?`FZOiL!FfM>-@NvLIa&IUX`10OR$kKagoMK&L@;T zDzxBy*E+C{<3xz_?PXPf7CK}oK=Iob&!3G+Bmx-npd-8m+m04s$hftLtemlCb?)e)>^o~*bo|a6 zbS97XNIX&r-YHHg9cK}~eN1@N>e+%rGEcmngP+fX%Q6&aztPUbg~L0X|mNZ+sRC}PRU$<%n*GkTrPi1xnHr$o$IQhkC8`U~Uwyj1NG6fHL6r5;mOz&G1FJg$5=R z?c(m_wqsqhu8OEf$Bi@%4*++qNrl8y|wHMyuDF-k)4lL8QUtO1U8+I+C8 zAIufN5P`;2!S*Xy+kFhP5uHkmR?n5n5nR!|b^A7`!SjXr1o!a}0xFY9w0OvD+jey8 zLvOfwfy(sHEj});n9?|5Y~Sw(lgrKze{#Ur@6mhutAP5I-oiIWll$R;(%Jz7C`Brk zH2-*<7&=b_@=r?3N!sBDZj>XNm|yu8o*ZC26nH{#(zhFnepm~x50BJNG(4C2nKvXy za=znb$;!!1v}40+nhmEkq(e!%$V_NrTAt>P1a2i_w7Q~YX@}pY*X8qU8M1NUTyd`=t3B}Bp^bgvg9hwxPx9kdrl>kwWs2Eb zKI*O_sYkIK>|0ulG1RN55MPrZF^C(CqAKWIzmqd%I8xDhg%4<7&7c4 zX}H$z;wZNs`?YE?nLX7>=g>fcNLG`~A2udzUeQprpOyf&_e3LMk>W3NwDqaGz?SKgV+cE*x7Y{CV|C5mvNt#u4 zR*$gimrbtaDv>=t0TKEBkVeifzFM>d)_|ZM`)v~hyjg&d-h0*wqxsw*S4XlH{FY-~ z%Cc{>i=(jxcw*A&kBFS_Y98w~w{<+Zsl>A{uXvca_7YKA1MynF2z65;hS{5*73@iFGS=wErZy2zDxB$M z!rQ1gcDtyC(}3NWd*qKF=5=tDF{l-wp7miJ>axi;f;}rY%Af6J^ojyi6bk1SPH*{^ z0{U*h$+iGyKtDe1x>;qbuKv>a(XEg@Q#Z7dTV(0o(?A|z?4&;A${W?qW70?!(<@5hUw3To zPc}AwxX?(*RoL`pR^~XIZzazv+t5SS1{#kM{#4E#f{@V+eJ7C=a*Dw3AigN!aq!G~ zy6=PWFlK(q>%m!!#u#Vf6wP(l3I9#ey|F~+%JzPIza|cNFa-VVH5aU3HdV(%l>JkG z-{Ac%B1^23_~vE3L=%&_)_*JdrR3$)&NFu{GQ*V7FkGZ%(c=gCY6nU=^hgMqVW?eI20K#*cL5n2a-H2^=LS~~|6 z|1Jn7#7MR_{wK=){{8#OerZ5S!^L{Tf3IRRl!N7U(v+DOl8xH6{@VS-(XT#Yn4ig|f?N&Yp- z&YiB-1n+_kz7s#;qb@$3Oykb@H^X_ZGCBZ;Ar8UNa2_8YH~0&CaK?iM25vRTugYDR z{`1Fpl*{7fl9hasQK;~K2b-D5W)=RdVYZ)Z5Txg7UYEgGsDRn%wkWLi3dbE7L*GCg zA&7KgL|UJjQ37U4b#=8E78M=~SMP^!6O(ot3XC}lzf`3z-pU6>s&j?Bp!!8fE8~Vns~Vj~1KDHD{BZuZ4{XT%K?eo)ipqkPBMYrd@yczR3G1P(5X2e7l$;S+VLa z6INdE$VQ9u=IDCVH$edwEf*FN`g`GVeKJR8PgPMt0bp}Oi}C40T4thjl5|e?2{vjUT1p=I%ah`=hRfq?>I1t-gwW@?Y}xJBk4b zSy1>7na`!+yuru`6jIoq0E23OlJbDDJv1$zu{(1- zLrl|px)H`G3}A>qU}g#j;#CE^CIHsbgREkPSkYel4Xx$U^4k5X@n>>3QPwl#(M>@D z7r|R~zPu4Wz)rk=?rAgo<45T8Ki~uakACecR|q=deO+yBg<;HsWn^to@0pwDrumu^ zC+EICCG*3qWCpsS3?U1C9&)CfS}z+No6}`>j|GcP@mzzzy=`}n08o~i$Wj*(5eS3U z1-QCBHbb@Rx`lFoAZG9iGufdm+r``S-E(bSU?z*jSHnvfggfSdnwyoNsj=0;w$F9< zJ;BANcuz|dlT{$Z_;{g@EDP6%zJSU-s%nCS46DczE2r_8Q8j z%=GjzmYppjd$syR_YRTJZwKM8%UK@f>e5q z<`rtM2LW_v0RvHI%)PA35$Kv}@`K)%3y8IP`b*%nITDw{rL;7hGUwE%g9YO)x7gu2 znL!U@Ai9k2RR{=k-pSz8gKSW9C$XB?W3l=mPMeo z!L0Cx?Kf^znqfosQ+E7>Wc1_BM%7% zf(+lHoY}5zJMKL{IHn(~Xz5^4fE}j4wC-KOk!M9(7coyJRsEGa&V{U3xh86a{J^TB zv-2e^|GVegOgP0rkMavD71#qHlQqzVKYhB2%;7NZi#Bs7K7t+-dIDepfH>yVbbl(0 zKk&eJv5HbO;M8yL4=Dv*gx%QuZNRVm}@VR0hBvNRgiXcv>@Q2x_{YS#bC0>$E(PkV;Tq z{(4l4?@TvvjlL~;_=usFg^XdctHbA{i=Zf2NOyjI9uI0;^+zd%)-K**jnJXEp{Ne zcwgjjKvCg(1ieV1GdYmyZ@iQ6RleM=DJ?C1eW&2`L>uNM=)2bW6py1oT#J+hkRMiu z@oGuj|6k!#}Oie{1<9Ye`p2P0P{@*8hu;Z9ahL;TNxz+)G?OZxiNT;IU-Q(@O z7PPp({|&L&?7{sSm`h$7UV-y~F+x<`lV8xI2>;xcj{5yJd^vv z7SY$DErYM5hq^tjSoLddBw#S9PdZVV!Rw7LR2lh|w0Hz=h87cQ8;_Ng-_HOfs#M;^pfGrk7#uCKhGH@pg>I2S7dik|?ykKAc@ z3P=a@9({nCLP(}J@$X*=h|G&0zt_;J{gR0mCwrrViFnkQmYDubHL_`<%Gu{|L|Nu8GCa6PN0};`^<&2f(cXn!_XG18tuGKwX^dkk)3|hDpyEl zh!@7rH)s4Q%y4Wmec5Ksys#uRW5}OS3_j1?_j~>vQE39!^ZI7KLdC1|EpD|er}j5r z*b;OGw*L~^uU=)-%=ZiyQhnh2@z$D4Q{_axo$ePGvgHZ6pg)rFBLfchx(qLsms`2t zHqR}hyrgAii(sMjE|>$0BWct9`qJZ;qz@T9TciuPbg?#E5>MY|X8y;_QI!BndC0l@ z690=pu$_a8TplVb#AA%}*S)AQ;>F<_YA6@3N$~b^m~JI#r47Z1!2GT~2&CP=huIF6 z+esGt&qO(bJu|WPC+Z#Wo?jpz})loQBOWIreb=7bGmysVuiAR!3j(L$8tW4B`P48*ODvc|}wshpG zUi`?xe(+EpsFNf&Au$n0S(kv1(7SrMlVRuCoU17Sy+dT zZ2BL{0c8a+P-xFgFDR+#hATKzL~8FA@J1!)gx8o=!JpNfR)LY% z**P0=z@*>>rHCNP#FFH_JsGi=*w_Lr64KJshtJM@r!8sg@t?Rq1V>So*^r%N*D7B= z*>2S_eWzwxU1mI7+|Afe@q+l2X{Vl8OqBdZ7%`Y?)Y&=|1hqatn0!ViefHE|FN7E? z*7n0K40Qk1@;-&T;C6wK##NvB#y?#W6%Wmal*-?sEt6%zI+RD#`C{OCT<-;>kf=Bkp6e* z;;}!%xqBefOUl!&G%Xi1Nv(aaB)EXljKRwO zbB|Do*Qz9%L4;&!A^yIH8yRq=0_8{&tgr#|d}pC^{mo&sXSw1Zmjnjy?{2~}bQ)G_5H3dUQ zwofxvG;uA&c?qcikID3T-_E`W^`*|M*5%zgv-hC4`iHUo!kJa~BMOs5Fq3vVM6`{% zCA#2(Weg`Wj(CQY7wa$i@MZ+7bH5C?!P10R7?jEFBwy9ec?iFL z-8P$**pmI*2R$FdC!o(>l@H?f^zpG*O95O6YQ{~1+#8?TU>4*-dl2?T=@T?>O${6e zaCqcgQ=@78j;3!B*Of^x1AzRdWb)5cRqZKpxWU`wgV;IolNJx-Vq^D7@pck8^{5u~ zTz7z+{X)^vsb*-Pa;PFR%#(<5?mpvCnILd*p&rawMwVR2R`N|nu^IS2CE$A{zTR~@ zRtlg1n1PAcs{Pq=j0_I3C5(&fD>ywREoTYYj0kpSMQ?`GG>vL8B+_dr0t}rx6l0Aw z2v6pAsd8n0+;2A)B?>QdcZO;4LgzQLEKS6L?kimwgbThRLFGwZi``{BH`?XAF31|d z=jJc{X}nO|itC8qp}IRcX0%Se68}N@T9NA(iGP+MpdNm?Im&Z|=1o6$`qAh2@gN`2 zA4SgcmHdlTK0b4&;itz5e8S!8z%ApN9h`5ySr^+TT3K5w(Ta2b5Srf(3uv--0OJ3_ z$@yW&%-r0x9AB&LuRP@1(H%fRT3TM_`N_%PDquzt+BG*j1$y5FCLyw_XY55*3%3&3 ziP5Rrq1$8=R5#XgwK9j2_jNHc3jz-bYau)ete5won}%uw2rRN5Kumr_#YYmfJwP1| zg)SPcaI(UsHA&Oll_DJbrySrGc#V1lg69ZDJ?AbmLIi?mPDxeIDkMiT&Mp@g@?f)d z;~5P52y*ocOEo6vjU0ggG6oc+`Zq4f93X`F$v7NmXxXEp2%$r|3iQ_Xhl9onRC(mS z|Jy{146^$D2cA`kTNO0-h`G;@j-upayd2?-JMYS1TyM)WH!&G#XA1yB@6Vvayomt+ z{zjm%{sU%8+NC797j)a#pr&j9nqhzmU z+yT*QzrKZx{~uDuERvA)$h*q(f}GC@Y@7H`W@fVEadkdQX7wE=8fuM;WsdAxv!7G4 zQ)teHDp%yYJ3yi>uu))N39QF&cy|n#w^%_<3uLm*>4wpso>(M%9Ojw%vMr&7KVZ9I zaSe>92H;`CNSFUm^LyY^DMnH^efYBTg^)S*dPInJ+^E*@(r#Phi-pRdFtk8e4{xbT z<^(lLrjmkv%f|2g2tYYNl}P6rYeH5+RF)eQunOML6oiJfTJ1-)wrnX#ujFWvKf|tj zcot#TU+3Af5oQq9SAuVK%x=;P55^$&bJ?y(*nc_m&?#49yYyA>aU` zW!0Fo`YG}y3XS00V%M~iE&ItVkn5ZfP z+%og1Q$f!$n+(PSZ@?!J$v1#3;NfVTkF^}UZ==ZX#bV&Q7n|GUef;J>n7;ba2QLjC zfJHkM-?UO^@~M)jjM0j$7T)FHt^#ZmW~ezEoGT~XqtwmJvpjhvV?1@!0pq@X>(-v~ zAu#1&Q~!Vbt~csG^lGZAR#i3ovo7u=Y_hbi+|lO)6xEO{Y8Rlo6AFpxKM}8jhHv*I zZEV}C_b=+1rEOv~P$y2`h^YlMaX#j#H-~j{yCJ!+0f4+r?8UZP{ClQ2d1F^~2^?5) z9=kI>A+L6P!vB+9k%Wdm)OuWojIAv*dPW-+DA=K_IoWlGRd20KlgH#I-Xf9G81o=3 z&3qM{s_1tl9PpflojJ0|9a_S$b`~2vgEIv-81mFuYw_EXHwzYdUj8aK$EPH(@=>AK zq=@-FPK@W~IZyT~nrhzCCyCk1j=codF>c||m~{ueck-dQvq$RW+{s@Bt1T&A96Ed5 zoD+{@A+@>BlGRsl&y6}!a99wGC+(7d4E*{-`H?(q?I_=9>cCb&yb^W0)UwjZSs{{2 z#sj_`_0-&uT>A7;z`y&i58$Xr5+uFIkm-SU3Kp7wt-ViOEB+T{>R=ZRJ65;sW7eI& zfE2?<{QE3T$V;~TRSsh|_ah>v^cdJ%{8IuqC>V(TIt)4mYtqSN)Z@#Lbu$qdCT159 zIO`svcsHnQ!wm@VFj(3dflBQ5QS;KPlFc^S)c&CRyL?!Tw4~%?d#RYSDsJm(pXIEZ zTrto3Wo@6yYhc)t_%Xz)UrT!9Ef0oHVI2D>qy>qJGWV5*DDxkK7se6yiu>PCox{w` zOw+36U%y^2cDfYHFGrTQu^bkA>7)1JkBpqoPXMshIxqkF(+FeJd5p&o<62^b%Ipbq z7tDOX_=)wzU~YPBSuT_93n{?JA`>rUM)!zu7WRUZ-YPkcO!`9L(p@aj1JE_pBE(+; zI$qT`9gGpUJU3*iWCM!W(lEUd*VmI1@9Bza<<_etedJp|-`ffproSwk3{fV^OR8*+m*68Ty$-#uv zY3(T}u3(m#Fu2nD{L`=6%*Y z%jeJU0W^egW4$K<*-?9SgT@mGdQU1Qgo6&60ez!WQ%ZaF=*vIY0>aODzBwg7Q2>R) zhiwoSc#D3&uCp7R`D0P{Hf(;47{Yk(`TY6gP(4pgU}FI&$~Y!c5-;^Ztt6>fs~;v? z@X~&aM};T7fLycG+wdT--By|yQU3A$gjarHzd(8cK`VwZ4rINlZTB@4PZA*?=8+#I z>bKfFGnPuadOBvkV#b}r9O^w>%gNL*XMmN!TnWN64G<U4fk)th(Fwt`$AR>V{vkE6COi0zCl?gnc|4z5~(*4&7*PnNEt4 zB@$>(;W>K3_&Cfq;(gATV)9Rvud4f!y{3HVT1GI;a8yt5nFhl=T4y8z}GEu<);e`wb}4MRc;5kY5zFY$!2;E2Y>UffsPgBBll&UvAu za)S4+uuK+obSjLb@$;wK>ome|Gy)WU5I{b}+!*|J_-O<+IjWc6I-@v_Nw56P7nbI7 zCEam@#j&gvMQg1P8ynl^)#vYE+=AznZxnKd%6gIPO@^J{=8Ghi+*rnWZ9vS-#`f;^ z>1Tqvafja|!SE{_GUfrR`S8Z?yv8$y;Cdh(fM*1X@U%v=;Zj;GL79(g>t$PuvKkNE zZ5@1S&;2FX^J(fO1#tvjYx#TFYd6+$1m<(hA_#z|z4y(MG)yI&E@Agz1&ioaEqP}Z z{Nb;>laSD)8Rw+jc^11ym(0f*FRIBhn zzm-drUgpm+ZOcVQ_p;T|HM!{($_aZ-Pu62^xv!w@`fIkJsJ1| za5uazFv(UlG&m&|M!bt6fDqCfTu{D%^%9;96n5hfl4|-vZ<-yZzPj(<`HDs-pP>dg z>`Cq4GLRAUQmyiAh_7@0BnZj7KGU>S)%YPLCB@J+s(x2iPbU*ZLb}kiv~eVa`T3ak z1NRGYLix51bmH)b`q!hCmwab+E!Du7=IgkF#l1T)PwC&ucB;18*|$PbJ9Wrx;yA1j z4+5v1;^nxiDR=oB(9nzRuJaSl_4LyVMwdP)(p{48uudKY{;=7d`nD)w(i@_*eOrJmTEE^s+z8IcA7SW#9 z-5CA^dNs<_G?aI$KeJhf!f=exwQEIiaC3N*vQw^mabCn>s(3YDdHpDl;1wkoujmgr zR3PX<0=pKk!>9VS*Zh9}meEta)qZdUJ>_hMIqg{1QX}mH38#XshY{IQ&HF*<&tcPb zgEO(dO>7|>Jx-DzoYX!P%G7vzxg^~%FlrG{0z%HL^S`#x!AkzX)frFut0c578}Leq z^qD8!`}XMUNUSTAmbQJ|YSFnKG*RRZGvDa@SFYwl7nD2nkDu zQ4N6K{}I~3Q3t7Zm6cD9700@O%WLyfTq>nphiD!k+_u|+KYhHs?7X&+u>h=vi=YC- zCUCD^@j?&oAcQNqKdvY*FZtCP+IgLT6L2=3q$>qe>3oQCcZaN`+qy`Fg5n47wslo` zL5bn_iTU(4kWH7WsTQdykn>)aT@roB?2bSQ0iP&z# zHG+79yi~JjR!yvq>w+X32mdyhuaL!t>Y`>WGlWg{$VV<`&t(P4GMOKOu?V!rhz}k> ztW%(`8C&@U(*cYp@3?jrQ!F4@U=3W=4O`;m1Mfq)hlG^W2jG%`enhp@c}_{+Q=NSG z?$cus?!x!{X#|M1Kng>$9pLST9R*@Y104qZ=jSy6hnt9v1bE_H3r1etoL*oAJ-@v0 zL#Vq*a2`x$;~F1}!ASM>&FcCMGCj^#@j{ZYMSplI)c#waYv+~{?#4%czvIZ%8m-Ya z%XJ+*kqq57OcuZN`9+gcE^i zlT*6rS_cC|_}O@1hIZW<%WS};atF@~Syc)F*B2xsIbBTFyhetG4xX)0opQ_?Q@?zK z#&bVKspw=-XlIB*aGad+T=yl;7178qBU?`*3;nbWMo24J@`B{CS#NVwEmfYnVR5rL zeD7jt{<-fRG|X}mdWt8KVf%4T2lEsz5Tm zdeeBjzPi!lBa<4Q*b0SBAPL$`s7MFXy4b1_YxihJ!1Ys-AfxSFW1O7_jr0r4RmH=C zC+RFq(j%3MXKbiYT+EZivMfFjO~V6-j;f?y2(ML$ z!;8aNZn}D(Im2p;F;L9q2|qO!=VHB;uJSIsLXdqnynzq1hg54M+k#|~s)hC}|WtjFouQp08rk;&*P z;?c*y43_~{^)ln{0j|(Rh0M`1{MFQSgpPxg(>0Rf_1V%%`jsrXLI6x}=}WU!m6s1` zXp$^tL(~_d0|IskP(#c?Tj9s@k0NXSgQKKz5_bCxDEE<>T_6$eo=5y_US$RRg8*bA z0Sw^F0?>%}$zBn-07A{)gX(n3@T#tFGxv{gXGqsJ_zWnfM0mM+R(Yd3u z8J2gII{FC}$os_g9(FDFk44no5dK_TyaHQTguMGds`*VGAcmC-C!O#zgI?kme2s5D zHWh`ji58MP>bDYjXl%9Kw6Wi;zI*P;HBH-k^J|!GQ2rFn7fZ)64F?gfI*$$q8}AP5 ztuc`uCX_q-i*#~JU(NtdX1oE6`RCW`1YCUOk3O6ATJeh!+%WUj;Z~D5TgU>Y0Fqot z*8aeUXFolUoieryqg#!Et|2QrG-qE;-r^jiOfxA5UoF;y0}oBC-lw{)@N{_@Eg;G- zgKCK+b779;q~N?~flK93IE!!7uNhU2TNSY%rl|6pi!s);f*?Z&o5hz$>@I3Od*#3VT+<=_S$&F+dW868rt+Lf z#u#+03heC7_ZSUd^_uHW{x}U)ne?Y`a&$~LIY9i?vm)GM;(M#U7h|G^ z@4ZuS-hC~DZe6yXiH^JVh}x zF8waTz>r_kQd2f~+qEc2J9mov<)ZPke(Bqg_&_H|N2FO;#a|k-{%beZGNq>v2DsoU z2mJ?lqt^Kz>%)rd_t=<7gh;BGlJl#`Oi%I?TAbLLQe|?+Ei1K^%+a8vrS9Z#l`380 ztIrb|z0FT;t|=JR1B1q|y{P1|pD0#zbo9X`O!99&a#}lQ@}4q0Dj@P zGmKBYuXmq3N;658HYcv&ZxhQLn7p`L?is0bwUE>3u~3Lz%&^yXh!_?1&qkdff@ zdQg;cynoD+8afKx7jj(n_mhtHU{nS3Ck%HWd8$wfm0P`3>W7Q|-$_5XZ(qPhYZ*i^xj2RN;}BjXN~VE81CDM!Vg`(&4Pl;$#ATB;Am#3btm40vPJ9O?tBvw>$Ljd-GsOFsPZ#$gcNuFTigVZXb zKTv|)5Rw|$MM#4?Ht_$l<59iKL5Ad4R7F={?gb^%xAcg<3@ksRPxscX=^ zmM}eatLhifg;K;l6T`V+Kc{{|dSxoNy&t>^{^yVN|CMhMif2t7Qef#W)l6zF>j4(K zK{MoAc2e)Y?VvOTJ#!!j_GIauQ$<;s)lGNUx%H!_rxj_|MjkZy9QKa900i2)75($v@GzyXMBy_wf-LeFXt~$L;h6c^cfq^lx`%Acgrlt;hjN7(3 z=0YTrfoAdhHK^WHfG(BoVhi6si}>$t zyKb-tg`r^|V&$OY1^F0UI)wvIp1^0k`5)jH42iIwfE&VC_=W#6v{Vd70J-=9*CeUB z2$yl{Ro7!CpTF;J!!sevj|!*1i4VRMAnS!o7^KYz?`uG;t}QS0G~P1S0}M(TW6oO<%32?C zfqNx*1A&%cl8(eDZ4)U3bs)TSBe(E|Ukbd-<~Bgxx^oBqE)#>>dzlcP1VanJvgM?v zB^#;3NJx)V5h-6COdBTb%&E{;JqrOwCUVfrCxIRLS78tvYvf#HZ$Jrevi#XN``F7& zyIb|tsu<|?sH?Rxe7YRUUnwbt`!Kd~AEpiOQo$r~P3&Nc`1yO3e`oJXdT9H4SK-!C z&_?0i8&=1^^@URSo*tKyb6rmvZeOtRo8R7``2g4yFou}!N9s9By_2fI(v;|U%GaYz z&s%GC>8IwLRP39uiLHOIB^ya_lVDH_*>`%$Zf?OlEE6ho-tj zxZKHy^iKcD(&(4E5OZ_%xh}?d^MwjIWqNS#k8WXiC1Y*pv1RsT$=e86{tyxtK26=L zM<)bCbTFztskA^DxMO^qs#UyfEt8j%Tc3YGa>d-DUx~MnTV6T2gPCj2$~dwDuI{}q zcwcfX*&T|nrej1p`0{3T)%c{QY_=!t2qx?q8*%#mD1AG6yRkJ%a6c*s|L3eY;Vl{J zmH(7+CCGmaYkV(G)}TMz^EPZ>;V{u4uVz`A*#-QKct+)DP+t?)|Yy{wqa33EK)m_qWYE zlD}-Ly>$@jB)UN`+tpGi@u_iWS&V{Z5EU4vVuJg+9VFS$`1ga%sIsOpn&%m|_NaG*6)J z)R~Whta9-`U$Q!|I;PS17^eT)ipZ9=nKqn6#fF=zEJ%=DY43sUZTYl$7OX)cciDx> zF^y`o0V)~;06~!EDy>y_m)MISzwgo2a2_jPzc^Q*aWIQ=*23cQw)N-I(o-8PpNP57 zAF(YyDHi+8xV3s9p8JeL>rn8Iu)>6j>x$EVy7 zT@dr6ni>cUz~Er;!+Nj$I&_%lB&qsQydM()jyBI+2)_W8v$%%8!vQi(z_J&ZX*uc! zx3%gNn9hKC*6Dz;TmT;Us*`fiLGrr zXAX>u9;-qBS$_3Ny}c%Y5yL^&1nn~Ei>CSZO3UGhSxRmB7s6Au+)yqN4bNi>gMYhz zFb6!1$T!~$Z{ofgS|z+M$DX+zH;|E*hNQCX^9Ahiy}6vL8wcb2B9MP-TmRkMw70fy z;Uvp)O7`C0G^3b`H{+`M=v04)lfW};(z;#yV6op$lZjdeOeqv5`~uCROsvS@tl_^RFbH!tAmwF zHS`S`)Fi|{BG7(w0qs<$$Bu=Gsazgz*l&TYM$L`k5x$xq9f8OLE374n!I3w^jMm~D zOBrrRm6;uMCKEPZ6`bB?TEpq|FL|>blTHof@3XeBg zh*V^Dv{um94IH}*2EW{o@QaB%>I?g6W}N}dFIfs5f3+)Qn{WI;_&&66ueY0O4%zO>e8$XsUMW`Ae&=#W21NF2R#*D; z8VP(l5}(h>j*rgNKJp)ZV80yDAWh@ZWZ3vj#7bUe-sE!#LDuRqJFF_LoEv&;@q4GB zNFZr4-#j-nOa2X99ihWwTuwQ~+*=t9*2Ke4Fn#czVWhP@0VtdQIQVG^nDE#L2x!)Jf*Mc8d+p5$6L*#l~>hbmA2}un=dhGxlNbQ`a;Wk#LTyK zh;|>>D0swS{)pPz{CVMOh@S10TS>Yl9biODQ0<{RyDM|GxMBIz)&=Xoy}rduHb3IO z8?(J;z#_lOkw;zikR=i_gIFhzUD|ZpWVcF0ehovEXC;jrIGOK0CeONSY&UMpR^k)mEPC zdtSwkg-i8eDa&?W6Fc;o zo#WUuFmvb6vUl^$bz*=9_US=E;vlHHNgJDvl5zo!IdG5}&L#$3*UWvL3a*}I7SeQ~ zemX^3@~K4b==b=N{1W3izX?Jk#9zRCb(iI*R?ATU01>jR3!hEw2eB&lc(2h$sl}v{ zL_~RPC;!v*Ycjz9g_DyGp)wnh%X7||U-0uN2JBX--#`C&qc->E#|YnQzHXJ5xx!5% z*LlfWv+vpjCE_U%M)>$OfM+GiNzm%#s=Gt)wPS%-mq9&nF7q8=B z1B-FLy#d6^@VhU^qj13ffi7$8k*~%%;DHiRL%jsYD?49bNWE+|rDz_^@5X641Gm~w z8lm6T-WHV_)nqe%8WNKxpXsr&FD>yL3x_%BA^gNxSEYd(@q_d7 z>>|Uo#8HbwkNUX9is)rlpVRl6SR=3icqspIx*?zxm^jE&gQ5#|npu7aZxQ14{ZWy~ zFcixxbezbsvg?OeOe*}`MzDC#2l!p_v|JHUQ^8dSm@IR2RI%Yo|ExD{|}GE#*I|gYrZG0cWNZ!|;2Jch= zlE4b*#f&_P*;cQCgS~lImyz-=#fN=8Zv2?oU}tqlNdj4K;f@v=lw_^=#a20rc1B2{ zt9)uRn53?3wt@9zZ#~de%?po%`PHNdNpzpI&&pa&sCKu{@#RV1Y!&5HG(S!%bH0`% zNom?ZdB&ZBz8R}8Xp`{1H^blYJ>;1zc28qNn(KXlMz$r8X+_+(m}|mm7Qly&>F^>r zAZ%E_RkkEUqO_W@cILIS9B;Y{*mKCQ^WP^^qsn8#mH181TV#Cb0z?`%adBB{v8RHV z)r^JX`MomcFEPeX(y!@BI$v9UDZk}0-VmX4=w(b>KoBuqkav~^ThV*GjXz~(E)Gv= z2z>tLx@5*)dK)vaEDvC8L|fD-x9&dmRKM8z({w&}s(ei=+KPN;_GmA1)Wy8u4=sk} z-7`T-X5mXOw6zE=Ek05l8l%ZoZmkL(c0(EiTL z>-k%W9SLGp$=UEkqlSQSI}(pl#w;xJ=JxQ7OmD-ZOiX zJ(I?Z&@?h4E60jNwrt0-x9@dc@7w1;`1V7$#&HhkJjZoCuE*nkl?=Szn(JAAUNIFU z{ov&qY{>z?qFJm+tdg0Ko?PH7V@Yr(5!VYqLJW=yU{q(Jht9rK4k}nUT27VFv zcX~rcKeDiSNUnuJNoaRBJVQ0%on zCnX3ip2gE!zw2Kx+wVOyV6FIh^n5VaAov8!U_)DxK(pW{mI91`zfGu=H58&)<30SZ; z7fSQQpBrS7!3Hg0d0%V+OzxXv2XJb`KE7ocDyW$mB|Eqq8z>l*^sJ3fCDra`#v7pK ztNCV@>b0a!L{4U71@jgdlx8D0Y2sUKh&$)E+C}qV&qmXFYkf2_eHQ*iZv+t~&>jBU zJ`9`(OJ4#phO3I2Z_H*lUW2(8?9^CMj){*S2_v)Vf<>CJ!y8OI>*q0#IDHzb0G*J9 zd{`Q0&qae^j@HTJBchbfYnh@?__hHz_8CCY9rhJ1#PR_kW<{SuB#Oe#!D=^j7; zPZ117%jJesqqHCbMg*gR@eVE|8;cNJfFo}C$TMPOWHrV z7J6tv5t?6E1?!Pk87z!}2A6oY!pn^T`YZyw>pH=3CNUg0?m{Xp&Q#&aE@!gX;Pd3=Z^_e=P_;(s5(EYQDm+8ksc( zr~yoBO5E)9+o4IB-HMGfiYhhe2@4fz*ep7P^t1HqwA=*< zF_kYIL#+w=ZC3+akwTdL44LB}I68LeVgB2P0HjVTr#=LySahxQXD!Y+o+mCQ__4aG z`xGd{AW;=U0U+gyc_pP=zw7vnq3vDUKZiB{`3nu@X5!W*KF!sO^E27L?Yz0FSoZ!O zZIf7Y-!n!TD<)3!;ql90I;bbcBRlW8zA~PIp8}@4#MC6w%mM^2VAVW&HOb7zD3`u0 z8PeTif7MU;_%0Q15rptnBfFrOx%j-xI9uFh^oGK&WH_fRz0x%b+)B~;6em~&3)#lm zap`$_dNN7K7s!QaeS!PXuZgQXj)JTvWGS0iNQI}lD>R=Hx@@Os3S0v)tGoyGB!xX{F%X7nZ`Zv(qdDqPpfSo}lqPJ3q^1j=W>DgteaUy~>7@9xslRvV3dgh0P`Rd&=q?cBfEPPKOdySzE#P z3=_2TWiXg0_UzMLiY@u9YBs9ArfS@sJ=7!?(Hx#k3bjzSrCsivb-B4kY7~N2CYo6! zw=(5Ce~GqH&5SFkjYX$;)0?n;jF3MJ+UUW&B{{Np(G5YJxA++0a9HItedbWABJ!jw z|8m;?GgiLfsk;ibJgX-hQw%xso?||m&Lp~fTdiF1&z`lms6WW9{c3WV>)LHYyI&&0 zR6^sKcS5D4)H5V$yeP-{2|a}Y@{-J6-_=7mmV|_}O;UnXRqInFYi_{$}?)=+^OBzS=W6y|e$}hw{i>`#}3$$-iHQ zepr|?*z#llzN{x<*gTT+-ES)W6}%(Mws`f`2EL7pZt+t2BR_B5q>@83{_a;sqLg^l z9O<{=Jn~gpkHPY~@v53l7W@qEoQDVJwv|}Ul<=1NXtm20Rxpt?x+NUOCyS76xpEbC zQQ8waMxyx@y0)u51%FSwoL*i4cdf)2j1hsDW+AJ2VUhG%TF|&L7Ueer2J=f9ot-k5 zeb-ovK3Vyzpj`6FG;3K|SqBrW%%%|UBRmz}jD6CtoFo-jx_ z4dFwf{~K+kKD(4t=TMFQu?!+M3?a$OkH8FfLHFq~5Q1QB!xq@SAsGtpL{3F85}82J z0y-=aNeRBr!N_!CVKNmhg=s@;Ob8751KnXx!Q`NeQ{SImp$-~6uG>AsG!Zphy)iK} zF+31vn2i_+`v3w91ScI$vP@rLz9Yn$XtyE__)aI-?JcR#N*zy0Ek7@La#i+yGb9?* zF|7RHzWAwqU1uEF){O{lnj-pJ^Io!})T+|&fY^Hsm__Z;U=QN{LwGx0UnIduf(_~} zBnx42$SWKYQnL$iX}|Psf*9ljZWBO-p)~rzNs3@q)KmHOaoEux#n313!bK$wBId|g z(D5|xXuRVqE|F?G$HZ1+VpFfTG4fjtx+n~fc*aE!U>{qecl{_m=xa|WCrn<7Skhqi+{C!^!{@~rt0<{(lP^zn|i$UdKsHGnF zKX@x_?xEnxN9-KIt_kAE1DO^g{JuAlx`c;FAu)mM=Na0tFIP3eN7%)j{rvg619fuI z)jn_+1LB^b7r72}A%=y<-V&UKQjVNGTdUmO1bo(zdtGok*>?H~+g6=UR=)nk1suCV zM{)$7&UY5mng*DC>p#vZ&SXda6u3#`x_rQfd{QxZy1;En-02AjUa;H46dh>4L!cfK zhZZbB&m3i!8+#6Jxn$?UUH6)(I*At!$xo)O!b7|H4H`yMV#C8Z7Rld+U1<2{3rURO6epHcOKKH7vHg9w|iyV=Kk%mZi+ik!rW zjlx=G@u?k&PZ7r_A$aAN`I^czT`F)_`x{1W{m_Y~jR=b_hMMxVcubJ;teI=#*e^6k=ce@nIkIZN@N@ge7` z>i9G>Z9si+j4v+uKH`(=%vE!JW2GK7m$iAxZTg7F0{Lvp?m$s)y*kVaW_BK5=V9O* zrnTlz>Dn-^Q)}Do!?fIpZb;bY<9j2bP8n)od7r~^H>6-|gUk0z=a9FnsI!T>(4K_u zU(dqyJ&&=lBaz3^*H+!UKf9FgFb6mdBXIaB1Nvwlr5@3WUw8h(eEBU?kS+}6-!cb^ z2CR7$D(m_&@zT+`O{Ma4yf>2|w!rBWUT`#wTV+EWW}{)xZ!^^hoL)e+hJ6&V^BNS4 z7RHH# zG2*eKFa;8me(tGeD1?;2XR!~fgI|L}5=};s6`&#-1o-&2e|qdIU%*dzvGOUd#ZlP{ zX2?vR)TwXUX*($xf8ngJS#&vZYWa%T`bs2oNlpI!+q&5Ktc$SfS5_23%_Xz2F~}6| zAnpPwame>D3Dj|9M125@UCc5h%%ZtL=x_&@FeHM(EMQiww>fV=mMf}g8 zF$j~u!VXxT1|>T2ezklT|EI?O0cw|hbOe3^kFhg=?d_M>2|5=V(s8#W1dNRPc_$kI zx1I~zH)(X`uBCO(Zi3Pv2EQE)Jf zSbSbX+eM54LHrP27;H~zWZ(e@2gv>rKA;>R6e^x;YF~F-q=>?hfG&KRutH;uLRBM` zv{wN2b%3|?07wmh2xBhZwA$&F^a(3cuhyanuDZO*7UTW39QKQ-z-D54MI!hXXek6W ztoY%4H$>`BlYrag_t@A69}RBiL4fF2Mp5yQcke>yxjjQ9S!F#fZ7d6 z-63M^r@nx1`2;LBAeqLp*Vos7*aXXS>$mJ}P)(QMacM6KhLgXZ2e(Aubw0`o|3nLd zP}tXU*tL_m0}cdeW6L202#xMhR=|eSn_jvy{k9MgAK^YPWl>u(x)1h%0+w8IjS4uK z9G)Tp3IV1qpzws-Ui+Ze5Y9~b%1M^nZ%y?s$KFx?o#jiB%`i`gJO=dR)vyS}o~t@c zmLZRUKg5C;Ze+wwhfpFCo`?4u1t3G>bixG)QL%JW1sr)g=DXCEj=Pqit!f zVDd1&IVQ&1NO-QvzRZuO+W*EoA#-?l{U?JuIVPqp^o!Gk5wdUM^WT^~m9=}fF~M}0 zA`jYO(Xvv0<#;OlM45?#TX~WMe0;B#r3;nssjT>7KW|oHYV!8EJv5Gwy5Hu_aK(1u z4&kb4@B>N9f9LuIl|`3m=y@IMo4+I-XnSl_jncKwd;c04C+DZ2xbEibWSqWVmu9!5 zkNu{ozQepQ{bu9IT6a%NuGOC3J!D9Ib+vHW(8C@b)jQ%7Fuo}U-9+egPgPFlU4-J) zIpRvRW`l!vC|Wiso<9ty4s)IxM@Fj&+mOE$N&oU71bBPD8mYB+qNw9LoIGKRW0EHP z<{1%9`Huc&=B+zt9|qCWi;Lv~@XetOxPl;I61S~;L8{4iS&xy;y>N}*^QoofvTL#! z9dZng_;38b<_2yLL5L%wy~Y-c(pGa-Gf_MCU@rNDQoEfm9Fv+dP%8F$P2Dy~=vw&@ zF*UJ7t{Qpx@nm~kcuVjXc&#|{GM#Ug1M;8ylpa9vDhkv!JR@K%rhh3=Hqo}k?~yRe z!WrFj?b~)x_h*y*ZUrHwr2oPDk;kv~)>=J4NkCp+%+31oq&W-Dfa@l}W&@Guf9w*X zT^H_k#K_L-nU@q^cE<8~i{Pf0ATs7=&;tPP3tm!%)$Ord91N6+MJ1E zlckXkpLIo;NXzXX?OWJ1rdRU8Lbwt*G~B<{UL|%!!MO^rMl^~xspCUH?gxz2pfO7} z#df0K)G^ALmHG%Ai{;ehS5u)fRb+O1Tf|LQ8eC;`UGkHug3Yfqxc?C;06eR5`a&(i zY4aMI1zgmidNsfV|!|12gej0e*t@JT!n1n@F_>J8Vd3=WL~V!ZC_0 zG5Ms)Gbu0K?%pHE7f!f{9rDph70~w|Wf>92d@$C7YkfXhAHY~jW`Sd^7{vyZ!;Eyfoep!ScM z48QrlPXjtcx!0})EKcw(!Nm|79OBivjem~J_B5^gf#dbu?OlQ`SQ^2DiutexIu*R( zL?lYTC0xAGu0A8Y0_LxOz99=lFY7vlw889NLihLR=m6YsOKOz`Qr`y;IYSWwO3azQ zURYbx`<=iL(R{OsDm_#to)n^7tF+w`k%KV8hScM}iIHYWt!feW+HS>L=-u4@2V4d| z%Wc}w=d?E-qna`e0~JE)o5)104@<}K)=ZVe5?;42OWvs(M0Q}Bm6es%$2li;OkWCtoQ>lLuX#fD;ECfLemgk7#A!Lo6u~A-d+R#6F#c^uG(C`2NIe zPa9$HXtxRvM@t~K%c#E0MV>H{>1Vc6tHrEBWDivKL2y$Zm{g6MQvKGlaz!G{qSS96sPy)3R58`JqGclK0cBu=Pu)?Q?*F-h}vLTn(5O0{5F{Hd;SX?8JF99@I$ch0p@ zP9~$ar2VIJRcc*l&D9yRkTugazh|EgF%+@rJm&uh)I~4@266>L&m-KrXTg*tkwK$r!^$Cu z^~k#lqbxH=Lq4safJ!*_@tX-tUNG-fPWM38Rj!}lT(N^efy|b<9e9crD>6>|Ce^&+ z`phH#}8UQR1HR*ryKtU75~fWejsM>N8|~TiVjxv6;s-VVBvZy{ArVHzi}t z5qY^Y2O$jRyIi>ZIm7*GVI0|B^c=Z}jTCCM_^*ObvtWexR0Y3h)6t7s&hIoivAsl& z(5kcJJKp2EQ?CMFn`@YyE3Q|t1?%6g=Dg1rcJHjFFIATHea%bP$u8nUZ6nO|vsJb; zaU!Pi##Op7~!aNH1U*0jBcfZnWG?=THD`=l#9r(@4 zZqV0T6{xrk!9vBPB;3K-WZg${jkDn^T>_Di+hU`A`pb*&;Vd-Z(iZUB`wVzW?GI~= z+Q7+}{vJ=9(-M)JKm~`iD2U8NM>E2gX|fOStMi~d4St_{XgpA%XfC?=(N8xI@93Vc z{(Z^5={NMyP!PV|IRcy2&w?bOX`9{A9C>yz?H*3a$7?&&!o)5Z3UgxU)?N%* z(tqE%P)bVbJw#k%9NE6=s40|k-VjFy(kxKN6&Z*}*Zr-6Vt8wN<+iTM)boL`3g{F> z+;b>Yd*f-qRjmz489zowduz`1tnou_lX$e+nTP)TJHc};zg#T+WDTQWzxk`5i-rj! zqzng!y2a@If44hobo2`EoY9dOOPqBtdyD85O087lN&JVH8Abh}58NC(x5 z=h+SMpB_$X?vWFdoX)MQ4?i9ToR>8NOpJEqi=Q&B)jt=v?^uyd6X#lS6SXX<8fKfu zdr)B$b!kY5UMaq9iSzGE`bj58Z8nB>_1|29id*s0GIOZ933C3{E#YZ5>{H)lBAm!) zT0dhr}NqA7gl|IDkSrB7y@&d?A3i z^aJBn9C%SH+qR=>LQd{!<1r-V5z9;&Da0HX#E_^f?S#)UYCNcHV>SA zg1@a5ZX|W}Mrs#P;R_>0xV$NC=C5J!zpM_L8=yzr$GUe4ZjCuLcC28pb@U`G0o&+Tt=2NZfPpHc) z<}Fc?wmOsiBV01of__P#k@Q8g0gPPz4;1W{$yN1fqa+w*~ zSx9Q*np+2o$z7ezi=XgyHK*rVV9SvUC9otDVLewd=FjpE_U+*QzD<_&lNPW*o=&TkWoBkiU{PJw~L9V;FVs!QZ z(u;W-XU|eg>c!eStpGdO%mTssHa0XN5vgYUfy$cs%3EJlR_>YTvu<@-dTb7c9wuQU-XPFd>JM$<1fv@%N6F zwIA1Otv8rzbvy$(j&|03&^d;ds-D?2WjYn>KE8f_Z!J&uhlo<)J0IA1aTpJ^)&F=D zeGNW=tWnpmC`IyMXvjHuzYn5IiDv`kXzW2<`lqP(aqi5JfP>j5c@tA}pi0$S3~Tl& z6s81M%2gA#ex3!15ylm!f{7@Rp@;8br`=`}lr*O!Il`7l+M71F9|Wm~{k@@Z zPE3bh$-_8Ft75Ft>aMy0QqsBm%C$ALr={Ql1RS88!{kz}*yySUb9)v?wTHe@!Trd% zDjww9qfXnY6RQ~rc_A=JywFh@h>e?&^ro=oEQ<#_@s-8d4Cyy-5}nfZ#~I5^$Ha8u zSoVw4g&b-nw|&^Ah){KUS{guoWr1>Y+5n1Lh->Gkqg5)99~L^N@nOuD1Wh4qp>J`W^G4Ueq+B@~jGx|0ZFeOBGG{ocn3!873*_ z=X_@Z7A2;|eIwF9xv`}@D83J3fW+W4m?eNHC6h4bW&I;?&N<)H9xpM;+kXTf+QOe2 z55GLtt{|U~ZoFn=(BQ7j3TE>mRUMz26gx`HlIdyrEv4R^Pdifk2A4JBPJ;>$zN){@^#>MV9k zynm(9i>6p!`3-`*0b_0Km-SEKO{O!20%LvvmoQ{dB8iB?{mo_NfdozF^=Z5eRX3~Z zwb5L=xpr5m3HpK?#m?BD<6*q*@xjW++)WhM=@%-{T~&SS0{Fg(*kbc(3Ej$330@`V zZ+`i+?yqzR;femBzoZXn2|;XwzV)xa>oM|*4MKq|?W6VCS}tql%=Cq=qB_jmg=b#br)jYDI7}NUDIbFq zObWuA%DCI|i`+`a+SJ(OrG)){O|ee5&swWPCgMWJ3ypZ;^U{Is3mp7X8GQ_hrG4&) zQhba8bKy3G+-%|V>Jv*{pa0sRlI3YS*J_>(N=G?utkY4jT&i0(lrV!Yz5uQhSlD9vfs-zTB%~sE&BCH^( zPvaY?`gwd~WpsxvnWF6L_LK+1U4P_!{`6^H1BtyX{i}YtRil0Rw(?jGjZXD^USn0b zb9YGhJ6!wz=BX*XLKIFX*Y_q$1obliJPZaff!-w+7=H4V*l?XGRCYFpaihUmTczlo zlEa^+M!{v;#|+dRU#m{I+#<(6PPndp=CmUd*;RfM6o0Y({PoMerXAnVJt2{*M)T|l zGyp@-+n4;1(;gI}Rz@}R$y?g)V*?LMHY%P#!VT(DpgKbj48ox_azQbMW#zw} zKm#DnJ@!o?`8FkI)){n)-MPgS8DZBTwji?T`U3&i0dMaU+koL+uIh-TD9Jrf^ zrHRlZ(y!iHEpu>`zJ6Z(RuHuYBT%Ab0u3Q#;fUci@Tomx>YyVSAKaxvb2d^J_0|;1 zpO|B$44%+wMO2Bj7q);{dD|yXn^W_!-X|hWCMuEiY0mTK*OdA2*K2dL7kFb~pbM?| zbsqSpUWj4E7P1fnI^SlC^!x+sCam`nVM9ZcOEuR0?upL~UZfPlr29y#%TJ{Kt@JW_%fYCVU=Co(~ zv&`$iEt-d0BBGyQq5*!gC;$9of^gnoq&XOV;^7kq0m2b-%N?Uvr`a;q-uKSSu@q9% z*(X*t?J$UI1dWOezj3mhixg$;D%DpZpYK%jm0^Kk#a(!=3z@lik@(=vsrpx9_$HU69t92(pa17}?`b>xu)4Py(#q3EMA&XB$V775s6yN#V znzOcb;4bxN^X|A!fu_m+v(OcXcH;^^VvB(f zcIo!y^GK84UiE4>CPL)-bLh>SkJKhRJc%zF-jPIw-%*CR7jLCQLDU z6^GikQgBDBqW0$U#}i}hgoU`;uN;3BE9h?Xj{V=?wAW93xU}Yp|Dk;`De;iR&aOuX z{y=>29%)-!e*FJEjyxezo&SH2ikYEC3WZ?)_b9G*gqk*$-+#{yPr)A;L%;vubHP)n pl5lZt{@)AxlU%&`|Mi6qrOxj5KaMr$G$Vmux>|;s|6aBV{(q2qKK}p! literal 0 HcmV?d00001 diff --git a/gan/gen_images/img_100.png b/gan/gen_images/img_100.png new file mode 100644 index 0000000000000000000000000000000000000000..091505f9c2c6fc0a8bdac8fbda7d6194887498a7 GIT binary patch literal 145587 zcmd43g(6UW|hO zJad)Na((4s;p%SeY>xE8*wxX_!PU;%gx1a6*~Qwyo|~PYos*T;%GK4;Meymm|AM;a)s zq=RS$x@etwB)DxAE)E;>rv(50WMBNj-|CWd!)SQ=U#pYn;OlShGc4tr8Vbc`!}1yZ z7=+K0bSbCLP@kIIG?B0l6Z?|35F%w6h z;@vEZEj_(Cc)EI_Ir~<#?NFxIxKeA$xd9(HeA%t(4${`v776vJ*j3>T5mJJ3VP#`u zlu2boPmfIV$uDn=P{|)ZezYeW`b9c72y^&VSL(773uG$S>#-w=SIg4JN7LCo#b<2Awi_{n0;O1u!U-o`WRfkeckxB8$qnB)5(s$ z(#w}9NY|78=PyYNf+It((It}y_8uO2O}u_$aR0n3_g;L17x{psSgal2Txdy`u`Aio z=2y~R^?Wx9)6__e?-k}7-(ne*lj!Q|!u@{y=lHzn#JX-yOINq+ssGt?_2SomcXn{K zUKNVW*wo@$eJj6zeBtZbq|cK+Tv;MknxD9Ng#K z69!W3PMg|XJ@!0xmeie@!(5EsLt|;FnztT5MLe>MBSy4)dw4h8n)*}{-I_!`x-1=g z-JxuGGLwGsd2zSPrnYm{xdYx0H-7Qxdh+8lwjGV)(3TbvpR?6ucpGeHaluU4ym9G$kmE}aowAXs)k!+z zDN}7*B$1A?Y#g`3&S3f_lrG;s`~FDftlgKHE#&7J$?Uotab8;NiU>0^3&)Hp zo1TRx_x;`Lg*GX!)b4oyOH)cpN^A_*yurZqYJ+k_a@!@-Ct=SZ`?~1hV3cR47VMY^ zmu)v8JHB-B=Ln)d2(5VK!eGS$u8+JP`zxpc3``Mw9+g_%lZ7vht7nx%hwoM2zjokD zhvSbDGqZKPk{2)9`6$aL2o7=EMN^xUXckS%415d8oB+5L>MTqM8y@ohRp-7>wx8`_ z`_9)pp@^N2$K%6!NMF1}6T8}cIa+!tK#4mvGD4rKlsj%^WNVAH>3U8&Bx>I?EuZG3 zHjr;rt;L%1=~Hj1Zk)d%3)E@lp+;wNB2s+PUpq zwW6iNQL(;glBZ+4C#uC$aH3_FUTyrj@fM~AAo^j)_hY-SC!-J1@%=l|ygmPat5x-= zM_yz4*0nn5L|J<5kAy!&A@x1)7!`q22fJ34naHelK&q&lKmCQBy}gOMyZdim(rCP^ z{1*ysFN&wq#JQ5i3ri&!2|HkM6*V;>4y|Ws%7uqN+|Qb(KMG~y{yRBw^6!+hG~GMoI4IR(L*(Msj{6slVtDPH`Ku-lFw_=UoT1M?D!|IOZ{MIQ$b88<){i8HJ^X#^?JIt~ z&8q3qP1jDue!E3=&Vqe(?U&L{=Z2WlQnnv<-%KOI$*cqYCww+WJw-gTzpcc~9Jo*= z^zcrNv6olR+MxuE{yi&?VoAab$ZJtF-r4uS#|$;9p1r#>vy$J(sRqT1NT26Nwo^2(0} zU@=Hi)oFZpu=17DdRpeXUZ(8FYYcb67cRdU<5Bn;6}cpb5Gg*sqpE8%wx1|TeC2*B zLfvO3!jvyi>tkiYd7jzFCW$kz;T<{!f2|B2v-tIgLGwVdVfy9aet_L=x2{dss70rg(6Ysg zT(f49#4t0idv$ZM06W3K!KM{o=eEQ85P>}=1T*~#N*~vwn5PxIN3jVw-lbx70`w#H zY4I`O@!+&idf`ywhGVq3HTka9K8uunh7L6ZN!of7C>|ir!2uT#4qQCE%5UGobV|cC zikUEp7hcpXWhy^9zY_gA^|hIQy$2Ra7)eWt9c8XtJcUMUmp+VEK7&;_8R^y(>)gOP z<^d%@hJg}y@cMhJANl)NuU={C>4kJHx38@|G-&n+l+B}?0g~f$F!1Q~6cInZ>AJVn zf#P#KrMYqJwdW!1*t7s2IEwt6zyWGbv1Bi{!Nr4~p<0uV(B@jHGOS2kD2rqPcB);1udCaKPb$JJ%2IkgEUL zp!f#Z0m}t=U`dL?U_0kT2}H7~O=Fhz8dZrnxwtY-Kq%~*s4D`vB6SIFo)6N(8tdk8 zvPK^%O`HxvC5JVb3gYyN4qh`_e^AA;$EizuT+(htiTQx7`kC-<3j6yAj?H8EIT+zx zK=j^yQ;_M$)<<|xB2Qa}wB7gIbQOe}c5t2Xq-lX2lO?N1fclN`{eSD8bgCAf!qlf% zesI7fyf%v0XEE*~1JFs9&q#5Q5+Qn_2yeSZACK;H$i(k*?{GUlM!tF*FxaP%d}lvy z3qLJ3G=cB|3r_NZSMnfJft<``yWF1|f4`tO9_9`4n*sfO0+9|Gy*XmGJgm{($ zrNmmWsg2r-!{-fsIv(lOf(!S{o~3gZ;CIZZ(R0IQ`O*pZ?VG#dU3bc7o=7zRw&v#M zmVfx(QGgPqLL`wuc1+CY6dxEcfC1MGrEU34FhFu2f`F`ZG}dzqk^Q`SEEa!4o9r(~ z{{f4F!uc6iH6j*7(88DTa(sm^VmmD zPfy=Cxd7CPkfu*bP3>s$K7p12`1bzZvefTG&sS}GGHc3BQuTOGy~?8#M2ll(QP9!R zp&9wSgB;z1oHZH_^}Tp1%16}ShNtZt>nO`uc#h_|oefjP;%@X}l5OeCZyut+zJ_QBPv(`vG8i|Sc4Y$D$l zGD8=^%#}{eyT}oJ2sn=`m~g#tSL@xj$upE60Z72Bae*DGE4<)?*7HA4F8^AJNi{7H z69t%N2T7TyOQS@I=~X-R2R{#;59FsHoZ_*MIH_6>MgM`3dSHkaM_PLpExP`C(poYL z`{1>B)A_8WzNTb|V6E(vwsXO2+mfHXTc>0>@?6xPqZ;+t?*>Z%YJ^DA-M+ev@5N0@ zBog_NWOB#7!eXuV*8jXRvd-1JlyAAgOWW;D7^~~Vn@fJqnns6dxh!?=*HtED{f1pp z{TFk}m+Xxptm>9w-#2L1TR*Wgl9dY?4yB)Hwqcczvm+sz@f#mW-iJ=dt!do8t|y!Z zK0LWtb`=DQ1dj>&BmC%|1bIeAmtqy>>~X7zDSJK|N}9gsHSH1Eaf-?8V{+sFo+|bZ ze?_I>(E1&i)-*22*&0mN?X9{Z+s2w>UvpiXB>iy0j!%`9xaXZ`CVrxEHzzq8K9ya; z%syj|KiO{a%xf$?OdZ+pYW+2HZz|(p)58t-YWYMol%14YdM%rG2k_QI*pF3wWYd)% zjv-(|Pv@6qaa!7s_=gj7+k8-8U^BwIpsfI^cnj(+Eo`O&qrYZ|6FGA!JvL`PmnSOr z2@KfbgsH;T$WaLZE}l0|y4RzoO0LvL7KUP`pHtZ+BT=~f$k@|oo8$RYeL}uRo zK0Ny!9vBKo8oDVc(7>S*A&B*U5xz~cCirU7ay%B;dRLbeK;B*CJJR$7Na8sv__E5Y zs2=yGX6^WfhKHBehSLwIFX{3(56?Kn#Nv%Om_-$dkC>Ab)g}eWV>_1}jr{zm>l_xL z@OG?c`Nt_ebYWe&$oI`zpp!*adp~UPK0s8KI$lcaPmA}*5_AK@;wk9_l&49)fXW}! z*6tKu0?yS7(mD&XkosDr&nkSf$H>7}Sc^#= zu4a5`Ih;%pn_5RN2sJ)0#%&4>xm!q=&uk?jF&TNV1sR*EQ^t1JQfTP?e*OO2$Cy?3 z0UCBeSvIXeM5_xTeso<*fKrwgA38{446QuDG}%CFUPgav&2f;qUYrn|;9hkfF;Oh0 zBfrRF$#BQi&GVn_UkvOxGQ4sxZQk?R4&ynWCF4*E5x=O9Wq*p+yieYGKaum3t!UP+ zgKxX3IM$x1EK|;0lhVtoeXa35ORjkkc_)c5#IqgJM$5pZ}X?wZ9c>W2?8+i(yy&K zo*?e`Iw&o71#Z}q6s`EuQ4$w{K4`qap(yojBVqc-W0XLS^3!#kA+AqLBCaz5Vb(ZzdD%Q4 zJoWuc{htU|hJ9hu1wkKK_T;YK-mv=4(=O++KyjoT6%3FRKuLlHsIdPk1nNYDnKNq# zJ!-Zd`}5b`D$F7Bj6r^Fcy)7Z&S98!JJ#aKDP=33s^sb7G$eN1>`x4BXG0t|o{pnF z($Z|0+@wuX9FQe@gnjUJlb$0@RhP%_U!zLfBF$bkS<=8{Z^@0l2H^qM7Z56n3+#zF zLRJGhyhe%eJB;wfE|>B4pWdvtNw+Qb?d-5~r4F@Ua5&GbALghqFP$B(Pn0=1IN&8I z%8*Mt#wUzZQB$uhcZI7}{mcK)ex2!xI!0~U#ZlW#$(;P*P;3?f@v7Gz)leBPVJv#n zLYx^_q}bJ@SPxWPmEtMT2#?|JyJ%&;vE?snGA<@%4= zS%R5>@fIUKH=Ujg^t`I)fh&#zjN;DfKj-F99L<&qH;suJRRgCw8hanI5N!aw&6FF; z)y>HislUtB`aN4%ikd`$sVy2Ux~EpeL)*nljK!6Tty4-201Yq=%m4_h?+Q}>0aX&w zulOi$I1Q}CC`f^G&kG0vyO}H^ZP#4|Z&g4QW}X9by+*t%VIG#hrXg`LW4Jk@8VvN< z3U8u0gndUH=wmS#^my-j5tEa6aj}0Hk8useqUtk3E20P$%2A-wL!4ZIHpVF;5^GQ% zu2?{y`AOa^A24~?!Uc)?JNA^;7b)FgB?|JBOVZN+Gz(Y_j;LzXg#S|aHqKv)&BO(#z31nGw;l8c#ezF%W$QX}Ul-vJpX@B$ zzq1XkCpMbX`UurM!l*t3$}op~h?`Jm-1o6h&?y{m&BS+94<&6MdqHRTV}4$`R;Q<< z;|?D`Kk8?izGtLpS8>t(*s-FDqM8iUU3Y_ISz~tX%-ZeiC=L$~q1X7>cs6AD$n+&6 zVZHy2D2RO^-2iI9-_U$Z<|O3DzTAZ2v@{b+O#eN@j%q_+epkx(u9r`HQ>HrRbn$=&^?{Ea-o?;ROkjD7q)`+fR++*NU&_?D(L2{GTRw?Db=A zj-ukP;G402EAT5P#_=alzyzYIYYP#%FO0wWSb1XEo`DqRl*dktE+o- z$NO(byTC`FMJ}8yP!+OdyNrrebG%FGUL8)LlX*NI^Q2||e&yF@mks0`idW@`-1g!~ zWn#>(PwMoZXUZeq7fa@h$6K;LtEj>Q$O@m!>>9?|8XMoaxy-t8VP#|cpPq5s44PCj z59t(Q6Oh~0%>mIo-N=jIbGROEli(ozAkM2}qgM#WRhph|6gAH10@nLMk?H8d7x*90 zLF)&b$6n}0R(zJm{>SU1S$TTwh^_KAVt-M(`RI{4(ct7FM)GkC(U-cjUND%6w2ov@1_I3^^t20{)p`z)-VE~pz zMUR1C{N3F}47`7Y@_Hqpy3dx>UtVW+GU`*0N#a*GAV9+wufF!921~$tfZINv09hVL zrV29=2ra1l1r(-kZo~y@_ZEE)aopV8ev9~sE{b2u7f-#53d@^FlG?F6exd&X!<=Jk zVEs^`K}_wR)%a-lj)Pt}Er$J?glktSh@OAtU7;j$+WLn8^U>1Q?&zcOk1^u#$mKwf`^Q?1RW-{B1fyUa7b`2JqrJp~_Xr$x8B~~ z$T!d;RBDDy5C`oa&h)(WrIsCj@p6$cXK{8``+p~Hd#-NP0gg>PwFokju-~OtN?MsA zwh`?gZc=O$Ko|HY_&$V6(paeNNJ^g5oQ4mNY~9*2GpXQ8wMw5BcabI1;=HiYikHmn zP_ZCpJ;6&opPnY3*yIttI(k)7Ue1sxzZ8ron!vo^cf&05S)FBhX$c8V;IbnrEHO8Q z>AeEL4}cIz@*pRHhe($`j7jMD(bro;W(u)y_kJQ6*gYHTN_QI@(Nh!q*<> z@3iZTCqc5RAQ5P2XzUF<%EJDwiI)d`h#g-v$fdQlyq7B^Z3&;BmEabdl6Njwd_OA` z2Mh0(h=`spp&WUM*f}^1p0F3cTkwoP*4K>6s~Ye$ZF##85pif;Nhy<6{q#!v>>WYF zr0{>sj`GH2=OwXdsD0+@Uzx`;l?&T{+Yw8(jv(_2FG5iQsW8j;AKC5JN0M`nVE>Sm z^Z-!V*x#Q#Jj^3`M*7d5$8UsR%ZZ}O$E4= zJtq6=&;P^DrLlNyfJT;DLX8(nzx>SR9QbFBioDNSm!8;Am-$zv92N0OE$Je4Ngz>f zMSqtx*ptCw07DWaQ+Rcs{5iSkDVMX#l9vETtjsX;jgusaO@9^{gPGwsUBQ`A!w<+I z%t##{ZM(u_j7zC~V;A&c*dlRoHJ_f=vAg((2zEdT$^yMK=NC{MMYOB^+Mf2$Y<1QN z;GV~_5l3rf^QCX6IQR38d2TTxo{4VHS5IS{X$nw&9KwUssG^*F5M=vBm0Vx;qlCk` z9{B@|T(;k@q!*hFcEvN@M9rq<4*qpl#w7_KZ&|$fb;7vr z;^$`&B?#CFUB0y$$N{%bAJ}{f*<;Ls;>p$oanZ_xwD7=oTTZBVeziOqW6gOYyYPon z15j#frX1_8j07(~e>lz6hTJJ^Tr_&2wj8-uPV1EfVuf2~&e>(NouY%r@Z5 z+vE?V!NLDRSJ>+a0TEeL3EGf`bg#-|GkQRBypCc&X@k@uizBYrw^N$nxYh_ zDf|;c@zVb13i5xg4i4P2NNMETMgp98P9dS_)KoH8K`Ia}mw*cR1-gW=1P`47MYtdoLo!sAjbE|)n8pM^k=kD`}wCw>qB#N|#2IL9mY0~Xatv@#ws z?9tItW{Z5+YuVI)Z&#^bsgLz^){7XovA_ zYJbX880gj{YYQN_23DPyK{q%(6uUVLeD|Tm#ti#A*LhaGXmxcpD8=uB3sC|*UNq>* z@}*NT+e~a7=lc|eWel!z{kO_>%YKdT_P#Z_{Df%fy^>H(q`f4MJrZ?4)_{aSvh4sU>w4b^eg5Gyq3DF3sG zl)r$!DwN_<4J?pEWI0H?!7v1R`{!5?Xv@;RhYCxQvT(H}!IA9OnXMl`f0BEvWH_}B zi9XtF{Mps3d}GN&-XnGyeuIB=Zg^v>>im*IXg5{4a6j7c61nYa+X0`2xx?qrpV7XCt{r;X+1Wv}i-6)-TwJ_T zy*NKlWZODx_n!c%*4J^?1)^T??3cSvEY&Zeqt0J`V`nFi^kjXj_WnkBC+3vKg2E`1 zPflvyzq$9SgrcA0rPixj%QTLeyP36h7`j;XMiNJ`m+;tJ&zqI+M+wIug<-m$e?GNC znmCI<54WALuN%GlB9YUI^x$>*7DtbSt~_NSyPC1ajc(W9B6Z9LJ!QqZ18Sll8I~XO z^B<;-nHw zcgRQ-t_LGpS=%ZevgBS;;5h&`@GtrVYq5qwRSPt?^ zH^Py7b@l7NR?wEZ-z!rvEbu4FOS77pRwo*(1AGtjFWyqCcp5P{eInn`Wa-~quAvM4 zuGL|y(J2k&DFQBXd41BBEZ#SHH)zc|xsoq!-AYRj%Y4a7`TYPR?Cx7-7cwqDMraT+ zKP3yDEL?N;Gq3!_etGYT=ry_FK>L0A`~Ay`=4MtWQ66m4*&VkgCfuOJHNl`v%%`gD zKBDpPQ=kb1AVx|cdQ~|2cvcPU59Z`Sa1el|UYne(RY#=t zr`WlZ_+Mr>15gP`vKI1`gS(k|z7%cJeyBdj8s2zYxpREVMvMiAWpCTTp8|9m@K^!+ zQE+Gk{Ex0S6wP(&ZI)fB1N%{|rm<4SDhF2ydlYT!=T9wU^kTYA9_VcG->*t$8XK0^ zeVq{wmpL`{8mV+rc?~F0xKWm2m%3SyKqE@aRTd=PqI-?7o?ldNS z&GG;!BPndKo}HbY)M~5xIHHaDL3PIZPvEWG7O?+T4^mma=(~L_X{{R(hwn;yK za`TR6iAJOKn=Qe=N)k-|xywInY7+*`KyEUEe2D{4u*A`I2rEffP80h_b z;?~4Az6LduG;l=0{6Q()au9+lO10y?OY0rkw%sl&S#&9%E<94&;uJ#B>B!@FHvAt2 zT6HUX{>e;55VcMMJhXu&S}#|^{mh~Wr_oR7#Ovpq$PaseQpu8@=6knbu6&w`Dj?3E zzwp81(=w)V#q=vxvH6s3Y}2{Rs57W^_I(z;>-Sy%M?tSkHJC6)>_$lKUVI1`KWD8Q zYX1%nEBN6FmF@czDiiCkpWx?BJh{I?PR;p_OzJyU(PUu^a?cmz>JM~-_1EV!ZN1RO z-7*X~Aqwb}BB|upRH!y>iYpIilt@UAY_}mlv3qm93rqmaW)2}CEa=by8>|QKi5s;P z6fo_dAqfyix3AmK&+9T1bsNglDa+S`fcbvF2&hGpA}XZrfQWxq=b9AdmdwDT5$#^Q zT3Dn@9$X&JlY8{Ba7r=Ig8h7#a!X)Z`ywNDbj9UM#RfIfq)D38!; z+sKea%M_(oR96Rs@{v%-Su59uhh+?R^YOzxHrmD%2)W%}nlydlov@N5E<$6YX%Bt| zE-3`1mF9r?>Ck9(+>nSRQMGoH4$Et3-=W_2%F*~TrgG`1Y-Cu(1tWih#vdfo(?7-K zfcY}1qFCbxrhhRLxwdu1o(l(yqW5}|^T(Sq@}ESiI=MG3fCmXCuT|aL=~}vj5pctq zbf56%Pu}>Xu8%4y%hsmg%CWGpJWdwenYIt|gOtEbJ@(S4pVQRTtgNgI^bviUcnTRp zt|d2!5r8}f4lZ;Meeg`aPO(sn`a~4I%!*p>miN@~HcQBx+!WT>d8>yyY|s#D&xq)@ z#_HM_T@^Vs6_#&TrNzV>f%o0M3E%w8a&{#T3m7 zhy2&&r7$rG2>~|R{`JK!;$rdUx>B6qbkwGiAxvT_gJ0*<5MAM7L^xzROy0b~$?`jY z?A$85(i!lxD2URu9JpPPKKW z{ui4w1<4sSlUu#P34s>Wu_SK(4Z3&F!Biz#b;ns&&X%A z$+7hzVX+ka(ian!d05>!pZr4bXR2f2EU#Tdb45kK#mVmT=P%x{p#<-vkkgfD6oX>d z1%a%)oWf5wBdo8-su0=}%s)6L*tzoFiP@XHmOSqq5Must&!uU>9v~i4R*GrVD7bHF zSr@)SYXwKT#8N*b^bo>(plRP4KKpg)4Z5`%O9t%3(V$~@fYvNN9sH}>zD~E~#;+|N zQY4@QlRPz8+MFx|UDxCK@)<;Zq&IEq=D3s(UeKG=>b$6O*odN#`_`94@{u!`pNE_O za~IiUmU30qk4_HI%uNwjv7=nkLH?5)JWSF}PgCq6K$lN}&#Q~6(J2kOB##bKAFDLZ zO`?Pa7a2iwNQ7?bM|Fe=>SMGhkS}k82fP!Vp-Km=d%3DboGg3@V%A=7(%s@DHZC($ zCmfwetQ?&W2|y|Us0K4qjdz#Tbj>9Nv%g`)vX4dOgDrVsHW^Y>Vhp1!KGn%c+Sl(*E^&GMT7iO!7c@uA0bHjgh2RY{M$HJeA+ zaA2yrSL&8{kKq#vbyjEr)ob(G3u}w}lsGd? zNx3%&iU*`opbmkO33|mX;CcM}O9s>)vU=g?-m$yW_H|6PFV;mauKd6`9caVe;520g zY5;xD>Dj1%95f4dd`~3*)?8Ttx(EgRmq&0ggP=;Pd1vtrEp21&^8@QJ`=OzsrA+r< z1i$t+#u*|Xj~580PV|D^dwu2_ ztPx{bA?k&r10iOh65!kb*r}m@@K#^{dg$&~r^0OH?X9a)1sUxzj_|FLS46Wap%18= z7RruP;Iu%%5(PEIiq@Gel9J<1Tp88Ql#^?Nk2&&HGx8AVF!|+Wy?3f>NCzxPQCp+sd zr;U2Ymp6D#ew4P^dH>#$sg#Aw`bTJyCSk_+1%u29e}fTTRCf)!gU@~sN#SQ9vdEy& z?%ijZ${u7_)2GkP6^M`NFO`p?n3J65GbpC5E%#aK=6r{^3bXT%m5STcS?JymWNWc1Hsgh| z`q$WH8?B|mTb*_Z_08<=EzbQYmoEHCM$z5uB;k}6)4FS%P+&mBbv&7Z6q>;P-{^Ux zg#=-##`6j9uTy_gKRKy#1$VFqyP`kR7nhZ@1mE@^>v$kP6vn2eCTN!?_*=mU2zd)V zIQZFHY2z6o6<_Y$|BP;cX~{)b9Xm+NNY5Y~@!dYwZ_XHhU%^kZc#5UfB=%p-dmgEA zQyxtGs}sn_e+=qFBwG2gJnubO^X7P}$xR4(Q_P}&nz+RhW%`tQ&rR=MYX2+y_B}#c z?{jGX#lbJw!;q=qOMjEiF`~WO<=fw`r(;31c9|K5wCC&>sl;)mG}`64n2D^!k7R6k zcY!<&4SyUz&ym6UiC@axGJXCiuP0lQ;DN~w-44$624)mCt&0F9eZ<98tC^h@e>i9c z*XWSoSam+rA`ULoluxdcyHS>?O1Y;@K@c$f`_04WB;Nr8d_J+<^vDrT)e;@66SmcD+^;`R1o=cX%W%#0l$Xo+Sw zjw2DmFJ8RJF(}W{!dno)GYg6dn8A*amWkEI#Ma0SG7qsIzAI9kKh9Ms_Bw0J>D_n` z3T-MISnkk1-4ZpWnK|rGQ}R2gm`iI1sXOfE7V>@56nToO4$Ac22P#!qgDzz3n_-P1p7eyLG^AJ3TJ< zkA?dH$Qk))qT&<=F>VPIlq8sq0KA6)VD#&9-AZSJO?IOaskX&ra2E}S>mS*&6^GsGHo2$L{% z#F9~;Rpm(0;^Y7LuxS!f+qujET^2m@TW*}r?~uE=i|7bOzjYcQiv@H(dUMknthP#g z;G2AWe1JOK*$Z0@wL0-SqU4jkJSF*ynW}xPf2H1}1~u!kN5{vGPE4b2@@PT4>o%{O zszjeW2#!&_FOF+P^tdFA?81&}x&qR>tdZl1BIV}7u4Qo$s5(1?zUPWQQDv^sN=OY= z&JsdR_-AX=>pwBCN>E6j7u?&cDvrosch<8LP8JF^_SGjRYO4qD2dcyBM%VA( zO>lZhzG8820*Du6W#1l=(RyjvY8~G1JXJ4&v@5NhItxe-d!SD#mV|!7;!Z{`CUlPN zr5ih@p0V}^8v@R^Uz_0?LkRE5V8;Cf>QmWTd4L{^oo?fI(j5yYt&HZKmqu zopBzPI%%v(>e%42yUsKCjHsCpZH900pk+0Uh6%WPX%j5JU{8g7g3HJd7;%ZqNEd>SsX6OCe4c@*Y`Q%3mE-3*IP!KvR>DWs0B_0Z=)RW>`EB#|Fn zS#V$M5xefYAq5o&PGBcCq&fjQ8IclIi;gzGfmCJmp!$U0&tBT7{_LLr>*CkKo(Fet zGpKXhx11GH3&2Tk{Ug8yFf4FByx_S{TUe@DJ=;Ap5@)sFcsR+-!`i=9GWK=Bz7K%; zm;a3~K=Q5l)%Wvf8ipFe!1%6E=@}>yoA!dcn(?vHSRp-j8x(8LwvOWzCqPiiRc8T5 z%8&?MV+A>Go{k8u5H*LhG=h`jr;Jpu5KC$)ke$wQ|0`SY&hP#C&09$KaMn(PwHG2& z9D>nLA)^JJmcs9*vKjH{gbfngcK^d+{&(I(Z*z?b+LHd8h8dK-r`J7g_!6>P9GS|` zFNQ&EM}Fh&O))n&2Ln|w$@97ALrwd5X=Gn$iqE>xV&d6krwh#OBW$Rl6n zj(?q({_YryBW7hz?u{@A5zy|vcr^xt126z(1ei`w`?9)b^gxNbQHicBGAKZUgg-Xy z3b8Nn%X6Iy^0PcJp99+U`yklYm=CbtRg~mt)C|c#;piO==)ep(68kpy1}sxxNb}8} zuV_0!j{$}Ty!4r)G(k-I4eM4ZvV`7W+($2X)w0sYWrF zsZr4}8hXHE83_rlr6=yV^3ZNbJ?wt|!$3~=)#Hi&NGS8)zkfJ7n!b9%jM2b;6kL6p zFn&IBk+>d)F{%)?C}U-BkJ~<2BTmlIW1@;YjU=x~c2W+8=Lrp}KG=k!6fiRf6d&d> zzUBKkLADByNfeYEP{<<03km-_EI@pLY)m%|{;*xG4rHD^)-&DlSRhTs`P~#unJ{@0meoAJMWoYVX%g3}lavI3^xTci|&n38i-a`bB-~%|NOJ?mIzlsN|hZR~;ko zkv#T?E@>vtgf6rUQwc))G{n&|ik)c4cWxUX^$bLdCkNR)7#d9VviuAUN`~9k(mxVg zMLKPK(61cY{E0FeT3i2bQ2gnI29_MxJuYb~DmyoeBNq>}jT!7vNj0r7(=qQ*+x$ZW z8PC8O)we!*od#1*Vz%Fb$q#0GWzNsYQ77)CdfC?u1|EJHN27nOUIzDU*--%P0|h2^ z=45&BPiAS?3gS`1&{ntSka$EJhi$Io(<)q7_Pv&vfC`!Pd z;m(Wmw8uY4F#uchr{($5WeU{DHu&Jc$!x&NAhR53!HXL%b&B@t44%aASZFHS2{hTCO5_YXql!eVU_aBAJ2&`P z`#B@313Ug`_R|k^Cbu0T^Yvh11^r>J zVFJMsHmT?79vvjZK;JbJt*u=@_Hw$p_MLBVL5GAhyp8vhm_K__gk@2tNE|O$Q~2n5 z7vLkz*MT+#l$J@p4_hCGDe zu2AD49(A(lPXkN}rV1dLMzmN=u)ng~d$y!)wuZ9&l1oTu2VsD+77KzA2+ENCr9Qmi zei0RzVRk9}ND#LN#wF>;0|-!MfX7Y>O`_C@_sm-iaTx;z29v0LCIs zAGo?|PM`;O06L8)PoBVA-aYIQya3cwiwV_WVe5fZ8hB)oT@KVi_n{$I(n>q8uLXz9|D%Wp%DE!vK0u4YEV%a`S9 z-v*8d4LYFlN|kZ+YtuE%86!&9f&#PaY6Yvd%!np5DA(U1_8J3lK0S)mQimas;QD={D>)pAl&!`DToPMsYCVY zZVa?w6weiy=MMUn5-DDg(#>uqjq?LvMibq(GXEwdIz-LSajEoGW{hB8*m}IEEPPiCfG1CpM7%qxzN391s^(&@+(DtM4Jnts|KO zDW3`7SpE2z8ADXg(T~%?#P#IUQ!c)QA;Ukyjb_Mvk~!4!htCfMSOEbiC@b3bFx<_M;rB^M$uXdZqyg8EZ%sAu$SO zVusk`oAvTE#Iq6)1{lt2*{kb7fdiO*eAPkmL-qu`(0l)e2_i%YJmyM z&f=6gYRpg=6M-?3+qjv0SminG0y+RYu&5Quq4h(xo+0d_aobK20p-B5V2YypO@TXc z=mJsdFALNrOmD*z#Dl7u)xhARh+THx&f4!VXh<;z^>uAGhj>JLL;AH<UYxEyhA zt2XGu8LEn`L4G{;7~>hSti)D}#KUOu7S)O7z|>*0vdJFKA^%DC4gHQ8JokaUJ< z$nAVEn5iGRI!Z>BJqSoka>`#h^Gx)*TXc|d4_XqPLo(zJrOY=m&jaasD``6c!*h`V zf7i80VqvcsS?N$FF>om$SNp%{%Xh*VTZzy%Emr6t8Hg}%LlpG=_aj53y%(E3??YEL zp%7cDV~teFF_9-155KH{F(OeSmh#bz>=SRVm^@N0S$eKbx2A$e4V5Y+>lF}1?};V> zxu@P`9rv~;1{x~td#?Tmb-u|R?{+i*hGtjx>$~S19XOd`V}o!9S|SBlu_hIp^sk3@ zAT`~m@&QoQLzo@2A})NT6%Hq0aA!PBon=>!W{Jtc*zjty^*iZ%XZ{DmRQ!B#;sP%; zf4zBOdrrPm&-{!Mw{nCbv0ogWn()d)uUR#ce7>0I_xUUdolWI;O555rYp+=WUJu`h zn3$Kkp0To0Ax#$DvN$auPwA@qjbv#isT%o+m4&MYSaIoc=gF80qlajBEmyR=VF#ED zg@rAX4Sj=*1sr&vE!{;)`osk8-joL{;$Hd~k%SV1>xaORCwlJ(NUy7%aih)PFl-M} zJ*p((cZnynbR^g5JzM!9--V5N<)V;=)>g{WU~*$3zRv5Jj*q*nF-TuY2MCeP{?9hAp7Om*%{~k-%;x zd?S4bGwDQG^ik5kK6_$$YmYUq>23b2X_O!-Uw)QNI9NhRE*$ez5hB|V;4g??&qDnE z^(gamw_!+`UN*%hqv5=E#A{EjMa>hBHDB9WayNJP!~wJX$L(M8N!Ic!4L`Q+v35t8 zod34!`EwemYV3x%*z_LTmBaZo-dOT*6(n2h7>gkbKTAwHBzmow$3k98vRGSORv)~% zJIP2{@f5@!54KcsVx+=g9awrWW<+>>3IHRqtwrJA%^Z%lh!cQl9GXDbyGEMT#{ z&e!WZ=0Ef`7CY);)>F{%6!fI5ORa=s1LfR>>l&2t?6r2-=|K0mgja>4s){%#D8s9a5s^})9&hr&}`Da@WqWmyThU76rV*A+;()VMB>`CaGNjz z%QnRQm!}+Z3F%!~{vRCF5Urbmf z`OF#Qk4Hg-Fvumz5oB?c0!`;kX0eFiG-|>BuNO_Gesy=MzTVZ zB*`YqN~p+8MrA9aVPz+TY`(YWd4GO?#P3|M>s+VngqPRzG4A)ySRm9(<1m@aG>mp7&Ljd;ZMV{RQ}rt5>$` z3LAC0U3O^?U_qsG<{s%?U&>=y&1IRqo#dFbC#~)D;H1?<@v-+XUUSm(b4L?OcD&1X z_r6v@Afr#8e)`iF#tqYzE)OL-C7HMXggbWeySqvoHdE2-`r8ypy;Uyyyuat(JwA`? zr_OMeUVd161cv%6txi@FH-&M9CryKTWns8kW&5*2t}*Y-nZRKesppA1yc5We>V!mg z+>#OAtC`;3dA-fC$VD!spp!LR9hdR11bdy_-sKX@tA{x|rH_x5?^OFxay~-Yq4$8p zzT!93ro-#z+bmxC*P$PSbPcfb=Bp_#U*_z6GCKi z4vQr%-i)l}&A9*1Jh`E1{94AVi$+EZ>CJ9m-;TGj+dT$c#GLl;+P}5qLc!&?(@m0W zSEGGMyjuJ-RP9PWiq)y^-4-Lk;5)KeiA(_$(%VE7O`RHq&qV${I^(y$%dVI{c?SY# zzJALNPx-0>iqBDKU>ARf3HV_ zhUvq|?_T+}!ue2JM$MMZwqfD(MOj*sUCeF8r)ph`IJ2gTYPa7UK@Ze>@!z9}&^hXo zzx**_HGhbk5+ObkSYt)Bnm<4ISj~zKUfq#3f5gyNXx2;Kyz=h%G4<2b9q?YvRYzwq zEgIh#x8K(Ad;SyOB_>r-k#CJb^=ggo5;UF0qApAd+nwbsJo>!Gcr*MbGuP-N#<^r0 z<~yC}Zt2ef!lj_-xUAkUnpOuQ6$TeDAxk_98W##B(to_!S{N*klwpfo-G~>ufhGqq z0g+HZKr=7~RjmDaOa7yhO{n!SSgnKgrz6GtoiaOiuQuLPN-^%P>EL#eO~e_|`0t-A zM-&z4NbzzIpS7xe(M{L7I({}RakEH!S#-L+el^5)P7<-D%N=|Cr#{R#Z^wXy%WL|w;8+To#--Z zVlo&So5r1{`z5JL*waM0`KJ3n>&JB$v^oE%xSPrU`6wzLHeFY~pj3Z7DV`R`R`L{Q z)`(Z)i#x5%lXt&+Vj7-a7&BGle!rIElLLpj)Ufd$Db`Ofq|&yYF40f%G8D0ma__N! z;mB=kn3q%0u3%>q=XUr;LAsIVnBh%;J4V1Gf(c&#%M-$8dx4l(hC<&Q{+)q(MqN+NJzZZHdxNy_K3d>0DpF8b2nFeE9Lp_sxrx5_g&FPE3F`mZ zweRA&DM`|J-DH3}o5=N|3C9tiuGj4{3WR^HCrrLVed{BS+kG)AQR0k z0QEcOT)Hm1GAY@z+26@~iiL}EyoljHC)+2xXQxhD{aISuCc;8PW90kQI@U2DiqEfC! z;R&f6!tMN{>sFU<ZaUGP{!e^*(sdf2^#RpGoZct&m0ex zFV#=3!_GN%kJ*0PkGdVEP(XGZD#VxDCj7cKJ#cHm$pOwtd-Y}GFuT4*DQz@ab-(f* zFUtdRk(`u7@IN^fUkAwZEUjhS8fQabHja)*iHWh#&#PPEK}$$U z1wrKwX3fUSYti`T<>Dgq+a=$cMZ^u1L$5a-zVMs;a*?rsV27jKgu6$6S!4Forw~45 zZ3QHpO4Q$kAjr+zTku#2o%50K)r|}~E~BKi-^FdS^C??qWOb3G1%;0vDQFF5U-x8? ztwuM3#sgpyps>srY(C;1U4i_AdY>K#mWU|UD^aamz2FVr`uLFs9pJvQjb@&~#}gt{ zT+Q0A8H3bK){+kGqw(x+cPLe|SyXE&45_c7Q)SHUdnJJYMjh!H@#-^-xnUP#zUo`>(g}mC$D=cx<*(wdFCEHH$nSS-ysz{e@fo+bEiq`Q_iiaUr?=}! z$i7|M%>dvBstkNxtAojXG*`h5{gyAa>h@Z4DJv5 zdVDbvw1!2E2Z&lfIK2JZryBX;uM6JGb-r}?-<|yl^^)V0KwNe)HW!?`X#OGR7X%{E zN`#kNn3<_#i6hEot~h0b4xK1&_T4?<;a0R-PpH?bPKc#^NOS4cC3z@J)nL>#o1-bAZPKWql|zWw48gD;DjA0cESP zbl67Mo~RJPEF`^{sWE*QAx&(tpIhv?aAKW&ErS(_5h`j_1AlL{8>1!PC9bU=MZ+6J z+WW+bshlZLkIEy4Y@dB*hP}|E(tlI)E15jCxcfavNU2IaD|7k|T<;Bir+Y-oZ?pV< zYcZw8({%}j2Roda!`y5Yxf{`ELgb8)4~B4cbp{xN(A6_-ttf9ffHa}z&(KJ}Zd|>6 z-p<}@Cx6SVk3C$xRqKCG5DXbUu)Q~CNeT26(OJtOuLRmS9NdgL$u=_Ak{1+BTS@Ne?w630+cuD+bYp)kqhI&*RiID7 z%4@~SbxT!CM}bi|Ei5e0+5GpT*O!Z^xm-1Nt$=!LL??6q!>^*3Pl2`O%^~~g55q$l zFNLK0Yd21p(LX-I?f+H)qe9!>4^}s4V3@Zn#Q+9VBB$VIR0Hnn!f9Q{<~+^ zA2=2{2ERBYXvWK* z8WzaNdbV@IX(lySqk}6wtq}~=k95Z`W{c&KI%DkB9nQaQh?_q(7NL=L`F*;u>*?|j ztH9Ii@v0FkRfsycaRx zr|Y+|RF$Fdhr@bTCLHU|99-#>X+E0jQWdRZQ^?e)R@>j`ZW;9=F2?w>FWNpB=D4HB zzRKJ-#%JF-u~1eX78Uzb+RDy03?|%1#d>=s?z``n@|8}~+qulMwy~*Vm}l~9bxP0o zC;Sc?YBP&e>w^>RJWPMED2?&Yr4*z zpt#fVdDWEaJb35|Ao+tu8yEF4O3{ZIsw#-rXuqq%BYtn_dDr=j zc&QdwFR!zAdY>3pZ1ZNf{IHZUn;j8AEy-N&F6>}aIHK1et;aDMF=Pz@4l)?zJgN!P zus<`(CHU$qd%T!4wkO2)uIr!Q7t7h8FWr^uk6116D&`uz&wX5LGk)OP?E=(3XrLZe*!B# zS>Qjr#x!1J{QK+JFior9bb0;`{$UE|hEuL%C9BhsG*yAu14 zX36&rzALzqVO~ZMN#`@^%sg5%ckW)36FnE?t}5ClUoA3bvWpb5FwIGb(LAF^qbn=S zo^ih;%X+<96Gv?>awf}(%)Z#4u@$V$7v4=@dVQV8V>EN%xKbj`+1xL?s{OFY&oKop z=XgHZ_M!dyhw)_TSi9jNADi9d=bX+u?a({EGD&{L+dJ&S=HGat^Tei6F=>=b2ywmt zNuZLnC3)&U@_`aEGAQW>epX%whs7=U@x|-cp%5pfLfq=%amJZ5I^A(XP3rgT9LH1R zDE_nRT_%>c`H{Q0cTxozT#6HAhbtXt!h7Kh78Vb0DSn;|_eJ6BMeEs5ph7IdwIIN|0^^F9*->o<7&B!Q8H z>id=9OyK-D2@uVIqW#9q_5Pr5(+$W9gt}zPBV`S|BYc+Eo3IsBuL3qB^3P_57xBnhBMai1xA z`Q+-!A`gCAQTE(Z95!lUbVzF>RxLC%yBvF9>p{wMS((t3N=jwN_~EDp#WO1i0VMbN zC+$1#S9WD@c}#)o8xk>>;^P^o=dR!LCc+lyaxZMqT<}}T%2cY@;mO|dJiEiG%_=Pl zya0YHA}X3_?orPZX(O!y3%NU61=SCFu>H>8nE;E`qf6gCyS>_tN+G4i*$qsFK(Slw zksDkD=zcGp^9GbBt{t)=`2k>p@MA(yrc5*A$^lxqSpNRJ5y6ttp6Xui{-TeqN5Sg&?bYeF@TEZE1dVqBw z%>v9PccP5Ab8Jy1I=N3@DT6OufTqecKiyb_n>IBgQ^O=-?1#U zG57hK$IA}%o1CM~?U};GY<;xrovrpy7#bnmgtb15)cn-Nrgw*~SBP0zuEsAartEKC z^ez>bOwV4mQ26U>*m>!V)o>Se)TYEAp~^9zn@B~oJxD%AqE({6yjOIa;Ai$H4Uft2 zi?^Q4GKguq>S`9bYdDQk`UiQrc(>EM=V@OTit=s>Z4pg~mbO{ueqviXYy5H5q_E4B z*rEvTBvNe9WFpoI!4pJ|%YP|JKYuoCZf>fmbRQm<4oOc4In*g3ypij_SV%&G8;bz4 zkmQt5mCY#1b-TXF{q;Abo`&?VkID@-z?O)hV)CjlxCR)1A)FvVdC^O)m$n;1sc_2q}nwworLKwS-l4`sG?+j6Y(%5K2$v@tD_4vX*LO=l@%Hyv& zZ4SPD#ACCV$r0b#m2aGT10*{Ukv%)txc7v9GJBrRNbFR@bDNURUd?!ydR5VEA$35J zeA6<&KY9JSCeNyVi!884%Y&S=MQ+x>UG_wDM!WrLLX6-q61q3+CD(OW<*kF#(Bm^s zH8)$f^Tzc;xVHW`zWP0yUP^n18}FT-Io6E}Y}QJFm?wKeK4(bN5%em)frhhlj@B%l|h0u*qz7UQp{oR+hc3aHe}y;KRM5qDu3M zlzN9*sG0!PA-7d~0`abdOR2!%xS>?kz5J6=WQl+1X@;%FgF~K2RbArJ{|rMmf_^|T z+o&)3%X&DO*Oz6uak3&iKCm}DKwRTq>F+;~1hxUo1SFdjw3OmEr!@J7+vhL+ zGoulFb(?~xqmpji>cOAx?uSepXsQUu^KFwqzki2WXXn?+dJ#?xfyXVA%*AY}vlZP2Oj`b~mhG{9--Ehdm z_*?Qw+Or4ao1=ZcJuEMc4tf51O@H<0_wNtB?rFV@v~Y;O5smq2~Lz1@DXRiDk0-I;%3Nk-74XnhN2b_b?9S+R~=pQ z{-?8AUY~E+j#cu~p1W>FUI-eQ6_19Q|kC zj9=dRcbODyfkA4QGnc*4<6~V!28Vyb{P&ri{{rPqS^J(#v=-VA_*yLVZ$D>{3QvS~ z+VJ(bPj+){1^M}dkSSm_5UD{x5dN+xq9RHRRCE(nX<)wX%~Bp2xkpw93k0Ki#iZ!_gsuJmMD>ExfB7+tWvy_-X9 z&hq8<6UYgxVcJY8t#RrYZ*t|z^DxQW*=(oiz-IPgO!DO2tpoGv%r5p>&|;Rm>`sU& z5_<1M=gii8X}#J{Nwf*|gVH=s2q;})al@iS=sik<(|lfrm8W}24pm!Fnjb|K=>6_+ z4Cx<}s@*}~!`#NJo%U(IwLDxXqKTl-tO!=x#P$}+Lz;yVMdLMM16Sx6r*nH;kFUr# zT1TqO{S2ad%t$)2lf2bijL%Jd*f`{o7hCI*6xOIBiEgL%7v=1xGKaVi-&d*DA=Q4W z+0UD=lJxvlQ4w#Xz1gvCn&r>GU*~6hW#u~X$!w2J2ZD|R;bvQ(4OM=Rb`O*$VSu>w z8g!KLt2xB^A3qeohvB8^qa-`-sCquVReF9cpQa0E)o51}oa_$l+AcKmG0aZ(A(8;d zxt>T5TgS2tWQplXNn0G3OpJ*AcdLq(5Gy<&5oI}na7?19m>+9{a9QB!4ia1?cVL@D z=MI{QeOP?&h#k-Mh25xSi4It&8UnDpKfY)l8%7|(k`Hvqc^;-=bSkzFWSDo1<~vBT zqXW<~>4EdPK$0fST?l$KW|W)I!COZ(wCwb{gP9QV8?9PbWZC(gpVA6R{5ziF%GLCB zYEj+Fx`K-TTRfVO9re09lFlT58lk$?ug8~^t9-HTv3X&2#_-!^CB^2N^32i3D?Ke%>APh^CU%CUCQs`Q zCzDnfrYB^@=wxM%JkykY)UZt@&xq@q%HS!DCso(XjT91etx?#J4UO;3W^hm#_4yvH z8B`nTX?E+b*Puh6hDvXS)OAm~kh$cH_C2&^XBfs;KVyo4C24VQp7GH_Nroxmu+XsC ze!HsN5Qg4_2vYIiy}Hw}qSDW7L9f6j6v$Rq>*cv@(&+b4=8J~lqf3j=gO3avoA#H# z2-6h8kPemyifSB(zIZs?zSTArU7;Hm-wh`Xn`yy(1v_JQg)}oi|fBLXXY;FN%T)GQrLBsZbZ57 zD?d6TxX`zKp-Y;7I(EPc05V}FLL>v$xjH|jd3?Xb)R2X%LpF7+>za3OyCmgR$pm%0 zFhD{fsiEhB|55z|mB>`^(SQVZ#(!%KGE+e5bq*;v_lqYKw0b^tNI4sZmKK3SmUz;r zObO6RIF92J=aXRSVpmt!aM{);7ffw!12p%hv9q^@{;NasyocJg$AfcA7%&2_XBY_* z5lO@uTwPxo9T2j~E~C`kNAn7_0TE+@W^Lq3uQbC$nz(vv`O$Aj4}va$y7$gsH22$5 z+P2|XC1NyYeJcqg%*_G$>JovdJJU{U{r`;wfP@6DclkGHD?X0LKcCM6B_Wzb3TDj2 z=`3yeZT3h;caVLk-^V`c#hZlmn!RWkv8J(`v?S6I-;Q_nzxa6Eq6jpjZL?1tIz52^ z9S7cb;xI&{J^)@PG+hpLU`OPb=<}_oyMmWhX7mw|_+1kjVm;V%^!sJJ5KE30oYnQr8Iee{6HNNrysn&~L?RR(FvJY+d z{aI9Gx;NNBHZhLI!T!(D{1WyQuVe?%#f;;gVjLgnB<%;D!|3%OEG0Uk$zfuZoaf{H z4!M(7ZI!u(MWO2^Orlk^8`Vr&4P#R){O0dfyZwxlMAK&EFFp}**RgWB z?RR|N59(msJcFG1iIqPbSHSV1z9X^dcFcYo@XWFK%|LbJ9FIg(>(nB~72Og0aj`$4 zMY$(tE%2DDec+YvawJp_et?}YG2$?A;PUxPj_CjRPn6aDVlzi+qW0~)`6P5ckM8^Q zRU5PxKzhlp89e*k6gjP!Df1~;(A7zE_;yD#6AQP(C|l2z*96^F%$va`2C6}*^3d?$ z-9Uy(7TPgmS7e-dnl{6y)QFBQ<%}qgCqEUpI2Cm#4Uv%mpV7lZ&c{=Eq)om`3?Y-0IS3o6^CFsShQ~H~#DszIb5d{?tZV#ItcP_If_< z15Q&6-p^83Zz#Ek0#*~6@-=1H->-e#cB(pI!|y(sbR;UL%wkfuN5{?IA3yHl5|-#S zwn87MVoAcXH}28%Nw>ql=+MHT0G``-X5zp{cupThKrv@*OhO{0Wmm*0Q(;9a@o>HX z;STG|5(syo$}^*CZUN6l@t)nvtGM~VUpZmMbuPBZc~YLF{&5Sdax2W6z<48Z(;PG6 z(#{=6iQyUxkv`s9x@78@05^Ek|j5G~M0@xE2h3@6{Oei-H^PuT0GcxU-+ z+XuUt(>YVrdVo_aZzo*%G2w||O93&cPkFhc$pe@MEjxA?>2z+YNuJ_wmbrM5gGFl8 zll-`DTeCw!iU&IrH3d=F17OE}jH8YIcZ}7onBjDl?5#QJ2#?Q|PZPL;gV>w>I1+gG zo9%g+S{WG`JAdz$*0YKi+TnLE1Eqd>;MA^~@7ZH#$Hm_9H@~D^kY{_Pr~aHHszF6g zdG%4_vG2u-q2-#CZCO_XCyzER;@N|Lv^FW;Us)j6_Af6oytlVEu*F^tu(|AWxC@|* z-*rvpL_(&E!gx`;ep)1NA)oXm^^7Na*%YIUCsWd6x1?9r9jP{KMOt%Q!9RL1~=dP5S0uX;a{EZG``JsxhPD($N=&gSjpdbjK7vzdGwo5S>`@4*i~ zmopVPF2mMTEi(iYv_?^$p>XGV@Y#QCY8u?BduWTY70l^4BMKfimUYxS1;i_=Z+i!- z1Ypd{TiNl*1YtAs>3_pF7fKDUJUXa+*UOv#Z+ld`>;Wt2TR}>9mK~SkrAct7)o=M6 zS#=;|Ccc(aDdp4^ezD^9-##KaR?TW-fsb4E4r*|lKK(W8>zoEdPN0g4!8I6wAQ6Uo zn&}BZ6_zla>Kx(seqG^FvcJ{Sjf($xc9dTKkGvUyFXHmHcWrx zk7aK^*W!61>pu0urPoIWY-ES|`=Tt>&023gcTB4(Ez`Ps=cg10eYa5J?Fz4bGJl)g zlSrq(IXr%N_1yTbS9wc+Ain)zdpo-Lk3w~wN)g08SnM=gX}qZ}k#5mwmW4=9s3AB{ zTbRImkM&PqC8AxB)`+qPg_u)uQj2}j+qV&L90MSP=FgFSZ~?8?n)&(laz25G?`%EK zzBq@Ues2ncn#*3MY`IE%5>0O?mTLNE`#rD!JjR^?i9xzaM!VU?# zpeE$XtbeLGT_bvAjopW0EXwQf@->dLhA-LI>K?N*H3JZYkqG2FAXI~;Bn>}Dgpf&; zZ3|leT7M?{$E1huz9^jsEaP;U7o|DycWmUhHJ&H^zgdi04$f?CcimhGAHkb-oWQ;&+Oe8$@WcNnv@Z-0qf3^(IHEn=vK#)DK zOnevoH$;zc;A0vL{s=#Dp3zjzGA5DqO}|reDm!Oi~*ttsYM7TP+cQc z6qha<2TYklm4l&!BqT6MntSgc^7KeR7y*NYCIPz`cr4*O$7H;oDF=(Oh(8i&s4c~* zqZ`Tb{eWHIi~@d2U{hsge{P6f)t3Ifp(%fAYfgFdI7tnWRZ_j0Tm26F6iP895>VmG zP?CedlIDmC9GkjXFGWED#GthUlht6UCMM(QWuv#))=JWL9JeZjW^j0c-usDQC48m` zA;71N{MAADOOucJHTEBjqX7Yq&k;u%UigS{ticHx8K3DR&=!W-iohYIX50>AQra&w z+>Ht3eoKROq5loI#G0(MUw9?>arfhUF*$;I<5wI7Xg5SWPfy{NsglEvWw=&sx)u6^Q>GTDm)8FJCm-0POT3H+hfxtmJ5uV3=H7xcQIa#Q zswlwRK}6WVWsk`uKQ1Bl5v9ORvm?S^oMniyr<^bDmwdU}=Mnj?!Mn0+;yoMXE7bnLc6J%-oKEFnveFG(*0@2qEPJ72>FRfU;c zGCRu3&^q33`5EnGwV{=CjhQ)bs&?%^yp{29^hkbfu3CIQQ?YZ2zYw}#67g4FWrl&R z@f~8G-7|<5Nzi{67q5Me^7V!N5LY8Y3GUG*tHWY>K1RGpXy)#XZ>5YJ8TS2`qu!L% zY({%dDX5*haIlXEctpq;EJpGfcg7JC3Ye*|4PnejqfT z@TJQWjF-u_ZVl07jzcF`A!d(efp%7n~!5_}Aa3d9U$ zW+B+=Xnvrw$I^m~jUXOy0ze=+jD<|zUOKu)0wV+_a}ZN#p*@3!2|p6M4EzS;f|*oh zL!TY$Lt;jgqx7#Eq+-m5<*@-7H(NYL0qfHQW7`p9YFq5vHK|pE^2n@q5MO>hf=dAOgBb~06Sxbh= z9aJu%BEzg)^^A_Rw$DZMth}y5lQ+G%hfJ?b%j~VBGrR&ahJ<2YdTJ&KwjFZ(Fli2t z_?GO%+@v>$a6T?d{AA?36=Ydvr8lqbVV3*ZhTO=m3C`m2#noAlR_5vx>a}4D<8yzn zE6@iFcQ&y!YS&lcWIo!!J9fxCHSy$Mld7&uuPL8OIDg#jtDW8A0?h~#)1m)|-biKO zi^-px1_NEW0vQY(J>CtqpK%9}&>2?=@DG31cm8kSSRjI&bHCieMG#!%qfFI>QkL;e z$;S@^O+0w^2zSBY-2k_3Jb_mqAB&N=U*_oDJ?KW4dhvhQATo0BYXqxW)xg+t2@^t5 zuQh{lKGKt1fq_eNNi7Xsj?zSE*!pz;rYIf?){);5tlB#n_5IpX1Eu7f+-2UIUme7!0E=C|sby zP+4haxQqPl)3w|~`CTKcEp70U@Vdvg;07OqFcW?^ig^gA{E<8j`ZhbzaX$9BX$lo36MJgibV@eZY5c# zJ_Q~+6vc3_Dbmrs{o45a3TmNX_C1YuoXWvEC|8PmnVw#a`&iCB@1zO`+wi~u2{;bE z?{K-3H2Jd6oTSv*X6Y12|7efM@X*b8F8w_1#_Mj%Q%BWC7!LoL=`Il9fBp@}RlX7I z@Hp=FHN`JUP(?XYYSEs~(3Lpv^0Yms76a1CP+ zkB%qTmLUDYUJmfrS8QS|a=hcy!okUL*ZfCp^S4)SY!q&OI~&unOKC!( zbw{y=3-bYW$_Tq>E(a_i9%ZM1tTNEfj&(65kmmq*yJ z>KVnv)tDP*-uYl zJ~=+g!k*|AQJFeR_5AuPhIxeX{eoWI3y$ai);4w>Gd~nhc?VmIoKl9(M6b3cfJYQ_ z3B-oxmQ|z=QXYotoF0%$zrXIXK6gAKgzpumb{s; z?&uin+w~>z93qPbJg^y1kPf$Pt+x@%n^VdgObGFyP%z)$w{$Tx*C-$)2K;hYz|5aT zUqo_I+;JF;M*!$>^wx4T0ySnK$=1Eo#x{IvITGo&46m;|c6q0pFuD~Q6EYpu|D~7V zd;g7UP}>flaGCu#znNN$N3wp+?f38<_eazV+jq22Q8~EynzOTOpRY0vQVwtW?U{8r z!!BJ^SxHT8pk$r6!Rk*v{ovxgbF*DIdnP%Pc}LYLR6~wVrj`n!-T3>q6@KS74rxYA zJResq;54TVa7h(a&6o;w(T=BLeu1YrDGVe=%iuf zb;4i*bv|TR3wg2Y`Cf=3nf-a=k2X!a&)7Yq(*47$9K&j1`ixOLkDvaqUiFO%iL#06 zrwJ?|=kxTby!zJFdEW+ay9rN=RieLPTET{iX4JA*P)nl(y(y{#Lf;XkX+v^pn?*q= zE-@|ME+v)KbnG*@HE^Ioit=}*!nhwAZI8qPA5me5Qh%N6854h|^5 zxM465$EO&rv`P)A{>m0Kf6yz|V3{Km2rOKJ?mPS9LH~`ytzbf`=6$D!wB>O4;q1QG z`TSp>jgtjUBod*_(9ocdBAy3?b2$7kpTcZNr{sQ)e@}P*A%nWoLGKdry+T^G8+aqiblm&sT@B>L*y#9xF#GzNI#Z8-ekB*UP$llMhkc5BcBW($W9_Yr9=*99 zc4%U4=eIEq-p-y$_b8VX_N5&&xy)jik|;hYH31C=O)$#w1|!Ake8%yTO|+NbOu%De z9Or|$%u{o&CxZ7p%`*#TZZ1O4LU>#L3zR%rjwV}(_&hC3+r!XqOXp z#+)*a%GUaQ^H1AT5)v3|AAhi=AZ=e7D_$IX+$-_&an^$mZoT0sJTY9SX`X!`BV*zj z=Qc9ZV;ta|-cS<71wS)cI+Z+5WEiY=KrD@xM^vEnzvGR3Cix3sbl{i6u{6kkQMI zLOtH*$_7(*oFQNsQBD!958dLD;|uou3!5inC8+9k135?Ub}Y4TIZNhFI<6qhA#a-AoUol5>F` z9@C0&4G1jW!*x>~XcwkH6bhMu8{tjkcnxJLI}Hv|bRJ7H{f%#Ds*VgyS_bZF z*b8tOqOYQ%gqMr;tQQDfFoe3_`TF**E1V(b5QeX3t6F=$bsW4@#JMPq_7RmZS`7>` z4}Krc7V)QDR3kXngp0$zM~DA|VDsWkgS>3R%9Gnl31>Z}@1K5zk_zd&gn5pT!bSU4 zE4P2OWAZ&nq2N}L8qz<5oQoL$XUr$ZZOa8kvJOfjyDg9bb=~?NI;s(lf-h68nXPJl z9PLV~HXU^N#*c-p6jYzg>uBAlJ8@oVm0Lk3itGzw`=Hj|CwBJ$6OHzwys1J7n@Q1$ zx{bcLbpDrKUKLihPraS}$L#JUug#bH3UWFobnQ@GhD9D(AiN0M6*j2uXMIhXQM&T8 z;g;It3yevm7Tw3-V1zD4a&+F)`K|Df!edGeXGuRjxo3Y&HAx+qY7}DCfGx^$){cy}O>!#WPnSb}|s^BBn z{t(kfki~}ttlEYKD!=(eVtmA`LGtypo{R_ke!tCFjmPFh0zzn6nLK1QM2Zx2$p{^y z@PSj6eUvzruu!Xz9Qxc3svq;W5o2UxrQk&oyHW?U(PmlzH*3}aNoJ|G-w7_8@RS5aVi zD4tY>Y1gn)_H6o2^G0e&b;8wv>fW*~$|HVX?_DrlwixB`NQuX+DPuM-#&Ve*vO#b^ z>HxB*7%2J1o{N4P#LRG*055QNa|=aeB!DTPx}5vgzsYhcS#brDL0>8Mn*|MF?eh%z zl|&&x3^7y>E4G*0sRyyZ{|qsotNeD0M0aV?S_limok5JrK^PLG4FnrVX}tzsj-c9rKAjwmZ-05{NuAI4uU~8Y*Di1EAf}}d_HYmjO4d}I24QSt`yj># z>kbcFpV#OWd0;Z@(LhLv03i3XQ4tMM_fDryZKN`CN(Ht`fTHNVfFS}nd|~crRhQ<7 z+tB+J_9qGAeen1wDIpNRX-=5`5E2Cmu~I;W*A9%m|1TdJp~HkV4J{%@JP-pqfzaN7 zCT97=DZg7_If4`3D0@jI%->^-ku)6=ahO_KJD#waaXsors7Ghc!vXE3k^OVtikMQUJ~ELSfivQTPfS-a)@;u#F@h!9ZOxOfA7rh z(RbGrxB$I}zmnDDw_rAZctt9*M9gsQ`pWD1OM0?7AVZP5f(z&YYT&|i6y!bDh`-w! z-@Cz2BpjjQQip8k;GCCZn$PKU`+U)A)NK%CLqYtZfB)|E7xclZyUZOBJ157>ld{zJx5nK;u+dR3l156y#+6q*b zL<*KFXQC^hOVCLN1lPmq_`waaxC9!nO^z& zjK&AHIafNruFNi;gg}6q+n9)G%aC4-1_E4(>wlkC@waJ!M%I3Q+G*lD-rqX0SJ48fKmW>_TX>bSbm zc(#;mCzVS)3CQBc=E~SEjiZ-Xn{x$TNyEL#w}7!B+<q={&-sR3?`U1jx7KRTYUySl-I`89{`2XVf zA^I6^RNj>E!*H*#nfUp#%1TiWy&x)a<&HqH-uK}dvMnabYoIc*BO!!P<+>~NEG z`}&W_>d91@eB1kic^Jzp$blt}gAbJqMD`>B$m(`3rHL5H8Khll0cU`to+`Z|A)&@Y zRc>z^F;4g6rSGs3T_`xv`OZ-7ZtTpl*Igz)@vq*WqUA;pWze)C$tKHA7Q3)Lmd$F1 z>sj6Lq0F5zC`=A>vTU)i%LK<4@v({O$x7hE$1)>g|F=z^-2MA8smHqRAV!AsDS9d- zzOsx&a4_Y`M;$0erWR=)U@U5@rZlM3U9(y@7cKo#s~UphBRD1 z&66P1u6cW0QY)L%xl@aI(2Qi4E*l+HeQ9mAOkzvmitFodASZ#r8zjd^xh%JqhwA|# zI}{H|0*8L8mn=ox{(=Y=PR^wqC9~pcbC$@q{!%{Mg#+Yl`n$XuD5Pk^Dmo|alhFXj z6(h=r;zK9nBnNNi%MT8di=T%F#|+!q_w1sh(m35klV7weDaPB+Q~#NJa-`E$)~tit z=cOd?M_k&kcM(I~e!RVgx$?K5--6WS%!Saqj+MG;X>zkKG^(7_>}(4h_Te~3su7W! z0w|iW5Mi%CG*<8X`JGv8NFtID=Gr!Um631QQ0&k)yS3TBMW{>!U;TyM`Z=WY+yA7M zo@Cu=r7o&V8%zenQx=^F`_6=ILQ zS0fYgU?oeXptxpS+Y6L(G$%JN$c0+np|`?xiX-~6i)V%VZYz}O;hcaNyFB#=Dimy0 zq6)^225HhcQDVylGz&ErL{RI$9hB>El^^+^=wis2xf*N-lxffgW1K6dY%m~S(X!Q( zr3s2^Vr(Dc34|3m=>fW77W0{WkAWLUce6dxy7pc$Gj8V}xrP=Tinu26_1d++Hf=LF zpo;@+YIbNFv`4totzhTHl14-lM(~03X_%aRZrFPslI`!`zXw>Kh-Zltpc)zpLnFjS22U}$j+O^v-EADbJy`S zcaLYNpPjm{f8wpz6btdLc{rlzmlpz#i7vd%jh%2$db&}ir@E2%YtGvZ=3l~70#pSB-H6J8ag0O>RfbBu;503@%{`m7oe z{dfJJ?!V6{h>1CEgvJ;1R51;<(;NxIS+yUqd4L~5wP$3r8sx;>?A~ zb(8oNQ00wyn0ABFM9&F$ga|#<@+PJ#Ss<_cz8-5tJ(b7;CdGoSTMzs=-{d0xm#ZKk zL}Sli%N-f#cvT8bwNf-$nXhnMwF}(goNW71^TH2p!R^5((bQNqkR8x{=6gn~x;P{y zip;ESr*hY(7ngX$%6|T|FDai!2&zqx3BW)m2_1>mrWvidcTk(1N=%V9eNaHj+5C)t zug8g1d*djkQ+oWR%Go2g9#iU?%d+=Gc&K`Y`K)9jAo@xfF*I3sKY8MGPNX}$uP125 z+lt2&UG}N+2ZIo&cus${E2P%0t?i9B%TmD4V#C>}HmURErad($>`rB`N!UdhDKlH% zJk=@{w9QraTa87J&G2HMmj?U0YlA+vwLHSxnbvPF`}}EnAjDN&Tf`O=(Eld&@X4{j z+mV?YL66;m4AqX!Tj4&&WxUt>VefnMrvsJEBsHhCvYC<&D8ve#1{VjdH~x1cnse}z z0&)+gR3h~D+KTG3J$Prxjb8x8KENZ?m{^=APMoUzu$U}=u=06XcCdDc?eDzz4~`}Y zQ*mkx=$$&Xlj4KEic88Kt7>F4Aa+T$2>Kdb~?jvoQ`E zpU}}wQ<=_1k|Smn=ecAz(!B#sOWq6J_AEOCqFKC}<&qgRij8?T+krQL#lYxHg2+4+ zPmH)ChVBtb;XvRJR~v9VnmY|_10?_3+#YyrEKGC-7VTL|l$G@4;hQyB2A_V+`776b zo6jG)<0^{zA~i?m&N3{?bO>~>X0K@+RAwqiMMeajFGchH2_F}4-5;YBwl}GVXx?B0 zHJUo@8UhOJ>f56MBGZ`tqc4clLWh$g=oes{%yjm*8AY!UihLa9Y>t^+EAKChL-B-E zjYtV6FQ=1sE2$1gkg}%q{V82TOT%)>K);Tbr;`%7#@;f^ zkgJ(+I5tyx?n9_xGq__SWF$%xrUaY{M8@*^R>?=yHYy{YM~i&Zpw<=G71O+fW&x&J z942Z1`IWt>%U`DtQUj^Uqjmf9>sPO!`XJIc)49fe<=M!l>uOr-aAcIoACLSs zDs>_B|55iIZXxgg`*?#SN(=2YL`k%V_LK(7s7QP7MVqvD36+)xiKYgn6m9K66e^`5 zREn1JyI<%1`Th~V>*{hH=bYB-^&F4K{kX@uk@8#4{VLbOirq*Qsm?Ob-7H-pw>Vj` ztG(@_80Qy%<{ql;LZVF1hYGY^3uE@f%Z|RbMck|^m?Qe?Ubnx#PBG5g>jH;eda};0 ziOjy)UQA08Msduu? zD_edvuwJBE=9~>9!)*bBHNrUX+iw|IFJagIA59NsMbIVEh(A9(Wgbjgf&ajl6a)qj z`5(UHB2Ln&?Dp)29Dup%4BHbPL3+wyaOc8n*fnBRKqI*DrFj>&6kQ%zmw$aLwlNnr zZX^WFK9sswAVTH?x-n*rKr?YA5rju2W%W))NfPsF4;?$>m~7)W8J4i39ul?jNIz=UB+ziS@Yz1liDJB^s) zTOo}(p!8U22+})A{OT!80N~CwjV`ucy^YkQwhvHEWt_!f=e%D!1*`|Bxk3Zx zkBkUBO!}S%G66=x!K;SbkECknTq%j}iQazW@bfFv;{6^4;`2!Fp z(I0qt5*&6qWo0%msU&Ti7oV9Ym2_Y{`-?{vWXF!!*h!_6-C2QY3204vSCi$H zdA1dgoVBOa-@$L^5L`burrK3oaqKhYgvX~!ugBZ--7;I0tZlYxo2tj#vEES zwEQk6#w4Y=3r=Hu&RqsxZTQ@NKeur<%Wu(_^<^o$R_=A55$X7IoXYbT1;uN24vshT zo(hYZ!=Fx>R2IL$M*r&jLtZ3KWk7SO>$hkPm6Y>VM}wttjP0a2(;5xWEqSp+I<%5I zvQJ()Jr@+Cw_}{-*r8s8!yU6&zdV!m_`;Ktx<7u*dDEY??|bNDu@FH6R#w|3(x|hp zZ%Gs0QXe3(-jCuCVsVUvxNn1dh}&aQW7qEW3Z}Z@`4u&(W^>`$cMmr2OzitUL3L|T z-okjcqiyg;Zu)P`BTwGf0e!aFJn=#-2@z(YMxdC78GD_d;reNAWu*!w0wcBg7J<%l zqTbJ}h_zgn=4$q>6Pk5KqlC<1vbPM%Lv-(CjAN<9M&mnUW6sv|Ff-qgy8F`+IX++A z$u84~aSm+U+@zkl z#oEEafw$6cD6XZ;N3Pa(&XZMDC}%NnbF0HN515+svt3y|hgR4wnuSW<2~!##j>6I+ zx-#?(@IG3=$y6rNULo}lUW+W3N)`tqPPjB=Wt;5N$6_1=YGMjjA>or3nPj%h&`08!jXpSW7TQ-r53P)lmIEF8F#M~(V zI5cA~9OuCFtywAazq()|dn(UNu+0|k37AKB_WQTje-;1+&{@eX#NlTZ@oYm@C@pLY2m~Fya3X)p z4ZXVJVdZHi&nT|M!*OX559vq;-s~Ofn0dz>3Wx2iJ25dWltaCoxK87Kdq1RT;fQxk}@q&u119@66D@>6om zYAW=tJv(i&V9Kj&FxhgC&2+iqV#z|nyOPfSlj(iS^f#|;?(ERRiF-1r)Sy`V(CzWi z%#=FW;YqqheopIa4ppjEcAniQgz_xU^>5eJ4IW`mP_sHWeIQHyBP(NDjpwoHod3)X zG*}u^3|)-4WKJI#vq~(RpG}Sy`Vg*pXn7(pc)a)t*c7GBl61ep;$uWr`#9lmI8N$-V`KT+AH11knOB1tBuC+ ze+WKkR7#*p7o1};?W`y^Op~FHJirl8gqh(V5Xef7ANp1%g`$KfxW?cajE`q;BeM%N zW6R?*e>w4}X;URk{b56xIHox@mTI|YQ7P`6{D4aa{%Ul*Ue4O)X^-TA5PJv`m}pUh?KdqLzg0CB*Gf)CKn?IeXP){6LYi^{r%!fO0W-NgQSw{$g#sW6N3M%F*w~EL#l8Wpu0^F=E=dtAXogG~Ck$m%tovdkMl`QdhU@NMkO zMZtZIfP;u=U+wKy-S9LZGA}`b00(Z5!e7?|I(r%vyRN>J6jcE`8-sHqP6>|=y#QhU zS8&dLQrw$on~W((#;GGW0~|zCcVoQBrfsjGopGQ-S?Z!_k%FoSg?&om=O$=v6%+ea z>-lqw4HF|T#Qf3GBmGZ``c%SESt;l$bKsKO2BUam-U9i7uZ~`4ccMYGb8x(Xw6h%o zYJKxvn>u`_cXiLN5dPor9DJqdvF9b{LjR#|D(8?_Q0!wZslGCOF@jfwRIlX7Q?PlgE7s2TQ!E$4O-Xd4I`TM0hi!fK!To!^})n<%sr9voM;5u z|DrS?P;^{B{kD5>1WQf8J}2O_21yE*m;Rvc_>-~f*yS_=U#V40}n zxr1vmG{?SRm{v#bqu{V@M$s;SMicT4Q1)?c^vl0R#tUQF7w>AJdm18BxdwvffQ3*^ zON^XlU=}F)?HfSy6b^NIIm}F*HK%y#2_X*9YJh{SPbpkt6cr+++Oa0k+kbG}hbcMY ziru}dNmz1f9HmxtvXi#Gu+~%Wc;n5^b&&e#z&&{Ck{1}Vym@?1;QgmhYDj>So$JVP zGn(REr>V}5P%XU?7dLnRR(o~M>C|Q~%4X3Bby0rhMD4CYD|1cX)1uA#`uPI@_;=$l z#5kzo9^?AozAW-qo<;tOS(8DkP`CIqA135tNfk?y&L~9R>ZoVEp+|r1uibvhSuzh>%RTNmYW?LE z#`yYA?rVM3qM}VbQQc1~wNmoQS<hv!cOmfAx+m0PjQL-&#*ueSJJ?iQNWQCmwc`uJa^PlAK)Ar1}B(1|S)g zvpeUW^2vnqT#`k?0g1-lZ5@TbTEDuRL7;)}PE?Gj$yd9**mwMNf}+Df5Yh=r*DQ>J z2*`n?>0ooM7sM10W006v+L98Z)>98mae|K98GxNiRbd};3I{OI2ZKeKFPmOm)N`2+ zzYo0Wv@ZXWBjvEbd}$n@3?hNlLsGg0OfL#Um%d~d^KdAOb%H@`R#At&UZhx?oc(#L zT-yz;t>WNGgOY}cMPi1Mul-KGH_(CmF_s<1TDRE(rs9*b=7i4(Te~r5thW~)rVm(! zO~GYm09lOYnKp4jD>gkLaIsJ~R{>UJQIN7M5b0WAt;l%S()OdnJ;US2sl5#+w@Xn)nA65uzbxG3h;Kc3 zMQMkg-R*5R3}o-wIbdLvoJ3_Sb3bukO&@20@zEN~gLH70{iev*!U%wiNZt1TIuzN> zK-aB!iHfTDt)cf$zl_!iw}MN>p<*lXaW5sne#=!H%A)pD$Ox3u&28ya9_m|Bw+gNw zxWllU;viG^st`c0%kJ=4A*7{fc?KOMYhJ7xKYW(>Z_ZSI3&Nk1+VO^5ykl0IlsTm9 zm-Ql1&OxffXj0oao*=~(dwd}fyBBmYz^|C$wf0s-_p%=Atxm8s>I|Y#*$+SWHZ_z@m4c{`WZ(HmatjG-~s0yT1nhj{lzn_(*Xjhyz% zpbn2``-M;Px4fQ7@0)np=O$F~#^5Ew!X_TKJ)e#xyC;9P<_{yvIF)Mi-4XjDVxDA^X>AX+x%-A)e<?knbRS66=zXAt)kyWmJw z^9C7SBQmz_@A`(E!4w3l)$x@?(f2+28CZT3oJGBY-AxQLvVQ?#zfuAr;Fal_cbTC% z#rG;o2e!@@r-J=0#)4vL@2I1ERx-=VA+EsXG?0v8)Ai-V=o$^-SAB}5k6OSDr@W-g zXVv3OsseXzRaMu7y`)n*p(893Jmclx_=u4zl!Wco0Q@ulV;G+KmR(*^dO_8YsnDqC zH6mZ(>5=sro<$%UkVNzw2ql+QRfVDZAD6d-p+?oSf5?S<^`tJGYS$yBUCC z1*P>fl^kL1gZ~o?q6^cLvcWhUL3Q1Pjvs&x`s<@nM?-6zX;mgX&iUqUm(e_SfP9Q{ zhaM~U-|PU6>$b1`nd~0j{#V~7CstUvdA{O{=VKO0$pN`lk3_u^OKpUzVG|Txm`i!< zk!l&j*mYk=$6vwd^Ep?~1qNpJClFr<&2FhiWL*fqz|u(;^=LsvBBxgKw>*8Hu2RH4iOULNpPztdo!dDhAiUJ$`Zjv4d+Z+eTH0b+Ta2e(%!j*opi&@;$?Ew}d)S8tG#R_tAJEsI<2L-yi9 z?Vc51Lay{n-Db-@V7^3SY>|GK^r+E#xsaZ8OcZOSjj}^YRK@vIK^jc4?{3iPa1Z2; z@g?;hXS*XPk_QP*WS9$jRO|8_u^E3uc@0q!s_RoRth-WiB=9$;Y4Z{CBVf9kC1eK< z-m>F*`j)q&|Jz@mOtm6|IiK+p^~H9%))t`HWAY0SdYkJxxA@*40KYIbY~rSsHVX*A zgsV&a=jXa;Ku{ho%k}zh2zLT+vHyC&xHEt8Fk_x|jc$0}nWJ}3 zA(kj{xe9(hbgPB7Cns(cnDJWFh6z(B@A8&V%_dX1UKiF-bm0g(1Bd`2Y$4nm7rmh; z#8rIEDkf5~?@Zs8pMV8y4n)p+Z#`G=Y^v{DQJ|{pBQrk6aovCkE*}#h>a33MxgLSA zFN`3@Py^seAYNNJ`^@t}+i#LV728E<9=`E|kDg|Uxo-aGJSVNJOi?V$aSy4Uxfj!W z95VDvUkY#!KGOG;;vgXpzpEWt{jtWJ&Fs>;9VsQbrA!yNYXH|lhXyIKcdo8*Z`aDZ zSDrNoVut33kYUE8zRm9$x`&jr6BwJSz2@#dKWn>lZ?qbGwLR}k$kxxfN;SPzQa=?M zXJNT5F#Ajbg?utsUW<~t6sweP52mBzFw408t{k;IG0MyOw{$({vQQ%s6uC{%hvoz3 z{fOBBup|)TJc#gP)6%xMIAz$E5(E|;Z~}Meo6qbjaZ5MkwwhQNMTS}4(a>*OTQ3hk zJV#Nj03{guTEc}r)&pI*@HT>>R^r(+Bd2cFXOQ{UwrC($9K3HQt%CO#(7t?�kA+ z^5iXuPNa*vBAEy%DY^)($3?lgFQSybE(spfH&XWz3hjBq zM?F7ab)UyRNa<@Nzuaz-a)g=fPAFrDnhfwRAvd!m62`#%pN1FxE_bOF~hj zM4I5C@*pKaimMrw+Saw#4UBJwuW5?i+(Jya)}&)l|z#YKX2tk|_L%rwVls z0vnK}8+21u9C#Bkyhki`lw$t<34f-5QJIFMUU^YUF<)`#Ya{g zYM-`OYWo%}LlJ5dOlI7A**5gb=x7X6^y}ip-QKW_xK-26^yI>mP*8S-$^hLI78Pmo zokp7su?8zrncnyz%XT&k0eV~4|9mdgC>DG{b47B>r_;w&MEZQ<`Ge=Zp1gI==IU_Y zMX{Up_-(0V%?hvQ1CN_Bm6CS2JT-dP8~pf%0fV91zEo|I*0z*s=`VqM)`~JV zI6j}`6XiBM|NXrpcY9mJ^Oa1qJq{&x@ob8X^ZCw$-L;qQeSi9^PGaWaejTg!j}+~$ zpemw7!Hsi!;2j2Y*!7+%X=si*m zX>>PzjuleecN?mEQo!a_zWb%_`+Kh0&M8VN?SEydcl&9DH=0ETKGG&>+lYX$)a<1^ zEu|?eNeOl!t`sa!auLbw(_2{wV}N)O7MVCu3gX`Uc+tE5ma$G(+8I7@Ey3!^XV$|x z0}s0j%>9Ey7O@~zxw#%i3w@Yep)KMEd1QJC=9*}>@Ig??R~#jDsv{V*c^*g$P0P)T zuI7cwq6C5)(W7!``-5t^qcw6OYedbfj$=dL006CvosVh6~gg1Q5IW z5l0C$i@e-JR?dViyhO&l^|qdMpI;pB$pd9Mw4S)RJ4T#yGfA-E#-jSHp442k8#VT+mSRHO7ro+R_$c{FkExh; z!tAd{Is5r5$Ei6!W?N7N5!15_Poh%!<`tmk&YeQ?jTZW$f>}zn_#MX|Ce}AY)>!Ov$mI)rIzH;))2`b zA8WjJp@OJiZ9axM)Ik@8UCQqY)imD7x@1nY)-%Y1%eZ>+-#3$SLcJ5(rOTu2J#?9M zUFJ4gr@vjJe`B{Xv5n{zOd6a>lKELJNB&`?CeO3KT=z)2OR;{&pKP~7Zxko?@1`iL ztPH*Ozu+B|`d=QQ!Ekd$_}XM2>B&13Std(jtJmcf_V^pZU5W@w0PqIH!A<0YCZyC~ zpfw{1>QG&RQ`Z6nTQNMj%#pMRmwy73p&>_I&~Np$5t5DE%S=w3&p8- zX@#zC)*icpAXlh3%t44)r%EWz%k>z@=Kk0{>>%L5aA8wuXIAivMt($4kna3!t~nwb z+0`#MP7b@h^*bMb5oDOfMPXfCT{ef1x#+p5phmTKLRmp}MN662jQU>f{#T?gz3$@c z55G(?tuI_E{?5N7JyXlB+S^ig-3|#1?4~=rkAtZa<2-L!=#~%G?MLY|`9mW&@xZp4 zzTG>Ye=O%Ub7*~6_;I{^Zh9>KwWZNZO5uhk)4hF2J9>F9R3a; z)V++znYO{aYk!>Do;h{u9DKBg)yyck+OW&yIhBR848603M`HSjS}0vbcjP_s`i~W2 zQ7G-8neTR)+IhNRw%`o5%uAIc<}3z9wU6GneYCn*g%T7AGkCj(^Rl}#s6tmB=kklb z>GNo=FMA0=V#g~v7P5!0COAHhj3mi_?6TIs|7Tv$f_d!wOL(@G_RoK;<~cM>IE#({ z^pwFIDv5*A@qW&<_WZ6Tnc-4W+C~+o)FqW^Z5|Vrmzlh(hayYCNV>@DexW9KCRFq4 zVBF!@W9`|H+hQI^^E+EOkHH5w({2j#S$(B1R*+;?oMP4RI9fKkedr2clgGEQQUDPc zKJ$$63N$%!_OIcUD=i3B-&SR#$vQW6wBy#gS9g)bpY<1BUT*~ZU%F%{9g1mvm(qC& z@(sH?sk-@#uXb=E_YQi4wrwV=p3CJZ#1T}2Z%K^d;+%C|PQ7$eDOO|1W@0C!waU`w zW1rsBBXWx3N`QSjKMQxJ`m*LJBf2@;kSM?Z!C<67WjGW91wRddKC#fJ!TIW`AVEHl z)9!yOcDTpxyAi={?(MKhY4KOb}ZU*55o;8GqiAXX96NvEZhDnf~3QYNd zqXp;Y^8CMGlLvY2*W*w6uDG5nYi%6Xmtm3RY$w@8YWdwKiIO}z$OK*62 ze|Uw`@XxjX4&u8vLYiJ|a_jcenk+UjK^PFY6XH^eV?$vzSmB1#2yw1YFMUyE=j1#g zGt<{6tWTwCS*<`Mvt{>y2BQk&^|zuzO;N0c+KF5Nv?D%38{C-$U1oGPV{GUG7&c-eWu zG~b2r2RCId>Tb`S&r)xr{!!|5$;kJqPXz01)Tx9fxvP{GLWcSDFL&h(9h+-NYUjm^ z+P8myv*rWQ94*>*vjeZkFR=dLlVP{$u8j0fnce@)Z)mh&Kq$9wM$h-BS4c#<(+CYu z@etGeodlV7GZ5fuS+9yMd&_>|E!(-bJ#F08;N{YJi<8gOhx)8C|7I^`Fa7ns{ClZzbH8O6Bly@$)7U=5mhAGP75P$N z_?@L$XPGZ|YF;m-*rUMlJ419cuT3+L!tV{Q;#ivZ*Je|NxR(p7`!o~Ur2s#7&SdSLJiW%_uY&Uy|GvnP%;R4}a`zny`6^ zVZSe#w`_i_Wu}}T-}LbO&!0Jcw(x~GHL0zUrels@oKWb3Z+4h*vZ)96C8`Oajj-&8 zW)Foh`hBYCD_Qcb!2v=8XF7CVvYxODdtI!|CMX~`=ID-8Ah!Bzo}Rohozc4wk2a=j zW}hLsk=k%@)J9lRaDW3)5};)i{+`E2K5?J^Q52XJLc_IjFJF(Jjh%g`$K41-of0#8 zBFMztRFv>dLh0N`nR{ikF}B3)kGHIl^yfuy!Pe|wj$SOL0+*@+4zgir#Ah;VYiyD% z-2uZ3C`cwa|1EMJw9gUds?eHNNgj2(VwVCkB3RUuiqS4A6?DCASKz%@aE{(`9QQQj z5AhswM7$VLN$-aR_v(k9K)&?t##c^G6i;{7a*#l4GL~Hb_aO9UL})<)$MMKJ4XL7* z^xe3{p++pNu8tgcjX<~YW;RTfu0l!j2=m9Eb0V+zJ*wFeJe4#fe*gM_TYo_fE;^L{ zA49-sO8f(!BU^ZYr)LOCtR0-Ks<&rqi4zGK468^_4t?MLl9v!q_Vp!ps^ky274Eot z0OAX>4f2L$lfcOEJ)Cc@AYTqc|L0(hg4+Uu2HF7}uh7B63_4FR?)OT=llZy1M>sEx z88kX=gRf7U_LIMed1gP-to?&!%ZW5cuqajB9g3H@Ae?C?#;go-77?nS6 z6F@?3SX?N4h^=6!z0sPT)cGU#pfw4DPtY!IQ{^bJU$qyp!GEb7D+F7$3zOtRN`^LY>U9~cBNhmEiN$~ciugW z=9-*C3G$0^HPliLG2V1^WnQ%K26)^ z*cM7>_v4Ay(WmKuJ(+3x=H3gkBf2P^+wT=jmYysRzY|5XpDQ|9aD7Szt0{UYxpfQ zxPh?|e1FOev{^cERzR`{wsms%+JRx^ieSHFf6|}zLYw; z{3DUEob=Q=f*NF~CH*XI9WTo=+7FzD=s^W13*W*-a zrX%A>>W^5g$|yHC@$4g&I>RlX&qBjqH}HXNH^r@$Z3pr=)yZXQ%+F<>WD1VD`PpbV+L6J-N=Ry5LtNXfE*J`$?mh)N<%jhplx#s_v7b zLG`7fq2XeG?{cV)x3`J57Y@euF8jb8Jmq+w1lM}?>#^(nS--ty`={>gh)HRk){}aM z$6|7QQyhsY4jNH6zbtx#xy?DI@HhP54NUHk^m0#$c}2qmIJix3{S%z4IJUmu#GlJyxo7Kpk1HOl z@KoVFpMRSx;E}lb`^Vrp!kj6&xJMj?{?~>(1TjehGg5@0e&0XUm3m@2GaBTNG3Go3 z3xj19(`vy_XEpr2J?RjLb)Yu2fJYzIoYR?nwF>d$-$(4e7KzT>NOF8or^fDfM(F9- z%Xo9;2p7GXGYJL09E^V?VyffhJAXek+0p%L;08m{@wsU6vZ(p58^~fUec!(Nw)Kgg z@bOWbcVbH#(~>$G2AmwP{z@-RSa+P#ajl_z6+4t)zU1^a`-O1IT8(qJ?F z)dQZ!w#+kSc7q>7W~g68&i2sC;Rl43rXpXG5*%ObBY=p6g?@FzG>GL9ZDi^om-D-v zaSKW5)2;XDWIg`Di;N`CI%6)$1JRhWOO4Ud;<%ugxw;3$0}QS7=bTDOnZV{K?FYsAiPkC{OXqh!PeA&p7IhfPGW{ zQj&c2)d#v1Q^ltlySz*@Z%r1?>*Xd!Q_d&vkcVs=iw@km$e5G0yh|xQ7X{*RVVRd9 zHF{1eMvaq2sS(ZhVk74k?f)j@O&~)bkRT98GR~PFl|#&JhCBTlL69Z(aid~ zj7aKk+*+bjO`;>!{bO+blCJj7|l_s`FsOqhrUPAM3B1#BgUEyR|pEnH#1LZ2K%_ z2L6KM>AkwZ1&9X4IEoK=mEHtRy8X&qhjZ8WEd8xGqRIoi1q3dBore^$pTd*=edj~) z&4P8pV+)?42xxk1H;IKe9LzKLVb(K`_w`djGm4U;A{dsPI=X&dMbG7wn8lioM#H^x zo*XYO9uX&@IruLi_;W!>`*0kb1`+yD_2nJ=DZg(GhTD`?O0-@)YGQ~C5u;k0J$*eY zYil`QFBxPj-p5>mjx3%mw8lG5Psi_IDLXO*vH=7gxcMP7Klr6L+;X8>j4GG&`TRLEPtfzoENVOi*>IFDH?Juo{q5wFl<^6$3^=$M+* zPbJUN+pEu5t9EaU`5pSYw07-k$b=Dm0ioUnEfP#9kk<*genQt!=6lN?Q|VFSV90xg za|Y0N#|d;8ncufr{KEzOF~Mo!7%S}u2rn6ww|fcD+lg; zzJ1WM7Whmlado=QO$pUlr=HTECY$B8UClbXJ!4EgmrEn>sny}@+O0!JE0+ZJtzA1? zp=&B;J5rS!MIx1PIUv-D{0rF39T;T|cT zMY}C>{fNt)GNH{^cvZtS{SV#}Wy#>Evb-8R@t0mLBh+K#9gF8km7BZ!P2x1i1mIPr z!_Y!5=O$%GM@Rp_Gt|ka$DSRO$xn%z(7Aki`sT^7wA(5QGBU4S0+(2Ec4O_MLx1b$ z`f5dU)gNUgZbS^9eQ#{|%i}-8y<(?Zr`R`VD&6UYmWcspN09sp4G$p)ud3pEU>@_w zuP*bpLfN16gN_B~-t;NOdCl;al^Lod8Wdx!#kJ|I=%>7-aULpGk3Wq2{+zu$Gmz(b z+g5_j=X`bF`JMA+1G6X7264t~GAw>yBNC>_p2#Bw3$Aq{^+2)uB^8jY75R{ru3KAE zm^i&Og99E>@J|KlE(m6wx~5a+)JX8;i_aO~wOnV+BE#j5(Y z{;MiH@MVvn>4cqK-a<;$0l^+GA`oO$W%90TwYrAbH`Tx>MD>6egkFAjrd{{Yjqalv zodD^mAqEIsZR9kEQ9mwyT%#Di zc3CsLwf}vml{PTBxl?Oy=yS!{{ML3IrPpznKG4KRef;#P8I6$Cg;5PNMzvf@5=rNe zgx3RZ{)H~dQD7M-eUekJWir;;hk^!8kZw8ut+t|mhCzJN;)Cq}5%RHzJY6**hQ}dE z9~lyC)!mk9y!XRq6t%9mb+sl(F4y2$-hW+jZWD_JG|eRG;WH%-oYj2C^n_d4@JWmAdCR&JD-;=q^l~2}1ZgS9{`?prnwzk50$)#> zv9q%y`mmRdvOmn=on7iMlu(POx7rnyV0vJ(_0_~2K@sU1+)An=VU5{RI|trevg_q{ zOoJM*IeLIW^ZBhSm0{}Bzt(>VkgKIcu_Bd%s$wI+>(LF-gPn(OyfM=%n)UpE`12Q1cfgA<$ta5Uic+yEo5*aF3I%Tvzbd8 zQ-#4<7e2OK*uVF4{8T{cG@$GKH`!t-Z^z}mabuW=k?DaS48)4yUocpR5tzg=<^fVh$OL@G%@}suen?!zQUVp z<-Q-|JIudsXCF+`)cCq%sPOZ|IH+)+Y6e_VWY)Y2jLQJXl*cW}Q6wcPi#102TGbu`(gg_GB zpfVHbkFNZ!D$3>w}V z+^?Fq0`^YPFyDz$=K;h)^iZfB56CIMh`G&doKiq9X;uuOugpD)R7ZCKDKMZQu=Tl) zRe195QsW|;Il^t8h}6OpIl+DE*^F+|+_GGJtA$yk=%FsQ?7$0Kc*KOk1IoF3zBJzZ zB-y>G>#sCD!vBK{0p$`f<-e1M6kgS@?*B&y#~Al?pvPwpa%{BQyhJWS%Y?9fB}?GO z$mo~y9(fgL27nSy$_4`n$!MqC3uU<`={LX0Ra`IxM1g=`8s)s9IT-b|5SRZ-3*(L_ zY^Yv1WW8^ICTMS+_hiWucq|D>hFG=DL2sKxad44j#H}b3R_~K(vZqUf{+EQK|dMr{@ z`<8;;)kV%u+0=h@Mf%iVp{Si)qTG|D+t10mJiV|b&_pee#i%wjnshs5#IFUl{c}s2 z#JFwjXE^>S9zMgc_mdu14OK{3LeqhA(zrFpq@Sby*6cxc&r|1ZDrAamJtsvRG)GU2 zpS@d3XKX5SlUfB4s8TkCPTkW>*k!L3U?8kV(Yj{VcpDl8HjaT(y1=1FyF5zoTD8~j zbQzGceH5s7W$kguT!P)MfwCbxY7d?CXUF*3edg0t)hFvCZ zT))lWfU|85`)}syl+9fjpIntRfu^UvOet-dlT3&Qa@f z>7MM<{4%GTIq$jy_!uVw-vIm)Y4J^}x3pfCC|^CAd!ShIX)mc%w~6%%EY>SCn)fVK@v3U9H(`47f=!KWc5q{F2)3s zB)wYKm?od~)y%N(56_t)&-iP9o>*U}eAq}p<3D8bLE9r6`_3zQv?S`!a(yb557zJ2 zIOi5A2tRBYxa5H;QI&n4oK$68CX^+*`5?6tet>J=(WpRrgl-buGxp2(`FSm03n(k^ zoN9h6ZQh+?A&0pgen2$sD~)Au58e{&%BkgdcN9t{Cvl^iSbW|oIiD3r<9hX1mc$pC zL-LxPvd=#>h1K^w;Xt@9VUGIlGsuRJS?iISUwLxo@EAH!^V;e#;ictugEp`*p&sH%K%k!7C*FFoz820ybCAbj&|~uI9FE0D3OO zh4TOYdJraR_tncM-mjePq)d7fvQYEqwK&W8zPgmxL&PRg2#kTOB47lm*ElJNq1~yM za2>ADlBnUk)Hj1mg@`jGWL?us$9~7y+P+bRI|;k>9<4e1x}SifBXA7q{D1YH@jKtd9E zeRJsg(SW*7H2LEx_b8CbO^eV?+Pi)rQ1pwlx6k?cvH$uYrp!SyZX=`Ozfa<4nbRei zefLzg+DzA$DRn^t4MdX|48sm?$f2~o3q>SQAG%oe&1!o+N_;B)MN7}H>^s6c7FufDk_Sc;rFm+Jr zK9^|MAU=^ff5^P!+n!JCaTaYYrwU2TzJ==UV+ZT~ubzYPL+9r-V#BX*N9xMi+FWDt znWL83@x0G=3|k2%4~W;=e=OR#4D$Vz%=F(*QR<2}1|ka197YvM5Ou&ZBU7_CxMzI# zp<$;Bm0mip{}ib7bPSO~=bqNAQPp{VGF208)(KYn+Hj>86%K&hZLaquuVcqSM$eS+ z%Jc?MM(j6kM933FpaF$VeZu9ZrM=1t?LE8>@S%}rBvV~D^w#e1Lt5=NW6^u!mIaq= zzUgtYZ`MZoj0_LoV%aLG-(ums{#O`RrRp7yQ2WU_C zlUq0Mh`g^FNSKj!M(XvBkG~wZ3DVzjEL9t}+*&36GF_8=(D$$rP8hwoa1>SWaX%0d!3hVn4=CcWNYQ)zAi*boVjlazxKsnZ_{w6QPwL^I_L#c-Lbtz!(@bZLap1r6^U@tp2}?zyQMlDQ6{I~W2aM)Pb zta!V}^*QmWm5r}WN*wIzCwbXySW2TB9ltg8@S*oDr27e~>C;xCr~tmGnHAe=fx|-U z&`b0T7axmZ=}7HSed9Q?Pj?qPh3Et9wn_PicSf0mbxR_3ww+X$mY3fbe~lx<SCXs_0$UG>G2b?2{(JLyaZa_xMtCE7&TKv95$^@m{Q_ z*r_pzUvo(EvSiOP1=jnlMooPvtv@jzpOq2%x0`7h*ACHs z!bJ(L5C;P{=S)z9gJPjL_GZ5E;aV}3gCNKuz+RAuCyaXtBNZINQ4>w_gEBYMTkeyO zat!Kbw{{hWbf(SHTsTK&$vYQkc&~GE-{Mn`4*)o!jq(2nR*zy6OTR^rx4JwqVB#Q- zjaS$*kl}%ves;U!1C3_2M;UM80!APo!Fn|_yu18RVkL&v|IOV}Am6mx;=(Tt6&gl6 zjlh0y`&Q4tH3h=>8wQD6%~$r`IN|Y++g!$`{L$^c-nEL237tsw6e)@tSp!zrDLkWI zT3Lninwlt_)c|1$Lg36yn^_a7l&&Jr2kq%+h61)SSycg71AQQO+uT@T|G00Y>cRED z-m;)1p&_8x;G&NtAwkdss=Wh#w`W-Q%;Ro&ehK+2aUTKk=xu)`Hk{75!t(kl$Jp12 z&8g!X%dbE3I|$D5esz~7me~$@_OpSUw+Gc!lig?ajz%$O*zpFdH>n<}$UogCkLnun zHca2X(?e%%dqeXN+!a@UbsSTRT$J@x=NXRdRWR}~dN*6vh^C>ma3FBpc}IY)dCF%S z$4gquEGE|(=ww`}!rg0^y}HtutgQCU@*FK;?Yq7|ghF$AiS(q6s@#wawbe*f0(C0u z%9?+FWh}*=x7%f$ayOn2^nHE*q3Xwh@tRM^BExWEpn=y*`?;8&+1OnP-v!lhx~Uxp zx-1|+!CV@h`wh{D|6HXQJw;&FG_6=nC%;nI%|P5}4IQ+@g>R&_!@gGVmdr=bw1vEh zQDqczr|!D)R?gPv(^`6{uv_pYujPVy&1)nB6FKp7g9|xAUS>AJQxh@-V>+_UYTWzqBwl))HDI~$LMd&Xc7M_Pk~d{1N^(r!{R#+bF40@| z9dHWjD(jq z(%98z|I*Qsch{)67YSeN4o)(#==N%}!F<$V`Rlbe_tQjvD7pu^nU(4AvIf-tc%76p z(|6Bl_lHZvvXd4U;uu}`F_V_;NbRQo`E}}Dl$OezQ6eGdR`kV8(GIj0l6-0{19$bo zU^*2XVzp9zBt(|35lY%}ByTX2TXYkzCx^L(6xQK5HmC!Md zdCEFe-t)gpV+*4_;4_4ETzEOy-ix#OSu!ktTz~YOy zTtgqdo+;FY+jja4+RJhz%e8%!C28e&CnsgA@$k-kozg!Et-BRUHXDjhc}K4XciRl{ z9(}FeX}CRDsa@Jwt$5J#d>Y3;H3fyDh4tYCyS7V>`GQIP(_!TKVVU8#7hHD*?ip?E z7a6HCHd8HDktjD~EY9GUQ?GIU95eOFU=EGXZNa^drnWDdwE*7SM=m%14OCye>opuF&Jo|iyo^~B!qtiKhD^p?j`cw|qj)=;3)6koE3n$f zJcd^Jcj9Ynzpts=_Um77d?q-G*po`>zL4Zm%YT!S2V)-J5KW1^BJo1O&YX+Oo5kCB zOH8Y;uOv-Re5aN*qe8Upw_2NiD#{x%;hI#ICN3oOhD#c(&hI*YJ@W}jDx;}&oH2Zx zy{7{s)*MGZX?5#pod8bfB6Y*pZ8iQ9(lOb8b z@S*JB2VWm&rLHI3I?2l`BQer{uYmanrRc@3>H%%Hhqsx|&Ye3A?ISG5k=wgWbDyV^ z^Xhra^+%tawLE)7p26+|DcW`vszQ;)jD0(J{+EBJ^cJ01!`k{<#efL^Cs)I=@BG#) zIthlI4go{8rn(`;`eLX3eD7#4X}g%yP;v=BP`nl1&OR1@<+)Li{R5dJ!sFJPtTzr* z(4S-a`m6l5-R=`w)yqqE7MfRroJRCEPN}_~VzAsKOPJUfR8HA&Zt$|ju&prnTmP^{ z?-=wwIFm6l1V{keDGYru`XQiwHk#baLc0bZ8MdlYYJYv;=ggoxl+*Fu`xvj#teaVp zJjq4nakXYA&Y6mEp=r^K21%}uM?6D1_ch#(&Wq9x24S2xS$jG74xC@rPDbqad1u!W z><~Nw6LK_ar6}7$JAvXCEfqVj*JQVC26a86-7%N}E+ov7@#h^BWv;a#OqyF*Ogwlf z2y+;~iUfr7)qVACNnj|()vcLh?V*FaK5BV7woZT#v<+t?4oUDsu!uavEPm8*h<>sm zYB|6681C?s$3~Qu?Or*WLH}|^{0^)q!|%`h?xxHL zx1aTThAWkGYa!fw<Hi;p zp&b?D?6wpkA-WG&soemzKx@DN8zXn` z;B^z`C-|x)H~y^yT7NJNonV^_#M>4y|1ryq=~xu|N3HnT;bqIv@A}`Bh=Re60g8sM z2pIOn%jIkCjwB7!OI);+_)JqNHe}Cqj4sP9{KMt}HE|4!LR>I8$==Z&En_?pZWo+c}~~Q6KV<$hWjuq02K~xH7XG>F3@7z_-2*x;P->} zuS@|^0ld>NCLMhx9Q~hJO-?dUy|6|u_?CiiCfISy%V|UcKVRV}z8xX6EM9RKkxR3w4jp5p!qq_Y$@=G!XToE{E8eoee((`DE%r|bhN^gPms!;;X-Ehg2Ts?ugv3>V-#*Omge$O z3Em_qNkOp!mkYfYcx5C~L#$re9Go8CZ9Ry|GZ@|F=*l<>Ko-8)-H@j?{NWv~G}u0}L&F{yd`3HUvJN4zrxVvV`Pz zEKvpsi6$GeKCixf<)QE`Y~5!E%LlpYwbpGPQ_7)6mSQi(r!0E!#=1#-5l7}U(qej? z)&*>!S~0kPFrjLxWnn+ttMc$-bHw0Ld&^1WOC4v4g;PuOhS_9e52R(Fu3&;nFynmX zz>0leMNL>!oSYAkVv~`*IXE zBbmE>q{_^YC~Pb`;o943!F-9EkBw7K-FZm(U-1xCmJW}Us(0rj+kTIfp|96chSr3l zd|dG5pf1FEZ5*eCEnS!Oz#>O%3dp-kxfLtd>4aB)2)494y|m#EtRHn_FTPZ)zxnrX zed`2~k&KKP!473ORhAhv*^1rjxwqoLefi^cUuuQ`Zu_@$zb*g40)BV6N-8URfy2&F zWsIp1Rh)CIlBUvWBV1$s_yMyj2Txra`%3Vz-t$uyp%n@}dyQ|k&vR@$o5o=C8cidoxEf@zcQgNe4 zoU-jzlny0Cb^WOGe~4f1!jtVJ?msR{^Re)Oa{($6h5_$BpN~l6@%rrdX?K1a9r%C5 zOcqr$!QT3sYyx$Y^yg{Bmc+N>c4M=9G<1GAgeFLT+HN1!^?tUVQy&jpBQbxze6Mfg zDx9|!*4j_g!mX$qL=!`%+5O_*DBuTfZ`MqWON9^Ihb5w>0;gD#bEXd zH~*N_OQ!@fbS>Z|1@9S*w}HyID~QE?OsaB<-g=+{{(@CJH3d0#1g70w$sJ~5EMPLU z)q1}8l-#eMoaiXAiv;l6Eo*|K#f>u-6VO+`eu=Qw=a2u8~|_rS1gK0sy@ZLASuZRt4mv9i(h zWqg>g7)xZ?)az$Xmt<9Z8!mhMKGn8R&DQt<=fL?DQbh@0*k^D~h2+zTnva#w`d8Sk zc8i83-9DO2qb{+&dG2_p&bJMBl^x4AJ^DY5676%v_^-*&8dmgUN_}im*!t+SG|O~A z*q1+s*cf2vf%1>j2sw+%#f_A5FxnT>IJE9HuQt7KY)RJH{Z0hs^tlqJZ&XF1hcA~W zp4UN*NIdNSH!2`p(^a|0DT}r9-{Zxnb)k?Yhog z^f;m?8*RntpAO&_fo<^fh_FQ7T|(A0&tX4II&MlfeFVe1h~Tc7fhs3V?38$J=$Du< z=su6E7Jg)~wt4RG$B%$;TU%S{z{?bxYl(qU3oB5mzSlcF*qpa zAMZ4R!Pn|knhTydN+s^F^tr5_mI!&4SSr1@juKWbi{Uej)8G#r*cVMWaiZ+$vu&ty zLSZia^Dm7@maDT$HZ9`IQMzq=Cr-zH^xm?A3J>o8`*Jm; zq@@9<7UxOXN#TJb6|BWzpvJBFUQ^bz`Uyd1+PZ;46qm-2uVKy2dxq`3K z)X!J^<;aknS8B z6r~&K?v|8LP>@o(hft(DL_|PJR4=!!}bq6jP)T5sVR?Vys&b)Mrn-&tO1D2;xAqO2j9Z<5W z#)VZ^5n@Ln@*TK=Ks`hqYcw1`o8g(zP{)_ zGFCh4!@&qNAVF5V6hi~v0jH?}TwI*hVKCeH$b%P0-L0RO zyFT)aYc^3np{Y%Sfp9VS5;APzeuefUVCvvXu)I4;@=ys%I#jseq6QFAG|N!D5o|+g zgYd!wlMj<40FnS+qocEojNq>&3$qkh#J^^S3R4mG=YaJUeZ#njCY`U%HWg1$DQv%; z3fS;aFZDOzN>;^q>D&5qaq_{<6jk=WZI{QF@PR>}BLLoTsujx;h&FNoI#=rm$_M?x zPFUuFEt+PbSb#27C>e)|66)B^VU7f0MBBx#^FD+qf&l2h{t@uI&<%I8#m2pZn@l## zY+Dxteqea%mw!RBo2qym61~d-2jA0Jh6EQc947Fo@|HnrqbqhyYH~T@hk2&MUS$qG zDLKJ~-I6TZXf7JfuYp0{q(sTW+8|&J%LN+2dVVep5=f{6%A-WQ zkWX(YtjKrh_u`VBj?L9PZ;3>x234|}MSeGcNL4r&iQN*nvIHV6e!<;tSq0Uia5RCd zi&>ORVeAzSN8n{xJe_nO z7G8hBn-)&S#;K~dI$h2ZIp>ZII!PJNbw;ETY_F7mM@nPJEYy!=( zfEfRWfX@ioE+F<-CCYW0DSht2|Ku>Yx*k%%Z&47`F#`L*6f7?)lpA`0+H(I-3ocF% z^bh1Qxbhul*%K#aBHx5O6xqu@xC!g<-ZA~3`^Oj0Tx5P%c~X^Ir#t2Cg62Ud?j9d& zP_58k4sK zFo4iGwgC7qkcA2oV34)!r}TAVFWOYg)g<{C$nH3WhbeNFJ-c|(R*4C41AMk5#p?>2 zJ4i>Hw9$83$WuCV-=78z0#g=J#&Jlo+hzN8oqr2F5gc=gJxDz>Av$8TBdJP{6i#N) zL*=11x5Hi0br(N!F9gx8yf6)-!5zTN(3>t=uL-(Jhz0EY^G6sqb2uhovxQp-U2KpC z4lFDZk-`%rGFYntI|3mxY$HJXe>SYviD`iX9sno$b4q2VJ6`Ecz+&}qsMDjbHwxMR zvP8Q)?+H);Ml6w$mJUVfe+@}3;5AXCP20NefAQ%wxFkgY*4dx;3 z5R@uNAY9fhbaK%JaR3>DL^Fhtmhr7Xkohl2Wkw7B3&-$ay!i^fE;fkHfB&T4Ouo54 zU2>ocA+zWO9K=>h`+_Lvb>~P$#Rk6TW;oRj-Cf+=+nPgTaCL$FTwuhV03Zc00KuiX z*$x8*kP%4H7#NH+l<8lt4yh32y+x6hGdyW^bzi-jB}SNe`FOJ|r z&>^;?bvN~Q@G_=H`xB0ze8RwML*tkrhsXarEEZ>>bea-hrR6R+yJLg5hRE2+`ubeJQ#WIp-rZIw zd;FK~S61rNcLX4q4ze_1B_kK0Jmyl1LAP80=n3BlC{f@`fhWa~Fj4-<=tea=w{Pps zL&41?`fT-V=h8G=CP%tPIeQwr--yk>+d|a=n+^iv>^}zY%ScqrCblrn3+@GVdR!5$ z2tUlpU+Lh_4B2dt_Dz_Eb(T0q%I8tbv@#pZPP$|$%vdmYotuoX?>+sF@jFC4Npoa{ zjUV;GpO}TlH%BPLitMG2v;3$iP7AKM1Wk5Pq0luWM6%3=nOZ68>+GyNB;mpIrB?w1 z7-#}&ck8n%gv05u=LlcApr;1la7I!d;NGja85OF1xC28nTm^t%6||RS0rUfpCj?sD zN5C2nES)w+bgfSSPz)qjH5ecTEs*Y)J~-q_q^M%*^l}?J2D67$)vtw!1jJO!cMx(&VhSbU1!=f^{y)5yXbar3=aVykS_aXnWCfP?P4016Zx zehOzQjHd-U7nPuiM$ZY$%LVPZbPEtb_zd1jSixakgku!wixcR1DNY9zC`HPYTgO;Q z;t@^0k50kP`t9V%qWIZ73mW5}=5vbxNVO#CjcPn?dfyb9DY7DB7?EEm`La$UMyw|K7OM74u&Wl$Vf@teGvPA#D2l_)&axurq=E&6_QB9&q;68} z2ZtpHIMGE=Zi?;e>m@_xW z{B?GlU?nBq$9KdvbZ$}5`F2pGFuDG0zK(%+SP_vMqbTQ=I~X+nuvkzHH$z4RCixxm z`3-4x=y9+PfWQs7y%RH#>z~2Uc}WTw1gOAa4eLCavTugQaOvrdC!4B_o)i=29j6E9 z7gug(+ExtoZf|qHL>Y?5h#nb3<2SDS4rzN|W`5$E3S#$+nC|2lWEm3USjwWH;lq3u zvhcDh=$hk%id*5QN=PC{Ktvt@Q{OlZ1=Tq-%4vUxm+h5BSwHNSgqJ>;k24!ct^PG^ zjJsXb9291q_kB%&BWIe_19cCNN&c86rS@5{k(nmq@cxAqy~WBG+IJBbmHrI$H{7lW zMR!|W$!IFhf582xf<(%g?t0?;XWSC4mx2H6PV#1ec(x+&oqr-{%Q802*Y9&u4~pQkel*%)*}6$|{5!oN!R+vU;ADS) zq+I-#^>k>CQKdJdVJToZFlrZT_r01=JGSVYPR!ZY2#@_h#lCfpjA|LAhz*?+ve3dZ zE15%Jt6kNQ>nqc^Mvqs038yds9$;t$rT8ejy(D6;>dMr$Zhn?q*v zC;q;USFDwJ$FzpyXiXnWNc+ca{rxRykebcugsjO%sjTEfgP`K(=il?{?i8YO$*0a5 z8HF}(MLyS4lhc!`AZiG0ngEao4MbGw`Eg~S;z{kpUg>z3KrgJ%^7>FFfJE8@VpN2| zvz=d5g8FB%T=eb@p<>e>7md~OsL=>+UaeW8m`}BJ>BGPo{w>$FWLtQBYDkcC1RCUI zWt91KBX#py_VlSd9G}faQ;Gx)Q)igb*u7V%K2QU6galFtYvDXp= z*DgScFtssX*eGkq4e*>2CVrMLKHM>&-V|GOo~w#HkY|g^LVFw0*{qXx=*;fBTs9(I z13UZH0Bz+y|3eM>4RpOc%%**XAB(XD5uwI{Gherk4J{j-Xq`ny`GjT_=WPKTg(e{~KWI1@{eL8>^!(9v21v0Ql z!veqZf{Wv`B;a0J`;E`|HlOUt6L0kbBCw>b&MH|x^iGR*1E#vMX2OC7(?W(3t9n@M zU%{0I=sO%=Htq(I-6@|cDHo9>@!pgFgv73KXjkgEv{PT+#|;4;^%cNkZrkdyy!(4k z#i>2LUWg_JJOApU_lwpAAu%_a^nOUx&IQdfy3ZBX9m!eW3bb<2)j!{+7`AyV$Ywu>T+3pW;SI+8Kj6qm zdon6V z|MVod{jVdJfj5E1Q0ZJPQ38zMQhvG|;g3*A17UF|7YmoqXFolsg((znX);&ADojyQ zjn3)}^8(gk*bd;bhB$Yo+>vW!e0>kcH!<_=>h>Zi`QEUN0PG1WdbBh_kbe`hBQZ2} z#DMaF_`l?fKHWlU^c(;({guKv=|K33HgW@Efi>O;^k~Dgfoi!1iU@x5$q706HWdhR)H zqI8j{?!+?C6x`p183}0TZIik61-jGLBtc7wY7$lUwTfMlx$greE^SHI7+AWLggG!i6&T`yOWPVJZnA1!0cT)>mE6Nj5 zWweE}z~jTm4omap6i)VWu}6gFO`Ae3^Gf^Kqw`bh#kGb6O{}y~-2(#zqpiW%!?LOL z7OmFn9-5iHIeyu`Ne3mQiWmMH5t#?iVzW=B7b{VDpBT64=3Yi{QE3DVit*35x;(WO zFP5wjOH(1HcVWP5$3^T!HIj0gr}{h?r~^G58@ZO1Ens!chAAPovTTFQ03w(5Ibzx3#%Bwxa4_ylqOc<9D}&?+wc(4>%QU z=4E=;qd$NJoIO>hkS+{Suy|;pvk26OQ6ar8P;yleDmcJz;#k{PL1B*_zgZ;9z zGqCX8^op3{^%gL^tvv-y3Phb~<062H!^6a&!UoxOFrp|qGu^m}+cb$R>I)F6P)l)6 z_T!R!$s4?{Kuw@q670TE=OZhX3Q0lG0Fp1X`jy6aC_U5x&QY`+7JwFXK0k+Y+&A45DDoT2^H4fvLDLo!{>2FQFHlyTc6viFov) zf}0s9?KYYH>;UZU9H|x(D9$1{0DuDl;up1fqU%{0S!-9t3#`LFKosOD&-!O&ZPOfC z!FRYpukO1_%7o$EPvzkwm^gk1(PUs7?7?Bn4<82jHjrc=Zw!;flCP?X>nc6H-It|q zTZ~~l+4K~qEK3&Jzp=2KWhSp6s0h&;>Hx=>aRqN9{|$l|EY@8>=(ye*7#O%EeR6Gq z4F~o*x?^n~%Ke4Q^MD?ci%AnP@mbfzEsf6_8==aBs-PYC&t-|;;~~Ze*kWFX(W8^m zJa`EGPnN>|GpxZY1V0~KNIi6XrPDTu&v|Jc{l0_{Y4Gdbzn;r>bU!ml>HCpngViCL z4UXT(uMSbXZ}fch8w~dVb&Jg;m;-!(=E&B{ed*n5Fkb&{>RE}GdjbnsktgJ4ptHrm zFnRAjlpsL;YY}ldBVzS>i$7i@S4lPMp2H9M=S2Z0`p8+K&x36{1lONyEKZy-(9;jG zi5EGU2hqjiYK>a3kAZ)dJGt|^)}A{CCI*Izyo@gBO94~?;}Kx}I2h;-+Fy`RLX~3q zpD6^&6S#*wXO&ylk@n9Ev<6ofP7C8LSd0O>g0}-iZz*&>s#fQa01tmxJ}N@!BSV`- zdnq#qHvRZFp3u6N82N}^%Z}17Dzch-f+HFls!5o7Z`he z=TgH)$!{{&Fia!)mNKcuV=b9|05Idl-V7;DtvLf7b=6tsIAt+1u zjnjjqe>~X&QYOJPJ^{YN8d%+J^?wqFix|v5U1}7Ic@GVU5`p+_$&Bcs+noa?iDZj! z+nVO>`sCMA5c^@4nl)<1nTHOE1?LrH(uEA1F)!1_LkjXW1&zvdoDG#M3Ix|+Q=xA@ zd)(*qnx{sKQ?qpUuvMUTl*cRfRpusBuYZlFZ|RMTzZpi(0$(-4GRhcT#D~T26tJ3z zjE&V!HM5E7y#FQ9xFV|*hJ@>neX~&RW?TNTr=FGsS&RGD&oIJ8 zQx_-3RXC#c=wlYAOrDV)oSY8H6teziU||uE5W=nya=KS-qLBvU4m>hh&@!r z!p)W|7zZK*t>%?e+3S0!758M-Y*BWp(fftKbp%)MqAwAjk0ZK;y->3u~4RLp5fpJD@k0CD|z>Ar;S4aI8XWqd93DB&C!?%=kE zMgOFt?d-N#m!GMrOcKLAE%T~moF&r&b4kVDV4gv1)lMo9S^w|^r}3UGV+g3K%nP*~S3a0BByS0Blg4f-WC;(GPu~IlBYmfN zaLr8=0?nl+E{n+Gr2#Cq4V26cmhuE`xxD;0XJ{7mw zn(;CyVBNy1QqeV_l6ru^jEZ>%cN(0E&-5wL{jeZq2Wi0)m_!mh7a6dIA29vC0r>sI zA#RWiTyK)zzc9cSUEG_ylXNU#>(KP#i2B-@v(u%tmX)cx&FHrUN$Bp;E(bZe@^Eaa z_Qoej_L^CCyIUKNk8;rcQ<ei8XDWe zT@=pTJ4YF|wxfg5xq^Ers`|+Zu1oyjMx2KOk zW2;87gArKHKcU|35lKsI6KpuCRi^HXgH51s>End96S3Q`c7rjkQLGFPI*vim2%;Bs zbd8-5zuWA!8o@9+`+w)(DW%&yUk?g>ZawDiWL*4#KSDq-_x6{^*>}O0OkuFfs%(hp z?77ap&QcEQNcaliV|?fW&iOAcXvW@o&nSW3OnlAu5XIg*1__prp>^x$MJ-BCeCKJHuC$agb9(Kqqc9G?R%(Rwp z{pbNi0V%=nTcG%mcg%QLxwHjxKuGY5puto|405Qz>>w+<`i&%5%jC%6FBb*D$&dPx z)ua|U3S>CMaAxrMIw7{@3B(|R{0D@$pC3SI3BRtq($-?eu;it4$+yFd^e>Vw*>+=o zCPEk+>IS+a3(a8O2k7Mmo+OdiZ6dGER^sNL{>_^$z&0pxhT z3b-R^me7XKTs>{4VwJP=A^)nMj2Gg_T}n$sJ*&6fCv+1sKkTR?M z+u!b@Bqb|+H_Os*B}I(7#@ROcP;SzN6!#8VXZlz!R_2&U#1W=#RtjA7Slx%q5S{Rd zZnNtt&y-%++OOxiW4@{$i$BsV5^(r8O*wQ*Y-Wp@ptD&Yq88Z5Tt%;)`FY=QL-)la zj8Gc^zZkqPQT^)7UcApVUMwyM@oc{%9lUC}u6F2ruwZx}K|*6DVtW0(eRJ!&qTMKu zYQi$!zO6ZCmO^XREusTH@lSRsAGtWj_c^MUQplLMJ7SR*ug7&JiBnIFqJIwk<=DtN z7&?2Zk$_BerseevQamyk$H|B<*1TsE{-o{l(RAivK;%=JU6zr3$0!C)^3Dly<+zXK zKZcG4eV3($Ym{8o$oUmI@4v!DG=ASr9kwlvpR|>E?n_JbLBH8mze`fhoH*+$#IB8& zUvp$iKUnuWp)Mi82$z0lpef?DbgUf!5KsqMPya4L4Qcf88x=TV$Wc|k#vH{)>KlEP zFY?F>Nv|3C2%$AJ=>uDyAD3?&$ZTfYT&*T*!QV}96Ef|sn$m7dH9kDrnFcE_c^q=u*?U z3cepD*4uwXI)6aeDsWv*e#g}f8|=~Ps>O7XI*d|%;arJ*z4cI)hHC=4dQjUHLLDYG zefj{$j|=V<5w-LN;yFUGxEatO%6PIgyur6EVa0DZZQvCg$!Ju=66hnntPYQLQg)dP zg=iq=eF1GV3T2M^>Y_Y818X+r&iwhu{<*Qg9lk4qc~mtJ?$l*)%a5NZ=Q5NWYXVIZ z)bWA_u=6X7NKJ59fF4s6cl~*0Y{QmAmQvQoN*5Ei=b+Byx_S-!iktr-X-BYR8%AUqurTjX*I~o+1F}PI3;q9EbV{CG;DfH7j5JI(xDpEZ`6in z9~4W3*C|~grF?POAdoCGtwfp7SjB2E^s?lAUr3RfBjS~8SFCUC?C%^p@Ac+)@7|${ zo*kxC#CWSV4};wj1@<6wm7SpIJ-m5rHC>W-Xb%%*H1Kk(7;jQig8FUEVXNZx0mXZc z(4m<$Ep0ldfN5G67z$~6ZJdQ5Q1dbIB6}PI1`JjXl(CJx7qElFCJr%4bz`$hbD4rR{ z68~~~#{+RT+UevHtVezEk=ldETJXXfES%tahPWXp5Yjr#6{f+U>&=F!N8!w5fo6B{ z-Cn^1La!WJ87Dj!=>l6Cgifg@tK`%B8<&0dX4XnL62PSb5g-SP86azrYzUe=(x@** z?{e>iYghy)6Vg~&-*eB=>#<(*b|qA=%bAyODu~A_AuY3h()h)mKjh0xzIbI=wgGZg zNf$Uy1j!&oDFAiV#h`gxa3FuDNSf7LLl$e8qO50y^dww$`_Y4z?+Yh$!Ov9c1oHnJ ze3Bza;9aJ1VQY*FTsr@8*g!&ylJ~umf^@yZ4*Ih}yH*m7TW4?N@1^29lc^$T3xEA{ zk9xew6F4di#l7WMD}%$5RVf>*|nZ%hIb$JP}Jp6)*TEq%0;+T88a{kUzT<-B=w z;nVHc5{vVKug;T)RsUlat9y2@Sg*<>s{|g59TchPu}PE0+XG^uXQTLhV~d@BVzXOK z9B=&d*unZ^T$PL@;i?sDf*9Ju6%fg8()Hn`c2@gi1nbCCXvX0al{4IZPe3iwS^q+M z*P)r&-O0!0g`UI}`3rc$n!O?_w&$znLO^vmB<}yxTCf zl%4~+4gXFPl|7}*VBnBq_q9SZ*E2J|5mM4B>02smqyfR>O`B&IpUhu3DkT7a1e0ZQk3e1WUd9dvo%(57o_I1}n0`GfP#uvZ0(NAeNqMIJLb)Zrp_59s(@f9-! zMU3KF)&}fh2R+D<^im6oqLEVT@*7A^Hl`PlM~+V0ivV{FOpY^SZYeo@%n~WyuH?hq z&c(>k#O`7F;KAue8|4d@TY=49WfN(cD1ylr=Y(kY3FVL?){Ln6bG9+!ADOa>hZk>| z!vWU@cq&`M3zT2z-gW)Rx{12`QlHK4HorMzt5Z3+SmO+T;A*fep4 za@OZKTPm z2wS@IP`@gWA$;E@*vV1q`%NMUvzh()-tkD~jT2qUkil_avmM;Xv_*d%W__gxEBV94 zS-ND^wc}@%;7ndRVpiy*1F5C0ZJ(We_C!Qlz`VV80m$D&YEGk6nfTRCM`QiayV1vYTl>Jvxr zJmsmYVwuK0--G=8S5+{qIWWEBs?y~K4riRXYGH2$^n)j-BLTbwn#bE#hw{Bi_P_27F8Cgt*t4AO;3| zKp$z3c>gL52g;z7>d0#+K!k<}Ru-1r5y(q}T%!kXctFiG9KW7_+xL>+02M5n(lXA> zPCIKja`xiz#cGblO%XTm2F+|eDrG?TOg9<9a(i+@1zALgpPgcx3&L-0$yUqPt{vRP9nDD3EgcGmn90g24@mBqdq575S+nQWvxe88wb*O zPhB;>n_5bl2M}_GEedjC93!u%s8xESmC6ITXv)FMk9W!*cLdKwO%mEV5m$-MF5Z#C zoEZ>Cnu&K($7uQyllvA5(8Vaivqy$`@RA&Zn6;qBQr189#`>zqbD^8bmin28oJWZN?B`*kGp0{9I2f;FDh-=W++v%Oa@GIA+fiNRZ1k{80ccxXtj`gV6 z8{2|GmER@Ns0w){pTwj_O=k?vv@vxojdMe*L*L|;&-Nr!6Ss1=+R2DFj3>pz&s1oM z6r(cAt9mpfw8Xcql18NRBTz{O6`AG(&4i%RXf2y2 z`)KFJ(Can2SL~vB*u2$F?U%a(zz)`(bhIMWAsR%Jz}3-<5iYKMFxTt_#UhQm;G1!B zOB!18sWs})083nHv=^4*49rx&O<8p^l=Yrh2U8O%1?g~kCc;}Ap|mlI#3kjSp-oSO zik!c{bLh8S1C#_~@z+EImCZ852Fid-5w!MTMFJEWWZsrCuKXWl>TAeQTr3T9AeN;( zIQ4IWpq_uH_bxX;z;hp-n!Y}K5IL_+@YXkkn9qQD3GC=-z7HOMl-9kFX+K}xU4ScD zUo%M9+p>Sz-$0J}EIuER<%pS9h+g6O`NcgHVfL&u%E5yM%oG1vs*LSI?0VW`z+5->2J(4q9=*LhG zbm<^`yY$VYibr8D1h8stS5FT%Fqo#NCN+U;%#g%EHHp}rpa6=jbr2?`PuRg2ji z+xZ2F-fs=Q|L!QpkfKozHLP6>0NtyU*FFwU$1&ZpEg=C1qHckF;aF;h-WYQOkJ<;p zaaU-;D~M8NU(I?P&m5)WIiO>U`)cT*k$)PSPeeKT zaw_z3*B6?CxiHy(6|v2=pGVJ&M1FgVDf zB&FQAFQ{-N7;n_?hdlUI8m~{aWBbg8-UxZ=Dye?8$1NT7_^QRr$~SD6<4^s@>$AP~ z++&Z7KXNbSSnrI0%?)~-XDOu=gXLZcmeRT4U^uAWAP!rTbg#Cj!KS%MG=%k9mkHTA zSV$SAfKl4L0m#iyBe}j02h^;pG#;S$haX}@K}i8uJK7>$08GN|Alw6;8-!d)iX3H4 zeMAv>#7|BCs0O)U(KXJ(8E;8qP;kJp3CtBN1RGAHy&mH9DmryLjMMMaS;ikRwS>V! zZODt(jfvTR3iISnSMPl1_-b#<-%dg?={1{@xGqon4?N*LaZ9M zrw^sEn24K|s$@3#G;-O$-9h0O8OC!p@75e%yuSb!}a6nd-kN5|SCBLr^KmL3ydTJGYI zs^8$_bYdwJzcu=Zw{nitx3kUO+Su!2r5@g#EuM1H+uP0B=X8XQVf17`IhxV`%`I9LP>8H<{e^ zI&F@+~`&@Eh*SX@fnbbTV@fDPxfEe2P%1Q@jCh%v6 z9ptFR)hH@f%N~l6M(08I%`d1Zha2?2UX*}~#uaS7SjJ?@c(LbakDvt#Vpyv5f`Cwl zr3%!rg$(Icq52ij2E6Ne)fgJWKw1Y3p-iK}4O|()&h&y6D%%8x+fGlkpv&Rc;g$}F z-rx}dxPApvvB6)24(|l~oUab#@sLH6)88YNcinU8MW!C;fHCmwWHvZ}04KqNL5cZD{_E25*}s2mpushs-$6p*l^i>(23AJ+h5;O`lEXMyzSymBYZ zTYa&hUz#F`8!pk2`5bH?c{$y3qXZ+uIN^2&lcfP#;qca#KY^~4`Py9Q4HsWyIv)Bj znVIvu3*zF_K?;SH3-*fs6sT)ckvZMLBb^<>Qu+zPhhC#;umy8j+Y4vb;pv-oxTYsR z(ASD2aQsfm(FEzHEjv5%&1V-*p#yb1VsxfHKKilQZ2C4JO@K;;JYM?pUoY^G5D5-2 zWgqQ!jGzj2x_N%v(~-GHeUGT`w*G5mp3eD{iDmyHXJe$E^E0H|;skZ5T@25yvW!^$ zyon;sD*ly2olpL0t$82ZnG600F+qpjn@?E-3`+T~l#p@kNM>uceXgCF6moEwgpxs} z5r0t~^^70IT6Kxa^CsP<{-ZL?rtD25JZK(e>ZQ3c{Vp7# zD8;n+mpP}P5-W&xm;Q#|e|--1pFpI%O%7**n z7vGHn%6;#@#gt>>ySQ2TnP7kf&ro+9wwO-tXsnCI*6&fs*x!jFvg@tM(6bsJmHGrY5nrzRK1L01(+u^_jXA;zNE1z!d2gvQC-EZYZuOcU#*pD9rj$Ad(r%mGHj z>!4r=T&cJJJydC-{XzD2i2nM(>?gUdAG)DDD*tP5&1mT!87m(pe$;62rK1BAj)g3t zds`p;^;+|rD5(`(orXfm79NkSSc^ZI4ai8c`d+%m4;-@FPstdlpiWBQm@Cad@>it| zpH;?uuu?zJhsxEI6FLt4*XKE^Gmvuj+0)-2?b6mR4@RprP5Swl^I7Q3hp&2Ed#L*7 z8PL;LuGu2-zc`H)fx%09`?HsowrG_OWdqEu|uY^r1-QmqHh)BI>eeyT$tuYDKxdO3DYxZhx8BsUeSYLOq^wp-3ezOX4G|HM{jh+Ou<`fl zYZC6>Cq}xjgZ-fD4DGdPyF71Gf|5g!(@5huDPxFW-=NFJsZ#|Y{eIqAL!tg)$NM`a z7Xt+e$=@HeJyVFU*^0NBj`2a)G+2s!WA#?~Koh`>8S> z)QmohEjf#0$n&%viMzkYGjcX&u)FU}AW8CfF}RT+-+Ky!cxa0kXeyeCvuD7V@cIyOyqq%C9LYaj%HVdr_D6ibzF@%-&FFLX zvca9B4=c}@QcNIQSLs{)aF^gVYA4b+;`zr{^>w_0c9XuL&-?UQDh~Ri1x{zxOW{OS zxxRUtr%4>v^*M+$9V zzmUq|`csk34|(&0GDwo%H%=hA$3z=D;hP1YZxUrAV?B~eO#O&%zI75IivU>` zR-XkK=(|#RRp=xL4s2s2jlN2kHjjRt9vbz;_kR$)a=qn)2zj${2A{*_bnUGPa&TIU}r4 zA%@*aSCHwm^=HyYGpiRsct@OYCr7roWw=(8l9x!jGZO#f`^6k4BUcYj@cssG=f4c| zYCM#3P!nmb!5SxjQ*3$`S6zxvqa5qCZAg)52~~vW_6zn2On6~IaWh_*vFjy9oJFf4 zT_|l9`HC1j2$zgZrD1B<)PqTxBA!#~H$rrVuKFR4$A@^rzEs2~8dIyYNF#ogSytRA z--N9zdXf*kp6?WiN{0_81E2t@s>%ae2@Fr#dK45tNVlpjR_@i>@|>oF9tDyxp&k*8 z-~IbY2i7-I<|1**QGc@BBO+se54DKp-`@SQe@;DV)1`3TP$ZB4VX!{I-orwC!v}*# znZ%I{*FO!vEp^2iZqbspvHEuh!ks}4ie4c(5<4IU0eI?LwbU^hqI3|+?zY-66#Fpv zi;r32_vaax8?9-MV)!xwzGK$mBLV>@9P$#5?goeA)3(;1i4eJZbQlHu|m?mtuj+Fd8$(|E-pVt&>KJcICq&CF!D$R8d&yvwgOpqV(q>|j)d z?8KleBP&$FAPWHk6{PHV3GEnx$mD@Fx<_&_Pn`NQfF2om8+ht^AfOVschI#!9BpY1 z+O>rBl1Wy5pEMnNc>E2h8;|!Elwdq;G*E!RV+tN3el^f;+yWz4@HIKSOtBvp0{E~E zsdF5V44qEmJ>lmoLu-XKB?X*ltXwoY98t#2T{;^DvCWJ2Fo%0 z19&&wg|Ksi8xow6Fk_Nhs~2*kdevFnd8Z&YKNu_J>ZtOz@lP7#NsW6A%oAhzyg}x{ znkA(_WBlTKr=!uyN}EGv3(m41OWY=fqSsq9g<_qK-Sk}rM>#6H$|l&7n`06~+qTBG zkL~`H#D4vXFoo9+unBaYmEPmWU+i&)Pj2WY1&a*fWoMtxY6^%u(;=?pXVWqS=f|^M zv@VG7Pro+K)J>D`-Q?SPLqMM|*!gUQvA`ZY7VyJ^gRDTll*@7apfvkP-<3*TDTox{ z)oFBfvRm_yvc!`4XVg?}L3HFsf#rLNgRW$|{-03wcyRW!D)Zgz@fpL7;G<8{EG^E* zC*t#K67=Y#LDrpMhVxn+zDYmLQko~nA{M_5-x$m-fa9T+W$OJ?-V7gj@2q+66B5#Z zt0fFFptp#Gn^`*4SxK{Kag6*a#WyB&Bufohi{N(xuL5T#U|0#{){j2{u^jFFlQuR{ z6Kj)k7@ywK^M)modAkS9;9&d#!@w|O-14G}nAGpRf(^|L+Z#7Q+XX$(whpzTSxSJ=~ zE3I?0$X#T&Q1-k!C`^XOpY_Hv+<*YG%L_M^rQr~t*osLRDqlm>Or|NJg4?C zR8jk?AtA(d5c7}86R{A`Y){0$`9nOUtV(;RpB!g979O;I%VzKUDtprft>_~Qh?+iu z))9>RR5>)mTBWEHbW-_jGg2w<&ahOg@%+u}X?dxYagPiQ4JitZA=Df~XF$qq9uTnb z3a6!-pFdY60GEEWLj9FtvCWlo4yO!BqE=$~rt9(GpuzSvgk;y=^zNvhsJeVDFm<;g zNyC0Ua=YPk7;w3FDTVRO+4(xUwtcmszU?%#4bx@HcCb$K+qpwsCj)7_z5)Kr9{~Wm zTiTudqqao-s+&>7C6t%){>!yc==UzOjHxHo$F$1CU7xOJWJT=G9Z5*Bvl0Ml%kN&c zwcpAk(5(w24Wyrd^HhSHx+EDsA)J>wxqQd!MG36~&Br$09m(Dz&W&m9Xt>0gG6q$~y0d$O zr4tgzq{c8(KE^1PmdcIG@CC&Us5Tm0T_n7PFpXPLqR>&=R&V21P`c1eihJ@!8wg6_iCoWY_f{j}v~&ILMQ_e1JV;)sm3{IO&@ z+9w7#&%Ys!{O?QrH$P`i5gD8meygW(8!sK<6Sq1X6pnJIvJq`~Kk((VaxnSl4)f3G zoz^4z|6{POE}BW+ZL?UnDz}KZHR`uwFW#9QV#BH8tls)sG}d5gM{INv zZ46?|9$s_Zra=IUe>|3o;^JTtxn}+wLL0AOfM2-S`c*mGk;mLr0>jhg>-nZZuY;hU!95a1s4>-i_yq1%-rFOJeX4~OB6gEn$>$k)J{ zi@*O5n-ZCt-;cWG{fhl5eR~cmG?d*b#SD3`7^&4{+S}-T(tL&Sv#b}oe$mdm$e1vi zU+qyaI4)dXEcBplfhti-BE#6ZjRsZAAcTQoL=?(o(A|DePu!%GumuiLw7?m{yCB+y zIo}W=)j?!gLekJV@o*E2UL-zN>{c0T0=d&W`l)jKvM>#x!#6;@oWvSmDW~{O+CzN+ zYG41W6_tHr@hPFRnU^xEb9~ZVwZiPj;HeBK-_b7eJbg^>X4G`5#ZgO{W7` zV2kjRU@Ww2(5r|@*dT4guwX>%-_h}3E|fl`lh4*hV8~!M`3SNE;+Nmzqs?R)!ggZJTEhTeS+#869Mby%@1AF@w8uxM<$Gh#faA(YS~hh9_z zpHEt6deX-#;6#WF@npisW{gGmeXUzUVs87%hHl2PZ2) ze1u{Ln$hYoby}b{duRRsExFv1Lh~f>(6jfH_6bC@q@P<g=uxkqiIP|+%EZt+r zK}^wb2n!nRK#mG+u09=0tE&lIk9}Zc_>FPiy-ZzRzO;cO9vNYrF+D!=W?I73^Fpke zTDa^#>g_{Ppo_2+wPMJJf4W^#iFpo2yao9jtr$(rn=$qw-S*>O$#GD@JlQu{&GPb% z+FQvpPMyg+QAIa2*#@2+nx(V1ggxL{a_lT1&3pvKVpLCB@fm@Hp9b9Kp9j9VM$J>e=l04x!(vbYsGHiVM;ZCEb zQTi4$l0j6l#MSzjY*^B4BCslBUGfx&35^ZIK9$o1c=vka@EB!5iGf!B*a_LMAX0qRb_n)z$e5VfNZX=j%8yK z%SAMh<8h#0Vlw`$9N`tAw=sB3ecmk)%plij;E{z;&GrBrx6n^iuP#ounB<>Y=mZ<@ z$uwrWQ36M4)<;YI-yhPwglPl#oHfmdH@mkqj(_Y%?9l+H zr{vK|rknnXd{1}Xu=0bmbLfW#jz9`smjb~FuZbD(o8fHX{Jx(T0aa?{Iwb`g&4*57 zILBt-uYlw~;C}a^HZe?QnyvKU^U8iWxiVX~dyYG{Sk*7TaBaXXdcLiQvv;34R(t7f zj$)t@W;-DzT}^rn=WiUq$fyHwvf^Slp>;Qv@^{kkHjzk4hRuIcUUI>G;6)lG$IY z54T_f1&dlPWNd=`+hUJ@x5FK=_@fW9eL(eOC4dY5h38mwh8lbr!;D|s}RaqMe|B9$e+~wXK2FaNQBPH!MUySs0v~21|nWWRzpl!-7Xw)s8XnF!f41K}jR$fT4^l;E6Q%(fdE@uEHy-?rVc6C5=j> zG$JA~)KJo(G^n6}q=0mHDBS|m9TF;_gaT56bhmUfASERY-=6pPSA1*D^364I@44sf z{p=^$Z!`gP1Cc*Y3VHJjMPamjn^WXJ^Bg}A&M{-zP_KY_8M>`Od(QxG2?jYW1Fx3a z%yOh9o3YcD``PsNctH<_nI^U6Gy#Y+_|xPGv=_2Tb@CTHesEBqr@nN=(^)*W9_5q+ z#H>#v9(U7!^~FfHI0!I4A09$DC!Oq1ziuI@8oKa{kTtL4A6}BV&n9q> zv!N1$#1#-}0HGY3kNk=?&wm@qORvqn_?L>93IQI2A!9R4-n@gcl{|HH*{xg^+&+!1 zhYluRBbAN58R-0O!oOeu{oZ*xSbJ6=#rr)wOCd{;=Imlz*#uxI!1wn%3$!_rl%u+T zfvW*BUSMf}lm>>NKViuAA!83nNYFBQ2t~^k=zT&*RdqV(KY3%SL&kzhqQO*WT$iv< z%N;CF=|U#u^rXqsVhf{-3APL%iT<4rzKymwM8_=qS2lmMUIaVVpFlYSTHCcjW5??p zb}M!-if;jxEN>-^t{I(Vbmci>Ndfnrqa@B#RQ$0LvqtNp{qJx0gMEMhyQ>}{rx-!eb>_xpAg2K!^w@{`R>`wi>Es6uXjtp%Q)V}V zJ3sg7GgB8;FJici2MgaPbMfW^`}Pf5#B{mtd;TDqjrw{HN8`AK6@jReF@>Ir$n{(w zH#gk5&-9rpHyOOaP?cFL-_J>3PoiPvfw@dinaYcnKfF@ZvJRezV0lyn_zuG-Ej_%Y z{AWd!+Ybg?gD77FvUt)g(2q;mc#nneiT0-v{nt!NY;O(~^nQK&x0=uTD&6XP_^5|H|rM;6g6xQn5b5!*9Hc&_B@qcnC2D4??v*J zu3^Vmuok%JPd&QB#gvbgx1By#fKpi?3bjV8q8smPbjoYntlfFlr28Jpujk$Dzmm=5 zEH+cC=}Q;TA2nCn(@z!d=}_~IU{3_hIDh;VFgTNEeiYLhajcUus#Tj=Xm2A=J!YyBf#R;!Zs*Ns-EwX_DF9NltNgTmihJ|_kZld)R-MAD&vDjK zSxFYeV&ZZCCf4yc-vs@`M2%yn-R_yTe_XEYV6*DxP^@YDx7tE`d@2~1EQW+mX$>`c zn9JbO^I#AefK*!Ns!L#vS9(2ds(<++y1&Q?_K84CorH(m`yaa{vF5mi{5*5X<@R7i z3uvVVU$PSGhiIYX4;#miA865BzgCbAeok)z zC($0Il1{iDLHN_^Fh~}N6&X$4#F9c1OBbQA3G&cqD|m|%miH-TGy1U zBsV9~)RL^!TDg^$liLW}A5?^Q1@m^NU?Ki#(kU8Md%?&fM4fnIpF&f-D|Z zazWiww(|HxEECE6MA67=v{2hl2)r>|BIq(DajYtEoG_A`a-tR-yK_25ln83LUNBLy zk>D!$gN^u{kd>dmt&Ia8&Lh+A=9_LvqSR#g2_1$w5lFo9eoL%gj|Y7C%SA$R-w2EiL6Hb%TF|AL>Q-awpkQ4NUpjJGEG4;`+%Rp* z*`Ugz6X<Z1MMW)S znBmo?y4XI{HH&Kay2El<@63Jd?bSOASY|i&CE#KiY%UCD4kHL-%xG*}-t;2s; z98zP@LY1@e%yTMm{sczc{$eJAb*gj-pRi_2FuTuw%#M#vr_KjMp-phq1$dgUw^|9T zhq!gP%|c`B{5UUKy#^Y=J>qs&lzmoBfa+f8QSOgAdtyF`UY9XAvOsc^$jg)7JmL|G z{hm;xJ4E-{6D20ZD((8tQN`D8Kq6v0z+f?&C0?4Tm8Tyw3d|S=lD6i1Q!arjTK8vs z>pQrT!1;6RrH_36r^1dg#_cZSiWh`1+z6M23?Shv@h7n-^}1Y(pzsG9w-tS(sEm`B zW2xm+k!MUzry!+?QXNtI6g2ObXz4I*K!2V>W6~KCnfkKXH_b%v?KL4{zd2$*T?$D7s>CE*m~EZ;rxszae|zw)q$(&H0r ze3{ZOR>*Y`r;#z(E4$S zrhl3UBOS8EIYX%?XwtGg$-jue1DTF(=dzJygX+|MBkty(szP&>j>Y0F!R-WLo2DX= zmG%;k{=MJeANNSEz~*YBc|u+1xB@soK}ev`ojaqY0qOP+Oo2@;HUqxofAfK0CfQMVNmF8#$7>LCKKyB z)$Xgxz~01pp^b{gY)^_ckXOhs&X={lQv49_?w|JP&fiNfxv76}7%ebEg5O(?`wt#G zzCH>Q9CWJKyC8|qK%R9%}FUy5%ztn#6 zO7ziR(JlC#3)aS9M4v2^1{D$6&OjlAws;+kJR_@&Ls%kfR?d2)w0XcL8q8dy07irH z0;(@lB;*-Nm=E%rz?z?|AkOlAuQ_bnFy+g8;DmQ4lIn-*t_dH9kKAb*mh~5Ysu3r( zwf-Gyr5_~cCRgzurgZm*u829(-~AkLXa5u3l0^U}xj#;nuJh%rS9>ixg*Y+;v zkm#&vuktExu^@Y7BDB9tpfy$<2?uVXU>1jw*24(O*(J9k?h4myb1YZ}WMt+MR2?uZ z2Rs*tPt8+z!VggV(8gmOE`0i8fG>VwtyKR4X9=L|rKs9LX~tyOiRHE?tb`lgmz}Dh zre1d3R?#$7@yabu`D6AIk3*|YFk#NqdH_z4V8HSxN!TnPu!3Rfh}W!bH(xP;V)7dc zg%axRUPp=UfyXrFrbBN>j%zsMJ~CT_Wf&q{T2)~roEe#OQ+?IkV9Yos`a#yUY2eZ+DRF{!;;$y?l?1wKnt5CjQ~7IY>79Gh2bM%zP@ zZK!~7^RLn+sG_{-l>+o=Wj@DrPRx*(ZD+4tDe2#{ojpH9dZ%sDI?X98wyhBccCce9 zl7h^BzJ*)WS|=g5$v?&sP6e3lvBt&F?r;i;4GTK4yUi~7K@HFrxU%OC%@)rJ>ubqe zg}g#-PJGqif{*sPV2ld>k+5l^LlnRcY2W;|lb!Ubq;%I;Vr+ky9S@pi^caEN2q-&c z+NwTqu}|Grdi>f(6)eyyido2tqVqG*g!O!$QTMy`CE*)yo_%i_o-Go)C&uuK*xu3c zwZh~X{hs5*9XrgF>KEQGQ60?e9o;c{CbV1}x>r4TlGLIuez@?i2J&8$H15K3cIrrv zLiq6^0>32mj$5?%1aR}KHceSkYarS#o>oZYJxK%B=Ne1!=a% z8HsZDeAlOpO1Df8N{(=f`c$pYpVm93T-Wk71wnkm?@fFr!tin$Q*~W}`d*ldr#W5W z(3QBf+OeB_=k3P^b6J`cQ{^^m7-HCG;`x8&a))9O)Qa>OQX%QTCmx2#(owK_dV+O)9W z{W~yprXItJ>{S08%j$0MT^mt zXObro`FFgkdTr-xn^>SZ&MCz#z}i55y{Y>C@7>fWbC*)<%#|VMM}ZOnn?RsK&r3dy zFgqBSwAq6?vWa#?1uOJ@qeXcR>^)r!!ZvDY7vI;W_e2r_&;=N5#v6)IPY45JzrkFV z`ax;p?>Fl%%D>e>fi=HF z8SB+$&qV412*>^h0gj2PcSSwhiwAD_w3BIQ51Nl?4H8TwAo&h0ErB8zon%T+-#G;% z9>5+LzP{G7dJb-N7(=hn5;g1l+CP z(h~)PL1C+{&mN61@B6qcnhZM)^L@%UcE)@BdusTb=^8(Kq@0K{4`r|<=iN$6N{k>a z8Jr){*(7jhLV&vu4EfI{QKW5&ee(V#xp+3(32qS1j#dtV^(hSq=gxMT@ASrD%9O{&xbBMuBnw-=`J_RG7vPg zzy<>if&xSV`2>I-BocYS`3$ZRv8AKNpC3D{Dkb-I@K2f}0xX+!MI8@;#}egjD(5tn zi9zcbR&VKOonyAYowDv=>+iwuo&j#B~H+GNia2Lp2o#=WqT`^)=QLG zIlB#k2L|v%BjuV0s8n6UmY$=IQauAbLT(Bm?RW@j=v4CC3OAfBtO4!?C4Alh48l0O z(EhqUN6oi$VDxziD4ox@$l#0_|;E$-~3&vhLjj{N&vqetf)df*vEvpQ0u!&E4eq=nu?<#?us5 z!VY$dsKXG3M~dNU&H5?l#o4|{ejBB+u8`E9eDSQ?&&sVTgFCLZdm?-xQ$Ayj+3lSj zi=#t?oKjNUdVu4vjL85p{%%w8u{@M34HjKws(O8|XT8OM0%3f*b!Pl1Y0m<2u1vz; zzkD@YN!yTHhnCUCKO!CumOI2y?L%AKx}NmbtJm5%w$$F~%qR5I z8o!?V{&D9&_xax z{w;VgH%4cigI&P$;sn~e&gBWxSq%6ny7nk5+9EsJhi0R zPnel~qLl3lz1)i}WJI3C5eQQ}hf1)wH|qTwDD5Og0ksKWms^s)XUliHvqwf-AhBy6 zlz}jx{z_7)(3_n-+EhI+yat56zsFvHyBaO^k~=~y+8w1wSMYPabC~lfE?H&o{eub+ zgjFInfnW1|A=3a_m&ArMmW%Dn^MAm|khnlyo@E~O*!nEGJ^g2K zhcu)|4Yqc4vb3;H#Nr|RbxiB(*e${vzQEz8q)l&I5+laOlK=RJBf#Bw^C1AMUdPLc zO>Sl~_)1*yyy>EHt7*|d$_Agt&_QREXmR(O@?70&TOn2P%)XfXxr?O2#lXOJY1d|u0KQKry$z3DAft3 zL&A-1ky8_Y*BjJrF-hb^4)-9#0$bz-S$SE|@^_@#;yLef`}-DXLn?*l>sewOIa6krWazAxq%t`>bbx3qK>nqg3awsv%cKIGh3 z{ZQxGRYn^ryvkr%m1-wKlg3?UR!w#~jb+E4)D@$V+Q$C0MWvaUdqLrt%-4RMhR<9jYdS>@D|T(T!hV^NT?G`ksyKB zA9zW$xb5(T(Y8PHfA={ffu{k;NA~0<8efL(+^<|h7Kok;3k%CQmzNaSwocl=6_gHf z2ios$H>Z(*FHE@n{(0yTX$H~_vd@6X_mFW_^quVo)zGCw^Wk`9ulBu(i3u{ge@8ou zq3Qw{l0uNmW>*gQe(u+JmzAmq&K}j1n?|m#uB<2KtemcmMTJf`c=2BMlXv*8>!t_c zW19K8A#qu&gM+!gc;D^%kko7#pkn?TG+!afSbPl6HSv-UxAOCFw zS5nV8$M97NVGkj%rq%O8@>g$eX>{+3dh2bn4>tbsE^3nwUpvxlFpmlrcCDbB(xkr2 zQ~d<-SIKs@^$~5eVov0@WR3ne8TGc2GujFK<+*7EysM(Z@-%i*w!lUtD8&P-*%AuI zhR2C&JcGcPkHNaDFgMp&IcW_+Q7}n_xTE>+4d=y;sP5(bAq$8+1o3*%ENX8aLW#iC zD=}ly#GF^PweWpkp5|4XRKKfiDrvpG8gF=KMZ@v(4oe3x?tA3^t%g)M7@0r}+R~SV z7vF8_5NzEd7SZ2^*3ektmBh<`-y2$BFO>dF`i<`3*h}go#5xR~E#(}R&K9I^ zK3kTZ4KS|=KQ!EZHI;TpvzLzpNYyaIi6=pV(gN+_0!=rpV_{u+*RO~Jx;d-JkCE?J z5YT7A+K9yMhc7B&FvH;g~{5HX;5{`Z*YxVc9>zRYvw`adz*~H^I}tumjraW( zQ)3s~xjCf|0=Z7ALWXtv2e`?GkN&KKy%XAT4M@q5Wd#xDzd)+=_`2YK+DGA5NCRqX z&3@L6tBHD7eT*od?%5k9r|H?}EFjgxUzHOd3{M{e>FTcCfccH@wzKHHwIbA| z2@+`QUqk$YYKEvJjCqz_*Ao2oiS6C#5_}TDw`_i(;v1 zwg=@8S-d9OvO{%pH%;VIh=v2O8@6cZxdV23AHG5$H;WqSf!+Ho$561TB;zsc^5-N7 zMp=gLKC_->2e1r*loD-y{e%i5aMro=P1I?%BaRJ{BGJZh^;-mk-RDi7ANZQqhkRmw zRDSvLmrOn0=1Yzc7}m>~79{7`Jemz~bCyxaE!`7LF)$$$sjyFPxvKK^hWo4s{l42@;i?Wd zdQpmEaPi>HzU2`caKY8AB%#VGtAY|cWVYv9@Zc<&I5Mwz*dVYbe!$mb#Mxuny?grV zTyF?JQs4kDa)L9RfZB+j0+N36iY-7qq~q51t56PHIBf0+*~0#@CDL%v^cW$ zOT&2vdQ6n|Ll0MW-1K>o&kF|ISJ!(72R_)3oM_RQ134J0)~c#9D(yW7U#{t%VB}}< z7jMlea-H(4k8;&DH`Ofl`Wgo8`(2d#`k3=bgrsRhKCYtvBiSGqMzKobDG7x|1O~{V zti(_`{rCW|^98fSBA|?*{SVA2iy#%|?ol5E`hbh-f98Z`nA#0Rk(S_lZmaIO1>_|p zp@l*q@kHX9HS8T%Owu2<Jgw>o5WDP6!ZUmc`SZ3iXMHa%{jC zPTYP?Y!fANZf*D|2hQ}bAakDlMps;L;Art)cHOP##U0|n#b0y&MB1YCZ7_#{iS=+L z-&ik#)iac2+|coMJ>0jvc`ERV5##UdLeWL5hNi%#2XSNnN$7`vih+R8rhj^-`T4^# zdf_6BB_#(vqSin#*!e*9kT=;W&3_tbD8MTM=;&_veAZgrFE`?Drr3GqZ?)oyPibWK zs4B(^1Vgz98B^m*`A*W8@cN9Hk`=Btj47F}9@UL!PHpAsE+R}T1~*N2izaz3xfe| z_g{AnIx0K6Ra&Y*n<*zT|Y?K2E0^PgpTiOo8Py>lz&+R# zcILa6&&4jo(oJn&@2hd|ncSk)Yq^Enbi4_uUH*isSfP(Y9uYO6wC3j^g9AAWE@=BI z+O=@#Zi)-KYr(iQ<-q`U&&L24)<{z&N`-sRJX!-ph18&LhAn4TB_c|gAx+C$=sE@t zmb&0G?$nSZqo!_A3nl4R3|g7ng7ZORMOPgS*VZx3Xo4hUaGfkib=p5^+&K}Wz5<5{ zuqmaOLuD8>nmY&UK-i9kYdm$R{&EPMnr=;Y2iNr;t{=PKtPuayzQkyRbeLsZJohHq zdMOZg<<6IHYf5`rY}gbCA&PX0`sg*bEo15{>0~BZ!1zT6tf>n`M%%7IJ8qt>gh^!x>H2TJPM=#B;yu(oQRN>42AXyXQ<#KMX45qUj_ zKzo#Q2+8li05G{)0*P@(pcymqX2jA@h0dCEI}wxKZgeTcG)l(B!nfBE3{qYVp2UX_ zTdfJwXMUXl)HAKB5(2}(Dee(DAvHF&R~c#ZJU1x+;0}NJ^2P6eQhy6nM=VXblXQ4c zj*uddstg>ZBxtR2aQ7pWS-<@wqS~~4i>3G`?V*_a85&TBIlhi=If+N1*VAH>eJ?vv zC-+t`ir;^sQZS_OK?6d);HEvA1dzt(xa*}6H)Z?R$bc{UY{Uf&&VnfU2A`O-@<~_F zlV4!J%6KI0{Otb3C&8gBvn)5}PdTUhPTtXE@MNW{bRn(zYXQOs=PapgKV2?VA&GF` z7t3au!eQX1{d!V52K2WNoxua5s`AEJQl^j{2LGbv&YllHN?|PDjF+nR^5RsZsL7=R zwt$nj+!#3}xjzk5#tC(j10~t+_LgyiMbVo%s;q&kJ#lkf=Z{b0KI-&s!K1z@h#}uW zZ~Z1}Yy4rTnL0+nNtFD0nJ-2(&&oir)s!atjjK9$c2a8@HjhZBO(x>{AkY#}JwFHv zf-4F>Uycoxm4V=fVPQ1=-r^SK4EVVmUU9kicxdJUj$fS9Vk;pebU~z#l*h{JkLbt- zfz-g+ZM4t{WU+2DHS}@*_A_r0Vp4kk?d+NQHx1t@vY1j&7+T<8_Anv&6(jUnAy7CW zZLw=_+ze9X=fvzp`6d0E%-FP?KnM&t4p2}mcqIdc=%c|Ed!1dF=dlUbM-nCDVmd;; zusVhJVr!=d+Dg1B$k^&fJOe4uvL8CSd(Tgp%o)gup3Fj(0?$5fpj3|C0}ZLyC5i%y zhN=YLdPk1cN}7QxRJT(^zJG!k6Lc)apsfjCb^yF4cc6WsEJfIOv}Nyy^9y~S#16Kk zK*=$diVcGHy{@%J^St-$Ys^u2kq8k_uKV|Yg4uGr!grMwM{@7^=z1H#j9};klG2tA zZect`Kf$h3Gb0~A$nq0D@_b?8Xv9{B9n2x>YM%w#$pYwvz;y#2T_Bs}!U7uV6J%0# zG&B!vQ3S6Qs5ztxjj$-or0$|!TrA4u-AS&6TAi?qr1Oo+H3#VLuNdkFWI`55lz7in z)(KyVT7f2hBb9o{U5vWWeKANk6_&I~$Qi)Z@7r{~c+vb)3sG}7kc)+ffo(IdF6!&@ zSyBW4J@*t8s?J>XqZ4(sL#&iQ+2$$bm2AFT!GLp1z#@OgV^S zU{7!?c%FM8eo)ctPoB)e6BQ$-YGX`(8#^2$?^k3IE%t{vHJKTS(vHhLaq#xQ4}42f zHU1cqVLI$LHcd^Tyw#1enY$w7xZapN50*J#Qw|~tv{w{#f|TGlbdAxlZW*+Lw3~{I zQ!tug=^VwDL~Zg@H@54bI;+gv>)FCH2#MbQ1b+5a&aRG57-u;AVmIWqzHtz=BE?Vm zxoz<$+&Tb!3#fd8tE}^?_eBdB$6i~dPG=!4@6gaMsB zux18S)~|1V-a~rPBO7j5_xBtW9r_)Mc@(Ey0%-etdOF@bx;5A{_Ahs?XPw!>0R#$z zQW@rPX+OBb1%?stse1)76PJww+By_aj@(Zg+mp8q%jsq$hAbdj$-sS6=u5OnB=ZnG zz#%YyBl3J$VF1>aK(_0>G-$p%I)u*U)&NaFc#8Wfy*;|T#UMaQAxe{mKI5g)dj!^uib(Vj{YlN>_?{WCkkL9-r z`~L87$8T(h>9Tq|jIW!wln^56)HyUAUYeT#om!*lJ-ZwB%?S4Cx!3xS*Kz+a#-$g_ ziu|6K7qdM_GZWkXteY>k9V$OJgK5RjyGj&g>k}1C6*z4OS|Sk+Z$G|;w5>e(fP`NX zboN7buXm|vn)*xriaoz1f73ruCKp6ioLZCs%DqB+AzC?(__zPrXT^20V85}_Z@$>X zxVnQmhs)`%<@#0o1}e}Iq8HIqL$tX&AXDAiTX7M>zC-tN2VF#>w8qvgMm-VK;Kvp( zYZM!{-`Z~%LDNn2P?WV{cDuct`vjH))I0Ek74J~X-0%YRO-VstghGolV7J=t$8<^B zZ>J{<0ywW`CX}bLq%|3oG}`0z$6`cEVWx|o(by%-^w(fs3ry9W^`E(Max#(a{seKx z8u2HueO)<>#-r&#W?e&VZXlqk+ z`f!}DM_(DW5YY?$#e>>gALKjt6~9M_^h{AJEOqipH4$F|b?>*WIaZciRO} z<(+2!?`LUo1vD(?IgP;m@VPwny$z~b=$>Ukpx&T~x%Mw;e?mzWPbj?#QXL_|M0nvn zwoq|4G4 zrrG)Zu3Oc~%Jpwu@+!*2Y|l!hSgCdd!Hl}Yjz~x!%ni2dPq|=+g0a=#qa9;#MsRFs z3kVj=7+Rr*Q8;5em?^P&quB=%4sr>8j(79F3Lr!P!hN(q zq$=wRF(#0nD?Dg6gg=Je;W3qpaNyJft{_K}mw0BbBmGcG${06T%|!oXPd1iod-H_w zOt)dSZEK4Qf_@=hphWKnt2ZV%G&wbz_!ZI7QlCS*7SP0m2j91KpPc(Z+=ek|2Ef1z zO`C;T@{;3ckN&F`|2DGp7bF#(veplf;+JQR!o^z>=LMHeYr;vLS(=I|8HuTk#y!GJ zMs@xCRv%O^a(Lj!0f9NbzN$OZd@(otod3o2{XvuaW}LUk*^D6hq>V6*+R5SS>&lc| zvznQQHl)b9ZkTI9LJ8a+=&X{t>FszQx0JMPh%V0mqpv3tqN*GU!xOfAfc&3Gw#w%m z3BK<8aVt`SG1mmJauy46y~(L^Fqz1IBUWtOFLbVNPu_R_n=dPGeb!(-iAD+j7YbZ6 z%>{xcu6;c}K73Y0$IP|HH6Jqy@FEHI62FYy6Yj!|IZcSCsTD+yI<@lKk3Bk%yiIoxDF8g#AKgjCRNX zOefR#LKwJKa7@r16qWMbGu&6CgUFy$?^Uta0;@(G4+|KbgmdJALbrAXzNy*G|NTR^DVJk% zXgAY-^?!fYr8{#andbk=KkO*)&1YWh7hw3o@dtj~KoLW;H^7v|Hw21iGz+}pZ219H zbhJ2Q>*OzR{4wF8SxpAbZU=*Z-D6SCnQvfg+_Pfog2tYILR` z1{nC?1b_r~S6-K?aQKN36bYP0$Zh`DndkY96DX$Gmpc*{@@L1Hm%{J~XbWw$XMW{# zLNsjozg-6C3NV0O6ak-1K+)h&NO^>>V%)cb)Qvl9@JU}!oCP8&2~jX627ofKUPpHg zxa~g2Kqm$+{U9RUhs4V^-O*&OJa}vP46%4;Hd;{B~U2u6NB?c<1DiQbQN-lYp5uCyX??;E2DF z?gN8ksAa+U&+TW#4eQAuFaf?p0!j$b{*l@9aNwlHJb|VO&>G;F7HLU=LX-2CPXl_; z_V5k{#=;Yj$OHA(J@X=Bt%HXHZYmh*N$(O!FiLJ9Y(o#4o9eG0;3Y`(eumU?FU8U`&7>_B4 zgT~gOmx2B~_?eAIy9aF_`JSUqM!k<*eQ>FJoqj0U%=^WaTZF5XP$cQaq=ZN8n3i7V z%k;(6|8o;{+32&7S*OByJF)sTN-h_U9T?`rVL~Jm)=;NkDot_VAtvg3LECU~P|8Ce zy#qogtxCVVk`z0}dyW*2Gx^Ro$u zzy7BYjE6TWO?3b{L`QMJ&;f1_a8lX(z&S@w^uM6^4q`&PA}t5XUMLQLD0mwUaKj)M zjb=j%IJX8YB4FwP(qineChVz~ zZTzqxWIa*>mJ;yMt~`UZd3g45(&%unGQ-4{8vUw#el$|*69|Ul;Qs*0SMZKkgdX1< zaL=+wm4l@bnjj8OJlPbOD}WFhGQ5ul?{%c@>ziOnzJ5hVolC zT8;@mAF||lW^}QJZ%)MlGZbcMzv0`?ZvQ|spu7`2+wZfuQrVwIDfXh)@lhCV?wdb4 zK3@qhB0%O!r~gd;=&A6qpx6HmZ9m#R@d;0)-N`vTCk_l-X?x zrpImmaw;@V$fdK39XA5F0Cqy0$RXXXv==$X6Ge+vcK2&TSJMvj+D>^h({CC%XLP?- zt=+mvX>shi>M#})i1+5T+w%r->PT8<_Dw~;6zWJhz#-5~c*vxMvjn`z?N0w$!(s&I zF3{cUyoWqrSTo>^4Hd+d%kR(ctpsR&3kpU}i2O98%@(;EI2y=tg8P)zail{9%YU~M>PI2Q)7K%55YY}_Gy-Z2f z(_NnfB?DNIkar6FD_EKE0`m{}1o#o|nJ)X3#VK-8mu$~(;s-9B!(0!hAn=VJ;e;PZt)m?A$bd#ahF4Ay291=5%42HZ`jziA**t0-h$e!=Q(O&xDy8}X z9U#Skw!4IR8`*vJkh#_O{#3Hj(iM`tzBVkZLt_DQ{P_Ho1n~C38ZQd!^6eiLKgF{9 z#e(SvsjleS7!F7vn4ujZz<~)KP0DB1{gpq5k)fx$j*7SqW3Tz$>hyuw2QR}PFqMQw zftF?Lj?@Ec!G+v&WRd)-VZ^7{>O|GlMxo~#{?7JMDVvgnC5?V&S+b^hKHuEh15LO6}@ znnvh(ZaTmiYgHeWS5ct62v(r>0Ix!1%}!X4BXlCbl6+ZW2Mfb{n_UHh`WCIjln;B zHwb^kHSplsSL0m#XJN0M6y&jUo0Ip+1Kb1KbkQ!RFkQx?wy*iWPA^r~7WA zP{P3rS{HcC$O6oz^5o>4Y{sY9YM*_dynk9Vv=)*L|JU2v9oH0YD{)QaU5r`TTG=+#G<;e_s47LlI1+y^N&kXwlRXs zEms& z>w%_ll3Xi7_vw0*S5!o2TO=}FK7@Mh6d*~r<6V~BV^JvjNbFO4^4}?fh1aWBujcH8 z0^WBygTd#^H#MPK$*u3Bpk%+L)$5f%5t7n3vZMn?Ae`=vYfd?8?6?aQ1lS)A1LTOR zC5{DiU6I&RY$y7D(sefpu;DEpL~8DOzq8*SQ9s%L%zMip$YLO%2lQT@BmV01m4yNP z@mJ+|SgC&nBWdD`p|mbbo7|LRjClw-5Fi`_&f&#Hz08Kyt)IqM8gu2N|Mm#Z;yQtr zofP*fkm%uT;;#B1CuAvNXx`bLFl9L~k%2mWu)ijhb*Fq{j^yH6P_EI1zV9J#fERuG1%wbB z{hPFHDg4S@sm88wV*dIyJ{l;|<)WY$_X+_kN+`PAMCo|~;8wvHcy}>HL?)OuwFiQL z!stapH5<)-@n zGqC%u7sZ_fm%DuYJ<_6wm1R9O=(+q{L1gS_0>a1-TTQQAs>;LqRl&Ya_I96WraO_| zH`!}hgk|oWn;WZM)$X^?zTfmuk&`YBj$=G8m$@jI)}=NT=1RGpsP-nqN%_@#uW_UL z$DQ^H*SXJ1RI!#-pCfSIScV0~uP4!64;>`L#$qT}_cd?(9Z>Kl*Te3<|4&2VWG*_9 zt{=mmkwoIWj!ZkZsVRN^UtP;7M7~h7{bmF_V!U! zw|5UtRypM3E@g1UclLW$j$5H&6liOi$w;fppih8OQ;VbHAjwoXH^=Foa0g{dTP=RG z1xu}M`ZE@!EH5Kr3-d20J2#(;Eun#Prr&##1z(hy%?8N`urUpApRQ2DTLM=D{NrG> zxXzW@gZ7}YL#6|H1H(>6X{mn9^Y`Zm*m7}7$D&b8(SHmWK}X`^@-(DMW&qfrS+KiY z2Ya9#X+TT7?ap@LvZhy=D-NPTEIPV)VoSEP_to?3xP-I4s|>TPgU zhRAe0*x{gKgX_@<8cmt%T@PiOpF$Dag^?al2ABioqNSE|sg_<DWr$(ft^R`c0j)mTb1$+o zBos?0n~w9}4q1~&A_+9=iJLt0h!$u4_<6fO1}NsbBr+KDtiEFYNO+a-fub>j%cHqJ zZq#4EyrP*a=?TUP22iOQpjmkIuVbN{hIKK7= zjdVJSmL?5gbiBzm(CYaz0@fbq`=@g|l~QK-{>_X@7yY$YQ+rqmEnv*>j&<5b5LUBlrIc|hC9EXpfl&heqMlNl1vv^6i?dtPZ{YG))@EHg*x zrEM=dqcw1?d|c+MHo62F9=-wBAnz{dg9v;to(J~B+mA%dHvpFDsPTy37s%>JWuiH13 zyYPv)FPV{kvqiuoZIP_STB4z^OMR`tp}cEUXSRuDJ>Y{D1TN#3$;~F}v8&pe`yx~aD*S`7k3PUN2!)*Kw*Z%0=Gvh~ z`5Je@z!zOr_4Pe2sDWAnKJB+Gf+scao4s@K zaL_Ktyyc8*!)!2&y3fu;8DnsPi2!b!`=nVJ<5N?=&@wNnY&$Ey5{aZbW`GOAw z2^rWpcJxaR9}zn>H3EDJs*swxo}L~>;uYXc+L1ddAU}>`zfWyJ?J>|2JwC=erN_B~ z3B5{n3A%X_*?U`a{5Hy<=m>*AG7Ne9WA2Sk18$PQY|_y1uz%dnab!b3DG8!NM9v`L z#>-X78R}V1h$6SKQQ2LDAqadTz!|L|!>RqDQh)^o6nrY_F*vXC@bj}QY9^Z%Xbyqz zO7T;0U)h1?0j%pE-iWdhH)P4@DbuKZ<@9Rhp>mby6fb^?SmdfxbkMK9Toa{2byuZf zUnet>X>{mehdv>;e^N@y+i9D`gRDcGA!TH|Q<`Qot_$rcL~>#XIc>nGCt`j1VDF3- z2^v4>xe0=s-@pzr{JQd4nwvK<8x_YU=NHnafJTDRV~O=dvPsxGYonnx1k_Lgro?C~ z3$$x&<@3PF&4eHU2=UNJM2>XeUp@D#R58XU^doqet@0yeH7xa0Kxw7;KaV=}0T19F zkC<5GZAd&GbPBd;o4xq=9ZlueS~Yc$XuWT|&YDFbL4mj#9Q5`mOUX8Bmg#I0!hys= zj@6lSJ-8VFJ0smnhd~xYK-fTV-`N3AJ&Bo<-VZqPut@?|tpz64K0TXB6pt3zWfgU& zol?G5nElhf-GcCaJVS+swilZW_t9s(b@Ep@Q70zBQVc+xfZYwA3x;%+>xpk>jdcjs z6IBZQA-G!a_;=kl;%}n9W$xCH({n`T9IwGid4_Z;`Nd@gY5-psC?kCjFC!GFb7dKy zurj3)ST@zK99ZPKPaKFvc^mwz>KCQi5_YV|BE53%-m@qiz6xajYQP5QfQ}#FdBs41 zILShBtJF@2Ahic5a1Gd%qMYCNZRz9zpS+a)i$V(-+ymnFma2B;d~LIk_NNx2Td0#(yC%yAvh48Flp z$8>>a!PoBfib%Zzcf%{^V7dX;ebC)NwmESlx7VX>%`xX1T`qWo&|i3KgQw0yw1c<> zLu+^9I&dv4Az~Iz1kVpjvP>8!_3~7=;=UF;I>q^Ex<@`8AW=l96lf|)b#K};kgFTs z_MB!Eyn&CNAdanPLn)oto-g&&K&{3R5@;1elRBfq0?vYgO05vT*o4%!t310&P>AC>s&MtSx?Q!PDV$8Cz@HE&P# z`JKtlZ+Xj8Hs6Kfp<-<@QcrWufkC4pNdq*H@MyNio-XFCGj&8cE%y98-E0$_lkcASl#LYkvye@$3AR+Kg)6Pqs*`0zq1J|-wXO4Rd@v~E(M&F3g7W}Hkr3? zA9gX<+CQPz4h^07OPAJKm>DGfkilgAz=KCZB3j~nNTLNKaO^RmaB_-gwha}is0Z^T z!LTTiaTDs1P1Lka8(jGn6bjDB0E(s?G}$8nbU*rV1@7$tja^kR{|le@BrT6v;{ex! zTh%6UYIaG0_Jsy_2XyFrU7Z*}eemEw&qY-zWyGE-l36D%;J7gyiXODI7#Vqiq|j)s z)>2G5IIh#FKCrr9ZBHWv6i* zuJ6r|C(>UFOKP_5witAdI5~78%8mwh$=xceC-@9}(#{u6-C-+1zb%a0^4m?840j~VwBfiby z_3cdl9&VKZB0<0GQ~v7v!?%^j(q)}e{PX(J;lu`|u86s!ajUS4@(GH@82=%g@7M0m zQ)kl~eGFfHKf{)*M&eypLrS=eVE>h8nzr_!$HwfE9GqB3i#eEPoT}eRjuoq{Z338x zR!zZ-Mnj~C@UEgg6xEFkq05j80(PWHsi`!)t6Cc?h&ynzX<}3YfVSH1=Px|{83)=8)$f%0l!I8QnK6ehWbxKA zFl%DUxe_f`eYEu&%^vSV#LJyzr7M0U_LP;5%q9@dHTKds5pm{_uJbBi#b0-vYosWT3WUgHwC)hb>V2oY^?X_ zAeGp7!Lx`bYAw~bq11>?aMy&6Sg*Msc0~w>=~1&Tu)!Ewrz7HpKm>ql(UX4g9EIYN zM?~b_)oWrKzdq8ZRI^`1kmAO_ixNGi>uDb$y0TZZUsCi7jA|fQ3&JUY;Vq*>x;rM9 zLWjao82)%^-YyK8=dF=6Ks=>zKil0XzOZJ2>D;lGPaz`oP&Fj}u) z0_xu*kY@j#`{|#pQ34}{c-(-T4uTaQOib2sSB zmf}fN6HLklP!CvjAR}oJ6pf|yua&u|LiT!d7kh0zCY9HmT=ea8MnEPLEj7K z`G40L_4M^y_xGz-@2)+d&t%R4zaU)B82&)32p2dHjQDrI?4vvUetEo#ECR~o#k4jv zGwSOdl>?Qx1FZ_B*AMrookz2te8gk~L(y7xRm4TH+Gvzyhjw2ohiREKTUdWXxR0j4 zMJ-hl4&>!uqDe9QrDFO(I!{^P$n(YXV}AY*g2Z7LLb;w7^A)eef24{J=!P@lpo!hc zrqB&0Qcr#qVMqK@@IF6FYf@{HC$p#-vfe(95YeeNDpOYbVV9Mi>8G=J;%+6PmYp(~ zvK3}$k+899%(i?ocEv@@DaCY8LcQ(71S!Oq(4Mq?AWqjA@f;2NgF1cIn7Q9%Zj|1D z^Oq)T$FzNR{UG2KsZP+axxBCbO47EdCf&#Nk^E;TZa;o)(~Hmx{nu-$oX)S9LS&{Z zKn}pk9!gMGzjNJ0BDDekBF#2!QmQNQ*o{fdVDjWV^-VbY@wgcpUuHd&zt_oBD?CRK*DeG6AXwyBI&K5yKhS(2?JqA*ln3!!`XxY;{D$`qvm^jA z!V?IR4KQt5SXx3G6U2Ek$_1@bY&nkYQ65$nGEU5pp`&bYqX*^wJrxS%OE-q)1uhVC zQZ38kmQ z`(NU~936xh9=`kGCcGeMv^6kV;LNC?dYNO;o%KjF<%OXO73ser1{fAF#4Kix0I>lk z!W6Pr1%CNY9eWd3JUUKPx}!PZZ=h%2qA<7Qr0A|tKSTfaB3*6e`c6csVI_ki>j-{& zy9hO2_=DAXf|MEC{ORw)X0+|Xjie=M4BlmkB%}>*Fdy>Tw^HpE9_Km#wilnJBg(4u6$|Ep#H!+Rb_xRzBHA5`Owen zs{LA2=vmnLRq|!FbDPY{6G^DYI-R$fzcw3HcFTf~2%kd6?m zfZ66vcwwh9wu4ZWb&8(M)V`WB{6R)NxL@bXKV86q^asJ1xxec-m;2wlNO#g=OTZix*KmYO*AoljG zb&Cf-u%To94P?$12*9)WDX>Mx6C%)rmbtzUGuVr*|y zMzjk^1`c+t)fI)lzp9HKhNKM$y_*gT$_oJ6I`yP*a-CRYcPyRglEU_4Jrh|z9bWqV zfnqRcZPQHhLs=OMaPs{~B%b`iN%)AiMZ6eK9e8#7r^8Lo-)}OeAD8IB z=pB$W?*CTcYFdWCErwGH@?~!@HG@_=Fbu>J6y5i4T!CG$8<*#=`ZDjEwq+v8qp#Pl zhjs)sJf-mJLB3chbY7~#@?zx^C)2Mzr)a!t>Tc`%*(8M)%SjJX;zX7YzrPxn-!zzg?>guKd zZ0X~|V+SLkot<4!Zh>L%Alyj|=%G|!k+X1@`lkuGQAsrOL1cqJB-G{#hh&|Ag!(nQQ6!CvO z`5mhEE*F)h%5}~=C{$ttUS(1t+|Dw7eAg#);B^zXT!>C>t)nb|mu!CnTMnZ~agN|` zYQ^Eng0kTTpHb{zSqU;s*!Ab->_mZzn2+k~#KcX=b$}re@@;^DgyFHh!ZfiMestbd zm0PQ;t(&g!Em8wWb~C_Hj6RY666yoOU*1x)x$Gm^dGVW3frYGS{ijdcKv`T+ScoBK zq3#FrvRqic14Ybr6O%CG;P4t!VjTTTGTzii)I53C{Yu6-~aq!^FMK$ z>K__}EM;zE-YQBxwtl4_m7w1(uQO@(c@JH$9LVqkl8#%ppR<#w2Fv9hZMR)>Jp5w_ za0)u?eRPrL$ky!ym0kB?^okb_-7ql2$6-)uO2X)VovXzBgVL6IiCa-5K?gY+0wBqG zS7UGdVPyKi(!O^3<>%&z*xl5ArELNtxA;YV-os@;jy*zI$4oi!h~0TiE=MRSb>Fy? z8+%{=>U#P$5)!CRfMAl2(Fu2IaRb?xxas^OxB~oqOK&ahhs~T*H>@~=M!iT_Y4aqz z=ALOs^gbR&XSL;J3vw{dO8UByF{8!?i^`!TOW4Bx%Tvm2uv6_uE^1vjTB&vUW9T{T zrLJ9Wb{Ny3u%s#z#Ga&I@>lMq+M^mdMHM(B!QTl2?6SMea=w5@SQVUD6Mdjq8{IlI zZz01%f3|2nI%}%^%N8DzM8f)SIb)LKG7c8m#F2Nngd-Qvq&^7qq3y&;VP@TAj5=4s zxQLsSJV%=qCv!k(xJlEBvbjyL>DX)5DdWrIlNWIkbxLDv4JJ&j1w-6JS(Qtb?#=pN z3}oXZ)L^$`Gu60n@XJbCfSMS14Blx>dQ#bT@BLN9; zESezJ&<4qLi^7@F*8IwYA5|l|yCSR0jM~B}RNm7E$(kAcuDXJIpf7{F0j@dBc>o{* zFwU5$=05+?snz$Se7WQg$e4+5h1cr52kq{sgjE*I-Cyf`8TKvM$mV=b@4-YC_)Ctn z!(|-*AD1R)CL|8Gewp(Lg)^wORs>#T&}LtIoB~Ig7$8cJGuH~bQh>r`_;eO|9vv0y zUfw+L0Nq9;M!pI<7EB7G(NXT2tINz@9?dcIwf^BJmULE)b@*IYcO|j+9q1vBn^>0z z1_w=jeCT1O+-le(`7>S193|?>>aclfBCpw_k-K{g{+XteHBMMYo_l)IV3tRxcu!y# zAny;{m`uqkN>pjCv`5Df)B(Qyv(34S5{74W4~Y(5Kej}8b77S|-mH$70N1Gc=C)O% zlK4}o%Q;@jG=;_l%vuBKBRt~b;<%OMaKli;`u1d`!`Xl@p_308GJZA0Fe*)r4csHJ zqydo*cRjQg;{S5kr4ov;DC8@P9bCbv7BOEjIX;4zZLlbpJRt%5mH9(w=k+4F8*)h- zFM&*f)=Gi| z32s~CFSk|0O+%l`{lZjw!K?}=SJ+jHQA$q1`f(%3&jEN4lR^sTET*aGxvj18NqKB+ zZY_N=3(ztnrP|E*L5U{5GyddR&k*~^Lz_~%{yW3%!;|^DIKp(&M(Y~0u@t*N31Pxf z9LFeYR<|m@fGCoR>3dT!UxNE;ALpJWi=p-X1c61aDW<(NJ3ZI;CjJANkT+u;-aSo8 z%xlZv|2|31U*jbZ@M8Ba)9HTI6(b>Jg9U!v#)SZXVy=>}yFp^v&gEXYpi!)UZB0%8 zT@_9SGAg~%7cP>^tiy){M6p_k(JufW>vF+rpGr$W%p|Fg>Va!*_X7Yd}x!q7*pp z6|f;(lsX#rHs;_^6~}znv^e7`Gpawqm%JU7g^~>zuXn9A05X>Vx*Azy0jY){MfNB5 z)%t)sz3i(jkGV>P^7!I^PeF}Errj{@z6Q3nz=;o9tVOa?KrYjyx%L0f%TcOJ0m1h{6VK1jKk_mY zSLSbF*|-gyK3#CPgY*qjM4q8FU%U%5`228EW8QJl^~RPI4GI6|L!9aLgFJCNfW6`J zh9)=!A<}vVjj0WWvxey52r5U;P&6|8uq*H5Rh2dc`EeBM#^1Igo2}-55@2^x$$*|A zzTYC0L?$pdLGjZAhU+Z=mtht>uhFbe4Uy*WRK`K84GL!irt{(n-!-nnwnW&Jk{cHGA7)GbLk5le2*~cyt@b%LCeJCd#va8=9+Sg3@!ZG9s1t2t zDG4(oERtZ{gJY@;u~W-Mb=ky|(QiOiRUx8!&cK07)CrkBLIF|iiZn8LWzh7ZuXjlGw zckcknl&^UyLQddPTln4YjbTIL;>Np|Uqv_ujps-XXlS4oJLH(W@C*Cbk+dYq*s3e{ zVBpp&dhYD}s8fAc3`zD&Zt?hi5~^P1O8OT_cbXa24d|*}hB*(SV7g$7m7~74IipU- zDDp9B@F}O`Xwv%N`rM8sN(EF2043%N+}&%UCKVyhQ!K?%47>sP&5ufRWQM$4b$p!@ zpkP!6lC3QtE_=Ym4j-(SE9fpK>V8}wdd=eivJS0IHwaWXeSH@ThXILGAl<0|$(%}g zR!iTl{p=o>wAQ&J{~+&K$6O{9Y39bK6Hbp+O`7?@rK=2fUC*t?KuG1(eT&Vn`VCti zAZYLyR26?tsR|42<^SBtm!kUNR(L@2-INCtFqQf$>#&OkI1a}my4cO(QHFKEKC4GT^t9SdRX}W^dLa|_1uS+->VA+=GWt(WHq7jtzrXE$1JLwPDG5Cvb^1<7 z#(zBBLxZg_#ENjnD+S|ZXHpFIzW)i_i36QZG*;ADV!+tJ-tx(?OzULuGbd`19>x`M z=i6&2?haIf3fnrLxj`LT3V(*>ExJMEmUgxVrN`06Tgbl%U=mdGGHJt`@QI!8^ZJF^ z^BVxAhHBtXnh@*=%aMxX&*|wnIT|pLFBZekND{#P7^vSCOq~?aLBD{f*ZLua+v=a^ zLd+s$Q#RT5_wVN{Tw41}4{Qu0`H{Ec7nsU4zv(o0jdEFWFeD5B5YzJl5=4SYL_U84 z>CL!}q94YU57a*ZyF#Grm!2urU7pxFTw3u0EjLLMkd~|Pv6$YLo%G=)iq@c5bBXTi4YP6+V*_0k!D4`uJ zF$j632q!Moz>~cvsHp_|4|$3ob7e%a3VS*-Tx-)0&<>BEt-D-{m#)pM0_{nag*vm#Ec?jPG@xnzj)Bs8YQ!p?9jzf}wp-U3i zyu+a465!lOi4y`K7XdOmTKia5USIDy@8+PFqe=F$+Vsn9fnLT>w<5dVrD8RNEb;_Z zz1_U8-03(Ag&WAiHZhv@Fe-2I3FBG6Z{gRHn{%04h_N3ud<2>pGl-lY&cVMQO=53H z`SnC2AqT6ivvA5z|MLeHRBG=Mrs5ucXF~SKE4nMq2ZQd7v;(bz1!6)J#mT2B{%M^L zDe;D%@@}h#l-H0F{HyTl+jLcaQUEg~!8g#Pz+~wM{sMsJpeV4xWD!B0VJ6HWh9vfX zLug%ER@Usw9|ngGME^hs52!rg-UyuNa1;xS&8PgH#n$ zFfrg>dXrsh#;UlMSB*^@A80**m&-t19$T6@DKKEAa1HDCT-qZE7{y@GpZj-li1iwX zJ)3IG{CiFE?7Gm)Ss4U%2izKfZsyB!4kJE(i!|DD;M#;9br|I^tjPlG6meB_nfwR% z#P>2IlRs4c+=LY!6B7UhKyt1xN7ba@4oeqxgL7iBa`C?7vmH7#L7cQ3#vcX0?60Xx z%d(k^3bIByb$!#inBenWmtQS|JGx$TPoi0=3jq{NJ*NCf8+q(`ZWx1Bz``aGqM_O` zh}&o!2ue~4b$8<)g9tgbLgtL*2rL**{@+ctNRCYq9Oc@)7(1G z%D<)ur8rS@Yd|)_&8S;`WfK_I>kIIyV)j{0u)Pp97|(fQNe@H}D5u~T8kJ#a+^%}? z&VeQX=WX9zo!io1d;~^`Vt+KKTm=Et6J$}k9D8yOF{3E;r}mK3uQr=5NIHP^K%|2s zoE8P!M#mI)ywayYL~-dO2C@5xcV1`nvA;M|yIL7}Iu+Y3gLoVL9S{%wlAD-upy+c} zEM>3^NLq1?fAcdO>qI(DOw+oSFLHT0bKN73sx7O^Uh-t&c(B+OGCyG1e{uF>`1kac zHC{tJ;{Ha0wfLbr9V3K)3#mc>`*6~qKYpYvX4eh@upAe)n(z*07dTeb3du2vf)LF7FM!Q!$9D}ECje|$3$QorPq2Jc;Hf&GB0QB zoSuX5eIz9*9_LIf(-!Vu4qP$~0QW(_50eF^-T{tAhQ!`r&4OIuXYymI4|(a>rPd9a zsq?9-3;MCO$0! zp&*z|HbxVNLynSM)FiFro-)2Hme8=8MoCQPEPO_y`MTF`(Lv|Z$lYsGN=NiPL*{`W zLD}K{Gd`XI9%=XvV1M>~05YeFbUR#`q>-@w_gJtO?lW1A-j3DHV|MJ{Ft6^&Be<_K zm{@BTa*-Y}JK#hjVN31uw{-GULw;%l(K#6PE?t3zg`)G#{gZlwFDN-Ig4*aad~bE? z1j$kZr)hWRd#EAw2Dn|=#qa#+QVaf3bK)fdcsd+z)*Kxx^5?B-4HGZ9!l5WO@y7MJ zFGlq`5y=vg!7oq@Nu^a%y{kMsMpdQ&$K~mTt64id+o67)`;Zqkt5q~+Yd+K;H>Njv zkpz`?jEIHlIb@ z*FVl@M2xCfpQye+2nZOrmrTo$V=n6zI-;U}-aK~=y5suqP@ZcN?xdiUl?|^J#nTXS zg^?V4y((E??Vyu)_`MYwO5ieZyM=SMF#u(Km#{3>u@PFt>8f={IuF%!GtN)JZ6@R9 z#nzV$Q6Jgddj8Y`VlQVyb+AsZX)@Err-}@RcI!nGpVOldCiL=K6zAvQ>T#$Iusb*% zo*S+n?mKn5DLOT~#usOQFIEVS~2Ph3z9+|Npj zKeLS~9F}@0RSE()pBsx#JTK&&X!hp8;2k$jGp)=*v{qe2TnC&%$U6m=-4OEU5|ZR{ zg%=^Ad!&``jnR3ter=fgt@@3dl1Xun15 zv_3F#UvD8lOyUX)jvISE``$}{|G0{@ZW#|N(0jc4H&51j&?w`L^vlazlzM!=HgbVo z?pwFwHH(PC=~ur6$KD7IFoe&%9Edo9DxH3wqb9Jo(~G@&{eL?jdL3fyM>uxEh(<1o%Watb!syzXN2MG2eQ| zCLm*&G4JjTYNq{9ec`qvD|^|Kq8qQ1ddwiGji)_)s9o>x?2sf5gC_3*NpBZMc7#z^ zf<8Q~nU&i{TCFRTr7c=IEw zPj3>S&FJV)!7`V?P>NAh0alsJhzf(v8bk}264c)vp-(Ja(&Q-{whbc|k_zK1s(tbS z1GdJ}Dw}*}J!dV~&Ekl4JyOSwKgaR8|G*i=GXmv8t1yDvJ75`#p|ZYiGkGl5Slb;m zmI~ivcW3@#@9A^@(y3^R8?DrKa^hh+gbU%1P$W|bmcqwb+EQLZ`YL{ZP{=GW%)8QNMyKnG-Ej>-x~7X%qjsyu7u) zZY_RfEQ~*ZAOVvh)ik;3iovEJ)Dvv#S>rarIEAN#7`6msN(Tu9?4^Mp#H+3c)4apg zlg(Hllkjt`7dI15R)2}025G)iI8v&x!ctV1E_?l;^MM~}CM&)Zaq5ex+PVIf9A;Dj zPR~=G$ zNKKUiz7qYfpMSpK-L8ui6}tJ1`Wb7XX8*u|(odb`dY3w^mMG)lazxLq8ySHCq3FvT z0gkc15mbRIE3GEDE?_g7w@ybs-|tiN2I{5Nq8Ydx4Aae+EEluYIJu6=Q-z%dv~i>+ zHwojkL&AQis};6<+s`3gD6885gTV9eNIHY z1_3yn8|AwtPAe=8=9PNGkAdtICfi8r4vuQcW`;~)GwqMd8yd|i=*mgi&T7`Gj8QcH zBcWaI@=$}1^7vbvrW&)a(0~_rc#r#RQAC596Vl4;>btk)an`g7C;aZ$P;W(I zU$b*b_0lo}1n3BcT6C0LSK?N|uoXybE|1`8#`f*ks#vb)S$P{sF{{Z$J{E*t&fmCe z-XDDB&Vg_OPSlLd7&;dZ`aDeorT<#4q+Lq47+KPip@lrBZKWd;u#bQ&UHgqg=9$$e`puT6k&z=z~ujCedsS1!^b9)+~F2HYctef0Rzus`kt}(}FII{y+Wkr1j@) z@cRK#uT?})vCZ`Uot!-|Ve8b1Vdh>O;&R+9QjhCYq&+$Gll7@wpC8HcC;`iKDWB(` z()Z{&fm{o@m1*6uoFW-(E2?8QGC}|*;mFln)V4eOQo1vi{;oy=g_{#!U4+$j@8tW* z4;Qr)mf`EstPz@;6)c+r>7pa#skNe<#xnA6%>c8AF03<6{$rD%z=COd`I8(SIZ%{& zc$_pTGC(kMMX>pOm{T3>QdrNsD_F*a*Qj=WD7;#@9oWXG6kg7sD_c4TFTcwV)R=mG zM%TGYvHyB{l#mEVA5ChxP-@C-Qd-e05GzGi*3vfu!i;up! z3PBGjLv8NSAX{LPEMo~PdEW_6=tM_dBpbCO5`Mh4a%C4{cHRVi^6o~l=C!~!5Pjat zZJ8Doq7f3z<(T;qA3}-+{xeL$1uRXCGe0*4VNWk_ZoY=4b@Qw3vUr6~1}R_sRlT?r zELTmcak+hAJdcsB;t1Kc=}p&s_shzueOnH9Rbk_YWL|hT-~t8O75EKYn@JM-Ok=>+ z(4NO$^iXv3tz_VnVnlDG`j474od{{=0gtdzgezFIVGG6BkYQy8mxr0XH^`T4R&1{H zJOO+-Dr1xqh18_3P4@pZ8s_}#eFuV6occw9Yt7tczc&wx;ZXxlVuUQgGxT5y@!S94 zQPBA?j`sSSn>q-FVn&-t7tFEvNr)q>3#TqU$2Wb zLUNWg4M9n@{yj1GU9%vDm7P~+rNZe~6D%s&)&7g{hP1ep2Yvp%+#EmHdBnBO)A}tX zm8znLC3Bf<1yf^Q=Hr+NDzV=T{SQ3>3I-Vd{}@8pPa%zn(klG>>W9}5>wxh$sk7y# zm(N?bBNSMRHfjcqWClEn9a}C~8{9^A;A6+2LJOcHg$yv0Zt`G%;T)aAuT{OE#m~Ca zHKWbd=R<=YdrZmfbiNq7 zZ#HzG+o$P3`cBB$<1S+Dgx>>aD9g5hZ&1466%0SS)YOiGV?#2+@ z!cmY(%}5D|IA39!LsNX)1OGsWY^ulUfd(ek6Ma_Zw0t3Bu6j;4yI%7*kD~X7>Q;=z-XOpV$kkN9ap>o-X2hk@F# zwjc)(5QK8D({(2VYp->R*V)Lev;Pq)xMiJ1NLX*com}2|BWTLgD0A{#^pYchBB&qr zK?VmBy6hIEMeQuNCLJ2jYSi%UuX z{8bLJ%gwRaG(aDiaOCW9`Ebg2UXiVPpN1#6LXF2@+X84X6W)Ux2P}eOPZQt*cJ!x8 zuADUpo#hO>S-V^vErHgz&N|w1oJ)O7W5c;X@_@jhE)4o@G2_kA$$A+G4D-hbg*giE zut#_%6I;Nry!d6x61J{%c}%|FmB_2exzUREQeYabE2Mc zn)tO=%%|gLpPyAN-*;lN$&SthKzQduZw}M!1$QtE^^izo3dvV+=L2Dhk>G>8H?Jv~ zROIJ{wN}Q>Rv$zFccO9-d)NtDw|qLpog+pU$R{Y7@dqGTkzy6;5rYdJ#s}VExK;*T znwbiBdYpG_`PuqObX%eybt-i}2zKK-w@)f&)C5$D-cnWhggH-!oWmfa~-=`R^ ztX=~NWnM|D0hGxa$6-#$D&2f?6&3~Qh?MHSEd%Z1q?z0Z)jR5xNrNnKDUH%CZ>y!6 z@GRAc8A8oMneVwRKqH_%_&wX`8Iw@wzPHTTHL{hX^RcH!BjJ_xibGt|Y5!UsH%D=` z1&eJd9i2uLu5IO19#=JtA0TZ4NkRD(2`3?-%CsbxK@AzLR)|eY1ug+jVm)1*DJ#VF zEAK!Xl8?6weg;4aA?XNHWdvd%5MEvd>4BDJ*08GFK7^8i+Zu?h|HPV+Tr@8KS#DbZ zZU&eiE+P!iTVueD@d3d#0r5PLed&!i13xS{ehs*vDQSC5<i5~`;3yk^bI5{5exiwgP?C2QW zHnJKzj`*JDfBu!w+EJfW*+X|WZ}4S?d@~z=GeW6vf51Jg^6{0`20o4%-n9k`=R2F* zHiheACI?~FfOfFo0{J!kN^ojln$#zZzkbS=6x*c692+rPm5cnAo%3mYsmg!igTf>$8z$!qV4D#jN3L>mWzjv6;C%mfqXrkrwW`B@QeXNB4e(v zSSeYLF0%d0PRxIq0Jz!W(o&|>{*d`)R2~|Qev*>B{Vv*|Yr$sNj|fJM?cF71utvi3 zgn^8*a;TaSE&fxmAIJ#w(ZoI$1zR0>)-p|fpCj=a)Mv03a&j^k-ghTN;}IjxwUyqM zbKDYj_67L~Y(4NsNg0{mza&_h^)`2ROp|=j8fheUt1K`?<5?kS)u1pM(0d%Lk-Pw< z_^_SyQfo{WE6**!B91@nx$+Do{~1@VACrdtw!U$E z3aL!6_>2jHsCoee>9UZd2D0}!5}TQhT{Zg5$&CY#{4ny@aclMvK?1IExRW3X;!`uU zjr@m3mqq=)Th`{8S_P0EBmIc6AdcE!1nA}A4_PX`Tf@@1tbTHoc$@~8pnEo;pdcWU z1xf}oYNH2N0(aFB4B7)8ZyZTSbWgn`;O{U_bcQ3+5HP~C-?y4uuK8@^K>i84`a(rA zb3tIQ!q5NOm+`gjpsw}*twc%5$)xY8gx~Jmt@{c6!qTu5d``lwtDOV={fx;f|IZF0 zdEqh3IeKY<>_xHaonGJ3A|6t*M@Qb9c~M_!;3@;<2}mRrA8C*-?YRSx1aDuc@g!aB ze)X!t<7Zdt=$7vs5ZV5UYT1p=Jj4CBJa;^*!Y zB71tnRFIG$_1j!Xmi&Cdg{QepUI9nGn|YG3u!+=gsP)|Hj!scQZv@kQ>HTvw;{CV} zn@z`+)KIaj=Z567%|uk856d9@1nRTkDgf@~oz*3xK_5ZqyfYyRjojg=?i9_-w*;7n z0HEpbSKV?kZGj%Q9dRU;R$T%c z3oxwT6vA^TS^?^I&qZe{d4GEj3(n!8w0NuU32IlFxi|@o5}(Y%BaB8-gSrSN28f3- zVc0+4nMT}2W$6Cv6Zn?037U-RY5|PK2E-7)V5DU6MySaOM40k&Sa7J8Vefe)KUo^A z8enwlbj*Xi24us|G0Zt|*q$x2NkU~36PChbRfuc>Fc*YeVBKb3Pd@+A?>V6ccPc%A zp$y{pgZSWwUv#R?9;t_aPleUA)<;0nZ}35GJaR_X%w#05rWZwxIO#eQ5qa{X+i7mX zMxX)YJdpSb=pzkH;V-W7`wKA@l>1-?hHSShi+PvrSMLsf=%f%{b1N0sm#aOY>~k+G zDFK0w;)S1gVo$<~8=|3))*KE?D8~D*W3TVq(x-GUrL7!5Gcf` zY4DSRD-4oHktn*2)Y}BO0UD$qt+0f{9KL6V_>qE)3SeaiZ~#F5OR_msnQU)N@x#uB z3n^ak3m&C5AJe#(v3{IV3byV3$#IXDL`2b=&T=F9sipqw{s`fSv4&gJi@VkV6KYNAp`3f3~)t{ag2ymB^HbzLa3QvQ#*Rv4um_ zs-=}IBL*Mr-9@mgU2{?@9EGDQp~@PbUTM1T5D)-*fOdsFFF>fEPP`M?DL`i+CBF~J za6d5fa>Ta{aK3>1Zl{MW6VN2LAk#_^x5LWFi|{JTO}RHLGJN`w#{S}|+cYg(W>=i1 z#y^(9uJfpsfCPgV}Kc^s~u`ks4Yg`B~JK%axZ3db$Cl?q;gpv}|;8cjHL$(`K zYd{`z8iS~a_3G>uwfwM?!*!+;5$vdH^Mg`?9W68@j>A9!exq!OD<>kWE+#P*`?bkW zN_9R;ks*bJuhVz0TlKxkRdYo7$cYPac2CKm$o1Sb6YBw4f`bDE1Hv`>J>x5MU+0Z z%9wimfIqV(&{np182>vO^=&8!o&XF}5BCvYJ2NHG6>W=83s>zsFH=etw?4GP`w%xqLB$^RN}_eGCNDKew?_ii$=d z?`_4-vDG&XTY(QAxERpJDLlH7!$=$3vo4{g7|9t}nr)|gN&KpH*kR9>mV2tIyWMB$ zi9Z_~#fV-2H>A^Bk3`bn{+^rWGzi>SEt~>@-uls>`Yk9Nz^GZ@_}tG~Rlz~p4@U?S z-yF=JyGF{l{9ZsY8WItpUG;dG2A+PPl`sXJ@VQ_yRIeDUxSr0VxO@#l{c`X`)E z%gf6kZ^5npePB&;X=>L_42QOfnQTExkH~N-w0doyW1an-9Q*uz7o*7K4q={V%R7{oD!}qmc+NtDxBS%T5%(m6kfcWM8;|r$}udx4e6}0xCx<>CQFZ9x;3a&O9sS{DM zRpMR37P&=L4KX1=k3+f936CwMl{Qt6yG$-linX$(lzjPgyI|^zpsL)bbpdV0J-2R# zc4U7QMX-XY8oXQ=8X`gVrSmBIh=)s}^K+nmJzBc&8w{LV(cl*JLUowL@G&Zeh6J^_ zcNc>w5rg=!boJg1CNlQ!_n$mS8OqU&btIs;n|dYv&SWuh0mWir`ZaK=fs|*u$@}Rn z_9H`&7twbML@1DSZD++0%7V`ffkWUpCB_8*6%9RSAD7Jxms9O5A?T4Gz8fo;_M>PV zoE7pc9bf^#*p4xdS6IXV`Yu*Hr%kc?$2~mC!y<}&nBftT7mb*70_ra1>T`gR6WQOx&yoZE0-U!?nt~+QEkY%Bx$`6sibb56gT*8 zP&!g|eCdtXljR?|s z-yXb{OB5eZ&iU13oLs0E+_u0^y~y%#m%NH!3CDDovCorFmVB;Q>uSTzKh28hf=OA# z&Jf3eT-R3B-LdtvV!#^RP3wqFntc((s%<4dhHUP1yeFdM{sO>SD|aJ|t03*bb-f(0 zHw3sl=w}5P1{E#g6<3gfV+U~TaP1vD8+n0$-E#lMO2l>`v)utC@MvUvV>-e*nd_u>-Vmo zNig~Y-9mDG@I+&doR7oc>69<{zM~J3yfP289aOxBo}2SgSzlmc4Zx1z{!fNB$(Duh z>)6-3cVB2noHR(uzNnmvf)0A9&Az}d;f%(c>q#phqa09sivotK!amcfd>MXfIcsn&D zc?HTWVXblyrft1BX+YFZ@cyDpk5ufmXpN$3Z)8th%bqD2di)}i{pUDpeq@ewW#$y3r%TfEE68pXo9$1hWaIVp<$%-M{>l1(zl4vcGqZG%go`ED#pt z)KKpjclAEM(aL2JNUnyz7v-CCOYN^%IOX~i7;VcDA$Yn4tb=}M(4 zuwZJvd(6yc>zm|fY?3^^$Z|%-Tb7na`rT~JyN?@so(%bYR*RYJk9q_tOjLTQ(KX|8 z;?{dMrg^F6L$NH6##j(mktxH;tftnh8L8^z-2{{TEA7tfv}x!mv~9sI)N19FAA1|} zSuowG3)^Bck$9woXO&Q^_t|y&@C~yGX*xf(&Xsto@PdGj;2O9ld%E_nJ)-fFU|rAj z<&PPgY#VT1>10ie&|_L73a>tN@N?&E`&_(n_L^C zo4Ymd6(fAS;exQ0OSB9osOIITv!It2txcp5dG>jA|824lRs`*xz&2h)(3+}6-Lvj2 z-|erLu}D%y%HM==KORwfeC_1d7B&HGcX($*>_D?tbadbI0YOl}!48B6$vdn|EC71i zjEf}FwnSmG#$Lc-#CoS=!I5{rxSlmQLJ|TRrIqTmihdpMtziBi;7~X-MD<$321HZ` z?CyEeGm5EMQ3=F)qe&C%6yuFi0^$Z}?}nkrPeSdfLGD zX<%h#1>B_3O8EhuKT}k>P)PsAgOB4J5DNgCIv%S9 z(hXv41*9*88FRo}+@Tw7`S838Ukt1Bw?;VG>}8h$bD7U4Q;xFv8axfgx9dy0Ner zos#iWiXT6!iDqkj2rOP+wo3Ouu~x+OLN^fi0cr!R1!zc^)73yw_$yHIj4>f0!GED8 zgV28jlD9!Va|UHb-<)cvH3C~gL#Rk2wU$v$XuD@JD2`r#x66Lg%NW8*{Gnf|WLeqF z8YUUQ{W7gy9o!$dTk7iS%CUC}8ee(Cu?bm`nC4`O^ZiHG5*-K1Y(LfyNaCmXtcEA8 zmVz{_hTh~}VQG5y=W32&m!nE2+itpCw*6EKUR!36XI>;QT^WI z|J3@7vLuzRtBTAb;$4X53Y9x8d5X~bpM%DojDGr&m1s>3=CWs^+RH1eC@WXVVbV_* z?vfjId3yC?8ROn-R?}DH#%6Y{(iCoT#4F`ED6BE&4J?$)#6)+mFF)KnkJx*~@`;yv zk>4W3kAi`P(xxkhofULQa{i>L6gxI)d}}q!5;R>R`&?MW(Kzx&EKC8GhC(3S)UrkP z17)6{P4u+ECMZ#jGriEH;z(&ND088H$l!IQ+-I?XfuEyA!;Ks$dUq{+IuIW2y?3*F z%x)V0N4VF$^SE}e8=hRa;;|kqpE)H31auWSBnO(r73dXFpX5g`Ef&FTk3tfI6!7W@ z#Nv*kyS2Xn!(hOD8H)^E8J=su*DVQCa)${iR7YfW!72zo0f7Pp3ydP5faNoZ_m0O_ z=t;1j&9dEf=T85LM{?_0dQ|9@Y=g#~Db5T9oIzzdHqEQzzNz0NqZJsU6@rFmzkkQV z!mK<%NWi)QFw{G#hn+3~XLq*{PBxZj2gSh|RE#wb?R z3*5o7)_UVNY~>XtJ^3k6-KnEZs`4RI8Z(#C$KoEZ86I(jB1WtGu#%k$x zbR8sUv96^S_s<-A6bAv{C#jZe3feY;WC_p-LDmk~as461?e^#U%Sf{_FA`}H)f+vZ z+rpec{tt&I=&omd|9L|k7CA5}QYqtu2(U>2HroN&Rd^pJ2k@ii61p63N2kC1OUV=L zbz^xIy?uP{14)4ovEG}aqZ+JFe{o3#Mt{BK(9Ub(oDF2poxqJ;$Ak}WN6#+!mZb2{ z!Igj&;Cxf?Cu3VudQ;7C)%?UUYGx+n{_9yT<1HBTFe-U1fYXBkE}=T}an({Nk6V zL1iTs7U1K;Qp&ajd@F=iLE_rYmTa;g5Zt#cv0=UGRO{cbmf^>pI!c=99;vP5PtTuB zlp*OG0cvDOi&ebZ36XaD^tFPz+z42(LA6oqDuJ_?@g{d!^yR1DIlNO-QxCxb1a`A< z5J$m1%pPk(LBLjM?Kj{HDd1?_LYnKUQYwK1GQr=&R)s%pSikGSXa)=nWFScyczjT0 z3fKBip^0`xk^g+sKsX7&c~EI~<;LEz1Gu)&j=Cg)E|-OTs)ZeOh!MkNL&8tjo#rH1 zk@F|ZDCg_20Gjn$dxH_(5UWvag6T_n18ow!xfE~Ir~$gg0?AtjIIg+nI=DV-aUR46KgU)Z<%ml*k|VWVL9Ch=`5qf$_tC-tk~g zfyM582h=6sul==nPFR?+xl`~>7ujK57Tsq*5d*!!Ul(>Tk}N6bvhK@4y%G=;pOjD=^lNPTW* zMiv^~2?9txN_1km^IfkLhQ)8pT3EN?AJuWcZ>` zK?WQI5XlNDHW;m}q)!;|Td=ZVWSEd<>D+Xs$|S~&LE=&AI3QloLh`((;U$moA`_sT zj142CqCJG8cQYZ{6vKO0jDQ^mP%cKjv= z!Ba7{bxJj*&I#4mS3~K+uOJP~7^IY{u>AP(BWCymOT^H&b)=SjM+>8AlKUJu3%g8l zrH=eF_VrmYjk^Ous735nwMN*l(wODv_C}rrM`I>c~Lbht0rZn>@=OP0%kW zlsV2q@nLoq>g{b>;OP-&=UOs7dAs3Sa32+i-g(7x=V90DQ9#jY;W_F1&D#9>swl+N zK>8pp3C2X8>2t!4F$?|4jJh>-fci^0oa)~L-_o}qG7nWcUX3_YPwwF})V>fLsNi^9 zPk;_+CGiIigGe44l_17ia0`I)|2$g2Wxxq7yX^*Oo~!1kb|Z4@t4uHDgQ0G; z0tMv^QQ*Hx>oyGP1;`sHs76OerTuF_o^F~y36;0-`qjyC zH~-7AL`fPlO|HKSMmWrQXTC!N^TSLWkMdXBz4xeW8P!wSy&lz6PRw0iiHQB)KnkGn zJ%Z%kk@hs3YUJ2r$C@$ExADec#ntEgy|he(kHccRe_IeEG_k2sF=)hbxN|L4Kfjh4 z=OiST02B(K$W`MG|8~SkO9aZ|sqC^3VZC8q1G?sukm?ZR>q&b-Ax%Z{QLDms0>$dX`i6GKkq z>=xtEOwCK@tcW|$AgR(HWunCUGje@Wet%3*tMZxl+F)I0k}e1Gq@58jFxb9X@>W6;H6omO7+W6b|r^j)K^MOV%%99P%2 z&=lHYzHr4LZ--~zC)x6wHcCP7m~GB0NXOTRlcygr$SbN=U|M!l?rqSLk<9w2ycl58F}hc~!|ijW2D~J;vmrbW4d?mZQ`ktHRpI zto=r4!7kq@B?6i-C*YI@mE}J_<;pQ9mC8M~Vto4a9jriO}wP5WA1}M%3?fQSYveQSz51?O%>vzOm-m zF)`xU=A4n1l+yqC!1nWZbzJQfe1{hXPbcsihp_moF#J>brGpj!vy2lN5MK z{J^hVvNQEtm)u{RrYMn`V{U8-TqzE2P>xwlD_2bQtG4N7+*bNSIcUiB3%A-S$>ohz zQE#FQ9eoZkK~Hn;G$^9^S)CoMboci)8O`ymGv4aF8>23AU+Hd>DFdb6-x(*sN2A^qIrfh~2Uh-Nd`rP`T*pGBBPt>F3zl?N7$mSzeSBWS=rA*< z@%18d-yufus^A<^!Fod^hVbV&8zrtq#nP78VYMYlZ|)>X^!|ejd3Da-;RA-eR7GQc z)d80*-amCroh~joWD~C_XscY95=Qq{dYb~Tc9zhsZ#r^v-^u0Ew>s4|$osLGmF~_W z6J|~PI6l(je=_Cj`s(vt#oY8^6h}tGgZN>Y9pdevpL%j!JW#fAAbxnsVq4Yf_d-?< zn=Q`*;6)|?rhA|IBI2HZVavYD;9M+g_s*gL5i*(q>roNKp;(c{VT(0Ql$jK+$ zuP})4ol&5hXVm3DKFgp&Q+yvO!G>O!m$l7;Rl=5%N7*f_c+>Xs^isF5A*U_R8kGME z28DD2m->6`Qt&T_B1l+{M#l+NezH6n)6!i3G}x_7=fO~Z*R?dQ`Ih{9lGH)M5dtau zpA1^a^$X3C-Usx!c19f5Nf4hnsdn-}*5vQ3IKRC3iF}ogfTz_wkE0C9&*nwW!D+dTAxp@dCu%B5ViMR`~hj9knOCO)f{ZC_ES@CQ7*nhp7OY0;l8Z)3^ zBf@~7?N4?{dP4~!zk5cOy>5?s`?(a0#;jzEHSrgbAX-1`CQnZ-(923vOA1c8=3#4K zOD%HYnq+a4i(@2{P*^oT_5LV+{a`2;%>*eZijkS#g(=az?LlP1$b!IuL{2IJ!=Gl|xBQo% zb|o`WlF9I41N~%swd;_;pRkU9#tIO-?tL>TIu>?WyG3oeN67x^O83J6WmeIz(N|NS zzgGe8ux{PNmAZe~w(+;t>ZXz`} z&yg|=Em{}OA0s*HBp*nm8?t)(sCi$+C;LT*=pR?!JbmUI?q{Tylu~aWH=w?0)928( z>vAe&58R%{>@7YZqnHAe@%rO2L;m;QzsCCJJ>Fx+ zb3dz9jk#US#3B55Ip-{id(Eoo$$wv(4oTGlT@J_p_iNUz*4fA7|NNU|h?V#MkN>t) ztzhGyy*oHPfPOI7K(7XxCvqo8nw$?4GoB?)&m?jEjX~D)2<03jv zkMiC4oydl*@77w=ZG`9#k!lJUPb|~f$NgVlFtWSl%P-1Fi!)2iO$p+0>VP@HDneTh z4Gw-S#zLOn;p8yx(3yUaM>Nc>uZBHItXm z5Fd2uSkU#~(~{$o3g0SzSlp?afa4HUEx2F*ne4E!apID`{YnM00WLC<)t0?#I(`Ut zWp<1`PDn^)Sa2J$Z)!;})tFwyVhWHWU*t~2(PF`djFw|u{TFH{0w|d|OAJ_jae%kR z*!L2!JZR2$D+2*uk}=YE;hP?EYnMmN0X{t0nRnk1gGj#|gu{xkXFiP45R|sR@5)zB zJyvURJGQIaLKiC9o>^+@fTqH!Vh0_CxIVj36Sj>P%<||2CMV5zb+Yw!8h{VgWSXacUMPexWC9yYjPZ?x8B$>ZAz%Rul^~m&UT(KF;hBcW12M+x>goqv z_wxMkPSy+n_47e;hgxRNf?hKR={bcRE2r`K)KoU+xu*jqpIjNLkm^BrSZf5R-Qc3=+^! zLoTc6ed*m~5bom51i27zo={AasLBa7OG$$?JDc{?0cURj)4M8ni=0&a_8t>f!%#8! zpD6pg8FT?qRU{e!1);mc0a=5&2o(gjgYqEO!ODS95$Qs0gZ~F`7TdR{Qoq1Ou54xU z6g+crpeHmKCx_JoaC!UH%;lJYs4G+AaVF@9=RV%BafPuezs518Q4?i-I02= znf1+wtwBx(ITiZ(`+0LfhhT--ADCBFgLY!@e-CLG0(wct_(20q2&t9smRI@tKERc4 z&(?8b)un(k3ii>x4@aO2Av;;}7RpjC)&8g9M0WC*kL z=bhvCnU4kjwP2m=x<($m<#H)?*Y;iIj~>}7W%<>(diGp`6C{>rU=SdzuPf;G;+?z4 z3!YLlPc=BDsgZYE7Wm8=KOEztrXcq>&-BdqHg}eU&og16yQMl+Zbm&0f zkyv3v*N#DFgOPB%w4AEMci(JLkjZ=*>e(xzl2aby#}}UTX>9IuDTlFqhm~~>}#ZCH012Ky#JL$S9az?*trK{>iLm|a?!N6{1>NVFODaxkYVo|C` zjtQ6V#CI`n--1L#^uVY>RrWWF^kt`usUg})qdlkamqW|sdZC(}SC`dy-uqpr>fzSX z@@!(D{6_NLCsTO?GDS{==Q930axt#ubz@<1w8gpiX5lCn(c=rtdt#Wy?)3ujAUt_* zW0hRN>_mzKAOFMQjhVv(u+W$0+FwDKN2$Vmw8i(91a)wY;Nyv3F7Gzq-y24jAB!BK}Ij3f^d+msD9uyJ~(B@JC$Z{~r1ZP^_C8=Q4w zpJ^lB;%piwp|!2&4L-G)kzZqx^A$!FDi2qq>`Qj;Gd1h}#pUbuAZ$7hMG-eFQ? z^MpD(4MslH1Oj8Zsk%KzAx2sepmxis0LkXljvW)8c|R4eK5EWQ;2>-NAqY_WV9f6l zWr{0O-W@OFM904K@m!=yvXXZ>$RSP@VBnKh1LD%N^MNA>6a@x^?+uem1qo)v!rX5d zx`!mhBYS9h;*1AxxHz|uhzEPcrp7w0Kcd|%I3*^s*_SlTWo&aGF4lLy@m5!j_Kbw; zGZW^sLK9{*R@VDXUV7%_Xex$qh))Pn=L8vYMm!MP8Es+^-f2H?R_oBUWYyQ{poAPl z6-z}1JDV>{k{*#=S#fc5VjAfuS97fPIMBO>=iJc}(DZKps3P`=5*F}4Lf@O7Iu=Ey zaN@M!VydU@f+uL1aEt;U562fkSG*-K<0B(OT|r{sKU;TL#Dgn<`|5?mBlnUVh(6Ix zSQ!_U4Kz0;TzRIsh(hXHi3*KEij%r#ct*p$R7c@r`HMUSoAWU-6m)-m?p z_ANnO24h3X_BNb&8L*7T$AN7SIA&m)A@u=ERJ`ioiaD`vG>yjB5S?tdHQ4oG(YL7R zVg|W8fN7i@5o|XpeDQs!S;Pw&%Bwe{3Z)m9Zli<3qx9PTizL-8XBNHEBYE3qGZ@