Transformers_Image_GPT_final.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Transformers_Image_GPT (1).ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P9tObiU-qVgv"
      },
      "source": [
        "#Run Image GPT with [Transformers](https://github.com/huggingface/transformers)\n",
        "by [Alfredo Peguero](https://twitter.com/alfredompeguero)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OoWYiUzT_lLs"
      },
      "source": [
        "# Download Image GPT"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WkPOYJsCTaUb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ed65b4c-eaed-478f-b961-ff7e112d9a82"
      },
      "source": [
        "!git clone https://github.com/openai/image-gpt.git"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "fatal: destination path 'image-gpt' already exists and is not an empty directory.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e0DcaUYv8LYf"
      },
      "source": [
        "model_sizes = [\"s\", \"m\", \"l\"] #small medium large, xl not available\n",
        "model_size = \"s\"\n",
        "models_dir = \"/content/models\"\n",
        "color_clusters_dir = \"/content/clusters\"\n",
        "bs = 5\n",
        "n_px = 32"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ylcjIJcwXsFw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab3d97e6-8386-4eb0-fa9f-3213b9a2b30d"
      },
      "source": [
        "!python image-gpt/download.py --model {model_size} --ckpt 1000000 --clusters --dataset imagenet --download_dir {models_dir}/{model_size}\n",
        "!python image-gpt/download.py --clusters --download_dir {color_clusters_dir}"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "input args:\n",
            " {\n",
            "    \"download_dir\":\"/content/models/s\",\n",
            "    \"bert\":false,\n",
            "    \"model\":\"s\",\n",
            "    \"ckpt\":\"1000000\",\n",
            "    \"clusters\":true,\n",
            "    \"dataset\":\"imagenet\"\n",
            "}\n",
            "Fetching model.ckpt-1000000.data-00000-of-00032: 1.00kit [00:00, 735kit/s]      \n",
            "Fetching model.ckpt-1000000.data-00001-of-00032: 31.5Mit [00:10, 2.95Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00002-of-00032: 28.3Mit [00:03, 7.34Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00003-of-00032: 28.3Mit [00:10, 2.82Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00004-of-00032: 28.3Mit [00:12, 2.21Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00005-of-00032: 31.5Mit [00:12, 2.51Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00006-of-00032: 30.4Mit [00:03, 7.71Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00007-of-00032: 28.3Mit [00:11, 2.55Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00008-of-00032: 31.5Mit [00:10, 2.92Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00009-of-00032: 29.4Mit [00:04, 6.83Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00010-of-00032: 31.5Mit [00:10, 3.01Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00011-of-00032: 31.5Mit [00:13, 2.38Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00012-of-00032: 30.4Mit [00:11, 2.64Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00013-of-00032: 28.3Mit [00:10, 2.62Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00014-of-00032: 31.5Mit [00:13, 2.33Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00015-of-00032: 32.5Mit [00:15, 2.16Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00016-of-00032: 31.5Mit [00:13, 2.36Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00017-of-00032: 28.3Mit [00:12, 2.27Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00018-of-00032: 29.4Mit [00:11, 2.49Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00019-of-00032: 28.3Mit [00:13, 2.06Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00020-of-00032: 28.3Mit [00:03, 7.13Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00021-of-00032: 28.3Mit [00:07, 3.60Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00022-of-00032: 30.4Mit [00:13, 2.18Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00023-of-00032: 30.4Mit [00:09, 3.08Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00024-of-00032: 29.4Mit [00:04, 6.97Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00025-of-00032: 28.3Mit [00:09, 2.96Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00026-of-00032: 28.3Mit [00:03, 7.35Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00027-of-00032: 29.4Mit [00:04, 6.90Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00028-of-00032: 29.4Mit [00:13, 2.25Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00029-of-00032: 29.4Mit [00:14, 2.07Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00030-of-00032: 28.3Mit [00:11, 2.49Mit/s]     \n",
            "Fetching model.ckpt-1000000.data-00031-of-00032: 28.3Mit [00:11, 2.39Mit/s]     \n",
            "Fetching model.ckpt-1000000.index: 10.0kit [00:00, 6.37Mit/s]                   \n",
            "Fetching model.ckpt-1000000.meta: 18.4Mit [00:06, 2.67Mit/s]                    \n",
            "Fetching kmeans_centers.npy: 7.00kit [00:00, 4.16Mit/s]                         \n",
            "Fetching imagenet_trX.npy: 5.04Git [35:07, 2.39Mit/s]                           \n",
            "Fetching imagenet_trY.npy: 4.92Git [38:22, 2.14Mit/s]                           \n",
            "Fetching imagenet_vaX.npy: 205Mit [01:19, 2.58Mit/s]                            \n",
            "Fetching imagenet_vaY.npy: 200Mit [01:30, 2.21Mit/s]                            \n",
            "Fetching imagenet_teX.npy: 205Mit [01:08, 2.98Mit/s]                            \n",
            "Fetching imagenet_teY.npy: 200Mit [01:13, 2.73Mit/s]                            \n",
            "input args:\n",
            " {\n",
            "    \"download_dir\":\"/content/clusters\",\n",
            "    \"bert\":false,\n",
            "    \"model\":null,\n",
            "    \"ckpt\":null,\n",
            "    \"clusters\":true,\n",
            "    \"dataset\":null\n",
            "}\n",
            "Fetching kmeans_centers.npy: 7.00kit [00:00, 5.08Mit/s]                         \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UjVa2W5f-6BB"
      },
      "source": [
        "# Subclass GPT2LMHeadModel\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eoImkBA2d5jT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b37a857e-332e-43c8-fdc0-bf97c876a36a"
      },
      "source": [
        "!pip install transformers"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: transformers in /usr/local/lib/python3.7/dist-packages (4.4.2)\n",
            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.7/dist-packages (from transformers) (2019.12.20)\n",
            "Requirement already satisfied: sacremoses in /usr/local/lib/python3.7/dist-packages (from transformers) (0.0.44)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.7/dist-packages (from transformers) (3.0.12)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from transformers) (20.9)\n",
            "Requirement already satisfied: tokenizers<0.11,>=0.10.1 in /usr/local/lib/python3.7/dist-packages (from transformers) (0.10.1)\n",
            "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.7/dist-packages (from transformers) (4.41.1)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from transformers) (2.23.0)\n",
            "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from transformers) (3.8.1)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.7/dist-packages (from transformers) (1.19.5)\n",
            "Requirement already satisfied: click in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers) (7.1.2)\n",
            "Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers) (1.0.1)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers) (1.15.0)\n",
            "Requirement already satisfied: pyparsing>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->transformers) (2.4.7)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->transformers) (3.0.4)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->transformers) (2.10)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->transformers) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->transformers) (2020.12.5)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->transformers) (3.4.1)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->transformers) (3.7.4.3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "soYP5NE_KPZn"
      },
      "source": [
        "import os\n",
        "import transformers\n",
        "from transformers.models.gpt2.modeling_gpt2 import GPT2Model,GPT2LMHeadModel\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import logging\n",
        "logger = logging.getLogger(__name__)\n",
        "\n",
        "def load_tf_weights_in_image_gpt2(model, config, gpt2_checkpoint_path):\n",
        "    \"\"\" Load tf checkpoints in a pytorch model\n",
        "    \"\"\"\n",
        "    try:\n",
        "        import re\n",
        "        import tensorflow as tf\n",
        "    except ImportError:\n",
        "        logger.error(\n",
        "            \"Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see \"\n",
        "            \"https://www.tensorflow.org/install/ for installation instructions.\"\n",
        "        )\n",
        "        raise\n",
        "    tf_path = os.path.abspath(gpt2_checkpoint_path)\n",
        "    logger.info(\"Converting TensorFlow checkpoint from {}\".format(tf_path))\n",
        "    # Load weights from TF model\n",
        "    init_vars = tf.train.list_variables(tf_path)\n",
        "    names = []\n",
        "    arrays = []\n",
        "\n",
        "    for name, shape in init_vars:\n",
        "        logger.info(\"Loading TF weight {} with shape {}\".format(name, shape))\n",
        "        array = tf.train.load_variable(tf_path, name)\n",
        "        names.append(name)\n",
        "        arrays.append(array.squeeze())\n",
        "\n",
        "    for name, array in zip(names, arrays):\n",
        "        name = name[6:]  # skip \"model/\"\n",
        "        name = name.split(\"/\")\n",
        "\n",
        "        # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v\n",
        "        # which are not required for using pretrained model\n",
        "        if any(\n",
        "            n in [\"adam_v\", \"adam_m\", \"AdamWeightDecayOptimizer\", \"AdamWeightDecayOptimizer_1\", \"global_step\"]\n",
        "            for n in name\n",
        "        ) or name[-1] in ['_step']:\n",
        "            logger.info(\"Skipping {}\".format(\"/\".join(name)))\n",
        "            continue\n",
        "        \n",
        "        pointer = model\n",
        "        if name[-1] not in [\"wtet\"]:\n",
        "          pointer = getattr(pointer, \"transformer\")\n",
        "        \n",
        "        for m_name in name:\n",
        "            if re.fullmatch(r\"[A-Za-z]+\\d+\", m_name):\n",
        "                scope_names = re.split(r\"(\\d+)\", m_name)\n",
        "            else:\n",
        "                scope_names = [m_name]\n",
        "\n",
        "            if scope_names[0] == \"w\" or scope_names[0] == \"g\":\n",
        "                pointer = getattr(pointer, \"weight\")\n",
        "            elif scope_names[0] == \"b\":\n",
        "                pointer = getattr(pointer, \"bias\")\n",
        "            elif scope_names[0] == \"wpe\" or scope_names[0] == \"wte\":\n",
        "                pointer = getattr(pointer, scope_names[0])\n",
        "                pointer = getattr(pointer, \"weight\")\n",
        "            elif scope_names[0] in ['q_proj','k_proj','v_proj']:\n",
        "                pointer = getattr(pointer, 'c_attn')\n",
        "                pointer = getattr(pointer, 'weight')\n",
        "            elif len(name) ==3 and name[1]==\"attn\" and scope_names[0]==\"c_proj\":\n",
        "                pointer = getattr(pointer, scope_names[0])\n",
        "                pointer = getattr(pointer, 'weight')\n",
        "            elif scope_names[0]==\"wtet\":\n",
        "                pointer = getattr(pointer, \"lm_head\")\n",
        "                pointer = getattr(pointer, 'weight')\n",
        "            elif scope_names[0]==\"sos\":\n",
        "                pointer = getattr(pointer,\"wte\")\n",
        "                pointer = getattr(pointer, 'weight')\n",
        "            else:\n",
        "                pointer = getattr(pointer, scope_names[0])\n",
        "            if len(scope_names) >= 2:\n",
        "                num = int(scope_names[1])\n",
        "                pointer = pointer[num]\n",
        "\n",
        "        if len(name) > 1 and name[1]==\"attn\" or name[-1]==\"wtet\" or name[-1]==\"sos\" or name[-1]==\"wte\":\n",
        "           pass #array is used to initialize only part of the pointer so sizes won't match\n",
        "        else:\n",
        "          try:\n",
        "              assert pointer.shape == array.shape\n",
        "          except AssertionError as e:\n",
        "              e.args += (pointer.shape, array.shape)\n",
        "              raise\n",
        "          \n",
        "        logger.info(\"Initialize PyTorch weight {}\".format(name))\n",
        "\n",
        "        if name[-1]==\"q_proj\":\n",
        "          pointer.data[:,:config.n_embd] = torch.from_numpy(array.reshape(config.n_embd,config.n_embd) ).T\n",
        "        elif name[-1]==\"k_proj\":\n",
        "          pointer.data[:,config.n_embd:2*config.n_embd] = torch.from_numpy(array.reshape(config.n_embd,config.n_embd) ).T\n",
        "        elif name[-1]==\"v_proj\":\n",
        "          pointer.data[:,2*config.n_embd:] = torch.from_numpy(array.reshape(config.n_embd,config.n_embd) ).T\n",
        "        elif (len(name) ==3 and name[1]==\"attn\" and name[2]==\"c_proj\" ):\n",
        "          pointer.data = torch.from_numpy(array.reshape(config.n_embd,config.n_embd) )\n",
        "        elif name[-1]==\"wtet\":\n",
        "          pointer.data = torch.from_numpy(array)\n",
        "        elif name[-1]==\"wte\":\n",
        "          pointer.data[:config.vocab_size-1,:] = torch.from_numpy(array)\n",
        "        elif name[-1]==\"sos\":\n",
        "          pointer.data[-1] = torch.from_numpy(array)\n",
        "        else:\n",
        "          pointer.data = torch.from_numpy(array)\n",
        "\n",
        "    return model\n",
        "\n",
        "\n",
        "from torch.nn.parameter import Parameter\n",
        "class ln_mod(nn.Module):\n",
        "    def __init__(self, nx,eps=1e-5):\n",
        "        super().__init__()\n",
        "        self.eps = eps\n",
        "        self.weight = Parameter(torch.Tensor(nx))\n",
        "    def forward(self,x):#input is not mean centered\n",
        "        return x / torch.sqrt( torch.std(x,axis=-1,unbiased=False,keepdim=True)**2 + self.eps ) * self.weight.data[...,:] \n",
        "\n",
        "def replace_ln(m, name,config):\n",
        "  for attr_str in dir(m):\n",
        "      target_attr = getattr(m, attr_str)\n",
        "      if type(target_attr) == torch.nn.LayerNorm:\n",
        "          #print('replaced: ', name, attr_str)\n",
        "          setattr(m, attr_str, ln_mod(config.n_embd,config.layer_norm_epsilon))\n",
        "\n",
        "  for n, ch in m.named_children():\n",
        "      replace_ln(ch, n,config)        \n",
        "\n",
        "def gelu2(x):\n",
        "    return x * torch.sigmoid(1.702 * x)\n",
        "\n",
        "class ImageGPT2LMHeadModel(GPT2LMHeadModel):\n",
        "  load_tf_weights = load_tf_weights_in_image_gpt2\n",
        "  \n",
        "  def __init__(self, config):\n",
        "      super().__init__(config)\n",
        "      self.lm_head = nn.Linear(config.n_embd, config.vocab_size - 1, bias=False)\n",
        "      replace_ln(self,\"net\",config) #replace layer normalization\n",
        "      for n in range(config.n_layer):\n",
        "        self.transformer.h[n].mlp.act = gelu2 #replace activation \n",
        "\n",
        "  def tie_weights(self): #image-gpt doesn't tie output and input embeddings\n",
        "    pass "
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_orA2jylbTXp"
      },
      "source": [
        "# Unconditional Image Generation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SxJvFFK8gqJA"
      },
      "source": [
        "import numpy as np\n",
        "color_clusters_file = \"%s/kmeans_centers.npy\"%(color_clusters_dir)\n",
        "clusters = np.load(color_clusters_file) #get color clusters"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q00XounhcEIR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a792bd0-8819-43b7-f83c-f834039bde52"
      },
      "source": [
        "MODELS={\"l\":(1536,16,48),\"m\":(1024,8,36),\"s\":(512,8,24) } \n",
        "n_embd,n_head,n_layer=MODELS[model_size] #set model hyperparameters\n",
        "vocab_size = len(clusters) + 1 #add one for start of sentence token\n",
        "config = transformers.GPT2Config(vocab_size=vocab_size,n_ctx=n_px*n_px,n_positions=n_px*n_px,n_embd=n_embd,n_layer=n_layer,n_head=n_head)\n",
        "model_path = \"%s/%s/model.ckpt-1000000.index\"%(models_dir,model_size)\n",
        "\n",
        "model = ImageGPT2LMHeadModel.from_pretrained(model_path,from_tf=True,config=config).cuda()"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:528: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:529: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:530: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:535: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PJBT0ZIgGJKo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dc13e4a9-7d68-4b18-b27f-503f4ccb89e5"
      },
      "source": [
        "context = np.full( (bs,1), vocab_size - 1 ) #initialize with SOS token\n",
        "context = torch.tensor(context).cuda()\n",
        "output = model.generate(input_ids=context,max_length= n_px*n_px + 1,temperature=1.0,do_sample=True,top_k=40)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "drMf9MZCmf6m",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 188
        },
        "outputId": "6d984bdf-6d9a-43a7-f64c-97fc74c7c768"
      },
      "source": [
        "#visualize samples with Image-GPT color palette.\n",
        "%matplotlib inline\n",
        "import pathlib\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "\n",
        "samples = output[:,1:].cpu().detach().numpy()\n",
        "samples_img = [np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [n_px, n_px, 3]).astype(np.uint8) for s in samples] # convert color cluster tokens back to pixels\n",
        "f, axes = plt.subplots(1,bs,dpi=300)\n",
        "\n",
        "for img,ax in zip(samples_img,axes):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)\n",
        "    "
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1800x1200 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u7xe3DCnXKG9"
      },
      "source": [
        "# Tokenize Cropped Images for Image Completion"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iZYMwQWgXKG_"
      },
      "source": [
        "#numpy implementation of functions in image-gpt/src/utils which convert pixels of image to nearest color cluster. \n",
        "def normalize_img(img):\n",
        "  return img/127.5 - 1\n",
        "\n",
        "def squared_euclidean_distance_np(a,b):\n",
        "  b = b.T\n",
        "  a2 = np.sum(np.square(a),axis=1)\n",
        "  b2 = np.sum(np.square(b),axis=0)\n",
        "  ab = np.matmul(a,b)\n",
        "  d = a2[:,None] - 2*ab + b2[None,:]\n",
        "  return d\n",
        "\n",
        "def color_quantize_np(x, clusters):\n",
        "    x = x.reshape(-1, 3)\n",
        "    d = squared_euclidean_distance_np(x, clusters)\n",
        "    return np.argmin(d,axis=1)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iAYXA8w_XKHC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "77989fdf-200c-4c49-aebd-9085e477c5ed"
      },
      "source": [
        "#get images\n",
        "!curl https://i.imgur.com/fIiwqyn.jpeg > sg.jpeg\n",
        "image_paths = [\"sg.jpeg\"]*bs"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
            "                                 Dload  Upload   Total   Spent    Left  Speed\n",
            "\r  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0\r100  746k  100  746k    0     0  6017k      0 --:--:-- --:--:-- --:--:-- 6017k\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L4RmFF79XKHF"
      },
      "source": [
        "#Resize original images to n_px by n_px\n",
        "import cv2\n",
        "import numpy as np\n",
        "dim=(n_px,n_px)\n",
        "\n",
        "x = np.zeros((bs,n_px,n_px,3),dtype=np.uint8)\n",
        "\n",
        "for n,image_path in enumerate(image_paths):\n",
        "  img_np = cv2.imread(image_path)   # reads an image in the BGR format\n",
        "  img_np = cv2.cvtColor(img_np, cv2.COLOR_BGR2RGB)   # BGR -> RGB\n",
        "  H,W,C = img_np.shape\n",
        "  D = min(H,W)\n",
        "  img_np = img_np[:D,:D,:C] #get square piece of image\n",
        "  x[n] = cv2.resize(img_np,dim, interpolation = cv2.INTER_AREA) #resize to n_px by n_px\n",
        "  "
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-hinQ-KtXKHP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 188
        },
        "outputId": "1cf71bd4-5be7-462c-8c95-93cb94c41c44"
      },
      "source": [
        "#visualize resized images\n",
        "f, axes = plt.subplots(1,bs,dpi=300)\n",
        "\n",
        "for img,ax in zip(x,axes):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1800x1200 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4AuPUbLlXKHR"
      },
      "source": [
        "#use Image-GPT color palette and crop images\n",
        "x_norm = normalize_img(x) #normalize pixels values to -1 to +1\n",
        "samples = color_quantize_np(x_norm,clusters).reshape(x_norm.shape[:-1]) #map pixels to closest color cluster\n",
        "\n",
        "n_px_crop = 16\n",
        "primers = samples.reshape(-1,n_px*n_px)[:,:n_px_crop*n_px] # crop top n_px_crop rows. These will be the conditioning tokens"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SggQqpPaXKHT",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 290
        },
        "outputId": "bc38caa9-17d9-4ade-dcc3-d3718c80e114"
      },
      "source": [
        "#visualize samples and crops with Image-GPT color palette. Should look similar to original resized images\n",
        "samples_img = [np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [n_px, n_px, 3]).astype(np.uint8) for s in samples] # convert color clusters back to pixels\n",
        "primers_img = [np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [n_px_crop,n_px, 3]).astype(np.uint8) for s in primers] # convert color clusters back to pixels\n",
        "\n",
        "\n",
        "f, axes = plt.subplots(1,bs,dpi=300)\n",
        "for img,ax in zip(samples_img,axes):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)\n",
        "\n",
        "f, axes2 = plt.subplots(1,bs,dpi=300)\n",
        "for img,ax in zip(primers_img,axes2):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1800x1200 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1800x1200 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-0ksgzgxXk1F"
      },
      "source": [
        "# Conditional Image Completion"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ySPBUloCXw3p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6fe582a2-d46e-4ca5-9a37-3bbcd7957fae"
      },
      "source": [
        "context = np.concatenate( (np.full( (bs,1), vocab_size - 1 ),primers,), axis=1 )\n",
        "context = torch.tensor(context).cuda()\n",
        "output = model.generate(input_ids=context,max_length= n_px*n_px + 1,temperature=1.0,do_sample=True,top_k=40)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EF8FKNJZXw3s",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 188
        },
        "outputId": "8ae80c02-d483-4cd3-e2c6-d67624ca31b0"
      },
      "source": [
        "#visualize samples with Image-GPT color palette. \n",
        "\n",
        "samples = output[:,1:].cpu().detach().numpy()\n",
        "samples_img = [np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [n_px, n_px, 3]).astype(np.uint8) for s in samples] # convert color cluster tokens back to pixels\n",
        "f, axes = plt.subplots(1,bs,dpi=300)\n",
        "\n",
        "for img,ax in zip(samples_img,axes):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)\n",
        "    "
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1800x1200 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ug8_fm926bTA"
      },
      "source": [
        "#get images\n",
        "# !curl https://github.com/chhatbarnikita/image/blob/main/index3.jpeg > sg.jpeg\n",
        "image_pathss = [\"4220549.jpg\", \"4220550.jpg\", \"4220551.jpg\", \"4220553.jpg\", \"4220556.jpg\"]"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "__OXGSDI6o-P"
      },
      "source": [
        "#Resize original images to n_px by n_px\n",
        "import cv2\n",
        "import numpy as np\n",
        "dim=(n_px,n_px)\n",
        "\n",
        "x = np.zeros((5,n_px,n_px,3),dtype=np.uint8)\n",
        "\n",
        "for n,image_path in enumerate(image_pathss):\n",
        "  img_np = cv2.imread(image_path)   # reads an image in the BGR format\n",
        "  img_np = cv2.cvtColor(img_np, cv2.COLOR_BGR2RGB)   # BGR -> RGB\n",
        "  H,W,C = img_np.shape\n",
        "  D = min(H,W)\n",
        "  img_np = img_np[:D,:D,:C] #get square piece of image\n",
        "  x[n] = cv2.resize(img_np,dim, interpolation = cv2.INTER_AREA) #resize to n_px by n_px\n",
        "  "
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c2l437x66xuu",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 188
        },
        "outputId": "e0845c53-74c8-4041-e9bf-525576fb6771"
      },
      "source": [
        "#visualize resized images\n",
        "f, axes = plt.subplots(1,5,dpi=300)\n",
        "\n",
        "for img,ax in zip(x,axes):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABa8AAAEsCAYAAADElk/1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAuIwAALiMBeKU/dgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzaWYxk2X3n9/9dYsnMiMg9qypr37t639ndFHc1W4RESpQ00ogaScMxRoBteINt+MGGjZFgQ7A9GNjwy9gezWgoQ7BGpjQSNZKaFpduUmyym93sfauufcnKPTMy9oh7/VDyi4H/7xhVoOtm+/t5/eX/Lueee865JyPK89wAAAAAAAAAACiS+E5fAAAAAAAAAAAA/09sXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJh8xoAAAAAAAAAUDhsXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJh8xoAAAAAAAAAUDhsXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJh8xoAAAAAAAAAUDhsXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAonPROnfiXf/PTucqHmR8nSUkee7s5cLPRIJO1aSlxszjqy9r52ZqbJelI1k5O+/nR/WOydqpx0M3eP3dR1rb6ZT+MZKlNTgzdLMn1Nc/MyMdv33h+w80ak4Hravjn7vb1eauxf9OL++qyNklF34n1q3Z9ZcfN2h39IDbW/L5TrurzJiJut/zna2b2+//THwd6SLFVKhXZGeLY/99euSzem4Ao0GrVqn/siXH9Xg36/th36vARWZvkfj+Kag1Ze+XqFTebmpqRtb12080euOs+WXvq4cfdbGu7JWvfevEFmZfM7x6f+cIvytqnf/6X3CwPvTW5f97f+u1/JEu//fU/cbMo0WPfWL3iZqO+nr9SMc4Mun6fNDObFP3jS1/+T2Ttf/QbP79rx6Bf+O1/rscf9duC4F2LdU7kz1NmZqLbB8+rfg0hlnTB84bemVwUR4FieVmBa87Fuxp+Rvrgubju4BASOvUt1obOq+Y21VShY0eBOxrd1mPwi0PX/Ce/9eVdO/6YmR19/Ki8w8ifmq0u1rtmZuVTc27Wynqydqzsj19zY1VZ+/hh/3vo6Wc+J2svXO+42eGDp2TtG2+/5WZ/+vWvydoPrq24WVrT95uW/O/hfsv/rjAzi2K9ju3s+N+82VDP67mY90dD/S1dnvX7Tn2v/gDMM/+8pTS05eF/8zRmxmXl+jX/m7W1pft7Razr81y383t/9tKuHYMe/3u/rUfY2B9jIvGtfrPWz+PAR1gkvv3iwPpJXVasPrjNLBL3mwR+apqI1Vfofk3er65NxA1Hgdo48AzjyL+uJNAguvbWrysOnVfkaaBWtWUS61clEc8wCfQ7tX5We2JmZr/z737hjow//PIaAAAAAAAAAFA4bF4DAAAAAAAAAAqHzWsAAAAAAAAAQOGweQ0AAAAAAAAAKBw2rwEAAAAAAAAAhcPmNQAAAAAAAACgcNi8BgAAAAAAAAAUTnqnTjzKhzKfnPSztDSuD55GbtTe6cnSXt/P40w318qNlpvNzpT1eZOKmy0nNVm7vHbNP+9sXdZO7PhtFSW5rK3VG262tnld1l5c0s8wKfv/V9nY8K/ZzMyGJTfq511Z2sz8bHV7Q9Y26v4zTMu6LSup3x79jiy1wci/p96Ofs/SiriuYaJPvMvF8a3/72400u0aRX4fLZf0ODLK/E7Y7un+O9PwB87QNS8eOeZm77/zlqyNxLH3L8zK2lK6183WVpdk7R//we+62TDS7fy5n/tFmZdFfVz133Uzs9Xr59xscd8+Wdvq+31nZeWqrI1Tv0+P+n1Z21z3568o1+OX7fj5REOP9TN75tzsgXsf0ufdxYaZbtMo8vPI9BwYRX4/CD3LXBw7NGIO1aHFmGhmFos4t8A1Z35xFmgrdd7QDaeinYMCyxj1nELPP3hwIdTWoWpf6Jpu/bypOnYuFnVmpl/D22mL4hsO9TMZ5gM3a7X1WuRAPuVm48mYrJ064te2zl2Wtee6/jVvrOr7feV1f52zuq4X4tXyyK/tNnXtlP8tZeYf18xs0PPn9c62XvPNLYoPbTMbtv1jb61vy9q04n+HLZ5ZkLX9ob/26m1tydpS1e9brR39HPrNtps1r+v7HQzE3kJg7kun9rhZd2tV1u5qaWALSn2jyYnbLBG1SWBiz8W8ro5rpr/94lh/U6tv0iRwv2rNF+p/kTh2FLhmeb+BKT8JtcdtHDsS30K30x6hE+vnEFgvJirX583FPUWJPxabmeViP3ZoxdwH4pfXAAAAAAAAAIDCYfMaAAAAAAAAAFA4bF4DAAAAAAAAAAqHzWsAAAAAAAAAQOGweQ0AAAAAAAAAKBw2rwEAAAAAAAAAhZPeqRMnSVnm12/03Kw20ZK13V7fP280IWvjKHOzUhrJ2rGSn69sDmXtZmvkZkPzMzOzhblxN1teHsja2oT//4s01v/bOHtx280uXtTXPDblPyMzs37Pb8vujv+MzMy2kx0329rR1zU+7vfLbKDPWyn797TRlKU26Pt9Osr1NVvmX1ce6z67KfplFOs+u9vFaSLzKM/92kC7piX/2PMzk7J2ZdPvLL2efiYbTb92fqYhazujjp/1u7K2Xvbv9/q592Ttdt/v31Gu27mT+c9otl6TtbVEj2+P3XfazZLWiqxd+st/6WYrU1OytrF43M0mShVZm4o+nY10W5ZL/nKgMqbn69amP34NxfM1M5up+c/pzR/+QNZ++pGjMi+ywHRiUeT37Ug/SvkHwVLzzxssFn+gxlMzM/Wqx7rUVFOG2ipT1xU471D8QRRorMAUIutD96SOHZq7EnHeQHPIOw7Vym4n3oWbpcGO6YpFx8tlz9r9KmX/28HMzKJNN+pt6flz871rbjZ/aFbWbl3w270W12Xtxav+NX/11Rdl7fUPXnGzC9fOy9rG/GE3O3PyjKzNU39ttrHtr8vMzNodP+9NtWVts7sh86TqvxuNOb2OzcR3SXNd35Ol/nojDXyH91r+GnjP4iFZe2Pg1+4sXZS1A7E0r07oax5u33CzUTvQVrtYHAW2oMQQEwX2J9LEXwtHka5V80moVs2voWuOxTXHgUlfXlegVj2FKLTYUOcNrDVCbRmJ+lh/vstzx4FieUuBe9KfrIE1oQxDN+yvkYYj/Q0WiWPfztrqx4lfXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJJ79SJ1260ZZ6LffVmfyRr69NVN9szNylrmx3/ura3u7J2fX3gZn1dauP1yM1W1vzMzKxRH7pZbXxa1m5ud9xselp3j+mGn2WLY7L2g0v6+Y8y//lnSSZrm+3cP25f145KiZvNzfiZmVlz2z92HJdk7UTV79NXr/vP18wsiv3zpuJ+zMziyG/ntFyWtbtdpF8ri2O/7SLz+5iZWbnkt91WKzAYCGmqn2dJ5L1OS9a+/9Zbbrbe1LUbojGTWDf09MS4m3UH/phqZjY25teOT/jzgJlZb3tV5s3Xn3OzKNP3FJn/Tg7W9Xm315bd7Msfv1fW/ovMHyt+8MPvytpBp+9mSUn/n7s+M+Fm5a6er3/0ne+72TsvvS5r/73f/GWZF1kUGIBkHhi7FD1ymeW3c1r1B+rAgdLQWJ2IPwhdcy5rg9V+baChb+c5hO4qEwcfjvSZb6NryXkxMA3I9siDjSWeQ6A0u41nuNtl+bb+g5HfemlVt2xXdMJLV5qydvqgP6+PJTuytr3tz4Hlof4u+fTHvuRmo5FeT6RiHNnY8b+zzMx2OmKOLOv7rQ78tdloQq+fZqp7ZH5x8003G9qGrG1u+H1rPNbf4dVpf/2cjfQ9DXb8dczy5UuyNhbve1rW33CjoX/eblt/d07v8fOufvy7W2BSiGJ/3RlH+ltI/jYzsKBIxHdxaEJR39QqMzNLE//gcaLvNxdDSCza0cxke4SuWdaGJv3Ac8hFe6h1W/Dcoa6jDh3qs6K9Qmv+TPTpcuC8uVgwqjWOmf4Vcx5cqd4Z/PIaAAAAAAAAAFA4bF4DAAAAAAAAAAqHzWsAAAAAAAAAQOGweQ0AAAAAAAAAKBw2rwEAAAAAAAAAhcPmNQAAAAAAAACgcNI7deLZ+YbMr19rulmWjWTtlJXdbH1rRdamceSfd6jPm6YDvzbV/yeIxDWvLLdlbT7yr2t+XyZry5Ffm0f6mmcm/Wvu9IeyNk/0sfNh7mah51+q+lltTIRmpi5rrKrbct9evz22tvU1X7/Rc7NK4JoHQ79/jAa6nUtVPy+n/v18GNTq4zIfDf3nPT9Zk7VPnjjgZitN/T6/8P5lN6uUS7J2Yc9eNxvm+p0sl/17mvaHRTMz64r3fbpWkbWLe/22urZ0Tda22h03m4inZe3C3KLMD95zys3OXl+StZ22P39ZNzCet1fdbH7lkqx9+rG73ezVN1+Stf1B383SNJG1acXvl52RHjdLiT++5XduiXLnyXdOv5BR5OciCh47VBuJWrG0MjOzXF2zvxy4mcs/0CeOA3ngzLd62tuT6wa5nXSk4sBzyEN/cOuHlvTjD7SGiG/nfnaDtet6TVCfmnSzUarH9WjQdbNqQ6+f2mv+/BnX9Lr0Zz79S27WaCzI2iNTE252dG9d1p67cNXN8pa/TjEz6/T9tkqH+hnFkT83j2I9b2d9/5vVzGx+dr+bbXenZO3EzD436+Y7srZU9gfP4ba/TjEzi8V369iE3nfYvuHvD5Squt+pz9JRYO1dbfhr5OzHOpHcWXGgf8p1TBz47aVYcESBxYhcxwRqVf8LXrN61nngmsV1JYH9FnXsKFCrrioOLBhDbanKkyTwXoi2Vv3qZumtr+tUbej5q0MHlnyBlYo+r9qdigu6BOKX1wAAAAAAAACAwmHzGgAAAAAAAABQOGxeAwAAAAAAAAAKh81rAAAAAAAAAEDhsHkNAAAAAAAAACgcNq8BAAAAAAAAAIXD5jUAAAAAAAAAoHDSO3Xi69e2ZV5KIzcbZH5mZtba7vthrG+51em4WR7lsjYb+NeVjTJZW478/NTJPbK2Uhq5Wa+r73e7t+Vmea5r19Z7btbt6rYqJTrPc789qtUxWbt/esLN1jo7snY48LNLl/x2NjN76z3/2HmeyNqk7OelclfWZj2/Nsv1NefxUKQq2/3+wRe/IPO/+PZzbnZiYUrW3nPIf2ffuaHHvvHLy242Nzcra4/d/YCbdbb1ecdG/vu8vqX/z9lu+y/OoT3jsvb0mfvdbH52Wtaefeesm33+y/+BrP25Lzwj8/X1NTd78v5HZG0q5pk/+T+/Lmsvvb/qZo26bsuv/fWzbjYa6fd5NPDHitZGW9YO+/6cO1avyNq9c4fcbGp8n6zdzaJEv1Nx5K8nItNroEjUBslaPW/HKr6ta9Jxnvt/EAdq9cossE4RF3Ybd/u3B/fPra/KzER76PvVBw+eVwidVy2vw+f1/yIKfC+oWvV8PwxKcVnmo46/Jpg4qMfmKPPXBLVZPSekZX/+fOTwQ7J2/8J+N7v7sF4/7Z2tudl2S3xXmtlYreFmM1099+ZDv52zwDeLiW/H9bZ/XDOzUaa/8QYd/92oZPo7bN+Bk262unNBnzfedLP1Nb2OTVJ/Xm3U9Zyb9/3+cf3CNV2b+f1j0NXfYVfe9PPZ/fpbYzeLYv08VB4HJvYo8muT0HlvZ+2ljh24ZjXfhObARP0WNbD2Uver1qGhWsv0+GOx/p6J1IIy9PxFHgeev27KW3/+odpc5Coz0/0ytATSa6/bWfX9+PDLawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJJ79SJDx6Zk/ny8oabRV197GY782uTjqwd9EduVk1LsjbL/fOW0kjWTjeqbja0nqxtbbXdbH5+StbuRH7e7/vXZGY2P1Nzs2vL12RtvzeU+d79M2524ui0rL1xacvNRtu5rO32/Dyt6P/1jOXi2JE+b2R+v9zeTmRtKfHzLPb7pJnZqO8/h55oiw+DtNeU+UPHDrnZlz7zUVnb6bXcbOz4uKwdDPpuNrV4WNbWDx93s631FVl7ZNYfC5prV2Ttwt6TbvbOmy/J2slaw822J/W7fvqhp9zsxR/+SNbOTNdlbuLVGR+ryNIHH7zbzSZq+vl//pljbnbt+/5Yb2YmhhGbrej5qz3ujyPbm3rebG34/T0X86KZ2YOfe9jNzr35qqzdzSK9JDA5+gZr/eooVKzPLGXy2KHz+kJXFIn51V/R/d/HFkfP9TWr67r1u739I6g3Lgr9ZkWtGQLtoUSBpxjul7raFzrv/39NLU7KvL7ofyImk4F3I5pws3Ks++D+xlE3++SDD8nauw/6a4b5Bf3dmSdlNytV9XfYnjm/La9e0G31wcj/qG35nzNmZra2tu1mg85A1g4z/W0xNuGvkQZtvX4uDfw1w11HHpW11zffd7NeQz+HftdfI118R69jBx0xW8SBWUiU1gNrzUHXb6sk09/Ku1kcGAeiROSBBVQU+bWxyG4W39pxzcyi2C8up7p2KObX0Hl1e4Tays/z0EJVrDY6l74jK+tHf0LmUSK+lYLXJR+irhRxHOsxU7al6BtmZom45uBzkI8/cL8yK+YKiV9eAwAAAAAAAAAKh81rAAAAAAAAAEDhsHkNAAAAAAAAACgcNq8BAAAAAAAAAIXD5jUAAAAAAAAAoHDYvAYAAAAAAAAAFA6b1wAAAAAAAACAwknv1InPvn1V5pVKyc2ySB87iv09+VFnpGtFi/QGQ1mbDfwsHpOltnxt2w9T/T+GPPMvupT2ZG1jJnGz5ua6rL225GdpWpe13e6GzM+fW/HPe31T1k7k/rnXOuIhmVmtXnaz2G8qMzOrT1fcbLKuX7X3z2b+eU13+LGa/660W7rPprFfm5Y+3P/b+sbrb8v85x4842Zr27r/Xsn8cWbPySOy9mf+ztNudmO5L2uTof/OHpjNZe2xk3vdbO8jfmZm1mz7ffTY/AOy9s11/71pdfX9Xtvy+/fc3mlZ+8ob78h8YXbGzR6457Ss/Z//6e/6tQ8d07V/s+hmq539svY/vd9/Z/dsL8vaVtMfV//e69+UtTbnP0PL9Zz7/HN/6mZJop//7qbHdbGMCdbqSl2rRongWeNbvy554tu4Xz3qmVkujh3p6kjUBq/4NpoqJI1up3/4Cx1/lXJTHm5tdWIR6ePmKg70yTz37+rH+IiKIdbtmu34Y/f6ypqsLY3G3WzviX2y9qkT97vZPUcXZO3cdMPNqhOTsrY/9NcTkw39EZdGflsN9up5bEt8l15YacvayLbcbKykP1oqkc4Hw66bjU+IOd/MqnnHzabLut/NHX/EzTauXZS1o/6Om5UC7TEa+GPBeKJr87I/YQ+H+js8qfgjzdoNsTewy8WBNo3F2B3aB0rEHJgH5oRY1MZ6YSbnjFFwzecfW92PmVmkrjlY659XHdfMbP2K/x3VvnJO1iYVf6w2M6sfe9K/rsBzGAz9MWZrw99fMjNb2Ot/76bJre+L3DM3JfOzm/7YJdc4ppexcRLodyKLstCq7874cO9OAQAAAAAAAAB2JTavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJh8xoAAAAAAAAAUDjpnTpxrZbIvLnTc7M01rVJNXKzKHDHUerv56dxLmvb/ZGb5QP9f4J+S9Safz9mZkkycLPmZlnWdntdN6uO6Wtu9zbcbNTOZG2e6bbsdv08j3V7TCR+/yjHE7I2iv22jCLdHiXRtzZ29DVXKlX/vBW/b5iZ9Tr+NVcqgfNO+Mfe2erL2t3usY88KfNnfu4zbtbe6cja1nvn3ezt19+StQ8/eK+bPfXQnKxVw1uW+f3EzOzS6jk3+/bZ92TtmYXH3Gxu36Ksvbe06WazpWOy9sbaupt965vflrU7b5RkvnHksJu9/q0/l7XXt3fcrDR4VdZObzzoZmm5LWtLPb8tB9N1Wbu947dlq+fPx2Zmo44/3ldqeg66cXXLrx3/8P5/PQ7MY3Ek8lzX6iVD4LwqD55WXbOuzcWjDpzWIvk7jMCJZaXuf5E8dviqb1WoMheXFeo6SqIObGbqyvLAc1CXFQUuOovEsQP3m+f+ejF0zbvd9Qv+mG9m1pgYc7N+NJS1C3v8+aYe1WTt0YUZN4sDfXAoVkHtdmDdJr7h0jywHs5ErsZyM5uc8Nf/xxZnZW1P3NPKtl4vNNv6nibHx92sPqGfYd715/Vjs/79mpnN7ltws6z/jKz98z/7AzcbDXTfUV+t1YZex2xv+s8hC8z1w57/LpXEnsRuFwXaRb03SaBWrQniwLd8JM6rsmBtYD1RErHKzMyG4thpoq85V/NroJ13rrzpZp0d/zvIzOzC26/I/L7jT7nZMLCH9J3X/bG8MtLzwNxePwuc1lLRXvvq/nhqZvbelt9ewfWT6NPBZZtwO+vFH6cP76gIAAAAAAAAANi12LwGAAAAAAAAABQOm9cAAAAAAAAAgMJh8xoAAAAAAAAAUDhsXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAonPROnbjbyfQfjHI3ist6zz0b+dmgI0IzG7YHbpYEzpuO+fmwr8+bxJEIZakNe35brq61ZG19yu8CA78pzMys2x662VbTz8zMymMlmaep35aB5rCjY+Nudq6ln+Haxpab1Wersra35V9ZudyRtUnJb49yIvqGmU3U/KzblaU26PvvWR4FOsAu1538QOa//9JlN6tUKrK2Vvf7yvxMWdbe6L/iZmur+r1JEj9PYl1bGveveSzaJ2u3Gn7/3hgFOmHDH7/Ue2FmlvR7brY4MSZrTyzslfmgfcPNfvlX/q6sfeeN19ysPOdfs5lZY+jPFVlL99nKuGivVI+cl1vrbpaU9VKhu912s9IwMG9WxBzUD6wTdrGymvPNzCK/3XLTtZHKA6dVfyCPGzy0P9fcLBbVgVJ14jxYq+43xP+L0GlDvxxR5w69FbE4eR66KfEHt3NPoT4rn1Oo6wSvTBXfTmPtbqWyXouYGKPKFT2/xmL8umufXk+kuT8HDgLP5NJFf93Wz/U8Von6btZcuSRrmzs7bnbj+pKs7Tb9+TPw6WhxPOFmlaH+7shMr/EnKg03m67ptjxw5KibHV6clLVHTh3wa/fvkbU3rl90sxd+8C1ZG4vvzpCR2LOQc5uZpWLAztVxd7k41u0diTFE7pncLPbPG3ge6ryhRYG6pyRw3pI4bRbp9bu6p1KgXw+yW5/nssz/ngn23EzvEw0H/uD3N2/pgfF6dMjNPrng7/OYmY1G/nXFsf72H4n56ZuX/G9KM7NIPMM82Gf9LPQc9NqsmGsgfnkNAAAAAAAAACgcNq8BAAAAAAAAAIXD5jUAAAAAAAAAoHDYvAYAAAAAAAAAFA6b1wAAAAAAAACAwmHzGgAAAAAAAABQOOmdOvFgMJL5WKXkZvecvk/Wjpcn3GxteVnWrq1vutm11SVZ29vJ3KxU000dR5GbRbn+H0N53K8NtXN3Z+CH4prMzCoTFTfLNjuytt+TsSWxf89Zvy9rn5ze72YL7XOy9qvdoR9u6HsqlcpuVhdtZWY2MZ672XCgn0OpXHWzQVdf87DnP/9qyX8HPwxef1u/z3HZb/fxMf0+j435/Xd60n9eZmazUzU3q6SJrC2LPE3184zE/zKrJd1/dzrX/eMGxi8z0b9117e87o9vZ47slbWfuucRfezIHwsGHf1eHT5wxM0uz43L2hulfW5Wam7J2jTy22NsTc991TMNN/vsfXrO3Vn326Na089/a8uvvXx+XdbuZpGY48zM4sjP88ifL8xCv0oInVccO/A+BmJdK4tv/ch56H5z/36z4A37tbfTFjcPrcZF/fxN1Vqg9jYq1TXLS/p/c3B5Xj/LAifOxYlv9xkWnZrjzMzKib/OKTf0WmRq3l9v1Mt6LdIb+Gv8d94/L2tXt/17quY7snbftL/OOXTQn5fNzNLEb4+5SX9NZ2Z25cIVN+s09Vpjq9Vys0ysB8zMxmL90qV9v71OzMzK2ic+/qSbTc1Oydpe13/+Jw/p5/DEww+72bnLb8vaa1f8dWy/q9uyPOZ//w2H4jvbzMqVMTerTPjZbqfWOGZmUaLmwNDcLI4dKFXXFQXOq/I4sOaTo3Gkx9sk9s87DHyDqWsONXOe+e9F6H5Dz+HF15pudvz4Xbp4zd+Pu5gdlaXly2+52YETJ/R5hdBa5HbWG5lci+ojZ7nfVqJb3VH88hoAAAAAAAAAUDhsXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABROeqdOnA11Pj+7389Giaw9+/prblYfG5O19x7e62aNiYasHZb85tzYWpK18xPTbtYdDWTteH3czW5s3JC1w47/IBrRAVl77vz7bhbF+hkNevqeslLkZulYRdYulPxnnO1ZkLVjtuzXDv1rMjNbnD3qZnE0krXt4Yab/eTR+2Xt95fecLOH7j0ha5trfTfbv39S1u52SU8/z4Hoos2ufp6dpqjdactadezpRlXWTjUm3Gwi8K/KKPfHgv7A7ydmZpFoyrFyWdaWxFhRSkqytixmsK0Jfc0Xr+uxcXFv3c1ee/esrN13yJ9Hvvn892Xtqris00fvlrX3PvCgmx37lc/J2vIrX3Wz2deelbXVmt+5eh091tcSv08frY/Jx7kAACAASURBVM3I2t1M9V0zs1i8U5EKzSw2nSuReJnzXNfmojYKXJNaMQTvV7VVsC38fBS44VGmDhu45jxwXZF/7ij4uxO/Ng+0R67uOXDNqrUCXUcLFvvXFYdqb+vCdrdsqNcx937Wn8d644EBbMsf10e9jixduuF/L1296q/RzcySxP8+2L7mf7OYmQ2PHnSzeqq/afYf9L9Zj584JWunG1NutnHtmqzdWPbboyO+78zMSlV/vWhmNoz99deZU4dk7b6DflsOumKBbGZ55F93u7kua2+s++0VWMZalPhr1TzWxYONln/cwCCjVkilMb1+3s3iwLxukT/PhdcEoja0Fkn82jTRtUM1RwbWBCoPtZVqD7Wmu1mrQllqkVgvRIkeM3uZ3o9bLvv7F//Fx2uy9n993v/OPr+mb6ok9txCfSdS/U6s6W7mciGrqX4X/JmyX6uWuHcSv7wGAAAAAAAAABQOm9cAAAAAAAAAgMJh8xoAAAAAAAAAUDhsXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAonPROnfjozB6Zn2zMu1lnpStrHzp+n5uNuiuy9rsfXHKzuXIka/cMJ93sgWMnZO3F6/51HamMydqXLi+52f4p/5rMzE49fJebjVemZe3y1rKbdXs7sjb0f5NKqexmC+NT+si9zM3amx1Ze3zPGTcrWy5rL7//gZtNB57h+N4ZN3v1YlPWfubJp91s6fxVWVsyv63e+ot3ZK39+zouusUDfh8zMxuJxx0nJVlbG6+4WRIH/mcohpleeyRL14f+e9cb78naJPJvWI98ZuWyf0+9UV/WitNaFOkzp4mfzyzOytpyU7/Pr1wWc0GjIWufPH3IzZ59MfBetfz57Z0fvSlLe+//wM1WWs/q8yZ+31qcH5elo9yvzXSX1f29PwwU716lVPdt1fdD76OsDbxTKo9DJxZy/brJPA/MvXku7jcw3MbippJAS2eZf10iCp7XzCwS544D7RGJm1ZtZWYWi+c/HOj1U1ry570s0AHUeVU736z1szxw3ly0lZqbPgz2ntbfB3LFEBjXO9vbbjao6LXI2Xf9OXLQ1yfOWv56+fF7T8raRx960M1mFw/L2qTkf04P+vq9mZtecLOpuv9tYGZ28IjfllFg8h1m/vrfzKzV9/P9x3R7xOK9Wr96TtYuL/nfLeOLp2VtX3x7NlvrslatgSzQ76rj/jdeqay/F7ot8b08+hD/xjBJdCwG9tA6Ru0xqLnm5h/41xX6fEsytRa5jTVfcN0mLixwzblq58BaI8v8Nbq8JjMrx3oemB7ccLN/5yv62IPEX4ucmNXj3pFSzT9usO+oPPAMRW1g2WYWfB9urTS0frpTPsSjIgAAAAAAAABgt2LzGgAAAAAAAABQOGxeAwAAAAAAAAAKh81rAAAAAAAAAEDhsHkNAAAAAAAAACgcNq8BAAAAAAAAAIXD5jUAAAAAAAAAoHDSO3XiG6vrMq+/t+xmj9fmZe2zl6+5WbfdkrWfi2tuNvGxe2TtN7/1opu1ltdkba8y52aXrl6UtR/dt8fNDj71cVl74oGn3Cya8K/JzCyp+P/7eOHt52VtKZqUeVqputmxmRlZu1odull9OC5rHxx13aw3rs9b23/Kza5cuSxr4+VVNzt5siFrH9o362bDfcdk7ZuvvetmOxcuyNrdbnq+JPPBsO9mWeRnZmZx4vfBLM9lbVpK3KwR6yG7nJbdTBzWzMxG5l9XEkWyNhb3FGUjWTvM/bxS8scBM7P5zJ8Lxm+Mydr/6tmvy/yZew7459Vdx5799nfd7I+/6WdmZr/zH/7bbvaZB47I2t979m03e+3V78nafaf8DpKYfv6qR2fmvwtmZknuzyN5rN+z3SyNdZuqJg+8jhY6tKxVTzPSv3dQ1xUH+pDqRfmP8XcW6qqCzShuOM91v48jPZardyowhcha+XwD1b1Vf21tZpY1/PF4rOavrc3MEtHYeaDDqzjLb73f3cZrtDu09B1eec3/bvnYx47L2lfWl9ws3acXI8urN9ws7+v1xH2n/XX4Jz/xSVnbrOx1s//hjYGstW7bjc5f9df3ZmZx5K/bDh3S32FzjYqblQNj0P6S/h6+f69/7LRal7XdTsfNlq9fkbUvfPc5N7v7E3ocOfvBOTebnJuStVGcuVmnqfcsSuN+n968ptcxpTH/+dcm9X7HbhbHehyI1UImMDgnYq0SmhLUfDIS61Uzs0hMZFFwHvNz2Raml2ZRoJ0jMQeqbzszs1x834Xmz1Ksj/2llv+N9ge1n5W1v/oZf9z8p8/psfzZLX9/6tGpDVnbmPHPGwWeoeqX6hn97R+41NoqWDwKrRfvDH55DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJh8xoAAAAAAAAAUDjpnTpxXNZ5Uo7c7LmVC7L2yty8mx3odGTta601N/tU96isna3415ytNmXtctJ2s4M7LVk7mLnLzaKZY7L2v/nH/8TNjh46KGuPHjvjZj/x6NOy9p2XvyXzfWnVzX7hF35V1jZfe9nNygsDWftHf/pNN0suPidr06H//Bv9vqytT/r3Oz77vqz9V7/3gZutb5VkbSXy35ULF5Zk7W43XhuTeRJNuFke+L9fmqqhNZe1eZS52XCk+1EsLivLh/q8I/+6okRPFYnf9a1c0W0VZYmblUYVWVtb8SeSs+fek7WVkr6nNPHfndff1cd+88aWm+2dm5W1M+0rbjY2eZ+s/c1f+yk3+9nf/JasnTvi32+5Jh6wmcXifej2R7I2Tf1jl0r6+e9mZXHfZvpdzi30PPxcZWZmeeTn6j2/eWyRBX4qUUn8cWAw1H0oivyDi9sxM7NMDMcjfyg2M7Nh5F/X1vJ1WTu974DME9FgsbhfM7NIzDGhvmO5X1tN9XN4/bvfcrPGxLisPbBnwc2SRb0WTeqTIgzd7y2Hu94g0muC2vSUm53/oT/HmZmNun4fHeX6mVRSfywY9Xqy9vgRv6/kA71+enVp3c0mdNe3/YnfHvef0h+8H71rv5ttvaLHkZ2rO2621NLfO+92dHtcO7zHzT5xVD//OPb71vqm/h7udf3runHVXx+Zma1ubPjXNNTvcyv3v7V7A117+Lj/LXX4qF7HvPSNt9xs6fJ5WbubJYHJOVJ5sNYff5JY15bE2mwYGLvUNce3cb9RYB5T9xtHuu+q9UQ20HOEWmuE1ilHt/U48NT3/9TNZk9vy9qv7v2HbtYc6vH4yz/t7/VdfvdvZG08N+dmeeA5RGJtptblZuF1vSKvKi7mGohfXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJJ79SJSwtjMu93Om623daXXckzN4tjPzMz69rIzbaWm7L25EfudrM3378qa2vjZTcbvPyerD179byb/eX/8s9kbWOi4mYvvukf18xsbavrZmfqPVm7tVmX+bnvv+FmR6t/KGsP33PSzf7N178ha09OltzswuamrF1b3OdmC1fWZe36YuJm1bJuy/y9Df+azvVlbad62c1OdPx34cMgDvzvbjTy7z+JdNvk3YGbZYFas0gkuT6viEexro0jf1wd6WFTjqvR0O/bZmaN2B8LDnSPyNprm1fcrDfyn4GZ2dSMvql+z2+v2boev1rXdtxs/5Se+6bmpt0sqtRkbRL513xsYVHWvvZtf7y/53F/frp5YUM3qlb18+8O9XP6sJqq+O+5mVkU+XmW61oVR4FaE+cNPEpLYzF2Bc6biOF4OPTXg2Zmrbbfh2Zn/PfJzGwkrmugBlQzG438i77w3tuy9uLLL8v8vkP73Wz+vgdkba/kv695YA6JxPwzL8YmM7N9Z4652dUr/lhtZnak76+vLzz/dVm7U/PH44VPPyNrVWsEHv+ut3F5S+aDnr8m2Cr5604zs3/rM59zs5WVFVlbLvvr8EN7jsjamYbfF/qtbVm7suyPM9db+rszHq662f7ZcX3es/46faGu5/y5fQfd7LCsNLv/+nWZf2vdz5fjtqyNzP9uaTV132l3/fYop3rd3tz0x5HRmL9OMTOrzfptPTGh1207G/4cNGy1ZG11vOpmcTmw+N7FYjXpm5mJ9axaH/3tH9zyeSOxjokD6xh1XaFrjtX6KVAbRf49hZpK/UGeB75XRX5yy/8OMjP7pRt6PO79/V93s7s++UlZ+8W2/75+8IJ+/l99zR9/9uzoPZU9d4m+I9ZWZnrdrlcqOg2NIKHuUUT88hoAAAAAAAAAUDhsXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw0jt14vVz2zI/0Zh2syvdXNYe2Wm62Va1ImuTqO1mzaVVWXvizCE3Wz4ykrWPHptzszfePCdra/m4m33uk4/J2o/df9jNXj97Rda++OZVN+v3Ilm7fv5dmR8QzzCpDGXtxeUbbna1rJ//Rx845ma91XVZuxb5z7i7lMjaqFxys69uZLL22D6/79w3c1DWfqvpt9X1D/zn+2FQj6syH8V+Pysn+nl2+wOR+s/azCyN/TyK9dgXi64SlfU7OV7x342dXkfW9vp9N2skM7L2eHbKzZqdHVm7PvDH6/hR/b/Z+6v+HGNmVn1b1OdlWVtq7HWzcq7vqT5Z98NU951s6F/XE4Hp/r99a8XNKrP6vKWG3y9LVf0cktzvl8mY7rO7Wa2s2yUX7aJHAbNM/EFuuk1VWgr83KHf9OfI6Wk9DqSJf/C+Xj7ZN/7sm242Hun7/diDZ9xs6qQ/NpmZZeKV+sQpPfdubesxdaLnj23R974haw8eO+5mK3sPyNpeZczNuq2WrB1trLnZfFWPIZeWl91soe6vcc3Mro5N+GHg+Ue5/7IESne9Q3ftkfkw67nZnvmGrJ1ubbpZlugR7HLXXz899uijsnbvnL8enp3R1/xUyb+uV77vf5OYmV0Q36Xv3fD7tpnZ5pQ/wH187xFZO35DfJd09DW3AjNJd+gvKOcm9LdUHvvjSHtnQ9aOMn/tPV3zj2tm9uTj97vZd999R9auX/Hbqx0Y+yZq/vdE3NETZynyx8ZB1JW1u1pggI0jv92iODCuqzxw3kz8rjMOfINF4thRrPuBuqw4NI/J2w21lX9dmXgXQ+f96JLeM6n90pdkvv7pn3Sz8bbeQ/zM13/XzU639Pf7P5j/dT/UQ5fFYgUd6rOhIytZJBf9UnUk1prpHdsmlvjlNQAAAAAAAACgcNi8BgAAAAAAAAAUDpvXAAAAAAAAAIDCYfMaAAAAAAAAAFA4bF4DAAAAAAAAAAqHzWsAAAAAAAAAQOGweQ0AAAAAAAAAKJz0Tp04y0Yyr52+282mXn5F1s5vbbrZTrkia6ux3yTd4bqs7eXvudk9p++XtWOz42728K98StaefW3NzXZaHX3e8Rk3+8jDc7L2vQvLbnal35S1x564V+bXvv2ym221NmTtVsPvWw/OZbJ29P6P3Oyhh07I2hN7/LZ88eqKrLXymBt9sKqf4dG7j7pZZSeStU9/5KNu9ubS12TtbtdutWQelRM3G2ZDWZvlfj8bBWp7UdcPR/p5dvo9N8u7geFeHDoJlD5Ze9jNpkazsnZ91R+vLzWvyNprB6+7WSmXpZbrx2+dzsDNdtpVWTvzxhtuNv3UaV07Kdqr5M8TZmb5s991s88ePCxr//sffcfNmi09bx7Z5+e9np4Lyok/9uXmP4PdLjfdQWPxPkbqZTWzKPLzKNbnzUf+/LmzuSVrO81tN/vOXz0vax85ecjNZhf8udXM7KdOHfRDvdQ0u+aPMa+//ENZOvfIo242P9Lj/J408AxLNT+TlWZp039O3dk9sjYr+2Nbr66fgz3mP8M81/2umvlzZmfpqqydmfbHzP5Ir/mUwBSy623pTxqbmvZ72hd+7TFZW3nXb73+S/43i5nZ/HTdzSbG/czMLI/9dVt5fFrW3jdRcrP/PNcDyYvv+L8F++EV3Qd/sOy38zvmr+nMzPYv7HWz8tx+WZtV9Lx+qO5f98F9+rtkdWXVzRb26bVI/dwFN1t755ysbd3wv0tH27ot05L/HMpib8DMbOWy/126sDApaydrfp++79GTsnY3S2L9+8lYLIKiQK1F/vij1kc3jy2uSYU3Dy5qb7nU4iRwzeK3qFHgxGo9mQW+V/Pcr/2zI/7YZGY2/4ieQ5I//EM3m/2rP5e16Y4/Pi3M6r2tL/6av+e2ePeCrL2+7X/P1qYC6yf5mPQzjFXnCay9BuIbLMuKuQril9cAAAAAAAAAgMJh8xoAAAAAAAAAUDhsXgMAAAAAAAAACofNawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw0jt14tN375f5sYOzbja+MiFr0wOH3Kz7w8uy9p0J/9iNI3tl7ez6lpvN5JdkbbLnIb/2xB5ZO9Ufd7O333pN1l48c9TN5md1O7d2LrrZ448+ImuPLR6U+V+9+JabXb68JmsnRd+ZOlCXtWvnrrlZdaEka+dn/dfpU//wi7L223/0DTfLkkzWrm513ewnn/gJWRvPTrpZ5+HDsna3i6v6eXbjtp8NO7I2Tf3/Cw57Q1mbZ/7zzgL/bqwkVf+4nZGsjQd+e3z2kO5HDau52UpzW9ZeGvhj45X6VVk76PTdLBHPwMysnOjnsJn13Oz+N96Ttc1S4mZf+NhjsrY6Oe1m+famrM3eeNvNpr/8G7L2Y2+/6malRX9MNTNr2g/cLKnr59DP/Hdpp92StbvZzkC/j4n6bUEUydrc/DzLc1nbXbvhZudfeV3WLkz4Y8hPndgnazeu+WuzzoZ/TWZm45l/T/ML87K2P+Gvn+47eULWvv7Gm24WPf2MrM2SisyHI/+e8mZT1tY3V92sJeYIM7PhwD9vNNRrkdgf9kx0STMzy0V/z/cc0MWK6Bs3z6vzD7MTj/jfHWZmrRv+fHL8yKKsffEHZ93si09/Qtb+zav+XDSIy7J2RXyHvfPyS7L27EV//b+xsiFrE9G/D83MydrHjvjfw7WG/t7ZXvXXIsur/jhgZjZI9Bo4Pew/43ND/Q0fpf5zqs3qb+nDM/5648TJu2XtP3nOX4v0h/560cysUhVjY6q3S9LUb8s4VQOjWR77Y19/y1+H7nbits3MbNRed7NSQ79TFvkHjwPrp0hcWKg2l+eVpRaJ2igwgYpSiwLXHIvifKS/k7LMX8f2A1Prxlf+QOZzb/nzQLbj73uYmTV//VfdbP1zPy1rn674e1+//209ptrgAzc6NjUjS9UzDjxC3TtCHc/88UntR9xJ/PIaAAAAAAAAAFA4bF4DAAAAAAAAAAqHzWsAAAAAAAAAQOGweQ0AAAAAAAAAKBw2rwEAAAAAAAAAhcPmNQAAAAAAAACgcNI7deLf/MWPyXx7O3Oz8fG7Ze1oOHCzPQ+clrUT33vXze79yMOyNtq47Gfzh2VtuTrhZqO+LLXxxbabPTpxUNY2Zmpu1hvuyNoz9/jHbnWuyVobTcv40Z973M1W39+UtWMTFTcrp4uyNr5+3c0qeUnWDqzqZhOz+v9Ei4/7fbq5fk7WmvXcpLp4QFZ2Oltuds+n/GfwYTAa+e1mZhZlIzdLh5GsjSN/aK2N+f3EzGyY+2NfKfDvxkHPr31oz32y9iePPuZmzc1tWfvCubNudm7wgazdHmu6WTnXNzwY+Xlu+hkNE//5mpnV7/Xb8uIp/Qw/9dpRN7vnlJ+ZmaX1KTf7zp8/J2v/+uxbbvbIxfOy9tSJU272/tYrsra+t+5m5Yo/HpuZRZa72dzsvKzdzXYG/n2bmUXm9z+LdN+OZN/X561W/Hnucyf3y9qhGDPLK+uyti+uq1fz+5eZ2fVmy81WU12bLfh9LNrxxyYzs7mH/fbojsTzM7NRpJ+DeoRRoyFLNxuTIg2cV/S7KNe1Q1EbKA2M1rot5VgfOPHtpLvd9rpep+fRmJv94J+/JmvfPe+/78e/+BuydnPLX2+8saZ7yk/d47+Tpdz/NjQze+uq/76PHdoja1cu+uv0Ydf/RjMz2xv765i++J41M3vpHf+b9Yev67VXUvW//8zM9r/+npudOaHb46Of/pQflvSaYCqddbPh3iOyNisnbjZe1eu2g4cW1JFl7fVLfp8tT+g++5OffcrNUtPr1N0sEf3ezCyZFOu/OLAGEmukODDbJOrYulRfVhT4gBO5up+b5/XnKnk/ZmaiNhrp8ScWz3D+kr+fYmY2cc8+mQ/Et0PzAf092/rSr/nZtSVZ2/jXX3OzL/3Vt2TtVz7+tB/e/4iszfPAc1JE1+q39F7eoOvntem5W72iHyt+eQ0AAAAAAAAAKBw2rwEAAAAAAAAAhcPmNQAAAAAAAACgcNi8BgAAAAAAAAAUDpvXAAAAAAAAAIDCYfMaAAAAAAAAAFA4bF4DAAAAAAAAAAonvVMnPjg3JfPr4sp2dvqytttbdbP5/Xtk7dGfP+pmU/vnZe3Bfafd7NsvL8nasfEZN5uZ0/9jOHZ0wc067Q1Z+70fvelm07M1WfvTnzzjZjP1sqx97/1I5odPL7rZvpN+O5uZ7Tk4dLMk0205bg+52ewR/5rMzFa3/H4Z5fq8n//p4272q9N+O5uZDTM/W9nS71ke+S/acKjfs92uPdD3F5VzN6uWxmXtMB64WTdq6dp82s2uXCjJ2tn+ITfbv+eArP3G+99zs7d3LsjarazpZkms+34Wjfww1VNUNfHbo9nuydqkrNsyGfpj2OaOHt/GHxHzyEE/MzMbtDpulv/vfyFrf6Ln9zsrVWTtJ//OL7rZxDlZalcGP/TDTAxQZlYtibaM/Hdwt0si3S4W+XNkZHr+NJEHK0f++7h96ZKsTRP/fe2picrMRuY/67Upf0w0M+vO++Pe1MI+WTvM/HkgmazrWjGHpKGGjkN/4LdHJDIzszxXtQGq38X6GUZqqA++yv4f5MGL/jGd98M7/JiZWa/flnlJ/L5p/nH9fXDv5/e62WBMrwlOPfERN3vt+YuytlLd72YPPPi4rN3X8L/Dlm/435VmZutH/ftd3d6StaeO3+Vm+cj/njEzm/vsnJs987j+/mv19LHL1Qk3O3xErycHm/65lzeuyNqPfP7n3ezlJb0Y2XfE/8bvDvVAcurQKTdbap2Xtf2B35YLs36/MjNbXfLXz6WJHVm7qyVJIPfHidD0qfJIzHE3T+vnWRS4ZiGSE6RZLK5LZTePLW84UOtn2Uh8UwSKF+p6/TT+S/43h5lZ8sYbbtZe35S1vW3/ven91j+StXvOX3Cz1PS+weIHP3KzyH5W1srlxlB/z/a6fv7eGzdk7Whwwc3uf+InZO2dwi+vAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJh8xoAAAAAAAAAUDhsXgMAAAAAAAAACie9UyceRbnMry713aw81tDHHnTdrNaYk7XT4xNu9sq7b8rai6tlN0vSkqxNxvy8b35bmJmV0yk3azT8azIze+YTJ/3z9vR589T/30dsFVlb0s1h+w7Mulm7p49dr3XcrNXtydpWZczNuuubsnY8rbnZWKUla6Nq1c3afX3N/ZH/Li0tfyBra5HfP6pjdVm726n+a2aWVjI3E01uZma9UeRmSabfyQvrP+9m1174iqyNs+tuVj78nqytVBI3G58dl7Wz5udR5LeFmVkp9aehqKSnqMHIfzcOlHQ7R009j/zrP/LH+5lcH/tj/+VT/nkTfU9X//BrbjbV9/ukmdnUhP/O6pnP7Nr8tJude+GcrI2qQzfL/W5lZmaDvj/PZLm+390sMT2IqLcm8EoFjquLB4n/wHbue0jWlrY33Ky+tCRrq2JRMHfjmqy9tt12s7F1XbuS+u9yp+f3azOz/UePuFk/1s+3u6PXBLVpf10X6gCjgf9OlQJr0Vz0jyjUZyP/fc0DfVYdOXReVZ0HSnP1B7fzou0C1USvpZ9+8Iybldb098Fb17fc7OQZvS69+9BxN5uIdmRt3vXHgtLUpKw9eO/9bja1sCZrr1y67GYTE/63gZnZ/tn9btbt+d8zZmaVxB9zk0kxhpjZ6qpfe/PcAze7+rZeE3Sv++Pukc88Imtn7/bnmXdfeE7WVsf9d3Z7U7flO0t+v2xvNGVtY9Z/xnFHj7nLbX/dvrKtz7ubxYkeXyPxiRYamtV3RxLrbz9VWwqcOFdzUaA2Fnkcul8xbweaWTZmNvLHgJulfu0bJw7K2gdqelycPX7CzdbjC7I27flj2+R/9zuydviW/+3Xuuq/q2Zmjbp/T6G2NJVX/b0pM7OtZX/eu/vAjKw9e/6sm0Vl/a17p/DLawAAAAAAAABA4bB5DQAAAAAAAAAoHDavAQAAAAAAAACFw+Y1AAAAAAAAAKBw2LwGAAAAAAAAABQOm9cAAAAAAAAAgMJh8xoAAAAAAAAAUDjpnTpxZBWZj6WrbrbTGcjaPI7cbDjoy9rZPXU3++TUflnby/xjd3NZan/9va+72cL8hKydnlhxszNHa7J2bEzluq26g66blQb6vOXxGZlHtu1mFy9tyNq77/L71upKS9ZeuHrBzSrVcVl7/NC9bjbob8narY2Om03P6c7T2em5WRzp2rXWnJs1hrqtdrv6pH6vKhV/eEySTNZGSeJmmY1k7fS6/z6/crAqa7sDf/w6fGxW1g6G/rgaRyVZG0f+/Vpg7BsMh/5xA/9f3RvvcbMjw8Oydqbut5WZWXxP2c0eP6PngvriETdbP7ska9/46rP+cWP9HPq539ivfOV/k7W/1/Ofw+Qhf3wyM6sf9efrWPRJM7OpeNE/b0XPE7tZ56c6bgAAHnFJREFUEulxII78dUzodweRqA39YiEW41O/ovtfuzHpZoN9h2Rt0vH7WLZxQ9aemPX7/UTXX6eYmU2LdVtLrHHMzFqvvOBmM3edlrVXzl+TebXmrzf6e/13xswsL/tz1wcvvSpr7z3mj5vtGb2uG3T8ftfZ0WPI1Ly/FglMIRaZPx+vLi/L2um5ef+48h3c/b709x+WeWXT74OHjvjrXTOzr/3+77vZQ8f0Gv5ffuV/dLPx6LisHfT893nQ2pG1kfgk3gz0o9UVP5+a02NfWva/WfKe/t7tj/wRvZT5c7qZWXVCv8+d2B//tpf8Od/MbDjw39phqt+rD370vJv91Ys/kLVrO00364ux3sys1Wr7oW5K6+74z2mlor//pqpTbjbqiLX1LhfFgXWMisU+j1lg7A6O66LNA6Vy3RaolSu+wDWrPLTmy0VtPvT3F8zMRuK7cXtHvzQ/fOE5mf/M8y/613VGj+XZ0l+62fu9j8vaG01/PH7iC1+QtQtvv+lm53tifDGz2qT43on0nsNw1V9fvbKk55CdTX+v50xczPGHX14DAAAAAAAAAAqHzWsAAAAAAAAAQOGweQ0AAAAAAAAAKBw2rwEAAAAAAAAAhcPmNQAAAAAAAACgcNi8BgAAAAAAAAAUTnrHThy1Zf7QPQtu9tLZXNYeWkjcbHtH79dHSeZm5WpZ1pbjSTfrrK3K2k88ctjNzi2vydrWsOlm7VZJ1o76fTeL00jWVmK/nbtt/Xxfev01mR/cP+9ml1d3ZO3J7j43W5zzr9nMbOHjh9xsONR957mX3nWzim3J2mOH/P4+FtdkbalWdbNyovvsu53rbnb2SlfW7nb12pjM09R/d5JMj0FR4g+teaC2Fq272es1v2+bmfXX/X62fEW/z3v2+/dbTf0+ZmY2GHbcrFTWfXCQ+O3xSPqwrH3w2ENuVp2ckrVRrN/nqTl/PJ8c1+NqXvbf2f/sv/7HsjZr+s//hn6EdsmfCmzU1nPQ9LQ/5h44+ICsfWLup91sfMxvRzOzOPHH5ETMMbtdko8Cf+E/7Nj0GKLSPPCbhdFo6GZJpDtgq+XPzdXJaVmb1f13ZpD544uZWdbw+24z8M5kff/YSRx4zzf9tVmnrJfXi0f8tYaZWVVcdyf3n5GZ2TDyz/3g3llZmy9fc7PyzClZW4799fPg7Duydu2KPx/PPfigrFUuv/a6zN9fWnKzE09+5JbPuxt85IlFmTcq/jt77vIVWTvd8PvghSsrsvb5H11wsxNH9TW/8aa/Dj88V5e13VbPzS6cvyRr233/frfWB7I26ftr7c1t/b3Ty/x3bmX1vD6v6bVZK/MHofbWpqztiuv+vX/1f8ja9Q1/rTLMdVt2m/4zzBI9Gah5M070XJAN/OsqV/R83S7538vDWNfuZmngeagleh4F9nLEWiUOrGMSsfbKA+sJtUaKAtc8Gvl9KEn1u6rWixa431jEmVgPmpl8aQK3a6+8+F2ZP3j2rJtNPqC/K25M/sduVtl6T9Y+8/m/62ajQAeYvXLVzV5L9b7Y9Oycm20tiY87M6uIvZ4o0s9wfdW/rkh1jjuIX14DAAAAAAAAAAqHzWsAAAAAAAAAQOGweQ0AAAAAAAAAKBw2rwEAAAAAAAAAhcPmNQAAAAAAAACgcNi8BgAAAAAAAAAUDpvXAAAAAAAAAIDCSe/UiXsWyXwgsrFqImur436eJGOyttddcbM4zmStWddNJhr6mtO87GYzkwf0aYdDN0rKqiXN2v2+H2YlWVuKcv+S0o6sfeLBgzJvbvv94/RiVdZ2235bjo2NZG0l959T1vOfr5lZudxzszjW1/zqpTU3W9puy9q7Dk672ea6f01mZqtL19ysP7pjw8P/J2ppQ+Z57r/vcazf506v5WZjqR6DmqeX3Sxd0u/z3ff7780rf6P70X337nGz+v7LstYS//+guR7qrdT2+1nSqMnauOyPUXngxMO2HqP6raabTRy5X9b+m68/52YvbPrHNTPbNDHPZP6Ya2Y2OTnlZuWyHoPSkt+WszOzsrZe9/M4DvyPXDwnMcXselmm56Io8tslt1uvtcDaq7m14WaNad0PRgP/ncpv436jQEeIcn8NFLrfTKyf0jF/LWFmloq1aCLGxP+rXTuNkeSs7zj+r6qu7p6e6Z6da2d3Z4/Ze73r+EbGYBxDMDHKSRBKSCBRglCUV5HCu7wjb5JXiYTEi4iEFxEgEQiHYsAEDNgYGxvshay93vWxh/ec3Z2zZ/qsIy/Im7z4/yoiUqbG+n7e/vbX1V311FNPPTtmZklrRuZt8ZPDgjk17/lzfXZ0XnbToZp/9DVMMr87fuKo7K6vrrjZSKiPa+K4hw7uktXVEf8ajjb09d/q/ulz35T5zJg/CO+5+52y+8Hfud/NVldek93GNn9NcGS7XgM9ceq6m52onZHdtQ1/3Tazd15224k/Br/3oydld/z7/ry5VjB/zezZ72aH9s/J7vlTJ2UejTTcbNgR745mNhzz1xs3Fpdkt7vhv7dURvX5CJqjbhYm+jtXxXpy0NHvUsnAv/5BpN8XsqF4flXfun9jWHRe1HNOr3HMwsA/b2FBV65FrGAtIo5bcFiLKzU/LHjoB2Ke6G+s6wNn/vjLMz3fyh9V8IOHsd5j+OqJY252x4Jei05n/tw1NvNu2V1Y8vdjRupN2d31/ve7Wf/fHpNddYlP/uSa7K6s+OPy4x86LLt//5KfDboFY2eTvHVnRQAAAAAAAADAlsXmNQAAAAAAAACgdNi8BgAAAAAAAACUDpvXAAAAAAAAAIDSYfMaAAAAAAAAAFA6bF4DAAAAAAAAAEqnslkHHm82Zd7rb7hZs1GX3aASudkPf/Sy7D5034ybNZoD2U1T//8CcstkNxfdMMhlN6z6n93p6e9csZqbDQdD2bWGf55j2yartbo+H9vGAj9MRWZmcbXqZt1BV3aH4lTXKxOy+867xJgu+G+iUIzZPE1kN0v8azy7K5bd8ak9bhbr6pbX3liWeRj742ioBoqZxZF/wRfbK7LbTf25b9cJPfaj0P9eY6vrsvvCi352MOvIbmVCfHbqj20zs1a63c1eW3hFdkcjf+yPT4zLbrev57e9B4+4WVptyW479G+eP//Yn8ruP3zq027WbOp5dWx0zM3iqn5uTkz4n33k8H7ZrYp7xQI9ZgPz8yjQY2crW76g1yKdjZ6bze47KLu1MX986qth1u203awS6nbe87vp2oLsRuqbJf65MDNL26mbdddXZbc69Ofb0Za+Z6oV/z5fXtLHnZ6ekvnJV6+4Wbdgadaq+/fNWntNdmcnGm6WVvz5xcxsadW//jtn/bW1mVkt9+fy159/Qnbndky72cLly7K7f89ON9tYuyq7W93515dknu+ddLNXF/V5vW/msJv9y9dfld0/+JM73OzSFb2Gn1j054pBpBe1zV3+WDj58uuya+Jd6tjcLtncEMvJw3P+Gt3MrDHuP7fPXdDf+cKqXotWV/w5rNoald2VoXhvGfXPlZlZMPSvYTbUz6Bh3++miX6X6mf+xNpv6/VzIubkULwPmJlFVX++bs7qNd9WVqvo8xKItWNYsK5U6071uWZmgfk3ZBjqNalazwah/r3DxF/HVAtWboH46GZTP7fTzN+PyTP/O5mZ5bl/rvKijY+CS5gdOuZmM488KrsHd+9ws05H74tlmb81moo5wswsGPHXT7VI7xus3vTn4+Pz/ueamZ274H+vz35ZPwfe8cAJN9u46a9DNxN/eQ0AAAAAAAAAKB02rwEAAAAAAAAApcPmNQAAAAAAAACgdNi8BgAAAAAAAACUDpvXAAAAAAAAAIDSYfMaAAAAAAAAAFA6bF4DAAAAAAAAAEqnslkHvr5+U+Yr62tu9vhTl2V3ZmrEzW4stmX30krLzfZXR2U3qPj/F1CvBQXdqpslg77sVs3vjjf0d06SzM3ySkd2a3HDzeqBn5mZDWxd5nFe979XkMtuv+9/78D/uWZmNjLif+9qqH9T0O+5WRRGslsRt2Ie+J9rZjaMYv87BYnstmpjbtYfdGV3q1vcWJF5HvvjbNDX5zWK/Ovd6evzWo39eSTv6TGYtGtuNj+7T3ZH2/4YfPmpJdmttXa52YP33im7d99+u5u9efqU7D7x/Itutu/YHbLb3n6bzPdu3+9mp944J7uzc3vc7N//4wuyW636c18l1o/sMPLzuKD79vvvcrMdsztkN8/18+2Xpqf6LS1e1+uYhdevu1lvVd+PYy1/HVMNUtnNOv7zZqWt121VMQxurS7IbmJ+eXzMf06Zmb3w4stulmd6EL374fvc7OXXLspu0vXXGnmuj3vuor7+ozNzbjbS0PdbZ33DzWYm9DOkXvWfP2mi122t3D9u74pee9fq/vwUrS7L7uLqDTcb3tTdC1cuuNmGuBfeCupNPUZ7N8T4flM/Tx5/8Tk3G6/r+/nyZf+8P/irH5bdf37u+252V/+q7B6cmvGzo4dk9+xzr7nZyYJ7PQ/99eSpl07LbpT5739ztx+W3UPHT8j81oI/Z3dNr4HPLPnPqF6q7yu1nOhvDGR30PXX15W6v7YyM0t7/mcPOvr3qsVKOtB/J5j3/B/cr+v38K0sFu9JZmYW+uclCAr2VFQuPtfMLBRrkbDouKKrIjOzMPTHSdFxVS4+1szM4kC8cyb6fjOxzskL9luKlvdZ6h97pDktu2EgxlbBHtLKhr9maGV6T60W++/gofg9ZmY3L/nz7Ss/uya78Yj/jnbikP8+YGZ2+rS/rt/dOy+7m4W/vAYAAAAAAAAAlA6b1wAAAAAAAACA0mHzGgAAAAAAAABQOmxeAwAAAAAAAABKh81rAAAAAAAAAEDpsHkNAAAAAAAAACidymYdeH0wlPmt1babNbbpz17sb7hZWtP79U+fPudmncFO2b33wH7/uElfdtM8cbN6fVR2ByLrJz3ZrcU1NxsLp2Q3Mf87J1Egu5np35TndTcbpqnsBuYfOwhz2Y2q/vnI0kh2a7F/O4UV3c0zf1x21/Q1HGv5N0RUiWV3eWPRzeLqpOxude1+V+Zhzx+jLdsuuzvG97nZRGuH7ObBiJv1qnrsTx+ccbOl5VXZ3Tvhf3bPTsruwpI/537vyadk92vPLbvZ/COfkN3B0g/cbO2LX5Tdd91+QebR2mU3233wsOyutTtu9sKLL8putebPfTUxP5mZhZE/j0y39Jx74sRtbrbWXpfdWtWfZ8JQP3OHQzWm9XNkK3vt7EWZz0xPu1mS+OPLzOzyuRU3m5/X65jBwF9RTDX1+Bv2/GdVlupn73JHdEP9/Fxe8cdnfaQhuz940r8f9801ZTcQP6nouEGkn83qtlkT62Mzs/FRfy0yUtX3Y9L3r8P1Kzdl99rl62527Mhe2X38qVNulqeZ7B4+stvNLq3pd42VVf9eykyP2a3uweO/KvNz/+k/A194+lXZPXDbnJstLfnrTjOztW7Lzf7yj94nu5946VNuNnFQz33t02+42eSMv7YyMxud8z/7wXHdrTXH3awn5lQzs5Ux/17PJvUcc+uaf33NzG70/PHfu++Dsrs9W3Kz8898VXaHG2t+KNY4ZmYVsX7KE/W2bDbc8N/Tay39LMjEHDVc89fHZmYW+Gug7i09129lYcE+QRD6eSgyM7MgEN2g6O82/W4kPve/D+xGeaafY4EY22HBcQOxYCg4VXKVnRbst+RijyEU7wVmev1kZpbn/vlaXfLXGmZm07H/DBn09fVvVv1stOHPL2ZmS2v++2xYcP2vnL/mZhsdf7/NzKw54l+nmW163T7I/GfIqZMXZHez8JfXAAAAAAAAAIDSYfMaAAAAAAAAAFA6bF4DAAAAAAAAAEqHzWsAAAAAAAAAQOmweQ0AAAAAAAAAKB02rwEAAAAAAAAApcPmNQAAAAAAAACgdCqbduT6QMbz83NudnDfTtm92V53s7X1vuxWK7Gb5YM12b3UP+9mY/GI7Ga5//8IPdPfebQ+7mZhEunjJv5xk1B3R0dm3KwzWJbdoQ1l3husulm9os9lKv5Ppj1ckl0Lp9yokhdUg8DNBr0N3Q3971xpjMpuxzI3i/NUH9cabpYHmzc9/H/4jYOf0P8g8ueCarWmq5F/74ShP07MzHIxzk6ffV12BwN/LDTGmrJ7eMd2N+veuCm7X3jlu252z+Sk7F4/8pCbzUY3ZHd939vcbE9L37Dt01+Seee6f74Wx/Vvyi6+4mZvP35Qdk9dXHAzNU+YmTUbdTe7444jsvvG2VNu5o+qX+h2u252/Pa7Zbca+/eSuhe2uhsL+hm5uuyf0wNH9svu3r3TbrZv76zsdjb8cX9zyX8um5klw8TN0qF+5l8+f9XNutv02uvyJX9+ah24T3YnY/87X796S3brVX+e3zal5/lmSz9fO8srbrZzQj9/0tT/TSPiuWZm9tOzl92s2/c/18xssevfsD89fVF2N/r+WiUO9URw5bL/nGiv63EXRf6cKpZ0bwmPPfa0zNX9PDfqr//NzBaWLrlZ65he0z78rj92s8WC95K5nf73Gob6SXax0/O7q3oNf37Dfy/5+Zp/L5uZ7ev580x4Uz8nmsf953qvrdcLVzf8Z4yZ2Y2hf67Xfv4T2b3vwx9zs2pPn49T3/uqm/U29N6BXCPl+voHopsn+l0qyPzvFbf0eE97frdSf+u+h4mp18zMgsifgKOCtXAYiHm9YByYeEcreiSIw1pQ8EAJ5bNId1Ue2C+/kM4z/fxUVyH4P67f06F/X6z29ff6wt/+lZsdfei3ZXdw/jk3m7/7YdltHLrHzaam/P0lM7MfPPtzN3vwwftl99lT/pz6rR/qc/XRDxx1s3/89Auyu1n4y2sAAAAAAAAAQOmweQ0AAAAAAAAAKB02rwEAAAAAAAAApcPmNQAAAAAAAACgdNi8BgAAAAAAAACUDpvXAAAAAAAAAIDSqWzWgVtZS+aVoOZmYcGW+55tfjcbz2Q3Dv2uhYHs1uIxN8tT/aU7yZKbNeKq7ObB0M3iUX2JK4n/e1P/Y83MrN275YdBLrut0brMN2zFzdIwkd1q4P/mHcFe2e0OVt0sjCPZtdwfW0mmv3OY+d+5VvfHlZnZYOh/dlZwi4dR6mZRpeD3bnH1hp6DwkDc7yozs1zF+tawQHz2/L452T1z9nU3a4w0ZDcK/bEy+uYV2X10ZsrNpqd3yO57pv3vPD+v54mvPPEdN7vz3GXZfW5hUebnbj7jZtfeWJDdd925x83+7i8+JLtPvXLRzb72w5/J7uGj/vx224nDsjvamnGzQb8vu6+cOeNm58/5mZnZ8WN3uVmSF9wsW9hIrWBuDvy5+c3Xz8luLO71xYXrslsf8dcES7f856OZWaXir1WuXbkpu73ewM1mJ0dl98TxnW622vfXEmZmkflzTLerx30c++f51pI+7qDfk3klFmvgyV2ym2T+2Clai6ap300T/xqZmQVijXyzYOyM1vyxEwZ63T5MxDom0r83M/87V/RjfssL1vUaKOuvuVnY0GPh+tV1N/v4fR+Q3d7UA252ckm/mBz7leNuduul52S3O/TvyTeuXZXdyZZ/T16fOCi70we2uVn6zW/JbqfXcbM3Vv1rYGaWF7xMTzZiN7v02inZrY/5c+OOe98nuy889iU3Cwvew+tNf97cuNWV3eHAn2fCjh532dDP01wfV79riT2JLS4umGDVtVbPGjO9XROYfrdVnx3Il7uC4xY8i+RxC55FQeB/dlCwHyNfV1O9d6HeV3OxJ/K/kST++mt81wHZnWn6c9etH39FditivXHmya/J7u279rtZWDDe6xX/+fPtbzwvu3NH73Sz3XN6D+nL3/DfJ6q1EdndLPzlNQAAAAAAAACgdNi8BgAAAAAAAACUDpvXAAAAAAAAAIDSYfMaAAAAAAAAAFA6bF4DAAAAAAAAAEqHzWsAAAAAAAAAQOmweQ0AAAAAAAAAKJ3KZh24MdKUedr3s0Hald08Sd2sHozLbhb13KzoZAWD3P9ONpDdOG24WRQHshsG/nED012r+Cc6rtZkNe8P3axW93+Pmdkw98+zmVljZNLNBv7l/YXM/weDYENWx0anxHHXZTcYVt3MT36hO2j7xw30eF9rr7hZpeA+i8W5rAQjsrv1Ffzfnbp1Qn1fBYH/2WGkjxsE/me34pbstqa2+8fNEtlNu/743lhekt2jFX+E7/zNR2R3YeGGm33jmR/J7sTMrJst7t4ju+nZMzI/e/2qm/3ezlh29+7b5WaNMT2vPnLvYTe7tLQqu0fvusfN9uw5JLvXbvjXoRLr3zs5PuFm5y+9KruDof8cSdKiyX7r+vVfOyHzVKxjgqhgNZL7c8hGT69F1NQ2OeY/l83MLl1ddrPxcf0UjGN/Xiz6ueNj/mfPTuv5trPuz3vdTB84rvr3xVpbrxf6Xf1cr9f839So6d9046Y/Xy+v6u+VZ/4AGBsbk90o98fWtlZddquh/5uGiT9HmJlVKuI7R7JqYvlskbi+bwV7btfXs1XZ4WbzI9Oy+47uMTfLbui575vX/bVK1NDvDjMPPOpm4wsvy+6lm/5guHrDn9vMzNpr/npivHpRdl9a89fpSVMMUDPrLV13s8a4ft8daejrn6T+se94j17Xjc/tdrO4rd9LgtC/73oFa6C8J8aOmGPMzHri2ZiHeiKpiIdUJt5JzczE64LlqV63b2VV8cw3MwsD/5wHBe9g6mqpd6yivOi4oeoWvHPKr1X0ncULa1iwD6RmmCTR68VclAt2nwp/U5r4Y3+kqteTB//wk2524buf119LrHNXzjwru89+5m/cbMdd75XdsWzRzab37Jfd7mDNzfq9bbLb6fnz0/y8/469mfjLawAAAAAAAABA6bB5DQAAAAAAAAAoHTavAQAAAAAAAAClw+Y1AAAAAAAAAKB02LwGAAAAAAAAAJQOm9cAAAAAAAAAgNKpbNaBt8VTMs/igZsNk4bsDpLUzSpZTXY7/cDN4qbuViP/ewU2lN1GNXezLM9kN8/9/4MIIn2JayM73Szt3ZLdyoh/3DTzr5+ZWRzUZR6F/vceJGuyq/5PJu1vyGZa9bu1WH9ni/1rmAz9MWlm1ogn3SwI/TFpZtZIt7lZOvS/k5mZVWM3ykyPu60uFfeNmVklitwsKPhvP3XW84JLkot/kBfMBXM7Zt3s2pXLsvv66TNutnunnq/DlWU3Cz7/r7K76yO/72Z7jx6Q3a9/51k3e/rHz8vukXl/7jMze/jB+93sgaP+eTYzm54ec7NQ3HNmZp/57GNuFi+vy+61Kf83VeJR2c3VqA2qsjtM/XFZqejfm4njhgVz31bWDfwxYmaWdG+42ba5g7LbmNjhZmNpIrtR6E9uRWuRA3fKWArVpJoVPIsCMU5UZgXzbcFxQ/HZQaSP217S66uZ6e1uliV6PZmIPEn1WiTL/DwouP6p+Owo0A8+9Uhtr7dltyKHTsHvTfz7ISs4V1vd8c49Mn9bfY+bbVvQ6/Co7+ffDv31gpnZrUtLbjac0O9/cX2Xm9Xu/KDsNn/sr1XG1ruyu9jvu9m19orsRp1V/7jj47I7OeG/O4w2m7LbqOl32r75z/3dv/sR2a2N+N0oa8nuew885GbfXn1cdtWyPg/9Nb2ZftcqfBuq++cyLpg3B2sdNxubLXjv3MKqkX6RUs9XsUwxM/3sjip6HITiWRUWrQlMPPcL1rO5+r0FS2F1OoKiNZDIsqE/r5np9XuW6Wd+VNHfSz2b44LrX9+1z83u+uhfy646X8nwz2T3zOc+6Wb9iy/I7tjsXjeLLp6X3Ur3gpst1n5Ldh99aL+bPf35Z2R3s/CX1wAAAAAAAACA0mHzGgAAAAAAAABQOmxeAwAAAAAAAABKh81rAAAAAAAAAEDpsHkNAAAAAAAAACgdNq8BAAAAAAAAAKXD5jUAAAAAAAAAoHSCPM83+zsAAAAAAAAAAPA/8JfXAAAAAAAAAIDSYfMaAAAAAAAAAFA6bF4DAAAAAAAAAEqHzWsAAAAAAAAAQOmweQ0AAAAAAAAAKB02rwEAAAAAAAAApcPmNQAAAAAAAACgdNi8BgAAAAAAAACUDpvXAAAAAAAAAIDSYfMaAAAAAAAAAFA6bF4DAAAAAAAAAEqHzWsAAAAAAAAAQOmweQ0AAAAAAAAAKB02rwEAAAAAAAAApcPmNQAAAAAAAACgdNi8BgAAAAAAAACUDpvXAAAAAAAAAIDSYfMaAAAAAAAAAFA6bF4DAAAAAAAAAEqHzWsAAAAAAAAAQOmweQ0AAAAAAAAAKB02rwEAAAAAAAAApcPmNQAAAAAAAACgdNi8BgAAAAAAAACUDpvXAAAAAAAAAIDSYfMaAAAAAAAAAFA6bF4DAAAAAAAAAEqHzWsAAAAAAAAAQOmweQ0AAAAAAAAAKJ3/AuT43kSIK1eyAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 1800x1200 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aIdLttGtcLab"
      },
      "source": [
        "#use Image-GPT color palette and crop images\n",
        "x_norm = normalize_img(x) #normalize pixels values to -1 to +1\n",
        "samples = color_quantize_np(x_norm,clusters).reshape(x_norm.shape[:-1]) #map pixels to closest color cluster\n",
        "\n",
        "n_px_crop = 24\n",
        "primers = samples.reshape(-1,n_px*n_px)[:,:n_px_crop*n_px] # crop top n_px_crop rows. These will be the conditioning tokens"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N7Y3o-NFceXc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 324
        },
        "outputId": "d3549261-2c24-487b-ac6b-b3f9e964f8ed"
      },
      "source": [
        "#visualize samples and crops with Image-GPT color palette. Should look similar to original resized images\n",
        "samples_img = [np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [n_px, n_px, 3]).astype(np.uint8) for s in samples] # convert color clusters back to pixels\n",
        "primers_img = [np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [n_px_crop,n_px, 3]).astype(np.uint8) for s in primers] # convert color clusters back to pixels\n",
        "\n",
        "\n",
        "f, axes = plt.subplots(1,5,dpi=300)\n",
        "for img,ax in zip(samples_img,axes):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)\n",
        "\n",
        "f, axes2 = plt.subplots(1,5,dpi=300)\n",
        "for img,ax in zip(primers_img,axes2):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1800x1200 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1800x1200 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LyuxDHk9chxA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c8ac57f-c029-43c6-a0c2-8255b5762d0c"
      },
      "source": [
        "context = np.concatenate( (np.full( (5,1), vocab_size - 1 ),primers,), axis=1 )\n",
        "context = torch.tensor(context).cuda()\n",
        "output = model.generate(input_ids=context,max_length= n_px*n_px + 1,temperature=1.0,do_sample=True,top_k=40)"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vlk2Lr-2cl49",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 188
        },
        "outputId": "ba624634-b6c5-40e4-86a6-0eb44bf36c95"
      },
      "source": [
        "#visualize samples with Image-GPT color palette. \n",
        "\n",
        "samples = output[:,1:].cpu().detach().numpy()\n",
        "samples_img = [np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [n_px, n_px, 3]).astype(np.uint8) for s in samples] # convert color cluster tokens back to pixels\n",
        "f, axes = plt.subplots(1,5,dpi=300)\n",
        "\n",
        "for img,ax in zip(samples_img,axes):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)\n",
        "    "
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABa8AAAEsCAYAAADElk/1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAuIwAALiMBeKU/dgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzaeWyk+X3n92+xWCySdRdvNtnNvnumu6fnHmlGGt2WxocswZIlyLu2k4UTOwl2EwSLAEGANRaLbIBgsVl4bcBZxwvDa9nr9dqWIx+6rHtGmkOaq3ume/pgs8nmXffJYlXlDy2QZK3vp6TicPh0z/v176c/z/PUc/ye3/NrhrrdrgEAAAAAAAAAECQDB30AAAAAAAAAAAD851i8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4LF4DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgcPiNQAAAAAAAAAgcFi8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4LF4DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgcPiNQAAAAAAAAAgcFi8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4LF4DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgcPiNQAAAAAAAAAgcFi8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4gwe140//0lNdlZcidTdLtkbktlW3UWjKbsr8bTfTHdmdjQzLXBk71Hazhamk7I6Oz7jZpYuXZXenk9UHJoxni27WKidkd2pcn8uvf6vmZslD/vU1M8uMRtxsq6qPazxW9vc7PiG7SqKblnmusOlmxZb+P6b19bCbjSQb+sCEeknfz5/9zc+G+t54AESHhuQYNDjkn9dI2L/H9io64p/3kZG47LZ3/fHtxLw/TpiZxQf8y7kTT8nu8q11N8tk9L1fq/njyLmzD8juPefPudlOU4/1z333OzKPdVtu9sGPf0J23/+zf0/m/frn/+TXZf7lv/4PbjYc8e9nMzPLDLlRuKLHoHZcj+dKOu2PyZ/8xP8su//jr3z0jh2DfvGf/p4cfwAcrFxRj5mf/xd/744df8zMTtx/WM+BalE3G/YjMzNr3TvtZt1iXnbHY/77JJ6ZlN1Hj/vz9A9/+AOye31p182Ojx+T3ZeuXHSzzz39l7K7uLzlZqFURnaVXue5l07evz3Ww/qdP1arulmhorsT0wtuNnDoYB652Lj+Vq5u5dys13VQ17hX99LfvHrHjkFPfPyf6nWgdOytOpQ3Tbb/ZYI9GW/78/demtb/GHNQsil/zSyooqEpmcf3sF5zUP7lP/rYgYw//OU1AAAAAAAAACBwWLwGAAAAAAAAAAQOi9cAAAAAAAAAgMBh8RoAAAAAAAAAEDgsXgMAAAAAAAAAAofFawAAAAAAAABA4LB4DQAAAAAAAAAInMGD2vFAsiTzuUTEzdrdEdlt1cN9HZOZWbFQ98OC7m6L/wsYmxiS3Z2cfynWwz3+j2Fr3Y0WppKymmv3f66SmSk3K5l/TGZmi+ttmQ8ka/62V/Rvas/690eo4G/XzGy74J+P7ZWc7HbTo26WHNmWXfX/SKV6SzY7Ff9Zqlb0XlsZ//dGKuJZuAsMDvV/77fa+pookbA/tvVSr+sLmkmm+t52fP6Ymy1dviy77VbDzSanxmU3Fkq7WWl9UXY/f/ElN6tbR3Z/9uM/L3OlHUrIPLd8w83GJv1xs5ftjTX9D4b8Maixo8c+29jD8y42PTyp39cjqaybPfrg/f0eEQDsSTal56l3u62OeCf0eF2cKPhzpHI6I7sTM/48ZvPWddm9VfLfJ4VF/e3w3KUX3OzGtL4XJsRn2s2y7oZS+nwo3WLezTr5ruyGF/xzZWZmef+bJ7xR1t24f0KmHjqqu4L6vWb6XPbqqvNV6dFdLfU/Vsz2P22/o5XSsQPZ72xYz4UbWX8efVASbf3d0HyLjuOt9HZ//8LHX14DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgcPiNQAAAAAAAAAgcFi8BgAAAAAAAAAEzuBB7bhTSsp8uV53s/TIuuzW65G+jqmX4XRU5omdppttb+pt30533Gxu2D8XZmaziQk3W9/S/z8RyejjUq5fbrjZ5SU/MzMbicdlHin5t2az6p9nMzO77Ucb1aKsTsbSblaK6OswF/J/81JO/14lkm/33e2lXqn42f48RneFSLj/kzM9NSXzja1C39uu1msiTcluc2fH326rKrvjCT/bWHxVdiv+bntqiKFgLB6T3aGoHs8fu++U393YkN3Vb/xbN1saFifLzKamj7nZQEwfc2ww5GbVHud5OBL2w8yQ7DY2xNiY1zueedgfcy+++LTsvvuhwzIPslxRnO+Ayqb2710E4K01GNXvorSV3axQ8b9ZzMy21v2J+GyP+f/rq342FdLzmBtv+OU/znxVdm++6M9VJmOXZDc6ccLNHp6/X3aVlV095nbFd0cnuSa7G+L6mpkNZPz5xHiP+aTSLeb77u5l2/Hjx2W3/NK2m21cXZRd9TZPx/V3eFfMBTr5ruzih8v6yyLWsNG37kB+DIm2/jYE8AP85TUAAAAAAAAAIHBYvAYAAAAAAAAABA6L1wAAAAAAAACAwGHxGgAAAAAAAAAQOCxeAwAAAAAAAAACh8VrAAAAAAAAAEDgsHgNAAAAAAAAAAicwYPa8Ua10Hd3rUd1eqblZlMTc7JbjhTd7HarIbvLtY6b1co12R21kL9di8puZtQ/ISPhtOxubbTdbHwyLLupiP97zy9EZPeVxYrM66LesKbsDovj6qUUqbvZbGRYd1f8a2gZvd9Mc9fNrtX7/z+mkaS+7+CLhPU9rERH/HslX/LHmF4iQ+Ie66HV1Pu9fsXPtwv6Ptru64h+YCw96mYN/ajbaHzEz9Jx2W0WVmVeubzhh+s7sqtEepyt3E0//6XHz8nuv636J+z7L3xTdhst/12gRz6z4Un/OgzX9Ln63peec7PXn3lVdn/1H3xaHxjeVLminhNkU/49BCBYdpvlfdt2oSLm4df0/H9o2p/z7sb0/H6r6nfv20nK7vs/4r9PukX/HWdmFhv254vbRT33qrT8b7x6ZU12O4mqSLOym90pyfzSyiWR5mV3a9v/zeOWkt3wgn/c3aLebyffdbPKtWuyGxJTxvZkQnbDG/6zJJ8FM5uUKe4WifbUQR9CoNyJ88VoiGsYBPzlNQAAAAAAAAAgcFi8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4LF4DAAAAAAAAAAKHxWsAAAAAAAAAQOAMHtSOJ2NpmS+u5d1sNBHqe7/rm8v6H6gz0or0vd+9HHPuVkPmr4hsZqItu8lmxc1KA7u6mw672e3bLdk9KL3uOxOHPTBZl9Ujh/z7I1/T3WX/MthIUlalemlU5iPJmp/F4/3v+A4Qjyf67maSKZk/dGLSzUqlHdl99upNNxuK6DFoenbOzWotfQ9GRkfcbEw2zRpNPxvvcZrHx2bdbGv7tuxWyjk3i41nZHd2Ykbmc2dOudnl1Jrs7tb9c93eLcluuFZ1s9TNa7L71BPn3OzKa9+T3XZLv2eUdNR/vxVsSHZHI/57BG++bErPCYC3k1zx7Tv+FCodmcfD/ny5PanHkfBG2c0Go3pS0Ml33Wyrx99cfeqJT7tZIqYn03MJf85w+IyeBd24esvNmlX9PVTf8efh+6na0nP82Tl/DlSq62NOJItuVsuKD559FErpOWF70Z9PTvW479Yn+/+eUMc1YP5ayNtZduKgj+CHS7SnDvoQAuNOnWtGQ/41rI/532dmZiPbMTeLJ/v/xsL/H395DQAAAAAAAAAIHBavAQAAAAAAAACBw+I1AAAAAAAAACBwWLwGAAAAAAAAAAQOi9cAAAAAAAAAgMBh8RoAAAAAAAAAEDgsXgMAAAAAAAAAAmfwoHa8uJaX+Wgi1Pe266vRvrtFq4u02fd2a+WuzNXvPfvgrOwmm/4xl/Rh2XrL/xfxWkR287WWm1XKfvYDetvRgv//KslYWnaz0YSbFUZWZLdTSrrZ5hX9fz1XrSJzpTuQcbORZE1266XRvvcrt1vp//fcCX7x539O5l/66pfd7PRETHYfnEu52ZVyW3aHbt52s4mJMdk9fOaCm3Urm7KrlPP6ea0V/HvlyJQ+Vyfvf8jNbq2My+6tV19zs4986tdk91OfeErmmxsbbva++x6VXeXP/+rrMl9bfdbNHpwakt2/+svPu1m71ZDdRkvclxvqvWi2ldp1s0ExHpuZzc4edrPomH733c2yKT1OAG+1XDEsc3XP9uoigHb8uef0QI+xedqfqwwc6v/77uH5+2U+OzPlZsfnJmU3M+HP/5t1/Q4Mj/jz8Oy4/hIb3PC/l9qFsuwWUuI7bLPXN2tcpqW6/vZQjiycdbObG8uyWxv2v9M6ef0trUy1/XmKmVkt7c9Vrl7Tx7yX0W19w7/Gkyf09+7dLDtx0EfwdyXa/vhyN7ob56HRkL6G9bFq39tW3XiLOdCbhb+8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4LF4DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACJzBg9rxoXvGZZ5f3u5720Wr992tlbtuNpoI9b3dXt3JWNrNQoWa7K4Plt1sJDqij2s34Wbt7qjszkTH3Kyze0t2C9aQefakfz6OHRmW3a2Ntn9c15KyW4qIe8c/JDMzSxX8c91Md2R3qL7uH1NhSHZD1tQHJjQKfVfveAM7eoy5cHLOzX75I++T3XLdfyZjtZjsNpo7bpaZWpDdzOxhN8ttx2V3bjrlZrWtFdmdOXTSzV5+8UXZjSX9/WYrk7IbfWzKzZ5/4fuye2hKXwdlcCgq8wfOn3ez5Jgegy48cMrNVr6Q1wcmjMb1u8Ai/rjZ2NDv1Oa237Ux/1kwM3vggQfc7I2l52X3TpZNiXMG7EFxV8+vldTglpuFY5kebb+L4Bkf89+9Zmbhhey+7Dc2rrd7z4g/j/mpRx6V3fPz/ndJZlzPgTpD/v3dqLdkd2HS3/bV1/T339XqdTer6s8wy98quVmhFdZl0x8AyRF/54NV/V3a3fGP68I9+houNq662aq9ovdb9OdIS1f1PLZQ0d9p/UrH9d8J7td+gy47cTD7TbT97wa8earXvi3z2PEn9m3f0dDBXOOJnmPuW68V1e/bSDP3Fh3Jm4e/vAYAAAAAAAAABA6L1wAAAAAAAACAwGHxGgAAAAAAAAAQOCxeAwAAAAAAAAACh8VrAAAAAAAAAEDgsHgNAAAAAAAAAAgcFq8BAAAAAAAAAIEzeFA7Xnlt66B23bdaudt3dzQRkvlGtSCyvndrxyZqMh/INNysUi7L7vXSsJuNpEdlt/FGUeY3CqtutroZld1ka8TN1Hk2MxtO+9tW2zUza82F3WxmZEh2b7zRlLmijrlR0NvtDmTcbCSp75073beevSLzn3z8tJttFm/L7s2iP7TOnTghux/98Pv8/eY6shsOrbnZ7LSs2sI9E242N3xEdsvdupudjPnn0czspZr/bBTq+v7dyrfdbGwyIbvfefmazMdSKTd75P5Tsvvbv/N/udmjZ4/J7m9+x78OzaELsvs/vd//zeGLN2RX+cX8X+h/MJl2o+Hajqx+6et/5mZDE/p+B/B3pQb3Z369l+1mU/5YjWDqFvNu1sn3/z0U6+p382PvPeNm5+fHZDczHnezaGxGdust/3sok9THbObn0/P678TKbT+/tvFaj/1uu0lyVz9zAzH9LdWpivlXVHdjHb+bHPbPs5nZhUMPutnq6iuyqwxG9TVMm/7m7Vehoucx6bh//XfWSm/24QBvmvWlJTfL3b4lu0eG9LM8On/ezTpinDcza26tu1m1qJ+pkbFZN5to+es8vcyPZWV+vdL3pvekFfWPK9LMvYVH8qPjL68BAAAAAAAAAIHD4jUAAAAAAAAAIHBYvAYAAAAAAAAABA6L1wAAAAAAAACAwGHxGgAAAAAAAAAQOCxeAwAAAAAAAAACZ/CgdjyaCMm8tlH2w5H4m3w0P5qex1zu9pWZmVm90s8h/YA4H9u2o6uDrb53W2je9rPNvjdrZr3OV1N2h7sZN+uG/ew/7blH3p9CXV+H7kCv4/I1Cvm+tzuS9H9vo6DP853u8Xe9U+Y/+5n3uFlhfVd2a0vX3eylS5dk94kH7nWzRxemZVcZMf8+MTO7ue0/tF/b+Irsnpj8gJulDk/I7pmcP/alwwuyu7m+4WZffPrbsrt1NSzzuZk5N7v61b+U3aVGw82itddl91DzvJvlduuyG87fcLPD8wnZXbrlv3Or9R7josh3x/R5rpT8cSbR0u9cAEB/bl2tynwi6f99UyWs57QT0wtuFh+Jye74WFLmSq3tfw91Wv572cysUfe/h2q5Yt/H1Esq7b/nTs2OyW6rWXKzUkV/361X9Tw2mfbPZToe1ce145/rE5Mp2Z2aEt9w9zwlu3/113/gZrtNsa5gZoVKx83Gx/Qx99p2v/tFfxLtqYM+hDdVNtWWea7oz7N7dfcit3nRzZob+ptzsfyizO+d97+FBrb0mtn3XvfHkFZRv/ceOS7jvs2P6bXL65U9rAO+zfCX1wAAAAAAAACAwGHxGgAAAAAAAAAQOCxeAwAAAAAAAAACh8VrAAAAAAAAAEDgsHgNAAAAAAAAAAgcFq8BAAAAAAAAAIHD4jUAAAAAAAAAIHAGD2rHtXL3YHZcr8h4pyLW8+sdve2ReB8H9CPotV3xm1Z7bHrUQm42nI7KbqPQdLNe13c04e/3R8mVkxMRN3tjU3cLhbwfpnvsWN9a0kjSz5KtkR5t/8BKkVp/B/Q2UIy/JvPf//JVNxsJ65shkvHvwUMP+ZmZ2aI97Wa5WkJ29yIZn3Cz0c49slsJ+Q9WZafHjsXwNrobk9VuveFmJ4b0c3M6My3zcuuWm33iV35Zdt/4+vfdbHi6KruJmv+bwxf97ZqZdc6Id5Terb1UecXf76B+F9TFO2iotiu7oVF/2+X6Ac0T8EN1xvVcZGCr/5eg2nav7e5X906lfvNefu9eri+CZySjx2YT85y4jfa937NTszJPRMJuVuzxGVa76b+3exke8ufLpbVl2a2W6262urIou5WWP0lqtnqc5wF/njPU9Y/JzCzW0SczNuQvEWR6HNbskaNudvSQ/r47fsrvTk7redt2xf/q/e43/1Z2x/U0RypUetyY+LEl2lMHfQhvqWyqfSDdPakV+65WB/3vt17+9LL+NgjN+Wt575kRCy49bEb0eZ5o+e+ur9+88+ZPrWj2oA/hh+IvrwEAAAAAAAAAgcPiNQAAAAAAAAAgcFi8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4LF4DAAAAAAAAAAJn8MD2XK/ofCTuRg9fOCurcfO7m+vLsru+3XSzrdKi7LYLXTcLp0Oyq35vT3vpCo2Cfy7MzIbTUTerlRuyWyv756qX0YQ+l09kZ9xsppiT3T/KqePS50PJzI3pvLnrZvl4uO9uqaWPS11jdX3vBq9f3ui7mx3W91E445/XseS47GZGI26WTOt7QRrM9vgH+jcpyYh/zN1crO/thrJVmbeS/g1++vSC7D42c6HH3h9zk4FGXjazZ865WWF2WHY3lsQ1ntTXcHLDv4Y3krJq0Xvn3ewDZ/Q7JlSo6Y0LO9Wym11ZLPa93btZZ3x/3vl7tV/HtZftBvVc7acgXgfcXYbTeg4/M932u4N6HrPb9N8JN676mZlZvubPhweb+j11eMrP5o7578deYokRmW/e2nKzYnVTdneL/m/KdfS3UjRW13nbv04LM9Oy+64n3ulmo9mU7A7s+POrcwv+952Z2YX7H3azpaVrsrt686bMlfZkou/uWM2f5w5G+99u0CXa4oF7G8oV/ectHMvIbmrQH0N6Ke7636R72W4rsbclxu9+138uTj90v+w2r/rHvWj6Y+i0+ePAyPFZ2cVbg7+8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4LF4DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgTN40AfgmY3PuNlEJyy7Vy4972bxVFx2z5+ecLPF22dlV8nlt2WezYy5WXNnR3aHp0fcbG39huxGKrG+jsnM7Oori24WTodkt13oyrxXX5mMif+TOZqV3dFW//s9nrnHzaqthuzmoyU3+9DUw7L7XOllN7t/ZkF2S8stNzt1NCq7b2e5Rl3/g1U/2tjdktX5csrN4rWI7I7Oj7uZP7L9J7u5Xv/CVdoU4aB+5rLhppvtmh6vVbc4qv9vdrP0hswTC/749+zrVdmdy/jj6rf/+orsrmz477fjp07K7oMPXHCzx97xLtndftG/7+af+wvZLY743VLdH2PMzIYz/th4LOVv907XGdf3Nt4cEy09X1Q2I+038UiAO8vZTyb77nbXhtyssaufq2vreTdbuy0mV2Y2POg/74Xb+p3fOXTKzdIR/W0Qn59zszPn/G8DM7MjY/6ccO2mP5cwM9tM3HazbKEju6HkUZkrp0/qGeX8iSk3a5X0HLgiPnnzpbLs5orX/O3m9XfnXoQ39HEpBZGN8xn2thGOZQ5kv6lB/Tzum5BeY7p99rCb/e8P63Hx34jsSkN/654Wr6de88lWVH/v4s3BX14DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgcPiNQAAAAAAAAAgcFi8BgAAAAAAAAAEzuBB7fhI4pDMT49n3Ky1kpfdR07e62bVdkl2n3vllpul4nqtPzYw5mZnzh2T3fXFnJtlh/Rleu7ahpsdio/L7rlH7nOziPm/x8wsl992s2K3IrvhdEjmyiHTv2ngdf86NYc3ZffM5AN9HZOZ2e2rF90skUzKbjYz6WYv3/Kvr5nZBx/9sJut335DdocGO2722udekV37NR0H3dysP8aYmTW7RTeLhlKyG09E+jqmvard2nKz0ujBHFMy7Y9tZma5XRFuVvve7+zYiP4H+rDs4vKim6ViE7L70BP3u9lXX/C3+wNtN7n87Vdls3XpJTfLtb7QY7++sWOjOhfZYEldYN3OtaM9ungrTbTCfXc3I/59HVT7+Xv3sm3gzTB5Ir1v224Umm7WHt2R3cXLl91st6a7+R1/DvTwhZOy+64HzrtZ5qj+hlMaDf3dOTLjf9NMJ/xvAzOz6bL+PtiL7Yb/7Xn42OG+t7u4fFPmlVvLbhY99pDu5v05YzXsf9/v1fiY/iZQdpvlN/FIsJ+yKf1ezxX993o4pr8596K4648hqUF/TDQz64zH3WxgS6/l7EnXX0MyMzuy7K9P/ONv6Wc5uXbOzU4tyKrNiXGiFc3qMt4S/OU1AAAAAAAAACBwWLwGAAAAAAAAAAQOi9cAAAAAAAAAgMBh8RoAAAAAAAAAEDgsXgMAAAAAAAAAAofFawAAAAAAAABA4LB4DQAAAAAAAAAInMGD2vFGflvmA8urbvZU5F7Z/fe3l92ska/I7s+M1txs7NiHZPcLLz/jZt1KUXaLNuZm+dVLsvv4+JybzTzxpOze8+jjfjg8L7vxbNvN/vbFv5Xdoc6kzKPDYTc7MT0ju2tt/xpHxXk2MztV9a9/KxGV3fGjx93s8vKK7Jpt+sd05ohs3j8jjuvU+2X3+ZeuuNnujVuye6eLJyIyjwyp/9sry26zj+P5UUx1/OfCzCw0NL5Pe94/pYI/jiTT+vfONvzfG87r5/XX/+arMv/J06fd7PDRhOx+7Q++4mb/8VvPye4//4e/4mbvfdeC7P7OH111sxe/+SXZHT+VkXn/9HXIhsXTspt7k4/l7WGipZ+bgxDEY9pPd+PvLa9el3nqUNLNOp077910t+vkuzK/8XzJzd75wCnZvVi+7Wbh4SHZ3Vh+XebKuXvPutm7nvxJ2W2NTrnZv35an6tQeN3Nbt7Q37vKkaP6uRlN3uNm0bKeiU7H9ffwo4fF8zyUkt2amCJXbvnf6GZmzz/zrJudHhqV3WtvLLlZKKXnOGHxk7rFvOyOxzputrEckt3BqD+fTCQPyy7eWsVd/TyGY2/RgfxnUoNbbtYZj+/bfrvllpvFbHhP235y4Mtu9sXlD8rux37CPx//6pL+rmguH3KzB0M3ZDc5eVTmeHPwl9cAAAAAAAAAgMBh8RoAAAAAAAAAEDgsXgMAAAAAAAAAAofFawAAAAAAAABA4LB4DQAAAAAAAAAIHBavAQAAAAAAAACBM3jQB9CPP95+VuYb4Qk3OxGqy+6V9Yqbva+9LLvT9ZofqszMCp11N8uU/GMyM2vdG3Oz4eljsvvP/rffcLMzx2dl98jJ82725GM/LbtXnv0bmS+MTrvZRz/zc7J7+7kX3OxkIyy7f/SnX3Sz7up3ZVcZ63ENR9NjbjYxvSO7n/2T6262nR+V3Wwk5GaLNzdk906XGY30+BdTfW87mdb3Wb/y4UKPf1Hue9vh7YSb7dfv2eu2w/mom928cU12U8NDfe/3pcWXZP7qmn+dMpm07E5u3RDpguz+V//1O93sU7/wJdkdP5Zzs2zUf8f0kmtW9T8I+9vey36DbqK1f89UEMWzvcbb4KnkWn13y6v+e9nMLDGj52ZBPF+hfEPmL377VTdLR/Xnxomx4262e9SfH5mZjaZnZI7+hFIZN1v+fmnf9jsc9d/NjaaeDx+bn3SzVNd/x5mZfW3Rz0Lhruwe2vHnXidPxmX38dP+XHPtSo/3Z/FlN7qy5s+PzMzWylsy/9zmCTd73+Ft2R1K+d/ahZY+l82K/720sqSPuVL3z1eiqMfzUkh/pymJe/x53cR8VnZf+pp/DW/ceKXvY8IPF47545qZWWrQv8eKu2/20fxoEtP63dsxPcYE0cm6XmP42F/630NNpQwAACAASURBVFn3H9fdf3XiH/Z1TGZm733Sf5ZX37gpu0n/9YM3EX95DQAAAAAAAAAIHBavAQAAAAAAAACBw+I1AAAAAAAAACBwWLwGAAAAAAAAAAQOi9cAAAAAAAAAgMBh8RoAAAAAAAAAEDgsXgMAAAAAAAAAAmfwoHYcmo3IPHw75oeliuwm60Nix3XZVVYqIZnPPXm/m12+vCi7g/FhP3zhouwu3txwsy/87u/IbiLsX4fnvr8su8t5/zqcHd6V3Vw7K/NXvvq6mx2L/Z7sZs+cc7Pf+Opfy+6xjJ/lLuv77tahMTfL9Lhny2NdmSu7K/71t9dysnstGXezC4VGv4f0tlcqtPdlu2FL7Mt2e+n1e5LpcN/bzkb9sf5Q7ZjsLtVvulmppY8pken//25H46Myr+1U3exQSnfjc/4zOZCa0AcmHF3QY+7zX1t1s4ff2/due8o1/XN1N4tn9RzobpNu9D8mhkbyMl/Jt9zs+OS07NZLHT/cwzVa+p4/hzEzu3XxWZmfOT7rZmMnHpPdVsofQ/ZibmJG521/Hrt8Y1F2j47485iXv/6c7HaH/XMV+/CHZfftbGu7KPN22H822m39/vz0B/zzXsjr53kk6n/DHV3Q78BDWf/9Wqzo75K1lXU3u7mtf+/osH//hrtpvd9b/nfp8WSvd/5hvzuumwPL+nx8rnLZzTa29bajN/3ftFMvy25BfA4tiM97M7N60f/mKYX0d9jCnH/CGoWm7HbX/APLF/TJGoz68/rxqKwCByrU9Z/lEw293vbRuj9vMzO7+al/4GaxDz0iu79Q98e2f/FFf43IzOyZ4dtutpPbkV09Q8Kbhb+8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4LF4DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACJzBg9px4XpV5qcn4262Wjkku5OhYl/HZGa2JLKpjW3ZfeDoSTfLHZmX3cePTbjZS9fWZLckso+842G93wfucbNXr7whu995bUXmSv7GJZmfLqtz/aDsrq1suVlhaEh233vmnJtd3ND37NKI+L+gFX3vVIaibva5tZbsnoil3OzUO/zra2b2pdv+uVoqXZbdO10yHd63bZcK7b67+3lcSjYac7NcU9/76vcuTCVld7Jzwc2KDb3f4k7IzQYu6P+bvcf858bMbGTN7zcsIbvdtN/N7jZlN5LOylxphcbd7D1D/rkyM/v15zfdbGRGX8PIWFkfWJ+mOgfzLLwV0o3+x4jC8MGcl17HXCv5c5WRudm+99vQr0B79YtfdrPrUf/damb27nv88Wfm3Cm9YyF5j56nNpb1+GO7fpT49udlde6+e91sKTktu92hMT/c0c95Nb/qZpm0vg7L1xfd7FRkRHZvjB/Yp8wdbfJEuu/udFy/A9NV/16JhGuyu9TccbP7z/vPq5lZKum/Aw/N6Xfre63rZi9uF2T3Ws4fky9e8+fZZmaFo/7vtdm67J5s+Pu9ntPnuZeKGDvTEXHMZmaZUTcq1/ufL8QSeix4+MJZN/vqzSuyu7jsX6dO3r83zMwGKv78qlcXP75wLLNv2y7u+mNIalA/y6qbmG70fUxBFY34ayoX1vKyG/uFp2ReefRJN5sS456Z2fwXPudnw+uy+182Pu1msxt6/LkTRZo5N4tnI2/hkfzo+MtrAAAAAAAAAEDgsHgNAAAAAAAAAAgcFq8BAAAAAAAAAIHD4jUAAAAAAAAAIHBYvAYAAAAAAAAABA6L1wAAAAAAAACAwGHxGgAAAAAAAAAQOIMHfQCe+KkTbjZaeV52MysVN8sn47J7WGSp6rrsFgaibnbhwQdkN5YY8buffr/sDr943c0azV3ZjY7G3Oyh+++X3RtL/vlYLDdl9/j5czJfL7/gZoWQf33NzHLdbTc7M9aS3crK19zsgcfOyO6RmTE3e3VF3zvdzqibXSuXZffMOf9Zsduyau996h1u9r0/XNHlO1yp0D7oQ/ih9nJc3Z0tNyvspmT3pjXcLDMakd2z2fvcbL6r91u+6T+vS6U12b0y/pqbTe2EZTc0NC7zzUrNzeLNYdk9fPGSm8UePiq7ifEJN4sk9TFX/+ibbvbuCTFOmJnZS25Sy/n3hpnZ6akpN1vb1WNfdCfrh4NF2b2ThUbyMu/WM26WbvQ/RvTar1It6fd6o+k/M//xz/5Udh887N9DMzMzsvv++4/LXBko+WPIq//hadmduuDPkaYGu7KbSHX0gQmx3UMyr9/0n5vKuWOy2xr2x81I079GZmatx/q/DkNFf163WVqV3bGkf3/oGd/bWyev79GBTMjNPvaP7pXdkW/730Pb1/ScNp3y5wzxmB4LzPxvnlokLZunzvrznP++x14vXvfH1afb+v350g1/PrHc4xtubCzpZrExPV8IjejzkUr42b0nCrK7spyTuTL8xpKbbVx8XXbr6/5xdYv9v/t62bjq73d8TM+B02n/RE8+qcf6O1k45s9xgqozrteQEuI76m7U2PXH+S8c8scmM7N7Tjwm88hfftbNOn/yBX1cItOzGLNP//2PuNnh9+tl08udTTdLD/jfdgepFfW/wfLVt/BAfgz85TUAAAAAAAAAIHBYvAYAAAAAAAAABA6L1wAAAAAAAACAwGHxGgAAAAAAAAAQOCxeAwAAAAAAAAACh8VrAAAAAAAAAEDgsHgNAAAAAAAAAAicwYPa8anzh2R+fGbKzZKHY3rjKn9mSVZfyiTdrH10XHbPrq/5Yfem7MbOnnGziXm939sV/zLefO1l2V2/d8HN0smE7Dar62724EOPyO7xqYzMv/6dV93syvWS7E6/c9rNJiNZ2a3dLPrh1JDe79iImyV+9Wdk98t/9k03G6xGZHdjq+5m73zve2Q3MuHfW8V7T8vu3a49VnazzfWa7E5MjbrZwGpTdtcH2vrAhCkL991VnkjcL/PEoD9WlOv+eTQzu9TddrNi9oo+sH1Ub+642fTTl2U3J/5b+Cc/pJ/JeNp/B7VKW7LbXfTfb5FPfkJ233PFH3OTh/T7enX3qzJXmkM5N/PfMHe+fFe/1214n3bcY7+1wqqbLb78vOxOxfy5yE+cnJHd6oa/30JR3wnZYX/cG477z5OZmYn8vtO6++rV19ws9MhHZbc1F5d5pFhxs+K0HlOTBX8uGpJNs0qu5WYDA3q/o6Z/k9JK+d1ae0F2a+qVKX7P293cO/W7qPLa99zsfI93wlca/vP80z/xftl9/plnZa5sr/vX+43X/2/ZfeUN//1ZWNfvXuX07DGZjx3zv0tG0/r+rRUW3Wz7Df/damZWjOjRIHtkzs1ej07I7k7TnxOm5/3tmpmdPHLVzQ4vnJDd33r+T9ysU+jKbnhBfB/m9blUBjI9Rl1xWJFN/b1wNxusXnez3Zh+pvYiMd3Yt23fbaqD/rlKdHS3+Ft/IfNI6aV+DsnMzIZ/+hfdbP1T75Xdp7r+XOR3v7Yiu1G77Wbpk3rMxI+Ov7wGAAAAAAAAAAQOi9cAAAAAAAAAgMBh8RoAAAAAAAAAEDgsXgMAAAAAAAAAAofFawAAAAAAAABA4LB4DQAAAAAAAAAInMGD2vF/+1MPy3y1EXez0dRDstssNd1s+r5zsht74TU3u+/++2W3W9pys870EdkNx2Ju1q5WZTc24WfnE1Oym04m3Gy3WZbd02czbrazc1V2zR6R6YVPv9/Ntl+8LbvxUNTNwslZ2a0M5dwsK5tmpd2QmyUTI7I7fe6om+U3b/XYsy9+RN931fyamz363nf3vd+7wcCqP45MWVh2OyILDY3L7sSYfu4kccwfOHFcVj+4cMbNtsr6VfHSlctu9kLzmux2I/64uZ+6O3q/6bP+dcqd9MdrM7MHXvEH5dNnj8nuQMrvvvLvXpDdL373WTd78HH93rzvtD9WXK5fkt2JqVE3y7TTsvt2Vcm1DvoQfqgB8ScNHzqj359K7GZD5tsl/3yUx6Zld2nbH/csMya7obFJNxsuV2Q3dXrezYpdPY53cv485QdUrruFpHjHtHvsdg+Cek/jh1tdfUX/g3TEjb74m9dl9fWb/jz9v/vM35fder7mZq9u6bnIRx6ZcbPBy0XZ3b3l58mpw7K7unbDzbY2CrI7Ntvr68L3wmv+u/k7z+i518iY/942M5u9dNHNVi7Pye6jH3qPmw3U/G9HM7PhIf+71GbulV0lnRbbNbNDMymxX5GZ2cpr/nxyNO5/G5qZPf6+D7lZJinebXe41KCegxdjeq6sJKb1fAM/mmqxJPN4y3/nxzb89RQzM9NTMyk67c+9zMxyv/wJN8tv6DWkM3/1eTf7he/+lez+3sNP+eHJC7K7XyJNfR02I/6kMD0gFhgPEH95DQAAAAAAAAAIHBavAQAAAAAAAACBw+I1AAAAAAAAACBwWLwGAAAAAAAAAAQOi9cAAAAAAAAAgMBh8RoAAAAAAAAAEDgsXgMAAAAAAAAAAmfwoHY8fXhM5o31ITdbKaZ6bH3DTbKZSdn8yQ/5eezwhOzOJc672beurcluOHrI3+5wXu/32Lyb1QpzsvvslYtuNpnOyO7Hnzznd+Mjer/X2jI/ecw/19NnjsjuwtSOzJVsyP9Nva5/sdnte79PffABN/tM+t6+t7tSi8s8lpl2s6rpe/ZO193Z6rsbGhrv8S/KbtIe8zMzs0LFH9/yKxHZzVb98WtyTj83X3nhmpu90PQzs72dy72Y6oTdbH1AjzG9RKL+/+3W1kdl9+HHj7lZ8shx2e0UN91s9xtfkN37drfdbHAoKruPf/Izbjby6p/J7nLheZkr2WjMzTbG6n1vN+gGBvp/ZjqdXuPP/mi8rMcBmxz2u8VG3/vNj+u5SHvCzwfSM7IbMv861GILsruXaxjP6rF8Lyq51r7st1bQ+X79JvV7cDBmH/XfvWZmD/7cg31v++g7/O73v3JddoeHZ93s3DufkN1U0h9Xt9f1PdhqJNxsOV+V3aNn/G9HK+p34Cfe/1E3e/c7V2W3m9PP61DWfzfPLej5ZG3d/w7fWvPnOGZmjz71M272/NJN2T10j38Nd/L6u3R+/LCblas3ZLc+77/7ZiaysrtS9a9TZUB//9/Jirv9z2MS0/3PJ95u0gN67UKp222Zd0P+uHfY9HOe+m/8scvMrPTsgpsttZdlN1zz74/IP/lfZLex6c/r/JW6HxhffMEPn/xYj3b/Is2cm116bl2Xh/2xOv3we/o9pH3FX14DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgcPiNQAAAAAAAAAgcFi8BgAAAAAAAAAEzuBBH4AnX6y52WhqVHYb4aibJafHZTcWDbnZs1eWZXcjtetm4UZMdkfjETcrV+qyOznq/6Zs2z8mM7O5h+5xs2p4S3aValH/3pEe/cOzSTfLhXvdtms9ct/msH9vNXMV2Q3H/N+c2PHvZzOzzNT+PIrl9asyH4wm3Cwzqq/hna6wm5J5cr4h0vKbezD/H/m1n3azpWf+nezeaC25WfbIrb6PKZkO9/gXU31v2waz/Xd3c240P6GPqZvT9/dn//x7bjbd9d8xZmbv+vS7ZK7U/sDf79CNFdl9R8YfN223K7vVmN+9ceuy7Eb8YaSnXLPqZoO3+9/u3WxgoP93cyqkL1ZR3Cblh98tu53ahr9fuym7SmYrL/P18kW/e0iPA+st/3y0qm/I7pHjx92sMKT/NqRWWJX5aHpG5oq6PyJFff1bqXjf+90vmXDzoA/hbenj95xxs27O/2YxM7uS9wfvIwv+82pmdu+5+90sbq/JbqNR8rujY7I7f/a0m2WOtmQ3f8M/H5Fh3T0emfBD/clqhbA/jozZYdndHtHHlav7357Xv3dJdofK/ndY9rFHZHfi+BNutvKt78qu0o5syvzWlv976xX9/TcS98fNemlYdpt1/xqu99jvnSwxrb6x8ONID4gx5IC8fvqczN8xor+j0g/Mulnx+3rf3Yr/bRj/F78lu5GL/vvp6qJeB5yc9r+jdmTTLNL0j7kV1d/J17f998/h00dk99Zr+vsuiPjLawAAAAAAAABA4LB4DQAAAAAAAAAIHBavAQAAAAAAAACBw+I1AAAAAAAAACBwWLwGAAAAAAAAAAQOi9cAAAAAAAAAgMBh8RoAAAAAAAAAEDiDB30AnnC95mblHd0dCPtZu1qV3bnxGTfLPDqhdyysNPR+v/TNr7rZ4fmo3vbOhpudm0zJ7mR8xM2qFVmVquEtmQ8kpnr0191s+XpLdo8fi7hZr+uwuHbDzUaH9TEfHz4kUv9+NjPbvrXrZmPz+jFVvynS1ecqX/KzXX3b3fGOzA7rf9DukQu7s/3/v+C9t/3nuTMfk91aJeFmcydnZbeU9++VZMZ/pvZqL/udrPrPXKp9RnbjsbTMO2f847pwdl52k0eOu1n5ZfHQmdnX/uTfu9mxsD9em5ktiQd66c9+X3Y/m/dfnNmTbdnNpAtuFt7270kzs5Gwfx2y6f7fuXezVEif0/1SGOoxrg1Nu1Eoc1JWQ82im3Vq/phoZjafGXKzVKchuyPD/rt3p96R3daV77jZ+PF7ZPfWoj/XMDNLD/hjfWNWzTXMLBF3o5ee+4qs3nfisH9Mo5OyWyisutluTs9FxsayMu/X9nbuQPZ7J/i1X/oJmSdyTTcbmz4tu7/9+3/hZvfO6uf5D3/3/3Czwcox2f3psv8usuyY7Cr5G9dlvnZzyc1SRy7IbnXCf9Zja/qbZbuxl894/Uwq9QFxns2snvPnKr2euBsvPeNmn//6s7JbEWP2RkjPY6zsv4N6mSpsu1l3QL9H4iP+9a/3eAfh7SE9cDBz4fCAXssJdctuVs77mZnZN76pn+Wfuvg1N+vM6213l/252VLrYdl9puB/dz76sz8vu5lLz7vZ5c6m7Kaj/V/jdjXvZkvrPda9SiE3O9H3Ee0v/vIaAAAAAAAAABA4LF4DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgcPiNQAAAAAAAAAgcAYP+gA8911IutnrN0Zkdyoz4WbFZrfvY+ol1h4XaVV2P/zAMTd7bWtFdkullpu1InnZ3ZDp/nn+8jdlPn9oys1WtnZk9/gx//ofGo7J7sefPCdz5QvPXnSzaK0ou2eOZUQ6JrvqN+WzUdktbZTd7PWb+p79GZne+ZIT/j04WKrI7m4r3vd+I52am70Y0/dCq9J0s+3r/nbNzMaOjeoD2yfJTMTNHhk4L7v3PnbKzQZS/jjwoxib8o8rFe//1fmP/9n/KvNky7+GfyAyM7OrbX9sDD/tvyfMzDKZtJsdnntEdh8a+bCbDd2j3otmQ9EhmePO0d0WM4rxhO5GU26209RjV2jqpJv1muMUu/47MDWlj7ldWnWz3bAeT+cXjuoDE+Kmn+XhnY6bPXpYj4s762KucnRSdtNiv6vrr8judn7YzcZOPCa7yvL178v8lWfW3Oz0+Qf63u+d4OwZfR9NR/zn6tXbm7I7Odt2s5VFPYf/wtP+XPqRc/oefP7VnJud3tLHnN/xj3nj+7dk93bInxOMb1+S3bMPzrjZtS19jXL1upsVC/rbcS+2b/vn+Qc7b7jRH//pNVm93vCfyV66Jf3Nu1/0EfvvGDOzjZD4/gv1czQ4KOmB/r87Ch09Pt1tXnrhazJ/4o033Gxgflp2a7FP+t2Q/34xM/up9/6qzJXt3GU3e7GxILsL54+42fqtLdmdEa+JJdk029rS6xlBxF9eAwAAAAAAAAACh8VrAAAAAAAAAEDgsHgNAAAAAAAAAAgcFq8BAAAAAAAAAIHD4jUAAAAAAAAAIHBYvAYAAAAAAAAABA6L1wAAAAAAAACAwBk86APox3cvPy/z5GjXzUaHp2Q3lsi42cSoPq5qeMvNDoVjujzcdKMjwyOy2iiuuFkkc0p2J+N62/vlqQf0cT191T+XycGG7F5bv+Jmx6f0fvfi3H3+DbJ0SR/z1aUbbjZ9eKzvY6oN52ReH6i72Yh4jt7udpPxvrulfEvmK4VbbjZY1YPQVMb//8iV63oMyqaH3Sw13eP/OatpNxqMT8vqkZDftZ01vV+hUtPnubO5JPN0e8bNBi76Y66Z2ZXKhpsd/cCTsvt//pvfdrOpqWOyO56IyLxfhYr/fjIzmzl8ws3CUf++Qn+K3fJBH8KPLRbtf64RiupxL5b236/N2/6zaGaWyQ65WXZH3/fFQX+MGQn3ePe2wzIfz/rj4rrVZNeKfrSTPiKrgwm/HB3W48t20e9OzczKbqVcdbNe9/uhjH9c9x7Wc34Teal85z1nP46tTfHuNbMt23az1Z2LsvuRj73LzXIX27IbSvnfYc/felF2x+L+e9saedktbPjP7K1SRXbf8+gH3ezVy6/L7te/4X/vLF/X85S5+86KtMe345qex+zFjakJN6vc1udj0hJ973cj1XfVukV9fyjJrv9NUArpe2cv+8Wd4wExNJmZvbqo5gR6PtGKZn/8Awq4i0eOu9mF+AdkN27X3WytvCO7jbo/F0l/549l9+x3/tDN/nzqM7Jr59+pc+FdD/s31/VcSHYr1fW+93tQ+MtrAAAAAAAAAEDgsHgNAAAAAAAAAAgcFq8BAAAAAAAAAIHD4jUAAAAAAAAAIHBYvAYAAAAAAAAABA6L1wAAAAAAAACAwBk86APox8kTUzL/7jNXRFqS3UuX33CzM+fGZTfdHXGzxFxSds9Nptzs0HBMdm34lM4DaDLunyszsw8dPeNm1fCW7K40qn3vdy/Utg89qK/hqxv6/lB2D2Xc7MHSMdl9cKLv3d7xEmF9bro5P0slsv3vtzUk88WdRTdbvnVRdtOxiEgPye7R+Y/LXO/YjwZ3yrKa2/Sf58n+T7N1Npf0fq9elnkkvelmt03/plDkiJsdPnJYdkdG4m5WalRkNyreFdGIvu+UM6cWZB6ODve97Xaz0Xf3TpYZ8d9TZmajw/5DNdYJye6tnbybjYf0/GkksuNmjd112Q3t+uPPfffo6eZWY9vNXnt+VXavv+w/61vrt2U3G0+42d+u35LdlPU/nxjPLMj8+Aff52ZDzajeuHiv7+w0ZXVoyL8/enX9K2iWiOs5TrEt/pZme0N229WWm83MTMtueLjmZqWNO/IT6Ue2vq3HoOa2/765VSnKbivujxX5JTG52qPvX/qWm7Vn/e8KM7OjXf8erG93ZPf5v/6Gmx07qicyOwn/Ho2l1JzOrFrx5yK3t/z3gJlZdjgs82HxzBYH9Dt/ecmfPx1OHpXdbtO/7/ID/vNqZmZ1P9oI9Zi3pfxvqV7UlpMFf05nZlYK6XkdgiM90P9H8/f1NMbUk96K6jEk0ty/MXW/dEP+3MvM7MZ9/jf6fe95RHY7y7/hZpN6+mzlP/pNN4td/7IuC7GIfs4LjR5jm3A95/+o7zzvr2uamRXX9LwuiPjLawAAAAAAAABA4LB4DQAAAAAAAAAIHBavAQAAAAAAAACBw+I1AAAAAAAAACBwWLwGAAAAAAAAAAQOi9cAAAAAAAAAgMBh8RoAAAAAAAAAEDiDB7XjyfiIzG+nht3s8R7b/tj98262UanL7uXLqz227mtlRt0sk9Snutf56FdkZkzmu2tDbtbt9n8uegmFZmQeT4vMkrI7lejniH4g1/b/P2c8q89lpdZys6lEQXbVMfe6DrdFtl6+3mO/x2R+N5vOvlPm4UH/eR6K+s9NL4OTUZnvvLTuZlMTE7Lb2m242VBsXB/XkD6uvvXYbqhZdrPMULvv3Za3NmU+M6/HkdeW427WWDird77rH/fSzSXd3YNapeZn5mdmZuHBmJvtNJuyW8jn9IHh79ha0/fBWHjZzU4unJDdxu6Om9VLi7IbSobd7JXXX5dd5eW/0N36uv+OzFc6slsIrblZrdyV3WbCv7dT1v+8bLWsnzezRZnmq/5vevTCw7q7WXKzraKf9ZLPbcs8PujfO8NR/31qZnbh2JybVSv+O8LMbHM772alVf88mpk1mrtuVsj77+K7wXpZnxsT05zRlp5PKN++tCLzSfMnxPER/z1lZlapV90sv63v31bC3/apSfFRYmbDcX8+cf36huya9f/+LL4hftOJad2NhGS+mPOP6+amHpNbDf+4pg4f1t2QP47MR/QcuBqZdLNsy/9GMzO7dO2SzJWBQ/65LKcjshuyjJslCvqY8eNLD+h76KC0otkD6Sqdgj+e9lKJ6PvezP9eNTNbun3LzW7e1mP5WOyTbtbZVasmZpXzflbYuk92z5RedrN4j/PR3PTnjKuFLdm99D1/rae4pr/f6rUbblba8LMfeLJHvj/4y2sAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgcPiNQAAAAAAAAAgcFi8BgAAAAAAAAAEDovXAAAAAAAAAIDAGTyoHd9ODffd3T2U0f+g2HCjyfiIrE49/EQ/hxRYu2v9d0Ohmb67g9M7Mt/Lce2nbLjjZp3ipuw22v7/BeUz+b6PaXClLvNZkW302Ha3u/pjH8/dYiSWPpD97u40ZX54Jutma8uXZbfZCLnZTnVrT8elDA5F3WxkMCy79WhCpDXZrUX8a5gYn5DdjcquzHfn5kXYll3l1deW+u7GBv3ra2bWbvnvvnBEv3OzGf86PPjABX1gwk5Tvwvau/41rje7fe836F56+bW+u8++vijziLi3h+L+PbKfmlU9vtQq/vtzNO6/l83MamX/PhlN6GemGy26WaiZkl2l137V7zUz+/zXn3Wzp59elN1WtP/5htKp9L/dgbiet0/O9D/fTOyMulk3rCebyYz/DqmbvoZ3u/a6/55bbeh34JHW+Jt9OGZmtna7IvPNpVtu9p6fOyO7eTHdKO/GZHcu7s/b7L7+z8VWRc/bcsmIm2WH9dzrmdduyny96o+7A8P6W/r4Xsm4xQAACr5JREFU/KSbzQzoc1ka8cfzQl2/v2JD/jxnMjsmu/ed+Iibra/elt1bVf/7sFKvyu5GqOxm5bR/feEb2BLjxKT+NsCbI1LW31i9VMx/LvJlPS7Ghv35xGjsvOyOjvrPXPfjp2X32rN/4GaTo0nZffmyPx4v5vX7diEz5WZF6/+bM9PV3+AHhb+8BgAAAAAAAAAEDovXAAAAAAAAAIDAYfEaAAAAAAAAABA4LF4DAAAAAAAAAAKHxWsAAAAAAAAAQOCweA0AAAAAAAAACBwWrwEAAAAAAAAAgTN40AfgmS023Ox2avgtPJK3xkBqws06xc238EjeGoPTOzK/Wau62aFSZt/2q6hjMjM7MhoTqcp6b1vZqNT77qpnaS/nGf0bTSTdLJsZk93mjn9/n7n3vOwODkX1gfWpvtuW+W6z7GadrL4HR1sFN1up7MruYmhW5tbjuPuV37qt/8HQqBtVe4wTMTEGhQf1GPTud7/DzepV/zzv1Ugs7WaJiH9v3OmmRroyj4/6eaVW0d1J1Q3pAxOa1Wbf3V4yU5G+uzMiS4zqY16uDbnZZKz/MTHV65Ue78g4JMavXHxDdmMtfX8oe7nGoW7KzaI7Pd4DMX+MyVX1HOdapeVmMdPnolm9Jo5Jv2/vdF/4xrLM5yP9vwNf2fLv7/iIfhddvbbqZjtFPYefSPvbXtnU77ET0/5I8sa2nk9MmP/cjJseR7YqWzJXZhcOu9n6tp5rDI34Y5+ZWW7Z//Y8ef9R2Z077B9Xp7gku5PD/nHF4v58wcysKr6Hdnb02La74y+JjI3pseDo4Sk3q7XCsnu9uO5muc012cUPl5zU9yf+X+lh/5uj193XbPQ/n2zv6knSTnHEzeq95in+kpptFkqyGmv4c9HxrP99bmZmj/6C333jsqwu5v337UJGjyH/w39xn5v9yz/U88Wrz8k4kPjLawAAAAAAAABA4LB4DQAAAAAAAAAIHBav/5927WU5jquMA/gZ3UaXkTWyY1u2KjYh5hJHWUEVqxQPwBNQsOSpeAmW8AJsqFAVKKiQIiQ4sWzZsnWdkTS6DYusUtT3TdFjMcf277f919d9dLr79OlPAwAAAABAdTSvAQAAAACojuY1AAAAAADV0bwGAAAAAKA6M5M68d39kzRvte6E2frBiIO3Ggxowi73txvXzqydhtn51lzj417leYfDp2l+N6steW3mfCu+r0a5v9a4dKT1g9U4XE6yMub1T56lUdfoTTcz157IeTce/jjMdl7spLWd5aXkuB+ktUeHh2F2cX6U1maOB8M0Xz0ehNnKvfjvKaWUzcfxfPzp2aj/zW6NyGML7fwlc3K5GGb/ftr8uVpazOejfx7P9c1Ofh0+2vhhmC3PTucDG8dpfN8tdG9f3XknbNCP7/tv8zgbtvfz2u2VMGsvNV/Xxqm93lluXLvTi++RUQ6P8jHfGuNvGsfouYz3yKN2dbvPzsJssXOZ1o5zjeeGz8PstHUtrX3xLN6MjHpW+uU4zKbb8f6olFJaJX5W+v3Hae3rbmk7vk9KKeUfrfi5uzXMn+edMfbpx5tPwuz7P9pIax9txu/1zz77Z1r7YC3+Prg/lT83n3wT34M/uJHP89Ry/GxM9/N5Pjt6GWYXh+dp7fNBvp+4trwXZrvP8v3TX3rxN+3PHj5Ma7OZXlueTWvTUfXia1RKKV8/jdeZbmfUuhjPZafka9B7c/HfdOv2gxHnfTt1p25OegivXHc+/m6oVXs+/q4YnOTfSdMz+fqTpWf9vIeYudnN9yKZF1ubaX7Yi/cxK198PeLo6w1G9K35hXi23n1nxHf04nth1j/O18xJ8ctrAAAAAACqo3kNAAAAAEB1NK8BAAAAAKiO5jUAAAAAANXRvAYAAAAAoDqa1wAAAAAAVEfzGgAAAACA6sxMegBvkpm108a151tzV1I7akxXdd5RWq07jWvHMc41GmWc+RgOnzaufXQ0H2Yzh4/T2ludhcbnfdOdnw6u5Ling/wevDg/CrONjQ8an7fX7zeuXWi3rqx2v38ZZp3utbT2y389i2uXrqe12TyXUsr0zGKaZwa7O2G2NJPPR/98GGYXZydpbbwSlPKrX/46rR1H5/b9MLu+uprWtmdnX/VwXgtHvfy3A/vDXpjdKStpbXupHWaDfr6uXV+Kr9dOf7f5eXsXaW2/5M/jVeksxs/b8GgprW0tZmtqPBdXbfX2ZJ6p01a+Xl+VlRLvY9oz3bT2enc5zkbcs6+7zkJ+f3dKnPeOm+8ntp4cpPnGhw/D7Mbau2ntl199GZ/3IL8XvtiK9+EP1vJvlp9exu/mJ8+309rMzsmI9Xo+XmcOpuK1rZRSzs7yNXdwFu9Vl2bz/dFePz728cVxWrsw3fy7pHUavzeP9/N7dngZt0S+2X2S1n74cCM+7xh/79ry27k/KqWU7tTNSQ/hlerON/+mqNXgpPm34ShHw3g/sXeWv5sPdzbDbHfEt/3J/os4nM/fIXfa8T17+8+fpLWzN+6F2b3382//R1/E75jPPo/XxFJKOT76KsxOdjtp7aT45TUAAAAAANXRvAYAAAAAoDqa1wAAAAAAVEfzGgAAAACA6mheAwAAAABQHc1rAAAAAACqMzPpAbxJzrfmJj2E/1LjmEopZWbtdCLnHTUf2bgeHfXT2vUSH3vz2m5ae3c/jSfiee84zVf+T+O4Ksf9vea1g+ErHMl3LbRbjbJRrnLM4xz7eK/5dfjm8jLMps+PGh+3lFJOD180rt159HXj2qWZ+BpfnOW1H//84zB7/8GHae2t22thdqPbzU/M/+z0Wv4uuntxJw5HPG6DfvxCmZ+9mdb2y0F+8PS8gzgrcVZKKe2lduPzZrXZmMbVO2q+Ho8a11Ev/m3JYide90oZby4zncXm6/ywu5jmrb14ve4s5s/K/PJ6ozGVUspl/zDM2p3pxsd923UWlsLswftxVkopq5fxvXKw12s8psP9x2n+6V/jdbO7kD9TK8vxmO9+715auzQV77X7B+dp7fZ+vE7snuR7oEebf0/zzHA73x/duPlOmH31PF/7Ht5ZiMNe/LyWUspuP94kHZeTtPZ651qSZlkpW1ubYfZgLXmXl1JWFmfDbL7z5v7GsDuV70Vq1J3P32Nvm37yDbbz7i/S2rPV+2neWo/XkM+3P09rPyrxmvry5cu0dnYuXn+utfO26fLf/hBm6yPWzN/8JP5u/P1O/g757e/+GGb7W1e3B56UN3dVBAAAAADgtaV5DQAAAABAdTSvAQAAAACojuY1AAAAAADV0bwGAAAAAKA6mtcAAAAAAFRH8xoAAAAAgOq0hsPhpMcAAAAAAADf4ZfXAAAAAABUR/MaAAAAAIDqaF4DAAAAAFAdzWsAAAAAAKqjeQ0AAAAAQHU0rwEAAAAAqI7mNQAAAAAA1dG8BgAAAACgOprXAAAAAABUR/MaAAAAAIDqaF4DAAAAAFAdzWsAAAAAAKqjeQ0AAAAAQHU0rwEAAAAAqI7mNQAAAAAA1dG8BgAAAACgOprXAAAAAABUR/MaAAAAAIDqaF4DAAAAAFAdzWsAAAAAAKqjeQ0AAAAAQHU0rwEAAAAAqI7mNQAAAAAA1dG8BgAAAACgOprXAAAAAABUR/MaAAAAAIDqaF4DAAAAAFAdzWsAAAAAAKqjeQ0AAAAAQHX+A/nDt36FOpuZAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 1800x1200 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uJ3Vap9bctHh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e1d4e87e-bbf7-4da1-fb4b-27eeb8a19bdb"
      },
      "source": [
        "i = 0\n",
        "for img,ax in zip(samples_img,axes):\n",
        "    ax.axis('off')\n",
        "    ax.imshow(img)\n",
        "    name = f'img{i}'+'.jpg'\n",
        "    print(name)\n",
        "    i += 1\n",
        "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
        "    cv2.imwrite(name, img)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "img0.jpg\n",
            "img1.jpg\n",
            "img2.jpg\n",
            "img3.jpg\n",
            "img4.jpg\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aoiI3f2NYMuT"
      },
      "source": [
        "# !python image-gpt/download.py --model s --ckpt 1000000 --dataset imagenet\n"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X8qS-wtalGDF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ed1f151-4e93-42f1-f241-eb0914b9066f"
      },
      "source": [
        "!pip install tensorflow==1.13.1\n",
        "!pip install tensorflow-gpu==1.13.1\n",
        "\n",
        "!python -c 'import tensorflow as tf; print(tf.__version__);'\n",
        "!python image-gpt/src/run.py --eval --n_embd 512  --n_head 8  --n_layer 24 --ckpt_path /content/models/s/model.ckpt-1000000 --color_cluster_path /content/models/s/ --save_dir /content/models/s/"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: tensorflow==1.13.1 in /usr/local/lib/python3.7/dist-packages (1.13.1)\n",
            "Requirement already satisfied: protobuf>=3.6.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (3.12.4)\n",
            "Requirement already satisfied: keras-applications>=1.0.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (1.0.8)\n",
            "Requirement already satisfied: astor>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (0.8.1)\n",
            "Requirement already satisfied: grpcio>=1.8.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (1.32.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (1.1.0)\n",
            "Requirement already satisfied: keras-preprocessing>=1.0.5 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (1.1.2)\n",
            "Requirement already satisfied: tensorflow-estimator<1.14.0rc0,>=1.13.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (1.13.0)\n",
            "Requirement already satisfied: gast>=0.2.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (0.3.3)\n",
            "Requirement already satisfied: tensorboard<1.14.0,>=1.13.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (1.13.1)\n",
            "Requirement already satisfied: absl-py>=0.1.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (0.12.0)\n",
            "Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (1.15.0)\n",
            "Requirement already satisfied: numpy>=1.13.3 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (1.19.5)\n",
            "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorflow==1.13.1) (0.36.2)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from protobuf>=3.6.1->tensorflow==1.13.1) (54.2.0)\n",
            "Requirement already satisfied: h5py in /usr/local/lib/python3.7/dist-packages (from keras-applications>=1.0.6->tensorflow==1.13.1) (2.10.0)\n",
            "Requirement already satisfied: mock>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-estimator<1.14.0rc0,>=1.13.0->tensorflow==1.13.1) (4.0.3)\n",
            "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard<1.14.0,>=1.13.0->tensorflow==1.13.1) (1.0.1)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard<1.14.0,>=1.13.0->tensorflow==1.13.1) (3.3.4)\n",
            "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard<1.14.0,>=1.13.0->tensorflow==1.13.1) (3.8.1)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<1.14.0,>=1.13.0->tensorflow==1.13.1) (3.7.4.3)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<1.14.0,>=1.13.0->tensorflow==1.13.1) (3.4.1)\n",
            "Requirement already satisfied: tensorflow-gpu==1.13.1 in /usr/local/lib/python3.7/dist-packages (1.13.1)\n",
            "Requirement already satisfied: gast>=0.2.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (0.3.3)\n",
            "Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (1.15.0)\n",
            "Requirement already satisfied: protobuf>=3.6.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (3.12.4)\n",
            "Requirement already satisfied: tensorflow-estimator<1.14.0rc0,>=1.13.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (1.13.0)\n",
            "Requirement already satisfied: tensorboard<1.14.0,>=1.13.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (1.13.1)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (1.1.0)\n",
            "Requirement already satisfied: absl-py>=0.1.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (0.12.0)\n",
            "Requirement already satisfied: astor>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (0.8.1)\n",
            "Requirement already satisfied: numpy>=1.13.3 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (1.19.5)\n",
            "Requirement already satisfied: grpcio>=1.8.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (1.32.0)\n",
            "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (0.36.2)\n",
            "Requirement already satisfied: keras-preprocessing>=1.0.5 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (1.1.2)\n",
            "Requirement already satisfied: keras-applications>=1.0.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.13.1) (1.0.8)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from protobuf>=3.6.1->tensorflow-gpu==1.13.1) (54.2.0)\n",
            "Requirement already satisfied: mock>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-estimator<1.14.0rc0,>=1.13.0->tensorflow-gpu==1.13.1) (4.0.3)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard<1.14.0,>=1.13.0->tensorflow-gpu==1.13.1) (3.3.4)\n",
            "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard<1.14.0,>=1.13.0->tensorflow-gpu==1.13.1) (1.0.1)\n",
            "Requirement already satisfied: h5py in /usr/local/lib/python3.7/dist-packages (from keras-applications>=1.0.6->tensorflow-gpu==1.13.1) (2.10.0)\n",
            "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard<1.14.0,>=1.13.0->tensorflow-gpu==1.13.1) (3.8.1)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<1.14.0,>=1.13.0->tensorflow-gpu==1.13.1) (3.7.4.3)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<1.14.0,>=1.13.0->tensorflow-gpu==1.13.1) (3.4.1)\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:528: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:529: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:530: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:535: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
            "1.13.1\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:528: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:529: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:530: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/dtypes.py:535: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
            "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
            "input args:\n",
            " {\n",
            "    \"data_path\":\"/root/downloads/imagenet\",\n",
            "    \"ckpt_path\":\"/content/models/s/model.ckpt-1000000\",\n",
            "    \"color_cluster_path\":\"/content/models/s/\",\n",
            "    \"save_dir\":\"/content/models/s/\",\n",
            "    \"n_embd\":512,\n",
            "    \"n_head\":8,\n",
            "    \"n_layer\":24,\n",
            "    \"n_px\":32,\n",
            "    \"n_vocab\":512,\n",
            "    \"bert\":false,\n",
            "    \"bert_mask_prob\":0.15,\n",
            "    \"clf\":false,\n",
            "    \"n_sub_batch\":8,\n",
            "    \"n_gpu\":8,\n",
            "    \"eval\":true,\n",
            "    \"sample\":false,\n",
            "    \"seed\":42\n",
            "}\n",
            "WARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Colocations handled automatically by placer.\n",
            "trainable parameters: 76571648\n",
            "2021-04-05 12:15:11.871536: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA\n",
            "2021-04-05 12:15:11.904677: I tensorflow/core/platform/profile_utils/cpu_utils.cc:94] CPU Frequency: 2299995000 Hz\n",
            "2021-04-05 12:15:11.905091: I tensorflow/compiler/xla/service/service.cc:150] XLA service 0x55b5b12907e0 executing computations on platform Host. Devices:\n",
            "2021-04-05 12:15:11.905126: I tensorflow/compiler/xla/service/service.cc:158]   StreamExecutor device (0): <undefined>, <undefined>\n",
            "2021-04-05 12:15:12.024423: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:998] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
            "2021-04-05 12:15:12.025256: I tensorflow/compiler/xla/service/service.cc:150] XLA service 0x55b5b1290940 executing computations on platform CUDA. Devices:\n",
            "2021-04-05 12:15:12.025294: I tensorflow/compiler/xla/service/service.cc:158]   StreamExecutor device (0): Tesla K80, Compute Capability 3.7\n",
            "2021-04-05 12:15:12.025560: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1433] Found device 0 with properties: \n",
            "name: Tesla K80 major: 3 minor: 7 memoryClockRate(GHz): 0.8235\n",
            "pciBusID: 0000:00:04.0\n",
            "totalMemory: 11.17GiB freeMemory: 8.51GiB\n",
            "2021-04-05 12:15:12.025609: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1512] Adding visible gpu devices: 0\n",
            "2021-04-05 12:15:12.027876: I tensorflow/core/common_runtime/gpu/gpu_device.cc:984] Device interconnect StreamExecutor with strength 1 edge matrix:\n",
            "2021-04-05 12:15:12.027910: I tensorflow/core/common_runtime/gpu/gpu_device.cc:990]      0 \n",
            "2021-04-05 12:15:12.027925: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1003] 0:   N \n",
            "2021-04-05 12:15:12.028109: W tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.cc:42] Overriding allow_growth setting because the TF_FORCE_GPU_ALLOW_GROWTH environment variable is set. Original config value was 0.\n",
            "2021-04-05 12:15:12.028166: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1115] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 8281 MB memory) -> physical GPU (device: 0, name: Tesla K80, pci bus id: 0000:00:04.0, compute capability: 3.7)\n",
            "WARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use standard file APIs to check for files with this prefix.\n",
            "tcmalloc: large alloc 5043118080 bytes == 0x55b5d2be8000 @  0x7fca2adba1e7 0x7fca2801546e 0x7fca28069e7c 0x7fca2806aaaf 0x7fca2810c470 0x55b5af8c00e4 0x55b5af8bfde0 0x55b5af9346f5 0x55b5af92eb0e 0x55b5af8c177a 0x55b5af93086a 0x55b5af92eb0e 0x55b5af8c177a 0x55b5af933e50 0x55b5af8c169a 0x55b5af92fa45 0x55b5af8c169a 0x55b5af92fa45 0x55b5af92eb0e 0x55b5af92e813 0x55b5af9f8592 0x55b5af9f890d 0x55b5af9f87b6 0x55b5af9d0103 0x55b5af9cfdac 0x7fca29ba4bf7 0x55b5af9cfc8a\n",
            "tcmalloc: large alloc 4924923904 bytes == 0x55b6ff566000 @  0x7fca2adba1e7 0x7fca2801546e 0x7fca28069e7c 0x7fca2806aaaf 0x7fca2810c470 0x55b5af8c00e4 0x55b5af8bfde0 0x55b5af9346f5 0x55b5af92eb0e 0x55b5af8c177a 0x55b5af93086a 0x55b5af92eb0e 0x55b5af8c177a 0x55b5af933e50 0x55b5af8c169a 0x55b5af92fa45 0x55b5af8c169a 0x55b5af92fa45 0x55b5af92eb0e 0x55b5af92e813 0x55b5af9f8592 0x55b5af9f890d 0x55b5af9f87b6 0x55b5af9d0103 0x55b5af9cfdac 0x7fca29ba4bf7 0x55b5af9cfc8a\n",
            "^C\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qZqUMBOuTc4t",
        "outputId": "14f35143-2628-4ef9-e8e0-c75948687a3c"
      },
      "source": [
        "!nvcc --version"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "nvcc: NVIDIA (R) Cuda compiler driver\n",
            "Copyright (c) 2005-2020 NVIDIA Corporation\n",
            "Built on Wed_Jul_22_19:09:09_PDT_2020\n",
            "Cuda compilation tools, release 11.0, V11.0.221\n",
            "Build cuda_11.0_bu.TC445_37.28845127_0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6f6awWy__aTQ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}