04_MLPMixer_CONVMixer.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "04_MLPMixer_CONVMixer",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.0"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7xUvWv8Lv7lB"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/drive/1F1rtlQY0vZ9BVTtP7CuvyeBv2hEOpPTo?usp=sharing\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
        "\n",
        "\n",
        "\n",
        "By [Ibrahim Sobh](https://www.linkedin.com/in/ibrahim-sobh-phd-8681757/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p1WyTv-jvDaN"
      },
      "source": [
        "# Image classification with MLP-Mixer and ConvMixer Hybrid models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wqj1yGIYvDaZ"
      },
      "source": [
        "## Setup and basic code"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U3kYcVJDw-mj",
        "outputId": "6332af8a-d861-48f1-9ca0-ab9e78a0b734"
      },
      "source": [
        "!pip install -U tensorflow-addons"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting tensorflow-addons\n",
            "  Downloading tensorflow_addons-0.14.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.1 MB 5.3 MB/s \n",
            "\u001b[?25hRequirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.7/dist-packages (from tensorflow-addons) (2.7.1)\n",
            "Installing collected packages: tensorflow-addons\n",
            "Successfully installed tensorflow-addons-0.14.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JFd19Y5NvDaa"
      },
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "import tensorflow_addons as tfa\n",
        "import matplotlib.pyplot as plt\n",
        "import cv2\n",
        "from google.colab.patches import cv2_imshow"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KnvHCYFivDad"
      },
      "source": [
        "### Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7OLwd4cTvDae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "59cbfa3c-7f95-4c52-94e6-d3d25a62ef36"
      },
      "source": [
        "num_classes = 10\n",
        "input_shape = (32, 32, 3)\n",
        "(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()\n",
        "print(f\"x_train shape: {x_train.shape} - y_train shape: {y_train.shape}\")\n",
        "print(f\"x_test shape: {x_test.shape} - y_test shape: {y_test.shape}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
            "170500096/170498071 [==============================] - 2s 0us/step\n",
            "170508288/170498071 [==============================] - 2s 0us/step\n",
            "x_train shape: (50000, 32, 32, 3) - y_train shape: (50000, 1)\n",
            "x_test shape: (10000, 32, 32, 3) - y_test shape: (10000, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kg6PmqYAraL3"
      },
      "source": [
        "# scale data\n",
        "x_train = x_train / 255.0\n",
        "x_test = x_test / 255.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o4mZxUE1vDaf"
      },
      "source": [
        "### Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kkwfHroLvDah",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f7af2e2b-2441-499e-b1db-3938b0d959c3"
      },
      "source": [
        "weight_decay = 0.0001\n",
        "batch_size = 128\n",
        "num_epochs = 50\n",
        "dropout_rate = 0.2\n",
        "image_size = 64 # resize input images to this size.\n",
        "patch_size = 4  # Size of the patches to be extracted from the input images.\n",
        "num_patches = (image_size // patch_size) ** 2  # Size of the data array.\n",
        "embedding_dim = 256  # Number of hidden units.\n",
        "num_blocks = 4  # Number of blocks.\n",
        "\n",
        "print(f\"Image size: {image_size} X {image_size} = {image_size ** 2}\")\n",
        "print(f\"Patch size: {patch_size} X {patch_size} = {patch_size ** 2} \")\n",
        "print(f\"Patches per image: {num_patches}\")\n",
        "print(f\"Elements per patch (3 channels): {(patch_size ** 2) * 3}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image size: 64 X 64 = 4096\n",
            "Patch size: 4 X 4 = 16 \n",
            "Patches per image: 256\n",
            "Elements per patch (3 channels): 48\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e7FUcUvIvDaj"
      },
      "source": [
        "def build_classifier(blocks, positional_encoding=False):\n",
        "    inputs = layers.Input(shape=input_shape)\n",
        "    # Augment data.\n",
        "    augmented = data_augmentation(inputs)\n",
        "    # Create patches.\n",
        "    patches = Patches(patch_size, num_patches)(augmented)\n",
        "    # Encode patches to generate a [batch_size, num_patches, embedding_dim] tensor.\n",
        "    x = layers.Dense(units=embedding_dim)(patches)\n",
        "    if positional_encoding:\n",
        "      print(\"positional_encoding= \", positional_encoding)\n",
        "      positions = tf.range(start=0, limit=num_patches, delta=1)\n",
        "      position_embedding = layers.Embedding(\n",
        "          input_dim=num_patches, output_dim=embedding_dim #, trainable=True\n",
        "      )(positions)\n",
        "      x = x + position_embedding\n",
        "    # Process x using the module blocks.\n",
        "    x = blocks(x)\n",
        "    # Apply global average pooling to generate a [batch_size, embedding_dim] representation tensor.\n",
        "    representation = layers.GlobalAveragePooling1D()(x)\n",
        "    # Apply dropout.\n",
        "    representation = layers.Dropout(rate=dropout_rate)(representation)\n",
        "    # Compute logits outputs.\n",
        "    logits = layers.Dense(num_classes)(representation)\n",
        "    # Create the Keras model.\n",
        "    return keras.Model(inputs=inputs, outputs=logits)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SfEp6XsRvDal"
      },
      "source": [
        "def run_experiment(model):\n",
        "    # Create Adam optimizer with weight decay.\n",
        "    optimizer = tfa.optimizers.AdamW(\n",
        "        learning_rate=learning_rate, weight_decay=weight_decay,\n",
        "    )\n",
        "    # Compile the model.\n",
        "    model.compile(\n",
        "        optimizer=optimizer,\n",
        "        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
        "        metrics=[\n",
        "            keras.metrics.SparseCategoricalAccuracy(name=\"acc\")\n",
        "        ],\n",
        "    )\n",
        "    # Create a learning rate scheduler callback.\n",
        "    reduce_lr = keras.callbacks.ReduceLROnPlateau(\n",
        "        monitor=\"val_loss\", factor=0.5, patience=5\n",
        "    )\n",
        "    # Create an early stopping callback.\n",
        "    early_stopping = tf.keras.callbacks.EarlyStopping(\n",
        "        monitor=\"val_loss\", patience=10, restore_best_weights=True\n",
        "    )\n",
        "    # Fit the model.\n",
        "    history = model.fit(\n",
        "        x=x_train,\n",
        "        y=y_train,\n",
        "        batch_size=batch_size,\n",
        "        epochs=num_epochs,\n",
        "        validation_split=0.1,\n",
        "        callbacks=[early_stopping, reduce_lr],\n",
        "    )\n",
        "\n",
        "    _, accuracy = model.evaluate(x_test, y_test)\n",
        "    print(f\"Test accuracy: {round(accuracy * 100, 2)}%\")\n",
        "\n",
        "    # Return history to plot learning curves.\n",
        "    return history\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ma3WOScDvDan"
      },
      "source": [
        "data_augmentation = keras.Sequential(\n",
        "    [\n",
        "        layers.Normalization(),\n",
        "        layers.Resizing(image_size, image_size),\n",
        "    ],\n",
        "    name=\"data_augmentation\",\n",
        ")\n",
        "# Compute the mean and the variance of the training data for normalization.\n",
        "data_augmentation.layers[0].adapt(x_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U_7WDYdZvDao"
      },
      "source": [
        "# patch extraction as a layer\n",
        "class Patches(layers.Layer):\n",
        "    def __init__(self, patch_size, num_patches):\n",
        "        super(Patches, self).__init__()\n",
        "        self.patch_size = patch_size\n",
        "        self.num_patches = num_patches\n",
        "\n",
        "    def call(self, images):\n",
        "        batch_size = tf.shape(images)[0]\n",
        "        patches = tf.image.extract_patches(\n",
        "            images=images,\n",
        "            sizes=[1, self.patch_size, self.patch_size, 1],\n",
        "            strides=[1, self.patch_size, self.patch_size, 1],\n",
        "            rates=[1, 1, 1, 1],\n",
        "            padding=\"VALID\",\n",
        "        )\n",
        "        patch_dims = patches.shape[-1]\n",
        "        patches = tf.reshape(patches, [batch_size, self.num_patches, patch_dims])\n",
        "        return patches"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yCWi9-UbtZ1h"
      },
      "source": [
        "### Plot"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qEK1sY2Rtbxu"
      },
      "source": [
        "def plot_curves(history, lossname='loss', accname='acc'):\n",
        "    plt.figure(figsize=(10, 7))\n",
        "    plt.plot(history.history[lossname], label='Train')\n",
        "    plt.plot(history.history['val_' + lossname], label='Val')\n",
        "    plt.title('Learning curve')\n",
        "    plt.ylabel('Loss')\n",
        "    plt.xlabel('Epoch')\n",
        "    plt.grid()\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "    print()\n",
        "    plt.figure(figsize=(10, 7))\n",
        "    plt.plot(history.history[accname], label='Train')\n",
        "    plt.plot(history.history['val_' + accname], label='Val')\n",
        "    plt.title('Learning curve')\n",
        "    plt.ylabel('acc')\n",
        "    plt.xlabel('Epoch')\n",
        "    plt.grid()\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "    print()\n",
        "\n",
        "\n",
        "def print_exp_params():\n",
        "    print(\"num_epochs: \", num_epochs)\n",
        "    print(\"embedding_dim: \", embedding_dim)\n",
        "    print(\"batch_size: \", batch_size)\n",
        "    print(\"num_blocks: \", num_blocks)\n",
        "    print(\"dropout_rate: \", dropout_rate)\n",
        "    print(\"learning_rate: \", learning_rate)\n",
        "    print(\"-\"*30)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7nLdHz8mvDap"
      },
      "source": [
        "## MLP-Mixer model\n",
        "\n",
        "Based on the paper [MLP-Mixer: An all-MLP Architecture for Vision](https://arxiv.org/abs/2105.01601), keras code [code](https://github.com/keras-team/keras-io/blob/master/examples/vision/mlp_image_classification.py)<br>\n",
        "\n",
        "- \"While convolutions and attention are both sufficient for good performance, neither of them is necessary!\"\n",
        "- \"Mixer is a competitive but conceptually and technically simple alternative, that does not use convolutions or self-attention\"\n",
        "- \"The idea behind the Mixer architecture is to clearly separate the per-location (channel-mixing) operations, and cross-location (token-mixing) operations. Both operations are implemented with MLPs\"\n",
        "- \"Mixer relies only on basic matrix multiplication routines, changes to data layout (reshapes and transpositions), and scalar nonlinearities.\"\n",
        "- \"The computational complexity of the network is linear in the number of input patches, unlike ViT whose complexity is quadratic\"\n",
        "- \"Each layer in Mixer takes an input of the same size. This “isotropic” design is most similar to Transformers\"\n",
        "- \"Unlike ViTs, Mixer does not use position embeddings because the token-mixing MLPs are sensitive to the order of the input tokens.\"\n",
        "\n",
        "The MLP-Mixer model tends to have much less number of parameters compared\n",
        "to convolutional and transformer-based models, which leads to less training and\n",
        "serving computational cost.\n",
        "\n",
        "https://keras.io/examples/vision/mlp_image_classification/#the-mlpmixer-model\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mLVA3xkqvDap"
      },
      "source": [
        "### The MLP-Mixer 1 block\n",
        "> If the input to the layer has a rank greater than 2, then Dense computes the dot product between the inputs and the kernel along the last axis of the inputs and axis 0 of the kernel (using tf.tensordot). \n",
        "- For example, if input has dimensions (batch_size, d0, d1), then we create a kernel with shape (d1, units), and the kernel operates along axis 2 of the input, on every sub-tensor of shape (1, 1, d1) (there are batch_size * d0 such sub-tensors). The output in this case will have shape (batch_size, d0, units).\n",
        "\n",
        " https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "inTh4-iRvDaq"
      },
      "source": [
        "# Original paper\n",
        "class MLPMixerLayer(layers.Layer):\n",
        "    def __init__(self, num_patches, hidden_units, dropout_rate, *args, **kwargs):\n",
        "        super(MLPMixerLayer, self).__init__(*args, **kwargs)\n",
        "\n",
        "        self.mlp1 = keras.Sequential(\n",
        "            [\n",
        "                layers.Dense(units=num_patches),\n",
        "                tfa.layers.GELU(),\n",
        "                layers.Dense(units=num_patches),\n",
        "                layers.Dropout(rate=dropout_rate),\n",
        "            ]\n",
        "        )\n",
        "        self.mlp2 = keras.Sequential(\n",
        "            [\n",
        "                layers.Dense(units=num_patches),\n",
        "                tfa.layers.GELU(),\n",
        "                layers.Dense(units=embedding_dim),\n",
        "                layers.Dropout(rate=dropout_rate),\n",
        "            ]\n",
        "        )\n",
        "        self.normalize = layers.LayerNormalization(epsilon=1e-6)\n",
        "\n",
        "    def call(self, inputs):\n",
        "        # Apply layer normalization.\n",
        "        x = self.normalize(inputs)\n",
        "        # Transpose inputs from [num_batches, num_patches, hidden_units] to [num_batches, hidden_units, num_patches].\n",
        "        x_channels = tf.linalg.matrix_transpose(x)\n",
        "        # Apply mlp1 on each channel independently.\n",
        "        mlp1_outputs = self.mlp1(x_channels)\n",
        "        # Transpose mlp1_outputs from [num_batches, hidden_dim, num_patches] to [num_batches, num_patches, hidden_units].\n",
        "        mlp1_outputs = tf.linalg.matrix_transpose(mlp1_outputs)\n",
        "        # Add skip connection.\n",
        "        x = mlp1_outputs + inputs\n",
        "        # Apply layer normalization.\n",
        "        x_patches = self.normalize(x)\n",
        "        # Apply mlp2 on each patch independtenly.\n",
        "        mlp2_outputs = self.mlp2(x_patches)\n",
        "        # Add skip connection.\n",
        "        x = x + mlp2_outputs\n",
        "        return x\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0EvlyVRwtMc5",
        "outputId": "d4541ef6-2b3a-47cf-8bd7-6fcb9612d900"
      },
      "source": [
        "num_epochs = 50\n",
        "embedding_dim = 64\n",
        "batch_size = 128\n",
        "num_blocks = 1\n",
        "dropout_rate = 0.5\n",
        "mlpmixer_blocks = keras.Sequential([MLPMixerLayer(num_patches, embedding_dim, dropout_rate) for _ in range(num_blocks)])\n",
        "learning_rate = 0.005\n",
        "mlpmixer_classifier = build_classifier(mlpmixer_blocks)\n",
        "mlpmixer_classifier.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_14\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "input_31 (InputLayer)        [(None, 32, 32, 3)]       0         \n",
            "_________________________________________________________________\n",
            "data_augmentation (Sequentia (None, 64, 64, 3)         7         \n",
            "_________________________________________________________________\n",
            "patches_30 (Patches)         (None, 256, 48)           0         \n",
            "_________________________________________________________________\n",
            "dense_180 (Dense)            (None, 256, 64)           3136      \n",
            "_________________________________________________________________\n",
            "sequential_116 (Sequential)  (None, 256, 64)           164800    \n",
            "_________________________________________________________________\n",
            "global_average_pooling1d_18  (None, 64)                0         \n",
            "_________________________________________________________________\n",
            "dropout_82 (Dropout)         (None, 64)                0         \n",
            "_________________________________________________________________\n",
            "dense_181 (Dense)            (None, 10)                650       \n",
            "=================================================================\n",
            "Total params: 168,593\n",
            "Trainable params: 168,586\n",
            "Non-trainable params: 7\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MBSw7fxOtVbD",
        "outputId": "7d5a2789-188f-4d22-ed56-59107284ca9a"
      },
      "source": [
        "history = run_experiment(mlpmixer_classifier)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n",
            "352/352 [==============================] - 19s 50ms/step - loss: 1.8038 - acc: 0.3347 - val_loss: 1.5240 - val_acc: 0.4372\n",
            "Epoch 2/50\n",
            "352/352 [==============================] - 17s 49ms/step - loss: 1.5425 - acc: 0.4315 - val_loss: 1.8105 - val_acc: 0.4154\n",
            "Epoch 3/50\n",
            "352/352 [==============================] - 17s 48ms/step - loss: 1.4457 - acc: 0.4682 - val_loss: 1.4649 - val_acc: 0.4852\n",
            "Epoch 4/50\n",
            "352/352 [==============================] - 17s 48ms/step - loss: 1.3750 - acc: 0.4998 - val_loss: 1.4517 - val_acc: 0.5038\n",
            "Epoch 5/50\n",
            "352/352 [==============================] - 17s 49ms/step - loss: 1.3089 - acc: 0.5200 - val_loss: 1.6996 - val_acc: 0.4622\n",
            "Epoch 6/50\n",
            "352/352 [==============================] - 17s 49ms/step - loss: 1.2535 - acc: 0.5438 - val_loss: 1.5966 - val_acc: 0.4844\n",
            "Epoch 7/50\n",
            "352/352 [==============================] - 17s 48ms/step - loss: 1.1992 - acc: 0.5668 - val_loss: 1.5676 - val_acc: 0.5100\n",
            "Epoch 8/50\n",
            "352/352 [==============================] - 17s 48ms/step - loss: 1.1499 - acc: 0.5813 - val_loss: 1.7252 - val_acc: 0.4804\n",
            "Epoch 9/50\n",
            "352/352 [==============================] - 17s 49ms/step - loss: 1.1083 - acc: 0.5963 - val_loss: 1.5389 - val_acc: 0.5284\n",
            "Epoch 10/50\n",
            "352/352 [==============================] - 17s 47ms/step - loss: 0.9571 - acc: 0.6518 - val_loss: 1.5884 - val_acc: 0.5406\n",
            "Epoch 11/50\n",
            "352/352 [==============================] - 17s 49ms/step - loss: 0.9085 - acc: 0.6681 - val_loss: 1.7746 - val_acc: 0.5382\n",
            "Epoch 12/50\n",
            "352/352 [==============================] - 17s 49ms/step - loss: 0.8697 - acc: 0.6814 - val_loss: 1.9154 - val_acc: 0.5242\n",
            "Epoch 13/50\n",
            "352/352 [==============================] - 17s 49ms/step - loss: 0.8357 - acc: 0.6932 - val_loss: 1.9112 - val_acc: 0.5238\n",
            "Epoch 14/50\n",
            "352/352 [==============================] - 17s 49ms/step - loss: 0.8116 - acc: 0.7017 - val_loss: 2.0605 - val_acc: 0.5114\n",
            "313/313 [==============================] - 4s 12ms/step - loss: 1.4876 - acc: 0.4939\n",
            "Test accuracy: 49.39%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "C-ov6kyHjch7",
        "outputId": "f9b89100-2b20-4388-ab07-5b3e1a56f648"
      },
      "source": [
        "print_exp_params()\n",
        "plot_curves(history)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_epochs:  50\n",
            "embedding_dim:  64\n",
            "batch_size:  128\n",
            "num_blocks:  1\n",
            "dropout_rate:  0.5\n",
            "learning_rate:  0.005\n",
            "------------------------------\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAG5CAYAAADGcOOUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3gU1f7H8fdJBxJqIJSE3nsJKNICqKCgWBBEUSnWa/far/70NhUrolexIVYQsGChSy8CoffeQm9CKCFtfn+coIAJJGF3J9n9vJ4nT8rOznwzhOSzZ858j3EcBxERERHxrSC3CxAREREJRAphIiIiIi5QCBMRERFxgUKYiIiIiAsUwkRERERcoBAmIiIi4gKFMBHxW8aYdsaYdW7XISKSHaM+YSLiDcaYrcCdjuNMcbsWEZGCSCNhIlJoGWOC3a7hYvnD9yAi+aMQJiI+ZYwJMsY8bYzZZIw5aIwZZYwpfcbjo40xe4wxR4wxM40xDc54bLgx5n1jzDhjzHGgozFmqzHmcWPM8qznfGOMicjaPsEYk3TG83PcNuvxJ40xu40xu4wxdxpjHGNMzRy+j9LGmE+ztj1sjPkh6+v9jDGzz9n2j/1k8z08nvX9Bp+x/fXGmOW5OV8iUngphImIrz0IXAd0ACoCh4H/nfH4eKAWUA5YDHx1zvNvAf4LRAGnw04voCtQDWgM9DvP8bPd1hjTFXgMuByoCSRc4Pv4AigKNMiq9a0LbJ/T9/A2cBzodM7jX2d9fKHzJSKFlEKYiPjavcA/HMdJchznFPAi0NMYEwLgOM4wx3GSz3isiTGmxBnPH+s4zhzHcTIdx0nJ+toQx3F2OY5zCPgJaHqe4+e0bS/gU8dxVjmOcyLr2NkyxlQArgLudRznsOM4aY7jzMjDOTj3exgB9MnadxRwddbX4ALnS0QKL4UwEfG1KsD3xpjfjTG/A2uADCDGGBNsjHkl69LbUWBr1nOiz3j+jmz2ueeMj08Akec5fk7bVjxn39kd57Q44JDjOIfPs835nLvvr4EbjDHhwA3AYsdxtmU9luP5yuexRaSAUAgTEV/bAVzlOE7JM94iHMfZib0M1wN7SbAEUDXrOeaM53vrlu7dQOwZn8edZ9sdQGljTMlsHjuOvUwJgDGmfDbbnPU9OI6zGtiGHV0781Lk6WPldL5EpBBTCBMRbwo1xkSc8RYCDAX+a4ypAmCMKWuM6ZG1fRRwCjiIDTIv+bDWUUB/Y0w9Y0xR4PmcNnQcZzd27tp7xphSxphQY0z7rIeXAQ2MMU2zJv2/mMvjfw08DLQHRp/x9fOdLxEpxBTCRMSbxgEnz3h7ETsR/UdgkjEmGfgNuCRr+8+xI0I7gdVZj/mE4zjjgSHANGDjGcc+lcNTbgPSgLXAPuCRrP2sB/4FTAE28OfNAxcyAjv5fqrjOAfO+Pr5zpeIFGJq1ioikg1jTD1gJRDuOE662/WIiP/RSJiISJas/lzhxphSwCDgJwUwEfEWhTARkT/dg720uAl7B+J97pYjIv5MlyNFREREXKCRMBEREREXFLqOy9HR0U7VqlW9fpzjx49TrFgxrx/H3+i85Y/OW/7ovOWPzlv+6LzlT6Cft0WLFh1wHKdsdo8VuhBWtWpVEhMTvX6c6dOnk5CQ4PXj+Budt/zRecsfnbf80XnLH523/An082aM2ZbTY7ocKSIiIuIChTARERERFyiEiYiIiLig0M0Jy05aWhpJSUmkpKR4bJ8lSpRgzZo1Htufp0RERBAbG0toaKjbpYiIiMhF8IsQlpSURFRUFFWrVsUY45F9JicnExUV5ZF9eYrjOBw8eJCkpCSqVavmdjkiIiJyEfzicmRKSgplypTxWAArqIwxlClTxqMjfiIiIuIOvwhhgN8HsNMC5fsUERHxd34TwkREREQKE4UwDzh48CBNmzaladOmlC9fnkqVKv3xeWpq6nmfm5iYyEMPPeSjSkVERKSg8IuJ+W4rU6YMS5cuBeDFF18kMjKSxx9//I/H09PTCQnJ/lTHx8cTHx/vkzpFRESk4NBImJf069ePe++9l0suuYQnn3ySBQsW0Lp1a5o1a8Zll13GunXrALucQ/fu3QEb4AYMGEBCQgLVq1dnyJAhbn4LIiIi4kV+NxL2z59WsXrX0YveT0ZGBsHBwQDUr1icF65pkOd9JCUlMXfuXIKDgzl69CizZs0iJCSEKVOm8Oyzz/Ltt9/+5Tlr165l2rRpJCcnU6dOHe677z71BBMREfFDfhfCCpKbbrrpjyB35MgR7rjjDjZs2IAxhrS0tGyf061bN8LDwwkPD6dcuXLs3buX2NhYX5YtIiIiPuB3ISw/I1bZ8USz1mLFiv3x8fPPP0/Hjh35/vvv2bp1a44ryoeHh//xcXBwMOnp6RdVg4iIiBRMmhPmI0eOHKFSpUoADB8+3N1iREREAt3uZXAq2dUSFMJ85Mknn+SZZ56hWbNmGt0SERFx0+5lMLw7/Pyoq2X43eVIt7344ovZfr1169asX7/+j8//85//AJCQkPDHpclzn7ty5UpvlCgiIhK49q+DL66H8OLQ+QVXS9FImIiIiASGw1vh8+vABMHtY6FknKvlaCRMRERE/N/R3fB5D0g7Dv3GQXRNtytSCBMRERE/d/wgfHEdHNsPd/wI5Ru6XRGgECYiIiL+LOUofHkDHNoCfcdAbMFZKlAhTERERPxT6gn4ujfsXQm9v4Rq7d2u6CwKYSIiIuJ/0lNh1G2wfR7c+DHUucrtiv5Cd0d6QMeOHZk4ceJZXxs8eDD33XdfttsnJCSQmJjoi9JEREQCT0Y6fDsQNk6BawZDo55uV5QthTAP6NOnDyNHjjzrayNHjqRPnz4uVSQiIhKgMjPhp4dgzY9w5X+hRT+3K8qRQpgH9OzZk19++YXU1FQAtm7dyq5duxgxYgTx8fE0aNCAF15wtyGciIiI33McmPgMLP0KOjwNlz3gdkXn5X9zwsY/DXtWXPRuimSkQ3DW6SnfCK56JcdtS5cuTatWrRg/fjw9evRg5MiR9OrVi2effZbSpUuTkZFB586dWb58OY0bN77o2kRERCQb0/4L84fCpX+DhKfdruaCNBLmIWdekjx9KXLUqFE0b96cZs2asWrVKlavXu1ylSIiIn5qztsw8zVodht0eQmMcbuiC/K/kbDzjFjlxcnkZKKionK9fY8ePXj00UdZvHgxJ06coHTp0rz++ussXLiQUqVK0a9fP1JSUjxSm4iIiJwhcRhM/j9ocD1c83ahCGDgxZEwY0ycMWaaMWa1MWaVMebhbLYxxpghxpiNxpjlxpjm3qrH2yIjI+nYsSMDBgygT58+HD16lGLFilGiRAn27t3L+PHj3S5RRETE/ywfDT8/BrWuhOs/hKBgtyvKNW+OhKUDf3ccZ7ExJgpYZIyZ7DjOmdfkrgJqZb1dAryf9b5Q6tOnD9dffz0jR46kbt26NGvWjLp16xIXF0ebNm3cLk9ERMS/rP0Fvr8HqrSBXp9DSJjbFeWJ10KY4zi7gd1ZHycbY9YAlYAzQ1gP4HPHcRzgN2NMSWNMhaznFjrXXXcd9luxhg8fnu1206dP901BIiIi/mrTNBjdDyo2hVtGQmgRtyvKM3NmaPDaQYypCswEGjqOc/SMr/8MvOI4zuysz38FnnIcJ/Gc598N3A0QExPT4tyeXCVKlKBmTc+uhp6RkUFwcMEc0ty4cSNHjhxxu4xsHTt2jMjISLfLKHR03vJH5y1/dN7yR+ctf7xx3oofWUuTZf/HySLlWdr0v6SH5n4Ot6917NhxkeM42S5Y6fWJ+caYSOBb4JEzA1heOI7zIfAhQHx8vJOQkHDW42vWrMnTJPrcSM7jxHxfioiIoFmzZm6Xka3p06dz7r+PXJjOW/7ovOWPzlv+6Lzlj8fP2+7l8NlLULISkf3H0zaqvOf27WNebVFhjAnFBrCvHMf5LptNdgJxZ3wem/W1PPPFiF5BECjfp4iIyF8c2ABfXA9hkXD7WCjEAQy8e3ekAT4B1jiO82YOm/0I3J51l+SlwJH8zAeLiIjg4MGDfh9QHMfh4MGDREREuF2KiIiIb/2+HT7vYT++fSyUrOxuPR7gzcuRbYDbgBXGmKVZX3sWqAzgOM5QYBxwNbAROAH0z8+BYmNjSUpKYv/+/Rdd9GkpKSkFMuxEREQQGxvrdhkiIiK+k7wHPrsWUo9Bv18gupbbFXmEN++OnA2ct1ta1l2R91/ssUJDQ6lWrdrF7uYs06dPL7DzrkRERALGiUP2EuSxfXD7D3YpQT/hfx3zRURExD+cSoYvb4SDm+DWURDXyu2KPEohTERERAqetJPw9c2wexn0/hKqJ7hdkccphImIiEjBkp4Ko26HbXPgho+g7tVuV+QVCmEiIiJScGRmwHd3wYZJ0H0wNL7J7Yq8xqt9wkRERERyLTMTfnoIVv8AV/wb4vPVNKHQUAgTERER9zkOTHwWlnwJ7Z+ENg+5XZHXKYSJiIiI+6a/DPPfh0vug47Pul2NTyiEiYiIiLvmvgMzBkHTvtDlJTDnbTPqNxTCRERExD2Jn8Kk56D+dXDtEAgKnGgSON+piIiIFCwrxsDPj0LNK2wriqBgtyvyKYUwERER8b114+H7e6DKZdDrcwgJc7sin1MIExEREd/aPANG3WHXgewzEsKKul2RKxTCRERExHd2LIQRfaB0dej7HUQUd7si1yiEiYiIiG/sWQlf3QiR5eD2H6BoabcrcpVCmIiIiHjfgY3wxXUQWgxuHwtR5d2uyHUKYSIiIuJdv++Az3vYrvi3j4VSVdyuqEDQAt4iIiLiNWGnDsPn18KpZOj3M5St7XZJBYZCmIiISGF1eBt83RsOb4GQcAgOh5AI2+4hJAKCwy7webh93um3sz4/3/Oz2T447K+d7k8covHyFyB1P9z2A1Ro7M55KqAUwkRERAqjw9tgeHc4dRRa3QUZaZCeAump9n1G1vv0U5B6Ak4eth9nt01mumdqOjcEpp2g6Mkj0HcMVL7EM8fwIwphIiIihc2ZAez2sVCx6cXtLzPDBrSMU1lB7VQ2n58Z7LIJetk+P5UVQY1oUqOjZ75vP6MQJiIiUph4OoCBXS4orCjg+aaph6dP9/g+/YXujhQRESksvBHAxDUKYSIiIoWBApjfUQgTEREp6A5vheHdFMD8jEKYiIhIQXZ4a9YIWLICmJ/RxHwREZGC6swAdsePUKGJ2xWJB2kkTEREpCBSAPN7CmEiIiIFjQJYQFAIExERKUgUwAKGQpiIiEhBoQAWUBTCRERECoJDWxTAAoxCmIiIiNsObYHProHUYwpgAUQhTERExE1nBrDbxyqABRCFMBEREbcogAU0hTARERE3KIAFPIUwERERX1MAE7RskYiIiG+dvgsy7bgCWIBTCBMREfGVswLYj1ChsdsViYt0OVJERMQXFMDkHAphIiIi3qYAJtlQCBMREfEmBTDJgUKYiIiItyiAyXkohImIiHiDAphcgEKYiIiIpx3arAAmF6QQJiIi4kmHNsPwaxTA5ILUJ0xERMRTzgxgd/wE5Ru5XZEUYBoJK0x+3w7vtIAdC9yuREREzqUAJnnktRBmjBlmjNlnjFmZw+MljDE/GWOWGWNWGWP6e6uWvNq8/xiO47hdxl/NegMOboS5Q9yuREREzqQAJvngzZGw4UDX8zx+P7DacZwmQALwhjEmzIv15MqCLYe4/M0ZJO7NcLuUs/2+A5Z8BeHFYe04OLrL7YpERAQUwCTfvBbCHMeZCRw63yZAlDHGAJFZ26Z7q57calGlFDXLRfLt+lTSMjLdLudPcwbb9zd/DU4GLP7C3XpEROTsuyAVwCSPjDcvuxljqgI/O47TMJvHooAfgbpAFNDbcZxfctjP3cDdADExMS1GjhzprZIBWLIvnbcXn+KO+mF0rBzq1WPlRtipg1z6293sKd+Z9XX+RuNlL1L0xHbmX/IRTlCw2+Wd5dixY0RGRrpdRqGj85Y/Om/5o/OWP+eet4iTu2m69B8EZ6SytOm/OR5ZzcXqCq5A/3nr2LHjIsdx4rN7zM27I7sAS4FOQA1gsjFmluM4R8/d0HGcD4EPAeLj452EhASvFtbBcRi/ZQLjdhieurktRcNcvol0/FNgoGKv16hYqgrEPA7f3EqHiilQt5u7tZ1j+vTpePvfxx/pvOWPzlv+6Lzlz1nn7dBmGP43CHKg/3haagQsR/p5y5mbd0f2B75zrI3AFuyomOuMMdxUO4z9yacYNnuLu8Uk74VFw6HJzVCqiv1a7a4QVRESh7lamohIQPrjEuRJuONHXYKUfHMzhG0HOgMYY2KAOsBmF+s5S61SwVxZP4ahMzZz6Hiqe4XMHQIZqdD2sT+/FhwCLe6Ajb/aZTFERMQ3FMDEg7zZomIEMA+oY4xJMsYMNMbca4y5N2uTfwOXGWNWAL8CTzmOc8Bb9eTHk13rcCI1nXenbnSngGP77WhXo15QpsbZjzW/HUyQHSUTERGvizi5WwFMPMprk50cx+lzgcd3AVd66/ieULNcFL3i4/jit630b1OVuNJFfVvAvHftf/b2j//1seIVoc5VsORL6PgshIT7tjYRkUByaDNNl/7DzgFTABMPUcf8C3jk8toEGcObk9f79sDHD8KCj6DhjRBdK/tt4vvDiQOw5iff1iYiEkiOH4TPriU4I1UBTDxKIewCypeIYEDbavywdCerdh3x3YF/ew/STmQ/CnZa9U5Qqqom6IuIeEtmJnx3Fxzbx7ImLyqAiUcphOXCvR1qUDwilFcnrPPNAU8ehvkfQP0eUK5eztsFBUGL/rBtDuxb65vaREQCyew3YNOvcNUrHIuq6XY14mcUwnKhRJFQHuhYkxnr9zN3ow/uHfhtKKQmQ/snLrxts74QHAaLPvV+XSIigWTLLJj2EjS6yb7gFfEwhbBcuq11FSqWiOCVCWu9u7h3yhGY/z7U7Q7l/7LQwF8Vi7YjZktHQOpx79UlIhJIkvfCtwOhTE3oPhiMcbsi8UMKYbkUERrMY1fWYXnSEcat2OO9Ay340Aax3IyCnRY/AE4dgZXfea8uEZFAkZlhA1jKUbjpMwgP3CV3xLsUwvLg+maVqBMTxWsT13pnce9TyTDvf7YjfsWmuX9e5dZQtp4m6IuIeML0V2DrLOj2BsTUd7sa8WMKYXkQHGR46qo6bD14gpELtnv+AAs/tpPy2z+Zt+cZY0fDdi2GXUs8X5eISKDY+CvMfA2a9oVmt7pdjfg5hbA86linHK2qlebtXzdw/FS653acehzmvgM1L4fYFnl/fpPeEFpUo2EiIvl1dJdtR1GuHlz9mtvVSABQCMsjYwxPX1WXA8dS+XiWB9dtTBwGJw5Ch6fy9/yIErax64oxdk6ZiIjkXkYajBkAaSl2HliYj1dIkYCkEJYPzSuXomuD8nw4cxMHjp26+B2mnYQ5Q6BaB4hrlf/9tBxoG7wu++biaxIRCSRT/w3b58E1b0PZ2m5XIwFCISyfnuhah5T0TM8s7r3oMzi+L/+jYKdVbGbfEoeBN9toiIj4k3UTYM7bdm5t45vcrkYCiEJYPtUoG0mv+Di+mr+NbQcvoj9XWgrMGQxV2kLVNhdfWPwA2L8Gtv928fsSEfF3v2+H7++B8o2hy8tuVyMBRiHsIjx6eS1CgoJ4Y9JFLO695AtI3g0d8nhHZE4a3gjhJSDxE8/sT0Tybu9q+wJLCrb0VBjdD5xM6PUZhEa4XZEEGIWwi1CueAQD21bjx2W7WLkzH5Ph00/B7Lcg7lKo1t4zRYUVgyY3w+qxcNwHSyyJyNmWfQPvt4Yx/TUtoKCb/H+wcxH0eBdKV3e7GglACmEX6e4O1SlVNJRBE/KxgPbSr+HoTjsK5sklMeL7Q0YqLP3Kc/sUkQvbNBXG/g2Kx8K6cTDvXbcrkpysHmuXiLvkPrv0m4gLFMIuUvGIUB7oVItZGw4wa8P+3D8xIw1mvwmV4qFGJ88WVa4eVGkDiZ9Cphc6+4vIX+1aCt/cBmXrwn1zoN41MOVF2D7f7crkXIc2w9gHoFILuOJfblcjAUwhzAP6XlqZSiWLMGjCWjIzc3n5Yfk3dkKop0fBTosfAIe3wOZpnt+3iJzt0Bb46iYoUgpuHQNFSsK170KJWHtZ8vhBtyuU09JSYNQdYILgpuEQEuZ2RRLAFMI8IDwkmMe71GblzqP8vGL3hZ+QkQ4zX4cKTaDWld4pqt41UDRaHfRFvO34QfjyRjsFoO+3ULyC/XqRkrbp5/H99u47jUoXDBOfgT3L4foPoGRlt6uRAKcQ5iE9mlSiXoXivD5xHanpF/hlu3KMHaXq8JR3RsEAQsKhWV9YN94uxSEinpd6HL7uZed23jIKytY5+/GKTaHry7BxMsx5y50a5U8rxtgXpm0ehjpd3a5GRCHMU4KCDE91rcP2QycYcb7FvTMz7OKwMY2gztXeLapFP3AyYPHn3j2OXJyju+2/kxQuGel2mZtdi6HnMKh8SfbbxQ+0rWOm/ge2zvZtjfKn/evhx4fs3eidnne7GhFAIcyjOtQuS+vqZRjy6waO5bS496rv4eBG6PCE90bBTitdDWp0th35Mzy42Lh4zs7F8FYDmi59Do4kuV2N5JbjwM+PwPoJ0O0NqNst522NsUvhlK4OYwbCsX2+q1Os1BMw+g7bB6znMAgOdbsiEUAhzKNOL+598HgqH83c/NcNMjNhxqtQth7UvcY3RbUcCMm7YMNE3xxPcs9xYMIzEFGcyGOb4f02sOZnt6uS3Jj+sm203P5JexPMhYRH2flhKb/Dt3faEXHxnXFPwL41cMNHUKKS29WI/EEhzMOaxJWkW6MKfDRrM/uTz1nce81YOLDOjoIF+ejU1+oCURVhoTroFzirvocdv8Hl/2RRi7egVFX45lb45e/qtl6QJQ6DGYPsnMuOz+b+eeUbwtWvwZYZdkqC+MaSr2Dpl9D+CajZ2e1qRM6iEOYFj3epw6n0TN6ZuuHPL2Zm2jsiy9SC+tf5rpjgEGhxB2z61d5GLwVDWgpMecHODWzWl5NFK8LAydD6AVj4MXzcGfavc7tKOdfaX2xIrnUldB+c9ykFzW6DJn1g+iuwSe1jvG7vavvvVbUdJDztdjUif6EQ5gXVoovRp1UcX8/fztYDWYt7rxsHe1faV2NBwb4tqPntYIJh0XDfHldy9tt7tk9c15f+/HkICYMu/4VbRkPyHvgwwd5UoaVvCobt8+1E/IrNbH+p/MwrMsbOIStbB767y96UId5x6hiMut1eCr7xE9//3hXJBYUwL3mocy1Cg4N4fdI6+0d0xiA7Mbfhjb4vpnhFqHOVncOSfurC24t3Je+FWW9AnW7Zrxla+0rbcT22Jfz4oP3Dn5KPtUnFc/avhxG9oXgl24oirFj+9xVWzM4PSz0O3w7UTTPecPrGiUOboOcnEBXjdkUi2VII85JyURHc1a4aPy/fzZZ539nmgO0et5cH3RA/AE4chDU/uXN8+dO0/9gwfOW/c94mqjzc9j10/j+7xt3QdpCU6Lsa5U9Hd8OXN0BQqG3GWiz64vdZri50fwu2zYHpL138/uRsiz6FFaPtnL3sXuiIFBAKYV50V/vqlC4aSua0V3BKVoHGvdwrpnpHKFVNHfTdtns5LP4CLrkHytQ4/7ZBwdDu7zBggn1lP6wLzH5Lndd9KeUIfNUTTh6GW0fbti+e0uRmO1Vg1huwYbLn9hvodi+D8U/b9jxt/+52NSLnpRDmRVERobzSZB810tazofbd7vamCQqC+P72lfe+Ne7VEcgcByY+a9cXbP9E7p8X1wrunQV1u9sFob+8wV7SFO9KPwXf9IX9a6H3F7b7vadd9SrENITv7lafOE9IOWLXhSxaBm740Hd3oYvkk35CvclxuHz/cPaYsjy+vn7uF/f2lqa3QnAYJH7qbh2Bau0vsHWWvURSpGTenlukpJ0M3n0wbJ8HQ9vAxileKVOwo40/3AdbZkKP/0GNTt45TmgROz8sIxVG94eMNO8cJxA4Dox9wN7wctOnnrlsLOJlCmHetGUGQUkL2dv4PpbvOclPy11ew7FYtG2PsWyknRQsvpN+CiY9B2XrQov++duHMXY08+7pUKysXTR60vOQnurJSgVg8vOw8lu4/EV72dCbomvCtUMgaYEd6ZT8mf8BrPkRLn8BKl/qdjUiuaIQ5k0zXoWoijTqdj/1KxTntYnrOJXucqfs+AFw6oj9AyO+s+BDu2h7l/9e/M0Z5erBXVPtv+XcIXau2KFsVmiQ/Jn7Lsx7F1rdA20e8c0xG94ILe+0x137i2+O6U+SFtkXObWvgtYPul2NSK4phHnL1tl2/lXbRwgKi+Dpq+qSdPgkX88/z+LevlD5Urtskibo+87xAzDjNah5BdS83DP7DC1i767r9bm9DX9oe1gxxjP7DmQrxsCkf0D9HtD1Ze+v73qmLi9Bhab2Mujhrb47bmF34hCM7gdRFeC69zQPTAoV/bR6y4xBEBlj734C2tWKpk3NMrwzdSPJKS7O+zDGjqDsWmIXjxbvm/4ypB6zo2CeVr8H3DsbYhrYnlM/3K9Lzfm1eTp8fy9UaQvXf+j75p4h4Xben4OdH6aefhd2eu5e8m577oqWdrsikTxRCPOGbfPshN42D9sRC+zi3k91rcuhnBb39qUmvSG0qEbDfGHfGnueWw60XdK9oWRl6PeLveNy6VfwQQfbCkNyb/dyGNkXomvBzV9BaIQ7dZSuBtf9D3YttvP95PzmvQPrJ8CV/4HYFm5XI5JnCmHeMPNVO3H6nAnYjWNL0r1xBT6atYV9yS4u0BxRAhr1tPPCTv7uXh3+7nRLivAoSHjGu8cKDoFOz8EdP9pRt48724nKWvLowg5vs73AIorDrWPyfueqp9W7Bi79Gyz4AFb94G4tBdn232DKP6HetbbvnkghpBDmaUmJsGmqXYg5rOhfHn78yjqkZWQy5NcN2TzZh+IHQNoJWD7K3Tr82YbJ9mehw9O+u0xSrT3cO8e2VBj/JIy8xc6ZkeydOGTvMk1Psd3wS1RyuyLr8n9CpXjbcuHgJrerKXiOH7CXbEtWhh7v+nbunogHKYR52oxXoUhpe6dTNqpGF+OWS1C8X/MAACAASURBVCozYsEONu8/5uPizlCxGVRsDomfaLTEGzLS7ATvMjVz/FnwmmJloM9I6PqK7SX2fht7o4icLfUEfN3b9pXq842967SgCAmzva6CgmH0HZDm4sh5QZOZaRc/P3EQen1mR/ZFCimFME/atQQ2TITW90N4ZI6bPdipFuEhWYt7uyl+gO0Gvn2eu3X4o8RhcGC9nasSEub74xsDl94HAyfbeYmfXQPTXtZi0adlpNsbGZIWwo0fQ5XWblf0VyUrw/UfwJ4VMOFpt6spOGa9YUeYr3oFKjRxuxqRi6IQ5kkzXrOvylrdfd7NykaFc1e76oxbsYcl2w/7qLhsNLwBwktogr6nnThk74isngC1u7pbS8WmcM8MaHwzzHjFhrFAXx7HcWDc32HdOLj6Nah/rdsV5axOV9urbNGnsHy029W4b8tMu+B5o5vy3/RYpABRCPOU3cth3S9w6f12gu8F3NW+OmWKhfHK+LU4bl0ODCsGTfvA6rF2joV4xoxX7Rp2XV4qGHNVwqPg+vdt24U9y+3lyUBuCDrjVVg0HNo+Bq3ucruaC+v0PFRuDT89DPvXu12Ne5L3wpiB9hJ/98EF4/+WyEVSCPOUma9BePFc36UTGR7CQ51rMX/LIaav3+/l4s6jRX+7bt2SL92rwZ8c2AALP7L94WIauF3N2Zr0hntmQqmqdsL+L48H3lyjRZ/ZkZQmt0Dn/3O7mtwJDoGew2zbjNF32LlsgSYzw14+PpVs19o8z3QPkcJEIcwT9q62a5Zdck+ebm/v06oylUsXZdD4tWS4tbh3ubpQpY293JGZ6U4N/mTScxBSBDo+53Yl2StTw84Ta/2ADYsfd4b9Ls9N9JV1E+DnR+2qBdcOKVwjKcUrwg0f2b5z455wuxrfm/4ybJ0F3d6AmPpuVyPiMQphnjDrdQiLtL198iAsJIjHu9Rh7Z5kxi7d6aXiciF+gF0mZfNU92rwB5um2caR7R+HyLJuV5OzkDDbvf/WMZC8Bz5MgMWf+/ddsjsW2qVtKjS2IynBoW5XlHc1O2c15P0SlnzldjW+s3EKzHwdmvaFZre6XY2IRymEXaz962Hld3ZuST56QXVvVIGGlYrzxqT1pKS5tLh3vWugaDQkfurO8f1BRrptzFqqqr0rsTCodQXcNwdiW8KPD8KYAXYum785sAG+7gVR5eGW0YX7UlbC01C1HfzydzsC7++O7ITv7rbtQ65+ze1qRDzOayHMGDPMGLPPGLPyPNskGGOWGmNWGWNmeKsWr5r1um0B0PqBfD09KMjwdNd67Pz9JF/+ts3DxeVSSDg06wvrxttfepJ3Sz6Hfavhin/Z81lYRJWH276386NWj4Wh7WzDYX+RvAe+vAFMENz2XcEeocyNoGC48RN7s8Wo2+GUi70GvS0jzb4wSEuxo5fZNL8WKey8ORI2HMjx/nxjTEngPeBax3EaADd5sRbvOLgJVoy26wIWi873btrWiqZdrWjenbaRo24t7t2iHziZ9rKU5E3KEZj6Xzu3rl4BbneQk6BgaPd3GDDBXpIc1gVmv1X45wimHLXLER0/CLeOhtLV3a7IM6JioOcncGgT/PyI/15G/vVfsOM3uOZtKFvb7WpEvMJrIcxxnJnA+dZLuQX4znGc7Vnb7/NWLV4z6w0IDoPLHrroXT3VtS6/n0jjgxkuLVFSupqdc7L4MzX0zKuZr9vu3QWlJUV+xbWCe2dB3e4w5UU7gpS81+2q8ic9FUbdZi/Z9foMKjV3uyLPqtYeEp61LwIXDXe7Gs9bNx7mDrHzVRsXvtfnIrllvNmjyhhTFfjZcZyG2Tw2GAgFGgBRwNuO42Q7DGOMuRu4GyAmJqbFyJEjvVXyH44dO0ZkZM5zRyJO7uGS+feRFNuNTTU9syzN0GUpLN6bwaD2RSgV4fvpemUOzKfRypdY2eAZDpS9NF/7uNB58zcRJ3fTasED7I3pwLq6+Q/jBeq8OQ4Vdk+m5saPyAguwp7yHUmOqklyVC1SImIKVNDM9rw5mdRbM5iYfTNYW+ch9lTo7E5x3uZk0nj5Pyn5+yoWN3+VY1G5H+krUD9v54g4uZcWix4jJaIcS5oNIjPYhRUnclCQz1tBFujnrWPHjoscx4nP7jE3Q9i7QDzQGSgCzAO6OY5z3m6E8fHxTmKi9+esTJ8+nYSEhJw3+PFBWPYNPLwMilfwyDG3HzxB5zen07NFHC/f0Mgj+8yTjHR4uzGUrWPnCeXDBc+bv/mmL2ycCg8ttvOr8qlAnrd9a2Hc47BjAWScsl8rUurPdUcrNbcfF6/oWonZnrdJz9tRlE7P2ztV/dnxA3YeX2gE3D091+soFsifN7AjmMO6wMGNdqWHAnYJucCetwIu0M+bMSbHEBbi62LOkAQcdBznOHDcGDMTaAIU/JbQv2+HpSPsPCoPBTCAymWKcuslVfjit20MbFuNmuV8/MohOASa32GbWR7aXOB+ARY4W2fDmp+g03MXFcAKrHJ1od/P9g/j/jWwczHsWmzXSJ39FjhZd/NGlv8zkFXMel+sjDs1//a+DWAt77Tz3PxdsWjbyHV4N/vC8KbPCtRIZZ6c/B0mP29/xnp9rt8/EhDcDGFjgXeNMSFAGHAJ8JaL9eTe7MH2fdtHPL7rBzvVZMyiJF6fuI6ht7Xw+P4vqPltMGOQnWdyxb98f/zCIjMDJjwDJeLyfWdsoRESZhdKrtAEyFqvL+2kXVh6Z1Yo27XYzuMha2S9ZBUbxio1t8GsQpNcLed1UVZ+Z/9N6l0DV71aeMNIXlVpbe9unfICLPgILjn/2rUFStpJ2DAJlo+y7zNS7f+n+j3crkzEJ7wWwowxI4AEINoYkwS8gJ0DhuM4Qx3HWWOMmQAsBzKBjx3HybGdRYFxZCcs+cK2dCgR6/Hdl4kM5+721Xlz8noWbz9M88qlPH6M8ypeEepebZcx6viPwtVuwZeWjbDrMN74iW1REmhCi9iJ/HGt/vxaylHYvcwGstPhbPUPWQ8aiK7150hZpeZQvpHnzt2WmfD9PVD5UttZPijYM/stLC57CLbPs73qYltAJRdewOVWRjpsnQkrxtiR5FNHITLGjl427Ol/N1GInIfXQpjjOH1ysc1rQOHqwDfnbdvKoe2jXjvEwLbV+HzeNl4Zt5Zv7rkU4+tX9PED7C/H1T/qzqTsnDpmb5+PbQkNb3S7moIjojhUa2ffTjt+8M+Rsl1LYPN0WJ51Y40JhnL1odIZlzFjGuS9m/2elTDyVnv5qs+IwAzFQUFw3fvwQXsY1Q/unWnn7xUUjgM7F9m7OVd+B8f32bV2610LjXrauz0DLTiL4O7lyMIneY+9TNekD5Sq4rXDFAsP4eHLa/H8DyuZtm4fnerGeO1Y2aqWAKWqQeIwhbDszH4Lju2Fm78OnEte+VWsDNS63L6ddnSXDWSn55it+enP/nTB4XaE7MxLmdG1cvwDHZ6yH7661y4b1vfbghU8fK1oabhpOAzrCj/8rWD8fO5fZ4PXitF2abTgcKjdBRrdBLWutDcUiAQwhbC8mDMEMtOh3WNeP9TNLeP4ZNZmBo1fR4fa5QgO8uEv06AgOxo2+XnbZ0kL5v7p9+0w711o1Atis73ZRS6keMWsy97d7OeOY/9Anx4t27nEXu5d+JF9PCzSzin7I5g1sy8STh6m8fIXIeMEDBjvlekBhU5svJ3LOfEZ+3N62YO+r+FIEqz81gavPSvsagXVOkD7J6Fe91zfwSkSCBTCcuvY/qyRoV4+uWsnNDiIJ7rU5f6vF/P9kp30bOHjPzBNb4Wp/4ZFn2rNtjNNeREwcPkLblfiP4yxzYJLV/vz8m5mhm1TcOYdmQs+OrtVRlgkRU7ugdt/sJcxxbr0Ptg2x/6sxraCypd4/5gnDtn5fyvG2GMDVIqHroOgwfW2y7+I/IVCWG7Ne8f+AfDhbe9XNypPk9gSvDlpHd0bVyAi1IdzJoqVgfrXwbKRcPmLEFbMd8cuqLbPt6/wOzylURdvCwq2/erK1oGmWdNLM9Ls+pynL2Ue3MiquNtodOYcNLGhtsf/7PywMf3hnlneaRmSetzeEbtiNGycYq8SRNeGjs9BwxugTA3PH1PEz/i+LXthdPwgLPjYvkqPruWzwxpjeOqquuw6ksIX81xY3LvlQHvn0ooxvj92QZOZaS/xRFWANg+7XU1gCg61lyVb9INrh0D/cRyM9sEoT2FUpKRdrun4fnvXqKfWAc1Ig/UT4ds74bWa8O1Ae8nx0r/ZsHf/AujwhAKYSC5pJCw3fvsfpJ2Adr7vvn1ZjWg61C7Lu9M20qtlHCWK5PHOsYsRd4m9ey1xGLS4w3fHLYhWjrF3d103VKOCUjhUbGbXMx33OMx5K/+j+JmZsGO+HfFa9T2cPGQvBzfubSfYV25t55GKSJ4phF3IiUMw/0NocJ3tIO6Cp7rWpds7sxg6YxNPdfVhDcbYCfrjHreXfwK1f0/qCTu/pmIz+4dHpLBoeSdsmwtT/2NfVFVtm7vnOQ7sXZXVUuJbOLIDQorYHoKNboIanW0TXxG5KAphFzJ/KKQmQ/snXCuhfsXiXNe0EsNmb+GO1lUpX8KHt3U37g2TX7CjYYEawua+A0d32sasesUvhYkx9tLtnuUwZiDcOwsiy+W8/eGtdvrBijF2qSoTDDU72478da6G8MBdhFnEG/QX5XxO/g6/DYW63V2/++qxK2rjODB4io+X1owobpsprhhjz0egOboL5gy2NylUae12NSJ5Fx5l15RM+d3O5crMOPvxY/vtaP/HV8DbTexd0UVKQrc34PH1cOtoe1e4ApiIxymEnc+CD+HUEejwpNuVEFe6KH0vrcKoxB3M3nDAtwePHwDpJ2H5N749bkHw67/sXV9X/NPtSkTyr3xD22pmywyY+RrB6Sdg6Qj44gZ4ow6Mf8LOe738RXhkBQyYYC9lFot2u3IRv6bLkTkITj8Bif+D2ldlLVzsvgc61WT6un30/WQ+A9pU48mudXzTtqJiU7sWXeIwaHW3+124fWXnYts0tO2jUKqq29WIXJxmt8HWOTD9FS4LCoXMVChZGdo+YtdsVFNmEZ9TCMtBpZ3j7PB9B/fmgp2rdLEwfn6oLa+MX8uwOVuYsX4fb/VuSuPYkt4/ePwAGHu/neRbtY33j+c2x4EJz0CxstDW+yskiHidMdD9TUg7zp4jGVTq+ohdgD1QXlSJFEC6HJmdU8eITRoLNa+wI0AFSNGwEP7VoyFfDGzF8VMZXP/eXAZPWU9ahof6AOWkwQ0QXsKOhgWC1T/Ajt+g0/N2XpyIPwgrBr2/ZEPte2wnfQUwEVcphGUncRhhaUcLxFywnLSrVZaJj7Tn2iYVGTxlAze+P5eN+45574BhRW3n8tVj7URef5aWApP/D2IaQbO+blcjIiJ+SiHsXKknYO4QDpVqaofqC7ASRUN5q3dT3ru1OTsOnaDbkFkMm72FzEzHOweMHwCZabD0S+/sv6D47T27UHfXl+zyOSIiIl6gEHaufWsgI41tVXq5XUmuXd2oAhMfbU/bmtH86+fV3PrxfHb+ftLzBypbB6q0hcRPPbcMSkGTvBdmvQF1ukG19m5XIyIifkwh7FyxLeCx1Rwp6W5fsLwqFxXBx3fEM+jGRixP+p2ub81kzKIkHMfDo2Lx/eH3bbB5qmf3W1BM+w+kn4Ir/+12JSIi4ucUwrJTSNcGNMbQu2VlJjzSnnoVivP46GXc/cUiDhw75bmD1LsWikbDQj+coL97OSz+Ai65RwsQi4iI1ymE+aG40kUZcfel/OPqesxYt58ub81k4qo9ntl5SBg0vw3Wj4cjOz2zz4LAcWDis3ZhYheXqBIRkcChEOangoMMd7Wvzs8PtaV8iQju+WIRfx+1jKMpaRe/8xb9bGhZ/PnF76ugWDcOts6Cjs/aJVtERES8TCHMz9WOieL7v7XhoU41+WHpTrq+NZO5Gy9y2aNSVaHm5bD4M8jwQKhzW3oqTHoOytaFFv3drkZERAKEQlgACAsJ4rEr6zDm3tZEhAZzy8fz+edPq0hJy7jwk3MSPwCSd8P6CZ4r1C0LPoRDm6HLfyFYi0iIiIhvKIQFkGaVS/HLQ+3od1lVPp2zlW5DZrFsx+/521mtK6F4pcLfQf/4AZjxql0doeblblcjIiIBRCEswBQJC+bFaxvw5cBLOJGawQ3vz+WtyflY9ig4xM4N2zQVDm7ySq0+Mf1lSD1mR8FERER8SCEsQLWtFc2ER9rTo0lF3v51Aze8N5cNe5PztpNmt4EJhkXDvVKj1+1bY0fyWg60jWhFRER8SCEsgJUoEsqbvZvy/q3NSTp8gm7vzObjWZtzv+xR8QpQ92pY8qVtcFqYnG5JER4FCc+4XY2IiAQghTDhqqxlj9rXiuY/v6zhlo9/Y8ehE7l7cvxAOHnILuxdmGyYbC+ldngaipZ2uxoREQlACmEC2GWPPro9nldvbMzKnUe56u1ZjErcceFlj6p1gNLVC9cE/Yw0mPQPKFMTWt7pdjUiIhKgFMLkD8YYerWMY/zD7WhQsThPjlnOXZ8vYn/yeS41BgXZ3lrb58He1b4r9mIkfgoH1sOV/7ErAIiIiLhAIUz+Iq50UUbcdSnPdavHzA376TJ4JhNWnmfZo6a3QnB44RgNO3kYpr8E1ROgdle3qxERkQCmECbZCgoy3NmuOr882JaKJSO498tFPDZqKUdOZtMhv1gZaHAdLBtJxMndBXuS/oxXIeUIdHkJjHG7GhERCWC5ag9ujCkGnHQcJ9MYUxuoC4x3HMcP1qyR86mVtezRO1M38r9pG5m36SCv9WxC21rRZ28YPxCWf8Ol8++F+fdCREmIjIHIclnvz/z4jK8VLWMvafrCgQ22O37z2yGmgW+OKSIikoPcrtEyE2hnjCkFTAIWAr2BW71VmBQcocFBPHZFbTrVLcdjo5bS95P59LusKk91rUuRsGC7UeVLoN8vrJs7jjqVSsGxvVlv+2DnIvtxWjZ3XJpgKFb2wmEtspxtJ3Exo1eTnoeQItDxufzvQ0RExENyG8KM4zgnjDEDgfccx3nVGLPUm4VJwdM0riS/PNiOQRPWMnzuVmau38+bvZvSNK6k3aBqW3ZvTadOh4Tsd3Dq2J/B7Kz3Z3y8b7V9n5n+1+eHFMk5oJ31cTkICT/7uZumwfrxcPk/IbKsR8+LiIhIfuQ6hBljWmNHvgZmfS3YOyVJQXZ62aMr6sfwxOhl3Pj+XO5PqMGDnWsRGnyBy4rhkfatTI3zb5eZCSm//zWgnfnxoc32jswTB7Pfx7mXQ3cmQqmqcOl9+fq+RUREPC23IewR4Bnge8dxVhljqgPTvFeWFHRtakYz4dH2vPjjKoZM3cjUdft4s1dTz+w8KMg2UC1aGsrVO/+2GWlwfH/OYe3YPti12E7Gv27oX0fIREREXJKrEOY4zgxgBoAxJgg44DjOQ94sTAq+4hGhvNmrKVfWL8+z36+g+zuz6RQbTMP4U0RH+ijsBIdC8Yr2TUREpBDJ1W1pxpivjTHFs+6SXAmsNsY84d3SpLDo2rA8Ex9pT/dGFZi4NY12g6bx8rg1HDxWgFtViIiIuCy3vQHqO45zFLgOGA9UA27zWlVS6JSNCufN3k15qW0RujYsz0ezNtN20DReHq8wJiIikp3chrBQY0woNoT9mNUf7AKLCkogqhAZxFu9mzLp0Q50aRDDhzM30+7Vabwyfi2Hjqe6XZ6IiEiBkdsQ9gGwFSgGzDTGVAGOeqsoKfxqlotk8M3NmPxoB66oH8MHMzfRdtBUBk1QGBMREYFchjDHcYY4jlPJcZyrHWsb0NHLtYkfqFkukrdvbsbkR9tzeb0Yhs7YRLtBU3l1wloOK4yJiEgAy+3E/BLGmDeNMYlZb29gR8VEcqVmuSiG9GnGpEfa06leDO/PsCNjr01cy+8nFMZERCTw5PZy5DAgGeiV9XYU+NRbRYn/qhUTxTt9mjHxkfZ0rFuO96Zvou2gabw+cZ3CmIiIBJTcNmut4TjOjWd8/k8tWyQXo3ZMFO/e0pwH9yQzZOoG3p22keFzt9K/TVXubFudEkVD3S5RRETEq3I7EnbSGNP29CfGmDbASe+UJIGkTvko/ndLcyY+0p4OtcvyztSNtB00lTcnrePIiTS3yxMREfGa3Iawe4H/GWO2GmO2Au8C95zvCcaYYcaYfcaYlRfYrqUxJt0Y0zOXtYgfqlM+iv/d2pwJj7SjXe1ohpwOY5PXc+SkwpiIiPif3N4ducxxnCZAY6Cx4zjNgE4XeNpwoOv5NjDGBAODgEm5qUP8X93yxXnv1haMf7gdbWtFM+TXDbQdNJW3FMZERMTP5HYkDADHcY5mdc4HeOwC284EDl1glw8C3wL78lKH+L96FYrzft8WjHuoHW1qRPN2VhgbPGU9R1MUxkREpPDLUwg7h7mYAxtjKgHXA+9fzH7Ev9WvWJyht7Xgl4faclmNMgyesoG2r0zl7SkbFMZERKRQM46Tv9WHjDHbHcepfIFtqgI/O47TMJvHRgNvOI7zmzFmeNZ2Y3LYz93A3QAxMTEtRo4cma+a8+LYsWNERkZ6/Tj+xtvnbdvRDMZuTGPxvgyKhkCXqqFcWTWUIiEX9ZrAdfp5yx+dt/zRecsfnbf8CfTz1rFjx0WO48Rn99h5Q5gxJpns14g0QBHHcc7b4uICIWwLf46mRQMngLsdx/nhfPuMj493EhMTz7eJR0yfPp2EhASvH8ff+Oq8rdx5hLd/3cDk1XspUSSUO9tWo1+bqkRFFM7WFvp5yx+dt/zRecsfnbf8CfTzZozJMYSdN0Q5jhPlnZLAcZxqpz8+YyTsvAFM5LSGlUrw0e3xrNx5hMFTNvDG5PV8PHsLd7Wrxh2XFd4wJiIigSO3zVrzzBgzAkgAoo0xScALQCiA4zhDvXVcCSwNK5Xg4zviWZF0hLd/Xc/rk06HserccVlVIsO99iMuIiJyUbz2F8pxnD552Laft+qQwNAotgQf39GSFUlHGDxlPa9NXMdHszYrjImISIF1MXdHihQ4jWJL8Em/lvz4QBuaVy7FaxPX0W7QVN6bvpFjp9LdLk9EROQPCmHilxrHlmRYv5aMvb8NTeNK8uqEdVz28q+8MWkdB4+dcrs8ERER712OFCkImsSV5NP+rVi243eGztjEu9M28tGszfSOj+POdtWJK13U7RJFRCRAKYRJQGgSV5L3+7Zg0/5jfDBjE18v2M6X87dzbZOK3NuhBnXKe+1GYBERkWzpcqQElBplI3m1ZxNmPtmR/pdVZeKqPXQZPJM7P1vIom0XWmVLRETEcxTCJCBVKFGE57rXZ+7TnXj08tos2naYG9+fR6+h85i2bh/5XUlCREQktxTCJKCVLBrGw5fXYs7TnXjhmvokHT5B/08XctXbsxi7dCfpGZlulygiIn5KIUwEKBoWQv821ZjxZEdev6kJ6ZkOD49cSqc3ZvDlb9tISctwu0QREfEzCmEiZwgNDqJni1gmPdKeD29rQeliYTz3w0raDprGe9M3cjQlze0SRUTET+juSJFsBAUZrmxQnivqx/Db5kO8P2MTr05Yx/vTNtG3dRX6t6lKuagIt8sUEZFCTCFM5DyMMbSuUYbWNcqwcucRhs7YxAczNvHJ7C3c1CKWu9tXp0qZYm6XKSIihZBCmEguNaxUgndvac7WA8f5YOZmRicmMWLBdro3tr3G6lcs7naJIiJSiGhOmEgeVY0uxss3NGL2Ux25q311pq7dx9VDZtHv0wXM33xQ7S1ERCRXFMJE8qlc8Qieuaoec57uxBNd6rAi6Qi9P/yNnkPnMWX1XjIzFcZERCRnCmEiF6lEkVDu71iTOU934t89GrD3aAp3fp5I17dn8t3iJNLUa0xERLKhECbiIRGhwdzWuirTH09gcO+mGAyPjVpGwmvTGT5nCydT1WtMRET+pBAm4mEhwUFc16wSEx5px7B+8VQoEcGLP62mzaCpvPPrBo6cUK8xERHR3ZEiXmOMoVPdGDrVjWHh1kO8P30Tb0xez9AZm7jlksrc2a46McXVa0xEJFAphIn4QMuqpWnZrzRrdh/lgxmbGDZnK5/N3cYNzStxd/vqbpcnIiIuUAgT8aF6FYoz+OZmPHZFHT6atZlRiTv4JnEHjcoEkxK9h871yhEarFkCIiKBQCFMxAWVyxTl39c15KHOtfhi3lY+n7OJe79cRHRkOD1bxHJzyziqRqsTv4iIP1MIE3FR2ahwHruyDk1CdkGF+oxYsIOPZm1m6IxNtK5ehptbxdGlQXkiQoPdLlVERDxMIUykAAgOMiTUi6FzvRj2Hk1hzKIkRi7czsMjl1KiSCjXN6tEn1aVqVM+yu1SRUTEQxTCRAqYmOIR3N+xJvd1qMG8zQcZsWA7X8/fzvC5W2lWuSQ3t4yje+OKFAvXf18RkcJMv8VFCqigIEObmtG0qRnNoeOpfLc4iZELd/DUtyv410+rubZpJW5uGUfj2BIYY9wuV0RE8kghTKQQKF0sjDvbVWdg22os3n6YEQt28P2SJEYs2E69CsXp0yqOHk0rUaJIqNuliohILimEiRQixhhaVClNiyql+b9r6vPj0l2MXLid/xu7iv/+soZujSpwc6vKtKxaSqNjIiIFnEKYSCFVPCKUvpdWoe+lVVi58wgjF25n7JJdfLdkJ9XLFuPmlnHc2DyWMpHhbpcqIiLZUFdIET/QsFIJ/nNdI+b/ozOv39SE0kXDeGncWi59+Vf+9tUiZq7fT2am43aZIiJyBo2EifiRomEh9GwRS88WsWzYm8w3C3fw7eIkxq3YQ6WSRejdMo6b4mOpUKKI26WKiAQ8hTARP1UrJornutfnia51mLRqL98s3MGbk9czeMp6EuqU4+aWcXSqW44QLZMkIuIKhTARPxceEsw1TSpyTZOKbD94glGJOxiVuIO71+6jXJRdJql3yziqyE4I2gAAH5RJREFUlNEySSIivqQQJhJAKpcpyuNd6vDI5bWYtm4/3yzcztAZm3hv+iba1CxD75aV6dIghvAQLZMkIuJtCmEiASgkOIgr6sdwRf0Y9hxJYcyiHYxcuIOHRiyhVNFQbmhuFxGvFaNlkkREvEUhTCTAlS8RwQOdavG3hJrM2XSAkQt38Pm8rXwyewstqpSid3wc3RpX0DJJIiIept+qIgLYZZLa1SpLu1plOXjsFN8v2cmIBdt58tvl/POnVXRvXJFeLWNpXlmNYEVEPEEhTET+okxk+FnLJI1amMRPy3fxTeIOapQtRq/4OG5oHkvZKDWCFRHJL4UwEcnRucsk/bJ8N6MSd/Dy+LW8NnEdneqWo1d8HAl1yqrVhYhIHimEiUiuFAsPoVfLOHq1jGPjvmOMXrSDbxftZNLqvZSNCufG5rH0io+letlIt0sVESkUFMJEJM9qlovkmavq8fiVdZi2dh+jEpP4aNZmhs7YRKuqpbkpPpZujStQNEy/YkREcqLfkCKSb6HBQVzZoDxXNijPvqMpfLdkJ6MW7uCJMct58cdVXNOkIr1axtEsrqQm84uInEMhTEQ8olzxCO7tUIN72lcncdthRi3cwdiluxi5cAe1ykXSKz6O65tXIjpSk/lFREAhTEQ8zBhDy6qlaVm1NC9c24Bflu/im4U7+O+4NQyasJbO9crRu2Uc7WtpMr+IBDaFMBHxmsjwEHq3rEzvlpXZsDeZ0YuS+G5xEhNX7SWm+OnJ/HFUjda6lSISeBTCRMQnasVE8ezV9XiiSx2mrt3HqIU7/li38pJqpekVH8fVjSpQJEzrVor8f3t3Hh51ee99/P3NZLJvZN8IEEgIa4LEgCIYoFpcALucKpfHqsXjVbt5as9p7dOeero8rZdtz9Nauxx3q61UW6uguIKIWpVNwk6ILAKBJOyJbFnu548Z04ggMjL5ZZLP67pyMfObIfPJTSAf7t8990/6BpUwEelWfl8Unx6Ry6dH5NJw6Ch/W7GDx5ft4FuP13BbcDH/lef2p7wwVYv5RaRXUwkTEc/kpMTxleoh3HThYJZs2cdjy3bwZPBySaU5wcX8YwrI0GJ+EemFwrYq1szuN7NGM1tzisevNrNVZrbazP5hZuXhyiIiPZuZMa44g19+oZwl35vKzz47ioSYaH7yzHrG/2wBNz2ynJc3NtLe4byOKiJy1oRzJuxB4C7gj6d4fAtwoXNuv5ldAtwNjAtjHhGJAMlxfmZVFTGrqojahmYeW7qdJ97eybNrdpObEsfnxxbyL5WFDMjQYn4RiWxhK2HOucVmNvAjHv9Hl7tvAoXhyiIikak0J5nvXz6cb08rY8H6Bh5btp3fLarjrpfrGF+czoiEVsYcaSU13u91VBGRM2bOhW96P1jCnnbOjTzN8/4DKHPO3XCKx28EbgTIyckZO2fOnLOc9MNaWlpIStI18M6Uxi00GrePb9/RDl7f2cZrO9toOOyINijP9jE+L5ryLB8xPi3mPx19v4VG4xaavj5ukydPXu6cqzzZY56XMDObDPwOuMA5t/d0n7OystItW7bsrGU8lUWLFlFdXR321+ltNG6h0bidOeccDzy1kB2+POatqqep+RhJsdFcPCKHmRUFTBicoc1gT0Hfb6HRuIWmr4+bmZ2yhHn67kgzGw3cC1zycQqYiMj7zIziNB9fqh7O9y4bxpub9zJ3ZT3z1+ziiRU7yUiM4bLRecwoz+econ5ERWmGTER6Fs9KmJkVAU8A1zjnar3KISKRzxdlTBiSyYQhmfzoihG8srGJp2oCl0v64xvbKEiLZ3p5PjMr8inLTdb+YyLSI4SthJnZo0A1kGlmO4DbAD+Ac+4PwA+ADOB3wX8Q2041XSci8nHFRvu4eEQuF4/IpeVYGy+u281TK+u559XN/OGVdyjNSWJGeT4zygsoykjwOq6I9GHhfHfkrNM8fgNw0oX4IiJnQ1JsNJ8ZU8hnxhSyt+UY89fsZu7KnfzihVp+8UItY4rSmFGez2Wj88hOjvM6roj0MdoxX0T6hIykWK4ZP4Brxg9g54EjzKupZ+7Ken44bx0/fnod5w/OZEZFPtNG5pISpy0vRCT8VMJEpM8pSIvnyxcO5ssXDmZTQzNza+qZW1PPt/+6iu8/uYbJQ7OYWVHAlLJs4vy6oLiIhIdKmIj0aSU5yXzr4qHcclEpNTsOMndlPfNW1fP82gZteSEiYaUSJiJCYMuLiv5pVPRP+8gtL2ZWBLa80DssReSTUgkTETnBx9nyYkZFPjPKteWFiIROJUxE5COcasuLuxdv5veLtOWFiIROJUxE5GPSlhcicjaphImIhOB0W15UDkhnyrBsppRlU5KdpFOWIvIhKmEiIp/QiVtezFu1iwXrG7j92Q3c/uwGCvvFM7Usm8ll2YwvztC2FyICqISJiJxVJTnJ3HJRMrdcVMrug0d5eWMjC9Y38pdl23nojW3E+31cUJLJlLLALFlOik5bivRVKmEiImGSmxrHrKoiZlUVcbS1nTc27+XlDYFS9uK6BgBGFqQwpSyHKWXZjC5IJSpKpy1F+gqVMBGRbhDn9zF5aDaTh2bzwxmO2oYWFm5oZOGGBu5auIk7F2wiMymWyUOzmFKWzQUlmSTr8kkivZpKmIhINzMzhuYmMzQ3mZuqB7P/veMs3tTEgvWNPL92N48v34HfZ4wblMHksmymlmUzMDPR69gicpaphImIeKxfYgwzKwqYWVFAW3sHy7ftZ+HGRhaub+THTwfebVmcldi5uP/cgen4dQklkYinEiYi0oNE+6IYV5zBuOIMvnvJMN7de5iFGxpYuLGJh/6xjXte3UJyXDSTSrOYWpZN9dBs0hNjvI4tIiFQCRMR6cGKMhK4bsIgrpswiPeOtfFa3Z7A4v4NjTyzahdmMKZ/GlOHBRb36zJKIpFDJUxEJEIkxkbz6RG5fHpELh0djrX1hzoX9//8+Y38/PmN5KXGMaUsm6nDsjmvOJP4GO1JJtJTqYSJiESgqChjVGEqowpTuflTJTQ2H2XRhiYWbmjkybd38qe33iU2OooJQ/65J1l+WrzXsUWkC5UwEZFeIDs5ji+c258vnNufY23tLNmyjwXrG4MzZY0AlOUmM3VYNiV0eJxWREAlTESk14mN9jGxJIuJJVncNn047zS9F1jcv6GRP7yymZx4mHTBcS3oF/GY3uMsItKLmRlDspO4cdJg5tx4Hn++YRxNRxzX3r+E5qOtXscT6dNUwkRE+pBxxRl8tSKW9bsOccNDyzja2u51JJE+SyVMRKSPqciO5pdfKGfJ1n187c8raG3XGjERL6iEiYj0QTMrCvjRzJG8tL6Rb/91FR0dzutIIn2OFuaLiPRR14wfwKEjrfz8+Y2kxEXz3zNGaKNXkW6kEiYi0od9pXowBw4f555Xt5Aa7+eWi4d6HUmkz1AJExHpw8yM/3PpMA4daePOhXWkxPu5YWKx17FE+gSVMBGRPs7M+OlnR9F8rJWfPLOelHg/X6js73UskV5PJUxERPBFGf/vygqajy7j1r+tIiXOz7SRuV7HEunV9O5IEREBAjvt/+81Y6non8Y3Hn2b1zbt8TqSSK+mEiYiIp0SYqJ54LoqirMSufHhZax4d7/XkUR6LZUwERH5gNQEP3+cXUVWcizXP7CUjbubvY4k0iuphImIyIdkJ8fxyOxxxPmjuOa+t3h372GvI4n0OiphIiJyUv3TE3h49jiOt3dw9X1v0nDoqNeRRHoVlTARETml0pxkHry+in0tx/nifUs4cPi415FEeg2VMBER+UgV/dO454uVbNn7Htc9sJT3jrV5HUmkV1AJExGR0zp/SCZ3zRrD6p0HufHhZRxra/c6kkjEUwkTEZGP5eIRudzxudG8XreXbzz6Nm3tHV5HEoloKmEiIvKxfW5sIbdNH87zaxu49YnVdHQ4ryOJRCxdtkhERM7I9RMGcfBIK796aROp8X6+f9kwzMzrWCIRRyVMRETO2M1TSzhwuJX7XttCaryfb0wt8TqSSMRRCRMRkTNmZvzg8uEcOtrK/7xYS2q8n2vPH+h1LJGIohImIiIhiYoy7vjcaJqPtnHb3LWkxEfzmTGFXscSiRhamC8iIiGL9kXxm1ljOH9wBv/x+CpeWtfgdSSRiKESJiIin0ic38fdX6xkZH4KX/nzCt54Z6/XkUQigkqYiIh8Ykmx0Tx4fRUD0hO44aGlrNpxwOtIIj1e2EqYmd1vZo1mtuYUj5uZ3WlmdWa2yszOCVcWEREJv36JMTw8exz9EmO49v4l1DU2ex1JpEcL50zYg8C0j3j8EqAk+HEj8PswZhERkW6QmxrHI7PH4YuK4l/vXcL2fYe9jiTSY4WthDnnFgP7PuIpM4E/uoA3gTQzywtXHhER6R4DMxN5eHYVh4+3cc19b9HUfMzrSCI9kjkXvktOmNlA4Gnn3MiTPPY0cLtz7rXg/QXAd5xzy07y3BsJzJaRk5Mzds6cOWHL/L6WlhaSkpLC/jq9jcYtNBq30GjcQtNd41a3v507lh0lJyGKW6viSPRH9q76+n4LTV8ft8mTJy93zlWe7LGI2CfMOXc3cDdAZWWlq66uDvtrLlq0iO54nd5G4xYajVtoNG6h6a5xqwaGjmziSw8u5f66WB6eXUVCTET82Dkpfb+FRuN2al6+O3In0L/L/cLgMRER6SUmlmTx66vG8Pa7+/nyIys43tbhdSSRHsPLEjYX+GLwXZLjgYPOuV0e5hERkTC4dFQeP/vsKBbXNvHNv6ykvSN8y2BEIknY5oXN7FECs9GZZrYDuA3wAzjn/gDMBy4F6oDDwPXhyiIiIt668twiDh1p4//OX09KfDQ//cwozCJ7jZjIJxW2Euacm3Waxx3w1XC9voiI9Cz/NqmYg0dauevlOlLi/Xz3kmFeRxLxVOSukBQRkYjzrYtLOXiklf99ZTOp8X6+Uj3E60ginlEJExGRbmNm/HDGCA4dbeWO5zaSGu/n6nEDvI4l4gmVMBER6VZRUcYv/qWc5qNtfP/JNSTH+ZlRnu91LJFupwt4i4hIt/P7ovjd1edw7sB0bvnLSl7e0Oh1JJFupxImIiKeiPP7uPfaSsrykrnpT8tZsuWjrnQn0vuohImIiGdS4vw8dH0V+WnxzH5wKU+t3Mnh421exxLpFiphIiLiqYykWB6ZPY6s5FhunrOSsT9+ia8/+jYvrmvgWFu71/FEwkYL80VExHP5afG8dMuFLNm6j3k19cxfvYt5NfWkxEUzbWQu08vzOa84g2if5g6k91AJExGRHiEqyhhfnMH44gz+e8YIXq/bw9yaeuav3s1jy3aQmRTDpaPymFGezzlF/YiK0o77EtlUwkREpMfx+6KoHppN9dBsjra2s2hjI/NqdvGXpdv54xvbyE+N4/LyfGaU5zMiP0WXQJKIpBImIiI9Wpzfx7SReUwbmUfLsTZeWtfAvJp67n9tC3cv3kxxZmKwkOUxJDvZ67giH5tKmIiIRIyk2GiuGFPAFWMKOHD4OM+t2c3cmnp+s3ATdy7YxLC8FKaX5zF9dD790xO8jivykVTCREQkIqUlxHBVVRFXVRXReOgozwQX89/x3EbueG4jY4rSmD46n8tH55GdEud1XJEPUQkTEZGIl50Sx/UTBnH9hEFs33eYp1ftYm5NPT96eh0/fmYd4wdlMKMin2kjcumXGON1XBFAJUxERHqZ/ukJ3FQ9mJuqB1PX2MzcmsAM2XefWM1/PbmGSaVZTC/P46LhuSTF6segeEfffSIi0msNyU7mlouS+eanSlhbf4h5NfXMq6ln4YZGYqNXM3VYNtNH5zO5LJs4v8/ruNLHqISJiEivZ2aMLEhlZEEq35lWxop39zOvpp5nVu9i/urdJMVGc/HwHKZX5HPBkEz82hRWuoFKmIiI9ClRUUblwHQqB6bzX5cP583N+5hbs5Pn1uzmibd30i/BzyWjAu+wrBqUjk+bwkqYqISJiEifFe2L4oKSTC4oyeTHV4xkce0e5tXU8/cVO/nzW++SkxLLZaPymV6eh3PO67jSy6iEiYiIALHRPi4ansNFw3M4fLyNBesbmVtTzyNvbuP+17eQGmtMbVrJhaVZTBiSSWZSrNeRJcKphImIiJwgISaa6eX5TC/P5+CRVl5c18Djr67h5Q2NPLFiJwAj8lOYVJrFxJJMxg7oR2y0FvbLmVEJExER+Qip8X4+P7aQzOY6Jk66kLX1B1lc28TiTXu4Z/Fmfr/oHRJifIwvzmBiSSYTS7IYnJWo61nKaamEiYiIfEy+KGN0YRqjC9P42pQSWo618cY7e3l1UxOvbtrDwg2NABSkxXcWsglDMkhL0Aax8mEqYSIiIiFKio3uXEcGsH3fYRZvauLV2j08s3oXc5ZuJ8pgdGEak0oymVSaRXn/NG2BIYBKmIiIyFnTPz2Bq8cN4OpxA2hr76BmxwEW1+5h8aYm7nq5jjsX1pEcG815gzOYVJrFpJIsijJ0ofG+SiVMREQkDKJ9UYwdkM7YAel886JSDh5u5R/vBArZ4to9vLCuAYABGQlMKgks8D9vcAbJcX6Pk0t3UQkTERHpBqnBTWAvGRXYc2zLnvdYXBtYS/a3FTt4+M1tREcZ5xT1C6wnK81iVEGqNovtxVTCREREupmZUZyVRHFWEtdNGMTxtg6Wb9vfucD/ly/W8ssXa0lL8DNhSCaTgov889PivY4uZ5FKmIiIiMdioqM4b3AG5w3O4NvTYG/LMV6r28Orm/bw6qYmnlm1C4Ah2UlMDC7wHzconYQY/RiPZPrTExER6WEykmKZWVHAzIoCnHPUNrTw6qYmXqlt4s9vvcsDr28lxhdF5cB+TCrN4vzBGQzPSyFa77qMKCphIiIiPZiZMTQ3maG5ydwwsZijre0s3bqvcz3Z7c9uACAxxsfYgemMG5TOuQPTGV2YSpxfu/j3ZCphIiIiESTO72NiSRYTS7IAaDx0lLe27GNJ8OPnz28EAqc4K/qnMW5QOlWD0jmnqB+Jsfqx35PoT0NERCSCZafEdV7nEmD/e8dZujVYyrbu47cv1/GbhYHd/kcWpAZK2cDAbFlqgrbD8JJKmIiISC/SLzGGi0fkcvGIXABajrWxYtv+zpmyB1/fyt2LN2MGQ3OSgzNlGZw7qB/ZyXEep+9bVMJERER6saTY6MDu/KWB05dHW9up2X6gc6bs8eU7eOiNbQAUZyZSFTx9WTUoncJ+2s0/nFTCRERE+pA4v49xxRmMK84AoLW9g7X1h1iyZS9LtuxjfvCalwD5qXHBQpZB1aB0BmclYqbNY88WlTAREZE+zO8LLOCv6J/GjZMG09Hh2NjQ3Hn68rW6vTy5sh6AjMSYD8yUleWmaEf/T0AlTERERDpFRRnD8lIYlpfCtecP7LzE0tKt+zrfhfnsmt0AJMdFc+7Af5ayUQWp+LVX2cemEiYiIiKn1PUSS1eeWwTAzgNHWLrl/VK2l4UbGgGI9/s4Z0AaVQMDpy/HFKV5Gb3HUwkTERGRM1KQFk/BmAKuGFMAwJ6WY11K2T5+taAW58DvM/ITjXMaVlKak8zQ3CRKspMpSIsnSqcxVcJERETkk8lMiuWSUXlcMioPgINHWlm+bR9Ltuzn9bVbeXPzXv7+9s7O5yfG+CjJSWZoTjIlOUmBKwLkJJOVHNunFv6rhImIiMhZlRrvZ0pZDlPKclgUv5vq6moOHmmlrrGZjbtbqG1oZuPuZhZsaOAvy7Z/4PcNzUmmNDcpWNAC5axfYoyHX034qISJiIhI2KXG+xk7IJ2xA9I/cHxPyzFqG5qp3d1MbWMLtbubeWplPc1H2zqfk5Uc+89Zs5xkSnOTKclOIjkusnf8VwkTERERz2QmxZKZFMv5gzM7jznn2H3oKLUNgVK2saGZ2oZm5izZzpHW9s7nFaTFU5qTRGluMqXZgYucD8lOipgLl6uEiYiISI9iZuSlxpOXGs+FwZ3+ATo6HDv2H+ksZe+f1ny9bi/H2zuCvxcGpCcE3wiQTGlO4GNQZiIx0T1r+wyVMBEREYkIUVFGUUYCRRkJXDQ8p/N4W3sHW/ce7ixl7xe0BRsaae9wAERHGcVZiZ3rzEpzkhlZkOLppZlUwkRERCSiRfuiGJKdxJDsJC4NvkMTAtfJ3Nz0Xmcpq21oZtWOAzyzahcAs6qK+NlnR3kVO7wlzMymAb8GfMC9zrnbT3i8CHgISAs+51bn3PxwZhIREZG+Ic7vY3h+CsPzUz5w/L1jbdQ1tpAQ4+3asbCVMDPzAb8FLgJ2AEvNbK5zbl2Xp30feMw593szGw7MBwaGK5OIiIhIYmw05f29380/nCvUqoA659xm59xxYA4w84TnOOD9epoK1Icxj4iIiEiPYc658Hxis88D05xzNwTvXwOMc859rctz8oAXgH5AIvAp59zyk3yuG4EbAXJycsbOmTMnLJm7amlpISkpKeyv09to3EKjcQuNxi00GrfQaNxC09fHbfLkycudc5Une8zrhfmzgAedc780s/OAh81spHOuo+uTnHN3A3cDVFZWuurq6rAHW7RoEd3xOr2Nxi00GrfQaNxCo3ELjcYtNBq3Uwvn6cidQP8u9wuDx7qaDTwG4Jx7A4gDMhERERHp5cJZwpYCJWY2yMxigKuAuSc8511gKoCZDSNQwprCmElERESkRwhbCXPOtQFfA54H1hN4F+RaM/uRmc0IPu1bwL+ZWQ3wKHCdC9ciNREREZEeJKxrwoJ7fs0/4dgPutxeB0wIZwYRERGRnqhnXURJREREpI9QCRMRERHxgEqYiIiIiAdUwkREREQ8oBImIiIi4gGVMBEREREPqISJiIiIeEAlTERERMQDFmkb1JtZE7CtG14qE9jTDa/T22jcQqNxC43GLTQat9Bo3ELT18dtgHMu62QPRFwJ6y5mtsw5V+l1jkijcQuNxi00GrfQaNxCo3ELjcbt1HQ6UkRERMQDKmEiIiIiHlAJO7W7vQ4QoTRuodG4hUbjFhqNW2g0bqHRuJ2C1oSJiIiIeEAzYSIiIiIeUAkTERER8YBK2AnMbJqZbTSzOjO71es8kcDM+pvZy2a2zszWmtnNXmeKJGbmM7O3zexpr7NECjNLM7O/mtkGM1tvZud5nSkSmNk3g39H15jZo2YW53WmnsrM7jezRjNb0+VYupm9aGabgr/28zJjT3SKcft58O/qKjP7u5mleZmxJ1EJ68LMfMBvgUuA4cAsMxvubaqI0AZ8yzk3HBgPfFXjdkZuBtZ7HSLC/Bp4zjlXBpSj8TstMysAvgFUOudGAj7gKm9T9WgPAtNOOHYrsMA5VwIsCN6XD3qQD4/bi8BI59xooBb4bneH6qlUwj6oCqhzzm12zh0H5gAzPc7U4znndjnnVgRvNxP4gVjgbarIYGaFwGXAvV5niRRmlgpMAu4DcM4dd84d8DZVxIgG4s0sGkgA6j3O02M55xYD+044PBN4KHj7IeCKbg0VAU42bs65F5xzbcG7bwKF3R6sh1IJ+6ACYHuX+ztQmTgjZjYQGAO85W2SiPEr4NtAh9dBIsggoAl4IHga914zS/Q6VE/nnNsJ/AJ4F9gFHHTOveBtqoiT45zbFby9G8jxMkyE+hLwrNchegqVMDlrzCwJ+Bvw7865Q17n6enM7HKg0Tm33OssESYaOAf4vXNuDPAeOi10WsH1SzMJlNh8INHM/tXbVJHLBfZ30h5PZ8DMvkdg+cqfvM7SU6iEfdBOoH+X+4XBY3IaZuYnUMD+5Jx7wus8EWICMMPMthI49T3FzB7xNlJE2AHscM69P9v6VwKlTD7ap4Atzrkm51wr8ARwvseZIk2DmeUBBH9t9DhPxDCz64DLgaudNijtpBL2QUuBEjMbZGYxBBatzvU4U49nZkZgfc5659z/eJ0nUjjnvuucK3TODSTwvbbQOaeZidNwzu0GtpvZ0OChqcA6DyNFineB8WaWEPw7OxW9oeFMzQWuDd6+FnjKwywRw8ymEVh2McM5d9jrPD2JSlgXwYWDXwOeJ/CP02POubXepooIE4BrCMzkrAx+XOp1KOnVvg78ycxWARXATz3O0+MFZw7/CqwAVhP491+XkzkFM3sUeAMYamY7zGw2cDtwkZltIjCzeLuXGXuiU4zbXUAy8GLw58MfPA3Zg+iyRSIiIiIe0EyYiIiIiAdUwkREREQ8oBImIiIi4gGVMBEREREPqISJiIiIeEAlTER6FTNr77JVykozO2u76ZvZQDNbc7Y+n4j0bdFeBxAROcuOOOcqvA4hInI6mgkTkT7BzLaa2R1mttrMlpjZkODxgWa20MxWmdkCMysKHs8xs7+bWU3w4/1L/PjM7B4zW2tmL5hZvGdflIhENJUwEelt4k84HXlll8cOOudGEdjB+1fBY78BHnLOjSZwYeE7g8fvBF5xzpUTuDbl+1fPKAF+65wbARwAPhfmr0dEeintmC8ivYqZtTjnkk5yfCswxTm3OXjB+d3OuQwz2wPkOedag8d3OecyzawJKHTOHevyOQYCLzrnSoL3vwP4nXM/Cf9XJiK9jWbCRKQvcae4fSaOdbndjtbWikiIVMJEpC+5ssuvbwRv/wO4Knj7auDV4O0FwE0AZuYzs9TuCikifYP+BycivU28ma3scv8559z721T0M7NVBGazZgWPfR14wMz+E2gCrg8evxm428xmE5jxugnYFfb0ItJnaE2YiPQJwTVhlc65PV5nEREBnY4UERER8YRmwkREREQ8oJkwEREREQ+ohImIiIh4QCVMRERExAMqYSIiIiIeUAkTERER8cD/B9fpVdChtWfCAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmcAAAG5CAYAAADLbpPTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xV9f3H8dc3G7IgjIQM9t6BCC40cQEOhiIFFLHWOiraaq0/tXXUXeuuo1K1biIOFJUhCAFxlA2yEsJOGIEAIQGybr6/P85FYgwSQm7uTfJ+Ph7nQe6959z7uaeUvP1OY61FRERERHyDn7cLEBEREZFjFM5EREREfIjCmYiIiIgPUTgTERER8SEKZyIiIiI+ROFMRERExIconIlIg2SMGWSMSfd2HSIiFRmtcyYitc0YswW43lo7x9u1iIj4GrWciUi9ZIzx93YNp6o+fAcROXkKZyLiM4wxfsaYu40xG40xucaYKcaYqHKvf2iM2WWMyTPGLDDG9Cj32pvGmFeMMdONMYeAFGPMFmPMncaYVe5rPjDGhLjPTzbGZJW7/rjnul+/yxiz0xizwxhzvTHGGmM6Hud7RBlj/us+d78x5lP389caYxZWOPen96nkO9zp/r7+5c4faYxZVZX7JSJ1k8KZiPiSW4ERwLlALLAfeKnc6zOATkBLYBnwXoXrxwGPAuHA0RA0GhgCtAN6A9f+yudXeq4xZghwB3AB0BFIPsH3eAdoDPRw1/rsCc4/3nd4HjgEnFfh9ffdP5/ofolIHaRwJiK+5Cbgr9baLGttEfAgMMoYEwBgrX3DWptf7rU+xpjIctd/Zq391lpbZq0tdD/3grV2h7V2H/A50PdXPv94544G/mutXWOtPez+7EoZY1oBQ4GbrLX7rbUl1tr5J3EPKn6HycBY93uHAxe7n4MT3C8RqZsUzkTEl7QBphpjDhhjDgDrABcQbYzxN8Y84e7COwhscV/TvNz12yt5z13lfj4MhP3K5x/v3NgK713Z5xyVAOyz1u7/lXN+TcX3fh+43BgTDFwOLLPWbnW/dtz7Vc3PFhEfoHAmIr5kOzDUWtuk3BFirc3G6c4bjtO1GAm0dV9jyl3vqennO4H4co8TfuXc7UCUMaZJJa8dwunuBMAYE1PJOT/7DtbatcBWnNa48l2aRz/rePdLROoohTMR8ZZAY0xIuSMA+DfwqDGmDYAxpoUxZrj7/HCgCMjFCTiP1WKtU4DfGmO6GWMaA/cd70Rr7U6csXEvG2OaGmMCjTHnuF9eCfQwxvR1TzZ4sIqf/z7wR+Ac4MNyz//a/RKROkrhTES8ZTpwpNzxIM4A+GnAV8aYfOAHYKD7/LdxWpCygbXu12qFtXYG8AIwD8gs99lFx7lkPFACrAdygD+53ycDeAiYA2zg2KSFE5mMM+h/rrV2b7nnf+1+iUgdpUVoRUROkjGmG7AaCLbWlnq7HhGpX9RyJiJSBe71xYKNMU2BfwCfK5iJiCconImIVM2NOF2UG3FmRN7s3XJEpL5St6aIiIiID1HLmYiIiIgPqTerSDdv3ty2bdvW459z6NAhQkNDPf459Y3uW/XovlWP7lv16L5Vj+5b9TT0+7Z06dK91toWlb1Wb8JZ27ZtWbJkicc/Jy0tjeTkZI9/Tn2j+1Y9um/Vo/tWPbpv1aP7Vj0N/b4ZY7Ye7zV1a4qIiIj4EIUzERERER+icCYiIiLiQ+rNmLPKlJSUkJWVRWFhYY29Z2RkJOvWraux96spISEhxMfHExgY6O1SRERE5BTU63CWlZVFeHg4bdu2xRhTI++Zn59PeHh4jbxXTbHWkpubS1ZWFu3atfN2OSIiInIK6nW3ZmFhIc2aNauxYOarjDE0a9asRlsIRURExDvqdTgD6n0wO6qhfE8REZH6rt6HMxEREZG6ROHMg3Jzc+nbty99+/YlJiaGuLi4nx4XFxf/6rVLlizhtttuq6VKRURExFfU6wkB3tasWTNWrFgBwIMPPkhYWBh33nnnT6+XlpYSEFD5/wRJSUkkJSXVSp0iIiLiO9RyVsuuvfZabrrpJgYOHMhdd93FokWLOOOMM0hMTOTMM88kPT0dcLa1uPTSSwEn2F133XUkJyfTvn17XnjhBW9+BREREfGgBtNy9vfP17B2x8FTfh+Xy4W/vz8A3WMjeOCyHif9HllZWXz33Xf4+/tz8OBBvvnmGwICApgzZw733nsvH3/88S+uWb9+PfPmzSM/P58uXbpw8803a00zERGReqjBhDNfcuWVV/4U8PLy8pgwYQIbNmzAGENJSUml11xyySUEBwcTHBxMy5Yt2b17N/Hx8bVZtoiIiNSCBhPOqtPCVZmaWIQ2NDT0p5/vu+8+UlJSmDp1Klu2bCE5ObnSa4KDg3/62d/fn9LS0lOqQURERHyTR8ecGWOGGGPSjTGZxpi7K3n9WWPMCveRYYw5UO61CcaYDe5jgifr9Ka8vDzi4uIAePPNN71bjIiISAO3/1Ax6bvyvVqDx1rOjDH+wEvAhUAWsNgYM81au/boOdba28udfyuQ6P45CngASAIssNR97X5P1estd911FxMmTOCRRx7hkksu8XY5IiIiDUZBUSk/ZuXxY/YBVmblsSrrANv3HaFjyzDm3HGu1+ryZLfmACDTWrsJwBiTCgwH1h7n/LE4gQxgMDDbWrvPfe1sYAgw2YP1etSDDz5Y6fNnnHEGGRkZPz1+5JFHAEhOTv6pi7PitatXr/ZEiSIiIvVWYYmLNTsO8mPWAVZl5bEqO4+Newqw1nk9rkkj+iREctXANvSJb+LVWo09WlVNv7Exo4Ah1trr3Y/HAwOttRMrObcN8AMQb611GWPuBEKstY+4X78POGKtfarCdTcANwBER0f3T01N/dn7RkZG0rFjxxr9XuVna/qazMxM8vLyvF1GpQoKCggLC/N2GXWO7lv16L5Vj+5b9ei+VY8n71tpmSW7oIzNeWVsyitjS14Z2QVluNyRJzLY0C7Cj3aRztE20p+IoNrdBjElJWWptbbSBU19ZULAGOAja63rZC6y1k4CJgEkJSXZioPp161bd8qD9yuqiQkBnhISEkJiYqK3y6hUWlracSc7yPHpvlWP7lv16L5Vj+5b9dTUfXOVWTbtKWBlVh4/Zjndk2t3HqS4tAyAyEaB9I6PYlh8E3rFR9InvgnREcE+vSe1J8NZNpBQ7nG8+7nKjAFuqXBtcoVr02qwNhEREaljrLVs23f4Z0FsTXYeh4qdtp3QIH96xkUy4Yw29I5vQp/4JiRENfLpIFYZT4azxUAnY0w7nLA1BhhX8SRjTFegKfB9uadnAY8ZY5q6H18E3OPBWkVERMSHWGvZdbCQldudAfursvJYlZVH3hFnPdCgAD96xEYwqn88veOb0Ds+kvYtwvD3q1tBrDIeC2fW2lJjzEScoOUPvGGtXWOMeQhYYq2d5j51DJBqyw1+s9buM8Y8jBPwAB46OjlARERE6p/cgiJWZeexarsza3JVdh578osA8PczdIkO5+JeMfSOb0KvuEi6xIQT6F8/d6H06Jgza+10YHqF5+6v8PjB41z7BvCGx4oTERERrzhUVMraXBfr0jY6y1hszyP7wBEAjIEOLcIY1Kk5fdzjxLq3iiAk0Dcn43mCr0wIqLdSUlK4++67GTx48E/PPffcc6Snp/PKK6/84vzk5GSeeuopkpIqncAhIiJS51hr2ZBTQFp6Dmnpe1i8ZR8lLgusp3VUYxJbN2HCmc44sZ5xkYQFN+x40rC/fS0YO3YsqampPwtnqampPPnkk16sSkRExLMOFZXybeZe0jL2MD99z08tY12iw7nurHaEHcrm6ovPoWlokJcr9T0KZx42atQo/va3v1FcXExQUBBbtmxhx44dTJ48mTvuuIMjR44watQo/v73v3u7VBERkWo7XutYaJA/Z3VszsTzOnJu5xbENmkEQFrabgWz42g44WzG3bDrx1N+m0auUvB337aYXjD0iV89PyoqigEDBjBjxgyGDx9Oamoqo0eP5t577yUqKgqXy8X555/PqlWr6N279ynXJyIiUlsKikr5LnMv89L3sCDjl61j53ZpQVKbKIIC6ufAfU9pOOHMi452bR4NZ6+//jpTpkxh0qRJlJaWsnPnTtauXatwJiIiPu14rWNhwQGc1bHZL1rHpHoaTjg7QQtXVR2pxg4Bw4cP5/bbb2fZsmUcPnyYqKgonnrqKRYvXkzTpk259tprKSwsrJH6REREalLB0bFj6XuYn57Djjzn95Vaxzyn4YQzLwoLCyMlJYXrrruOsWPHcvDgQUJDQ4mMjGT37t3MmDFDW3+IiIhPONo6Nm+90zq2ZOvPW8duPb+TWsc8TOGslowdO5aRI0eSmppK165dSUxMpGvXriQkJHDWWWd5uzwREWnAfrV17Ox2JHduSf82TdU6VksUzmrJiBEjKLcJAm+++Wal56WlpdVOQSIi0mBZa8nYfWzsmFrHfIvCmYiISANQUFTKwg17mZ+Rw/z0PT+1jnWNUeuYr1E4ExERqYeq0jqW3KUFrSLVOuZr6n04s9ZiTN3fof5EyneZiohIw1RWZlm2bT8zV+9i5ppdZO131h1T61jdUq/DWUhICLm5uTRr1qxeBzRrLbm5uYSEhHi7FBERqWUlrjL+t2kfM1bv5Ku1u9mTX0SQvx9nd2rOLSkd1TpWB9XrcBYfH09WVhZ79uypsfcsLCz0yRAUEhJCfHy8t8sQEZFaUFjiYuGGvcxYvYs563aTd6SERoH+pHRtweAeMZzXtSXhIYHeLlOqqV6Hs8DAQNq1a1ej75mWlkZiYmKNvqeIiMiJFBSVkpaew4zVu0hbn8OhYhfhIQFc2C2awT1jOLdzC0IC/b1dptSAeh3ORERE6rIDh4uZvXY3s9bsYsGGvRSXltE8LIhhfeMY0jOGM9o30/ixekjhTERExIfk5Bcya81uZq3exfebcnGVWWIjQ7hqYGuG9IghqW0U/n71dxy1KJyJiIh43fZ9h5m1ZhczV+9i6bb9WAvtmodywzntGdIjht7xkfV6Ypv8nMKZiIiIF2TmFDBz9U5mrtnF6uyDAHRrFcGfzu/MkJ4xdI4OUyBroBTOREREaoG1ljU7Dv60BllmTgEAia2bcM/QrgzpGUObZqFerlJ8gcKZiIiIh1S2KKyfgYHtmjH+9DYM7hFDTKTvLc8k3qVwJiIiUoOOLgo7c81OZq1xFoUN9Dec3bE5t57XkQu6RdMsLNjbZYoPUzgTERE5RUcXhZ25xlkU9sBhZ1HY5C4tGNIzhpSuLYnQorBSRQpnIiIi1VDiKmPu+hxeX1HILXNn/7Qo7AXdohncw1kUtlGQFoWVk6dwJiIichK25h4idfF2PlqaxZ78IsKDYFjfBAb3iOHMDs21KKycMoUzERGREygscTFrzS5SF23n+025+Bk4r2tLxpzWGrNrLeef19vbJUo9onAmIiJyHBt25zN50XY+WZ7FgcMlxDdtxJ8v7MyVSQk/zbJMy1nn5SqlvlE4ExERKedwcSlfrtpJ6uLtLN26n0B/w0XdYxgzIIGzOjTHT1sniYcpnImIiACrs/OYvGgb01bsIL+olPbNQ7n34q5c3i+e5lr6QmqRwpmIiDRY+YUlfLZiB6mLt7E6+yDBAX5c3KsVY05LYEC7KG2fJF6hcCYiIg2KtZZl2w6QumgbX6zayZESF11jwvn7sB6M6BtHZGOtRybepXAmIiINwv5DxXyyPJsPFm8jY3cBjYP8Gd43ljEDWtMnPlKtZOIzFM5ERKTestby/aZcUhdtZ+aaXRSXltEnoQlPXN6LS/vEEhasX4Pie/S3UkRE6p2c/EI+Xuq0km3JPUxESABjT0tgzIDWdGsV4e3yRH6VwpmIiNQLrjLLgg17SF20ja/X5VBaZhnQNorbzu/Exb1aERKorZSkblA4ExGROm3HgSNMWbKdD5dkkX3gCFGhQVx3djtGJyXQsWWYt8sTOWkKZyIiUucc3XQ8ddE25mfsoczCoE7NuffiblzYPVr7W0qdpnAmIiJ1RsVNx6MjgrklpSOjkxJIiGrs7fJEaoRHw5kxZgjwPOAPvGatfaKSc0YDDwIWWGmtHed+3gX86D5tm7V2mCdrFRER31RU6mLWmt2kLtrGdxt/vul4cpcWBPirlUzqF4+FM2OMP/AScCGQBSw2xkyz1q4td04n4B7gLGvtfmNMy3JvccRa29dT9YmIiO8rLi1jzKQfWL7tQKWbjovUR55sORsAZFprNwEYY1KB4cDacuf8HnjJWrsfwFqb48F6RESkjnl8xjqWbzvAk6N6M6pfvDYdlwbBWGs988bGjAKGWGuvdz8eDwy01k4sd86nQAZwFk7X54PW2pnu10qBFUAp8IS19tNKPuMG4AaA6Ojo/qmpqR75LuUVFBQQFqbZPydL9616dN+qR/etenztvi3dXcq/lhdxYZsArurmuxuP+9p9qysa+n1LSUlZaq1Nquw1b08ICAA6AclAPLDAGNPLWnsAaGOtzTbGtAfmGmN+tNZuLH+xtXYSMAkgKSnJJicne7zgtLQ0auNz6hvdt+rRfase3bfq8aX7tn3fYW574Rt6xUXy4u/PIDjAd9co86X7Vpfovh2fJ0dRZgMJ5R7Hu58rLwuYZq0tsdZuxmlF6wRgrc12/7kJSAMSPViriIj4iOLSMm6dvBxr4aVx/Xw6mIl4gifD2WKgkzGmnTEmCBgDTKtwzqc4rWYYY5oDnYFNxpimxpjgcs+fxc/HqomISD315Mz1rNjujDNr3UzLY0jD47FuTWttqTFmIjALZzzZG9baNcaYh4Al1tpp7tcuMsasBVzAX6y1ucaYM4FXjTFlOAHyifKzPEVEpH6as3Y3ry3czDVntGFor1beLkfEKzw65sxaOx2YXuG5+8v9bIE73Ef5c74DenmyNhER8S3ZB47w5w9X0iM2gnsv7ubtckS8Riv3iYiI15W4yrj1/WW4yiwvjeunTcqlQfP2bE0RERGe+iqdZdsO8K+xibRtHurtckS8Si1nIiLiVXPX7+bV+Zu4amBrLusT6+1yRLxO4UxERLxmZ94R/jxlJd1aRXDfpd29XY6IT1A4ExERryh1lXHb5OUUl5bx0rhEjTMTcdOYMxER8YpnZmeweMt+nh/Tl/YtGu42PiIVqeVMRERqXVp6Di+nbWTsgASG943zdjkiPkXhTEREatWuvELumLKSrjHhPHBZD2+XI+JzFM5ERKTWlLrKuC11OYUlLl7UemYildKYMxERqTXPf72BRZv38czoPnRsqXFmIpVRy5mIiNSKbzbs4cV5mYxOiufyfvHeLkfEZymciYiIx+UcLORPqSvo1DKMvw/r6e1yRHyaujVFRMSjXGWWP6au4HCxi9Rx/WgUpHFmIr9G4UxERDzqha838P2mXP45qjedosO9XY6Iz1O3poiIeMx3mXt5Ye4GrugXz5VJCd4uR6ROUDgTERGPyMkv5LbUFXRoEcbDI7SemUhVqVtTRERqnKvMcvsHKygoKuG96wfSOEi/bkSqSv9vERGRGvfSvEy+zczlH1f0okuMxpmJnAx1a4qISI36fmMuz83JYETfWEZrnJnISVM4ExGRGrO3oIg/pi6nbfNQHh3ZC2OMt0sSqXMUzkREpEaUuceZ5R0p4aVx/QgN1sgZkepQOBMRkRrxyvyNfLNhLw9c1oNurSK8XY5InaVwJiIip2zR5n08/VU6l/WJZewAjTMTORUKZyIickpyC4q4bfJy2jQL5bGRPTXOTOQUaUCAiIhUW1mZ5Y4pK9l3uJip155JeEigt0sSqfPUciYiItX26oJNzM/Yw32XdqdHbKS3yxGpFxTORESkWpZs2cdTX6VzSa9WXD2wtbfLEak3FM5EROSk7T9UzK2TlxPXpBGPX6H1zERqksaciYjISSkrs/z5w5XkFhTz8c1nEqFxZiI1Si1nIiJyUl5buIm563P46yXd6BWvcWYiNU3hTEREqmzZtv08OTOdIT1iuOaMNt4uR6ReUjgTEZEqOXC4mFvfX06rJiH8Y1RvjTMT8RCNORMRkROy1nLnh6vIyS/ko5vOJLKRxpmJeIpazkRE5IReX7iZOet2c8/QbvRJaOLtckTqNYUzERH5VSu2H+AfM9dzUfdofntWW2+XI1LvKZyJiMhx5R0pYeL7y2gZHsI/R/XRODORWqAxZyIiUilrLXd9tJJdeYV8eNMZRDbWODOR2qCWMxERqdSb321h1prd3D20K4mtm3q7HJEGw6PhzBgzxBiTbozJNMbcfZxzRhtj1hpj1hhj3i/3/ARjzAb3McGTdYqIyM+tyjrAY9PXcUG3lvzu7HbeLkekQfFYt6Yxxh94CbgQyAIWG2OmWWvXljunE3APcJa1dr8xpqX7+SjgASAJsMBS97X7PVWviIg4DhaWMPH95bQIC+apKzXOTKS2ebLlbACQaa3dZK0tBlKB4RXO+T3w0tHQZa3NcT8/GJhtrd3nfm02MMSDtYqICM44s7s/XkX2gSP8a1wiTRoHebskkQbHkxMC4oDt5R5nAQMrnNMZwBjzLeAPPGitnXmca+MqfoAx5gbgBoDo6GjS0tJqqvbjKigoqJXPqW9036pH9616dN+qp6CggPvensP0dcWM7hJI/uZVpG32dlW+T3/fqkf37fi8PVszAOgEJAPxwAJjTK+qXmytnQRMAkhKSrLJyckeKPHn0tLSqI3PqW9036pH9616dN+q583PvmZKRjEpXVrwxITT8PNTd2ZV6O9b9ei+HZ8nuzWzgYRyj+Pdz5WXBUyz1pZYazcDGThhrSrXiohIDckvLOHllUVEhQbx9Oi+CmYiXuTJcLYY6GSMaWeMCQLGANMqnPMpTqsZxpjmON2cm4BZwEXGmKbGmKbARe7nRESkBh0qKuWTZVlc/foi9h6x/GtcIlGhGmcm4k0e69a01pYaYybihCp/4A1r7RpjzEPAEmvtNI6FsLWAC/iLtTYXwBjzME7AA3jIWrvPU7WKiDQkrjLLt5l7mbo8m1lrdnG42EVck0b8rmcQp7WN8nZ5Ig2eR8ecWWunA9MrPHd/uZ8tcIf7qHjtG8AbnqxPRKQhWbfzIFOXZ/Pp8mxy8osIDwlgWJ9YLu8XT1KbpixYMN/bJYoI3p8QICIiHrT7YCGfrcjmk2XZrN+VT4CfIblLC0YmxnN+t5aEBPp7u0QRqUDhTESknjlUVMqsNbuYujybbzP3Umahb0ITHhreg0t6taJZWLC3SxSRX6FwJiJSD5QfRzZz9S6OlLiIb9qIW1I6MjIxjvYtwrxdoohUkcKZiEgdtnbHQaYuz+KzFTt+Gkc2IjGWkYnOODItiSFS9yiciYjUMbvynHFkU5eXH0fWksv7xXFeV40jE6nrFM5EROqAQ0WlzFztHke2cS+23DiyS3vHam0ykXpE4UxExEdVNo4sIaoRt6Z0ZITGkYnUWwpnIiI+puI4soiQAEYkxnF5vziS2jTFGI0jE6nPFM5ERHxAxXFkgf7ucWSJcaRoHJlIg6JwJiLiJZWNI0ts3YSH3ePImmocmUiDpHAmIlKLSl1lfLsxl6nLspi1ZjdHSly0jmrMred1YmRiHO2ah3q7RBHxMoUzEREPs9ayOvsgn63I5rOVO9iTX0Rko0BG9ovj8sQ4+mscmYiUo3AmIuIhm/YU8NmKHXy+cgeb9h4iyN+P5C4tuLyfM44sOEDjyETklxTORERq0K68Qr5YtYPPVuzgx+w8jIEz2jfjxnPbM6RHKyIbB3q7RBHxcQpnIiKnKO9wCTNW7+SzFTv4YXMu1kLv+Ej+dkk3LusTS3REiLdLFJE6ROFMRKQajhS7mLNuN5+t2MH8jBxKXJb2zUP50/mdGdY3VgP7RaTaFM5ERKqoxFXGwsy9TFuxg1lrdnG42EV0RDDXntmW4X3j6BEboYH9InLKFM5ERH5FWZll6bb9TFuxgy9/3Mm+Q8VENgpkeN9YhvWJY0C7KPz9FMhEpOYonImIVGCtZf2u/J9mWmYfOEJIoB8Xdo9hWJ9YzuncXDMtRcRjFM5ERNy27zvMtJU7+GxFNhm7C/D3M5zTqTl/GdyFC7tHExqsfzJFxPP0L42INGh78ov4ctUOPlu5g+XbDgAwoG0UD4/oycU9Y2gWFuzlCkWkoVE4E5EGJ7+whFlrdvPZimy+zdxLmYVurSK4e2hXLusTS1yTRt4uUUQaMIUzEWkQCktcpKXnMG3lDuasy6G4tIyEqEb8Ibkjw/rG0jk63NsliogACmciUo+5yizfb8zlsxXZzFy9i/yiUpqHBTFuQGuG9Y0lMaGJlr4QEZ+jcCYi9Yq1lk0HXMz/fA1frNrJnvwiwoIDGNIzhuF9YzmjfTMC/P28XaaIyHEpnIlIvTE/Yw+PT1/H+l2FBAVs47wuLRneN5aUri0JCdTSFyJSNyiciUidt27nQR6bvo5vNuylTbPG/LZnEH+6IpnIRtpkXETqHoUzEamzdh8s5Omv0vlwaRaRjQK5/9LuXH16G75buEDBTETqLIUzEalzDhWV8uqCTfxnwSZcZZbrz27HxJRORDZWIBORuk/hTETqDFeZZcqS7TwzO4M9+UVc2rsVdw3uSutmjb1dmohIjVE4ExGfZ611D/ZfT/rufJLaNOXV8f3p17qpt0sTEalxCmci4tPW7jjI4zOcwf5tmzXm31f3Y3CPGK1PJiL1lsKZiPikXXnOYP+PljmD/R+4rDtXDWxDUIDWKBOR+k3hTER8SkFRKZPmb2TSN5soK4MbBrXnDykdNftSRBoMhTMR8QmlrjKmLMnimdkZ7C0o4rI+sdw1uAsJURrsLyINi8KZiHiVtZY098r+GbsLOK1tU/5zTX8SNdhfRBoohTMR8Zo1O/J4fPp6FmYeHezfn8E9ojXYX0QaNIUzEal1O/OO8PRXGXyswf4iIr/g0XBmjBkCPA/4A69Za5+o8Pq1wD+BbPdTL1prX3O/5gJ+dD+/zVo7zJO1iojnFRSV8ur8jfxHg/1FRI7LY+HMGOMPvARcCGQBi40x06y1ayuc+oG1dmIlb3HEWtvXU/WJSO0pdZXxwZLtPDs7g70FxQzrE8tfNNhfRKRSnmw5GwBkWs5iQboAACAASURBVGs3ARhjUoHhQMVwJiL1lLWWtPQ9PDZ9HRtyChjQNorXJnSjb0ITb5cmIuKzPBnO4oDt5R5nAQMrOe8KY8w5QAZwu7X26DUhxpglQCnwhLX2Uw/WKiI1bHV2Ho/PWMe3mbm0ax7Kq+P7c1F3DfYXETkRY631zBsbMwoYYq293v14PDCwfBemMaYZUGCtLTLG3Aj8xlp7nvu1OGtttjGmPTAXON9au7HCZ9wA3AAQHR3dPzU11SPfpbyCggLCwsI8/jn1je5b9dTF+7avsIyPM0r4bkcpoYEwomMQyQkBBPjVXiiri/fNF+i+VY/uW/U09PuWkpKy1FqbVNlrnmw5ywYSyj2O59jAfwCstbnlHr4GPFnutWz3n5uMMWlAIrCxwvWTgEkASUlJNjk5ueaqP460tDRq43PqG9236qlL962gqJR/p23kPws3YYEbz+3AzckdvDLYvy7dN1+i+1Y9um/Vo/t2fJ4MZ4uBTsaYdjihbAwwrvwJxphW1tqd7ofDgHXu55sCh90tas2BsygX3ETEd5S6ykhdvJ3n5jiD/Yf3dQb7xzfVYH8RkerwWDiz1pYaYyYCs3CW0njDWrvGGPMQsMRaOw24zRgzDGdc2T7gWvfl3YBXjTFlgB/OmDNNJBDxIdZa5q7P4fEZ68nMKWBAuyhen9CNPhrsLyJySjy6zpm1djowvcJz95f7+R7gnkqu+w7o5cnaRKT6Vmfn8eiX6/h+Uy7tm4cyaXx/LtRgfxGRGqEdAkSkyvbkF/HUrHSmLN1O08ZBPDS8B2MHtCbQXyv7i4jUFIUzETmholIX//12Cy/OzaSo1MX1Z7dj4nmdtLK/iIgHKJyJyHFZa5m9djePTl/H1tzDXNCtJX+9pDvtmod6uzRpKMrKYNcqKMiBkAgIDofgCOfnoHDwU6ut1D8KZyJSqfRd+Tz0xRq+zcylU8sw3r5uAOd0buHtsqQhKMqHTWmQMQs2fAUFu49zovl5WPvZz+X+rOy58q/561eh+Bb9jRSRn9l3qJhnZ2fw3v+2Eh4SyIOXdeeq09toXJl41r5NThjLmAVbvwVXMQRHQsfzoPMQiOoARQedo/CgE+B++vkgFOY5fx7a47zX0ddcRSf+7MDGFQJbeLkQF/kr4c/9mnV5/v5Ig6JwJiIAlLjKePeHrTw7O4NDxS7Gn96GP13QmaahQd4uTeojVwls+/5YIMvd4DzfvAsMvNEJZAkDwf8UxzWWFh0LcD8LcxX+rPjcwexjj0sO/+pHnBkYAQWXQ4/Loe3Z4Od/ajVLg6dwJiKkpefwyJfryMwpYFCn5tx3aXc6R4d7uyypbwr2QOZsJ4xtnOsEH/8gJ9AM+D10ugii2tXsZwYEQ1gL56guV+lxwl0+FOaxf+k0old9CEvfhNAW0H24E9Ran66gJtWicCbSgG3cU8CjX65j7voc2jZrzGvXJHF+t5Zar0xqhrXOYP6MryBjJmQvBSyExUCPEdBpMLRPhmAf31/RPwAaRzlHJdYd6Uz0mQOc8XFrPoHl78Hi1459zx4jIX6AJi9IlSmciTRAeUdKeOHrDbz13RYaBfrz14u7MeHMtgQF6JeHnKLiQ+UG88+G/B2Agbh+kHwPdB4MMb3rX1AJauwOYiOgqMAJo2umwpL/wv/+DRFx0H0E9Lwc4vqD/gNIfoXCmUgD4iqzpC7extNfZbD/cDFjTkvgzxd1oXlYsLdLk7ps/5ZjrWNbFjqD8IPCncH8nQZDpwshrKW3q6w9wWHQa5RzFB507svqT2DRJPjhJYhsfaxFLTZRQU1+QeFMpIH4buNeHvp8Let35TOgXRT3X9qdnnGR3i5L6iJXCWz/37GlLvasd55v1hFOu95pHWt9BgRoMgkhEdB7tHMcOQDp052g9sPL8N0L0LSdE9J6jISYXgpqAiicidR723IP89j0dcxcs4u4Jo14+ap+DO0Zo3FlcnIO5ULmHKcVaOPXztIVfoHQ5kzoN8EJZM06eLtK39aoCfQd5xyH98H6L5yuz2+fh4XPOOG2x0hnMkF0d29XK16kcCZSTxUUlfLSvExe/2YzAf6GOy/qzPWD2hMSqNljUgXWwu7Vx5a6yFoMWAhtCV0vg84XQfsUp2VITl7jKOh3jXMc2gvrpjlB7ZunYcE/oUXXY0GtRWdvVyu1TOFMpJ4pK7N8vCyLJ2elsye/iMsT47hrSFdiIkO8XZr4OD9XEaTPONZdeTDbeaFVXzj3/5xA1iqx/g3m97bQ5pB0nXPk7z4W1NKegLTHoWUP6OkOamqdbBAUzkTqkaVb9/H3z9eyKiuPxNZNmDS+P4mtm3q7LPF11sKsezlr0WtQVgyBodAhBZLvdtYeC4/xdoUNR3i0s+bbgN/DwZ2w9jNneY65jzhHTG9nxmf3ETW/Jpz4DIUzkXpgx4EjPDFjPdNW7iAmIoTnftOXYX1i8fPTuDKpgrQn4IeX2ROdTMxFf4Q2ZzmLt4p3RbSC029yjrwsWPOp06I250HniO13bDJBkwRvVys1SOFMpA47Uuzi1QUb+ff8jVgLt53XkZuSO9A4SP/XlipaMRnmPwF9r2J95JXEdEjxdkVSmch4OHOic+zfCms/dWZ9zr7POeJPc7o9e4yAiFhvVyunSP+Ci9RB1lqmrdzBP2asZ0deIZf2bsXdQ7sS37Sxt0uTumTzNzDtVmh3Dlz6HCz8ztsVSVU0bQNn/dE5cje6g9pUmHWPc7Q+wwlq3YepS7qOUjgTqWNWZR3g75+vZenW/fSMi+C5MYkMaFf5tjIix7UnAz64CqLaw+h3tCZZXdWsAwz6s3Ps3eB0e66ZCjP+AjPugqZtwS8AjJ+zz6fxO3b89Ljc835+P3/uRNf4+Ttrs/3ifP8TvJ8/MTsPQkH3hrVAcRVVKZwZY0YCc621ee7HTYBka+2nnixORI7JOVjIk7PS+WhpFs3Dgnjyit5c0T8ef40rk5NVsAfeG+VsOn7VFGf9Lan7mneCc+9yjpx1zhi13EywZWBdzp9lZRUeu/88erhKyj13omtczmSSn71HFa5x6wqQ/oKznVXnodBlCET31EK8VL3l7AFr7dSjD6y1B4wxDwAKZyIeVlji4o1vN/PS3EyKXWXceG57JqZ0JDwk0NulSV1UcgRSx0LBbrj2S6dlReqflt2cwxe5A93iGe9wWvheZ2HjeY/CvEcgIt5Z0LjLUGg7CAIb5hJAVQ1nlS1qoy5REQ+y1rJ0dyn3PTuf7fuOcGH3aP56cTfaNg/1dmlSV5WVwdQbIWsJjH4b4pO8XZE0RMaAfwCHwtrBub+Fc/8CBTnuBY9nwspUWPI6BDZ2FjruMsTZozU82tuV15qqBqwlxphngJfcj28BlnqmJJGGzVrL9xtzee7rDSzaXESX6HDeu34gZ3Vs7u3SpK77+kFn3ayLHnEGi4v4irCW0G+8c5QUwpaFkDED0mdC+pfOObH9nBa1zkPq/T6kVQ1ntwL3AR8AFpiNE9BEpIZYa0nL2MO/vt7Asm0HaBkezPjuQTxw1dkE+GtFdjlFS/7r7OGY9Ds4Y6K3qxE5vsAQ6HSBc1z8FOxe4wS1jFkw7zGnCzQizun+7DwU2g2CwEberrpGVSmcWWsPAXd7uBaRBqmszDJn3W5enJfJqqw84po04uERPbmyfzw/fPuNgpmcug1z4Ms/O6v9D32yXrc4SD1jDMT0dI5z3N2fG75yd39+AEvecHd/Jjstap0H14vlQ6o6W3M2cKW19oD7cVMg1Vo72JPFidRnrjLLjNU7eXFuJut35dOmWWOevKI3IxLjCApQIJMasms1fHgttOwOo94Afw0XljosrCUkXu0cpUWw5RunRS19JqRPd86JTXRa1DoPhlZ96uR/jFT1/6XNjwYzAGvtfmOMFiYRqYZSVxmfr9rBi3Mz2bjnEB1ahPLsb/pwWe9YtZJJzTq4E94fDcFhMO4DCA73dkUiNScgGDpe4BxDn4SctZDu7v5MexzSHoPwWHf35xBof26d6f6sajgrM8a0ttZuAzDGtMUZeyYiVVRcWsbU5Vm8nLaRrbmH6RoTzovjEhnas5XWKpOaV1TgBLPCPPjtDIiM83ZFIp5jDET3cI5z7nTW8jva/fnjh7D0vxDQyN396Q5rEa28XfVxVTWc/RVYaIyZDxhgEHCDx6oSqUcKS1x8uDSLf6dtJPvAEXrFRTJpfH8u6BatjcnFM8pc8PHvYPdqGPsBtOrt7YpEaldYC0i8yjlKi9yzP2e5JxbMcM5p1dc9+3Ow87MPdX9WdULATGNMEk4gW46z+OwRTxYmUtcdKXbx/qJtTFqwkd0Hi+jXugmPjOxJcucWGB/6R0DqGWth5t1Oi8ElT0Pni7xdkYh3BQRDx/OdY+g/nN0TMmY6R9oTThdoeCtnwkyXodDuXAjy7j7FVZ0QcD3wRyAeWAGcDnwPnOe50kTqpoKiUt79YSuvfbOJvQXFnN4+imdH9+WMDs0UysTzfngFFk1ylss47XpvVyPiW4yB6O7OMegOOLT3WPfn6k9g2VsQEOK0pl35ltda06rarflH4DTgB2ttijGmK/CY58oSqXvyjpTw1ndbeOPbzRw4XMKgTs257fxOnNZWm5LXGmshYxYReZuBZG9XU/vWfwmz7oWul8KFD3u7GhHfF9oc+o5zjtJi2Oru/iwt8mo3Z1XDWaG1ttAYgzEm2Fq73hjTxaOVidQR+w8V88a3m3nz2y3kF5VyQbeWTDyvE30TtJl0rdq3GabfCZlzSMRA6G5IvhcCgrxdWe3IXgYfXw9x/eDy/4CfZv6KnJSAIOhwnnN4u5QqnpdljGmCM9ZstjFmP7DVc2WJ+L49+UW8tnAT736/lUPFLob2jGHieR3pERvp7dIaltJi+O4FWPBP8AuEwY+zc9U8Yhc+C5vS4IrXoVkHb1fpWQe2wfu/cVoBxqZ6fbyMiJyaqk4IGOn+8UFjzDwgEpjpsapEfNiuvEJeXbCRyYu2UVxaxmV9YrklpSOdo7WGVK3bshC+uAP2pkP34TDkCYiIJaOoO7GDxsO0W+Hfg5xBwIlX+9RsrBpTmAfvjXa6YSZ87izSKSJ12kkvFW2tne+JQkR8Xdb+w7yStpEPl2RRZi0jE+O4ObkD7VuEebu0hufQXvjqPlj5PjRpDeM+/OWsxO7DIK4/TL0Rpk2EzNlw2fPQqKl3avYEVwlMuQZyN8DVn0DLrt6uSERqgPbxEDmBLXsP8XJaJp8sy8YYuDIpgZvP7UBClLqOal1ZGax4F2bfD0X5cPYdzn57x+vGi4yDaz5zuj3nPgJZS+DySdD27Nqt2xOshS9ud7puh7/srH4uIvWCwpk0XAd3wNK3nAHUnX+5TWxmTj4vzdvIZyuyCfT34+rT23Djue1pFVk3tv+od3avhS/vgG3fQ+sz4dJnoGW3E1/n5w9n3+6sXfTx9fDmpc7jlHvBP9DzdXvKwmdg+TtOOE28ytvViEgNUjiThmfXj/Ddi7D6IygrBePvbAjdYwQA63Ye5MW5mUxfvZOQAH+uH9Se6we1o2V4iJcLb6CKD8H8J+H7FyE4Aoa/BH2vOvnxY3H94MYFzgKtC5+BTfPq7mSBHz+Crx+CXldCyl+9XY2I1DCPhjNjzBDgecAfeM1a+0SF168F/glku5960Vr7mvu1CcDf3M8/Yq19y5O1Sj1nLWTOge/+BZvnQ2AonPZ76DfeGVD+0XVs2XeYRzd3Zvba3YQFB/CH5A787uz2RIU2kKUYfFHGLPjyTsjb5gzov+AhCG1W/fcLDoPhL0KnC2HabXVzssC2H+DTPzith8Nfqjt1i0iVeSycGWP8gZeAC4EsYLExZpq1dm2FUz+w1k6scG0U8ACQhLPB+lL3tfs9Va/UUyWF8OMU+P4l2LMewmPhgr9D/2uhkbMO2fJz/0PYlN/Qds5Ews3t3H7BGK49sy2Rjetwl1ddl5cNM/8P1n0OLbrCtdOh7Vk19/7dh7snC9zkniwwBy57zvcnC+RuhMljITIexrznbEsjIvWOJ1vOBgCZ1tpNAMaYVGA4UDGcVWYwMNtau8997WxgCDDZQ7VKfXMoF5a87mxjc2gPxPSCkZOgx8ifFiXdW1DEXR+tYu76HBIa382HkU/xdMFzmLi+0LiTl79AA+UqhUWvwrzHnM27z3/A2YbIEwvJRsY7kwW+fR7mPeqeLPCq704WOLwP3rvS+fmqD6Gxdp4Qqa+MtdYzb2zMKGCItfZ69+PxwMDyrWTubs3HgT1ABnC7tXa7MeZOIMRa+4j7vPuAI9bapyp8xg04m7ETHR3dPzU11SPfpbyCggLCwrR0wsmqrfvW6HA28VnTiNk1F/+yYnKj+rM9YQQHmvT6WfdPxn4XL68o4lCJZWSnQM5PCKQxR+i96kHC8zNZ2/0u9rY43eP1nkhD+vsWfjCdzhmvEF6wmdyo/mzodCOFjaKr9V4ne9/CD26g27qnaXRkF9taX8GWtmOxfr4zJNeUldBn5f1EHNzAir4PczCyChMhqqEh/X2rSbpv1dPQ71tKSspSa21SZa95+1+fz4HJ1toiY8yNwFucxGbq1tpJwCSApKQkm5yc7JEiy0tLS6M2Pqe+8eh9sxa2fucMGE+fAf5B0HcMnH4LzVp2pdnPTrX855tN/GNxOglNG/H+Vf3pHhtx7ISzz4Z3L6fnun9Cr7eh6yWeqbmKGsTftyMHnMHty96A8BgY/TbNug2j2SmMpTr5+5YMg8fCzP+jzfJ3aePa7GyB5AuTBayFT34PeWth1Bv063mFxz6qQfx98wDdt+rRfTs+T4azbCCh3ON4jg38B8Bam1vu4WvAk+WuTa5wbVqNVyh1m6sU1n7qhLIdy6FxMzj3Ljjt+kpXSc87UsJfPlzJV2t3M7RnDP8Y1ZuIkArjykIi4OqP4Z3LYcoEGP02dL24lr5QA2OtM+tw1r1weC8MvMlZ3iIk4sTXekJwmDPAvuOF8Plt8Oo5MPRJZ0Nkbw66n/co/PghnH8/eDCYiYjv8GQ4Wwx0Msa0wwlbY4Bx5U8wxrSy1u50PxwGrHP/PAt4zBhzdHTuRcA9HqxV6pLCg7DsbfjfvyFvOzTrCJc+C33GQmDla5Ctzs7jD+8tY8eBI9x/aXd+e1ZbzPF+4YZEwvhP4J2Rzurrv3kHugz14BdqgHI3OmuWbUqD2ERnDFVsX29X5egxAuKT4JMb4bM/ODsLXPqsdyYLLH/P2TM0cbyz4K6INAgeC2fW2lJjzEScoOUPvGGtXWOMeQhYYq2dBtxmjBkGlAL7gGvd1+4zxjyME/AAHjo6OUAasLws+OEVJ5gVHYQ2Z8PF/4ROg8HPr9JLrLVMXrSdBz9fQ7PQID648Qz6t6nCL9mQSGc7nHdGwgfj4TfvQpchNfyFGqDSIlj4LHzzjDPT8OKnIOk6Z6FYXxIZDxOmwbfPOZMTti927yxQgzNGT2TTfKcFr32yEw61ZIZIg+HRMWfW2unA9ArP3V/u53s4TouYtfYN4A1P1id1xI7lzqKxa6Y6j3uMhDNucRYV/RWHi0v529TVfLI8m0GdmvP8mMSTW7OsURMYPxXeGQFT3AGtkp0EpIo2pcGXf4bcTKd7bvBjzhgzX+XnD4P+7ISjj6+Hty51Wq+S7/b8zgI5653/KGjWyelar8s7GYjISfP2hACRypWVwYZZTijbuhCCwuH0m51xSU0STnh5Zk4Bf3hvKRtyCrj9gs5MPK8j/n7VaHk4GtDeHgEfXA2/ee+XG2zLryvIgVl/ddaba9rOGdPX8QJvV1V1cf3hxm9gxv/BN085IfOK/0BUe898XkEOvH8lBIbAVVOcVlwRaVAUzsS3lByBlZPh+5chdwNExMNFj0C/a6r8S2rayh3c/fEqGgX68851Azm7U/NTq6lRU7jmU3dAuwrGvO+sMC+/rqwMlr0Jcx6E4sNwzl0w6I7jjgv0acFhMOIl6HQBfP5HZ2eBi//pjHOsye7G4sMweQwc2gvXfglNWtfce4tInaFwJr6hYA8s/g8sfg0O5zqDxK943VnJvYpdOkWlLh79ch1vf7+VpDZNeXFcP2Iia2g/zJ8C2nBIPRrQ6lDrT23b9SN8cTtkLYa2g+CSZ6BFZ29Xdep6jIS4JJh6I3x6M2w4Olmgyam/d1kZTL0Bspc5q/+foNteROovhTPxrj3pzlIYKz8AVxF0Hgpn3gptzjypFont+w4z8f1lrMzK4/eD2nHXkK4E+lc+SaDaGjWF8UcD2jgY+37d6p6rDUUFkPa4M3GjUVMY+Sr0/k39GszeJAEmfO5MbJj3mBNAL5/k/J09FbPvc7arGvKE19fXExHvUjiT2mctbF7ghLINX0FAiLOW1Bm3QPOT3zZp7vrd3P7BSsrKLP++uj9DenpwkHnjKGfLn7eHweRxMHYydDzfc59Xl6z7AmbcBQezod8EuODB+rvFkJ8/nHMntE+Bj38Hb14Cg+6Ec/8P/Kvxz+ri15z/Pwy4wRlXKSINmsKZ1B5XCaz+xPkltGsVhLaA5HvhtN9B6MmPCyt1lfHM7AxeTttI91YRvHJ1P9o0C/VA4RU0joJrpjkBLdUd0DpUeWOL+ufANmewfPp0aNkDRv0XWg/0dlW1I74/3OSeLLDgSdg0z9lZIKpd1d8j4yuY/hfoPMRpNatPrYwiUi0KZ+J5Rw6QsO0TeO5myN8BzbvAZS843V2B1RsTlpNfyG2Tl/PDpn2MHZDAA5f1ICSwFtfKOhrQ3hoGk8fC2FTokFJ7n+8LXCXww8uQ9oTz+MKH4PQ/NLxlH4LDYcTLTgvq57c7kwUueapq3bk7V8FHv4Xons4YS19b701EvELhTDyr+BC8eg4dDmyFdufAZc8747SOs2hsVfywKZdbJy8nv7CEp6/swxX942uw4JPwsy7OMQ0roG393lmzLGeNM07w4ic1s7DnFRB/mrOzwNQb3ZMFnjn+LOO8bHj/NxDSBMZNcWaEiogANTxiWqSCb56GA1tZ2fsBZxB154uqHczKyiwvp2Uy7j8/EB4SwGe3nO29YHZUaDOnBS2qgxPQNqV5tx5Py1nvjLX77xAozHNmrY5LVTA7qklruPYLSPmbs2jyK2fDth9+eV5RvhPMivKdtcwiWtV+rSLisxTOxHNyN8J3/4LeY9gfdWrLAhw4XMzv317CkzPTubhXK6ZNPJsuMeE1VOgpCm3mbPUT1QHeH+Nsu1Pf5GXBZ7fAK2c4kzlS/gYTF2lWYWX8/OHcv8B1s5z/EPnvUGdWp6vUed1VCh/+FnLWwug3IbqHV8sVEd+jcCaeM/Me8A+GC/9+Sm+zKusAl7ywkAUb9vDQ8B78a2wiYcE+1iMf2twd0No5LSKbF3i7oppxeB989Td4oR+smgIDb4Y/rnTCR1AtTL6oyxJOc3YW6P0bmP8PJ6Tt3+LMaM2cDZc8raVYRKRSPvYbTuqN9JnO9ksXPereP3H9Sb+FtZZ3/7eNhz9fS4vwYD686Uz6JtTAYp+eEtrcPUngMnhvNFz1IbQb5O2qqqf4MPzv37DwOWeT+T5jIOVedV+erJAIGPlvJ4R9cQe8OMBZz++sP0LSb71dnYj4KIUzqXklhTDz/5xZmQNvrNZbHCoq5Z5PfmTayh2kdGnBM6P70vRkNi33lrAWzti6ty6F990Bre3Z3q6q6lylsPwdp6Unf6ezvMP596vr7VT1GgUJA5ytnyJi4fwHvV2RiPgwhTOped/9y+m+ueazai2rkLE7n5vfXcrmvYf4y+Au3HxuB/yqs2m5t/wU0C6D966Eqz6Ctmd5u6pfZy2smwZfP+zsaRo/AEa9ceqr3ssxTVrD+KnerkJE6gCNOZOadWCbM0Oz+3Bon3zSl09dnsXwF78l70gJ714/kFtSOtatYHZUWEsnoEUmOAFt63feruj4Nn8Dr50PU64B4+fMwPzdVwpmIiJeopYzqVmz/ur8edGjJ3VZYYmLh75Yy/v/28aAdlH8a2wi0RE1tGm5txwNaG9dCu+Ogqs/8q3As3MVfP13yJwDEXEw7EXoM7Z62w+JiEiN0b/CUnM2znO6xs77m7M5dBVtyz3MH95fyursg9x0bgfuvKgzATW9abm3hEfDhC/KBbSPoc0Z3q1p/xaY+yj8OMVZAPXCh2HA7yGwkXfrEhERQOFMakppsbNEQNN2cMatVb5s9trd3DFlBQZ47ZokLuge7bkavSU82mlBe/NSeM8d0FqfXvt1FOyBBf+EJW+AXwCcfTuc9Sdo5MMzYEVEGiCFM6kZi16FvRnONjRV2C+zxFXGU7PSeXXBJnrFRfLyVf1IiGpcC4V6SXiMs3L8m5fAu1fA1Z/U3ubgRfnw/UvORI2SI5B4NSTf7cwaFBERn6NwJqcuf5ez+XXnIdB58AlP332wkInvL2Pxlv1cfXpr/nZJ99rdtNxbwmPKdXFeAeM/cZZX8JTSYlj6X5j/JBzeC92GOctiNO/kuc8UEZFTpnAmp272/eAqhsGPnfDUbzP38sfU5RwqcvH8mL4M7xtXCwX6kIhWTkB78xJ453LPBLSyMlj9Mcx7xBlf1nYQXPAgxCfV7OeIiIhH1JNR1+I1W7+HVR/AmbdBsw7HPa3MWv719QbGv/4/mjQOYtrEsxpeMDsqopXTxRnWwglo2xfXzPtaCxvmwKRz4JPrISgcrvrYGe+mYCYiUmeo5Uyqr8wF0/8CEfEw6I7jnrb/UDHPLS1i1d4MhveN5bGRvQj1tb0xa1tE7LEWtHcvdxYnPZUAlbUU5jwAW76BJm3g8v9Az1HOxtsiIlKnNPDfkHJKlrwBu3+EK9867ibYmTn5XPvfxew64OKRET25amBrjKmDi8p6QmQcXPulu4tzJIz/FOL7n9x77M2EuQ/B2s+gcXMY+iT0/y0E1IGtrkREpFL6z2qpnkN7Ye7D0O5cZzeASizeso8rXvmewhIX9w78//buO06q+tzj+Odhl96bS1lhUUEFy+29GgAAG01JREFUVMpKTRQUDTcWMDYsCJZLILbk3thyjUnUmKi5XjXXEjRSLKARjdzEhmVFKdIhFFGEpfdetz73jxl0xV3cHffsObP7fb9evJg5c2bm2UeRr79zznNqcXWvtgpmR2rYOnaIs06TWEBbP7d079uzMXafxid6wIr34cw74dYFsXuZKpiJiCQ1hTNJzPv3Qu7+2EpNMYHr7cUbuerZT2lStwavjerLcY2qwNWYiWqYHltBq9MYxl8E6+eVvO/BXfDe7+DxrjD/RTj9BrhlAfS/C2rWr7iaRUQkMApnUnbr58K88dBzJBxz0rdeHjttFaNenEfnVg2YNKoPbZpW4vll5aVheuwctNqN4PnBsGH+N1/POwTTHofHToNPHoGTz4ebZsOPH4pdWCAiIpWGzjmTsiksjF0EULc5nHnHES85D779GX+ZupJzO6bx2JCu1K6hFbNSa3Ts14Nqxw+Ca94AL4D5L8CHf4A96+D4s2HAb6DlaWFXKyIiAVE4k7JZ+FJs5eyiv0CtBl9tzskv4La/LWLywg0M7dWW317YiZRqOr+szBq1+foigfGDOb1afTiwFlp1g4uegnZnhF2hiIgETOFMSu/gLpjyGzi2F5x6+Vebdx/MY+Tzc5mxcjt3DDyJkWcepxP/v49GbeJ3ErgAy8mLXQ3bcVCx5/aJiEjlo3AmpZf1Bzi4A3788FdBYePugwx/bjYrt+3jfy4/jYu6podcZCXRuC3cPJdZUz+mX6ezwq5GREQqkMKZlM6mxTBrdGyGVstTAVi+aS/Dx8xi76F8xgzvwQ/aNwu5yEompTqYrtkREalqFM7ku7nDW7dDrUZw1t0AzPhyOyOen0Pt6im8/NNedGrVMOQiRUREKgeFM/luiyfB6mlw/qNQpwmTF27gl68spE3TOoy7rgetG9UOu0IREZFKQ+FMji5nH7x7N7TsgncdyrNTV/L7N5fRI6MJz1yTScM61cOuUEREpFJROJOjm/ow7N1IwaXjuf/N5YyZls15p7Tkvy87jVrVNcNMRESkvCmcScm2fQEzniD/1Cu5eWoKby3O5rq+7bj7vJOpphlmIiIigVA4k+LFLwLw1FqM3Hg+763dxN3nncwNPzwu7MpEREQqtUCv0zezgWa23MxWmNmdR9nvYjNzM8uMP88ws4NmtiD+6+kg65RifPZP+PIDnrTLmbqhGn++oquCmYiISAUIbOXMzFKAJ4BzgHXAbDOb7O5Lj9ivPnAr8OkRH/Glu3cJqj45iryD5L55J2towzM5ZzPuuh70Pr5p2FWJiIhUCUGunPUAVrj7SnfPBSYCg4rZ7z7gQeBQgLVIGaye/AA19q7lkeo38MqoHyqYiYiIVCBz92A+2OwSYKC73xB/PhTo6e43FdmnG/Bf7n6xmWUBv3T3OWaWASwBPgf2AHe7+8fFfMcIYARAWlpa94kTJwbysxS1b98+6tWrF/j3hGVx9jpuWPVzPqmWyd6et9O4Vvnk98ret6Cob4lR3xKjviVGfUtMVe9b//7957p7ZnGvhXZBgJlVAx4Bhhfz8kagjbtvN7PuwN/NrJO77ym6k7uPBkYDZGZmer9+/YItGsjKyqIivqeiuTtPZn1J+y/vg9QUeo76C/WPaVtun19Z+xY09S0x6lti1LfEqG+JUd9KFuRhzfXAsUWep8e3HVYf6AxkmVk20AuYbGaZ7p7j7tsB3H0u8CXQIcBaq7SCQufXbyxm1pRX+FHKHFL73V6uwUxERERKL8iVs9lAezNrRyyUDQGuPPyiu+8GvrpT9hGHNZsDO9y9wMyOA9oDKwOstco6mFvAzRPm89Gy9cxsNAGvczypfW/67jeKiIhIIAILZ+6eb2Y3Ae8AKcBz7r7EzO4F5rj75KO8/QzgXjPLAwqBke6+I6haq6od+3O5ftxsFqzdxd9OmUfTL9bAxZMgtWbYpYmIiFRZgZ5z5u5vAm8ese2eEvbtV+TxJGBSkLVVdau372f4mNls2HWQ537Smsx3n4ETz4P2A8IuTUREpErTHQKqoEXrdnHd2NnkFzov3tCTzDm3QWE+DHwg7NJERESqvEDvECDR8+HyLQwZPZNa1VN4dWQfMlkKi1+FH/wcGmeEXZ6IiEiVp5WzKuTl2Wv41euLOalFfcZcezrH1EmFV2+Dhm2g78/DLk9ERERQOKsS3J1H3/uCx97/gjM6NOfJq7pRr2YqzHwatiyFy1+AGnXCLlNERERQOCubgrywKyizvIJC7n59MS/PWcsl3dP5w09OoXpKNdi3FT58AI4/C046P+wyRUREJE7hrLQKC+HZs2lvLaHbidCgZdgVfaf9Ofnc+NI8spZv5ZazTuAX53TAzGIvvv9byDsA//YQHN4mIiIiodMFAaWVfxDST6flxinweFeYcg8ciO7ota17cxgyeiZTP9/K7y/qzH+ce+LXwWzdHJj/AvT+GTRrH26hIiIi8g1aOSutGnXhvP9mVrXT6XXwA5j2OMwZA31ugV6joGZ0bt66cus+ho2Zxda9OYwemsmAjmlfv1hYAP/8T6jXAs64LbwiRUREpFhaOSujQ7VbwE9Gw6hpkPED+PB+eLxL7OT6/Jywy2Pemp1c/NR09ucUMHFE728GM4D5z8PGBXDu/VCzfjhFioiISIkUzhKV1gmumADXT4HmJ8Hbd8CfM2H+i7HVqRBMWbqZK5+ZSYPa1XltVB+6HNvomzsc2AHv/Q7a9IFTLgmlRhERETk6hbPv69geMOz/YOjrULcpvPEzeLI3LH0D3CusjAmz1vDT5+dwYlp9Jo3qQ0azut/e6cMH4NAu+PHDughAREQkohTOyoNZbCTFv38Il40HHF65Bp7pD19+EHhI27L3EPe8sZi+JzRjwoheNKtXzI3LNy6COX+F0/8dWnQOtB4RERFJnMJZeTKDjoNg1AwY9CTs3wbPXwTjLoC1swP72pc+XUNegXPvoM7UqVHMNR7u8OZtULsx9L8rsDpERETk+1M4C0JKKnS9Cm6eCwMfhC3L4K8DYMIVsHlpuX5Vbn4hL366hv4nNqddcYcyARa9AmtnwoDfxgKaiIiIRJbCWZBSa0KvkXDrQuh/N2R/Ak/1gddGwI5V5fIVby3eyNa9OQzrk1H8Dof2wJRfQ6tu0OXqcvlOERERCY7CWUWoWQ/OvC0W0vreErtY4H8zY/PG9m76Xh89Zlo2xzWryxntmxe/w9SHYN8WOO9PUE3/uEVERKJOf1tXpDpN4Jx74ZYF0O0amDsWHusCU34DB3eW+eMWrN3FgrW7uKZ3W6pVK+bqy63LYeZT0G0otO7+/esXERGRwCmchaFBSzj/f+DGWXDy+TDtMXj0NJj6J8jdX+qPGTc9m3o1U7m4e/q3X3SHt26P3dng7N+UY/EiIiISJIWzMDU9Hi5+FkZ+Am37wAf3xVbSPh39nXcb2LL3EP9YtIFLuqdTv1b1b++wbDKszIqd61a3WTD1i4iISLlTOIuCFp3hyolw3bvQrAO8dVvsnLQFL5V4t4EJn64lr8C5pnfbb7+YewDe/hWkdYbM6wIuXkRERMqTwlmUtOkJw/8BV0+Kjbz4+6j43QYmf2OQbWx8xmrO7NCc45oXc8P1Tx6BPetidwJI0b3tRUREkonCWdSYwQkDYMRHcOk48EJ4ZSg8cxZ8+SEQG5+xZW8Ow/tmfPv9O1bCtMfhlMtih0pFREQkqWhZJarMoNNgOOl8WDgBsv4Izw+Gdmcwbddg2jU7njOLG5/x9q8gpXrsqlARERFJOgpnUZeSGhuFccqlMOc58j96mIcOTWV18/5U25YGx5z89b6fvwOfvwXn3Be7IlRERESSjg5rJovqtaD3z/h1mxf5c+FltNkzJ3Y+2ms/hZ3ZkHcI3roDmraHniPDrlZEREQSpJWzJLJ1bw6Tluzmih63Yuc8GDvxf9YzsHgStOoKO1fB1a9Bao2wSxUREZEEaeUsiUyYtYbcgkKu6ZMRu9vAuffDLfNjN1lfPxc6DoITzg67TBEREfketHKWJPIKCnlh5mrO6NCc44uOz2jQCi54LDZstlaD8AoUERGRcqGVsyTx1uJNbNmbw7V9MorfoV5zSK1ZoTWJiIhI+VM4SxLjpmeT0bQOZ3YoZnyGiIiIVBoKZ0ngX+t2M3f1Tq7pnUG1ahZ2OSIiIhIghbMkMHZ6NnVqpHBJZnrYpYiIiEjAFM4ibtu+HP5v4QYu6Z5Og1rVwy5HREREAqZwFnETD4/P6J0RdikiIiJSARTOIiyvoJDnZ67mh+2bccIx9b77DSIiIpL0FM4i7J0lm9i8J4fhJY3PEBERkUpH4SzCxk7Lpm3TOvQ/8ZiwSxEREZEKonAWUYvX72bO6p0M7dVW4zNERESqkEDDmZkNNLPlZrbCzO48yn4Xm5mbWWaRbXfF37fczH4UZJ1RdHh8xqWZx4ZdioiIiFSgwO6taWYpwBPAOcA6YLaZTXb3pUfsVx+4Ffi0yLaOwBCgE9AKeM/MOrh7QVD1Rsn2fTlMXriByzLTaVhb4zNERESqkiBXznoAK9x9pbvnAhOBQcXsdx/wIHCoyLZBwER3z3H3VcCK+OdVCRNnryU3v5BhGp8hIiJS5QS2cga0BtYWeb4O6Fl0BzPrBhzr7v80s9uOeO/MI97b+sgvMLMRwAiAtLQ0srKyyqfyo9i3b1+g35Nf6Dz70UE6Na3G+mVzWb8ssK+qUEH3rbJS3xKjviVGfUuM+pYY9a1kQYazozKzasAjwPBEP8PdRwOjATIzM71fv37lUtvRZGVlEeT3/HPRRnbmzOPhy7vTr2NaYN9T0YLuW2WlviVGfUuM+pYY9S0x6lvJggxn64GiZ7Onx7cdVh/oDGSZGUALYLKZXViK91ZaY6evok2TOvQ/SeMzREREqqIgzzmbDbQ3s3ZmVoPYCf6TD7/o7rvdvZm7Z7h7BrHDmBe6+5z4fkPMrKaZtQPaA7MCrDUSFq/fzezsnVzTuy0pGp8hIiJSJQW2cubu+WZ2E/AOkAI85+5LzOxeYI67Tz7Ke5eY2SvAUiAfuLEqXKk5bno2tatrfIaIiEhVFug5Z+7+JvDmEdvuKWHffkc8/z3w+8CKi5gd+3N5Y+EGLu2u8RkiIiJVme4QEBETZq0hN79Q99EUERGp4hTOIiC/oJAXZq6m7wlNaZ9WP+xyREREJEQKZxHw7tLNbNx9iOF92oVdioiIiIRM4SwCxk7PJr1xbc7S+AwREZEqT+EsZEs37GHWqh0M652h8RkiIiKicBa2w+MzLtP4DBEREUHhLFQ79ufy9wXruahbaxrW0fgMERERUTgL1cTZa8jJL2RY74ywSxEREZGIUDgLSX5BIS/MWE2f45tyYguNzxAREZEYhbOQTFm6mQ27DzFMQ2dFRESkCIWzkIydnk3rRrUZcHJa2KWIiIhIhCichWDZxj18umoHw/q01fgMERER+QaFsxCMm55NrerVND5DREREvkXhrILt3J/L6/PXc1HXdBrVqRF2OSIiIhIxCmcV7OU5a2PjM/q0DbsUERERiSCFswqUX1DI8zNW0/u4ppzUokHY5YiIiEgEKZxVoPeWbWH9roManyEiIiIlUjirQGOnr4qPzzgm7FJEREQkohTOKshnm/Ywc+UOhvZuS2qK2i4iIiLFU0qoIIfHZww5XeMzREREpGQKZxVg14HY+IzBXVprfIaIiIgclcJZBXh59loO5RXqQgARERH5TgpnASsodMbPWE3Pdk04uaXGZ4iIiMjRKZwF7L1lm1m/6yDX9s0IuxQRERFJAgpnARs7LZtWDWsx4OS0sEsRERGRJKBwFqDlm/YyY+V2hvbO0PgMERERKRUlhgCNnZ5NzVSNzxAREZHSUzgLyO4Debw+fx2Du7SmcV2NzxAREZHSUTgLyMtz1mh8hoiIiJSZwlkADo/P6NGuCR1baXyGiIiIlJ7CWQDeX7aZdTsPcq1WzURERKSMFM4CMG5GbHzGOR01PkNERETKRuGsnH2+eS/TVmzn6t5tNT5DREREykzpoZyNm55NjdRqDDm9TdiliIiISBJSOCtHuw/k8dq89Qzu0oomGp8hIiIiCVA4K0d/m7uWg3kFGp8hIiIiCVM4KycFhc64Gdn0yGhCp1YNwy5HREREkpTCWTn54LMtrN1xUKtmIiIi8r0EGs7MbKCZLTezFWZ2ZzGvjzSzf5nZAjP7xMw6xrdnmNnB+PYFZvZ0kHWWh3HTs2nZsBbndtL4DBEREUlcalAfbGYpwBPAOcA6YLaZTXb3pUV2e8ndn47vfyHwCDAw/tqX7t4lqPrK0xeb9/LJim3c9qMTqa7xGSIiIvI9BJkkegAr3H2lu+cCE4FBRXdw9z1FntYFPMB6AjNuxuHxGceGXYqIiIgkOXMPJg+Z2SXAQHe/If58KNDT3W86Yr8bgf8AagBnufsXZpYBLAE+B/YAd7v7x8V8xwhgBEBaWlr3iRMnBvKzFLVv3z7q1av31fP9ec4vsg7Qs0Uq159SM/DvT1ZH9k1KR31LjPqWGPUtMepbYqp63/r37z/X3TOLey2ww5ql5e5PAE+Y2ZXA3cAwYCPQxt23m1l34O9m1umIlTbcfTQwGiAzM9P79esXeL1ZWVkU/Z5nP15JbsEy7vhJLzq31lWaJTmyb1I66lti1LfEqG+JUd8So76VLMjDmuuBosf50uPbSjIRGAzg7jnuvj3+eC7wJdAhoDoTVlDojJ+xmtMzGiuYiYiISLkIMpzNBtqbWTszqwEMASYX3cHM2hd5eh7wRXx78/gFBZjZcUB7YGWAtSYka/kW1uw4oPEZIiIiUm4CO6zp7vlmdhPwDpACPOfuS8zsXmCOu08GbjKzAUAesJPYIU2AM4B7zSwPKARGuvuOoGpN1Njp2bRoUIsfdWoRdikiIiJSSQR6zpm7vwm8ecS2e4o8vrWE900CJgVZ2/e1YstePv5iG788t4PGZ4iIiEi5UapI0Ljpq6mRWo0rerQJuxQRERGpRBTOErDnUB6T5q3jglNb0bSexmeIiIhI+VE4S8Df5qzjQG4Bw3UhgIiIiJQzhbMyKnRn/IxsurdtzCnpGp8hIiIi5UvhrIwWbS1g9fYDWjUTERGRQCicldF7a/JJa1CTgZ01PkNERETKn8JZGazYso/F2wq4umdbjc8QERGRQChhlMH4GdmkGlzRU+MzREREJBgKZ6V0IDefSXPX0bNlKs00PkNEREQConBWSnVqpPLKyN5ccHz1sEsRERGRSkzhrAw6tWpIi7pqmYiIiARHSUNEREQkQhTORERERCJE4UxEREQkQhTORERERCJE4UxEREQkQhTORERERCJE4UxEREQkQhTORERERCJE4UxEREQkQhTORERERCJE4UxEREQkQhTORERERCJE4UxEREQkQhTORERERCJE4UxEREQkQszdw66hXJjZVmB1BXxVM2BbBXxPZaO+JUZ9S4z6lhj1LTHqW2Kqet/aunvz4l6oNOGsopjZHHfPDLuOZKO+JUZ9S4z6lhj1LTHqW2LUt5LpsKaIiIhIhCiciYiIiESIwlnZjQ67gCSlviVGfUuM+pYY9S0x6lti1LcS6JwzERERkQjRypmIiIhIhCiciYiIiESIwlkpmdlAM1tuZivM7M6w60kGZnasmX1oZkvNbImZ3Rp2TcnEzFLMbL6Z/SPsWpKJmTUys1fN7DMzW2ZmvcOuKerM7BfxP6OLzWyCmdUKu6aoMrPnzGyLmS0usq2JmU0xsy/ivzcOs8YoKqFvD8f/nC4ys9fNrFGYNUaJwlkpmFkK8ATwb0BH4Aoz6xhuVUkhH/hPd+8I9AJuVN/K5FZgWdhFJKHHgLfd/STgNNTDozKz1sAtQKa7dwZSgCHhVhVpY4GBR2y7E3jf3dsD78efyzeN5dt9mwJ0dvdTgc+Buyq6qKhSOCudHsAKd1/p7rnARGBQyDVFnrtvdPd58cd7if0l2TrcqpKDmaUD5wHPhl1LMjGzhsAZwF8B3D3X3XeFW1VSSAVqm1kqUAfYEHI9keXuU4EdR2weBIyLPx4HDK7QopJAcX1z93fdPT/+dCaQXuGFRZTCWem0BtYWeb4OhYwyMbMMoCvwabiVJI1HgduBwrALSTLtgK3AmPgh4WfNrG7YRUWZu68H/gSsATYCu9393XCrSjpp7r4x/ngTkBZmMUnqOuCtsIuICoUzCZyZ1QMmAT939z1h1xN1ZnY+sMXd54ZdSxJKBboBT7l7V2A/OsR0VPHzowYRC7atgLpmdnW4VSUvj82n0oyqMjCz/yJ2GsyLYdcSFQpnpbMeOLbI8/T4NvkOZladWDB70d1fC7ueJNEXuNDMsokdQj/LzF4It6SksQ5Y5+6HV2hfJRbWpGQDgFXuvtXd84DXgD4h15RsNptZS4D471tCridpmNlw4HzgKtfg1a8onJXObKC9mbUzsxrETpadHHJNkWdmRuzcn2Xu/kjY9SQLd7/L3dPdPYPYv2sfuLtWMkrB3TcBa83sxPims4GlIZaUDNYAvcysTvzP7NnoIoqymgwMiz8eBrwRYi1Jw8wGEjt940J3PxB2PVGicFYK8RMWbwLeIfYfrVfcfUm4VSWFvsBQYis/C+K/fhx2UVLp3Qy8aGaLgC7AAyHXE2nxVcZXgXnAv4j9vaDb6pTAzCYAM4ATzWydmV0P/BE4x8y+ILYS+ccwa4yiEvr2v0B9YEr874enQy0yQnT7JhEREZEI0cqZiIiISIQonImIiIhEiMKZiIiISIQonImIiIhEiMKZiIiISIQonIlIlWBmBUVGuiwws3K7c4CZZZjZ4vL6PBGp2lLDLkBEpIIcdPcuYRchIvJdtHImIlWamWWb2UNm9i8zm2VmJ8S3Z5jZB2a2yMzeN7M28e1pZva6mS2M/zp8q6MUM3vGzJaY2btmVju0H0pEkprCmYhUFbWPOKx5eZHXdrv7KcQmlj8a3/ZnYJy7n0rshsyPx7c/Dnzk7qcRu2/n4buFtAeecPdOwC7g4oB/HhGppHSHABGpEsxsn7vXK2Z7NnCWu680s+rAJndvambbgJbunhffvtHdm5nZViDd3XOKfEYGMMXd28ef3wFUd/f7g//JRKSy0cqZiAh4CY/LIqfI4wJ0Tq+IJEjhTEQELi/y+4z44+nAkPjjq4CP44/fB0YBmFmKmTWsqCJFpGrQ/9mJSFVR28wWFHn+trsfHqfR2MwWEVv9uiK+7WZgjJndBmwFro1vvxUYbWbXE1shGwVsDLx6EakydM6ZiFRp8XPOMt19W9i1iIiADmuKiIiIRIpWzkREREQiRCtnIiIiIhGicCYiIiISIQpnIiIiIhGicCYiIiISIQpnIiIiIhHy/3N+CyK6WoKBAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PK7W8edOXUYZ"
      },
      "source": [
        "## ConvMixer\n",
        "\n",
        "Based on the paper [Patches Are All You Need?](https://openreview.net/pdf?id=TVHS5Y4dNvM), keras code [code](https://github.com/tmp-iclr/convmixer/blob/main/convmixer.py)<br>\n",
        "\n",
        "> Is the performance of ViTs due to the inherently more powerful Transformer architecture, or is it at least partly due to using patches as the input representation.\n",
        "\n",
        "> ConvMixer, an extremely simple model that is similar in many aspects to the ViT and the even-more-basic MLP-Mixer\n",
        "\n",
        "> Despite its simplicity, ConvMixer outperforms the ViT, MLP-Mixer, and some of their variants for similar parameter counts and data set sizes, in addition to outperforming classical vision models such as the ResNet.\n",
        "\n",
        "> While self-attention and MLPs are theoretically more flexible, allowing for large receptive fields and content-aware behavior, the inductive bias of convolution is well-suited to vision tasks and leads to high data efficiency.\n",
        "\n",
        "> ConvMixers are substantially slower at inference than the competitors!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9XDtHoIgUJnT"
      },
      "source": [
        "### ConvMixer 1 block"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DxNPFZ0LDKo0"
      },
      "source": [
        "# gelu + BatchNormalization\n",
        "def activation_block(x):\n",
        "    x = layers.Activation(\"gelu\")(x)\n",
        "    return layers.BatchNormalization()(x)\n",
        "\n",
        "# Patch embeddings (using CNN where: kernel_size=patch_size, strides=patch_size)\n",
        "# followed by gelu + BatchNormalization\n",
        "def conv_stem(x, filters: int, patch_size: int):\n",
        "    x = layers.Conv2D(filters, kernel_size=patch_size, strides=patch_size)(x)\n",
        "    return activation_block(x)\n",
        "\n",
        "# 1) DepthwiseConv2D and then (gelu + BatchNormalization) \n",
        "# 2) Skip connection \n",
        "# 3) Pointwise convolution and then (gelu + BatchNormalization)  \n",
        "def conv_mixer_block(x, filters: int, kernel_size: int):\n",
        "    # Depthwise convolution.\n",
        "    x0 = x\n",
        "    x = layers.DepthwiseConv2D(kernel_size=kernel_size, padding=\"same\")(x)\n",
        "    x = layers.Add()([activation_block(x), x0])  # Residual.\n",
        "\n",
        "    # Pointwise convolution.\n",
        "    x = layers.Conv2D(filters, kernel_size=1)(x)\n",
        "    x = activation_block(x)\n",
        "\n",
        "    return x\n",
        "\n",
        "# ConvMixer-h/d where:\n",
        "# h is the width or hidden dimension, \n",
        "# d is the depth or the number of repetitions of the ConvMixer layer\n",
        "def get_conv_mixer_h_d(\n",
        "    image_size=32, filters=256, depth=8, kernel_size=5, patch_size=2, num_classes=10\n",
        "):\n",
        "    \"\"\"ConvMixer-256/8: https://openreview.net/pdf?id=TVHS5Y4dNvM.\n",
        "    The hyperparameter values are taken from the paper.\n",
        "    \"\"\"\n",
        "    inputs = keras.Input((image_size, image_size, 3))\n",
        "    #x = layers.Rescaling(scale=1.0 / 255)(inputs) # data is scaled\n",
        "\n",
        "    # Extract patch embeddings.\n",
        "    x = conv_stem(inputs, filters, patch_size)\n",
        "\n",
        "    # ConvMixer blocks.\n",
        "    for _ in range(depth):\n",
        "        x = conv_mixer_block(x, filters, kernel_size)\n",
        "\n",
        "    # Classification block.\n",
        "    x = layers.GlobalAvgPool2D()(x)  # should be AdaptiveAvgPool2d?\n",
        "    outputs = layers.Dense(num_classes, activation=\"softmax\")(x)\n",
        "\n",
        "    return keras.Model(inputs, outputs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d6d0N5FHDO7Q"
      },
      "source": [
        "learning_rate = 0.001\n",
        "weight_decay = 0.0001\n",
        "batch_size = 128\n",
        "num_epochs = 10"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6nfu1Oa-DO-N"
      },
      "source": [
        "def run_experiment(model, from_logits=False):\n",
        "    # Create Adam optimizer with weight decay.\n",
        "    optimizer = tfa.optimizers.AdamW(\n",
        "        learning_rate=learning_rate, weight_decay=weight_decay,\n",
        "    )\n",
        "    # Compile the model.\n",
        "    model.compile(\n",
        "        optimizer=optimizer,\n",
        "        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=False),\n",
        "        metrics=[\n",
        "            keras.metrics.SparseCategoricalAccuracy(name=\"acc\")\n",
        "        ],\n",
        "    )\n",
        "    # Create a learning rate scheduler callback.\n",
        "    reduce_lr = keras.callbacks.ReduceLROnPlateau(\n",
        "        monitor=\"val_loss\", factor=0.5, patience=5\n",
        "    )\n",
        "    # Create an early stopping callback.\n",
        "    early_stopping = tf.keras.callbacks.EarlyStopping(\n",
        "        monitor=\"val_loss\", patience=10, restore_best_weights=True\n",
        "    )\n",
        "    # Fit the model.\n",
        "    history = model.fit(\n",
        "        x=x_train,\n",
        "        y=y_train,\n",
        "        batch_size=batch_size,\n",
        "        epochs=num_epochs,\n",
        "        validation_split=0.1,\n",
        "        callbacks=[early_stopping, reduce_lr],\n",
        "    )\n",
        "\n",
        "    _, accuracy = model.evaluate(x_test, y_test)\n",
        "    print(f\"Test accuracy: {round(accuracy * 100, 2)}%\")\n",
        "\n",
        "    # Return history to plot learning curves.\n",
        "    return history"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eiKuVJVGE-9o",
        "outputId": "d28aa913-1732-46b1-95c4-cca13b81bf8d"
      },
      "source": [
        "conv_mixer_model = get_conv_mixer_h_d(image_size=32, filters=16, depth=1, kernel_size=5, patch_size=2, num_classes=10)\n",
        "conv_mixer_model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_33\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_60 (InputLayer)           [(None, 32, 32, 3)]  0                                            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_81 (Conv2D)              (None, 16, 16, 16)   208         input_60[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "activation_27 (Activation)      (None, 16, 16, 16)   0           conv2d_81[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "batch_normalization_82 (BatchNo (None, 16, 16, 16)   64          activation_27[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "depthwise_conv2d_57 (DepthwiseC (None, 16, 16, 16)   416         batch_normalization_82[0][0]     \n",
            "__________________________________________________________________________________________________\n",
            "activation_28 (Activation)      (None, 16, 16, 16)   0           depthwise_conv2d_57[0][0]        \n",
            "__________________________________________________________________________________________________\n",
            "batch_normalization_83 (BatchNo (None, 16, 16, 16)   64          activation_28[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "add_57 (Add)                    (None, 16, 16, 16)   0           batch_normalization_83[0][0]     \n",
            "                                                                 batch_normalization_82[0][0]     \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_82 (Conv2D)              (None, 16, 16, 16)   272         add_57[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "activation_29 (Activation)      (None, 16, 16, 16)   0           conv2d_82[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "batch_normalization_84 (BatchNo (None, 16, 16, 16)   64          activation_29[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "global_average_pooling2d_2 (Glo (None, 16)           0           batch_normalization_84[0][0]     \n",
            "__________________________________________________________________________________________________\n",
            "dense_246 (Dense)               (None, 10)           170         global_average_pooling2d_2[0][0] \n",
            "==================================================================================================\n",
            "Total params: 1,258\n",
            "Trainable params: 1,162\n",
            "Non-trainable params: 96\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ss00EH_uE_Ea",
        "outputId": "cf03ae97-a337-42e7-9d7c-8e90d344cb4b"
      },
      "source": [
        "num_epochs = 25\n",
        "history = run_experiment(conv_mixer_model)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/25\n",
            "352/352 [==============================] - 6s 13ms/step - loss: 1.9899 - acc: 0.2785 - val_loss: 2.2899 - val_acc: 0.1322\n",
            "Epoch 2/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.7765 - acc: 0.3526 - val_loss: 1.9426 - val_acc: 0.2894\n",
            "Epoch 3/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.6997 - acc: 0.3806 - val_loss: 1.7555 - val_acc: 0.3498\n",
            "Epoch 4/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.6415 - acc: 0.4046 - val_loss: 1.6910 - val_acc: 0.3786\n",
            "Epoch 5/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.5980 - acc: 0.4233 - val_loss: 1.6169 - val_acc: 0.4002\n",
            "Epoch 6/25\n",
            "352/352 [==============================] - 4s 12ms/step - loss: 1.5587 - acc: 0.4439 - val_loss: 1.5827 - val_acc: 0.4128\n",
            "Epoch 7/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.5252 - acc: 0.4553 - val_loss: 1.7459 - val_acc: 0.3864\n",
            "Epoch 8/25\n",
            "352/352 [==============================] - 4s 12ms/step - loss: 1.5009 - acc: 0.4631 - val_loss: 1.8364 - val_acc: 0.3650\n",
            "Epoch 9/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.4815 - acc: 0.4702 - val_loss: 1.5180 - val_acc: 0.4564\n",
            "Epoch 10/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.4648 - acc: 0.4761 - val_loss: 1.5350 - val_acc: 0.4590\n",
            "Epoch 11/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.4472 - acc: 0.4800 - val_loss: 1.4873 - val_acc: 0.4616\n",
            "Epoch 12/25\n",
            "352/352 [==============================] - 4s 12ms/step - loss: 1.4330 - acc: 0.4842 - val_loss: 1.4789 - val_acc: 0.4736\n",
            "Epoch 13/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.4197 - acc: 0.4926 - val_loss: 1.4433 - val_acc: 0.4770\n",
            "Epoch 14/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.4101 - acc: 0.4954 - val_loss: 1.4365 - val_acc: 0.4842\n",
            "Epoch 15/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.4022 - acc: 0.4964 - val_loss: 1.4252 - val_acc: 0.4870\n",
            "Epoch 16/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3957 - acc: 0.4992 - val_loss: 1.4515 - val_acc: 0.4820\n",
            "Epoch 17/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3864 - acc: 0.5012 - val_loss: 1.4254 - val_acc: 0.4894\n",
            "Epoch 18/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3802 - acc: 0.5041 - val_loss: 1.4670 - val_acc: 0.4624\n",
            "Epoch 19/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3743 - acc: 0.5071 - val_loss: 1.5159 - val_acc: 0.4370\n",
            "Epoch 20/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3693 - acc: 0.5097 - val_loss: 1.5256 - val_acc: 0.4318\n",
            "Epoch 21/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3627 - acc: 0.5131 - val_loss: 1.3796 - val_acc: 0.5116\n",
            "Epoch 22/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3646 - acc: 0.5120 - val_loss: 1.3695 - val_acc: 0.5176\n",
            "Epoch 23/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3664 - acc: 0.5108 - val_loss: 1.3934 - val_acc: 0.5028\n",
            "Epoch 24/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3691 - acc: 0.5104 - val_loss: 1.4021 - val_acc: 0.4960\n",
            "Epoch 25/25\n",
            "352/352 [==============================] - 4s 11ms/step - loss: 1.3696 - acc: 0.5127 - val_loss: 1.3830 - val_acc: 0.5062\n",
            "313/313 [==============================] - 1s 4ms/step - loss: 1.3966 - acc: 0.4936\n",
            "Test accuracy: 49.36%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 933
        },
        "id": "Jm-1_gw-E_IH",
        "outputId": "031591d4-a44d-4f77-abb4-6449d1e5ed33"
      },
      "source": [
        "plot_curves(history)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ITE3Xtpb-RX"
      },
      "source": [
        "### Hybrid MLP-Mixer and ConvMixer "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X6RzvwiS2Tvn"
      },
      "source": [
        "def build_convmlpmixer_classifier():\n",
        "    inputs = layers.Input(shape=input_shape)\n",
        "    # Create patches.\n",
        "    patches = conv_stem(inputs, filters, patch_size)\n",
        "    \n",
        "    #------------------------------\n",
        "    # ConvMixer: 1 Block \n",
        "    #------------------------------\n",
        "    x0 = patches\n",
        "    x = layers.DepthwiseConv2D(kernel_size=kernel_size, padding=\"same\")(patches)\n",
        "    x = layers.Add()([activation_block(x), x0])  # Residual.\n",
        "    # Pointwise convolution.\n",
        "    x = layers.Conv2D(filters, kernel_size=1)(x)\n",
        "    x = activation_block(x)\n",
        "    \n",
        "    #------------------------------\n",
        "    # MLP Mixer: 1 Block \n",
        "    #------------------------------\n",
        "    x = layers.Reshape((16 * 16, embedding_dim))(x)\n",
        "    x = MLPMixerLayer(num_patches, embedding_dim, dropout_rate)(x)\n",
        "\n",
        "    #------------------------------\n",
        "    # Apply global average pooling\n",
        "    #------------------------------ \n",
        "    representation = layers.GlobalAveragePooling1D()(x)\n",
        "    \n",
        "    #------------------------------\n",
        "    # Softmax\n",
        "    #------------------------------ \n",
        "    outputs = layers.Dense(num_classes, activation=\"softmax\")(representation)\n",
        "    \n",
        "    # Create the Keras model.\n",
        "    return keras.Model(inputs=inputs, outputs=outputs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ien2_plWXbAE",
        "outputId": "6e36cd3b-37b3-472d-8e0c-cba5400e3226"
      },
      "source": [
        "# MLPMixer\n",
        "num_epochs = 50\n",
        "batch_size = 128\n",
        "embedding_dim = 16\n",
        "dropout_rate = 0.9\n",
        "learning_rate = 0.001\n",
        "weight_decay = 0.0001\n",
        "\n",
        "# ConvMixer\n",
        "filters = 16\n",
        "kernel_size = 5\n",
        "patch_size = 2\n",
        "\n",
        "mlpconv_classifier = build_convmlpmixer_classifier()\n",
        "mlpconv_classifier.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_41\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_68 (InputLayer)           [(None, 32, 32, 3)]  0                                            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_98 (Conv2D)              (None, 16, 16, 16)   208         input_68[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "activation_43 (Activation)      (None, 16, 16, 16)   0           conv2d_98[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "batch_normalization_103 (BatchN (None, 16, 16, 16)   64          activation_43[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "depthwise_conv2d_66 (DepthwiseC (None, 16, 16, 16)   416         batch_normalization_103[0][0]    \n",
            "__________________________________________________________________________________________________\n",
            "activation_44 (Activation)      (None, 16, 16, 16)   0           depthwise_conv2d_66[0][0]        \n",
            "__________________________________________________________________________________________________\n",
            "batch_normalization_104 (BatchN (None, 16, 16, 16)   64          activation_44[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "add_66 (Add)                    (None, 16, 16, 16)   0           batch_normalization_104[0][0]    \n",
            "                                                                 batch_normalization_103[0][0]    \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_99 (Conv2D)              (None, 16, 16, 16)   272         add_66[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "activation_45 (Activation)      (None, 16, 16, 16)   0           conv2d_99[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "batch_normalization_105 (BatchN (None, 16, 16, 16)   64          activation_45[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "reshape_53 (Reshape)            (None, 256, 16)      0           batch_normalization_105[0][0]    \n",
            "__________________________________________________________________________________________________\n",
            "mlp_mixer_layer_47 (MLPMixerLay (None, 256, 16)      140080      reshape_53[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "global_average_pooling1d_38 (Gl (None, 16)           0           mlp_mixer_layer_47[0][0]         \n",
            "__________________________________________________________________________________________________\n",
            "dense_266 (Dense)               (None, 10)           170         global_average_pooling1d_38[0][0]\n",
            "==================================================================================================\n",
            "Total params: 141,338\n",
            "Trainable params: 141,242\n",
            "Non-trainable params: 96\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "25InAnAVcJgG",
        "outputId": "aa888077-9387-46a5-d31e-c2d7870e098c"
      },
      "source": [
        "history = run_experiment(mlpconv_classifier)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n",
            "352/352 [==============================] - 16s 39ms/step - loss: 1.8110 - acc: 0.3320 - val_loss: 4.7709 - val_acc: 0.1480\n",
            "Epoch 2/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.5244 - acc: 0.4421 - val_loss: 1.6364 - val_acc: 0.4164\n",
            "Epoch 3/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.4522 - acc: 0.4690 - val_loss: 1.5365 - val_acc: 0.4466\n",
            "Epoch 4/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.3927 - acc: 0.4915 - val_loss: 1.4739 - val_acc: 0.4736\n",
            "Epoch 5/50\n",
            "352/352 [==============================] - 13s 38ms/step - loss: 1.3532 - acc: 0.5057 - val_loss: 1.4146 - val_acc: 0.4830\n",
            "Epoch 6/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.3189 - acc: 0.5204 - val_loss: 1.5187 - val_acc: 0.4584\n",
            "Epoch 7/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.2943 - acc: 0.5291 - val_loss: 1.3913 - val_acc: 0.5104\n",
            "Epoch 8/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.2661 - acc: 0.5394 - val_loss: 1.3493 - val_acc: 0.5132\n",
            "Epoch 9/50\n",
            "352/352 [==============================] - 13s 38ms/step - loss: 1.2467 - acc: 0.5478 - val_loss: 1.3506 - val_acc: 0.5194\n",
            "Epoch 10/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.2240 - acc: 0.5534 - val_loss: 1.3643 - val_acc: 0.5198\n",
            "Epoch 11/50\n",
            "352/352 [==============================] - 13s 38ms/step - loss: 1.1976 - acc: 0.5652 - val_loss: 1.4389 - val_acc: 0.4896\n",
            "Epoch 12/50\n",
            "352/352 [==============================] - 13s 38ms/step - loss: 1.1754 - acc: 0.5743 - val_loss: 1.4324 - val_acc: 0.4954\n",
            "Epoch 13/50\n",
            "352/352 [==============================] - 13s 38ms/step - loss: 1.1563 - acc: 0.5801 - val_loss: 1.4041 - val_acc: 0.5118\n",
            "Epoch 14/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.1050 - acc: 0.6002 - val_loss: 1.3715 - val_acc: 0.5246\n",
            "Epoch 15/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.0953 - acc: 0.6027 - val_loss: 1.4123 - val_acc: 0.5198\n",
            "Epoch 16/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.0817 - acc: 0.6100 - val_loss: 1.4352 - val_acc: 0.5238\n",
            "Epoch 17/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.0747 - acc: 0.6130 - val_loss: 1.4833 - val_acc: 0.5152\n",
            "Epoch 18/50\n",
            "352/352 [==============================] - 13s 37ms/step - loss: 1.0667 - acc: 0.6147 - val_loss: 1.4817 - val_acc: 0.5142\n",
            "313/313 [==============================] - 3s 9ms/step - loss: 1.3555 - acc: 0.5191\n",
            "Test accuracy: 51.91%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 933
        },
        "id": "LW5jJ-rCS8Tt",
        "outputId": "97564076-7cb0-4f08-ed40-1cb14789c76e"
      },
      "source": [
        "plot_curves(history)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        }
      ]
    }
  ]
}