EDL_4_4_EvoLisa_ES.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "EDL_4_4_EvoLisa_ES.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOrT8CpOPtD5urM2tQam+fs",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cxbxmxcx/EvolutionaryDeepLearning/blob/main/EDL_4_4_EvoLisa_ES.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QA0DAcx1b-Zk",
        "outputId": "130af200-2a48-4736-e930-744290fb70c4"
      },
      "source": [
        "#@title Install DEAP\n",
        "!pip install deap --quiet"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u001b[?25l\r\u001b[K     |██                              | 10 kB 20.0 MB/s eta 0:00:01\r\u001b[K     |████                            | 20 kB 24.8 MB/s eta 0:00:01\r\u001b[K     |██████                          | 30 kB 18.3 MB/s eta 0:00:01\r\u001b[K     |████████▏                       | 40 kB 12.6 MB/s eta 0:00:01\r\u001b[K     |██████████▏                     | 51 kB 5.5 MB/s eta 0:00:01\r\u001b[K     |████████████▏                   | 61 kB 5.6 MB/s eta 0:00:01\r\u001b[K     |██████████████▎                 | 71 kB 5.4 MB/s eta 0:00:01\r\u001b[K     |████████████████▎               | 81 kB 6.0 MB/s eta 0:00:01\r\u001b[K     |██████████████████▎             | 92 kB 5.9 MB/s eta 0:00:01\r\u001b[K     |████████████████████▍           | 102 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |██████████████████████▍         | 112 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |████████████████████████▍       | 122 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |██████████████████████████▌     | 133 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |████████████████████████████▌   | 143 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |██████████████████████████████▌ | 153 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 160 kB 5.1 MB/s \n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L6P5gIVNYj-f"
      },
      "source": [
        "#@title Imports\n",
        "import random\n",
        "import numpy as np\n",
        "\n",
        "from deap import algorithms\n",
        "from deap import base\n",
        "from deap import creator\n",
        "from deap import tools\n",
        "\n",
        "import os\n",
        "import cv2\n",
        "import urllib.request\n",
        "import matplotlib.pyplot as plt\n",
        "from IPython.display import clear_output"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Es3IZavnIjS7"
      },
      "source": [
        "#@title Image Helpers\n",
        "def load_target_image(image_url, color=True, size=None):\n",
        "  image_path = \"target_image\"    \n",
        "  urllib.request.urlretrieve(image_url,image_path)\n",
        "  if color:\n",
        "      target = cv2.imread(image_path, cv2.IMREAD_COLOR)\n",
        "      # Switch from bgr to rgb\n",
        "      target = cv2.cvtColor(target, cv2.COLOR_BGR2RGB)\n",
        "  else:\n",
        "      target = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)\n",
        "\n",
        "  if size:\n",
        "      # Only resizes image if it is needed!\n",
        "      target = cv2.resize(src=target, dsize=size, interpolation=cv2.INTER_AREA)\n",
        "  return target\n",
        "\n",
        "def show_image(img_arr):    \n",
        "  plt.figure(figsize=(10,10))\n",
        "  plt.axis(\"off\")\n",
        "  plt.imshow(img_arr/255)\n",
        "  plt.show()\n",
        "\n",
        "def show_results(history, img_arr, org):\n",
        "  plt.figure(figsize=(10,10))\n",
        "  plt.tight_layout()\n",
        "\n",
        "  plt.subplot(221)\n",
        "  plt.axis(\"off\")\n",
        "  plt.imshow(img_arr/255)\n",
        "  plt.title('best of generation')\n",
        "\n",
        "  plt.subplot(222)\n",
        "  plt.axis(\"off\")\n",
        "  plt.imshow(org/255)\n",
        "  plt.title('target image')\n",
        "\n",
        "  plt.subplot(212)\n",
        "  lh = len(history)\n",
        "  plt.xlim([lh-50, lh])\n",
        "  plt.plot(history)\n",
        "  plt.title('min fitness by generation') \n",
        "  plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 592
        },
        "id": "xX-PazxIeD3v",
        "outputId": "d467f74d-4d05-4f93-e94a-74f04ebfb79f"
      },
      "source": [
        "#@title Default title text { run: \"auto\" }\n",
        "polygons = 255 #@param {type:\"slider\", min:10, max:1000, step:1}\n",
        "size = 32 #@param {type:\"slider\", min:16, max:1000, step:2}\n",
        "target_image = \"Mona Lisa\" #@param [\"Mona Lisa\", \"Stop Sign\", \"Landscape\", \"Celebrity\", \"Art\", \"Abstract\"]\n",
        "report_every_gen = 10 #@param {type:\"slider\", min:1, max:100, step:1}\n",
        "number_generations = 10000 #@param {type:\"slider\", min:100, max:10000, step:10}\n",
        "\n",
        "\n",
        "POLYGONS = polygons\n",
        "SIZE = (size, size)\n",
        "\n",
        "target_urls = { \"Mona Lisa\" : 'data:image/jpeg;base64,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',\n",
        "               \"Stop Sign\" : 'https://images.uline.com/is/image//content/dam/images/H/H2500/H-2381.jpg',\n",
        "               \"Landscape\" : 'https://www.adorama.com/alc/wp-content/uploads/2018/11/landscape-photography-tips-yosemite-valley-feature.jpg',\n",
        "               \"Celebrity\" : 'https://s.abcnews.com/images/Entertainment/WireAP_91d6741d1954459f9993bd7a2f62b6bb_16x9_992.jpg',\n",
        "               \"Art\" : \"http://www.indianruminations.com/wp-content/uploads/what-is-modern-art-definition-2.jpg\",\n",
        "               \"Abstract\" : \"https://scx2.b-cdn.net/gfx/news/2020/abstractart.jpg\"\n",
        "               }\n",
        "\n",
        "target_image_url = target_urls[target_image]\n",
        "target = load_target_image(target_image_url, size=SIZE)\n",
        "show_image(target)\n",
        "print(target.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(32, 32, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5MNv6EWeeWYO",
        "outputId": "184fea01-ecad-4988-9269-830a5f181aa0"
      },
      "source": [
        "#@title Setup Polylines\n",
        "\n",
        "#polygon genes\n",
        "GENE_LENGTH = 10\n",
        "NUM_GENES = POLYGONS * GENE_LENGTH\n",
        "\n",
        "#create a sample invidiual\n",
        "individual = np.random.uniform(0,1,NUM_GENES)\n",
        "print(individual)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.5825531  0.73328857 0.27729114 ... 0.55356697 0.4061114  0.60748266]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 575
        },
        "id": "sTzsqLjtDxWQ",
        "outputId": "0d662613-9a1d-403f-85b1-717440f591fa"
      },
      "source": [
        "#@title Render an Individual\n",
        "def extract_genes(genes, length): \n",
        "    for i in range(0, len(genes), length): \n",
        "        yield genes[i:i + length]\n",
        "\n",
        "def render_individual(individual):\n",
        "  if isinstance(individual,list):\n",
        "    individual = np.array(individual)\n",
        "  canvas = np.zeros(SIZE+(3,))\n",
        "  radius_avg = (SIZE[0] + SIZE[1]) / 2 / 6\n",
        "  genes = extract_genes(individual, GENE_LENGTH)\n",
        "  for gene in genes:\n",
        "    try:\n",
        "      overlay = canvas.copy()\n",
        "      # alternative drawing methods circle or rectangle\n",
        "      # circle brush uses a GENE_LENGTH of 7\n",
        "      # center = (0, 1) [2]\n",
        "      # radius = (2) [3]\n",
        "      # color = (3,4,5) [6]\n",
        "      # alpha = (6) [7]\n",
        "      #cv2.circle(\n",
        "      #    overlay,\n",
        "      #    center=(int(gene[1] * SIZE[1]), int(gene[0] * SIZE[0])),\n",
        "      #    radius=int(gene[2] * radius_avg),\n",
        "      #    color=color,\n",
        "      #    thickness=-1,\n",
        "      #)\n",
        "\n",
        "      # rectangle brush uses GENE_LENGTH = 8\n",
        "      # top left = (0, 1) [2]\n",
        "      # btm right = (2, 3) [4]\n",
        "      # color = (4, 5, 6) [7]\n",
        "      # alpha = (7) [8]\n",
        "      #cv2.rectangle(overlay, (x1, y1), (x2, y2), color, -1)    \n",
        "\n",
        "      # polyline brush uses GENE_LENGTH = 10\n",
        "      # pts = (0, 1), (2, 3), (4, 5) [6]      \n",
        "      # color = (6, 7, 8) [9]\n",
        "      # alpha = (9) [10]\n",
        "      x1 = int(gene[0] * SIZE[0])\n",
        "      x2 = int(gene[2] * SIZE[0])\n",
        "      x3 = int(gene[4] * SIZE[0])\n",
        "      y1 = int(gene[1] * SIZE[1])\n",
        "      y2 = int(gene[3] * SIZE[1])\n",
        "      y3 = int(gene[5] * SIZE[1])\n",
        "      color = (gene[6:-1] * 255).astype(int).tolist() \n",
        "      pts = np.array([[x1,y1],[x2,y2],[x3,y3]], np.int32)  \n",
        "      pts = pts.reshape((-1, 1, 2))\n",
        "      pts = np.array([[x1,y1],[x2,y2],[x3,y3]])\n",
        "\n",
        "      cv2.fillPoly(overlay, [pts], color)\n",
        "      alpha = gene[-1]\n",
        "      canvas = cv2.addWeighted(overlay, alpha, canvas, 1 - alpha, 0)  \n",
        "    except:\n",
        "      pass\n",
        "  return canvas\n",
        "\n",
        "render = render_individual(individual)\n",
        "show_image(render)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "626salpU3bCa",
        "outputId": "0691c6c7-2121-443c-eeea-867abc253e2f"
      },
      "source": [
        "from skimage.metrics import structural_similarity as ss\n",
        "#@title Fitness Function\n",
        "def fitness_mse(render):\n",
        "  \"\"\"Calculates Mean Square Error Fitness for a render\"\"\"\n",
        "  error = (np.square(render - target)).mean(axis=None)\n",
        "  return error\n",
        "\n",
        "def fitness_ss(render):\n",
        "  \"\"\"Calculated Structural Similiarity Fitness\"\"\"\n",
        "  index = ss(render, target, multichannel=True)\n",
        "  return 1-index\n",
        "\n",
        "print(fitness_mse(render))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "7804.764603062693\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cnVh9cdmtlv3"
      },
      "source": [
        "#@title ES Bounding Hyperparameters\n",
        "IND_SIZE = NUM_GENES\n",
        "MIN_VALUE = -1\n",
        "MAX_VALUE = 1\n",
        "MIN_STRATEGY = 0.5\n",
        "MAX_STRATEGY = 5\n",
        "\n",
        "CXPB = .6\n",
        "MUTPB = .3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZRvse58ccZpI"
      },
      "source": [
        "#@title Setting up the Creator\n",
        "#creator.create(\"FitnessMax\", base.Fitness, weights=(-1.0,))\n",
        "#creator.create(\"Individual\", list, fitness=creator.FitnessMax)\n",
        "\n",
        "creator.create(\"FitnessMin\", base.Fitness, weights=(-1.0,))\n",
        "creator.create(\"Individual\", list, typecode=\"d\", fitness=creator.FitnessMin, strategy=None)\n",
        "creator.create(\"Strategy\", list, typecode=\"d\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KlffxCeQt6gA"
      },
      "source": [
        "#@title Individual generator and decorate functions\n",
        "def generateES(icls, scls, size, imin, imax, smin, smax):  \n",
        "  ind = icls(random.uniform(imin, imax) for _ in range(size))  \n",
        "  ind.strategy = scls(random.uniform(smin, smax) for _ in range(size))  \n",
        "  return ind\n",
        "\n",
        "def checkStrategy(minstrategy):\n",
        "  def decorator(func):\n",
        "    def wrappper(*args, **kargs):\n",
        "      children = func(*args, **kargs)\n",
        "      for child in children:\n",
        "        for i, s in enumerate(child.strategy):\n",
        "          if s < minstrategy:\n",
        "            child.strategy[i] = minstrategy\n",
        "      return children\n",
        "    return wrappper\n",
        "  return decorator"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NeEjluAhcysa"
      },
      "source": [
        "def uniform(low, up, size=None):\n",
        "  try:\n",
        "    return [random.uniform(a, b) for a, b in zip(low, up)]\n",
        "  except TypeError:\n",
        "    return [random.uniform(a, b) for a, b in zip([low] * size, [up] * size)]\n",
        "\n",
        "#toolbox = base.Toolbox()\n",
        "#toolbox.register(\"attr_float\", uniform, 0, 1, NUM_GENES)\n",
        "#toolbox.register(\"individual\", tools.initIterate, creator.Individual, toolbox.attr_float)\n",
        "#toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hU8nWySkXb0j"
      },
      "source": [
        "def clamp(low, up, n):\n",
        "  return max(low, min(n, up))\n",
        "\n",
        "def custom_blend(ind1, ind2, alpha):    \n",
        "    for i, (x1, s1, x2, s2) in enumerate(zip(ind1, ind1.strategy,\n",
        "                                             ind2, ind2.strategy)):\n",
        "        # Blend the values\n",
        "        gamma = (1. + 2. * alpha) * random.random() - alpha\n",
        "        ind1[i] = clamp(0.0, 1.0, (1. - gamma) * x1 + gamma * x2)\n",
        "        ind2[i] = clamp(0.0, 1.0, gamma * x1 + (1. - gamma) * x2)\n",
        "        # Blend the strategies\n",
        "        gamma = (1. + 2. * alpha) * random.random() - alpha\n",
        "        ind1.strategy[i] = (1. - gamma) * s1 + gamma * s2\n",
        "        ind2.strategy[i] = gamma * s1 + (1. - gamma) * s2\n",
        "        \n",
        "\n",
        "    return ind1, ind2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lb2RB47quEgQ"
      },
      "source": [
        "#@title Setup the Toolbox\n",
        "toolbox = base.Toolbox()\n",
        "toolbox.register(\"individual\", generateES, creator.Individual, creator.Strategy,\n",
        "    IND_SIZE, MIN_VALUE, MAX_VALUE, MIN_STRATEGY, MAX_STRATEGY)\n",
        "toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n",
        "toolbox.register(\"mate\", custom_blend, alpha=0.5)\n",
        "toolbox.register(\"mutate\", tools.mutESLogNormal, c=1.0, indpb=0.06)\n",
        "toolbox.register(\"select\", tools.selTournament, tournsize=5)\n",
        "\n",
        "toolbox.decorate(\"mate\", checkStrategy(MIN_STRATEGY))\n",
        "toolbox.decorate(\"mutate\", checkStrategy(MIN_STRATEGY))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kJYSqw0C49as"
      },
      "source": [
        "def evaluate(individual):\n",
        "  render = render_individual(individual)\n",
        "  print('.', end='')\n",
        "  return fitness_mse(render),  #using MSE for fitness"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "auv2mxKrdWDV"
      },
      "source": [
        "#@title Mutation and Evaluation\n",
        "#toolbox.register(\"mutate\", tools.mutGaussian, mu=0.0, sigma=.1, indpb=.25)\n",
        "toolbox.register(\"evaluate\", evaluate)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "th7zmZin5wiC"
      },
      "source": [
        "random.seed(64)\n",
        "    \n",
        "NGEN = number_generations\n",
        "RGEN = report_every_gen\n",
        "CXPB = .6\n",
        "MUTPB = .3\n",
        "MU, LAMBDA = 100, 250\n",
        "pop = toolbox.population(n=MU)\n",
        "hof = tools.HallOfFame(1)\n",
        "stats = tools.Statistics(lambda ind: ind.fitness.values)\n",
        "stats.register(\"avg\", np.mean)\n",
        "stats.register(\"std\", np.std)\n",
        "stats.register(\"min\", np.min)\n",
        "stats.register(\"max\", np.max) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/",
          "height": 661
        },
        "id": "pORryNkH73S_",
        "outputId": "419f8820-811e-4176-c8db-4e58bad3388d"
      },
      "source": [
        "best = None\n",
        "history = []\n",
        "\n",
        "for g in range(NGEN):\n",
        "  pop, logbook = algorithms.eaMuCommaLambda(pop, toolbox, mu=MU, lambda_=LAMBDA, \n",
        "            cxpb=CXPB, mutpb=MUTPB, ngen=RGEN, stats=stats, halloffame=hof, verbose=False)\n",
        "  \n",
        "  best = hof[0]\n",
        "  #pop, logbook = algorithms.eaSimple(pop, toolbox, \n",
        "  #         cxpb=CXPB, mutpb=MUTPB, ngen=100, stats=stats, halloffame=hof, verbose=False)\n",
        "  #best = hof[0] \n",
        "  clear_output()  \n",
        "  render = render_individual(best) \n",
        "  history.extend([clamp(0.0, 5000.0, l[\"min\"]) for l in logbook])\n",
        "  show_results(history, render, target)  \n",
        "  print(f\"Gen ({(g+1)*RGEN}) : best fitness = {fitness_mse(render)}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmkAAAJOCAYAAADs2JBcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzde5ilZ1nn+9+91qpzVZ87naTTOZGQEAQBmySKs0V0ABGFSx1EEaKba7J16956bR0Uxz0g4gz8MTrDODLiMBKQoweGgzgaOYsmpMMhmBPpJJ10d/pQ3XXoOtc63PuP9ca9aPq5n0pXV/qpyvdzXXV11brXe37fp+5aa72/NncXAAAAylI73ysAAACAb0eTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFoklb58zsgJn94Plej15mNmRmnzCzaTP7s/O9PueSmf0LM7v/fK8HgPIxXmC1aNLwbczszWb2p6uYxU9I2iVpu7v/q3O0WueFmbmZXfX4z+7+RXe/5nyuE4Cu8/1Ham75jBdYLZo0rIXLJH3T3Vvne0UiZtY43+sA4Pwxs/r5XgcgQpO2MTzfzO4xs0kz+xMzG3y8YGYvN7OvmdmUmf2DmT27p/brZnbYzGbM7H4z+wEze6mk35T0k2Y2a2ZfP9MCzewZZva5ar53m9mPVo//tqR/1zP9688w7ZCZ3VKt771m9gYzO9RTv9jM/sLMxs3sYTP7v3tqbzazj5jZe6v1vtvM9j6Baf/czP7UzE5J+lkzu97M/rHajiNm9gdm1l89/wvVpF+vtuUnzeyFp63rGfdDVXuPmf1XM/ural1vN7OnreSAAoiZ2fskXSrpE9X1+Ybq8T8zs6PVxy2+YGbP7JnmPWb2TjP7lJnNSfp+M3uemX21ukb/zMw+bGZv7ZnmjGNoavmnrePp48UBM/s3ZnaXmc2Z2bvNbJeZ/XW1/L8zs609z4+2Zbt1P1ZyyszuMLO3mtnf99SvNbNbzWyiGt9fdY52PZ5M7s7XOv6SdEDSP0naI2mbpC9JemtVe66k45JukFSXdFP1/AFJ10g6KOni6rmXS3pa9f2bJf1psMw+SfvVbeb6Jb1I0oyka1Y4/dskfV7SVkmXSLpL0qGqVpN0p7qNXr+kKyU9JOklPfNelPSyapv+g6TbnsC0TUmvrJ47JOm7JN0oqVHtg3sl/UrPurqkq3p+fmHPuub2w3sknZR0fTX/90v60Pk+Z/jia6N8VePZD5722P8uaawa5/6TpK/11N4jaVrSC6oxYJOkRyT9cnU9/5ik5ZWMoanln7Yu/zxe9Dz/NnU/DrK7mvdXquUMSvqMpDetcFs+VH0NS7pO3fH876vaSPXzz1Vjz3MlnZB03fk+Znw9sS9eSdsY/sDdD7r7hKTflfRT1eM3S/ojd7/d3dvufoukJXWbkra6F/51Ztbn7gfc/cEVLu9GSaOS3ubuy+7+GUmf7Fluzqsk/Xt3n3T3Q5Le0VN7vqSd7v6Wat4PSfpjSa/uec7fu/un3L0t6X2SvvMJTPuP7v4/3b3j7gvufqe73+buLXc/IOmPJH3fOdwPH3X3L3v3rd/3S3rOCucN4Cy4+/9w9xl3X1L3D7PvNLPNPU/5mLt/yd076l6PDUnvcPemu/+lpC/3PDcaQ8/Wf3H3Y+5+WNIXJd3u7l9190VJH1W3oQq3xbpv0/64ug3dvLvfI+mWnmW8XNIBd/+Tamz7qqS/kLSuPyP8VMRncjaGgz3fPyLp4ur7yyTdZGb/V0+9X91Xzz5vZr+i7oX/TDP7G0n/j7s/toLlXSzpYDXI9S539wrX9+LT1rn3+8skXWxmUz2P1dUdzB53tOf7eUmD1v182Uqm7V2WzOzpkn5P0l51/yJtqPtq3Iq3I7MfTl/X0RXOG8ATVDUvv6tuM7JT0uPX5g51X0GTvnUMuFjSYffuy09nqCfH0FWs5rGe7xfO8POolN2WIXXHqmgcveG0sbCh7h+1WEd4JW1j2NPz/aWSHm+0Dkr6XXff0vM17O4flCR3/4C7f6+6F7RLens1Xe+AdSaPSdpjZr3nz6WSDq9wfY+o+zbnmdb/oKSHT1vnMXd/2Qrmu5JpT9+2d0q6T9LV7r5J3bcubYXbsdr9AGB1Tr+ef1rSKyT9oKTN6n6EQfrWa7p3miOSdptZb/308Sg5hp5h+edStC3jklqKx9HPn7beo+7+C2u4vlgDNGkbwy+a2SVmtk3Sv5X04erxP5b082Z2g3WNmNkPm9mYmV1jZi8yswF1P+O1oP//L7Vjki4/rfnodbu6rwq9wcz6zOyFkn5E3c9HrMRHJL3RzLaa2W5Jv9RT+7KkGeve1DBkZnUz+w4ze/4K5ns2045JOiVp1syulXT6IHZM3c+2nclq9wOA1Tn9+hxT9+3Ik+q+Mv7vM9P/o7of/fglM2uY2SvU/Qzp45JjaGL551JyW6qPevylpDeb2XA1dr2uZ9pPSnq6mb22Gpv6zOz5ZvaMNVpXrBGatI3hA5L+Vt0PyT8o6a2S5O77JP1rSX8gaVLdD7n/bDXNgLof4D+h7ltyF0h6Y1V7PID2pJl95fSFufuyus3ID1XT/6Gk17n7fStc37dIOiTpYUl/J+nP1R2MHh98Xq7uZ0Uerub/39X9SzJ0ltP+mrp/sc6oOyB/+LT6myXdUt3Z9S13R52D/QBgdf6DpN+qrs9fk/RedT9ycFjSPep+SD+puoZ/TNLrJU1J+hl1G5zHx6NoDD3T8s+l3Lb8krpj21F138b8YM96z0h6sbqfx32ses7b1R33sY7Yt74VDzz5zOwXJL3a3Vf6gX0AWBNmdruk/+buf3K+1+WJMLO3S7rQ3W863+uCc4dX0vCkM7OLzOwFZlYzs2sk/aq6dzUBwJPKzL7PzC6s3u68SdKzJf2v871eOVUO2rOrt2GvV/fVQMbRDYa7O3E+9KsbdXGFum8xfEjdtwoB4Ml2jbqfkx1R9yMjP+HuR87vKq3ImLpvcV6s7mfj/qOkj53XNcI5x9udAAAABeLtTgAAgAKtq7c73/im14Uv+w02lpO1drsdzts68f8F3pmJ+9kdF6V35dHmWLImSWP9c2F9IPN/AC95etsWmvF2r1a9efb/h3pDg2F9cLD/rOe9MBrv09kHF8P65NJSWL9gZFOyNrQtzqudHYj3Wb2WqQ+k90sn88K4dzLnQ+Y6WF5I79d6K75G+jqdsP6W3/rkSvPp1qU3v+3V4dHpeHr8yr3j0WjEQ3mtHu97tdO7vpY5Z1rL8bXUqZ39dVxvxDcjtjzz/6M3+uJyJ7jOW/F2NzLr5rXMr9fgbPdgTJekVjve597O/D7rpBeeO16eOdfqjfiY1GrBuZYZv9qZMaSbppLWaqb3W8Pj4afj8T5967/92JqMX7ySBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAo0LqK4Bgbi2+ndk/X64rv7e1vZ+79HY7Lqqdvz93WiOMclltxFMXSzEJm4WkDA7lDHN813FiaDOvLC7PJ2tz0fDzvwXSMhSTdtT++zXxTX/qY7f7fLo6n3RLvl+WJOMJj8tR4smY741vQ+9vNsN5cjI+J1dPrXl+IbxO3zE3ilrnFvd0M/q7LzLvlT+2/Cfsyt/DXG+kd2O7E50wm9UDeiZ/QqaWPTaOeiVbJHNZOJj6kL4jJaGb22WBm3p2leL/Nzqav86W5eNxtN+NrxTK/XqPYlKHNcQxG32Bmp2euxeVaep97ZpAwj/dpLRPjU7f0utcUT9sI4jskqeOZYxKcT9aOp22cp+HrqT1qAgAAFIomDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKtK4iOBZq8f9wP7ScrpniaecX4/pcJ74l+oLh+NbhyEJrKqw/86L4MD1y33SyZplkkcPT6WklaerROIJDQazC/KlcdMiRsDo+E/8NMXVhOhfl4fceC6et98XH8zu+c0tYX26lb9c+/nC8XRdfdkFYH8j86TSo4FbxoXjipeZQWPcg1kSSrJmOkxleipfdHltXw80519cfn3Pu6QGsrxFPaxbHE1k9rrdqweDpcXxHXQNhvd/jCKLOcjqq58SD8bW0cCgenxZmgu2SND2fHrdbHu/zZis+32sW77fl5fR+aWciowaG4iiK4c3x8d5xWTqi6KIr4/HJBjMRHBoL61FqSr2eO8/j7a4F43J3BkGtL/4dXmvHPcJa4ZU0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKtK6Ci7YMxqvbXErntzRqcW7MyLY4y2fHYJyh0pyN5x/Z3I63695PPhLW5xfT293sj/N2FlsTYT2zy3Uq2O6+gXji1ny8zy8ciTNvDhyeSxcX4+O1aSzOT7rt08G8JXnw903/QJzlM39dOhdKkp5+4xVhvVNPH9OBVpxhVO+L68rkDI0Gx6Sdjq2rZh1v90Y3NDgY1tud9HnT15/JoMtkOHkmPqq/FuTnteNrpdaO8xCPPngwrB++50Cy1p/JIts+Fl9rQ1vjcbldT++YheV4p9lyZmxtxvWZ4HgHQ7okaSD4XSdJSzPx2Hrs4fuTta9+8b5w2md912Vh/enPi+vtoXSuXi4HLVeXxddBX386u847mXPFMgdljfBKGgAAQIFo0gAAAApEkwYAAFAgmjQAAIAC0aQBAAAUiCYNAACgQDRpAAAABVpXOWnWF6/u0LZ0RkqztS2cdm4uzkDpb8W5M51Ouj7anA6nXT5xMqzv2JnOdpGk8WPpPJ56pg/ffcGmsP7N46fC+qbRYL95nGkzHccrqX8wzq0ZmE/nGHlfvN1TM3GGkTyutzrpHLaZ5XjZJ28/GtZn5mfD+vO/99pkzTbHx9Ma8TVUS0cYSZLa0+l9vjgf77O+Zpxdt+HV4jFkIMpwyuSgNWrxcW3X4oy2Wi19rbYX4/U+cOc9YX32ZDz+bR1Jr1uf4nNq87b4Wps9FU+/fTS9z+eXMnmHmTFGC/HvlLaC68Hiec8txOs2uRjX68H41lD8++bzn300rD/00Imw/qIfuyFZG97UH05rffF2eWMsrLfb6X3eamXGp/gSXDO8kgYAAFAgmjQAAIAC0aQBAAAUiCYNAACgQDRpAAAABaJJAwAAKBBNGgAAQIHWVU5azu6d6SCTxRPHwmkbu0fD+qPzl8XTn3owWZuZmgunXezEWT4XPj3Oftl1aZBjVIun3dJ/SVh/5nekc7Ek6f7Z9HYvzOwIp50cn4nrM/F+u8QWk7WjJ+K/P5aa8XZlYoakWnr+lsk48kwG26MPxQFyRx/9RrK2KY6W0yt/5nvC+mwn3i+2Ix2kNqZ4p7X7N9Rw84Q16nEInQX7zzI5aPVanC+lTlzv03Kydv9XHginnT4W5/rt3jUS1i+8YChZ27EjnnZ4OM5/W1xIjxGSdGoqfa1Nz8Y5ZxPj8XX62JE4WKvdHE7WWhZndrVq8XXqjXggmFtM75daZgzoz4Qp7n8oLGv+g3ckaz/5muvDaW1zvOy24nVvhDmR8fjV15cZXNcIr6QBAAAUiCYNAACgQDRpAAAABaJJAwAAKBBNGgAAQIFo0gAAAAq0ru6Jz9xtrYeOp2/lvmprfLv0YvoOdEnSxX1xhMfX70/HSVx7WdwLD26rh/Xdu+Lb50f70odx16Y47kGKb1Gfbm8J65cPPDtZmzx2TzjtxNH4lueHH4nXre/C9LZ96s543qMj8X558NgqLo34LvDcnd5amI+fsNhK39p/vB3f9v/QwsmwvuOi3WF963J63Toj6UgBSWo3cufixtYXxLZIkvUF40AtHiPaHkcIdZbj8e/wP6VzE2aOj4fTvuD5u8L6FVdcENa3bN2crI0MxtdC3eKLrdmMYzTm59LxRTMzcUTQ1Kn5sP7gI/G1Nvxwet0PjWeOdzuuL3fiCI+6paMs3OJ9vpy9jOMx6NDh9HZ//M++HE778te9IKzXRuKYjLqlf5fW6pn4IcX7dK3wShoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAVaVzlpmwbjoLThRjqfpVaP83L66qfC+j13Z/J4FtKZOnMTcQjbM54d5wxt2p7Of5OkQU/nibVqcbbLkuJ8JVOcOzO4NJWsXbhlTzjtwlicPXfJ2FhYP3pgLll73jPiMJ877w7L59XyfHy+NIMYIqvFGUeTk/H5sGd3fJ53PP13XTPIb5OkpVp8jW10jWB8kqROkOGkWjwGWGbfNw+dCOt335bONLzxuTvCaa+5entYv3D3hWG9FmTA5bIx1YnHdXk6D0yShobS9cGh+DWMgYF4bGx3MtdSazaoxrl27WYmrCyzbF9K77eZVtwW5HLUckGQ7U563fc/nB7TJekbdxwK68994TVh3ZXOxZPik807ue1eG7ySBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgdZVTlpnNs7EWRpKZwXNDG0Jp20ei/NXvvn5+8L6zqu2hvVIf1+ceVOfiXOzWmPpvJ52JufMFOcr9XWmw3onyOXyTF7OtsU4X+nRwwfCujrpdb9wTzp7SZKuXI7/PunfHq/7ffemj1lfsF6StLwYH0/VMjlFQc5Q30C8XZ/7cHweP/Pai8L68lJ6/oth7pPUGoiPyUZX9/i41urpzMKWZzKc5k6G9a//QxwM6Mvpdbtwe5yl2DcQr1sjOF8lqa+RzvRqLcdjfi2T2WXZerrWaMTHq68/vtaG++Ppt46kpz+1Kb5WZufjMWahGa9bM8hCqzfiZU8t5TLa4nI9+L3Q9njZX/zsA2H96c+LszmHxtK5eK3F+Bqq98VZhWuFV9IAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACjQuspJ6xuJV3ex00oXj8R5O4cejeurUY+jetSai3OIOpvj7W7V09kvQ504+2W1rJbu86M8L0lqZfLCLr40zp4zS9cPHYzz3S65JP775NjJU2H9WdemawsLcYbRA/eGZUmZHKI19I+ffTCsX3vlZcna9m1xTtrMwroabs45y8TEDTbS18PiwkI47ZH77wnrs5Px9TAwlD7n+vszA5jH19LyUnydt9vpZbfb8bVUz2QKRuOTJLVa6VCvhbng94mk2ZmlsN7pxPttdLQ/WbtwZxw21rF4jDCL99s3F9Pn08mFzPFe5fjkweStdvx7eG4m/btOku6+89Gwvv1pO5O1HSPxeVprxOfDWuGVNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgdbVPfF9g3FPOTCTrs/OzIfTfvkLD4X1zWFVim5aDu4wlyR55t789kR8S3Tf2GK8gIBFsSWSLJcfEmz55MRMOOWjB+KYi9yd3kuevl27P3NqD9bifb51S/r2eEm69570smu1vnBaabW3cqf3eTsTe5JJgdD0bByjcc/+w8naJVfFUTItm8ssfWMbGcuNIunzYu6hOFrg0buOhPW56fi82H3VWLI2MhSPu96Jz6rl5XjZ/cFrBf398bXUameupSjvQZKFr1PE2903MBjWB+vxGKL+9PQDQ/GYPjgS1+sWx4McPJ6O4Oifj49nLRO5suRxlIU3gt8prThiwzORKvfeF0dOPWdn+nzyeOhTf1/mCWuEV9IAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACjQuspJ62Qyb7zZTtYeeDDO7Fqtsf70/MeW4t3cWk5n1kjS0nLcSzfm0tkvnaE4Z6hRS+8zSXr4gTh3JjI1lc4SWwnLRLTNHUvnDM2345yg49PxzAfbcV6PlN62o4/Fx7NZW91lVx9Yu7+tOu2hs572of1TYf3Sq+NcqY1ubDC+Fmfn0jlM0xNxxtzx8TgvrOnxOWe19PUwMBDnfZnF5+PiYi7HMRi/gixESWo04u1aXIzHgcmT6fzMubk4W7PWn8m3DKtSu53eb4vNeN4LcRSZljLxcfV6etm14FyQpGYmi7GZS2MMzpehvsw+zeTiLUzE59riTCdZm1qKj/e2rcNhfa3wShoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAVaVzlpbc+EvwRmvvFQWG9NxNlWM5n8lkfvS6/bFc8aDaeN8nIk6dBjk2F98ESQWzMaH+LG4Ory404eSWfqeJB/JEkz0/HxtExQWlTtxPFIms/kJ4Uzl7R1OJ0d1RxJZ/FI0vGFXILS2mkvx8t+5OuPhfVrb7gkPe9M/tuh+3N5WRvb3Fw8xhw/mc4EO3Qsvk4bA/H41GhlssyW0if8wwfj4zZw8FBY93Ym66wvfb1cc90F8bzr8bV2333TYf3++8aTta2b4szAHdtGwvrkdDr3TpLGT6avxYVM0Jl7fLzd4ukHg7G10YnHiP56PK67x4NnW+nfV5lhV/VavN3NzLA+OZkOmKsNxNs1ORefa2uFV9IAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACjQuspJC9LAJEkPPnz2mV/DmfyVXEJbfzu9duPH58Nph7bEOWg1i7d8KMi8OTGZCY5ROu9LkgYbcWaOa+2yY2YW0pk2OfNL8fHcPhSf+tPLcabVwnR0TOO/fbaNxPv8yFS83Y2BsByqZdat3YyP50InOBc7cR7Wcj3epxvdiczmz8ylz9lTJ+MxwJtxfSCTQOWd9LIPPBhnjV2xe1NYf+ibx8P69h1jydrOC+bCaTdtT08rSQcPxFllm4bSWWdXPy3erge/eSKsHz4W58s1BgeTtf6+eHzatSvOaOt4fD5MnZpK1uon4jF/2OIxJBoiJGkxmH2/xeNPLjuz0473WyvI7LPmcDhtc5mcNAAAAFRo0gAAAApEkwYAAFAgmjQAAIAC0aQBAAAUiCYNAACgQOsqguOBR+I4icHJQ2u27E7m7tuF+fStvXu/57pw2sZQfFtxf1+88C1Bq33Zlr5w2px7H4jjQXYNn/1tyUOb41vURxfjrIkLtqRvYT8wvrrtvrQW30d+x93pPIVWbXW3am8fjbe73p8+4BNzZx9bIkmZpAZ1PD3/msXRIn2tVWSHbACPPBZHNowF8QO+GMebaD4+504txWPn8y5MR1l8996d4bSNwfhv/e07wrIGBtO/hrZsTV/jkmS1+Dof2xxH8ezckZ7/1m3x+fzs5+0K65fPx5kr3kmv+45NcRxEuxaHQt3/QBxH1fH09Jn0Di124oiOVmYMiX6ZdmrxudTIjK2eiQFqzgbj41C87Hp8OqwZXkkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBA6yon7e4v7Q/rOwbTmTgnluPwFrM4HKbWzoTHBHuyE+RaSdJIPc62soE460eZCKWIZ/r0zRfGp8jy7Gyy1q94n117VZwFdHw8zuNZDqKfcsezkfnz5I7bJuInBIaG45kvZDKt6v25oKH0tm0biXOjpubifKWcE/vnk7Xdz4intc66Gm7OuYfuHg/rWwbSuVrWiEOaphbjMaTZjK+HPqXPiwt2xNfh4Oj2sL77gnQGmyS12+m8xFZmvZc68Xbv2BVn823dkt6vF+3eEk472DcS1mXxODC/kM4ymzxxKpz2saNxxuTUdJzRNjWbPqaLnXiftzwen2oWX+eNYPDttOPxqZ7JUetkxv25mfQvy62b4uPZ3xdfB2uFV9IAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACjQugouWliIM1QeHk9nywx6nDXWUZz90lpI50NJUqsvncfTvxhnV3X64qCzIcX5LK3gMNZyWT2Lk2H91KkgjEySWXq/NjLRciem4+2uxdFQ4V8Y9cE4i2wp3izNLsfn2hW7NidrX3k4zsOan4vXrZXJArLMuRqprWJaSZo9kc52GhncGk47Wp9b1bLXu/mZePsXj6XHr8Z8PAYMZM53BdepJB06ml63pVPxOTM8HNe9NhjWm8EwMDAS55wtnIrzwAYacZ5YvZYem5cW4wHM2pmAykxm11KQlzg1Ga/3sePxAHb8RFyfmU/ny9UsPl6NzGs71ojPtboFGW2Z31ftTL1Wi6+T/lp63XbvjPP8Wpa5xtYIr6QBAAAUiCYNAACgQDRpAAAABaJJAwAAKBBNGgAAQIFo0gAAAApEkwYAAFCgdZWTNncine0iSQuWzrYaXozzU2pBbowkWSYj5dRCevrJ8XS2lCT1bY0Pg9XjZXc66Twez4SVjZ+aDevNTC5NazqdM7R1Z7zPlcnsysSsqT/IUfPMor9yx4mw3teIt9s9ve57r7wgnHbfQ8fD+kwc/RRabQ7aajz81Thzb8funU/SmpRpeiqdgyZJtdn0Sds3m8kUjGP9tNiKx5DHgtytiel45v2b4xO2P8gik6SFID9uYCDOSWs143VbXo732/RUur5981A4bbsVDzLL7XifT0+ns9DGJ+LtytWnpsOymsvxMYnUavEY0/F4uy2Y3KKipHY79zslNjWRzjt98P54XNbg+XlNi1fSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFWlcRHJ65tTdKH+i04luWM3f+yjJ5ENHt2PcfmYjnvTW+zXzs0pGwPjGdjtGYX0zfcixJs61MxMZc5lbt4Awan41Pr12bV3c79dHperI2OpIL8IjlbgVvNdKRK/ccjY/38Fg8bxuI67Vg3dpBHIskzWZuzV9NgEctykSB2p14/zSXgzicXKxBM/f3drzsycl0jMYDD56M5zwYjxGjo/E56UqPAwe++Wg47dfvmgrrB4/FsSc7dqXHqCuu3BVOu7QYxzbNzKdjTSTp2Hh63Y6fiKc9NR0ve3Epjh5RLX2+5EbOdjs37/hcawULqNXjpbdr6TFfktoW/06xdnr+s7PxPh06T+0Sr6QBAAAUiCYNAACgQDRpAAAABaJJAwAAKBBNGgAAQIFo0gAAAApEkwYAAFCgdZWTVhuNM1JsIZ3ytMnjfnTurNbo3DhxKs5wG+hQJIoAACAASURBVD11IqwvL6QP4/YLh8JpD92fzkeSpMZyXK8FwVrterzPpzury0mbn0nP/5ED8RGtW7zPD0yMh/VWM30u1uuZLJ92vN3zcbRTmOFmmaSzvnomo60xGtZrjTh3LzIxHmdabXR9mRi5+SAKbbmTyStUnKPWyAQ9tjx9zh5+LM6P2rYzzgXc2RwM67su2pKsNWrxtTLQF2e47d4dn88XXpiuf/OBY+G0NY/zwgYH4u1eWkwfs04mErSvL3c+xOO2B3mKmahFWZCxJin+pSCFp6q14w2vZ15X6mRy1DzYtv44rlT1wfOTA8kraQAAAAWiSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFGhd5aT1Z7J+ms10bs3MQpy3M9wf11uLYVke5E/dflect3NDJkCpoTgTZ/vgSLJ24Mtx6Fb/cJwr08lE3qzG5Fy87K3DZ5+jdnhiNqy3MrPOxMNpppneMe3MTmvnFp6xmr+sMhFI8la83zpK50otTM+E01553fbM0jc2q8UZUMMj6eG43Y6zygYG4yNbX47PyXlPj0GPHImz8b7rOfFxbQaZgpL0yIF01tlIf7zel16UHvsk6cjxOC/x6KHpZG10U3ylXXrZ5rBey+REuqXrzeX4eM8vxWPIwnJ8rrU9PX3d4rYgN3rVM7+na0EWWisXsZYZOxuNOJvOgpC2ZmbeQ/Xc6Lk2eCUNAACgQDRpAAAABaJJAwAAKBBNGgAAQIFo0gAAAApEkwYAAFAgmjQAAIACrauctK274gyUU5PpurXjDCcfjLN8lhqtsB4lUA1n0qnGJ+M5b9ocH6bB5VXkbmVyaWqZaJgoC2h0IM5/yzl0Ks442nf7+FnPuxXknEnSBRcNhfXph9PBeZ12vNMajTj3blMc/aS5+XTWj2eOl+WS0jLnw0B/+njPZ/KwnupGxwbC+sLcUrJW74vHgM5iPAacWs6MX7X0gX/kWDzvL9x2Iqy/8HsuCOt7rtiUrC0vZLIxp+NlD4zFr0Ps3Jz+ndE/EE+7OBcfk2YrDls8MZ7OnzsxEe/zqdn4eC4043qnkx5DakF+mxTnu0lSJ8hBk6RacK41M+vdygSpNQYzOWrBL7QRj7drJBj71hKvpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgWjSAAAACrSuIjgskw9w2Z50BMCJ2TgeoK341t92JuVieCgdNzG7HK/35FJc/9ytE2H9ip3p28i/7/rt4bT1/tWdAlEEx/hi+hZzSWot5+Ye75coRmMx8+dHqxPf2m8eL/vKPek4hUcei88ls3jZJ6fik61m6XXrZDI4MgkbqmX+bqsHt+5v6x/OzP2pbctoHOtSG0hfL61mM5x2cjo+brmxs15LH9d6LR47v/LNOGpicuahsP6j//KSZO2Zz9odTnvBRdvC+vT0bFg/ejQd8zM9G49fU5mIoJMn4/1ybDxdPzUTX8cL8emg5cV4+lYrfb64ryLSSVI7c641g7E1+HUiSeo04nlHY6MkeSe9bQ2Po0P6++PopLXCK2kAAAAFokkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABRoXeWktVpLYX2wls4x6SjOjWlk81Xi6T3Yle12PO3X74qzfHZsjdftWDtdv/9gnNUzNxBnIE0txfs8yqVpt+LtrseL1qGDcQ7RYrRb4sibrP6+zMqF4py0nEYmR60d5AyZZf7uymQBdTL1+XY6O2pkeSReduYa2+hamX1bH0hnLS6dyox9fXG2VV87XvZSkK9Xy5zPc534uO4/GudLffATR5K1H1mI1/vKp8Xn3PRUHCh24kR6244ci8efEyfjHLW5hXi/LQXj9nxmCDk1l8lRa8X7vBbk4nlm3G53MpmiisfOeiN9nitznuZG1o7F0y+00tfJzELcDjWWVjeuny1eSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEDrKidtx8U7w3r7+FSy1qhnMlDquQyUOAuoFUy+ML8cT9uMl728HGfeLAYRSn/9tfFw2mc+e0tYV5CfJEmdoM9vZKLGcqlZU/NnH3bWqK/u74/2Upw7Fe2Wqy8fDKe9675TYd0yOUMe7LlsElkuRy2jFmz4XD3OlXrsK/G5tNFtvWBzWJ/z9HU+fTjOUvTMdXoqPp21FGQ5tjNn1fxyPPN6X7xuj06lz8n3f+pEOO3OLSfD+nBm2VG12Ymvw2Y7vpaWmvH08830fm01c/s0XvbYpnjZi/PpXxq1TE7aQhzZl82oDGIetejxerc9/l3Z6WRyIGvphU/Fv6Y1sHR+XtPilTQAAIAC0aQBAAAUiCYNAACgQDRpAAAABaJJAwAAKBBNGgAAQIFo0gAAAAq0rnLSfC7OjmlYOt9lYCTOfpmdjutz8/Gyl5eD3Jl6PO/lTERbLgPpyGSUT5VJzurE87ZM3lgjKLfr8bLvvSfOC+vLBK3l9sv5MpcJpbpoy0BYPzqeOSE66XptlTloy5mMNjVGk6WhRpyTNtNeOJtV2jBay/H1UB/pT9YGNo2E056YWYwXXouH+gGlQ6KWM9lTwwPxObOcCc5ypc/nmaVMztlEvOzveMZwWJ+fbyZrS4uZrLFmJkPScvstveyBofh41TO/U/oamX2+KZ3Jd2omnvfRE3FQ2kI7vV2StLSUPt51i7e7FvyOl6SGZ3LSggw4r8Xjdnsx3q61witpAAAABaJJAwAAKBBNGgAAQIFo0gAAAApEkwYAAFAgmjQAAIACrasIDgtuUZek1mz6FtnF+E5szR+L641GvOyIZ2IupMxt5rnJozv7M9Pec/d0WH/md24N6+0ogyOz7EY9E7ERTy6z9Iafz3iOVju+lTun2Yyn92CXdzLbnQlkUb/Fy+7MTyVr8Y350tDoU/xvwnbmOg+iKEZ3paNPJOn40YmwPpSJw2k00rEwfZnz8VQQCSNJjXo67kGS6rX0uvXX4jGi3h/HIuzeHe+34aH0/Kem4nlPTsSRM0uLcRyEPP07xWrxtIND8T4dHop/X80vpONwakEciyTNz2TiPTrxudbx9D7PjV+5cb0/M8AtBYOnZ7Kw6plokbXyFB81AQAAykSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAo0PrKSZuN61O1dBhay2bCaWtR3peUDSszTwe0WJB/JEljQ3HuTCfIEZIkb6en98wRnvd42RfuiffL1uH0Pl+ejnNlrtwRZ7CtRi1zvDqZCKNaPd7uQ0cm08XMTr/3G/Nhfdv2eN2nj6cvhPbAUDjt4Fg6D0uSBvrjfKVjC2efAbds8XZvdO1WPA7MzpxK1lzxcRv0ODerY/E5tejRuuUCD+PxqV6Lp68F41u9PzNtX3ydLszHF/rTr9ySrG3fshhOO7MtXrfZmTjjrdMJMrsy49fAYDzv/v7MfllMj82D9fganz8V79NWZmxtBYNvJ5PkGGVjStKWzH6ZXEjv15ml+Po8dnA8rK8VXkkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBA6yon7eiDR8L6xHQ6C21hMZPvtJypx/EsarWWkrX+WrybBztxtsvycnrekjQ6ks62qgc1SXrWNXFW2c6+wbAeRYIND8fbtVrz8+kco04mT6eWyW665qp4u2t96VyqxWC9JOmRoXjZg7lYqj0jyVrrWJz1U2tkLvlMgNzWII5rMo7Fe8o78uChsO5K78Clhfjv6bnl+Lg32nGO2kIrvex65jJ2j8fO/np8LQ4FQ9SWzXE+3EW74v2yY2s8/kX5l1u3xWPA6HA87+bW5bC+HByzeib/rZ7L9cxk2zWX08dkIHO8pybj8W02F4c4ml7A5szYlylrbFO88rNL6XVv1OLjvTCXCYBbI7ySBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgdZVTtpMayGsR+kttUz4y3ImAqUWzj3WDrJ4JKk/cxS2bo4zji69OJ11Zpk8nSt2jYX1i4NMLknatDkIx8pklfV1Vvs3wqZVTp82Pj4d1i/fszNZOzo+FU579VXx8WwdmAvrneX0+dT/tDi7aWk2PtEfa8bHpNlKZ2INWpwztNgZDusb3fTJePyK8hBN8b5teXzcap04s2sgyDKrN+Lxa2goXrexkXj6Sy9NZ6FdeWk8/lz1tG1hfeuWzWG900qP61aL8ymXMmOrjWXO92B8bGR+X1ktHluby/Hx7rTS6z4wEI9P01PxfjkVD52amEmPQX31OHOv3h9v96LHdaul9+vYQGbsy0SprhVeSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFGhdRXBMTLTC+uDWdM8592gca+DN+LbjhsW3kTcG08s2xbdTX3xB3Cvv/b6hsL57RzoOojYa3x7/7N2jYX01Fjy+DXzIMnERmdvI19LW3ReG9fbMfLK2sxlHLRzZNBnPO0g1kaR6LX2+NBTfgt7J3Gaey6IZDG5hz6R7POVZPR4Hms30cLwwG887k5IhVzx2jvalz5u+wXhs3HNBnE3wXc/bHtYvvjwdA7RlUxxjMToSj40jmboHcTaWG59G4u3u1OJfr416ev71RiZioxlHQrXa8bm2OJ/e7uZ85vdsJgajvx4PBAOWHuA2j2WukWDsk6RmbuyMzvN2vN4dnZ8MDl5JAwAAKBBNGgAAQIFo0gAAAApEkwYAAFAgmjQAAIAC0aQBAAAUiCYNAACgQOsqJ62TCZCaOZbOd2kt5EKc4jyxgdpSWO+z9K68cvdAOO32y+Ptev4zrgnrM0qHKD1t29rloK21gf44p2g1OgNx/pKmT4Xl+lh6ep+JL6vpmXjRe4bjHKKHZ9MZRw3PZDdlLvnhgfhcnJ1N/123JR0dJ0maGo7ztja6vmY8hlg7fdw7nTg/ShaPb7VMvpQNpOd/0Uicm/X9N2wJ65dfl85xlKSRLemctOGReOzsD7LGJEkeB8gNDm9O1pqZ0K3+dibH0eJ9Xqul171Wy+Sk1eJjsrAU15csPU7UavEYsjwX79P+zPSjQaboYHy4NR/ku0nSQqa+uJhet+EgQ02SRvvOz2tavJIGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBzDM5MgAAAHjy8UoaAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgWjSAAAACkSTBjzFmNmlZjZrZvWznP4XzOxYNY/t1b9Xnuv1PBfM7IVmduh8r8f5ZmavMbO/Pd/rAeCJMXc/3+sAYJ0wsz5JpyTd6O5fP0P9PZIOuftvPdnrdiZm9kJJf+rul5zvdXmymNnlkh6W1OfurfO7NgBWg1fSADwRuyQNSrr7fK/IU9XZvgIKYP2hSQM2ADM7YGb/xszuMrM5M3u3me0ys782sxkz+zsz21o993IzczNrVD9/zsx+x8y+VD33b81sxxmW8XRJ91c/TpnZZ6rH3cyuMrObJb1G0huqt0A/0bNuv1at27SZfdjMBnvm+3Iz+5qZTZnZP5jZs3tqv25mh6v1ut/MfqB6/Hoz22dmp6q3Xn8vs39+08xOVOvymuqx51fT1nue92Nm9m2vEFa17Wb2iWqZd5jZW83s73vq15rZrWY2Ua3rq3pq7zGz/2pmf1Vty+1m9rQnMO07zexTZjYn6fvN7IfN7KvVuhw0szf3rOoXeo7RrJl9t5n97Gnr+j3VNkxX/35PT21F5wOAJ4G788UXX+v8S9IBSbep+0rXbknHJX1F0nPVfeXrM5LeVD33ckkuqVH9/DlJD0p6uqSh6ue3JZbzLdNWj7mkq6rv3yPprWdYty9LuljSNkn3Svr5qvbcal1vkFSXdFP1/AFJ10g6KOninmU/rfr+HyW9tvp+VN23X8+0vi+U1JL0e9U8v0/SnKRrqvo9kn6o5/kflfSriXl9qPoalnRdtW5/X9VGqp9/TlKj2q4Tkq7r2S8nJV1f1d8v6UNPYNppSS9Q9w/rwWq7nlX9/GxJxyS9MjhGP9uzrtskTUp6bbW8n6p+3v5Ezwe++OJrbb94JQ3YOP6Lux9z98OSvijpdnf/qrsvqtt8PDeY9k/c/ZvuviDpI5Kec47X7R3u/pi7T0j6RM/8b5b0R+5+u7u33f0WSUuSbpTUVrexus7M+tz9gLs/WE3XlHSVme1w91l3vy2z/P/X3Zfc/fOS/krS469U3SLpZyTJzLZJeomkD5w+cfVq24+r2+jOu/s91bSPe7mkA+7+J+7ecvevSvoLSf+q5zkfdfcve/dzYu/v2QcrmfZj7v4ld++4+6K7f87dv1H9fJekD6rbgK7ED0t6wN3fVy3vg5Luk/QjPc9Z6/MBwArQpAEbx7Ge7xfO8PNoMO3Rnu/nM889G6n5XybpV6u3OqfMbErSHnVfPdsv6VckvVnScTP7kJldXE33enVf6bmvervu5cGyJ919rufnR9R9VU+S/lTSj5jZiLqN2xfd/cgZ5rFT3VedDvY81vv9ZZJuOG07XiPpwhXug9y0vcuSmd1gZp81s3Ezm5b085JW+pbkxerug16PqPsKbG5dATyJaNIAnEtP9Hbxg5J+19239HwNV6/uyN0/4O7fq24j45LeXj3+gLv/lKQLqsf+vGq0zmTrabVLJT1Wzeewum+d/pi6b/+9LzGPcXXfNu29S3TPadvx+dO2Y9Tdf2GF+yA37en79QOSPi5pj7tvlvTfJFniuad7TN392etSSYdXsK4AnkQ0aQDOpWOSnkhm2h9L+vnqlSEzs5HqQ/FjZnaNmb3IzAYkLar7amBHkszsZ8xsp7t3JE1V8+oEy/ltM+s3s3+h7tuLf9ZTe6+kN6j7Ga+/PNPE7t6uam82s2Ezu1bS63qe8klJTzez15pZX/X1fDN7xgr2wdlMOyZpwt0Xzex6ST/dUxtXd1+kjsOnquX9tJk1zOwn1f2M3SdXsK4AnkQ0aQDOpXer+xmyKTP7n7knu/s+Sf9a0h+o++H1/ep+yF3qfh7tbep+iP6ouq+avbGqvVTS3WY2K+k/S3p19fmpMzlazfsxdT8L9vPufl9P/aPqvrL0UXefD1b3lyRtrub3PnU/B7ZUbceMpBdLenW1nKPqvsI3sIJ9cDbT/p+S3mJmM5L+nbqfG3t8fvOSflfSl6rjcONpyzupbqP6q+rezPAGSS939xO5dQXw5CLMFsBTnpk9KOn/cPe/ewLTvF3She5+09qtGYCnMl5JA/CUZmY/ru7nuD6Ted61Zvbs6m3Z69W9eeGjT8Y6AnhqapzvFQCA88XMPqfu57FeW32+LTKm7lucF6v72bv/KOlja7qCAJ7SeLsTAACgQLzdCQAAUKCi3+7csWOHX3755ed7NQAAALLuvPPOE+6+81zNr+gm7fLLL9e+ffvO92oAAABkmdnp/5vHqvB2JwAAQIFo0gAAAApEkwYAAFAgmjQAAIAC0aQBAAAUiCYNAACgQCtq0szsgJl9w8y+Zmb7qse2mdmtZvZA9e/W6nEzs3eY2X4zu8vMntczn5uq5z9gZvynxAAAAAlP5JW073f357j73urn35D0aXe/WtKnq58l6YckXV193SzpnVK3qZP0Jkk3SLpe0pseb+wAAADwrVbzducrJN1SfX+LpFf2PP5e77pN0hYzu0jSSyTd6u4T7j4p6VZJL13F8gEAADaslTZpLulvzexOM7u5emyXux+pvj8qaVf1/W5JB3umPVQ9lnr8W5jZzWa2z8z2jY+Pr3D1AAAANpaV/rdQ3+vuh83sAkm3mtl9vUV3dzPzc7FC7v4uSe+SpL17956TeQIAAKw3K3olzd0PV/8el/RRdT9Tdqx6G1PVv8erpx+WtKdn8kuqx1KPAwAA4DTZJs3MRsxs7PHvJb1Y0j9J+rikx+/QvEnSx6rvPy7pddVdnjdKmq7eFv0bSS82s63VDQMvrh4DAADAaVbyducuSR81s8ef/wF3/19mdoekj5jZ6yU9IulV1fM/JellkvZLmpf0c5Lk7hNm9juS7qie9xZ3nzhnWwIAALCBmHu5H/vau3ev79u373yvBgAAQJaZ3dkTVbZq/I8DAAAABaJJAwAAKBBNGgAAQIFo0gAAAApEkwYAAFAgmjQAAIAC0aQBAAAUiCYNAACgQDRpAAAABaJJAwAAKBBNGgAAQIFo0gAAAApEkwYAAFAgmjQAAIAC0aQBAAAUiCYNAACgQDRpAAAABaJJAwAAKBBNGgAAQIFo0gAAAApEkwYAAFAgmjQAAIAC0aQBAAAUiCYNAACgQDRpAAAABaJJAwAAKBBNGgAAQIFo0gAAAApEkwYAAFAgmjQAAIAC0aQBAAAUiCYNAACgQDRpAAAABaJJAwAAKBBNGgAAQIFo0gAAAApEkwYAAFCgFTdpZlY3s6+a2Sern68ws9vNbL+ZfdjM+qvHB6qf91f1y3vm8cbq8fvN7CXnemMAAAA2iifyStovS7q35+e3S/p9d79K0qSk11ePv17SZPX471fPk5ldJ+nVkp4p6aWS/tDM6qtbfQAAgI1pRU2amV0i6Ycl/ffqZ5P0Ikl/Xj3lFkmvrL5/RfWzqvoPVM9/haQPufuSuz8sab+k68/FRgAAAGw0K30l7T9JeoOkTvXzdklT7t6qfj4kaXf1/W5JByWpqk9Xz//nx88wzT8zs5vNbJ+Z7RsfH38CmwIAALBxZJs0M3u5pOPufueTsD5y93e5+15337tz584nY5EAAADFaazgOS+Q9KNm9jJJg5I2SfrPkraYWaN6tewSSYer5x+WtEfSITNrSNos6WTP44/rnQYAAAA9sq+kufsb3f0Sd79c3Q/+f8bdXyPps5J+onraTZI+Vn3/8epnVfXPuLtXj7+6uvvzCklXS/ryOdsSAACADWQlr6Sl/LqkD5nZWyV9VdK7q8ffLel9ZrZf0oS6jZ3c/W4z+4ikeyS1JP2iu7dXsXwAAIANy7ovcpVp7969vm/fvvO9GgAAAFlmdqe77z1X8+N/HAAAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFCjbpJnZoJl92cy+bmZ3m9lvV49fYWa3m9l+M/uwmfVXjw9UP++v6pf3zOuN1eP3m9lL1mqjAAAA1ruVvJK2JOlF7v6dkp4j6aVmdqOkt0v6fXe/StKkpNdXz3+9pMnq8d+vniczu07SqyU9U9JLJf2hmdXP5cYAAABsFNkmzbtmqx/7qi+X9CJJf149foukV1bfv6L6WVX9B8zMqsc/5O5L7v6wpP2Srj8nWwEAALDBrOgzaWZWN7OvSTou6VZJD0qacvdW9ZRDknZX3++WdFCSqvq0pO29j59hmt5l3Wxm+8xs3/j4+BPfIgAAgA1gRU2au7fd/TmSLlH31a9r12qF3P1d7r7X3ffu3LlzrRYDAABQtCd0d6e7T0n6rKTvlrTFzBpV6RJJh6vvD0vaI0lVfbOkk72Pn2EaAAAA9FjJ3Z07zWxL9f2QpH8p6V51m7WfqJ52k6SPVd9/vPpZVf0z7u7V46+u7v68QtLVkr58rjYEAABgI2nkn6KLJN1S3YlZk/QRd/+kmd0j6UNm9lZJX5X07ur575b0PjPbL2lC3Ts65e53m9lHJN0jqSXpF929fW43BwAAYGOw7otcZdq7d6/v27fvfK8GAABAlpnd6e57z9X8+B8HAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAABAgWjSAAAACkSTBgAAUCCaNAAAgALRpAEAABSIJg0AAKBA2SbNzPaY2WfN7B4zu9vMfrl6fJuZ3WpmD1T/bq0eNzN7h5ntN7O7zOx5PfO6qXr+A2Z209ptFgAAwPq2klfSWpJ+1d2vk3SjpF80s+sk/YakT7v71ZI+Xf0sST8k6erq62ZJ75S6TZ2kN0m6QdL1kt70eGMHAACAb5Vt0tz9iLt/pfp+RtK9knZLeoWkW6qn3SLpldX3r5D0Xu+6TdIWM7tI0ksk3eruE+4+KelWSS89p1sDAACwQTyhz6SZ2eWSnivpdkm73P1IVToqaVf1/W5JB3smO1Q9lnr89GXcbGb7zGzf+Pj4E1k9AACADWPFTZqZjUr6C0m/4u6nemvu7pL8XKyQu7/L3fe6+96dO3eelu3ReAAACsBJREFUi1kCAACsOytq0sysT90G7f3u/pfVw8eqtzFV/Xu8evywpD09k19SPZZ6HAAAAKdZyd2dJundku5199/rKX1c0uN3aN4k6WM9j7+uusvzRknT1duifyPpxWa2tbph4MXVYwAAADhNYwXPeYGk10r6hpl9rXrsNyW9TdJHzOz1kh6R9Kqq9ilJL5O0X9K8pJ+TJHefMLPfkXRH9by3uPvEOdkKAACADca6Hycr0969e33fvn3nezUAAACyzOxOd997rubH/zgAAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAACgQTRoAAECBaNIAAAAKRJMGAABQIJo0AACAAtGkAQAAFIgmDQAAoEA0aQAAAAWiSQMAAChQtkkzs/9hZsfN7J96HttmZrea2QPVv1urx83M3mFm+83sLjN7Xs80N1XPf8DMblqbzQEAANgYVvJK2nskvfS0x35D0qfd/WpJn65+lqQfknR19XWzpHdK3aZO0psk3SDpeklveryxAwAAwLfLNmnu/gVJE6c9/ApJt1Tf3yLplT2Pv9e7bpO0xcwukvQSSbe6+4S7T0q6Vd/e+AEAAKBytp9J2+XuR6rvj0raVX2/W9LBnucdqh5LPf5tzOxmM9tnZvvGx8fPcvUAAADWt1XfOODuLsnPwbo8Pr93ufted9+7c+fOczVbAACAdeVsm7Rj1duYqv49Xj1+WNKenuddUj2WehwAAABncLZN2sclPX6H5k2SPtbz+OuquzxvlDRdvS36N5JebGZbqxsGXlw9BgAAgDNo5J5gZh+U9EJJO8zskLp3ab5N0kfM7PWSHpH0qurpn5L0Mkn7Jc1L+jlJcvcJM/sdSXdUz3uLu59+MwIAAAAq1v1IWZn27t3r+/btO9+rAQAAkGVmd7r73nM1P/7HAQAAgALRpAEAABSIJg0AAKBANGkAAAAFokkDAAAoEE0aAAD/X3v3HypZWcdx/P3x6mb5AzddN1FrtbZ0CQtZF4kgLDT1j1ZLUIkUK4KiokDQfypKhKB/JMrAQkiIJCpF/EFIBVamudG6Ia22SeBa4KaZLWn++vbHeTaHxbvdmd17zpnu+wXDPfPMM+c+537uc+Y7Z+ZwpBGySJMkSRohizRJkqQRskiTJEkaIYs0SZKkEbJIkyRJGiGLNEmSpBGySJMkSRohizRJkqQRskiTJEkaIYs0SZKkEbJIkyRJGiGLNEmSpBGySJMkSRohizRJkqQRskiTJEkaIYs0SZKkEbJIkyRJGiGLNEmSpBGySJMkSRohizRJkqQRskiTJEkaIYs0SZKkEbJIkyRJGiGLNEmSpBGySJMkSRqhg4cewL48+/xLbNv59JL7hyzjaJZH5m/IkgbgvmLlmMfXsnm01Dm1cFB469ojlncwixh1kbZj124+8I1fDT0MSZK0Qh192Cp++4WzB/ndoy7S1h39Oq6/fOOS+lYt82CWwRwOWXOs5nGSCHBfsT+q5usopNO0L0v/Q686eLhvho26SDvi0EN436lrhx6GJElS7zxxQJIkaYQs0iRJkkao9yItyblJHk6yI8nVff9+SZKkedBrkZZkAfgmcB6wAbg0yYY+xyBJkjQP+j6StgnYUVWPVtXzwM3A5p7HIEmSNHp9F2nHA49N3N/Z2v4rySeSbEmyZdeuXb0OTpIkaSxGd+JAVd1QVRurauOaNWuGHo4kSdIg+i7SHgdOnLh/QmuTJEnShL6LtAeA9UlOSrIKuAS4recxSJIkjV76vlRMkvOB64AF4MaqunYfff8JPNzX2HTAHQP8behBaGbmN7/Mbr6Z3/x6W1UdsKux916kTSPJlqpa2sU7NTrmN9/Mb36Z3Xwzv/l1oLMb3YkDkiRJskiTJEkapbEXaTcMPQDtF/Obb+Y3v8xuvpnf/Dqg2Y36O2mSJEkr1diPpEmSJK1IFmmSJEkj1GuRluTQJL9J8mCSh5J8ubUnybVJHknyhySfbe2rk9ySZFt73tsn1nVukoeT7EhydZ/bsVLtI79fJNnabn9JcmtrT5Kvt4y2JTl9Yl2XJ/lju10+1DatJDPkd0qSXyf5d5Ir91qX869HM2T34Tbnfp/k3iTvmFiX2fVshvw2t/y2tmtZv3tiXe47ezRtdhPPOyPJi0kummibPruq6u0GBDi8LR8C3A+cCVwB3AQc1B47tv38GvCltnwK8NO2vAD8CTgZWAU8CGzoc1tW4m2x/Pbq8yPgsrZ8PnBXe96ZwP2t/fXAo+3n6ra8eujt+3+/zZDfscAZwLXAlRN9nH/jz+5de+YUcN7E3DO7+cjvcF75zvhpwPa27L5z5Nm1+wvAz4A7gYv2J7tej6RVZ3e7e0i7FfBJ4CtV9XLr90Trs4FuQ6mq7cC6JGuBTcCOqnq0qp4HbgY297clK9M+8gMgyZHAe4E97yg2Aze1590HHJXkOOD9wN1V9VRV/R24Gzi3r+1YqabNr6qeqKoHgBf2WpXzr2czZHdvm1sA99FdJxnMbhAz5Le72is7cNhEX/edPZvhdQ/gM3SF2xMTbTNl1/t30pIsJNlKN/i7q+p+4M3Axe2w7l1J1rfuDwIfbM/bBLyJbmdzPPDYxGp3tjYts0Xy2+MCuqOdz7T7i+VkfgOZMr/FmN8A9iO7j9Ed0QazG8y0+SW5MMl24A7go63Z/AYwTXZJjgcuBL6112pmyq73Iq2qXqqqd9IVW5va98xeAzxX3aUUvg3c2Lp/le7oy1a6yvR3wEt9j1mvWCS/PS4Fvj/MyLQU5je/ZskuyVl0RdpV/YxSi5k2v6q6papOoSsCrulvpNrblNldB1y155PB/TXY2Z1V9TTwc7rDfTuBH7eHbqH7DJ6qeqaqrmh/nMuANXSf4z4OnDixuhNam3qyV34kOYbuo5Q7JrotlpP5DWyJ+S3G/Aa01OySnAZ8B9hcVU+2ZrMb2LRzr6ruAU5u/cxvQEvMbiNwc5I/AxcB1ye5gBmz6/vszjVJjmrLrwXOBrbTfZZ7Vuv2HuCR1ueoJKta+8eBe9ohxQeA9UlOao9fAtzW35asTPvID7p/xtur6rmJp9wGXJbOmcA/quqvwE+Ac9KdvbsaOKe1aRnNkN9inH89mza7JG+ke+P7kap6ZGJVZjeAGfJ7S5K05dPpPm16EvedvZs2u6o6qarWVdU64IfAp6rqVmbM7uADujX/23HAd5Ms0BWIP6iq25P8Evheks8Du+kKMoBTW/8CHqI7bE9VvZjk03QbuADcWFUP9bwtK9Gr5tceu4Tu4+lJd9Kd4bkD+BfdWbxU1VNJrqF7wYDupJGnlnvwmi6/JG8AtgBHAi8n+RzdmYDPOP96N+3c+yJwNN27eIAXq2qj+87BTJvfh+je4L4APAtc3E4kcN/Zv2mze1Wzvu55WShJkqQR8ooDkiRJI2SRJkmSNEIWaZIkSSNkkSZJkjRCFmmSJEkjZJEmSZI0QhZpkiRJI/Qfn1K1Mh50aJ0AAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 720x720 with 3 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Gen (3400) : best fitness = 168.79848581918387\n",
            "............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................"
          ]
        }
      ]
    }
  ]
}