{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# To ignore warinings\nimport warnings\nwarnings.filterwarnings('ignore')\n\n# Importing relevant modules\nfrom PIL import Image, ImageDraw\nimport os, random, json, PIL, shutil, re, imageio, glob\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nfrom PIL import ImageDraw\nimport matplotlib.pyplot as plt\nfrom kaggle_datasets import KaggleDatasets\n\n# TensorFlow for modeling\nimport tensorflow as tf\nimport tensorflow.keras.layers as L\nimport tensorflow.keras.backend as K\nimport tensorflow_addons as tfa\nfrom tensorflow.keras import Model, losses, optimizers\nfrom tensorflow.keras.callbacks import Callback\n\ndef seed_everything(seed=0):\n    random.seed(seed)\n    np.random.seed(seed)\n    tf.random.set_seed(seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    os.environ['TF_DETERMINISTIC_OPS'] = '1'\n    \nSEED = 0\nseed_everything(SEED)\n\n# Setting up TPU usage\ntry:\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()\n    print(f'Running on TPU {tpu.master()}')\nexcept ValueError:\n    tpu = None\n\nif tpu:\n    tf.config.experimental_connect_to_cluster(tpu)\n    tf.tpu.experimental.initialize_tpu_system(tpu)\n    strategy = tf.distribute.experimental.TPUStrategy(tpu)\nelse:\n    strategy = tf.distribute.get_strategy()\n\n\nREPLICAS = strategy.num_replicas_in_sync\nAUTO = tf.data.experimental.AUTOTUNE\nprint(f'Number of replicas: {REPLICAS}')\nprint(tf.__version__)","metadata":{"execution":{"iopub.status.busy":"2023-06-12T06:25:44.597828Z","iopub.execute_input":"2023-06-12T06:25:44.598601Z","iopub.status.idle":"2023-06-12T06:25:55.560835Z","shell.execute_reply.started":"2023-06-12T06:25:44.598565Z","shell.execute_reply":"2023-06-12T06:25:55.559952Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Model parameters","metadata":{}},{"cell_type":"code","source":"HEIGHT = 256\nWIDTH = 256\nHEIGHT_RESIZE = 128\nWIDTH_RESIZE = 128\nCHANNELS = 3\nBATCH_SIZE = 16\nEPOCHS = 20\nTRANSFORMER_BLOCKS = 6\nGENERATOR_LR = 2e-4\nDISCRIMINATOR_LR = 2e-4","metadata":{"execution":{"iopub.status.busy":"2023-06-12T06:25:55.562433Z","iopub.execute_input":"2023-06-12T06:25:55.563755Z","iopub.status.idle":"2023-06-12T06:25:55.569303Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Great resources:\n- https://paperswithcode.com/\n- https://junyanz.github.io/CycleGAN/\n- https://towardsdatascience.com/cyclegan-learning-to-translate-images-without-paired-training-data-5b4e93862c8d\n- https://github.com/architrathore/CycleGAN\n- https://machinelearningmastery.com/cyclegan-tutorial-with-keras/\n- https://machinelearningmastery.com/how-to-code-generative-adversarial-network-hacks/\n- https://github.com/soumith/ganhacks\n- https://keras.io/examples/generative/cyclegan/\n- https://www.tongzhouwang.info/better_cycles/report.pdf","metadata":{}},{"cell_type":"code","source":"plt.subplots(figsize=(20, 10))[1].imshow(Image.open('/kaggle/input/imagescyclegan/header.png'), aspect='auto'); plt.show()","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:14:11.308917Z","iopub.execute_input":"2023-06-11T19:14:11.309833Z","iopub.status.idle":"2023-06-11T19:14:12.843592Z","shell.execute_reply.started":"2023-06-11T19:14:11.309790Z","shell.execute_reply":"2023-06-11T19:14:12.842208Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# CycleGAN - MONET PAINTINGS\n## I’m Something of a Painter Myself\n\n\n#### What is CycleGAN?\n\n##### From the authors:\n\"Image-to-image translation is a class of vision and graphics problems where the goal is to learn the mapping between an input image and an output image using a training set of aligned image pairs. However, for many tasks, paired training data will not be available. We present an approach for learning to translate an image from a source domain X to a target domain Y in the absence of paired examples. Our goal is to learn a mapping G: X -> Y, such that the distribution of images from G(X) is indistinguishable from the distribution Y using an adversarial loss. Because this mapping is highly under-constrained, we couple it with an inverse mapping F: Y -> X and introduce a cycle consistency loss to push F(G(X)) ~ X (and vice versa).\" \n   * Article: Jun-Yan Zhu, Taesung Park, Phillip Isola and Alexei A. Efros, (2020), \"Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks\". \n   * Source: https://arxiv.org/pdf/1703.10593.pdf\n   \n   \n### CycleGAN references:\n- https://junyanz.github.io/CycleGAN/\n- https://hardikbansal.github.io/CycleGANBlog/\n\n\n   \n#### In essence it maps and image to a given domain:\n* for example if you are turning horses into zebras the image will be the horse and the domain is the zebra\n* in the case of this project, I want to turn photographic images into Claude Monet paintings. \n","metadata":{}},{"cell_type":"markdown","source":"### Some examples from the research paper can be seen in the images below.","metadata":{}},{"cell_type":"code","source":"plt.subplots(figsize=(20, 10))[1].imshow(Image.open('/kaggle/input/imagescyclegan/image-domain.png'), aspect='auto'); plt.show()","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:14:22.957685Z","iopub.execute_input":"2023-06-11T19:14:22.958112Z","iopub.status.idle":"2023-06-11T19:14:24.193118Z","shell.execute_reply.started":"2023-06-11T19:14:22.958078Z","shell.execute_reply":"2023-06-11T19:14:24.192246Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Some further examples from paintings turned into photographic images.","metadata":{}},{"cell_type":"code","source":"plt.subplots(figsize=(20, 10))[1].imshow(Image.open('/kaggle/input/imagescyclegan/painting-image.jpg'), aspect='auto'); plt.show()","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:14:25.107682Z","iopub.execute_input":"2023-06-11T19:14:25.108735Z","iopub.status.idle":"2023-06-11T19:14:27.348775Z","shell.execute_reply.started":"2023-06-11T19:14:25.108693Z","shell.execute_reply":"2023-06-11T19:14:27.347348Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### CycleGAN architecture:\nThis image will help the understanding of what is happening:","metadata":{}},{"cell_type":"code","source":"plt.subplots(figsize=(20, 10))[1].imshow(Image.open('/kaggle/input/imagescyclegan/model.jpg'), aspect='auto'); plt.show()","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:14:27.350716Z","iopub.execute_input":"2023-06-11T19:14:27.351063Z","iopub.status.idle":"2023-06-11T19:14:28.073631Z","shell.execute_reply.started":"2023-06-11T19:14:27.351034Z","shell.execute_reply":"2023-06-11T19:14:28.072360Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"\n\nFirst, we get the regular generator discriminator thing, where the generator tries to generate images that seem to be drawn to the given domain (in the example will be creating zebra images), but it would be possible that the generator generates only the same zebra image or zebra images that do not look like the imputed horse image, this is why the model has a second generator, this second generator uses the first generated image and tries to recreate the original imputed horse image, this way the first generator has to generate zebra images that look like the imputed horse image.","metadata":{}},{"cell_type":"markdown","source":"### Note:\n\nThe CycleGAN model compromises of 4 parts that work in a cycle:\n\n- A Generator that learns to generate Monet paintings from landscape images\n- A Discriminator that learns to identify Monet paintings\n- A Generator that learns to generate landscape images from Monet paintings\n- A Discriminator that learns to identify landscape images","metadata":{}},{"cell_type":"markdown","source":"## Scope:\n- The idea is to learn to capture the special characteristics of the Monet paintings and figure out how these characteristics could be translated into the landscape images, all in the absence of any paired training examples, i.e. image-to-image translation.\n\nThis happens through the exploitation of the property that translation should be \"cycle consistent\", in the sense that if for ex. we translate a sentence from English to French, and then translate it back from French to English, we should arrive back at the original sentence. Mathematically, if we have a translator $G : X -> Y$ and another translator $F : Y -> X$, then $G$ and $F$ should be inverses of each other, and both mappings should be bijections.\n\n\nThis structural assumption is applied by training both the mapping $G$ and $F$ simultanously, and adding a cycle consistency loss that encourages $F(G(x)) \\sim x$ and $G(F(y)) \\sim y$. \n- Combining this loss with adversarial losses on domains $X$ and $Y$, that force the generated paintings to be, in principle, indistinguishable from real paintings, yields the full objective for unpaired image-to-image translation.\n\n- I will use the Fréchet Inception Distance (FID Score) and of course the generated paintings themselves, to evaluate how the model perform.","metadata":{}},{"cell_type":"markdown","source":"## Augmentations\nData augmentation for GANs should be done very carefully, especially for tasks similar to style transfer, if we apply transformations that can change too much the style of the data (e.g. brightness, contrast, saturation) it can cause the generator to do not efficiently learn the base style, so in this case, we are using only spatial transformations like, flips, rotates and crops.","metadata":{}},{"cell_type":"code","source":"def data_augment(image):\n    p_spatial = tf.random.uniform([], 0, 1.0, dtype=tf.float32)\n    p_rotate = tf.random.uniform([], 0, 1.0, dtype=tf.float32)\n#     p_crop = tf.random.uniform([], 0, 1.0, dtype=tf.float32)\n\n    \n#     # Random jitter\n#     image = tf.image.resize(image, [286, 286], method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n    \n    # 90º rotations\n    if p_rotate > .8:\n        image = tf.image.rot90(image, k=3) # rotate 270º\n    elif p_rotate > .6:\n        image = tf.image.rot90(image, k=2) # rotate 180º\n    elif p_rotate > .4:\n        image = tf.image.rot90(image, k=1) # rotate 90º\n        \n    # Flips\n    image = tf.image.random_flip_left_right(image)\n    image = tf.image.random_flip_up_down(image)\n    if p_spatial > .75:\n        image = tf.image.transpose(image)\n        \n#     # Crops\n#     if p_crop > .6: # random crop\n#         crop_size = tf.random.uniform([], int(HEIGHT*.7), HEIGHT, dtype=tf.int32)\n#         image = tf.image.random_crop(image, size=[crop_size, crop_size, CHANNELS])\n#     elif p_crop > .2: # central crop\n#         if p_crop > .5:\n#             image = tf.image.central_crop(image, central_fraction=.7)\n#         elif p_crop > .35:\n#             image = tf.image.central_crop(image, central_fraction=.8)\n#         else:\n#             image = tf.image.central_crop(image, central_fraction=.9)\n            \n    # Train on crops\n    image = tf.image.random_crop(image, size=[HEIGHT_RESIZE, WIDTH_RESIZE, CHANNELS])\n        \n    \n    return image","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:19:52.319078Z","iopub.execute_input":"2023-06-11T19:19:52.319593Z","iopub.status.idle":"2023-06-11T19:19:52.329782Z","shell.execute_reply.started":"2023-06-11T19:19:52.319545Z","shell.execute_reply":"2023-06-11T19:19:52.328886Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Creating the Dataset\n","metadata":{}},{"cell_type":"markdown","source":"The purpose of normalizing the image is:\n- to bring the pixel values within a certain range, which helps in training the machine learning model. \n- to help in reducing the impact of lighting conditions on the image.","metadata":{}},{"cell_type":"markdown","source":"### Auxiliar functions","metadata":{}},{"cell_type":"code","source":"# Images that are represented using floating point values are expected \n# to have values in the range [0,1). Image data stored in integer data \n# types are expected to have values in the range [0,MAX], where MAX is \n# the largest positive representable number for the data type.\ndef normalize_img(img):\n    # normalized between -1 and 1\n    img = tf.cast(img, dtype=tf.float32)\n    return (img / 127.5) - 1.0\n\ndef decode_image(image):\n    image = tf.image.decode_jpeg(image, channels=CHANNELS)\n    image = tf.reshape(image, [HEIGHT, WIDTH, CHANNELS])\n    return image\n\ndef read_tfrecord(example):\n    tfrecord_format = {\n        'image':      tf.io.FixedLenFeature([], tf.string)\n    }\n    example = tf.io.parse_single_example(example, tfrecord_format)\n    image = decode_image(example['image'])\n    return image\n\ndef load_dataset(filenames):\n    dataset = tf.data.TFRecordDataset(filenames)\n    dataset = dataset.map(read_tfrecord, num_parallel_calls=AUTO)\n    return dataset\n\ndef get_dataset(filenames, augment=None, repeat=True, shuffle=True, batch_size=1):\n    dataset = load_dataset(filenames)\n\n    if augment:\n        dataset = dataset.map(augment, num_parallel_calls=AUTO)\n    dataset = dataset.map(normalize_img, num_parallel_calls=AUTO)\n    if repeat:\n        dataset = dataset.repeat()\n    if shuffle:\n        dataset = dataset.shuffle(512)\n        \n    dataset = dataset.batch(batch_size)\n    dataset = dataset.cache()\n    dataset = dataset.prefetch(AUTO)\n    \n    return dataset\n\ndef display_samples(ds, n_samples):\n    ds_iter = iter(ds)\n    for n_sample in range(n_samples):\n        example_sample = next(ds_iter)\n        plt.subplot(121)\n        plt.imshow(example_sample[0] * 0.5 + 0.5)\n        plt.axis('off')\n        plt.show()\n        \ndef display_generated_samples(ds, model, n_samples):\n    ds_iter = iter(ds)\n    for n_sample in range(n_samples):\n        example_sample = next(ds_iter)\n        generated_sample = model.predict(example_sample)\n        \n        f = plt.figure(figsize=(12, 12))\n        \n        plt.subplot(121)\n        plt.title('Input image')\n        plt.imshow(example_sample[0] * 0.5 + 0.5)\n        plt.axis('off')\n        \n        plt.subplot(122)\n        plt.title('Generated image')\n        plt.imshow(generated_sample[0] * 0.5 + 0.5)\n        plt.axis('off')\n        plt.show()\n        \ndef evaluate_cycle(ds, generator_a, generator_b, n_samples=1):\n    fig, axes = plt.subplots(n_samples, 3, figsize=(22, (n_samples*6)))\n    axes = axes.flatten()\n    \n    ds_iter = iter(ds)\n    for n_sample in range(n_samples):\n        idx = n_sample*3\n        example_sample = next(ds_iter)\n        generated_a_sample = generator_a.predict(example_sample)\n        generated_b_sample = generator_b.predict(generated_a_sample)\n        \n        axes[idx].set_title('Input image', fontsize=18)\n        axes[idx].imshow(example_sample[0] * 0.5 + 0.5)\n        axes[idx].axis('off')\n        \n        axes[idx+1].set_title('Generated image', fontsize=18)\n        axes[idx+1].imshow(generated_a_sample[0] * 0.5 + 0.5)\n        axes[idx+1].axis('off')\n        \n        axes[idx+2].set_title('Cycled image', fontsize=18)\n        axes[idx+2].imshow(generated_b_sample[0] * 0.5 + 0.5)\n        axes[idx+2].axis('off')\n        \n    plt.show()\n\ndef create_gif(images_path, gif_path):\n    images = []\n    filenames = glob.glob(images_path)\n    filenames.sort(key=lambda x: int(''.join(filter(str.isdigit, x))))\n    for epoch, filename in enumerate(filenames):\n        img = PIL.ImageDraw.Image.open(filename)\n        ImageDraw.Draw(img).text((0, 0),  # Coordinates\n                                 f'Epoch {epoch+1}')\n        images.append(img)\n    imageio.mimsave(gif_path, images, fps=2) # Save gif\n        \ndef predict_and_save(input_ds, generator_model, output_path):\n    i = 1\n    for img in input_ds:\n        prediction = generator_model(img, training=False)[0].numpy() # make predition\n        prediction = (prediction * 127.5 + 127.5).astype(np.uint8)   # re-scale\n        im = PIL.Image.fromarray(prediction)\n        im.save(f'{output_path}{str(i)}.jpg')\n        i += 1","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:20:27.130594Z","iopub.execute_input":"2023-06-11T19:20:27.130970Z","iopub.status.idle":"2023-06-11T19:20:27.159922Z","shell.execute_reply.started":"2023-06-11T19:20:27.130941Z","shell.execute_reply":"2023-06-11T19:20:27.158582Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Auxiliar functions for model:\n\nHere we the building blocks of our models:\n\n- Encoder block: Apply convolutional filters while also reducing data resolution and increasing features (increasing the depth or number of channels in a layer by using multiple convolutional filters in parallel where each filter or layer extracts a different set of features from the input data, and by increasing the number of filters or layers, more diverse and complex features can be captured).\n\n- Transformer block: Apply convolutional filters to find relevant data patterns and keeps features constant.\n\n- Decoder block: Apply convolutional filters while also increasing data resolution and decreasing features (decreasing features can help in reducing the number of parameters in the model, which can lead to faster training and inference times and lower memory requirements by applying dimensionality reduction methods such as pooling).","metadata":{}},{"cell_type":"code","source":"conv_initializer = tf.random_normal_initializer(mean=0.0, stddev=0.02)\ngamma_initializer = tf.keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n    \ndef encoder_block(input_layer, filters, size=3, strides=2, apply_instancenorm=True, activation=L.ReLU(), name='block_x'):\n    block = L.Conv2D(filters, size, \n                     strides=strides, \n                     padding='same', \n                     use_bias=False, \n                     kernel_initializer=conv_initializer, \n                     name=f'encoder_{name}')(input_layer)\n\n    if apply_instancenorm:\n        block = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(block)\n        \n    block = activation(block)\n\n    return block\n\ndef transformer_block(input_layer, size=3, strides=1, name='block_x'):\n    filters = input_layer.shape[-1]\n    \n    block = L.Conv2D(filters, size, strides=strides, padding='same', use_bias=False, \n                     kernel_initializer=conv_initializer, name=f'transformer_{name}_1')(input_layer)\n#     block = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(block)\n    block = L.ReLU()(block)\n    \n    block = L.Conv2D(filters, size, strides=strides, padding='same', use_bias=False, \n                     kernel_initializer=conv_initializer, name=f'transformer_{name}_2')(block)\n#     block = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(block)\n    \n    block = L.Add()([block, input_layer])\n\n    return block\n\ndef decoder_block(input_layer, filters, size=3, strides=2, apply_instancenorm=True, name='block_x'):\n    block = L.Conv2DTranspose(filters, size, \n                              strides=strides, \n                              padding='same', \n                              use_bias=False, \n                              kernel_initializer=conv_initializer, \n                              name=f'decoder_{name}')(input_layer)\n\n    if apply_instancenorm:\n        block = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(block)\n\n    block = L.ReLU()(block)\n    \n    return block\n\n# Resized convolution\ndef decoder_rc_block(input_layer, filters, size=3, strides=1, apply_instancenorm=True, name='block_x'):\n    block = tf.image.resize(images=input_layer, method='bilinear', \n                            size=(input_layer.shape[1]*2, input_layer.shape[2]*2))\n    \n#     block = tf.pad(block, [[0, 0], [1, 1], [1, 1], [0, 0]], \"SYMMETRIC\") # Works only with GPU\n#     block = L.Conv2D(filters, size, strides=strides, padding='valid', use_bias=False, # Works only with GPU\n    block = L.Conv2D(filters, size, \n                     strides=strides, \n                     padding='same', \n                     use_bias=False, \n                     kernel_initializer=conv_initializer, \n                     name=f'decoder_{name}')(block)\n\n    if apply_instancenorm:\n        block = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(block)\n\n    block = L.ReLU()(block)\n    \n    return block","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:20:48.479460Z","iopub.execute_input":"2023-06-11T19:20:48.479827Z","iopub.status.idle":"2023-06-11T19:20:48.504593Z","shell.execute_reply.started":"2023-06-11T19:20:48.479801Z","shell.execute_reply":"2023-06-11T19:20:48.503741Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"GCS_PATH = KaggleDatasets().get_gcs_path('gan-getting-started')\n\nMONET_FILENAMES = tf.io.gfile.glob(str(GCS_PATH + '/monet_tfrec/monet*.tfrec'))\nPHOTO_FILENAMES = tf.io.gfile.glob(str(GCS_PATH + '/photo_tfrec/photo*.tfrec'))\n\ndef count_data_items(filenames):\n    n = [int(re.compile(r\"-([0-9]*)\\.\").search(filename).group(1)) for filename in filenames]\n    return np.sum(n)\n\nn_monet_samples = count_data_items(MONET_FILENAMES)\nn_photo_samples = count_data_items(PHOTO_FILENAMES)\n\nprint(f'Monet TFRecord files: {len(MONET_FILENAMES)}')\nprint(f'Monet image files: {n_monet_samples}')\nprint(f'Photo TFRecord files: {len(PHOTO_FILENAMES)}')\nprint(f'Photo image files: {n_photo_samples}')","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:21:09.575554Z","iopub.execute_input":"2023-06-11T19:21:09.575958Z","iopub.status.idle":"2023-06-11T19:21:12.112265Z","shell.execute_reply.started":"2023-06-11T19:21:09.575926Z","shell.execute_reply":"2023-06-11T19:21:12.111109Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Feature Engineering\nAs there are only a limited amount of training data, namely paintings made by Claude Monet, we need to find a way to create more training samples that would be similar than the paintings which some little tweaks here and there. For this we will be using Differentiable Augmentation (DiffAugment) which provides a method by imposing various types of differentiable augmentations on the real and generated images (research paper: Shengyu Zhao, Zhijian Liu, Ji Lin, Jun-Yan Zhu and Song Han, (2020), \"Differentiable Augmentation for Data-Efficient GAN Training, arXiv:2006.10738v4). \n- Source: https://arxiv.org/pdf/2006.10738v4.pdf\n\nThe benefits of using DiffAugment is that the distributions of the images won't be affected so much as they would by just directly manipulating them with data augmentation that would influence the style in for example by changing brightness, contrast of saturation. On the other hand, if we would change only the sizes, or flipping and turning the images, we still wouldn't get enough knowledge on the specific style we would like to reproduce and hence wouldn't lead to a very good generalization. Thus, I've taken the premade functions that adjust the colors through brightness, saturation and contrast with some minor changes, and translation and cutout as they were.","metadata":{}},{"cell_type":"code","source":"# Feature Engineering with DiffAugment\n\nwith strategy.scope():\n\n    def DiffAugment(x, policy='', channels_first=False):\n        \"\"\"Differentiable Augmentation for Data-Efficient GAN Training.\n        \n        https://github.com/mit-han-lab/data-efficient-gans/tree/master/DiffAugment-stylegan2\n        \"\"\"\n        \"\"\"\n        Sources: \n        - https://paperswithcode.com/paper/differentiable-augmentation-for-data\n        - https://github.com/mit-han-lab/data-efficient-gans\n        - https://arxiv.org/pdf/2006.10738v4.pdf\n        \"\"\"\n        if policy:\n            if channels_first:\n                x = tf.transpose(x, [0, 2, 3, 1])\n            for p in policy.split(','):\n                for f in AUGMENT_FNS[p]:\n                    x = f(x)\n            if channels_first:\n                x = tf.transpose(x, [0, 3, 1, 2])\n        return x\n\n\n    def rand_brightness(x):\n        magnitude = tf.random.uniform([tf.shape(x)[0], 1, 1, 1]) - 0.5\n        x = x + magnitude\n        return x\n\n\n    def rand_saturation(x):\n        magnitude = tf.random.uniform([tf.shape(x)[0], 1, 1, 1]) * 2\n        x_mean = tf.reduce_sum(x, axis=3, keepdims=True) \n        x = (x - x_mean) * magnitude + x_mean\n        return x\n\n\n    def rand_contrast(x):\n        magnitude = tf.random.uniform([tf.shape(x)[0], 1, 1, 1]) + 0.5\n        x_mean = tf.reduce_mean(x, axis=[1, 2, 3], keepdims=True) \n        x = (x - x_mean) * magnitude + x_mean\n        return x\n\n    def rand_translation(x, ratio=0.125):\n        batch_size = tf.shape(x)[0]\n        image_size = tf.shape(x)[1:3]\n        shift = tf.cast(tf.cast(image_size, tf.float32) * ratio + 0.5, tf.int32)\n        translation_x = tf.random.uniform([batch_size, 1], -shift[0], shift[0] + 1, dtype=tf.int32)\n        translation_y = tf.random.uniform([batch_size, 1], -shift[1], shift[1] + 1, dtype=tf.int32)\n        grid_x = tf.clip_by_value(tf.expand_dims(tf.range(image_size[0], dtype=tf.int32), 0) + translation_x + 1, 0, image_size[0] + 1)\n        grid_y = tf.clip_by_value(tf.expand_dims(tf.range(image_size[1], dtype=tf.int32), 0) + translation_y + 1, 0, image_size[1] + 1)\n        x = tf.gather_nd(tf.pad(x, [[0, 0], [1, 1], [0, 0], [0, 0]]), tf.expand_dims(grid_x, -1), batch_dims=1)\n        x = tf.transpose(tf.gather_nd(tf.pad(tf.transpose(x, [0, 2, 1, 3]), [[0, 0], [1, 1], [0, 0], [0, 0]]), tf.expand_dims(grid_y, -1), batch_dims=1), [0, 2, 1, 3])\n        return x\n\n\n    def rand_cutout(x, ratio=0.5):\n        batch_size = tf.shape(x)[0]\n        image_size = tf.shape(x)[1:3]\n        cutout_size = tf.cast(tf.cast(image_size, tf.float32) * ratio + 0.5, tf.int32)\n        offset_x = tf.random.uniform([tf.shape(x)[0], 1, 1], maxval=image_size[0] + (1 - cutout_size[0] % 2), dtype=tf.int32)\n        offset_y = tf.random.uniform([tf.shape(x)[0], 1, 1], maxval=image_size[1] + (1 - cutout_size[1] % 2), dtype=tf.int32)\n        grid_batch, grid_x, grid_y = tf.meshgrid(tf.range(batch_size, dtype=tf.int32), tf.range(cutout_size[0], dtype=tf.int32), tf.range(cutout_size[1], dtype=tf.int32), indexing='ij')\n        cutout_grid = tf.stack([grid_batch, grid_x + offset_x - cutout_size[0] // 2, grid_y + offset_y - cutout_size[1] // 2], axis=-1)\n        mask_shape = tf.stack([batch_size, image_size[0], image_size[1]])\n        cutout_grid = tf.maximum(cutout_grid, 0)\n        cutout_grid = tf.minimum(cutout_grid, tf.reshape(mask_shape - 1, [1, 1, 1, 3]))\n        mask = tf.maximum(1 - tf.scatter_nd(cutout_grid, tf.ones([batch_size, cutout_size[0], cutout_size[1]], dtype=tf.float32), mask_shape), 0)\n        x = x * tf.expand_dims(mask, axis=3)\n        return x\n\n\n    AUGMENT_FNS = {\n        'color': [rand_brightness, rand_saturation, rand_contrast], # selecting color enhancements\n        'translation': [rand_translation],                          # selecting translation\n        'cutout': [rand_cutout]}                                    # selecting cutout\n    \n    def aug_fn(image):\n        \"\"\"Function that loads DiffAugment with the desired feature settings.\n        \"\"\"\n        return DiffAugment(image,\"color,translation,cutout\")","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:21:43.868964Z","iopub.execute_input":"2023-06-11T19:21:43.869430Z","iopub.status.idle":"2023-06-11T19:21:43.897165Z","shell.execute_reply.started":"2023-06-11T19:21:43.869394Z","shell.execute_reply":"2023-06-11T19:21:43.896389Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Building the Generator\n\nWe are now ready to start building the actual model and for this we will first build the generators that use an encoder to reduce the dimensionality of the image which will help to better extract the features of the images, and then, a decoder that will increase the dimensionality of the image back to where it was in the first place.\n\nThe main structure of the generator consists of convolutional layers with a stride which have an instance normalization layer placed on top which normalizes all features of each channel to zero mean and unit variance. This provides a more stable solution compared to batch normalization for example.\n\nThe strive, the length of the step that the filter takes, and the size of the filters are the main adjustable components of the convolutional layers that learn the features from the images. A stride of 2 for example, that we will be using, reduces or increases the height and width by two making the image either smaller or bigger. To make sure that we stay with the same length and height in the images we use same padding which makes sure a certain number of zeros is always added before passing to the next layer. The size of the filters will all be set to (4 by 4). The decoder will also include some dropout layers in the beginning and the layers will be concatenated together to enable skip connections that will help to adjust for possible overfitting issues and to deal with the vanishing gradient problem. In total there will be 24 different layers with over 54 million parameters.\n\n![generator_architecture.png](attachment:29e7847b-8088-4fe4-a306-f2e81e863a6e.png)","metadata":{},"attachments":{"29e7847b-8088-4fe4-a306-f2e81e863a6e.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"#### Encoder block that creates a neural network layer to downsize an input image (defines a layer that can be used in a larger neural network for tasks such as image segmentation, object detection, or image generation)\n\n#### Transformer block: Apply convolutional filters to find relevant data patterns and keeps features constant.\n\n#### Decoder block returns a sequential model that upsizes the sample images using transposed convolution layers (Conv2DTranspose) with a stride of 2 and same padding to control for the height and width of the output. It also uses instance normalization (InstanceNormalization) where the weights are initialized from a normal distribution.\n\n##### Note:\n- the decoder function performs the inverse operation of the encoder function, which downsized the images. It takes in the encoded images and upsamples them back to their original size.\n\n\n- The downsizing is performed by a convolutional layer that reduces the height and width of the input image by a factor of 2 (stride=2). The size of the convolutional filter and the number of output channels are specified by the \"size\" and \"filters\" arguments, respectively.\n\n- The function also applies Instance Normalization to the output of the convolutional layer, which helps to improve the stability and convergence of the model during training. The Instance Normalization layer is added conditionally based on the value of the \"apply_instancenorm\" argument. If this argument is True (which is the default), the Instance Normalization layer is added; otherwise, it is skipped.\n\n- The output of the Instance Normalization layer is passed through a LeakyReLU activation function, which allows for the learning of more complex, non-linear mappings between the input and output.\n\n##### Note:\n- LeakyReLU (Leaky Rectified Linear Unit) avoid the \"dying ReLU\" problem. The \"dying ReLU\" problem occurs when the input to a ReLU function becomes negative, and the function outputs 0, effectively \"killing\" the gradient and preventing further learning.\n\n","metadata":{}},{"cell_type":"code","source":"def generator_fn(height=HEIGHT, width=WIDTH, channels=CHANNELS, transformer_blocks=TRANSFORMER_BLOCKS):\n    OUTPUT_CHANNELS = 3\n    inputs = L.Input(shape=[height, width, channels], name='input_image')\n\n    # Encoder\n    enc_1 = encoder_block(inputs, 64,  7, 1, apply_instancenorm=False, activation=L.ReLU(), name='block_1') # (bs, 256, 256, 64)\n    enc_2 = encoder_block(enc_1, 128, 3, 2, apply_instancenorm=True, activation=L.ReLU(), name='block_2')   # (bs, 128, 128, 128)\n    enc_3 = encoder_block(enc_2, 256, 3, 2, apply_instancenorm=True, activation=L.ReLU(), name='block_3')   # (bs, 64, 64, 256)\n    \n    # Transformer\n    x = enc_3\n    for n in range(transformer_blocks):\n        x = transformer_block(x, 3, 1, name=f'block_{n+1}') # (bs, 64, 64, 256)\n\n    # Decoder\n    x_skip = L.Concatenate(name='enc_dec_skip_1')([x, enc_3]) # encoder - decoder skip connection\n    \n    dec_1 = decoder_block(x_skip, 128, 3, 2, apply_instancenorm=True, name='block_1') # (bs, 128, 128, 128)\n    x_skip = L.Concatenate(name='enc_dec_skip_2')([dec_1, enc_2]) # encoder - decoder skip connection\n    \n    dec_2 = decoder_block(x_skip, 64,  3, 2, apply_instancenorm=True, name='block_2') # (bs, 256, 256, 64)\n    x_skip = L.Concatenate(name='enc_dec_skip_3')([dec_2, enc_1]) # encoder - decoder skip connection\n\n    outputs = last = L.Conv2D(OUTPUT_CHANNELS, 7, \n                              strides=1, padding='same', \n                              kernel_initializer=conv_initializer, \n                              use_bias=False, \n                              activation='tanh', \n                              name='decoder_output_block')(x_skip) # (bs, 256, 256, 3)\n\n    generator = Model(inputs, outputs)\n    \n    return generator\n\nsample_generator = generator_fn()\nsample_generator.summary()","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:21:49.042114Z","iopub.execute_input":"2023-06-11T19:21:49.042501Z","iopub.status.idle":"2023-06-11T19:21:50.485940Z","shell.execute_reply.started":"2023-06-11T19:21:49.042473Z","shell.execute_reply":"2023-06-11T19:21:50.485117Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Building the Discriminator\n\nThe dicriminator needs to distinguish a real painting from a generated painting, and on the other hand, a real image from a generated image. Added to the mix and what makes this more complicated is that we will have a cycle where one generated image from a generator will be given to be evaluated to a Discriminator, but also as an input to the other generator. Normally, the discriminator acts in a deep Convolutional Neural Network (CNN) performing image classification. However, usually these models are trained with thousands of even millions of images which we don't have so we need to create some adjustments in order to avoid overfitting.\n\nIn the original research paper, there were two discriminators with the same objective function to minimize Mean Squared Error (MSE). However, we will try to improve this model by creating separate function that can handle two different objectives for the Painting Discriminator to minimize, as we want to focus on creating paintings in the style of Claude Monet rather than photographic images from the paintings, and then we will have a separate Discriminator with one objective to distinguish the photographs. Here we want the focus to be on learning the style of painting through the use of brush strokes and colors, rather than learning to generate a photographic image from a painting. The competitive objectives for the Painting Discriminator will hopefully push the Generator in better results. We will then use InstanceNormalization to standardize each output feature map separetaly rather than across the whole batch that was also used in the research paper.\n\n![discriminator_architecture.png](attachment:6e1f604a-f21f-4a9a-9dd4-bbca5e527816.png)","metadata":{},"attachments":{"6e1f604a-f21f-4a9a-9dd4-bbca5e527816.png":{"image/png":"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"}}},{"cell_type":"code","source":"def discriminator_fn(height=HEIGHT, width=WIDTH, channels=CHANNELS):\n    inputs = L.Input(shape=[height, width, channels], name='input_image')\n    #inputs_patch = L.experimental.preprocessing.RandomCrop(height=70, width=70, name='input_image_patch')(inputs) # Works only with GPU\n\n    # Encoder    \n    x = encoder_block(inputs, 64,  4, 2, apply_instancenorm=False, activation=L.LeakyReLU(0.2), name='block_1') # (bs, 128, 128, 64)\n    x = encoder_block(x, 128, 4, 2, apply_instancenorm=True, activation=L.LeakyReLU(0.2), name='block_2')       # (bs, 64, 64, 128)\n    x = encoder_block(x, 256, 4, 2, apply_instancenorm=True, activation=L.LeakyReLU(0.2), name='block_3')       # (bs, 32, 32, 256)\n    x = encoder_block(x, 512, 4, 1, apply_instancenorm=True, activation=L.LeakyReLU(0.2), name='block_4')       # (bs, 32, 32, 512)\n\n    outputs = L.Conv2D(1, 4, strides=1, padding='valid', kernel_initializer=conv_initializer)(x)                # (bs, 29, 29, 1)\n    \n    discriminator = Model(inputs, outputs)\n    \n    return discriminator\n\n\nsample_discriminator = discriminator_fn()\nsample_discriminator.summary()","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:22:17.165975Z","iopub.execute_input":"2023-06-11T19:22:17.166398Z","iopub.status.idle":"2023-06-11T19:22:17.429177Z","shell.execute_reply.started":"2023-06-11T19:22:17.166365Z","shell.execute_reply":"2023-06-11T19:22:17.427838Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Build model (CycleGAN)\n\nGAN models never converge completely, but instead try to find an equilibrium between the generators and discriminators.","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n    monet_generator = generator_fn(height=None, width=None, transformer_blocks=TRANSFORMER_BLOCKS) # transforms photos to Monet-esque paintings\n    photo_generator = generator_fn(height=None, width=None, transformer_blocks=TRANSFORMER_BLOCKS) # transforms Monet paintings to be more like photos\n\n    monet_discriminator = discriminator_fn(height=None, width=None) # differentiates real Monet paintings and generated Monet paintings\n    photo_discriminator = discriminator_fn(height=None, width=None) # differentiates real photos and generated photos\n\n\nclass CycleGan(Model):\n    def __init__(\n        self,\n        monet_generator,\n        photo_generator,\n        monet_discriminator,\n        photo_discriminator,\n        lambda_cycle=10,\n    ):\n        super(CycleGan, self).__init__()\n        self.m_gen = monet_generator\n        self.p_gen = photo_generator\n        self.m_disc = monet_discriminator\n        self.p_disc = photo_discriminator\n        self.lambda_cycle = lambda_cycle\n        \n    def compile(\n        self,\n        m_gen_optimizer,\n        p_gen_optimizer,\n        m_disc_optimizer,\n        p_disc_optimizer,\n        gen_loss_fn,\n        disc_loss_fn,\n        cycle_loss_fn,\n        identity_loss_fn\n    ):\n        super(CycleGan, self).compile()\n        self.m_gen_optimizer = m_gen_optimizer\n        self.p_gen_optimizer = p_gen_optimizer\n        self.m_disc_optimizer = m_disc_optimizer\n        self.p_disc_optimizer = p_disc_optimizer\n        self.gen_loss_fn = gen_loss_fn\n        self.disc_loss_fn = disc_loss_fn\n        self.cycle_loss_fn = cycle_loss_fn\n        self.identity_loss_fn = identity_loss_fn\n        \n    def train_step(self, batch_data):\n        real_monet, real_photo = batch_data\n        \n        with tf.GradientTape(persistent=True) as tape:\n            # photo to monet back to photo\n            fake_monet = self.m_gen(real_photo, training=True)\n            cycled_photo = self.p_gen(fake_monet, training=True)\n\n            # monet to photo back to monet\n            fake_photo = self.p_gen(real_monet, training=True)\n            cycled_monet = self.m_gen(fake_photo, training=True)\n\n            # generating itself\n            same_monet = self.m_gen(real_monet, training=True)\n            same_photo = self.p_gen(real_photo, training=True)\n\n            # discriminator used to check, inputing real images\n            disc_real_monet = self.m_disc(real_monet, training=True)\n            disc_real_photo = self.p_disc(real_photo, training=True)\n\n            # discriminator used to check, inputing fake images\n            disc_fake_monet = self.m_disc(fake_monet, training=True)\n            disc_fake_photo = self.p_disc(fake_photo, training=True)\n\n            # evaluates generator loss\n            monet_gen_loss = self.gen_loss_fn(disc_fake_monet)\n            photo_gen_loss = self.gen_loss_fn(disc_fake_photo)\n\n            # evaluates total cycle consistency loss\n            total_cycle_loss = self.cycle_loss_fn(real_monet, cycled_monet, self.lambda_cycle) + self.cycle_loss_fn(real_photo, cycled_photo, self.lambda_cycle)\n\n            # evaluates total generator loss\n            total_monet_gen_loss = monet_gen_loss + total_cycle_loss + self.identity_loss_fn(real_monet, same_monet, self.lambda_cycle)\n            total_photo_gen_loss = photo_gen_loss + total_cycle_loss + self.identity_loss_fn(real_photo, same_photo, self.lambda_cycle)\n\n            # evaluates discriminator loss\n            monet_disc_loss = self.disc_loss_fn(disc_real_monet, disc_fake_monet)\n            photo_disc_loss = self.disc_loss_fn(disc_real_photo, disc_fake_photo)\n\n        # Calculate the gradients for generator and discriminator\n        monet_generator_gradients = tape.gradient(total_monet_gen_loss,\n                                                  self.m_gen.trainable_variables)\n        photo_generator_gradients = tape.gradient(total_photo_gen_loss,\n                                                  self.p_gen.trainable_variables)\n\n        monet_discriminator_gradients = tape.gradient(monet_disc_loss,\n                                                      self.m_disc.trainable_variables)\n        photo_discriminator_gradients = tape.gradient(photo_disc_loss,\n                                                      self.p_disc.trainable_variables)\n\n        # Apply the gradients to the optimizer\n        self.m_gen_optimizer.apply_gradients(zip(monet_generator_gradients,\n                                                 self.m_gen.trainable_variables))\n\n        self.p_gen_optimizer.apply_gradients(zip(photo_generator_gradients,\n                                                 self.p_gen.trainable_variables))\n\n        self.m_disc_optimizer.apply_gradients(zip(monet_discriminator_gradients,\n                                                  self.m_disc.trainable_variables))\n\n        self.p_disc_optimizer.apply_gradients(zip(photo_discriminator_gradients,\n                                                  self.p_disc.trainable_variables))\n        \n        return {'monet_gen_loss': total_monet_gen_loss,\n                'photo_gen_loss': total_photo_gen_loss,\n                'monet_disc_loss': monet_disc_loss,\n                'photo_disc_loss': photo_disc_loss\n               }","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:22:40.513259Z","iopub.execute_input":"2023-06-11T19:22:40.513640Z","iopub.status.idle":"2023-06-11T19:22:41.901824Z","shell.execute_reply.started":"2023-06-11T19:22:40.513613Z","shell.execute_reply":"2023-06-11T19:22:41.900723Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Learning through the Loss Functions\n\nThe CycleGAN model aims to reproduce the distribution of a target dataset via two generators $G_x$ and $G_y$, and two discriminators $D_x$ and $D_y$. The discriminators are trained through the real and generated images, whereas the generators are trained through the discriminators. The generators minimize the loss that is computed through the idea of an adversarial loss that forces the generated images to be indistinguishable from real photos, or as in our case from real paintings. This adversarial loss is also captured through the cycles that aim for a result where the starting photographic image should be as similar as possible to the ending image that has been first transformed into a painting and then back again as a photographic image. The generated images from the first generator is received as input for the second one, and this loss is minimized through the cycle-consistency loss. On top of this we will also have loss that constitutes when a generator fabricates an image or painting that is actually the same as the original image or painting. This is called the identity loss.\n\nWe will thus have different kinds of loss functions. First, we need to encounter for the loss that happens when we pass real images through the generators and get back generated images. For this task, we will create two separate loss functions for the generator that creates paintings, namely Binary Cross-Entropy (BCE) and Mean Squared Error (MSE). The idea is that having two competing objectives will hopefully force learning that doesn't overfit easily and also deliver better end results. Then we need to calculate the loss that happens when we pass fake or generated images to the generators and get back an image that is as close as possible to the original, the real image. This is the (forward and backward) cycle-consistency loss that compares the final image to the starting image, and then we have the identiy loss that checks that the generator doesn't fabricate the same image. For these losses we will be using the Mean Absulute Error (MAE) together with weighting - lambda - factor. The general idea will be to compare a matrix made of ones when we have a real painting to a matrix of zeros when the painting has been refabricated, and of course anything in between, in order to eventually reach as close as possible to a real painting.\n\nThe image below shows this visually and a more detailed explanation can be found from the actual research paper: Jun-Yan Zhu, Taeun Park, Phillip Isola and Alexei A. Efros, (2020), \"Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks\", arXiv:1703:10593).\n- Source: https://arxiv.org/pdf/1703.10593.pdf\n\n![imag3.png](attachment:5dd9aaba-b2c4-4294-88f9-27a30e2986e9.png)","metadata":{},"attachments":{"5dd9aaba-b2c4-4294-88f9-27a30e2986e9.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAA10AAAFeCAYAAAB+cHXYAAAgAElEQVR4XuxdCXwN1xf+tIgiCEKVWGrf16gltQSxSyy10/qjFUvsoVESVEpqqSX2fd+J2jWxFFEEiaVRe2KLILbglbb/OZNMZH/zlnmZ9965v9/7PfLu3Hvud+7M3O+ec8/J9J9QwIURYAQYAUaAEWAEGAFGgBFgBBgBRkARBDIx6VIEV26UEWAEGAFGgBFgBBgBRoARYAQYAREBJl08ERgBRoARYAQYAUaAEWAEGAFGgBFQEAEmXQqCy00zAowAI8AIMAKMACPACDACjAAjwKSL5wAjwAgwAowAI8AIMAKMACPACDACCiLApEtBcLlpRoARYAQYAUaAEWAEGAFGgBFgBJh08RxgBBgBRoARYAQYAUaAEWAEGAFGQEEEmHQpCC43zQgwAowAI8AIMAKMACPACDACjACTLp4DjAAjwAgwAowAI8AIMAKMACPACCiIAJMuBcHlphkBRoARYAQYAUaAEWAEGAFGgBFg0sVzgBFgBBgBRoARYAQYAUaAEWAEGAEFEWDSpSC43DQjwAgwAowAI8AIMAKMACPACDACTLp4DjACjAAjwAgwAowAI8AIMAKMACOgIAJMuhQEl5tmBBgBRoARYAQYAUaAEWAEGAFGgEkXzwFGgBFgBBgBRoARYAQYAUaAEWAEFESASZeC4HLTjAAjwAgwAowAI8AIMAKMACPACDDp4jnACDACjAAjwAgwAowAI8AIMAKMgIIIMOlSEFxumhFgBBgBRoARYAQYAUaAEWAEGAEmXTwHGAELQMDdYxSmT52EHNmzW8BoeAiMACNgDQjEvn6NUWMnYMGc6dYwXB4jI8AIWDkCTLqsfALw8C0DgT37DsKxVg0UsM9vGQPiUZgUgdePbuHe8/dp9JkNeT7Ng5zZbPFJFpOKxZ1ZOAJEuvbsPYjOndwsfKQ8PGUQeIenkbfx5G1aj648+NQuF7LntMHHygjArTICOiHApEsnuLgyI8AIMAKWhoAGMTfO4eT5Q5j7P28ceFkSX/tPRZsCH8b5KHgOfP3PIe+gLdjr2xJFbCwNAx4PI8AImB8CsbgdfARnz67DCI8NiLRvD7/53VFCGsirmwiYOQlbnjbCpI3L4OlU0PyGyBJbFAJMuixKnTwYa0XAe/JUeI70YPdCa50Axhh3zFq45u2FXQ5eCI6YgjrJ2ow9NxH1a/rgfq+duLjaFbx8MQbo1t0GWbr8ZszBxPFjrRsIHr1BCGi2dUW2TptgNyQQT+c4J2srCgG9K8NtczFMO30cnlV4x8ggsPligxBg0mUQfHwxI6AOBGjh8k3v7uxeqA51mKUUmoDeyO22BhBI1XOBVKVcmsRgY4dC6LajCLzPXodPTbMcJgutIgSYdKlIGWYsSpBHXjSZ+1p4dD3HatdUSNVNfziVHIyz7TfgwfausDPjsbLo5o0Aky7z1h9LzwgwAoyAURCIW7jEoN2apwjomfqy5LJfNVQaE4paM8NxZnhZo/TLjTACjAAjoD8CYfCtVBXjLjfGwoggfOeQWkt70S9bayzT9MLO/1bDVf/O+EpGwCAEmHQZBB9fzAioA4HNW3eidSsXdi9UhzrMUIrL8KtWCWNCa2Fm+Bmkxack0pW6G48ZDptFznAEVqxejz6ClZ4LI6AXApGL4Fx0AA5XnILQS16okmojEumqimmXLsCzol498UWMgMEIMOkyGEJugBHIeAQoZDydi+DohRmvC7OUQFq4pHGeSxrT3n7Z0HqZBhWnhOKSV+rLG7McPwudIQiQe+HAIaOwatn8DOmfOzV/BCS36OypnueKH590XhXpWcPMHwsegfoRYNKlfh2xhIyALARoAcN5umRBxZWSIZBwnqvvHrxd2ioNfCRrGOJcENu/R8STN4nqfoJ8Re2RQ/qLJgb3ol7iH/H/H+OzIoWR+SOGnhFIigA/t3hGGIKA5BbdZetbbOyYRpCMIA/kbTIXMck2lTQx9xD1Mu4JJZZP8qGovfAES/LsAgoXccDHH2UyREy+lhEQEWDSxROBEbAABE6fPYfaQp4uLoyAPgjIOc+F+MPoJ2zaY8OD7eiaNRoRf23AN3WH4nDWTlh5ej46lUtEumJvYG67Upic2RvLp/ZHi6pMuvTRjaVfw88uS9ewkuOTNoLSt2CdGlcUdX0jU0Q3JNJ164Qv2rSdjxt1fsKZXUNQK550HRhVHq6HGmLS9LEY2aoaky4l1WhFbTPpsiJl81AtFwF2L7Rc3So/MnkLF+k8l73gxhMphGWO21PW4NS4isKC5incDz7A/GYfdpqjAvrhq8Au2DKnGYeXV16JZtkDuxeapdrUI7Sc81waIUx86S/xc2Ra57misNa1GHodqIeFV4RAHJ8DUcfHoe+88pi1qidKc4R59ejbAiRh0mUBSuQhMAKXr4SjePGi7F7IU0F3BOSc54rahq7lO2FTZiH610Uh+lfiJF1SOObGC3El6DsIaxYQ4Wr9a1vsWcr5vHRXiPVcQaTr9u0IVKxQznoGzSM1GgJyznNFrXVFsV67UE44h/qHcA41NQ6lOTUOFev64oWwoXSucyAGMOEymo64oaQIMOniGcEIWAACfC7CApSYQUNIP7EoCRWfXHR7acw8GYThKZKLxgjJR0vCbU1eMX+X+10mXBmkSrPslp9dZqk2VQit7TyXJswPTrXH4E7Dhfht13dIOy+yZO3KjBJuC3GALVyq0K8lCsGkyxK1ymOyOgTYvdDqVG60Aad3nktz9yhm9/0KEy47Y+nhVeiZlq9NiA9K1ZqIpzXroFK1UVjv3xFF2C3HaDqy1IbYvdBSNWuKcaXnFq3B3aM/oUvrqbjTdR1OyXge3V3fHhV67ES2JO7TphgH92FNCDDpsiZt81gtFoE9+w7CUQikwSHjLVbFRh7YW5zcuhv3Hx3D1B/mIiTGAd3mzESHQvHdvLqJkzs2Y20w0Nx7Bn7q11ALiYpPUJpZyJXzh5ArhwmXkfVlmc0R6dqz9yA6d3KzzAHyqIyPwN8xOLArEA8uLYHnxIOIRn14bhkGx4RH1yGsWboHV/M1xvdTf0K/hkVSdSlMLFjUIQ98tak6OkW7Y2iis13GF55btHYEmHRZ+wzg8TMCjIDxEIgNR9CqDZi9ZgP+fJIP5RsVwMuT95G793TMHdoQ9ldnwbnncxwO80FW4/WqR0v/IDriHhIHfE/eyMe2BVHYTiZ7is+Dc4Pzd+mhC76EEWAEZCPwz9+4d+9hfCqK1K76GLYFC0PuoyuOcDWMs85firfYux/Eg/nNtJI12TIrVDE2fDf8Z83C6sORyOpQCw6aMNzP2RGTlnqhZZZj8Gi4DMMvbkSJLAoJwM3qjACTLp0h4wsYAfUh4D15KjxHenAgjQxTTSzO+XdBu5FHkLfPcqz3dUWlhLe+4OqyrT8azHyJ0td24kzXQDwVov9ZVNnbD9lab8e3gU9haUOzKD2pbDBk6fKbMUdM7M6FETA1AnGEqwm2JAT8icFGwdzfbUctzLtxHIMoKpAai7C5t6JvU7jvzos+yzdjeudyCfkRNXe3oX+rxXhqcxR73k1CzAVP5FHjGKxUJiZdVqp4HrZlIUALl296d2f3woxQq7C7uKhdUww4mhdDdvyGn1um5s4ivcw1cYmFe9plhKTG71NIInrpRCB+nf0tvHaVxfCdM+HRtC6KJ2RINn6X3KLlIMCky3J0aT4jiUV40D4EbZkEz4U5MPz0Tkx2jA/HSp4Kk/qhid8J2LXzxZqx3dCobvEPCd/VMMioAPSr2QVr0RPrTvmjYyqHZ2M2dkChbjtQwCsYEVPqqEFqliEeASZdPBUYAUaAEdAbgZvY0KEOuu94jy5b/8TGjoljqSdtNEYIXZy310ssjBBywTjo3WGGXjhlyhQEBQUhMDAwTo53r/Dk2Rv8m0gqG1t75MqWoWJy54wAI8AIJCAQExODZs2aYdCgQejTpxteRL8UMgzGFxtb2EsPrLcvEP0y4Rfgo0+QJ19OqMY7TxOEkSVbYebjDznFUlWzmAZkKIrsfI7VrjJdxHm+mAQBJl0mgZk7YQSURWDz1p1o3cqF3QuVhTlZ6xqE+Tmh9pizEMxXuBPQM/0kwAG9kWlcOYReEgJNmFRO43R27do1lClTRmyMyJeXl5dxGuZWrBqBFavXo49gpefCCCiFQO/evbFmzRp88sknePLkifhtfiUGe/uVRetlQuiQeTdwPF3fxwD0zjQb9c14g8/89CNPYiZd8nDiWoyAqhHgkPEZoJ6bwm5ihQE4rCkp5qfyqalFhrNL8e2Faljcr1YGCGt4l126dMHmzZvFhj7++GMQCStRooThDXMLVosAh4y3WtWbbOC///47GjRokNDfiBEjMGPGDJP1b7SO4tNy3LBzx8EH89EsXQPWWSwdfw/Ok13FZPVc1IMAky716IIlYQQMQoCTjBoEn84Xh/iUQq2JNyBsO+LG8UEW/XLbsWMHOnTogLJly+Lq1asiVj169MDatWt1xo0vYAQSI8DPLZ4PSiLQqFEjHD16VOyCLPV//fUXTp8+DUdHKci8kr0br20pn6KdmURWNN7ILaslJl2WpU8ejZUicPrsOdQW8nRxMRUCrzDL0RYjBM/CilYQJr1SpUpCmOZ7aNGiBTZu3Ii+ffti2bJl2LVrF9q2bWsq0LkfC0SAn10WqFSVDGnhwoVwd3eHh4cH5syZgwEDBoD+5uLiggMHDqhESjlivIBvpdwYdxnC2eG3wtlhPqclBzU11mHSpUatsEyMgI4IsHuhjoAZXD0K/bJ9imXCmeteO/8TDisnbzAGYQcC8dfL5H+3RZkmzVHFjIIXTp48GRMmTMDcuUIS5ZAQrFy5UiRgtGtcqlQpXLhwwWA0uQHrRIDdC61T76YYNQXPKF26NPLnz4+9e/eiZMmS8PHxwZs3bzBt2jQsX75cCKrRxxSiGKGPB8IZrc+wBlUx7dIFeFZM1uStk9gacj9FP5/V7IR67AFuBPyN1wSTLuNhyS0xAhmGwOUr4ShevCgH0jCZBiTSVRo+IX/BO4WRUYOYe1F4+c9rBI2sjT5bX8Kuy1qc9HOBQ1F7dYUgTgczOnROixYnJyfQ2YiWLVti//79+PfffzF79mwMHz4cP/30E8aO5TxLJpt6FtQRka7btyNQsUI5CxoVD0UNCAwePBj+/v7iOVQiX9WrV8ewYcPg5+cnbhj9/TclWb6nBlFlyCCRruZY/nA/+iQPkhsbjYgnb/D63I9wab8EkXZCSPmTfnBxKAp7Tt8hA1/TVWHSZTqsuSdGQDEE+FyEYtCm0fAbLHLOjgGH07J0SZdFCvWKCvVsBIuYeYbvpTDLX331FehsRFRUlGjpGjNmjDhAWsS4ubmJv3FhBPRBgJ9d+qDG12hDYOvWrTh//rwYaZUKWbek5xadRQ0PD8ePP/6orRmV/P4SftVyYUxoGpaueCk127oiW6dNsBsSiKecpV4luksqBpMuVaqFhWIEdEOA3Qt1w8sYtaOEvFvFeu1CgdG/45oQOj5VL/uYtXDN2wu70A5rngbA3HMiHzlyRLBM3MY333xjDAi5DStHgN0LrXwCmGj4z549w86dO1GtWjXxY47lpr8TSg4+gebLH2J/ClMXjUiDQwMLwWVBjJDB5CkCzP1lY45KkiEzky4ZIHEVRkDtCOzZdxCOQiCNAvb51S6qBcl3WQimURMjLlbGlJNH4FUjuR9HFAJ6V4bbmmig8UJEBH0HM82JnKAzOgNBli46L5EnTx4L0iUPJSMQINK1Z+9BdO7klhHdc59WggBtFFF6CzrT5e3tbZ6j1oTBz6k2xtzpjJ0XV8M1mYuhJswPTrXH4KymFmaGn8HwsuY5TEuXmkmXpWuYx8cIMALKIaC5hm3DuqHvmoeo8p0XfHq2Qal8r3Hvj12YP3M1XvVchm9vdsRI2wBc0ZrISzkxjdUyLV7ow+6ExkKU22EEGAFTIEBW+uLFi4sfsy2x5+DfpR1GHsmLPn6/4Ns2pZDvyXXsXjsF809Ww08/5sOk72Ix9/oU1DHbQVq24Ey6LFu/PDorQcBvxhwMcu/HgTQySt9vn+HalVDcj49WaPtZRZQunh+2WTJKIGX6JcJFxawXLspAw63qgQBZuvwXLIXnSA89ruZLGAF5CJB7IX3IOm8JFvq3z67hSuh9xL1ubPFZ1QoonSebPDC4VoYiwKQrQ+HnzhkB4yDgPXkqBg3ox+6FxoGTW0kDAXYv5KlhTASIdHlPmorpUycZs1luixFIgoBFuBeyTi0CASZdFqFGHgQjwAhkFAIvXrwQI2FdvXoVL1++RNasWcVPlixZEv5N/7exsREPcZvzTisdRg8NDTXfcxEZNUm4X0aAEcgwBMjKRSkuGjZsaPau0UQg6X1z7dq1FO8Y6d1D359++ikoqT0XdSHApEtd+mBpGAG9EKBAGo0aOrF7oV7oyb/ot99+SyBY9OKjz927d+U3INQsW7YsatasKX5q1Kghftva2urUBldmBCwFgc1bd3IgDUtRJo/DaAjcunULZ86cSfG+eS1Yh+WWnDlzJnnP0LumXDnOiScXPyXqMelSAlVukxEwMQIcMl45wPft24ft27eLn6dPnyZ0RDuJRKDoJSZ958uXT0y6mfjz7t078f9kEQsJCcG5c+fE78SlYsWKaNKkCbp3744vvvhCucEY2DIlQ6YD6YcPHzZri52BMPDlRkKAQ8YbCUhuJl0EyDrUvn17DB06VNXpLiIjIxPeNceOHUsY00cffSS+ZxK/a+idQ0nq6d0ivWMSv3du3ryZ8L5JvDGYO3dukYhR7sUePXrwhp+J7x0mXSYGnLtjBJRAgBYvVHJkz65E8wltBgYGomvXror2oW/jRI5q1aql7+VJrjt06FDCy+/Ro0fib+Sa0qFDB7EPevnlzZtX777oJSmRL+n7woULYnuOjo4i+aJPgQIF9O5DujA2NtZogS/evHkDjUYDenFnypTJYNkofPPgwYMNbsfSGvjzzz/RoEEDVQ5rxYoVaNOmjdFkexT9WPGzqA8fPkTlypWNJrMxG5o5cyZ69eplzCYtpq1Ro0Zh1apVBo/nv//+w/Pnz0UX708++cTg9ogEUaJ4Y5QHDx4kvGuCgoLEJvPnzy+SxNatWyds6BnSF5GuxBt+wcHB4gZi5syZxfcMkS8XFxdDukhyrb29vdHaMmZDNJ+kBNnGbFeXtph06YIW12UEVIrA5SvhqFhBebcBIl1NmzYVzyYVKVJEFWjQLualS5dEVwxDSBe9lP38/MQ8VPfv3xfH5uTkJBIt+hQrVkzR8dJZqXXr1okfqf/OnTuLL8R27drp3TeRLnIzIfnVsvCkMxbHjx/H3LlzmXSlolkiXRUqVED58uVRsmRJvXVvzAtpcUgLt19//dWopMsUzy4iXYUKFUKpUqVU4171+PFjnDp1CqtXr2bSlcZEpUXyjBkzREJA55TUUE6fPi2KYSjpOnjwoDg2+qZCZ32JaNG7xpibGmlhtmHDBvFds2fPHrFK6dKlxXcNkTD6tyGFNuRofaCWRNSvXr0SPTSmTp3KpMsQxfK1jAAjEIeAqdwLJdJFu4+9e/dWBfy0cPfw8NCbdJHVicgWfcgFsE6dOglEK6MWvDt27BBfiNu2bRMxdnBwwNixYzFw4ECdMZdIF13r7++v8/VKXEAEuXbt2ky60gBXIl00J0ePHq2ECnRuc8uWLaBNAGOSLlO5F0qky8vLC1OmTNF57EpcQOdDmzVrxqQrHXAl0hUdHS1af9RQWrVqJW4+6Eu6aLOJ7mu6j6jQe5TIlptbxiQIp01LetesX78eV65cEWUi4vfDDz+gevXqekFOpOvrr78WNzDVUKTnKZMuNWiDZWAELACB02fPiZYuU7gXkqXLUkjXrFmzxBcgLcrISubp6Sn6uqulkFz0QlyyZIkYHZECb9DLkF7SiQu93L755ptUxWbSpRZtypfDmkgXWbpq16ohHxw9ajLp0gM0FVxiSaSL3MjpXbNp0yYR2UGDBonvm6JFi6oA6TgRyL2RyNeyZcsSZKT3DZ1flvu+oXpMutJWKbsXqma6syCMgPoRsBRL16JFi8QXIB02JjcuevnRzpyaC8n7448/imHpydefXoZklaNC+bMoYTGdkUpemHSpWaupy2YtpMtUmmHSZSqkjduPJZAuinBLz246Cyk9q+l9o+YogmTJo3cNpQjJli2b+K4ZN26cKD+5hpcoUQLnz59P86wwky4mXcZ9EnBrjIDKEGD3QnnuheTXPWTIEPEMGL04yHXL3d1dZdpMW5wnT56IL8NffvlFrNS/f3/xhUhRuWhsqb0ImXSZjXoTBLUW0sXuhexemN7dae6ki57Nkjtrly5dxM098lYwl7J7927xffPHH3/g888/T3A5JLdD8qyQiGTy8TDpYtJlLnOc5WQE9EKAct1Qnq4C9sr6vZuzpWvy5MmYMGGCmFCSfLtHjBihF9ZquOjixYviy5xcVSiSVq5cucQdyNRehEy61KAx3WSwJtJFz64+vbvrBpCOtdnSpSNgKqlurqQrLCxM3NyjsO8tW7YEnSWkoEzmWhYvXiySLwppT0E2KDEzFcolRh4WTLrka1YR98J3j2/h2qM3MqX4BHkLF0S+3NmRReYVXI0R0IrAPy9w/+ZdPHuntaZYIUuuAvg0vx1ss30s7wIrrWWOpIvOQlFYcjq47uzsLAZvIJdCSyiUO4yCiNy7dy9hOMlfhEy6zE/T1kK6TKUZJl2mQtq4/Zgj6Zo3b55IuKj4+vri+++/Ny4oGdTaP//8g379+iUJjkHBPyjoE5Mu+UpRhHRd3jACsw+/EmJqnsL6XRcRS/LkqIx23eugYDLZoi7uxdHz9/A8c2UMmLsM47o7ooiN/AFwTUYgVQRigjBjzEZcxSuE792O3+9phGo2KPxlB7QqlzPpJa9u4ORvf+By9HsUbj0WC6ePRptyOcwKWL8ZczDIvR8H0kiWp4sCUNALkHJL0XknHx8fs9JrWsKSVWvixIniC5D+nbgkfxEy6TI/lVsL6SL3Qv8FS+E50kNRJTHpUhRexRo3J9JF+RzpXbN582YxVDpt7pmzdSuxUsl1nd439J28kEt78tDw7F6Y9i2hCOlK6C5mLVzz9sIu4Q/Nlz/E/j7JKVdcTU3MJax3bwH3TfeQvd1s/LbYAzVSr6rYzc0NWy4Cp8YVRV3fSCHu9mj8fs0PTqmS+ljcDvwZPVwn4mRsVQzctwUzW5QWaJp5FO/JUzFoQD92L4wnXZRzi16Aa9asEXMd0QuwSZMm5qFMGVJSIuWAgACRcNG/KewvfaSS+EXIpEsGoCqrYk2ky3vSVEyfOklRDTDpUhRexRo3F9JFqT3ofUO57Oh7zpw5imFi6obpHUNki/JISu+ZxOSLCBe9bxIXo5Oux5cQ9qoMqhTXL1eb1YSM1wT0Rm63NdCgDmb/FQyPdPOtRWFb1/LotCkGFYcfQeDMhimsYqaebNyfJSBwGX7VKmFMKGDbfx+iF7dIl0hpwnzxRdVxCLVtjsUhAehf2lxol2l0ZS7uhRQkg14Q3377Lcjdg85xWUOhl6Fk+ZLyvhiVdEUFwN1tK+qvXoqeBtwbnKcr/dloLaTLVPckky5TIW3cfoxOuozw/Eqep2vYsGGYPXs2ChYsKL5rOnXqZFwQVNoavV9pw4/eN/SuoeTOUjEm6dLc3Yb+NTphDXph67kl6KiHK5zVkC55FoZEM+qyH6pVGoNQVMWU0D/gVYUXvCq938xHLJnW1g8DikFA75JwWxMDuy5b8efGjmZB/vfsOygG0uA8XbXEBMfNmzcXz3H16NHDfOaqQpIajXQJC5beNQfh735f4cbSJ/ghZDVc9fRIYNLFpEtCgAJpdO6kbGJYJl0KPVwUbtaopMtIz6/kpIsSzh89elT0piDixcV4ebpEwlVnKP6e+humfjIdTkP/xuxTuhMvKyFdulkY4iZqGHwrVcW4y0DFKaG45FWF5y8jYBACullb47rSbOuKbJ2EBIa2XbD1zkZ0tDNIBJNczCHj5YWMN4kyVNaJUUiXcEZyZMPxyDZ/O6Y4FUTsOT+4dLoEz2D9iBeTLhOSrqhD8Gj4FUK+O4ag4VX0dpnesmULOnfujF9//RVt2rQxyiw3p5Dx72Nj8Pztv/goW27Y5chs8PgpsE+zZhwyPj0gjUa6jPj8Sk66DJ4IFtiAUSxdLw/CvepEFFy9HT7CO4dK3HvnFrxDF8DFVj5w1kG6dLYwEIAxWOuaF73iDoHh4f4+ZmFlkK96rmlqBHS2tpKAp8ahaF1fRAqzb/TvD+FnBpFeafFChS1dtUw9xVTfn1FIlxAOKSYmM+zsPngfaGJi8N7ODvqEnGHSZSLSJezu9xOsk5Ee36Ps8jEI7n0MR7xq6KUzJUgXofAo+rHiZ1ENtXRFBfRD6w01MLfrdXTp+juGh5zB8IqSDjUI8nBAk8W1oXm9G1k/kvdIYNKlHSejkS4jPr+YdGnXm1FIl/ZuZNewCtKlj4UhCekqKAQ9eCgEPZANK1dkBJIjoI+1NTHpSj8AjJrwvnwlHBUrlFNcJMPPdGlw9+hSzN19D/++zgLHIZ7oXO4VjvvPRMA9YRc5T0P0HdwGZbLLHwq5dVDYdFrI10oWvVB+K5Zb0ziky7j4MOlSnnRprq1Ft8azUX7jbtE6Cc01rO3WGLPLb8TuKU46b2gqRbpM8ewyiHRFCQHBGv+J789PQZ0THsjbZC6KTruEC54S6wqCR94mmIshePd0DuTawJh0aX+mGI90ae9Lbg0mXdqRYtKVNkaKRS/Uy8KAD4tkMOnSPrO5RvoI6GVtFZoUAsBkEgLAUEkv6qaa4DcP90INwvyc4f5+Lg4Ku+2ZDw1EobZnUK+hBnm/3Yuf7eahWbtpeDnoKG5NayAbXiZd6UOlD+m6czoAZyKSJ7n7DDU71UOJRN3dOrkVIfc//OGzkrVQr3pxrbpj0qU86YRk1l8AACAASURBVELUOZx5URGOSQKeROHcmReo6Kh7ZFYlSJc5uBde9quG73Jsx/FBnwsWrbwQOBfcDz7A/GbxVt94z4hHvXbi7WpXrXNfqsCkSztU+pOuWzi5NQSJHk1iZ7ZlmqB5FTovkPL3YuW+gGMlB61CMenSChEMIl3C5tA27zFYHBiJ9w2EFD6+HZH4ERZ1bgXmB+TCDz4dkSWTdlmohhVYuvS0MEA4qJ3JTYhSIhTnxYgM7I8i8jDlWoxACgT0s7YC9JKtROEOhb3g4UfuYGZD9Qd0OX32nGjpUrN7oUZYnFT/qTwOB/SM22WXAufUn4cbxwfh7sgCaDjzBRr7X0DQQPlWOyZdxiddmmcPEPUwCJ71ekIIKIs6P53Bpl4lUbCwXZIzQZqYcCzuVB6jr7bG2IWTMahBedjnyqb1acSkywSkS6sWdKugFOkiS1ftWjV0E0bH2oZYuqLOncGLio4ojUMYWMgFC3J6IThCsHrFyxC5yBlFBxxGuzVPEdBT/gFgJl3alag/6YpFdMQTPDn1Axp0WYNoVMTw/VvxvVM52Iv+0MLvJ6ejWX0fXK88AHMXDUW7SiWQz1b7u55Jl3a96U+6ooQjRm1ww/sIvG38xcB6eRdGIOg7iQxL3KIdXv4TgJwyXXktn3Tpa2FIOEsjLHeFsPF3hLDx2m8B7ROAa1gnAvpZWxOdK4QzFkcGoj8z/4QJZIh74d5+BbC/+yPMcY5vbm8/ZGu9DOWSuOroPleZdBmfdEkthviUQq2JN2Aj7OI/F3bxkz+PNWF+cO55Fz6H5qCZDoG7mHQpTLo0Mbh0aAmW77oO22pd0e1rZ5TLEYvw3f5YnORv8u83JUiX/N4Nq2kI6ZJ6ljbxinifxXWfmvF/lt4XtTAzXDjnVVa+nEy6tGOlP+mS2r4Jf6eSGHzCBu03PMD2rhIp1uDa/JZofGoQTi3pCF2ikDPp0q43fUmXRvB+qbijPS7Pb4bXa12RVwjw0Dgx6ZK4ReOFeBf0nWxXXosnXfpaGG76O6Hk4BOiRrtsfYuNHZO/4m9iqaszfgx5j/eZMwuAv8bjOy+QubAzpgbuxQDpgRc0BkXa+eFebNzksMldGIMnrMH0EY21zxauYSEI6Glt1cTvZgq7+0IITYRe8kIVPMD67nXhdewZHt57LuSdo5ID9sXKYPCGc5hQNzlkQRhTvANm34mrS/Pv0y7+uLXIFTKt4TrrwDzcC5MOK8y3EqqOu48hgU8/EDGdRw4xVC+f6UobOH3cCxNak6yRNu2x4cF2JKxZqAKFYG62DR0P6R7BkElX+hPdoDxdFK3wq9koMnkhhja0w6kR5dF8swsGOZ9GtOteLCi9Bx2aDsDR6svw8sD/IDeDnRKkyxzcCyVNxbkW5oRXcASmSGYujXAP5Ba8cwoktX7JeYwx6dKOkuGkS4gUsLEDCnXbAU28R8Xn4qOrN5qtcsG2DT2TuK5plwhg0qUdJX1JV9CYGjjc+hwmN5DIcn3Mu3EcgmevWCRuUcArGBEJN6F2eSyedOlnYZBAFgDMNxCH7vmjaZpmLjJBFhOiHApL2lqzcPXMMJRJhvtfvziirG9eTNuwCIOaFNcrWpN2VXIN1SKgp7WVdloKuSwQ4mgC9f1v4vjAxCdYEs27qtNw6YKn4LSQetEc90TpprvgsnonZncW3P4UBopy3VCergL2+RXtyRBLV1LBIrHIuSgGHBbC8r8VwvIbYNJm0pW+yg0iXUhjp1gTBj9nd2CB4IKoRz5FJl1Kka6bwn3VBhG+5wViEHdTSSkwbNpvwIPtXRE+tgjqTXuMwiP2InKGs+yNIKVIFz27+vTuruhzy3BLl7SJ1ws7/xM2GSRp471zXg0JxNMEE768oTDp0o6TMUiXwLrQoVA37NCUhPfZ6xidyRcuQzILjy5P6PHoYtKlXW2Gnemi9m/6w6nkYJxotwZPheMIkn1SOlOp60athZMuPS0MCYmRgapCjq4/hBxd6a3D6HxIRSGs9w1BHUkOtYq7GP1Qd3x2LNLR5UXGXOIqZoKAftZWjRBDI7eQGFkg8zYCGXgikIFkbOkDKUs57xKgEZMw/ohyu47Aq4bSdMu0CjEa6ZJ2iOstRITgJhDnsa1BzL0XsClsDx2CF7KlS8sUMIx00fsv3gNBcOmI01WUcJ80w7aOh7Baz+zIaZGuf/8VIlh+JNNR37RT36S96W3pCp2CKhNL4qhArqSFirQJ+sF7RLjPYt4L4f91ezYpQbpMBarRSNdNdxx8MR/N4p9Xp8ZVRF3fG2l45qQ/urRIFyV3z5Url6mgUXU/RiFdwnvl0MBCcFkQA7vGLih/20HIL7hU78TubOnSPmX0tXRJLUvvnKTnJCVuoftGrWWTLr0sDB9uCjgMx5E/Z6Kh1vdBalYHIRz1tv6oM9UBG3dPQXw+Ne0zhGtYHAJ6WVul3RUBjeaLIxEgHOZKSfxD4FOqFoRjLrARdmHuSEEhJATjCZeDFKbZRMj6zZiDQe79VBxI4x/EXDqK85m/gHM54eYOigu9nDOxmwDtSNYPx4QrPqimA25s6UofLENJFxKe6eTqEYgvtwoRKLEAQZ76J9pNjXTlyZMHDg4OmDdvHho2bKjDDLC8qnqTrhRQSBblxlgYEYSE8+h6QKYE6SL3Qv8FS+E50kMPieRfYjjpEuL+zHJEzRHvMCH0D3hVeY/wFb3Q4H87hCAN+mGbGulq0aIFDh06JN4D7u6CJdnKi3FIlwBiiA9K1ZoobNIbfk6bSZf2SWkY6ZLOSSa7ryIXwbnoABxO2PzTLodUw6JJlz4WBk2YL76oOg6hKCkkow0VktFqZVxx+0yJrF29dv4J3/ejmXDJn4cWXFMfa2sUtnUtj05CqDabdstxfXOfNA/XJviIC/OV3BUSzlRTItK6w4FZwcLZQx2iChhBE96Tp2LQgH7qdS+8dwwFijREdMkJOHPdCzHxO49VE4JoCOHkfZ0wvuhuIQKYbtgx6VKYdAnOths7FEK3HRpUdXHBvwUF928hqIZuWkoqY2qka9GiRRg8eDDev3+PyZMn44cffjDCnaHOJp49e4bbt2/jwoULuHPnDo4cOYJq1aph1qxZosBGI10SYdbiDi0HJaVIl/ekqZg+dZIcEfSuYwzSRRHvxEAk+6KRLftHyFM9Kw70+BFBemKbGuk6duwYhgwZgrCwMHTr1k204ufLl0/vcav5QukeoPuAPnQf0P2wY8cO0AYMFaORrqjN+Kq0YCF5mTyghu4IMenSjplhpCt+/RbeF3veLkWr+O4kN+kPawbtclgF6dLZwiCcDfD9oirGhdqg3fLr2NwnNetCWuB+WAwgRw7kLj8Uu9nCJX8mWmpNPaytUdu6onynTYgpKSTlDhWScqfH+xMF27BzP4gHQqQdm6jjGNemKyJ/CNHb5coc1KG3e6FIujqj6bYT8M0yA922OOJbjIH73R9wYVM73FsxGBPvDsWWOc10Xswz6VKadAmH0eMjSQm+3wj9QwguY8AZPJI2LffCK1euiMTr8OHDaNasmbjjX6ZM8hO75nCnpJSRFpmNGzcWF5j07+SFxtyoUSOjkq7UD54LkdvOhOGTKo46RW1TgnSZSpOGkS7Bg+bMbzh1xxZV2zZICLwQJdwTxXodQL2FV4SQ1vEn/XUYUFruhf/9959IvPz9/VG4cGHxHnBzc9OhZXVX7dOnj7jJQPdB8uLj4wNvb++EPxuFdMWfP33eKD9m+O5KElBDH6SYdGlHzTDSJVm6Ep2fJB061caYs9n1CrxlwZauRMmNu2zF240d0w/5Li5Um8L3bGY09z+LbUJuHnk2rkRKTzAbQ+c8GdqnDtcwRwQ+WFsrYkroJcEVJL1RCAuQtd1Qv9cOvCg/DDsPTkULGfFjE8652Agm8LBf8LxHK1waewpLOuqyaWA8dPfsO4jWLV2M12AaLelNuoT2/n56G9cjn+Nd9kIoX7oAsuJvPLr2Jx68BrIXKI0ShbLLDgGbWDwmXcqTrquCa1W5EWeThu81YLZpC6RBi6+JEyciW7Zs4m5/v379DOhNXZfSuGh8iQstqmmHXyr6Wrpiw4Ow79IbfP5la9QoKLntv0bfPW+xVNoyJjfeymcw7O4MyE9BDihFukzx7DKIdEluTUgUFl4TBA+HJlhcbBpOC0GT9NmE0BZIY9OmTSL5io6OxvDhwzFz5kx1TWQDpPnll19AH7JuSYWsW7du3UqwctHfDSZdQqLdtd064uDXwvnTFmFxedZiknmo6DgOJl3aATOMdAlebGGz4Fzve/w9dA8Wt4nA4hFjsOZUNGJtBCL2XAhko+Omn+WSLtkWBjLT+6Bv1+k4iXqYFrgbQ79ImnRTu1qpxocFczT9t6Q3zl73gZRBQ14bXMvSEJBrbdXcPYNlo9pjxKbHyN93NY7P7ozicll/QkQk4WyXTWE0nL0Xu77T/4yLoTowx5Dxho5Zup5Jl9KkS9p5lLOJIU+r2kgXtUIEnxad9MLs3bu3SL7MPcDA8+fP8eOPP2L69OlJgEps5aIf9CVdIwtkwkzhZeiy7D4OtA6Ea7Fe2KVJrDf9g6AoQbrMImQ8ka6KW/Hlzvnwci4NG3EhXx8DrvfCjkMzdMpPl1jp2kgX1b1/X0ipIdwD27dvR61atcR7oE4dKV69vHtNjbUWLlwo3gf37t1LEC+5lctw0hU311e5bMOGnoLehAalvIMJHip6gMOkSztohpIusQch1+C9qJf4Bx/D9tk6NK46BuHxEVjlpyCPk9WySNfbRwgOPIZ7b17h0hJPTDxI9KcgOk2fhy7FkivnFW6e3IHNyw8g5P1ncJuwBLMGNZG/0E3SnHAGZFE7tFraBHvnvkaHunRI0nB/Xe3TiWuoD4G4IA2B4U+BR/vxw4hluEoJsuoMx/qR9VLmoXl0Edu3rcGuoPvIXLMPFq/0hWslXUm/RjgDlk04AwY4jP4d1/ycMjSR96Pox4KHbXYVB9JQbtYw6VKadAm7+nmbYC6GIPDpHOEouuFFDumiXv7++29x0bl48WLkz58fnp6eGD16tOECZEALZKmghWZMTAyaN2+O3LlzY/Pmzfjmm2+wYsWKJBLpS7o2dCiA0c9GY4VfMWwaMB8VFwvWkSEN8FPBuTgw3h4BvlMR6boC8+MXobrAoATpov5v34lA8WJFdRFF57oGWbqEzd27+3wxyP8uytfOjktHIlBzwBQMc60EOx133BMLLod0SfXJKkTWLioDBgwQ74MSJRKnM9EZkgy5ICAgQLwHzp49i1KlSonh1+fMmYPixYvj/PnzSaxcJKD+li5hfeiXSsAfKVhWankHZSLCpEs7UPqTrpvY0Ksdvj9fC9P3rUQnMayxRoi75SDkyMsl5Mi7nJAKQ7sUH2pYFOl6dTEAI+bukT3+QtVc0LBuXVSvUNiAB1Yc4XJb3QI7g4YLpv0YYUejpBDqW8iuxNYu2bqwnIrR2DBiHA6/kjminKVQr8mXqFO7CsrZyzVtJW/7FMYVrQvfSDu9fIxlSiq7mikWLiSMIe6FsgejY0UmXekDZnD0wvhcRJHJcqboqKYk1eWSLumidevWwc/PTwwwULRoUXHROWjQIENEMNm1GzZsEBeadF6tSpUqYoCQr776SnSfpMU0WbkoiEbioi/pojbevojGS81H+CRPPuQUMx+/w6snz/DmX8Eqb2uPXNn0G7r1ki798NJ2lS6ki9o6d05IGisEmNm5c6fY9IgRI8T7oGBBQ0LaaJPSOL/T/U73wK5du5A9e3aMHz8eY8eOFQNnVK9eXdx0oM2H5EU/0hWF4+PaoMONsbgoHHFJis6HOAD1593AcSnrrg7DZNKlHSy9SZeUOipHa6z8cze+FkiXJkw4Y197AjDpNI7rGTHXokiXdviNXSM54YpvPyHPlxCQY80dnSOgGVtKbs/CEbg6C47lRuAsdM8ZoQQy7F7oIQZnIBccLkkR0Jd0xYQdQOBfDxI8GGzrj8acYbVRpmYn1DNwk11X0iWNaOnSpSL5unbtGsqVKycuOulgvhrL0aNHxYUmLa7t7e1FsuXh8SE0Oi2eQ0NDkwQOkMZhCOlSCgslSJdZuBcqBKiupEsSgza+6B44ePAgsmbNKt4D9LG1tVVIUv2bvXv3rngPUGRSKjT/x40bhwIFCoj/p4Ay7du3TxKxMHFvupCudw8uY92aOVizcB2CbsUKObm8sPSXUehQRXJGu4WT8+dhpM9MCMeDAHsXePv1R90aTdA8oY72sTLp0o6R3qRLPCs5Dp8F/YaxlQQreODP6NFxKeym7MKmQTV0j/kQLyqTLu06S6NGLM75uaBTYG/s3PVdssOria1dXgi+PAV1DDD96y0iX2gVCCREc9MjZ4QSAB05ehyOjsJDSdhFVLKwpUtJdJVpW1/S9Y/mFV7//V8KoTJns8UnogVF/6Iv6ZJ6JJckWnjSmZAaNWqIi84uXbroL5CRriTXwfXr14Msc8HBwWKrY8aMEQlXzpw5k/QiRTCUwmMn/tGaSNeZM+fQqKGTkTSQejOGuRcqI5q+pEuSZvfu3eI98Pvvv4tueXQP9O/fX3TDzehCQWHoHti2bZsoSqdOncR7oGrVqilEI2tXckuvVEkX0vXvew1i3/ydpP2kz6p3ePPyLd4nkyBT1uzIafOxbMiYdGmHSm/SRU2/e4rIP//CX88yo5BDYRT+rABy66Cf1KRj0qVdZylrxIZjRd+mcD/ZHb9dE8yNqRGqv36BY9nhgvWBrV36QMzXyEVAI7iz5hbcWTWoOCUUl9IPjyi3UbOox6TLLNSUREh9SZeSIzWUdJFs//77r7jopA+Rnbx584q75h06dBDPipiy7N27N4FsUb9k2erRowcGDhyI0qVL6yyKtZAunYHR8wJLJF0SFHQukO6BkJAQ8U9t2giudcI9QB86N2iqQuSJiBZtOlAAECqdO3cW3QZbtmyplxi6kC69OtDjIiZd2kEziHRpb17nGky6dIDswc5v0WzYTuGwrRAuUrwuB+y7LUbo+u4olKidyFVfoe7QX3HvOUVQEIpNbhT+NA/qTvwdW8gxlAsjYDACxzC+Um+sefUaj+Pno03uwvg0TwH8b8M5TKhrcAd6N0DuhZRglC1d7F6YfBJZKumSxvnq1SvxTAjtrtP5KCpEeqSFp4uQ0NnY5Z9//hHP2NAZFVpoUqhrKq6urujevbu42DSkWAvpIvfCUWMnYMGcpNEcDcEutWstmXRJ4yXyRfcARTqkADRUKBWBdB/kEHKZGrtcvXoVQUFB4j1w4sQJsXlHR0fxHqBNB7oPDSlMugxBL+OuZdKVNvaZhER8Kf1HMk5X3DMjwAjogcCK1evFPF0F7JV1LWFLlx7KyeBLLJ10JYaX8v7QopM+x48fF38qVKiQGGabzoCVLVs24Ts1t760VEUEiywJ9JH+TZY2KpUrVxYXmLTQdHAwzgafNZEuenYNHqBsHjZrIF3S3H379q04/yUCRvP0o48+QtOmTZPMf7ofKPmy3HL9+vUk85/uBclFNl++fAn3wBdffCG3Sa31mHRphUiVFZh0MelS5cRkoRgBc0OASZe5aQywJtKVWDs3btxIIGAXL14UcUhcaMEpLTzJMpDWh4JdvHv3LuFSchesWbOmeJaMFpgNGuiSYlje/LEW0iUPDcNrWRPpSowWWYElAkZnDKOiopKASRsPtBHx5MkT1K5dO8174ObNm3j8+HHCtRQxkeY/3Qf0IYuaEoVJlxKoKt8mky4zIl0UVnflypWijzIXRiAjEHj06JGYvNTb21vIfWV8lwwlxjRv4VL06d2d3Qs5emGK6WWtpCs5EGQFCw8PB7lE0bf0oQU5RYFL61OhQoWEBSYtNGlXX+liTaTLb8YceI78ENVRCWytlXQlx5KIU/J7gO4HigaaJUuWNO8BsuBKGw30baocYUy6lLgblG+TSZcZkS7abaFD1pSPgqLdcNERgdhonP9jC3ZuPCCElA3FA7q80JcYOGIgOreqmygRtZCt3f1HFPh5LuomDaqlY4eWV71jx47i7mDfvn1BIarNodC5CFq4sHshn+lKPl+ZdJnDHZxURmshXXymqxlWr16NXr16md8kNYHETLpMALICXTDpMhPSRYeh//e//yVI+9dff+kV+UmBOaT6JjV3z2D9FHcMXxGC92XaYeSAb9HCuTIKUwTx1/fwx8YpGP7Le3id2oaB5V7hkEdDtA3qjfBLXiiu+tGZTsB9+/YliXxG4XidnJQNZ2y60Rnek+ReSAmJDQ0WYLg0cS0QMabcL5ynK3VEJdJFUcSmTZtmLNgNaocinTVv3hw0jwYPHmxQW5Z4sUS6yNpOERDVUChoCIUk//XXX8UIeeZUJEvX0KFD4eXlpQrRjx07JibJZtKVtjok0kX3A0UnVUOhs5vkrpzcVVMNsqlFBiJdtD6g57saCllyaR03depUMYVHRhbVBNJ4LUQxKlOmDN68eYOnT5+KmHTt2hUbNmzISHzMoG8hd5l/F7QbuQf3ivTC8jWT0Llu8VSTyGnC/NGy6UHU7X8fM3zPIk//fbi+uAXY0PVBzeQ6QQ9U6QxHo0aNEiKiqXky7Nl3UAykoXSRSJfS/ejTPpOu9EmXPpgqfQ2TrtQRlkiX0vjr076xSZcpnl0S6dJnvEpfw6RLO+lSWge6tk/JnZl0pY0akS41FiZdibQycuRIzJw5E926dROJFiXT27p1qxiBR6lDmmqcFDrJpAnDonZNMeBgNOzbL8exNX1QTssRpKi1rijWaxc0sEWXrXewsaOUrV2nni2y8s8//ywmmKRIZBQCl3a0KOfIggULMGDAAFWPmULGTxw/1iTuhQcOHFAlFrSzVovPdKXQDVm6Jk6cqEqdFS1alC1dqWiGSBd5fqixUOAQY1m6yL1w4JBRWLVsvqJDJdJF6ws1Fop+ye6FqWuG3sdqLRx3IG3NqFVvdB6XLV2C3k6fPi1GgWrdujXIsjB69GgcPXoUbdu2Bb2UyfLAJRkCAuGa5VwPI07Gwq7dcvyxuQ9Kp5YwOjlwmgD0zu2GNZo6mP1XMDx0z9tpkaqIiIgQXVmrVKkC2gAg8k8JT4cNGyZaXsk8rUuIaVOD9Cj6sRD0I7vigTRMPS7ujxFQDIEnZzB/wgwce6Kth08wxHcW6n+eR1tF/l0PBG7fiUDxYkX1uJIvMRyBB/htsheWXn4jo6l8mL74FxTJlUVGXa7CCDACqSGgCvfCFi1agHbPz58/j927d2P8+PEICwvDkSNH4OHhwUE1UmhOCILRuzLc1kQDVUfj9wN+cCood4JfxSzHchjxZgpChfNcVeReZuH1vv76a9G3ns503b9/XwyiQaTr5cuX6NKli7gbrxb/5NRUwQsXC5+gPDzFELjp74SSg0/AwSsYEVPqJOkn9vZmuNfugmZ7otHLUdkceIoNUOUN87NLBQq66Q+nkoNxws4dBx/MR7MkG7ixuB3oi69a+2JV5D+oYP+RCgRmERgB80RAFaSrZcuWqFq1qnjIbf/+/fj+++/FczRkWahfv74YrlfNC15Tq/7mImdUGHBYcBF0QP99Z7C4hWzGJYoa0DsTvsu2D38K57nYuTBOe0SssmfPLrr00CH/Pn36iO6tJUuWBEUzzJkzJ1atWmVqVcvuz1TuhbIF4oqMgFkgoBGeh7mFDazsGBL4FHOcUwod5lsJ19oGo2NlW7MYkTkJaSr3QnPCJCNk1QT0Rm63NdC0W4OnAT1TWRfEYK1rSdRZ9RSl2OCbESriPi0EAVWQrsRYShnO1ezKlaG6j1oL12K9sEsD2DZfjtD9fVBCR4GIdC13eYqAnky5UoPOHOfgkaPH4ehYg90LdbwXuLq1I3AK44rWhW9kO6x5GoDUHomX/arhbkch2mJJa8fK+OMn0nXmzDk0asgRYo2PrvwWgzzyosncGDReGIGg7xxSvTCgdzVUX3ABRc0jdaX8wXNNRsCECKiOdP3yyy8YPny46GpYrVo1E0JhHl2F+JRCrYk3BGEdMPBQKPyb6kqcYhC0aD2yug3SwSXRPLAxlpQ7d+5E+/btOYiLsQDldhgBtSJwdRYcy43A2VozEX5mOMqKckZiz6QDKDihHyjr2/np3+CjPitRVfmcyGpFieWyaATC4FupKsZdrogpoZfgJZ05uBmAGefKYWQnuisiseqrWWi7ZSbUEbjdohXCg7NgBFRHusi1i9y4KJ9G8eLFLRh6PYamOYSBhVywIIY4l3CW65pwlktO8Aw9urLmS6Q56OrqKgZ2MYdC7oXTp05iS5c5KItlVA0CMUI017xCNNck57miVqBFt7+xJOg7YWuLi5IImCo5spJjMPu2IxfBuegAHLYbgsCncyB52NJZx+G5f2WPGLNXMA9ATQiojnSpCRzVyRLkgbxN5oI4V0EhxxafyVKdhjJMoBWr14t5ugrY82H/DFMCd2x2CEhuVe2W3MBcl8x4cj0IAdM8sbzWrhRBNcxucGYgMJEuenYNHtDPDKS1TBE127oiW6dNQLsluDHXBZlf38PFoGUYOeIs/hdyAZ4VLXPcPCpGICMQUB3pIvdCsnRRfi62dCWdEnS2oNKYUPGP7dbwmSylbhhyL6S8RhRUg11clUKZ22UEMhoBya2qPjy3DIMjifPqPOaPmIHP177F0lYZLR/3zwgoj4C08VB14Ar80Din2OGjXWMx6EgXBEdMQdJ4nsrLwz0wApaMgOpIFy94055uFABDCDAkFAd4BUcgWXTjZBfGIjriCdLMvvGxLQoWtgN7J6bEm1IV0LlCb29vs0nMPW/hUvTp3Z3dCy35ac1jMy4CkltV1Wm4dMETcRv6l+FXzQufHU49qIZxBeDWCAG/GXPgOdKDwcgQBKRAMlUx7VIiq9ZxTxRd2QgRvPOQIVrhTi0XAdWRLsuF2vCRfSBdzbH84X70SS9SfPh8tGjhh3Dq9vVj3ImOjRfABrkLf4o8Giyj8AAAIABJREFU5Udhz6HB8QsNw2XjFjIWgVFjJ4gLF3YvzFg9cO/mg4AUJjv7kEA8TYgVfx4rJ0WgwQRXfG4+QzFbSflMVwarTtp4cPBKYtV6fmwOlr7vhZHOugbqyuDxcPeMgMoRUB3pIkvX0aNHOZBGKhNHJ9KV5PoA9M7kBjKSFfz6V4SubAPdMnupfBYbWTwO5mJkQLk5RkCFCJwaVxR1fSPRZetbbOzINn8VqohFUhgBKZCMTa+deL7alT1fFMabm2cEVEe6OGR82pPy6ixHlBMOtwIyLF2Jm7nsh2qVxoBOg/FZMO03vTmGjN+z76AYSIMLI8AIyEGA3AgrYUxoYyyMCEIaqYnkNMR1DESAn10GAmjA5Xv7ZUPrZRpeFxiAIV/KCOiCgOpIFwlvjslpdQFd77oJ5MkW/fdFY3ELebuz0m4WhCOxs/8KhkdpvSWwmgvNbQ5SyPiJ48eye6HVzFAeqEEIUFj4T/+HA8ncqgxqky/WGQFyLxw4ZBRWLZuv87V8gYEIaI7Ds/SX+DkyWX4uA5vlyxkBRiBtBFRHusi16/bt22J+pDx58rDukiAQhbWuxdBrlwYQQry+2tIZ2pPDx2Bjh0LotkO4hhcYsuYTzT+ah+Y0B2/fiYC9EC4+R/bsssbIlRgBq0Tg2V/o4vYtbj6+jehXhEBW5Cn8GfJkqYexAb5okdsqUcnQQV++Eo6KFcplqAxW1fnzcPRzHYA/n93HvWd/i0PPmqcwPsuTBVU8NmCOsF7gwggwAsogoDrSxe6FWhR9czmaV+mLg7EO6P/rScxtUyRdP+yogN6oLIQ8jBaa5dxe8m4ic3QvfBT9mK1c8tTLtRgBRkBFCPCzS0XKYFEYAUZAUQRUR7rM0cqgqIZSaVwTNgvO9UbgZKw92i8PwrLulWCX3NNQE4NL693RYlpWzByTE4P/twA1lj/E/nRDHpp6JOrsT5qDlKPLXHLFsXuhOucSS8UIMAJpI8DuhTw7GAFGwJoQUB3pMrezNBk2WWLDsXlUT3y7IgTPM9ujThM3uDR3QYlXJ3HyRDB2Bsei+ShfjBvUBuVyROHQSB/cHbwAfUpkmMRm07E5zkE6jN6ooRO7F5rNLGNBGQFGgEjXkaPHOQgQTwVGgBGwCgRUR7rYvVDHeffuFZ5E3sLVhy/jL7TFp6WL4TP7XMimY1NcPQ4Bc3QvZN0xAowAI8AIMAKMACPACKgXAdWRLs6RpN7JYi2SSXPQ1dVVDKZhDoWSI0+cMJYtXeagLJaREWAERATI0uU9aSqmT53EiDACjAAjYPEIqI50WTziPEBGQAEE5i1cis4d3TiYhgLYcpOMACOgDAJEuvwXLIXnSA9lOuBWGQFGgBFQEQKqI13kXrhq1Srs2LHDbIIYqEifLIoRECD3wokTJ2LFihWgYBpcGAFGgBFgBBgBRoARYAQYAUMQUB3p4gVv2uqMjo5GWFiY+Hn48GGKT0xMjHjxf//9l+Q7V65cKFiwYIpPxYoVUblyZZQsWdKQOWRx1x45cgTDhw+Ht7c33NzczGJ8K1avR+dObuxeaBbaYiEZAUZAQoCs9IMH9GNAGAFGgBGweARUR7osHnGZA3zz5g0OHTqEM2fOIDQ0VCRad+7cSXH1p59+CumTN29e8fdMmTIl+X7+/DmioqISPm/fvk3STu7cuVGlShWRgFWvXh1NmzZlK6NMPamlGoeMV4smWA5GgBGQiwCHjJeLFNdjBBgBS0CASZeKtEgBHIhoSR9JNFtbW1StWjXhQwSpaNGiItmSCJYuw6CQ6Pfv3xeJ3MWLFxOsZxEREQnNVKpUCU2aNBEJGH1/8sknunTBdRkBRoARYAQYAUaAEWAEGAFGIB4BWaTr1KlTFg9YnTp1MmSMZMnasGEDtm3bBon02NnZiWSnWbNmaNiwIcqUKWMS2R4/foyTJ08iMDAQv/32G65cuZLQb7t27dClSxfx8/HHH5tEnsSd8BxMH3LKdUN5urgwAowAI2BOCPCzy5y0xbIyAoyAIQjIIl19+vTBypUrDelH1dcS6enatavJZKTzWNTn+vXrcfbsWbHfL774QiRZ9GnQoIHJZEmvo5s3b4rki0jY1q1b8e+//4KsbhL5ImJoqjJ+/Hj8+OOPpurO5P38/PPPGDVqlN79snuh3tDxhYwAI5BBCLB7YQYBz90yAoxAhiCgE+ny9/fXy50tQ0Ymo1Oy5MybN08kQKYgXYcPH8bcuXPFyIxUPvvsM3Tr1g3du3dHjRo1ZEiccVVevHiBTZs2iR8iYVRKlSqF/v37Y+DAgciZM6eiwkmka8qUKSBLoKUUcvMkMmko6bp9JwL29vk5kIalTAweByNgJQhcvhKOihXKWcloeZiMACNgzQjoRLrI0qHPGSK1Arx//360bNlScdJFERmJbAUFBYlQdO7cWSRb5hIZL7n+rl+/jo0bN2LdunUIDw9Hjhw54O7uLpKvEiVKKKJuiXSRC6aDg4MifWREo3Smjs7oGUq6HkU/5hxdGaFA7pMRYAQMQoCfXQbBxxczAoyAGSHApEtB0kX5xsiSRi6EmTNnxuDBg8WPJYVoJ/I1f/58/P777+K0/+abb0Ty5ejoaNTbgElX+nCye6FRpxs3xggwAiZAgN0LTQAyd8EIMAKqQYBJlwKki84/TZ48WYwKmC9fvgSylT9/ftUo3tiC0NkvIl+S6ySRLy8vL5QuXdooXTHpSh/GPfsOioE0cmTPbhS8uRF1IlCoUCHxbCUXeQiQ2/js2bNTrdyoUSP8+eef8hriWmI6EfIOMWYh0kWBNFq3dDFms2JbZcuWBUXq5SIPgVatWmHFihWpVqZAWn/88Ye8hriWuLFOQcm4MALJEWDSZUTSFRwcLJ7P2bt3L/LkyQMiCkOGDEGWLFmsZuZRTjE/Pz8xSAgVCg5B5MvQc1hMuqxmCvFA00GASNf79++Nbkm2NNAJI0q94eHhkS7pOn36NIh8cUkfAXKNJ5yMTbqUxJ1I16NHj1C3bl0lu7GItvft2yd6qaRHukj3pgyeZa7AHjt2TDwywKTLXDWorNxMuoxAuiIjI0XL1pIlS0RtDR8+XCRchhINZVWvbOtHjx4FBb2ghQ8lXybi5enpqXenTLrSh27U2AmYOGEsW7r0nmHmcSGRLsrZZ06L34xAlhLC08aXNtJFCedv3bqVESKaVZ9KzTuydHlPmorpUycZHQ8iXeRpwovf9KH977//8NFHH2klXYQjpZXhkj4CPO94hqSHAJMuA0nXzJkzMWbMGHH3mQJkEDmgxMJc4hAgV0tfX1+cP38eFSpUwLRp09CmTZsk8FCgEW1BRZh0pT+j5i1cis4d3TiYhoXfeEotfi0NNiZdxtWoUvOOSJf/gqXwHOlhXIGF1njxKw9SJl3ycJJbi+edXKSssx6TLj1JF7nRkescnWWqWbOm6FbYokUL65xFMkZN573Gjh2Lly9fimHmiXxJlkCKeEjh9IsXL55mS0y6ZIDMVSweAaUWv5YGHJMu42rUHOcdL37lzQEmXfJwkluL551cpKyzHpMuPUjX1KlT8f3334sz5ocffhBdC7loR+DevXuiVZBCzRcsWFAkXq6uriL5Ss+fnFpm0pU+vitWr0fnTm7sXqh9Gpp1DXNc/GYE4Ey6jIu6kvOOrPSDB/QzrsBCa7z4lQcpky55OMmtxfNOLlLWWY9Jlw6k68yZM6J1iw5K1qtXD9OnT+dDunrcN5s3bxbJ1+3bt+Hs7JyQv4zOVqRl7WLSlT7QHDJej4lohpcoufg1QzjSFJlJl3G1qdS8UzJkPC9+5c0BJl3ycJJbi+edXKSssx6TLpmky9/fXwz9ToUsW2Th4qI/Am/fvsWwYcOwaNGihEboXJcUcj55y0y69Mear7QcBJRa/FoOQnEjYdJlXI2a47zjxa+8OcCkSx5OcmvxvJOLlHXWY9KlhXRRgIzvvvsOy5cvR7Vq1bB48WIO12zgvUK5UyZOnIiVK1emyKNCATcIZyZduoFMuW4oTxcXy0ZA3uL3AQ785I352zbjQMhzaARIbHKXRv3J6xE4pJbwP+H3Ec3RcdZFxIq/FUbnb+Zi9S/tLQY8Jl1xqgxbPwpTl23HrqBb8bquieY9BsPH/xtUT6Tt8yu/wteDt+KiMCFornjOWY9JvWmuxBV5806/6aPUs0vW4vfBAfzkPR/bNh9AyHPxTkHu0vUxeX0g4m6VAxjRvCNmETD0W+HqmL51M/rVcdBvsCq8ikkXKeUNVg7qizX7diHoVryuazZHj8E+8P8myZ2ClV99jcFb6dkZN1d2H9gJpxK2CZqVNe9UOA9YJNMgwKQrHdJFyQCJcFHQjL59+4pWmY8//tg0mrHgXohsBQQE4MKFC6KLYeJChIuIV/LClq70JwS7F1rwDZNoaLotfkPgU6oWJt6wRd+90Vja0uZDS5rj8CzdAdcnHsOaPuWQw8LgY9KVWKEx2NihELrt0KD+vBs4PujzVLR9GX7VGiOw/35sH1QjxXzQbd7Jn0yqcS8M8UGpWhNxw7Yv9kYvRdJbxROlO1zHxGNr0Kecpd0pAJOuRPM1ZiM6FOqGHZr6mHfjOFK/VfxQrXEg+u/fjkE1Us4HJl3y739rrMmkKw3StWDBAgwcOFCcExR5z93d3Rrnh0nGTMSLCBiRW/r30KFDU1i7mHSlr4rbdyJgb5+fA2mYZMZmXCe6Ln5v+juh5OATsGm/AQ+2d4WdKHoUAno3w7aOh7DatWDGDUbBnpl0JQU3ZmMHFOq2A5qS3jh73Qc1k/ysQZifM9yxAEGeVYT9+5RF13mni2ovXwlHxQrldLlEVl3dFr834e9UEoNP2KD9hgfY3jXuTkFUAHo324aOh1bDQm8VJl1JZtOHDYqS3mdx3SfpnQJNGPychbXggiB4VkntTuEALrJuTiuuxKQrDdKVKVMmMQkpWbe++OILK54i6hg6k6709fAo+jHn6FLHVFVUCp0Xvyl2bolw1YVf9Z0IGp76AlvRAZiocSZdyYDWHMLAQi5YEFMS3mev48NaUiBcs5zhdt4TwatdkRYF13ne6aBnpZ5dupEuIIGY1p+HG8cH4XMiXHX9UH1nEIanscDWYZiqrcqWrqSq0RwaiEIuCxCTfINCIFyznN1w3jM43c0qXeedaicGC6YIAky60iBd4eHhKFWqFDJnzqwI8Nyobggw6UofL3Yv1G0+mWtt3Re/GhwaWAguC2JQ0jsY27OPTNeiYa64JJebSVdyRD7MAwevYERMqRNvyOmNZqtcsG1DT5ROfeNerKf7vJM3k1TjXkjiJiamwduRfWT6Fg15I1R/LSZdaW1QOMArOAJxt0qcd8Aql23Y0LN0qtZgqRUmXeqf8xkpYcaRrjdPcDfqJd6nMfrMtgVRJN8nH35Np37egkWQ6xPdydH+/fvRUmb0woxUEvdtpDxd/2kQdeeBcGQ2jfJJXjgUzIVUT+29f44Hd2PEoARJSmZbFCuSD5n0VNLFixdRpUoV/Pzzz2I6An3Lnn0H4VirBlu79AXQTK7Ta/ErnVexyYESPdcheGnaFg0zgUGrmEy6UoEoyAN5m8xFjJ07Dj6YjwZX/RDnKeUJbYYcveadVi0BRLr27D0o5hg0dtFn8RviUwq1Jt6ATY4S6LkuGEst1acwEdhMulLOvCCPvGgyNwZ27gfxYH4DXNXifpu4BX3mnbHnPrenXgQyjnRd3oARsw/jVdQ5bD4QAjFwEBWb3KjZ/H/oM3oMBjklcnYQ6n/nPhqrfr+XsPDNYV8HTdzqwmOUD5qUyaUzyky6dIYswy4wiqUr+hJGjJuDV6/CsXf777gXP+dscgsRvTrXQL32EzCsZZHUd7Fovk6Zg7UbTiFaRCEH7Os0gZvbAMwd3RI2H+kHjbFIl36981XmhoB+i980zquY2+B1kJdJV2pgSYFV7OC+aQle/Rgg+6ySfvNOB4UpUFWvxe9NfziVHIwTNu2x4cF2SEe7FBBPNU0y6UpFFdJGlbBBsWnJK/wY0BGH0nG/ZdKlmumsekEyjnQlgkbaXaI/fel/C8cGFk8DOCHi1qdfYk7mLliwfwG6V7JL18yrDX0mXdoQUs/vRiFdqc45W7RbewUBPYpoH6wY8e1LzK/gj1Mb+qKSXTr+ONpbE2sYi3R5T54Kz5EeHEhDJu7mWk2fxW9UQD/U/Xoj7j+PhUY6r2KuAMiUm0lX6kAlvGttamHaaeF5ps3EFd+MPvNOjqrI0uU3Yw4mjh8rp7pOdXQnXYILWb+6+HrjfTyPTS/So05iqL4yk67UVCRtUAh2gFrTcPq4dmuw1Iru8071U4QFNCICqiBdkHaXaGD1/XHz+ECUSDFIirDkhHonvsWl9f1R3AiRW5l0GXEmKdyUsUlXkjnXfDke7u+T5iHyuKHFzb9Wl8bi1JKOKGI43zIq6aKFyze9u7N7ocLzMKOb13XxqwmLdyE7WB0LHVILpJDRI1KmfyZdqeMas9YVeXvtQuJzXXI0oOu8k9Mm1VEP6foQwfFg9YVwSC2QgtxBmVk9Jl2pKSwGa13zoteuxOe65CmWSZc8nKy1ljpIl7CglQ57AxXhExIC7xpJV7VRAb1Rc3Yt/ParB4yVKoNJl/lMe6OTLkguVyLTh//N4xiYkuknACTOv+WNcWpzH6MRLmrcWJYu89EkS2oIArosfjVhi9Cu5wkMjA93LVk54s4pNDPIS8CQMZjiWol0UZ5Fena8evUKsbGxSb7p70+ePMG6devw6aefomDBguLHkkvcWRVgSOBTzHGWP1Jd5p38VpWtKX/xKxCuRe3Q88TAeBeyRG6YBx9gfjMj7bApO1y9W2fSlRp0QfDI2wRzMQSBT+dAh1sF8ued3irjC80YAZWQLgFByYdW+KfDwEMI9W8an1OGUmX0Q83v82LjGT84GcHCJemLSZf5zFzjky4hRHD8ri+hUGf2Xwj2KJ0qIFGHPNBwaDYsNfL8Mybp2rx1J1q3cmH3QvOZ0npJKnvxG59fyHXvEnSUzLIWel6FcvuFhYWJH9rEoG/629u3b3XG+OOPPxaJF5GwxB9aSNWrV0+MaGu+JQy+lapi3OV2WPM0AD3jU1HJGY/seSensWR1Vqxejz6Cld7YRe7ilzbUmm1zxd5EHgyp57cztoTqaI9JVyp6CPNFparjcLndGjwN6JmwFpWjMbnzTk5bXMfyEFAP6UpsebDthE3XtqCzsOkYe84XjXo+w/QTk9HQCGdoEquQSZf5TGglSJeQmCU++7yAQ0UfhIR4I5mBVciFKBD9rncw+eBMtDCWT2Ei2I1l6eKQ8eYzlw2RVNbiN+oQPJr5oMja5Ak8PyT+rD/vBo4P+twQUTLk2tOnTycQK4loPX36NEGWrFmzitFAixYtiu3bt4tJ1lu1aoWcOXMiR44cSb7HjRuHhw8fYvr06eI3faKiohL+Tf9//PhxknE6ODiI5Kt+/frid82ayZKnZggqMjuNXATnogNwuNZMhJ8ZjrIyL6NqsuadDu1JVTM6ZDxtqDXzKYK1ySM4pshvp8fgzOQSJl0pFRW5yBlFBxxGrZnhODNclzuFkyObybTPMDFVRLoSJScU4KjvfxOBTlvgVE9wjwnfjD4KLHiZdGXYvNO5Y0VIlza3VrIW1FyOxqeUmX8EgrFIF7VFC5gc2bPrjC1fYD4IpLv4jY3G+cP+GPu/iTjYcBNebeksxNhMVDQxODn5S9SfchkoORq/hxrXc0AJFMla9euvv2LXrl3iN7kNSqVw4cIiwUr8qVSpkvizsc50vXv3TiRh586dw8mTJ3HixAnxmxaqVHLlypVAwIiEOTvr4oikBGJptanB3SWucPj2AGz77kX0UiHiqg7dK0W6lHxupWdxiI0+j8P+Y/G/iQfRcNMrbOmc1IVGE3MSk7+sj7hb5XeECud5jehkowPyyldl0pUMY81dLHF1wLcHbNF3bzSWttTlTjEt6Xp09GcMmxKAiJoTsO8nF9gqP1106uHxpSCcfv05mtYujqw6XWm5lVVFuj4kJxQAr9gYjZ/ZopeCC14mXeYzsZUhXZQPMz77vABFErdWIfu8n1NXPJ51RvhW7nVrLNJ1+uw51BbydHGxbATSXPw+vY5flu9Mkvcwe/VOGNikeDwgj3Bq9Wocf5QMn/JtMaq1bju5SiNM56wSE6337+OyOTZt2hQtWrRIIFnpnb8yFulKbax///23SLwSk7Bnz56JVQsUKIBu3bqhe/fuqF27ttJQyWr/0anVWJ1C8UD5tqMgV/VKki6lnl1pka67p7di47HbibDLjuqdBuLDrXIKq1cfR8pbRT5eshSjkkpMuiRFpPGMRHm0HdVatmXY1O6Fl/2qodKpMXi2vRtyq2ROxYkRiVVtymPQCz+cPTYQ5dKULQTTvjoMly2jUF1V8isjjLpIlzDGD+HjbeG27gp2dJcRyltPbJh06QlcBlymFOkCTmFc0brwjRQG5SAcpA71R1M7yj5fE8sbn8LmPmnk7TISBsYiXexeaCSFqLwZJRe/GTn0yMjIBGvWgQMHRFEyZcqEdu3aoW3btuK3vb29bBGVJF2pCXH+/Hn89NNPuHv3LoKDg8Uqjo6OIvmiD5Excy5KzbuMdi80Z50YS3YmXcZCMq4dJl064hmzFq6O1zD++kTU0vFSc6yuOtKFcxNRpqYPrglo2nbahGuCi4xS8aSYdJnPlFWOdCUl+l22hqDbvuYYX3A1gqco71JiLNJ1+Uo4ihcvyu6F5jOl9ZJUqcWvXsIY4SJyG1ywYAHoWUyFzl5JJIu+6RyWPsXUpCuxjETAKCLi+vXr8eDBA/Gnr776SiRfbm5u+gwnw69Rat4R6bp9OwIVK6S9D67v4E29+NVXzoy+jkmXcTUgb97FIjxoFXb+FoXMxRuiTQ9nFLxxAIF/vRSFsS3TBM0dInEg8C+8FJwGyzRpjip2Ka+hSN7JLV2x4UFYt/sobj8rgOYD+qFhWkdzBDfKM7u2YO+lN8hXqRnc2jnGRWYW/74Th/58gVzlpb/HIOxAIEi8z6rWQZaIS3jy8h/kq9UUjuJFJNtmHDweibcFPhX+WxjdOtjhj5D7NBg0aV4FdtTunt04fOkRsjnkx5N/asOrxX9Y5tEag44IG9+Le6H0ZzXRqR6Fkab21mH30dt4VqA5BvRriCL3T2JrfHt1ij3Dpdsv8CprKbR0Lpfg+ktjX7XzN0RlLo6GbXrAueCNeAxFUAU5HBAZP466TdqhsJ3pnR7VRbriXbpWxt7En39qBJS0h/I25HZh0mUIeqa9VknSJTy1UK3SGITSfWlnhyL9duGMiXz4jUW6+DyXaedjRvWm1OLX1ONZunSpSLborBRZtPr27ZtAtowhS0aSrsTy79ixQyRg27ZtE/9M59CIfA0ePFgM9mEuRcl5p9SzS97i11w0oJycTLqMi632eacRPGkc0D/nOtwSUnfc9nfCl2u74OSRnoga74hGG9vi8J+z0ChzDNb1LIttrX7Dsu4Fcax/5ZTXBA/BP4ncC//d647K32bB6htCmPtnggWp5C9ocOosRsYddf1QxLV2Pez/5hz2DbLHsYFV0eOfJbg2pxAWObXCbd+rQqqEHELk8N6oO74U1p+ZgOqvA/F91aaYn/17/BbiC8eTwtGMHv9gw7VFqLCtOVo/8EPYuKpCuPEVaFH/Nn687on88zuixMwvcEawYr0eWQrz653Cxo75oRGSTZeeWR0XBZfIuyT/YlexTpylKwZ73Svj2yyrcUPIa/FMiDJd8pcGOHV2AHJSeyPOof2C49jQJzOWOlXA2i4XEDyknChr5f45se7WfDS77Q+nL9eiy8kj6Bk1Ho6NNqLt4T8xq1FmxKzribLbWuHqxt6wy/qxcZUvozX1kK74SXBiYDjWF/GNS04oDKCiTwhCvGvodOhXxrjFKky65CKV8fUUJV2QQikL46w/G38FeqC0bmdn9QbIWKSL3Qv1VoFZXajk4jcxEP/9+y8yffRRutgEBQVh48aNIMsOhWivXr26+PHy8kLu3ClPF9C5p/nz54tki9zw6EyWu7u7+DG2+51aSJcEIEVFlKxfIUIeSiqjR4+Gp6ewMMmfX/VzUKl5x+6FGa96Jl3G1YFW0vUsHKXsXNA5OAK+dQSOcm4Pfn9VBm0blIaNmNZjEdpeDMOYSkK+uA6/odP2MagkplRanuo11xNIlxM2OhfF95UC/8/edYBFdXTRg70XYi/E3pXEil2xYNSIij1KLFiwYOwKsSYSxRZQxN4wikZU7BW7YlcExf4LoiIGbKirAv/ct7uwwLIF3oPddeb79kPhvXl3ztydN2duQ5RQhE9e4PnvFndwZUJSS3K0T3eU7PsZqyL3wb6IDPdP78W9fM1R53JfWMy1woVQVzDRWKPwi1a4Mus+Dg9+C7cfauGQYyj8h5clExs7rA7AlNc7UXddA1iurIBFnrPRtW5h/HcnAmWbMOsWI0JmE8oLhOqlQy4MDB6FZcvHonWVWNxnp9xNmFVLsNSpki4hy+o01FLWEiT3Q3NGHu8w8niX9TeoUELtND97M0wofxkPZpthVqX6WNfrAkLloGL/mfeo8nMLtpeT12Rd+TMrJzKlFgth6o5jPXYyfMWdd117MwzSxcyOvkOtsCkhhkZZnJANIyHORtch6X4dJ126Y5XZV0pKumQsS2HBrvBmxlVN9bqkwEAs0rX/4BE0YIk0ihU1/A2cFDh+K31KtflNxO8LAt2aoMc/dXHv5spUYZ0yZQrc3NyEv2c1/x5xeUsgC0vmERvzHyNTJRixWo5u3boJf793714C2aIkFJRhcOTIkQLZkqoZGulSHeeRI0cE7I4fP448LNsoES/65M6dOwkcu3fvNhh3RKn0jkjX/gNH0KuH+G6XWje/UimfkfXLSZe4E6ZV755fhVmpudjCyErfFGdT8rIeTuWPIKzDDtiHTcK2wYzgEHnp+l7tPYnuhXlb0g7kAAAgAElEQVQwxqwr9nVxxaoBiTVH8+cIhbuTB24rh9n+b2yrNAtWSaxL8j8Siel6foaK1SlYIFqrrE/h6uLvsJL9O2DKa+wkwVVIV99cT3FqzR+Y47ULF4M/oMLobdi/tBPKqpCu+jEh2O42BUvWnsL1V/nQcMFunB5TPyXpEsa6D11cVyFxGAoXy9OJJI6sYomkKxz2bOzvtyhkSzalAsl0Ko8jYR2wwz4Mk7YNBkM1U5oBkC550oJpZX1wWSWGRlmckDl8oce2+yylq/iRXZx0ZYrOpemhkpKuABdYNHZluXZqYu7NIDjXSZOIabpJLNKVpofzm4wOAak2v0ogog84oGqnAPQ/eRyLW6pfc8eNG4e///4bOSo0Q2wDRpwKlE7AMT40gB2OeiDuzTMsWrSI1b67KsQ2UaN06kS0evToITnuhky6lIMnUjV//nwEBAQI1i4iXmT9UjbCmMYxc+ZMyfHS9gCp9U7b89Pyd62b37R0aoL3cNIl7qRq1btkli56egRzs/5Qty4omknIqNw7FK1aFcevq9bCls5Rk1m6VO/5kKqli10VHYjzYay2YJ2kldCTWrqoN2btunYXssu/oXYSS5c/nMzb4LwLWctiBQKmjnTV3ToQu+pvwFTGhGRP16NXJU+0uKGwTCksXVHjB+Kt8wb0YOOJYe6Fll3+g/vjtSi3Umnp6gX/7tth7V4Kk1UtXcIwziOsbBPUSZV0JbN0yQHCtQ91UVcOKkaW7I3QVq1Q/NdVWCuAmjktk0lXBI46tcTYXGtSxtCoFq5t6olHZ0cKCilm46RLTDSl7UtK0iWcFE1htu78Q3EwchU6ZJBrISEmFuma+cc8TJ7gxBNpSKuGmd67tJtfhYdBidTXW8osSGnbc1RujdhWqZCB9y8Rt2MgCubNAXIp7NOnj0C2WrRokWH4GQPpUoJBbodk+aJizxTnReRr1KhRGDRoEDZs2IDHjx+zJDnlMgw7dQ+SSu/I0uW2yAOzp08VfXxaN7+iP9E4O+SkS9x50653ipiu9+4IYDFNFSJ84eD0Bs7M+iIvVy9fh5fbnsLLRco1k4wTLKZLzT3vXWvB8vxkRO6zR/5AVnux7WmMPOuLQVW+4prrYPhZb8Jsq2SbGkU4zzoWL3ZzNnPHY/fZbawPX9cicGcxXQHjTzNrVgVE+PZBbZeq2HNzNqxyysMwzk+OxD57RloCXVHL8gAcH55Fqx0/oPWt2Qj0tkUJIjiWO2B7cSVaHeuDXOMqCO6KEfa58EfNizg3xVJwo7T+JQ7LWUxaeWbZKshcBg9E9cPx7ucwYOdofGYx9W1ZmvmzvoNQ5es1uA72g/Wm2fhxX2J/Vowo+vbJhaHmR/Ccxca9FmK63sM9gFkQK0TA18EJb5y3YbAcVHlm9OW2OPVyETLuTZRStzKRdMnYPDdDnyd/4MjiDvKsKUmaDEdHlkR7LyGyC7PYienMuuLuhjnpEnexkbI36UiX3O95wB4mfRdvRPn1R9IzISlHJR7poo3LQHuWmpq7F0o7YZncu1SbX2FYioQyud3v4YJTonuK6pB79eoF311+MOvpzVINpu59EB+yD3FnFmLx4sUgy1hGN2MiXUpsVq9eLZCvBw8eoHr16oK7ISUaacVOZ0+cOJHRECZ5nlR6x0lXpk6r8HBOusSdA+2ki56nkomwRmf06anIHKgQ5ezkDjhnfyhZ3FHKe/LeTcx4CEXmP9nTy9jz7wEEffwODboPQmdKcaiuqWYvbNAdgzorsgAqsxcGPcHXcr0wuB/Jlpi9kLoqVaUK3jG3cUWuRRSIfYyoIuXw+uolPM9SAZ379ESDL1fl2QapscyB5mGnEVOzCB4fvYf35nXRfVBnyEVj49rnic3H36LKoOmwryOkUMTTy3vw74EgfPyugfzal4rshYr+quS/h3uK7pVjT8xeWEMugyqxYNa1DufscSizgrkUc5BJpCsG19zaw/qcA4K2D1JDuBTSCSbV2XjI/pukcK1I3xFNpOvGjRvw8/NDy5Yt8cMPP6BQoUIiPZV3owmBL1++IHv27CkukYx0ZWI8Fw1SLEsX16pvAwGpNr8CeoIvvTds1r3AoUHqCVUV9rJ98DYHsnTx1Az4uxeI9emDqVOnCvWrMroZI+lSYkRuhXPnzsWrV68SYKMsiJmZbl5SvZNIOXTb/Er0cCPqlpMucScrrXoXHbASf5yrjOmjYzEzk+OOxEUkE3uLDsDKP86h8vTRiJ1pj7BJzPKVWcFcmUa6GIs+OKktui2tjU3v/0UvjWVY5FlHRp8jptwD2+6z60UM7dJEusgthjJxUVYuZaOXHrl5WFpaCkSMPryJhwDFgEycOBFDhw7FqlWrknQsGelKiOcqC2eWTYi5M2doE4t0bd+xG506tufuhRk6exn/MEk3vwrSlVoyma9fvwoHImZVfkKWllO0Dj5+Y0d0YTpJhCGjm7GSLnrvzJ49W3ArpH8rGx36RUeT1wfwgbnkUcZISkpC76iMOBCUUu/Wb9qCQcxKL3ZL6+ZXbDkMvT9OusSdobTqXdjGzqi3sSn+/DEAL3pux4zkLoHiivlt9Ba2EZ3rbUTTP39EwIue2D7DSpJM6PqAmSGWri/vHuPM4asIueWNde6HcfUN1eCqiAGe7hjTRVlcTVVsGaKDzsHvwErMm7Edd+ly1gors7KYV0ObprVQOJ3ehtrcC+nlN2vWrBR4krvHkiVLOOnSR9M0XBseHi7UraHAcisrKyxduhT16yetTS4m6ZJFB+Hc8RBE4SUO/T4eawUFq4mhq2ehPTNo5v7eCm0blMmQL6dYpIunjBdJGQ28Gyk3vxBS9Y7ACZt1eHFokNqi9HXq1EHQs4/I0n2NZqReP0Hsv78KBGLGjBkZjqoxki4iWeSKefLkySSHfUrwKM7r4cOHCYWklb9v1KiRkNiE1k6pmlR6x1PGSzVjuvebmaSL1gcxE8V8+fQBIfef4SsrWVHFomhC0Vzd0Uj/lWklXfTkuC8yxGbNieyaq3WkX8hvqYe4L5DFZkVOAwE1Q0jXqyvb8OfmC2qmOS+shs5An5rJ2dN9+M3yxInEg76k9+a1wtAZfZDiNj0VSRvpSm7typo1q1BjhiwxvImDwLZt2wTCRa40ZOVasGCB2o7FJF0hvi5YcSYm1QHktRqKGX1qGhXposFIVWRUnJnmvYiBgFSbX7ls8vTAU272xo5PPrBTc6j166+/YtOmTchi6wWzYtVTHVL8tY2Iu7pecNHu0qWLGEPXqw9jJF3JB0heFvQOop87d+6EtzeLo2Pt5wJZUCWnGbKzotL3ZHHY9SYO8ez35JJINdKkaFLqnVTrVno2v1JgaKh9poV0xbE6fvTOps9///2HfPnyIW/evEl+0n5JW1MeMlDMoiaL7dmzZwXrLn1IF8nCa2Njg/z58yd5RExUOAKP/4Plf8zB5he1Md5rE1ztWP0rbYKI+Hej1ruv71mR5gO4ecEMTaf0RJ0cIgLDuxIQyBDSZahYayNdJLeqtStbtmwgF5vMilMwVBzTItenT5+E9MjLli1DmTJlBOuWppgFMUlXWuSV6h6xLF2XrlxDQ1anizfTRkDKzS8hF+BigcaurzH0YCRWqUnjefPmTcHCb1aiNrJ09mBvELMUgMffP4K4k65o2doaJ/2PZ8qEmALpUgIXEhLCapvVRI74ePxdKhsscyfF/OXXeCx8GYvTMXE4duwY2rRpIzrmUuqdVGuXUW9+RZ/B1DtMjXQR2b98+bLwIcJPBKtSpUoJZEubiJQIhshY0aJFhcQwyT+5cuUSvFuonh8RLiJeyUM2yKV2woQJWL9+fYrHlS1bFh4eHqnsG+TZ/rp654LjkZtY3i7j0mMZu97JWMKJys1DsSSVgzdt887/rhkBTrp++glbt24V0hqra3TSWLhwYWEx8PHxEdw/Dh48iLqspgK5GGZkGmRTUWaq2zNt2jSEhoYKuBPhojo1mhonXZpnn7sXmsq3Q/M4pNz8Ck/2d4J5m6XI53wBoakEOFKGPSqOjELfI4vVSFbo80dWIZkdiX6IQvy9Q4i7LI/HpGREFP+aGc2USFenTp1w4MABrCiTHT8kI1xKbMO/xKNf6FdUq11HwF3sJpXecfdCsWdK//6UpKt9+/bCfkZJtJ49U6aGA+jAma4jt396V6t+6FCA9kPv378XPjExMQn/pv+/ePECd+7cwcePH5MIV7lyZYHE0X6KGhEviv+k8A1qb9++Rc0a1fE0/Bm6MOvuzwWzChbe/9ghgy+z7h6LiUfE5zgh46dqfbuEh7C05M0qjkZg7x144mOXYVmJ9SFdRGw3btwouBQbTMiKkMX2GqZz0qX/l0mHOzjp0kK6CEOydtGXQ3naQv7z48ePFxYhFxcX/PnnnzpAzS+5x1KMkvuLr68vSpcuDVdXV9jb2+sEDCddmmEKvh3CkrxY8EQaOmmT8V4k1eY3ARGZL/rkYkmLrNxx74IT1CeOB9asWYNx4yfg/bu3wq1Z8hdD3LuXwr+bNG0O978Xp4jLzEjUTYV0UTbXHDly4Ce26ZxZPJtGCFf9F4t1UbGgdZY2tGI2qfSOSNf//hfKNtfVxBRX6Eufza/oDzeSDv/9918oP0qR8+TJgwYNGiT5jB07FufPn0+SUVPfIVI84u3btwUCpvwEBQUJJE210T5r4MCBcHBwwNq1a9GnUFb8VlS9q+KwsC8I/BQPssBTvGnSpnCXfsTcpZ8wd+kMMnZp0jvaO5Kstra2goVOeahPchPp+u233/SFVfzr1ZAuWXQ4It7FImv+4iidkEwhBpGh/4GoNLmS5ihUGkXzJv1dkRKlkVO7l6n4YzDgHjnp0oF00RfD3d09ScAnLR5k9Tpy5Ahq1Kgh/I1q2PCmHoF58+YJhIuIKsVwURppcj3QtXHSpRkpqeIidJ0ffl3GICDV5jdR+jCstLbAiBM2WPfiEFLJHC9c/vTpUyHWiOIs6FCKvAEo1kLXgxQpETMV0nXp0iVQooyxbNPZl20+NbWT7+Mw9flXUJys2O8iKfVOqrWLky712kJ7FiXRou+JsjVp0gSenp5qE4RRXGZ6SVdyaWjNoPVCNUsnXUMWL9ofUEH1zuyw4XcNhw1BjHA5MOJFLoq0FiVvwW4/oNaUR+i94wl8Moh1KfWODpVPnToliKRMFlK+fHlhrSTCpczqShhQI2JLZDPTWxLSFYGzs7pjitkCbHcogCMTBuKwzWasHZQD22wGIOyvI5haPgjzWg9B9k17UGJS0t/1PR2EKgUyfUQGJQAnXTqQLk0zRq5xlOEwKioKnTt3Fv5dr149g5rkzBRm+/btIMJFGzPKrkULUevWrfUWiZMuzZBx90K9Vcoob5By86sERL5Ruck2Kp/YRiUjQ9DFmxJTIV0XLlwAbYbHM9LVSwvpOsNiuiY9+4p//vkH/fqJm4JdKr3j7oXi6bymnijZBZVkIdf+J0+eCJdaW1ujZ8+e6NGjhxB3RRt+dbFTdK3YpIuIFu0DiIBQGR46sCFXZHItpP/TvmH48OHwLJMN9XJrTuU34ukXvC5aFo8V40qCg6Lg+yOJXQzJpZdcBMmKReT0u+++Ew5LyLKlWu6BDuopjo3GmRrWGaMRGp6iQro6nx6JkgPyYc8LNzSjWyjDbeVtsAsciYt1vNE8eAPsKxbG/1aMx4nWLXHecl2S3+XovxjldT9bz/ShZ4QAnHSlk3TRJNELnsgWfcGoOTk5Cf+nWLBvtZGf9vz584WTHsKBYrjU+l3rCBAnXZqB2n/wCBqwRBrFimqOjdMRbn6ZgSIg1eY3yXAVteteDz2IyFUdMjTzl1iwmwrpojgYcvfSduJPuK1lroWrmYsheWFQ0gIxm1R6R6Rr/4Ej6NWjq5jiCn1xSxcEKxKRrYULF4KSV1HsFREt+lSsWFHAKS3ZC9M7Wcq4QyJY6rIWkpVrxYoVOFoxB/JrSZ++ODIW21/HIiIiAsWKFUsmmsLFMHQAdj/cBFsRtmSEKREs2tuQdYrGoEwIQg8na1aJEiUwefJkDBo0SCCUZNXKiHp66Z0X4X4V0lV4kjna+E/EzSBnyJ03/WBv1hUv193FrGeD0Pb380BRK3SbOQ9/OdTB04Wdk/xulWNLaOHMoohsTJ1w0iUC6VJO+LVr14T4rz179qAgqxNBX0jy0f2WyNe5c+cEsrV3715kyZJFyPRIn+SpXfX9knDSpS9i/HpTRECqzW9SrPzhZN4GS/NNwpn77ITTCI1dpkK6aF7oVJw2eBstsqMqSySgrkXFxqNvaCyKWJTDAxY7I3bLGL0TV+pvmXS9e/dOIFpEuChmqmnTpkIWQHLDS94yg3Rpm2nyiKF4+X+YzldMReeVfUxhLrVX43PjHUvaoa5dnVUJ9WdHYcDuh9iUBtalJFhkiUseh6WMP1NNuEZZHimzIlm86PdGQ7aU4KmQrtJzWDZbvxEpSNfHbUEYVyIH6jUqgle3d2OMjSNiF5/BFItCSX435eobNCprhC8QbQqajr9z0iUi6VLOw44dO4R6U+SPnzNnToF4EQGjF5epNkq/v2rVqgQ/ZYrbIrJFCTPEaJx0aUbRbZEHRjk68EQaYiibAfeRMZtfGUu3XJClW66EuTeD4Jw8Pt2A8VGKZkqk6+rVq0JSkrrsyHhisayokCMp8XrFsrkNffoVz1kGQ6nqokmld2Tp8vRag8kTnETXqm+RdMlkMuHQk8gWZf8jl36qf2lnZ5cqvoZIushTpmPHjqwmXVa4FNccy9j9SSwqNmqC06dPqx/j1VmoVH82ohyP4Pnydhot90o3QbJOKbMo0qE5kSfyXlLGZikP0un/yuQXSoJl9HqnGtP1gGUyrHcOE5/4oX9xQMa8IGp2DMOih3bwbXAJI4PnwopxKnJJH553JCoseZLkd1E9z6F5+byif7eNuUNOuiQgXUqFoMBOSsChXAyIeI0aNUr0zFKZqYCUXWjlypVCmllqVDyV0kmL7d7CSZfmWZ75xzyMGuGQOe6Fr2/j4EZv7LxRCg5eY9AoV2ZqZMpnvw0+gJ2B5mjX1wriHAFk3vik2vwmH1HYSmtYjDiBLt5R8Osvgk9OBkNmSqSLoFOuf/Tv/oWzChavbIx73ZNR+ux4vI2NEw72lC7uYsMtld4R6Zo5Zx4WzpsjtsjfnHshedhQVmXKEtiwYUPBsqVLQhVDJF0kU03mIhv64D62WGRFcVJ2NW3pq1j8Ex0LLy8vjBgxIhUdUmYxbIolZ4/jtzpyy4vSTZD+rawRSnFmZNlSTXRBvyMyRjFvlGGQmjIWTd0DjZp0fXmPLb8Pw/Jz7/Hjz44YM6UNCpz0xHQfGazb5sOZvS/w8+wZ+KncKYxvyeo0/mSPtpUi4B9gDgfXoljVLunvZrj1A8uFwpsKApx0SUi6lDhTjRUiX5Q1iFqHDh0wYMAA0YOdM0qzKSUx1TYjsvX8+XOhZgcFvdKHzOpSNE66pEBVxD6F07EATH27E33yi9ivCF0Fr+sGh71tsGzTaNRLVTbK2jcWBf0MT35VCKTa/KaA+YADcnVai1brXuCQphSGIsyPFF2YEukKDg4W6hlSem2KH6ENn2qrwmodLWKbQUrkJFXLML0TcQBGvfnVA4fPnz8LmZSXL18uhDIsXrxYryx4hki6aPjkPfMT25+Re+HYIlnRME/S3bs7i+XaymK5bFkdu9379mlGLOIoJrTrhsUvamP8stWYaVsLM6eOU5vogg4uyNJFyb+oKbMr6uom+K3onR4qyi/lpEuOgPJLrak4spjaQhXXN2/eLFR3p/orlOGGyFf//v0NPuMhFUokt0n6nDlzRoCFFiYiWsOGDRPit6RsnHRpRpcSabRq2Szz3AsNmHTppJeyoxhZ0gstnnDSJeAlkK7t6JqBqZZ1micdLzIV0nXs2DGBcFH2OaqNNmTIEKGoPJ28kysZpZumArNSNylJ1/Ydu3kijTROIMVOk3XrwYMH6N27t0C4SpUqpVdvhkq6aBCUTGMCI5QfWBIQsu4KxZFjmYX3M/DqSxy6s1T2y1lYQ/HizPdNa5MhOugcjl85hL+dVmHipg1CjBuRKdqb0X5GX4Kl7pGcdGmdiG/6Am7pygBLV3INoyrtSvJFwZbU6ItKFjDlxxC0kixaZGqnzDtEUKmRVYtSzNKnTZs2GSYmJ12aoU5byvgYhGx3w6wjUShXxAyFGozBuKqXMNXjFKhcZfYmjvAcGIs1w1bhEvt/Q/bTofZTnFozH2uD8qJUnjiU7zYBw5uxF14y0iW774v5S87jQ9ZwhJZ1hNvYliijLp5Wlkp/MSHYzuLULn5gRT7e5kGTcVNgVzkngv4ZB49TMShj8wtqRjzEe9ktPLIYCWe7ysxXn9UUWckyXkWYIWvsO9w6EouhOzvh5p/bcP9LQwxb5YD66q7Z1RW3hw/EuD0sNfKUgahXviWGDm+JknSt53xsD8uB6Hsx+Nl1HnoVDMACob+66PZLDoT9D3h2+yPajh8FgoFaTMh2uM06gqhyRWBWqAHGjKuKS1M9wMQmUOHoORCxa4ZhFQO1zeDp6G2lu3VYys2vqoY98myGiqPzaa3VlWELgJ4PMgXSRYdzVPOMkhD5+PgIMS6Z1aTSO54yPm0zSoe2RLaWLVsmkAaK4Ro8eHCaOjNk0kUDevz4MWbMmCFYnsjq+x0b748sxpFcJ4cOHarnmCNYvGptDMqxEQ8XNsYTRcp6Xa1YujyMky5dUPp2r+GkKxNIl6q6XblyRShUSIGjt27dEv6UN29egXwRqaGaX/Shit9St7CwMIFkKT+PHj0SHpkrV64EokWV1DOjcdKlGXXavAi6w9JL69qClzRAvY09cfXGZNQ8PRVl2u+B48XbmPiS1eZoHw6PKBY8y8J5gt2s4VxqLYvtKcQMIFXR//NqPNxki/cbO6P68HzYGOkDu1AV98JIVsujhhc6XL2ByTVlODqyJAbk3YMXC4RKHyotWn1/T53x8Ke2CPr9rjzbVIQv+tSejtoHb8Olngy+fZg+XvkNJy4vQStshq25KxreYH8Ld0CR7bZ4vOFn5Af58U+HxRlmuXrsilqWV/A7uT6eSeUaf3uYdX2PrQnukTL4O5VFj9fysRZ+5IlmNfZiyANWMDiK+puDYivvwH9YeQS4WKDVwyWI9LFD/uAlaFBvI3oKYz+NqWXaY4/jRdye+JJZ0toj3EMRI8VIqrVzKfzr1x/f6Tph7DqpNr9JRZDHQGxqfwZn3JrB+CK65GU8aCNF5TvItVtdo0B5qllEmzpDa25ubkJsbJUqVQRXbkr1nZlNSr17GflKklhUU938Xrx4USDjdChKxIMIV5kyZdKsHoZOulQH9oG956iEQlpbtE93lOz7AV7P2TpeIq29aL7PVPVOGrS+vV456cpk0qWqcvfv3xfIF1mV6EOLITUzM7ME8kUvX6qvQVkBaaHNl0//ynPR0dFCLZfkn6dPnyaI06BBA7Rs2VLI4NO2bVshC2NmNk66NKMffDsENWtU02OKPrG04LlxbMIN3HaxZGmJohEe8RWFLIoiL65iVqWmjEw8YPE8n+Fp7wVLzwVo9pqRKYuxKLYjkhXNZcFRMZEIfZ0NxUsXRk4VS1dtL1Zcd3Fz7Ls0CbWZRF+PjEHFxQ1x47YL2JMSGxVaVNNfoSvsGYwAbVAhQES0fsm3H5/WdGQnlWYYU/YCQudasb6obsgEVLjyALNiJqBY+7WwGOSKqT1boHHV4ihUmo1H1Qp3PZVr/JKRLhnrt2BXhC+4hfW2zNqGB/Bs2xFP/mJjr+bF4tdYRqcEUsrGGzAVb3f2wWUnVtfk2ATFWJk7S3gEvhayQFGWwIlSFzdl2Z8eHBqEz5728LL0xIJm+gXASbX5VU1tXK10Xtx7lR2nQ18nWO/0UCyDuNSYSRdZMChgv0WLFoKFyxCy3kqld6Qs+q9duqmYKW5+6YCWwhEojkvpbqobGqlfZUykK31jpbhdC4x4twR3L/+GKunrLNW7TVHvJILqm+yWky4DIl2qGkhFMS9cuACq/UUpg+knnWwlb+bm5gL5omJ82bJlS/hkz55d+DedDFE8gOqHXBNUG1Wjr1GjBmrXri2QLCJb5EZoSI2TLs2zob974QdGVvLiTSrZ6QT3stVdELT2A6Yf74mdk2sqXAiXodOFUAh8R7WpEJsC43Kh05GROHT2NySUaM16BYuajmcUSdEsxsDPKxa/1krZ311mgas2vqyK1YlRK0a0ur5ch+eMsFxk/55Q4QoezKqXlHSx/8aE+GPj1jXw9d6Dc1EDsDPCCx0p7a1Kkg+11xxKJF0/f4oEojajVbXx+M7zDlZ1TjxZzf0dI1D/S9ofpctVki5/kvONN6KYBSuFhYisZRVXo0vQWnyYfhw9dzILo55fMrE3v1S8kyzbygKeJE7RvDnw6sMXjHX/FzOH90DhzD1v0RMh+eXGSrr69u0rEC2Kz6GfhtLE1jvluLh7oe4zTBYtSv9uYWEhhCc0b95c95s1XPntkC5FFsOoabgQ6orkrzBRwGSdcNIlFpKm2Q8nXQZKutSpW1RUlEC+yCKl/ISHhwv/fvnyJb5+/Sok6FD9mTt3biFhh+qHCBW5rRDRog8RNkNvnHRpnqFLV64Jli7d3Qu/wrNZdsxscAKvlrQSOpcFbsLOz/boW5/9J9oH3Uv+hpAqrTDpgA8GkfeKkGyiPULmhTG3Ork7S8TRTbhSzR6d3iYSEZv9zIVjYD5se7MJtsKG/RH8VtxB3RGdkCR6KbX+vjzC2E6nMTnMH/LHyF+Wq9qdwXXmokjERi3pemoP6whXhWyP2PjqIGDSc3hXIsuUIrMicyNUew1GJbgX5h7VHR89XRDyY33sHhaEG0Q4afgBK+CdbQQccqdOuiKJrM5sgBOvyPVRABWbdn6GvRxU+HQvid9CqqDVpAPwEUDVr6Vn87t7926heDtZtZQudUS6NmzYIKo830MAACAASURBVLjikQWc2oYN6xFy2Q/BOw/iaNYB2HTWHb3KGVetFWMjXVRygzLQUXF5qvujTE2tn3ZId3V69E6TVES6yNLVsL747pOmtPklN9mlS5eiWbNmAuH6/vvvRZvsb4d0yV3d23uVkrT+oCnpnWhKxjtKQEAv0kXpak2pkTUpIiJC8JmnDFG8GS4CStJFVj2y4JlKIzcRygxJxbTpFDMjmyxwCaxbrEarfZcxo2YQ3J12ob7HPFgLJhr5C6r3+/XymCaFYBF+Dqj3axTmBW1Ft69+mDH9PQavYRmgTv6Bxh0uwenaLjj+GIdjDo0xPf9yHJjXHO+3TIR77snw6lM+xfDU9uf9C2KXWKPtGUdc29oNX/0cYe1eFVv2uaD21xBsHFAdMyx24eb8lsgRsRUDqo9HzlU3sKaAK4qNzYI9Nzfg53xnMbn9MjTy9oLVfRXZQicg3/Bk12xjMWnx62BT2QMtz29Bnr/Xoz5zp2zwmOHT9jB+Oe2LIfmu4K+5Z9Fh5kiUvZnY35Byn3Hpj8bosKcPjp2ahmZFwrDcugVWt9qHyzNqIsjdCbvqe2CeHFTGW1m8XO/3WP+QEdI0BEvpuvml7HYbN24UrFiUmYtIFREuKvBJjQgW/Y6I2KlTp2BpaZkyzXQEc7Gs3RXeb7tg3YPtjHjrbvKiwyGKV6Xgd3JNpix7tGEk1+iMaMZEuv766y84OzsLsMybN0+I5TK0pqveGZLcxrL5pVIAAQEBQkZKygJMVufGjRsLtS4p6dYvv/wCqsHVr18//PPPP6JDbMyki0Iy6KCCsKN3KWFHoRG03qhrMuZGXrCrNyrNvYkgiaq+G4veia5IvEOdENCZdCWvDaJT70ZyEaU956TLsCeLSNfZs2cNW8h0SNeJ1RpJD+nS371QISyLy7p+8RQeohraNK2VxJXsUSpxR7Loh7h2/jqizOujVeNyyCvEg70Dy+TLGrOsCnFhLJ7p4TWcvx4F8/qt0FiDpSRFfwmiXcfFUw/xsbTiOez3MZGh+O+j/IKsLKtbjnfvoPgvcr97ivs5qqNA2HGEfCyN+q0ao1y2ZLLF3sfNr8muURhxZNFBOHc8BNksf0YLlilRaMnxYdYq1bHmz/8Z797JR84Ekse3sdyPkdcvgomOam2aopaqfx5zMbT3soQns9jpF80lf4S6zS9ZrshadfPmTaFALm08iGxRUU9qRLrIbZiuoxTJ9PeZM2cKpEtbk7EYtJqNXfHQZh1eMNdOXRIzu7i4wNXVNUXXFJtKFhySUepmDKQrMDBQsG75+/sLhJSwqc+yshlik4p0fevuhXPmzBG+i+oaEXByMSVCMW3aNLXfKTF0xVhJF6XHpwLQ6hqtQX/++WfKPylidb0rzcXNIGfUEQPAZH1w0iUBqCbUpU6ky4TGy4fCETBJBKjWDdXpKlY0nbF4V+ah8cAYzL/aCYf7nka/NMQdmSTA6RrUFcxrPBAx86+i0+G+ON1vJ8tsmLYOafNLBciJpJN1qmvXrgKZoqKo1MiSRZs4+l358uUFsvXrr78K16WtRWOzrTkG7GkKz0dnMTKlsTJJt5R05/jx48hRvgm+1ugJsyKVgdjPiH9wDPGPTyM+IkhIbb127dq0iaPjXYZOulQ3jMo503FomXKZlKSL1q5B9v1EH5ehb34pEzBZsLKXrY/Y2n1h9h37riAO8f89QPzNrYgPvyp8r+kAY8SIEaLjo+zQGEnXwIEDBUt+rbzZ0SZPPGzymyE7O9S5J4vDtug4nI6JQ7t27XDkyJFkuMlYfHBBdPWuhvlBlGFWfFgNXe/EHzHvUR8EOOnSBy1+LUfA1BEIXoduw0+jctO8sOj2J0ZbpcEHztQx0nt8wVjXbThOV26KvBbd8OdoK53TsBN5IqsVNSJOtPmNiYlh1rV3wv+phh41pTsN/S61k3O9xVbcELbSGhYjTqBLKklXlP2Si+zkyZORpd5gmNW1V/u4uNNuiL97ANu2bRPSXUvVDJV03b17V7BuUZZacoMi61bTpk2lgkG0fqUiXaIJqKYjQ978Ll++HKNGsThSy77I0nC4+u/KhaWID/LFunXrQLGXUjVjI11k/aOEM7YFs2BaMfWhBmtYBeU1UbFCOn3KBqra5Gnjd6Ha/MR4XTGxNWS9E3OcvK+0IcBJV9pw43dxBAwKATdWSHiUo4MeiTQMSnwuDEOACBa5cRPJomQK1GiD/vfffyckuqDNL8VIEakgK5aSdEkKYCDVJXNB6NCDiFzVgblPpmyfPn0CJe3JVrI24jsvTV2cz+8R7zsIFkXz4bGiDqAUshsi6fL09BTmk5IdSekuJgWeUpEuci/09FqDyROcRBfbkDe/VOrlU+6SQLc1qY87jrkt7xyEgllYBuJXLKOqRM3YSFc5lr1RFvEMW8pmRZ4sqYPiEPYFwTIIsV5J4sCFJFF9WaztMjw8OwoVRMbVkPVO5KHy7tKAACddaQCN38IRMDQEZv4xD6NGOKTfvdDQBvYNyUNJLSjmihplF6TERcrfUfwVJaWgAHtyK6TTXl1issSBz5/VdGuDpfkm4cx9NzRTw7ooEQDJlqXxGJjVstP42Ljz7ogP3oVXr14JWVWlaIZEusiVkixawcHBqFOnjvBva2trKYYtWZ9Skq6Zc+Zh4bw5ostuqJtf0oNatWohS31mEf5RvUVYCUbc5dWIv/EPHrEDCnIXlqIZE+miLM3FixdH70JZMa5oVo1wbH0dC/fIWFy6dEmwKie2RJfpZQ/PYpTIrMtQ9U4K3eF96o8AJ136Y8bv4AhwBCRFIBa+E3piru87DN5/FKMl8LuXVPw0dq4am7V+/Xohm6DS+kUEjEiWVJtfzSIr4yAqpZpqecWKFXB0dESWzu4wK5mkBHaKrsm9kNwMjx49KhRel6IZAumi4rUUu3Xnzh2UKlVKcHNKLfBfCgzE7DNz9C59IzDUzS9lIKQCx1ls/oKZRWONg4x/dBJxx2fB19cX3bt3Tx8gqdxtTKTr8OHD6NChA6YXz4ZOBTSYudhYr36Mw6inX7Fq1SoMHTo0yeiF2opTvkqSOt5Q9U4S5eGd6o0AJ116Q2ZgN3z5iHefvqZZqGw58iB3Ts0nRmnunN+YYQjsP3hESKShe52uDBMtbQ+S+aJPrpmoczMIEmX2TZtcEt9FroVEsFIrz5FZm9/ozbYwH7AHVu73cMGJAv6Ttv3796Nz587I0toFZpXaaUQp7uoGxF/bgJCQEKGQaPKWnGimBfLMJF20ySNrFo2vdOnSAtkit0LK3misTUq9o0QavXqkNdFL6oga6ub39OnTaNmyJbI0ZTpRw1Yz6bq1HXEBy0F13KTKbGlMpOv27duoWbMmhn2XFYPNNe9bDryNw5yIr0L8JBG1xKY4RDo5hlnuF6i13Kfne2qoepeeMfF7xUOAky7xsMyUnsL2z8Effk/x/uFJHDh3H2+YDzNY1EXp5t3RsVq+FDJF3DqCq3deIFx+IX7dcBsbfq2eKbLzh4qHQJpTxosngsg9sRpRZi6o9o2RLm0gSrn51fjssJWwthiBE6mkjqci7VRDD0WqImu3lRq7iv3HDvmyfMbevXuEGLYnT54IPyk1Nv0k0pXeAsGZQbpWrlwpkC1KlkEZJolo0ccUmlR69y2mjKckOAUKFAAKfY+sPTdq/q749IPZ++egelRS1bgzJtJFYFE8XF7ZB+wpn10jdr+GfsFdWTxevHghuCQqmyyQuUg3XIgGex9jeTvxi75z0mUKK550Y+CkSzpsM7jnYLj9UAtTbrLHWrnj3gUnpDyPVooUg5D1A9Bi8C4M2vsM8zuzgF7ejBoB2rxQMxlLF5KRrpgQbF+0FsFU3Sq+OFr82h9tWO0v2X1fLPvnAWKyyPAp9BTiuh/AvHqX4bnuFD59icXbd7dg2XM5ujcsatTzqxReqs2vdnAU68ujoTgYuQod1MR12dnZYefOncjScSHMWG01dS0+ZD/iziwQyAgVaKb6YslbegkX9ZcRpCsuLg5+fn5C3B39pGdasCB/GpsyEYp2XI3jCin17mXkK0liUQ1580tlHDZt2oQs7f6AWbnm6r8rD48jzv8PDBs2TIhLokMJakpXY6U1nH7qWndP7XcyPl4oykzuzOTWrK516dIF58+fF+IwM7N9/foVJAtZr1yYi+HPqbgYXvgQh3HhX9GzZ09s3749UeSvb2FfqhLKbAnC3LbFIIXt2ZD1LjPnjj9bjgAnXaaiCdGbYWs+AHvYeGrqVG09EK61WOyF5zs4t0xpETMVWL6VcQTfDkHNGtVMaLgqpKsqS+RQdiBy7bwPN8riEMF0vepO9AyajchuvyHfruMYyows5ALnmHs77A9WxrEB97G4JbuWFffd/MUJ/ZvrUtbX8OGTcvOrbfT+TuZoszQfJp1RzEOyG8hKVZMlCPgUx9x+Go6EWRVVlx7GlQN9EHdxBapWq447t4MFdztKhZ2ceNWrVw/NmzdP+BQtqj9hlop0UeZBJckiovX+/XsBBYpNo7pLo0eP1gajUf5dSr2Tau0y5M0vkZcaNWri1eu3MGvEvivVuyTRi/jgnYi/uBylWSwgfVfoenWJNCiDKVlXqeB5WpuxWLq8vLwwd+5ckFW9LHPbDWM/nYpkRb/CSd0M9zK3Qo9XLPNjrjwIZvGUZHXOyGbIepeROPBnqUeAky5T0Qx/J5i3WYpoFMe4k0/kG04tzc++BF5PewHuXagNKcP/uym7FzoGUjxRbuz45AM7Qa3lVpctvc5gdlgf/LK1BNoM7oX+XW3QqLYl3v3TFI2mPkejLgNg5/AT+rLMVYXzm0bcopSbX21aLvOzR8Gu3qik4VBn3759QrKIe/fuMfcpC1bwtRIrjvwFZlEPEPeWzYlVY/y9ZDGsrKwSHqdKvBo1aoSoqCjBnUrZaEOpSsJKlCihTVRRLV2USfLixYsJVi1Kj0/NxsZGIFrK+mlahTLiC6TSu2/RvVCpBpRIhr4rt27dAgqUlhcSJ6sT+67EvgmH5Y914c6+KxT/RU1ZPoL+TZYpcjekwtr9+qWvsLShky5KIkJki7K3VqpUCc7OzkIs6MSJE3HhwgWUym6GKjnNkI2Zre5/McOTT7GoWrkyFjEySkXkM7px0pXRiBvX8zjpMq75SlXaABcLNHYNY3/vrbI51Tw4P/s2yLPkONpJk7XZRJA1jmFcunJNsHSZonvhgAtUnLdYCtK1uP0BHOlZFt+Zv8ONM4fh9ftCfJh2DV6N3yAbcz15wl7I/86ZjAp/3cSkThWNYyK1SCnV5lcncJTWdC3uy2QNog0RpZG/xjZKOXLkhCUjTh3at8OMGTPUPkpJvGgTSa5SZDU7c+ZMwoeSUihb7dq1hfT0dIJN7nyqP3PkyCFclhZL17Nnz4S07sk/b9++TXh2x44dBZJFZKtYsWI6wWYKF0mld0S6yNLVsH5d0WEyls3vpEmTcPbsWeG7QmTK0vIHtLFuLRCN5I2sXfTdIOsvueeSux0dYDg5OQkFg9PSDJV0UcIRV1dXUMZCioFzcXERiq+rttmzZ+PYsWO4fu0aPrN150dWkqFxs2ZYuHBh0tpcaQEmjfcYi96lcXj8tnQiwElXOgE0jNvDsNLaAiNOMGlSCXSPiWTFFdlCnRg2ehdLGsyE1XkfNNYcj2oYQ+RSfGMIqLgX5mNJHGp4o0vgcfxWhZm6ZOxvBcegxDE/FJnhidp71+AnUmxmiTHztcNuLMDj3xXXBrthxZmmGDGiqUngJ9XmVzdwlOtMU7jfOw6nytqt6br1K7+KiBcl0VBX8DksLCwJCSNipK4RPkTEyBpG7n8NGzYUikhTgVQig/RT+SFLwwe26acaPtRf8niVChUqCJnSlB8iXObm5voMyWSuzVy9SxuMprj5peymrVu3FnR627ZtWLp0KTw8PEAHA1S/j8jX4MGD9QLM0EgXfRfnz58Pb29vYRxkDSTCVbhwYb3GlVkXm6LeZRaWpvhcTrpMYVa1xnNdxay6K2F1QTUAXoanD5+jSMVyyGUKGHzjYzAt98JYHJw7Cp4H7+K7VkMx0qkfar/8FzPW3ULtJpURdvg08v7yB0a1eov1/RxxvlIfdLMqjPv+t1BrtAuyebSDB36Cfds6eHfRH3WGz0H9UnlMQkMye/MrY27MZZkb89su6/Bg+yCUEZd3CS5UFKOircXExICImPITGhoq/Fv158ePH1PtJnv27KBEGLThpBpaquRK+W/KksabHAGp9O5bdi9Mq27R4QQ1ZdILiisk4kWfiIgIVGaudUS+RowYoZO1x1BI1+bNm4XkInQYQs3e3j7BlTCtWGXGfZx0ZQbqxvNMTrqMZ65SlzQhnqus+iD3q7NQaU4lXPbrD+M4KzKFScnYMVCtG6rTVaxokYx9MH9ahiIg1eZX90HIELiyC9qOOAIM2IZLXr3AkkgaXFO6F9IGlVyUyO1Q9UMCk7WA0tVTzBZvmhGQSu+IdNHaNcg+fXFJ6qQ31c0vWYMp+UzyDJl0iKAkX6TTefLkQbdu3YSiyvQztTpxmUm6bt68KRAt+pClOVeuXALZok/TpsbpnWCqesfXSHEQ4KRLHBwztRdN8Vyyp6cwp5sN/AfcUlvUNFMF5w/nCHAE9EJAqs2vXkKAWclPrcG0MVOw+RGLtTt4DHbNK+jXhcRXpyWmS2KRjLp7w9A7/SA05c0vEa9ChQqlCsjq1auF8g2HDh0SrsmfP79AvOhDMYmqLaNJF8WikesvEa0TJygmAkKMppJsEVk05mbKemfM82IosnPSZSgzkWY5VOK5WMRW0e+LIGHJ+voaL8LfsC1SWThfCMXcxIRhaX4av9EwEXBb5IFRjg4mlEjDMHHObKkMbfP78b9gRH8ohlJl9U/rLiWWnHSJi65UekeWLk+vNZg8wUlcgVlvfPPLqmswd0OKkSQCpnTbK1iwoGD9sra2xo8//shS19eQtE5XJIsnVybFoeQY11jSC2rkvqskWpS11FQa1ztTmUlpxsFJlzS4ZlyvqvFcLqdwYFg5lWf/h8D5g/Czd8NUC5pmnKD8SVIiMPOPeRg1woG7F0oJsgH0LdXm1wCGJqoInHSJCqekMV0z58zDwnlzxBWYk64UeFJ2TiJg9Dl+/HjC38myRAllqlWrJiStICJGH8qkqGy6FEemBDXPnz8XPhRbqSRa5EKobBRvpiz/8Msvv4BiK02tcdJlajMq7ng46RIXz4zvTVs8V6ArarlWxVUfO4gc857xY+VP5Ah84whw0qWbAnDSpRtOul5ljHrHN7+pz+7Tp0+FulfKDxX8Vm1EuCgDKLklkkWK0tS/e/dOsJApf/fff/8lkKwXL16kyP5J/VWvXj1Jjb3vv/9eV5Uz2uu43hnt1GWI4Jx0ZQjM0j1EW30umW8ftAr/g8dzSTcFBtHz/oNH0Omn9gYhCxdCOgSMcfMrHRqp98xJl7ioS6l3Uq1dfPOrmw4oY7r69OkjlG24ceOGQMYosQVlRiSy9ejRI1BRcLJMkUVL2YiYkW4k/9DvqVxDmTJldBPChK7iemdCkynBUDjpkgDUjOtSe32u6IBDCC7fAc2KZ5xU/EkZj4BppYzPePyM5YlSbn6NBQNd5OSkSxeUdL9GKr3jKeN1nwOprtQ3kYZMJhPIGNXNUnVBlEo+Y+uXky5jm7GMlZeTrozFW9ynaa3PJe7jeG+Gi8DLyFfImzcPT6RhuFMkimRSbX5FEc6AOuGkS9zJkFLv/vckFOW+txBXYNYb3/zqBqm+pEu3Xr/dq7jefbtzr8vIOenSBSVDvUZbPJehys3lEh0BqTYuogvKO0wXAlJuftMlmIHdzEmXuBMipd5JtXbxza9uOsBJl2446XoV1ztdkfo2r+Oky4jnXVs8lxEPjYuuJwLcvVBPwIz0cik3v0YKiVqxOekSdzal0jvuXijuPKWlN0660oJa6vdw0iUunqbWGyddRjujj+DZrCJGn2MDsF6FsOND8e2FrBrt5Iku+MlTZ9GgQV3uXig6sobVoVSbX8MaZfql4aQr/Riq9iCV3hHpunz5Glq1bCauwKw3vvnVDVJOunTDSderuN7pitS3eR0nXcY077GfEHRqH0KigPdBqzF59hFEkvw1h2L1rPYQ6tPn/h5WbRugDM8Pb0wzy2XlCOiEgFSbX50ebkQXcdIl7mQZo97xza9uOsBJl2446XoV1ztdkfo2r+Oky5jm/d1juE13xzNNMue1wtAZfVCTky5jmtl0y0ruhVRgNC8rdMmb6SKgTM08a9Ys0x2kCCOjYq99+/aFk5MT3N3d1fbYqlUr3LlzB6tXrxbhiabdxcCBA4UU4IcOHRJ1oGTpmjh1Brw8ForaL3VGm18zMzO4ubmJ3repdWhrawua4/Xr16sdGhVHPnnyJDZv3mxqQxd9PI6OjqB6ZOfPnxe9b96h8SPASZfxzyEfAUcA6zdtEep0FStahKNhwggQ6aJCpLzphoA20nXq1CndOuJXwcbGRhLSRWvX6BEOoiNMpOvevXui92uqHWojXXv37jXVoYs+rsaNG3PSJTqqptEhJ12mMY98FBwBjsA3gICvr+83MEpxh2hnZ6e2Q46l/jinhqX+PUl/B59f/THm3xX9MUvtDmP6rog3at6TNgQ46dKGEP87R8AIEFi2Yg0G2ffj7oVGMFdcRI4ARyARAbdFHpg8wYlDwhHgCHAETB4BTrpMfor5AL8FBCgugjYu3L3wW5htPkaOgGkgIGVMl2kgxEfBEeAImBICnHSZ0mzysXAEOAIcAY4AR4AjwBHgCHAEOAIGhwAnXQY3JVwgjoD+COw/eERIpMEbR4AjwBEwJgT42mVMs8Vl5QhwBNKDACdd6UGP38sRMBAEKGX87OlTuXuhgcwHF4MjwBHQjgC5F44cMxEb1y7XfjG/giPAEeAIGDkCnHQZ+QRy8TkChMDLyFfImzcPT6TB1YEjwBEwKgT+9yQU5b63MCqZubAcAY4ARyAtCHDSlRbU+D0cAQNDgG9cDGxCuDgcAY6ATgjwtUsnmPhFHAGOgAkgwEmXCUwiHwJHgLsXch3gCHAEjA0B7l5obDPG5eUIcATSgwAnXelBj9/LETAQBE6eOosGDepy90IDmQ8uBkeAI6AdASJdly9fQ6uWzbRfzK/gCHAEOAJGjgAnXUY+gVx8jgBHgCPAEeAIcAQ4AhwBjgBHwLAR4KTLsOeHS8cR0AkBci9cOG8Ot3TphBa/iCPAETAEBHhxZEOYBS4DR4AjkFEIcNKVUUjz53AEJERg/aYtQp2uYkWLSPgU3jVHgCPAERAPASJdtHaNHuEgXqe8J44AR4AjYKAIcNJloBPDxeIIcAQ4AhwBjgBHgCPAEeAIcARMAwFOukxjHiELXAIbpy/wODwZdXJqH9RjnwEY/3wSfMbVgQ6Xa++QX5GpCCxbsQaD7Ptx98JMnQXjfzitI31mFsSfuwajpmI4MZGheJ2tOEoXVq4UMgS62cG5oCt8h/P1w/hnPXNH4LbIA5MnOGWuEPzpBoVAhJ8j+l3oiR3zrFE4Vcn4OmRQk8aF0QkBTrp0gsnAL4rwg327vehzag06pr5CJRuEDAEuP+Kv6ifg17+4gQ+Qi6cNgYlTZwgbF+5eqA0p/vdUEUi+jkQHYOUf07FgyTHkmx+EG5OVNIx6iICffTv42h3FJlu+fnCtShsCPKYrbbiZ8l2yQDdYO2bHqnPjEg5+Uh8vX4dMWRdMcWycdBn9rEZgs21F7Owbhp19dGZc8lFHM7JWdR3a3/ID511Grwh8AByBdCAQzUhUVaxrfyvpIczdJWhQbQnaXwjFXKtk3Udshm29Sxj70APW3FyeDuz5rRwBjoAcgWC4/WCLNyuC2Xqj46LC1yGuPEaEACddRjRZakW9OguV2kVhVRTb+KRhLAEuFuiffRcezKqXhrv5LRwBjoBJIPDIE83qB2Pm8+Vop7LXid5sC3OHgtj9ZhNsU+yBZIyoFYR70/vwH17WJGDgg+AIcAQyDwHZ0ZEoObsmrpwdhQo6i8HXIZ2h4hdmOgKcdGX6FKRPACJNHd9tQJRHKpQrJhKh/31G/uKlkRCSofpIfyeY9wDuMtJWNH2i8Ls5AhwBI0Xg7pIGqHZxKj752KnEeMo3M13frMGLDa0h+5AHxUsXThIDKpCydR3xyX84jw010rnnYnMEDAWBAw65MLnCJQQ511Evkiwa4RHvkOM7CxTNm3iJch36wtahbIYyGC4HR0ANApx0GbVaRGNJA3PsdQhVc9IcgbOzemNwyK/YNisvPIe5ITg0Dj9tvYYZjVUGHc1chMwXYuHbG6ic36jB4MJzBDgCaURgs60ZFjZNHrcVABeLxlga1xy/LnbH4BcT8PPJoTi9s2/iKXSgK2pZhuBk/CbwYgVpBJ/fxhHgCDAEZGy9yYWwpfEsTjQZILL78P3NHgsxDsun1UDoAicc+skXXsogdsU6dImtQ3k4lhwBA0aAky4Dnhztov0PDrnK4/O25IuUDP4TKqLj8ZG4dNFZyGYY7PYDak35Ht5RLH4rSegXi+sy64qxz+JRr6T2J/IrOAIcAdNDwO0HMwTNTraOBLvhh1rzUG3HHfjYsWQZiv+3OB6FBMO64tBm6fsbsFA5eTY9hPiIOAIcAWkR+MD2Ik1QK+gGkuTswSOss6mDiYU34g6zxBcX4kzHA4tDcHlcVblIinVo0+cbKJhdWil57xyB9CDASVd60Mv0ex+yRao1yiYPcqc4r/qzUdM7igXFE8NSuAk9dUcoM78njb6gwNVaaHOQk65Mn04uAEcgkxBwMjfD6/VJSVeKeC7hNNkFdXerXkeHNjPxJyddmTRz/LEcARNB4Os7WGdvjg7JSFe0T3eU7BuIqVceQB56HoPI0A/IY1EUiec88nVoKSddJqIMpjsMTrqMem6JdNVEjv2fsKZj4kAozquxayWsCPWHPL5d7ibkN+KmGl9pTrqMG8NWQwAAIABJREFUWgW48BwBERBwsTBL4dZD8RWdHiUe1AgkbMB1OCc55OGkSwT4eRccAY5A3HvYZm2GpklIVxhWWltgxANnXAidi+QJVBNB46SLK5BxIMBJl3HMUypShsHJ3CLFCbWfvRm6nlRZpFTcgoZHLMXTVmNgk+BKSItVb4x78Qk/8nI7Rq0NXHiOQFoRIPfCa9M/MTdCZYrC58ylpxRm1b+AUCFXfDR8updE30dzEHRjcmL9HMHVZwt2xVxGGR5MkVb4+X0cAY4AyL2wIardDEJiHg35ofCUOrsRnyLQSwUyxTp0/PNlFODuhVyXDBgBTroMeHK0i/aOnQIVwJqfVXyb2U2PPJuholdH3Axi8VxCEdPa6OptjR2fJuGW7V78fGgWEhLEh62EtcU2rPvgj3K5tT+RX8ER4AiYHgLqsob5O5ljYP4DAumSMdfCRg13od+ls5hMQaLKFuACi47vEMiynxYyPVj4iDgCHIEMQ+ALSwyWAxenqh7+AKcnFEPLB4sR5dcf8nB0liTMZQg2NFyLNcrC7Ip16B5bh3JlmLz8QRwB/RHgpEt/zAzqDoFgHRmhsiAx8WSBWNlnOM42GY5a/7uMHD+1xFNnd0Q2LYa8HVbAS7lQ0aV+9ig4sxYi2ek1T15oUFPLheEIZBgCypTLSWI+I45iQr/lyG9XB9d3vMQvyxeiV7Wk2TIo1bzl9d/xgZ1CZ8kwafmDOAIcAVNEQG0JHMV+5pDlcPxS6hUuBL1Bo5FTk6xFynXoI1uHzEwRGD4mk0GAky5jn8pHzFJV5zCGhe1EnyRZCXUZGLkMlcUqm0CWcl73UoS69Myv4QhwBIwIgWgfdC+5Fd2fJ89uqmkMj+DZrD6CZz7HctWKykY0bC4qR4AjYEAIUBKwbl+wWWP8VnJ5+TpkQDPIRdGCACddRq8iMgS41MSIgn64kTTPqvaRUayX7RusCGYBqioeQ9pv5FdwBDgCpoZAMLNa9Xy1FNeZO6Euy4GMufT86GyBfSwjKj+yMTVt4OPhCGQGAtE44FAbK1tdZZmXdQsy5+tQZswTf2ZaEeCkK63IGdJ9zPzuZu0IePknjbfQJGNa7jGkMXNZOAIcAXER0GdNYNe6Wk9CCe/DGMwZl7jzwHvjCHzLCESw5F7tfGF3dBNUIiHUI8LXoW9ZU4xy7Jx0GeW0qRH6QxA2/XEKVZ1HoZEOwVmBG6bhRv3psK/FU46ZigrwcXAE0o2AsI5cwQ9/DWRJeFJr73DR0xUP28xGv2o50v1I3gFHgCPAEVBF4POLk1iy/gMGTeuIYnwd4sphQghw0mVCk8mHwhHgCHAEOAIcAY4AR4AjwBHgCBgeApx0Gd6ccIk4AhwBjgBHgCPAEeAIcAQ4AhwBE0KAky4Tmkw+FI4AR4AjwBHgCHAEOAIcAY4AR8DwEOCky/DmhEvEEeAIcAQ4AhwBjgBHgCPAEeAImBACnHSZ0GTyoXAEOAIcAY4AR4AjwBHgCHAEOAKGhwAnXYY3J1wijgBHgCPAEeAIcAQ4AhwBjgBHwIQQ4KTLhCaTD4UjwBHgCHAEOAIcAY4AR4AjwBEwPAQ46TK8OeEScQQ4AhwBjgBHgCPAEeAIcAQ4AiaEACddJjSZfCgcAY4AR4AjwBHgCHAEOAIcAY6A4SHASZfhzQmXiCPAEeAIcAQ4AhwBjgBHgCPAETAhBDjpMqHJ5EPhCHAEOAIcAY4AR4AjwBHgCHAEDA8BTroMb064RBwBjgBHgCPAEeAIcAQ4AhwBjoAJIcBJlwlNJh8KR4AjwBHgCHAEOAIcAY4AR4AjYHgIcNJleHPCJeIIcAQ4AhwBjgBHgCPAEeAIcARMCAFOukxoMvlQOAIcAY4AR4AjwBHgCHAEOAIcAcNDgJMuw5sTLhFHgCPAEeAIcAQ4AhwBjgBHgCNgQghw0mVCk8mHwhHgCHAEjA0BWXQ4It69RHh4bpSuVBYWRfOyIUTg2uW3qNmgMnIa24C4vBwBjgBHgCPAEVCDgGbSFeSLOVvO4umrmNTBK2OL6TPqwL9bbYy63Bfbb3mhY2HDxDri2nq4TVoE34fvka+iHWZ4zkGvavSCF6nJnuLgTGc87r8JI2ul3ufD9SPxd4FxWGin74ZChqeXt2D1n6vg+ywniuAVZKXsMOz3oejXoIxxb04Ydpf3bMGaFWuwrfwCvF5jq3FSYkL88e+ebfBesw3lF7yGlstFmmDxujk9vQI6LimJeRfPYXRN8frlPWlCIAwbM3ydisG19aPw97lPuOFzCJ/azccOn+Gok6FM4jSmV+iIJSXn4eK50TAUdYsJ2Y4Zo37H3i8/47dZ/dG5EhC4bg6WvBuGGcVnoOfT+XjpYS25Sr87vRQTVmzB7q0BiGSraOnm3TFr8RY41Aeub7BF3xF7cFeWF+Wtu6Cn40zM71FVcpl0e8Bd7JiyCOv8NuHgXRlylm6O7r84Yeb8HkiQ8MoadOw/mv09myD/uJkrMaZFft26T+dVsqeXsWfLGqzQa40Ogu+cnTh2fjMOhnxGUas++LlGHoUkkQjeewIXI9+jiesFbOlXMp0Sqr89qT7kRe0u/TB0wiIV3MKwf0ovDHILwNuC9WAzfCrcVDGXRKq0dJpUP5C3NrpM/gvLZnRC2eeH8Xv3AZgbwDSextDrV0xYNAYZpBpqBhODEP+N2OruDa9X3XDi3GSDWad0QT5sYzfUHnUZfbffgpfUG+CYEPhv3Ap3by+86nYC5yaLtKLruQfTBZeMuEb3vRTtn49hz75V8PZ6hW4nzkEs6PQZp3ZLl+wsJldujgVhNTH3ZhCc6yi6l0UjaNNAtPBsijM3hiJiakc43R2ILRm+odBtuDL/Caj+2xvM2zgDdaJ8MLbvFBx52w1bn+9EHzFIoiwQS2yc8OrPbZjbrLgWoWQIdLOGI7zgP7mObmRJdh+b+zbFgAPfw/nwLsxoSSSLKdGpOehmswjPu67BiY39UTlDN3O6Ya/zVRHr0aHEYBwesBvxmzSTLurzkWczVBx9DgN2x0OHy3UWI60XxkRHI1vhwjrNZ/C6bui9ugKW7F6EdtrUJa0CCffJEB39FYULi3i4kC55MvPmaPhn8DoVfcABVTt9xur4TbDyc0Qbl2xwO7NU8oOppLoYjHXdemN1hSXYvagdJFU3naZXhvub+6Kpw2302XUMC35SPTCSIcClJhq7PkQX7yj49RdjcdZFKBmOjiyJ9l6A45HnWN5OsZBG+KJPy39gs9sbg8Q8oNNFJF2vuToLlerPxsMu3ojy648kiLH3kmuzIYhZsk+H95KuD9T9uoj1HVBi8GG91+gAFwumA+aYH3Qj2cYoAus7lMAJR6nX/Gj4dC+JvruKwflCKOZaJR1zhG8ftPynM/ZuNYJ37iNPNKs4GueaLsPDs6NQQfFeCHRthiExC7FrRkuUMYR9g3KvaT4fQTeMi3RF+09FR6e7GLjFB8N1PFGTsf3CV7ZfSMubWXZ2Mio3XwDz+UG4ISZz0HMPpvtKIN2V+u2llOu8hZq1RToZVXvWTroQDLcfamHKTUs1Ql7F/CGX0XXtiMSTtYyRW8+nPIJn979RfasHrBWLS9hKa1iMCML4Uy+xqIWe3aW4PAJ+9rUxs9oxXGSsVLf1i3BtjaDZtxhh0LYNisYBh6rotPYt24g8YRuRpNdHbLbF9wP2oMCQ/bi7pmPSl256h5ah9/vB3qwrvHUkXQx0mHX11vuFLsmQIjbDtvMzuF42rJeFLMAFNZc3xANDYKWSAG/YnR5wyMW+t72wm5Eu7ccIIo3FQHVRPjo6cGqGhlOeoNfuVNa+QFfUstyFISGXMS4jjUoK8vK021Y839kHhRlhcWMHadk9DmOcjhspkWZQz27Y+61ZRYw+1xTLHp7FKPmumjV6L7WDr91RHd4xej5S18vTtEYr9hyhY3A8ir2zkz3Lz/4H3J2SnIzpKpDu18mOjkRJOQvH8+XtEt7rskA3WDsCXv6TM9hirbvsSa9UEsgymHnlAWbVY5rh54BOe3/GfuYiom33kdan6n+fYt5hfKRL77HKAuBSczkaPkjjeyHYDT/UmgK2KReXdEHPPZjeA8/8G4LdfoAcOunXEHWjTQfpikFk+GcUKJ14sh8TGY7PBUqjsArriIkMxX8fgaz5i6O06h90wp6d0oe/RY7SefAh9D98VulDHgcQm8Z+FVaS2dWw/y5zv1AcDQp9fi2kiCnQSUDhomj2YqnY9Q08ovyQ9GCW5I8AE1OtnNGMLJmP/x7HwxLJoNqnKk+qCjviyPPlUB7CJlwrY1+UgoysyJK/dDWPQT5fRYBXTMYc32kdN+HzNkdpFGVOOKFsUhPnVDnO3PjOomiykxvNGJCESh3J/d11TMinhnTFyJ+H3Mlk1PuFnihL7u8sIISOqDSlTrGBobiKXguXMMtu+NscKF0UiGS6+FH1mphrcG3VBC5f5qQ4oVOOLYXsQpcKPJVyaHqGXAiFPmVF/uJJv2fqZlr21BdD6/aAdwfdLIeatEXTODTfJ18T8nyQf18TcWfrR3IcFR1pmgclZgU+p/L9Z7oS/rkASud4q15nBH1Ltk4p78nzAeER7xCbXM+U809/gzodTw0B5YHVAL1JV+rftSQKK5dXVaZUdVG5lib9fqZZ59OgjwKMjFA1snRBKDtYecgOAtTasWhD8dMbrAidi2QGBt0X5TRdqUJe7i7H52FO+MII12SJCRcdAFoeHoqbO/uibJrkTrT6N132EGcF1kXk1g4eVdcy12t9t9WK7ybrJcU6qXWNElZ0+Xeb9PL6BOTT92Asmh1gmQ8QPB7eMB2h7UR04HHcM2+DRmWAI+OH4N30tbCT2ggqO4qRJdszfxSV926EHxyG3IWTr8SEy98J5sMK48iD2WBeruluqgQy0GYbuopIuDStIcq1NuX6nzikxL3ca/zT2hJTdCVdpIvC+qfufaiig8n2JIn7jZR7APZykL83Ul3nlf2qeabyPaKyz1WLDXPj8x1aFz28O6R8LyjHpG4Povr+f/0PWlvqQbq0jEvrHkybBqa2RxNkVrOH1zRODbIq34t5PjBe8Tlxn5ZiL5WAVcq9t/GSLiIC3WOwkrkWxvouxvRpS3H4fjnMSWCPETg6oR2GPx6Hf0Y9h0vPObiW50e07Fgb9To6oXukC1oM2wMLgamXQ+R15kPfZhj2RNMGxR3lfeZjsvMyHH7cDAOGBGH72nDI6i9GyNnOuOxgD9+Kw/FLsbP4fbwPcozahaN6uM0Im9FWq9H8oB+GJvjjncaEYi2xOLI1e9n7Y7jOb78wrLS2wIh3TLbL4xItfmxxdmw8Cs+m7cXS+mcwsLEzZAsv4pxqAM/dJWhQbTzyrwiFv4YHyq1yJ8DMXCndR4QvQzQ225qDGbvQekUI1lVai65tF+CmYDHqgGh2+vmXXVssUFgre0YuweyJs+FztQy6DiiIfdvPs9fkEOz/xAiomi/X81NLMG7cbOy+/gb1B4xmb/hQfPf2OPbcygPHdcsQv2oJnpXPjqs7z+Bzr924xV6U9JqXBa6EXVdPlJi+EqMszmBq3zm4b7MCh9coXDJo8RllhbFRzvh3kgUOzx2BefvZPCdYuiJwlsV6TIrohgmNXmL15HkIbuiOA76KmBg9SJfs/mY4dPobOZmeDvk6D53GXEUT9wPwHc4sk+xEe6VdV3iWmI6VoyxwZmpfzLlvgxWH16B/5fvwdZyIsd6HEd7MEePfsHvCXuNF+CfUnn8JZyeXx8PjG/DnICdsRV94LO6OKlXawKZqGHM3bYEtDX3hPfgjlnbuAb92O3HLqyNen1yGv36fgy3nItFdcI1kcQwanyGXcYl1R5wcSPp0A7/ZDEa+1ZpcbJ7i4m4Wq9LNjbmVTMa/vzVAqdpWeDqzDnpvi0ZNl3M4M6067rm3R0uXK5A1XYBbe8egVuGvCFlog+quZbDjjg/scBQT2g1HUHcPzLP9AM++g7GjxETs2zYLmrxog3wdMXGsNw6Hm6PLkEb47+lnZAk6jDOvmmAu08nLSw4jd7FI7NlzD9UFHMlCzE7mHRtj1LNp2Lu0Ps4MbAxn2UIhDski6F/8MXEKlh9+jErt2+Pt9bt4/+EJImOKov0K5qdt+xorfxuPGbuvokCT9igUFIyoz68Q/gaoOmYvTnnUR0Tydcr8FJaMG4fZu6+jTNcxqBy0B9dfvsKTyDzMeppohZHr8SZYrl4Iy40D0HsnS/DQqC2aVLTGsFUO6jdF0YE4fPwUNo5nehHWFJP//Q0N2HFFpWr3MLMFW+cs5Ke55SKvY4tDGwzbEy232Fb0hePEsfA+HI5mjuPx5oAvwl6/QPin2ph/ibl6CwSA3PPYSfXfOTFt6RB8ndcJY642gfuBDWgeuTWZLlZCztPL8fucLTgX2T3xJZ8unU+LPsrXKbnLVuKJu9p3OWF3Jz9smpTX9qpX/F3hNnq5B9YcmAAr3VwN1D/apztK9t2FbAVbYuw+XVzFdRRR02WPVsLaai8GBuyDfYKVSs9+FURlT8WZuPJgFsowS8aQu07w1dV9XfE4WeAS2LTYgoa+3hj8cSk69/BDu50UpxKufY0izWTv1lFWYxHl/C8mWRzG3BHzsD9cppc3goyt6wUZUbNJcC+NYO83e8QsO6zHe1mJn8K1tthc/LPSVuFapzu2cjfHl+i29Tl2dguDm50Hqq5dA715rO6PlF8p84dT2WHItycYrulR6ITnXsWsSvUx+ymLTezK3sGihCKkvl6bJ+wZ2B5jTGUE7bmOl6/Yep2H7e9uMeuOcA7A4l3d2sP634bY7NELkWuHY8zmW4ippt3SFcFctRuPeoZpe5ei/pmBaOwsw0JlfDQR43p/wnwj02EwT5hO+9HzKlk1mLwO9fCn+Ub2TgbzqOmE/T2vKixFiv1qUHd4zLPFB8++GLyjBCayNWCW4kUXcXYWeg++glaLXdD8tCPaLo/D+F1H8Xvxs1g8fRqWHr6PcnOUlqfUsSl4cTeWTugGN2aZFt4LpeqhR5NSwppu71sRw38phrO/j4dPjlHYdVQRfsAO09zaW+Pfhpvh0SsSa4ePweZbMaim1dLFDl+W2KDFlobwZYP+uLQzevi1w05l7gWNe7C2+N92RzTs7Y3IsuNw7OZfaMMIZcz/lsOu/O8otPka1v6SG9fV7tF6AbvU7+ED1wIjOp7EQJq7G7/BZnA+wf3elg6KUpG1cZgP5k92xjL2/m82YAiCtq9FuKw+ft/0KyJWqu6lmFpp2XsbEenKiYKlS6BQNvm3+CttBMolnuz72Zuhq3eiC6L8ZGUfHBX+0PKBhmLM8SgIsdEpzKPJT4UVZOZEUWbdf4wFZS/i5LsqKHWiMxoHzVacgCX64Sf0q2lxYy/zne4zMXHhbjxmuUFyVh2Dvac8FDE10QhY+QfWPWuKSc52usdGyZjPf64e2JbMJS7pxCpI0cO5uBnkDGVYHJSm3FTJlHww/k7maLM0GuzNlWqskxx/oObcmwhyfpzCTS/5/Mj7/IDWywKx1/YNTt7Lj1bW1VL1L1YSP5tVYfAbymIwlC959mU8eWcxWjJrjbzPH+SktRi9NNpg99ALCFU4xMvY6V3ZNkvBlABhHk1x17URLNd1woVgdqJNG6Vk/sSCBXFmLRYzKHfZU8ZwtVaSVF1Jl/AC64gni5WumQqCXWAGLj9wxlunsmizeyguKE/WhevbYCmYewtZIaGYY8tJOHPYjZENha6GKImqGreIZLLJX95NsOMTIzJsrHL9uJm4GVHqUWrPoJPPNk8SrKlkJR2b309LLJsaVwGF1fS20mVGeZpbI9Hfn3BuH+mOB7MKswOFGhiRf00i2acNYo0RON9kBW77D9e4iZHrQz6MO3kHi0lBmKujRWNXhNmsQpjfUBZHoPiO31C4ESVbEwRL8ICHCbGkSswsmY4LbrxscbWvzSyjb9lByW2mc7fk7qaFe+/AHR87FCf3sGYNMeVKAaZyYWzdycncrZKuUxBc2VzwrMs6XNw+CJXpO0lW49rKQxSF9eM7xYGH0qrMxh/Kxq/5bEadpSulriTXBRmLF8nVYxssJ53BYeaKV1yBSwhzH/7E3IeF71HHJ1j8hFnWafNyegKKtVyMAjMu48Hs3HJ38CSnxcnlkLHvajp1Pi36GMZ0x2IETpR1Tvyu6bsZVXt9GNbZVMaQc22x4c4+/KrzgZmazmQH4VC0I9ZmS8WrQBR5k3cid7nseNwBB/akNclKIqEdObMVLj5Nm+uY/PuhtMwyFyiLxnBtsgOf2Pcpp7Y1iuLHGlliXacLCGZrvnxJ1z+mS75Wvkbtrn1gxTwL8PQ0Nj0bjKtpivORr/WeOVgM99N50DuSQOly2sUZU9+cQ54MsHwqtSOCvUPqTSmE9Ql7lPQp372/G6DquCtItIamr7/ke7jk63Wgay1YujxDl3UXsX1QZbbdkZPp2otDcJn5DVNcXPVfPsJDuY7pHNOVbA1V7EUeCnufOhD2KnMbJ6wxAS62ON3PD5ML0PozF42VMXrsfWR7uh/8WEzUI3ZPjRH5sSbBW+mR/N13von83QJ67y1A45PBLL6PaXbYOthUHoIjHbfgNbNQF1S87y3/z96VB/R8///Htn7IyGrLlTuGdZEMRZkrNLlvMZKrycRkDLFpjgk5csXXrZIjZxFCuRKptlqScyQrR8XH1777Pd/X5/P+fD7vz1Uxs8/nn+93er9f79fr+Xrep2AE6ZBlynTG68Mt0jD3CRkftLw8Mkm6Un6IDaIGNcXQ5yG4RTWbrENb75ouFR2Al8HOu1+ASJrEn3YdjLQuLnU5SdT/QB5wmYaaWnU0cAEJFR3eZKs9ut4K4XUKRjeehMrUDKinamqj0l7Lc/dKwQdL0l1yFtfGhVPP8GmnlniyXFmX0qV7/4OMLuWariK6dIevP8F+nhGqKjPcwfIVRag8ANsLTQ90Gl0MjYoFAMMgOCGw/H0nONXjcrL++/h33Hv8Ep9Nj8HhcXoWAFD3l01erhi1Nw/mLFKXokMWf478GQrjgt0Y02HmAtCKDBncPIclw5wxJ0E1zUi/HGaOeaWXqdFlMOKpGTg8MTsovFLiNX2uMApztIqHkxfiD8lYedIDu0i5PThGDH8xg3DlonfnbOD2GaVAsjB9hJvUuQp91uFmcBeWietT08UJA/JsidI/mXD0I+r/aIVINpUlWsWgFTyc3odeYEN3deNFGTcl7pHpBJRwHzVcKL5RTJEs3+4YulNRGK5mdEnkUit9gxf+D+zGYWPEzxhQ/yUKXplDe38Mqfxsnon+IiiVqvUgjEd0EixjqTbkIWckKRfrClFVJwTrqLlRwzGeVrgILFfhpAxHpoMVSzRogps4t2QYnOcoGqWow0xhvLJNFypPYvFBLvgY4cQL+qo8faoZXZr4kNxo4WEod4zw57+l2xtLu+PrYcV0r9voUsdrCbogD66iaQKTwvEI+IRJOZXiKSr7EBwmpcH5kuAjNRWp4EFuTt54FKt88vRV+T8aksZZSuVR/jpF1md64/tTGYhPvMtFN8qky5I++yNPux9lhtwYhvUrfdGRl2/6vCk8I+A6nBbiIsnnkmRFMh0HE+7XgEtLSxRT92Lf7kOxU97YQDsf7MrS2kGMERyrHIHrxaMV5+RxlbIfOCcYNYta3xPONwPlzjtDYFL6ZwXasVSKfpd+XX1WIGN8rSd6rWqABTuC0NNWvyZNUiszmR4jJoci+3gikmpx0VAq7SrlTx9+LaqdUeK14Hijhdh5pZ8+xKlXJ3ABrcCpV0swzHkOEnh+VsBGqw/jE4952L5mEtzMi1FgQrKyeBf61BiMw594YN72NZjkZo7iAhNqMnWFcy6oNPDg9IZoOJGRuOJRZ7QhZ4TcMcvsgUpniivyKYqqRhdF8bTJMlXdltU3lr8PJ6d6nOP7v4/x+73HePnZdMQsfoqBVIRkIc6I0rumi+nYl4D7NVzQ0rIYaVG+6D50JyfTJ11nHYyadTBORnPw3AsnPnX5cmBDTLKMpTRmc506mroODzDvO819ALtxGxHx8wDUfyk0FNGyV6ZZiAZeoqYX6NC9DdZ9S0klqq+XoqYrCRvm5cKdaT8qV55EkS4+qmFGyg7j9aLWUBT5SsR0If2wJEYX72nL0BlS1QNKentVdKylBfnZlsgB2/HX0PlosccOw8JLZnQJxE+5gxq865lY2rIJ/JOYDESm49dpnZEugxHPQKPL45BKJIcFo4w8NhXQL5zwZN8Q7OilmpMsFur1EWTrgJmOWuqR9BTonNFqK48yKd2ohCHA7lSINrC4RsxJpcGHTqOLWeNuPDZ8H4wEBz94P52CToEKAWSw0cWE3tf2RfdJhyisTm2M/SNxOKibjq5T0kWxglDqTkrlzno/w2ZYOJCdDaqyRrpLGGqHuiKTaSSgJkg4yAlOAF1dIw03ulhpiojZAdj+11DMb7EHdrQ34TtSRpfAiFlDq/FCNaNL8MYKhp7hRpfg8XTHVtYjyxmpsxpoqUmSI9jrMLp4urDlow9q7EkPo6tMcL4E+KgBn5i0w2sxVLPz7BKW9ad0WHNPBK2bgn49XPXPONCD5Wt/RNRRtt8ZdFTr9mbgB56dphSibUg14LWXvx3F5vh82I34DyL/I2r7rucaHM/aR/TyhCLgJc2xZDribsD3wQlw8PPG0ymdEKjqgNDgNGkoVaCuJ4+WH1GinuvZrkHwNd1cijPpCUDJxyh6x8ghE32cLLq+w7Vwj6WkFb1/eeexa99vMGsXiB2HppespTuTEdA5Cn2PrUfFuRIdOvXejMSDOvm1JqNLXabKnVR61XSRURMxGwHb/8LQ+S2wx26YKNuISxXsHUypiuWt4LEkGuG+jqwxk3tsCjr3DkZqEY2G8FiC6HBfOH6o7kDmBR2bBZHuFYndL/ujX5pqppIIHlK8TQtslPUHXi/K0IBjUjSkt9HFKiKI3/A9ghMc4OfCqRLYAAAgAElEQVT9FFM4RQRXKe1SvRmHlM7Ap6aCMdZdsbnqSjhnMl2/edrQoqNJGV1Ud0LlHN0xiSkloTEG/pGHESR0sNW0V0OMLlaN0Kx7G6z7loY+JN4thdGlvJqaMsPUHUSMQMfhF9FokCsq3S6Cy7yVmCYUgpTE6NKYjkdCO/kRGjsaNveK3fNdfdKEtECdr8tKUvEa39jZB62HPMQcvpuUJPLxkbugair1YKqfK+A8NHuhocW94LkuL/xdk0dSYRQbjHgGGl2Dz3KhYC7dUZRQycA8gozPc7aY4xiAFEoFY1NX2DOL992Q84TJPZ4KoOQkJ6OioyOq6SnQ1aKu/FJsy9bCCPRgUp5sVBgqu3YEr8AcNdjokp2fA4f2K9DhANd+WhXeBhtdVFyaRzVBZgXxWD5uKGYTw9LdrVJDJyIhpbDdKqz9IBBXx6fCeWV1eF2ZgG+cIiEbf4drmc2mkK1AgdIdCdEl3d1/DDa6buxEn9ZD8HAO3wxA5X41G10RFDyhiOR/Oa+6ONIlGF3/x6e0GG50MZL6LOaSkFj6wh0DGv6B6+a+WLtMnxTk12F0aaILYTTATd3phUKaX2lwviT4qCkrQCBtfl+JEpGwMpZ7KstxBuSMJ0F8DZSetWdluCmmI15b50j0TxTq9gxfnEvnbacU0TdsFWrXP8cB7Vd0wAG2YZOqAa890sUZXSkYyKYu8Uafnjxa2Kd6PZdhJyjzp3mcvK6ayVLmH5JYkE2f9gHW69PhWMOGco/Br384OkbydWiqHTpLcw69+LUOo0uJB+kb6bqBnX1aY8jDOXwLfGW8lBXkUQTKEuVyIjB1wCisSX1F0arLuDShJvKKK8KyXA4ipg7AqDWpeEV9Ai5fcsBaatKyomCgsmNWpKPOTbOltFtPNdqSj+ZQNbp0wEZVH+T+W339gmvJePTbMnzaf6uyLqWv0UVdEuc4tMeKDge4Dpzi93ijS7MOpui3y5V23Ma387/Enru9kc5281SNSqvraOfVstWYCGEeYGmGgvjlGDd0NtV8mpH8zsSGjpma92qA0aVL9zZY9y0NjbxRo4udWxVExXabMVJqCAR/+bfl6X281ZyuiAapGypCKpQ1vj2TQvUajO+CPHNRPhiYOgkJTC9UvX+M9e5CRYCKFuwl617Ip8w1F6f78Mh4g1K4npLwkje6UI10cczioM4UR6HNcpJE4ST9jcnLnZlBWSVCQwKeCckjY6IIEx9pNBjxDDS6pplytT8nncSzQThYhbZnogSVMYdhdCBGxzRsYBOVxfVxXfm5OcWUE36dcsK5WT5FyUHosqgBDpL3U4jE6Iq4CMZDsTjthhFofS5iwglvpHSj3O2TTkrtltlwf2h77MumXGNzPdMLRQYih7uKbpKqc2cMNroI/m3vBvKdyZjC8rqUeumL+IdLtNQpqKbGKYiD288dkIXCNnSoyacQyMT1NkJt2ytxfYv+6XWGGl2c0naDajifktFH8Q8+vUNbpIu7py+5rp5H1Y0ubo0/5HdbEqOLaa888OJXODS/rYEzVbQYXaJ22GqRQ020xjt2hHpMBb0ztcPD0efiBJyYXxnL1ZwVqvvgo3elwfkS4SP/3dtTFHWcIn4tpLEoGijozczZdKMjv9dENy11qdKrMU1JRsD7ojciQxQzzDS1C9d/R4Y8ydxPCxofUpoIVVlEZHh+IZ/nxMs2PdMLe/JOGrK6uJpKlqVz9Yk6eTQPLs3zuQyBp/hZbiBqChzQqaV4Hpx+65VN9FC/byk/VUBBfGvMsT1T8pbg5Cya6b0AdYKiRLOjNI0XEL7OdecTd4rWtHuOv+vi15qMLjO+3seBanYv0PxXRrrricO87niDanuecoJCqUQgnWagrmp+hHMcsq3ZKXXQOgy/Bz/C0FXNcYQ1GIR5gNYI+z0a9X6iGtcVr5Rm9HGy4xbbWlxwIlsSD1Y0CqPRAYE1sWcP1VmpGF26YKNqZAn16tZUx5tC9Z2sZss0fBuYikm7alBTGtKlHMgxfIF6ArCg4mqRTXRlffH7ktfx8WU+XMlALvy06mCiISeC419GOMmPHWB0b262oWYd7bSE0bV/eFvcDeRHWzDjTepS2qZvPB66bmCdptJ71Te9ULfubbDuWxLy1fKO7kgXD5RomTm8D9/Bhm5So9wEpb62vIbrxkoXWE9MoYnyHdHLjm9ZW6MZBg0eQXm4zBp8M4OnjeEd7IcqUVE4dusEUrOt4bUxAotGfoQodvaIOzY+OIqR/BIFh8fDrs8a3EMVtHAfgE8Lj+P4i4k4fmKylhz205hlOxxbK3fDovWUG92oCOfnDcOUFzNxSN71kJonsN4O3bUqqvBkc1RDuotmivCF3bGA0zfB6P8oijrhnUBOngO8Zntj6LiJcK9Bq7AEsB69+CJ/7XfLdPIbiC8X/IIOwfsRPKIN6lHdS9yqsRg8+wLVtB1EeCAV3bOLCN83Q5c5geiYHYWIS1dwOZO6G87ZjjVTOuBWAEMslch4zSLjVXcqimAkyL2YgoEkUtI5gVkoZ1zpG93xhfcVtN2agJ3D6iCPIp+Os6tiO18YzHkk9uJpY28E/9gVOPo9/MMyITNvgRGzl+Cnzqno12oiEouo41IHT3Sq9Bt1PmqG9ec4r53AqNw3PsBRAUEkgcjNUeu1NQ/lq7SAe/cqSD38FONO817ldCqK/cIbV9puRQINu6yTF4ERjrNRdXs8QpjJxUKDD7kyIgguATcFz3gTTNg0FC9OWaLzx9MwOJhiU9Q9MLD+UWwMJ/jfo/TPid+g98jZcDzC1enJB8Dq+sZ5MijI6cl1fuKMLv+6h6khSQctc+H4tIB8StcK/hSp13tg7Y+uqMzAiPV4LoC9ULfCR79i/ZKogYbCeVFAQ8XbdF+FylOO4yAZHZWS58KlayLGH4/WMQRSRjCvQjBvqBiqzguKdNX6qGjOOPU85Y5G3izRILj/I0SticGJnDw4eM2G99Bx6JDSjfWkW/beiNNbR6J2ZhDau66Gw/bLXFtsXsCUd5qBmL2zqR7kILXMH4Hs7xJxYjLTHVGdTwkFyYWqjUUqUdOULIo+lI/F+Eru2GTSCC7d28O6EgO8SmjYeTCGeLbUnt4pHyyvzMNOT6kKt+CnaOwdDL8qUYg6dgsnUrNh7UU57otGwuoI13xALnyEkRHuG/Hg6EhUExqI5FFzoxbu6F4lFYefjsNpto5HHRdn/scRu5gUqXSRJ7W0OF8ifCTQsZ3FhuJo2xU4HjYS3LxhitJd2AAv359w8XINfGfwfC7BqDSAdzMti3MyELucOqatscRP16Mx0VqQbaR4ZmyGV1NfxJT3xLqrNMy6WklGnugnrVkD79t68oZB+r0lPMWPkbi1CZ4ugUjptwm3lnhIjO7QZ1Whg68lei8KRP2jGxF+5TLJWk9M/KY3Ro79C98xw+s18kE+ArGXw22OpfsjLFMG8xYjMHvJT/jGjRF8Ej+2TfQ1rOxAXXaz+2HTrSXoINk2W59ziJ/hDcnymrvzat7PHzgzzZnKAmpiZvxhjCc9xvCxN4bul3+epfkL+LYE8/2YWqPfLmzELOocmdR7P36lbrRCF3PGsXzqhzbouvQOrL89jhNf2yvjCl93KZNnzWje/x2S75r59Sg0j2uHdosV+oDgyKhEhkUWGRYUVqVskHnINOuCOYt8UO/mekybG0sZHdboNjUIixYPgK3U54UmFtQ39pvg/ngURd0YT+Qgz8ELs72H4ovnAegaOYSra2SyiWza49y3v+BE291o1iISQ9gusIz6ZYP2577lGkIVnMCUNt2xqvIUHD84H20rJWOuS1ckjqfOuHyHY64pkwwf1u8AT7snOHz5M2y+zHViFJwLtfmIqHbYjIPzuXZU15QPz6BgfJp6HT0WOmNnmz5YQzoCw9MHfFqI48dfYOLxEzQjkAEVRaDnZcKsyxws8iHNb/00zI2liJF1N0wNWoTFAyQhJW+ylGdJ3RID6+PoxnBc4RQRfNN7JIaV/0G7DvaNGziK5Q2sxOnKY3HSV8JFo46mqidxl8kYnD7gjVfWvvBHXbItQkxmsA2hNO61aCJF2xKgqu8JTktOlyrkmipp1L3H4P0fDNN9S0jBGl/TbnTlJGL35d+VX2bbW4pb+T7DjbPxSH7wgn+uAhq0/RKO5mnUYnoKcj6ri7+o9wHzK8w+hcMXamHhNeoGQ61xmaLdHevX4xw4Y8zsyio8aDISXzT/E5kHz+KGsKRJJXzauivsq3PrMF7NzTt34SoV/DYbNBgjdHo3uTz14O0pYLZSqWFn9B/QHW2UipUpYrTlO1L+3PDd3J7Qt1kxu6GCwxjdeBjKbedSyfhNkgIVjOP82VxeRuG7lVdhPdQfo904jxtjrLlcCZR3pNHncmUFaWQYRGLX1fvs4zWaDUL/wS7U6lvFcKJ84oOr1iH6QXV0HjwELR4eQrxFJ/RyrIq883G4lvdKfl/VHd3QtgGrikv+nt04i/jkB+CuowKqNyXo5PwK4cpNKn2KRlVv41fhwkT3VURNRA5HROLY9cpo1vNLeFK3GXHgsyjjIFati8Z1NITnGGc8i76PeqK7YXAkesdOeh9Kiu6Da0dx/rdCcKcwQaVPW6OrgCCSp2AKWzdj566reEb3P3iIJ1oqbYQaNxyOQCR9qHKznvjSsxP/9wdIFuGiiaU97Cv/hmThrBUaoO2XjqhOXsVVC7cgu7onxvh+iSYmTB51MLZnc/D3rPMrls2KRHEnf4xochPXRHu3tLdF5d+uyvFd8hs2L3D5lwI8v/crUm8+xofOw+D7peZukwIIZFlRCFocA7Txgc8QMewp731VDKrR+AWh4D595yr83sGX7+apAKIC556hoTPdYX9qdCHlexHBXel+GHxoVBO/Z/2GQh7tKlRvijp/ZuE3AQ8rVIejW3O8PLIIwcfB0bXLS0R9txJXrYfCf7SbvEuR+9yNaHX3nPo98kaXjc9yDK+UhuuVxU4eCT7V7FM8S7sG+RYaOOLTZ9fktMHcQ0e3T/Fk31fwpSYo1arwjIxa26fui0P2oGjNRu+zGzgbnyynERAMatm7oDVDZ0yTlR3ryXnAn9PsClY9aIKRXzSH5bNkHDx7g6c1E1ja2xNuJMtxo0KDtvjSkRghUyy8eSfxAboTVQNQCRed8PLMefwmAN7EEvYd3fApQ+5FpcD5EuIjxxvpuxGbsCI8DrdefIQm9s3QuMsg+HRuhEcXLsPE1dkw/svLBIMiXaqyrfKn6Ohuz80NY9v9/4ZnInw2bdAOHo6GzrvSh6OTi+zQPKwoHoBF/akrgMG/HCTuvgxlKV0VDiWsh2PrUIO3Ex/jeGSdX5dhVmQxOvmPQMPrCjzUyAeZBgIHV2FdNMOwiRc6P0P0/XoY0J2chFp4Rk7ibqiqGhDficFwkXPAEkW6Cq7FIO43MQbQ5KbXiANqx0vagDGJn2Kxnyu5lw35CfWRindqtugHQWVTh7MKruQm49CZBGz3D0OzI7qGxzJ1VdL8eowbkJGRx8tn0gkdiddeE3gtw9c6wo2YkFwHJF2ujQ9FlpLPo7LLYLjoaBrC1Ows4gQFBo9wwcso0t2uWmOo/2jY559C4p1XyMtJQc6tV6RPjMIQJsrJ0HXiHbzKy0FKzi28qkcphmKZSI6YtISdiGR1BGfSAfrzAQIelgzfjt6BnayOwHyXk4PK+hFpSCyPrqwRNowsqwUaRRO0GDFoAx+fIZyuIefp1IBLtD73dSZiuwPrSWjcr0HvUJOx5POV4SKl+ymhi6D7ZqM6Kyfq4NdlsxBZ3An+0waw+9elg8kp6doWbMh1hy/jiBb9pHU0Zb2JkX+CDp+TeAi/FDzHvV9TcfPxh3Ae5osvWYVC816Hd6mIB/flBoFc31PVA1m8srqnQfceg44fXEeayFbRpfsaQnn6Pqs70qXvSkq3wLVqPjHhlloE4lpQM4Q0u0od4Uqy8Nv7jqFT6tkc/u5p+J73lLy9JzPuzAiBtwMCkjVd4q1pbNRQ8v0zaXt2E6tjDxv1EksaSoVtextzxbP5Sv4Z45tGCBghYITAWwEBWdZq9PxKhiUJk9lRLcafEQJGCJQdBF6P0cU3l7jlFY6LoQM4Dxd5EbLPrsfUlf+Hubu0pQKW3eHe9Eq5x/zQP+xzhOkYPMgOkBwSj747FqObVL3bm9648XtGCPwDIPB3GF2HR1eAxzY7zI+PpQHdXMvmIhpofGj2VJzsugOhr31K6j/gYoxbNELACIF3AwJPjmLm+Gz0Xc909Xs3jmQ8hRECbxMEXo/RxbS33jIaY6fuxfk8mkJMqkqVRi7w/m4BJiulOL1NoCibvciyLiHdrCW0ZaLkJF/C/9noqAcpm+0YVzFC4J2AAJNSHBLQDzOiC9g6udXf9EIPV0W3UjbF4ScfDFidgvJUE7Ym0AvdPKjDZWlPT92/5gzxxfKELDyR0WIfWqJ176mYOVNIiSjtB4zvGyFghIARAkYIGCFghMC/AQKvyej6N4DOeEYjBIwQMELACAEjBIwQMELACAEjBIwQMEJANwSMRpduGBmfMELACAEjBIwQMELACAEjBIwQMELACAEjBEoMAaPRVWLQGV80QsAIASMEjBAwQsAIASMEjBAwQsAIASMEdEPAaHTphpHxCSMEjBAwQsAIASMEjBAwQsAIASMEjBAwQqDEECix0VVUUAATc66bF9OZMK+4IixVZ0WVeFsqL5bR+kV5NEzO0pKd9v1P/zEDEP94LnUK0xIOxnzDEKE7LXhlDnOtl8EP/vxTYm9lMjjT8DP/4+Fu+JHfmTfYeWNxGbh94waKG9igZWtuFlvusbU4U2cs+jV+Z44qcZAiFBSYwPx18WhJ0NGQ4dt/QIlNmX6MOpZE9Mxw4txnkJO2NnouI/7/Lt+u/mcjnppXjIqWvOzW/0WVJ5XxqXSytaz2ZOBhaCAzja8Hg466f4TLrPqg18PqyxWRvDMheacyTlP8oIx0qlekU5XwC/KlGBlVXLGOnufSffKyfEJJbyzLhfVcS1aQR7Cx1HoP2pZSl/8q+pYKX/ug8hscqK228dLy/FLivJ538m97zECj6wFOr56GGYF7kFBzNj+ZOhNLWzaBf2oXhGXFYFTtsgZhGa3PT1o384/HwyWuZb3JN7wePwDxwgaMmhMDE88grPNqxO3h4TmEBIXhbsv52L3t7Wv7+ixtDxbMnI5VMVnwDP8LW3pqAx03+POX2ED4rE+Hw4RN+P6LSuwLhTf2IzjoAMp578S+oG5KA5df32X8c+H++mDy9q/MDHxdPnEkfs52x8K1U2lAuDUqFqdhx/ivkODojpTZaZh0fz+GsZNx360fQ2+hNKT95z0JqEnnvDrtDU7ekWXh9IEE7F04DsuSZDD/YgaCfxyNr5hJrTSc+KdvvqRulC9hN2w2/Ad10tBtsoz4/7t1rSU+TebSlmjin4ouYVmIKYmwfnAaq6fNQKAYn0opW0u9pxJB4zBGV/BAmJk/4h8ugUaN4FkaIn+gbqXrTiHLMxx/aRdYajt5cHo15gX9jC0xZpidJjVsmHSqdUFY8vMWxGR5IvyvLdAqErWcteD8fAyY9Ri9bU/Bf9mvaLHiAhK+foP0rnFvUnpjiS6tdC/xo4xSu4QhK2YUDFdVZcg6fQAJexdi3LIkyGoPxPLgCegmHkROA5gjA4ZgwJbHaOc7AwFD+762oeqawS1BoyWAHDsuJcwM/vEP8Y9XmUtw/tf1ioFGF7ONawiydcBMk4W80UWIGBWE0AedEeDbtvQtmtVOWkbr557FqoXHUH38DPRtpMXdZAikSalIzvwEjvZ/j7Z2Z20H1Bl3FRPj8hHSQbRxGTecejZ+wmUa3vo2sF0xWGVRg1ChXzi89ukyuri3TvhZoOOKZlhz+wTGijll7n4Mt+uFo56HkEnTtt/ULfxT4W4Iar8rzxYlr0KfrlOQ73McB+er8CfZMUyo0QWhdQReJnHqMqHxXCQnF8PRkYyNv+N3fibqtAmCxUL9ja7c5GQUOzqiTHZ8ORANnebibu+duL9nEEenDI/qMB6vVsRihtaBQCXl/38zzIV7zk1GcrEjyvbqS342WVYUgkIfoHOAL9qWdJ7CtSDYOsyEiYBPhspWFZiUyZ4MpqtcnF21EMeqj8eMvorRE5LLpC9CM9sApHjtM9joYjWmIFs4zDTBQkmji3miANt6WsAr2gv7Smx0ncaUqm6Im8rQ+Cc4tnAWkh1/QEDnkl6ywQDV8YKq3ljW6+uxHvHyqKBQPOgcAN8SIz/Du3i5gfGIvb8ancXqpN58TY/9luYRVRotwVq5Z1dh4bHqGD+jL8pKZS7BNt65V0pgdKVjUTNbBECLovLOgUnqQDSLLKgVhptsf7PeY/lWZNg/vAp6be2F3S92oa+KHVmwrScsvM6oG2Rvw93sH473em3V0+ji8e3VfKSkzYC9yv7Pz6yDNkEN1Q2y13bOfzDcXxtM3s6FZdcWoe3nAbg1YB9SyUMtpX7sH/4eRn4Uh3wlr4VwnrKh8VxyMjTdPxj5BnrJywyqvNJIWp9+vCo3CoOa7sfg/JJ73ZX3fgOr2lrj6wQXrMw+C98Gudg/uj/iBkYi5DUphX87zFkA5CJqUFPsH5yvI6Jv2E3/7WczFJ+Ujvd6YGIYBA18upRGFzfUHVqMLpAsf49keSmMrjJQsg2EioGPv1t6I6d3PETvnfexZ5Dg7mX4mgcO9DiEDT3/ZmO3VDRq4NUaHzcIAnoaXUW4ee4Uku49h6mVOZLGd0Kg2OiiPNa0hIv4X3N3CEGfopvncCrpHp6bWsHWriFq11HUUgm1FfkwhZVTe7SpJ2Qxc9/5vXp7WOQcQdrzBmjHDDhVW59yTa9cQPIHzdHe4jqOn7+F5xZN0NHFFuav8nDlQjyy801Rl6/ZECDC7un36vBg0luYX9FNnDv1O6p7OEB2gr4n8Y5ir4BFk45wsWVy4YuQsckLrqP2ourMeBweY43K1ay4PGHKE+e+T/9f2JPcIKLc9bQEXPyfDWxkSTh/qzIcmNA0ebrSEuKQQe9YWH+OxvX0yQM+AT+LjljRbA1unxirHirnDRsHfRUtHWgjDQfuJfZvF/+H5u0tcP34edx6bgHbbh3QRJScrnjfAk1k6yilSM9I15216FBnHK5OlFaMOYGWoqcBZxBtaHj4zcKdqX2R44Yc/wT05fHZQYYTR9KQb1oXrTupDN1mcTwJRLoi/OWPRmtnJyfiCvNHolOn9m3AkqIoL53LSX8lqs0R5bAL9EP3nkPff96gHZdKIfqmqZUT2repp1SnwAwyZmkWFrB2a4XmqnUS8vdV+QOztGa+onxh6ZT23ILSnt2x9RalDmqQgfuHV0BU3yekFKtGv7XQuCa4qWGMDHfj56G3exCSemzCrSUdYPoxU2uhgQ+U5/49jmEEBJsmHV1gKy8CEd4R8zxbdOvQRA5bMY1Zf94Y9QSeJCmAFTxdfPdMKua83u4ISuqBTbeWoINQg8WySwXs5biiJ0kV7OqDGoP3otacY1hyw59gfoxgrqdiosb/tcFCE8w5vJbEdy1nkBVkIznxCks/YlyWFdxD7jOmIu0DjveT3LktFNkyMDMrQPy83nAPSkKPTbewpANPN8JZbD7H++k8zxfommSHsAaLJyaiuje25q0i8rTgE4s3Ftb4vHE9elZTzZYCdu68sNaHfytommjSPAnjOwUyVoTciFeTrWK+Jci0innSMIH6nuTraeVtGRzfY/SI5s5wtObOrPNuBH4jl//OfERXrOfYwq5hba7+UGR0Fc6ryus1qrxWM+0qjK4EeOYyeoY6L5Y0urTwfjHKsnVGh6ag7sjdsGH1kXrg+DbF0KT0DQKSJrzmJUuJ9Ct1MtKhN7Lq0hVciM+mO9Qsn3Kre8BBdgJHCHACDZrI6VJV19DGQ0W6irs9F3HXQweUZA9q0Xty0C3qi5DGYSU3uLTIzbKgUcU5VGrleR6vRjflBX3cA4LKzIGMlwNqMoqHL9VN50v8TfF95Vpfoe5NUS+n0DE0yhw5H7WBLIl0zsoO6OFKJTZ83TbzfSUZqLRvdb1CTzFWJo/pNrooJLttsAv8K63ExeWdUbj7K7iOiUaBAxPp8sKjtfMwM2ANEp44yD05BZTj3ZhSwvakLELzzCC0d87A9y8Yrykh5lpPdN/ghM2RU9H45FdoOCqOzT3ebReLyb6zEJ5eBAcnDxT/QTnUOXUxdrYr0paL1v8rCn6TxmPFiTyYN26Nz1v3hme9OATOjYVZ73Gwe1KINl5t8NsCf4TlD8OhzA3ofi8K02d/h2V7syDjUwTSoiZggk8ozhQ4wLmTKT6pXx8P9+3EeXhz7xBF5pLhYtfrIebfoTS24lB0bDwd5db8ghNfmePehSVwd5sPiIyuipQz3MF1B9pHRWJG6xeI8HLFqLPNseZ4NMa+fxAT/cZj5ck81HZyRtU/biEt5x4G7EtD8x9b4dSEDEQMAQ76OOIH25O6PdK8IHg1PwVpM1TjP4T8fApfWRhdGuEw1hTxq/ww9uvdyKztBDcrM9S0K4/kLUdw0y5YntqYe3Ymvuwai95xsRhfLRk/9eqExSnQy1CS0R1UoahYr90vsEs1nEckwKVupOu1VplQzBuEu+zaWngOi8GgzcvQJn8lBnUKwSPvcFzeYI2zEybAJ/QM0aEzOpl+gvr1H2LfzvOAtyLVMveYH9xG3kXA0TD0evwTWrYLwYtxe5AaSqmYlJo5uoUv8n84irABHxEcSUFc8gxjDsSz0YeieH80bb9UkZJWFA//pu2x9A7jjV2Ij5ZOhu+scKQXOcDJoxh/nMpCTsOFdPfAmM9Xol3Mrwh2Oo3Rtbsjelgc7lAkiVGIcvePRgufQgQnh8J+T180m3QSsHJA64YDMO/UDDSmPXcOrIylYWNhcWYiOo6JQ9PgRJyYbI9ijXxF/WZlxyagRpdQYHws7q/uzDX8kY5S8HgAACAASURBVPgV5d3DSzPeYSL+O2N4StC4+WPtcFP+BCNcIjGh7kjs7scbXbmXMC9Aig88QN8oO/R6OB93COeLQzui8fRyWPMLpdSaxmOV31h8vTuTeIcbrMxqwq58MrYcuQm74Mu4NJkSiNOXomWrU5iQEYEhOAgfSi2yPcnXkKgaXXz68cp2Mfg12AmnR9dG9+hhiLsTglZPbyNyQl2M3N1PZHQV4phfZwRWXoqwsRY4M7EjxsQ1RXDiCUy21zNVW0jJKTDHwPBr2DyglsY7UcDwPuJV5YuFLljUU4c5Y8AUGnJv3A5YXPXNxw9EPwM+ovQoMkaXPBuDA/Eh6FytCPH+TdF+qYVc7gk0c4eRMaHOuB05gVWE+/FGl+xGKMYOmIOTeeawalQTjZ3s8d/Te3Dmngmc2fqbhri7vidqj4mR8zPZ3fXoWXsMYlh564uqqvhEZ3u4riVanZqADE6AwPEHW5y8Ok0trfx+/FrMmxmANQlPwMkFC734tyxrGwa7+KPSyotY3rkQu79yxZjoAm6N7hlqspWQkRweEjLNt6oaTP6bswc/K+3pL0Tpwdtk10jWOm9Gl9Mn4f3we7TvthrZVRrBuZkrJmxcjlortdzNFmtETZ+N75btRZZMiC4V4PDoxuTI3IOURc2RGdQezhnf4wUTnRaMLksrtGjiAdem17Bt3Xk8lafLUoRjuAbabcC8zjgGb8OqfkVUt2sBxMfg8hO6c56vMRSkanRp5v3qEXtJo+tuIhZ87yehb/yFxdCC13kl0K+k8vq16o0MbpIuuLQDXHe0R1TkDLR+EQEv11E423wNjkePheX5VZg8cQrCU2WwbuGOhm6e8HwSAv+wm3D2Hon3ciqir1dl7J82F/F1BV1Dyz0QD107byYC1iTgCUtL0/CXHjqgZp2Bj9ylfMFm2fRKHg3vTD9ETbPXg69JyCs2K0NKbjbFeT10LK00KlXHy2Yz9EN4wUBRphSTAvo5Lky/hfmmSzH7u2XYmyUT6Va5JAfcMPJuAI6G9cLjn1qiXcgLjNuTitDuFVndfljMIGxe1gb5KwehU8gjeIdfljRCZRSZbUUpyik2ogwmGe2pQgCsz6VjfuvHGmVO56yp8Bu/kvhobTg5V8Uft9KQc28A9qU1x4+SMpAxiNvi85XtEPNrMJxOj0bt7tEYFneHynL0lF9lojxyi+g0utKp8LbFDy1xQJ67qp6byzEMhdHFFuBlLEH2WV80IOLaP9wX2LIBXam2wKZNPCazKSb09QIqZm3sgV3u+3B/a0+8YlPionmBQMLz3kuYkbvmqMr64GsUzOQGB7+ndAUCcel1MaSDvgCV+yh5q4RiWG7f7lhHRpUPdTHjanVOypGMPcc2MtxekBEm1LJZb0X+/mEwV1NkzmOmTRsscd6HJ8So2assIGPNuhe2WsxB0vVAtOD3XUhCOXtLV+DeU5Qr3Ib2TX5Ay9j7WM0kB9O6ww95YIuOgneNdUU8cgjhb699TxDqnKvodKjUJUzkcdDSPUwrHEjAsumm+ZNxihDajRyDXA1WHU4ZqcndccacbJxlL11hEOpT06WxnotdSciFV+Ae+WG4qIypKUyfP6f/5bqlKbw49JrIe28oLb05uN/A2g6fIXxgFk6whWyqZyXceo9wy30dKek+1EjkDj1fB+NO8kpE7jb0rOsHqwM8XrGKUAt8J5uLC9e+QmrPuvC6NY+vy2SgwN9jRm/svL8Hg37n6hgU3mxByCiUFK4OgYd9vTzce2mGwv+0pUJ9IDjjEiY3llF6VQX0S5yBc7fnozUuI7ChE+Y67caLXX2JRviooXUwMqj2sDF5M/1q9wN2CTWKRFN12iDoIX3zyRb8n680X5EqPOeKgBnDXiqKpeetq0WIcqn2Qgfc1BQQ/p7E9SBSfMDqEiZRYf+2YYfwgmFYfLqQ9dZ87Gc6fPB7yZ98igwlN4pu8bDj69FMmAYJxKeFGoP0RcNxyGMLWDaieg6+oJwuiQy2xryDJhEzzt0mYSehAJ7wA3ctIWBLR/n9P6QzyXmdTpDKcHSMJbqtf6mSkqPzRV4hFdG4DljYQBXmJbg3ln68cGueKCWT/24Gr2z/rpo2ppqGJpFGzcmc2vj2TBbV3RK/F5SfYp7uTqumXvNn4RVF9bNxjUZ+aCk4F4hOhx+CxxZ1o4uFtFoGhA7+bcPxjR9aHlA4L1RT2VTPzeKXBpkmlVquticdvI144a4+NTD4t9l8yjnP+xLJYcrKasHQEaX0qaUIqvIzrrFGxhJeTsloD6zaIjK63DfiwdGRlKasWoPFvauJdgWja7wg4/la5K15QrqtKs3p4v0SNCOV2SLFZ0xiMEQHXpuXRL9S2ZIuvbEhqwsugbOIPxfQGazJwWoxJwnXA1uA0+GiMVBwuLJKORkKIkWd03Oq8fJG+z0QlDmZKaclAe6adUBt3OnGqraw/joBDl264H/VJuCYhhR23RwO4JrJaJKbZUCjEpu4HNgQTnPzyS/J6wgFu9CncSK+fsjxedUsoly6j7p+VgpbgHH0tfgOsrkXcK3/eXT4LBwDs/i6+wLinxZeiBbBWnkLPA3vdeJTzumvTPTw2xo4SZlbVXXInCvsvReSfM8Gp0qXQ+G29hpkIN+MCYKeweFR4oxzuM0IvDf802F08UpPc97QYDennpuranTdIOPlMzJeTOzGYWPEzxjA55mxCvSJqZK1OWKBoKqMq66vpkQIe0oR5USrMneJvGy1kL7qO0KrYkqLuLRjKfwCgnG+Jl/LpqrIEJJYdFyBOkrpfLzSGW6D+SlpmPGBqiJLp2YVTUoTfGoFj3nbsWaSmx6d+LTXFSkr0Dvhnp+MNT5fYEZSN4Rd3IihTYRW/zexunt9BFutwroZI9BBnA8oRkRtcJDAB3EOu88VhnFekSt02u5ZHfe113OBEYxViInW4o1adgEm9TQCY91HYe/7I7A3aS16kUFdFDcR1h7H8GXwEoz15FqFG/57g3Dn0ypvd/JBB5VuBp+PWYfRTurKvBifHVkHQlXJej/yLrApmydVCsOFqCEr5Jos12F0aapDENrMAhkH12HOVH9EZAp0ye/5CyEllqePDJ6mWBrahgb9+sFRyXiphZ6zZqPpYWm+ohFveC+kcvOVZBw6c0OpjbmpkBapupAqjesDN7VorITRpSHfXmhnXDHvEnYs9UNA8HnUFPiJ2jvKfLghI6SI/zy18sC87WswyU0USZL4ntDimy4J6+ZMhX9EptzZpMoXWb69rQH69XNUblZTqydmzfbQowsYk+HQFzPS6+DxilAkuKzkHXL6UaDe/F+e8q4C8xLcm6oDjtupsnOvyXKVWh29jS6xk0hwUoGrv31mqNFFqcV+tcnJ9RRWHvOwfc0kuGnjbZqMLlG5gFIN0jOuCUtzwfhnVQAVOaZ6bm0yzRCjS8SflHGSx/3bExHHOwI43uUob0ShVkel0+jiDJ1xJ01gN24jIn4eoEiP16g7KO5RG+1K1XRxxsIdaZrTyfsl6EbK6JKge33wuu91XQ43+r7WumzdemOu2DErdPpSNarUvqFuNKnCVisP1Wh0adEbtbGoG6vQ1vprJDhQtOYC1ZuXRKWQr69Nbqrr3AbTqNQ5bpAe8Nk4JHbnGhwVkBHZJW85a/ByZC4u3eAdG1UFh6nyghxe3UYnnw4qzZc+x5h1o+Ek8X0ZL7PMWCPbFscm1EaoayZbI6dL5jyVqJMU1pOUgcJ4CGTg4Lo5mOofgcwSNsbRT2ppfkqH0cUj+UAxoHUbXUwB8dlF3hg0+xDuyT6E85yj2BPogJN9zDA4SfB6a2Ycb4/RdRfxyydj5qWWmL+0Ky586aBoIKLK0HgGYaOS7qeEuA0ljC7G7qKOUt/0HYE1qUUobzUQG05uxjCt7WK01xXJWC9SEMjSQTpZ8myeO5tuRZ6Mw3ewoRtXbMWkDQ5Pn4poSk/Uyi9kWuCgw+jyOMQQ7ivO6BSyIPVtpKGjnov1vFA0033rLYoGKNeHcH+7hdkpFzDDOh1BfZahYdh6DCiRsSXg6huEO58z7qQhrVLutdOgmNRivVg22Jov0QpdUCKU6FohSNm0IY9DJTa6MiKmYnSICfw2LED5oEqiAnEuhccjrCbhA92LfRpFvlwQMewUrgS2xkuq+zEb/JsyriixCSm+ItUxVdWLLVqEr5u5ua473OZfh+e6q1jdrz7VP0hQgCblUhvc1CLUBhhdTGv7yTNxicY9LO16AV86iCKNOowuJl0nK+ob9B2xBqlF5WE1cANObh7GdZ2SMrooDXHq6BCY+G3AgvJBqCRqbKOs4D6jqALx7d+kG9noI4CYND2PAz1waIMryQCKUOythTlJ18HLdp1LlNro0gffVe5N4NtyLzu/S/FeON6mJZqiMdKlbHRx38rgsjL+a6jRxQoQRH3TFyPWpKKovBUGbjiJzcM0dOQz1Oi6zu1HCQ66jC5tMq1MjC4mm5YycPyzKe38V0o7L8dGvkbjP8gm5ZGRBIYbXYxAPItF3oMw+9A9yD50xpyjexDIdLnTx+jSQruSjTR4OHjyxqwSzenk/SU3uvTB62kordGlW2+8zkZ8eWe0vDpChW+XxOjSxkPL2ujiI4IN19zms1F0sjItD1ANsUa5qcPo0odGJb8sI0OnBrqEfkbRprUo6jMWH+7hs9DUjC4+S8VGHIBRLMpFzZyknbwaT803WPqFukDeodrr+pRWfYfpBqlb5kg3p9EiA4uofGfqaISY+GHDgvIIqkTO+rfT6OJnWVQVG0q6ja6cxETA2Rk1GQLw7o+A2KfsXJBJiY1I4RKFE9nLIEBdSodZS2qYoUEZ11volmmkK5cYuTUZiZP41CiVc6sKHp4A73gqIyXngavKddd7KmF00VyHxDu14WxfjohuEnoND0Omrtkh/Lel67n4NDLMw8Wz00TeF37/lZYiM+4bVDmqp8FFBrRWOOgwunrGMmHzJAjChb1yPY0urfVcfGpqdFcNnelkfLqnzQxMeXEHjlu2oK+edfsaecSbhDv/rduqNUl0rp0HzDG4XwaXKqHB6GrCpitkK1IH+EPlJl/C05qZmFqDQv+1lR0gXB1gLOdxr6Zb8KoXf8twPpAaPcxthA28saf2jOwmNg9qjSVPnGBRsRLchgdi2gC+GQSPFy4rFamo7LZpJtvOux3Q2iRVkq9IzRvSnpYKMv6Y9ENn7V0vVWlcSJnQBjfx6AYO2dXuScoIQi45RKwHI2kSn/KgQbFVS/fkIxQ1ryXiTm1n2Jcj4TKpF4aHZUI+k1BlLdn5QGp6MxeNNvCpiyr0qHpn3H8rUqEE+rixfyfudhgM18qadQmFwcXVouhbaydeUW/+rynSVYJ7E1KbaiuloPCR2VguwlKtxOmFykaXkoxINtTootmBiXdQ29ke5ciQntRrOMIytczWMdToujUaFShPt6oYDrqMLm0yrYyMLiaj4dz0VugfXws2ZhXxqeckBIxWZIkYbnTRTEhWbalJzW+Ww7t/AGKf8rNHebktbhmvhJOfaKddKQWRwy9FBogSzenk/RJT3PWMdOmD1x00OXi06VdKLEC33viMj/Qp6QVCJLkqnwlhqNGl4x40pxeWLNLF3auKQ7lEdpcuuanD6NKHRjXtizfwq3t5Ib+wOxKEkR5qRhefopet2iafxldceor3TvaHI9UtylMV+e/Jzu/EAfPB6CeBsswjXIOlU+jl1Q7XGszGL7wnTpfM+ThUvSNogSYZGFQOgc3bY26jDVxpkJRMLtG9lewlHZEuIe/SjMLgqXy3KT50bKbwfKoKxf3DG+LKJN6TyRdQHxx/Dil2i9gOVnCaj0QqmnekLl53o3zQPf4rXGIK7d8qo0sllK0600dgjPKuekK3tO5cTQybHsVZ8lM+3opbdNnVpNKK6N9azqqDWB7ZuTzhj6UjFPwda54TxTU9GX3HB8cPzlebw8Ih+DV4L+yOR08GIER1bpEkDumAgw6ja9oLfkaP00K5EaiWq60BdzXP5zqLmV92wvraG5Cwk/fmS6yRu6krqo+6ismnbiHYTTqWV5RBXZGyK6t3/ZNY783CnfcsZTtQ/UcM1X+QysoWJ/fFxa8vUQHoUa1GV0+emWZbemF38nr0ZVIsk4PQ5TvCrZgByGAjTmaiiAPv9Yodj3PpVH91k6nL8EeqULcjO4tpjdphMdtIg2slrm50CXVhXA1Wz/JCq3DhHa6gdUK57Tj7zafqEGZyymsMxt6Knth4IQIjmTANeZ9n9vkBdbbGoDp506T4imReNptv7o//imtyhC/qM5+LeVaNxoVInRa4qaGZakqlYl2lFu4qSpNgnMjTlXVEurCoJWbVieXbF/NwJ74jVX8qRFaEejehNkHIMODulSsQZ1Izhc6DFT034kLESDZ6xjTH6fNDHcKlsVS3K/1jGrn0Cm2OLTu5d7gfj9d3+RomPYbrldjokqexluDeeKdOmJkodZnHm1iSZUwGwU1+0LAARxk5uRq1Wwy2kQbTgIG/0y9EnnC1swgyoio/w4wfNNxEPgNrE7pWH8U30mDqtFTxiWiu5SzUieVlDp/y9LE4HVDZgmUjV4oGSzoUupo8TZoRDacSTTOWs2rNj2okSJtM42vWxDBRrzPTnjrN8B4mS8PlwGCkb+gmmaUhDFzWeDdqJQn0zYZXMImpvab1Ofo7iPFMnWNl9TldSvfIRxoEmKrSrrrRxfHaHhk/4ReqX2HoR5mX6uL9ErJMT6NLqKPXhtflS2106aE38vw5lU9t49QlJl1vCj4WMlcMNbp03EPZGl18XR81exJSXDWr4NxQ5ZRnEt2F2Zd0yc0yoFGNmxNktLmawaRa08VFs7Jh6bUbyev7UhlMEZKDuuA7kjMxTlvYWYzZDt/iTAw1BWHVFWrA0/civr5ENWKaUqnkDZaUnXq6ZM5zifTCdE0yMOh3fEEpCRmCLiOkhb6dkS66qZxdGNTuK4Q/+gTt+nRHrdxTOJyQhSewgsvQBVgT0han+9aHb4w5vKMysbyPJY6T0B7463zEx06Bbc4CuLjGYvSFBHxtw8wxaIGBYRS+L1+FunC9wuNGPyDxxGTYU8vduLlt0GlxNhwCz+MkebG4FuxUd6S0vhkK+A5PtScfR8pPHVGxOA7fOXSizmouWJQeg2+tX+JaSA84TEuA9bdnqBtRS7yM+w4OnZbijssipBzwI49wOua6tEBgijW+PXUJP7iVw6VpDmjHfv8yEuaUxzqm5XQS0LibO8xvF+P9F8eReLcxWriPQGhEK2xlarGoPcBgp/9DxbGRWPXZMYz4YjRO2CzBvvU9YEoRpb4b7LFlTyDafkTtird8BRvq/Fhx4DYkhw3l2nOzDO5n2IdfRGhPExwa4Qh/8/9wHeZUCIVrtZ2Owz+OxOqU1pi8Ywqc/497qJCiAWtXX6dCxAX4SeTxU1pCdgSjLbsjwj0cWZED9BxkzRuTGuCwfJU1VtgPRHixJ9Zl7IBPjQJsGtAQo6Ir8l3KPsSV+V+i0/fkRrTzxBCqW0zdF4fzeUWo0qg3vl2/CjPdaihtkzWE0i5g65gZiC7XDz+vHIi6/BMPz4VidQzgPnsV5gkREimGwijr3t/jVEY8LlNInDV61Z7jvTdJH2JcTCFCu0hzpr8H7qRYMN0He6xApqw8qlhVp6Yrr/D5wsOIGmuPV8lz4dIiECnW3+LUpR/gVu4SpjmQUURGWuDlBMxxNGG7Qzn7J5JP+ENYWpmgGP2w/fIGTnEi+AT26YoFf4xC5L6paHRvLbx9KDIWI6S2CvdONQ6eHVHuV1PUqRqOvQmW+GJuBNaO/xPr21AXSuZ7509ieiumTlBQbvNg2doTds+K8afpGcQnmcHOpT9mRQ7E5ZZdsPAe2PN8ZMLAuxKs3cdj7jxmWCvX3bTTuFjkMXuu+xFePraAdyS1GaeOioxiIs1XpO+Ng98u1J23E2t9OxK9Me2EjyFoMuWtv5+C+Ma7NMzn4tcTalNENL6hdZYOuKnuha8VSayHbn2q4n3bICy2XIzmanyAMxKT0Bjd3M1xu/h9vDieiLuNW8B9xHKssl4B+4HhKPZch4wdPqhRsAkDGo5CdEWivWubYbOjFWx/tkf4xVD0NDmEEY7+MP8P01WqHG6uH4Imou9ViafushS9yLNsDU+7Zyj+0xRn4pNgZueC/rMiMSV/KNXkJqJetz6o+n4zrNzRFef6d8K42DzgQ0vU/eglHlt4I/LYEurip3pe8nweOoLju4Ixb1sqGk44gsjgrrzRxSgfO7HMj+FfgMOETfi+uz03FkSTUiDF/yNGaIXFgFr3uPocAebNViJqxFP8pBXf1TeQezaQBmsvwB+jIrFvaiPcW+sNH/L0xsjTNvk7M7GDZ8dy+NW0DqqG70WC5ReYG7EVs+sc5Gom6nVDn6rvo9nKKDT+uQIZtIBll4XYudwTFKpG3wOuClgKxh7V+LZzb4wHT6qg6Y29iM63gffqHVgyvBJ2KZ1tMpx39MEy+3BcDO0Jk0Mj4Ohvjv+khrIdeJV/1AJ6dV/U942BuXcUMpdTOm9BBEZo5d+18PuuQWj3VTgefdIOfbrXQu6pw0jIekJdR10wdEEIfq6xTVm2/s7Ug2qQaUIdiRwmWzDg7BClPVXM1MXb8rH5y6b46hBxNsu6+KQid8oaDiMw9ecZ6MtY+LxSn6ThbgIcMhQ6Q8oB+Nmfhs97A/Hr/HjETrFFzgIXuMaOxoUEH9QUdAf3Vcihjnf1kMzrDrUx+XgKfqr+H7TVSLuhWFlzLpp+dRxNv9mNdZMb4sXBGRi6pj7W8vQjK4jHrJbtlXjpYy28X01/pZrrCwu+QOvAFJgLugWNG5DUN1jWrw2vyRFusH7VVmkkCHsZuvTGsP4ov20Evhh9AjZL9mF9D1PEUYrsBvstVIrCpIwL3UHvwH1VDnW0rAdCXvSt74sYc29EZ69Cj3JPsWdSY/QNK4bnxuuI+DxS6z3sGHxJ/n5U5nL0qZipQwd0VD8Xk5nFGFA3ErBw3DIkVR2MkOChcGnnAWZaivSPdyLQH5WcDfKHtcvN6SFuiO6kTcfSRaNrEDbMVtPmuIYlfnWVjUfCqbjvHNBp6R24LErBAT+mxf41LO3gDP/EIlYOWJkUA/22UzdlJouB62zYY0Ump9tXp8YWrz7HwsNRGKuj2I2tbzw3U3n0EXXYXUu191Iyx7UcNc/4yoY6qJKOuS0ZYUO5kTSskSglA9ucY5u5heVZorWnHZ4V/wnTM/FIMrODS/9ZiFzVH8oaqEZQlckfdHYvZL8inxfBzI6xwf+u/44anzXn5s3cywU7roT/MfNFKhbfw+OXf+Jh5kVkPxfN/+EWQ0F2MhKv3IOptRtaNefmdyl69MsXoq5zJurrVzDF8xc0NEX+Qb5LnfwfPgA1rsPz54pNffDBB/jzT9EmqVNfpXLPUChfhmatVC6HZ88U63JzUu7iEs2demjRHM6O1qh4+zQOpLySz6DilPGHsFCZNcbMEIvPfg4rar9p34Q7n1L3PGavQrdApjX1I0LeZ7dxNY1gojKLSXzLamuI/6il+6D8MbZG6ls0oXRP6qKt/49quqTh4IJqj8X3b0pwfElwFGDNz7AhKSHMW6DBbGhfPR/X/ldfPldFdSNquCB+QJ/Og4zB5ReB9iEhsD/G1HalYwrbhlTd3SLLojv9rZJWxe9vgzuLN/ycIHJyNHd2hDXniRDNzeJwqTLhswJ9RXMu+Dkoz604HFYuXRLTYhs0/0yldbpA97CGW6vmKMw8h/caM7O8VL5PW+DmTzEXRbnpzMw7/h3LQqZxxX1UZWfmvULyMi9seN8bHWoKtPYQqVvXYPkHM5DDR3vls1to5hDzXflYHWrvrpmvaEBndvbJYRzdfxX3azRDFzdXbp4fGYh5xRVhKVXLJVpKmsZ1wE0Nobl5QsQ84WRVjMdihimiW/m32JlDFXGbEe6vaBaXSzU8zn0GOQczpft+SfctJ7PK+KhiMQkTho1cRdo9U/mML0185xXr2AA/J62QDKUzuF+1NTq1ZBpwCHfIzz5kyYabjRhPAwgtRHxbHeqquKHgASzvV5EXcj4oeX0S8qVSZbws1A4LdkYV5fALMOdmK6rKHgl8l9qDfLaXKazbNMdnKvOvhNloBEiSZYXIPPceGovm0nEOJObquZlrQoQk8HgonGjWl1gGyj/Pz+vJZ+WOBe5cu4fa9oSzAvtSOltFFN97RA6VZ7h9NQ33TMV3pnwgNVwwrUR4VCiS35r5t3wGHDN70uZ/uP57DXzGyG7RbDH2aww+fwI80iLTxDBphEf8vDN+r6YVqOvsC0WjG0neRo7XI5Phd/ILeH/+Hv9sIW4c24iQMx2w/xc+WsXP7FG/Gykc/QivHj3Gyz8fIvNiNp4L8wVFMwvZHarSHj+njWl+w+oCqrTLz9FjYJ+TwdAm2aqimWJqvFzES6V5vwTFMXO6RCoRbRKVSA4XauAzHCkIM+tU8Fr1PoUuwPLPSuhX7EwwiVCGRr1RdAZhrinpibaf26MJz+xVcfUDTqlT8EA6o6kpdScWq4Ikg8wKNNyDKg+l9yvQ+wpVUoMOKJo1yu1agocJs/o0FsZz7zCO9CkfR7EdY6X4prTcbIeG7z0uHY1qEI3yf6YMmkvpZmgpshpVdTBhlpZCDpB+q4THyvyV/iihb2jYSG4yLj21QUu1PgZSMkcd/sLeGJzh2I6yDGS/KvBMXnYVJh/CmftV9cpw0gU+Q/+un9Fl6KrG599KCHA1Ug8R+uAoRpa2vumtPCGxxLtH8O2YIzSQlJmlw2ySS9VYYLMR1yk1qlR9NEp45n8D3PUBDVv8HtYbF9Oo05P4Babmpm8RVkoN+dZnYeMzRgj8QyCgnl74D9n4W7RNdg6oB2UmvNgF5WahVPrQbAc6XuVHG7xFezZu5V8OgdxjmEAhbvd9fIruvxwc/+bjG42uf8XtM0NG4tW+PgAAIABJREFU12PX3m04cqMBug3zge/svtAccP4HAuXZJWyb8TOWn7yAJ7UmYGv4NLSqAtyPX4ppM2kI9t0qaD1oNMZPGguVbMbXeNh/AdwNgN7pKVXhFgz0XrUfQV9agckK+uM6tSyffwzNlu7SmYZgwKeMjxoh8FZCwGh0lf5a7mx0RyPveNix6Xr2+JiWLL53AbsWrcGzCZSCqZ7zWvqPGlcwQqDEEHiG0xu34H0PJoW+xIsYX3xHIGA0ut6RizQewwiBtx4ClMZwdPnPWLwlBtmFtNsaDhgxZjpGDmBSFt/63Rs3aIRAKSDwDGl7QvDjT+upnpVquloPwpCvxmByV01tSErxqXf+Vaob3LQac9dtRsp9Omwla7gPn4yJPp3ZFE7jzwgBIwSMEHhbIWA0ut7WmzHuywgBIwSMEDBCwAgBIwSMEDBCwAgBIwTeCQgYja534hqNhzBCwAgBIwSMEDBCwAgBIwSMEDBCwAiBtxUCRqPrbb0Z476MEDBCwAgBIwSMEDBCwAgBIwSMEDBC4J2AgNHoeieu0XgIIwSMEDBCwAgBIwSMEDBCwAgBIwSMEHhbIWCY0cXOlAI+UZlVUvrDSc0+4FfVZ/5U6TdQJivICgrwytxcYqBemSz/NyzC3At74SrznUq7FVo3rxgVLYX5OaVd7216vwgFBSYwL01BN80uofHC8vlUr/10RNf6zKx67ft4bR+geR9M8wJh4Ndr+85bsPBbd5dE6wWviB6MnVLKAjtkBXkormhZxvy4LHb2L1njTfPmsgLrW8cXyupgb3adIk6QlImO96ZoWZ89v6m9qN7W6/6utrMzs8iKKwrzRd8cHulpdOVgl9cQHLLvg6LF03C43DjskZx4X9KN5yBx92X8EhsIn/XpcJiwCd9/UYldrPDGfgQHHUA5753YF9Ttb5mzpP1UTFeqBZg5fRVisjwR/hfNYdD4QgGuxcQhOfpHjFxN0+M9g7DOqxH/ND/ccfMZvD/lHG7Pb60TmLH+9TBmj67HWmLumUiMqK3rOeW/5+zywpBD9uhTtBjTDpfDuD2pCO1ubtgiak8/wOmQbxDw40GcrzkbaVenwaaUK74trz9L24PQRcH4eU8Cas5Ow9VpJT3ZYYyuQNPTzfwR/3AJXF/nAR+cRsg3Afjx4PlS7vl1brL0ax8eXQEeYWbwj3+IJa8VoKXfa+lWyMTSlk3gn9oFYVkxGGUgzZfu2ypvP0vDngUzMX1VDLI8w/HXFs1csUy/+04uxoyemIe5szbh5NMB2PeEZMw/qElf7rGFmHWkBr7+aTjs/0H7FqNSWtR0/DhnJcLTG2Jh2lWUmL2/afz8l/D41wtW0vEif8DUmetwSqeOp+dOMpeiZRN/pHYJQ1bMKLw2Vk0z7Sp4hMHMPx4PNQm/N7UXEWgenA7BNwE/4uD5mpj9uuhJw9kLzs/HgFmP0dv2FPyX/YoWKy4g4euS6mt63rfoMb2MLm4uRjXWoOh6bQu++w/w1WtgoCf8LNBxRTOsuX0CY8VYmLsfw+164ajnIWRu6I7Sqv6Gg0nXGzJEDaqAfuFe2KfV6OLWubO2A+qMu4qJcfkI6aC89rUgW3ibapparvwsM/PFB7uRvL4vGaPpWNTMFgEpDnKhUJQchPbOEeh/2UAhcWcj3Bt5o1r4X9jS9Rq2cBeO4SWUmLKsZGR+4gh79uLoLt/rha0OC98po4u9mfMzUadNECwWlsboysXZVQtxrPp4zOjbCGWvo8iQlZyJTxztOTqigdnv0dBGh1LtWRd9/L1/zz27CguPVcf4GX2hNvT+791aGX+d7jYqiIafd0aAb1voPxKGWnAnF8PRsX7Z7kcWhUEV+iHca9/fY3TlJiO52BFlfayyBZK+q9Hg3zptENR8K/L3D3sLZaDmc7BOj21uf78jQF9QSz5XgG09LeB1ZQbO3Z4P3S7RUn2slC+r0HMZ8Pjc5GQUOzqijDmEfuekUSPJmZ/AkVMg3thPWW8R9Cv9dDydm6QzRQWF4kHnAPgaMLxLeU86vwLknsWqhcdQffwM9JULPxUdoIR70ePryo+o3GPpZxbqkFuSZz+NKVXdEDeV0dE+wbGFs5Ds+AMC3uBsPz2MLsMMCoMvQv4Cj9Sv5iMlbQbsVRY6P7MO2gQ1VDfISv7BMn2TQyB9CJJn3tGe2Jq/H8NU+Ej6omZY2Pgq9HEM7x/eDJkBgkGlbnQBzN21QvYsw4wuWdQgVOgXDq99ZHSV1kEtu4agVsNhsl3YwztsdKUvQjPbAJDVW4pIV5mipdpismtBaDXcBNuFKGMZCOTXu2Pj6q8bArlE7033D0Z+qYlddac8rf8tRlcu8b6m2D84v/Q87HVfgD7r31mLDnXGgQQgTih5JPV5+e9+xoCUa3Kwjp+ch293jMbbNcHsBPwsOmLbsDjkq3pK/27wqnxfjZ5Ly+NzyXnSdD8G52vL4nldQJDhWlArDDfZ/mZlqpreUsZGV0nApbankixCWqGqDlCyZQx8S/0eS2t0lUhu0dltHWbC5G/U0bQbXUwNVy6TVuaG+en9sOnWEnSAKT6uw+W0ygqykZx4BfeeA6ZWTmjfpp4o17UIN8+dwu/V28Mi5wjSnjdAOw9Hzd5XXqhcnSjN1BhjxDYgpWwMARZdqNYgLQFxGfn0/y3QpKOLaLCisHcPOMhO4EhaPkzrtkanlrVEkQfR+xZNIFtnh2F6Rbo45r2i2RrcPjGWCysnbUBIcX/4uVbBnUNrkNx0HHoaLHGkjC4FXRTlXcGF+Gywp23SES62UvVUXG1damh3uM1PR79Nt7CEInGmFUzx/AVdMv1MP6YcWBMGL57hT+YfRDV3RTfP4dTv1dHeIodg9hwNWlgjZYorRu2tipnxhzHGujKqWZ2GDx/pSjnZHY/iMmhPFrDt1gFNxGUfRTdx7lQS4ZYprJzao418ei4H94v/s4GNLAnnb1WGQw9X9QgG+/7vqN7eAjlH0vC8QTt4ODK+f+5ukwhp1XGW/prB3Tf9Ec2dHWHN1mZRTdDtP8BCwPRj1LE0YeH0jAMAKlfja94kjS7F95g1ndqLBgETfaUlXMT/bGwgSzqPW5Ud0MOVolvC3j2cWc8ik3v8Bwd+pR97FyzMlHGxo4utZM1HUcYmeLmOwt6qMxF/eAysK1eD1WkfPtKVgpPdH3H0YGGLbh2aKOWts3ebdA/PVc+guimqebhyIRkfNCe6v36c7ue5HN9eCThoWhetO7UUpQrrQ4vtUfOB9L3J8a7mAw17VNCzM+uqFXCoOeHqdRw/fwvPJc4su3uJ+xvhp7VbKzRXqgkT45Et7BrWJrzQVbckwiMWlT4G/uDxSgK3PmDuh8U//e6XvQoBp5q785FlbWeV4W78PPR2D0JSj024RcTO4ZRmGtPO84Xvx4FFoyYyrLMbxkW6Qp1xm0dibTyEO0IaEli+oEr7DDFo4gsiRJTdRfy83nAPSkIPloeZooLpc/AsjKXhj/GHiKY4mWZScA+5DFGLeZpefFOdNtk7U61bVakH0lxvoF6DWLCtJyy8rmDGudtQzzyn5++9hJletdba62llBIOn5awk6klFhpOGuibm3Uf4BFYVi1HwyhyKMj71uj6pZ2VZ2zDii9FIHHFKMr2+KO8eXpqp1BcTvgvf0l4fog5T5ed11BnzWQzNt+Zjv6qnlLnre09Rzkqi1kdeB18RxSq1jfKaEtAZTAheKmkNkudlZRHVQxO+UrEkTKiGXPGaBno+LmQzaOPx0nJKdjce83q7IyipB6f/sfJPms/JZYSaPlVS/l6EjE1ecB21F1VnxuPwGGuUKwe8fMkIXl7uvsqT8xVONnN7U9NF2nmAE/968I+iDGzyUtVbfsdyNpOIHOuF81CV103qtu6ElrVEF8fyX4H/adKzOH7B8rmL/0Nzdz7rRM67RbLTths6MIqR2p7KoRxeggMFo1eZ45VIT1DoBgpYeJDwk9QBCPHU9sICkZHl8cjmlEYo6xX6yVDupOr3yOhMp32YQAVlZqWcRPdHPMyE8wosVX5fYhtDk9xS58MCHrBnZ+BzaArqjtwNGxaf6hHoBBkrxcNfz7+V2Ogq3D8aLXzz8cPRMAz4iKIZRJhLno3BgfgQ2GYsxWTfWZT/XAQHJw8U/3EKWTnac6Fl5I2pQmlOvXa/wK6+6klVTNqdw8z0MjK6cimryg69Hs7HHfpucWhHNJ5eDmt+obTG4ihMmOCD0DMFcHDuBNNP6qP+w33YeR7wPpSJDWxdE6WAzfwSXWN7Iy52PKol/4RenRaDTELd6YU88zabn4K0GUw8j/HIuiP5m6sSwtSQS9dkdJGHYWkHuO5oj6jIGWj9IoJVvM82X4Pj0WNVcuw1GF0fV4NsR0/UHhMjh7/s7nr0rD0GMUya4JFWiJ3si1nh6ShycIJH8R+U+5wD68ATWPHfiWTAQd3oMrdC/Qb26OVaGYdXRyCz1hwkXQ9ECwYix/zQObAyloaNhcWZieg4Jg5NgxNxonMWpvqNx8qTeajt5Iyqf9xCWs49DFCKyFH9w9LJ8J0VjvQiBzh5FOOPU1nIaUj7jGmOtZ0DUXlpGMZanMHEjmMQ1zQYiScmExw4ODlv7oLTJ73x8Pv26LY6G1UaOaOZ6wSsCSzGN8x5Ba89KXbre9bGmBhFOidUjS7yTC1q+zlWtovBr8FOOD26NrpHD0PcnRBUPTgRfuNX4mRebTg5V8Uft9KQc68LAgJMsGfZXmTJBFxi6nQ8cH3OQQTYVwSexmKisw+iK9DfU8nzSLS31nMYYgZtxrI2+Vg5qBNCHnkj/PIG9FTKL2Pu9gKWuJMDBepGl7lVfTSw7wXXyoexOiITteYk4Xogexs45tcZgZWXImysBc5M7IgxcU0RnHgCk1XSTdOi/DBp/AqcyDNH49afo3VvT9SLC8TcWDP0HmeHJ4Vt4NXmNyzwD0P+MCFVWDMtDircgilDJiCM+IhlfRtY29Gd5+xAdOorWI3bg9QFtXBgyhBMCCO8s6wPG2s7OFfNwY7oVLyy4upO65yYjtnfLcPeLBmHu5/HY5XfWHy9O5NwyA1WZjVhVz4ZW47chF3wZVyazOV25zL8zacQwcmhsN/TF80mnQSsHNC64QDMOzUehaMbk/NkD1IWNUdmUHs4Z3yPF3pEinJJea7rFY1yPkeQt64ryI2LVuR5S7EJxOXLc+BIrE+WPBctnJMx/RZFwvW+X67uZ2bAGiQ84XHSQtdZ65ECF4kJdUdidz/e6Mq9hHkB0jS2GJp5PpudQekcM7/sitjecYgdXw3JP/VCp8UpIMBTemFX3F2vhYewkVeiwbWe6L7BCZsjp6Lxya/QcFScPOdeI1+YbK+chkvKwu3ICaxw5RxHZFSVj8GQul6ILueDI3nr0BVMBN4BM1NsEHj5MuZwgMfcFs5Inn6LFOuPDOCbCj7NKKnLJ8/EJZvpmNEyBj2HpmLc8sGQXdiO0NAzeDU+FvdXd0b5GyvhYj0RWaJai6KMCEwdHQIT78UYUfg92i/9DBGXV6C7uYzkVRX0Okj8Kj+EHJ/8jxSxiKkjsZTkzpAnC/Bt1mRcvjRZsk5Wal/TEk6BK2UgpShiKkYuBcbMJ14TMAibrTfgzK5BsMjagun9Z2BryiN02Xkd398eCc+gM7j3RFwjeQM7B7ri2//OwNoeyZgzeRc+21yIhR+txfLQFVhJcuFzeYRO07PLsOjHlVh2/C4adxsO1z5jsG60k9LevIY8wYJvszD58iUMyJuHsWOCcTzrE0wnJ5rd5q4YvzUdea+U6xmlYLo40BJ3DuxAMPEAp5XZOOtLHk6S45XcN8ElLAsxEsWQnNPXQjnTRg7/MZjvcR0BxIOtN5zBrkFcEt6NnQPh+u1/MWNtDyTPmYxdn21GIcMjZOcxr2VXHOixHtP+bzMCfs7FuAuX+DoxxV2Iz8uwJdn5eWjZ9QB6rJ+G/9scgJ9zx+HCJXFdNGOQqdAz40ThjS6NPF6LnGr19DYiJ9TFyN28013S6GJkhBtG3g3A0bBeePxTS7QLecHXgb/UqGv9P3vXHVdV+f/fvyIMUhQKF+IIDRUFGe6BA8U90FTKjXtg7tRMzK/mSE1zImiO3LizUFFwIIiioCRouJAUKXAAev1a39/nnPOce88999yF2+59vfojvPec5/ns/TEq37+vj4L4BfAXDAje6SpWivhycjXiDQdNG0XMWFRruggZnJyZWwKLFGyRypTZiPRcpWxXyOQHFxCIX+Avs1tEp8sRTt5V0a5JNSRvDEXcgy7YfHsnepJZqEpehY69ItFz3feon7MUPf2W4M+grTgb1kk72XA7Bqu+mYpJK0/iPmuzcIhZhuAhI7EjjewBXyfYla2JIonr8cv1mlhI9D68rMKZSDdMrtYUixzEVo18xIzlYJMh6DqXCHz59WR8v+sKVEwG69gABZexf3GI1lk4kaBKXoTmTTahacR2TKn3GNs4J/SEJ1Ye3oshjnEm6VC1VOQCDzp4FJ0uezhV+hjunZug2IHl2JZWDtPP/A7O9FAlz0OjOkvROPISFvocw0DntthLmeaMJXXxQInOpbGAi/K7d3pDnC4eagpp1ayN6EQK7MY3kjIqZnCmdtmM2zt7ggqgKTK3l/WKkHI3EonT28/Fn0EsyZMYuPQ3bijF5acOFFfJQc771eHfojqsrxzDvqS7Ar7thb8V0/FdhGEFG8nwe0w9Ypzhw6UcXcQoFkvH+4dmYM8gym6xLNxRZnDnUoOea7tUTE8/AU5eC2V8pvV0Cf1csWS/1UPlEqTu/jiPC3/2wQGpMjXH11J/V9npUpGT51Z/ARrsvk9lNoIzm0v3cyEH10FtWGu/UDGryGCiKTmUlQnmEk04kFHDhEhFFpX8YzGnrLiKO1l5ofMEHL9CTEVHEkpHmRCtTJlA527AFrHfjfUy3CUng2sgPyf0TeURLtLJkINihFFGLxWzkfmkCNKmV0Y3bFGXhwjvvUsCimDTZBcCygTi8tfMGWY4jw1iNCL2oklKpXTS43KnizWoYmEqGfOuEMo2Y9XRauH9efT+dOqd465iDSfH66w3T3S6MvDzykRUG9qJym1ycYCMfeqLpd9cIHyWwlWip+pbe+AKy5oKEXGR7+TNoYxGIOmnY3h1nnAcV+Y1IuOVwZsJ8spHgiGggxl7LGhwl+BwnwwIeXhEuJMdZiVdBB9TYLyV0mMHHm/pSt9nuIkMws+Pw9AWhnlRpEX/NXfwa3+y7PkSC85YdhGE8/tCSWeS/xrc+bU/KTehjMFjahJcGH3r0DPDU86YaHKGfSmjx7LP5UW4nEVIZR/M8BHPzP7dZSFSyah1ZWdOXcAMNhXxwghgPSlX4x8GX2sxyJCLLQFlEHigrVp5524JgOuxYcgg4zzTLPxyLXoseijym9G7KpQAMhxr8ZiV4LTol/n+OMXRZup0pJ8YIZSGyXu6jMiQyrysisEYUa7mEm24tsMW/924HVYMUw3JBTkh6rxLlDPWaqXOwblM4AG03XwbOzmrKXcLAlyPYVjGcjQhOWOu3OSNLr/ReH8h57QRrfKGfASG8ANcVDg0vAxarWmqxnPW2taocDKY10GcQ+nb4QC6RqdQ8I1k1dKG8BhfFMv5gSgCzSxoKuE5KsMb6N0DZ4afRvwUVyRMrILGYZ21nTJGjIbPRUGPgd7osbc1dqYRP3IxRR522yjI+JiCjCLcqmPCFCvkeK3EYoxH0W4U/BF7khmNVeD1py39vBGVvQtORNqi2qg69r8a+W/gu4Ls8JSU3bOznRmO0/FT4EoORpXGYejMv1fssRqEKa3+wAfDt6L9rxzfl1Q7RoZhehXLGrlg5B2RD1U4QTAcU+YQL6u1P+xdNyRyk8F/b+ud6j5znve2iXKNydoKQg+eLcG0UdokwhMBhYdvNNMD3PfmwvU8V7pn6L6Mt6NZTxkHx7muOK8T6FHgZyMy3s2InjLWOsEHkoKdsO/2crTk+DCFhkR4T4ZqRjySJ2UatLVMle/Skn3hNxKbgtFUkqiblWyRImmYXtmAXSGTHzrvUNvB/lhz51dwqkjUtYJNdBWrmlfH1h5XWPmvks0qpSrdNgvhnTkYE01Ohi95EKR7HVr8gPKsFE7vmST6XJ+uU8NGvIfUBpD32VNQYKobyZsGEnmTS+d1oV58B8YvRvWKjIUUqoAEunLGhONXKDjNG4JaPfGC7ACZTwkY48ps7Fixp9KE0nU5XXBHetZSW+MK3ug3TOjp0nW6BMfhqCzrRMZQDTKGUnpgx+Mt6PqrkNI2rS/IcD8XOKOmOCFckg3hb0bZhm193dFjqydCM6JA/hEonIoWVX9E4z3hGFGvqt6x22JpgW12AjYtCsakhTTBTazz1Gcc8EzdRLGh1phgEjAhMiKDEcfonFE62xVneYP0WT7KTpfgzJbXnrgkGkNuyv1zhXK6FJwS7ja6gkKfsGGlo8U4QbMRH3frBi+tfrdy6DTta7R7YFrflC4+WE3+x93QTfvBKNdpGr6uuJk33m+qy1sZPXuJQwB0mdyo00X3F0uIkLofodPHYyxlkUSe0IUNDzGZ06WhCcHZD8dTcmAuEb2UQgYJ+vIYetMPg5rLWpzriJFiKU3pd7o0gzS031+Mo5+NH6NbNy/t5v1ynTDt63Y6U5eMKkRe7mn3PxriRSVaFOVPMy563kjAm0ap0AvEIEkzoYT3gbw0WUcByOHCcM1+7ywGVVJFo0tQsEOPWqHm0DXY9l137dJYI2x8NqQyfGaAGf/M6doFdOGN/1wyBlshezEX7TMXv/qdLo3Roueu0r4rBQVpVObfbo/1ZXrj3BTp5FUZzxhxurI4WjsyXrGnVzBADMgF+fgvBacLZ0NQWQA8n8UVnC4e8HygMHdZI7TKXsz/m/lyM4Uy0t4YW2SBxumU0YHq0HCUabUG7VkA7Oqy9vjukwgs94nincud5MjwWTA5/TB8OEiyRTz9XaTMF2XN3RKmon3rdfD46SzCtNPbvDwxdC4+aENDnbpzgZ9OgsAVe3p5/hryQJBHOc7oOHQ/tlEk5RznHC1oqpmiqDqE4WVaYYWVkH1vbS2OtVcYPqH3u4zWoSm7F852kTLrGVjilsBnUdd5/CRkDphNsLukB3otisTyrtaCXhYdI+aw64Up3fMq4dtlJGXk+AAF5xR3xeXx+1kgVYIE9q79VHEh9HMx/j9PkyTTyVniwSYGXpsxp4852SushABZa2vNWo6ry9DIZSTO+MzF6RMT4fJAGEOeZei+6vOegc/c0+QgukD4mbzUT7/TpU/Gc6EiQ3rKsG3D8FZSDFDpCr/nId/NcrqUbBEz5Yd+p0tSzSQ14ANP8D2XN/0GQVcVh4JP2mp99NlBus6kePeX5nTJnD3h2CJ9uwkB1XfldpiCbaFleujabfrsJ40uF0uCQeZTKKaPH0uZMBH+/zKnSzSEeshKAbWA+LsZTpeRfi6hJCcS/htYBFGKTF6AjYOKKw36LBchvVah6sYN6GlkdJe63KL2LCxqHY/2HpIBCAadrsqCEpIN/DDN6VLo5zr3HcYm98BCc2e668g2ZadLOBdjFPV0EsNNoa/S6Vr2KAB2gZc1mRI9BoixYRU6+HhIUWw7ymSpyzp1HiwYJ+mdseMSBQ2s6ftlBgI/ppMhzBFTIZ0usWQoOAxzisxGUUkgwiyni3oLg52pF/ApOezc+Xj6lmdkjFj7SlEunciPlDaW4VGAHQIvKzvnSm8rlNMllmQp8KIhWvThMoit9ug6XSKufITM1FOznS4xo1iW6DCeMnYXKfPVENt6ReNcSD3BKKZSunlBPfH1z5lQfdAA03/diRBTp1Axo+s3rtRsxDnU7XQEpRGJyNJLkb44G61GO+Igny0yF78vzukyKvN3f4ZNnSfhqRZ/meN0DcMFjtbOKE+He0gOkkG5oGPTKOkflt34bRgO3h6Bc3U74UhpIDKyNJamL0Z2q9FwPChUL5gtN5mhUsvQoAst4704QgKi8OnOibAzMM2Wu5bg8OaoA2eC87YC1t0moN/fybjk2AFjpw2Er7S3RISHwXOxrCu0YS5knFhGsKQwwOOoC30nhab2iVNyWQZHjIvxTe00fMmKnPcLlH3hxRO77zaxooSdSfG7LDtxQwx8is6ZdTdM6Pc3ki85osPYaRjoy/qq2b0KOm7ADcokiU5YNFu3YmhCsJpUpM5s95MYOMEG88mh05mRx78rVO0sixF5SlVJes/kGWxORnADKGh6J3NGNf6wmI1PZQ4Ulccauy8PT5blT/XB3NMnMFFxmnAhnS4DesqwbcNklJv+qZqGbC1T5fuzOl3myg+zna4W2/mAjo+e9hhdXfkaO13MJnCT2UpauKr8cpwurux54BIrBIfNQZHZRSXD6v5lTpeYVnXWEjrMEz44SihxUIo06rEJDfZzsYjV3tYSYa71HBZR2lIL7byd0MsEhwtZZFC7BOLMaCY05ZFdg05XVWEXzhnt6YMmOV06/VzGjGRz/l3Z6RIUaAY6ajUAsyxOSckwD8mrXqXTtR6CsdRQrLUXz0X72jbfao7AD1eYNCFQFx+MSRuSYSuWP/HPvoo9m2+heSDVFOefwpd1P0VMOTfY2X6CjqMnaZR8IZwuVVwIPJvOQJUw1nwtoyvTnS4VRd6dKWP5FD12XKKeR67Mjmsg/wOraWjGpJucEclKO/g7qRC3eR/sA7tRKZz0Y36mi+b7k6BrSEapWEorPO/qns241TyQesC0adRsp8sILyrRohCJZ+VNpVh5oTRTwzK5B1nWUl/Jhf7sDwfC61jXsx4W3PeBg21R+PYJwcTu4nAR2isYCzRoUJYGUSxG0KeTcPCBObuxWHYruhfGB+xFul8aZt5sRqUlRdGu3WVY90oTyt1EJ9lk/L44p8uozD9VCZOoFuQMGcGakebmOF0TcYPfp+YjozUab5yQArs/vkdpQ3JBToh69I+Q3YpGr/HMkhrGAAAgAElEQVQB2Jvuh7SZN9GMMqVF27XDZeteSKOMFwd5c+WmaYOeWFbg4UKcGn0OYcUWU2bKXrckVKbf+NJ1dVkNV3XEVS9wAQFWwmtATRg8l9gSoC6h5uheyFqtoUFPv1GW2Inntd0sC0uQkU1R1AyjEKZFdtvqoC7fFMujGjPdY+i7gg0QjXHioBDmVJXVEyQTerwfy961Eb1YyaNpk9GEIGhowG5El1qHY5/tVNy/JbzLRV32KMA0VV1+yUtclsWstfI3HOlnr85qiQ6mWMqvHp6idqBYT9A5oZRM+b6aISD85DlqhRDbOHSHqJvvdLU2oqcM2zZsN2C6XAfROO+EB3ArfxaBBmwtU+X7szpdYlmZXrtCJj/Mdrra/SxUyog9myJPUqne5n32COwmL1l9jZ0uZqdmaMlyriiL4wNWvqtTcfS8M12tERdCg65mVEEYm/KtTYf/MqcLzBEKt9MMPxCF9cFhp5BC45WKmOF06d/PxTVm+2G1cxhObu6lf8cONZ5/4h0CW1PHQMqi+2LkUKydFRlUp3+JGXZCedAtTZRKqWxQQRGaFH1T/44aao/8gvRi8qmJ+jSs6HQ5a0+44uuraQlfW6GEhhfSLDv4oVLmkDP1lCZFskVzVUUYZ61F69IDhEEafBO8MhMIz7op2UlmpLywCZdhCsQu245YE78N/bndElyDfsBMlN8QiSGPClteKJZx2aLjmnhs68/twOIGogRgZvkNiBzyAaG9IfYFpiCsjVKhJ1taXFW8bxbWti6NAQYGaYjKme8Zo346oZzlpNnlhSqur4oUsqaskEcSeu5pjQlPAogW0+FBPVmR1JPF9TRd2RiIrqdHIoFKYbRvwmjkJguMcLRgMNO1Hk1YCZZtxzWI39af58GsE1MRMLM8NkQO0RnrbLbTZYQXdWmRBVkOBguDVxTqtgV+Pohg1pBrvtNFkWiC5XDrn3Dii08UGI5ouPI5jGaDX4T37ccwzmD0vIJj+5LwUGfaqfZjxECTSswgZAolRyeLsN5FhjhB1piK32dwutSllAJt6aw+MCrz38O3XB/cLUkUXuytEPv5jMiQsmK5n88sxFLvihdNUbwVMQhtY/ohYcZdBBqSC/Jpr4yuhBI5Se2hWKquciE5yfVPZQq9PSeLCL2d4tZhM+WmWH4prf7IOrQKx8sPgdTe4p25Bf+gEpU0H94q8I+uE0X0t/4n3OsygIIamlHll1ocxRr7iai7o4LM6eL2s4XiQq1RFEzUpjOD53qqi2e+pG9aOWzlhvRQbIc/W2h7dSmh4HynYxYN6nl3/59o+v5XWOQSLwy/Yo5SezbYSL3mJWky8hI/Quu7/TFTz3fF9+yIrYPTyW0xt/z3Ok6I6koEQi/UwqgAa6GsOkfTYyW8qwF2ZHTG+Z010Oz3Jjow0sBUhBErfzzlBO/e63GSpnfqSn5N2WP69//FqsS26HM3QNanLJQbTiu3Vcjycfwz0wXxfMsAq25pL5Sp7+lTAym0I4jrd9XKYGbpOl2a+15EnxopGM+v0mHnkdxdG+Py0mjjMr4ycyL16SnB2BXLJnXFoSijHHuLO0PzkTi7FSZ/SHq1dIjWHki5rWWqfNeU/Yt9ghfU/KqiEs0qjecLgzT4HjcFW4Tr1zRDfujaLQrVQVq667HQB5zuQT1KkdSjxAVGr2BjYFecHplAPYg6Tac6+0r16U7t8kKpLcUc3guizhD6EhvPZ4M0OFDo6EcFG0BndyorSb6g6TPmgtOcnBxHOOUzy0ZL9GV0wr4vxaPh8kJWUZYq3o1VKZyUlRdK9ZacNN/Unq786z8hyIvG/uZ6ICTuKGUChBGlWSdCENB6Dv4asB27x1ehhu8gDKJoR+Q6co5ojGfUjPo0uYqMhZA4HP2yrp4R1tx47nhsGDyFpkp1w3dLe6ACA9zdUyuwPBLw/3oZvlFHmBXsn6xDNOFsJ/7ruBU/HCTloK6xNhT+ExyRM5QHaONvj5sF7+Dx4VjccvWGf9+FmP4kGN4h1Ig/IRoJM31hTQ28HsTU6R40YewkTRh7EodZ5Ax+RdHumh0/o0WJF7A7Kg7Z+cVRpcsErF42Fb5lNO8XRk+n4MB/+mN5kjMClywkAVAW3t2EkeCKH9bceuaDoYjMW4FWBq7Djfa8eXk3P41vby4I5iexd2A1fowoDQMlI7wvmg08ArcFu7G6gw2ivuiKMPf12BmisECVRnT+FORF4+9peqMUd6LR9cAJjf1dced+cVS7ugt7c9wQtDwck50i4E8THDkYxR39EnXZ/FvRYUC9QPi8Z4u+C72wtvYIRDqPweGkb9HCNpv15eXCf9k1RFCzeTpNMPMbehDZNOLAsUIJPLnngKDth6gZ3ZqGZ/SD2+C9sO2xEYnhn0M9SV4Cn/zsKMyo74f5JAClNCs0lA/FQaqF/8CxAko8uQeHoO04tKAlSmWsQ/tq/fBzPvfOj0BzAulTBh59x+M7fqmuWHL2AE6N/eF65z6KV7uKXXtz4Ba0HJsWdIXdts9QVXK24jFCD1a2Yz10rPkQBX/b4HjMGdjVbIiAsfPhvasZBu+1RY+NiQj/XFi3oMqNwmQPPyzKaIh5SfsQ7HoOE7iywsdtaKLmSrQtkokLF9OQQBOsfm59nEpqbyLYtwN+SFOhSHEnlLbOw9M6c3EgQj6ZkruPmDEDocMH79n2xUKvtag9IhLOYw4j6dsWsM3ehr7uPYjf/bHsGk3yLJNO0xH9MFQAGiqUeIJ7DkHYfmgBdPYJqic6OmPM4SR824LGJEdNhocfTZZqOA8pkRPg8iQZSzp4YOJJF1JOSZhnH2qAF1dg9ruD+FURRVyDsH7z16hy/gt0mPYE0w7QgAKuvEYUrEVcEbR+M76uch5fdJiGJ9MOIGIIV7aTi6jJHvCjiU4N5yVhX7Ar8vf0hXuPrSjoGIrUTYNQJnctulcegL22dO/kdeheLh5flmuFuZlAcafSKGHFwa4oXPyHYcY3I9CoFKfUe+DSrBgcHFcD1+Y0RJODAxF/ciTcmCIG9BspPGmxjELyTDaMgwI33ECN4aX3aff1kHwzGb/Eu8u7VsKISHsERaRhMZXr5W4zdtdMoT8ttiLaBJTEOzVmY77jfHgq8JhBmU+oyI2bhfZ+XyEWNdHxM1ofe2E3ouKykV+8CrpMWI1lw/MxjXqXwhVlyCYs6FMK0dxQh3Aq2SxSnCZLPsW9KjM100X1yQWlxZZXqSyu+lDEVmyDgJLvoNbSCFaOxZz25JnqjDef/RpeWjMIQECQeXKTBiv0qdkZ2yp8gR2hfcjum411743G0qnaMpbP0n6ezk8kY4My2ZSuSbjRdhn2TPNE6poZOFH3ByzvRYEhsWG9Yw94lw3EyhWdUIKf6jUJFyoGYeF/vJAethfvjQ7DjDbSlSZMIBo811WsoXHVQVlTkBQ/Dg5HJqDztPcwc/dstOFLFXUHeAiGYR5qNm+JmZtW4L2p7yMg6WtyksfBanFd1Flen58ayg3k4I2q3Q3RqkVNDF9p6LvMEMzxga93XyzbRXzEJupNulARQQv/A6/0MOwleIbNaINyBcLQJnUpImdmc+/a7wpv3yFYs4WG3aQJMFKEqURX8NH77+vhZ3GIiI6eFSskuqCXY2NMoGe7Z66Bv3sQsqYkIX6cA45M6Ixp783E7tl0Ng5sXHAhIAlfx1Lmzmox6tZZjvo7udU7d/kqmW+rcc5JI8T3rYa+Gd8IcsPQfa+TvVL1W1TbkYjVjeLRt1pfZHwTj5PC6EnZh/Wbifxcaz4WFp0OVwMyPvC30Xr11KfTtmNczufUWxeLim0CUPKdWlgaMVF76jGdfVHzBhgbm8/rCCerAqAb671jwQtlW8sE+S6W1ZOVFejzHmyHbEdY5U2CzrAiOdPCGpdsyqPk1l046dgMM7atwrC/V6O+ji0iTEZVtCsU5IfcbhkQFohYP04vM71YEUic0ZC3E0Xd+eQYNwznB6SpivB6wzrvKerMZXpIhqX868vRtRLZQfZBiEhbTK0PucwOKkDH0FRsGlQGuWu70/RWztbZiuR13eFIQ3e44KtoSw3ZHobKm2rDe+wZWNXsiBbWl2BTviS27joJx2YzsG3DJHikavRv0r5gfo2IUDUj2gBDsO6rTAyTnoX6BMX1DUfcFmD36g6wifoCXcPcsX5nCOk/CoYZ1SsyJ1OOR7KzvdbWJl2lsRWy2TNz/ZfhWkQgfhvNDQ3LhmO9jqj5sAB/2xxHzBk71Gz4KaZtH4eczyV6q9ZSREyUTrGlac0S24O/O62yiJ/TDPUIZ/YG7EdDpvbz+DcTRsazfUzsbVpz7cmgSU+MxblMG7jU90R1tidEZ6+Qnt0O+vYP8a8ysA9CfXHO4SLjvM3K+fDLF5RsjnSiogEICY7QXTh4NoCXiy1uHtuHpKe0n6gubXCRLEV6t1gxWD98KOxo0jqXuNeCJknTHqnSOcn4p5K410n7xdwIUn7/i9ZHs+9M+Zik9OlMl4uK+6UMXIZzuuSLnCS7ZvhfijsXHjmhRh13VFXctSGMjNc6qvQ5bGdCjoMnGng5ICM5E87utBNKuitDAJJ6lxtnvNxKoH1Ndx1oR5U7PpDuJaJnF7N+iIeSHVTifgn1XjEHF/jW9eQHoujAUX5H4aKanVpqlIn7rCRwyJHtXiKH4ZcxwTjaLAh1/o8dKO8qDq1ZguPN9+A3fnw6wzn9ltvh5ZCRjExnd36/m76zPeX3foHtecpD4s/HcbukFxlQVsKODS2+eio7O+0iKUGOyz1tHtSQIruXmg+JFnl6VtrBxn5F90w4HIe7DrRXz/0Dw7SuxiPB9Fw8Ymhhh4OLL+p6Kuyj4UGrvU/Mxob2uz2SIPddG3riIzxS31vYtcINs1HkRdoVdp1lXXtsvIDBRVLxyImjPRdNEEd0ukiIXhhcBKlE35r9arpneldY9CLsmONJlWjwCdGg+AeepqyR8n1vhL0ThOZlxfPfxYUNNLnt3Sm4trMDnmbeI/zdRdrpdDqTZEeherfhOHwYwU1d0s+3WYkJeOBWW53BV11JQIpdbWGfjPRjEn51edemaDE8yZPQjuJdiVZo9PURjkhpf5+PUwHuSQWAnMf0yHz1ccW9KuB20pVGTjJldaT40idD1Dqa7pGeiNhzmbBRoDUluaAPwsLOPe5a0h2M9O2sRCQ8cENtLm3LfSginZBih9o6gJfIC4Nyk51AvVNGaa+b8J2stZ3QPnsmRaS1x9yrd5Np7QfkfsEqHmy092CK39fhByVgGDyXZj+TDm/ztPwQxKRsX5wAu5/PqODG9g1eo9UR98rZI5f4IEe2y0fFTRK+/J56N6Gh72Yl/ozj9yiDJ90xKO48kvE0H2QkfSfdRcS/K4OycpLf64epCCQuM9AIoQ3385NglT9Mfz2Unc0QTK/RepN75WCfe5p2HEl3gNLE5WOpsC4JpF+kiI58t6m+++Ym41iqNUoiHcLPpHsrFU4t4eeGlZ4iy5A9w2Q8ldUo6CmxykagwYuQ72qSvlvUEY90dJBeW8sU+c6xp2irSe4t4pYUK+mjPKSd+j+4cntidWwhbTvLdPkhtVu8UPye1C6yQbFiT/BQIidFu1i9x5Dkn1QPyeW5es+poIRQlJ6XJ3meDdmdT8ju1KgljgdpTpzalhL3fYo70JiNkZeGU//nKuw1lcNClOVSG8CrOO6JO1fZWcQ9vLwtxet9wmmNOnCvyvQ+kwuGdaiuDSLFo/sH0j2JZAcUsyZ4ahmCtHONBmjwdMdswDySPcdvo6S4G01K5/K9swp3L0q2Zp7WvlNjNrg+zfJsfzdheuGzveBF/Zr3xAedxcCti+AndO0KHvzGRticTHsTuEmGlo8FAiZBgGWxKKMojDWXfKi+udamFjjPT62yfF42BIz2yiiVEDzjIVNoVK13eBec5st5JB+uXK5rPpaKS831vCeLyg07b/DHbnGgwDOex/LztwQCtGpl4NRimCXf2/OWXO9NuwbXc9v3WADWyRzgN+0eb/J5jcr3N/lylrNbIKAAgTfQ6UrHL3NXYn/6ffz3PSd0HDcd7bnCeFqGNiU8En9yGe6PyqHRZ1+jaw0Lzi0QMAUCGVRmUwVBMTXxxY5QWvr7If2ogBb6bcG8lQ8xfJNCKZ0pj7V855khYFQpvwCn69i4kvBdSJPEl+3B7PaUiaNb/PU7jfyfdQi1Fm0Ryhr1fR4ew5r176DdCIXS3WeGhuUBbx4EzmBO/X6I9++D0unvYVgYt4j9zbvFW3PijB3o12YBbPr4Iy/LE98tkC2ufWsu+mZcxKh8fzOuYTmlBQImQ+ANdLpMvpvlixYImA4BKptZu3wGQtcl4Tb9qqiLP/qMGYVBLal80mIkmQ7H5/jNO8dCMWP2d/gl9Qmsq7ZBr14DMKZXbc2y8zvHEDpjNr77JRVPrKuiTa9eGDCmF2rrbkM371RUbvbr4u8wf30k0vPop2U80Hfwl+jfXSzpMO9xlm//myGQhUNzp+GXop9j7EBfoefH8nl1EKD+o/WTaYJtvbGSaaSv7jj/5jcble//ZuBY7v7WQsDidL21qLVczAIBCwQsELBAwAIBCwQsELBAwAIBCwReBwhYnK7XAQuWM1ggYIGABQIWCFggYIGABQIWCFggYIHAWwsBi9P11qLWcjELBCwQsEDAAgELBCwQsEDAAgELBCwQeB0gYHG6XgcsWM5ggYAFAhYIWCBggYAFAhYIWCBggYAFAm8tBCxOF6FWlZuLp/b2/HLal/bh9ggU2NIugpf61pd2PVNf9EpgLz0c4YHW7/F7wF6rz6s+F+3iyCb6dHyTpojk5yLXyl7P4BPaZ5L7FPb2LwbR+dm0PNpReX/ZS6WrV003hb4s7YThQfhi8CMeK59kvRXJev3zLPKJTqyITl7sxAtVbjYKbB3fiiE9b9NdCk2+r+yHz1OuPV/a5/Y2FthKdmS+MhiZ++LnCwez3m5Qh5n1pJf/5TdW97xcUP2Lna47OBY6Gwu+W4/IKx2x9X/r0ellwD43DrO6T8O9LjUQPfZ7XPL+QdhI/zLe/dq84yEu7pyDqV8ue7mw17n/AQx8vx3C7cYi5u4CNHkN4PPw4nbMHD8VodFX0HHr/2hp50s+FE0EXPLFJPxnfxzKfn0R5ye+/pR559hyTJwSgp0ny+Lri+ehdeSHF7Hzh/9g9rzdONtxK/73XAFKMmT5REwJ2YmT2QHY/bJkiF6SeP3o2Sj1En62zxyPqaHRuPLc8cPeztHAinlY+B3hqezXuHh+oq68JbpfPnEKQnaefPF0n7YItauOxYVW4bgSOQDORoH0en7hzrEl+GLSf7A/ToHvXs8jvz2n4mh6zlR8uSyy8HyTdQIhQ1eh6uRByPmRpsDStFY7PTL/VsQQDEzojLAZbYxO4MyNm4Xu0+6hS41ojP3+Erx/iMfJka+/HsHLlAFalMjZQyswb+F3yjrsjaDaN1D3vCK4vnqni0Z1JxZ4wavSq4BALjZ2ckDvvb1NN5honHRi2kfwcqf14IX48DuAosbziv+jQ3MxLdELMye1BL/f+V/1USGi5/vottUM2D93+GThxLK5OFR6GKZ0rWIg+m34xVmJiSjw8kKhSVhGUy9/d0kWEhML4CUy4Z4++L/OG+Ax981wujjsJM+uAY+pVpgrd7q4f1RFoOf73bC19+7n7HTxb8bsGh6YmvIq6Vikz+dDz8+dzYw98AXsWtN9ZRymlq+P2Q5zlZ0ugYhQw2MqrF403RO/R8xegTstJ2FEo5ct+VW4kpiGj7zcUTgNpg3ZPX3+jxaBeyjznTG8v9H/LpOZhbyL6koi0j7yQqHMiWeRa1l70Md3M9ofXofu3B4DE2g/i/RCy4iuOGRw6fsxjCvpi6jxnO74iF+XkOg1E5Navmw6LyRCTIBDIZ9s9GdxU8uj/myHN5SXzNU9z4d/jAL1NfzCK3a6ssjwroY9gTkvP6LPkCEoDVMNJhXJprroY/VTITMAzECzMqD4X0MieVFHMg/2L+oUz/jcLDLoq+1BYE5hM6W6NPWyna6siJ6oticQOWIW6A10ugSYQY/CIgPj/zpjwwtxulIwr1YNTEoyVYY8I729jT9/KU4XwxMMyF52DiKiQsr31x85KjIq6/axwk9K2b5CHP/f6nTpyMxCwA60M2x23T6w+kmWnTf5WYWUa/TeeY0a4OTodOzpxZwhk2g/i4LULljcNB4JY/Rkrl6h02Iy2Ax90SQ4PJc36TzEsA57Me98VU99Lvzzqg7/jO817HRRX0dm1kP8zb/kXRT70BYFf4n/T38pVgpO9k+RffMvPKJv2Hwo1u/m4/qpaJzJfAQbJx80rV9Rt19KdQsx33SB/+wz6LD2BhY0t8GH5aknIv86TkX/gdJNHXDtl4t49HFjtPMiwUBnuXgyCqk59CKHqmjRULK0VvxNOw+ojvyCizk2qFDPD7XVmyip7vniSURxP3ZwQR3XiijlJNT1Kxn+qtyLOBmVCuFVLdCwBvfdfKSu7Y0mA3ah5NQYHBjsgmKlnISafMnZNN+XYYbr4frrZ4yr0B873KYi5sBgVHy3GH8OOhxOnv4Hbm4qnIm7gWIeHdCkCj2YnpueGItzBEcCJHyaai9nzc8+h/jEd+FJsPr9cBxuPHJA1RYNUYPDybl4xKTnwKZCPfjVLqc/i0PnOhcfA/qqLlwhwO30P55o6vA7DtPZHjnUQJvmVbXwmX/9FKLPZOKRwhm1oSDFQ1WoQmuilyzTpcpNR2LsOQhXltMO9X3QvRLflZ6H0cJT8R5y3HNgVMInO5madhoImSoel6fxj2dTOPx+GHE3HsGhRhs0r6rba6K6FYNvuvhj9pkOWHtjAZrbfKju0eNxE5MuoyE5tyrT1B+LOQciCb135+GbkoyPdPBoAo+pXyfAjaMHQjKjEZ5wcSvmG3Txn40zHdbixoLmAg8fFjNdSTja9k/GN3K8a+NSix9FGLq5QXWG6LKYBzo00c0kqukGNnDyaYr6FTUw5v/tj9Jo56HCEZIDOTYVUM+vtlZpi5Tu7M8Mg1+Icafr8eyyAh3r0KrkPlowEoEo+Xet32o7XX7Ux/AXJwxFmSnKCCnqDcky7nv5qcKdObh4NoCXi3YPkln0THKLk8V/lG4HD9UR/HJRv0xQ5WYi66Eg7Um440PbAvwl/j8n/7m7EJ/d5C/I5DV/Xk5mnyGe1cWjNsVLabYGalZ2FvhF4nTlfVOSyRIFfOvhKa53RIC5cCYryT0EHcXRuh6nS3p2+zMYJhCRHqfLEI2IcCa5cY100KOP0bidF0roke08Dknme/q74CnTnwLYhfPK7/QBk8WCDpPpP7lY0UNf+alr0bvJAOwqKegfFzVshAcUBv+HxUxX0lG0/VPQz7ryUr+sEuGgpPtEfW9Yp4rMRrj/EPhLw3yCLLMSbRhGv6bqawEiCnaDLbKVZCaRsSG+1LnnJ58gPcQPA3aVxNSYAxjsItgC3PEM6lMtW0OF0Jq9JBl8ymIe24fLNoZ1/tVVzVF9dDlsvU+BQrF1UeJsnOyYxcsJJTpTUUCueI/7CLuxB6K/JpIfT7M/j0OF/jvgxttIFdX0TLfSo4NE2pPZQJ+QrVOCySKOr03ErX6dItoybnBTnSG9XgweHZqAM7O05JdRGSD9vsY+fKok96Gxn5VsYzl8FZ0uU2xLOf8zmc/Z37o4JDikJyL2HNlrCnpXgAXZ34WwpTW/ZbaUmfzD0Yg+v0EtLyW2bo02zaFllklgJdqO5Jzo6mNFvOgA8YX9wUimS4W4qW6U8kxHvcWXcSq4CngPtdtW5NJ/edu788Z3/rZPUXTKJziVMgv17h1CcMsQFFsUjiEOxzGqxWBEVVuI2CNj4C7tTeackO3DeQbtxjtdD3Ap4j8YN20rUvI94NOOFD71tVyrTJHJSFfMrdkZd2dlkJNUgBUtXPGl9Ur8dmQICiKGY/igFTie64EGfjb4qFIl3N29GXEIws9pYWhLPk3KotqoGz0cqds+A/YPgtfMGjjKIn1yp4tLodfsfBezMiiKVLACLVy/hPXK33Cknz0y4xfA33cWSEqqnS7btFXo2CsSPdd9j/o5S9HTbwn+DNqKs2GdtEsGFZ2uW4id8xWClx5FtrMPGpT8CzcuXkNmdyqDmg8M9B6BnJm/Irx7CcqwkYO64CEG74vBkpbZiAgejWE/HEG2vSvq1amHLh0rIipkBg7adcHQmveRV7836l+eg7HhOej1cxrCOEDIPqrkRWjeZBOaRmzHlHqPsa13Eww44YmVh/diiGMclgUPwcgdaXD28YWTXVnULJKI9b9cR82FZ1mkKwuHglsipNgihA9xwPFRLTA4qhoWxh7BGC1kcy+m9PPU9mh9sAuiDg5DqcRv0dlvPsi1UJd2Zu0ZCO8ROZj5azi6l6AoIDk0Cx4Oxr6YJWiZHYHg0cPww5Fs2LvWQ516XdCxYhRCZhyEXZehqHk/D/V718flOWMRntNLjXu9+BxSgIgvv8bk73fhiko4Q52YZQgeMhI70pzh4+sEu7I1USRxPX65XhMLzyZAHtzjlMz24RXQf0c3idNlheRFzdFkU1NEbJ+Ceo+38YbOCc+VOLx3iDYPcEENBZoSnS5HJ29UbdcE1ZI3IjTuAbpsvo2dPQmPWSbyGG83JGNR8ybY1DQC26fUw+NtXODgBDxXHsbeIS54cHM7hnOBgG66Tpe9UyV87N4ZTYodwPJtaSg3/Qx+D/Hmn7mqYy9E9lyH7+vnYGlPPyz5Mwhbz4bB5cQoBA9biqPZBMMGJfHXjYu4ltldVr5L2b15jVBnaWNEXloIn2MD4dx2L3pFZWBJcyq9Gj4cg1YcR65HA/jZfIRKle5i9+Y4IOhnpIW1pbIoMi42BqLh2KJYenoxWubtQL8mg7GXZIBieSFYRNjRCVVKuKKa8zVEHbmGp07CmTuVyiK5UhOd785CBvF/wYoWcP3SGuMQ7JkAACAASURBVCt/O4IhHwswXNWxLcJ81mH7eFcc7VcZA6K88UP8SYx0k2W6VCcwsUoAkkZuR/hoX93+B66sR48sE15FPNlgHVodO4qgu1+haZvlSC9eBQ1qNcHwNWHwu6BHPinQc6eLERg+fBBWHM+FRwM/2HxUCZXu7oYASgWZoKISPDcqwUuvh8WXTyG4ilCJ0G1rLv2Xh+3deWmPbZ8WxZRPTiFlVj3cOxSMliHFsCh8CByOj0KLwVGotjAWR8a4ywI9uTgw0BXBDjuRNM8TabObokHqV3jMZVdFp4vw4121HZpUS8bG0Dg86LIZt3f25PFtkKdwC6s7OWNwpChLKJiwuhOcB0dKSmR1nS7VlY0IbDgWRZeexuKWedjRrwkG7yVYKTpd+mmkY8YijBkxDVtT8uHh044Ck9Sfdq0cen1WFpGbZLK9wyys/OgAJq08ifseQtatMpd9orLGJLdZSLo4Be4833IlsZPgcioFszzT9PJbJ3nVll766gf7zHgs8PfFLCg7XSgE/n/lnS57OFX6GO6dm6DYgeXYllYO08/8Dk5U6JdVLXFlfDCGKei+x+PvmKZTSads7FSB2gOsMeiXbIS25qrk6lKZcRLcQs7i7HQvokEVEmd4o0Hil7ixpxdKJJuor+noynbDCJRUkJn/UKBK0W7g+HKUwj07hyOm8kII5oTodD3BMUP6lHqwprZvjYNdonBwWCkkftsZfvOTQNE5oWz66lI0dBmF2CJk+zwm20fRbGR84LASN8l+UvcTMh68STLftnRNeCMGkWfvw6qBzHbLWIXm5YciR4FH9DpdtmkGdNA72K8En+4/YsP9IWbg9lNk6dMpJfdjVPAwLD2aTbZMA5T86wYuXstE993/w+rq5sgAjpyD4dv/FiaRjdL53reo3XgJHg/diQvfV8amNu4YebQ8Qs5eBpEe/7m2vBGqRQ7laa8Up7d9++PWJLLpOt/Dt7UbY8njodh5YYVgp8qqNVRm0Koa1QbfQTJsoDdG5MzEr+HdiRdmU8B1AR4O3oeYJS2RXWhbui1SZbYU14puDv845umzaXoiNywYQ0buQBrZyL5OdihbswgS1/+C6zUX4mzCGL4/l4dV2zD4rNuO8a5H0a/yAERx8xKOtEK0Mby8MPdK+cHGywtzN6KTQ29EqhXgWYRU9sEMTMeZ30OIOYGzIZUx2vEgToxwwpFgZ3TDFuQsac6/UahTvUty4T6VEMomQrEypt5E/EJlk9hjxYynitnIfGIHp1Mj8H67jeQ8PCbnQezfcMGGHIq2ELEKjpM/QslRGkTZrQyK5JQfepTeyT2XGL52VcysfRC3l7ckIUxCp8/PaLdeaKaWO10HBr6PdhvJaOeFFisHdNmAHGIae53U81Wsal4dW3tcwZEhnPiSnV8nA8+MP6ZshX9mvQZ5ZDCkr0drZOKBtRUiPyNlcuMbSf8BE5apXbD59k70tGe/s9MoaqGvJQU9djzGlq4EaxF3ZKw+5gAn/TAFu6DBbtwn4POYyaXzuVAZlgPDLbtvzphoXFroSw72ETKaWuCH8sxYOBIM527Alpwl4LEdNxXl68/GXVIC6meyd+YeGAjXdqmYnn4CIzjrkpShVk9XFtFZhd648Y0kyszenyrSHnu+3awkXJzCmSZiP00P7Hi8BcKVO8GhdyQZlQKtGMSnGP2WlIYJgi8HY6IvYaEvGZl0R4cWP6C8nui3nH5UdEa3+gvQQELvuUTnLtQj5SA6LVI8KJQziOWF/mvu4Nf+ZFUxPO7llWtrM3iMBU0WNMBudVQzl2jehfjFgRlGCiUqjC+dJxzHFVJkRUQaZf0wNlykdGsPXGFKW4D5XrWxKvB8HvFfOui4yHxgDSetqXQCT47FQqSS0HRlvQmxU07hJhnyxJVCOaB/KDlBg8hxySA+K4+hR5lRnUKDCLxnova+21jeUpApBnu6xOc1XIr0EyPwMWfEcwp60hnYDuPkwn8xggaqbOzF+ISVyLhsyKHyG1sh8BQzhv2W0MHT8hb4776NDZ1uasoL7wzG6R5f4b3/bEWIvl4d+q1+WZaLLQFlEHj5a2Z8s3vHaowoc+mZkM335/mHUsBqEGW8mdF0VE+ppcg/agf/bAgq+8wAEYvgcIOT/6PheJD42InkgSAAyFmWyLK7hCdpFJ3HkNBonbognfQECQAV4XgEsJ6CU2qny38N7vzan4JV2r22rU3gKZ2KBZ0SWbnTlUI06E16YR/TCzwRGejpEs6vTCP2TO6IPFAR2ZlPYOeUhm+4PjIt2e5Ek1LleoDhfZcPlorykYP7hDI4Sjz2XyP8piXXDdKX8RJLs/BPaBTg7owJx69QyRrxIpPRDry8rGxEVp0T+uy04KPCzg5m6FT2PmuRPnO3IKBMIA60FR12DrauODYsg2RFphn62pDdoCszDfOlko53wt1l2iXRKoP6tAmiKGjRLnW6Wg7p9qpS5QRV+qQXM5Dp0tIlkilNotPFy0POTmJBhg3ZaLiU8ayEj8MbyJw2kQh1+M4UHaQMH8cLgj1hGm6vG9YpjE7ySO6lC0oJ1k53EWqODOBtlGA4qfWOIEMmq2YgPnkSqh4ajjKtVkj0PCfHXBA7ktNT9/gAQbCTRt5wTon3ZBVmxCdjkofc6TLXtuQQIAQh9L2j34VOqND7Br6R9D0LtkaqOqBbeFtaXmZvDv9QNYtBv+F3QcfmjEE0BWkFs8wBLX4oLwRZKwvBwpgxIp0KAb52W/yx+/YGtI4zhJcXO6VW2+gW/s+400UKkDcEDrRlxj5zutJdBKOtxiEMd16BJmmcIyAY5Rs/7oZuXtqZlXKdpuHrdrI5TTpOl3K5H5/mzy6ArSOl9hM2YVHwJCykiUliVFufwhWcLgGhLX54AKd23+CnlaPhqy47VHifOCrbNhsJmxYheNJCxJVlfQByA5kZMDf9BqG5bIpCncGhGOgjB7mS06WgCPUYRtpOFSNESY+Cbi+QgZpvRWdCdITcMCvpIqa8Ow+1hEYZVm6jfdYsjvA3foxu3by0m7LLdcK0r9tJpnIxI+rcFJy6SdlQBhYp3ry0HGURbjKn6nc955H208hpyhA+9TpdkjI1IzXectrTEgai0y02PEsj2eIVDThdmmCElG58sMpkHtN2kjXH6Yn3KVPtxjuv13T7nfQZrDycZ+EO5wDd9MMgXaJHKBG9SbXp4nhZpGJ/6HSMH7sNaWpHQJdupXAuxTt1nuqgCwdKs3u6RONDzDawEd622QnYtCgYkxbS9Eae7rN4mXZkvOjoy3laVDaOcHJ6H91/ukLOuiFBbkiWsWfdHIUoFsgQeN5Lkyk0k55Fp0uHlvT1t8mNVuZ0pbsIgZgaZFg4r2iCNC4DxcuQjfi4Wzdoi/ty6DTta2iLe8GIGHrUCjWHrsG277prSkMUerqkvUI+qyQKVg9PXZP35hpzupgR5sk71kxXGeF1cTS6Lo3QoRR0md6SRjEIIAm+8QY3BXfseOehBg4Nd8aKJmmU2c4TAg4G+E2bIk2gL0N9bebgnwuPyAdpaOGymBF74IFgTEnPY7ZOlQWB2fl3gQUnc5ehUatsLOYCxGY925DdoKBXTeFLGdzlMovXHfr06ahcjKTg9zl1YIrDeiF6uhh+nqoDl4x6lGif8UiGlqww4rjr8J0pOuhdXTrgj2UGbrmvG9IpBu5nqgwQgvkl1QFeXYP6KpY1csHIM4z28igr6JGCrzhZzmivpBgQV7DGtejBTsgomm5b0gMNvkMWuFSbWEKgKaXHDjze0hVC5lrSn6wl1wzxhNzpMod/jPkNunJCC1ZZnB46gvGczcqXCcg/BvCi9PUX/DcTnC5yeZgHX50iHvvKhcB18V3UiI3E+QEHcanJCtQ8NgwZXHTkIUWZ7AJxWc7Q+i5hhtN1K2YxxkxNQO1Zi9A6vj08JE3zhp0uejk3LeqLrui78gLyizihR9hRrOsl9Jjo/JbrNVs8BlMTamPWotaIb++hUQpyxmUGiY8BRtK+uolOl6i4GCOoTTgtgQYdQWWW08WeJRjeGkrVekZlQ07XMFwIsKOovKQkRi+xMoZ8qv1dKewr8xGXJE2WTssxY5lPFMbpMoDPF+B0CXdiTqsarAaGLZjrdB0vj2km8xijN7mzp2UYwUynazTOcZluH0FIK7kXpjldqdg2fiCWWAUjbE4RzC4qHXRh2OmiAxOMNdnNQjldIu5zhECAJ/XnLR4zFQm1Z2FR63i0FwQMzg+7wMu0M1rGjpTQRdzSfjD7XBS4zMXpExO1y0i1+ILro9Mvy/jo59h0dN5xibLV1nzAayB+RDo5OXwlmSH5pEDPZjtdFOA6NLwMWq2oTlmXfSgX4orFd2sgNvI8Bhy8hCYrarKsQRE83BIAu8DLQoBGUdnJBAKVR80L6omvf86E6oMGmP7rTiEjaMTpcp1rnKcEmtA1FjSlgjJjkck/dVWAQESyIJP2+bkeTkUa4XYUPKPTRbVhgsH22zAczPDHhkqR6J2xHC2LMMPTAL/JTmmAvoxnurgAp6n4595r0Ola9siIPaBwHrN1KkFuWSO4jPwNww7exohzddHpSGkgMhKlyV5ZnN2KVeFQWs7cZ+u1G5ScLhP0jEGn6yHxugF9qugsvWCnS3TqOrJKH57QzHW6TNFBlfU4XWbgljsa9cLq1SlKvG2mDOAqunxmuGkF++QmTy7JxDKBu+BDtLcefdAqe7FQIcBoz00a5JH9WEtvPhYqDPTZlqKdpn4EF8AJL0An+o3yO0Q9pa031Y47CwD9btDpMmRLK9g4pvKPUb9Bl+aksBp2gdNDZzDl1E3whTIKH714ecEOltLjTXK61BGH0uMxHrvwweIUeC4ujs77/dCueip8FrP6bZ0yHvGVV7Fn8y00D6Sab+kpTHS6soiQXQiooxlQ5UadYacrF8mxGXBu4A7r1G0Y3bkPwtPsMDbmLhbQYibt32aR4HNB4JnRLCMjQ7accXVS8uxyVLq3eZ89Aru5ymBuotMlRuGdtTNDKuqne7/bQYyK4sp59BEiN4BBLNc0IJTFKJaWQBXLtEpi5U3qZ3lgONMlMGhDTUkMu+3VPZtxq3kg9QKJ12flZGc6agksKeybsBI1Zy3jlmXeDrLIv47gVGB0LZoygs8X4HQJpXUZ6KglXFnGrqRCSYa5Ttd56m/kSu/UpXKGeIyVbWRow10soyq58iaVxSaa6XRNQhoXnb5JxuFtzigU309lJJv3wT6wG54anCTICe44hNCgkhlVwoSyXZ2IrWGn6z2uBDi8pJaQNTvTJZZMepJBEWqFIBdyrEaz8kYtnNwQdrn5iKWJIo9fQUKKHWp7/akuL1yzG5hEpXxcj8UFPWOVjckyrmfq1Jd18WlMObjZ2eKTjqMxaaDYG2Y+PZvvdNH9mIFQevx4YNcHWJziicXFO2O/XztUT/URsgaCxc2XLmqXH9Hfr+7B5lvNEagRAPTHa4iNBRo0KMs7BUGfTsLBB60QfiUSA5icSZJE1KXGfJNNxnkq0Vyniy/DC0dJqbwx5HRlUUBRL408D6eLylZ5gy0anXs3RvLHX+M3vpxTzH7q5zepljFMX6Y4XWbgnycB2ch4pYCOXln1IVbIM11m61Q6BMtuRfcaj4C96fBLm4mbzUhGFW2Hdpet0YuvwuFAKeizm+oSOkP62pDdIJdPJvKlkUyXAEs9+tT5DsZ5j8UZLX1dCKdLX3mxEu0zO0Q7u8YyV7VMLS80RQcpZDxFtWIqbo3pFKX7mSkD0iggVpUCYpxzL5a1c8fMSkzAA7fawlAOMTv3oAu6fHIV9VaxyZRsN1+6nPZoZVLCAzfUph9r6TAWYDaNVhmwDL6jLNLGl6EeOWdt54RV4RwcFcW3BBXelpbbYubwD6NjM+SEFqxuCLKcc3T50nW1ik5Ail1tcHP49OJFZqG/jP810ekSy3eSUISYnm9IZdmvXK3+JLE23RYd18RjW38um8QNUAjAzPIbEMl3pUs+TGk3440/ofRQaZqgtmAXI3GsnpPXd4ZSokQMtaeh/EEmeK9SuYHLSHzIjGLt38qcIhWVTpZphRWsh8lNFNqMQNWITPegmvZIqmnnpixewcbArjg9MoEcI3kewESni0o6+ZrUcDtNQ7IYgaQhFPzAkiLP6HSRMufqkcdeEMtGOegL0dZxHwo4LqXPyWHKoyyL6th2XIP4bf15oZN1YioCZpbHhsgh1Duj+QhRolvwmXsaJyZyTfZi3waLvBRQz4Qrt6hY0ytIKVYe/geHCU37Rcx2uozg87k5Xc0EJ5UjYb7fiBafqnsKOLByNDeOaO6GZkSvCBodmtLwmnJ54SDKMFK57y7TeEzInFxAW3EIB38cigyP+xAb+AlUDEbNJErUYHnhesp+cLhMhwf1fEVSb1QpNtii6+mRSCDB/bsxp4vdOVXs/WM8edLE8sImjO7sJM6N4Oza6cm6KBgn/DtnwIsb3vFwkNZeMjGzL/TxlRXKq3cBPrNiET3FCx9QtiliUFvE9ON4nJX58qWXq1GJb+RPRbOlyfhlxCc6mUBjsowb/NJwXyBSwtooZBHNp+dCOV1qvihCwQOOZkuw7IdsyIRYymXbEWvit6G/IAAwNWAmym+IFIaQqD909srnMJo5bAKM92MYF0grJhjD+pyuiTDOU3xPTXhVdcl51trWKD3AwCAN8ex2hLcLNMWNU8w6PaO6ukrMnGnTyPNxukR5tyJX2/AWZKd+fpNqGcP0pVu+qmxkiAaUEfyr9bVkgI2W09WE8Y4+WfVIIcMhti+YqlO5G6iIzCkIvEEFF3KiOV2RyWe/TqKIVn+xOc82ZDccEwJVaplpIl8qOl03WRBVdLp3QVmf+mA9V2FwywdzT9OwHm5QlRicVVfEmNDTJfK2nkEa0smdPI13SMW34kAhHtTCzkNN/62MgnR0hzBQwbAOMhQMMBG3xnSKolMp9P/tMlUGiKXWjr2xI3E1ulKbSn7ibLSaTLpUYu9kUQC5AvU4q7ScCJH2HNF7RyJWd6X+2vxEzG41mewCQVZqBw7NoVURB4bf0T2V60UOZyXMfNiMVbEdJDlMA3vqFXkGW/oP2eoUc/jHmN+gKye0YFWW4RE+mBUbjSleNOv1VgQGtY1BvwQq7WQCUhkvyhLwRf7VZKdLMBynwV3t5QsIPqxuXhOOyU8R8RuKg9nAB44VUOLJPTgEbcehBQoLgK9S3Wr1oYit2AYBJd9B9Zkj8SCoDeaTExMSdxRf1hVGqApMewZwbQN/+5soeOcxDsfegqu3P/ounI4nwd4ISXLBhOgEzPS1RsJEDzSeT0qKJhidnF4Eyyia9p37Vpxe0QlWP/eF11h7/EgTY1rQhJ5ptZtK3vcHlnOOCP8qf9jfLMA7jw8j9pYrvP37YsW2utjgTIMkqCsp0Oc92A7Zjlm2s+Db4QekqYqguFNpWOc9RZ25BxAxRD69i2rt4+egWb0QJNn3wMbEcHxe0YrGd65HPzeavGYr/o2Nzea2xQe0xpy/BmD77vGokrkKQYMoyhK5Dr3IuFHdWo1OzoMR6TwGh5O+RQsa7xw12QN+izLQcF4KIie44EnyEnTwmIiTLhNwPGkeGsmmnnPTu/o2G4gjbguwe3UH2ER9ga5h7li/MwSNSlEZ1La+cO+xFQUdQ5G6aRDK5K5Fd5oKw511azItVXTkpmr5YaiAbFQo8QT3HIKw/dAC6OxCzI3DrPZ++Iqi3TU7fkYQvIDdUXHIzi+OKl0mYPWyqaiaHoKA1nPw14Dt2D2+CjJXBWFQ+jBErutFDp1mIpnzmMNI+rYFbAuiMNnDD4syGmJeSiQmuDxB8pIO8Jh4Ei7kECTNs+cbZfXhc/GPdRAh/j5pH4Jd87Gnrzt6bC1Ax9BUbBpUBrlru6PygL2wJTgkr+uuM42OH787NBYV2wSg5Du1sDRiNGy290WzgUfgtmA3VnewQRSVtoa5r8fOEM5BkX1ojHewlKYGhCEw1o/Ho/+yazTJryJo/BYaehPdMFw3yvjRdB7jggB9m2HgETcs2L0aHWyi8EXXMLivZ6Vd5GjzvTaxFdEmoCTeqTUfC4tOh+uISKjhnL0Nfd0J57n+WHaNJuLZxNIUpg74IU2FIsWdUNo6D0/rzMWBiCFwLaCyin5uNAXOFj02JiL8c4V1EbnMwc52RL2ONfGw4G/YHI/BGbuaaPjpNKwL+g1dufsS3UYnzISvdQImejQW+PTsSZoMdRdbejZGv61/4qPGAWhbLgvRB07iyn3AqeHnmLMyHL1qSOF8DF+Wa4W5T9pi2Z7ZaP/+71g0MhhX+uwW+JQ5ymfgijb+9rhZ8A4eH47FLVdv+PddgT0D/qBJoj0Qninc1+7pPVSZyU3oc0VBZjRm1m9NNMhgUyYNM7xJHqU4osuaSKzq7kmDEzRnMSjLVixF2RnV0O/nfF52fmQr/K6MR1+M/24Kulahc5tDz+7WSJnREN4hScQP0UiY6QvrhInwaDwf6R4hOHtyOkg/KX54x3yauyabyRschzFGPQhHMHaTV3WE39CDyKYxO44VSuDJPQcEbT+EBToCgDNMe+DSrBgcHFcD1+Y0RJODAxF/chDKRk2Gh98iZPgvwzWaoFURiZjRkJPpzhhzOAnftrDFzY2GeUoYbhKOB06N4e96B/eLV8PVXXuR4xaE5ZsWoKvdNnxWVVvOXtvSE437bcWfHzVGQNtyyIo+gJMCEeHzOSsRLiUiQzQSOBvB+cNpkhync+JwlDKV9iSv9Mn2/OvL0bXSCETaByEibTECJATCBw9OTdWeLMdPJFPmN/mQWMP0tQ11aegFtY6hXqAP3rMdgu3yKbuMGkzCP42XXt61EkZEavCUzXRGLsNlmXR99kATWOvRffyEOJN0qoZ0BSc4GTNF+uSd6uEoLRm2w33b9GcLjoCS3dDWXi4zx8B3eyAmKtoNn2PewtJYrKDjxT4+QgZ83rPFkJ+CcWegfn2aGzcL7f2+QixqouNnVEd1YTei4rKRT9NNu0xYjWWBF9DN6PRCCropjYzPWIf21frhcLUvsCN0DCo/3o8pn69EpVUyXub7OEmeKi6hz0X8nGaoR/LGvsdGJIZ/Dn4LiEEdVEK/DcTQaxJuDemUgLGY770LzQZzelxyLnq+WTKATVFtMDaW6hFI3jlZoYDGxv3ET8CViFEWLM5cIukX5W1jbjLtWMTmc+aSE6wKgG4/nUUY92PipdWfVdXSm3mF4QND7+ASICEBaD3nLwzYvhvjq9BgmaBBSB8WKbTbkBMoyN3C2NISW4yzpdz/wGKT+WcpNrU+hU/1+A0lbjH7o6AjQlM3YVCZXKztThOEORtjazLWdS+He9zk6x7hyOTtcDs8vVcFM+VTtPXg5UU6WErPNt3p4qLZCSmwq+2lNhy106qSx6t3PznAxbcuPLUml2kfIz+V2x0D2h1UC6Ue5vH7vsSPZrcBGdwJtDPprgM8G3jBxfYmju1LwlPan1T3w7+05/AXs8bDh5qn2HxYClb3/iTmeIib5y8i00bccUJ7IyT7Ubh3Cns9biGBdl7ddfBEAy8X2N48hn1JTyHuBFDdSqA9P3fhINkrpN4tBSfhfPxeGNmHHxkvvR29r2gxPMnT7D3jd6Fp7fXR7FSwcakPz+psLxi380Lr7DawsXmER5LHv2tjA+4P4qYLbu+OuAdEhgG2P+MRnGrUgXtV2pXG21PSHW0ccIqh2JOH0KztEZ+n2b/h4OKLup7s94qULO5hILuG4Fc6Jxn/VJLBS72bzAYu9T1Rne0u4ZpkteBH97Oh+2mu/C7BgLuy+sbCjhBuIIoiPuviw7+E/XLC511YWwNPnmh+b1OM8PNQvpdOjlshungR8t1xbG/YIyfUqOOOqgZ4QEpTXsXvaXYl8WDXPoMaj2bwGHc7cW/YI6caqONeVcsREPdCEROiYaWnyJLQ6bv0fmuCgYSjhH16ajwRLtW7pIheM7M0NMJBVbYLSA1utouKBARPM3mJP+P47ZK0i6s6imRJ8EJ0W8ya6E59AHE/lGaHDrfHx+2f3/FHmeoGZA3HM5dx4TTtTqNdfb51tZ0hNQ74u5CRT/tukp5KdpNJ6VIt0+R8SPwrkz+699cvy5pXtcKtX8Yg+GgzBNX5PwbzPFw9tAZLjlPpx29U1kdZNlPpuVhRkoV5EgqX41KyV06HXclQEsonRWsiC4kJD+BWW2Hfmrg/SwGumucSrDLv4cnfd5FGOHgk7uAzJmekMlGkeT08JezoyYEDh0OHDCRnOsOd27Eof4fkmerdStzuK7d/8PsfZVBdjwzTRyNNatrisbbiQnm7J5Idl4J84WW7ZEeMABvJvjPufyXlRlo4UeQ3JSFriL64ZVIi/ejZnyk+0gT8a3aJsfvJaJ8UqrCHTUlWGcCJoH7YvkZDOlXr+nL61LVX1Fcz6dmcLFOyG9hTRPkl7vHUx5fNPVFMr47X4Eqzg9OIPhX3yhFcfJqWRk7yP6hEdopgcpi2p4tbgcEtR44blyGsINEABpnXUnH+YiYn1Hn7R9uUEaqMPrfagQyqaNDRhFo7kXRpW1EHGaED4Wgm4laPTvHyLgsriV6X20LmyADuNJp7KMGIQwMFmD5ch7YZrLpKSqcSGaaxFfXrTfP5gD+gsHuV5KSSPap+po0L6ntWZ3sMuZ/JdloV2pbmZN1HwJ9m8I8AWLYzVuo3yGFjQzr2Cdn4op2msZml95Lrdx4FhvCiJEpf0N/McLpe0Aksj7VAwAIBCwQsEGCj6POwgq0/0ICE+iJqbUKL82w1gwVWFghYIGCBwLNAgNvn1jICXQ+x0loTnsWVPnv/pwYOGBwUZMKD3vKvcGVsNWNHCsPl3vK7vknXe13wYnG63iSqsZzVAgELBN5aCGSs8UeVoBjU/GIHQmm58Id00wJaaLtl3ko8HL5JoWTvrQWF5WIWCFgg8IIhwLUXDBx6Dn2o/FanGlj27qwT0vbyNQAAIABJREFUIRi6iqYMhnGl/i/4YG/i41OWomW773DbpTyexlthTDL1eMtGGLyJ13rjz/wa4sXidL3xVGW5gAUCFgi8HRCgMpq1yzEjdB2SbtONirrAv88YjBrUEjWUSpbfjktbbmGBgAUCrwoC+bnItaJ1F0YcqfzcXFjZCz32lo8CBKjvclznQYh46InhK1diIjdUzfJ59RB4DfFicbpePVlYTmCBgAUCFghYIGCBgAUCFghYIGCBgAUCbzEELE7XW4xcy9UsELBAwAIBCwQsELBAwAIBCwQsELBA4NVDwOJ0vXocWE5ggYAFAhYIWCBggYAFAhYIWCBggYAFAm8xBCxO1ytGblZiJK6X9EfdcqYdJDf5GH53qIvatJjvTf2orhzDif96okX1Ys/hCtQHE3kdJf3rwjQQ0qb0Y7/DoW5tnZ1buEa7l1QeaF5Vz/Ki53BayyMsELBAwAIBCwReJgTM0xHXaL+PyqM53mQ18Fx1LK0POHbiv/BsUR2maGy98LPo15dJ9JZ3vaYQMM3p4ubn/3YbFWu7054Ry0c/BLjdQYewes1e3H7wNx7Y2qFcoyGY2L0q8vYMw9z/zcHCzsXVP8+ihW7t9nXAz3oWVCq+h9ux0XUJXMNlC/leOlp095wpHUG+p4hbEOgf/F8siZwI+WJP/ve0t+PiodVYs/c2Hvz9ALZ25dBoyER0r5qHPcPm4n9zFkIDwizsGdgO+zr8LCwYNPGjSp6HrktcEa4Dd+55QUgLjsBExcOZ+IK34Wv8XqBreKe+FyoZuw99N7vAFo6GurFNbNjmXsXtQfntdkXUdn8B0obfBXIFJZo3MH4vY/d+bv/O7eb5Dbcr1saLuLLhYwq7AK+9Ux9eRhH93C783B7E79g5Z4W6zasK+wXf6M+bjYsXDXpVbqbWDkPl98n2ntGOJ7N1BI1THxiUhuAIPTrqRV9U5/nm2RX6dGyh4Ef2xiL/YPx3SaTpOlEv/Cz69aWTjuWFrx0EDDtd95MRsXgaJkzfi2sec3Hx/ES4vXZXeD0OpLoSgS+6BmFf+SlYt3QEWgir2HErYhDahuagSMx1dDl9EVPc2XmzNqKTdzSGXAhDWzNtS1XybDQKskL4K92XIThdid83QutFd9Ex9Dx+8Ldll/sLv+9fhuFjw1Hrp8fY0pVl5VS0b8hzFD7anoAxOoREix0jvkDXoH0oP2Udlo5owbbZ30LEoLYIzSmCmOtdcPriFGhA2Ane0UNwIaytmcEAFZJnN0KQVThOTHTXnsiUFYGevnsQGGP6/pLXgwKf1ynuIzliGob0/QFx+b2x+38EBwOPVt36BRM+i4DvpmXoaiD7yn1vSt9N8FwZhl76Zg5nRmPBqMGYuusKqs69iPMTn6e0yUT0guEYMJ5kGYzf63lB09hzMqMXYPiA8dh7zQNzL57Hc72ykZdnRq/E9MnjER6Xj967/4f1hhBt7CKv6N/39Pk/dN7wAYZG0n6zVq/oEM/htW8DLp4DGAw+gncayKAfXG0EIl0m4PCRkajCfsGvVggZgRmZXyDpOeiIrIie8N0TiBhiCtPDec8fAmbbFQZ0rPnwUyFuqidGfbQdCboK2+Bl9cLvX69fnz+NWJ74ZkHAhExXMmbX8MBUK4vTpQ+13A6LgNZz8GRKLKKneMkirrnYElAGgdGDEZUjLjfNxZ4+Lphf9wxOjCjMMgduM7wzvvWIw5FXugxCRfcoTkaPPzbk7EEvmfO4p48DovrlgJbX85+UebXQ+Pp83NZZGpiFEyEBaD3nCabERmOKlyxmnbsFAWUCET04Cjniw3JpuaPLfNQ9cwKFA+EhDHf+Fh5xuvs0ri5rhHpp3yCD3vXmFnE+myASjFkjzgm3YNN7DVqdJdybYpmYonBT5qFWjUkgD+Q5O108BWJerRqYlPT6OF0iXwhXfrlOF/duFRmX73fb+sY6XapbCTh8uRiampTpysKh9WdQtU87OD8be7yQX7/puHghQJE/lMmHnCmncHNWPe1/5f5tVHHsOzJEwO8z6YirWNaoHtK+ySD99Wq0gPl2hSEdy0BlDvy47za+jvm3l6Ol2SDQDz+Lfn0pnGJ5yWsKAROcLmao4F/idFHd8Y7bZdCtgYm1NimLUNt7LNI778ClLV0Vo2Kcs1Hj5Hjk7OklZGQyVqF5+QMYoOComEwnR4LhMNgBh34PgbfJP9L3xWuI3XEbZbqZW3J1BMEOLfBDeWXa2NOnFtImiYYk991+KHbgJnR05aLa8B6bjs47LlFWTMl6F2jw5Pgc7GGeXcaq5ih/YIAGpoWAwZFgBwx2OITfQ2QQ5PBTJRKDb+9ETzOzkIU4xmv5E+NOVwoW1fZGRL/fzAoccAq3ekRv/EaGkWK4weJ0vVx62NMH/9d5wxvrdJkDrCy6a83pNXD0da3Y+Bfh4lrsDtwu0w2mqlkRz7zcHxpL9HqfMrMyT4CTHXNdcZ6lbJ9VR3C/rxI5GLd39jSzkkKBKnOTEXkaqONvYotGYewK6NexhYEfpx/7FTug69yayHR64WfRryZC0PK1txEChXa68lOPYN3mfbj1X+DP99zRv3931OdL6rhPPlKpvGxj7GP88877+KRWI/gygz4/dT+WbYzF43/ewfuf1EIjXyZ4qXZ4/eSlSPedjBmdjDg8fL9JLFJRFQ28XGBbQHX9UXdh71sXno7PWNnPG30XMcNIWZVwz6tY1bw6hh71wdJ0/RkXzukaVXwfZaWE+Gruxk5wWNMWN8WInJSy+J6TGOTa+6KupyNw/RSiU4CqDbzgIu2ZUVEZ3Ptj4HJK14kxn1AFp+biDDNLjBSiZilLg/Br43CM8wDNpYgFGjBHLm4qyrd9iB/V2T52yqvk4FQfiqM+hPsTI5QNcT5DMQrF91FWSghhYmMnB6xpe1MNU20QnkN8TC6jBw6E0fQEgVa0QUhR/jEuOHVzFrRjpkJ2N/5LjZOnBNOsQ+PQ7tNlOHtfBXxQCc3HLcO6KW1kAzrSyDkJRvG9kRhQRg9mngc951/HqW3rsfP638SQQPV+g/BZ7XJ8po7rkTq6dgPuNJ+JRlfnYeHh2yjq0QeTRjTSBAlUt5CwaTV+/K0A1rbVYR8/ANMj9WeEcrcEoEzgPSy+KeKE3Y315G2IycaT+7ZwH6Q5B/8NPuAwGeV2p5PRpODRqp2us9hScQ9/VpSpj6HD+8NL9McN3JV7Bdfnc2j1BsRkP8F9W3cMGvQZGzyjnemqmxKN81f+RN5TKxT9yBn2VreRcecxPYH+/5N6qIXziLuch6fcX4p+gnqt3fHB5RhEJWfjqX11+FNjuTX/ri2IffwPHt0rgRaDR6A968AXzrEGd5oMg/0v8xH5sBFGftuHehkF+RgalY13rR3hnLseo1dbGcx0Kd2p6pMExCTeAX/ioh+hSq2mcCt9BymHz+DSvadwdG8B30+o9d0QTpQMfR6+a7H2lAB7DfwMSBb2m21EP0/+dkQbCRz4MuuEvdi04zTu/VOAx45tMEC98FnoY9q9/hBK9h2Aor8sxE9JeSjjPwFTulZhmWYD+kRN2wsx0IfHPr1rE9Zsu46/8S5K1a2LRi2awubICHT4PBxpJQOxZGEAPvmkBfy5Bjq9d+X67I5i7YY7aD6zEa7OW4jDt4vCo88kjJAsPlWkNas0/Bp3meiKjvN+CVSqXhfeFGG4GncSybfyYPVxI7T3Kq0LTEVcpOLIus3YJyhauPfvj+71K6qrKfTrU46f12AbJw/eLYW6dRuhBTP4sw7NxbRfSmDAtCGoZyCoxMmN+AtAzbqe0KhVgks24PiMepYPRF6cgf+ZVdOqUFmhOoBR1CM8e1UnFCPHJjbDGQ34xkj9OsLke1EZfw2PeHz5LMFREcsqqgooPh01zpqSzS6cXUG1gMo6Vk1p5sCPWgHKt8XDHzWVKuJjnh1+pulXVfIq9Ow8Druv5QNFisP700UIXUl6QGbiHRhYDlF9bmHB/7d35XFVVWv7+e5Hqag5JKY5peh1KHLWEkXTBBNFSZM0cQBMcYjCMbwOYJIjiqKgCeSAqCgoCgomJg5ZoveCWZpTOVRIiZlaGPf3fe9aex/YZ5+99zlHsPTedf5T9rDWs9Ze7/i8r5vW+SSdL/+8URttlfLfFh6y/YqUuEMgYBWBBzK6uMdw9H1E5a3HkPrFOBXeA13CfsDwrSd5QYOrcR5oFueFr5gSzVKKWhJH5iZxQ67GwaNZHLy+YgZKPna82RK7ht6UuAQsctNrJQo7RODsiffQXG/ovJBEOJyWRMN1X3+0S6qEHg2GYM5b/8QgL+JI/esrzCSF/8F/+aTQN0KMuw0e/JNz0bRDKC56bbQr4pIeUBHDHdNLU+VMg+UE1C/gGzMF9+Y2x+QLrdDENRRTnWai/4z6iC/YgkEl5YMkBXJfoLbhYe/888kQbBTjLq2ZjTebvI7+ab+DaFUATzfbgUEXaa1VTshzFM1qsTvAwtA8ObcpOoRehNdGYwPHfEjpCKg4HI7plgKBFSfx/8IXMVPuYW7zybjQqglcQ6fCaWZ/zKgfjwKKRpZCyAzsfQhUGw70MhbpGV1dkc6oxoQZi27J6JMQi6Du9VH87QGsmjgSsz9thLADexDUuQYpjBKnr930xki/EAquE6p/5bKfpahTsHMCfqf53WNGve8ZzMm5gLk1j2F16AhMWH8RTvW6wSvkHXQ9vxDjlp9Gl5iv5PTUM4jzeAUznvkIp+ljrH4tHkOa+iG1SM/okhQa33+GmBusjHTd0w2bPbN4mm0+RbWcJ+bAPfY8MvxMCV1MmL+M8LY634xsdJ0lI7bT2Cl4ExsxN+I4CpxoLKcZz85grhSwZCTynm6b4ZnF0lTzKUXIGRNz3BF7nozeBuZGV59r2zDypUi0SNiK92kNKxSRp7gBRW5/D0TmbUqpIRI+Owt8U1soDCL2jG74dvEPWN3hAAKae+L4u7n4ksiax2c2xMtLOyCRIqTd8z5CeOh0RB0shFPjgfBwvYiUpKpYkLsHrda+DK9sPxxjnMziI5jWuhsWX9TndBnNqXMiKa/Tc82+n6K9AXCa3xb/Yt+ytTVRK/qF6QhsPx8Ntmci5PlCxA9pCr8MF0Sc1OJhypuZnVvtJ+B+5HF8NMgJ2ePrwj3aAcGHbpAiRPzJRV3RaXM/HDs6B+0cGEezHQYnN0MEVYkbBeLxvTsA8w9SIRaXLsQDHYXKqeMxLQWYdEBK7dKTJ857liA+IhwRhHEJJy17MmoP/A0JLCUKpNx1HgGHBKboamRsGMx14C+rETpiAtZfdEK9bl4Ieacrzi8ch+WnuyDmKykl2WhdvE+NgDNFEKso0+C+WY6OL32DcL10LfVasPPUZTTuR+Vh/RA6Y06Fo0eXMPwwfCtOsiJABvI0e3JtDPwtgadyE4EVnUc4IIFH+K6So7AhOQoroOTc1jqWsiZj0AEvvPfkBHgeC8b5DD+esseNpQVuilR5G4WF+jLGaW4UA3euC9j6DDmzwtmkI0h7yx8f44QFGVJbRhTZNS/C/39Go/oBSzlj64hLr2P8qOfRtzBaI71e9bQH1Cv0ZGzp0+3A7xxl8LTYjQCVbCwv/KzKV3YWO4/HvYidiKRCZA7kwNoVMgx+8Tfx5oYj9H+S4+Eu+yb65CD4ZDKGauQMX4rzQci/Z6H/ARe8V+8QbnDLTDY+r0VqO77tX1xxh0DAZgTsN7p4nvRA7BmuUEiLSHFoRorDHVJWSKDcG0N8kGNTcTh3EbrSl5E9axZ+nzcP7lyoHMPUw7lYJP0Bs36fh3mcAE0eiev5KK7eUOFVs9BQyTbriQPDsihFjbR6+XlMuRzxjS/eWtcGy9Ing/2pTD8u7MagSsJlrO6tHznLC38BrWeewSsx9hg+LPLRAuvfUHNWyLvlMQWVNyRzfgwXbrObkAKXiOdW9sB712cggbx5pfKpiIzWipjzoqTwlf1HlYVGuGBMlQRcJkFtPV5o8prVx6tjelIluDs4m56Mw+3XaRqgzND0vL9V5dmU+YJnXkGMhuGjOycuENbjDTUHhgwhjymVsSF5OEVwJCVrdpNE/JD4HFb2eA/XZyRgzQCFhOfRwjl4MVdR4ER+KV/bvFBuxGhtp18p0tP26xBcCFWaUmRkHYrEuLdm45M7tVCnyh0KOnXF7C2xmKbwjisFcfns52wyKPti0/B0XCOFiDYP50XVNO1LWZnz2S4XNSkkhaemL1J9d/L1uERpNK3GVcU6hUfXOL1QO62U79koz1JDjL6jwF4zcWdmKjYONeEuK33H/JH2OxWRUS+yRfSUFT3pTN9ZLpzn5FAq6F2Dud7max7lWcr3yKeqob1m3sHM1I0Y2qTU6Nqe64r4iWcwYfNivKYoAMLnMP0KKfySolW0fzzqukejjQnLS6vQ1b0AkSyt9+p69CNSP1Z9jT0jSeJznPeU3ivzpTzifsS+0VKYroicSw167cQYRYRaeqcep0sas+6cakh8x5SSSLHE94x2O4dkyo21uiYqRZ87QQ4H4XT8ADxF4y3OnATnMalooMWh4TOS+KkDf1lR8t0zY6Sf1zZ02/IpZleNNN+L7Jb8ePSp44cMVym6/RuffzHmm75D5rF/ORw1ZV4f34ta8oQeJWGXW2J0SedmI8Rd2IbRtK5X189C2kvzMK65pdFlba7SN+CD7b+Ts4sOAZ6h4Jsqv8vKujQ5iblNOyD0piQTGSeGpda6F0RapjObvgGztZBx3TNcYeAUUeGfZui2+A4CM8novzdGR57KZ1+jOFzYNpoi71exflYaXpo3TnJmUjbFlVsOeKYecwxp/YiP028J/r5jGcly4uyWKKfyt1t7u+65aI8c4s7bMVWQcJnwsS5wSs61K+0HY3A7imblH8fm1FsI0sr20JQR9s5Lkk95oYpiUPZM0EJ9IYdx1y7YN+oU9k74uy5f+MH0CkBbxioGIZ+tNuGXHoCKnvex1Szjp/zwsyZfQYZnx/nNkZw81Ix/effsNkwZ4oeYS45oVIuCvz/Vge/6HVheEhVXzLeIeNuDvsGUPT2wnc7QBW4mnVWSX1lTykt3KsumEPf+tyFgv9HFP8ZYi+pi/IOPrY0QOgCn3AxAc7qmoLILxsVtwxLyVPAzlTyLzDMcW1AZLuMo9WHJEDt7YbAeS5fxjFs7nhbFP9wlZISpU9YsVpH6dKQdxqXfbF/eP0hhnDMxBRWHr8amdSwlyPJeSSg34HM24ykVZmHp9C04p7zFZThVZnOjKIskEDcPUxtdxKvKLkZ7N5ZSIxlUg2/EGHpi+PshKc5av/xTaThs36Sxa85EpFAUafWmdRhhWDZd7TWjEZAQ7XhpJlU6soxTao+VeRIHYmMDVcSEbZWspZi+xQxBuAxfikluFKfiwmMzhqmNLuLjZRe3hxurjscNqsG4YWgQS++nEn0Wldu48rZ5mH7FTlJcrt9/CvUc7+F6fjGqN3RSGKqSA+HXf/8vqj5TD0/eK4RDDS0F50H3s94+votvD2zC4lUrkZRyBs+ailFYpC3JuHOjq53k+b4x36zql7HRpbzftPckZ0JwS/39WKpbGhTp0OJ0yf+X66NU9jTmOiCTjPFgtNStxGcyuiqgQoXqGJ/xHSK6qz5sZlQ5T8RXgZncI32dR+uOArKBUEhGSZBTpjmPjaXv7YrA8pgExB6k2oim92ukizGeRK+V7iWKPMPE0OjiyqPRnED6CYsW35QUcbd9GPH0evS9yviINqyJ2Rjl6ytMQ9K7Hc032bPtMbh1FVz5WXmIsvLcJxBU0RM5YdqFT7j3PThHxRmT35PjxQvwtP1IZXSq9kAhyRxNeaJhdEHmwuSgHjzDEhAT1F1O91UbXVbmSmQji29AiVUL6+sipeCmoEPURdovv9G5PwD3Yin6rEfCNVsLFqkhWdlCxZeV5W9tZgQTx1VPnp7hPNkcoJ4nwhJieDTedl+kLItcTmIoGfS3ImWnIk+RG4hrpn+rj6H8U0g7fAm2i9k/KDliDiamUObH6k1YN0JVSVb1fIvMCiZLOy7DCyf0nDdqGWHvvPRktWlgVHE3ezdyb9iuV+DeKURNjMCFNtMRnxSK3hoU5gfTK6TsDCN9wC78+F5kolFZvbb88LMqX+lMvX77SdQjhkXBlVtwIDmqpAbcLbgCdhRVerohnrpfSOneNSwdxZRumn35Gbj9XzRlJK1AX1PEkp8vC+BWLhFMO9ZeXCoQIATsN7pkwaD2fEqKw1k5ZaHU4592vQhO7jH4JHUsN1yKrh1C5Li3MDvtOoqc3BHzSSrGPlBPJMnrFlR/J34ho8NYoJiUYFvXvBhXEkfBK74u5q1aiFG9SnPolU+QDE1l6pHq+TJWrlzomjz91g5y9gzJoMmeYVzBzdoha1tfjtIxF19JxCiveNSdtwoLR8kl2/Ug0+Bz/Zodhz1P+2GoRqVv7bHqKBaKd0oCyNWcM6dndCnHytNVKQJkWBGuDEYXGcZ5awah7+QjQK0quPPjLdR8bSG2b5qgyjln3tJ38fReFffJAld79rPlouQfWQT/d7PhtpQUrFqb0VlZAdDQ6GoqVfS7aW742mR0maXV5mBO044Ia2jsKGAjN3y2ZiEN2ciTja5benPtuQ1NO4ahoa6hbTK6nOHsfBEXb5tSFpV4ytVG0/si8buJONb+A1QZeh8fLvkRcz6Lxg2vaLidMxVYkdocDP3wD0zbFIkh5wLNi1JoGF3S3CVjw1Tt09DoypljZU40dpkXeaxvIr4esg2dswNxlVcItWFNzMYoX/+8TupnZjCeeztZAdbrWJvbETHVh+HTSdqpuKZIlDp9WMKhAyLOnqAMCGOji/O05AiyWp6oI11scCXe8NN3UaH5JOw+tIKUW7XRZWWuWvtUiVU9G9bFlK761BzkbAV8gpyQaZS+bbYWOg4pU/qtfxp+p5xufXlKPLhtUzDELwan71ZA80m7cWhFb7vKn1vwNvmZmoUpGpkBfFMwRTn/V+LS2fgrvoLEUV6IrzsPqxaOktus6N2rVSn3HLbHXUcvv56WhS4MZITt87Iuq03Kv40zRuGJULwR+BX6R32Efwx4wcyQMD3jwfQKa0aXnfhpGl3SCMsDP6tGF72HcaZ7e6/Bj7VYSOtH3G8xAYk7w80yE9jZsOPNujj0tn4KKHdKrehb4pyXjM/aZo4vW9dPXCcQKCsC9htdJq/zK+bKFeczhLflykSLHeuAgAB0IHL+oTBveIRTmV7mde/5GdYhgAjPTIiGwdsjHDlqT56tM5JTpH41KVjUnyJmowPGSWzqMv2YZ9Ul2BHxXFjrP0o6fNIxRKuSEt0mpQncVkXCJD7MElcDg4qn10RjoMkTc2kXYr5uh3GeyqRlG55jDwosCukSDMf4Q1hhNGn5mZZeM+OX8f1xdaUqKmdScIdg5y+WPDBCUGpXcFsVCeNrvwSuBgYVf1/0wJKD9tKuGHzdbhzMIdR/jvZ4FXNkefc+lxC+J5oaN1Mc9+5Z7JnrjzdXfoceS3dgY0BnEqik+MT74tXV3ZBBPEXDrlNl2c9qQ0X9b1siXQfNUzyNjS6Zl1VT6YU3pQ2SQfGdooQ8K5CTcAvefizKy35yhCHfMrrJ/6xldPHiG+Nwk50hnmnmJeWV1w89wq87Rsbgd1Qp1PTpFuVtQMItb/i5XSkpGb89l9JNOk3HaZeF+ELV705KKYxDG48u+LLJ+7j6/iW8Rs+90rIlbveIlA0aVpGa8Xa2oZ/p+1fjrBvpYnwl81YKuumF8tz158RQZSmFjEdVEy1b3sarUTfkNg02rIlWpOu0ag2J27ZlxkY0XzAFbS0+czniXZPW8wwVpDF5v/L3Y83hhhj1xHxUI26To5lRZs4JrKpOr1TtgZx1OvKEeDxqo+tq2jrkvUhN5xtI356bXwpuU0T3lw1NEcmcCyVVeOV9aDDXK+q2CUqs2kl70nhdpJRCxmts2bI+6gQd1Cz8UwKp2VqYHASq1Gs59bIt48C22KEjT4fi23V5eJEaxzegcyne1w1+Kbe1K/4ZHNtc+c/9sIRjXW58Lkl1p3Q4FwQ7xttoDGpkVhiJHAMZYfu8pHPu6ko7C0zpjYtFYT32ISDd2NH8YHoFJE6phYw1DcZO/Pg+u4qVGgXFygM/q/KVtYlpvhYdkjZgMufbUmGY2CnwDt6DmhMSkRrWn/p4ynrkW/kI1e13Kn3n77eWnBSCz2WPUiiufRgI2G90kQBmBTAGb22liD5I+eur+x7gvY32UX+mDF9KdeHNHYjvVacbMoNJYWq+EDWpIpqpT9ORaXXQjbynvOly4XGsmReH712VVatUUz4Thd6eS1A99DDWVggigycHk+XUvvxNryMQ0Ui2qWGQEZRsLj64ufYEKS5W6oWzIghdOxFvYSny9k7A35XhNtak8HkqGHBzkkX6I08xuhVvZoAUpk9Ct/EH4b3hSwzMYulCz8vecEbAHYDd/XdJPLaSX/nmmzNvkM/NtThB62e9Srpxfy4tdLmRFt3HIl2vKI94f51mo+rSPIs89yI6+J8nbsdNCy+6JEBuxSuFIQnxSd0w/qA3Nnw5EFmMT2Hy2LO1GLAb/XcplEI2SF6dKg+hMmejdNzW+XK/JL6O7lfnWfSS4l720ROx8fg9qmhYDIcWoxGbuByDtBoC27qfSYFdOCsJ+eqKg6YBm6LPUw/j/KKOKIgfgqZ+qaUpwIZGl4nTdRBPkXLKCmk8Q1U5eQGKo+YRGeW68j289nUzXpbEDTsIdAhBWlIIula7jM3+w3A04BAVWjHtKkmRWdpDJ0KtYXTxIi/BTkg+R2lE2VKJ8waac60kVxNlQ0hDUkhXVLu8Gf7DjiLgEGtCbl5I4yX2XOLo1B+/H0dXvaqIAsgKSqEpwio7B1IcNYylXEicrSrEt2lNfJuLhumFEqdrJW53MBl7JoOpimWaMgfcVMlMb07yqshpkUedKaqiaCNhdU1Ue0MyEo5SdkIUdm+med3YAAAMMUlEQVQJQOcnf8Du972woHEijmo2SC0inm0DSpksgJN3HLJih6HxL0cQTrzGWmuP4r2mrJgFOU6ulHKbyFVOPLRRlLYmFXKxiPSp9gDr96cpTzSMLvassZWT5cyCfMT3qYPA2gqj6yzjEq7Cy9dv4/pOb7gYzNUwvXCAjevCeCV13RF9z5sXWDFsQaFaC9ZgtiX1UGulyJTgXvvV5LW/Sj0f943QkaeeSGszFpWT5SIVnEMXiNqyc+AypfR9eKg2RkyfAE2qqbylzLMT5DOhfvnwuRhnp6nPTaw9QfOwLnBKnDGa/bk0xbmWjJAutHleBpxf+5UxdoY0x1oPZnhbafr+gHqFnozlYzXqz6UtsMmpEI0+Go7NsuNnXb6CIvwdVrSjvnoDzPQRHtmdNAbhe6+Ais4CtV/D7A0xOpxpPnFzOof8PWYLPpf9W1jcUS4IGBtdvNTwPzC8/2rkVuiAd7fHY3ZvCokXn8Kq4YMx80QnzFw+GJX3LUBctXnYGS6Vy941oiJ8svoiIikcL58NwaBljbFm/1L0Pj4CFX2y0DciCeEvn6WSwMvQeM1+LGWRFVZ1qnsEClQRNLNZnpyPVq4peDN5As5/9B1cnt6AXU02IaopVTj7nFJdltqXPqF9VrP+VzWQqVdtTn1T/hHM9emH5TeHYtmaIPSq54if87YgMuoEWvWshCVH3XHO1J9LvreIhGu1mS3wxZchMJXAKCQB22DCE1gR44zdGY5UxCEGl4J2YOS3Efi42lSsG6vKd+ce8K3wsacAhe6WYQLqbdTIvACzuhAa13OBnXYC2Rv24lyRs1REo/4AzJptpeEoP/RPUeEUiZSu/LEmkD79luPm0GVYE9SLeFI/I29LJKJOtELPSktw1P1cSX8u6T7J6JvZ4gtFEZFCcgY0wIQnViDGeTcyHIkAHXMJQTtG4tuIj1Ft6jqLNFYupLb6aPDmGB6Dge3lUbXK4Du1dT/LPI4iqn/I0rEsKHO8epwPYq87UIXCZ9HJvw/uLVyJgw5OeDUsDsOO+JGnuwA1vCKRscoXVfeOQpe3U1Ho5I247I0Y3bgQe0P64o0Iqg/t1Ai1HOviKYfj+Oan9vAIehfz3h0OXoVZ+ePrGQVPMz4jNZ+d3Bve9Bwq8ktlfolXE5mOHcq9y+9bS/edUTkR5IcTH3JG79ex/EpLTJg7GS53dmFNShVM2SAbrkZzXXAQ+9/4HpN7eyOCUsukIXgiMn0Hrf0t4nXGIdQ3BKmFrTF+9yZ84PoHVvZuhzknKf3KPwJrp/tLfED6MeXWNe+Dkh49PPoVWNusLx6vXtclGMeKq8GpVlP4+rfCxrCNuF2tGUYtWoxGaaMRkkrVC71XYVfESLmlxl2cWuUDr8lp+KliPdSpXh21Kn6Pk9eqo+db4/D+jGl4Vd0xg4xu7TkpPyS9yLf+mhRTO4rYIE8EKcdY93tsGvkKArZS+rdpDcO2IHaaor2AekuTkrhmUF8EsZRx9jfi8ganyOc6+1qv7UXIwKGIrTAGy8lw+/bjKOS8thZbJ7SDAylRYd4eCM8pQuvxu7HlgzbI/7AfeizORQUy3jNSZuNWSDVNedLlt9LxO4+MR+IHQ+G4mcqzh1VG4JYojK20Hf5jcjFiJ1v/CkT3Yjyn06hYrw46Tk7FnvGVkKQz1ypn4+Hr5oeUghrwiszAKt+q2DuqC97mWMUhe+NotLhjy7pIEYgeFIEwSoO/q7UWz4H2ynAMnnkCnWYux+DK+7AgrhrmmVKsSI5oy9OfSNFsj7DKgdgSNRaVtvtjTO4I7NzBUvyvUqXSZvDPNHcgaJ1ShemBcBlViIXZ03F//iBM2nQZnewqGqV/9vEeiTUyVYWINK6XnbGHPtuJxON0hslFNDq9vVZuEaD3Di0ZIV1r87xYOiUXA2QYGhzjNv2JyevWGbQO2lX2LJ7xAHqFZFipZOwD4ycZK6dmWRYRKTt+f5J8lUE9E+WKzuvckbmlKw6OG4R/HPqbmfPMpvUTFwkEygkBGyJdBm9iVZB+vs+LBShJjqY7eL7z/aqWVZI077OleiE9md8LInCzwgUyV+vJp9GwjH1DSmZptbKTNh53C84i74svcZ0I3C+0aYHGupWhmBbCvJ9T8dxh854dnIN1z1HGi/qh0ETvV30G9TTA5SkIUb3sKvGuv5LsXZZk1XLaY/JjmKe0FT6fqtHUkl9BYzibR4bodSJ/v4A2LRprzts0Jq4ET30Oh80anUr74Z6jjJnh/pSiF1G9NFoDMC9s7xuI1ivtXJ7A2LyfrXDDOJ/iHhzlb5F/e7Dvu5A4gLBS/KNkBXi55le/DS9JtzP7hjTPBalsslf+CpyjVA9DB7fMD6HBWO4DG+aqe/bYunb0jsLiGqhRUlXtLgoLHVBD/S1qrF/J/jN6F7/vN2MiuOp+4zmxCOIUPPupTgluK2e1eqjKvaB1tmtNTbrnSflstrzC2t+tLY09a6r9LtX5IL/wQeaqHKvxuJgx7IxjE02ZH9ZmqfV3Y1kgyUQtOawjH22ScXRvAZ0njsXIp2dXotTR5n3zMM+gH6U9M2OY3XLQlm32PMfoWl0ZYeO8mOOl9w0bSrzbMmB+ZqkLLlm/0S69gmcoGMlY6+9TXsEb2X8+VeUssH1f6OL3Z8pXpldQX7mnHG7xs+nObm88P+vFkoqi9iEirhYIlB2BshldZX//f+0TWBrMK9cieDqm7VWlTHCxw/UlnAuT+tg8Lj/GgWke6Yrj1BTa5tYsupNjnrhXcC3iATFg6VgvnUMYS9Mxg1Aquf1h6+NyD6tHAV2KjiwaiOlPLMWe94wrfP25o2VtBnpjx6D9VP3RgPwoD4qViH55UVvszHpPsxronzv2/6y3sVQ0l4SBOJf8pg3pwf9Zc3+UZ1PEemS9fh+xipTPR3m8prGxPl/dI5ph5cWjmNhESqWc1STZurPkkZqcpYyweV7MMdrgQ7Q+LvVke1x+5SpjWXug5pFwVWBQdvz+TPkqR3WPjkbGnWi488I2ffHZ+yepwrKVFM/HZcHFOB87BITR9VctGcvb7hkIRGdhmp3VGxnHpf2nY3HaWrTgr5qb7nvtU9KtDZ/xwSQIqcmsXbYna3rbHp+OPa3gGklvYzyytpNqIcla4QtrgyvPvxedx4m8Snixoz1ln8tzAAbPIoLz3pCR2O+xExHuJW2nLW4ozJqFtzO7YFmolIIsfuWAAG+O649Mh2qohmaY87lBA+NyeJ14hK0IZGNy7e6IuE3r4vAkBm87Z3HO2Pqkv+o6FqUY+7ckHJruRO0AfDD6YiAy1g+HFjX1rxqjLe9Vywjb5sUi8m0xqVbSY6icl6+MZY6y3jsGcW4Vc6uVFb8/V76ybJZmSBn2Nba+9jMVlOmLdS9uQPJcg1RpWzaVuEYgUAYEhNFVBvDKfCvjp3hSgQequGVDoEAyCsjQGEQch3Cen1/mEfz5DyBjc5nHO/hjRYbdxqbWYPN3UaWy3f2Rtk4SCtZ/VOp90SCEVAs35xqxG9l6vHEAPknGVSutv0NcIRD4MxDIxxFqabEhtypeDZ4mVdEUv0cAAdZKIByLM35F67eCEWBXj6xHYPh8CFT9MWsvvrxZCfXadkE7Z71Gyo/KePXHYS4jrM+LXf/GAR8k2Vli/5FBolxlLMnLZR54548VyJjGsizKgN9fIV9Z1cNPjuO732rCuXtntC0vGsojs9hiII8bAsLo+qtXjPLrqe4XbD0Ligp1GgH+1fOw5/2U315A3DUnW8kiVp59lyVtOymbExvdQDnphcXEzdFQUO8Sj8eBeDyPozFrD/7iWoGAQEAg8F+EgD0y4i7JWO1m9o8RYOUqY2Uel5NthrcufkK+PkYbSAz1YSEgjK6Hhax4rkBAICAQEAgIBAQCAgGBgEBAICAQIASE0SW2gUBAICAQEAgIBAQCAgGBgEBAICAQeIgICKPrIYIrHi0QEAgIBAQCAgGBgEBAICAQEAgIBITRJfaAQEAgIBAQCAgEBAICAYGAQEAgIBB4iAgIo+shgiseLRAQCAgEBAICAYGAQEAgIBAQCAgEhNEl9oBAQCAgEBAICAQEAgIBgYBAQCAgEHiICAij6yGCKx4tEBAICAQEAgIBgYBAQCAgEBAICASE0SX2gEBAICAQEAgIBAQCAgGBgEBAICAQeIgI/D+EXalCGRuFeQAAAABJRU5ErkJggg=="}}},{"cell_type":"code","source":"with strategy.scope():\n    # Discriminator loss {0: fake, 1: real} (The discriminator loss outputs the average of the real and generated loss)\n    def discriminator_loss(real, generated):\n        real_loss = losses.BinaryCrossentropy(from_logits=True, reduction=losses.Reduction.NONE)(tf.ones_like(real), real)\n\n        generated_loss = losses.BinaryCrossentropy(from_logits=True, reduction=losses.Reduction.NONE)(tf.zeros_like(generated), generated)\n\n        total_disc_loss = real_loss + generated_loss\n\n        return total_disc_loss * 0.5\n    \n    # Generator loss\n    def generator_loss(generated):\n        return losses.BinaryCrossentropy(from_logits=True, reduction=losses.Reduction.NONE)(tf.ones_like(generated), generated)\n    \n    \n    # Cycle consistency loss (measures if original photo and the twice transformed photo to be similar to one another)\n    with strategy.scope():\n        def calc_cycle_loss(real_image, cycled_image, LAMBDA):\n            loss1 = tf.reduce_mean(tf.abs(real_image - cycled_image))\n\n            return LAMBDA * loss1\n\n    # Identity loss (compares the image with its generator (i.e. photo with photo generator))\n    with strategy.scope():\n        def identity_loss(real_image, same_image, LAMBDA):\n            loss = tf.reduce_mean(tf.abs(real_image - same_image))\n            return LAMBDA * 0.5 * loss","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:24:01.013389Z","iopub.execute_input":"2023-06-11T19:24:01.013831Z","iopub.status.idle":"2023-06-11T19:24:01.025155Z","shell.execute_reply.started":"2023-06-11T19:24:01.013798Z","shell.execute_reply":"2023-06-11T19:24:01.023961Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Learning rate schedule\nThe original CycleGAN implementation used a constant learning rate schedule with a linear decay, I also found that the linear decay phase seems to be good at making the model more stable at the last epochs, you can check how the generator changes in a more conservative rate by the end looking at the gif images by the end.","metadata":{}},{"cell_type":"code","source":"@tf.function\ndef linear_schedule_with_warmup(step):\n    \"\"\" Create a schedule with a learning rate that decreases linearly after\n    linearly increasing during a warmup period.\n    \"\"\"\n    lr_start   = 2e-4\n    lr_max     = 2e-4\n    lr_min     = 0.\n    \n    steps_per_epoch = int(max(n_monet_samples, n_photo_samples)//BATCH_SIZE)\n    total_steps = EPOCHS * steps_per_epoch\n    warmup_steps = 1\n    hold_max_steps = total_steps * 0.8\n    \n    if step < warmup_steps:\n        lr = (lr_max - lr_start) / warmup_steps * step + lr_start\n    elif step < warmup_steps + hold_max_steps:\n        lr = lr_max\n    else:\n        lr = lr_max * ((total_steps - step) / (total_steps - warmup_steps - hold_max_steps))\n        if lr_min is not None:\n            lr = tf.math.maximum(lr_min, lr)\n\n    return lr\n\nsteps_per_epoch = int(max(n_monet_samples, n_photo_samples)//BATCH_SIZE)\ntotal_steps = EPOCHS * steps_per_epoch\nrng = [i for i in range(0, total_steps, 50)]\ny = [linear_schedule_with_warmup(x) for x in rng]\n\nsns.set(style=\"whitegrid\")\nfig, ax = plt.subplots(figsize=(20, 6))\nplt.plot(rng, y)\nprint(f'{EPOCHS} total epochs and {steps_per_epoch} steps per epoch')\nprint(f'Learning rate schedule: {y[0]:.3g} to {max(y):.3g} to {y[-1]:.3g}')","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:24:17.122837Z","iopub.execute_input":"2023-06-11T19:24:17.123292Z","iopub.status.idle":"2023-06-11T19:24:38.656121Z","shell.execute_reply.started":"2023-06-11T19:24:17.123252Z","shell.execute_reply":"2023-06-11T19:24:38.653058Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Train","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n    # Create generators\n    monet_generator_optimizer = tf.keras.optimizers.legacy.Adam(learning_rate=2e-4, beta_1=0.5)\n    photo_generator_optimizer = tf.keras.optimizers.legacy.Adam(learning_rate=2e-4, beta_1=0.5)\n\n    # Create discriminators\n    monet_discriminator_optimizer = tf.keras.optimizers.legacy.Adam(learning_rate=2e-4, beta_1=0.5)\n    photo_discriminator_optimizer = tf.keras.optimizers.legacy.Adam(learning_rate=2e-4, beta_1=0.5)\n\n    @tf.function\n    def get_lr_monet_gen():\n        return linear_schedule_with_warmup(tf.cast(monet_generator_optimizer.iterations, tf.float32))\n\n    @tf.function\n    def get_lr_photo_gen():\n        return linear_schedule_with_warmup(tf.cast(photo_generator_optimizer.iterations, tf.float32))\n\n    @tf.function\n    def get_lr_monet_disc():\n        return linear_schedule_with_warmup(tf.cast(monet_discriminator_optimizer.iterations, tf.float32))\n\n    @tf.function\n    def get_lr_photo_disc():\n        return linear_schedule_with_warmup(tf.cast(photo_discriminator_optimizer.iterations, tf.float32))\n\n    monet_generator_optimizer.learning_rate.assign(get_lr_monet_gen())\n    photo_generator_optimizer.learning_rate.assign(get_lr_photo_gen())\n    monet_discriminator_optimizer.learning_rate.assign(get_lr_monet_disc())\n    photo_discriminator_optimizer.learning_rate.assign(get_lr_photo_disc())\n\n    # Create GAN\n    gan_model = CycleGan(monet_generator, photo_generator, \n                         monet_discriminator, photo_discriminator)\n\n    gan_model.compile(m_gen_optimizer=monet_generator_optimizer,\n                      p_gen_optimizer=photo_generator_optimizer,\n                      m_disc_optimizer=monet_discriminator_optimizer,\n                      p_disc_optimizer=photo_discriminator_optimizer,\n                      gen_loss_fn=generator_loss,\n                      disc_loss_fn=discriminator_loss,\n                      cycle_loss_fn=calc_cycle_loss,\n                      identity_loss_fn=identity_loss)","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:25:38.669654Z","iopub.execute_input":"2023-06-11T19:25:38.670101Z","iopub.status.idle":"2023-06-11T19:25:39.201581Z","shell.execute_reply.started":"2023-06-11T19:25:38.670070Z","shell.execute_reply":"2023-06-11T19:25:39.200387Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Create dataset\nmonet_ds = get_dataset(MONET_FILENAMES, augment=data_augment, batch_size=BATCH_SIZE)\nphoto_ds = get_dataset(PHOTO_FILENAMES, augment=data_augment, batch_size=BATCH_SIZE)\ngan_ds = tf.data.Dataset.zip((monet_ds, photo_ds))\n\nphoto_ds_eval = get_dataset(PHOTO_FILENAMES, repeat=False, shuffle=False, batch_size=1)\nmonet_ds_eval = get_dataset(MONET_FILENAMES, repeat=False, shuffle=False, batch_size=1)\n\n# Callbacks\nclass GANMonitor(Callback):\n    \"\"\"A callback to generate and save images after each epoch\"\"\"\n\n    def __init__(self, num_img=1, monet_path='monet', photo_path='photo'):\n        self.num_img = num_img\n        self.monet_path = monet_path\n        self.photo_path = photo_path\n        # Create directories to save the generate images\n        if not os.path.exists(self.monet_path):\n            os.makedirs(self.monet_path)\n        if not os.path.exists(self.photo_path):\n            os.makedirs(self.photo_path)\n\n    def on_epoch_end(self, epoch, logs=None):\n        # Monet generated images\n        for i, img in enumerate(photo_ds_eval.take(self.num_img)):\n            prediction = monet_generator(img, training=False)[0].numpy()\n            prediction = (prediction * 127.5 + 127.5).astype(np.uint8)\n            prediction = PIL.Image.fromarray(prediction)\n            prediction.save(f'{self.monet_path}/generated_{i}_{epoch+1}.png')\n            \n        # Photo generated images\n        for i, img in enumerate(monet_ds_eval.take(self.num_img)):\n            prediction = photo_generator(img, training=False)[0].numpy()\n            prediction = (prediction * 127.5 + 127.5).astype(np.uint8)\n            prediction = PIL.Image.fromarray(prediction)\n            prediction.save(f'{self.photo_path}/generated_{i}_{epoch+1}.png')","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:26:07.017296Z","iopub.execute_input":"2023-06-11T19:26:07.017737Z","iopub.status.idle":"2023-06-11T19:26:08.159514Z","shell.execute_reply.started":"2023-06-11T19:26:07.017703Z","shell.execute_reply":"2023-06-11T19:26:08.158202Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"history = gan_model.fit(gan_ds, \n                        epochs=EPOCHS, \n                        callbacks=[GANMonitor()], \n                        steps_per_epoch=(max(n_monet_samples, n_photo_samples)//BATCH_SIZE), \n                        verbose=2).history","metadata":{"execution":{"iopub.status.busy":"2023-06-11T19:26:33.412644Z","iopub.execute_input":"2023-06-11T19:26:33.413131Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We can see the generators progress at each epoch by creating a gif that is a generated image at each epoch.","metadata":{}},{"cell_type":"markdown","source":"### Monet generation GIF","metadata":{}},{"cell_type":"code","source":"# Got the idea from https://www.kaggle.com/matkneky/monet-cyclegan-trials\n# Create GIFs\ncreate_gif('/kaggle/working/monet/*.png', 'monet.gif') # Create monet gif","metadata":{"execution":{"iopub.status.busy":"2023-06-01T21:21:07.625137Z","iopub.execute_input":"2023-06-01T21:21:07.625647Z","iopub.status.idle":"2023-06-01T21:21:07.643883Z","shell.execute_reply.started":"2023-06-01T21:21:07.625609Z","shell.execute_reply":"2023-06-01T21:21:07.642186Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Photo generation GIF","metadata":{}},{"cell_type":"code","source":"create_gif('/kaggle/working/photo/*.png', 'photo.gif') # Create photo gif","metadata":{"execution":{"iopub.status.busy":"2023-06-01T21:33:55.353883Z","iopub.execute_input":"2023-06-01T21:33:55.354303Z","iopub.status.idle":"2023-06-01T21:33:55.373385Z","shell.execute_reply.started":"2023-06-01T21:33:55.354270Z","shell.execute_reply":"2023-06-01T21:33:55.371783Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Evaluating generator models\nHere we are going to evaluate the generator models including how good is the generator cycle, this means that we will get a photo to generate a Monet picture from it, then use the generated picture to generate the original photo.","metadata":{}},{"cell_type":"markdown","source":"### Photo (input) -> Monet (generated) -> Photo (generated)","metadata":{}},{"cell_type":"code","source":"evaluate_cycle(photo_ds_eval.take(2), monet_generator, photo_generator, n_samples=2)","metadata":{"execution":{"iopub.status.busy":"2023-06-01T21:29:54.251250Z","iopub.execute_input":"2023-06-01T21:29:54.251838Z","iopub.status.idle":"2023-06-01T21:29:58.637597Z","shell.execute_reply.started":"2023-06-01T21:29:54.251797Z","shell.execute_reply":"2023-06-01T21:29:58.636551Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Here we will do the same process but starting with a Monet picture.\n\n","metadata":{}},{"cell_type":"markdown","source":"### Monet (input) -> Photo (generated) -> Monet (generated)¶\n","metadata":{}},{"cell_type":"code","source":"evaluate_cycle(monet_ds_eval.take(2), photo_generator, monet_generator, n_samples=2)","metadata":{"execution":{"iopub.status.busy":"2023-06-01T21:53:57.643433Z","iopub.execute_input":"2023-06-01T21:53:57.645099Z","iopub.status.idle":"2023-06-01T21:54:02.907627Z","shell.execute_reply.started":"2023-06-01T21:53:57.645038Z","shell.execute_reply":"2023-06-01T21:54:02.905704Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Visualize predictions\n\nA common issue with images generated by GANs is that the often show some undisered artifacts, a very common on is known as \"checkerboard artifacts\", a good practice is to inspect some of the images to see its quality and if some of these undisered artifacts are present.\n\n## Source:\n- https://distill.pub/2016/deconv-checkerboard/","metadata":{}},{"cell_type":"code","source":"display_generated_samples(photo_ds_eval.take(8), monet_generator, 8)","metadata":{"execution":{"iopub.status.busy":"2023-06-01T21:36:22.970060Z","iopub.execute_input":"2023-06-01T21:36:22.970667Z","iopub.status.idle":"2023-06-01T21:36:29.529151Z","shell.execute_reply.started":"2023-06-01T21:36:22.970628Z","shell.execute_reply":"2023-06-01T21:36:29.527832Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Make predictions","metadata":{}},{"cell_type":"code","source":"%%time\nos.makedirs('../images/') # Create folder to save generated images\npredict_and_save(photo_ds_eval, monet_generator, '../images/')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Submission file","metadata":{}},{"cell_type":"code","source":"shutil.make_archive('/kaggle/working/images/', 'zip', '../images')\n\nprint(f\"Generated samples: {len([name for name in os.listdir('../images/') if os.path.isfile(os.path.join('../images/', name))])}\")","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Output models","metadata":{}},{"cell_type":"code","source":"monet_generator.save('monet_generator.h5')\nphoto_generator.save('photo_generator.h5')\nmonet_discriminator.save('monet_discriminator.h5')\nphoto_discriminator.save('photo_discriminator.h5')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# # Clear output folder\n# import os\n\n# def remove_folder_contents(folder):\n#     for the_file in os.listdir(folder):\n#         file_path = os.path.join(folder, the_file)\n#         try:\n#             if os.path.isfile(file_path):\n#                 os.unlink(file_path)\n#             elif os.path.isdir(file_path):\n#                 remove_folder_contents(file_path)\n#                 os.rmdir(file_path)\n#         except Exception as e:\n#             print(e)\n\n# folder_path = '/kaggle/working/'\n# remove_folder_contents(folder_path)\n# os.rmdir(folder_path)","metadata":{"execution":{"iopub.status.busy":"2023-06-01T21:56:58.660791Z","iopub.execute_input":"2023-06-01T21:56:58.661235Z","iopub.status.idle":"2023-06-01T21:56:58.667813Z","shell.execute_reply.started":"2023-06-01T21:56:58.661204Z","shell.execute_reply":"2023-06-01T21:56:58.666024Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"As the model has over 50 million parameter, the training takes quite some time and the file size becomes larger with every single epoch, and actually so large that the notebook exceeds 25 megabytes (which is the limit in saving to GitHub) quite easily. In the research paper, the models were trained for 200 epochs, but here we trained only 20 with 15 steps in each epoch. If we train the model more, the FID score becomes a bit better, with 40 epochs reaching to around 13. The blurred output becomes clearer and resembles more and more to the photographic image after each epoch. However, as we can see from the training losses, the discriminators seem to be doing a pretty good job in evaluating the images, but the generators on the other hand, don't seem to be learning, instead the losses, especially with the one generating the paintings from the images, seem to be growing larger and larger. Perhaps the generator might thus be a bit too complicately designed to do it's job. For this reason, we will try another model that follows more the one suggested in the CycleGAN research paper that has a generator that is based on the Residual Network - ResNet - that was originally proposed by Kaiming He, et al., (2016), \"Deep Residual Learning for Image Recognition\".","metadata":{}}]}