05_prep_chip_order.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prep chip order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boilerplate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/mnt/home/pleung/projects/peptide_binders/r0/peptide_binders\n",
      "dig28\n"
     ]
    }
   ],
   "source": [
    "%load_ext lab_black\n",
    "# python internal\n",
    "import collections\n",
    "import copy\n",
    "import gc\n",
    "from glob import glob\n",
    "import h5py\n",
    "import itertools\n",
    "import os\n",
    "import random\n",
    "import re\n",
    "import socket\n",
    "import shutil\n",
    "import subprocess\n",
    "import sys\n",
    "\n",
    "# conda/pip\n",
    "import dask\n",
    "import graphviz\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import scipy\n",
    "import seaborn as sns\n",
    "from tqdm import tqdm\n",
    "\n",
    "# special packages on the DIGS\n",
    "import py3Dmol\n",
    "import pymol\n",
    "import pyrosetta\n",
    "\n",
    "# notebook magic\n",
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "print(os.getcwd())\n",
    "print(socket.gethostname())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load selected designs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_json = os.path.join(os.getcwd(), \"04_run_af2_short\", \"to_order.json\")\n",
    "to_order_df = pd.read_json(input_json)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "subpools = {}\n",
    "i = 0\n",
    "for length in set(to_order_df.chA_length.values):\n",
    "    subset = to_order_df[to_order_df[\"chA_length\"] == length]\n",
    "    if len(subset) < 1000:\n",
    "        subpools[i] = subset\n",
    "        i += 1\n",
    "    else:\n",
    "        for split in np.array_split(subset, int(len(subset) / 1000) + 1):\n",
    "            subpools[i] = split\n",
    "            i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 494\n",
      "1 907\n",
      "2 907\n",
      "3 907\n",
      "4 907\n",
      "5 907\n",
      "6 907\n",
      "7 907\n",
      "8 907\n",
      "9 907\n",
      "10 782\n",
      "11 781\n",
      "12 781\n",
      "13 946\n",
      "14 946\n",
      "15 945\n",
      "16 945\n",
      "17 945\n",
      "18 945\n",
      "19 945\n"
     ]
    }
   ],
   "source": [
    "for key, value in subpools.items():\n",
    "    print(key, len(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make functions to domesticate sequences uses Ryan's `domesticator`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def row2dna(row) -> str:\n",
    "    def capture_1shot_domesticator(cmd: str) -> str:\n",
    "        \"\"\"\n",
    "        run domesticator cmd.\n",
    "        split stdout into lines.\n",
    "        loop once through discarding lines up to ones including >.\n",
    "        return joined output\n",
    "        \"\"\"\n",
    "\n",
    "        def cmd_no_stderr(command, wait=True):\n",
    "            \"\"\"@nrbennet @bcov @pleung\"\"\"\n",
    "            the_command = subprocess.Popen(\n",
    "                command,\n",
    "                shell=True,\n",
    "                stdout=subprocess.PIPE,\n",
    "                stderr=subprocess.PIPE,\n",
    "                universal_newlines=True,\n",
    "            )\n",
    "            if not wait:\n",
    "                return\n",
    "            the_stuff = the_command.communicate()\n",
    "            return str(the_stuff[0])\n",
    "\n",
    "        stdout = cmd_no_stderr(cmd)\n",
    "\n",
    "        sequence = []\n",
    "        append = False\n",
    "        for line in stdout.splitlines():\n",
    "            if append:\n",
    "                sequence.append(line)\n",
    "            else:\n",
    "                pass\n",
    "            if \">unknown_seq1\" in line:\n",
    "                append = True\n",
    "            else:\n",
    "                pass\n",
    "        to_return = \"\".join(sequence)\n",
    "        return to_return\n",
    "\n",
    "    protein = row[\"chA_seq\"]\n",
    "    dna = capture_1shot_domesticator(\n",
    "        f\"./domesticator.py {protein} --avoid_restriction_sites BsaI XhoI NdeI --avoid_patterns AGGAGG GCTGGTGG ATCTGTT GGRGGT GGATCC GCTAGC AAAAAAAA GGGGG TTTTTTTT CCCCCCCC CACCTGC --avoid_kmers 8 --avoid_kmers_boost 10 --species s_cerevisiae\"\n",
    "    )\n",
    "    return dna"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reverse translate designs to order\n",
    "Use domesticator to reverse translate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from dask.distributed import Client\n",
    "from dask_jobqueue import SLURMCluster\n",
    "from glob import glob\n",
    "import logging\n",
    "import pwd\n",
    "\n",
    "print(\"run the following from your local terminal:\")\n",
    "print(\n",
    "    f\"ssh -L 8000:localhost:8787 {pwd.getpwuid(os.getuid()).pw_name}@{socket.gethostname()}\"\n",
    ")\n",
    "\n",
    "subpool_futures = {}\n",
    "translated_subpools = {}\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # configure SLURM cluster as a context manager\n",
    "    with SLURMCluster(\n",
    "        cores=1,\n",
    "        processes=1,\n",
    "        job_cpu=1,\n",
    "        memory=\"1GB\",\n",
    "        queue=\"long\",\n",
    "        walltime=\"23:30:00\",\n",
    "        death_timeout=120,\n",
    "        local_directory=\"$TMPDIR/dask\",\n",
    "        log_directory=\"/mnt/home/pleung/logs/slurm_logs\",\n",
    "        extra=[\"--lifetime\", \"23h\", \"--lifetime-stagger\", \"4m\"],\n",
    "    ) as cluster:\n",
    "        print(cluster.job_script())\n",
    "        # scale between 1-50 workers,\n",
    "        cluster.adapt(\n",
    "            minimum=1,\n",
    "            maximum=20,\n",
    "            wait_count=400,  # Number of consecutive times that a worker should be suggested for removal it is removed\n",
    "            interval=\"5s\",  # Time between checks\n",
    "        )\n",
    "        # setup a client to interact with the cluster as a context manager\n",
    "        with Client(cluster) as client:\n",
    "            print(client)\n",
    "            for subpool, df in subpools.items():\n",
    "                future_df = client.submit(df.apply, row2dna, axis=1)\n",
    "                subpool_futures[subpool] = future_df\n",
    "            for subpool, pending in subpool_futures.items():\n",
    "                translated_subpools[subpool] = pending.result()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save translations and add back into the original dict of subpools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "output_dir = os.path.join(os.getcwd(), \"05_to_order\")\n",
    "os.makedirs(output_dir, exist_ok=True)\n",
    "with open(os.path.join(output_dir, \"subpools.pkl\"), \"wb\") as handle:\n",
    "    pickle.dump(translated_subpools, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "output_dir = os.path.join(os.getcwd(), \"05_to_order\")\n",
    "with open(os.path.join(output_dir, \"subpools.pkl\"), \"rb\") as handle:\n",
    "    translated_subpools = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.DataFrame(translated_subpools[0])\n",
    "df_test.columns = [\"dna\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_subpools = {}\n",
    "for i, translated in translated_subpools.items():\n",
    "    temp_df = pd.DataFrame(translated)\n",
    "    temp_df.columns = [\"dna\"]\n",
    "    final_subpools[i] = pd.concat((subpools[i], temp_df), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add pool adaptors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cp /mnt/home/linnaan/software/LA_OligoOverlapOpt/pool_adaptors_short_list.txt 05_to_order/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 name\n",
      "1 pETCON_TJ_1\n",
      "2 pETCON_TJ_2\n",
      "3 pETCON_TJ_3\n",
      "4 pETCON_TJ_4\n",
      "5 pETCON_TJ_5\n",
      "6 pETCON_TJ_6\n",
      "7 pETCON_TJ_7\n",
      "8 pETCON_TJ_8\n",
      "9 pETCON_TJ_9\n",
      "10 pETCON_TJ_10\n",
      "11 pETCON_TJ_11\n",
      "12 pETCON_TJ_12\n",
      "13 pETCON_TJ_13\n",
      "14 pETCON_TJ_14\n",
      "15 pETCON_jason_01\n",
      "16 pETCON_jason_02\n",
      "17 pETCON_jason_03\n",
      "18 pETCON_jason_04\n",
      "19 pETCON_jason_05\n",
      "20 pETCON_jason_06\n",
      "21 pETCON_jason_07\n",
      "22 pETCON_jason_08\n",
      "23 pETCON_jason_09\n",
      "24 pETCON_jason_10\n",
      "25 pETCON_jason_11\n",
      "26 pETCON_jason_12\n",
      "27 pETCON_marc1\n",
      "28 pETCON_marc2\n",
      "29 pETCON_marc3\n",
      "30 pETCON_marc4\n",
      "31 pETCON_marc5\n",
      "32 pETCON_marc6\n",
      "33 pETCON_marc7\n",
      "34 GS_TJ_1\n",
      "35 GS_TJ_2\n",
      "36 GS_TJ_3\n",
      "37 GS_TJ_4\n",
      "38 GS_TJ_5\n",
      "39 GS_TJ_6\n",
      "40 GS_TJ_7\n",
      "41 GS_TJ_8\n",
      "42 GS_TJ_9\n",
      "43 GS_TJ_10\n",
      "44 GS_TJ_11\n",
      "45 GS_TJ_12\n",
      "46 GS_TJ_13\n",
      "47 GS_TJ_14\n",
      "48 GS_jason_01\n",
      "49 GS_jason_02\n",
      "50 GS_jason_03\n",
      "51 GS_jason_04\n",
      "52 GS_jason_05\n",
      "53 GS_jason_06\n",
      "54 GS_jason_07\n",
      "55 GS_jason_08\n",
      "56 GS_jason_09\n",
      "57 GS_jason_10\n",
      "58 GS_jason_11\n",
      "59 GS_jason_12\n",
      "60 GS_marc1\n",
      "61 GS_marc2\n",
      "62 GS_marc3\n",
      "63 GS_marc4\n",
      "64 GS_marc5\n",
      "65 GS_marc6\n",
      "66 GS_marc7\n",
      "67 SG_TJ_1\n",
      "68 SG_TJ_2\n",
      "69 SG_TJ_3\n",
      "70 SG_TJ_4\n",
      "71 SG_TJ_5\n",
      "72 SG_TJ_6\n",
      "73 SG_TJ_7\n",
      "74 SG_TJ_8\n",
      "75 SG_TJ_9\n",
      "76 SG_TJ_10\n",
      "77 SG_TJ_11\n",
      "78 SG_TJ_12\n",
      "79 SG_TJ_13\n",
      "80 SG_TJ_14\n",
      "81 SG_jason_01\n",
      "82 SG_jason_02\n",
      "83 SG_jason_03\n",
      "84 SG_jason_04\n",
      "85 SG_jason_05\n",
      "86 SG_jason_06\n",
      "87 SG_jason_07\n",
      "88 SG_jason_08\n",
      "89 SG_jason_09\n",
      "90 SG_jason_10\n",
      "91 SG_jason_11\n",
      "92 SG_jason_12\n",
      "93 SG_marc1\n",
      "94 SG_marc2\n",
      "95 SG_marc3\n",
      "96 SG_marc4\n",
      "97 SG_marc5\n",
      "98 SG_marc6\n",
      "99 SG_marc7\n",
      "100 pBAD_TJ_1\n",
      "101 pBAD_TJ_2\n",
      "102 pBAD_TJ_3\n",
      "103 pBAD_TJ_4\n",
      "104 pBAD_TJ_5\n",
      "105 pBAD_TJ_6\n",
      "106 pBAD_TJ_7\n",
      "107 pBAD_TJ_8\n",
      "108 pBAD_TJ_9\n",
      "109 pBAD_TJ_10\n",
      "110 pBAD_TJ_11\n",
      "111 pBAD_TJ_12\n",
      "112 pBAD_TJ_13\n",
      "113 pBAD_TJ_14\n",
      "114 pBAD_jason_01\n",
      "115 pBAD_jason_02\n",
      "116 pBAD_jason_03\n",
      "117 pBAD_jason_04\n",
      "118 pBAD_jason_05\n",
      "119 pBAD_jason_06\n",
      "120 pBAD_jason_07\n",
      "121 pBAD_jason_08\n",
      "122 pBAD_jason_09\n",
      "123 pBAD_jason_10\n",
      "124 pBAD_jason_11\n",
      "125 pBAD_jason_12\n",
      "126 pBAD_marc1\n",
      "127 pBAD_marc2\n",
      "128 pBAD_marc3\n",
      "129 pBAD_marc4\n",
      "130 pBAD_marc5\n",
      "131 pBAD_marc6\n",
      "132 pBAD_marc7\n"
     ]
    }
   ],
   "source": [
    "primer_list, i = [], 0\n",
    "with open(\"05_to_order/pool_adaptors_short_list.txt\", \"r\") as f:\n",
    "    for line in f:\n",
    "        primer_list.append([i, line.split()[0]])\n",
    "        i += 1\n",
    "    primer_pairs = pd.DataFrame(primer_list, columns=[\"adaptor_number\", \"adaptor_name\"])\n",
    "\n",
    "for _, row in primer_pairs.iterrows():\n",
    "\n",
    "    print(*row.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make commands to use Linna's `two_oligo_assembly.v2.py` to break oligos in half for assembly\n",
    "Make sure to check Tm (after `-min_melt_temp`) and max oligo size `-max_oligo_size`  \n",
    "`OligoOverlapOpt` has the tendency of overestimate the Tm, Tm range between 62 ~ 65 is probably good."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "adaptor_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 24, 25, 26, 29, 30, 31]\n",
    "cmd_list, dna_file_list = [], []\n",
    "primer_dir = \"/home/linnaan/software/LA_OligoOverlapOpt\"\n",
    "Tm = 63\n",
    "MAX_OLIGO = 300\n",
    "for num, adaptor in enumerate(adaptor_list):\n",
    "    subpool = final_subpools[num]\n",
    "    out_dir = os.path.join(os.getcwd(), \"05_to_order\")\n",
    "    dna_tmp_list = os.path.join(out_dir, f\"dna_tmp_{num}.list\")\n",
    "    with open(dna_tmp_list, \"w\") as f:\n",
    "        for i, row in subpool.iterrows():\n",
    "            line = \" \".join([i, row[\"chA_seq\"], row[\"dna\"]])\n",
    "            print(line, file=f)\n",
    "    cmd = (\n",
    "        f\"cd {out_dir}; python {os.path.join(os.getcwd(), 'two_oligo_assembly.v2.py')} -input_list {dna_tmp_list} \"\n",
    "        + f\"-adaptor_number {adaptor} -nproc 2 \"  # use 2 cores\n",
    "        + f\"-min_melt_temp {Tm} -codontable_fname /home/linnaan/software/LA_OligoOverlapOpt/codontable.tab \"\n",
    "        + f\"-adaptor_fname /home/linnaan/software/LA_OligoOverlapOpt/pool_adaptors_short_list.txt -max_oligo_size {MAX_OLIGO}\"\n",
    "    )\n",
    "    cmd_list.append(cmd)\n",
    "\n",
    "\n",
    "with open(os.path.join(out_dir, \"breaking.cmds\"), \"w\") as f:\n",
    "    for cmd in cmd_list:\n",
    "        print(cmd, file=f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use dask to submit the commands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run the following from your local terminal:\n",
      "ssh -L 8000:localhost:8787 pleung@dig66\n",
      "#!/usr/bin/env bash\n",
      "\n",
      "#SBATCH -J dask-worker\n",
      "#SBATCH -e /mnt/home/pleung/logs/slurm_logs/dask-worker-%J.err\n",
      "#SBATCH -o /mnt/home/pleung/logs/slurm_logs/dask-worker-%J.out\n",
      "#SBATCH -p long\n",
      "#SBATCH -n 1\n",
      "#SBATCH --cpus-per-task=2\n",
      "#SBATCH --mem=2G\n",
      "#SBATCH -t 23:30:00\n",
      "\n",
      "/home/pleung/.conda/envs/crispy/bin/python -m distributed.cli.dask_worker tcp://172.16.131.96:45285 --nthreads 2 --memory-limit 1.86GiB --name dummy-name --nanny --death-timeout 120 --local-directory $TMPDIR/dask --lifetime 23h --lifetime-stagger 4m --protocol tcp://\n",
      "\n",
      "<Client: 'tcp://172.16.131.96:45285' processes=0 threads=0, memory=0 B>\n"
     ]
    }
   ],
   "source": [
    "from dask.distributed import Client\n",
    "from dask_jobqueue import SLURMCluster\n",
    "from glob import glob\n",
    "import logging\n",
    "import pwd\n",
    "import subprocess\n",
    "\n",
    "def cmd_no_return(command:str) -> None:\n",
    "    import subprocess\n",
    "    \n",
    "    \n",
    "    \"\"\"@nrbennet @bcov @pleung\"\"\"\n",
    "    the_command = subprocess.Popen(\n",
    "        command,\n",
    "        shell=True,\n",
    "        stdout=subprocess.PIPE,\n",
    "        stderr=subprocess.PIPE,\n",
    "        universal_newlines=True,\n",
    "    )\n",
    "    \n",
    "    # block until completion\n",
    "    the_stuff = the_command.communicate()\n",
    "    \n",
    "    return\n",
    "\n",
    "print(\"run the following from your local terminal:\")\n",
    "print(\n",
    "    f\"ssh -L 8000:localhost:8787 {pwd.getpwuid(os.getuid()).pw_name}@{socket.gethostname()}\"\n",
    ")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # configure SLURM cluster as a context manager\n",
    "    with SLURMCluster(\n",
    "        cores=2,\n",
    "        processes=1,\n",
    "        job_cpu=2,\n",
    "        memory=\"2GB\",\n",
    "        queue=\"long\",\n",
    "        walltime=\"23:30:00\",\n",
    "        death_timeout=120,\n",
    "        local_directory=\"$TMPDIR/dask\",\n",
    "        log_directory=\"/mnt/home/pleung/logs/slurm_logs\",\n",
    "        extra=[\"--lifetime\", \"23h\", \"--lifetime-stagger\", \"4m\"],\n",
    "    ) as cluster:\n",
    "        print(cluster.job_script())\n",
    "        # scale between 1-20 workers,\n",
    "        cluster.adapt(\n",
    "            minimum=1,\n",
    "            maximum=20,\n",
    "            wait_count=400,  # Number of consecutive times that a worker should be suggested for removal it is removed\n",
    "            interval=\"5s\",  # Time between checks\n",
    "        )\n",
    "        # setup a client to interact with the cluster as a context manager\n",
    "        with Client(cluster) as client:\n",
    "            print(client)\n",
    "            futures = client.map(cmd_no_return, cmd_list)\n",
    "            results = [future.result() for future in futures]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenate all subpools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of oligos: 29408\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 29408/29408 [00:00<00:00, 1077258.45it/s]\n"
     ]
    }
   ],
   "source": [
    "CHIP_BATCH = \"300nt_0.list\"\n",
    "OWNER = \"pleung\"\n",
    "PROJECT = \"crispy-crispy\"\n",
    "oligo_list = []\n",
    "length_list = []\n",
    "out_dir = os.path.join(os.getcwd(), \"05_to_order\")\n",
    "for num, adaptor in enumerate(adaptor_list):\n",
    "    order_file = os.path.join(out_dir, f\"final_order_large_pool_{adaptor}.tab\")\n",
    "    with open(order_file, \"r\") as f:\n",
    "        for line in f:\n",
    "            oligo = line.rstrip().split()[-1]\n",
    "            oligo_list.append(oligo)\n",
    "            length_list.append(len(oligo))\n",
    "\n",
    "print(f\"total number of oligos: {len(oligo_list)}\")\n",
    "with open(os.path.join(out_dir, f\"{'_'.join([OWNER,PROJECT,CHIP_BATCH])}\"), \"w\") as f:\n",
    "    for oligo in tqdm(oligo_list):\n",
    "        print(oligo, file=f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot length distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqQAAAKyCAYAAAADycwvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAB9R0lEQVR4nO3deVxVdeL/8fcFLosgahmmKJUolSaJGqnZlJktTjpu1ZjZzKRpOWaJ07TRlFP2a2qkTCfDdJpRy91wmTYKm9EUcUFNnVJwElREcWMREOT8/uDB+d4rlwuyeFhez8fDx+Pe+1nO597DxTfnfD7n2AzDMAQAAABYxMPqAQAAAKBpI5ACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSBFhXbt2qU//vGPuueee9S9e3ddf/315r8yL7zwgvnali1bLBxt9R0+fNh8D2PGjKlxf2V93XXXXbUwuqZr1apV5mc5a9Ysq4dTb6SmpurVV1/VoEGDFBERoRtuuMH8nA4fPmzJmGbNmmWOYdWqVbXS51133VXu9w2qb8yYMZb/nADueFk9ANRPy5Yt06uvvqqSkhKrh4JGoixUNm/eXL/97W+tHUwD9e9//1u///3vVVRUZPVQAKBWEUhRzqlTp/Tmm2+aYbRPnz66+eabFRgYaPHI0JDNnj1bkhQcHEwgrYaioiK98sorZhgNDw/XrbfeqpYtW8pms0mSWrZsaeEIAaD6CKQoZ9OmTcrPz5ckDRo0SO+++67FIwKwZ88eZWZmSpK6d++uJUuWmEEUABo6AinKOXr0qPn4lltucVv3rbfe0ltvvVXXQwKaPMfvZa9evRp9GE1ISLB6CAAuIxY1oZzCwkLzsa+vr4UjAVCG7yWAxowjpJAkbdmyRY899li511988UW9+OKLTq8tWLBAt956q6TSVfafffZZudcdjRkzRklJSZKkb7/9Vu3bt1dqaqoWL16sjRs3KjMzUzabTcHBwbrjjjv0u9/9TldeeWWlY961a5c2btyoHTt26H//+59OnjypCxcuqEWLFrruuuvUu3dvPfzww7rqqqsu+fO4nBITE/X5559r27ZtOnHihPLz89WyZUtdf/31GjBggEaOHClvb+8K2zvuu2HDhumtt95ScXGx4uLitHbtWqWmpurMmTNq0aKFunXrpgcffFADBgyo0thKSkq0Zs0arV27Vj/++KOys7PVunVrXX/99Ro+fLjuueceSaUroo8cOSJJ+umnn8z2hw8fLretI0eOuFw5HRwcXOlRsXPnzmnFihX6/PPPdejQIeXk5OjKK69URESEHn30UfXq1avS93TixAktX75cmzZtUmpqqnJycmS323XllVfqiiuu0A033KDbbrtNffr0qbV507t379Znn32mrVu3KjMzUwUFBWrVqpXCwsJ05513auTIkS5DpqvPTyqdj1s2J7fM//t//0/Dhw+v0Tj//e9/Kz4+XsnJyTpx4oTy8vLUrFkzdejQQeHh4erfv7/69esnT0/PSvs6deqUli1bpq+//lqHDx9WQUGBWrdurVtvvVW/+c1vdMMNN7htX9HPlKOyn6Oynx3DMPTll18qLi5OP/30k7KystSiRQt16dJFQ4cO1aBBg2r9yHJ+fr5WrFih7777TgcOHNDp06fl6+urNm3aKDIyUsOGDVO3bt3c9rFq1Srz9+ykSZP09NNP6+zZs1q5cqXi4+OVnp6uU6dO6cKFCy4/i3//+99asWKFdu7cqdOnT6tVq1bq2LGjHnjgAQ0dOlR2u/2S39fBgwf12WefafPmzTp69Kiys7MVEBCgkJAQ9evXT4888ohat27tto+L948kffPNN1q7dq327t2rEydOqKCgoFZ+dtHwEUhx2S1atEhvvfVWuZXC+/fv1/79+7V8+XJ99NFHCg8Pr7CPRx55RNu3b3dZlpWVpaysLG3dulVz587VK6+8ogcffLBW30NtOHHihJ577jlt3rzZZdmJEye0ceNGffTRR5o5c6bbz8NRRkaGnnnmGe3atcvp9aysLK1fv17r16/XsGHDNH36dLfB4tSpU5o4caKSk5OdXj969KiOHj2q9evXa8CAAXrnnXeqNK6a2r9/v55++mn9/PPPTq8fO3ZMX3zxhb744gs99dRTevbZZyvs48svv9RLL72kvLw8p9eLiop07tw5paena9euXVq6dKkef/xxPf/88zUac2FhoV555RWtXr26XFlmZqYyMzO1YcMGzZ07V++8847LP+guh9TUVD333HPau3dvubLs7Gzt3btXe/fu1eLFizV58mT9/ve/d9tfUlKSoqKidOLECafXjxw5olWrVikuLk6vvfaaHn744Vp7D7m5uZo6daq+++47p9ezsrL0n//8R//5z3+0dOlS/e1vf1Pz5s1rZZubNm3SH//4x3Lv8/z588rOztaBAwf06aefatiwYZo2bZrbPywdbd26VVFRUTp+/LjbeufPn9fzzz+vzz//3On148eP6/jx40pMTNSKFSsu6bJpRUVF+stf/qJPP/1UFy5ccCo7ffq0Tp8+rV27dunvf/+7XnnlFY0YMaJK/ebk5Oi5557T+vXrqzwWNC0EUkiSQkJC9Mc//lGS9P333+v777+XVLqo6aabbipXt7o+++wzzZ49Wx4eHurbt6/Cw8Pl5+enQ4cO6auvvlJeXp7OnDmjSZMm6V//+leF/3GcOnVKktS6dWuFh4fr2muvVYsWLVRSUqJjx44pMTFRhw4dUmFhoaKjo+Xr66vBgwdXe9y17ciRIxo9erQyMjIkSX5+furXr586d+4sX19fHT9+XBs2bNChQ4d09OhRPfbYY/r000/VpUsXt/3m5eVp/Pjx2r9/v9q0aaM77rhD7dq1U0FBgTZu3Kg9e/ZIKt0PnTt31tixY132U1BQoN/+9rfm0RibzabIyEhFRETI29tbBw8eVEJCgr799lu98sorFY6nZcuW5s/V22+/LUlq0aKFJkyYUK6uu5CQmZmpsWPH6vjx47rmmmt0++23KygoSGfPntV3332n1NRUSdKcOXN0ww036L777ivXx759+zR16lQVFxdLkq6++mrddtttCg4Olt1uV05Ojn7++Wfz6GBNFRcXa9y4cebZAUm6+eabFRkZqWbNmiktLU3ffvutsrOzzff34Ycfql+/fmZ9x89vz549ZvC47bbbdNtttzltr7KjcBXZuXOnxo4dq9zcXEmSh4eHevXqpW7duqlFixY6d+6cUlNTtW3bNp0+fbrSS8Ht379fr7/+us6dO6cbbrhBvXv31hVXXKGsrCx98803Onr0qEpKSvTaa6/phhtu0M0331ytcV8sOjpa3333nfz8/HTXXXcpNDRU58+f1/bt27V161ZJpWcTHn/8cX3yySdVDocVufgSXIGBgRowYIBCQkJ07tw5JSUladeuXTIMQ6tWrVJGRobmz59f6dHlQ4cOacGCBcrOzjZ/1q+66iqdPXtWmzZtcqo7ZcoUffPNN+bzrl27qk+fPgoICDB/vnbu3KnJkydX6chwUVGRnnjiCfOPZMefhZYtWyo7O1vbtm1TcnKy8vPz9dJLL6moqEi//vWv3fZrGIYZRps1a6Y777xTHTt2lGEY2r9/f433BRoJA7jI+++/b4SFhRlhYWHGypUr3dZ9/vnnzbqJiYku6zz66KNmnbCwMOOuu+4y9u3bV67e0aNHjbvuusus99FHH1W43ZkzZxo7duwwSkpKKqyzatUq46abbjLCwsKMW265xTh37pzLeunp6eY2H330UbfvtyrK+urfv7/L8vPnzxsjRoww602dOtU4c+ZMuXoXLlwwPvroI7PePffcYxQVFZWrl5iY6PT5hoWFGX/961+NwsLCcnU/+OADs05kZKTLOoZhGG+99ZZZr0ePHsbmzZvL1Tl27Jjx4IMPGmFhYcb1119v1q/u53KxlStXOr2nG2+80fjHP/5hXLhwwalecXGx8corr5j1fvnLX7rs77nnnjPrREdHu/wsDcMwSkpKjB07dhgJCQlVGmdF3nvvPXN73bp1M7788stydU6dOmU8/vjjZr0+ffoYJ0+edNmf4+fx/vvv12hsZU6ePGn069fP7HfYsGHGgQMHXNYtLi421q9fb3z99dflyhx/Z4SFhRk333yzsW7dunL1CgoKjAkTJpj1nnjiiQrH1r9//yr/TJX9/A0dOtQ4cuRIuXrfffed0b17d7P+u+++W2GfVZGVlWXceuutZn9jx441Tp06Va7eF198Yf4OCgsLM2bNmuWyv4t/1q+//nrjo48+Kvez7mjZsmVO3w1Xv6tPnTpl/O53vyv3HU1PT3fZ5xtvvOH0s5CSkuKy3oYNG4yePXsaYWFhxk033WT873//c1nv4t9LY8aMMU6cOFHhe0LTxqImXFZ+fn6aP3++brzxxnJlbdu2VXR0tPn8q6++qrCfyZMnKyIiwu1f/cOGDdOUKVMkSWfPni13Wssqq1ev1g8//CBJuueee/TOO++oRYsW5ep5eHho3Lhx+s1vfiNJ+vnnn/XFF19U2v9DDz2kqVOnujzq8NRTT5lHvM+cOeNyusCZM2f0ySefmM/ffvtt9e7du1y9Nm3aKDY2Vq1atZJhGJWOq6YmT56s3/zmN/LwcP615enpqejoaLVp00aSdODAAfOIqaP//ve/5uOoqCh5ebk+QWSz2RQREaH+/ftXe6zZ2dn6xz/+YT7/85//rHvvvbdcvVatWulvf/ubrrvuOknSyZMntWjRompv91J99NFH5mnh6667TgsXLlSnTp1c1vX09NSdd96pgQMHVtrv66+/rl/+8pflXvfx8dGbb74pHx8fSdLGjRvLTZ+oDsMwFBgYqLlz56pdu3blyu+44w698cYb5vN//vOf5hHh6liwYIFOnz4tSQoNDdUHH3ygVq1alat333336bXXXjOf//3vf6/Sdn/3u99p3Lhx5X7Wy1y4cEEffPCB+fzZZ591OQez7OerQ4cOlX5HDx06ZP7sBQcH65///KdCQ0Nd1u3Xr595dZXz589r/vz5lb6n4OBgffjhh5XOO0XTRSDFZTVixAhde+21FZb/4he/kL+/v6TShQw1vVPUAw88YD7etm1bjfqqLWVhz2az6bnnnqv0VJrjafVvv/3WbV273a7Jkye7rXP//febjx1DWpkvv/zSXNEdHh7udgFUq1atLstF7lu1aqXf/e53FZZ7e3s7jXPfvn3l6jjOhysoKKjdAV7kq6++0rlz5yRJYWFhGjp0aIV1fX199cwzz5jPV65cWadjK1NcXKxly5aZz6Ojo83vXk2EhYW5nR5zxRVXmH/gVLRIpzp+85vfuF3A+Mtf/tL8Q/jcuXNV+uOuImULOaXSMOjulPOIESPUuXNnSaVTairbro+Pj5566im3dZKSkszLgF155ZVuvxt+fn6VzvmVpE8//dT8fTtx4sRK59nefffd5u/yyn4vSdITTzyhZs2aVVoPTReBFJfVHXfc4bbc09NT11xzjaTSBSHZ2dmV9nny5Elt2rRJK1eu1IIFCzR//nzz35o1a8x6Bw8erNnga8Hp06fNEBgSElKl+bht2rTRFVdcIUnmkdWKdOnSpdKrCpQdjZNKF3xczHERU1WOhlWlTk316dPHPKpWkcrel+NR+Zdfftm8yHxdcPzjx/EPgIoMGDDADDXHjh0zV5fXpR9++ME8WhcUFOQ0d7UmKvuOS5Xvq+pwNW/4Yo5HqXfs2FGt7aSnp5s/O76+vrrzzjsvaWyVbbdnz56VXt3BcUHngAEDKl1FP3DgwAqPtpZxnJ96++23u61bpuxKCSdPnnS6Tq4rd911V5X6RNPFoiZcVsHBwZXWcTxKc+7cuQpvh/jtt9/qo48+0s6dO6t0yvjs2bNVHmdd+emnn8yxHjp0yOXlj9wpW8xVEVenKy/m+Pm6Ol3quIq9KuO77rrr5O3trfPnz1dat7pq43397ne/01dffaWioiJ9//33uuuuu9SzZ0/deuut6t69u26++WYFBATUyngdP8PKFqJJpUd4O3fubK5y//nnn6v0XamJlJQU83FVr+BQFZe6r8qOJNeEt7e3OnbsWGk9x0tN/e9//6vWthz3badOnaq0IMfxZ6Cy7VZ0mtyR4x/XlV0+S5ICAgLUvn17paWluSy/cOGC08/DL37xi0r7vNjJkycr3Pf+/v7mlBqgIgRSXFaVHeWS5HQKu6JT9n/+85+d5jlWRV0Gpqo6c+ZMjdpX9p93VS6Y7vj5ugryjsG9KvdG9/DwUIsWLWplZXpFauN93XTTTfrb3/6m6OhoHT9+XMXFxdqyZYu2bNkiqfTofPfu3TV06FANHTq0Rit/HT9DV3MLXXGsdzn+eHL8WazKdX+r6lL3VU2n5UilV26o7AigVDufseNZm6ru27IzHFXZblUuSVXdn6+KAunZs2drvB/KbjftSm1dzxeNG4EUDc5nn31mhlFPT0/96le/0oABA9SpUye1bt1aPj4+5ikswzCqdAThcnGcxxgaGlrla/hZpaoXEb8ci5pqwx133KFvvvlG8fHxWr9+vXbs2GGearxw4YK2b9+u7du3a/78+frggw+qdLSqMvX1Fp8NZZ/VldrYL9Xpo7I2VQnWtc3x95LdbjcXg16KDh06VFhmxXtCw0MgRYPjuHo5JibG7dyxqsxBvZwcjzj6+PhUeB1QKzmu+C9bSexOSUlJvfuc3fHx8dEDDzxgLng7duyYtm7dqoSEBMXHx6uoqEg///yzJkyYoM8//7xaR0od93Nl0yzKOH7Wrq66UNscj6ydPHmyzrdXl8qO8FUWfBw/4+oetXPcN9XZt7VxtPBSv6OV1XP8eS0qKtLDDz9ca9NXgKrizxY0KAUFBfrxxx8lSe3bt690IcP+/fsvx7CqzPGI24EDB5STk2PhaFxzvApCVVZA/+9//6sX0yGq6+qrr9bgwYP17rvvavXq1eZ/9unp6frPf/5TrT4dP0NXK/4vdv78eac5fI6LfuqK4+Wddu/eXefbq0vnz5+v0qLFst8dUvU/Y8d9m5KSUqWffcc7YNXGvnXsw/E9VSQ3N1eHDx+usNxutzstsKzoLnhAXSKQokFxnDtVlXvU15drj5a5+uqrzVBaVFSkuLg4awfkQkREhPk4Pj6+0vqOd4pxp+y6nxffjrA+CQ0NdVoVX90rM/Ts2dN8/OWXX1ZaPyEhwbzUVtu2bau0MKimunXrZh4FO378uDZu3Fjn26xL7q5bXObrr782H/fo0aNa22nfvr2uvvpqSaV/IF98q9LKxub4s1Fdjn0kJCSYdx+rSHx8fKVzRB3v/LVixYqaDRCoBgIpGpTAwEBzDtbBgwfN/8Rd2bdvX738xfroo4+aj2fPnq309PQqt70c8/7uu+8+c/HZ7t273V5j8PTp0/r444+r1G9Z+KkPVzuoKj8/v2q1u/fee81rLv70009u//AoLCzU+++/bz53dYHzuuDl5aWHHnrIfD59+vRauUi9VRYsWOB26sEXX3xhHq1u1qxZlS4TVRHH68q+9957bo+SxsXFmWdq/P39a7TdMrfeeqvatm0rqfSyWf/85z8rrFtQUOB0Ef2KjB492pzyEB8fX+U/NCXmI6N2EEjRoPj5+Zn37D579qymTZvm8iLnW7Zs0bhx48z7TNcnI0eOVNeuXSWVrnQePXq026NTRUVF2rBhg5588skqHbGsqZYtW2rUqFHm8+eff16JiYnl6h0/flxPPvmkTp8+XaXFHWWX5cnPz9fOnTtrbbxVNXjwYC1btsztlQ62bt3qdO3aW265pVrbCgwMdLphwJ/+9Ceno3Nlzpw5o0mTJpl3lrryyiud/mCpa0888YR5puHgwYMaM2aMy7tcSaUX0l+/fv1l+Rm8VDabTWfOnNETTzyhY8eOlSvfuHGjXnrpJfP5Y489VqXV7BV57LHHzDm4qamp+v3vf+/y5+rrr7/Wn/70J/P5448/XitzMz09PZ0unh8TE+Pyj56yn6+0tLRKv6OdO3fWI488Iqk0YE6ZMkULFy50+zt07969mjZtmt55553qvRHAAYua0OA8+eSTmjhxoqTSu9ps3LhRd955p9q2bau8vDxt27bNvLj7008/rVmzZlk53HK8vb31wQcfaPTo0Tp8+LAyMzM1duxYderUSZGRkWZAOHv2rFJSUrR7925z0ZC7O/7UpmeffVabNm3S/v37lZOTo9/+9re69dZbFRERIW9vbx08eFAJCQnKy8vTL3/5S+3cubPSi7n379/fvCj4k08+qcGDBys4ONg8lR8QEFCn72///v165ZVXNG3aNN100026/vrrddVVV8lutysrK0u7du1ymkv5y1/+skZXaPj973+vbdu2KSkpSYWFhXr66afVvXt3RUZGqlmzZkpLS9O3335rHjG22+16++23nS4RVNeuuOIKzZw5U0888YTy8vK0d+9ePfDAA+rVq5fCw8PVokUL5eXl6eDBg0pKSjIDzuW4GcKlaNeunbp166Yvv/xS999/v+666y6Fhobq/Pnz2r59u5KSksy6N910U5XuXOTOlVdeqb/85S/6/e9/r6KiIv3nP//RPffcowEDBigkJET5+flKSkpyuslEnz59Kr0D06V46KGHtH79eq1fv17FxcV6/vnntXDhQvXt21f+/v7mz9eZM2fM2yxXdlH+F198Uenp6fr3v/+t8+fP64033lBsbKz69u2rDh06yNvbWzk5OUpLS9Pu3buVkZEhqfToKlBTBFI0OAMGDNDUqVP17rvvqqSkRJmZmVq6dKlTHZvNprFjx+r3v/99vQukUulc0lWrVulPf/qTvvrqKxmGoZSUFKeFLRdr2bKlgoKCLsv4/Pz89I9//ENPPfWUdu3aJcMwlJiYWO5Iaf/+/fX6669r0KBBZruKjB49WqtXr1ZKSopOnz6tBQsWOJUHBwfXaSC12+0qKipScXGxdu7c6fYo7fDhwzVt2rQabc/Ly0sfffSRoqOjtXbtWkmqcLtBQUF65513zFtqXk49e/bUkiVLNHXqVO3fv18lJSVKSkpyCnGOKrsrkFWmT5+uc+fO6T//+Y/WrVvnsk5kZKRmz55do2vMlrnjjjsUGxur559/XidOnNDZs2e1atUql3WHDRumP//5z/L09KzxdsvYbDa9//77+sMf/mDOUd2zZ4/27NnjVK9bt26aOXOm/vCHP1Tap5eXlz788EPNnj1b8+fPV0FBgU6cOKHVq1dX2Mbb29vt7aCBqiKQokEaP368evfurYULF2rbtm06ceKEfHx8FBQUpMjISI0YMaJW7z5TF1q0aKGZM2dq//79Wrt2rbZu3arDhw/rzJkz8vDwUGBgoK699lp17dpVffv2Vd++fS9rGLjyyiu1ZMkSrV69WmvWrNFPP/2k7OxsXXnllbr++us1dOhQ3X///bLZbObVAtydjvT399eyZcv0ySef6LvvvlNqaqpyc3MrXZBRWzZv3qzvv/9e27Zt0969e5Wenm5eLsjf318dOnRQjx49NHToUHNKRU35+vrqr3/9qx577DGtWrVKSUlJOn78uAoKCtSyZUtdf/316t+/v0aMGFHt+aq1ISwsTGvWrDGv0bpz505lZWWpsLDQvMtP9+7dNWDAAPXp08eycboTEBCguXPn6l//+pc5b/PUqVMKDAzUjTfeqKFDh+qBBx6o1evC3nbbbYqPj9eKFSv03Xff6aefftKZM2fk6+urNm3aKDIyUsOHDzenGdU2b29vvf/++/ruu++0YsUK7dy5U2fOnFHLli113XXX6Ze//KWGDx9+SQHcw8NDkydP1ujRo7Vq1SolJiYqJSVFZ86c0YULF+Tv76/27dvr+uuvV+/evXXHHXdclsuUofGzGcxGBlADx44dM+9fHhERoSVLllg8IjQVZbe2DQ4OVkJCgsWjAVATLGoCUCOOQaC2jiwCAJoWAimAasvOztZHH31kPq9vi10AAA0DgRSAS3PmzNG///3vCi9kf+jQIT3++OPmveBvvPFGSxblAAAaPhY1AXDphx9+0HvvvafWrVvrlltu0bXXXqtmzZopOztbe/bsUVJSkhlW/fz89NZbb1k8YgBAQ0UgBeBWVlaWvvjiiwrL27Vrp5kzZ9bomp0AgKaNQArApWnTpmngwIH6/vvvlZKSolOnTun06dPy8vJSq1at1KVLF91xxx361a9+VSvXdQQANF1c9gkAAACWYlETAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABLEUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIG3g+vfvr/79+1s9DAAAgGrzsnoAqJmcnByrhwAAAFAjHCEFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABLEUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsJSX1QMALofcwmKlZOXVSd+dWvsrwIevEgAA1dUg/xd99dVXtWTJEklSZGSkFi5cWGHdgwcPav78+dq0aZOysrLUvHlzhYeHa/To0br99tsr3dbGjRu1aNEi7d69Wzk5OWrdurX69OmjsWPHKjQ01G3bkpISLVu2THFxcUpNTVVRUZGCg4N19913a9y4cWrevPmlvXFUW0pWnqLW7K2TvmOGdFX34BZ10jcAAE1Bgwuk27Zt09KlS6tU99tvv9WUKVNUWFgoSQoICNCpU6e0fv16rV+/XhMmTFBUVFSF7WNiYhQbGytJstls8vf319GjR7Vy5UqtW7dO7777rgYMGOCybWFhocaPH6/ExERJkt1ul91uV0pKilJSUrR69WotXLhQHTp0uJS3DwAA0Og0qDmk58+fV3R0tDw9PXXTTTe5rXvo0CFFRUWpsLBQkZGRio+P1/bt25WUlKQxY8ZIkmJjY7Vu3TqX7deuXWuG0TFjxigpKUnbt29XfHy8IiMjVVhYqKioKKWlpbls/8YbbygxMVHe3t56/fXXlZycrOTkZC1cuFBXX321MjIy9OSTT6q4uLgGnwgAAEDD16AC6d/+9jf973//0+9+9zt17tzZbd33339fBQUFCgoK0pw5cxQSEiJJCgwMVHR0tPr37y9JmjFjhi5cuODUtri4WDNmzJAk9e/fX9HR0QoMDJQkhYSEaM6cOQoKClJBQYFmzpxZbtupqalasWKFJGnKlCl66KGHZLfbJZVOMZg1a5ZsNptSUlK0atWqGnwiAAAADV+DCaQ//vij5s2bpw4dOmjSpElu6+bl5Sk+Pl6SNGrUKAUEBJSrM27cOEnS0aNHlZSU5FSWlJSkjIwMp3qOAgICNGrUKElSfHy88vKcF8usWbNGJSUlTvUchYeHq3fv3pKkuLg4t+8FAACgsWsQgfTChQt6+eWXVVxcrFdffVW+vr5u62/fvt2cN1rRwqWIiAgzqG7atMmprOx5QECAIiIiXLbv16+fpNK5ojt27HAq27x5sySpV69e8vPzc9s+OTlZ+fn5bt8PAABAY9YgAuk///lP7dmzRw888ECVVsYfOHDAfFzRqX1PT0917NixXH3H56GhofL09HTZPiwszHyckpJiPjYMw2zvblpBWVlJSYkOHjxYYT0AAIDGrt6vsk9PT9f777+vwMBAvfjii1Vqc/z4cUlSixYt3B5NDQoKcqp/cfuycld8fX0VGBio7Oxsp/Z5eXk6d+5cpe3btGnjtL2uXbu6rNerV68K+5CknJwcLh8FAAAatHp/hPSVV15Rfn6+nnvuObVu3bpKbcoCYWWn9svKL54DWpP2jo8rOl1/cd8Xbx8AAKApqddHSFesWKHNmzerR48eevDBB60ejiW2bdvmtryyI6gAAAD1Xb09QpqVlaW3335bdrtdr7/+umw2W5XbNmvWTJJUUFDgtl5Zub+/f621d3zsbrGSY98Xbx8AAKApqbeBdMaMGTp79qweffRRtW3bVnl5eU7/yi4of+HChXKvlc3dPHv2rNtQWdFc0YrmljoqKChQdnZ2ufb+/v5moHXXPjMzs9z2AAAAmqJ6G0gPHz4sSfr444/Vo0ePcv/Wrl0rqfQST2WvrVmzRpLz6nbHFfCOHFe3X7wavux5amqqSkpKXLZ3XJnfqVMn87HNZjPbV7RtxzIPDw9ztT8AAEBTVG8DaU307NlTPj4+kqQNGza4rJOcnKzc3FxJUt++fZ3Kyp7n5uYqOTnZZfuNGzdKknx8fNSjRw+nsj59+kiStm7dWuER2rL2ERERbhc/AQAANHb1NpAuXLhQP/30U4X/hg0bJqn0Vpxlrw0fPlxS6WnzgQMHSpKWLFliBk9H8+bNkyS1a9dOkZGRTmWRkZFq27atUz1Hubm5Wrx4sSRp4MCB5eaADhkyRB4eHsrNzdWSJUvKtd+zZ4958fyhQ4dW+TMBAABojOr1KvuamDx5sr755hsdO3ZMEydO1PTp09WhQwfl5OTo/fffV0JCgiQpKiqq3MXvvby8NHXqVP3hD39QQkKCpk+frsmTJ6t58+ZKT0/Xyy+/rMzMTPn6+uqZZ54pt+3Q0FCNHDlSy5Yt04wZM+Tv769hw4bJy8tLW7du1XPPPSfDMNSpUyczRAMAgIYpt7BYKVl1dwnHTq39FeDTaCObpEYcSK+55hrFxMRoypQp2rJli+6++241b95ceXl55rzQCRMmaPDgwS7bDx48WAcOHFBsbKwWLFigRYsWyd/fXzk5OZJKT9XHxMQoJCTEZfvo6GilpaUpMTFR0dHRmjZtmux2u3mN07Zt2+rDDz+Ul1ej3QUAADQJKVl5ilqzt876jxnSVd2DW9RZ//VBo05DAwYMUFxcnObNm6fNmzfrxIkTatmypW6++WaNHj260tuQRkVFKTIyUosWLdKuXbuUk5Ojdu3aqXfv3ho3bpxCQ0MrbOvj46OPP/5YS5cuVVxcnFJTU1VUVKTQ0FANHDhQY8eOVWBgYG2/ZQAAgAbHZhiGYfUgUH1lF8av7AL6Td3OI2fr7K/XpvCXKwCgYnX5f4zUNP6fqbeLmgAAANA0EEgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABLEUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFJeVg+gMnv37lVCQoJ++OEHHTp0SKdOnVJ+fr4CAwMVFham++67TyNGjJDdbi/X9oUXXtBnn31WpW14eVX8UWzcuFGLFi3S7t27lZOTo9atW6tPnz4aO3asQkND3fZdUlKiZcuWKS4uTqmpqSoqKlJwcLDuvvtujRs3Ts2bN6/8QwAAAGjE6n0gXblypT755BPzuZ+fn+x2u06ePKnNmzdr8+bN+uSTTzR//nwFBQW57MPHx8dt8LPZbBWWxcTEKDY21qzn7++vo0ePauXKlVq3bp3effddDRgwwGXbwsJCjR8/XomJiZIku90uu92ulJQUpaSkaPXq1Vq4cKE6dOhQ6ecAAADQWNX7QBoeHq727durV69euu6668xgefbsWa1bt07vvPOO9u/frxdeeEF///vfXfYxaNAgvfXWW5e87bVr15phdMyYMZo8ebICAwOVlpaml19+WUlJSYqKitLatWsVEhJSrv0bb7yhxMREeXt765VXXtGwYcNkt9uVlJSk5557ThkZGXryySe1evVqt0doAQAAGrN6P4d06NChevzxxxUeHu50lLNFixYaPXq0XnrpJUnS999/r4yMjFrbbnFxsWbMmCFJ6t+/v6KjoxUYGChJCgkJ0Zw5cxQUFKSCggLNnDmzXPvU1FStWLFCkjRlyhQ99NBD5rSCyMhIzZo1SzabTSkpKVq1alWtjRsAAKChqfeBtDLh4eHm4+PHj9dav0lJSWbAHTduXLnygIAAjRo1SpIUHx+vvLw8p/I1a9aopKTEqd7F4+7du7ckKS4urtbGDQAA0NA0+EC6fft283H79u1rrd9NmzZJKg2eERERLuv069dPUulc0R07djiVbd68WZLUq1cv+fn5uW2fnJys/Pz8Whk3AABAQ9MgJy4WFhbq2LFj+uqrrzR79mxJ0gMPPKArr7zSZf3Nmzfr3nvv1dGjR2W32xUcHKzevXtr9OjRuvbaa122OXDggCQpNDRUnp6eLuuEhYWZj1NSUnT77bdLkgzDMNt37ty5wvdRVlZSUqKDBw+qa9eubt41AABA49RgAmlxcbHLwObh4aGhQ4fqtddeq7DtsWPH5OnpqYCAAOXm5mr//v3av3+/Fi9erJdeekmPPPJIuTZlp/8rWrkvSb6+vgoMDFR2drbTdIG8vDydO3eu0vZt2rRx2p6r99erV68K20tSTk4Ol44CAAANWoMJpDabTa1bt5YknTt3zgx8I0eO1IQJE1yeFu/SpYu6deumO++8U1dffbU8PT2Vn5+vDRs26J133lFaWpqmTZumK664Qvfdd59T27L+fX193Y7L19dX2dnZTnNIHR9XdLr+4r4vnoMKAADQVDSYQOrp6anvv//efJ6VlaXVq1crNjZWa9as0fTp0/XAAw84tXnsscfK9ePn56d77rlHt9xyi0aMGKEjR47o7bff1r333uv2eqRW2bZtm9vyyo6gAgAA1HcNdlFT69atNXbsWM2bN0/nz5/XH//4R+3Zs6fK7Vu1aqWnnnpKknTkyBHt27fPqbxZs2aSpIKCArf9lJX7+/ubrzk+drdYybFvxzYAAABNSYMNpGXCw8PVs2dPXbhwQcuWLbuktt27dzcfp6enO5WVzf10dympgoICZWdnO9WXSsNlWaB11z4zM7Pc9gAAAJqaBh9Ipf9bHHTkyJFa67NsBXxqaqpKSkpc1ilbSS9JnTp1Mh/bbDazfUpKSoXbKCvz8PBQx44dazxmAACAhqhRBNKyo5uXutp8586d5uOLr2Hat29fSVJubq6Sk5Ndtt+4caMkycfHRz169HAq69OnjyRp69atFZ72L2sfERHhdvETAABAY1avA+mFCxdkGIbbOps3b9bu3bslSbfccov5emXtzp49q7lz50qSrr76anXp0sWpPDIyUm3btpUkzZs3r1z73NxcLV68WJI0cODAcnNAhwwZIg8PD+Xm5mrJkiXl2u/Zs8e8eP7QoUPdjhUAAKAxq9eBNCMjQ0OHDtWSJUuUnp7uFDIzMjI0d+5cTZw4UYZhqEOHDho+fLhZvnr1ak2aNElfffWVTp48ab5eWFiob7/9Vg8//LDS0tIkSc8//7w8PJw/Ci8vL02dOlWSlJCQoOnTpysnJ0dS6RHZiRMnKjMzU76+vnrmmWfKjT00NFQjR46UJM2YMUPLly9XcXGxpNKjppMmTZJhGOrUqZPTuAEAAJqaen/Zpx9//FGvvvqqJMlutysgIECFhYXmdUKl0jsmffDBB06nvUtKShQfH6/4+HhJpavmvb29lZOTowsXLkiSvL299cILL2jQoEEutz148GAdOHBAsbGxWrBggRYtWiR/f38zmPr4+CgmJkYhISEu20dHRystLU2JiYmKjo7WtGnTZLfbzbG3bdtWH374oby86v1uAAAAqDP1OgkFBQXpvffeU1JSknbt2qXjx4/rzJkz8vLyUvv27dWlSxfdc889uv/++8uFultvvVVTpkzRzp07lZqaqjNnzig3N1cBAQEKCQlR79699fDDD6tDhw5uxxAVFaXIyEgtWrRIu3btUk5Ojtq1a6fevXtr3LhxCg0NrbCtj4+PPv74Yy1dulRxcXFKTU1VUVGRQkNDNXDgQI0dO1aBgYG18lkBAAA0VDajssmWqNfKLoxf2QX0m7qdR84qas3eOuk7ZkhXdQ9uUSd9AwDqv7r8P0ZqGv/P1Os5pAAAAGj8CKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABLEUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACW8rJ6AIAk5RYWKyUrr0767tY2sE76BQAAtYNAinohJStPUWv21knfax6PrJN+AQBA7eCUPQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABLEUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUl5WDwAAAKAu5RYWKyUrr0767tY2sE76bWoIpAAAoFFLycpT1Jq9ddL3mscj66TfpoZT9gAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFJeVg+gMnv37lVCQoJ++OEHHTp0SKdOnVJ+fr4CAwMVFham++67TyNGjJDdbq+wj4MHD2r+/PnatGmTsrKy1Lx5c4WHh2v06NG6/fbbKx3Dxo0btWjRIu3evVs5OTlq3bq1+vTpo7Fjxyo0NNRt25KSEi1btkxxcXFKTU1VUVGRgoODdffdd2vcuHFq3rz5JX8mAAAAjUm9D6QrV67UJ598Yj738/OT3W7XyZMntXnzZm3evFmffPKJ5s+fr6CgoHLtv/32W02ZMkWFhYWSpICAAJ06dUrr16/X+vXrNWHCBEVFRVW4/ZiYGMXGxkqSbDab/P39dfToUa1cuVLr1q3Tu+++qwEDBrhsW1hYqPHjxysxMVGSZLfbZbfblZKSopSUFK1evVoLFy5Uhw4dqv35AAAANHT1/pR9eHi4nn/+eS1fvlzbtm3Tzp07lZycrKSkJP3pT3+Sn5+f9u/frxdeeKFc20OHDikqKkqFhYWKjIxUfHy8tm/frqSkJI0ZM0aSFBsbq3Xr1rnc9tq1a80wOmbMGCUlJWn79u2Kj49XZGSkCgsLFRUVpbS0NJft33jjDSUmJsrb21uvv/66kpOTlZycrIULF+rqq69WRkaGnnzySRUXF9fSpwUAANDw1PtAOnToUD3++OMKDw93Or3dokULjR49Wi+99JIk6fvvv1dGRoZT2/fff18FBQUKCgrSnDlzFBISIkkKDAxUdHS0+vfvL0maMWOGLly44NS2uLhYM2bMkCT1799f0dHRCgwMlCSFhIRozpw5CgoKUkFBgWbOnFlu3KmpqVqxYoUkacqUKXrooYfMaQWRkZGaNWuWbDabUlJStGrVqhp/TgAAAA1VvQ+klQkPDzcfHz9+3Hycl5en+Ph4SdKoUaMUEBBQru24ceMkSUePHlVSUpJTWVJSkhlwy+o5CggI0KhRoyRJ8fHxysvLcypfs2aNSkpKnOpdPO7evXtLkuLi4ip9nwAAAI1Vgw+k27dvNx+3b9/e6fWyeaMVLVyKiIgwg+qmTZucysqeBwQEKCIiwmX7fv36SSqdK7pjxw6nss2bN0uSevXqJT8/P7ftk5OTlZ+f77IOAABAY9cgA2lhYaEOHTqkuXPn6i9/+Ysk6YEHHtCVV15p1jlw4ID5uHPnzi778fT0VMeOHcvVd3weGhoqT09Pl+3DwsLMxykpKeZjwzDM9hVt27GspKREBw8erLAeAABAY1bvV9mXKS4uVteuXcu97uHhoaFDh+q1115zer3s9H2LFi3k6+tbYb9lK/MdT/c7Pne1cr+Mr6+vAgMDlZ2dXW66wLlz5ypt36ZNG6ftuXp/vXr1qrC9JOXk5HDpKAAA0KA1mEBqs9nUunVrSdK5c+fMwDdy5EhNmDCh3GnxsnJ3YdSx/OI5oJfSPjs726m94+OKTtdf3PfF2wcAAGgqGkwg9fT01Pfff28+z8rK0urVqxUbG6s1a9Zo+vTpeuCBBywcYd3Ytm2b2/LKjqACAADUdw1yDqkktW7dWmPHjtW8efN0/vx5/fGPf9SePXvM8mbNmkmSCgoK3PZTVu7v7+/0ek3aOz52t1jJse+Ltw8AANBUNNhAWiY8PFw9e/bUhQsXtGzZMvP1srmbZ8+edRsqK5orWtHcUkcFBQXKzs4u197f398MtO7aZ2ZmltseAABAU9PgA6n0f4uDjhw5Yr7muLrdcQW8I8fV7Revhi97npqaqpKSEpftHVfmd+rUyXxss9nM9hVt27HMw8PDXO0PAADQ1DSKQJqeni5JTqvNe/bsKR8fH0nShg0bXLZLTk5Wbm6uJKlv375OZWXPc3NzlZyc7LL9xo0bJUk+Pj7q0aOHU1mfPn0kSVu3bq3wCG1Z+4iICLeLnwAAABqzeh1IL1y4IMMw3NbZvHmzdu/eLUm65ZZbzNf9/f01cOBASdKSJUvM4Olo3rx5kqR27dopMjLSqSwyMlJt27Z1qucoNzdXixcvliQNHDiw3BzQIUOGyMPDQ7m5uVqyZEm59nv27DEvnj906FC37xEAAKAxq9eBNCMjQ0OHDtWSJUuUnp7uFE4zMjI0d+5cTZw4UYZhqEOHDho+fLhT+8mTJ8vX11fHjh3TxIkTzSOpOTk5mj59uhISEiRJUVFR5S5+7+XlpalTp0qSEhISNH36dOXk5EgqPSI7ceJEZWZmytfXV88880y5sYeGhmrkyJGSpBkzZmj58uUqLi6WVHrUdNKkSTIMQ506dSo3bgAAgKak3l/26ccff9Srr74qSbLb7QoICFBhYaF5nVCp9I5JH3zwQbnT3tdcc41iYmI0ZcoUbdmyRXfffbeaN2+uvLw8c17ohAkTNHjwYJfbHjx4sA4cOKDY2FgtWLBAixYtkr+/vxlMfXx8FBMTo5CQEJfto6OjlZaWpsTEREVHR2vatGmy2+3m2Nu2basPP/xQXl71fjcAAADUmXqdhIKCgvTee+8pKSlJu3bt0vHjx3XmzBl5eXmpffv26tKli+655x7df//9FYa6AQMGKC4uTvPmzdPmzZt14sQJtWzZUjfffLNGjx5d4X3uy0RFRSkyMlKLFi3Srl27lJOTo3bt2ql3794aN26cQkNDK2zr4+Ojjz/+WEuXLlVcXJxSU1NVVFSk0NBQDRw4UGPHjlVgYGCNPiMAAICGrl4HUm9vb91///26//77a9RPx44d9eabb1a7fb9+/dSvX79qtfXw8NCoUaM0atSoam8fAACgMavXc0gBAADQ+BFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABLEUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABLEUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYysvqAVQmMzNT33zzjRITE/Xf//5XmZmZ8vDwUFBQkHr27KlHHnlE4eHhLtu+8MIL+uyzzyrdxt69e+XlVfFHsXHjRi1atEi7d+9WTk6OWrdurT59+mjs2LEKDQ1123dJSYmWLVumuLg4paamqqioSMHBwbr77rs1btw4NW/evNLxAQAANGb1OpBmZGSof//+MgzDfK1Zs2YqLi5WWlqa0tLSFBcXpwkTJmjKlCkV9uPj4+M2+NlstgrLYmJiFBsba9bz9/fX0aNHtXLlSq1bt07vvvuuBgwY4LJtYWGhxo8fr8TEREmS3W6X3W5XSkqKUlJStHr1ai1cuFAdOnRw+zkAAAA0ZvU6kF64cEGGYahfv34aOnSo+vTpo9atW+vChQvat2+f3nrrLW3btk0ffvih2rdvrwcffNBlP4MGDdJbb711ydtfu3atGUbHjBmjyZMnKzAwUGlpaXr55ZeVlJSkqKgorV27ViEhIeXav/HGG0pMTJS3t7deeeUVDRs2THa7XUlJSXruueeUkZGhJ598UqtXr3Z7hBYAAKAxq9dzSFu0aKHPPvtM8+fP1+DBg9W6dWtJkqenp7p166aPP/5Y119/vSRp7ty5tbrt4uJizZgxQ5LUv39/RUdHKzAwUJIUEhKiOXPmKCgoSAUFBZo5c2a59qmpqVqxYoUkacqUKXrooYdkt9slSZGRkZo1a5ZsNptSUlK0atWqWh07AABAQ1KvA2nz5s3VpUuXCsu9vb01ZMgQSVJaWprOnj1ba9tOSkpSRkaGJGncuHHlygMCAjRq1ChJUnx8vPLy8pzK16xZo5KSEqd6jsLDw9W7d29JUlxcXK2NGwAAoKGp14G0Knx8fMzHFy5cqLV+N23aJKk0eEZERLis069fP0mlc0V37NjhVLZ582ZJUq9eveTn5+e2fXJysvLz82tl3AAAAA1Ng5+4mJSUJEm66qqr1KpVK5d1Nm/erHvvvVdHjx6V3W5XcHCwevfurdGjR+vaa6912ebAgQOSpNDQUHl6erqsExYWZj5OSUnR7bffLkkyDMNs37lz5wrHXlZWUlKigwcPqmvXruXq9OrVq8L2kpSTk8NKfQAA0KA16COku3bt0jfffCNJGjlyZIWr5Y8dO6b09HT5+fmpoKBA+/fv14IFC/TAAw/o008/ddnm+PHjkqSgoKAKt+/r62vOKy2rL0l5eXk6d+5cpe3btGlTbnsAAABNTYM9QnrmzBlNnTpVJSUlCgkJcTnPs0uXLurWrZvuvPNOXX311fL09FR+fr42bNigd955R2lpaZo2bZquuOIK3XfffU5tywKlr6+v23H4+voqOzvbaQ6p4+OKTtdf3PfFc1DLbNu2ze32KzuCCgAAUN81yCOkBQUFmjRpktLT09WsWTO99957CggIKFfvscce0+jRoxUcHGyedvfz89M999yjZcuWKTg4WJL09ttvO13rFAAAAJdPgwuk58+f16RJk7R161b5+vrqgw8+cDn3sjKtWrXSU089JUk6cuSI9u3b51TerFkzSaXh152ycn9/f/M1x8fuFis59u3YBgAAoClpUKfsz58/r8mTJ2vDhg3y9vbW7Nmz1adPn2r31717d/Nxenq6U7ANCgrSvn373M7tLCgoUHZ2tlm/jL+/v5o1a6Zz5865bZ+Zmem0PQAAmqLcwmKlZLmeulZT3doG1km/qF0NJpAWFRXpmWee0fr1680wWraqvS507txZ3333nVJTU1VSUiIPj/IHk8tW0ktSp06dzMc2m02dO3fWrl27lJKSUuE2yso8PDzUsWPHWhw9AAANR0pWnqLW7K2Tvtc8Hlkn/aJ2NYhT9kVFRXr22WeVkJAgu92uWbNm6Y477qhxvzt37jQft2/f3qmsb9++kqTc3FwlJye7bL9x40ZJpddC7dGjh1NZ2ZHbrVu3Vnjav6x9RESE28VPAAAAjVm9D6TFxcWaOnWqvvnmG9ntds2ePVt33nlnpe0qW6R09uxZ83ajV199dbk7QkVGRqpt27aSpHnz5pVrn5ubq8WLF0uSBg4cWG4O6JAhQ+Th4aHc3FwtWbKkXPs9e/aYF88fOnRope8HAACgsarXgfTChQt67rnn9NVXX11SGJWk1atXa9KkSfrqq6908uRJ8/XCwkJ9++23evjhh5WWliZJev7558udkvfy8tLUqVMlSQkJCZo+fbpycnIklc43nThxojIzM+Xr66tnnnmm3PZDQ0M1cuRISdKMGTO0fPlyFRcXSyo9ajpp0iQZhqFOnTpp+PDhl/bBAAAANCL1eg7pjh079Pnnn5vPX375Zbf1Z82aZZ46LykpUXx8vOLj4yWVrpr39vZWTk6OeYtRb29vvfDCCxo0aJDL/gYPHqwDBw4oNjZWCxYs0KJFi+Tv728GUx8fH8XExCgkJMRl++joaKWlpSkxMVHR0dGaNm2a7Ha7eY3Ttm3b6sMPP5SXV73eDQAAAHWqXiehkpIS83FRUZGysrLc1i8qKjIf33rrrZoyZYp27typ1NRUnTlzRrm5uQoICFBISIh69+6thx9+WB06dHDbZ1RUlCIjI7Vo0SLt2rVLOTk5ateunXr37q1x48YpNDS0wrY+Pj76+OOPtXTpUsXFxSk1NVVFRUUKDQ3VwIEDNXbsWPNOT2i4glu4v3kCAABwr14H0ltvvVU//fRTtdoGBwfrySefrJVx9OvXT/369atWWw8PD40aNUqjRo2qlbGg/vGze9bpJUs6tfZXgE+9/qoCAFAj/C8H1IK6vGRJzJCu6h7cok76BgDUf03hTFy1AumLL74om81mzomsjGEYeumll2Sz2fTmm29WZ5MAAABNUlM4E1etrX/22Wey2Wx65ZVXqhRIS0pKzDYEUgAAgEvT2M/E1evLPgEAAKDxuyyBND8/X5KqdDQVAAAATctlCaSJiYmSpNatW1+OzQEAAKABqdIc0hdffNHl66+++qo8PT0rbFdSUqLjx49r+/btstls5e73DgAAAFQpkJYtSHJkGIbWrl1bpY0YhiFfX1898cQTlz5CAAAANGpVCqTt2rVzen706FHZbDa1bdvWbTu73a5WrVqpW7dueuSRR3TddddVf6QAAABolKoUSBMSEpye33DDDZKkf/3rX/Lz86v9UQEAAKDJqNZ1SIcOHSqbzSYvL270BAAAgJqpVqJ86623anscAAAAaKK4MD4AAAAsVeNz7ufOndN///tfZWVlmRfAd2fo0KE13SQAAAAakWoH0qysLL399tv68ssvVVRUVKU2NpuNQAoAAAAn1Qqkp06d0q9//WsdOXJEhmFUud2l1AUAAEDTUK1AGhsbq8OHD8tms+mRRx7RiBEjFBoaKl9f39oeHwAAABq5agXShIQE2Ww2jR8/XlOmTKntMQEAAKAJqdYq+8zMTEnSyJEja3UwAAAAaHqqFUgDAgIkSS1atKjVwQAAAKDpqVYg7dKliyTp559/rs2xAAAAoAmqViAdM2aMDMPQ0qVLa3s8AAAAaGKqFUjvuOMO/e53v9OqVav0wQcfqKSkpLbHBQAAgCaiWqvsZ8+eLX9/f3Xo0EGzZs3S8uXL1bdvXwUFBcnT09Nt20mTJlVroAAAAGicqh1IbTab+fzYsWNatWpVldoSSAEAAOCo2rcO5a5LAAAAqA3VCqQ//vhjbY8DAAAATVS1FjUBAAAAtYVACgAAAEsRSAEAAGApAikAAAAsVa1FTTfeeGO1Nmaz2bRv375qtQUAAEDjVK1AyiWfAAAAUFuqFUj/3//7f27Li4uLlZmZqf/85z/avXu3rrnmGo0fP14eHswQAAAAgLNqBdJhw4ZVqd6kSZO0YsUK/elPf9KWLVv09ttvV2dzAAAAaMTq/JDlyJEj9cgjj2jt2rX6/PPP63pzAAAAaGAuyzn0ESNGyDAMLV269HJsDgAAAA3IZQmkwcHBkrjlKAAAAMq7LIH0zJkzkqSCgoLLsTkAAAA0IJclkK5YsUKS1LZt28uxOQAAADQg1VplXxWFhYU6ePCgVqxYocWLF8tms2ngwIF1tTkAAAA0UJflTk2GYeiaa67RE088UZ3NAQAAoBGr1il7wzCq/M9ut2vYsGFavHixAgMDa3v8AAAAaODq5E5NNptNPj4+uuqqq9SlSxc1a9asWoMDAABA41end2oCAAAAKsPN5QEAAGApAikAAAAsVePLPmVmZmrFihXaunWrjhw5ory8PPn7+ys4OFi33HKLRo4cqTZt2tSo/2+++UaJiYn673//q8zMTHl4eCgoKEg9e/bUI488ovDwcLd9HDx4UPPnz9emTZuUlZWl5s2bKzw8XKNHj9btt99e6Rg2btyoRYsWaffu3crJyVHr1q3Vp08fjR07VqGhoW7blpSUaNmyZYqLi1NqaqqKiooUHBysu+++W+PGjVPz5s0v6fMAAABobGoUSD/88EPNnj1bFy5ckFS6+l6STp06pcOHD2vLli2aM2eOnn76aU2YMOGS+8/IyFD//v3NfiWpWbNmKi4uVlpamtLS0hQXF6cJEyZoypQpLvv49ttvNWXKFBUWFkqSAgICdOrUKa1fv17r16/XhAkTFBUVVeEYYmJiFBsbK6l0sZa/v7+OHj2qlStXat26dXr33Xc1YMAAl20LCws1fvx4JSYmSpLsdrvsdrtSUlKUkpKi1atXa+HCherQocMlfzYAAACNRbVP2f/lL3/RzJkzVVxcLMMw1L59e911110aPHiw7rrrLrVv316GYai4uFjvvfee3nnnnUvexoULF2QYhvr166e//vWv+v7775WcnKydO3dqxYoV6tWrlwzD0Icffqjly5eXa3/o0CFFRUWpsLBQkZGRio+P1/bt25WUlKQxY8ZIkmJjY7Vu3TqX21+7dq0ZRseMGaOkpCRt375d8fHxioyMVGFhoaKiopSWluay/RtvvKHExER5e3vr9ddfV3JyspKTk7Vw4UJdffXVysjI0JNPPqni4uJL/mwAAAAai2oF0t27d+vjjz+WJIWHh2vZsmWKj4/XBx98oHfeeUcffPCB4uPjtXz5cnXv3l2GYejvf/+7du/efUnbadGihT777DPNnz9fgwcPVuvWrSVJnp6e6tatmz7++GNdf/31kqS5c+eWa//++++roKBAQUFBmjNnjkJCQiRJgYGBio6OVv/+/SVJM2bMMI/ylikuLtaMGTMkSf3791d0dLR5HdWQkBDNmTNHQUFBKigo0MyZM8ttOzU11bxl6pQpU/TQQw/JbrdLkiIjIzVr1izZbDalpKRo1apVl/S5AAAANCbVCqSffPKJJOmmm27SwoULK5zD2a1bNy1YsMAsX7x48SVtp3nz5urSpUuF5d7e3hoyZIgkKS0tTWfPnjXL8vLyFB8fL0kaNWqUAgICyrUfN26cJOno0aNKSkpyKktKSlJGRoZTPUcBAQEaNWqUJCk+Pl55eXlO5WvWrFFJSYlTPUfh4eHq3bu3JCkuLq7C9wgAANDYVSuQbtu2TTabTc8884x8fHzc1vX29tbTTz8twzDKhb7a4Lh9x6Oc27dvN+eNVrRwKSIiwgyqmzZtciorex4QEKCIiAiX7fv16yepdK7ojh07nMo2b94sSerVq5f8/Pzctk9OTlZ+fr7LOgAAAI1dtRY1ZWVlSZK6du1apfpl9cra1aaykHvVVVepVatW5usHDhwwH3fu3NllW09PT3Xs2FG7d+92qu/YPjQ0VJ6eni7bh4WFmY9TUlLM4GsYhtm+om07lpWUlOjgwYMuP89evXpV2F6ScnJyWKkPAAAatGodIS2bC1l2BLIy58+fd2pXW3bt2qVvvvlGkjRy5EjZbDaz7Pjx45JK56H6+vpW2EdQUJBT/Yvbl5W74uvra84rdWyfl5enc+fOVdre8XJYF28fAACgqajWEdLg4GDt379fGzZs0IMPPlhp/Q0bNpjtasuZM2c0depUlZSUKCQkpNw8z7JA6C6MOpZfPAf0UtpnZ2c7tXd8XNHp+ov7vnj7ZbZt2+Z2+5UdQQUAAKjvqnWE9Pbbb5dhGHrvvff0888/u637888/67333pPNZtMvfvGL6myunIKCAk2aNEnp6elq1qyZ3nvvPZeLlgAAAFD/VSuQ/uY3v5Gfn59OnTqlESNG6G9/+5tSU1Od6qSmpmr27NkaMWKETp48KT8/P/3mN7+p8YDPnz+vSZMmaevWrfL19dUHH3zgcu5ls2bNJJWGV3fKyv39/WutveNjd4uVHPu+ePsAAABNRbVO2V911VWaMWOGJk+erLy8PM2ePVuzZ8+Wh4eHfH19VVBQoJKSEkmlC3y8vLw0Y8YM8zqi1XX+/HlNnjxZGzZskLe3t2bPnq0+ffq4rFs2d/Ps2bMqKCio8NR7RXNFg4KCtG/fPrdzOwsKCpSdnV2uvb+/v5o1a6Zz5865bZ+ZmVluvAAAAE1Nte/UdNddd+nTTz9V165dZRiGDMPQhQsXlJeXZ95hyTAM3XTTTVq8eLF5EfrqKioq0jPPPKP169ebYdTdfegdV7enpKS4rFO2uv3i+o7PU1NTzXB9MceV+Z06dTIf22w2s31F23Ys8/DwUMeOHSusBwAA0JjV6F724eHhWrlypf773/9q69atOnLkiPLy8uTv76/g4GDdcsstuvHGG2s8yKKiIj377LNKSEiQ3W7XrFmzdMcdd7ht07NnT/n4+KiwsFAbNmzQTTfdVK5OcnKycnNzJUl9+/Z1Kuvbt68++ugj5ebmKjk5WT179izXfuPGjZJKr4Xao0cPp7I+ffpo165d2rp1a4VHaMvaR0REuF38BAAA0JjVKJCWufHGG2sleLpSXFysqVOn6ptvvpHdbtfs2bN15513VtrO399fAwcO1Lp167RkyRKNGTOm3MKnefPmSZLatWunyMhIp7LIyEi1bdtWGRkZmjdvXrlAmpuba955auDAgeXmgA4ZMkRz585Vbm6ulixZot/+9rdO5Xv27DEvnj906NBK3w8AAEBjVaVT9keOHFFcXJzi4uKUnp5e5c7T09PNdseOHbvkwV24cEHPPfecvvrqq0sKo2UmT54sX19fHTt2TBMnTjTHnpOTo+nTpyshIUGSFBUVVe7i915eXpo6daokKSEhQdOnT1dOTo75viZOnKjMzEz5+vrqmWeeKbft0NBQjRw5UpI0Y8YMLV++XMXFxZKkrVu3atKkSTIMQ506ddLw4cMv7YMBAABoRKp0hPTVV1/V999/rxtvvFGDBg2qcudt2rTRwoULtW/fPt11113629/+dkmD27Fjhz7//HPz+csvv+y2/qxZs5xOnV9zzTWKiYnRlClTtGXLFt19991q3ry58vLyzHmhEyZM0ODBg132N3jwYB04cECxsbFasGCBFi1aJH9/fzOY+vj4KCYmRiEhIS7bR0dHKy0tTYmJiYqOjta0adNkt9vNa5y2bdtWH374oby8auVANQAAQINUaRLav3+/Nm7cKA8PD7355pvy9vaucufe3t6aPn26hg0bpoSEBKWmpio0NLTK7R0XExUVFVV669GioqJyrw0YMEBxcXGaN2+eNm/erBMnTqhly5a6+eabNXr0aLcLo6TSo6eRkZFatGiRdu3apZycHLVr1069e/fWuHHj3L4fHx8fffzxx1q6dKni4uKUmpqqoqIihYaGauDAgRo7dqx5pycAAICmqtJA+q9//UuSdMcdd+iGG2645A3ccMMNuuuuu5SQkKC1a9fq2WefrXLbW2+9VT/99NMlb/NiHTt21Jtvvlnt9v369VO/fv2q1dbDw0OjRo3SqFGjqr19AACAxqzSOaQ7duyQzWbTvffeW+2N3HPPPTIMQ9u3b692HwAAAGicKg2k//vf/yRJ3bp1q/ZGyi65VNYXAAAAUKbSQHr27FlJqtFdlq688kpJMu9qBAAAAJSpNJDa7XZJld/T3Z3CwkJJYjU5AAAAyqk0kLZq1UqSlJGRUe2NlLUt6wsAAAAoU2kgDQsLkyR9//331d5I2S0yL75fPAAAAFBpIL3ttttkGIYWL16s/Pz8S95Afn6+Fi9eLJvNpttuu61agwQAAEDjVWkgHTx4sAICAnTy5Em98MILl7yBF154QSdPnpS/v7+GDBlSrUECAACg8ao0kLZo0ULjx4+XYRj6+uuv9dhjj1Xp8k3/+9//NGbMGH399dey2Wx64okn1KJFi1oZNAAAABqPKi17Hz9+vPbs2aOvv/5aW7du1aBBg9SrVy/deuutCg0NNW9/mZ2drdTUVCUlJWnbtm0yDEOGYWjgwIGaMGFCnb4RAAAANExVvg5TTEyM/vKXv2jhwoWSpG3btmnbtm0V1jcMQ5L06KOP6vnnn6/hMAEAANBYVXrKvoyXl5defvllLV68WP3795enp6d5BPTif56enurfv78WL16s6Oho81qmAAAAwMUu+Ur1ERERmjNnjgoKCrRz506lp6frzJkzkqSWLVuqffv2ioiIkK+vb22PFQAAAI1QtW+d5Ovrq969e6t37961OR4AAAA0MVU+ZQ8AAADUBQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJbysnoAAIC6l1tYrJSsvDrpu1NrfwX48N8JgOrjNwgANAEpWXmKWrO3TvqOGdJV3YNb1EnfAJoGTtkDAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFjKy+oBVCY/P19JSUnat2+f9u7dq3379unIkSOSpEmTJunpp5+usO0LL7ygzz77rNJt7N27V15eFX8UGzdu1KJFi7R7927l5OSodevW6tOnj8aOHavQ0FC3fZeUlGjZsmWKi4tTamqqioqKFBwcrLvvvlvjxo1T8+bNKx0fAABAY1bvA+nu3bs1fvz4GvXh4+PjNvjZbLYKy2JiYhQbG2vW8/f319GjR7Vy5UqtW7dO7777rgYMGOCybWFhocaPH6/ExERJkt1ul91uV0pKilJSUrR69WotXLhQHTp0qMG7AwAAaNjqfSCVpBYtWujGG29Uly5d1LVrV82YMUNHjx6tcvtBgwbprbfeuuTtrl271gyjY8aM0eTJkxUYGKi0tDS9/PLLSkpKUlRUlNauXauQkJBy7d944w0lJibK29tbr7zyioYNGya73a6kpCQ999xzysjI0JNPPqnVq1e7PUILAADQmNX7OaS9evVSUlKS/vnPf+r555/XAw88IB8fnzrfbnFxsWbMmCFJ6t+/v6KjoxUYGChJCgkJ0Zw5cxQUFKSCggLNnDmzXPvU1FStWLFCkjRlyhQ99NBDstvtkqTIyEjNmjVLNptNKSkpWrVqVZ2/HwAAgPqq3gdST09PS7ablJSkjIwMSdK4cePKlQcEBGjUqFGSpPj4eOXl5TmVr1mzRiUlJU71HIWHh6t3796SpLi4uFoePQAAQMNR7wOpVTZt2iSpNHhGRES4rNOvXz9JpXNFd+zY4VS2efNmSaVHeP38/Ny2T05OVn5+fq2MGwAAoKFpEoF08+bNuvfee9WtWzf16NFDgwcP1vTp0/Xzzz9X2ObAgQOSpNDQ0AqP0oaFhZmPU1JSzMeGYZjtO3fuXOE2yspKSkp08ODBKr8fAACAxqRJrKQ5duyYPD09FRAQoNzcXO3fv1/79+/X4sWL9dJLL+mRRx4p1+b48eOSpKCgoAr79fX1VWBgoLKzs836kpSXl6dz585V2r5NmzZO2+vatWu5Or169XL73nJycrh0FAAAaNAadSDt0qWLunXrpjvvvFNXX321PD09lZ+frw0bNuidd95RWlqapk2bpiuuuEL33XefU9uyQOnr6+t2G76+vsrOznaaQ+r4uKLT9Rf3ffEcVAAAgKaiUQfSxx57rNxrfn5+uueee3TLLbdoxIgROnLkiN5++23de++9bq9HapVt27a5La/sCCoAAEB91yTmkLrSqlUrPfXUU5KkI0eOaN++fU7lzZo1kyQVFBS47aes3N/f33zN8bG7xUqOfTu2AQAAaEqabCCVpO7du5uP09PTncrK5n46zg29WEFBgbKzs53qS6XhsizQumufmZlZbnsAAABNTZMOpO6UrYBPTU1VSUmJyzplK+klqVOnTuZjm81mtndcfX+xsjIPDw917NixxmMGAABoiJp0IN25c6f5uH379k5lffv2lSTl5uYqOTnZZfuNGzdKknx8fNSjRw+nsj59+kiStm7dWuFp/7L2ERERbhc/AQAANGaNNpAahuG2/OzZs5o7d64k6eqrr1aXLl2cyiMjI9W2bVtJ0rx588q1z83N1eLFiyVJAwcOLDcHdMiQIfLw8FBubq6WLFlSrv2ePXvMi+cPHTq0am8KAACgEWoQgfTs2bM6deqU+a/sFHp+fr7T644LiFavXq1Jkybpq6++0smTJ83XCwsL9e233+rhhx9WWlqaJOn555+Xh4fzR+Hl5aWpU6dKkhISEjR9+nTl5ORIKp1vOnHiRGVmZsrX11fPPPNMuTGHhoZq5MiRkqQZM2Zo+fLlKi4ullR61HTSpEkyDEOdOnXS8OHDa+ujAgAAaHAaxGWfhg0bpiNHjpR7ff78+Zo/f775fNKkSXr66aclld79KD4+XvHx8ZJKV817e3srJydHFy5ckCR5e3vrhRde0KBBg1xud/DgwTpw4IBiY2O1YMECLVq0SP7+/mYw9fHxUUxMjEJCQly2j46OVlpamhITExUdHa1p06bJbreb1zht27atPvzwQ3l5NYjdAAAAUCcabRK69dZbNWXKFO3cuVOpqak6c+aMcnNzFRAQoJCQEPXu3VsPP/ywOnTo4LafqKgoRUZGatGiRdq1a5dycnLUrl079e7dW+PGjVNoaGiFbX18fPTxxx9r6dKliouLU2pqqoqKihQaGqqBAwdq7NixCgwMrO23DqAByi0sVkpW3dwgo1tbfs8AqN8aRCBNSEi45DbBwcF68skna2X7/fr1U79+/arV1sPDQ6NGjdKoUaNqZSwAGqeUrDxFrdlbJ32veTyyTvoFgNrSIOaQAgAAoPEikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClGsR1SGE9LtoNAADqCoEUVcJFuwEAQF3hlD0AAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABLEUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFjKy+oBVCY/P19JSUnat2+f9u7dq3379unIkSOSpEmTJunpp5+utI+DBw9q/vz52rRpk7KystS8eXOFh4dr9OjRuv322yttv3HjRi1atEi7d+9WTk6OWrdurT59+mjs2LEKDQ1127akpETLli1TXFycUlNTVVRUpODgYN19990aN26cmjdvXrUPAgAAoJGq94F09+7dGj9+fLXbf/vtt5oyZYoKCwslSQEBATp16pTWr1+v9evXa8KECYqKiqqwfUxMjGJjYyVJNptN/v7+Onr0qFauXKl169bp3Xff1YABA1y2LSws1Pjx45WYmChJstvtstvtSklJUUpKilavXq2FCxeqQ4cO1X5/AAAADV2DOGXfokUL9e7dW48//rhmzJihdu3aVandoUOHFBUVpcLCQkVGRio+Pl7bt29XUlKSxowZI0mKjY3VunXrXLZfu3atGUbHjBmjpKQkbd++XfHx8YqMjFRhYaGioqKUlpbmsv0bb7yhxMREeXt76/XXX1dycrKSk5O1cOFCXX311crIyNCTTz6p4uLianwqAAAAjUO9D6S9evVSUlKS/vnPf+r555/XAw88IB8fnyq1ff/991VQUKCgoCDNmTNHISEhkqTAwEBFR0erf//+kqQZM2bowoULTm2Li4s1Y8YMSVL//v0VHR2twMBASVJISIjmzJmjoKAgFRQUaObMmeW2nZqaqhUrVkiSpkyZooceekh2u12SFBkZqVmzZslmsyklJUWrVq2qxicDAADQONT7QOrp6Vmtdnl5eYqPj5ckjRo1SgEBAeXqjBs3TpJ09OhRJSUlOZUlJSUpIyPDqZ6jgIAAjRo1SpIUHx+vvLw8p/I1a9aopKTEqZ6j8PBw9e7dW5IUFxd3ie8OAACg8aj3gbS6tm/fbs4brWjhUkREhBlUN23a5FRW9jwgIEAREREu2/fr109S6VzRHTt2OJVt3rxZUukRXj8/P7ftk5OTlZ+fX+l7AgAAaIwabSA9cOCA+bhz584u63h6eqpjx47l6js+Dw0NrfAobVhYmPk4JSXFfGwYhtm+om07lpWUlOjgwYMV1gMAAGjM6v0q++o6fvy4pNIFUb6+vhXWCwoKcqp/cfuycld8fX0VGBio7Oxsp/Z5eXk6d+5cpe3btGnjtL2uXbuWq9OrV68K20tSTk4Ol44CAAANWqM9QloWCN2FUcfyi+eA1qS94+OKTtdf3PfF2wcAAGgqGu0R0sZi27ZtbssrO4IKAABQ3zXaI6TNmjWTJBUUFLitV1bu7+9fa+0dH7tbrOTY98XbBwAAaCoabSAtm7t59uxZt6GyormiFc0tdVRQUKDs7Oxy7f39/c1A6659ZmZmue0BAAA0NY02kDqubndcAe/IcXX7xavhy56npqaqpKTEZXvHlfmdOnUyH9tsNrN9Rdt2LPPw8DBX+wMAADQ1jTaQ9uzZ07yj04YNG1zWSU5OVm5uriSpb9++TmVlz3Nzc5WcnOyy/caNGyVJPj4+6tGjh1NZnz59JElbt26t8AhtWfuIiAi3i58AAAAas0YbSP39/TVw4EBJ0pIlS8zg6WjevHmSpHbt2ikyMtKpLDIyUm3btnWq5yg3N1eLFy+WJA0cOLDcHNAhQ4bIw8NDubm5WrJkSbn2e/bsMS+eP3To0Et8dwAAAI1HgwikZ8+e1alTp8x/ZafQ8/PznV6/eAHR5MmT5evrq2PHjmnixIlKT0+XVHrtzunTpyshIUGSFBUVVe7i915eXpo6daokKSEhQdOnT1dOTo4kKT09XRMnTlRmZqZ8fX31zDPPlBtzaGioRo4cKUmaMWOGli9fruLiYkmlR00nTZokwzDUqVMnDR8+vLY+KgAAgAanQVz2adiwYTpy5Ei51+fPn6/58+ebzydNmqSnn37afH7NNdcoJiZGU6ZM0ZYtW3T33XerefPmysvLM0PthAkTNHjwYJfbHTx4sA4cOKDY2FgtWLBAixYtkr+/vxlMfXx8FBMTo5CQEJfto6OjlZaWpsTEREVHR2vatGmy2+3mNU7btm2rDz/8UF5eDWI3AAAA1IlGn4QGDBiguLg4zZs3T5s3b9aJEyfUsmVL3XzzzRo9enSF97kvExUVpcjISC1atEi7du1STk6O2rVrp969e2vcuHEKDQ2tsK2Pj48+/vhjLV26VHFxcUpNTVVRUZFCQ0M1cOBAjR07VoGBgbX9lgEAABqUBhFIy06tV1fHjh315ptvVrt9v3791K9fv2q19fDw0KhRozRq1Khqbx8AAKAxaxBzSAEAANB4EUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAoEaCW/haPQQADVyDuJc9AKD+8rN7KrewWClZeXXSf6fW/grw4b8roDHjGw4AqLGUrDxFrdlbJ33HDOmq7sEt6qRvAPUDp+wBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQCgXgtu4Wv1EADUMS+rBwAAgDt+dk/lFhYrJSuvTvrv1NpfAT78dwhYiW8gAKDeS8nKU9SavXXSd8yQruoe3KJO+gZQNZyyBwAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpV9gBQBXV52aFubQPrpF8AaCgIpABQBXV52aE1j0fWSb8A0FBwyh4AAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApRr9dUhXrVqlF198sdJ6H3/8sfr27euy7ODBg5o/f742bdqkrKwsNW/eXOHh4Ro9erRuv/32SvveuHGjFi1apN27dysnJ0etW7dWnz59NHbsWIWGhl7yewIAAGhMGn0gLePh4aErrriiwnJvb2+Xr3/77beaMmWKCgsLJUkBAQE6deqU1q9fr/Xr12vChAmKioqqsN+YmBjFxsZKkmw2m/z9/XX06FGtXLlS69at07vvvqsBAwbU4J0BAAA0bE0mkLZt21YJCQmX1ObQoUOKiopSYWGhIiMjNX36dIWEhCg7O1vvv/++Fi5cqNjYWIWFhemBBx4o137t2rVmGB0zZowmT56swMBApaWl6eWXX1ZSUpKioqK0du1ahYSE1Mr7ROMT3MLX6iEAAFCnmkwgrY73339fBQUFCgoK0pw5cxQQECBJCgwMVHR0tA4fPqz169drxowZuv/+++Xp6Wm2LS4u1owZMyRJ/fv3V3R0tFkWEhKiOXPm6P7779fx48c1c+ZMsy5wMT+7Z53eR71Ta38F+PCrAABgHf4XqkBeXp7i4+MlSaNGjTLDqKNx48Zp/fr1Onr0qJKSktSnTx+zLCkpSRkZGWa9iwUEBGjUqFGaOXOm4uPjlZeXJ39//zp6N2jo6vI+6jFDuqp7cIs66RsAgKpglX0Ftm/fbs4brWjhUkREhBlUN23a5FRW9jwgIEAREREu2/fr10+SVFhYqB07dtTKuAEAABqaJhNIT506peHDhysiIkLh4eEaMGCA/vCHP2jLli0u6x84cMB83LlzZ5d1PD091bFjx3L1HZ+HhoY6ncp3FBYWZj5OSUmp+psBAABoRJrMKfv8/Hzt3btXLVq0UFFRkQ4fPqzDhw9r7dq1Gj58uF5//XV5ef3fx3H8+HFJUosWLeTrW/GikqCgIKf6F7cvK3fF19dXgYGBys7OLte+TK9evdy+r5ycHDVv3txtHQAAgPqs0QfSoKAgTZo0SQMHDlTHjh3l7e2tCxcuaNeuXZo1a5Y2bdqkVatWqVmzZnrllVfMdufOnZMkt2HUsTwvz3nByaW0z87OLtceAACgqWj0gbRfv37mXM0ynp6e6tGjh+bPn69Jkybp22+/1aeffqoxY8bo2muvtWagFdi2bZvb8sqOoAIAANR3TWYOqSseHh56/vnnJUklJSVav369WdasWTNJUkFBgds+ysovXiFf0/YAAABNRZMOpJJ0zTXXqFWrVpKk9PR08/WyuZ9nz551Gyormita0dxSRwUFBcrOznbZHgAAoKlo8oG0Io4r6ytaAV9SUqKDBw+Wq+/4PDU1VSUlJS7bO67M79SpU43GCwAA0FA1+UCalpam06dPS5Lat29vvt6zZ0/5+PhIkjZs2OCybXJysnJzcyVJffv2dSore56bm6vk5GSX7Tdu3ChJ8vHxUY8ePWrwLgAAABquRh1IDcOotPyvf/2rpNL5pHfeeadZ5u/vr4EDB0qSlixZYgZPR/PmzZMktWvXTpGRkU5lkZGRatu2rVM9R7m5uVq8eLEkaeDAgcwhBQAATVajDqRHjhzRyJEjtWTJEqWnp5sBtaSkRLt379b48eP11VdfSZIefvhh8yL3ZSZPnixfX18dO3ZMEydONOeY5uTkaPr06UpISJAkRUVFlbv4vZeXl6ZOnSpJSkhI0PTp05WTkyOpdK7qxIkTlZmZKV9fXz3zzDN19yEAAADUc43+sk8//PCDfvjhB0mSt7e3/P39lZeXp/Pnz5t1hg8frujo6HJtr7nmGsXExGjKlCnasmWL7r77bjVv3lx5eXnmvNAJEyZo8ODBLrc9ePBgHThwQLGxsVqwYIEWLVokf39/M5j6+PgoJiZGISEhtf22AQAAGoxGHUhbt26tV155RcnJyfrxxx916tQpZWdny9vbW+3bt1dERIRGjBihnj17VtjHgAEDFBcXp3nz5mnz5s06ceKEWrZsqZtvvlmjR4+u8D73ZaKiohQZGalFixZp165dysnJUbt27dS7d2+NGzdOoaGhtf22AQAAGpRGHUh9fX316KOP6tFHH61RPx07dtSbb75Z7fauLs4PAACAUo16DikAAADqPwIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsJSX1QMAAAD1W25hsVKy8uqk725tA+ukXzQsBFIAAOBWSlaeotbsrZO+1zweWSf9omHhlD0AAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABLEUgBAABgKQIpAAAALEUgBQAAgKUIpAAAALAUgRQAAACWIpACAADAUgRSAAAAWIpACgAAAEsRSAEAAGApAikAAAAsRSAFAACApQikAAAAsBSBFAAAAJYikAIAAMBSBFIAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUANGnBLXytHgLQ5HlZPYCmICcnR/PmzdM333yjI0eOyG63KzQ0VL/61a/08MMPy8ODvwsAwCp+dk/lFhYrJSuvTvrv1NpfAT78dwu4wzekjqWnp2vMmDHKyMiQJDVr1kz5+flKTk5WcnKyvvzyS82dO1c+Pj4WjxQAmq6UrDxFrdlbJ33HDOmq7sEt6qRvoLHg0FwdKi4u1pNPPqmMjAxdffXVWrhwoRlEX3/9dXl7eysxMVHTp0+3eqgAAACWIZDWoZUrVyolJUU2m02zZs1SZGSkJMlut+uhhx7Ss88+K0lavny5UlNTLRwpAACAdQikdSguLk6S1Lt3b4WHh5crf+SRR+Tv76+SkhKtXbv2Mo8OAACgfiCQ1pH8/Hzt3LlTknT77be7rOPn56devXpJkjZv3ny5hgYAAFCv2AzDMKweRGP0ww8/aOTIkZKkjz76SL/4xS9c1nvnnXc0b948BQQEaPv27eXKywJrRXJyciRJzZs3r+GI3TMklZTUzY+Kp4eN/i3s38PDJlud9Ny4NOR9TP/W9t8YvmMN+fNv6P1fjm1crp/R5s2ba/369S7LWGVfR44fP24+DgoKqrBeWVlubq7y8vLk7+9/yduy2er+x8im0i9ETVUUoGur/4rQv7PL9YdMY1LX+6Ch/Qw1hv4d90Fdj7+hq6vPx3EfNLSfn8vZf11voz78n0AgrSPnzp0zH/v5+VVYz7HMVSDdtm1b7Q/OQmVHfBvb+2po2A/WYx9Yj31gPfZB/VAf9gNzSAEAAGApAmkdadasmfk4Pz+/wnqOZdU5XQ8AANDQEUjriOO8Ucf5pBcrKwsICCCQAgCAJolAWkc6depk3qM+JSWlwnplZZ06dbos4wIAAKhvCKR1xM/PT927d5ckbdiwwWWdgoICcwJxnz59LtfQAAAA6hUCaR0aOnSopNKL3u/Zs6dc+eLFi5WbmysPDw8NHjz4Mo8OAACgfiCQ1qERI0aoU6dOMgxDTz/9tLZu3SpJKi4u1vLlyxUTEyNJevDBBxUaGmrlUAEAACzDnZrqWFpamh577DFlZGRIKl19X1RUpKKiIkml97mfO3eufHx8rBwmAACAZQikl0FOTo7mzZun+Ph4HTlyRHa7XaGhofrVr36lX//61+biJwAAgKaIQAoAAABLcWgOAAAAliKQAgAAwFIEUgAAAFjKy+oBoP7LzMzUN998o8TERP33v/9VZmamPDw8FBQUpJ49e+qRRx5ReHh4uXZbtmzRY489VuXtvPXWWxo2bJjLso0bN2rRokXavXu3cnJy1Lp1a/Xp00djx45tEpfMsnIf3HXXXTpy5Ijbdj169NDixYurvJ2GqLr7oExRUZGWLVumL774QgcOHFBubq78/Px07bXX6q677tKYMWPUvHlzt2Pge2DdPuB7UKqm+6CwsFBLly7V559/rtTUVBUUFCgoKEi33Xabxo4dq2uuuabSMTT174Fk7X6oq+8Ci5rgVkZGhvr37y/HH5NmzZqpuLhY58+flyTZbDZNmDBBU6ZMcWq7Y8cOPf300277z8vLU35+viRp3bp16ty5c7k6MTExio2NNbfl7++v3NxcSZKPj4/effddDRgwoPpvsp6zeh+U/fIJCAiQr6+vyz7Cw8M1Z86cS35vDUVN9oEknT59WmPHjtXevXvN15o3b67c3FyzzzZt2ujjjz+u8D9UvgfW7gO+BzXfBydOnNATTzyh//73v5Iku90uPz8/ZWdnS5J8fX0VExPj9ue4qX8PJOv3Q519FwzAjfT0dCMsLMx4/PHHjTVr1hgnTpwwDMMwiouLjd27dxuPPPKIERYWZoSFhRnLli275P6HDx9uhIWFGQ8++KDL8jVr1pj9v/7668bZs2cNwzCMQ4cOGY8++qgRFhZmhIeHG4cOHar+m6znrN4H/fv3N8LCwoyVK1fW6H00ZDXdB1OnTjXCwsKMm266yfj000+NvLw8wzAMo7Cw0Fi9erXRs2dPIywszBg+fLjL7fM9sH4f8D2o2T4oKSkxHn74YSMsLMy4+eabjZUrVxqFhYWGYRjG4cOHjd///vfmz3FqaqrL7fM9KGX1fqir7wKBFG5lZ2cbe/furbC8sLDQGDx4sBEWFmbcfffdl9T3jz/+aH5pli5dWq68qKjIuOOOO4ywsDBjwoQJ5cpzcnKMfv36GWFhYUZUVNQlbbshsXIfGAb/ERtGzfZBYWGhcdNNNxlhYWHGrFmzXLZfvny5uR8OHz7sVMb3oJSV+8Aw+B4YRs32QUJCgvn5Lly4sFzboqIi49577zXCwsKMSZMmuSzne1DKyv1gGHX3XWBRE9xq3ry5unTpUmG5t7e3hgwZIqn0rlRnz56tct8rVqyQJPn5+WnQoEHlypOSksw7XI0bN65ceUBAgEaNGiVJio+PV15eXpW33ZBYuQ9Qqib74OzZs+ZptK5du7ps361bN/PxuXPnnMr4HpSych+gVE32wXfffSep9NTyr3/963Jtvby8zPnuCQkJOn36tFM534P/Y+V+qEsEUtSY421PL1y4UKU258+f19q1ayVJ9913nwICAsrV2bRpk6TSXzQREREu++nXr5+k0gnaO3bsuKRxNyZ1tQ9QdRXtg9atW6tZs2aS5DR/0dEPP/wgqfRn/eLFBHwPqq6u9gGqrqJ9cPToUUlSSEiIvLxcr6cum7tbXFysLVu2OJXxPbg0dbUf6hKBFDWWlJQkSbrqqqvUqlWrKrVx/MtrxIgRLuscOHBAUumXw9PT02WdsLAw83FKSkqVx9zY1NU+cPT3v/9dt99+u2666SZFRkZq1KhRmjt37iUdkW3MKtoHNptNDz/8sCQpNjZWixcvNo/Alf1R8NZbb0mSnnvuOXl7ezv1y/eg6upqHzjie+BeZb+LSkpKKmzrGJz279/vVMb34NLU1X5wVNvfBQIpamTXrl365ptvJEkjR46UzWarUruyU8XXXnutbrnlFpd1jh8/LkkKCgqqsB9fX18FBgY61W9q6nIfODpw4IDOnj0rPz8/nT17Vjt27NCMGTP0y1/+Utu3b6/+G2gEKtsHU6ZM0ZAhQ3T+/Hm99tprioiI0C233KLw8HD94Q9/UGhoqP72t7+5PIXG96Bq6nIfOOJ7UDF3+yA4OFhS6SnkwsJCl+0dQ+TFP8d8D6quLveDo9r+LhBIUW1nzpzR1KlTVVJSopCQEJfzelw5duyYvv/+e0nuj8yVHcGo6LISZcrKG/OcoYrU9T6QSi/x8d5772nz5s3avXu3tm7dqs2bN+vFF19Us2bNdOLECU2YMEHp6ek1fj8NUVX2gY+Pj6ZPn64pU6aYR3eys7PNy7bk5eUpKyvLZf98DypX1/tA4ntQmcr2wR133CFJKigo0D//+c9y7QsLC/WPf/zDfF52KacyfA+qpq73g1R33wUCKaqloKBAkyZNUnp6upo1a6b33nuvynMQV61apZKSEnl6emro0KF1O9BG7HLtg+joaN1///264oorzNeuuOIK/fa3v9U//vEPeXl5KScnR7NmzarJ22mQqroPUlNT9atf/Urvv/++Ro8erX/961/auXOnvvzySz3zzDNKS0vTq6++qldeecWCd9GwXa59wPegYlXZB3feeaduvvlmSdL777+vjz76SFlZWTp//rx2796tcePG6ciRI7Lb7ZIkDw/iyaW6XPuhrr4L7HFcsvPnz2vSpEnaunWrfH199cEHH1S4cvVihmHos88+kyT94he/cHv6pWwRQkFBgds+y8r9/f2rNIbG4HLtg8rcfPPNuv/++yWVzkk1mtB9Nqq6D7Kzs/Wb3/xGBw8e1MSJE/Xyyy+rU6dO8vPz03XXXaeJEyfqtddekyQtW7ZMmzdvdmrP96Bil2sfVIbvQeX7wGazadasWbr++utVVFSkv/71r7rtttvUrVs3Pfjgg0pKStLo0aPNBWVlp97L8D1w73Lth8rU5LtAIMUlOX/+vCZPnqwNGzbI29tbs2fPVp8+farcfsuWLUpLS5NUOrfFnbKg5G4OS0FBgXl3iZoEq4bkcu6Dqihb8ZqTk3NZLxFipUvZB6tXr9aJEyckSb/97W9d1hk+fLhatmwpSfrqq6+cyvgeuHY590FV8D2o/HdRmzZttGLFCr322mvq16+fOnTooJCQEPXv319z5szRyy+/bN6S8tprr3Vqy/egYpdzP1RFdb8L3MseVVZUVKRnnnlG69evN3/ob7/99kvqY+XKlZKkK6+80pzLUpHOnTvru+++U2pqqkpKSlyeOihbeSlJnTp1uqSxNESXex+gvEvdB2U/o1dccYXbKRXt27fXmTNndPjwYafX+R6Ud7n3Acqr7u8ib29vjRo1yrxmqKPdu3ebtzG++NJOfA9cu9z7oS5xhBRVUlRUpGeffVYJCQmy2+2aNWvWJYeZnJwcff3115KkX/3qV+YclYr07dtXUumk6uTkZJd1Nm7cKKl0wUKPHj0uaTwNjRX7oCp27twpqfT6gFW95FRDVZ19UHYJodOnT5u/5F0puz7gxaca+R44s2IfVAXfg5r/cet45Y/w8HCnMr4H5VmxH6qiut8FAikqVVxcrKlTp+qbb76R3W7X7Nmzdeedd15yP+vWrTPn91TlVHFkZKTatm0rSZo3b1658tzcXC1evFiSNHDgwEY9Z8iqfVDZ/J89e/boiy++kCT179+/ypecaoiquw/K7qhiGIaWLl3qss7XX3+tU6dOSZK6d+/uVMb34P9YtQ/4Hvyf2vpddLFt27aZQeipp54q9xnyPXBm1X6o0+9Crd6IFI1OcXGx8eyzzxphYWFG165djfXr11e7rxEjRhhhYWHGww8/XOU2a9asMe+7+8YbbxjZ2dmGYRhGWlqaMWbMGCMsLMwIDw83Dh06VO1x1XdW7oM///nPxrRp04zExEQjNzfXfP3UqVPGokWLjJ49exphYWFGRESE8fPPP1d7XPVdTfZBbm6ucdtttxlhYWFGt27djNjYWOP06dOGYZTef3vJkiXm53jLLbeYZY74Hli7D/gelKrp76LPPvvMWLZsmXHs2DGjpKTEMAzDOHnypDF//nyje/fubu+fbhh8D8pYuR/q8rtgM4wmtBwQl2zr1q169NFHJUl2u10tWrRwW3/WrFkuT5Xs379fgwcPliS98cYbevDBB6s8hpiYGMXGxkoqvQSFv7+/cnJyJJWemnn33Xc1YMCAKvfX0Fi5D1544QVzRb7NZlNAQIA8PDycrt941VVX6b333lOvXr0u6X01JDXdBzt37tSECRN05swZ87WAgACna/y1aNFCs2fPVmRkpMs++R5Ytw/4HpSq6T6YPn26FixYIKl0GoWPj4/5MyxJgwcP1ptvvun2TllN/XsgWbsf6vK7wKImuOV4e7GioiK3F44uq+NK2SmAZs2aadCgQZc0hqioKEVGRmrRokXatWuXcnJy1K5dO/Xu3Vvjxo0z77vbWFm5D37961+rdevW2rVrlw4fPqwzZ86ooKBAV1xxhcLCwnTnnXdqxIgRat68eRXfTcNU033QvXt3ffHFF/r000/173//Wz///LPy8vLM+6bffvvtGj16tNuVwXwPrNsHfA9K1XQfDBo0SAUFBdq5c6eOHTumgoICtWvXTj169NDIkSOrdLWQpv49kKzdD3X5XeAIKQAAACzFoiYAAABYikAKAAAASxFIAQAAYCkCKQAAACxFIAUAAIClCKQAAACwFIEUAAAAliKQAgAAwFIEUgAAAFiKQAoAAABL/X+V7ErpGT+O4gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(\n",
    "    context=\"talk\",\n",
    "    font_scale=1.5,  # make the font larger; default is pretty small\n",
    "    style=\"ticks\",  # make the background white with black lines\n",
    "    palette=\"colorblind\",  # a color palette that is colorblind friendly!\n",
    ")\n",
    "fig, ax = plt.subplots(figsize=(10, 10), tight_layout=True)\n",
    "sns.histplot(ax=ax, x=length_list)\n",
    "plt.suptitle(f\"final lengths of chip order\")\n",
    "sns.despine()\n",
    "plt.savefig(f\"figs/05_final_lengths_in_order.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unused blocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "import pyrosetta\n",
    "from pyrosetta.distributed import cluster\n",
    "import pyrosetta.distributed.io as io\n",
    "\n",
    "flags = \"\"\"\n",
    "-out:level 300\n",
    "-precompute_ig true\n",
    "-detect_disulf false\n",
    "-corrections::beta_nov16 true\n",
    "-holes:dalphaball /home/bcov/ppi/tutorial_build/main/source/external/DAlpahBall/DAlphaBall.gcc\n",
    "-indexed_structure_store:fragment_store /net/databases/VALL_clustered/connect_chains/ss_grouped_vall_helix_shortLoop.h5\n",
    "\"\"\"\n",
    "# pyrosetta.distributed.init(\" \".join(flags.replace(\"\\n\\t\", \" \").split()))\n",
    "pyrosetta.init(\" \".join(flags.replace(\"\\n\\t\", \" \").split()))\n",
    "\n",
    "t = finalize_design(\n",
    "    None,\n",
    "    **{\n",
    "        \"-s\": \"/mnt/home/pleung/projects/peptide_binders/r0/peptide_binders/03_detail_0/0081/47f6c6fcb6d1e9c788e002cfeb798d0bfbc3f514e73931c8.pdb.bz2\",\n",
    "#         \"-s\": \"/mnt/home/pleung/projects/peptide_binders/r0/peptide_binders/03_detail_0/0018/8aeb40fd33d90cbae3429aac01b14b7f45a054268e56fea7.pdb.bz2\",\n",
    "    }\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "crispy (3.8.12)",
   "language": "python",
   "name": "crispy"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}