preprocessing.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "preprocessing.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "SQC4MsXKYge_",
        "4JPFh0eA3vkn",
        "uu5KOq6cYSp5"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "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/zhaoyingpan/592final_project_2021fall/blob/main/preprocessing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2X4Ep6kgbK8i"
      },
      "source": [
        "import dlib\n",
        "import cv2\n",
        "import os\n",
        "import numpy as np\n",
        "import torchvision.transforms as transforms\n",
        "import PIL\n",
        "import scipy.ndimage"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tAo5z9KxabBk",
        "outputId": "29f5c155-2d30-493c-8517-4ce937728dad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Image Alignment"
      ],
      "metadata": {
        "id": "SQC4MsXKYge_"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dfDk_C_SlYTk"
      },
      "source": [
        "def download_landmark_model():\n",
        "    # save_path = os.path.join(\"/content\", \"pretrained_models\")\n",
        "    # if not os.path.exists(save_path):\n",
        "    #     os.mkdir(save_path)\n",
        "\n",
        "    landmark_model_path = \"/content/shape_predictor_68_face_landmarks.dat\"\n",
        "    if not os.path.exists(landmark_model_path):\n",
        "        # os.mkdir(model_path)\n",
        "    \n",
        "        os.chdir('/content')\n",
        "        print('Downloading facial landmark detector model...')\n",
        "        os.system('wget http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2')\n",
        "        os.system('bzip2 -d shape_predictor_68_face_landmarks.dat.bz2')\n",
        "        print('Done.')\n",
        "\n",
        "    else:\n",
        "        print('Facial landmark model already exists!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "download_landmark_model()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dKPaIIU51cWQ",
        "outputId": "17fbe67d-f89e-452d-b46d-6cb7c2be2cfc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading facial landmark detector model...\n",
            "Done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OS_ZR_MryR0a"
      },
      "source": [
        "def draw_face_point(img, single_facial_landmark, is_point=True):\n",
        "    assert(single_facial_landmark.num_parts == 68)\n",
        "    if is_point==False:\n",
        "        draw_on_img(img, single_facial_landmark, 0, 16, is_point, False)\n",
        "        draw_on_img(img, single_facial_landmark, 17, 21, is_point, False)\n",
        "        draw_on_img(img, single_facial_landmark, 22, 26, is_point, False)\n",
        "        draw_on_img(img, single_facial_landmark, 27, 30, is_point, False)\n",
        "        draw_on_img(img, single_facial_landmark, 30, 35, is_point, True)\n",
        "        draw_on_img(img, single_facial_landmark, 36, 41, is_point, True)\n",
        "        draw_on_img(img, single_facial_landmark, 42, 47, is_point, True)\n",
        "        draw_on_img(img, single_facial_landmark, 48, 59, is_point, True)\n",
        "        draw_on_img(img, single_facial_landmark, 60, 67, is_point, True)\n",
        "    else:\n",
        "        draw_on_img(img, single_facial_landmark, 0, 67, is_point, False)\n",
        "\n",
        "\n",
        "def draw_on_img(img, single_facial_landmark, start_point, end_point, is_point=True, is_closed=False):\n",
        "\n",
        "    if is_point==False:\n",
        "        all_points = []\n",
        "        for i in range(start_point, end_point+1):\n",
        "            single_point = [single_facial_landmark.part(i).x, single_facial_landmark.part(i).y]\n",
        "            all_points.append(single_point)\n",
        "        all_points = np.array(all_points)\n",
        "        cv2.polylines(img, [all_points], is_closed, color=(0,255,0), thickness=2)\n",
        "    else:\n",
        "        for i in range(start_point, end_point+1):\n",
        "            single_point = (single_facial_landmark.part(i).x, single_facial_landmark.part(i).y)\n",
        "            cv2.circle(img, single_point, radius=0, color=(0,255,0), thickness=2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "igx5p5x-i2Xb"
      },
      "source": [
        "def save_facial_landmarks(facial_landmarks, filename):\n",
        "    with open(filename,'w') as f:\n",
        "        for p in facial_landmarks.parts():\n",
        "            f.write(\"%s %s\\n\" %(int(p.x),int(p.y)))\n",
        "    f.close()\n",
        "def detect_facial_landmarks(model_path, img, count=1, zero_fill=1, if_img=False, if_txt=False, output_path=None):\n",
        "    face_detector = dlib.get_frontal_face_detector()\n",
        "    landmark_detector = dlib.shape_predictor(model_path)\n",
        "    # image_complete_path = image_path + '/' + image_name\n",
        "\n",
        "    # img = cv2.imread(image_complete_path)\n",
        "    # img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
        "\n",
        "\n",
        "    face = face_detector(img, 0)\n",
        "    # facial_landmarks = []\n",
        "    # for i in range(len(all_faces)):\n",
        "    face_box = dlib.rectangle(int(face[0].left()), int(face[0].top()), int(face[0].right()), int(face[0].bottom()))\n",
        "    facial_landmarks = landmark_detector(img, face_box)\n",
        "    # facial_landmarks.append(single_facial_landmark)\n",
        "\n",
        "    # facial_landmarks_txt_name = output_path + '/' + image_name[:-4] + '.txt'\n",
        "    if if_txt:\n",
        "      facial_landmarks_txt_name = output_path + '/' + str(count).zfill(zero_fill) + '.txt'\n",
        "      save_facial_landmarks(facial_landmarks, facial_landmarks_txt_name)\n",
        "\n",
        "    if if_img:\n",
        "      draw_face_point(img,facial_landmarks)\n",
        "      cv2.imwrite('/content/test.jpg',img)\n",
        "\n",
        "    ldm = []\n",
        "    for p in facial_landmarks.parts():\n",
        "      ldm.append(p.x)\n",
        "      ldm.append(p.y)\n",
        "    ldm = np.array(ldm).reshape(-1,2)\n",
        "    return ldm"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gP_799X_k159"
      },
      "source": [
        "# model_path = '/content/shape_predictor_68_face_landmarks.dat'\n",
        "# img = cv2.imread('/content/original1.jpg')\n",
        "# detect_facial_landmarks(model_path, img, count=1, zero_fill=1, if_img=True, if_txt=False, output_path='/content/pic1.jpg')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K3IQh-pirJlw"
      },
      "source": [
        "import dlib\n",
        "from PIL import Image\n",
        "import scipy\n",
        "def get_landmark(img, predictor):\n",
        "    \"\"\"get landmark with dlib\n",
        "\t:return: np.array shape=(68, 2)\n",
        "\t\"\"\"\n",
        "    detector = dlib.get_frontal_face_detector()\n",
        "\n",
        "    # img = dlib.load_rgb_image(filepath)\n",
        "    dets = detector(img, 1)\n",
        "\n",
        "    shape = None\n",
        "    for k, d in enumerate(dets):\n",
        "        shape = predictor(img, d)\n",
        "\n",
        "    if not shape:\n",
        "        raise Exception(\"Could not find face in image! Please try another image!\")\n",
        "\n",
        "    t = list(shape.parts())\n",
        "    a = []\n",
        "    for tt in t:\n",
        "        a.append([tt.x, tt.y])\n",
        "    lm = np.array(a)\n",
        "    return lm\n",
        "def align_face(img, predictor, output_size=256, transform_size=256):\n",
        "    \"\"\"\n",
        "\t:param filepath: str\n",
        "\t:return: PIL Image\n",
        "\t\"\"\"\n",
        "\n",
        "    lm = get_landmark(img, predictor)\n",
        "\n",
        "    lm_chin = lm[0: 17]  # left-right\n",
        "    lm_eyebrow_left = lm[17: 22]  # left-right\n",
        "    lm_eyebrow_right = lm[22: 27]  # left-right\n",
        "    lm_nose = lm[27: 31]  # top-down\n",
        "    lm_nostrils = lm[31: 36]  # top-down\n",
        "    lm_eye_left = lm[36: 42]  # left-clockwise\n",
        "    lm_eye_right = lm[42: 48]  # left-clockwise\n",
        "    lm_mouth_outer = lm[48: 60]  # left-clockwise\n",
        "    lm_mouth_inner = lm[60: 68]  # left-clockwise\n",
        "\n",
        "    # Calculate auxiliary vectors.\n",
        "    eye_left = np.mean(lm_eye_left, axis=0)\n",
        "    eye_right = np.mean(lm_eye_right, axis=0)\n",
        "    eye_avg = (eye_left + eye_right) * 0.5\n",
        "    eye_to_eye = eye_right - eye_left\n",
        "    mouth_left = lm_mouth_outer[0]\n",
        "    mouth_right = lm_mouth_outer[6]\n",
        "    mouth_avg = (mouth_left + mouth_right) * 0.5\n",
        "    eye_to_mouth = mouth_avg - eye_avg\n",
        "\n",
        "    # Choose oriented crop rectangle.\n",
        "    x = eye_to_eye - np.flipud(eye_to_mouth) * [-1, 1]\n",
        "    x /= np.hypot(*x)\n",
        "    x *= max(np.hypot(*eye_to_eye) * 2.0, np.hypot(*eye_to_mouth) * 1.8)\n",
        "    y = np.flipud(x) * [-1, 1]\n",
        "    c = eye_avg + eye_to_mouth * 0.1\n",
        "    quad = np.stack([c - x - y, c - x + y, c + x + y, c + x - y])\n",
        "    qsize = np.hypot(*x) * 2\n",
        "\n",
        "    # read image\n",
        "    # img = PIL.Image.open(filepath)\n",
        "    img = Image.fromarray(np.uint8(img[:,:,::-1]))\n",
        "    # img = img[:,:,::-1]\n",
        "    # img = img[...,::-1]\n",
        "\n",
        "    enable_padding = True\n",
        "\n",
        "    # Shrink.\n",
        "    shrink = int(np.floor(qsize / output_size * 0.5))\n",
        "    if shrink > 1:\n",
        "        rsize = (int(np.rint(float(img.size[0]) / shrink)), int(np.rint(float(img.size[1]) / shrink)))\n",
        "        img = img.resize(rsize, PIL.Image.ANTIALIAS)\n",
        "        quad /= shrink\n",
        "        qsize /= shrink\n",
        "\n",
        "    # Crop.\n",
        "    border = max(int(np.rint(qsize * 0.1)), 3)\n",
        "    crop = (int(np.floor(min(quad[:, 0]))), int(np.floor(min(quad[:, 1]))), int(np.ceil(max(quad[:, 0]))),\n",
        "            int(np.ceil(max(quad[:, 1]))))\n",
        "    crop = (max(crop[0] - border, 0), max(crop[1] - border, 0), min(crop[2] + border, img.size[0]),\n",
        "            min(crop[3] + border, img.size[1]))\n",
        "    if crop[2] - crop[0] < img.size[0] or crop[3] - crop[1] < img.size[1]:\n",
        "        img = img.crop(crop)\n",
        "        quad -= crop[0:2]\n",
        "\n",
        "    # Pad.\n",
        "    pad = (int(np.floor(min(quad[:, 0]))), int(np.floor(min(quad[:, 1]))), int(np.ceil(max(quad[:, 0]))),\n",
        "           int(np.ceil(max(quad[:, 1]))))\n",
        "    pad = (max(-pad[0] + border, 0), max(-pad[1] + border, 0), max(pad[2] - img.size[0] + border, 0),\n",
        "           max(pad[3] - img.size[1] + border, 0))\n",
        "    if enable_padding and max(pad) > border - 4:\n",
        "        pad = np.maximum(pad, int(np.rint(qsize * 0.3)))\n",
        "        img = np.pad(np.float32(img), ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)), 'reflect')\n",
        "        h, w, _ = img.shape\n",
        "        y, x, _ = np.ogrid[:h, :w, :1]\n",
        "        mask = np.maximum(1.0 - np.minimum(np.float32(x) / pad[0], np.float32(w - 1 - x) / pad[2]),\n",
        "                          1.0 - np.minimum(np.float32(y) / pad[1], np.float32(h - 1 - y) / pad[3]))\n",
        "        blur = qsize * 0.02\n",
        "        img += (scipy.ndimage.gaussian_filter(img, [blur, blur, 0]) - img) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0)\n",
        "        img += (np.median(img, axis=(0, 1)) - img) * np.clip(mask, 0.0, 1.0)\n",
        "        img = PIL.Image.fromarray(np.uint8(np.clip(np.rint(img), 0, 255)), 'RGB')\n",
        "        quad += pad[:2]\n",
        "\n",
        "    # Transform.\n",
        "    img = img.transform((transform_size, transform_size), PIL.Image.QUAD, (quad + 0.5).flatten(), PIL.Image.BILINEAR)\n",
        "    if output_size < transform_size:\n",
        "        img = img.resize((output_size, output_size), PIL.Image.ANTIALIAS)\n",
        "\n",
        "    # Save aligned image.\n",
        "    return img\n",
        "\n",
        "\n",
        "def run_alignment(img):\n",
        "    import dlib\n",
        "    if not os.path.exists(\"shape_predictor_68_face_landmarks.dat\"):\n",
        "        print('Downloading files for aligning face image...')\n",
        "        os.system('wget http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2')\n",
        "        os.system('bzip2 -dk shape_predictor_68_face_landmarks.dat.bz2')\n",
        "        print('Done.')\n",
        "    predictor = dlib.shape_predictor(\"shape_predictor_68_face_landmarks.dat\")\n",
        "    aligned_image = align_face(img=img, predictor=predictor)\n",
        "    return aligned_image "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 273
        },
        "id": "wGnXJH7APJLn",
        "outputId": "f0e807f3-6d63-4296-f6cc-8c34fc7fe244"
      },
      "source": [
        "image = cv2.imread('original1.jpg')\n",
        "aligned_image = run_alignment(image)\n",
        "aligned_image"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAADc80lEQVR4nOz9Z7NkyZUYCB7hfkXEkykrS0A30ARJDGnEcGx29reu2a7ZmM23NRp3emfGhpy1tgGGTXQDDdEFVbqyKnXmUyHuve7n7Ifj7nFDvJcvE1WF6ibdnmVG3Lhxw8XREn/x0/8AlwxEvOyj/0KGql7xqYDaPYioqgRpu8q+2ddVVUQQ0W4DgBhjjJGZY4ynp6fOubZtnfMPHz04PDwMMT558uTmzZvdcvHWW2999NFH/+yf/eCjjz7e39+r65qIRKDvhqZpmSnGCAAhhLqu5/P5ZDIhosViEUIAgLZtiUhELi4uQghVVe3t7alqWRcR9X3PzDa98eTzCyofXTGQr/wUsWzOZTdc/fwvbzg7xc2p6JXz/S9gGFhf9lF6hWDAZPAtoICAiEMcQgiIWPvKObeYLxeLxXK5JCJmHoZhiEFE3rx3D6K++eabJycnzlVd133w/gf/5t/8mzh0py9Obhwd33vjzV/+6ldvvvnmyekZO3c+mzHzdLrP5Jg672tEZWYAWC6XDx8+mkzaFy9eENHBwYFzDhEXi0WMUVWdc03TqOpyuQwhEJG9VU1PKOsyLM3/0saS/yyQejUZsvHaE8O/++n/vuNZCvhfDAe4zv4CgAJoJvnlooioCiAYEY0xIiIRTSaT+Xx+fnoWQqir+vDwKMa4XC4BoBt629iTszNUNfJ/enr+6NGjg73pZDIVkfPzizt37szmF3v7e3Vdf/zxxzduHj98+PDGjRtd152eniOSCAx9d/Pmzel0enh4eHx8DKoq0WBXRBaLhfe+67qmaWxWqhpjJKKqqvq+jzF67wvEwwjticjeErmy2DE8bMDGSzkA5j28mhW89vgiEQAAEABhjSH+Ix3XBO5rPWoLAQxcEBEwXZ/P54jYdd1isbh9+7bJObOL2enpmffee8/MBwcHSMTe3f/ss/3p9ODw8Be/+GUIQSLUnj/55BMR+fa3v314eDjvlrdu3frwww/Oz8+89w8fPtzf32fm5bJ/6813bty4cXSwf3Z2+s477yyXy7/7u797++23//L7fzGbzRCxaZoYY9d1IQRVrarK6D0iiohzrqoqk39EpKoqABARAHDO2YuMA2MQWL0ZXU2oYpxEUba3bvyIfxwIAAqE/xUB1h+1CwFMwh5Cb5iwXC4Xi8XBwUGMcTabEdHZ2VnbtE3Tqupssbi4OD85PZ3u7+3v7w/DwOg++OCD2Wx2sH+0XC7ffOutvu8mk8nFbPbgwYM33nhjNptdXJwToXPu/OJ02k6Y/Ycffuhc3XW9hH4ybeumiSH8q3/9r7/zrW9/8tGHXdf9xfe+JyLDMFRV5Zyv67qqvHMuhDCbzaqq6rru8ePHk8nk7bffruv6+fPnbduKSNM0XdcBgK3LlnkF4U/ifX6FiP90EADzkv6kef25xyshgL5srZpHeYuIVVVFCefn52en50dHRwAwm82YeT6f7+1Pl8vl48dPnj55enFxMUi8cePG46dPJpPJ3v4+Ej15+OTBgwfT6d5y2Q3DsL9/ePfO3Vu3b/VdX9f1b/7h1zHGN+69MZ/Pn7945n01v7jo+76qajuXGKOIENEwDF3XvfPOO8y4v7f3jbffqZyvvJ8c7A1dX9c1E8UwtG3LzFVVtW3rnKvr+uzs7MWLF8YHnHNvvfWWadU2rgR9yEozr12hHRu+9hz9Uqjq6z1TVdcQAFcvrvW4rz96XAcBVgB9DQSALCrYayKKMfZDx8wxCgKKyP3PP/vggw+WXUeO+j5U3rdNi0SOqyGEetJeXCwePnq0XHah75umZua6btq2dejmi8Xz58+JqB+GO3du10310UcfESEihth7YiJyznVdZ6DcdV2M0eQcm0yMsfbVzePjqqp8XYvKt7/xjaapnXNhGKbTaVVXIURTV6ZtM5lMjo+PTXiLMS4Wi7qup9NpIn+EZbFmzCmvbU8MAVYWpK8WATSZcF7/iW79bXoQAnxhosM/9qGgoAgIqsYCwIybIoisqqEfhm4Qlhjj3/zsZ1T5g+Ojpcre0bESzh49fvrkIaMDwhBCjOqrahBZLnpF8EznF/Ojo+MoGgUePX3ova/a5uLiAhGfvXiuEolIJDrnHFeEEKOE0CNSjHp+fmFyObOPMYYoTISIUeTJ8xdN0zjviegXv/zVnTt3jo6Onjx9pCEeHR0dHByoqveebhybxszMbdsWdXk+nzvnJpOJgJodCQCYWS+negkxXnVrVwPX/tt6+JXkSa9JsrfHBgd4NQT4J8ABxiJNRIAxG1RQEVPvCpQUJqCqiHxxcbFYLPb29haL7pe//Pt22v7q3X8g73xdxSEMMYAoA4KgYjKqiGoXApPvw+CIiajrumEY7t69a4K7abEAEEJASD+qKgAgIZSZIyIQKGgMEqMQsaoigrEICcGkGtNNnXMSh3tv3Gtr//bbbzPzo0ePjo6ObhwdHh4ehhCWy+WtW7fOz8+dc8fHxyEEs9hWTV1VVV4vogIAEFGxGhEVEcg4w257kKnUkLXkywQq2/bdx3QlrL22avFfEWAk02+sJjtDjASWIzQHVgjhwaPH0+mU2f+H//Af5vN53/cxDuB4kNgNvXdOEWUQGQIjAXGMIUYRVUFk8kAIosVOH2N0zgGA9z6EYL4FFXHOxTgYCIJEs7emT0EFhJBEMIQIgObRMltn0dGJcH86HYZBVYd+IVG++c1vfuvb3zo8PGxr/9t/eLfrun/1r/915SpEXC7n3vubN2/WdW1WLBGp61pERMR7XxiCoUExsEKCh5VOPN7LlyLA6s5doPxfEeA1x2shQN4DFQQw8RoAFosFAJj5fH9//7PPPjs8Pv67v/u799//cDKZSjTdIA6gQaXreyISFY0CURx5IBSJqhBiFETHFTJBDKZRGGwRub7vje1UVYUA3TAws2q02xiT1mHwFEUUoNhhLht2s9k3GVBVFaRpmsPD/bpy9+7dOz44/PDDD2/duvXdb3/HZjIMg0lEbVub4cjQErLty+B+7DQovwa7zCdjBNh2Mu4EpKRXaD6mrxIBrvvlfxIIMLJ7jCkZqIrRATvpEMIwDE3TENFf//Vf//jHP/4f/6f/0WSTGBWAmFlFA2gvQQFUZIgBFFgBlQRUJIgAIgYR5ysFhSgxBiZGBXJk7gQAVLXQCbPzmPkdAUjWjYxXuKvHg5mLY4sNUFABwHvfLTrvGRG++51v37pz4/GDh2+88ab3fn9/HwBE5HB/7969e6enpzHG6XRa13UB7rHvbDSTNQ6wY3q0cT+M7991QkCIr4oAY+3iaghYU4IVFK4Uxf4JD1U1hRIR19FARcTCB5xzT58+ffzkaR/i/+P/+f8KEogZlSRG55wAgoKoghIh9kE0IhFGVZBBNQIAIqmKI0QZEACJHVcAICGCKDGqQoxGaFeOtsykVLdOcyNIoTC08hZG0Q0AEAylkUII7CtiHoKwo48+/XSIAxG/ePECEWMUInz77XdePHvy7Nmz73//+4hY1/UwDN77YgczEcu4QZmRsdAN0lPg22a4zjReMuQapjx5XavNJZ7grO685Mv/aDmA5jA1e2tMwGTxYuw3maHvewAwc/vZ6emvfvMPv3v/g2UfyHGMwbNnBQaMIgKqogLQhUFVTXZSVWYiEAATdQCyhEBEK0FaQVVMvB6DsqoCEBCpKAAprh00AgimB16xA9sCiYGgcxUiMBOogCqA3jg6rhw7577zne90XUdE3//ed5jp4cOHh4eH3/nOd+bzeYyxruuxRRggRYLkSW1K0CYorbnDikQEWmjtnwWcLnGEXU+o+nMhwHWs+zu+te3KjSlIcxgGOxKzmRi4m6ZbVN4//OEPv/rlL2eLpbDrQlQAVfGuYoVodvUYNUoECJq+bj9CRKjRKEoGGLDAOEMDImKkEELf94X/jGg5ixpZJcOi8YiwZpXfOcYUuuyARGjaFkAQ1Hs/DMEhiQgTENF0OnnnnXeI6NbR4TvvvNO27f3791X1X/2rHy0WC9MT7DnDMDDzOJ505wQ2EGB8c3Eef70QwNDypTv7er/6ehD8J45tBJCQrCVjbm42FrPJmIGy67qf/OQnn376KRENqsoO0AGCqoiohoiiIYQoggIRVGklRwEAIqDG9PuwUhwT6DMTkSO2HzKJa+xrQ2RF09CvjQCrcNU0SmCL0koUKTNhZu+9qUOeWESIsV8ufvzjH9fsmPnOnVtmje267rvf/bbN3J5jNGJnQPV4IPLG9Q270PYXN6S7L2m4l99y+fizwPFrjMtmabCuOVbMJBBmDiGEEJ4+fXrv3r2PPvroJz/5ickDxhmAOKhGEUY0EoiGCgCUhcdirFRVEXMwbM6iGBDrugbRYRjW5mzKJUCQiIgIlJVy3bHt69R3xeLKlQxtIiuEKQKMYV1VVVVVyRCIqO+7pml+8Ytf3L5580c/+tHFbO69v/fmGw8fPnzw4MHt27eHYSje4gL6l4HsTgi2X0/q/Wja5eYvCe43dm8U7LpB8r/u4v2OcZmhYAUQ65IrjMgtIpoxfrFYqKr3/t69ez/5yU9+85vf2LdMD0bECErEIcQu9KGPIGqijCNHAAygTIQYJaIqqGZeYB6iNSu4cR4iUpWidRhHMmTTDFeqAoqa2MilC7xiJBjNOjGsg5phcoyx8ZXNpOs67/3p+ew//ee//Rf/4odN09x/8GBvbxr6vuu6qqouLi729/eTjr6ueW8oHqp6BTAb4x2v5Wr8+WLJ7p/EAb4OY7wd19mYbeuEBZOVzBJXee/9x598/Mf33vvt736L6IYgio58FRGYWVXCMAz9MoSgMHiumCoQZHTglBCjSJQYQlARSjJVMjHB+gGPXxdJfUxTUQEkY68AoG5IcVdIHTCiqQmdVAVXDqyN2wzr+r43qz+IGQYkhPDuu797++039/b2COlg0jx58uTGjRve+7OzM4v/gwzHNopUuZMvbcxwI7wCEctBpq8gIKKCfBlE+R83Amzv6UvIgyAhRSmG/wQfZuN/8eLF4dEROPr8yaO//ftffPLJJ+hYBYIAOyZ2qrpYLEPsRUQ1ElHbHoGqBAECRAmiJj4lx60aM1jB6Bi4YSyK5Eh9LVE366qw3Z6U4Wvsw8an9nAAUELdElQKYySiKLHrOnaEhjAAALrsu/c//FBVv/3tb/+z73/vxu07z58/vXv7btcvnjx58uabb4YQzG2MiJoBWJLiYmi/HWSaPQaw5hbYDsNOLOUVDKevMDYRYJsBff3Htsh7xZ1jWCnMd7FYzGazmzdvsuOnz1/8x//4H58/f66qoALA3nvIVpq+7xUiM9V17ZwjcqEfVFQ1imgALJ7jAvGmPOSLa7Z5m0YIgQCLOl4wwVCIEFWSGKS4KQKNV7SBWkW6K9OwHy1pa+l+BCTSmGYoAKQg0ULfVKM4JABgYiT86JP7fT/8N//Nv3z7nW99+P573/3ut188e37//v1vfOMbJV4omqZUjmYLnHbCWLl4KfjhNeMTXm3s4ABfjfb9dRgGEIvFwkLkh2H4/PPP/+f/7X8pxnZV9c6p4BDicrm08DLva0Co60pVZ7MZmqtSBEQRgVEtQ9KiaGKMqjFRUgCRFR/QPGKMSFyCmSHbiMRy54k1RSUJomoKSFYmRsQQBkkuCEBEyzsz8WMYUgSRSXfR6DGusDFtAhOKFAyEjFQWcIGIZhCzWEARuX//foyRAN95550PP/z4+3/xvfffe+/k5GQymSBi13W+rsrDDYlxy/V7tVaw86TgEu73J441vqLrfwL62g62r2yscX9FUATZ/EMlezE+4EI7rXQCMy+Xy7/6q78yqmmeASPefd8vl8sYIyI7VxE5UwFPTk4ABEktYAGRCanyvvKekUI/hH6QPAxqQRVEUZVAHaFn8sSeGFVR1RGxAoRIoh7JITnnFFQ0BA0Rg5ntVSKoikSA5Lkz+5UpssMwmDYPACUatOxVifsYa9tFBLKPytMKhwwhWEIZIjr2Dx8+/P3v//jBhx/fuHHjk48/+d73vvfRRx8ZzxmHjo652U6S/xpn/RrfunqsOMBL00G+hgNzAni+sFtO3BB7Nj51zhHRgwcP/t2/+3cA0Pc9EHrvVUFU+77ruwCA7MgxigygOvRRYvCEoIoKTODIMaKk6YioAAqSSowAwIR2fGYndczeOWYmpLqqnHPmBDBLaAE+GONqXu8YvMwG75zTCKDpI+NUFr9pOGxqCbpVRBCMPcS62iIj8wBQBPoSEGp80kQax+73v/+9Y7z3xt0hDB9//PEPfvCDDz744Ac/+MEwDPbAohObCnud07xC9NCk/CdDVjrsLU/Ca4wvR7P4mo0RxRezdqhGkdANPTmumvq37/3h//0///uBdEAEZMeNRJKIYWnBzOoZHIiGToZF6Jdx6EkVR0qtxQvFGEyfNiJa4mRwfRhXCTm436KMrJBJQWlLd1RZI3jFYlvot3GqqqqKTIWIy+Xy4uLCcANyuIX5s0fsaM06XK4UxCsqhOkMhQOEEGKUuq7/4R/e/cUv/v7mzVshxGfPnt24cePTTz+t69q0fo2CL0msFdW47dq7/tiQ5V5v/KOxAl0W32dSjw0zOGzblUUCjjw1hYJ674nor3/yf/785z+PEmOMEsGAxkDQoBBXLq2VFT9R0yJLREFVVUFMbldVNfWxACsRISVbZzYRJlhHRHMJD0MKOU7CSQ5PHMPoynaUF4hE9hyj34g4DMP5+fn+/n6JXYthKDi5AZRjDlOmCluJEMZMiEhQo4rz7t3fv3t6evI//A//908/e/Cd73z75OQkxOHtt94pR6CyMkB9GSqlZjvpeGdeabycA2xHIL7eULBsQpXX+hsrJxsDc0TNjh/NVkXn3N7e3niDrCDP3/zN3/xfP/2pRfkXkAphMLteEQzGFhUY2VgMRVZ2z8xsIBdWSIQ8g5F9ZGWqmqaxSm+IaEVKYAt7DXfGyxkDqJayFMPgvS8VTQyXROT09NTii+q6Ni4BI4RM4B6lmIAANgWkEiZoz8n2WTSe4L3/7PPPfvKTn/zgB3/5u9/97t69e303PH/+fD6fmzYSSpTUlVGJ17l42bhCcLrOuK4IVMD3T4fgr3IUw5+FNhQqLiL7+/s//clPfvrTn9ox20nb6yInFFjZ2OXCH0zsgUzRidiAzwT0clv53SLtEJF3rq6qtmmaqoYoTFxM5opKDpEtQ0GLUKSqJjnEOAAIgIS4FAkqGmNsmsY5Z8KV/YSqnp6eLpdLVTX31ljCMZFmrEeNOUOZcFIhcsggIprf2m5r6vrBo0f/n7/6q+9+9y8+/exzRZrP55ZSU0SvQgjgi/bj2rgCwdJYM+/g6k+QXjohMwddQYC/DqOQNFinBHbRbIJWQ8FSXQ8PD//9v//3P/3p/1VVlUqKRyjYUswgMCL/Yym5vCUiRCq1Rrx3JVvKMAGZU9QbIAEiYIxRQhwWnSx7XQ5O1YHGoWfQpvJV5bz3zMlYKXGFgWUUkCUieyCavUjVe19VldFdMwFZUMNsNhMR4xJlFSX6uqDBWODBkafCUB3MU+4cAGZpKrGvx48f/+e//dtbt+6IQF03Dx8+tAwy4xJmFIYt/vaq53vZp2bl0wj2746/NWKsqz/VfwpK8PgItz8CE8edMxpp0P9//uQnv/3d7533fYxIpAgCkJy3GhEiSQQdSAaSiACW6z3mBvaLzuyezjODSEqagYw2kEOMDAKIyAIiTDIGSPpACKFbLufzuYXcOeccMROpaomzx3FIc8ZqEUGjsiGUPGCDOdPFq6oyxOj73sKYre5DmZv5CsZ8QNd1jHLFOAYALBYLZpZMCIKKqCLi7373u/c//LBt2/l8fnBwcHJyYhQHRkJX4WbjbYStgpOXHfE2LSjPGf/7SuMfjRJ8xVDVZC0pWb0bXnQkACGidjoZLs7//t13f/Pee3MRAo4CSCDmqEcQjanirUQ1K4wAuEqzfA9Z8oaROBTCwIyUKeuaXMFUzJFMTMyA4Ilr5yvvmYiRBMQ5F7suB88BInrnY5IcEqAUz9SY3dnqokjse8gJ+wb0lgVv0r+qLpZLAGiaxntvQpEJ9ON4ZoPpVORwDUahqCiq0vc9M0UVBEQFhGh4++677x4dHYW+v333ja4bFouFr1yMgSzEOj+h7F62kvHV4LuTtH1R458IAmx4MXRkEEDEYeiZyer+ffD+B3//q18/fPgIgYc4KCApKKlqFIlRFaNiFIgiIpgzdAHJRBIYYVcRauMQAMWqVhX6CqYHl1g0i2VRJSRCUlUNIhCXMiciRxgYAVAiDMMAqkTUVHXf98ZOdD2NcEXFAZDQMUVJEG+uKPtKjLHv+6ZpqqoCxPl8TgDeV444hmCybcREoQ0fSpWKy3YbEUMYVJkxZxTkYJ7nz5//+te/vnf37h//+N4//+f/7MFn99955x3Jm7YtxlCu16s6ZnGbLt8vD/rhnwACXCZTFuolI3/Qex+8/8kn9+/f/8xV9TBEUAW0NNwoEkQHBUZVUlWREnqioLpuyBtz3oRsWX8o6kSiWwgoSkSASS4iIgYUgACRharKe7PiIwzDgAxGvIcQiqMAAQkBiBRAJCmXhBBCQAUCJWQzU0CIAYe6rs1gYXbWMAzeuelk4pgvLi4Gl1zFycmlysxWStpqpps9oGjMMJIkRYRyrTjR4upCTTmW7ve///3x4eGTJ0+eP38jKthjiyBXjFeFeZoIlCMGi53tq3PK/lPQAeBKE5jpo1VVffLJJw8fPv7db3/bNG0IgohMWV6PYk4AybQfzL2QDcwbRCjmkcjwuqvL7ilfQUJmrqu6quq6bptqwq5CrgAdcA1UB9GhmJI0OgImIJMuFEwfYPMeIHpiUnCInpghpW4bXDKTac+m65e4oK7rzD18fHx8eHjY931JAYVMmy0NyG4DALP8jE23ZVEmko3xv3AbIppMJj/7u1+wrz/44MObN28+efaUHBs6m2G0GIVgZHTSNXf+a46XMoqd+sM/EQS4bNjBeF+99957Z2dnP/vZz2Ku028fiQRRM/kjAJMmKqQAgiBFrUABVLDk9lSjSiEKATISkahGQQEmIEUGQEUCYiACYnLOSYwaFURFVAQYqKoq51gFPLu+62IIGgVBQYWJKkd15ZmZkRARVAksOhVgVBbXzJ1EpCBV7czOgzmEAQAMBwy4u667devW0dFRyEpzsfYiooU8zOdzM3paxdwS0z9ierKt1Bb/g1H3n/70p6fnF/fvf1bX7fn5uYk6xQYFuaYqZMNDOaz8K6Iax3+QqgqUv0uP+4qx8yv/6EWgl+K99/7hk8eDwl/9b/+rr5p+ECBCBZFU50+iaJbvLftESoWkHNqupuvFCGDCCIEoEwEiE8QYmRAVUBRBMUc+AwAjioQ4aOWc9+ycI2Tvfe28WYeqqnIOPUPXdV3X9b0IM2ggYgRAlaAx6AAqBKq4SqtXEVAgQmKGLF0QA0Ysjgi70yy/Tdt2XYeIBwcHzHx2dmYFL3xdlR00U1Xf96YGWFelDZ5mEd0rWciMCAoSY1RRBGYEgA8//ODgYL9p2rOzi7u3CQCGIcUXMUHIJiZkIiIdRVBDFo1KdOr2KX+BPuWvPQKM0kEg54OUa5oKVl7Kxxhp0S3PZxf//v/7v1TNVIGQTW5Jjyqu1nS6lzwHE4Zo1vzUsfW9Qo3iiJItT6L5m4ZhICQmEhVAqn1Ve++IFZSZHZPEQQmAIA69RpU4aBw0DAhSM0XgfoieCIlCjD5FPgcVZeSV/R5WfhlEZCYAaKtmuey2JYrZbHZ8fDybzSaTyf7+ftu2n3/+uYjEENGy+LMVCAlFRENUS1HAvP0WFqAp5CSIRSlbY6hRzDMRqJ6fn3/88ce3btywaTZNU4xLoCtNKWoyPo+5zbqGMIaFLz5Z5ctFgJeS55d9fwyRu/nYzp8oF0MMv/71r//u739BhMvlgBZbn2J7UERQFFRSWM/lq0h2GEREYCaHFEMQUUQgJAQVUeccs3NIqNDWjYgMw4BKzpFPRsbIzEyKEOva1+asFdQYIUYGbataVQcZliKOEQBRnRJFiRwCqETQGHKx3uSnU4jJZYY1eu9jWNTOdVEkiiOKIDFT07Ozs+PjY4vdb9v2rbfeun//PqgSEAISc5LudLXqEAJ7V0SdDH9jlQetGtjqPaEF0j59+vTzhw+/8c47L168eOutt0pSNWaDgapa+XVHm33KytsxxH/h0A9XI8CfCr5f6Mjgv0kSdKvwU5H5nHPPXzz55OOPnz59Wk/2nPMi4pBCCJZbi5Jc2yKXrjT9hLmiEB0xAkqIKUNVQSAwELMljvgilCe7BzITsnO1dxKFiWrnETEu+7Mwn0wmdV0tFksAcczsedn1Tn1FUnmXLPQQJcBSB4aqH3TAGFWA2QpEIIBKtF0wKX8yaQCkaRoAWC6XmKORmbnv+2fPnpmXahiGO3fu3Lt37/PPPzd5I+UpUqrwz8yD6cExQg43KDBeNgcRaZ1+2B2icnFx8bvf/e74+LhxvFwuS1s+JCxRomrTu3L/v1i433hacox/gT/whY8rNBgYrWesq0kqqhw//vjj09MXbdsmSUchyfuZAwCApSxdgQNJHhVjFBHUancCAjISsmOitvJ1XYPIENUhiqon3Gunnj2qNnVNoBClrhwBE1F1cAAA0+kUCE9PT/tlBwBA6CgIUdO6qqlOTk+DRFbqwtDWTYig2qsKKIQYHRMQS4ySRXNRDSGcn8fJZEI0NE0dwrBYLC0RHlQN9GOMk8nk4uJCRN54441bt249efKEiDAHd5hYYmpxCIFySlc5hSix0HIAiFGZV8lGkANihxgeP33y6aeffuvtt05PT60hHwBIVCx9NwjhEsmzNL8oBGgEEnH90O3lS/Bk5w1fex3gknEZSqiqmfzn8/mTJ08+/PDDx48eu7Y14dVM/gAACCoRLINFw9UkgBVQBc1DKwqgDECY4k89ubZtK8cx9CLiXeWc88zOOSYkUCaqCJiyYdL7EgGqqhfnFxoFVJxz/TD03XIy3Zu0lW+rvl/O53NA5LYNIVRiwdTLPiAOFtscSVFN+AZUlaqqlsvl6elpXTdmCR2G0IVBRBRgNpvdvXv3888/v3fvXgjh4uLiwYMHN27cODo6Oj09BabiozVwr+pqPp9HlRJBlEg+4FhPRdQYSyI/AigIggKxB9C//+Wv96bTm3fvLpZd3XhGiKJc6mSJAoImfToB8noAsuKoTsTlYPCaXOIfAQJcAZ06igiAdHJRFZbLedM0v/nNrz69f58cJ5umKqgSYZQo0ilG828paPGHXPJbSdVTERVgQHbOaKpjN2lqJgohOlc1vvLMTOgJiUBDQNDWN3VdOWLHPsYYw0DeT6fTYQgqcTqd9F0XCGezWd3UBwf3VLWd1CH2TeUIJwK4WCwgDoLaNERcu24YCLtuGEZVriCHS0yn0+VyuVhcEDkAx5TCQlW167rz8/ObN28+evRof3/fObdcLp88eXJ4eGDRE3YnE4V+GIbB1VVVVfPFggCRCGy3s1psN4uIEjnnFFMbEQDzjKVAJgH51T+8+8a9N6dv3uv7rqkq5jSfVYvilwHAdRrA6CrPWK/v4PpzI0D2tSbL1raOC7C9mAKmG0zNMkvm83nbtr/+9a8fPHgwDAM5p0CgCgIKKkX9SgUaNv1W27+VWHsQRHTJ6QVMOG0mZqcHgKqqK19551ADKWCMsRuIYNJOvPOOuK1rIiKs60lrRcZPTk4Quaoq1Hj24vn+/t7Nmzdny0UYREJExEnTHh00Snh2fnZ6ostlh4q+rdummc8WGhVCGERBU8kGiaqgy27pvY8x9P2gGgkHZg9IMQ6EcHby/ODwcG/a9N2CEIYQBg0vnvcIZJ4NREVwdV3PZjPyrmkaPwyWb2A0nkZFLkrOQ1YGaCyyF7/40yfPPvv8wVtvvZkF1FWXg6xGr/natk9258X1YVYvXH9bjhUvYxF/ZgTAHPAOVwoh47ENqZgjzxCx7zuLB37x4sXjx4+bplVRAVEEVEDFcVb4zk3ZwC5Jljt1SLaLVVU1VV1XFQAQUeV8U9eMWDvH5pQFmDQTyl14G1/XTQMESOSrChHm8xkAVJVP0fb9sL+3d+fOHbXoUSKuuOuWNdeePVfOI09c9fT587P5zH70xs2b3s8Wi37Za993UVURnHdBo/TDsg/IFTJAiBqCKCGj4XLlqsViXte1+YyNGMcY0TxwIr5yEmOJmSMiaxVjZsoSzVFwAHNVOSIy6a6cRXnRNM3P/+7n3/n2N7/x9ltnJ8+n02mJXTWLHKxXKxof8YZ5Y/vi1bBRrl/2lT83B3jFUcjxaD2iClbabbnszBv/k5/85P333/feF90IBcFiftQi2MbP261npyvG7pEQwDE3dV1XlfX2qpyvqgoRCHXa1B6BEFt/4L3vwzAMw/7+PhEBkPNM1kEjqqpUnMJjQghDkLZtq8NDQFSRvXZiPVxqnyo7sID3VXNYTSbTzx58fnJxrkzDcr4/bZu6WXbh4hwu5jMVp4RM5Fq/XMz7YWBmBIwyRBkQUCzgDDmCWNnDkcQPIiJgfSYJGWOMhgDz+dz6YliDnLE2HHMp1RI9UTLRdLS/phfNF4vf/e4Pt2/etByfYjJNzyxnOfIGlCcUKXdsHrUX1zQQZVKG29LEPyYE2LXsVVWP2WwWQrh58+Z/+k//6dmzZxcXF9m5SBpVMWVCAICoRfuYDRTHghDkM0bzbamiQozBOaq935tMm6oGDcxYV65pvMTASrXzzqqKT6YV02w2q+v66OjI4vutmn6p2zMuGYSIe3t7BatTWDKtQnFS8Byxd65y7u033qyfP7voFov5fOhmdd1OmunNg4OHjx6fzmZxiL6uFGE6ndJyOZ/NOBlBo6gFBTq1YA6Vvu/NFV0iRxWh7wOTs4A8E2ksA8aMqoYVkF1Usp4wEEKw1Rlb0xy+KiIhRO/9L37xi7/8/vfu3r29WCz29/fHOaiqiIQImMKgQNf14BSQ8mWEyP2ZEWAXRX/JneVtNkpoiCZH9O1kcjGfPXj88KMPP1JCAKcJzFEFQ1QAYwNBNaoqkkYVBiABQkzhxaYLklkzlCM1VbNf+71J49hpjHVd7e/vWdtd9Fy5yhO3bbs3nXaL5Xy+OD4+Lvoo5Zbriuqc994TYwghSmTHdVNZwALm4HgzDVkAX4zRIpwRQEQc8f5k0tT14+fPzpWWi4WEQUTqavrNd9589OzZwyfPum7pqyay1lUlMS4XC+cZhWPoEVEkKDFSYobjbRcRRQDAYQiV41IWBRHPz88NskuJAMikWtaTH/ohIjnV1ekYDgQNTIwA733wwf7RQeW8ldcduavRrHRJ/llXYq8DHq89viIE2CmcqSoBb9yQCPBKnV+Z9pk5hMFSvyUnKFVVhY6DBKgcN9Xnn39+sVzM+yFX4i/OASDCGDVKELHKC9HqfmkROk29tSL6qgjqiKeTtvHcVo5USbVqmqbypBj74BC98820PZjuSYjzi4umaabtcYyxrmuDGABwjhDZRGRQHMJSVeo6gRQzErmiUxqJNfJvUnI/DINEVq2cq3zVtByiesBlXZ+enweRvp81Xt9843ZV+QcPn86WC61dCkFtmq7rSBCUFCKiRhkQ2DJUDLuYOUeFWOfJoJGRLJYPGVCizOfzqqog67XlvIq8bgg8bpZR8gpWIdAAf/u3f/vDH/7l/o0bF2enGykHksOBdBSTslP+2QlXr40hXwUCaMwyxronFwE1W1lWNycPf9y4gohW88zwYVzzbBj6rusODg4A4PPPP7deJiN5ETQVVhbRYP3nVFOUhd1GTAgIlKQiq3FSOZ40beXq2jOBOMaqqmvnVKXruopdszc52Nv3dSUhisiNGzdC3zPj3t5+3/eIyT00zrcCADMBFckBUwIxqTpENH+UOaEAwHsfRaIVqwuhZlbVuqrc0Y3zs9MYwiAaIA7LbhjitK3u3Tl+/Oz5xaIH8hU4IhXGECORRgEAAlCJgpB+12SVUkxFVUMYRKxnzACQihpZVSzzLRYxvXCDohUMw2BMzDsaa8wpxxpBJP7sb//2v/vxjyUMdV0X1xiMQqPBRE/Z0dnpyxhfqQiEL7P4XjGMKNpeW7da26BhGM7Ozg5vHMcY79+///HHH1vMpqogmolDLHVDIQBEwJhmsbLAgoISWkxzOrPG15Pat+yruqocexSP4BBQRQG890cHh01bO+8BgB3XXM/mF3vtpK6rMreiZUI6YPLeW0EHE84NBSxv3qzriCSSitdSbqNkReNQIcboEJ1nBrUqLydnpzHEqvZnF7MYtWnbN+/eevz85PGT58BekUAdM2i0ELXEUWPmMKUcBuVkSwAQicvlsqoqyIlaUVJmWQmEtkPRVStiGqvCoGkHxgZTBGXm3/z6N3/xne/cvnnDFPFL4GRFGV8VBy4zBOWPNgPsvo75AOM1bCiIkG3PhV3O5/O96XQYhsVi8eLFi08//dTEaEyxjaUOSohxEB2KeLrxoxYXqaoVcuuqtqpbV7W+qokqoBrZAWJUUmir+ubR4f5eSxpRgyeZ1MwwHOw17HQYOlSonGckR8wJkq0NEcdobWDI6H4hpWU5krMTs9fYW1KvsT4LmWZEdq5umsOjoxs3bjCChGF/0jYV9/2CSW8f7b995xbFjkEICNdbl46N9yUteEO56rquKCclRhpyD7Vy87jYSUYeMeOv5v4ApWhSyaP/m7/5m7ZtN5IK8mPznwIoqoBGQCXrkxBVrLBD2Cq6E1XiqFjL9cefHwHGFrHtUegHjbKuCvO9uLgAAFVg5pOTk/v375v0mdUyDSHVdQohKb6mohUHFwKgktmESKECqon3vTuoua2p8kAQQlgM3SIOgZn3JpPjg4OJ9ySh9Vw7qr1jslBkNQ0CCSgldAnSiowVmWdsRIfcT6mssSCDoY1VeTAcAIAQwmKxsLyapm1u3rx548YNFUHQyWTiiYa+I5A7Nw/ffuOudMuaGczEMtptysm4kGl/KSUN2aNsEF+mXQxTWKKmESE3Eh9Xv5IYh76XEECEEQiEQDQOqDFIRKQHj578+jd/2Ds4Xvbx4mKuqoiKqEaF7A80h1+v16HJ6PKFRa99JSLQnyD6FLGnwJDkZiez2YyZLdT2Yj47aCa/+9VvJtOpBGFVVY4BUVkgiAbAOIL7zWJ9qhKiOuccu4O63Z+2TEAq0IeIQKhV3UzbyXQ6bZq6qqqmcoQSYzCZSFUYiYmJSFGJADClHBCR5sZ4xegxbsaabbVgEvaGtmennoynSPP5XETiEDpRdhxCaKr63p17EuT56SmANFVtP7RczI/22jvHR8/O50wAwFiS00VSQHWm02uykNW9EgnD0NOCmAjVARBiHHprG8MAFqluHfVAVFK5l6gQiQjValYbD9EYBdGVoowA8If3/vjd7367H/rKsbnbTHnYoIPjcweA6wREvOr4WvgBNjgXIqru6IhYuK1RIxN19vf3ReTD9z9YLBYH+wdDDAigYJ0eLXpNFCSTft3+OQVAJGZoqnpvMjmoJ4RCFOMQCKCpmulkstdODqYTk0wqXxEqATjnowjkWPgxjxof5NoRjhI+aFQ4bSwJGHoUFC3mIAvGM30gxCgRoqojrqrqG+98M+rHz148t7RgBGBPi/ni9vGxBH10eorkGkLrXA9IooGI1CrAmAWSMMZIgII5PFMlxgDAmGPRiuJuFS7KNmYTajk7FRESyhdXegJmP9of/vjH//bf/vj2zZuHh/sh9HVVxbAye2xs3erFuhHlCxl/fhHIxoZoPgaj8qJQLDO3GTQcHR09e/bs3r17P/vZz/q+1yTxg0Q7jBQiUp4/9lPaLyMpodS1P5g0h9MJkA4ydMMAjtr9vRvHxzeOj48O9ivnK+drM3AAACAT+Vz0KtWBS2jARM7+SnHDMUBjLh1nErbpgkWEMEwhZEJGtGR3x+TYs69d1XBVoXfEKhrjbDE3bfIH3/vBnVt3CcgReXJMdHBwUDlu62p/MnEOnWN2rJkZIyIjZUfYjkalMioOaQe0KnKom2P7EMcvZH2Ytfc//+efRVVzmWcasqP01ZcBbOPxlXKAV1rNePHjvVgulyXR2w7s7Ozs5ORkNptVVRViJAAR0lTKVDAFuu+Id0gcVtQh71XN1Ddx3iFT7T0i70/a48PDyWRChJ5d7TyZWcRwUlFUnHPMibCh9W9BMjKVXljSYNYmx0srdX1y0mFOPFDLEklBzlZPBRGd86pS163nyqrPSowK1HUdETfN5Fvf+haivnjxdNn3xpcm08lh1F51uDhXUBBFh1HUjCyJESHKKHoH1037RZsySDZ3ipQyR7sclCslLRGxFaOwVcYYm0n7/vvvX1xcMGNbe0nFY6Hsw/iFbrWTQV3VbF5DWtDrNHgfj6+EA+Cm1LHjlnXJYef9RvvHvpW2bZ89e9Y0zbvvvltV1TAMoyCJcWh7tnmOSUs+Mkc0qeujvSmGUCE2hPuNv318eHy4V9cOKTBFpggQgCPSgDQAC3hEx0poNWyN2BPxKjMDUwwK5bGxnEv3ZJ2OjrytYP1pmHk6nVZVVXmPACJhsZwvFjOH9NYb927fvDOdTgkRVMPQ7e9Pbxwd7k9ah2oMZWV+UutBtqOX4wbNtqph+U9EsmFnV4X+bdZReKCpGVEEQJDgZz/7WQjiXBOjbgA9pFqVMc8KASjXxPgi5aCviwj00oHZXGgIYAUOFovFfD53zj1//ryqa0EQwKgQIQboBHrBTmFAFEj+eTBLEKkyAqJ4jweT6vbBXhWDg+gdTKd+f7/dmzZN63yFzGhFJHSLhRSc3RDYRh+tjcuWtik2rHuXVlQQEAGZHLIj5yeTiffeO1aRGINZSD1Xx4dH77z59nQ6dc4h6NAvbxwd3Lt943Ay8aaS65oqctl8ChCvqLvkoi5q3GBUL160/FHeIhWzk4KO9m6IAQmHYaib5g9/+IPZmtZ+5RXFnp33b4tSlz32z4wANrPtk8AUxUAbYWql9CwAEJGR///j//d/kPPzvldiJRIAUVGUbIqRGINIwgEUBdVAKASOaM/XB35KIYZhcI6m0/bwcNK23jskBCZg0tLVYjS3NHlYP4CxHrxx83W2omiQlwOBKQ+OiAwHmqap6wqtiWXXhxBqXznnbt28NWlak85C6A+me7eOjydVXRF6RIdcOQ8ApMTATpmESFYnUgh2qe1uPDOVkBFJAqbKTtgqz8iPWj3Tjs+KZFVV9dd//ddPnz7N2WRXbc7Vn27ccBkB2j6OLwsByoRQaVW2BFfTfSnSW+nt8YQLLTSj9XQ6nc1m8/n86ZOnkoMrYVSZuTw8ybL2Q1n4EcTGVfu+rhRJwDue7k329utJW3tPxGCmfRhp4TvnU16XezIarESLq9FgYx+2d2NsCE8/YfV0HNdtXdW+ZmSUrpt1/UKBnMCkqu/cuXOwfxD7bujnISwPps237907muy1jmurXmHFQc3TgjiWhXRdcy34UJAhMYfdpNZgX3QTEVRzrwbKUdPvvffebDbTbfZ6jbHxlY2v756VbCrwrlDTV/rtV53l9Qnh1tdXz8GspdnT+r7f29v79a9/TUSLxRIpVbMaQz+sd5LCXIaAAFt0+3XrgJio9m4yraeTuqk9gTpkC0ImImQTGUpa6vZCFNfFnnI9a8NXCT/b0hEiWKGR8bX1N6igmUBg004IOC4WQxjm87m2SqjWFe/2rVtR4rNnzwbpiHi/qd+6c/Pzh4/PFktH6Nip9XYVYWRrOwn5yIrRuSSvQM65ExFKKSyECCor82SiQSqkKKlwEFpNsWL2xVzp2ipw/e73v79588bB3mTDObNzjA93tXXJsAWqGl9matl4Oq1R6C9uFGq9AY6vNMY4XYDMgMZ7/9lnn+3v73/yyScx5ka8W/JDUbxU8yEhIKIXPKzbGrjy3ldVM2mbtjWLDlv8AiAqECApMm3yoq15RtPYRIJIKI0YVk76a9O2y+7cwTBTyL4j8nXTVFXDzAw4OzsfhkFzp9c37r5xfHyMIg4AwtAQ3rt5Y7+uSaR27IhIU6922FKFy4+O/5VcCVSLYxHXxEJVXXlwo47ZiK5CVBJUtG37hz/84fxiZlsuAlFFNHcVwrS3ZsuALFAkoBVMr/8EQeZL1AF0rZTSarw2Nxg/QVWHYfjggw/MIEhk3snNbjkrVgcAkBqtq8q08Z4C4UAEvsWq5sZXFXtCD0gCCMQKTsEBOAgSh7CiM+trHP9Qeg2iKZUylV15Jea+8+ZCUMbXQFFVCQmQm6aZTqcWjtF1nVlWl8slArz5xr3jo2NU0CgQYuurt+/ePWzbGqhx3vB8pzi3sbSxFAGJuFgQkYqGMVgriAqsQb+QRDRpw67EGAV0GIb5YvHs+fN517Pz6SdWysNmi6qNjSps6rUtQ19TyQeu1Hui6KzvfTt9948fRPLCHsihtWtfV1JLYKYiGDg6QI/kObWhrmtf1SnShtkjJqKiESQO9nfZAexc8sYYE78rvnXNPbGnrekkQADWZ56YeTKZ1FWFuetZjNHC2m7evD2ZTGOITMwAE+/fvHO3qRtGZCI2EmpgDQoA7J010bL4M0UQSDV8EthJ6q4X4yBiKcWpJ9qakrBLl1BFC1LUnObxq1/96vT01MLvMrzvFu7Hezu2Gejrtkz9shxhO2n/Nb/60pWIymw+R+QnT58lxj3al/EcRtQr3cRInr1nR0SV56r2pTEEASFS8RgArGzw4yhIHWkjGxPLB7MxfyzhQNccGzuwHgOjUaIJHZoLa6qKY1Z2NGmROc7nMvRWIUY1OM8Vw9HRftR4+uLEsUPEpqlv3zoenj4Bkr4XRABCESQgBIgipeekZHeYzWS8yeaPGpFhVQURIcQkVo14l6pKNJ0HRJQIRYAIAejjjz89Oz87OjhwxKDWDWEt22bHnqxbdQqH2taprh6u7PjGDyS1+FV5iwICiQgqXRa6dDV8vxT6NfvkU9UTohgHRrKTKHCpKzl1bRBiy+wRCa0gOpm1R1VVQNCMr0gM4+arspWsjVsS88aRjLZEcf2ejfUUb/FKldzYitwJnY1Gbz3f8jeZCAgrwCgiEkPoMbf/YKaqqvb390H05OSEoqKvDybTeFMePXkiFKKAY46gAKygtiNF9x3JNitSs1rdul0YsylinOFVXqgqAKOu8MqaBvz+979/4/YdrhtIeQuYPTejhW7ZoFd2Ntgop3XdkdtwxjX1wmSA11GOcdXNfOfnr8enNnQsEamq6o9//GNVVSaGJov16CtlGvkXNeMGemaHVLNv68qxJWMTEaeSl4gE4JAcMinoesj7BlsfcZgVT9+QXAkRNCIIaARRC21f/SmAZetrKl6zw8x05ch7pMQpuayqvDVjtU9Ln9O2bQ8PD6fTqUgYurnTeNQ0927e3GuaxjuH4AFJVlWoCijvPIUdExvZTzc+hUySDORMBCrqxGQy+Yd/+IfZfB5isA2w3pqlTK8dafYNr1oEjMEpqcVfYCiEXFI554qxdiS7Pn3p11/6WFUViU+fPu37fjabhbBqaYojdhlHrU7Lty1Y0oq3VZVvm6ZyDgWcydJkvV4oAnRRgmoAFHSArEBqdwDpuid1POfxJMcgAiP6dxUQr49XlSHR8pmJnHNVVVVVxbngs/VoYeaqro+Pj/en08ZxmF+4KAdte+f4+Gg6nbD3CmmpOZeNVr3x0tgpkKRVjCSQjaWNnGJBNQKYmQADQC+yHEIX4N0/vHex6KICAZqCQVs7sG5l/gLGS3QAFUHeLe/uuDlt0G6kem3o37hBVYd+ePTwYd8tKsegOgy9AkguMaw7namoTGwVpmp2beVT0hYQAycfEFPyXqHCSvrbIeroKGhsPPPxxfXbstqQVYhXXfvLhuTfRERFBO+9IcPFxYVJQUNcsmjl/HQ6ZYDnT59JlPn8gtr6cH8KCBBFRWPsQDWoAICoWuqaRCUGRByFdZFaJxDbEostKvauVYO1tVXC6BDTv6qI2A+99+6jjz7+lz/8YYzxfLZAxMlkUhqtli0tkWCXj50/PZrE+v6/DAEANrp3XDb+BHu/bv1r8kp6YU0Ii6NXVc/Pzj5+771hPtehV82Ng0aItz0Zi9hhwEnbeO+d80YgEZAtb/HK8JiXLGA9iHL7o513AvxJVrLLZmKHZgigqnVd9z0GCBJ7kYgRnfPNhG/ePT45OVtKt1jMa9DDgz1QiACCsFh2IaIARsSoQMiEKfJnLGpvsOUE/S9DZMn5TGrqtSTHuXPu4cOHJycnxHA0nVp/msViYVWVxlu3vaX2YudmvpR2X8sKtBu4NwwVgAX1XomelZgq09jWP1pRCwua77pOs9o0FnIu+1YZjOiBGu8b771nX3vvHCkR5CwNUF7lsFui1kv2buMnXnrzZYT/i0ADUzcFNSKYAGGZw1VdqwigBpE4DF2vKCAASI4Pjw+cr54+f3FyceH6sL+3HyWqagzSiUYUFbW2McSU1PR8xuPlrIFm0urXxKRy87p0BALRolPNO9b13cXFxVtv37NydKWUBuYxfoK9297MTAKuGmlimjeuXN0WSVOVnJ1/MP4z5eOVVZCXzzIbv63NoBXo++STT8yLvtPwoiMH3JhgIGhbV6zRMXl2hRKbfLvxkCutaZunC7twfv1K1ttw3ONtE/r/ZEForHIkB6r3XFUOHXPl0XEfQj8MIYYYo3NuOp3eunXrxtGRSlhenE3btvG+raua0aemGas8AQAoE9wmPeMbNpgDrEOXHZCOPMqIGEKoqvrnP/+5fWu5XK7/7vYDk+VOda1znoqCIAjmDaAN57FGSH8CKpcowX/6SVxzjH9ovFPji0YGlsulpUGenp6enJxsPGS8s5amvbFlqODZeSIH5Jwjq9KjaqVy7KvlgSO8MnIikHZ5TcFYPxJMMeu7dOK12a7o027M+RNHMX+VLPuqqqx1jdXhUbXuyDHG4Ahr724cHb119y6Czs7P9vf2HEHjvEf0aH3QZES113a17PlKS86XYf1cNr6ipiZkviEipqh89Mmnjx4+iUR9iJaYP46hWN8utYldRu8LU7p6k792+QCrdY5CDRHR+jar6vPnzzeiZxOQZov1eM32L6mQgvNOogCTqohVqdWgsEAK3pr2jB5pzizEolnoBjvYxoGNg9+4vj7hgmyy8d2rx9V3FFFhw2VBTFXt2buqqZtJGyQOYYgxDkPX950jqpxr2/bunTuoupxfTNpJ29RNXXPW/TTV0FvJP9nQKao5CCoMZtUVhAAaVCKooJFjMJobVOxPEay0CWQrrVrlDgCzbiPi+fm5Fabe3pnN/dxJaEYShO60i9jmvGzPv6yxfeRjWNGMAyWsipm7rosxPnr08NHjx71Sh36J9RLrTqsOvICTbAxNDFJERRBEQAAAFc2lnymVMLOZfTa0fNWXEOYN+JbUdnIHp4adx6NqCicAbFi1LxvX31UwTCBFUkAhBkRll4ZVGULDb6EhSh8CIBK7qq7evHd32lY1g0PZq6ppXXkEh4RCEKOGADGCmi1YRILqijmUHdhwj2zsQAkEghFoSq6GVNf1L3/5Syvca82MN8jKZXC/8brsw8bmbO/knwUBxu6M0dkjrP5AAVBzo+qxdX+57MIwIGJK0sitBWxtG1sGAEnuRgBzbxMSpSx2xFSgKpkP0/2jII51VUtH2t7GkkbCMWxNYHNks8VrbZ6CqpkgUXMOlv0pMlAlQFEJlFQQgUEJlFCY1BMgAde+baqpdw2SR2YgFNUQIwA0TXO4v9+2Tds0xFhXlWdHiNblcn1F2yC+m05vg+82eo8zb5bL5W9/+1si2tvbM1m3tHR45a26BuG4FAGuT3W+qLFB8IpQLrkL+TAMp6enDx89NNoAWzi9QXu0CI4IpEnCQSJmb9VqiUEVJYIqgq41qV3ZHQBKuG9xD22ryPbOLm+IItvKdLEZjIBGNnqjb7RHTxcRBFkB1Sg8EiCZiRewOJHX0ujK/uQZpZzSUsYiL1kJ0TNOJpP9/b3JpG2bmkGndYO6ZhIohTYuO77LDnQ8xgIJppqkoWgS77///unpKQC0bdv3PeZSu/Dq46XfuooD/Ck/ecV3d5HPS1Xh8tHJyYmlAkvM0X9bUt2oEOLKGw9gXlwEUQZ0gCopmSMfA60LiGM3ux38WghA6pG0JXNbDsFOw5QlzkMCfYu5INCdcQ9/0thGzjLDAvSljothwgjNlYicp6aup9PJpK2bytd1VbHTsR1ct0nVJtyXYyvXN16Mv74KNFK1WX3wwYchCiBNpvvDEACQ2W8/6orX43E1GL9EBHpVHBij9Z/ywPFt9qiqqm7evPn06VNdd4ptc4ANdUdVScE751KopwhYPZUIGlED6oAyEETUiBoNPfIhrtxbiGYTXOP1Y0yAdfjbuHLZhrzSLr1098ZUo0ygvDXyz5wwoZiJEJERAVREGNB7N520k0m7P5k6gKZuSvZZ+ZUxOObXxUew+mB8QwF6g/gNN06UOMQQYwSiEOX5i5OL2QKJDw4OX7w4gXWceT3SvHO8XAe4/o9d83heesNOpmm5pE+ePAkhAILoemNfVZCIAqhJ2BHNEjIqggk9QhQwNTkFUuUkLgiitc9TAMrhjRledSVRrIjlaBQY2qgMtwH66cX1sKCg9yUfX2EP2s0BChMoHMDC5goOpMhNCaqRUBvmtnJ7bTuZtG3tKwcOCAGjqoCJZ2pKCOQQKRQSBWsgPsbADQQYk6e1EKNUzC9GiU3T/PznP2fm58+fk+Pp3tT8P2MRd3Ty12ICl310LU+wXruDyxU3F664/ZFZZsq3CBgARSyvCqwWTdd1Z2dnz58/77pOgCSVRhoLu1mGXPnqs2gOVug+RWgb20dUA1oiQiDNiuwov668sM7Ym2R+G+7Hi8JdstCrjl2bubbqjYGp2I8irlR2tJ5DIqCp8BazqjjFyEiCAhARTcwQjL0Mg0ZtEKB2+5PJsg+V8103jJejW1pvNtoBwMpmP74ft+wHBRnKXsUYQZ1Vuj85O6urarFY1E1zdnJa1358887deg2R8rpWoA0utj1gJG5ePkUzG6/thWzXnxnxShEx4uW9Pzs7s9AoVYhRinwC2fpWStJu/S6WOg2GCAipzzNqpo7onPOU6rqZUIDb+7NNX6+5gde8c5tQXUG9dj4g/RzB2JQ1OpcdDMGUASu4giuRCZiods4R1nVFK5/AGsW9zL6+TZjXBJ7sAB4zAXsd8ke/+MUvbt+58/zkpKqqZtLOF3MYCU5X7MkVN2zD7SuYQV/lGHaMMQTEUa/SMAwySvMrN5cTsmYwVVWdnZ0tl8uu6yQq6CpwCEmRshcLdaNYjZFDRGIiJPLEBGBYQKhEtN6mKXVrG018rSLQBhPYeH31+BM38PqjTCbj9phHKeT6RWM1IKvFbKHUiEhKIKISCNGzM/d5WcjGWi57u/FiLBQVrNiYvF1wzr3//vuPHz++9+ab9+9/1raTumlLfIR90Tz5ugpQ1Q0L+4Yxbef+/zk9wcUhYmezTScg63CmNp2fnzvnzD8Qo7nS04aKiEqJgMhLLY9KLn1kawOWKhgCIlplT0R0bEHRkKyea2mNBECInKe6g5yPJ79xwC+lWK81rpKCkrk2W6vytM29nUT2MQ4wM5E1wkges6qqvHNM6AiapvLEtfNwCQ6vFri1cNgi/+MXmylElskmMkSd90Mf4uOnz7pZ39TT87M5ctX3fV3XY57zillgO27+4nOCX3rSdjwle5qZx32SVdcykig3XhaRp0+fNk3TdR0iIaoICljPdytCgqpRx1oBpAAHrwSqzspiIjlkRCAWk3MoZUA6BQQURN7QVTWL1Kqlp+p1rW8FReHawc/jL67P4eVfx5U7b3QFEHLb07TBAFbYh4gYC5UBMMcZgAigwwYgIETyi2Wo65qWC0TJmpKqSpmRKoRk5CVQVSIFoBztN548jsqiFOqWNRMCAOvF5L3vuu7Ro0dv3rm7N92bzWZKMJlMTk9PJ5OpRQZcc3+u3rqvuj+ATWUcsLUitmlnV1wyyxgQJM675bOTF8QUAgiqSDQWDaCsIjKAiuiKjQCApl5TgKTF65tUAfuPENEColERiAiscNbl04cRgK5PchfkrbA6Le/6OsP20K0iyVfePZInIYV2q5rqDwAKpIwgVisFxVoEKoGDOsYIKgFCy8AOCWJ/sDeEfjZjGbQHNdPYdoh8EUVUBUY9BEZUIDVoSpw6i74Wmmo5a1b6exiGuq5/85vf/OX3vl9X9WQyWfSdR4/IqkldpqSnjffnS1OCrzkuIYdJILP5mUHTaP+mxmyBEJt2QByG4eLi4vD4aLFcWptbJkNdU6OliEk7BgIxW5+8lREQrfGD4QVDzuBHK0gA1r6Os8CAKqhi5QFXrD6tLdMzGLH1LY6/qd+/VC7auGEMW6qiEFVFNYhE1QAQAaJqGJkTGMEhsq1ClVL5w9yTz3zHzpGlidqfI9MCXOXIe++cq72vKt9UlWNXO29CFe6C/vWZ79bdNYd1FQQoyxyrhZh9w33f//73v9/b27OOEMMwNM2kdDTb3sMruPHOAV91f4BcYrLIqXZxZXMfLaAIP4g4n8/7vvfeabIgSZSoyca3UZljxT3UIkohCcy6Kl6rgJJYALEJ9UQEmqwklDpWAaEZlVBAVAkEwcr3p+etBSnhqHkZrmwpdgPkWezYk6svlgeKSPE0j28r99q6ATaBL0mSYLINilirL8owR4kqg6KK1QgQogpx0KiqjKFyXDlmJguLGKPlhoSTrwsAbRxruUdVc49kllyZU0Ssupn1WmVmJVosFiGE58+fWyxw6EJVDc75EIaqcjqi+tsvdm72tun2K0WAMfTriAPm2a1ZMAtzJKKhH87OzubzRSIbohoVPSWzxpiFjG0LuaDe2AJIRAip9Qpm4ce2zubCioDIppaoUpIYwKxOBKQK1n8ewdoMASIJgIgipsYcyf+A5QWmmisIl1HPK0RYAFCNCpqDiAAAVNYsKpoS0rk8bR21sIgtiAxgoI9jCC7pcIjoGIcATE5QHJJD8MSWUBFijC/Pu009aseTGS/QDrfAgN1ZkMFEA7NRPHr25NHTJ9/73vdC10eCxbKfTB057sPQVLWISIi4rg+80vhSlOCdZ1kOiXKvqIKykqsJ6Pr9RidCCM7x06dPs/kl2TmNrItEXLdwrXBAQNGMzZHQJ4uHtS5i0wwqYY4ApAQaK0YkUlVCMNwUsWaFgMYfFEQUiJRUQRA1EjAiIkRNTUXz0lKEadkK+6+Q843N2VYhtoYUPM8345jvbSx/47XpPJpYnFr4k4GNSRQigkpGTZAUBYkQVSOhZ2CiylunhCsUTVgRHzSMxe2Vbhwu5IK7OGpIY5XT7e2DR48eP378wx/+0CHN52GxmNd1zTWFEHpAzBXzX3t8RRxAswJUrqyL/pmGwZq3xbweIYQQ4tnZWbfsRDSqBBVkijGKCoBVnDRRyuKnMQj7JLwgRcEoRODZIQABOitwAKSIQcx6LIAocfDMTBxVjTFYmSObmEMSUUSEEEQVCYEokkZQxYCQRFtMmc2KmQNk3N7Rg+iK7dpCCYHkz+Is2K3Jwfn+lWYyRj9YiWGkYPY3sIJahPa8qAQEDlQ0ACISxkiA5AgHB8JERIAOIUBe4+qk1g/auN7ap2P5EEaEYEz7mamECYUQzP8TQ/j0008fPXp0fHA4mU76PgzDANZSUtd4S9nVbQHyivH6CHDFz2xtyqqu2Kquhq72qFDNLM9qDspXKz25WHaLi9nQDwAYU017Kx0M+cjHZgkzNCmxxVOAiBAgO2QmIO1jjMMgSEgRuRZQBPTOEaCIEgSyVosKUQStbJZAp9ER288zsdXLFFUAgVQ7ZHW6qiszl10cxx5vS6vbbHOc2jZCGDU1YEO60FEVN6vgibaW9eikpIEFMANm+dS+HhVIooSBiFSFAFMSBSbR0fgnkZlCXyIFbYPBFcBa0Lis3URfE4SePHmyWCyODg5VtW3b0lRPJFauKpGRZWNfCvTj4V7GedNatl5sLDWtcftpa1fGzcLWJ5nljdUwCKjr+uTkpOs6InLZemCPTToQFNZBoKtAXIFV2RoyudZ55xyA9L1C6INoVEVXg6ZWjanhIxKRYA61IyKAlKtRYohDDIgICERECogQBaQ4o5NGsakKw4jybZDnvLcrrdYaEcEIAbbhaddRJKtu+hQZRjUa0FQRSXUATMw2BbTADpFl0iQsKs5iQiIml4K+zeuyFsljtL+ghcqmfrxTNiaiUWNzKdXsDAHM8vPtb3zjvffee/ONN/q+b5rJcrl03g3D4JjNcrrBMDd+aK3Orm1dtrYDgLvSovUVjRUTyPmMZYiI9/699/5QytMWH0KSARIyoNpWEkkW/VVz6XpET4wkov0QWaLGrutCtI65ktNEKnZsoQMAAOKcs2QxVQUrkOjZsaucYyLvyRGjumJJQUqRLclPhzgSgUA1tZkYg8Ua0UqkvPQjylUrMwJs2Hk3pAh7G7OGDoi0frIiSQTVmHq9lFCItLGgJNm/roCEmNX2hANEoOqJhhjHPQHKjHbSR8l1pbb53hgANGs1RUW0NDFEJOeePHkSYiR2Auq975aDr7ipm+Vi7n0dY7S9TLmv+JI6oWNjy5erA+wSEHe8vYxnmYl9sVg8f/787Xfeyr10EBFEdNz6EZHMqK+aatFKrvcARrSIAGAYhhiHMKiVGxDBoCqafGQuFagx36Rrm5YdExIgDHGIw+CIa8eN9865UFUlTomIOK5cAcYczLNGKylkJcng6NIKE9QCOSHXOJUSKQCbglD6eIwhJhgm97pBLRfLWiLuoECQsJQQE6bnPpbIxKqOSotILcIVZjciIZkqnFOrr6vMbDPDsvZRiYMkaiEiMRKDLf7Bw4d3b9/+/OGDt996W1SZue/7oY/SpnC61f7QSyBqe3yRCHA9aerlA7OOhYje+ydPnhBj3/earD3JFQDZQKmpLnRASlH9BESEEgMgACqgMoFEFeIwSB+iCsVR+wYD3iVayDA451hA+86JVU6XqIEIXQgh4hAGR+yWSzceSIUXm+RqMQGFpBXyn22jWpgDJueSFrIHmdet4Hu92oWMhgWViEoUCTFarVTKjbiN+hJRjGbYUkRMH40qGVdVRY49EXsHSIhKjCqAqFEECb1jMisQAiOJJCfCGA0UNMWkEMI6el9G+MeHXi4W6VBVkejs7Ozf/vjHT54+ffPem1bcRVWHYRjCYDXcr5ayrh5fdSjE7pEMFPmdKgAJ6XLo/bQ97xa+bdH7PoKoAEmMESk1n7LGtVaSDMynttKMywMhKPQhBFBRibmVZ9ksK4UZRaIAIipypDB0URZiEEyEItEhtZUXEceMPSBRVXlGqqqqqWsHiogSJckVMUGhZg3Vrmc02DQbYAo3Mg6gq/SGEfTHGK1BoOQWjmUYAsSoQ4wiQo4JiJnJsSOvqDECgqqIJ64ab/Q/isQYHfOgWmmFvpoPQuQBXVRRVERFQucQVB2SSUGZagiMYE7NHgBrERDbHMDG6CtpjBwCFtBrbxQBhmF48eJFDDH+MDKzKhjcd12njq1k4BXy1dXjy0KATWknYfRlNxhZXNdGFFzlHz95bClClh8t2eQJJSxnpPqM2HJSRQFAAVUhqvYhmlisaHkJoqCKGtH8ChAVkZDIAWGJ1TOQDSECqBDMlwuDA+8cM4cYGl+ZhCDrAU7MVEQIHVtpspN7rIBCBpcifFj4rshameu+H7phCDH2wxBCiCHE3LwRVpxQAVAHDdopMrrKOSi/ToY4EL33FvYhKkMEq7JKSG497l/WRSALik5j3Y+W9nz9iMdwP75zAzzGJDzdYyvOwPz5559Pp9Nnz561bSsh2D1hiHHobVZlY78uCDAeRVQfX9wgCZtfUQ0SgOni4uLw8PDZs2dnZ2fDMBQIV6MSZshAhFSYzbbPHPuACFlTwBgkEpTaV1YVDlMH4BQsTgDJECUJ4AxAY4wIyoSKSNlIF0IgxKqqjCqHYajr2jlXBAyrOzRelHn+x3BgbzekfM1yf4F+A+sQwnK57MPQhzSS8LPWE7bgAEUYIpAMAzFXFuHMDpAlhD4MguAsFouoLHPZLZmZii0NQWNkTPkblAwEm+xr++xgSyYZa7ewJRSNpbss9CUqZ3FyDx8+/NGPfvTuu+/evXuXQIkJBbx3KjDEwddeRBSUX7ETD3z1sUAba7aBCBI3TRyOGL0rBf3GWaGQbe249uSRnQTV1EJEVEAEjDFqwIiCCMQpK8D+hRghRqsXByoxRHODMZEkj5hlDFs4A1ozdFMiJUQlGKI4QHAe0DQTBEQBsnJ1hbRv6L4FIDSL9WMcGHMDg/5SGLgfBsPAwqbGW5dzpcVSdmOMgoARcQgq6hAdkaZQiHWNPBkJotGCZCsRQbdiazBiuVeeNACsDltz8leh0GOILzOxRUPKT0IVFEwb1YfQTCZd180WF9O2IiDFIUKY7E2Wy+UgIT1llF7y8kkCwFeDAC91mYw3ovBNdq7rB0Q8OTl59uzZ8fGxyP0x/bj8Ocn8L6AMUILiEMCZT4AQgCxYSzUiihKoeYuJlAmSVmBRRpTZMhZTBWIK9VJVUUFkQehjEAQiCirMzPkIRJKnqaikG6vW9SGjqrGa1eIC/VY/xz7dqJZTDKoiYswORUAgRnEeBVAUgBgdVr5KejAgoUV/oMmgxmYBgKxXlyjnxsAFqmwrdp2pQTBlSje2N658drYbl0FC4YrGl0rExLNnz+7evfvs2bO9d94UEYmp3TwRzWaz/f39cvMrBUd81Urw+NRHVyH79vKCEaNEKwG9mC/6rjs8OEJBUgbkiKAhOhJQJcSIImuxmdEkJFH1TAhgvYOSNweBMFlIECCGKAACos5BshiiqvI6MdakZZuP2kK9ENOBKWFqgG5zKJJPkdcKsd/mA+PdKFS/DLuyWCw2GIJmpNQsqiEioBhTtMc6QKFU0oIBNIpoEAcOnWdm7wuSUpbdBaGPQ5CUlUtKKhrRRfHqlGvHzmUkkG1xf+ugN0lfcQhs06+8OVSWVjbQYPr58+d37941UzioEmFVVQDAzCW63jx325O5YnzpCJCOdoPMR9hwBasKIEQNCBBJmFmGEIbOES8XCwS8/+l9q9CMjBKjWe+LEbA8LcFccgmrXaKUeACQgw2ZmAwE3VrfZkwWSVBJzWrLMyVhlSCgJqXdlqYRNKrCMIiIkR/7ir223y3Jn8X3tLFFsGXctG8Z9Nsyxw6s0YSzJEOoiDFGE4UF1SF6JiIL7vfMqSycpQCPsxxtBxwi1rX0Xfk5IpJhUEAVIzHZwpP8Cy9R5Aqea5aCVtLUaFymDNi/BtPn5+e28BACIyDSMHS2nLZtu66bTqdxCJfxFtiFpXAFAlyxsCvG1artS35LwfvKnDfWDWC5XFpahvf+/PycCGMhFbsmaSQZs7uJs60zGy6IUHNCDDkkBUiJMkg5ISYjQJTiio0ioEqmYSuIAQECEqqkeOkgUXJdEHPW2NyYuSCeHUApiDBmFJDXVcR6u7hcLgv0Sw4mh+xrg3UhHlP7MiQHoChY5K5Vwrvt53g+mH29NhmDp77vx7IWYHLD65Yza/sw7QMYyUuXnvj6GFP9MVFAROechYguFov5fL4/nTjm5XI5nU5tk2ezWV3XulK1ISNpEcMSdJhgVrI5rxkL9OWOsnKrjhSGIcQ4DAMAOOeapgE7MJMODYAAxztFFrEPo1IRAICoUS0TPpk7UJ1zSOTYJQ6QS+XASkgFANCRwKrRNNSk16GIaYKSEk0QRQVEAUEFS5g+c6KZER1SzMJPmfOGB2d83S7O5/NyXURS9UxQHeFMOT7M3l9SJHKZ+SQ0I0y1T7zz5roeQ7NmOSo/R82iZbpHDjDR7AwexYK+bIynV1iBbDXdKh9lU7ZdSd27zaQ3DOHBg4d3bt08n819VR23U08+9hEdAkDt6tjHynsJ6itn1rw1FSQDxfq/XxNH2IhO2JkRs6pOJhOrEJ8IHFMIYdyjClZAcKnMh7kcNBG5EqVPyQ+7giFSVErSlGiKpBvXvYkG4ioAoBApVfc0zIOoQqhBkZWVy4oo9/8hRMFVJjjsQgB7TURF6y3Qv/IGIOgoDWCNA1gpc0JmqhwxWxFcX8h8agebEWAs+I1Zt/fe9BkAqOu673sAUgR27L0nIrgs+1S34C1jimbFt0xm/IvltfEbZme4JpLKrxsMfPzxx/fu3pnPFzdvHFvRXDNDI2LbtmdnZ3VViwYRAbxuisyfBwEKyS9X1qBZFYmsUZSqWo1sEbE4WBWlYvRUAbHaz6IbhV/IQYgI4oCcZ++IHQEDEjASwUpZTFMiJlOhkgWliP6IClFzkQMFUlCJpJYaqwoqYsYlBgCJsnHqdpBCaO2uV+A4GgUB7F8zR5q8NNaGY4wW7Vygf7ylDIQIdV17Z6nP3tR9osQNUpkMMCVyTRCXcY/xEFUEU6oAOCLRwIANoydgBopqdrCiF8Eq716BBGFsMdux2Cuu6HqqoP0bY/Ten5yczGdz52hvb+/5k6em20BmIEY4nHMxCruvHwKsYzxAWnZZOQJAiJFcSlhXVcNvsws1TRPEonCtLSSaR0p1DQ4Kb5XR7yKgI6ZS7wFhDG3pHs3l43D1RQM+siAYEQmRiCUM9gwDTGMnBjsmKbkRYZZVFmj+8RFngBEtKOyo6zojwNsWITTl2/RCUczRbMY2HREzekeemQgdgXPkHWcvragSWNsMRcgSRmoUhYjJKKQaIqkqIKEisWIAqx2hgDmLAC6BY1UFUbwGAdZdKqltgi1fM5aWbWTm2Xze9Qu7Z29vzwiEUYqqqpbL5f7enjPh83rjC0YAzTafJJKo2eG3dionTK1E9hT6kSj92Ic6mUwAwHqdG0GkHHi8Ehxwy+KW32MORFMLhCQLy9zcfbuNwGBMUREwxb1EokgEMQogijqViOhUA+AgURCyPdQkk5Vsk2h/BmDKjEVy8muBpEL2xsFwYzcwZLU1qkDyZrBtAZa6bt5XDA6VURy7qjJZsiAJARjdAKsYk/LvjOdKrhygACNHmRkJUFc8BzG1JNjpCUBzESSxdEccxPhfWMcizGYi26+xgGoviGi5WLST+uTkpGkaGbnVVdUUZbNcbZ/vZeNL4QBJARmNza1CgNx2YSz+MjM6RMT5fG4fdV3HzE3TXFzMRxu3gv0VDG3+ZLJkE5FVfUjiTKoiusadEwdQIAdExKCIROQzByAA8EQREKI4UIhRQmQi03gx5+VrzlQGVEQBjaAIEBEINEDiDXy5G8jA1HwR6YFlmRt0JJnw80g1Zgi8o8qn1B3L8SmsxjK5gsRc2sfIMCCQ1YRHRVUhIpSQPy3qAeYzyqL8lTbQraXtyI8Z/1sWOL5z44WIvHjxoqrvPH/+/J233r44P6dcZK2u6+VyWVUVMomqscbr1Pz5ivwAW1fX3iGiSTLENMTk5zcUn8/nRi9LKzXMCYcZODZ9jeWN/Qxnu0WOsEp/Y+iHpCsjM3pOVn7CiAAovhvIATmNETBgNCYvpIDKmoxChGixSKiCpIhC6JJRVBBg8+Avo09GyUp79CJK7dxJHI2EBgTOWZKCFTnkMZ4TiAI6YhBM7gyixEYANWV6JeKQTIir2IqxtAaIuIsBbK5lux78hrhfVrFzaTBiHfZ2EPG+QnK+rmiWbFnDMNiajXt479dr5181vrRo0PKKkmB52Z2YgqUUAGIImsM/jPbv7e0hoqVIQ5YLY8w+qnVUKgIDAoIKFTazotAkqGoGU1HHhAhExES+qonUYyCJwESo7ITJkxKRDKQahAkJOcZA+WTRtA5V0whRbT0I6c3axDIxXoHsGLLRUCkL9JILBo4RVczljavHUi5tm5gAr7JwVFUk10bPAg6CAjIhEpCCEBKhlYQAURDLMwehFAdFqiGXhl+LAUEg0G1bkCl1mfIqwSgNaFvo38kNilAwDIOF/uso6OPi4uLk5KTv+9lsZpUjSkpAiZG23b1aBCqT+dI4wOjXd7IAqzGpBVOR1bzZiMMwiGrdNBfzWYxxiKFuG+fbZvJ8Pp8rCBBGwQiquBJXwyBmoct7nToIyEjEgoSJqUiPqLpcH9x77wgrXxFZSUUQiFExqoAjdq4ZcBgGiNFXFHp1QiGsRfARIpCZWjbltMLWNWVrrVG4YpXHXITCkp4KQFAuJ2jOkCLsjflDfpHABUxngOKstWkkGR0QFEwQiggAMZACRLEA5yBGR1CiRfNFERWrwGrMUpFGnchwyzFQOPNY1sd1KW6M/BufbqwLipbvnIgsu46IhmHYn0z7frDyxkn0V9WUW3zdkodfaEbYyBAs1ukx6aGw7oaDLOaqFV8A0YhREUQFFKyNTxQxeQAR27Z98fzcTON5c9a8AeU1JqWuOCJh3NsZtsgMObaMeO89EwJBgEhEubAPg4JojEM/wBLYgyMPUWGw6AeVVJKAJS0Zk42pxGHoii+NCP/4daFwBRkAwHvf9125UlzLiJCT4YAUHBKosACJelFGVKFBVIRVhV0thIAMSAQsMYpGsNISKgoQIohEDYIqqhAVZGXcVBErBFkWkjheYghXA4OanLnb2rNxdmNWkHnXKrJNR0bbvu/Pz85PT08PD/Zob7/reubKyL+ZSQw3roi22Pj1LwwBFCCutSeEMbO2d5rFzdXFRK4BiVSkLEOiiJowJ13XTSaT87PFFWx0JViPbPCQvcUAyX0K2QIrycWCXmSAMCzC+fnZou/ni3lQRSImBmJHfjKdtm3tHKIyMwkFYmpSIkJ0EoNEs+4wpVRli6AcE+ZCz2wCjhgJc4TSivKJmIc+2XxKICTluEjJMZKrtMkYkQAZALGPgYFrV9VNZQoAEJFzyE4VLObVbMAACmKtpIJqVEhFT6OyFaALMYpiHFdc1UTfENHCChFTtrHkWCzbaTsE1U3oX51RfrsTMTa4QREF8/7gEIbSOhKRQkjxPyb9O+eWy6XzHsph25xl9RoANAWuf7V+gO2LyZIFYC0fl8slABjS13XNzOfn50MekM38qqorLeDS56sqIRVzKQKolZDOFTZjjBcXF6enpw8ePIgS+xC6GKNiFAHRSJGUAdERV7WftAeH+wdv3r55Y2+vrjx68SCxRxUCjMyqYKqBxZrquGKjIYAj8ikQj5gZeDMqzm6LUXIyjS8IgDlvpmyaiDATm6GnqnzlkFBFLpb98/OZ0YIhhCBxur93eHg4aVomdJ41CkQLrIggMcQgIYJoiFGjxcZa6SwUAFVBFTNNMTEmb65t744jHl9UVaI1waZcv+y8CqXQHARarMOYLcv9MJyeniNQBGVeudUtdiN12A4B2WeSlyzsph1tgM2foTgu5JNOtnxJShgAhBDquh5TzRDC0dGRRQJiloZf+VfzHgFYHIEikoT44vTk2YsXAuBcTUzDxQV5Two+fTFGdApo7sZm7yAAPXz87NNP7h/stbdv3zo4mLgKL87OQRCJrQYLqKAKWSRFMqcUk3/S1VJ3OudpFNRZjpmTfV9NNou5qbrdOQ6kcZX33ru6Xvbdpx8/+OjTT+eLmcZUQpSJrUcKV+wc1943TV3X1dtv3jvY22/rpvIuRpUgcRCRCAIYe9sdUQXkFQIgFtqfVmROHMTMxct2JzcLKBCatSEX4VG0Jt9jljhGg/GVohtk7WjF/EMIDx8+PD8/b9raVfX4Bvt6KTS0zngTs9pAvC8MARAAdTMYZHuMlZ6yYCJCBREx6E9+ogzu7XR6dnEhIs75fgg58n9btVbAlNEIuTN2xdj4yldOMJWDgmxRnZ1fzJaLCFjVtWOOMaqCdy7Gki1FQFziZ27duuGdgxAvzs+Ww/DJoye3wvG94+PDad13cYgaQYkIFEEg5zevECCb6oEIckwyMbsC62UZzrFNEgDMDAI5QMgE3CS8OkdEUeSzTz756NP7F7NFvTeppwcqqiJseVWKQoCE0722rlyIYdHH3/zuDxCldtWkbW7eunXz+FiGoKqgWiVJFZCQEJhIiSIIxgGEBYF8hY4QOcbBrAyaekVC2bQEiCsBpIzdHbbXoGjLLrSBAAYefd+fnJ6+ce9u13UWnlTogikAIkKjtJgiG2+zna86FojWA9nLUFBkYiM+Co2vSAARI4KAzrtlF6OrapkvMOnUO/bR0MKiYG3BJh2wYzBLRs7onc1mZxfnQYSdTy3imHEUooyICBKBFElEvvnNb/53//bfMtNHH33kmmo5m89ms88+eyx9/86dW3XjoI8SBrOBErOhp0AqSWInR6uROhXgaDfKYTOziAXBCxFVVTUW/4zL21j23ceffvrZg8edqGta4ippPYBAZCVKhmFAprsHx/uHBzGG0PUyhMVi1nXd8/nyyUcftvc/m1bNjYPD6XQ6SLSDUVDL+ifvREFjJCYSJdOOcr3Eax35OmkcSyBjsl1eYFaCddQ8xg6uNBbo+/7kxYmhhPfeXGDFVsavUiz6ugiwisG86h5TfFEuccKNt2xj5WDsSa0MoQ7D0NQ1AkqUuq6rKiVziAibGLrr8Ru/xYCV95XzjCjR2sdoCGE+n1uWCRGZlYmITOWgUWg0AkQFi8v45je/eXh0xMz/8keHJycn7/7614zUkHv4+MUQ9LvfeqeixTAPaGF2EhEJVMfd6YgIQDBVy0JmZsfOVWC5MmY0QwBUYlK0vB/RbD6Kuf+AZwRmciyInz98+OzkTFwlIXpfAwKzC0OnilHVOzabPXv3zje+EUKIGmMbZqfnlQYkUoTlIorI6dnp4vyiadu9vWnbtoigoE6jU+c1MrMDAlBG8t7Xde1ch9QjIkk2Ql8JO1ogAzDrxzs8X7BeRk5HOTRF+rV/5/O5dUy0nh0FWwDArKUbgv4OWNEkLTi5CqRff7x0Btu32TodkYko2LSaoynrppnPH1qDNEMA2W1XHqtg0Ttf+8qx1cgNZlct+rRnpwjEbOLspG2bptEctWtPZiTv6ebNm9/73vcAIEZl52/duvXf/psf//Hddz/75H49aR+/OCGH33zj9uHeXtd1KpHIiUgIQUXYoSMkHAgYiVWFvAPHrq6rqjJaFSOFgICqIICsit4sPxRNQYLsBRMRARGRtm3f//Cjhw8fkq+ICEks4oOQiHwUAQRBIlHn3F/+4C//xT//56K6WC6eP3/2wlXn5zyfz5EQQeOyI2YFXPZddzK0XcfMzpMPvq4qqJuoSqQk4ohYyRFTCi68LCAoDREZlwMHMJPqDtpodH2880U8LnxgfPOiWwYJs/ncTQ+y6zdZyYyKxRg3uICpJSPES1P/okWgZGfLdYDWcV2zPjoeY/HOmtwZ0ENuTlEymGrfEKX+t1dy3+RucM75yjtHUYRyzrHJ1kRkE2FCVUFkkHiwN50vFjGCAgqCanTkPLgf/vBfTNoD1eiRGldJiFBN9qZHk8lJH4N4fP74EYXw3Xe+eTjdt+JFi8WC0CEDkaZigrmuDiK61IvRGQKM1T4ikhw1HQDEylgAKwIIgiCA84gnJycfvPd+NWl9Uzd77ZMXL1TVe08Ilas67XMEkB4eHPzwhz/0zALg9w9q5ya+fvqEn4pKiINjJXLsNIqqRpXz2YX3vpbaCloQc+W9bSkmz7f1GkRHPGjAdTYOmXmOlb0MGQAAqUqHpHiTMUSa7CqpsHay+Y6Fw4wJqCoRZLFYHE4PLErAHMDFUrIBZrorKMPGl9slclvmGVuByvUySMGiHBBRVELXIUDbtsvlsmmaxWy5S7zLVCjpOUqoEGPFzjNXpAzWEQgwRtBAoI6QHGOVKkOpqnNEILePjy6q6tmLF1GBAYGoqZpvfvM733jrnW5+4X0VKfa9xiEMy+7o6KDr7g7ShbgchuHJkydHe/vvvHGPmS2IAwAQgR24ZO7PhaWIqspTLl1YhpHAEEIIq2j4YvKHElsK6pnf/+Mf27ZFoqaqbt5+o51MP/v8oaY2R1B7rxJUxTn343/z4729vRACEomIZ3fj+BhjgCjdfFH5SqvoFIFUQEupoWEYDOIdkyMG5xCYmDEEBLDqWIQIgrqzuHIuFa8KMGrZDZADJYubcsMkmj8qjrBcZGkEJEQKYIFx79x7u3w9hGA2gxIpvKlnbmMF4hcdDr3+9PGvljPe/IqmmiW2p1FEEVxdIVNcLFmh2d8DUVAJsa9q1/e9Zetu7jyaNU4tnoUAHVmXEyFrgA6AIr725DjGiABMKQiCmb3z3ru6qrx3ZxfnIcbDw4M37tz71re+F5cLZe6WXTudnM/mpKqi0+nk1s2b56cvZmcnSnTRhffee//W4dGtW7eKPBolEgkxeu8otyAaF88y5jZW3ZgZkUtCVhwVuhERIGKEs5OTFCcj4oBq77/x1tueq88+u68avfMK2kfxjv/7/9t/f/v2LQnRRBYiBJHa09G0YTlqCS4uLmbnF6o6DH237Lqu6ykQk688AXokB1J7QnZA3jFVQ2BCE3/AhHpYO+UdIHGl/2ts4dn+CEZSQxECrfoDADx58gS2kpthnexeMfCLcoTp+JXty2gBqw/zGF8BgLE9U0CHEAw45sslRIkhiMh0On3+9KSu6zElKAtJU8gXCFCjAEHjK8+u8hUSAZNbWSQllfgDZCJHXDvvnPPOs3OTtr1751aIcTqZHOwfatcRuX52wUSn8xkTqwgggqp3/IO/+N6/+Mvvo4jz1e9/+9uHDx/t7x8QsfeViBATYmRGZibkuq4hm3cL+adcOLGIsCVYqJzTKrYnRgRW1R/96EfTyf4gYiiFhHeOv/3979z76JPPX5y8ANV2cnzv3r2bh3txWCioRx8hImIcwmw+i4u5Dj2Besa9vbaqKqu6YlSoy3UXVcQ5ZCQmdt4LQUq7WRm0Nqvr71RwNz4qAL0BDInSw5pRvzytuP/szsePH9dvvnVycnL79s2RZ5DHlSTXngxa/Nbjaazpy9dEHQO23Sb/jACvrVlz7gMQQqBo4fx448aNzz79vIRGr6FWcblalKfpWUTeOc/Op8hgRiKlwOxVfA4tRKsNUVeVc46RBFQlhmFAUEYIi8UsaqyHpmoHEeMV0RKrUmVxDxLjEM7PThRoMZvbjCQ5HJQIidiy59kRETkrTIIpR7HgQKH0AIC4qgkFyZ9Kdo8iatA33nij67rlok9ZnKoOuWLn2+mP/tn3m7YxGFEVQVRFGXoFHPqwmC/CMHhU6XuIcW/SHuxNAVINDhFRBfYeAER16LvQD4DinenZjAiM5J2rmLLUttunuwktu/jDThGlgGb5RrH8FEOQiNR19fTp02++/c7njz6/e/e2qlZVNZvNOBfEzkcweiakPVllqwjAV+kHuIJLllFiwlS167pp3cYQ5/P5ZDLZ39978OBRecg6kqdrlK1sTOy9Z+/YOUfW3Y0AnYAoKrADhaiigBW7qqqaqt5rJ1aIL4ShHzoAUI1tVXlHEAYEhagWdhIlLodhuVgu+wFAmKiqKmb8xjtvzWYXFxfn5Ek5IoJznggpxTohIjjvLgOWogmoKuKKRegoFMzsfAf7+wBwdnpxfnFhleJQNAWmUhSUiEDehTCEqE0zOTg4DkH6Qeu9SQgCcRBCABURhcjEqj6GymKt0VpVIwxdP3RdhAhKqBoVFdA58lZeA5NPYMioe/X56po2vBvu02tIKQkrvTmVIiCjKaoSY3ToYoxPnj2p69pqohj5pxI7+FJoA4DXRoCrafx1YB12MUHIoh4ihhCii8w0DKFpmqZpDLmLfHzZXAjQMVfeO+8dO2bybH0ukJyT3NbLCB0ze3YMGIaBfEWqDqCdtIgOVFRUgpi2McRgodUxxr7v+75XNMIcYkTn6iTfmwsaMLu5zNuQMrZMAciUPkkSRYQtDMFshZgdc6XmXFSViF3X1XU9mUyWXdctuxhjWPZDVSEiuSFKXzU1sE5q76pagWPoJ810r52IhCEE6bseNIYemBCrGKOCUo4fVo1IagZcVCfoSElVQ4QgYlEcnsmZVV6BLL5UJfekSjFCaVGQ5dNi8EGLnCvGjE18WCkVCjQKFixGITPlecaLi4sbN4/Pz88hO4Ctcoyqeu93geDmb8HXpyyKDR2Vhgwh9EOvCiEMjZ84x4f7B8v5ghRMDrb69IClIC5GEEZEVOd40jSV49pz5bhmZmYAIaJBNIokRhiTbzhoQABCAlRHCKIRokoEBRUq0ThD11uYfsrcJbQ4akSMMQxDT0TsUFGRwDlOQfwMnNqPpQJ1uD5o1EbAllLaGY05gKo650KMMcb5fK6S3Hydah/62C0RkUJg57rFEvree1+3EhURfLfoPbMqhBAIJQ49qghACAMkyVEQSFGIACU6xKjCjggdogaJQICRvWNfsXNIoGiF+hRARUFW0e87bKCvBgNF8C/e38Ib81EjEs5ms8lk8vTp0zfffFNEqqoqBfQRMffFwatn8jVCACN4ts6UAkYYQwh97/b3fV01dS1Jxdn5fVVRBSTCuq7rxntPlXPes+ekeRIRiFKMaiVvSUVSsx8RicMQQQaNoGIiLwEB0NAb1MVSrSQF6jjvnKtSBi4hKZqS7QhJmUmEAMDSEldhZOutGwugb1yBbN+ATBe89ynUJgSROIReRH1tPEdEJcYoQU5fnBmm1VUlfSDnEAh91SUCHQRBoiiAxJiy3RERkRkQGV2yt4KxTSAk1QjAhEOqq+e9d+wc0apr9/WUvssAcdtSZA/F9XJa491QcIvFwjtvCND3fdM0ZgaNMbZta+W0XjqlqxBAd75+2TOvln+uEBY1e4K6rlssFnVdLxaLGON0Ol0sFm321F72K0kSQkUkX/mmaWrPPje+8xYahVghDoiGAGB+CVHKuezmxdMYNRvjVSkMwXQvYiR2zOwiE5GvqrqunaPivCMi7xkJFRVAUgXe1ZztR8aWPogCIhoEgoAIKpAZhUEt9c26ngEjAwESc+WUhr7v1IlQRGJ2oFZNgsDqhMcYJYoBNzlF5DjUCcYglDR5UEV043gQAEBSRHRmKUYEZCRVAFVkBuecZ1dXvqibKAgKhBR3ZEhunu9IDShXdt6Q3m6csuS0OGPhFxcXT54+bV2lKYBKzFTQ9/1lz9weawhg+tc10ObyoS/Xh64Ylg5vNNIyY0ywfvH8mQUCWe2XjeeXt6TCio6pcVw5zw4cIzN7R0zFn4LApJLynpgZBKzKVVSg5E1QCZqfnNASEZESoFdVhQS+quu6RgIxcyQhu8pVHkBAAiKnApQICITKnlsEp0qCjMBBEASsx1OMoqm7X6poWVQFGwnaHGBEsWwB5BAMSNTEMES07uxmKWci71k1qkSJVsuIAFWj9cVEZkfsccSRAIBSF/EctoisEJ1zoKgijtk5Vznvmcmwhwhzv9SNQ9mAZsgWrXV4WU+QGn9rpEtojgsybm0doKvKI7MyPXr29MbxMQM44vnFLFuBts1TO8Dyy/UEv+pFZrZgta7rDg4O+r5/dnY+2d8bhqFqG8m1ly/7YVNqawsBQnCe2LHjVA7awB2JRTQqAlgGZk5iVGUAiErASk4diCoIxBirKouhCKbUIgM5JEbkFC0NOYfLfPUpWlsRIPWuAQXK0FmsOuVQN5ZSYL8cIaXSRkoMqOScgyglaKIQPyFeWY1ECUkz9Bjq4ihegJktsqGQf2ZmAmaCXAhIkBUJQgBAFWJO6oz33jvXDQERcwj1VeeLaTtyv3hcwf0mkVZLM0gNDxVWoZWZJyAYlxN6/PjxW/fe/Oyzz27dvFlWQUR937OvLgWV0fgz6AA7aUN5YWUx27YNISwWC0tGiTEi4NHR0f3790WscmeiDwQAAoTW5J0ax3vNpKoqQqqJPXNFzgGBKDORI+ecgmkaqGqFB9POighaIgGz2FvFUmUWAIAMmEBRkMGAgcYBpLmea3JsJ/6BBMhIG2EzYwE3sXULuclWwDJGJFkAWFRZRNUJW/5WahoHAIwJjg2rmVk0jOkuk99WQgo+ICIz8soYr6CgRM55FIg0OGJH6BxXlSNONdIJkZQh6cEKl4gcOS0GLFf4mqCyze2tPqCFnDx79uz2jZveuZOTk2nTNnXdNI3FatPL67YAbCPAn+LDuubAsUavSTQ2mSeEMAx93dbMvFgsokbyvFwuqsqLhK6fhRCMaFmHSFVVAQJgJImBESrn27apqopdauLLxKrAiGisgMkKnwPQuHpMokyiDilFZKhq1DX9LCmyqihAaoldWVXYFFpWm1mUMUTr4GCGICPJktqBCRbkwLWjGzOBdAuThyTzBKtYVxylIUJ2JpoUxEiqalVCCAmQi18pIUApqZLWwgCaugkqqgYBQEwO7DRWQUywITK/Bvyk4mLp28BF8kx6ihZbEOWsIMgZwGdnZ1Vd37171yx1wzDEEBWhbdvy/DHB3VYJXpcDFLwcHxWkiMHUpW3zG2vVv1RT4ZwiA1gbLJFILq12GIa9yfTFixdt08yWi/Pzi7quuy6UYiqGQ5ZIoKpIVFVVVfnKkWNCQGsVmimoscgUfWByOzNbocVEyEXZSBqziCgnRTkDd/E5g9Iq3D8tfwsBgBCilVLAIvMksEG0EmtpK4pElANpTbRQKKrIig8QomLMX2GEAZQjDoisHFVVolAGTCzRtRkB1wSelXEWyxqxUGtAtnbVWcFFRCLk1f2voDBuAGL5Zm5ufRnnWPFnKPIeG3ApM1/MLs7Pz5u6FpFJ286GWT8M0+lURHSURJ5/YrXbBolupbrnudEr5txuj20ysCYOrifBlNg9GMWKquowDF3X3Tg6ns1mdw8PTs7Pum45nU7Oz2fRbhsJkSG3SauryrNzjonQpUYwuRJJBlfK3RohtU1fVeYBVAbM7fFWeeiQCDAV4iSwqq844gAGprKKTiIESQWigEy4YQR0SESWDLDer2591zbga4U+2d+5wqdo5aMBQAkJVNF4nlt/MK5S3jjlJtMYwdK/YItCWTnpoFh+LGDJWEouJLeiAtfjADvMirmidLqh8M9S2Ga1CoUYxdoUnry4uHtbT08vJu1eFGmnTXfS2+6FIWWKARR7mhihRMQICABuh+5yHfPpa41C/sdv0+IRIfHuZHVZLBZYEpxFLi4uqqpaxlAgJj8teQ1BFRW9c75yTOiZLKs1aXsZUBMiMBcN0jSKNBnUdKsIEjJyIRjZKqIAoioEgAhISmS2GwIARkAQ0Zi/ZTJ9GitCC+tUOS9ndMAKGZJkPY+7IIC9LeUSAEDQ+Fi0/k5onW8UAVCzVxVoLe0z/5Qh0ko1L8SFECWrNCtlOjfKKOWpdwLNZZhQwDpDd07gKDaz/JoUEUhxJT7kyRMhgVLfh/PzC+e8iPZ9H0LFjNZIxvLLQwhFT0NcsXpVtRZCbgMTLWpOAXCHWn+9MXIHll1b+3xdCxxfNBXTiqHPZrMbN270fb+3t2f+V7QALxEra7yxv4iIxHVde2+lQtgoduofh+ZfZABUDJCSbRLpKk4TJQKx0B0Stb6KK9KYAUMAcv/3wgHWy85kOmqAgQBgKYj2ewUfRux49UOGi/aPyGax/ETAcpKUajRGb3qwCIoSUHJMEaCVoigPLwao0WxxPMarSJAPtlfmH3BMzICMiKC2zxgGYoqiiACigIKY3MTblsj8ZCUd9QdZBw9cj4Aag8f4hVkFT05ORMS3LWaO3batlQ4o8k/5ImXOOQyD2e42OYAxni+JA5TFFA1Yc/OP3OsOYoyKYKEQdVXNLmbtdPLsxXMR6UOwnlyDqtXgMgO00S4AQMSmadgC7hFN+M9/BSah0OZCtTjXXQMgRCvfobxywBcjD+YcmlyokCzMbgz3KykTDASNgNFIBxgBNGxxQrNhw8hUIFvl1EsyIjEBAiFnYdJFGSQKmNC8qqKYdsDWYN/GVDY7h+XkBgoKENCpCBCqYlSMAFEtkw4ql4xFquqcI1p5nTbOeYMpZClxheSwKzdg4wUkHrW6rcSHEqFzrh+Gs7MzIjo+PAghlAoy5key+qE6qs2aa8+kaLmVEmxGuBXhev2Rafn60Y7Wk6iajrCTFEKeKLL5+4MZ9Ya+x5wQ7b0r/pGxYgS6Iqsg6itGxMKpy68TrtaW0WB96roSShBh3NMlI0A6uPyQ/PyVf0eLmSX9ipgRBiEXFSzWlI392dgrE+02mEN6jWDJoyBOMaIjFEER6xIHJCoDKgEKajpizXxQsz0HVmtdafD2IsmZhVSVDcxfLHbVLRK/uY6yyZiYbSb8JubpWqrumHZsL3xMEewwjAnMZjPv/WKxaCqXjbnJ7ymjTsO60VlZFS7LCFOAVCEWkrSB8PKaP+W7m1dGoVEWVDNm67YqNomaSJWjJH+wubV9lQpVtW3bSWf4qaorW5AmQmdloNFEOALCUgIfM8ppKW8PyQ6wJrSomv8onRDiauaQpKwsnqRDLU9btZ2DzGqJVk0Kjf4CICCJgmASzRGZkCUORKQhUoiYZWLAVSH4jS0VTNTaDDqFuBakEjDCjmMvEo3EQc3EnsfC1QgNVnxvhB6ZdSsCICFKht1Lw1t22HaSxTb/NGzB/QZSlZkUcpkiowCsjrx1ixGRIQyIvq6dxZIViZ9G9dRwJZYLAK9slWuFPREAQWkF9NdnCVegyTZOjxdmuGDI2nWdTdqUGMiBgUTk2EEmA5qAMi2PEAlS0gMjYm6OstPbCqNzHV8pRvGk6xXbNzMzO2dJUWUkuSKqCkBUDSoRMAJG0KBBICoheofsCJztLDqnNtmM/1aZQsX+EtCP7WPl7Heuosy8THVsq7dRzJ1jo2cZ43MZi3wbZ1fO2EzA28C6DQxy+czH5zK+Z+NmlPRHiiipR6DkrhExxg8//oSZBaAbhslkWkIqx3y4gFnhDPbwl/sBJOnm11UMsq9646KOqdTK3GnQE2M25KR0+OVyaWERzjmJqWxoXdfdvEv0I+2RwqhPiYJZBtdIy7rTJ5E0I72ZPqXdSdQCURFF1CFHI8RQdOh0P6+3+E0bZUL4qlefQjZulAkoYqbIGCVHOGbZQEeloERV1sm/jrRDHpWTgFHc6IhMUj60HWVIsOhDO45vE1LHdFdyNUtNKVbI6wVLRuK9bvQpGuGVFbYBAKBL2omNl7MxDVCDYAVIYeqnp6cnJyeqBxLdcHhERFVVWZ2Isthi/NFcaltVAV+KALkCpAC8Quex7cesb8RqVVY/JyNNoigKy+XSqpxKjF3XMdJ8Pj88OCTm5CAkBOBo8CoYCciKBUWtnWN2RKhBhAkRzCCEmKzXhvwZnrLFrdDFLBeZ0yjPPyGA9fmSXJo3rwsRVosaLzNpzYSWl4zIAGRGFFWwdraYUaQoIGWLZL0j6vYGluvjL6oqACcZca1uIYKx+i3Wt5p2fiHrnKeMqBp1UAVSK/NoBiH7xm6B7bKBJatyNP+NF2XJq4Wn3QCDEFUNIZyfn1feTydHiGgXTYTGUXv68pDctpD0Wp7g4ph/RQQonGB8imXlCe6NijBDFImxiMuzi7PDvelifkbACDD0vaiy81FFmWQIAKC5R4mKhU2JiCBS1iUkB7mthjkHTYzdAICy76Y5EKX2EvnTBIJMK8fwBiBCJnvl19BydMgmlbifidRAa8pEgf7Vl1W2Wnto+V0cpQ3AiMWPZkUiisBIa0QU80oKsuHGErY0Ts20f9yzNZVggSxQZT58fegvUzKnJkDxbGrm0zt0YpuiycO9Jf3Uddd1Dx48ODw8PD8/lzt3JXeWMFjn7PcsaL/KvLVOadccEVVArfNbBA353/GfZBtq0Sh0LZBVy+GVbR07g01FtpLIdd2EYXCVjyJDDG3bVpXvuq4YlzTZC/PWGFJBVg90JWLqqoXjWnlqGJHVYmqEzA0KTxhrAvm76UWxMpUDGy9qXNInaQxsorOAoqFigSdYvVbNRcFgl/SPowSRcn20Lgv6SGEOmQECIrAjJEACQEVKf0SGDpL/dDWTUY/uggA67kCTD3Q8t9XrSwSq8VtE1NxPILVvG43t744pjF3s+56ZHzx4MJlM5vO5JYWZ/MzOLbvOlmdW9qgaQZEJHEdFAX15FcW1GaxTzWt+s2zT+LQ2FrOifCJm24LUChsE9OLiHBG7rhuGocSlqCgk30emxyMmqWp93bPJNb1I+Q7bsDtGiXSKCsXGbyKQqppHXa2b9uikYjT4AEntg63MOKui957Jp0gMowhRVAIgWQduESFFkagiJBC1SEarOPgCLjBSbMpsN0BQE69IYXAAwNkltA21mxCpqqPGItu03/JuJbXGWT3HLFfXAQndkug25LGN6W1+CoCiIFpixsixADx9+rRyLAiVr4aoMer+XnN6elqrIKFC6vttPIEQBQH0VTjAq46yiWPot4uFNG4ImibenZ2dmRKj0aKSZTafO2YVscqemE14hiRanOs5f7wgQ9EsR6xGNoxCBYbSRQRAMGpNo3jPfOe4LvIKHDUDSh4pOxsRUzH08SlmCCiuylwPMD3aHmiktxDg7TG+Pt75MftaeQJTzXNCIERGSH+K6U+ABEhGEVblyVtUyjSipElvAOjGMlf/lr91TCFEti5OpleYXQPkqsdqltUyawKAJ0+eWKIw5XDRmLusj4lvkRKttM2XhQBjYg/rZKYw6/ERJsavCgDL5bJt22XXFRMQInLuF1/2DiG12sPcAjrEuOx7c6+kRG2QGAeRoBpjHGJUERABKRaYEY0Z4VWGmRF6bLCIDZCAzNaMFWR3RyzVTTIXUlW1ED2A1dOIiis6nZAR2tGjRERCHhui48ZMynMQEcAh+tGfQ3QIDEAApIqq6d/8NmH1+EfzXmEQiSKiEI3FUTJJF0WxTCCRebNGaaoren1b4gbMlCvji5oRwC6/ePGCiD/77LNSM3BDAbDvFh6YTOjXns8rjAJYY/oBW7szBsEIoKDRslnN1x0iuypInC0uYuxVVaIcHx/avSKgKcsbFDRoFJAg8ezigphTLtEuDpBH3JjbZfRmJ6BnipsJYqbWG6AJACXiMp9BQn7KWQEwElo2fnGbzI9513hKo9djoClIu/mHSOWPmbM/G1VBRGVQDdbcRUGCxmjm9iAyRAkisdSRS9Xsd4jRl9Lvl4HNhkS3DTY2CoPN0oTWdX3jxnHbtqWgmIwqqWz/nO3/l5ISuYGmsGUGHf9rlUFVNYICohFQMOqO0Pe9if5ty8vZYrFcqq5pIsVUo6qEOJvNzH4iopGhpBxkQosxWkg8au5CNSa928J0nnw5g7UljCGz/B9jRLRQLS45nKmW3P+/uTd9kiS57gN/77lHZFZWdff0DAcnQUAkJQiUzFZa037Yj7I127X9y2Um7ZookwStEQQEzABz9Ewf1VWVmRHh77398Nw9PCKzqo/pIelo5GRFxuHh/u7T5qfMYRSNHOWSG1UWD0spocyQiRBD6TMAZ+CqxlzlTAIZLBIxLID0VCw/JUYrAM5vnaeQuUFlCP6flGO3WHVdsOQcOjw0rGxha9fCOem/PW5WmmsRdV0nSTwq7tWrV1UC9Aqq1epfs2podsV+PxwACzJ5xpa8Il111ZzhenXlqaGmnvTNzMMwuEjtd3Y5Zd5Rov3x4EpB2ZfZWjLLDA01fYBH3beRtlToUdwCRQTKvMV9sgWF/M5GBA6kUNXkdR6amZAYmScaI0SKkSIpkZKJmqimJCmlNKpKzlXLcqM07+cKq5yVjk5fE+eROa+Mv4t4qYKUa8OkJGOaVNS8rarIanHeCBun55zO6q3uUDfX6Y7Zb377W6bw8tuXpa36fM+6L83OGr6nnOAW9NtJt0Bff2oBtOIDismCiFS067qui13XDcPQ9/1hn9Nf2uLEZqZq+8NhUukoJxaYziLH/FxyV0h2prbQbMVOUjyAlbv4CSpGqmoi5CZhhacUqyZo0jTKNIUQOu4Ch45jxyESB7f+mIYQYUZk3Sb2fT9ItlBxZlDs8BRCgJmpRxZXzdhUtb5wdQZzE1bNzBxgua1dDt07O9pXrpvi4E65AJ6qlWpIKbn9pDTsTKMkT17LdZrejejn557KBWitQ8jpca2I2H4xswhi0HA8xhiN8Ozbb371L355c3Pz+KOPQghJkxZzGTflVhsOYN+LCLQCqfoTLW1BaBhFK912Xee1B914dxyO/XableYCiwWY1Qps+cGU5G6/33ZXxqrEQPbHe/92eGUGeLRglhz86S4L1bU2M4c1zgW3fMZiSmbiSS8qJoXkW5ETmHm323FpQM8lkZeqTZYzkleCREQqMpsB3FDLHJncb6BK1bqlqqRn1PFZfstUgZ1CtlDVqhwr2tQaOikbpqyQ/mRm4zRNSaZpKh5MAnIAr8Fc71zoHwY3FsEMvJBk3PJFWKRbtNDygPqwoqG+IBGsqsPxeH1tIjJWb9KY9Umna+M4VtnBcmRr+F44QAv9dcZ1vyuHbV8Dbg4nSlPaXeyG434axzRNwzCYmlcgMLENRx0nqDCQje9QUmMLYsbgNMnr18ePH1/BkMygTAxSih65qEawKmo6DZifvmzR02iQFTSzlF4NcGg8oB6AvtvtPDLRkaHG5ZopvAo0sRINw6CKaRznJSrhfUxETJGDwiRHNQJASpOjfEWGlYm2cDn/KasRLdFpVY7TbaojpZxY7JI/jNysXs1BHihY/bdqomfbZNwvxz8MPA9nGtuShvpOGJCmZNv+xfUrZ3t93x+GQzX3VaofclsqKcjz/Yx2cdF0OqmY0J5pxTOgsMP+9tHFpR6nAB6H0cw2/ZYpsFGMXQBBlD0l141vRUOtL3lzc2P2CSqbUwWzOmBkB3GTCE3UFhpozDXZY61mQJUdnSln+1J9nbrEMcbtdlsD0LVEs2YodN6Skptmuy5BbRxH5EnV3IZMzgNzcAslw7wwaErqsKnqZQD5JC4/19cyYs6h9tZwtlbdate/voiIUPM9Je+fLbKKg8g3kUXC7juqv/eBjd+GSuTfKbRUl7xvmYoGopTSOI5Tmo77g2VfIYvkorlEVMMrm1vJ+yBAu44rQD+da13uVsipTEDnpZzRFICbb1MSLR3AibnrulInGTN19r+z9YSI6Xa/T2pmrDDfE08TyaS7MJ7qz9elnFBf0H/iEpyvqsj5GyWJ2DyXEmbm1Ym3223f91QS3LzufglR7vwaMlWjNAyazMwkTQQzMZi6CZiIeopmUDEii0xEHYOIaBwnSYlz9uM8bS1mLhFhuN+zyRaqgtYyJr4lpe2OUFEsneRXKciWAREAPGYVjZLUAoknWTndWMHxCk4aoTyDR6t9PcBD8pIiR6WrWhJxIDkejyHwOCQi6jiIaR/jOE0kSoGZg6riPcyg78rR0BQ+wBIr6g1boSiECGAYxq7rVMUp6JSSmbluwMyimZm4zQ9V8VADsN8fpkmkQ+4SCsBZEMxDlLRYaVbsiJsUrUrViLjOumrbHjJjy4jlvu89iikrjkZGykGJUtd1HrubVCkGAzEHkUONsS146Q5BCDy4VSuWe83+vu+lgH7lqJVSOg74vvrjWpRuv9Q1xwkHqAS++jTcq924w7LUAUeycyb201ElzHasgLtRY/LiqxkTpPicXRgNMCXj3IceTEYM714Mo6++fPbJJ5+4gXu73d68fBlcQRElDh0HESEvNKRK/MF7hJ3YFlbH6/fMbRvUV9VxHD2AZ5omL2uVDilwh0bYOIuAVANryVKaxmkS42DBIZZKORh/UlW7AVfPnDeoKRlxCLFcoiASmvPCHODJoEpqJKpJxDWEULpzOlymlCbJUQw+b89gijGSJqm59CFOqo631eYYA4lKQMlkCFHEZTNst5uUprujK3MEiLOXiskhBFjGnGrFWklB9bNuR11bVJG63FBVDcXTVwlBIQeqJWhVFVyZ5RmoWEC/AfCMjpqklo30GR6UAKhB4CFV/hb53gqjkhNS9fVqbPB+ind3d0+ePHF6VPHKiuOs9h219zCDrpavhel2TamxcrTHq+6LQofqTdzMf3GxNck6u1e2mKaJihFzRW+83bG7bRQghggGGQ/74eOrK/P65G5qgC+ssZGJwkOmRc3LYLJ5YVwlEM1hOTQbGSu9ny0a9a21IZn+UtM0OQIA0JS6rvPS1iGEWFpRgAJxMqMKat7A2JTAgYw0CQX2BAgt6W9d16XbG2buuqA6GwQrhDGIG9MQluS/zrn9rs1wHcChapxExCa1cZqSCmqMRkrJbEwyTTKpJBVzr15NU1qCxzoU6h64mre1aBNZym9E7grK7QvC4JLCbnfx6tWrcRw///zzjz/+2L1Gfs+KYNwUxsN38QPcR+Mr3J/9tY6KCS5tAil2nKY977q7wy13ZAdR1W2/eX3zaru9EBVGGCVpjt31BWJYTvalanFTurm9lU8+JjYORfU0s0xT8/uvyJJlKmKOLDUu2qGfcsKLwS0OJ/41FBLOpdF30rx/E1Hf99UoxAzmXKsdNKvLbmEkIu5iH2JHIxmYmacpm1PzlAg5ymWR5DF/KiyXxLWivWTSSRTMxJ28eQ4gSaZWpZ058nkS8b4ISbKTvr6viCaRaVJVfVDxtTfG/thSCspw4qzc1AmfiPBJUeSq4ahqQuq7DoCX0b+5uYmFE7kFQoudunQzyTFaKu+lBOMEoCtI1Z2oQ5fWBjSGIPH4YU2io5mQBTNRTdM0waGzrI6TP9W8PWDSSSwXRGw4DCCwGLrb/V0yIVvE+uWnY42ZrUpQFcr6WSumFAQAThK9Kxq42SR/NyKilFIsrd3mOoScPRpqkJRURc0kpckTfQJ3HJiojx0zx8Cbi02gwF1w1xTlqgeBiGtgT86IBgOkCiKlUqMtU0nD0n8MIlb1Pjh58j6s0QeyraGhu6o6qSZ/A5rTadqNqCtMNb6wHUtJyVyXO1V2Gz/uqQpRH0eln1AIYRynH/3oR8fj0a4uARwOBwCeG9nycydQzpPfBwFO6TrNAfdrVxcafDidvS+ES/Y1eFVVPKPD3e8xxpSmEDdu0wVBEwFBSa3kx6mqfxrQMR3HNGaDl2dKNu7DBgG0sf1XDa9ug5VqAgWAMgIQFhKgL6tXYhrHcRgm1ZQUYIqhY2YRU+JJx5zUT2xEyUxMTGu0M1JKx+OREDgGgoYQOqYYmJk3x433YkIpd+PCoVlVJhYG/ko1/HBLg9DIP6qiajCW3KNAqrVHSs6UZtMw10VSNVFMWZFhB+ZTqXgJMe8SBbocK8LabpA2zhYjwJNgVff7PccfGME3ZTgcN9sNykZTsYf6snxXDtCCe53rCvRXZy7fJKOBixUGeFZXhVfNxSAsibiRC0SWw3HXVIeIvOD//nAcx+mij1ZyePw8aiyGVXeskBRym0FquQEyiDsSFE+ZCSAKQSAk1Wwr1DQhTXp7OH7z8sV+fwDwi1/84smTJ8cpMUnuJcBsgBCSCqphUfJu3dzcXF9fv379ioDL7ebjpx89efLk8vKy+pWZOcb4+PHjOnlapkc2K6xF+DmzEYASsRlUJEkOva6agDVBTdYoDP7rlCRJrnaktYjnCdS+AzgpQKVsaVaKFvqkleTG1VPQ2ExTSkT87Nmz7XZ78+kn+/1+s9lMw0FVmTgV8uoKSc2o/AAcYIWg9afVErT2h6UuS6oauzAMo4j0XaeqoQujjI6pXR9VdRgn7/FqZhQiiQECBtlMD5AlGUxpOhwPjx5tMshCAErmuSBERKIWWcnLphsRKCDX3qpAv5zzidgDI8re6+PxeHd3Z0aBOxG5u7s7Hg5mFkL4u7/7u7/8y7/8+OOPzSxJ6f8OM27C4ERUMI7jt99+e319k1IKTFOatl18/fo1AId+J88hhI8++sia2hDt8i43yFYb1DIKy2YcU4Eu1OC1eVSaqlLjOIqIMYcYWKUsZynFWG7uB4Hc8wbI2dv3q8JcIV5VnW+Ti77Z3bwgsvfd59GjR8Nw7Pv+yy+/vH51/fHTp6rqrdfF1CsiorQycXfBh+gUfw76cYIY/mddXzR1REQ0dmGaJlUBMI7jo92jlFIXo0INUSyM6RhAmy4Oh2OMPBGYGQqpnVLyTU2BZOn2sP8kXQmFWKqf+xSyEcegBvJ6spRZB81goVQ69jX2h/II8lAddxLbOI7DOAzDIGJmwzgMKaWu6zpiEdlsNs+ePQsh7HY7Kmp/MjWC01vP/JpGub6+Til5bVOCbTZ910W3hrlpz8zGcXz8+LEb+FA09fb1Tyj9DPrWWHtcsPetUIFa4+UtQxvnDJlBdBgG0Vw6NTJHspFEba7TWJbnIb/VG0/waRfrjtVmj1WPaoFNa117QFX7vt/v77bbLZGN0wggxhhjHIbBrXdajMV+iby3Erx6pdX31vqmjTG08lYge9dFRSSFEI/HAYAjaxplE/ppHB9d7cxUrBQ0B3WhUxEOM5VaLhyISEXF7PbuVvQTpSAiHGokQtmD0quHQjbyM6BuU50171kDBlDN6uUEd85gPxyTqjGlSaZpGoYjM+8uLhTkwehVtMgeVhEVmUzV7eiSE+G7GGMIksyTrZhw0XdE1nWdu5N9s3/4wx8+efJkRaRtqbauSA8a1/uSDLGqtbaEFgdW9690l4igC93Du7G057wRZlanmVk94Ma8NdFZurTP3lNV3e4ZY3z14vkf//jHn/74J8zs/Wq59MjS7G/N1dbOIIA1KuPqOE7Qt12gs8dRuOfM8TPhq2sNy56vAGAcx93uIqkO45jMCWSKMZjZlFLf92ZzNFg7sbJOOV/09rBP3nnOsgrWvpQfmkXbUhBXzRjzu1QtueEDi3AJSa44ZqdejFG7TsfRYF6Zvus6b/fkoE9E7jpCCZ5xjFDVrvN9sg1nzqNmzCF5ptw4yjD89Kc/ffr4SY3pbdYzx6i1hMCWtGm1RwUHZgPxWaCvsFX3yy/38kbzktL8oLfBgROgcjA4BTkP9TJrmNjKq1BRl5mPx2NK0zRNBnv16pWDO4jENHLnBpVhGLRUGTR7x6oQWKJHK8/gBCLrzFYr66e093TocTp3d3t7sbkgIgPGYeQQVFRZmWkUSZKYObnSdCJlqaqVVN5hGMZpEok5X7jMEUUsMMv6U5b7mT2xBSV8fHV/s7L0RC5BqdmYhpSSl0jwUgOx69TDDD0bRiA6MdF4OBpT13Xm0bk+GyKBZOtWlk2pgrIWU6x/ubjY/eAHP+i6TkuzwDYToC6vzn6YRZTB6S6UTxjObNy8pM0+NlS/BJ8SKARri87OkPAGWag9AMx3dqu3lfTkzHNybZdi3aUlsqm5WPHo0aNXr15tLzbDMKBUQq81gqz47OvWv09GWEtm2pdp8VKXBoQlJDm6mxXPnC+rL7U0sb5JNZNVVY9eur6+9iiOFbLVL7Vi7jSl4zCU4779ddELuSGzEkJR5yaW/J9BvQ4aoGbLqA2wEompY4UrqUSuOITaPh7FbKLFz+Wtts0sJ5vImZTaKtTWL33f73a7n//i559++mnXdzW1ry332ebHFDBde4If3M/FaH9uX7y0+1bnobkK+0kJx3rp29ZUo5ybyMz1u+vRtbh9C+6tM77ip5bgmufPn3/05KPnz59/8803Ffy4JAf7QHVcvmFm7zJWUL6SO9vv+TWawCwt5d4dR13I0SYq0Fs3SxJVI4R6nxUSslfbIQxi+8NoEhJIxaCqMqqNmAszq5X6a9oEOdY1qg6jgihe3GBhcCx2Rmaa2wd1XVdbT7eFaNFExbYBxi0J1+KO9f3u+/7y8vLq6urHP/7xT3/608ePH4cYmXmz2Sxu3VDl8lx+m4oHp2S7/QRgREZkDCWjwMasgQAShpCoCUjJJs/ecja2BHeqHw/OY/HX/EbNladTxbxqM+qO49R1nQHM/Ju///uLiwvnmUS02Wzq/euyfyc/wIp2ohHUWnKykpQA2EwzzExgFoj3x8GMxDAlDdlfHf3tQBoiE9Gmv7i52xf/y4xO86eHUpoF4NX16+kHP9wGnjGu8JYZDwlaBZKlCKtmRbfz9wJyBvosGRMRc2B2wwJUQcRAIqJQ3HOVEqcco1Y1ojmu2BldKP38HAJijF3XPXny5OnTp48fP95d7FQVBo+2sKVNkEtJXZQQMSIveeJzqFXAoCpOzVGy3nXpKXP1IwvmBIMxM5gslc6NMFMTyQ2yiQJ0Wkrw9hZQfx6o2j9b6kaNGZ2KIu77VGuUicjFxcV+f/f8229/9tOfuLxwOBy0cdF6SkDlCe/pB1jNtX2B1afeHyXR/qmqgKkqB44xjsdhlp3IrCi+Thl4KXS288mBnCA1u769OYxjHzdWiviroOYGV/9uyaqZ76O5CZ+X4M1wVXhy1oxTSqrmbikzSPLOA6rVVAcqtLwANHGl7lbqowQOhOjqsnefZuY+dheXu93V1Wa76fu+7/vNZoPIk+YSIABAHisCoBQ9M3Lj7qnEcd+W+ajeDw9obRl1XZDVaptBsyPP0cCqVsZemDXP893QoIJ4VQlOfz17lTVBWUT04sXLv/mXv0zjJKU0kHfZqt+59Ml8BwSgpWGhffxqKu2E7GSgQQ8r5DClFDiIiJcirA0ymLnG92pRCdwx095nhWMgGPHt/nh7d7zabNh72rERB9S6fxkNSGHQnEVuLR8zyymGcGTLE8i2hSJyMHPgrusoJSUix9M8E5CIhZCrKZKBYcykpjBlc/YRY+ydQV9dXV1eXnZdt+l77mLc9F3XgajvulD6PamVgPBGzW1ZARG9ZY56ljKWBZrqerbqb2URXhTF1E3NliTDvk+o6h5vD1Qt5FTJxyxLNf7Kq9OWr7AQgM3s9vb24mJ3OBwAniS9uH71+PKqmjRExFvoXV1dORf9YKEQqz9XVGQl/beXuHNRZk81HY9HKl1u6snsKV1mIYZxSNX5cjoBXzUxM8Wr6+tPHu04BoNGqmFtLiwZAHjPTHjRZle6gsHgpXnIxBKDYFwLDJp3czGDBQICB+WpptjTMjHQ36AV082MjWs+Wt/3fb91a+mjR492u10MIcZoALki0awDEZGRma42fgUQdSlOT7ClXHG6Kfn4cr+q3pJlV4Iq1GqWxYfQJG3eaxjPkXzqLL3w9nNMwAotA3A8Hh89etT3/YsXL7ouvHz58tHu0koNqGmadrvd4XCQUi/x/UMhVotrxXBxjl0uztTGNeb51w79nvC12+W4ea9vDMD3mzkXeUzT9EbGqiqkxsDLV6/2P/qUQ+gDgcEknjkAJiACFCmCOEc8czBHAwJIAFPTUg13Jo2+Nx6Rb2YhzNlV2nSkQunY7qPlUVQadMfYdV2/3W632+1ut9vtdi4H+f4bM9Xu8E3IbbYAYgHHq61pJ7yaQ/2O7HU6owefQr9flE0HqtVYwEYwJKVaWdpf8eENOjfe45IF6Pv3mmX1+vr14ydX+/3eLW9cGmmmlLzyrCevnsfds8QDDxrUqvqL5Wav7rZiCykly0VMIxFJShFMMGIYySSjQgCN1HXUx34TLzYjW0KutNFupw8XmTxuH4TXdzeHw8F9sF7+28wsF6vEg8x6LRusQMdHDVCrJRDRFkMvYWp1eljmS8QY+76/uLh4/Pjx48ePPaXYjarZrLl84gpAW+i35UAjVOQnuvIKtyzW/jGLqKd2etYY8TyQx0uCqkBprohotrZwfIjx0A1XL96uDBq7s1dYm6ZJS8jgOI7uCHPnOuUU6ncfdcnQrP7KjGi2sAWhpr2bkZlMSWVSmZgMk2xDF4kgqknJe50zuZRZdhGu4A/D0CL9AyoRcwDRJPLq9WtVVcrOA81a2xn21RhDZsvDA9vQptuh0HXHBJSc3Wqhb1W0gjDEzF3fbTYbzyd2dCo5A7OZE6gg4Tnm8MAlLxCnJ2Sl1OwyI4gpmBRWoR9LdGq/r7C9vWezoQojUXUjkMCUzpCG5WLdt4ofeDhglNQ8PhwOX3/99UcffcTMNazQT7u6uoKTqvvudQphK7ZQgduj9n2D25CH1WkoQNMerNDsp7MnehYNrDpEReR4PO52F94+nho77umsqqmOmJRw/fr1MArgreFzVWSAHQ/U1vqf0zXgvBKPJq7Gz69MYEX4W6pfz89xGopg3MfNpuu7EL0Mu8cCdTEG5mwecnxg5qJKlCmQWa7H2PoT2tnqSQhWfjTy5wpY2xdEG2C3iDIqLNGsNPMrydPf57DCr9sj9ftpZMThcDCz28Oe4+bV9S2F7tsXrzYXl8MkFIOSCkRJBGJ8Tn1ZaWxoVufUQIYTBn3qBFjd/dTq3IpPPqowzaXT0+3trXMxbuoqt/eZUc6f4/yd6frm9u54BAUDmZIpmRFqQfATZ0KdKE4wVs1EkxqSeC6JqCWR0Qv/YBbuc8S5914hQyDuY+ewTkCksOk3FxcXu93u4uLCo4asdOH1/Z6FHwOwpiNVK9VmtMiwsmYiV9ImzPeeV56asVrP9qF1CmYmBrEc3tpu5Sk4fajBBtJiumik07nsEoCG8Q7TCOBwOE5TMrPdbucZP9UvlsO37nveDE9mdmJnXMF6e9V9YgkWizjfgape6Sb2MKdobfrewcL1mGmaQghVIFg9ev1EQAxEYUj66ub20ycfmSkHrz5A7i5i5J68WTqHR8IpwFCWXJjTkhhQinTynGGTk7VhgEs1eTI1UKcuiGtg7n+pR1zs6bqu7bta1BgjA1MjrzR70W7/bKAsIpYWX/LZ3TwddL/CVlZ68fRCCipnmKM5LAfM+jUtbX0rxDDLYQ8PmXFtvlnVqbQETVWJZhiGq8ePRORwPByOh6dPn5Z04durq4vC0EjviwZFQ/5xjzh0bl0WKmklVKtz6kEu9Up9RYlQFS8u0b8t7nnVaClmkHYmLVcxj/QABGAOIPv8T3/6weNHH19tRXKUv6l597gsUJhVKxuKgbVYSLJG4D5c8kgYj6QNIU9elZhCYHeNUXHNOjfImZAxusrrgO74DCCE0IXQx67jwCX9w4hApUHtygO6NKP5Fy38c6V3NYML7PhxqXtkDT+Z+YbfVgQCUoKSAqoQxTGlw+hxTYNByhZQU+3dl+hdHQLvdn6FE4+h9INayqi5IcFJ/m9/+9t/+ctfeudpP+LCRQjxPALUB6yAbHXclmM1s7oT1LQwyAobmUFBpElITd2+wDZBjcnJfA7Et1yEUERCDFl/H46q5lZRnNC2OjcUBOtivBuGZ8+fP7r4SYisquadvxRGlsG/Vv4BamEIJ0jW6AkuE9W1xvxoNct96epbt+qvg7tD/2632263FUkAaBIVPRwOjuFZKIqBiQRmTUeputQ5CKAAvavGBZSzaK6qTVO36ppdZgUUwalt7aGqUtKDaqRqSmkSTUmPw7A/HodRfFlK9nB2phf6/IHL7tuJZNEicFULK0n1P/f7/W67+f3v//A3v/qVO++ZgjZZNW9AgPrgU0xoCXkVHCusn4qSaBQyp6mqmiSZmRKCdxYiqehb7zxNk6iO49j3/bcvXmy327vDwVSBhXkeJ1hap6QAh/Ds+fM//9EP+xBFwMwIKNnIShbaCy0rwcX6Yi0mZvACch0FM4sxAmqWSb6V6A9PIJzLKQMxxu1mc3V1dXV5td1uNpuNGQ77/c3r2+FwPByOFQE22+1ut7u4uqRIquoim3O/AgqU0iSSQKYl1Wa1fY4UFVZWu1CXqMWH+biWAhIwY9IkOetf0nEck5GYqpkUDAyhLCjmBz0M028ab2YI1lTxaLVWF+7HYbjYXnRdd3N760bPw+Hw+PEjtalmft+LAPcBVkWGU5WgAPeaRdQb+uLqcsWryOgQ0/d9bQrmsLXf7w04Ho8fffSxazDmFApsJxC/Gk4SxIxDuD7sv335avejH5MQE3mkm1fXKxM1YN09uMzTgSNV9PCX6GKXxGAKNiI2BVRERJOoyO3xOE1TmpKIxhAjY7JxvDseb+5uNtfb7Xa72Q7DNB2HJCJWWuIlGYex7w93t3f9zevuws2jIXYxFyesti9IITcGmblR2Ro3+J639qwW7XQrjaFJVcTLt4zTlJKMkwxjGkZLCWIkYqIQMeboWVyNrP9eAREPXuFQQYCpca5ettbUfbjT1yaLV3232T5/+fIwHK92l7e3tyFEkyQiRJ5+xG8lAuEEwioatKabs5e0xBhA5dRElFLqOKhqKMFowdNfHHAL33ceTchquz9YRVvCdjq3Oh8iEjMGvnz29acfffxoc6FzVpEqoVZ6cPVLYWzecBvZ1ieTNUNzpWuWlJSS621c5Jk0TsPhcBzGwzAkUcoNmZiJusCR+XikcDh0fb/peoBlSsM0JkleGpeIOHDcBxBCF0MfLna7R48ebfreI/K6rqPAIBVJKgoYwVJahANxSSSgdRvsMwrbaqfyF4KYF56jKaUxTVOScZqOx+OYplHFivJLJaKoQYDv0RZ0evf6sj60Cb50KSiE8OzZs4uf/YV7glFi/pgDHgiHbiWf9s+zOLf68/Q0m2OqyAHaZ6M5JS/POMZ4PA7WuDP6vj/e3IQQDsfDxcXFixevmAhuqLlnBGTzHAEQ5RBgQOy+fX398vZVRxo67sPWhBHYSRd5mV0gx7FlfKyCxMK+LnlYEgMhBAZyeYQ0Tnf7/XF/OB5GRHdmcaBAZICOg3mAB8fIY+r7pKX1UBXBsxVITTx2mnR7cXF5ebnZbDxcIvW9I75nSqqKqlRDuatPKCq4NqHR7U6dIfntbgLT5L3wYGrHYUhJk2I/jHdTSl5JJSVTZahbVhUAOi/Mr4T0Afrv0goCT36GLjskYJFAAhdBu+4CwNdfP/vXf/OvhmEYhiF2TrgzBX8oFui+GSxIxTmUqN+rVlBXuZ2fedU7kHrtKqVIwZRkVAipYErGYTPpLYXudn8gCsfjMQAdhwkzizhRj9az9ehxU/3iq2ePt9sNxRjd4WaeglgJAwpbq2rMirpUlfFwHA/HgZk5cqCsVMk4jeM4HEeFMTjEXtXAwRM7BZOKJU02JiK6vd2j6eHj06haRDbVMW7SzWG/DzHGGHe73dWjR33GAa6ZPO7litFDKNzi1AFWG8jW4j0uzxm8Ii97fycAAeQUPWlKqiKjSDLwOE7eHOw4psMoo9g4TaaWJKkZczBae8HsO0C/nSi79/56ApjVckilAu4wDI8eXe73d8+fP3fjSkqp63t4tW2zhxCg6kPt422WZNY40CoAVhRzETGlUnpS3IxIRDGE4XgMoMhBRPxebGRGgVmLJTuEKCKuyYUQxjExc7ZLvN0iZwgmECj2F9++fHn96Z/9WfcRQKaQpIEieIHAqhq8figvEuHrC6aUhjRNKQ3D4FmrMWyc0I7jqCKwHCmpkxDgBQ8DccdMDCZ22CWDkcUQVcRoTlB2N4Irnb6uAkiaBkyH/bC/O2632y7GEKOZDdNxlBQsxMh9z9uLvu8joScoxZhNWk1QsZYAfjOFBbNctjHXxipNIH1Tpikdh2mSdBinu8NhHEcZJxVNkgD2CuyMICjC6vvGPJhZq38RUWW/OCFwGfacBjTyDzWlU0REWEjDOI5EdHNzc3Nzo6peoKDvc429vuvPJ8VXPfXsXFsrJxrob0dD+FuVd1YerFHh6509BkamcZqmGIKjgVfFiZFfvnyV/aymKgIspDJU9Fs2gEGRGtVIzb5+/u3jq6tu0i4GGFKSGAm8NHblio3F4bB8U6m9E1WSiJlO5GXNA0qKS0dxNDkOwzSOkpKaBTCH0IXQ9d2m62JkqBExGQQ0TNM0TbHrRG0YJ1+1aRiSiOeFhSIl3t7uD4chhBBjAHsnDmEOBN1uOw4gqoFScycVylXX2vooCvPLLRet8KKZJpMkMYPRJDIkOaZ0mMbjOI0pSUqmpmIKzaWvzEAMGBuksQS9PSrcR/VXpLY9TkRtUFPdmhZoxYRkEhGofvLJx189+/qvfv4Xh8Nhu926hzMgmLxvOHQ7rRYT/LMKJ6dDatFJs8Bssi4lHUIQouq2GMfRE/u32wvnYqXDxf0coITkF2RDpvdA4Pj81atPn1zHT3qmQIE1qRIChzZ1cLasedi/d0KBB37BmDQZBb7YXRyPLljup0kIoePOhXyzdEjjy1evCOAQ/L5MnGIUlWE4BiYASQSuhQRi5uM00JTJg2sFgZhUh9vbLnYxdh0FN0qNkwAA1VoSut10zjq0knAzF5YAtCkEhUrkXMgsi6pOKSXTMU1JhUDTNB2nSVSP43R3OI5SW2SY+xcK1BaYN6wrNbzbUDOCksE4eHAYr2C63ply6sXaElij8YuayylNXQjPnz9//fr1ZrP56quv3AGvJS/+HRDgPnpfaXk9p2riqNS0nKml9Ijponmgn+yTVtNpmkKM4zhq8e3d3d31fb/fX5NHB3FYGf7aL/We2cipFigSMbruMB6//Pb51ePHIYA4hkCTgtSIreS7dJzjjVACUrUyASqcN0aEEPq+H4b+9avXZraJPXOU5N0R0YG3HIkoMpHvGIxU03AUryURoxHGaWIiFjZmGErxD47Cw3FMALMeDvtj4IvdznoBUEFtHI8U+GK33W6uNv324mLbdY5uc8k0M2uFiMqNVdXDozPCqCSVpCIiBksmx2maUhrFDsfheDxOoCSiTt1y6IoTsmyBdUssFX/Yu441lJOnBp4JPmhFhsLrFvuuJSZCVcdx4h5ffvnlz372s2EYrq6uiOju7q7rut1uN47jm2OBHj5eKcrqyBIoF8iT5R+epaDTNxQRr7m52+1ijMfj0cxiDB5+C+SyVufNoAQlGHIogZnB1LsmqoJj9/Lm9utvv/nzH34agwbufA6RY44GokWSeH6d4qxw60oPCHsrRVC/6T752O3SZqTJzNy1lz66uPBUZga5M3icJhDEwzmnpKosoqJdiB69FwIzkQkB6BPUNOnxInSh6zrjTgnu6GGLXbe93D366MlHn3z06NHjQDylAZSQW/qRiHkLGSIAsy+5klVTrwAjKaUE7wqZxFRVhzSNabJEcjdNRzENkkRVJ00Scoq0oSQYlGX/7uNdGcjp+RWiWghMKX3yySe///3vf/zjH7uWfDwe+76P8aTvwNs8spVYcIISWiKTGglkPWNx+lRoiTXNDpiZA4+pep0KPjC75h5iCCHAa+y/1SDk8vNOOTnp9PU331ztuj4+jczMISVjVniDGKI57reEPNSwcSq5mpm+RjOjNIJAMfSBOubAHDomnVIAxRAgmqakKsNxOB4O4zgmB2GzyLzZbHYXu4t+0/f9pu/zEymQJ9j0nZjCbBOC+3WZ+Xg4juPh6snj7aOr7qID0zgMwzCOA8aRcrAGERnDmILnvphZ7rKcsgpHSZOajmlMIkmzejOpiMgwjtOUZMT+eJymyTumzgLJ92boL1A7x6tWPnYK6L791hhmKkmtMJlSou2GiK6vr4e78POf//x4PG42G0/sflsRqEL8StTBMr9p5q3lqiIvuY5vUiR+zdFXGkrN2vZBXJptha73UAIAwzBcXOxkriT1BvvsAi2Nc+ibGVMw7m+Ox6+ef7Pb9cyh70Jgyt1ZWNti42XLVdPcQTWEELhTS2bmNvhN3PhTYIih220uOFIH3nV9R4GZt13Xhe5wOOxvblVkMkmTjtPxYrvb9LHvNrf7OyIe07h7dDWMI4w6jimlLifx2K7vwqZ/fXMTiB5fXNrVjmPYbHtjkjSZTKZiWQjOUp/leCGzppR8shIpDVGzSWVKaUpJVJOaAt4FfhjHNKY04jAck+qUktnc7LDCnKo+UH2o0q+3gbHVhW9/VSNozDJqlYK8sSwC/+f/8rf/9//1f3IXZb8PIQzDEGLsz5ZHv+/ZtPT74kFt+OzL1+Na4lH9gJQMZWtj4otVa7PZfPPNN54xrN5IL9uxFzXnVityskxgJlUzmCII6OXt3TcvX237HYfO/WElFD/rwGisYUzL7SS3ZnrhnVxPV1VhAYyDpD7GyIE4Roodd2w6HY4bCuFiF0I4DMf4JIzj+JOf/OTly5dd1/3VX/7lixcvHn305MWrl6MkIu677unjJ/v9/sXz52Z2OI490HedjJOQxhj7i62ZqeaAHMfMCgotl87kBjaVbjRmJpjMKIkMUxKRqel6P45pHNIwTNMkCSYqCvOWtZ5NULeVmc8t9vuPc5Q+lyFqRX83gjO5835u/q6NKOGrkVK6ub292G3U7Pb2NqV0dXXluZFyHwc4C0D1pxWVXRHvSqErG2LmlJxyLNrmZauoOnNYsDzvRsHMx3HcbDaq6g1t7u72JSzCrW9vIBKNblTamsPEyBgcN4fx+MWz51eXT54+Ckmpi6GzaCLMoZZ4KEC/4LMA0DYpg6m5O9ZfDMx2HCbmKWrabK/UTBNIVSVN09TFGIjTOMk4ffWnL7qu/7Mf/Ojm1UsZhxffPPv4k48vr64O43g8DsSUpimA9oeDUe72bGYisu13xDxJUv+fZXNQVbG8Q7Kakld4lKLglhAGEERlSiJiSZHrdEsap2mapjSO05TGSSfRKUcB3gcVs8Qyg8n8E94mMuIeks+gRESkVJ5yr166ygurFNZ/PR6PMcbr6+vf/e53//pXf3N3d7fZbPq+I7snFOIeInrG/nP2zweQpNJ1K5VOWoGvNXuJiN9ApsmZrycEM7M4FYNLo1w1PGrym7AonK+5sD0AJDIGKFF4vR8++9MX8WfhYrslkNHoRJtW9L6581nOVjwS5kYRNQkah2nCNG2Iu9iRwNRYLPcLMyOgix0TD8fj73772y4ECmEcx8N+P6WJOLgkE5inaZqmKex2yUm1Stz0oyTbJ+o4SVKoWjJduu09U9EgqmY2TZNCzFsT5LhWmMED2tJkkjSJTpOkSaaUpjGlJKKaoEokxCmknA3ZLAgbm5ESBMYLQHdf1VngeqdBmMsNnRlmcxBLZXpcWuu5iisises8Mvf1zY2ZXV5e7vf70HeR7gmGW9mVfFQyUD9XX+RcIlI9x/lAJf8ADCbmbgFTU4WC7Tge0jT1fa+KmxcvNv2FmT7aXXXcHe+OkWIJmyEwm1Wj/2IJzixTEyvmTlCAQeHl9c2z3Ysf/eiHUUiJEWDTyOzFeAgNcbof+rOnycwxVgAICWDjqK9x03Vd5BARInFg0pQjxqu+5CGrNk1m5p4mmLh58pgmAAIc7+4g6gYuIhymkQNrEjU1MmODkrmFnqAEb/uVs3fVwB7/0MY8++9ZS0iSpjQmSaJuDk3Idd9yrTIwQZsiWB9W9HlwnC548Z8WKbpsUyubVXGoGlGur6/HcfSEmJTS4XDYbbYRS6kR90j2p+C+kMka6HdLhU4CNTZLKoDAFCZOz1CEZsA80Dg0VfXc4klE0zSOw+jHLy8vmXPF3BCCKJhJcmLkmzOyrXzWGUc1A4kZE77+9vnF1RU/utz1nZkpwVSAXPVtcZ9Vw+flphBRzuY1FncWke2nMUxpu9n0wYyDjuJpwdDaCB4o5NPMVAwEyfEUmjxIwWxSi12ngRJsSHtCIGEzZQITmExzq3RIEXXMMja6vm42b6WqqiY1E6GUZJo0JZVkaVJVSDIVp3f+yQatVnk6B/3fb/xnBtG1CNQixorz18ykMj1m5ufPX/7Zn4W7/Z6JOHAIPExDPDXDN49cj/bM1vZkjdBfblRSSPIyLoxF1ogTaIL4pBQacXbBYY4L8qAOj530SAiKQc27blkbFjG/dn0E18IdKFMzIkbokkyHcfrTF19t/uJnHYM4xBCYSETpHBu8jwnUZfO3BVEyVaPJBCSHSXnAZey3HHtwpFlvIyLNEYEwmEvqyUHfW2fAYDBG0nEYJwvEFlkDUWAyImTpl1vvu+TSdkRmKvA6STnkwfUo1aRKU9IklpKmJFMS8WZJIDFI0mQeZ6rulzJdkMUHxJIPhBAu3tQFpxa+iMh9ZQBinkkOfJpJsyf0qUFAwkaRKd7e3D55ckWMlCZVnWOBzsI3VkJLA15n9QEr9rf2qnr+Cp28nkirYJnnPYl4zvim74dhOE5jGsZhGNwKJCKSHCgicvrpO47K8QgAC+H69ubZ82/Jnl5t+k3M1X1EFZ6Ynhc624JaJlDXijkWg6+HeCdTniSjuk5jMMg4aegGzd19QSSm7voFYIDARCVJSiITzCPSKDARySheigdMMXWh7zoOIYQQ2UzZyBu4AvmL838tWWxF8DEPZc04YJaSTUlTyuZCzUJPKS2hYp4jYRm0TinC2fW9T1uti9ZaFCrIViqeo1JIicibRhaRZhH95VnIZzPobY40AwALmKbp5vXrv/pnv/jyqy+fPv3lbrt58fLlbrc7bwY9xQosMWRFy1fqwTxFkLtv2l/rVW08s694beHU973XmvVkNi9y7b/m5Vo2AG3ZEZaIulqX/DjKLmpwFLNA+OyrrwOH8PRxz1slMYA4UOmul6+e3S/zWp2ujBXWpzqjvaiZTorRazYqjENIDrWUW12qaRLxngVjtusThACYmMFAFBAk2SZQJC8hAYCEjGtcSeFvlV6W4L0F9DtfTUlFTAVmkOTty0pQhKqzkZVCW17W5TiAqLaya9ak/OlVPYG3dxS3DHz101ti4Io7+XYwUQxxmtKrV9fb7XZKyTu4xTfetAWmusG4H9oc/Q3Zv2uWl6A92bK9n7wyApYYEpgNSkzqLoLIFxe7lL4x86LopJFN4JoimoiRU7h/4O3aZRJjcPenZ99cbvvIuOg6DmBm4mLu4ABkMnh6q1bDbmYCbVqhQRWKlCYWU1VjU6aUtYbsXKgurEJ0YUkJucyWLxqBN8ydtw0OuX5ELhaKItrBDKaAO2/VLKl4L+7KYVREjcdJkgYv9zCpTapJZFKdCGMIZhIZbDSJO7wy60W2/2pbnuO7jNXqrcwPWPpbcbKt+czGMm7Vy1SM7CJyHI7Xr15tP/34xYsXF7vdbre7u7uLp7db7uICak9/ahXoxSegZFqq+JGah02Rmlc4IjIKXG+XVSvfRiIzrzDCZiYpkVJtYk5Eks50FlqNt6EWhZ+QEYvZMenvPv/iV3/5F8y85SAigXPmaL5VaWB4ljihdqmYK2LMjcYUUFM2NVNRJ/MkDGMyg1cBMmSvll/Frohj1o5MtQuh62IIHALF6LZOT8vKvo6yV6KWVE3c0AYoREnFRExEkwFDmiYhVUlik8ikknIijPe+yK/GTG7uBFrR5g3r76tST6OlWnB2DVejBafTL6e8d3VDM29+5oBiTDwch9u7u922Px6Pl1dXRCxyrkXSWbo+v/QJMlQr4eIOdObk+qWEQmTDUauI15IQzLTdbv2c169fHw6Hyr5h6/c/nf9qemdPqDdhEDGDeD/aZ199c3dMuQXLmaU/w81O37Q+tNolcgESUyHT4C2GQESBOBARk3mmPhF5ZcXAxP6rEVsM6CNfXV7sdtvcQniums4oNKcUAJbs7yqihxU9oAybkiVvcmaUREVFVCcVgSazdK7IMUrhKhRx8GFZ/0ONU1Csr1P/rD/ADE5qDVVcTSJKiF03HKekdLtPsbtMk/Xd5Ztjge7Dh/rn2eh/s8LEG524hSRmnmTyN0ETW1KLugDIWcyUOwa4XTJvIK0h+y0I0gPvqDBSDmL27OX1bnuxoUchBFFhahqyGzw5wEHOjePtq3nuL2fBSZIYmUWmQMHMxNO+ckUXJgf3UgnPPBK1QSEqX7xgdN913iqmNORzuuPTCp6XazA1JVOYQZWJXQ1UgoCS6aQyiRo4SRK1pJjSpAZVpNl4akWOXyYTF+TX3PoJRTPGB8SElpbfR4V52cNzJjfF/kTuIFpKMTWk78svv/zBD34QI0/T9BACnKX37R3XFGJ1DpGVujGtEYmKPx/ZSqWhMV1VS6hHzhFREhnHoeu6YRjgxVAhtXB+ncwbl7VdKW0y0coJ6kLtyN3vn1/D7IfMRtj1FyocyILDpEJIutBlEaHMXC3l/Ho2mJJRCAHGrqz70/u+b5fC7QZmVqx1qqUAI1xLVgQiZvR9v91uvYh023NAVYHSR8d7/kGJAhOJCQACcc4acwewueFYBSlZMoiaKKqx2sxMtLjWfRPrjgLWln4wVQOIuR45Hd59qk21UwA51/Tt+MepSaaGir3x2hXcaqlF8uLFi8PhcHl5kRHgXghuoBwNPtRLTo+cfjGbUwrXx5u4Mw+XrxF8BUMIwPF4nCYJMabjIRsaCUxB4SF0CzNodQHa0gjrox6pL3XKRohoSukPXz8TaPejHwQb+qiEYLnqLeZpe2pvrgXNHqKlqlYq0RIFyCzjWQn18yNsJs1aybIpDpjYaBNjH0O/3XhViNbYpZpKWlwu8WImnlGl2TsmBiKDElACvH16Kamo+T9PvBIX+TTL64EgBq7QTWokZlAENQPYLBF5qVPFW7SjfO/RUlgq9TbrT6d7t7gQQJMbpKrejujV9bUXo3/69Om90aB0UtAB54DbSdpyYxYKOwD1DJWsEcMoR49I6XuXTCcRAF3XeaQDgCkl7jeT2eFwVPDxeFSzRKpCloPm3z8Ho53eGVpCNCJ8/uxl321+8vSpKRDIQB2xAVTKN2Q9K0O2CwPmYpsZmKDiwU4L5RhF1QFyt1dxO50RAKbSmJ4QQnj06NGmi13Xxb6ryRtZoyg9oyl7KQjGChVVIyFCQBSCaTITJIWL+cJJbBBLTvhFRVIWQQtLs6Lx17UqEGBVnq3H34YS378Fa1fufWe2ALbiCWev8uNcagJo6S7noRAwe/HiRd//4OnTJ+ejQVuIr6MhIQsmUPFyNvnl495KRN0a7B0ObWan2ZMBLzei4kWyWrI9DqOWhtIiCciJYMykJlx843M03HKcGoJOj6x2cZaRiMTo9188ixR/+PSKhDdME1IXo9+AFQYtpheYkZcBAsABZmZsxgFhdgUsWFMWJzJM5bmpktf28cImMe52u76P3FSN9oVTECHLObltK0o9x/IqwOLRYxpFpqQyDCLCOQrFA8TNUzUy26rpvagq/2LHqzxZQe3c6p8AVSvZP3zO6ssDyt76JyzU8wqcdd9Tmm5ubojo62fffPT06fX1dWxZzIq/tJhwOuikkeDq/ObCxU38fGYOHLzeoPeEnLtrEWkS5rC/2atqSjmHA2X1CZRth1kIKIx6+ban62sneouv7xlCoqZGE/Hv/vhFv/mL0DEx9YiiGjyyBCRNeIoZqSKEuU4TEanAxLzQlWJenEpHqs3Hh//pdaRL5fRQeu+Vac/2yXVRtNXi+1NSGWKTqqZJJ4GqTbkcoyPADE2U3ZfZsk60jrVsoO39yf8bh82u3LV/AI0e7AfFD/PKLOWTz82eKXsD0vF4vLi4+Oyzz371q18dDofsB9CmuPbbv1WhBFTBCEvEKKctLnGI77rOUyvcS+mVYrm0gFa1aUrDcPSiQfVulIs9+fYoAZrLNYf2/vdNuIJmCyin+oCZBbCHKkyK//n5t338iQvEHChSR2IahJkqmamjWRC4YgDkigc4gVEurTRc+g9lcNN0LIf3F2e5yOwPIZrdI3X7KjEq50ty11fCNNk4iSolLykn4opsXtqT7V0tGpmRR+cQFX/zw6DSCsPnNiU7mo1KUovWlPETlxYvSwBVhMxn3j8Ra4WaQnw3m81vfvOb//Xf/puFElz5jhYz8HyXezTd1ff51RZCxczOZlAuJzj5JyK0aGN2OBxKQ3WfktVFNDNmb/eiZW29OJoxyOBy15kpWTEFrHAAs15bgNc9csxJ7Xq///9+/9m/+Gd//snjnUyq3ZQCR2WEwn4K0K8ex8VWT4ZaAqNdmbadzAqLULatNlvyg0o1b3meOYqprY6UkgnUIMmrwaoqpiTquS8qaqkKMxVn4WTUhVYz836lxIBU0WqGlpJ9D6hLT/PO0glIOGfBeeZc79y++2ox20287w4P39DMmEhEHj9+/O233/70pz99/fp1bM+ufLNiQvu5Yq/1iJ2M1VX1ttV8W5d8SqqqXddpkkAkIoHZVJPKOCVVpGSgLkujlGCoRSYKZvuKeNZQJTZO2OY5t8t6agtq34tKUrD7bomJmV7t97/+3e//l7/+6/4qMETBFmK0TJlQqEa91tGeiHK3GLhxktD0tKrJ9bQcaGh5PXL6IqvQwhZWDFCYx/WM4zhMY5rSMKUhmRqJ220oGme6Ang4EpGzVybNCTNmaopMYqkoynUW/h9XaSoRfm+x6AF+YoXjtSL6KdG571rUYDMOXmLHV+z5ixdxtYL3Af1qKqszsdwhW2gFoiZnT3O65IuORnAionEcVRQgLy/uVcFrOyMCJKfU5IWrGIGyFat5Vz5elfhTVtt+iRStKKpJNYR4N6Rf//Z//ut//lcfX3UXoHGaQBRCaEPB2ps4YGcoJ08hzoOX3VTrDCs+ZGOAGUAGb8doOlcpciHE2hcBkL2fFJR0UowpHYfx5nAcxtFjHERRlF4AyD2iHpQYzYwoNy9EMUKcQsXbDLtfZHrgp3asoP+NF87zpHm7VfVwOHRd98UXX/zgB5+uw6Gp0TxoKWm19p+VwWelOvtGery1g2absmklFNQ5dQjBDEyUUqqGqnEcYUagcUzlcWs5zxbiuxUcABEIufxvG3Ba6QctPWjtClYWMZG40B+Y1dwLxq/2x1//7nf/5pd/Fcwo5nLtXAT9eluaa1YakeUi0cQc2CN4W5pfwzo8Zt/XFSiNC2BS+hLoyajHLeezQz0GTmRK034aD8NhmMaxRHnmVjKFWq8I3ykk1V+JGVIqBZT1tBp2uuILb87Wfs9BjRC74H7FILV68Ip5Uo4CxjAMRPTtt9/+7M9/xi0H8C8rP3O7yvXPxePPcYPV99W2+cxc+gdAnMOeHTGGYZjGxBxGz9nOQs66P2n7aeZxlQxwPR9NwWcqlQIqbtdlWgFBXTVVZSJVieyyglmIr/bjf//7P7w4ahp1GkUFaqqaSvhNjSYAM4mMKY2m4jVLrIgVq2U8hWYrEk7KxWo1aZbkJ0m5hJshqSU1Iy5fMIkM03gch8NwvNvv98fjkNKU0qQmtu4gVnnRah3aYb6sDwsbJ7Tp3YdZ4d73zaeFYyx3sM7i7CsA0GbNHcZE5Pr6+m//9j/PSvAKaldH7ptTPadCdr22uDzzmVJ6nlqp4aiqXZzVf6/WAuDu7o6IAgeRo4i0z6xQUl+smDCa+kJ5JWcbsDfX4NJx9dzyF+1tuWh5vUxK7hGp4cXr/e8+/+Kf//xHOzBk2Gw6RJcmjCg4VpuZiDGzkk46ebswj/Or1oxVIYPT5YXTcpkK4DrZo5JpMIfu+IVjSmOaxjTth+NhGKYpK7/e5ExzQslZCLl3OKWnCnbZxp5FKFRxqhE8zYzuQYgWQpaPAVDCd9590JtxcKY1DnvTNMUYv/zyq7UjrILCioS3FLclJNaYjNoXq8ocMgFGpb5+mpf/bnmZE+kppWkSIgLR8XgESCVlBddglvzMAFZVLw5blAhQ6etIpl48P5b678anIP7m0ZqG/M5mmKBfv3oZevzlT/6c1UineBEDDBy8/nvRbSyEjnRiIAQn/TnWtXKkhxHAl6XUsbJiDZtNnJUQeKaLF/IZ0uRipIO+7wa8z1g2E9SHVjjOFeTrEhXXNQARS0TMBjV4LhvTKSLROc3rg41TzDmLS1kTukeWm8GVg2sCwzDE+4j96kr/8xTKV1dVbl63p5AsOCeNIXgqy+F4d7nbQBOZd27UlNI4ye3hKLFj6DgMh8OByTICeOD70sJjWTO4N36w4nMNRnh7HLCluk9EgPfc4qT2+VcvphF//dMfX/ahH6zTEAO8FmcIVKi7QBAcyXWmQBWpaqbLfQueVESSqiZTNl5Bv5kpwZsITtN0TMM46jilcZSUTEY2jd4J3INR3DrM+f5s5D1QrRB2IvDq9YmYlEBFCvq+IHyx7MAZGfV0Z89C7Pl7NtBfY7FCCH/84x/fEA69krcy9Q05ZqFKzOf1YwW51VItV/IxyxUIgWkY6XJrZtM0dV3HFFX19vYWHKdpJNOUMmEDSlpDscjV9y8MBKfk5+zq1NJReAtrRnuaqno1OPe3MYIRffX85ZTSX//8x095Y6NxH/znWr0ixs40qXcmDaZeFLqY/Msj8jS8v1CdkgI5Qcxzc82SZnuAi5Gq3l7GJtNpmo7H4zAdpxHTKJMnI8tsKDM7Y+3Jtd5nT+a8hoV4uRMjm3SXJv73l/rfuPIPX0g1Oa6Rt9+od1v+Z2YmMM/EvhuO8T518OxBWnp5rRlYIqUVYen0DgDc+MPMwzASsf95e3sLZlH1IMmXr156g3jLDhctUn7rE6mzWtTGWq2vmRnmhXun1a8EyUBsIEKAR5orODx/faO/n/7VL35+td0chmG73ZiZiMc1pSkpc2A2bwATNHBp/lfgiRa7uFz5stDm3t85V71BAGOMKl4xYEyDJErJtNQNM1s0FV+9F1GgJq2izGXWT2oDJcumLTIDeUHCHOf89gv5PsOW8sxMiCljJYiSKRPPnrcGEdpr1ZSM2IIrAF3XEVHf9wsOsALfU8g+BfdTnGkgBmgoUFlETimpaYzRVImo67phGNM07ffHq4+efPbZH5lCv9m8eP6SuS+IJIBaznhiy9aUStfuNecvMLk57e1lofo6QK7jIzBiJTEGM4fDfvzt7z/7xc9+8ni72x+OTBSZLYiDECm6APOMxyVzNwMzuwW3TnfxCmXnXN8t5Uxm+WdMSWFDjffRpMJFV7b5BXzxl+9FTSR5VXNKZHUxgnE2nZnkrvUNm31o9eycIP7Gn+4bpzjA9Fb+ttWzHF78ezZhn22TeoZ8nqP0Z6n+itiT9zMtREVqYzzmruuSSNd1Xvd0PI4xxpcvXsbYbfvN7z/7w2azGQaZnzJHfFaxp071TFISmbdQL38iUwzng8xce76//TAngAA8FsPMjDjwYRj+5x8++9mPf/r40WUMbKoMICGEwDARDZSY2PtyngoAp2pANqzUUlbQigAtDohZUkmw0uHLS6mXeuL3w2gm4cUw4PYDKlbRnMxHULXALBNRrgqXCY6Y1oYJxaWwXCgFhTPP/WBjafRZrOeS0FijyNWhTSfz82bQKurcJ/AUwqyrI6uNzFm/ywk5UZFkMBJRUp6GtB+GzXb7zYvnl7tHFOjm5jVR8ASppKMimRddA5cQzIU3YKUEt+9Sl6xiP+WwnIWX5C3W3HKYpK+yO4DNzBghKPizP/3x008/ffrk0cVmw0YEUjEyIaIOTKTMC3chCun1g1qgaN6Fkk0mRfqfQb+UuRVTgYqo5RroIpJXI5t+YFAjBoHJ3JxgABHMO0Bl6A8O/VoEGxKBMSAWmD1bgzzrrJbHKrTuXOjPP9ywN7GUJXgsIOS8FWgFEy1kr2D9FGfqJb5hUKVcmG9tSgohECEwHw7HaZK+7599+w2MLy8v//N/+duUUmAKoUtp0XrQlrcqr5c/z85/Ps1j3JlIc3b3fSefv9z1JsvMt9Agcv+HEjHx8xcv7w773Xbz5NGjTb8JzMHTpVgCvNoczKC5JvZS4i971Ky2EkjUOzvmKtBWvLmqqjBRlwtJ3AvIbAFAqZFiYkYheA13hi2SCWs+jZlyIEACd9VFQ27u1DV4FVvQ9+Psfa+hpRj66bAVB2iAyY9HLKF/dfEpuJ/FhDOMonkGCqlz43TN6RQRIngLDAW6uCHEb799fnt7FzgCHut7HiFxD6LiBBWxJLROurFci7cZ5aUaOEV2BAmY1WIIxDxN0/Uw3d3dXV5cbbp+t/H+Gx4OYd4szCcTEIgwaTLLRWPqjBaIIeJAryYGy99dzSXzDPtSWg51BfLfjTZxQjWy2YcIzAHkydbZCeDnqIE4pxtVQ9GDK/c9ugJWj9Fmuxe/VYz1dW4EoRWtd1CM0rT9WMGWnYz2YLXwrFYWq/1TFRXmYGYe7ePYEkNIKd3d3QEIgY/7Y0rS95vf/ObvA3v6HzN0HMcCe1W3m99E5/BxXi19nWc+wdethJARvxsBIyKG5Xg8FHSyvLRmSEpdCd/pYiAKaZzYMBIpK5HFEMBGxATyvEdFAkEc+pftpjPeGtucZGzI9T6KiWfWgIgIwaj+1bw1Mc23rvtSfBHl1bwKC1FN7ITXaFG2+W3vG/aPzg0eULjXunJRrFTVA3XXleEeoK9nMaT1ALQ0WMSrayszQ2evZ7VC+tYeDofIXUoSQuhi/+zZN8fjyCG6jyE3i3ZXDtVH5FdiZuN7BR5DVtMyqSZUVSTTMIWZMbWyx0MbydVyv1IuarkBtY6IqpOOyGBjSspKpdCnw125lTGTQgC4T1uXt+bSDNx0bvy62ogyJbPGVH/fi6zMKe6e9yIr4DqvvKSeyNYyz9P7PbBc/0SGLeNG1ZQptD/d6wije0qe4Nw23IcJzSXqsTFW4zFEh2G4vLw8HkYQ3d7dgfnzzz/fbnaWZwyP+zUhIJoCFnK6qou3ImYouXvWbh5wbncIWLomMpq8o1VufqlmreqEc5oY4IWuvJRXZKi5WZSoZL6H4PVTCG5wX+qSZlB/r0zYvTgzGcHL35opjNu2flYQ4OyuAQuJlJmjVycueWdEucpAjZiKhAR1Fx0DABPOB1P9www7p+9aI8+0RyqXtqbFRisUZBGoHjp73/Z7C/QrClQJfGs7gnmJMiNn2qIUMvkn5tv9bYLd3uyZg4FGnfa3B1AwykU+pil53RErhrZioPhOg5Zmsrf07ldm6nJFvsOiFOHscqLsRTJhA4zhrQwsIKCk9QOojm0B2brwYOODp4xMxARzsT0rUUZgI+TkaGLkylql24AHQeQ3IMryDAA3QxNR13XMnmKKigAoPDw7+9+W0tuH0AHeX6A6C8b33bDS95wTvPq5kvMi9wZVgXEhsso8p3XXO0hTWsxj2+F9Kom8NZu3/t1st8MweM/T29t93wdvAfbr//5r5t7vNhxHM/KOwA/m0b3zet1/qzdf+JCsiVKEkEqLZ18tzs5W4jbowEPKAtgrdxjY3MfX3ramo4Ng7KTM2gVR0sxrCGzsdbjPAiEV321L+x36Qwhu/QS0olbJU/XIpQcK0H9IBcAe9F28cWgTuVgPOrNFCWglUEBuZMXMEC3Bko3c0lr3XeNc2TfRcBlrtGE/p/IaUaFlyJ6ZdV1nqsMw7Ha7b775psamfvP11zHEwJFBJspESYHiwPIb22x9s7dsC7DScL7rMICqsYbUEAggUnO50tNnWcEKp81slnNgXFwJPiWyXLLGDEwh5Fhq2AIBUKQ6mLF3OGrEvMJz2CNdFQpmmDGdFIkpCgKXFGTHAc+/D4GJQg4tp9kGGkKQJIqm8HqdV16JBaplIvD9yEctvOEerbcV8OrnaeTLSuRZmEFPxfez0HP2jnVmM7ZojqJyjsDMXvz1OAybzebm5ibG6EXrD4f9H//4x67rQgyay0AQZsLvFp7VTO7V82yJdR9q5MwCN/3MmGmFTM+00ImQ6wAOp2oevUKe3OD9AUDE3ueF3dyCFQfIpisFKZgJ2Q6VVxxmDMBYlTIX8JopK023yGkhzPWFavmJrgucGyAQAAW5w15Lx3IS49aWDZwF8QJnVfDGvBrZRvvufUw+xHgADJx2L1IiV7J+5QDtXVoO0F64AjtVrUXRUkogBA4pTZ755afFGMfxaIY//OEPXdeHwCqi6rqEmHUNQNi54lftVuh9KPEPNnwGulpzgsKKGOFfjEqvO3UgdvkbVQbPkoCDDJNnP7jMkxGx7ALMeE7rzdyfigGMShArcYzMkeC9sUIIHGOMXn+FA7wRqRkbC8TdhKZmoqbJzLXfs5BEPkEjq74HP/pdhJn3GPcJqKvjVVXzEUKYOcBZPvBGDtDiQ4sJqh46n2ODvaJyKrUQReSw3w9jUsLhcLw5HGNg4k6FjZhNPXiM2eWx+4J2qjj0/qMh3G8YLoBQfeZSGjGDqnmRNnhhEc9ALQqmt3W2zByyXSKU9GAX9Au6FzuvWuXlxm/IxABAIDXGbAEmjgFAnwOwjYhiJGaEQIEtBgSmGJm8eLUIiC2pGryZwymxw3q1PjCbfcthLbs5+emBq6g0ka/0Oq4uqxjT+rkaklNwo0RcLRUGtzzkoBQiGJHARKQL3ZQbd4LNjsfj8XjkEJjDF199wQxinmUMA4BS9Pj8uE8fffvxQWSkij5WwK7KauZx55ZNNEZZHwYX2w4RwTxfAuQhg0oUvNcboJw11/o0qjO3/OhopkQGFQapGTIeZueglRC3tgBRLbzlTgD/0+V+1Zy3GUIIGkIIqvKQDvxPb1RQfEsIWZdGRJGNgGpcX0C/rVnw4nLzwv/ThELp68nuco4xmtkwDERIKY0yvn79uus6s2AuyxKnNFkOFlrcocXD90aAD6MeLB7uc5u5AqAGMiNmyjAND59kAxgBIPbiueS5iOah1kTkrgIilNR+Y+4ANMu8eIWVzpPVj1rZoCCAL1cV/WOMgQMXQQg5xgnESKW6UTGnFDXiPEh9XxzgjVucc61QbJP1OM1k4o1AsuAALSjPZ5z7aYUP7fmFkGg1EFV+4mcys/d6Gcdpd3n1d7/+NdxhD3arv9+ZORKRJ8rURjLtS34Q+r18o3tvmNeRYNAqp5h3yIKDuhKH4JVBUajz4ub5DigbYxk4q2JdbJTEbrlzb5dgzp5hnle+VTZXolFrA6HMCnL50RBCFyIzR3YNuKuFiUwVlHX0Fm7y1waQTmGKPLXggxiA3tqR8DYPewAH6qLNhbFWAl8RddZwT42dB0uq3IYV8VzlU4lzcLUHAo3j+Pr16z5uvvjTV7c3B6LQ9xdEnEYxUzNhZrMZl1ZTb1MxP8j47rhk99+EStKmM8uHp+0p/I36aJEYtUkFchXYU4hvKRE1w2guv5VNn1yLT8eanGk1UY5mx86MS+c9SQXN/3G0gMU4u7CVMa5+Wv0Z2x9sacl5gNKfok1FDxda3JwMYJqmGMI0DhyDqh6H4e7uTkSM6fPPvzAQUwAc0I2ZxVSKQcHL7Kt6xwcOblACaFkU9nTUfX2P1fwO48yMbAamBVQBM5yZzbvSfimW9fld2j1yNrKaAS2HFyTNYo8L/By8N0Qr58wuJCCQKRSkTMZkTESEAJqqhSfbrN5/bVdg9k4X4gSC308enjkAlgZQrIGbVsfbyGec7HkIQWTK8C/ijVPGabLAMXbD/i6ldHt7uNx98pu/+60Kd5uemb38eeRgBk1ZtWiUy9m59g8O0+8z8nI1glDmAefOLPtnRGRMrXHDzL1p8NhPIiLzaoY56kIbCrfiijX7Hjk9PxbDf1frTvNcxjQzbVJpb9Xekk6asi3f5B/ZCv0AYJyiTV00M4v3XWk5es5aktMKJKbKRGLzyS4DiwhIPYkpiQ7DsNldTCmN4zSO0zim42Hc3724ubnZbDah73LMidV1T+28GxCBlbKBdUrvh/0nr/phNq9A+YmC3ECSAy8BRB70ZETiijJRKEbUekMArKTM7AyxkY7cNOp1Whag73821dWzFSj3hS4BcNQox6gGjGKWZUNTv7GFnn8aQk87rPy/dsgrVuZqjwPAJY4HoZwHIo8GPRVvmu9zf/qq2ranVawwM8Byd1FCSilwOI7Hruv8tGEYN5uLP/zh8xj73/z970LfUTyTxZNnfiJZoSnrZbYQDL7b+I47OhvEAIA8nqc6C5SMy0HAMBtX/PSiXmf0mSufr0XY+nn6yg7KWmqQVYunwzo1bQeq5FOFnzaC0pc3EGvpTxzKbrTPatTCD03zz+3DG2kclwsfVsTPik+oItDqvAXVb6D/XBIMtfet2+BnBQ6R+TiNHAJ38U9/+noSfPvN16IamT3FO4QANadLLuKfjsqL3lt8/D5GWxe6HLl3EN3rGy1ENqfst9VyCVwLulA2ShKVjO1Kmistr2BdzT7+WZGhntAigMs/tXJjyx8cA7jkhZ0uwVuOtuRWgZbmYqoQ9f5IdR+IPzziKnuwHbRUi09PMDMtBmwv1YGsoU6qaqAQg4mGEGLX3ewPr15dv3p547WADODAJmpmfdeh2FI8WOD0xYBcJrwtR0zn1PzvbzwkaN5zvIXLRj6qmhUVcgEi0ixqA1nLbGpHNzesO03L+PAK06EZlRVUyPb02QrlcNmSDMTEgSPYgCRJkRQpcRJR90nn3CFtXndu+PABxnfbxoreLUi8ETzO1wY9O051UBd63cqZe7iX6ogEjiFkyWd3cXNz++Lb519++SdQn2QKgcmMVcc00Sb2l9tJkowCnnnIGXxrxPUPyATeKAO9FY6d5C7Xayu4n96kBKKhkUpnnPHPjO22vjAvlAFAyB0ImJjmIJ8a+xkCAjMzBfbgiyr5+Do7eScPPhGpT/PJtxWFly/wT04feA9qeL4w1tlbt59mlvO4KdfJMDMz9YWVZEAgIjPpunB9fX17e/hv//W/xn53OI7+DM8H6Lvu6vEjRx7P0UxJqsrRMrW3fLf2Fb5/YalReWt5zRMjXaYblKdERMQEd3VzzvMKHEodd7jkbTAxMzYCce2JY1TzxojYzIohh4moOnfXdh5mcmQIHnRSOrHOvuVZQsvMqqgWgDItqlg7kf1HCu788INXkI0lDJ0Ve+qgon5VFcoMXqQMgKh4q4sXL178h//wHx5dPfEars6U/aqnT596cMSTJ09ijH5tBZpW4T47q8ry6sGZVv1DyUWe5B6JI6gjZhADbGBFFDDIUnaJsBX+VvDEyMAGYrjg04pMS2pbxfHmexZ4Zpmn2DprwM9K4m+B22+bVzI7vGZb8yl60PK5q9V9p9X+J6LCwc2g7R/3nbQCvro61duFXPgtjePg0M/Mx+OdSvryj3/6u7///dOPPt4fkiTEGLsuSJLIvNvtLi8vbw63TrSOx6NLqCretnZBpayx3bbTo6bvC5Y86h1XgxYUffmI1Zf2mkDMbkB0ewDmzB3/Z9l50lQiegt4cRw4q5ihqK31YCjtxhwFWvmemeHfM9wugJfepETVS2YcWLgcqFpBvotr7B9ymBViA+ABHaCCOMBzhmQBuJboVuukF3M2sxBCSun25vbVq1e//u//4+M/++H+bhwHibELXTATQ3r69JPtdquq3jJ1v9/7HVyVLkLDPJkaxTrPtbgCXDjI5xUnlMHeMoP4O0qyeQLnUK4oubkeN8USd7nMVGqgiVqdAUsAtRKbiCUqUhPjuVJ2W5ZREaDeFg29aF+n/STSmRmZKixHqcNqY6g8dysaCe6jJO8/6H2l2RVun6L6QotfCdCrz7MzsFKo2rc2peSq8PX19ZdfPvvTH7/8t//m342D7vdHpyCBeBqHjz/+uOt4s4nDcNhdXIro4e54HIYcha5OWIwN/g+ikeYA7LwiBIWJqSJ3QFnVjn2P9XrX8QbtuWGYLdXQxo/x9syKmuZiLay30N+Y/Of4Z2bOFX9OvGbtfHIsdVOG2pcbptVBMXsQlv6EE5Hon5Cc8/CYe4S1wsNqY85iSJZriwVaksH4eBxUdZrkt3//h88++/Lf/W//+//4zW/vDvuk05SOkVXSftuHp4+vkoxE0nVBRUVsmtKK8rW1qyqrWUk47cRWk3wnqfQfYFRZsU6MmT3/84GpWo4KLdoOAVAiI7IQKITShTJDuDtBQSUGLsZIjV2fT8hyu2jajFrfoDoc2nmeTjjf5zvD/HujzQNM7J4L8k/cglRVZ+sAAFJiy6mppAbxz5YtiAgHev36ZrfbHQ6H//Sf/p/jcfj3//7/+I//8f8dR0lJY+xjZACbfvPLX/5SRHYXu08//XQcRy/Sq14x121wTRsIs/NJ96ffW9PeKfv6IOON1tLVObb8da4MKbWgBgHMCjYoWE9mWgw+lcRapfEojVarAuCg3hLmeu3pItRfVyBSaV+7BRlWWtl/Hjh7/9MbPrh276xGn1LqGYaR/3nSgJaWyvMjbFYC/n/+jSuvOi4KCAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F85B2318B90>"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eyKCDUR1P9Pk"
      },
      "source": [
        "aligned_image.save('/content/pic1.jpg')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "image = cv2.imread('original2.jpg')\n",
        "aligned_image = run_alignment(image)\n",
        "aligned_image"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 273
        },
        "id": "uSHO4GGMebAk",
        "outputId": "a0d09b3b-4684-4b94-945d-5eec984b76e8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAADK8klEQVR4nOz9WbMlSXIeCOpiZu5+trvFjTUzkVWFKhR2AkSzOcPmdA8HM0KyRWZkRPg3RmZ+Bd+nW+alpUl2s/lAEC+sBgTTZIEgCRTBIcBCgVWVqKwl98g1Im7EXc7i7maq86Dudvycu2SsmQmAVlE3z/Xrx93cXFVN9dMN/+O/+yYAICJsDgXIh1AvOOHq8aTnXznoeV/wmYaq2n+hm5UO/kiPcwWR2DQNETnnEFFEiMiujIgpJbtyjHGxWCyXSxG5du3aeDwmoqZpPvzww+Vyefv27ZQSM4/HYxGp69p7v1gs2rYtikJVP/jggzt37qhqjBEAvv/97x8cHPzgBz945ZVXdnd3T05Ojo+PVbUsyw8//PD27dvT6RQA6rpeLBa//Mu/HEJIKXnvbTLOubIsY4xt2x4dHbVte/v27eVy+cEHH7zzzjuTyeTg4ODatWvMvFgs5vN5XddFUYxGo8lkMhqNmDnGKCKIaI+sqqpqD/44L7c/57FW+PEHviAGsGvaG33WOX4WDCA9WV/yZ5GtZ0HETLX5mK3Zp05VNRm9AoBRBjPbdVS1qqrVanV2dsbMo9FIVVerVVmWiHjv3j3n3Hg8ZuayLOu6rus6pVSWJTO3bXv//v2qqogohPDgwYMvfelLf/iHf6iqL7300ne/+10AOD09vX///mq1evDgQVVV165dWywWKaXZbPb1r3/9wYMHIvJX/+pfZWa77MHBQVEUR0dHq9VqMp3ElMqynEyni/lck3z7298uy3I0Gu3s7BweHsYYz87OAKAsy8VicXJyMh6P7Vfv/f7+vvHAcNGMH/KzX710iPjZMQAMeODpGGB9j2el3UsZYCiMNz9cOAccMPXW+BQGGP7VZrL1zrbk06cxvzRN45yzX1JKIsLMRNS27d27d3d2drz3Rkbvvffe0dHR0dHR/v5+VVVVVb300ktFURRFUde1c65tW7vIZDJ57733rl27Vtd127ZVVX3/+99/9913792717btw4cP2TkkXMwXCjoeT+aLeVGMJtPxcrWql6t2VZ+dnf3CL/zCwcEBEZ2dnZ2dndy6daup669+7WthVI6mE9uXVqvV4mx+9vD4lVdemU6nq9VqtVrN5/Pd3d29vb2bN28y86NHj6bTaYzx6OjIe1/X9Ww2q+t6PB6HEJqmsd2Ame2a9vhXr9ufSwbI29zV57xoDefTNtBPYYDLxlCSXfR3uuSvEmPMG0iMUVW996enp8vl8tatW8vl8q233jo5OTk8PHz55ZftnLqum6Y5OzsLIUyn0+VyeXJyMplMdnd3jYWKovjxGz85ODgQkQcPHuzs7Hzzm98khOVyuVzVi2X9tZ/9+o9+9KPDw8N79+4dHR2VZamKjx49Go/Hk3EVl3XTrIhIVY+PjyeTSdu2d+7c2dvb88G7srj7wfuq+tf/+l+/fft2bNqP7n4wm06vXbv23nvvee+n06lpNScnJ2+88YZpaHt7e7u7u3fv3t3d3W3b9ld/9VdTSkS0u7sbY4wxGm8sFgvvfVVVWbgMP9gi217x7AywJTRfLAPkb30qeX2RGcBewxXPcjkDb9+uP01ME7Cfbds2TXt6Or9169a9e/eZ+Y033nzllTuz2eQnP/nJO++88/Dhw7ZtnXNE7uWXX75169a3v/3Hv/iLv/jKK6+YUn7//v2zs7Osq8zn8xs3bvzRH/3RfLlIbXSe25jqmBaL1bXDw+Vy2bYtM//ar/3an/7pd196+aUbN65/9zt/Km1T1wuR1LZtJ4wBlovl7s5uUokgUbUqCpsziO7v7P7KL/+VnZ2d119/3Tl38+bN69evM/N0Or1+/bqIfOc73xmNRs457z0iXrt27YMPPtjZ2Xn11Vc//PDDmzdvppTqujZ1Lq9wlphb69zvtLz5FrZUgCcej8UAdgI+yV22LvgXgAEu+9O5W1w1Mi+JiNkVItI0zWKx2ts9qJv6k08+UcF3333n/oOPnePZbHZ4eP399+/+4AevT6fTqhqbzqOaRGS1WiyXy1/5lV+5deuWc+6tt966c+fOu+++++qrrx4fH3/zm99c1o1KXC1XSBwVV21LxICQkiDiarUqiwIQJcVRUYAIQBJJRoImzqEXvQmhSXEyGpnljQooevzwESK+/PLLP//zPx9jfP/9909PT3/pl37p4OCgruuyLD/++OP79+9/5StfGY/Hy+Xyzp07O7t7bdvMZrN6tUop3bp1CwBSSqrqnEspxRjLsoTHoJnnMq5igI3z/hIzwNZ1jHCHB42sP1XTG54P/Vs3OIjZn5ycfe9735tNd//4j/+4LMuDa3v37n383nvvi8irr756eHg4Go2aOt67/3FRFKvVaj4/nUzGIfjj4+OyLJfLZVEU77333q1bt958803nnaqumphiiwgCULfCLjRta1BSWZYiCqCmk2hqUcFzZ8/01K8A2j0yIThObWu2OwGi6KisFqulJkDGFGVnb69p4mpVJxHvfVGUZekOrx1+9Wtfa9v28PCwiZGIiUA1gaSDnd3Dw8PDw0PT8bz3ZhsURWE3fcz1fJbxohggf8s+fO4M0N/iUhpVVYCrVlz7MbR6n27aRnNt25olEGN87bUfvP/+h00dj46OQijatkWSO3duAyAzf/nLXxaR4+Pj4+Pjt956i5l//ud/9t69ez/84ev379+rqsosBBEJZWHCe7VaAYAggQKjAlIr0LYCvWjvdxIlJkRwSCDJ1O2OAfJbQ8VuG0BAJaKsPwMqkQMFEYlREBGJYa2vA2gCgLZtvQ9E9KUvf9l596u/+lcODw80pUlZfvTRRzs7O1/96ldtTUQkxlgUBQBkM+mFjsdlAABAeEoizXbMY57zgpjhWRgg6wNGXllbPYcC5UtdvAca9r9YLJxzRPT9738fEb/1rW8VReV9ce+TB6PR6OTklJmXq3nT1Ccnj5i5ruvlcmkyEhGn07HpCcy8XC6JKSUhwthG8FzXjfkBmqbFXpk2yAUAY2w3DU3amLO95cHMpSd2swoQCDeQe2UmAIhREGzf6KjfqBl6ZjCYy3s325mJxFu3bvz63/pb9z788Pbt2/P5/L333vvbf/tvE5H5MbI9fX4Zn/voGOBx7vTUDPB047k/+WMwgF5mTl2o8wwuu33w/Nfzn4ioKIqPPvrotddeCyF8+9vffvjwoQLev/8wtqkajVNKo9FoPj+LKSpKEiVix0yMIlFVJUkb207IoiKSqirYD8r4bJ6zUX/PrnkFNjbnjiu6/68fSmANwhARIvVbQWcikk0i06tsiwnjHLN5AKCsivG4AhAE+Ft/829+/etfv3v3rjkx7ty58+Uvf3k+n6uqwaPrib0wnPCLywDwvHngqRnAXu2W6m90kP8EANmpmfHs/P0kUjft6WKJiIvl8uzs7M233vzww49+9MM3Ukp2sr1yE5xmC4oIMNq8HCORaexpqIzpYCY9oYNI6phD8/TXPDz4AIqfhlBvPS8AEdkD2iWYGDp+Q1XlXlWE/szhMnrv29h4z86Rdw5ifOnOnV//9V8/PLx+9/33ZtPZvXv3fvEXf9GUusy0Zhybr/D5i8UvMgOsb/087vwcd4DhcWOMtm1TSkVRNE3TNA0AmJ8rxtjGxrEnXyi5d999ezQa/dEf/dHbb7997949Qg89axnpC4L0I6WECERMiNypHltKGqoalNQJaZE1cK6qAmhbw/ApNkT+1mNdEBCw4bK1wUT5i8QECiLdCawduqUAhERkoSIEoIiECKoqKioSiqIIBTHcvn37V37lV3/6p19944ev37l923Swr371q3VdZ16y9VmbFs9v/CViALtS/+G5QWxDZcMEOQCYDdo0TQghxtjE9t7RQ+Li9ddfv3v37r179z7++GPvPSia2QcAIhJTQjZtQQHUYoSYHSJ6IqQOIM9bjaq2kswLdt7kUFUVANgywDZ+3V6FK5e507kGhJh/qioCI6L2qo4dZ9g+03gYEc3qLUo/nc5SSj/79a/9l7/2Kx9/+NH169e/9KUvvfXWW1/5ylcsTkR7d9h653l+wz3fy33hx/Oh+60NIau8IjKfz5n55OTkxo0bs52dh48eppS8L9555+5b7773wx/8IMbknNFK5wM2YW/X7YPEBDr1ut9kUnJurVJn9UAFQQm0k+WI0Cs8kGW/Kmgv3Ne8ep74Pz2ESfMN8jYy0NHX1xncBaAn3/549ydT+VarWuR4PB7/6Ec/OXl49N/+nb/99ttvi8iXv/zlDz/8kIh+6qd+arFYnOfwZxkbquwT7AD4NEjoU48Xbf4/y7hQI2qaxnv/ySefWGjkarU6PT2d7uz+r//rN373d/9VAhJkFCUiZs6OsJQ6td4uiwTZdgSApErEAOCIiNTgFbNEVSHJenQUNtB/hvPcQlR0AGTl+V+44OdPGOoh9rlz3AoCANu0U7JHQO0YID9R1uI6Y4nAmGI6GwcCie3f+3t/7/T0tKqqr3/968z8k5/85Jd+6ZdMq9xCRS/TS7cf4fyhwYM+PQMMRYh2l32eNPvFZICBJOt+zdbnfD4HgJ2dHXtPP/zhD7/1rW/98be/U5alqJIL7AIhSpLlapliVACRpJ0/OHVE2Ss5hnjKltE5uKNmbxrY/zoJvaWS5a8YwX0q0WxxznBkM3RTBeqQJZXOPIDBJoAAqFuxJGszBhGdZyYnIkXpS0fNqp7PT//u3/27KaUvfelLr776KhK9+867v/CLv9C2rYqafb9hDdNjbFyXjydggE8df7EZYEhYebRta7GNBnH44FJKb/zkzf/pH/8v9x4eT/f2i1Atl0vvffB+dbaYrxZx1YgIMYiqqGBHzanT7JlUgQjNY6DIljMAHX2DqGYgSESGaOYw0jhPNR8cSu4hG2/J+K29YuvDluy3ixkDILBdOuc5AEDbNKhgOx4aeKodA4gqM4+qwp4dEVLS8Xgcm+bhw4f/h//6b96+fWt3d/eVV15xHF7/0Q//+n/516RtNcW8YYLx5LORyX9mgMcaa1xFBACcc6enp8fHx3t7ew8fPpxMJsxs4N0//If/8LXXXgtlpey5KMtiVNf16enpcrEgUSByRJIEUJAICEGldxgp9FLWAvqJKClSjzMCqKhKP4fzERnDIzrAZ/MOsKX2nF/h4ZEhtwwPZnsUzErp/Qam05vyU5aliIQQVquVBX5bgkFWmczsUdXZZByCa9uaiEMoYyvBuxjj8fHDn/qpn/obf+NvvPTy7dl0t6jKH77+g5/7mZ/x3HmyM97wnxngsxiZCFJKIQQLxCeio6OH168f1nW9WCwfPTr+7//7/0/b1t4z+9AKrqIuFgv7uqSkMSGRd44AkRQQowiqiophPhZ4g4hEPBqNiKhNawo29pO1pQzQG8pGlKYOZWrN/DA0WLcFfAZPAZAwa7XDk7euAANQUvuwOSNrWxN75N3dXTtY1/XJyYmF92T3MPSZQBLj4eH+ZDI5Pj4uy9F4NDk9OTZsoK5Xu7u7/9f/23976+ad8XQSm+bexx995UuvZjbrsogeTwW6jJyeKwM8Vyv5C8UA0It/e6Pmmqnrend3f7GYA+iPfvTj/+F/+Afelcyo0M6X81UEQe+csxdQFoVDiilJjKCgkABREFBUVUW7NEgTaIgYQnDOpx40NLS0A4uGL7VHfzoO6TVvGyZ0zz+IDnIRM00PMzPtTKOwbGEPv9LFhPbDvmJJLQBgwdsW32+JmvP53PYBALCwiO4uKvVqtbe3s7+/P5+vilBWZXF6ehpjTCk2TVONir/2X/y1//r/+N8E5yS2j44evPTSS2b329W2GOAKjf9CivrLBoM+5chahEH7toPv7e2JqIj+i3/5O//yX/xuWUxV8fT0LMnKBTeZTJrE3nNRFCKSYox1k5XvDudHix1QBUVAACAmBVRVQYiQsNcWUowIyIAJsvYPAEBGRdRbpZfP30T1kMpzkAL0AMuWcQ8Aps0b4205vFNKzrl8QeMTi/4PISyXSwt0VdWqqtq2revauMgO2ndVtKqq+XzeNPHw2uHp6RwEDvYPHz56MJ+3RLxaLv/1v/7Xy3r1f/4//bpnnM1mH3/88XQ6LYqicw93bjc126kzRc6/PhCgC3jgi8sAV+9cn/2wF1yWpZm8o9FIRBaL5n/6n//nH/3wB2VVoeKyXirodHevjRGJS++SpJOTEwAAlBhjZwJqRk4UUQEUUVEJEcmx4T8woMjO03tBLEP3EQUUL4D2hyPzMPSknHcnO7iWygMr2eg7M0++mikzWcUybNdccjnBLcvppmksDX+1WoUQ7Ea2SwAxqBC5mNL9+0fj8WRV13pyTOxjUlVAdIDpD37/Dw8ODv/qL//cZDw6OjoyA8mcjDYT51ySpAIK6WI5cAkdfXEZwMYVFtuLvu8QJ0HEGGNVVUAYU1uWJYZwfHL23/13/++7d+96H9rYirTFqJAEClhNZjGlNiWTnTFGABEVBFCTo72cUhEFJVByXFUjH0IIhQLEmOq2Wc9HRJOaztOFN6iuIRUTzJdrw0PdPS9pFt75oME1MGCG4XH7et4B7OBw67AYb3veEIIdtNyD1Wo1m81SSpaMZuS7Wq289wAEDPP5PKGmJGVZKmgOm0XUsixDKH7jN34D0v/9l37+527cuLFarfI0jM3att3Cqc690YsPv/B46z+nA3vfjb3j5XJpaUqffPLJzs4uIX3yySd//+///TffektU66Zu27Zt29VqVRaj8XTaxris67ZJ2c+lA4/vxktCcAiOmQglRkkxxaau66apJUaJUeLaU7Y2h/uBvWgTERQl3Zg/DGJ47NctgaKbXiodJHBn/jcKM4qHgdkw1P6zvmSC3yxyRLTgqOVyCQBN08xmMwv8FOnKAlgAFRFZ6ZSczHB6empUjoi2tru7u//8n//zo6MjK7hyfHycoyQ2Q0cvidq6xDz4zwxw8ciWIjOvViurNfLw4cNr1649uP/gk0/u/S//+B8fH5+anWdK0f7+/mQyWazqs7N5SmLK6EDcar40iGhKIIKqDMDMPrB3TjSpaowR1VR97aKIVTV1MRJdkEM/Oj1E1HQPoy0AoAHRG2GZnpApZojGZPltt9sK4cxqEjPnShb5yJC1TOHZOrK7u2vJOvZoe3t7ZVlqHzkSQljVK++9+f5sDtj77BAxJYlRAFCShlD+j//jP7QyGVVVpZTMQzxk8nMiYntsveiNR316enkxAwfjs7+74XQW4MDMx8fH3vuzswUR/eZv/uYPX/8RIq7qdlm3RTWezHbny3pZt977lBSRmT0Qm4DOpKwqMAgVJiJLEXTOec9VWTgkAoxtTLGx12VfYUQAERCRBKAIiqCEQACkwAokqimJCMSEogRoirIRtAGUFn8GfUCRGakwCE3L+4DxTI47wt752gEvANCnGQyjlC3HLYRgtzPhHWOcTqd1XdsFRcQSvmxiluUDAM65EIL33q5mqhQAOOcRUcS2FEbE3/zN3/zggw92d3cfPnxYlqXF4WbHAqyZVlVFNakmAHFMqKBJhqaUqtLgC88wFFDhs4wU+gyGBeXbu8xLFEL4xjd+6/XXf2QJrAg0mcyYfdNEIl8Uo+CLclTFlOq6Xq1WbWvlP6Iq9PHHYqi9fXDEhStK9iWHsR/tT/ecUIHeg0ttm/pgT5GEA40FspJjRm0OeutRS+M3U0hMPy7L0pLIjMqN1DKdQU/Q0N9lyCowcDXYapikzxYCAAx5LIRgxq7lrAGA6UJ2R6sckZmTmOyLtoGY8WBJbcxU1yuRmFIrIgoQJT06Of2Df/et//S97964dfNseVaWpalbGbQFsH+KuCFDexVrg+BJkoKgyhPvHZ/B+OxvOnxei1K2Vfvoo4+qqqomk3/xL7/5B3/4hwl5UbdALpSVAoqCApovd9nGs/lyuVzW9TK1TUytdrYjOnaWGpvVVDJYEBGRATCltFwucjaMkUU3q80Yh/XGmPlBwaLkoHcaWE7JZDIx1cg08hCCfZGIjCizU2lrHTJJnT9u2KgpVDnuDQC89zHG5XJpwt7wYudcvVoxUWrberFkwHqxDOwm1cghkYLUkRQcEoCophBcCG42m5RlWK2WznVhFGZA21Tfeee973znO8fHxypgHJWZFrNLpI8RhN5WHoqPPAhh2zz6Qo3PjP3WhI8gPdbOzAB0fHw8nU4V6f/3H/7jN377t6Nq3bbIjtmlHucx5dhqVy0Wi1z6kzrgmyxxUURAlImC82UoilCEUIZQeO9NJDdNG2OUlGxn3xJA+edQN5TeEM56v93IrmA1PY3QTT8JIUCfmG8mqfbGbhb8dmvvvXlwYZC1k51r+XjmASvbSAqxbjSm0odxWcW6SW1s68Y7b0xl24Lxhi2OFYrMer8xktWQs9vl3cno23v/7//9f/jGN77hvW9ja0tn2/XWO4WBNX8hIfUm/9WpEH9pxhArMDlnZuXOzs53v/vdf/SP/lEH0p+LGzMIaLlcxrZ1zKOqMsQzK9NkZgGzHTE6MNjE+eCcc86LQFZkM/Kova/34gkPAHvoUSD7lonM09NT7/14PDZ7sW3byWTifYgxxSghlHXd1nVrlJCVfuMWS703E8g5Z1uiUSoAmI1hdzdIZ8g/KaXT09PRaDSdTk0TAwDDQ81IyCiQPay5yczuMnhHVcfjcRbefQSUApCIFkXxne/8p3//7/9DjNHSiJfLpUVhwCatD4VIhygMtojPEwXqEQ2V/t8VgU2f8QZl75KZ7927d/369T/5kz/5p//0n2b11/bcfg2laRoDOkxApl5+26WYiImYmfroHUZkRM/cSf5+H8harKiaYM47O28mBBpPKEBM4kPgIoijqKKqbPYYACnEGBHh9PS0tzuByNV1u7e3X1UjAHDOTSc7q9XKdCQjyuzVQsSjo6OdnR0rVWLlo01ZMve21b61g2VZ2l2qqjKStSAIZvbeZ44CgOVy6ZwzV27mDRPh9kWbj42yLGkQDd5vO2qb2ze/+c35fGF7teFCQ6Xfvtgb+nkf7qgNlVCfX90VBZABKT/OP4XLk3A/89EBHZtHzs7OZrPZW2+99c/+2T+bn51l6aiDyAJ7bbb55pABez3ee0Y2GUQ9+IO9iqKiKkCqJEpWJN2hgCaAJIIKDjAAOcWg6BVJEQAUMCZRtVfKFlBgILqV79l6rrZtd3Z2PvnkE4Mji6IwiH0ymVi58+l0avWomd1oNIKe+e1BrLrb7du3T05OTHKvVitENAOjKIrJZGKmhYVImTZSFIWJAOwD5sy0zXa5JXkBQE5+t33GzJW2bXNqtdVpzC9IbOFQBaBNabFsfvu3/8Vi0axWKYQRIieJGbPq7QEEoJTENlc1c61H5wYMoM8QWpr9MX+ex5B6kiRTfoqi+Af/4B9+9NFHxGvl2AKTu+8gYg9ikALENArlwc5B5QtWYUgIkTESivfkkSbVdFxOJtU0uAIVJcX5/Oz05NSAmqLwCKoiRGSVdgblKdeOqlxLMAcmTSYTI77h46jqalWfnZ3t7+8fHR3t7e2dnJzcvn3byqyPRiOrTXv9+nU7k3sNzRR6u91kMvnggw8ODg6Wy6WJ/Lqu7fpt21rUqm0Lbdt67026224AvWlhWx0AqOpoNBpapUM71dSqHEahvftPBnHdSVOS1OkOCn/07W+//voPHx49snIytjkMXRkyiOAYGgP2eX0eDgzivwxDNwdktV4BDNZBTCn9k3/yTz788CPvC02CqSWJIAmlwdSCJltAUQtDUSba3dmtyrJeLqWNnjmwqyiUGDwwJ2RFSa13xATBcxEcM+/t7c1mM9PXV6sVgiCIihi0NJwxACBhtvlMsvq+aogR1nAfy/HJqjqZTKwg12q1unPnznvvvcfM165dW61WRpTL5WKxWBiybkq/qRApJYtXIyIj8XWCS79L2E64mi8gdbkKW6ioXdOo3Ko4Du3prC72NYDJCtc1TZMDLoyOU5IeF+6KCRRF+S/+t39Z1/XRg0dtGwnXBbl007F9IRk8gQr0GWvhl83hivH4382/DtGxTiD1cbbHx8ff//733333bVMHLBcFVAlEgQRIFLrAfFECJKIyFJratl4Gx8F7JrIcliQJALxzs9ns5o3r16/t37l14/q1/cODvel4dHr86Oj+vUdHDyS2DDoqytIHwg2PL/RaLPXGCQA0TVNV1c7Ojgnjtbo8WA0T5NY4w6zMhw8fIuLu7u6HH34oItevXz87Ozs4OPA+NE0TY7TC6EbodhHDTI3siqKzVawLQdM01WhkKj4AWH8a6epZWNr7KufNYR92YcaG9BWQTO0xWs/M4JyzWxhMZF6zDAxo50tOxlFvv/32w4cPU5KuTNgg3skoP3PCFp2cg40+7z1gHdJ4rib7c+HAjBNnTTFfOcNtZqXdu3fvwYMHRw8fWIQC9mUVwIB/BSEEFcRucV13AhQ+ANByuRCJoXDkmYGCMwQI69VykVLTNG3TEFNZlNf29o3WT09Pk0sA4K3eYN2A6hrpt7eIiBY94b0pytcODgCxaZuU0mg8Pjk9EVAmBkQVZUR1TkQ++eST27dfOjo6MpXmlVdeQcRPPvnk1Z/68mJ5FkI4PDy8f/+T+Xw+mUwywmM8k7V5wyszNTdNY0XszN71gW1rsmK9OREsJ4UZfVtUlbXAgV5xsipAhgsZrZsqtVgsvHN2rz4Hs/OKICIoIAIRf/vbf1KWlQ98584tQ1FhjdTp8KXjZtLKFysaVFUFYR3R9VyvnD+vsZRzB2315/P5dDr91re+9eabb7ZNRKvrBNg5csElQCBSRdQo67gGds4VzG1dr1ZzACiKELxzjIQYnPfeBx8U0mg0appmXBZJpFnVApRSapumDEGJoiYEYlAAWTZtAjHtHxELdorYxIRIzFwUxWKxWoyWu7u789WyXdWLNB+Nx8bDxAy9vm60e3JysrOzs1wuLar+5s2bH3/88ccffzQajx49enTz5s3j44eG2xhsapHM2sOyu7u7pggZJGpr1TQNMWdb1gBNq/dvB4eNcCyA2cxlYxVz/ZrmY6qRiSHvfQ75zK4AFbWSXAoKimSgAGiU9O7d937q/ffHk+ra4bWyCObHU02qKpqQrMZpB0YLrAtIbqtA0o/LyOipNZDPd2zhaOc/Z9HVtu2NGzd++7d/++zs7NGjR8w+JdOrCYAAOCkKkCiCJkgRAZjIMROixHa5nIumsvRV5caFm1bFOISCqSz8qPDt8gxjPHnwQJtmdXo6Ir51cG1SFpMifOmll7788ss3D67tTqdlCGURqjKUZejEGCIQRRUkcs4BKiKORiNmXC6X9rksy+l0mmIUEcMirc9SzjM+Pj42HcZwm6Ojo+vXr5sNYFFP+/v7OZfFlPu9vT0RqevaFBXrRmOkbA61uq4tetmwTjtoKRAZt7V9QFXn87l56FTVbGI7bmd675fLVYxxWTerVeNckJTY0LYUEZJCapFadAJe0EVg00LrFF0R/s2//Tcxyfde+765EVarVa/fbrsCMnkjbpaGVFUSMnxU0heaoJ9iZFwMNrND1r8SNW3z8PjRYrX83mvff+PttwC4blJKpOBFnapXdQjoQB0oqwRyFdKIuELyIqSxLHFUYlXgdFzsTEcO1QFOx5PZeDwqy4OdnWk1+uqXvvLf/I2/+Tf/2v/ucHc/LleHs53b1697RI2xLAvvgikDVTUOoewcT4iIWI1GSbqYGftgYIsJZiPKGzduWNqaaR0WVGMqjXXssjaPZjbM5/PJdLJYLKqqOjs729nZCSHkCDMzCawnn5kEiDjs8KWq1qxgOp2av9n8WTGlpCKgddu4IlSTsSsCunVSwWq1yp1jADurwN5S26YUJTsNuny6FGFTjx/acjlq67d+67defunlu3fvGk7QaW45DhfWsHW2JZ6nCqQXxVp80cbWJE0jJMQoSQnvPTjau3b47/7DH65SW7dCnSBgUDKNDEEJuxVlIte59pkAicGzcw6Yqaoqz07ayD6MXFFVZVH6cTU6vHbNyDEQltPx2WnlUFWAicg5ZGRmUVgt5gn0YDKN6aEkIcSmbc0GHo1G8/kcEYkwSUQgixdYLBalD9772LbT6dSUCukaVYTFYmnkax5ryzWpqqquawBU7RKOb9++OR6PzbQ1GxQALJjCzFAL37crmKVrOvXDhw9Ho1GoygePHhowSsyGTaWUiMl8wHYFu+9isRiNRnVde3LsnDFbdz726TgAloc0nwuAEpJVQRrG72Cfa8+ADx48+L3f+72f/9mv90Z27Gy89dtGIhLo8KvtHeAvwxhuAt0WaVsfkrk2z85OfvCDH1hbLlUg4vNcbYYzAooIYed5RVXHOJtM9/f2ihAgJu9cWRTjspqMymlZ3DjYv3n9OoEePzzyjh7c/yS2TSj83u7OdDLZmU4mZeWJJ1W5Mx6VRJ7hcG86rsrShSqUDim1EQCqqrJ8dNUuBNdIdrFYDONhVquVKRjXDg+BMIGSQyQtCj+d5mIkAJCaZqWaEPXk5KSqqhzlZuoK9PqhdYM0pN9uZLiT6eur1crAU3Mqm3y12DgLijZlzHAh+7BcLkMIdd11hcmaiXEj9tleiJYq4Mz2VVm3Gbbzh06DP/3TP53t7PzZn/3ZaDSyROTBe9vQ1TtIauvV5t0Ct4uqfkaDBjNQfCF+4iEggH1ApYpY7tL779998OA+IiooAlnd48wtqkoKqMCAIMpIDolAEbTwYTweT6fTwnkrgWgVUEbTMSO8dOfWjRuHbdsURem9//DDD0Pwu7s7k8k4SXTBjcdV4d3ebLq/M9vfmY2KkOpGm7Q3GU+r0awaFRw0qbSCymUYF76EhKAEgpogreJyWT84enS2WCqAqBpsLyKz6WwymQAAERk+k8VwXdcWH2pazfHxcQjBAnjMos1pvtSny8znc3MnGw/kSMzT09McvpEDWo2ULcLP9DGbFfZBVgYNmamdA0ksD+7s7MxumqKYaZEDB7bTuxCsX4EiqOo3fusb165d+8lPfrKzs2P7s9kiBGhotUICFPv3xUKBtoY95HN3z+FmNJsN6ZrVLb73ve/fu3dfREA1STT4Mc/HUHazqxgwOMfEgDCuRgfX9grHbazrpi58KMdBFQLzuBp51rZNi/kiicZ2VZa+KEoSPTs7886NpmNHxMRYjRarVfABpjukcv/RcVvXCrg7HithWK5OF0sFFFBr9TUajS3uyNxVLnhErOvae2eUbTR0dnZ2/fr19v33U0qSxCSrRW6enZ2ZPWrkaIFl4/HYKN5Az+yFtSUy3zARPXjwYDabWdSDqWEGHEGP2+TAvlW9qoquD6SFwdkmAAB1Xe/u7h4dHUHXL3mdKAOEdV2j4x4EI1VxhFGEkC33sbWy8iiMaPhhFPnRT974+MHR/u7uo0cnVVWKSBcmjgSAIqKwTvA/xwA9sakqKSGg4mfRq+yK8cJNCwTo4sbwgw8+ePvtdx89PPbBETOIIqElYYGSijBRKLyqgiqqMCVMzWg8unFzFhzF5ZLbWBHsjquqqopQVOUE2+S9L91IE7T1orNWnQfVyWRCiADqkByzAo7GZdukyXQiGpu2reu28oUQCaKbTp1zi3oVRdh2LVRXFBbSTIR1XQNo0zQp+ZzIllJans2v3bheVVXbtLFtgw85P8usz6GP1tQYRMy6fkZCTSMybHRnZ+edd94BgN3dXZPiBnHaLmFI/NpURagBbUsEQupDPnMmTVacAEyhj8ikqm3bllyqJgVk51LT9Fq7FdOGIXKuAKoQJXnnfuu3fuv/+f/6f/zkzTd+9a/8SoqJmCDbzKAW1WLRXJfuAFmNA/r8Tdsn4oHLNLfzbjUFSCASJUl6+/13r1+/9W//zb97/4MPiViFASBJMjxekqoCIxXsUEQQQhEcCWjcHU9v3LzRxPbk+MwDTspqb29/Oh7Nz04Lpmnhq93dGFMIXkGYKmRERCYK3k8nYxFZrRYo6J0j5pgSkRBBaqu4MztbLJOApISEzrtR4a2vNgVctalu2rqZuxBC4ZpGNCYL/7RoewsQOjk52d3dXS6XhQ+oQKKIkFIyHrA1sVBWW5OTkxMRMe+y2b5VValq7vqhqovFYjKZjMdja16WWSWlpAhJBVIEABDNCWjGPJ1HjIwc1axk65Jtxsaw0wcRiSQAiCkhoKFhXfQEdjFCaKmVbDWmQRQIQRHe//Dua6+9Nh2NP7l/jwB9Ecx8Go/HURIyWy80tg5nVxPT0G74HMfjzOGJp4qghKEqFZGYfvzjH4cQRMC5AMPCmgLQJ3yYrVx475lQdW86vnPnBoGuzs4K5hvXDr/+tZ+5tr//8MH90rmb+/seRWIzrkIZXGByjoNjR+gYmZFAHEFVFqOq8J5VIhNZDM6oqiZltTMZF4GDI4fKqoFpVIRR6Zig9G48HqHCcrkAAKvEZuB6HzaT8iMsF0vLL5lOp8F5xxyb1kS17RLQJ+ki4nw+t3AJCxc1E9YgfNOLmqaxWP+cT2NOAOpT2EzAZ9TSNofsFnDeQY9KSxfln3LCvgzycgCgaRruA4G4L0vRx2v1HQrt7YuqdtUEiqL4jd/4jVu3br3xxpvEvgij2c7uzs5eXqWu+Pan5gNc6DT9jIf21vDTzUHPjXwc+n3www8/ODw8PD5+9O6772ZqQETRBCh9/gohATFNp+Oi8Igym45v37ypSR7efzAuypdu3JqOxu++887q7PTrX/3q7RuHMTbjUTUZVYxW7ADK4JgpeFd4x6ioQqDBO2bUFInIByZCFC3LMBqX1/b3J1VZFr4ILjhXhsBInrn0wREFhJ3ZpAphuVy0bVOVRVbZzZqcz+dlWS7qlcXWdbmzRIwEqrHuiu7n3d7AU7OJDbXM5X2MtTLVWoqZnWlhmIY+DbMo277zjak3ZhCn1Lmxc74b9MUSh1ZZzy0YYxQV7EtvYBfthwCIQChAQNl7m1Ky6kvsUAH+43f+ZDyetLGNMYmozS0lC0RXR86TfywY9PH3gfPUdiHxfZZjjfZcNFXs8rnid7/7Xe9d27bQ9ZZbp5wDADM5T86RCyBap1RPRuXhtWsgcnZytjeb3r5xvfROJf7MT3/lzu0bjIkdVaNRrwgnRgjOO3aOkCwg3erAhUDECgqM5IjQBXaIyOyDLyej0agsHJIjZtGgOAIKgF61REhNjSLEaKq89RjVQfUrC7NpV7WILM7mKmJQ6Xg0ssii1Ma2bT0xijokBkxNxwOr1cpyeWPTmv5jXCF97bcc8Zb6EkA5AaXDJUFznSzpiwWJSN12VodtCykl6Puo4iAqsd8cxO5uDNOZK0CqlBRTZ4sBCHZpzOpYg4p3Lvze7/2rg4Od1fzs9PSRD14RyHkDjBgZ9KJQiAsIqPcNf86pK8/bDLG1lpTOzs5sW/yd3/mdHlEe7jaCJMTAjM4DkSLJzs54/2CvbetHD0+893du396Z7Xii24eHo6LQPs2PWNkheVo1K3KsCNb6UcBeHipyAlQFy23Jgfg2t6qqiqKYTWfT6bj0wZIcnXOOnfe+CKEKBZlBTKqoZ4t5TG2XW9NrIwaE14tl0zRJpKlrI3FLyAJVSGKRbbbpNU3TLFepaevFcjlfoELqi/IaxJS3C+1j18xFkGMudDMhPfV5/dQFs3Z9xMwFmcwE649YA0kAsKoZqgkRY5tM/KeUBIG8SyrKqNhJKNW1K0BERcDAruVq9W+/9QcnZ6ehKLJDgAb5Zfo4nuBLa239OR+IKCqI/Nabby+W85Tk0aPT4MuEqjEhEAsiCEBSBHKOGIlApDmY7kzGoxRrJpjOqpdv3BqV49TUB/v747Jqm4bIhYIB1DkGwH734KZpmZmYU699mdqgfal76/Fo8WGWwF5VFQAoovdLVVk2rQgQCCCR4/GYyLHMz1YiiUhIV6sVKuZrmofYatM6BFRQAEs8AOte0Zf4HCYT2mcD7A2iaVLMstk8BjpIkG+btna1ie0Uk7lHAABEBde9vfpnFCRSQleEVdtYnE7bdIntxiR5r8hcJD2iitJF18kgXG2oO0lX9hTbtnXO/9Ef/cf/6n//Xy0Wi8Vi8dJLLxn0pH2GDT6ZJ/jPPx/0kqtLY2/bVC/j7dsvnxwv/r//27/2voxtwqSE6IBA1JwA3jvvfRkKAhiPRrPJLNYtxHQw23355u2CfQC9trs3qUZt2yJxCF3VEGZHRADS/8SMOvCgmp9BJdjnsGJfdwQArJjPbFKNR9X+3m7pvXNIgKgpSUwpFc6Pi3KnLB0ok920A17sUWMfbp/aGGO03gJnxycdCtRZ+UKIVndL+zxP09etQz2KQhIUZUBSsH+paTUmSIKqFpitqjl7Ky94r5pnCd3xW9b+deA423Lxrq8z8NzLoMRd99fefLcrAFjVYU4AddP87u/9nnkbzs7OTO8aXvkL7Qh7vkMH5q+11wXA+Xx+94P3Z7PZxx99VISAiIBowZcKKEl8cMF5VGjbdlKWezuz2DSB+eWXXiqdK9nvzmasGryz65ZlQJIuRkYtGyNh73cERMI1rXdagapt4qoKXSM8yloBIo5GI1AiRN3buf/gQXC+Ti0pSEqMGpBGvoAJPjw7BceL5cpSjQWUQZkxxgYAVVJKKZeYWK2W2iccIiIkwUFCiA4AmeHqDX/NOrqdmVUdGIhn7PUxAEh9s2vbnYwQ7WD+kEW+DqxhgK6RB/TQVgilfX3IKsN9gNAhqaAmkT/642//nf/L37FAvezlyPzzlygWKCMYMca2jYhIiFVV3bt37/d///dFJaUU12Voyb7hnAPTCgBG1aitGxV5+c5Lgf3OZDqqqsXpWZfCF6MPjsg6fJmMJyRFQsBknbCIyHJuMw9kodUn4wKiAoLzRI4UAZnZF+V4vLu3v7e3t7+3Nx6XVVEG5LEPoKIaHUCFcDidzqrgHZEVzRUVTdI5iCRJC6iiArTdPGYLqNiyRIdEls8ZGrW2V2RLFzY7GedvwSBoZwjRSp8db1dIg2pIW28wXyQ70fIuOjxfVZPEFAUSErnVavUH//4PfVH4olBViQlkPatP3wHWsaQKpl/+Oa2BmN+c98HyG9uYUpL5fP7++++HECQmEUEFBBIRBHTOMzuR6NiNR6O2aUNwd+7cIcc3Dq+nZuWQyskEnFu2jXMcAiNqn7Zl3kkEkOBLIlIVq2/CnRwVVKWuxZz5Jjl1DQTEAowA0WFXZ0H70gnu4SM9Pkakpo0KEmNjmFJgno0nyP7o4WnTNIKgkUAFCEViG5XN9SDb9TEz2jXIuOo+DIVlZgzpY6HzkpJSJuitn3kHGH5reHdVTZubyQWQHXSoPwoiYIqJXZfkMFRpLJCs8yQogQIi7ezs/P7v//6v/epfLcsyeV+UAREtQebxbAAcfsTPN3H+vFR4/IF9H6vhwZOTk/l8vlgsVCT1hS+7Ss6I3ntSkJgK76vgSo+v3L45LcLBdNrUC0IQaYGVoC08VoXLCIOqiiSRJEkRnIXjZxX/3ONshmevq/x1uxb3tbRCCJPJZH9/bzabjaqyCCF4LoNHBEZihIJ4UhS7O1Nm9MREpgcAAIGCRJEEOT5+sJh6fgzPycp33q/yZ+21fN3U/mGTkYYPmE/LLoh82oXXsRXK7JZS6jXYDlzKm0Ya7Gz5Iqab/e7v/q7FrmZzv5vDlTTzF22Ylq0IiBBjLKvR0aPjtk0iESEBiMRWk8ka9j4wIYOOfFGF4AhuXrs2rcrxqHRErq+OZokd5lncom/jN2YGWCsGF+zssEEf+QMTw6AXS9YuqrK8df1wZzqZTcZVWRTBOeeIgRFJFEUYsCpKBC3YeWYUZSFWRkESoLROGx+S+xb1n/+1m+3mCd2TKkASSEIKDOtFGO4Sw2GeBMjayyUOpO2FWl9N9VyzD1vJrTlnfvve9773wQcfnJycmFkvvbvwCRgA8fMJkM5Du5+XV9r61On1yDEitm2LhB9//PGbb77pXDCgIvXbNKI1clQAKApPgJNqvDvbCd6XPoCIdy4475wrQnAu+zGTNYJWVcuiokGBGt1s1tvNaFDgdnuyA1s5f9Hi74N31w8PZjuT8WgUgvfeB3aeiYggCqRkAReE4IgJCIFAu8o3CkkVrLuZEaGqthJty1IVwXXs93mWuPjVDP50/rStI4a0Sh/ywMx5D9TedXDFjQBA+whtGJTW2kKf8sA++vV3fud3LNsh7xg0fD3POB6TNy7m9MuZfmM8pwwB7YvqPLh//8c//vH9+/fNAZxSgj4LAhGcY1AtisKzY5Cb1w49YhkKlTgqK2mjdy44ZzZtN8GelIc1ReyeTzdT6htGQJ96bzin974Ifnc6CcHNprNxVTAzKDjCgtFjGzCOSy4cOAYfCNAix7BvKb8m6AH2uD6wRfdwbkM4v6T5T4id7rZ1wlBlsoP5Rtk2yB6GK95dHvYShycPdh5QVVDDdRWRVnX945/85L0P3o/Snp2dMApqQo1PXBeoe5KU/6n9UwELRHr8C372A/tcOBFh5j/4gz8wMiVybdsye0RUMSASrRYQM8emvX5wOA6hYEeSRkWZmrYqSsuuQMQuWxKRCInRezfcnc+P4R9wsxINKlCfgYCABOCJuvUFZe7qJ5tVUJblzRs3Z9Pp/u7ueDQCAAIJzgV2tlMVzgeHjOqIydRoQZUrVSBZw+0Xnnbxwl5eu/fCkfe0zshxnAHTrTO7BVPoQQUBBUJkQEiiMTGgQwrsPDEj9VcgEUhJ+oqzCAihCP/8G984Xcz7gCWVJyqOm9kUlRDyP0RrRPC5VxQCgEs2oq2ZEXV7Ytu2P/7xj5qmsepLHTaH1t+FFdQ5RoDZbLa7uwMA42pUhEJEgmcitMBegBYpESuxEqNzHcZzGU3AJgNcLTIQwfWF36R3XkLvPmOiUVnevnFztjOdzSbjasTEiFo6VzA5RM8YnCs8O1bvmWm9FJnEt2akg1mdp0W9RM/J8vvc/Ad2Ua/q25EMm8YYAVEJxWridQXfdfCv/yr0QVp9K5BhRN3wjmt27ocFNB4dHb399tu5K4LIFzsj7IUNZOaPPvro9PRURMwgUkUkBkEBJWwsHtcxQ2oODg6LgBaHUwQX4woZ2BExAAigZha7lOj7eBLNjqjHHqoaQkjZaOtlpPkZUkpMdPP6DU2iSbzj4xMBp6AqLKqOWEQFIDUxKUGv6XVX7u06VJXzSGi2+jaQK9Dh12HALaaOe+/RvLNDf1b/HUEFgJxLCX2IkWXZD5k832VjETvyBx2s53mzqp8SGBJtPGJS47XXXnvl1p0f//jHe3t7h4eHz7kqBH3eqTMXjqGkIkRiPj47PT4+Pjs7Oz09jdJ3lu0qyFiMdCL0julgf8d7v1wu7xzeZOblajWqPHQaOQOsy86sRd1V4VN6bkO6aiCCKjBx3TRWrQQRbU8QESIEYBFxhHdu3TTVQkRPTk4kMYRCdCkJSu9qFkUWiUAIxG0SAUEEVQFRRMqy1Sx/GfiDu2ljh0V2ADpsIFrS99CWQW3Di59/4FWwIFZTh3I6f+qKbz/WKp0HFfLxzJa9IwLNYffo0aOjo6PDwwOrgPSXCwYFACKyLpzOuePjY2YarmC230TFE5DIZFSNy+pw76BerVbzRVEUgOsgtueIIlw4TG5RXxCXBx0dOyO7z2xyzr10+/bhwf7OdPTynVvMCJpG3jsA8uRAHSZHyqzekdVuYcScSjjUYHF7DppxShz4v7bWbVsKXDJyXfI12tb3YsrKzNVXeJzR61xrRS4lsSbE77z93n/63mt1Xc8X8+eJAnVDnxbw+EyG7bYiYuGB9+/f7+ECAqvgjwooooKohFCEUBVFcA6SOKKyqqgfT/uOekk7PGTaqimsAAk4ASWgqBSVWpUISo7N5kImMwPtMyAoruX0wcHBrVu3nOOXX365KArn3ListC+U6TyBCoA4ZkdABGi1dM+59rH/189N8lSHas8WuQ90qnMrv/lrRoRy1TordQqDMMFLx6etfFalLJZRBQxEkASLee18+c7dD9iXdRMnk8nzYIANV7G17vyCjj5wJY5GowcPHqRkLUfzA3QfBBIhqKTd2cQR1asVAZSh6GM1bfeX/Jo20DcBSSopWWR69y/ZT7B/kEAV7V8UTQpiZp5dwWw8wP7DBXbnWrcekKB9ns1mOzs7VShefeWV4DwDFuyLonDMTNwVspIWNVqDFKQLbJLeBbJely1bE2AdULTFAxcywHBo38IsKz9WpoWIcr7B1Vd4/JE3lhyIYV1C7r7//tHRw9P54jkT63Oc+osYJnLu378/mUzef/99AFBR3URlEJUBGLEsymo0Zk/jacWBgAS9MCspKLSAUaFRK0/Q1cXq+t4M7bPHn5h2df3tyxtfH5L78MgW9efdaX9/fzadjqrRqy+9vDfbGZWVI2/l2r1nBPXeOSbCbhM4Px9DX9Y1mnq95TwP9HffeJBPfVb7T+pb8QFA0zRlWW7FOT/FuOzrma+Y+YMPPjibL2/cuv3GG28+TyP42VW3ZxyXGZi23ogIhHWM83Z1e2fy43ffigxNoyoIKl1xN1TiFEJRst8/2J9ORkXRNYpwjgFBEFBF9QKCGBpeuuk47x3Q6wmep+n8RRs0aE6Mg4i0LfIyHsgHc3TN/u4enhyXPjA5JXy4nJ8szpJim6LlDSuRY9UETCrpnIYDnR28nq3mYg2oqkimvoNoIrKws8eS3FZkW/qSWNz17lUDgqww49VmNCKIbFRHhMegvWx5227w2mt/dnBwYJ6W5zle9A5gfqJL/11igVmUPQAgog8eid55552HDx+2bYI1rqcAAqKowIiz6XRvNisL74g9M0F+5aoE2NeYt05JOrxVv9YbIhwuwMivfM5Nu/zyF5w3ARw0zgghAONsZzYaj3Z2JjcP9sdFubez69l57xkwsPPeO+cdkkcs2EyaAfaCvStu+GybToDMn6pP1FZi0NayZzkbhqJ2J23ddPP6TyFqh949RHzv7t3XXvv+y6+88vyL4w5tJoAhdaCV2bra8n7GHfDCMZQW8/liNpu9/eZbqRuQbUAEYYSCXMFhNhoVnjS2RB4VkACxUxYQUfqQCYOQBs6jJ/aVnhtr/WkLFTlvAEC/XHm7wL7TKBI6YmaazWbee2R+98MPb1w7eHBycnxy1ratZyZG8mR59A6oja2IGO5kd6ReMgiAwLrtHGzK3bw/XM2rw6XISC70Tj3zS1rOynAH2NT6DEK43MN48W5gqR2giikpgDqnRPDRx+8fnxw9fxVIVbft4CfDvp//QOxigImoXq3G4/EPf/RDUEIg1aZnOQVQBg1EVQiTauQAWQVBHJqtiKpiQQq5QLH2sVYdV/cvR3q/QjcBWEOOsBX81qn+CKC8qXXgZjMb6IHX/HlIc+YjyxFmFihfVdVyvvDev3z7tkO6+8knOJumtl2gaisEQEygTqUVTEzQNgKE598WXrStwYDgjDqvIP3hbigqNkP7evYhIKI11+jzxRQAiFlFRdW2JBV1ziVIA8tFASBJ3767D/bekrND8RRjTBIdh+Pj4+3Qixeiw2w6hj4PQxkzmVohy3feflsERBJoDtMn09Q9u+l4UgTvEDxx6T0TMTt2jtghsSJaq18Ah+hUCdElZQEnAAk0a8+q2p2JJGZfXykI1iujG5pP3hWHiixsCryt923AovX3FZHA7vb167evXRuTu7m7tz8el8wowACBySExIiM4T9rHpyUEARCEy1S3tcGjFq2w1mryCWui6j9k/ScrbPm4sYQl3ROzIgJREkEm4o5bhtGB5+fzmKRlKQHvvX/3tdde/+JCls9rdCoFgoCy45PTEyY+eXRKCRlYk9GXICpIIkIgCIyMySEF9E4DgENiaw8DYClc1NvBW7DPUEwiIl86rctmO6BpPDegv+6WxblFEIho0IqlK1RVVbe1QLp5ePjy4Y0x+4PRdDaZFt4jAAE6Jk/ICATY1W7oG+zqZvvnZB/QIFtU6X5K2gihG0QZDd/C+gEzSw8TIDMPxBhV1/XhcoioiGBfJe7JF3Y9ASsZLaKv/dlrf/5igRT0AuD68hFBxISH51VsAfGD9z5slq2FvYGq7cgiQqJEFJwvQ7CWR7nIApHriRtQMcf/6CY4o9oFLyAwWFmQQZW/bv4XYef9kc5Nlo2KoRmQP/dpa3KeN/LVejGpgOC9Uw2r1QpZrx3u121zcnoaikJT4gbrmNoYicgRqyZRUcQoEZEEAQgt3GlNwX3cyAWvZgBtXSaM83ZhOlueeQ4Ftb1ao4aiAAArG5p3uRQjWvuMS/StT1W3sfcGOO8PDg6+iDvAFfrYY+YDrN8WdiaXEeKDo6MbN2788Ic/VARy3MRWOxesgiREDY5D8EUIzOyI2TEwEeekDXOBmRtLN3QAEFVLKOl9AgoIbJwwHBe+ONwyC849+1A7AgDHjskRMijGNknK55uCESXVCBEhASYkCYXzgRWTkuwf7I7HY0npzp1bk9G49CE4ZkRHGJxzhKrJEYEqqdUXQdj0FVxB3J+qhGR5MVzAvG/kdYhttHJduBkogfTUbrL1IzCzCiDAu+/e/ax2gGwOKuEWuvZUV9u6wPnLmbYtAEAYRYoQTk5OLNLnzbfehGx7dT0gIqbEoN65qihCCGzlQNkKsXXFXPOTDAX/0ATMW3mOJFjL9azED4TX+gPZpkYAIKnDVQCBsI9gViDoPhOQ9piMqRApJWubB10kH0pv9BvYwszOkQhbcYrd3Z0mxePT09lk5LxHAjmbNwCYtGAniq1ER5xAuiqcg7DQjmr7V7qls0F/8DKDWAeYaSZl7av94KAiYozREk2J1hn3pmc+FaSy/lLuv9227Z8/Fej80J7cLz6CqKBWzfjRyXFw/sMPP7S210QUo6iqgrIoUpc1X3jHTBY60A/bQ0z/NmQa16FzHZUTdi4hiz4UAEDqSKXbCgZwIQwohrDjaVU1WoLtbWHT0TYAhazJLvH6msysEodniogVcE4pEQMiHlw7WDY1YEPsTM0+WyxaTQDYqiYlUUFcx67l1OSLX8Fmx8FPU4HQQsm1jyaUQXW6fBwRrep6CIH7jmMxdjlcl/HA5SrQ+i/dXQS8C58DA6gqXj7NxxxX20Ha0SMKqKg2bWNazapeEeCjR8dIJDGpKjJB1wekBQCPWLgu1s0zkUJUIUAEZURQ4B6/U1yT8obN2s/hMhF4fhhLZagRegbYusiWvYE9rmUjpdiVfLINh7qS+dRXGkRUZnSOAQiBHxw/GpWliDAgwkiSgsKZzBWSZ1JwbWx6i2aDdNZie/ATDBa4egdQg4C72v5DwEB7XCirOs65pGIskbcCCx/6lHf/GMNu123xz3qxJx9ZK3jqoQC67WlQC1m367YphhCQiJVS03jwhI6gIimaOi7rFq2GH2rqql4iEjjvvHc+ePP1mgZjEbM0oPUOhDnHAN1fBwR96fzPaVBG892vg4W6kIvy1/NfmTmm1rhSe0xqS3NA7MQtIgLq3t6u8/7k9MT5UJZlG6N97WQ+pxQJUnCsMYEkZadAClYzT8EQeVDdCiLSLa/Ipe7hHLeBgypAQ3WINss9mBGc29jgphb6pENVicxt4txWkZzPbCiAngeztKegy7VJyYfPX7S3j4kIBU1gqHTyQ1UWiwURvf76nwFAjAkIuhgYVUAVBOd9qIpQFAaJkKlARu79/dZET9uaDGbd5TG2ty2VGgC1F4HrVchPdtE+kA/2mLqTZCkyFquDAklRsf8Xo9XDISJhBkd+Npns7+2fzueIVJWlKEpKTUqikEQElAk1oagCDrBHw0DP6RrnJ3bFsxsVYh/jlPU0W97sWMwwkUVJdJFO6cq4o14KXsYhvWTDGGOMnwcDmBS52FusoHCxm+MJLg5g+XWIGCXl6gyW4f7WW28DgIJ1KhJStMhLAmTHwQXvPDFbti8SYteRdOMuvd7ffR5yAuGQWK6aJw4sSzto1aGhs/LWGw4MBKT9KtIle/eOZPDOdy4k6z7QIVFdQbUO5+1D5RAxxsaxn81mdduognMlEqGKAPoQ9BTny7knstsmUUDpp0SdUnQuJwYGjH35g6//nvWfreuYigKEQ7e3df+2lDeDUAe3696vqjJzbjN8+RwQkRExpctzgq+4xLMQ6LOOTzMe0PolOte1YSPH7Gxdzk5PZ7PZ3bt3jSCi9m5LVEnJEwV23rnCe9ebtgJAfYtC2PRMwYXiHzuzWHu6vFAOnX/xqh2u0y+7bp18/osZcco0Z88OBh31M+mTPftu0n2kTfC+jWkyKufzatU0AFCVZYqxaaO15BFNy1WNIKDI2Kk0qccWFAhBLpOyZntvyWnUzhGuHUq2xj07LrfQdFGr4qJq2EDX15GINIl28J3mW4DxpKqqqIKIcNb0AKC3grZ4DPuypxcwwNXc88KHroM3uwOfJlQ2vt1rkAYaMHUQsnVIL6tqsVgYWZj+g4goSkgOEiOVnj2Cs8wRQjQDGbpyZ7lq+bktoRu4BiL10wz1brZZJEPPjVuBvsOT8/lm+A5DD9JAmTabBsF0qnWkjaVc9aEfQAjIPJ1O06NHQATQMpJzLiAgszXSc8QpJbUw8E7N7IyMizQhBc37AFl/0TWT92tm1AqGfRmCzLat6XAzhc2tDwZ1hNar3R/vz8xxpmupJH3J0bxpDDnzi+IIexylWVU/1XrGQaluIrIYKaOcUPjlcr5crow61xJCwQOSSsWyU/nSicdkHcGYjZY1e4JMeJyXEVk260WBAJc/zsYX138YlOUZjuH5W+Yj9uHQ2Otgzrkcb2PTNtI39AMs+RC0DK4oCkIoimI0GlUhMIBDGFej/d09xwxiHelQhZNg04qqoCYGYRDWRJqoy3YTgNT1MN1cmccf+fzhzqaDIij54NbKD9TFC5oMDNXUocT5ojDAYw5U2ygvHVnem6cDe5zBgn4fPnyYkq3OuoA99AtRuKJgb42KuPcAYB+gslZ+Nu91XkTBlW996ytb8kwvOmdrqtCnvWZW1IGuz8yIbK3g7AnsCPTptuY6sKcDZmCajUeVC6gwqorZdFw6l+oVI07Hk/2d3aoIqAAmUwCZUeWKGLnusZ6lTpRuNlnKr6DvsbfxFi78+qdeP48viiMs+636KpbD8JPheYBXRkNgn1dha0SEsbWAHCSijz/+2DRFZk4xrQkI1COPqypYxc++GnOvLayFTX4lW0S8QYuP/9SbQh0AELWvXrg+4fy3+s0QO40aAGyvB1BVRy5GbdvWeUIiAEFARs7Z4kTErCkpITAzOi3KQmpyRCBaj8d12yzbCCqjstzf2zk+Ppmv2igJkDTJCy2CNpDQmqO77Wduvp2VmUFO5kaVaYANK0vPGUv5yBeFAc6Np/QVqKpVEIHenY7A9rRlWX744YfQBwggWFSWAKqKMlFVVs55q3pixT3zSl1A35c7fbSHw+1X83pajvsaKO2cdaiCuuHHNpqW7Cc6f3E4ZxEN2dJm65xvk8Q2Oc9dI3VFVc0V5rptTcUsorIokwgBjasqSkoa3WJ1Mj8T1JL90gdRPZ2vXAi2AF0Xnecx8m6X+SqvdgZGMyp6xf5JRGYE4+ZfL3w7+fgXlQGuRHuuYI78bFZ5zzln4fnWefzevXtDFRCz0wqR2RVlaetIvaoAA4GhhEnE4hwQLDM4GxIIgKiEfYc5gJ7aESUpACB1tUkGfpzOaNt6mgHRXwqr66B01PCJ8teZmRwtl/PYpt5DnCzrqg9qAAAgJERhZkbnGycizFT6MBmN25jKJqTVkh2WwakkKYtF06JFHT0J9W+peedfmQoQEXS7n1GzZW9tWDtZ8OcKefn6G2Q9+PX8ymzd/YvIAIiX6D9Xkv6WYLDoF8Qu77lt66ZplsulkU4vxsDACgdpXBbjqiCn5JgoqDqBrp9vUkREUSSbQLJ9Gcyjrdq7PDFZ/4EezVj38AHomutk+BSR0rpTyzYD5GfFqwzu9a/9aR2VdKQgWLiiaWsUYCJhbmMaOAQUoAuIUtLO5yeIgN57XGERfCxD1MQCUmrbxuA1prRoWiBSdJcgYaCdP2fdyX0488s4R0RyONNw180MkJ0YsJlEloPnAHKIUdejbUgVl3HCF5EBVJWQZNNO3TpBe8k31Ajrura+ojnW3Hp7WWyPSDw5OVHtwPKYlC2dRQREiyJUo7IoilCUjh06n8P4uxfgeDgBiX3AfSZrFNzwgukAZDMh3X23n3n3p8wAm1psB29f+PjDk3ET1ljLS2BGDq5QSQJ2e1JVhB5tJBEBVmhTo5jKiheLWgkdwnRcAoKIpCiLpvXOee8RsG2To5ieSvfJD361SB78aa0LDa2v/KsOfHwAoH0tGefcUKu84i7wxWQA6BkaAASUSAFR0YKAQQC0D5uRdfgANE1TFIW1ts1VN4jIGn4BQF3X8/ncLq4iVgKOmFBR2liNgg+uKArnggAyoqpsTYloo0TzEE0gIkCgzgVrWo0grvdlg7wHJS+3DWu4ANHbIPThBwu2WVMSoalEUVUVCABVk7TGt4b1EULhCh9jShEkSYzAhjspqBdZOeeZmYEQhYiTQkypadpV0xAoEyhx8NxEVlEBuVRJ7YzzDTMULhJk51+6EXTXcBLQwLiMCNFmapG9ZejzJKUvNYedo237pi9KBTq/Rz+RgnjVlfMFNz/LuYBbaxtouq+5wHoaWiOGi8WqC6sipwiiipYWgUigO7OJYwbkDn2BNHwsE0hJQVWTKvelEbVPdiVQ6tQc7XX3bZgI+5giE8PaPaEpC12HG+0deYj2oNvsAZ2vo+OrTjFA6jxwyEaclr4fU8I+360V8RbdBJbWjJRqRnSACBRbQk0huKaJ3jsRGJWqCpqkbuoI4pmatnXMDqEFxRzn/RSvdcAbw70rS5TuV+xYfc0SG5sAECBI53xkYKDOx2zmPnQqLigoDCrAbhGn25rWhSdd+AAvevSxBBf8JU8jr2CMsSzL7fNsNbUDEJbLZdNE2/8NYhZJpKCaVKUoSmZvBoOiJk1daZysd6ak0MkhHDihslY63C+IyMoIZaGFHQ604b0a7u8J1u9+eM4wXsAulbERABRRZlJAImMXiCl1nmsQRRGLerVmcqoxCiMmBWLHkCSJJQ+wc7FpgnOQIIGGIhABM6Fq3TawmNdtu2ySYwjORY01yKd6Uc/rPHmYDS7rkGrsY+y6rcPWjftFoM3ohu7W2hU069anr7ehg7eWV2yzYc96ONWtKlxfCNeYWuDnxUIGezuyU4GWy2VVVXmhh8uNiERslSBOT8+w8ymabDNyiUQQimI8nsYkojpfLsuyQtUEyWJRIGdXdW8iQVLboaFf62GGLpguviXhEHtIaUOLhU0G2BTza0/QcFvfUMPsAxE4Zs/JMspjYiLu7UjbGKMmRFHVCCCizrmCgmgSbZi9KhLFlFIIQRBSUkJk5qLwO9MpEiWVVZPqVR18aBRaielKMai6DtPYGtI/ylBRB9h815s6Zl63/pprAbGl5Nh3bWce+iuGYmV4tfMq0FPvbM95KABmqQDrrSBrGfYkKSWr9TfExfKw57Ta84vFXCQCclJNmlBBEZRQVQSprMbLVaOSICZVQHZIwOZAMxJvo6pYfrBTZOp22KGEHnqORbQrt9JvAnlywzD9PJJmfWoN/w0fJD+chcirAmFfVoSQvHOBEbFt2xSj1XdAUERyzKrqvUsGIFrmIahj73wA0mTMCSOwyFB2AI2IsNNQcBFD0bb7k9162Ry1TSq8xhaFnke7tkuHntNyN/WfLnECByfnM0WVztHweW6x8UU0gvOL7mEURO1yyzPJYo+Rt21bFAVsqsj2gboaMgCDetzYV7BhZEYCVQZkglXbQGxTCwSaFBQJQKznlKVNAYCzppAAAARAotmXrABAoNwbbQDASMNNABH7FJoOvMr1z2xilrw21KmgZ4O+Ifu6KW9d1yLK5E3QKwI57wIJUIpJJIKK8wQARVEUZdk2DdQoIg8fPrx+49CxFwVQYhVCR0wsLToC4L5cXkdaHWcFD4q7s526bbmVVRtXzeJql/yz0oDR67mUAzhHxDnK7YIrbOr9F25HXyAGWG89uIYYsPdVdVkOPbt34f4xhhBMw9tSoNeXVaW+Xy+R+URVRAhJRayqTVWOYxJI0saWUFdNzEiz3RX7pr+u9oUPpWNGypXs7acjzIqQc05gO2SgV3HX9J0j3ow7BXIMHIhKjCmlGGNqUqzbpk2apG1TFIW4jKToyTvvkEhSYufQsXnBU2qRlBooyrI+O9OzU0T0IWgUADg9PT3Yv1bXNSqqEDMhIZEtIKqi9UcT8Sk1Iuq98+xailVVTscTWjbLpjmZL9KFBtqTvekn/+raSQKwHf7Qaf92BAft4Lc8EkNG+uKqQKBAXbdGAADAjXrFefT6Rod7quqWwaQ9ktD/iRqNzJxNMAAcTyYiEtvUNo22jaq5JvsuLEkAoCsR0dS18yuiwgfv2PUtggkxykbQpQ5EflfYA6Ev5kDS11HJ8TmqCkmidk2kY0oxxqZpmqapU1zWq6iAqJYmgohJpIk1SmuVI1iTi13AM5KKtIqwbOrpdCqiKUZAZEArs2M3res6OQearNyXc13to5xsAwBMBALOueAcEk2qAhSXTeGY4yU1nNGAl+dBRdlI0G6PXeNF/eu/8C6X3lo3AQZEfCE7wHkx/KQDbenzBWFQEQg78WmQP2w+1XA3tF+bOkKvN6eUrNNov8OCqBLTqKpijKvVqm1WqW1F1LzIMbammQMAEmIL3JAnLl2onQveF0URQnDErGAJ80gEoBKTDKIve21eLCqTqNuFZIsBRNrYppTatq2bJvZjFdvFctFaNggoIpKwtCmBMrNjNnYnoqIovQuOkJmipKZpHj16NJvNTFdkX5Rl0cbm6OioKApHRYoRER0Cgtr6iKhz3FMYGbgUQlBVjDGEUAlNUhoVJ/XiTC+CTFRVL1JdADqxRGAR1p+OOl5GSJcp9D21XMp+W3qyfmGD4Wzb6qCATP2Dh+r9+eshw4yQfmmYWbUxTSq2rbm/kFCFBBRZKYq2jcRmPp9DElEkx6jSpjqltb+diDApKYqSkKSUXE2F98vVqiiKUVEW7FLqQu1zHDUMSnaqKhH0zrV1gLv02QtmZ0dJMca2bZumsQ8xxjq1dg0RaVMUEQbngAlE2tTGDg3zRZlSJEKIXJYOCaFpSx9S01rFWRFYLBajcaUCbdsqUWv6ZooI2m9ckBIhqoIQoCIBJO9IE8WEIQT0XGs7mUwe1TVv9CMajotJ8Cn2hQt1WkQa/nV4zhbac+EVhuOLzQDakX7XKHkgR7L+nR/vwodsmoYYYyurVVOEwjSHDiPrjGlgorIsGRCsXxVijC0RJVEViSkRYVKhrr6zpITCDMjQqHPOsKrkQ7nZ3QR7N1z2SUtfuNhi0Yz6LVGh2wja2Epq2zYzgJmkap2dxHpls3POUyDBVapjTJLEcKC4XFh15bIMknA0qqqyRERHnJqWPBRlkYRAUSQF76VtmlVdlEHUmFBstYmIATMAQEQg4r2nJhKRQyy8H1eF5Z1e8gKzpv4c7OS8qrIZN/tcrvx5JMXbTwLZckFkbd+w9iuf9QqezlJBex8KEZycnEwmEyJK1q5LkZAsRJQUgg/r3HmJhjkiIWCfPphRy2TgAipzBFFJ0jYqgojcM2g2HnL7k9652ymviCiyTnHK+4Cm1MY2C/7uuEiMKcYYRYiZkVBRU4oDyAgRVbTVhpRg2WoKVVm15Byl0WjkkJiZkJpVDYTee1Btm6byRaTWzAYRUU1W6UREFBCIh1gkERVFqGMrsXGMVVV4wvZpXaJbgMwlYv6xqF03T+2ufO5qsHanDL744hhg6wm3oSsCS1w9/6fnctMhIoSIzHh0dDQajSxZTlQAWK1Imygzs1vnvqTYYUqk60SwjtQ6BEdRQFWUwdqCkUJd1xS6+n729Zx+jn2EXB+zZ7CPbmlBKaUkKaXUl+gBVU2S2hStyC4zISN2/lEBFfPDGdjqvXOuMt0rOF+WZeH88JUTYuG86VVMjIBt25ZluVgu6noVQuhova+9EwF8/+w2meBcGULdLD1z6b13RC3lNMXHeZXD1meIazMANyH/C98pAHTV8xBg00uQQAQQAUm6PGPBCxLWzlO/fC6d4s2TZRjJc7zshdRvR5iZCOu6zsKsK1zehRCId84Ri5UeIBLBEIJ2qRVol1TrIq9JCUgFUFQJREVT6xCEMEUAhGggehJA11dyNS1IRIYF07fsYIM8o0n7lKzGiQxSMbnvw0LMqKAxKap3nYVtRUyRKDhXhsJ7XxSBkS000Hx5IFqEQlQ0ie+LE4YQeriKANFCklC6GltEZLXDEFFVqjKcnIkjHJWhCOFkUW9RVf+OTfmhrYBC7fXYjGdsf3EwslG3HoPftuzg/qVvqMRb28iWgmq/fkFtgOc1evtYQwg5Ux4Ak/R7ImhZllVRsEZHpCItgGPv+rqzAHl1EUVFIFm+rQqqQ0QgTCl1G5pCJAnGUaro2NoeSpedHAFycxSwlJ2+U1PKmE/vigK79dDCsbeXRByaZwOYCQGZyDlHxABdWjAzOec8+1wiyaahMSohIQbvtYvXAOaSiFJqxaL0VLvKd5t+bkR0FBwXbWrJ+93peNU2y6ZtU1SlPgEIQJWURHUrO/7xx6fqP3iRkxgAdLMWy3nmlEFtiL84DHChurWhuHf91tls35RishQkUEQsQvCOWQQAlQnBEQIDKnGmm86RbJlhRH3t6VYVRRCZBVC0FS8FsiCDCCmk3hHQK+tC1EX4mA0wFPyZ9DNX9E+hRGSF9BBAUJHQO1c6z9SZGX36MhEyESqAZXUSEPbNMnIWlSfWnFQFXSA3ADB76hUDpU5AEDP0OA8RRVEfRqf1sYiURVE6T8htk5oovZDAq2m3e0dXWsf53V3210v1pa14osdAVz8fBng+6MDj365rRF6rKtrDo4BFGwMoADMzCioiUiJCVR7EwCFASinF1KYIokkByfqbQ0oJkFDBnFopQc3mgwRVNZBEVV3XanVdCdk+D9W2rJXKoLREL/iRCFWRCYTMSQKOwHtfeO+c896ZfO7AMYS+8B4yAjOqqsuZYoiimkRTikAWUYNb08hnDhyIAACByUCz5emJA/S20SyWbZSuX2p/nRf6QnOPtktP2JT35/8El3uCu5Oeo236Ii74RAMBptNpTImZrSpKP6Xu74hWXBOVlIFVxBE6YgvCEBHnSDyXWhpGWTfLGKMm6US0REZGYNOaWgZGcsysZCnCvYu6WwoAgD7qIVP8kAfWnlhVa0XWNeUgtXomgbUs2Hkel0VZFCEEQFQCdg7RNG8DoLr+AiKiKYl0qCUjmhZnuTJ5QXRQjyjL8j6kChFRAYuiOF4tCh8IcFSWjYhnWj5bQcvLxqeSzZCabaNPPc5mNiZtnjzUDmxcyADa/3yeodEvgqke91SEqqrKqvLeaxNzgoWIWmaMc45EkZB77SYQmTzN14gxSuxCi9lR09Sr1YpJRZKBOqiiCVUpamqgZaaA5NkLpKRASAAG74oqoggA5g5Z+S4ZjNp6VkRCVCV1zjnnCu99CFUoqqoyk5ccE5F5owGMXTR2KQxd7GQXcgrrO25p0ltLOmROMKpSIGbnHMcIIlUoWAUUCHpPzeO94k4FeELHmGbwZ8OzfNXJ5w/CYzPA80Qnh9a6vd7PUgVSVWZXVSPnXF23IkKE2gfcNXXtnENNmASZLZ268BS8ZyZEZXaatG1F2lh4bprYRGeBqW3bCmluUYSioJEoAEDS1FcBXMtXRBzE8G6nLmwBFxuLZrAZo3MUCheIy+DKsiyLoirKEAJ7R8zA2LuZASyISdQ0fk3Je9fjrgoiKeUstAtYwj4Miyx1x0Uck3euCAWjekDzBprrsHu2S+iP+re+xtce490Nl6X/cImnOXtFHsMNfJUK9HzHOazqOZSUeSItUxFaSbfu3CEXoswBFARUUMmp6OnpmSOOCRDB5K93riy9d2S1gwhUGRldQmACQmUGiZwSiCKIAmJKggDIjEjm1BJBkewDHmYkmZbejWFABwxK3+Q3JyKIFj6jTOiZA7vgQwjB+65+kapKEiTijgIR7TaEAoJ9pKT9CUBBBdGMbFmv54BX80SlM4VBVTSlpEgYXWqdyM7utBE9rZd97UnotK9LUMhnHEPihscTz+cp7bxt8Dn1B9BPiRe8kL6fejVVVSRVVTWdTk9OTuzihJhERQWSLOuV4+7dW9izKTUAwjqIy9Bkqe6g4hgL7xWABjUrVdVK0AFoSjER59BUK85j0ksVQKw6i6rqMJY7P2mWfD3nJIXkXBdulENQpe+lRUySkogQsXnHxBo+AuZWDIiAqACJHUmrQBqlKzaJfbPX4aKpqgXuWWIlKYAiqUFP6pxLSRyx4QSglwr+z2V0S3qufffWDD9jBhDs+s5aUairFDjZTDJ8lqFqES5469at999/P0sR6goR6vHp6cGsggvq8FjJbVAFFYgpxRRjir00Ak/cJlEixywqmgCM2siCitce+E3lvstkHT5dxj2p62yXVMFiV0ETiLJjR4gCpAAEEaRODbSq6hVBLIwH2WJDEZER1areqfYTABErDZQrw23Y4hYhnoPbVNX2I1xL0i4ynDgxoifn2q6QtgBA6jLZ4bk6+K8Y20bw5ofLTjbethW4igH6L2wQRP6EiE9qJXc6n+F0j71Az0WoEGFMeuPGDRiA6wAIIsp8/+jBtZ1XQJMlWNrWqaqAJCAAmpICUFRICilqSgJAhIyYbENA7HDGvoqW9DqF6hoG7YZIGjLA+WROREgJktVG6wrBgKQE7IhBUkpNS6KttWQFVKCkiky+644BCOCcSzFFSVbJixHNGIgxqnY1tGPS7HwQEVEZzgNhkJmEnXWBqEzgiKTPnrGUS1GxrkdP9F7WkaS6No0ROty3S6ReL4vlyNp+s67LgoNY4O5iFwUXDX9ms+fqBhnP2VLV/t8leQwb47wp8+yccOvWrYFBIogcJTmkRw8fwZdesePMjF3pSyv+hgIqIDGmmCQJCLEopARCHIETqmpE81UhmyfVyrIMn8WG6zquWg/tjT/hoI+LSFffJmkCo14ARDZRHGOrKoTsBDViUmUQ1KRJGkxVVZG5sQlT/75TStJ9iMYA5oduNxlg/abWaZxAAKJATICoSRDBETunIhBTAtEQAgKQghImEFCLerrqTVEfFcRDGtNuQWwG0GcOfOp4TMLIltVQv/hMVSArawWdxvjZJZ4hoogi4Y2bN513TdsCaJKWWASEWE/mZ1ERgVgpKcW6bZnrBttYzxdn9uKJCQDKsvQ+LNqF8y7Wws6FoqhXq7qumdnaVyGiakLrUdn7UG0T6FvhJiFpWyHSXO/bRDIimhfYNBNGNGSlC9ZPYkgoO6/om0RJoG6axSo5z0AAjiNg8N4xny5Wrk+FizFKSqCaUpf1EmNS1TZt5+VAZyp0srx7AEvFRiU2SI2diEByIiJRUEAjKSqpUb6C9Ebep7zkZ7Hrhl/f4oEsN0Ulm2Fb5+hnHwqREKx2y6Dh2gscax4zixbdbGfmQ6BVnWIkQsCuVFsbIyJak7kY44cffvjd739vvlx0kcmtBOexyyGW2WT60u3bhwcH4/F4Mpmk1CJzCEEkcR+aNqzqAR0Oy32UDougEliNWivpNQwKIiLm3lNhwaZqdXgp+IJYgWnZpg/v3n37nfc+/uSTuq6Dd0lVUbznw8Nr+7t7ezt7P/PVn67KqioKSWm5WDRtSwiSRABjFBWRpos5F5FO+SBBAug8d0hEQMzQxwP2ihABBucEwamMx2PRdjqbnJ6c4QCieXbl4RI1JjuzIHVFWi/Ww4dfxwGokE+wTeAzYoDeVPmMbKPzg4jaKLPZ7PDw8Pj42CQugeUeSIyx8w8pvPXW23/2+g9aEXWeR2OJseIKFVOKjIhJZrvTYjQ7Oj07nS8ny9VsMgk+EJKkqKnH13CtNOfdtkurdw7AaVJmSakDSQ3MsQjqlFKMrYE/bUqIIknRungTg6O7n3z8gx//5PR0Na+bohqX1disVUJEwI+PVu988GZVhNd/9BOBGOv69s1bL925MxqNZpOpQ6rbRkQkKnWluiRJst6EzATSpYYhOFXrJisdzKNKbKnZyEQeKCWejn1VlE1tpeouRO+edVwouR/nRtrX24O1ZmUh2Wtz+cUyAGqXZGQJAPkxPpviW1ludTclIqKDg4O33norSRxiAlaIV0TuPzz66KOPNWlZlTWIFoGklJZESQRjTIxOXDXe3U1NTQCL5SqJHOzujsuyXi0lh+NiF0vMbMW1EPoANecCIKgiJUltq0TatgBAmzUmRJLzCOhSau1ICEXhy7uffPLaG28cny0BCJ0nX1jOu4IiOWGw+IxiMp4c7IJI29Qthx+8+fby7IwRvaP9/f293d3JeMZEXRI9CDMTKqWuMrxzXrFlYhXT6LCP6UAmJxIZwSNh6aWRndmsbfWBqqYEeHEBtqceQ5xn8yAO7UO4qIQeAAhAAnV9j0Powd582RfLAH1XwO0H+MxGp4d2TQCgruuXX375jTfeOLr/ALLHmxAEUhJrpDcajc5OTs183ClHwY/uffLIshEFJIkURbmzdxBjk9rWl+X87OzegwezV1/ZG42Oju6jCCmicpQWNAIlBEcEzMzsXaj62ExlBxHRyqRp20EuNpxzKYGCQxSiLoWS0K3q5vt/9vrJ2UKBm5gaBZcMyWVLEDAkFNGHclxUU0IYMUuM5Wi6sxcfPngAqb5794MPPvhoOp3t7++FIjjnEdQxBeRQOFO92jY654qi6NIIFBAJ+1z3LkIO1BNVRXj51q26btu2IR/oGRkgq63WYW9ANec0oh4O+rRsMlVVUMKNfgKZeV64CmQ9Nx8H9jk/niPPICIBlmXx0kt3vvSlV4/uP7CgfEFKoo49EjHSuCiXbuGLAJJCSnHVjMsJGQzD6hljTD/zs1975UuvhhAWZ/O7d99VgJNHD3/04zdfefnOeDKplyunBCrStojAzN57SxMz/ccUDOeoC6/GDvsXiqlv6hFjJEIkQbQI6iSCsY0/euOtT46OEnFRliLUxDY/nVW/8+SIaDqa/NzP/JwDJYJkqfT1sqnb3Wt+cfZw6otmuTo9W9x/9BAQq7Lc25lNylHlA87VeSiKwhJ4mNmR5QZjB7eC2cekouwCsIMWpmU1GY+dD10X92d8aRnn/DR450K8fwgYDvX+DAHBZqTti2WAhJZZC/DksM95cPfCcbXW2budLA4sLhfN4bWdw2s7gAmUwarPKcYoClCG0LpWRYjJEwTvVm1E0Wk1WrbRCUaFcjQ+PLzmvS9DqPZDVVVvv/kTAFicnLz13gc/+9WfPry2++j+AwDLtOxsX+fYORdCMDYwF4SIMqKAWLCDIiXilKI9NTNhVFsDEYpR61X94x/9OFRlkwQVpuORLJbec/9qVVURJCW9fefWnZdeYpXF/LSp66ZphDyzhkAwSis5bTESY0Ekqm2dHnxy8ghPyoKKwo2qKgQ/qqpxNYq4dGVC9Q6Dc945JWZH3FntCEjURnHEVSjKolgu6id6v3o+IOCpzOcte/ey28Gas7pvwQtlAAVQ6h6vKwZyxckX0fFWkZ+t055of7Bdm5lHoxEifvWrP/36D36Scbq6bs7OzvZHJaA4xlER0Eo5NBFTKhhTa2mF+As/97PjIjjQdrkkRAa9ce2wWcylLO998smbb771X/yVXxmNJ83qTMETK1st0YH4z4EMMYoCOhcsywyAUKNlzBBRjADoEVOM5rNMP/rRT5JKmyI516xWs8kOEdWxRUZQ685BAlgE/7Wv/vRkXEnTetqduzPzvSBi256lGAXQhVLrxoFPqVUCJueYUlw1GBHrGCMoMBJB5X2ycCPbxNixZ49WlQNEAZjRMZdFqEJYLpdby/4scFDvh1gPXUew22fKyW7n6WFIKqYFGciBuW49ouKzMcBFVNurWV0pw67ZEQ7/9nkM7b39bdu+/PLLzP71H/wE+lmpahIBQO99WZbWYcB5j4gSYclNvTwD0Rt7+3euH2KKcblAwCYlVcHYHkxnFFOaTo/u3z85eVQVBUhBTICRSUMI3vuiKJxz1HOCiDKBAnp24oQVolh1RUtAQeccCZHGwvNitWKGo6P7ezuz63deBkRiP9mZXTs4/Ld/+Acnx6dlWboQYoyo+PM/93Oz6bRZLR0xgDhHB/u7KaXFYoEgo+AIYLVcxbpWkbpumqZRVUbSBEhCREisgDFGJETkXBnJOIF6F4FDSireUeF4HMrpZHJ8fCIb8WfP/4Xny2MX77f2A9jPjPr3Ih9JAWSdJi/d97rN4NJO8Y+ne2w/4XpDM7D/88E8t4fJIcMxYowvvfTSBx98NJvNTk/PLCqDvQs+OO8qCZNRRaBEVJalpMTOA+D1g7026o2bt0oXmsWKfGBmApDYOtWd8bgguLG7e3bj8Ojowc3DQxccJ4hJmMF774M3S8CgKGSCFB2QaHJIApxIgUFZVcmwUBGp65p9oZCqiuq6+eW/8sujcjLZ3VuuVorgQyhC+Du//ut337v7xltvHx+fTMblT7366pdeucOYHDMClKOKaIxEZ6en13b2fu6nv/bw6JPFYt7UDaoS0dl83tStGbvL+ZlqQo9sdANaBF+WZVGEoihCUfRtR/ruIAiq4D2FGKrC701nH+BH+lwr5mY3Yvceu0DoNa5vYLHJdhl0hF97shFVLogrW9sALwS5/eINCwcoy1JVd3Z2JpPJz3z9Z77zJ3+ammhWKBKJJEQcjUsicESjqlouVvP5vK5rRApFCFBDQ5qoTauEENhJ0ywWi7qpm6bx3kOKk8qrJgJwATF2Kbk+l+bto+JExVJUOvQdWFUBu7BQ6ho5al1bpqXu7Oz82q9cf/DgaFXHUVEkkTKEtl6V3n/1p1762pe+xMEnxVW9QmLnHSGlGCU2SWVUVbeuH5yenh7d/3gyqkZFoarHx8fMXFVV0zYh+DKEwjsiamKUGJtmFZsWVb3HInTWS1/mCPvS3ICAoOCIR0W5O5sxcxQFRbDuS4SqSa+QpM8sHy9xEWz6vAZWLxHppv/4qligz8tp9SIGATgi7vPHX3np9oN7HyPUDIwKGGXEbly6JFQKjSuX2jgqR/t7exY2U9c1EzvnQFGTJBUBaJrFfHHatI3RRgiuKifYxQ0AigbnyLmyLHINXbaqQbZ/KtIg0Iuoq7fexwt1YaGkznvPQFVV3rx+eP/+0eliqSLNasmQKAIgCQkxIECKNRFHiCDKROPxdDyetm2Lqq+89HJdr+ZnpynFlNL+3k6U5L03meoYSUEVyTmQFIIDSQqJEZmYiNj1AhXBegsiIApBBMdcheJwZ9c717ZJpHODAMALCHnZ8O5k4H8YyLT9hf6c814CeKFG8HPxhz/3gQBVUdy8cXN3tvPXfu3X/viPv8uKy1UajUchAIKkxIkpsRA6EHJI3nFBXvpWhFHiqm5i3WiKdbMiAgGdjmc++BAcirZtKkKhmtiBL8oQihCCpY8jEzNHi0mOGw1giAjBmc81v6ok0jRtirWInpycoKpz4j3WbapXbcFYeRBC7yvPjN7vzGaAyMEH4qIsQDXGOJ1NEXE+f5RSCiWrYtOoJHXCiEjQVVkFC9kAFgHnGDSqCpk6RF23b8gaMnTTJFQmCiGMq2pajVbtqfZWpvTNGZ70BV0WTfF0QnmLAYYH4QtbG/S5D0vta+r6YH+/rRvH/LWvfu3RgyMiICUkKIqi8BLbFSAAETqSVpqmsQJSRCQWS9w0ddO0bSsppqYlBke+KApHzqFLTXLe++DQFCBHRVGE4G3bAQAmHrwGzQUgOvrv31GvCHFRlKBQa7RMRpW2TQKqBAlFFk08W62YXRWxaLUoU5TEwWmTIrOkxrxaq+W8F5uqKpISCBAgqBBaK7OORDoNp6sapgBWygIBwMLgVNVqbCmAiiUPsUpyRNPxaG86u39y2n93rbI/4xjS/RAIuuxk2BTzYs32ELl3iQ7HX3AGyGtngf5gPiPQoiiKsrjzysu//uvlv/qX/4pAvWORltlbagchCKCINBK17wpsYBoiEiMAc0AiDCEEH7wLVoLA+cJUHVVCplCUzB7JJTFZykkgRVUgNbJGEZWu8gl2wZtWbNSzUwDxTrVodIUWwM3snAbvURmtBwTiql7WzTI07JfkgnfOBV94VwCAQdBGuyklVUtyRCJi8kTY2eVrAUmWUK+q9kfoo4C6chWDzmWmuWlsAWBUFNevXXvj/fftFj1M+awa0PlQiKEfN2v8iFfFISHiZWVUnjcDZJ5XQEsO+lwNCVspE/9dYLAIOyciQPiVr3yFiKbj8fFqhUQE7JCVFJwXSXXTaERSTCmCqEgiMgnOTKLO2kqg996HQL4T856tbgSJgHeBuSQOit4qryChxd53oTUDiTWEKeynBc/Flrz31stQVRMkZl+WRBSdczmPDEkBW01tu6qFXANzQuecN50qKzmIYP2AAZA8Os/QA53QoSuoXbA+Eg77LXThUnZE1CpAIhEQgQMApsP9g6os6kWNXbrmM6WUYO++eLqvb+0bmluK5f++aEfYF2SoaopCTDEKESKgiC6X9eG1G6vVav/gcDwp2wWPSnap0hQVUFUdOmBljaKqgVVRxQGQ6UHsvIoSBmZ23lmUm5m5jgB6U9t7H0KwHAAitjasqtFkvIogEV1EIjhw7vTJxJWxDaMDFGIChxHQRLdzDkCQnEhM0iKQ856JRaFzQiJiX0bOUumBXI+K8HAHQGRLhBSJTOsdYBh8pqqEJEkRsY0RAKKkWlIxKq/t7R8vPkIrPZQSkAA8h/C4q7X/vFZbUQ/5Wxd+1x75Uxjgsm3lRQBET+rlvXBu1vsRAETJ/OwikICIPCAqImmKKTq2eAQ4ODi4fvPG2FNXyBwYFEUEVZkdAACrSOxqVSmiOmBWSSKC6Mg5cp1n17Ag68wIfeyndZoxGmVmw6S7eQIAAsKGI3OYGWxP5H0Ay/z1hSqKEmIyBcN4AwBAQSQBRHReqUBEVWAi7EKwkImJkdEho2NDogiJiRwM2oz0C2s4ukcSQCGw3lPde+mpCm2Ht7JBZNWnCz8bT2whxfpWEcpzwoGGpRz6FesuPQyZGRL98KEQtz0U+DixQM9I6Jkhn/SLcnln4yefwBoBMCWemWOMi8UCAMbj8auvvvoRqguhPZ07onw2syNClShCphkDECZQsdbTYEyF1qax+7c2s0w7InKI1luVsS+42ydnGa1veOzzB3vZRASqRVFYkJxa1ZG2jSlxf5dc2lPVAwBQIupCLkxrBwRLxul8uj2cb+hObjo2pKGOSy1SRNZu1zy6mAIF7YtngYJH2p1NPbs6tl2vvyePfM/LcZ7yLtwHBlNSHVRxzLsB9sHSFhCKgxW/yg8wvMrWzKBnDO0vpcOfWzN8WiXwmR0R3XS2Us5Vu3RbVbWI35defrk+eWQaC/U1waFrJNPVdwCwHYAt0BMURBSJrWAb9h1rhpLbaNBYgvq+SdK2bYrYx18oAMFa/Gcu7X4l2x9ARFxwfXMDAACx6od2cv+AZqAQFbDu7NQxWAdDWaYjY99c1XK+umlfYG5uZORuYIiEVv/ZipyqakIAkTQdjcuiqGOroErPEwm/iB4wLzVuhk5mZsjqkJ2OXWD8+joOctzO5mQVAUA3GjNu3P2xwiU+x2ErIqKIG0F1AKCqIQTLBWmaZv/g4PjwuhUUpz6Hqz/TlsBQROyyE9HyWayystFVxwBEhMwGJZajseNCgQUYyRMXACKp1dQVZ4NLVAPb+nDg9reD2rdgUgBOiYg6cLN3A3UcaAY0d+nmZiUAYveJaAsJ3Aw06NZnQ58GAGtUhcOspv6qvcMOASS1ZelHZXW6nIMSgVJngG6SjnGa9tURLx0Km16RwTZlR3SLLbnvFJpFSWaDvEXk7cu+5eSSKfTS4Ir5faGHiUpbfBzYlDZyLSrz8N+6fVvqBXvHQJISOZdSQlXUlFJCcqqqSbAvbm52AqBQn+2eB/a5YBY9ScQCYBI3RU1pXSzl6qVFRIWNjcv1Vc5FhNWjbBSyhX7PMZdVJrnhjpQ3KARUw157ktqifjsiXTRvprksC1QEpC8zbFGGq6YFQnZELjoHkjR2VIQAYBix3VQvddp+yoJcfcJQ5xnu+TliVAcCJT/mXxAUaI0D9AeIAAXrui1GLu+PiKjE3TnsOBRny7PRaHR674Fj1thEsTZZJkEFk5pbQHuw2aJ0TH02CN0O9hX6+74jzjlruwTovaO+NIMOBvYzH74wtAIWCCKCBMMoLgQ0MyBHgFFMOQIszxA3S24RoQkDBCFru2y5UbpW2BDzz7XUABAClwTBWrkpEpJCStAKYJQEon09FbXmBgAQJTFzURbQJooxxvjs0RBbmv1mRPTwcycFhqbU8LsX0swXlwEyoVxhDRuaPjwylGTQhxMO5UEe1jLasyOVpqlDsJ5HlD3xMNAXTbdYX19ZFYiYkDPp5/sSUQiB2VnoVfAlM7dtss7Sun667hswgPD6Ix22kwW8WcOd9u06v3LElvpermpd/QxY6m5hsyXssFYFJEDq2Rc7w4BwoDCs11DWKYnrjoPQyfJ1WQ/ta8t131e10CCALrPHaqde+pofbwwNgCzszh9/Cp38cgbQ7Ip4igk/68hPkmXq1afZGC4NDOxdGABBeYQQTk9Px6MSY/TsJDYWQCbQkWn+Gpj+MGAiQmegUBchtzkHRCyKwtLhmRwimrhPSUE7PwAAJEl98ENmNBrAJoSAjrPuqgoqkIicA0qQVITYAa+3fqNF1PWusrEPrE2WjXXDc7Uc+mXMGBqLJOwiVVVVVFDFwoyH9pKoFZ9hLstCkNu2BVbR9qkN4aE2D+de9/mTr75IstKXoCy9xKE/Dy2SHufh8zCpY7BelGjhDzAQGDDYGa0BerNaSRIAZUSVdfNztK5K2Q7s+08REaAYMGo54AMbg0SsKjohMJmPgMkaDhNo1EioqaNUNDsl6y25XC4iIooq9X3t17p+7s4r/W4zFM+qin1DgKFl3P21szw3ZIrquqDn1hJ1u93AghyqasYNKVkp7D7dxII4nC+Al8vlutnZM48tOXihWDzPA+ePrCnhMyiL8rzG4+9u/fZtUI06ZhiQPgxesNmvCLpcLolysa7BenVU0OHsxhq6zu5XBAv46BruAVCMAsrelYROlZhdCMF5L6J13ZoRkVILvSGpaoK581uJCAIorLu2ICLRekrZ5EAchlJv6AMCAlZ72PpA4robJxpkO2SJzWWx0YfobZjggwEiIFZfXlCshqlhxiKahBQqX4C2JbEy1XViRlHR3oZ+nPd44biaDHCA81xxBRMnnalwhSf4eUK4z2M8kYanasVr0dgAFHDdVQpVlZBAtASvEmW5ivVZEVwCYSJQBhRc40jdNXETQsbeq5JVFhXz3/myLKnvlW0aQ+qhT4vyzIa1ISiY0/Pt+tTpX8Yj0CM5uMnJ2GNZmaXteEb98ml5WTLpb26qa+Ifin/7TUStx4bI+if0sr//NWkCtNjBukVlz06dlkWIkHN2cdPOeZqx5R7Ne9TWuFplsMnYpeSLbARvjeH+a6PTaPuxae+iJEBkAGVrsLtO1YS8bMTYxKYDK2WbwbbMj150bsvddZghKhEVRWHhDxkaGl7NhIqIqCYi6Hq0QG+vIxAgSr/nSEIG6Z80S2AjgpQSbyaC2OfL7f7OqMn4qyJsKT+bDAD9dTYamVl9afs99Z3uAUhFibBpaotZQESDAboHf3JKPT8Gquann6wDQ2j4c+NhP8vaoFuv5HEe/imM+uEdshzdvO/ArEeIMfV+xHQebMoG9Plf80EeoJDMZOLfGKALnBSJHSC4JrhOumMXXowWdaAg0KlcxmyqqgJtG5k9IvTgfbchJBEYvteBhB/Qylpn61WY9dNtbSDn9xNVTSkCQG5nZsxgHQwyYwCgqKYkUaRLu0Nk7kIsVEThYmn9pOM82eTHv2SH0T4gPCNaIERImCChfpoKdLUi9Kk72uOYKc9rPMUOa9idqMaYCIVwO2h8KPJxMGCokGjXf1eSWAAc9OSfxDxlrGLF3lqzNBTFuj7GpkXtDOucAB5YtUuOMR+eIUExp23ZJPNXLpth3jHyCR2rbyr3VyQTZp1He0x5WEs9NxUAMTBUkaiJqdPzmIMPzCvvfRuXSM9X1A5RuvU7465bFADK1pmXDZdwHUG5PT4PAPTxhz6JVXDx16GjVBEBZ9azDIr7bZD7FjPkn6AEliSMwGWp3qunhNiIMpOKhqiLxSrG6Byb8mA/LbOkB3g0N1SFJOTYkhYsicAgV+NuQsreD8yOuQxPbe1XaiE5GQXakBCZPTYVnuEelUX8OqsmH9eeN0QME9MkKaZoKpDtA6YNgoGtsK0IDbegDd2yF7vbYRuPOZ6EKJyZh1/M8YwkftWVAQA0akMuJY6NaIGkEiWJoHRsYSRPPVB5kT/BhHRMigjMPvhgf2Vmx53Mm8/ndd2oal1HsC40MUlKmpK16h7al8xMZCX1EhGZ89h7b3/NH4YcmO3CvCFcSNDQq87n22Jv6T9D73LPA8k+dy3sRaHvdE9ESREhtZJSBGJnUJPznmOELoGO0HDby/WJ5/iuHx+/wc+4P8BnOi5bzGyyIgBJ0yyANKYoQCJihqFV47fMmKxcX3gx7cvRAGBZVIgYY8PovPfsyLEXQwYpIqKVY8jag4pITCDQppjRlRijEBMzJbZ2X72MB0TXwyBddthQ29l4xAEqOiSs7NPIk88q0BYb5E0pxmiU3+v9klKS2LUy6L4ipkZGEcWen1PsSp3mWwMgAl7BA89tPDYH6GfpB3gKHf3q8ewyI6UkAtPpNIk0bYsqKEjEtFnKd0vz2ZqD1aAPofC+ACYkYgvcF0WXg206KFAzephEun1AY88YHcmyIyJWn1LCPv+QkIm0z29UlY5arUSn6bnYT1I2gwXyz6FQ0HMDBmxgi9O2LQBIH/NjP2OMqY39ziDGgnXTaEwK2EUExWjRQfarDnxqW3M4v8ib6/ti9fC/0DtAP86rmNAbUMxcFMF5ZMcxJgZxXYz9NmClup1XkPVXUWXEIhREDojYWWcxQATLvDGVvT9XUcFq66CARtsEEsSEoKhACDG2SKht8oXn4ElEoiIDEoKiJLGYBuh4D9Qg9gFwtBb5l0cHbJH+8KD92lN/ZwQYP3RskAxKhz69J0lKqkLkmqbue3zEGKPK4xqjz3GgBZxmtPdKQfkXjQFwCBWreXwBNp3/edjLtcKFcVE7VCYa2r75mlvIj90lqwGF98isKiqaGvGemUNZVADUNFEEYoyiUSRBbJ0Cq2+TJGUFRQIVBVzjLQqQYkIGTpQSqSq6LnjbIjsyXtRPcE3n57l9qA6cF/NDLQgGPoS2bfOfMozbif+UQHBtHfcnGKSmSUC07YdeGPX9aSrKesKfxjLPqAWoqvu8wt2ey7j6+bUz6bqUgK3jnWBGcuR88GlBoIKKkJKVYEAiAFZBa483CKjpnf8imlIIwYeCiBFBwbKsOsDSYnuMgSR2/bRRRPoQTmZrXqrM3Lbt2q+EHeYojTrvbeuw2+eG2+effUver2XB+oyexGGDB2DAOT01r3HPGKNZL2uuSGvqN1g0mgqHGJtWUqqXTYwxNkkSqJIBQIoEGM3d8cUZ7vFN5i/ayJJ48C7tP5BfuogArFt02etv29Z7D6qq6HzZNHJt7+Dt+0eFcyCqEtGRYkzgqA83GN4oi2oCsERK7pPTO/SDUJPEphXS2LTSRkRs2wgiqKp9azfsKj6EpmmIqGmaGGPTNNqjJTFGVAJEdGzEZw/lnDO5m3M713Xb+qe+EAuS3lWsuLEb5EfrZX/Kao+pMxI1RdEEqpDiGrPqOvn1wG4d28Vq1TZNKxueKewj564QtU8ryy8j3sel6xfcIumZ7dTLtFgbG04cXduB/XfXJZzyTKSvHmw0x8yAUIwqRRDRRlJgtveWUqLso+13gCHFiKollEGP4qsisSgRgDZNo9qISNu2khIpRFVJiTrgsuuZh9gl6VdV1bYtEdV1nVQ0dRSmAATdOZkPDV8377IlAwxzEs5vdz31d7Y4WNSdKkhXwF57DMp4Idu4HQe0nRs45/RkKQAAKaYYYxQ4my+a2IoqiHjvFYCFoW36V2IBWU8gb58eOMEXxgBPOaEX6QPOd9hS5raWL7+wjMx0bYW880XBzG2MqNAKMlCUROikT4C3C1BXtNleseTe66pAXeIlUowqgMA9v3XEBAY6pQSAzJD7ZQCIRWWLSFmWzExMbYqrxTJKsuIiOXE+F00Ba+iN2B9cJ45lB8b5lddzoyNzUAAwGzcrNln/adsWFI36oQuOGAZBQNs2qtqm9Oj0LKkoIQ9SQzvpYwn+L+Slr0eOmDK4bA3CbtKe9Hl2YOXRBzSyeXE8T1RPPsEXTvdXjayZZKFlx6nvyQ4AAoBM1WSyPH4kCmw9FAxhMXW/D9nv4mFAjCCSyP+/vDdtkiS5EsPe4XFkVlWfcwAYAIvdJXcBcBfg0iQaSYmkGSWZ9Ilf9EP1RWYymUwyk0w0crlaLcXF4h5gZgDMTGOO7q6qPCLc33v68Nw9PTOrqqt7uoGZWbe26szIODzc3306FiEZIzB7X4lIhESVDQGomEYwQReeAZgNKQAhIHgbRipFULJ4Ayomc4zmrrGDFJbiparNZgppz5S+4sCVdls4wgQknOe5yjPV6l/tmBWHK260I6WkClOMm3lSQAqdF5Q21T2E3AeEY+pe2XU9orfokVXv1hoqit/BOf9NFwZq/OMHZ2a6d5vnfy5HC/11VPLvZj4fInLv3r3Vk08VUMFE1NRy+62k6iH77g4zs+z5MQLIQgiysqiymQkRIitmCm1J0pzticWvZB33hmrIaiYaERE5576AITCi5Jln+Ctpvh5gJyLMnFXqrG3vau5aY9VpD1Zoq9JLPW2e53rQn1jtmIUn7IVDV9bh57sXZZ6jgoa+I2I0RWREYEZmDCEU7DEAD/ejqsq3c3uBYUdiNj5PAEWAG0i8vRwm8DsaV0l9NR4TWnLCwX37QCSAc5LVanX/tYe//uU7ZoaGKqBqDB7lpki5DCCU4gJatAsRmaaJMLeChEyKWGstFhGJ0TmHE9Su65KlKKymAJpiKlYm9FQTUXEQh3nOyi6h408tPFFlIT/Y8nQ88g23ENZyAP+QUlIRazAnR7yVaH9VS6ZqmkSs1PtUQgUU0cl0mzSCiVmgIJIQQVSYGAFAPGCJTfcr7HxmzfCZd7il/vBl8wPcPHJgPea2z86jk4iInZ3dISbLge5mZgmlK7ITNG4mbw9R6Z+qmiY19QYzWckuJTUtSZxnFagR0cMwJJWUUi44nsTrR9TslkpoqTSRN8pdM6q9pes6fwXHgRp5DyXk8zodoJXdzaDMP7+WiapqilGSpiRaXjMVHzCWcKKasF+FoirAYKlnCuXyAzP0DePwNHPL8iskwF9yBKiCvlPKDMSeTcLsZbAAiULoFmMYBpWtmntkUVSRlJICewoitfueIcYs+0c1pZDLnxCyQK4UgmopxhS1ihPr9XpYjMPQE6F7c5fj2IfOpX8XnX3y1aWqCF3XVT0B9m07OQa41n0p1L1yv1Z6gaNon/pra/apVMAafx80pmc/030XUAxuRMQMFHKetJT6X1CqCfk5UOyhx8zqdz9+zwhwG172WW7e/q0EUtQqEXXjj4Ih8vLk9Hy1UUNCU4Bc98abj+5nFVXhQFWnaRKREMJ2u8Vcd5+nlLJjS2SeZlMQkTnGJGmxGMO85sCB2cy6ELbb6WwYmZkMjDCqmOo8zx5MM6XIpuM4Vh2gQnlKqeu69jWhxEhXAcBK3hYU6X+fCWSghyZxp6lftNN0WzZi+5ai+tVPqEXHcJeYn6sS3kYrvd3OwkuBGrs5GO6L6yPzUTcgpVQlBFXv5LnXWMEMxGxxevrpo49CoVXgQe5mVirztGIFoCEhI6/X66S26AcRyT0SEZNkBNhut9M0EXCMcU4TEa2mFTKFEDqvUK0w9P15CItxMQ5DJpwlEnMb5xjj6elpzTLbn/bO5tPCXJXZ8lwbscqKmtuCuOVYzh2byueDtQxh9/JNBERFAwBg5jlJc5onz794AOjLhcC6RC3Z/ZKLQFB032o1d9iuzNdETAWRU1LjzrogMZqJuSCUwQgRyaAUc3YB2xDAmOjhw4dv//Kd1M1d103zjExi2lpRYoxx2iQRJAOAmNJ6muY4S0ohhJNx8eabb85dt5q2ILocF6ZqTA5bLnZ7nnHVs1ufVxF+oH6tGHuwCHb12MFxC+v5r+30HGiYTBaWNKklUDUEVWBERSCwACBoZsoERIDi5TOcfHi1rVey0VdKE88Urz6nCFCR9Tantd8PTqhiT0sgCSAVeSbFGcRTTwQIt3GGGIcs9KOYUs2GUUCu8zFEMwAzDQG//vWvv/uLX56enqpqSlEhx066LBFjnNNsZmlOT54+naYpKohaTNNmtRaJy1+8/a2vf+ONN98c+v7iyZYBQ8daIu/7vh/H0RuVup7QvqB/Zd4j9vVDawlpcaByCbeGlYAfaW9iZira3qSVglS1eEp8NQBzqTlfLC8fT0yEsisDfEvLzO2GlRjHz3SXZ4tAvwNB6LpFeVmL1RpYqq2wvXnfD2YGhJer1cnJCZqKCIeu3fJSByUfAPDUKgOAs7Ozb33rWx988AEizvMshay20sjl5eXT83NE6oeRgUW0T11HPaCapsePH4vq3Qf3753d2U6TzVtEVJF5mu7395m573u3FLUCjE9FVT1Fpq7Y8bq1FvdWrDer4W47PaGiSr1VhYHKCgoeVs3Ky7h7SbKcYpvlxuv35Zn7++Kw9+ww0kwtf/8c4OWRhGeMVu6vAOHWob4UkNvMM969Yynb+CvrMLP9vfD2oYDgvY94GAaHJCKqVYCkRHdeXl5crlbMPI4LAegoGIBJv1iOoGqaAhGYrZ6eQ5IuhBQTIGy2WzD9gzt3Tk9PvQWTtbbRgs+4XxzlYD2r5lMHNFAukuo8DwWjcjI0Lrn6q3/GbN4pp1GNQUiI2NRMeva+1Mm/FKNIvSV6fMpefdy9gLHfPwL8bsaBXbw6j9wzNc+zh4hupymKYMkBFxECLBEmvv/Z1eW3YgqImlJ8ev4kpTTPE3WdJ6xUYBKR0PV9HwGg6wKmRKiKAARmxMBMA6MnZEKcZok5nWpO8StvvvHWW28tl0sz6/u+INheKA4c2bvaN4UmdMJKxFtjDtoJ/e21O1QAA2ehJQi8vVXpPYDMCMAiiTjrJyEE84LS5iJQ1qUKI7bDChxXDS0OhFfnjP0yI0AlJ5VSQhMg1VLNlNLQ9yJyuVqdX16+fnqS5oiECqZGI7KZGQghA+zdENGIIE7badogmYHN80y8V5DUBRgoGQhOyL36HCISIKHH2Bkiuubg1y4Wi29+8w9ef/11D7rW/bpoO2tsE6laX/wADRqI39H79uR2rfaEn4ZbWiNA+kE189KNHIKx0qyUGAA6YvISR6YpqRpF8pN3TARKdSOAZyt7r258KRHgWnphRaWrQTWZCVA3jMs5AXM4X6/vn56ISqAgZgRmoAe9rtoCJIgoScwshND3NsXUnuNQ6/Ge9avlmorm5eisxGhUoHTLz7379x88fODGnxDCPM+tOasa790mdSA87Cj4UehbPUFzZOvOOLgj7QCa3d5gXhsRBFARc910AlABQxJEIFRANDSIdf6AkGI0U/eqtI8mIoBdR6MDtf6ljCru1hW4Dse+XAhQyyHZIV2pG1ypl1sYc2/TrkOAxWLx+uuvr86fPF1v7o2jxohmHEjNSgjEjkxm67vu5Qp7J1TRw5Qr9FI5lX6bmUsF5BMFaApdEdFisbh3794f/8N/8JWvfMWh32/u+OOC0D5/A08waKX2uvetZbN+KHxA66P3JtzER1pjQarr6UfIY8ibSM/dCgPOybMZyK1JB3t1A1C2u3bzCdAQtRdjI18uBLhmtK4iaJDBNz6EQGyi6XQxErEC/ubRo3t//Efzdss5yn/nyj+4c71tCIGZRJSIDEAtG3/aSLU6DVVl9DLmBmbEVGcSQuj7/uFrr7311lvf+OY3lstFAHIZCQC9cysRi0gpxV69e1eQ+YNxcIK/2sEJ+cP+hVqyiKoqDJ7WU1vTNRPIdF1ULU9aSz4N7rrx7RX+f/Z4ZbbI8MKo84UbLVGsX71+7SzzQGMI4eLyUkx//st3/uQPv0UcTCTX0LJrxSpVZSJvA0ykZqCWO3LudtcMEUMpats1KZQ1pt9dXcvl8s6dO2+++eaDBw/GcbRcIHpn5Wzhpm5ci971zPZD++sB5B1ghRW0rL9qJhYH2adGRGJqah7LrUkq+VdVMxQBAbXmce3Kt08/hsAdInrU0E3Q/5kw4/PCAQ529FXc/AB6vO6aN3Nfby5Tmj1Fa7PZXm7WF5v5biAoccKFglNW/MwUlJmN0MQIMDD3oVMFm2KHGA0AMBCrKqAlQATwZqlZ6AphGAb3cC0WC/d2jeN4cnKyWCzGcXSfl2Wv9c6ACwVtoEJhE6l2G4JaYe4G42lGgvIX9zMM6wJ6xTvyNIlGxHdd28wMUFQNiiloh34KRUq8ctOzn+XVU+bPCwK8ai7U0h4rSrDW/oGKADSOXeCwXm3v3nnw81++80+++53gnXZ9armKLQC4iJ81Wr/VOAzzNM8pEVGMMUNMA6+qSohd6Pz8xWJxenrqoH9yctIN/TAMwzAsFovc4Lqo0WS75jRVg4eGcjsOXPnKB4QW4JAVHCNM4QX7DAHAFMzQWwolmUWNA0U1MfPWmjmMgjCZJlO1WVTnpGJoDfVpt+PzMD4vCPDCHOCapSwAYdSecywJ1OPuZF2v16enp++///5mdfm973ynIwbV4wzrknCHZsZEXdeJJpfgJbl6DdC4n9DrvFpuIDCO4+np6enp6TiOi8Wi6zpk76vHVWHYMSvMFRor+bciTOt+9YeDcZ2wtHsJ2FuWVhBCJDDR0tEUvXclYC3v7qUArHjBqhkXMceHJ4WidNt1ck67Iwe/+qte+V7H93jGz0e41379/SOAg0gb5VuJHLwCznDM66t1HABOTk622+1isXjy+MnTy8vx7NShHfda5gEYeM/g6p0lxK7raJo8YifGaKomgmqoRsWC5Ahw9+7d09PTk5OTvu+HYWBmoBzqXF98R7Axu5CqxGKNbedKEl4/tOB1cObBkRb6zSzzuKPbVuRMSZwl1t7U/quW1JkoKal4MKgWR/PBblZR6hUxhGrxu3KVfDK3Q4BX54g7mhCUza4E76U/pW5GpdBe+2AYhu1223VdSimpvPPuO298/3sGSAZoVcZAgAwguIuvzpYcHy1MZK+tmau54zgul8u7d+4slsvT5Unf9xQYmY5f00lnVih3Tb/LE4/CdY7HDcyhPeEAPvJnd8HuS0GVpZgZIqjlRXDyUQxcXhU3iUr00GgzalLjqxTXYtQVE3tWO+0WYK5jL9DSkWtgaU+a3C1H9pBYDvl7ZdBfaUBLz1pt7xU91K7a2svLy7t372632/Pzc+Lw3q9+bYjJcr9cAGhL9fm1KSVAtEDU9WHoxnEIHXMgN+nUXkboorzaybh4cPfe2cnpycnJOAxdCITUsJcMYZUp1ZCHejAb9Y8A97p3vOEIHMHfAffYA4lyfiUiIuKHW+d6ilFzuFHGIisSZsvVsbSQQnRn+N4/wJeQNHO8IFcev5oDWPP3lY66AU6G3eNjjY3i5eJAKxbDTpDAEAaA0HXh9PReCB8xD8nip0+fbKbpJFCS1FEnoGyQLZwlNRIAZtUQggFQCMMwmOEwDGYmotO07TfdarVymrdYLO7dv3vv/t3FctF1fQjBU8XdH9bSs33I20Xy+HJlNGhieA6ugn3KB/vYdeXKtBQh38R2glZduoar5MQIMVMwZJI0JwMFRlEEAyITRAFI2Tdy5UZUPvP7GteIQAj6imWeg+FiQ66GcCNTe77h/RjrVwPV2l/ekswiPQAh8DxFM7t/74EpEDJaAoB333vvu3/0R6rR0BBLB4oiGeQnINYKJSGEcSQi8mwvTzFZrVbzPCPTYrF48ODBcrkkoj503qUQAGJK3O0cMhXQHWxNskkR9l0ZBxQdi4+pEo5KqusJsE8Cjsl8i0MJTXRn2RRLasBq7t2iwLoVNcjFkVRVzdPD0DSBiiIQmldEpdtrtAA7LL3pErtdVuQz5cCrEUDqrX9XaICI1cnfKgMt+fnsw1eiphfWHj4hBMeK+/fvX15ehhDSNHXD8KOf/eTb//CPIeYC/DkmQlUbVxGWeAoAoBAAdLPZJIyLxeLk5GQcRxGZpgkI3dLv0hEhg5k494vRtWq40h6/L+7bfnPsgw8tc2tBv0WGFs5bybO1pVqTNONfRYQxqIqpGUJKcnitQRIRjWwkgIIIQOo1xQD0emX9dz9a8nq9Evw7Af12Y6hUvKkFdl764xABSxSNKx7MXBVfd8SuVitENAVD+uTJ0/V2u6QgIsi5nEQuZ7IfTOpuNUuyWm1WqxUaTtOsaszh9PT0zp27oBbnOW3mebU9Pz9fnp7evXtnMYxGqGZRhTkAoJqA108280AFA1AE0wySLaOADHm7rEXYD4uA/eJq15N7OBClYJ+3QMM6DLO82l5rZmJZVBMwz5UUb7qTI+teYi7YyxyHCGDFCbd38Crl6aU8viVOTok9Wj2EkKkOHzcv/azjgFKmlMZhsdls/KEOyggOl/qbR4+++60/lNUUimwmomqmpTSVuQ8h6WazXl9erlZbFRn68enTi02cN9vtycUFmaUk2/UmpTRvpxjj6WI5vf7a4uw09F0Yh3Ecvb2K7cLUrNIF14gr/Fba7F/xKpFGj+L7oaF89ebtg2DXIz53AKsHAYCJvC40ItZaQqpqUFX2ggCSBFGVRERrp9qbAaYReTR/uy2AWZMVac8vOWcE8Cw2A9BbJfG8uN/qhrtpyV5PKTncV8S44doXJi0N87EQWDR1XRiGvgR+gSkE7H76i3f+5A/+gYcyEKGKgJGkqWSHJKSAFObt/Pjxk4unT1IUNNqGNCz6zdN5Wm+2p6coOk9zihEMmHmapu16vVqvhpPl4mR55/69O3fvApPjkpWYMygWYRFRFW+/5UxSmrqIUCC+hWNogJtKZSRoQBz20ebguIoeNBTzoFA/4p2y3Thb+U9KBmYqooBm7IQfQM0EjrZo/3vxrex9vdUefnZBJSOAVSvf89zzBRDuhpHF6JL5Wovfv2RZCBUpJ60ShhgjM8xxHQIl2Y6L0PUhhGBABAEZf/Pho9V2cxaCuX8UMpEuqbRRbd5sJhO7uLi4WK0CMWEwSZvziRhtuZTH52iic4oxekx/CIGY108e4/nTxcny/PJi+emni+VyuVy6P7hWQq+i2n4tkzxaBGgJOeyT9ish/soP/vmgkomjkKmJiLm+a2ZJkhdGMjBFEBCJGXWQtXHVATwvoD6DnL1ckCgIAM9uR/Pqhu17BB0CXCivkV4vcTgT9xaOqjqOo9feEUmLxcLnE0JIMQJgjOmX777zj//025qS7TvR5nme521MGkKfkmym7Xae0HAcF9wNjJhSevrkomOUKWqcU5KYYlIFgBBC6DpADKu1Pfro9PT07O7pnTt3lsul90HyKL3aZWxXlnAv7mBnxj8g4Vcgg2ZzM2RXslXG68NVVTXzzl4tCmWrK6KZeaSTmte6VTNQ1agipgYmBgKgBq4q5DtcBVpHcJzjTa7b7Xr+LaH/lqJBRgDFF2Qm9Rk3TOuWEKyNWukikN66OvZzDTNjonmea5F+3yYRWS6X/lDkgElUE3P45Xvvfe9P/pQQDFxDED85xrjZbLZT7LoBkJKI2weTyGq9DqEHRANISUUtiSRJUSQDBZNIMjCbtmb26ZPH/W/D6enpvXv37t27t1wuQwh914WuY2Y1S5KgsbciIpWmGI6N1CCn7QuoVyrBB5EUiGiN9nyMQu7QTipJRA0UQIpWHlVSSpKSqIlhMu9A0yR80R54HcND1kyK+nkduGATy4hHAVrt/fP9nLDvokrbotmZK2XH02cPPH3pdPrVjep49lIOlhtQw0cfPVosFiGwmSGAGoChqX300cfn2/X9caEAHBhShGIZnOc5xbTZTEQcY8waoZmqrNYbIloul8thsdU1DENUM1IEUNGUFA2JGI3MEiLGKT2Zn54/ufig+/DevXsPX7u/XC7HcXSzVTIFyREHiNiFXk24DETU1safzb17wQtuuwUAa+J8rK2UaFAwYw838jEABUsiSU3BtOi+USQlseKcFgAD0n1kcpYDDYrCswh5yx+sMRK2rK+BuGyXRqyYhhX6bx4h5UiHm+rXvQoy/HscZpZSCqEz80ZGLmrjZrPxSDj/CmBe5Gaa49tvv/MX3/lTUyNCMRNABULivhtFt1OaREXEUjQmBKA4x4vLi/OnF3fv3r1zdjp0HGNMIt58O6maGRsSOKYlK6TdQeTRo0ePHz++c+fOycnJMAwcgohQ0ZHMLIRQA0jdmxGIoTSSyXBfCgMXnrDXJ8Gukv6vI//+vQZmKJgk82qnoirislDGEzHUUnERAJDJBSosd8P9cKD6GYEAgNDkGmJa4P5awl9Pqx+eSZfDF6P2/8sbWFprASgRpqZL+ziO5+fnKU0xrYmYg5gZKYGFH//k7e99+9smKSYzs2SoiMQcutBrt5nm1WozbSYRmabolUAvn15s5xmZxsUgkpJJyR0g7jsVSbMoQsdBZgEizxsBJDVQgzjN208fd+cX4zAsx0WFFQeCEMKw6JfL5TAMWdLgXRy1H2HayZCOAL4CV6KBqoLuWX6qKcnBSAGSyCySJM2ms84iktRizH3vo9FsQYqslGQGZQUDJpe3uIHLG0DZaw3dHCJa16G+RX3rFzSDfrnHThgt4ZmI3hsOvB64g9Qbb7zx85//PCt5KsUkrUD26aefXKxWyxAIEYDMEgAgMYc+KCxGm2K6eHqx3c4ILBZNoRv6SPB02l4++uC1B/dVZDkuegqogAZEIfTE3PVdh4E8509EttMU55mIuAsiaY5xO82Xl6vcdMiylYyI+oldd3dns5Z+RNXP7SUnoBbGK/FD6AFqkP+qASAlScWcamgGZmigCGqgKl46dJaY1OOcVVUld0sVVROzXDnA1G3qhgxgiuBPxCuiieDga4Vdwr0sjhu21T6zRejvBQJYUQpdavcygy79ezFLLzIeQnjttdfqmVY0RQRAwp/+/O1/8ud/ppJMspCMgMjEXRhgvIMICdertUQV0Xk7Wd93zEmTkl1OW1RNZqcIgRkBNQkokOo2zQHRQA1BVKJpIiCEJGIGqNYZxJjIgJkxMBGhJkZLgiIzMXY9xZgjO8zQLPfakFIDuAC9Kycuq+wa3RU/w65wkGVANjXzhMYkuWNMcXWVRsHu4kUVNTFS7wloJqCqCo2YTvvu5BoZWrwuvzcF8u8FAvhwB74H/+wkipJe6Ju62Wy++c1vfvTRR23AuqTUd+Fv/vYHf/Hnf25GaknNAMgIAYgwDByGfjHisBpXGjXGdP70PG4nxMQYoiaLyRCTpPV2g0imygZE3v0ROBAzEeA8T1EjGQbuYnRnk0aLHlIMMULouOuXJ0OCNPTLYRiYcZ5n79GkTY8M3Y+AqJBX4b5FAAfm6HkrYIBQAi9UTB0NpMZjF0e12z3NBBAMSVyGApCsD19rVzzgAK9yz589vvwIUJfYYaLve99vB3FmqsIDIl5cXJyennrfdqIgIpp7nvJ6Wv/q/fffeu2hbzkSEXaopKqBu4B02o9v3L83dsP6/HI6OX9y/nTSOGm6nLdP5800z2mWbdpSCAgMGIwBAA1ANHah15SiiaigIUACVUiCBswsKnGeFRRmDbPEaX1yZzEsF3fv3h3GPoRQi1BUsdhfuZUuKoGv0F/L91ptE2DmPQHcFKS5J7ym0kfDM1209swzMxM1EGO/XE1VU0l/MAOjI/X0QMN+Mdn9s4y6UIj4eUeAzy7kaZM466JOhRXw2hCSeuizRMR89+59EQy8JJRN2iIYEEbQfnn613/7d6//m3+lkohAPOedAwfsiDtiQzoNw9gN97oRFmf25lc2m82c0sdPH59v1pfb9cVme5HW05TmFDEMZoTAaNZ1bJsZEUkMDVGNRNBAYzIzVMUklASZOsO7ixNl/bN/9GfL09ErhEONJShszcv6tmtIpaRuhf62fG8R9lQKjrTYkkQqAoiIuh/AmwubqZoqmqHjiRg478EM+nkOVT/xwEG4ChlexXimIejzjgDPMQwgG4Rz8b3y5qiWi3JC427LBvWuE9m6WjjPc2lB189TIgqIDCDMJKoA9ui3v12tN6dDl+YZ0Xb1EhGIiPuegcgshHB6OsTt9Ob9h5uL1cPhZDVtFGET0zptJ5MEmJIaG2FQkaELXQgGwMzb7erycgUJl4slEBIiIY7DiABd173xxpuXm+3y/tnJg5PV9vLx48fTvFUvP1VaQ1MpydjygRam/R330s28hWlxCh9IR6IqpqnoAIogHgutoAIZ+0ystE/zp2rz9GqE6Pt+miYqAbktZzhWjg+3d59vHPx0LO9deebx+PwjACKwtw71aE1PHDtQp3bc39XTpqSMqgIespHKAWm/nKD7dxsuQYikqgiYJInB3/3kp//sn/yFzhOa1dL3lgPlTNVSSmM/2mzLO2couhxHnNPd5cnFerUAudMPRiBAomCaIBmN3LGnEctmmmC4E+487LtliimpjP0QiNCMgJBpnuLZvbt33nywlS14GoOyyK52uTYNLaEJdCMiNU07+BbJgozWYBOxQwTYBSDtQj4lqrhNX03Mksc9mLEH0BXx/2qgrMkedf21CcNudwf22wFqkyN+cP+K83W0Og88S4h4JQjwEvkaYt7X2gvRk1egacZ28Dhtqig7iB87+bDk3VvxMl6uLvtuAIAQgnP77DE1QDfSE/XD8PNf/PIvvv+9EIJpau8qIimJzLJRG7oeTNMkAxDGtBxGQ3h4774KGEiKaRtT1w3L5agCm+1mtboAhTjLP/zmt56snm7i/PDB/T/+gz/88c9+nOZ0tlg+fvJ41i33YTg7CffClC5TnHXeIAihCiQv21YBon6oFDnDmYiJmFN0SdJ0yAMvZti2NVDRkgYku77xYmBVB3CmgoDFEQyteHkA0/7TAbBW0MSmEkIdVuwQz4yKv/JZ7a/X4cCtEOBVC2rPfHplkQ7QUIrcH1jQ2s+VFsL1CpaVYg2bzQbAttvtvXv3RDIdVc0Fs6CECAgYqfz4Jz/5/rf/NM3uTTNnNuaE09RUZhUx6aPFzdwpDBSISFSNcAjdyXJ5igg9r1cXwKQBvvuPv//++x88vHf/za9+5e1f/eL9334QJf7tD//OQEDkN+//Bgg0QEAihDlGUVQTMcuQgZiSqRwKCRUBdrKQiKgm0+iyfDH11jOLBpDlot3BRjcwKOnCpgBe/t/hHcFyBSRsQnpa2SbzosYI0XKJ+qG+Rq355fpDi1oV0/xuLh3UX2+vN37+RSA4gP4K2RUB2rdtvYO3vLlrZiISZzk9Pf3Rj34yDMM8rQERCRNo8I5XQACmTD/62dv/4JvfWAQgFQBjT+VKGgwnNAt0vl3fwS6qKogZmiZLamrUMYhuN5sI2i8WSbQfwlfffPPJp5++8fC1J0+fvvOXfxkhUcDHT5+sV5uTcVCRy2mbNJ29cd963oBYnOZJAqFozsiBDIA7eqlNI6OqDPiKRBVRSSKppJJlPfgIZ6yAf/NRC5X3QGgDt/wbqKKqOmbUfBYGlFKn28yMcJ7nOuc623Yvnhcw4DPbkb4ACODjgLHWxJErS2hdwf6KwaT+Sk1N8E8++eSrX/2qmq0uL4moGwbjGUQVDdDUAJHAzBtFbjbTBx/99uuvPxhLnxgnh1gCCVKKE3psFiQCUDUVAAiCAmJmmlKELRA+OT/fnl9ut9MHJSRjNa2QISyWIdBkslpfxiQ0sgRMJpCi54YlUzMxUdHoeeoGu8XZo6YVfM1mk6zUNoagHWnHrLm6fUdBsdTHEYOkqBDU1ADFVI1TSqJJlZNYMgFTZ8dlIxAAGFANfPlfUZWRlj4eQ8IhGByNLwQCOLwiQo5kjil1IUADwQeGhfYzACC4GrCHFVXHqrjkdhhEv9supdDjWAzAzT6i6Qc//Mk3/s2/NhM1I3N7uZCiqgJiMt2kLXJHIqA5ipIA1yjJ1AAYQVIksYC0Wa8lNyOT7TSbmoJtN5cRcZ1mBFgMC+jo6XqFCSEE4mBm7qU1y6EMAARGWkqIupQipgqWw9RMk5spsxNXxWPYzJyTGHghrp3YY2YmoOB2Ug+PMERMKbsAirMMKo/Ie2V102DXI+mgxcjxHl8FoLYfM5d3s4kJ3TG3I+PPMw2gPr4ICFApt2YSG4r66+29sAxo6IGnkly5BFRK3VuJLJ+mqeu6mNI8z9lSkT2ZzqYhdzMC9XCcjz/99LePn3zt3pmf6TE2sMtgtEkMk5IoGnRAhNYhKeEMCggxKQBAKT42a7KYBGCdZtE4yxwDSsdi0IUwgczbLRmjMcbkdbTMjAMhEDO7ywnAjNCj8K1MSU0NTE3FNNmReHOkJ/hbVN0AFLUKO1mLzpGajQBjhFiPguXmX+ylS72KKjyjIdjNwFo39/jrsf30eccXAQEAwF0qBd0zzVb1QpwuyLYplC3N2BGn3a3yNnv8THXNuKfT04LVlDFUPc68l5HvryIg/+BHP/76v/rn83rNoTdVUUEMGQFSCgpbQxUlM0YisYECACKhJjVVIgaEJEliijECYTLd0DzFaUoRMVBANVxt1wbGzD0GUibKheQQkbqBXE0pgNuaFK1YZLSJ9a8Msy7CgdCvRd33E1S0cAAAqNX7diTfMm4crnA73EiQm6redrMPwyis6Ls1Bwj2rT1awkBu+YQ6vgAIUGBac7x4kXZqy6Ca7u019R2m/doKEwc3hKL+AkBK6eTkxC8xs3v37q/X68ChJEqXBCJENARQQKTQ/+b9R5+eb+4slimmjgOVXWPAZBBVooGkFCVJjB3QMvQAmWYiouuFc4wpxpTSFOdZkngwTSCzNG9nTYamREhM20TMFDh0XRe6HFeNpUxR9jrtYz40UA77sHLgBq7HKwLUw+VPqyLDziDkoywPuIPgKjA/PnZAufcl+Ctu0W7li8H6leMLgAA7RL9KTHTar/v+3XYXd5eUrGfvcM48IGGStN7E+w9fX28mBpJECF3AQDabAQHU8gZmBkiIKqqBCJT+5m9/+C//2T8F1GyYqrNFSNmVIJMm/zupYBLfW4dSMUsm3hR1TilpImZmJoMY06yCyEhAZihGIB0EIGIEIAL3bjSAfiArHwg5B4ZO2x+VgrQI4CKQ03cA0NLoLofAgYKpqLruTAa5gi/sRFZELOTfSvPslwYS0KCB7vfPtH17yc0y0ucRAY6nazmmHFvUN8vlChEJsRalEU/znaZpGEYwZSJAFrOqhll2GROoquEc4/3xwWYzMQfm8Jvf/AbAuW24cuFKFB2/96tfr7/3vbOhMxXkXP7P2IgZMDmJdLFJUko6ezNJ20Xkm6p6ZyFFA2b16vspCgIiClhtz4GIxBS6EPqudBIwKzrM/prs2d0riNekrXZ4SIN3NMuGLId0VbC9+syohgrqPq9iDq0PzRzIsufycMUAAey4h8cBOauAezUL2Fd2W45RMfnghq2MdN24XRmg5x92y6H1H9R/aNT+88xEIkIGIDNUQ1UQQAU04h0x2G63taFidaC0S3OwHFoasTg0AMB2u3348OFrrz3cQeo+Wa3PQsR5lh/9+KfAQdSACQMhgU+SOuSATBSIOw7IbIhCGAki6MZkNpnBEpoQCqEGgo6tCxpImJQweSsaAwfQQGEcxq7vPZHfg7qZGJHAEJE8/OMgzuzAMKIHBlC3BTXusL0AoT1T8p51aN+epu3XFgCrNRT3TTdwBPoHwyndATjBPgLUI9iMq+92vXnUzJ7BAW7Gnua8ZvL5v1eFWteNWkyl73vP6nKZpRAHqIa8Y9aJiPM8j93o3U02m83NO2RmhNiP449/9rPv/6NvdwgMAAjEBAjIRMrUGZARoQoiGjBiQhRRBFAVByMmQw84yHUWAHLtCQYQZ2iEXccUOu67vgudNxpDBA6uWhoCIXoVzmN0rRO2JhnA9nLfq+e7uDKu2HW/obocUw1BfipibZO6014zxLsI5K4bpGJTeG5hCJvoICk1+Sr9akOM2vc9uLzSr/bO+1y+fj5aAER8deziMw4sFUXdEFTtmx4BZqrEZPuaU2s08K3yajzTNPkJZkZ07T4hooEys2j40c9+9v3vfsdQ0Ukxah+CV71NkBjYgYowIGYk2FljqDHFZG/ALm6Me0IkD7denixOTk46ZkJkZi+CkuvpOs40FjAtGQ6yH0PWUnHzbK99hcEAoALzoTDjd6gYUk5Hz4NBM0MrPR3NCzZmuX+nezXd4QF2cJqnQXhdN0grfptqoWq37yC+6LlGAL0djf98D0R0ayaVgj+Yq+UUCCP3pAHsk4dKG7quE4nTtCaGs7OT99/P5xzF7hKAGqAxgYky/uef/uTb3/32AiAwgQoiho4jopgCIlICCIAoJIaEyIhZzIZdBBgYGBIA7REqJKLAXdct+uHs7OT05IQpgycjiogmLUYTE9tFkrUBI9a84wFPwH1JtR5vPuwF3jik+s9VDKqqABEaUFaVi+JiKJA1ZAVAMKud7ltULHMqu3m9wbRibJWpng9QjvjA51EJfoHhQr/DU9/3XvA5xjiOPQKoGqoB5fJHlvfIrZyEwCIyz5tpve26sF6vOWSt2neoZa8HMGRmU0y/ePfd7//JH4tJYEIDJjI0MUIkQAAUiDtylXl32fmqgex2tCr7iH0/LMfF6dny5OSkD11WQTVXcGVkyzqUHiSSU+4waVZ43Z7wU/yArcWzRPC7Ww3d+4uIqCRgEXQCyd5IMAUQMMsWH3Rzj2WBH6SW5kU4XrTqsanWs0pabjleAO6vG18QBDAEIO92ce0pJe9pB2QAXmfX9YG6D7hr2t5qill2Ojs7cxet21dueiIAEXPofvCjH373T/6od9ElR2h654hKbBKSEXZCpMw1BF+9miyRlQzD+i4hhNxM8mSxWCyG0AHobKVxY8P3nXN43jocmUENSoJvTJ6xbjmkNGvDAGBqgJS7YRpC7kmTlyWzK6caOagnM4dMFMqqAmQOtUvK8c1rooNaKbTdPLiRor9EiD8YXxAEuF31osoZ3SMGAKrqBUaJgjbg7oJNFW9UdbFYrM4vlsvlxcVFPahNzkBlnY0KCIiARBcXl7/+4MM/+vpXTQUQgSAwixICoIF3vooGGpQIRCA3GzZz92pLmxEwEHEXFv04LhfLcRjHgUMevSYPXM30O6fdOq02ZASpczP/ySWUGOOsSVT9cmvsoQBFxc1ruLeeUMSetmNQXQQHbqLdxW51cICG4vcrd7vCgUUGtXoFvDIoPx6VKX1REOCmYU2kdFb+RJh5mjbD0O+kghKysgPlYnFzcyAgzPO8Xq8vLy/NDPEwcw+yDFOC8DLdAgzdD374w29942t+MiERQR86I9SgmkRUE1FSkaQJkzUF0BVBETy7jDGEELx3qreMDx15xH9+dEM0W39WhuMj+MEioyTQqDrPk9t5qg84v10x3lS5P7PHBlDKUcgUPfPb3bIUfnM1KGfQx6zatEtKJVDiBtH/NmNPsr31uC0CmFkGmM/lqDCNTWKRV+J3846Pq1bHEDGmtFwuP/rto9PT01//+tci2nUhxp1aWUNZ1NNBgAxBSRUUAJXChx8/fvTo46+/8cBMFZSBB+4MAQNKMDOLIZqZGkip9txK5D7bLgN/3/f9MI5dF1wMS0clsu14wOHmZNO+6TRNKSbwcE/dPRGKc6C82G6B8h1tT2tqb45e/srdVjn2G5lBSk8kFwfV3HhajDbESK57a/kLiMgGACQAN0u5lYHofoTLAZF6rvGF4gDXICA2yTFe0cSPD8NweTl7DrGvOBarnJMy7/UcSKd5Bhh+8e673/3ud1fbOfRjVNMDrcyLyZUSxu2Cuyv13/+Hv/of/+3/AGrJNAAbUtd5OTdU1WyYiqKdVg5gjTkvhBD6jkvBalddKLfjppii1roM+1pslmQQs87tS2WmqklljnE9bb16syWxI2hGrwsNVxRIrsqE/3/g4q2CEBJYDUUB8JRsKAbVSkQQEQkPnmKQG9DvgkmuGS9A3W8zvgAIgMXUDQBwFaKbCuTghRwtB9naQN6xtPy0M7M5zrid2j/HGJn57Oxsvdm4O0yPGmUewo2hAZIHLHD/0SdP3/3Vh2997Y3OQE2J2JufhtDtri1lWSrcV+GNmYnJENoUnwKsGQRbsedgPi4Jtb6tJDKrbNI8xznG6B18JUfrlDRp17vJCyRmGccnqE1GBJi5MgNQ7Y8AsJP+q8f9cO/2Sz8wonsJwMDLWXtYCgLUfp43wzh+Butne1X9/FwI8BJEoLIc7d9bXHVjRLmTolb+cYgXEU8YOHaUZL2z8m4iRBzHMYSACDHGvu/Wq/ngKkLSEiCDiIjsqgKaiCoS/4e/+c//9iv/TacgIIF7JLd5A3Nt+7cz/1mT4swl77sNwDkA9GMNErwJEdSkFdSS5Siqs8k6TptpO6Uo0SvNZaQuHqvdmjKzXdWxt8W3Ys+pxoArkt/r4uT/m/tg0QPc3QGiAMVTZlfGEN12XCcCHYpt+ym1PqUX5AAvBsevaBh4/RL0EP9KWf1Xdwh40nS9JGurzKie5ZS8GoqqDsOwXC4eP356G7GyNj9RM0L++NMnP3/7ne/+8TciIXEiICZSUwJg8tonlR35FHM0W5226hUlfaq2oPu+W90PaVavVJ5SlDRL2sZ5u916sSPbF5prigq6w9frhxLhfkSzP8uxxoUdM8uMoinGj011kwLx1xb5cQ+x125SdfxF9XdHOPYE7+58FOi224V9TnjDfvk6VyoJz8UBzAzgOKTv9z+woQGVWFa/WAghxuh2oRawmNkQzXaCk0cT3bt3bxwXXddt4JAD1FGJHwIKGCCgoZKp4V//8EdvfO0rdxedzhN2otwHNFAGQnBv6D4jruBbd7R9kaorx1yheVfScFenpOgDACCiMcY5xW2Km+1mu936u1PxVxUlt0TXZFcxeFTGlcBTlIQi1OdZOrAb4iF3xWpB8rcljCm5D3gIHRK7tc3UlEkTQ4kaCqVkd3nAnrLbLtGLKQPWlEytvOsLoAPcZrQw1EoOLpsOw+D1CA7Ea/d5xhhTSnGaA1IwPFss7925824Syj4n92hie2F9Lu6neyPxxWr6y7/66//2X/2L8/WKlstBC3CJem4L0s7QopLdRnVXqpWjBXE35rgJ/+An2S9vmJJM07Sdp808babtHOfCNPat7zXO6Rpyibgn5OS31tJF0eV+vzzXVwdDUgoaZ0RU0SgRAJgCB5IURaWzMPYDsNthWUAJ9MA79rybvje9ZynKVgpMOVl0FvSlQAAEU8NSg/uY+bo+EEKocQGIKE2e1DiOn37yyXJciMjJycl77747z3NllHhtjNbecC2UCN/79aOfvP3OH33zq0/W6wdLBgAUhWDMDJZQ0arT2pCIVbUAXKbBNWjZ41tVVcF2yFD+ikgqcpFLcVHExZ45RpN05bypVKWG3AGh4LYBAmRXCaiBAhoaEaKa1aZc5Ate1GgDYEAjTAaQE0dz2CmX0D3M5ckAEYl3UnilBLdHgOvE/duPSiwcDL4wCHDzMmE1aQPAfjSYw4f7BBbj2BolrGgIJycn77777tnZmQsYHiZww2QOZtKQIjADQP6Pf/2fT89OH9w5uZims2FhaVbRbugpA1JhxwAiyRteFMdzbcedoT9TfbDqPahij4hEEa+oIqrTPG+30zbOmiSpeP4N5hon7rVGggz9xbORodiz6Q9kDMwMrnnfugu4YyGOGIygsqsClBUb4pqi4BTKstnJP2AVAo831+fzGcH9eBzwii8MAtw8rJHqWqpftUYPjqj5k1nuL1ueUhqGwa2f4zjeu3fvyeOLGDcHT/Hd3bcklAlk3QPMDLibJf7Hv/pP//q//uesWyYaAEUkgoSdvpuznMlrjxZJGrVJT3GqrgUTVMUkamwxwQPeUkqbaTtNU1KNKXuaRRUMEuyIQgXow9UritPeyxbgawHxChrUuIoJgZCTJBHhzr0Zu4pu7A05KStg6GkS+BKI+u3HgeXqyyICNfz0WMuxYoBzH1lL55wGq+pqtXrzzTffe++9lFLXhYuLi+KB4uPtuXK3HNM8fA5NkfjRJ0/+z3////zLf/p9w80J80gBLgUDBA7uIDBQIORMNLkEkGX6JN6CMqWUUnQ+gGCmU9x6uZfMyg2maZ7jnFRqxyJtfMwGhLW25jU6LuzRRdqD9WMy7MfLoexI8UsYwXatLJmZOXRdAAAiCiEgEXNxbJt7D5I/zLWBil549WT3xgugjS9aG4vxJUEAXwzbLxZNRKkYRrP2IyKlyjSU/s9EtN1uvUl1Smm1WnutISKyJvG8Mmto0MyMzTy8TBGpCNQGAEM/fPrp4//9//p3//2/+dcap8m2aND3HYJaFMaATB4I49JBbnhqmHtSVEIuMqXoJH9OMUkSFQQQ1RijKYhIKmB3UOiBiJBDq1tfuXitvnvoDz6yWUFFjMY84HFWhESKItp1HRGBIDEG7uM29qfBESAw5ciIinsI7mXf2V9f2agIUD9/SRDAyRcUoR+biCBEJMzGR2JGxCTigQkGQEQu+TjF8tLQAOC5xXVUGMLrwcjMFIF3wY8GgE9W8//8v/0f/92//K960jGE1eqiR2JCtgSJmHsAMQCmLqlCjNVHJiJzjEULkFQMP0pmZsVXrV7KJ5frNxAzj64DRA4dAADmnM9r6GVj3YIduO+UAcrBEJlq1jSKJqCw3giJNCXK/fyMCNuatU5TauaGcxvK9QGumNbtceFA+n2uqz6/CNBuWPXLHL9hPs0IG0pWJR+vIVfj7GvEaKUERLRer/3IOI5uYkFE5tACTZUQqie4EQF2o5o1XANBRIBwuZr+p//lf/0X/+V/8dZX3gALc5pRIxswBYSZyb0WG1cDasphVsdFRcRlBjEV1SRxN5mCAFpg0/PCmEPNK6/IejUCFKUAaza9NShh5gmDddWx8QQf3IkQxCxJ8gt9bd33wszjOAJA13WIpah1vaGZmSIRPgvsjwHg4Mi1isr+JS1OvnIEeLn6zTH1vRn797DIjPY7qiOihwD1fb/ZbEII07wZht4USs+5vTV1JfJgBXMkS/H+1Hk6qWMQ6HpR/r//8v/9xte++mff+c7QBZBIOgcUBPL200hMSAYmTUJPElXJUn1SSaKAcFDUB4BEFcXUFJiYuupVyO8IVl+hFXWOl6s8d7duiDkAZRfxvx+Skk8rPi8RUcn0hZkJqeu67TyFEIZhCCU4qn00EoIUp1rJwSmPeUHIOQC59nEHkdjPgQAvF46fexx6cppfGkrcosF1ZKDGCLmY4ZVUENG794QQPvrot9vt3PdEtHvr4w/1+Q1g7bnMymRMRZiIh8WHH3366ON/9/W3vvq1Nx+eLUaQCJoCKRERqEo0IoIkydRMpSjEpSWpmgpYSdACMzSzWSIYIBgxIREwQckDrqyvwn0L+scL5R+8a2BFsCOKux/XUNRfQnTbFSEi50ZgTNz3/Wbaup3XlRymkq5JRCFgTKY1hfgZ5bOOgbBqOz6qdf/4NesJdeZ+4dW1nz6343rudjVVO7hWSpCcs+Zpmph5nmcRcQQ4PVu6RFTZdIxysMrQLK6ZYu6/5HZMlUIic9lmQCqp7iEERHrvV++/+86vzpbjN7/x9Yf3H4ROyUCjAEKMW9Bk5qU8S5aIR+KYiYFYImhqsmtu8xqIEdEQxJSbTPZ2wi0OAMDB5/pXdbeM9RZEmTMgocFeHxcuspNfyF0Qkb4PXcddF7ouyBxBI6P2ZB1SoH7WREYITMhExAQAwMgAIHjFtOtkjjWZK6H3OkGoyr1WAoSJ6POrA7yKkauoIXrOgJOki4sLj5q+uLj42te+vt2m5XJxfr5C5FZhqDfZF4GcKJJZLlZzAzlRVTANzEp0OcUf/PRthLe7oVv0w52z5XIcO8Kh780wEAIyiAEaKABoDrwGKlXcjBApsE+DSpApApTC7uWpBQyo6YYGxS1wSOC1Fe0sv63WgoeIhBUDsy0FEQEJ1ZuHKahhIuoA5PR00QVOKfXMKNKNixCCqNYaXkiExQkoKl3otAkEzNM/0sRuJnM3DCxe0VZK/HuEABn7GynIc2U2m81isZimabVaMVNK6eHDh5988qSxdTYIcIXkfCufZV5xMlNFQiYyBURKio8vLz9++nQMgVyVJWLExTienZ10HAJpHwIBdD0jsQtahJVgq9dkdCFCi9zlDyX0JKDsrg1eWRrQjQYG7iduzVYmVvkCuEqsSCoCpVoFNfCHiIRETGaUdEYyNEQ3GQEMfc9EMcahCzFGp7gxzdQR96STILCCOAIcxqtet4C3Puc6tbB5WYC/VwjgYNoETmbZpu97Lx4xjuN6vXaB1Tesgn6FqUb79Htmuf+ZCJCHISKJKhN3RCJilgISBlQDNQhM2FEIgTqaYrLiGguEbExmiMbsLeqJ0Ptf5jorebqW+/RmAp8N7liRGQ4kB8uaPgKY7cULZu63302whamMENmbLoSIpszcdbmAdQhhnufFsIDCbwGQmQMHzu03S2PJxrr6ikbLQOrrfGkQ4Ho1GQBgj0g7ydlsNsMwTNP04MGDTz/9dLFYVPeTa8MAUMus7x5zzQ5dwQRwL8VjJ0oZEbEZqEpNEOfyq4ChImAQYAAFE2JWRgodgIGpojFiFwITc3miqpqKq8VWnICV49UJwJUIoNWLgoCApnpg2zVkJDXNURy4uwMzIQIR1ax2KPSCmRAwYI7GNUtd14UQCJCJApKpIRmWMuvHSUvtul2/sc8xsJTUr5zhCxMK8eImsetuiOhS0MXFxVe/+tUnT564GXSep7t3737y8aeHi16+H+yHGdSAaK+SUGGHPMvkWBVDLRFmfh3ubCAFmlNKLl2oKgA73mSCm3sDEBESVgVUwRp+1Wi3VoSBev96mjWkd/eKiLiPAMyUkrhZHxGrtlMHM0tKiExopOIuFAAEVS9dvFgs1usLJDSTgECgBMIgYoYGimoIhqgmVNpCwj7GvsA4FoEOdAn4cnGAZwxrkiF8eJFxEYkxjuN4eXk5TdMHH3zwla+88Z/+5v9L0QOBslXOSq7GgS3FTJyHv8R5VncC7kvbrcqKWLTIXOHLrKmKdYAAUK2itfB/+0RPlm7/HU2q9GbWLHmVaTBS3w+EvFpPzMzAMqeOuAcaKDAGU2TG0IW+6zqknmDGhGCMQmiiUt4qR+q/rGW8cjjV272V2ReGA9w8Clfeme0Ofq2fWkeVmW2328Vi4WEFXdf99re/ffPNN5fL048//piZmHmO016K0pEPqP36YtaJFmSLfFG7fiBRbQZeBfV8lZlhsWoREdDOWrWnC+6vg5byGTs1BmpRRDNThFzyxMs0IAIYmSkRIOaSXsxMDGBERgjYd737Ex28+tAF5nEcxrHfzttAjIAMOYqWsu04R0G4+xcRj0qyv6rhj6kS1+cIASrlu3oR9l0w7cg0BK4WFlt+p6VcnGcPX1xcnJycDMPw5MmTGGOMcbPZMHfTNJWWWPkODt/HHefbORw/9wVQYieaOC/YG7meQnvIH01EkKs3y0EsAzbqh2cfq2ql9WrWJGkiovf8c1loNysqJWeo1GtBMgRm4GmKyDTP83Cy3G63HXM/BGbquq7v+4vVGsDSHN2jjQECUjQn/F5HUbGYrVoMf1njYBfq17p0vyMEcM3od4HgN8xhXwL2iEWP1tput8z8+uuvP378OISeiAQO4eya8TI3zK02LqzVRytgUQNAAVDMPGJZVFEJ0HIVjCyQ3xDz3H6uEGBN9BQ40XdLq+3KIbbifg7yCdSFHhWmKcaUEFFFVHQcOkdIF5Wc4kxxJgD3WijWeISc/6aqBhZCgCMnwGcc9W47drefOw7VE3ydunAwXozLv+qR01Mg51LdPElEdFOP7yUirlYrt4G6DPro0YciAsh2Y/PDm8eVM7iNQaMRBnZPt/LXzBxWRZXJm5MhaI7cRncw7cdi1P2un1ugh7KnbYQwirmPIJuQqPoPsxbiIQ2ukYcQNtsNEpmaiTD1ziKGoes6FomGkES6gNx1FALOZCIIaGpEzKZogECaW4+5JerFVv1wHMB6e6RSAao/3I7g/T7HzXO7EpOPR9sXlYjOz8+ZebFYIOKHH35IRO+//0GuaowAgDfe1gCvKFrov/h4LoJRIcya8p3tLrrkcHBbNAA1MCPEUIC1kOBCjKvlqDniJKA+t/pH99Tthvz7yR465SvJRBzCNE2GmFQAjJhOT5ab9ebu3QfjsGAMHeFyMRDikOOvdE4E2DP2DAEUmXrzzpMG4mUCyur+DsbntOnLDeMGNLgZQ7InMkYRWSwWAOD2H7/w6dOnzPzaa6/93Q9+Ogwjs1t4bh57GYa3xMDrxm7meKjO1h8qEMP+U1oKXc85HleCeD1C+8jj3c260FGJYwshLBaLEJjRSLVjVLNkejnNkW1S4T6AGSGJJMeTlJIkKV39vClfqclj3vbTI0QAIfcX+B1AZAsnnyMl+LnGldB2M/D5a3tGmJTUsL7vXQQahuG1116rksAurhBLYngx2u+x1H1ibNVIeqM6DkeXHJ+oJbPRrMhiGTyBcBfG06KKqWmOTq3rY2bGBpqL0SJizpkEM1TFrBC7GxbczVCnVKJ9csQOEXVdR4hgEjiM45h0m9dTRUECESGFEBbjwjtWeSIbAPR9b2bE7iwGl0LBa0ZAxGxjANunKa9u7N7xd/G0l67bv9DwyJ/Ly0tPfVTVvu+JyL1Oqvree+89evRoHMdqLLruVteBMlRh8lmJHQfiTRXKq6QB2VqlZoZ1PgqkxEZs5JJPxlVTVmBTMgGb0SKjECQCYVRE9eKzuR1nMwGfDkIuEYfFwVAFpBBC33dDx30g/7sYe1U9WS6znAY2DENgNhGJCRGHYXj48KErVJKSr7zDdzXDS0q4r4ocE4JXATN4FNr4BeYAdQVvOKEWgAAAT4rv+96JqzfOSCktl8vNZuNmu5///OddF7xM4g1Px1wbEKB5vlPlMjGokku9lYK5Insc8464I321PK6IiLB3FGvf6+BaVVVzsg0AubyPm/PzJU0cExwgqi9g1joJ2W1AmfznFppM1WDgrHKzWocQNJlnqxFR33WXIuO4GIYBEM7Ozlyw2mw2RNT3fWBCrLF6xXGeEnKgAutYwnX1xsV/icOqEvyFGxXubobUNsLEzNbr9XK5nKbJA+B8+1NK0zSllLque/r06d27d/cIJNY/e48mNAQl3GFAkaGBwLg8dtf1qETJGEGF0PrPdobwHSKpVbFZNZPbK4Ydms/R+2Lk7hhaBCSfT5MRkkUqRDJgQAZjQLJcwcERoOu6vutcAfDmxFASppnIEDbbrXmVVcTFuBgXY5I0jqOZpZTAgImGYUBE1cS554gAohGqKhqACaIi6g2+6Fc08AtUGOuG0XKDyuM85eUg8imltNlsxnF06PfIE9eMnRqu19vlMqhFJMNdn6w8qtiN7ruxmyJ4D1j8bRJey82rRdLjFyxnvwO73FwnUCX1zFgse1UNDGvUpuWqYUWjqXVtdw0wG10GMwcqUhAiErEHIAFA3/ciMixGRCQKjAEMxj4kkSHwvdfudR2vN5fID2KMIgogZUMspthxj4hexB129tXsxUd8hhb32UclMfXIF5UDHA9shpXag+Bsrqi28zwPw7CzpZSYiGEYPv74k6dPnxLR06dPC6Cr3Qji/tg9MSgfuXaY2Q113g9PLnKK8wA/BPuMAq4KGsOrByACubCFpqDuk0JE8mxKRmZgtkDYMXEgYgwdc+Da29Rv3nVd13WunCMAEaUYu64bx3GxWKSUxnFExGmaRMSFJyLy1pFawn7q+qMBATAi7dOH42XaV11ezvgyIEALfx7mgCXb3aHfDf+Xl5d37txxel+rEfqC3rlz5+Li/PHjx54db5ZN61AE6NvTpRto2G12rlVsMvRbbiB55c4TkZXGFjt7IpBDpjetzGeC92cxIEPyTJY9ZbdGOvjn0pgvVO9vriVj1vd913WmttlsuhCgaLdE7CzCZSQtbUcQcJ5nMqgB514zVE1V1HTXfePm5apre4zz9fjteYhf/hJEoFti5EtB2wP4aCdgTTghItaAHz9/nucY4927d+tNfJ+8gPg4ju4RQ8SUohczA9BC319q7b4mAvn47er06lc1VAUVgA7MTC2R++8PcgVx7z5V+amSoR9nZhNVUCKCnMmz16AAEZl7RMTAxedA9YZu2fSFEkkXFxeL5amZeS82Jz1933s6EZTYuzjPDJhS6rqeiKZpanQzAwDK6We7dn3l9Xeuayg5746NlXi1D7oOMQ5WuF2ZggBXeS4Ptkl/38E8Pm4msb46pSZPlnAWi8WHH354enpqJRjY/QB938/zfHJy8sEHHzx8+PDtt3/p8gDcGqsBoBp8coWnCov7FO25ls65FiAqquZy0Lzj/7g77ZjktYpK+Q33b47gjVXB3eF7OEBEzB15gQnIZlGHOihtZ83Muy7M87xYgplV4mJm4ziK7LJzUkoqEkLIhX6z2coFsmAAoQtzSkiY0yKRd76AIgG2a1hfuNGaXlxzIDIgAy/Sd2Cf+BwOa8bBT9REs/gmFU2Lzs/PM9duquK4gNR1nQdFv/XWW6vV6uLiApHMwJNUTRGMDyaA5qUaqnqA9b+XsmhO2VopaE8N2NcBWmgw81Z3O3JeBxatFxGZiJECEVJVd3fjQOypclF7gksv23kCAGbebram2nf9yWJxcX4+dL1aIoKYYlJdnCw9cqjvOgRjBGQ0UCMyZHF5iNAAcnbl80DzHqusVdefFQzWfn0eEch+z2hxAPQHb2KmAFg9uFhUYTf2u1R6ID552H1K6fLychiGx48fb7dbAHfSQ+mgR2hX2x/rRG4v3+UN2y/P1P6at892AoCqqle69owW2mnRe9pwYUTtnS07Q/beui4CIYAhUSACxPyXmQKzW+TNrIRfeH8nFYO+75lYVbfbrYgOi8XjJ09VdDGOiKgqp6dnhQaBqi6WS8pdADvI3QkMCFXEwLwWJBEpZKPaDdDbMrf2dQ6q/TwXs/0imUGvFP0PNOAqAtV18QZh7WlO+738srOCy8vLeZ7HcfQaQbX7KDM3xQV3w+wKc/XBd3xRp36lM3WDzW2gJXu83WCsWQoIzIwIpmK0iwrFpmiF7fpMOtIgcSDqiA4i5NjRCgCA6YAD+IoB4sXF6uTkBBFdmKxegnEcvddlipGZsw2VeRiG1WplQOK8ygyZLJYvkEs75WJe5e2OyNwhfLdfD5L+bjP+f3XFFT/tdmVBAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F85B228C750>"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "aligned_image.save('/content/pic2.jpg')"
      ],
      "metadata": {
        "id": "fUqluVaKeePP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4JPFh0eA3vkn"
      },
      "source": [
        "# Video Alignment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4KNKBjpx3S3r"
      },
      "source": [
        "video_path = '/content/original_video.mp4'\n",
        "video_obj = cv2.VideoCapture(video_path)\n",
        "\n",
        "success, img = video_obj.read()\n",
        "frames = []\n",
        "while success:\n",
        "  aligned_image = run_alignment(img)\n",
        "  frames.append(aligned_image)\n",
        "  \n",
        "  success, img = video_obj.read()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hoYwH0BU3rUt"
      },
      "source": [
        "def write_video(frames,fps,filename):\n",
        "  \n",
        "  fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')\n",
        "  writer = cv2.VideoWriter(filename,fourcc,fps,(256,256))\n",
        "  for frame in frames:\n",
        "    writer.write(np.array(frame)[:,:,::-1])\n",
        "\n",
        "  writer.release()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4iOhNCHz3tTE"
      },
      "source": [
        "filename = '2.mp4'\n",
        "fps = 35\n",
        "write_video(frames,fps,filename)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Extract landmarks for every frame in the video"
      ],
      "metadata": {
        "id": "uu5KOq6cYSp5"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S204HyfHorUY"
      },
      "source": [
        "import os\n",
        "os.chdir('/content')\n",
        "!rm -rf ldm\n",
        "os.mkdir('ldm')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CoXWwOr6o51Q"
      },
      "source": [
        "def video2ldm(model_path,video_path,output_path):\n",
        "  video_obj = cv2.VideoCapture(video_path)\n",
        "  success,image = video_obj.read()\n",
        "  count = 0\n",
        "  length = int(video_obj.get(cv2.CAP_PROP_FRAME_COUNT))\n",
        "  zero_fill = int(pow(length,1/10))+1\n",
        "  while success:\n",
        "    aligned_image = run_alignment(image)\n",
        "    detect_facial_landmarks(model_path, np.array(aligned_image), count, zero_fill, False, True, output_path)\n",
        "    count += 1   \n",
        "    success,image = video_obj.read()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "njB_hSapkWsS"
      },
      "source": [
        "model_path = '/content/shape_predictor_68_face_landmarks.dat'\n",
        "output_path = '/content/ldm'\n",
        "video_path = '/content/2.mp4'\n",
        "video2ldm(model_path,video_path,output_path)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S4hHII9Vkl_Q",
        "outputId": "34433c73-fe56-4fe2-84a2-b7332f82d4e2"
      },
      "source": [
        "%cd /content"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3E2APYSjo4Ep",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e2fa5b2-4255-4d4f-92d2-bec188926302"
      },
      "source": [
        "!zip -r ldm.zip ldm"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  adding: ldm/ (stored 0%)\n",
            "  adding: ldm/49.txt (deflated 54%)\n",
            "  adding: ldm/60.txt (deflated 55%)\n",
            "  adding: ldm/24.txt (deflated 56%)\n",
            "  adding: ldm/64.txt (deflated 54%)\n",
            "  adding: ldm/52.txt (deflated 55%)\n",
            "  adding: ldm/17.txt (deflated 56%)\n",
            "  adding: ldm/05.txt (deflated 55%)\n",
            "  adding: ldm/46.txt (deflated 52%)\n",
            "  adding: ldm/76.txt (deflated 53%)\n",
            "  adding: ldm/28.txt (deflated 57%)\n",
            "  adding: ldm/30.txt (deflated 56%)\n",
            "  adding: ldm/47.txt (deflated 55%)\n",
            "  adding: ldm/73.txt (deflated 54%)\n",
            "  adding: ldm/22.txt (deflated 56%)\n",
            "  adding: ldm/18.txt (deflated 55%)\n",
            "  adding: ldm/34.txt (deflated 55%)\n",
            "  adding: ldm/02.txt (deflated 56%)\n",
            "  adding: ldm/12.txt (deflated 56%)\n",
            "  adding: ldm/57.txt (deflated 54%)\n",
            "  adding: ldm/13.txt (deflated 57%)\n",
            "  adding: ldm/25.txt (deflated 58%)\n",
            "  adding: ldm/53.txt (deflated 55%)\n",
            "  adding: ldm/67.txt (deflated 54%)\n",
            "  adding: ldm/01.txt (deflated 56%)\n",
            "  adding: ldm/78.txt (deflated 53%)\n",
            "  adding: ldm/48.txt (deflated 54%)\n",
            "  adding: ldm/19.txt (deflated 56%)\n",
            "  adding: ldm/00.txt (deflated 57%)\n",
            "  adding: ldm/42.txt (deflated 54%)\n",
            "  adding: ldm/59.txt (deflated 55%)\n",
            "  adding: ldm/04.txt (deflated 57%)\n",
            "  adding: ldm/41.txt (deflated 54%)\n",
            "  adding: ldm/51.txt (deflated 54%)\n",
            "  adding: ldm/07.txt (deflated 55%)\n",
            "  adding: ldm/36.txt (deflated 56%)\n",
            "  adding: ldm/33.txt (deflated 55%)\n",
            "  adding: ldm/27.txt (deflated 56%)\n",
            "  adding: ldm/70.txt (deflated 54%)\n",
            "  adding: ldm/16.txt (deflated 55%)\n",
            "  adding: ldm/66.txt (deflated 55%)\n",
            "  adding: ldm/50.txt (deflated 54%)\n",
            "  adding: ldm/56.txt (deflated 55%)\n",
            "  adding: ldm/68.txt (deflated 53%)\n",
            "  adding: ldm/77.txt (deflated 53%)\n",
            "  adding: ldm/71.txt (deflated 54%)\n",
            "  adding: ldm/23.txt (deflated 56%)\n",
            "  adding: ldm/40.txt (deflated 56%)\n",
            "  adding: ldm/63.txt (deflated 55%)\n",
            "  adding: ldm/55.txt (deflated 54%)\n",
            "  adding: ldm/37.txt (deflated 56%)\n",
            "  adding: ldm/11.txt (deflated 55%)\n",
            "  adding: ldm/06.txt (deflated 57%)\n",
            "  adding: ldm/26.txt (deflated 56%)\n",
            "  adding: ldm/08.txt (deflated 56%)\n",
            "  adding: ldm/65.txt (deflated 54%)\n",
            "  adding: ldm/72.txt (deflated 54%)\n",
            "  adding: ldm/45.txt (deflated 54%)\n",
            "  adding: ldm/38.txt (deflated 56%)\n",
            "  adding: ldm/58.txt (deflated 54%)\n",
            "  adding: ldm/14.txt (deflated 55%)\n",
            "  adding: ldm/15.txt (deflated 55%)\n",
            "  adding: ldm/31.txt (deflated 55%)\n",
            "  adding: ldm/82.txt (deflated 54%)\n",
            "  adding: ldm/62.txt (deflated 55%)\n",
            "  adding: ldm/44.txt (deflated 54%)\n",
            "  adding: ldm/21.txt (deflated 56%)\n",
            "  adding: ldm/75.txt (deflated 54%)\n",
            "  adding: ldm/39.txt (deflated 55%)\n",
            "  adding: ldm/32.txt (deflated 55%)\n",
            "  adding: ldm/43.txt (deflated 54%)\n",
            "  adding: ldm/81.txt (deflated 54%)\n",
            "  adding: ldm/03.txt (deflated 56%)\n",
            "  adding: ldm/80.txt (deflated 54%)\n",
            "  adding: ldm/29.txt (deflated 56%)\n",
            "  adding: ldm/69.txt (deflated 54%)\n",
            "  adding: ldm/74.txt (deflated 54%)\n",
            "  adding: ldm/54.txt (deflated 54%)\n",
            "  adding: ldm/79.txt (deflated 53%)\n",
            "  adding: ldm/61.txt (deflated 55%)\n",
            "  adding: ldm/20.txt (deflated 56%)\n",
            "  adding: ldm/35.txt (deflated 55%)\n",
            "  adding: ldm/09.txt (deflated 56%)\n",
            "  adding: ldm/10.txt (deflated 57%)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YRAwa3ycw7TQ"
      },
      "source": [
        "# Record the difference between the landmarks of input image and every frame"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y6s7Xxrz-a89"
      },
      "source": [
        "def find_frame2(ldm1, ldm2_path):\n",
        "  # optimal_img = np.zeros([256,256,3])\n",
        "  optimal_frame = 0\n",
        "  min_diff = 10000\n",
        "  diff_list = []\n",
        "  for filename in sorted(os.listdir(ldm2_path)):\n",
        "    complete_path = ldm2_path + '/' + filename\n",
        "    ldm2 = np.loadtxt(complete_path)\n",
        "    diff = np.mean(np.linalg.norm(ldm1 - ldm2, ord=2, axis=1))\n",
        "    diff_list.append(diff)\n",
        "    # print(diff)\n",
        "    if diff < min_diff:\n",
        "      min_diff = diff\n",
        "      optimal_frame = filename[:-4]\n",
        "  \n",
        "  return optimal_frame, diff_list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iwNAPoz2_mTS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0045c81a-2ac9-48b6-ebb8-6ea4ba3e8d5f"
      },
      "source": [
        "import cv2\n",
        "import dlib\n",
        "model_path = '/content/shape_predictor_68_face_landmarks.dat'\n",
        "image = cv2.imread('pic1.jpg')\n",
        "ldm1 = detect_facial_landmarks(model_path, image, count=1, zero_fill=1, if_img=False, if_txt=False, output_path=None)\n",
        "ldm2_path = '/content/ldm'\n",
        "optimal_frame, diff_list = find_frame2(ldm1, ldm2_path)\n",
        "\n",
        "textfile = open(\"/content/pzy1.txt\", \"w\")\n",
        "for diff in diff_list:\n",
        "    textfile.write('%f\\n'%diff)\n",
        "textfile.close()\n",
        "print(optimal_frame)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "01\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aWVaIrBIV4-D",
        "outputId": "63056c67-23fa-48cd-a6dd-b069595dde5b"
      },
      "source": [
        "import cv2\n",
        "import dlib\n",
        "model_path = '/content/shape_predictor_68_face_landmarks.dat'\n",
        "image = cv2.imread('pic2.jpg')\n",
        "# aligned_image = run_alignment(image)\n",
        "ldm1 = detect_facial_landmarks(model_path, image, count=1, zero_fill=1, if_img=False, if_txt=False, output_path=None)\n",
        "ldm2_path = '/content/ldm'\n",
        "optimal_frame, diff_list = find_frame2(ldm1, ldm2_path)\n",
        "\n",
        "textfile = open(\"/content/pzy2.txt\", \"w\")\n",
        "for diff in diff_list:\n",
        "    textfile.write('%f\\n'%diff)\n",
        "textfile.close()\n",
        "print(optimal_frame)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "82\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kjsf-vE7Nj5k"
      },
      "source": [
        "# def loss2weight(txt_path1, txt_path2):\n",
        "#   loss1 = np.loadtxt(txt_path1)\n",
        "#   loss2 = np.loadtxt(txt_path2)\n",
        "#   loss1 = loss1 - np.min(loss1)\n",
        "#   loss2 = loss2 - np.min(loss2)\n",
        "\n",
        "#   weight = np.zeros((2,len(loss1)))\n",
        "\n",
        "\n",
        "#   for i in range(weight.shape[1]):\n",
        "#     # print(i)\n",
        "#     # print(weight)\n",
        "#     weight[0,i] = np.exp(-loss1[i])/(np.exp(-loss1[i])+ np.exp(-loss2[i]))\n",
        "#     weight[1,i] = 1 - weight[0,i]\n",
        "\n",
        "#   return weight"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nbSMqNsrMgaR"
      },
      "source": [
        "# txt_path1 = '/content/pzy1.txt'\n",
        "# txt_path2 = '/content/pzy2.txt'\n",
        "# weight = loss2weight(txt_path1, txt_path2)\n",
        "# print(weight)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}