combinatorics-integrated.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a5e3575f",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#yay imports\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from scipy.special import comb\n",
    "import matplotlib.pyplot as plt\n",
    "from textwrap import wrap\n",
    "from IPython.display import HTML\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "802b76aa",
   "metadata": {
    "code_folding": [
     1,
     48
    ],
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# functs to make stuff look pretty\n",
    "def wrap_t(text, l, linker = \"\\n\"):\n",
    "    '''wrapper for breaking long text strings'''\n",
    "    return linker.join(wrap(text, l))\n",
    "\n",
    "def plot_params(ax, title,\n",
    "                x_title=None, \n",
    "                y_title=None,\n",
    "                varied_by = None,\n",
    "                threshold=None,\n",
    "                x_len=50,\n",
    "                y_len=50,\n",
    "                title_len=50,\n",
    "                scale='log'):\n",
    "    '''mini-helper for cleaner axes formatting'''\n",
    "    \n",
    "    title = wrap_t(title, title_len) #shorten titles\n",
    "    \n",
    "    # conditional wrapping/naming/marking\n",
    "    if scale:\n",
    "        ax.set_yscale(scale) # reset scale\n",
    "    if x_title:\n",
    "        x_label = wrap_t(x_title, x_len)\n",
    "        ax.set_xlabel(x_label)\n",
    "    if y_title:\n",
    "        y_label = wrap_t(y_title, y_len)\n",
    "        ax.set_ylabel(y_label)\n",
    "    if threshold:\n",
    "        for line in threshold:\n",
    "            ax.axhline(line)\n",
    "#         title = f\"{title} \\n Blue line marks {threshold:.2} thresholds\"\n",
    "    if varied_by:\n",
    "         plt.legend(bbox_to_anchor=(1.02, 1), loc='upper left', borderaxespad=0, title = varied_by)\n",
    "\n",
    "        \n",
    "    title = wrap_t(title, title_len) #shorten titles\n",
    "    ax = ax.set_title(title)\n",
    "#     legend_title = plt.\n",
    "    \n",
    "#     legend = plt.legend(handles=[one, two, three], title=\"title\",\n",
    "#                     loc=4, fontsize='small', fancybox=True)\n",
    "    \n",
    "#     plt.legend(bbox_to_anchor=(1.02, 1), loc='upper left', borderaxespad=0, title = \"\")\n",
    "    \n",
    "    \n",
    "#     legend = plt.legend(handles=[one, two, three], title=\"title\",\n",
    "#                     loc=4, fontsize='small', fancybox=True)\n",
    "    return ax\n",
    "\n",
    "def hide_toggle(for_next=False):\n",
    "    '''this is for hide/show cells in slide mode'''\n",
    "    this_cell = \"\"\"$('div.cell.code_cell.rendered.selected')\"\"\"\n",
    "    next_cell = this_cell + '.next()'\n",
    "\n",
    "    toggle_text = 'Toggle show/hide'  # text shown on toggle link\n",
    "    target_cell = this_cell  # target cell to control with toggle\n",
    "    js_hide_current = ''  # bit of JS to permanently hide code in current cell (only when toggling next cell)\n",
    "\n",
    "    if for_next:\n",
    "        target_cell = next_cell\n",
    "        toggle_text += ' next cell'\n",
    "        js_hide_current = this_cell + '.find(\"div.input\").hide();'\n",
    "\n",
    "    js_f_name = 'code_toggle_{}'.format(str(random.randint(1,2**64)))\n",
    "\n",
    "    html = \"\"\"\n",
    "        <script>\n",
    "            function {f_name}() {{\n",
    "                {cell_selector}.find('div.input').toggle();\n",
    "            }}\n",
    "\n",
    "            {js_hide_current}\n",
    "        </script>\n",
    "\n",
    "        <a href=\"javascript:{f_name}()\">{toggle_text}</a>\n",
    "    \"\"\".format(\n",
    "        f_name=js_f_name,\n",
    "        cell_selector=target_cell,\n",
    "        js_hide_current=js_hide_current, \n",
    "        toggle_text=toggle_text\n",
    "    )\n",
    "\n",
    "    return HTML(html) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6d8e569e",
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# notebook wide\n",
    "sns.set_context(\"talk\", font_scale=.75)\n",
    "sns.set_style(\"darkgrid\")\n",
    "threshold_y2 = 1e6 #setting general threshold for OKR # barcodes\n",
    "threshold_e11 = 1e11"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d0043ef",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# $n$ choose $k$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "074ad365",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* $n$, the total number of elements in a set -- here, the number of available epitopes (=bits)\n",
    "* $k$, the length of the set chosen from n -- here, the bits expressed per cell\n",
    "\n",
    "$$\n",
    "{n \\choose k} = \\frac{n!}{k! (n-k)!}\n",
    "$$\n",
    "\n",
    "Mathematically, maximum ${n \\choose k}$ is when $k = \\frac{n}{2}$. \n",
    "\n",
    "This is also the easiest *imaging* parameter readout -- if a voxel(/cell) has only 5 bits, throw it out. If it has more than 7 bits, also throw it out."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40f39308",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# epitope hungry vs epitope conservative\n",
    "\n",
    "\n",
    "*Hungry*: In one model of the integrated shifter, each location always expresses 1 of 3 proteins (at equal proportions, biology to be solved). This is computationally much easier, but requires many more rounds of staining.\n",
    "\n",
    "*Conservative*:In the other, we have a variable number expressed -- each location has single epitope with some % chance of expression. This replicates the math of the analog barcoding system, but at what % do they need to be on/off in order to average $k = \\frac{n}{2}$?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f10c1fab",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## easier case: epitope hungry\n",
    "\n",
    "1. At each site, there are $c$ (cassette length) bits encoded and 1 expressed.\n",
    "    e.g. if there are 3 cassettes of 3 or 4 each then\n",
    "    * total epitopes are: $3*3 = 9 \\text{ or }  4*4 = 12$\n",
    "    * and barcode diversity is: ${3^{3}= 27} \\text{ or } 4^{3} = 64$\n",
    "2. Total epitope requirement $= \\text{num sites} * 3$\n",
    "3. Total diversity is (assuming equal probability) is $c^n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8c8a28d4",
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def integrated_hungry(n = range(1,20,3), sites = range(1,5), model = \"epitope_hungry\"):\n",
    "    dfs = []\n",
    "    if model == \"epitope_hungry\":\n",
    "        for epitopes in n:\n",
    "            df = pd.DataFrame(data = {'sites':sites})\n",
    "            df['epitopes'] = epitopes\n",
    "            df['epitopes_per_site'] = df['epitopes']/df['sites']\n",
    "            \n",
    "            df['bcs'] = df['epitopes_per_site'] ** df['sites']\n",
    "            dfs.append(df)\n",
    "        df = pd.concat(dfs)\n",
    "        df_evens = df[df['epitopes_per_site'].mod(2) == 0] #evens\n",
    "        df_odds = df[(df['epitopes_per_site']-1).mod(2) == 0] #odds\n",
    "        df = df_evens.append(df_odds).reset_index()\n",
    "        df = df.drop('index', inplace=False, axis=1)\n",
    "        return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a4269417",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "n = 100\n",
    "c = 22\n",
    "df = integrated_hungry(n=range(20,n), sites = range (1, c, 3)) ## this removes any fractional epitope signals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "42deecaf",
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <script>\n",
       "            function code_toggle_13345347366253662609() {\n",
       "                $('div.cell.code_cell.rendered.selected').find('div.input').toggle();\n",
       "            }\n",
       "\n",
       "            \n",
       "        </script>\n",
       "\n",
       "        <a href=\"javascript:code_toggle_13345347366253662609()\">Toggle show/hide</a>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAFDCAYAAAAH9GVIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAACPHElEQVR4nOzdd3hUVfrA8e/UTHrvCSGhhU5CCL0IUkQFRERYO2JdYUF317Iquq4LiL8FRURFLNgFFRDESu9FeieEkN7bJJl+f39MGDKkkECSmYTzeZ48M3Pre+9M5r5zzrnnyCRJkhAEQRAEQXAAuaMDEARBEAThxiUSEUEQBEEQHEYkIoIgCIIgOIxIRARBEARBcBiRiAiCIAiC4DAiEREEQRAEwWFEIiLUKjU11dEhtDpms5mMjAyH7DsnJwe9Xu+QfQuCINRGJCKtyPDhw+nevTtxcXHV/srLy6+6/ssvv8zrr78OwMaNG3nssceaOuRqFi9ezMMPP9zs+70e7733Hn/961/rtezs2bNZt25dE0dUXV5eHqNHj6akpOSa1n/uued4+eWXa5x333338cEHHwAwffp0Pv7442uOszV49dVXiYuLY9CgQZhMJkeHIwhOT+noAITGNW/ePG699dZrWvff//637XlRUREWi6WxwmrVHn/88XovW1hY2ISR1E6n09UrGb1eH374YZPvw9l9/fXXvPPOO4wYMcLRoQhCiyBKRG4gaWlpdOnShU8++YT+/fuTmJjIvHnzMBqNwOVfvfv372fOnDlcuHCBuLg4DAYDhYWF/Otf/2LAgAEMGDCAp59+mpycHAD27NnDyJEjeeONN0hISGDQoEG8//77tv0aDAYWLFjAsGHD6N+/P88880ydF2StVss///lP+vXrx6BBg/jyyy9t8zp16sShQ4dsr6uWoHz//ffcf//9vPzyy/Tp04fBgwezaNEi27Lnz5/nnnvuIT4+nkmTJjF//nzuu+8+23YeeeQRxo0bR9++fXnnnXeYOHGiXVwvvviircSoqqoxLF68mKeffpq//e1vxMfHM3z4cL744gsA27l9++23ee655wA4dOgQU6ZMISEhgVtvvZWff/7Ztt3c3Fwee+wx4uPjue2223jnnXcYPny47Vjvvvtu7r33XhITE9m1axdnz57lkUceYciQIXTv3p0777yTI0eOAHDbbbcBMHLkSHbu3InFYmHZsmWMHDmSxMREHnvsMdLT02373rdvHxMmTKBXr15Mnz693glU1dKR++67j4ULFzJ58mTi4uKYMGEC+/fvr9d26qNTp058/vnn3HzzzfTu3Ztp06bZPpM1laxV/ewMHz6cTz75hLFjx9KzZ08eeeQRjhw5Yov1L3/5i21bV6rtf6G8vJy4uDgsFgtPP/008+bNa7RjFYTWTCQiNxiz2cy2bdv4+eef+e6779i0aZNd0gCQkJDAq6++Stu2bTl48CBqtZqZM2eSm5vL+vXr+fXXX1EoFDz55JOYzWYALl68SGFhIdu2beODDz7g448/ZvXq1QAsWLCA/fv388033/DHH3+g0Wh45plnao3xyJEjDBo0iF27dvH000/z2muvUVBQUK/j27NnDzExMezatYvXX3+d9957j5MnT2IymXjiiSfo2rUru3fv5uWXX+b777+3W3fnzp289tpr/P7770yaNImTJ0+SnJwMWJOpX375hQkTJlw1hg0bNjB27Fj27t3L448/zty5c8nPz+ff//43CQkJzJw5k3nz5pGVlcW0adOYPHkyu3fv5rXXXmPOnDkcOHAAgGeeeQaNRsO2bdtYvHix7XxecujQIe6//342b95s226vXr3YtGkTe/bsITIykoULFwLYqoN+++03BgwYwIoVK1i5ciXvv/8+27dvp1u3bjzyyCOYTCYKCgp4/PHHmTRpEvv37+fee+9l27Zt9Tr/V/ruu+94/fXX2bVrF507d+a11167pu3U5tdff+Xbb7/lt99+Izc3l2XLltV73R9++IEVK1awceNGjh07xsyZM5k/fz7btm2jrKyMzz77rMb1avtfcHFx4eDBgwB8+umntmRTEIS6iUSklfnXv/5FQkKC3d+VF/0XXngBb29vIiMjefjhh/nxxx/r3GZqaip79+7lpZdewtfXFw8PD1555RVOnDjBqVOnAFAqlfzrX//C1dWVLl26cPfdd/Pjjz8iSRIrV67kmWeeITg4GDc3N55//nl27dpFSkpKjfvr1q0b48aNQyaTcdttt2GxWOx+rdfFy8uLBx98EKVSyZAhQwgMDCQ5OZlDhw6RlZXF3//+d9RqNT169OCuu+6yWzcmJoaePXvi6elJSEgI/fr1s13AN23aRHBwMF27dr1qDJ06dWL06NEolUruuOMOjEZjjfGvXbuWrl27MnHiRJRKJfHx8UycOJGvvvqKrKws9uzZw3PPPYe7uzvR0dHVfuG7ubkxatQo3NzcUKlUfPDBBzz66KOYTCYyMzPx8fEhOzu7xhi/+eYbnnjiCWJiYlCr1Tz11FMUFhayd+9eNm3ahL+/P/feey9KpZJhw4YxdOjQep3/K40dO5YOHTqg0Wi47bbbuHDhwjVtpzb3338/fn5++Pn5MXz48AZtf9KkSQQEBODv709sbCwjR44kOjoaDw8P+vTpU2Oj4vr8LwiC0DCijUgr8/rrr1+1jUhUVJTteUhICHl5eXUun5eXh0wmIzw83DbN3d0dX19fMjMz8fT0xN/fHw8PD7vtbtq0iYKCAioqKnjiiSeQyWS2+SqVirS0NLtYLvHy8rI9V6vVALaSl6vx9/e3e61SqZAkiezsbPz9/W3bAwgPD+fw4cO210FBQXbrTpgwgXfffZcZM2awZs0axo8f3+AYVCoVQI3tbTIyMjh48CAJCQm2aWazma5du5KVlYVcLickJMQu3qqujPf48eM88cQTFBQU0K5dO9Rqda3tfDIyMvj3v/9tV9V0KWHKz88nODjYbvmIiIhruuMmICDA9lypVNYaT1xcnO357bffDmCXIF8qabjW7dfE19fX9lwul9t97mQyWY3butr/Qn0SVUEQ7IlE5AaUnZ1t+yJNT08nLCyszuXDwsKQJIn09HQiIyMBazuOgoICAgIC0Ov1FBYWYjAYbBf6S9v19fVFrVbzxRdfEBsbC4AkSSQlJdGmTZsGxy6Xy21tWqD+jT9DQkLIz8+3izErK6vOdUaNGsWrr77K/v372bFjB3PmzGlwvHUJDg5m6NChLFmyxDYtOzsbhUKB2WzGYrGQlZVFaGhojfFWTeyys7N5+umnWb58Of379wfg448/5ptvvql13//85z+5+eabbdOSkpIIDw9nw4YN1UpwsrOz8fHxua7jrUtNiUbVxtMNdeXnpKaqvarnr76u9r8gCELDiaqZG9Cbb75JeXk5Fy5c4KOPPuLOO++stoxaraa8vByz2UxwcDCDBg3iP//5D4WFhWi1Wl599VWio6Pp0aMHYG1D8b///Q+DwcDRo0dZuXIlkyZNQi6Xc8cdd7BgwQLy8vIwmUy8++67TJ06FZ1O1+DYo6OjWbt2LXq9npMnT/LLL7/Ua724uDjCw8NZtGgRBoOBU6dO8e2339a5jqurK6NHj+b1118nISGhWinBtVCr1ZSWlgLWBqS7du3it99+w2KxkJKSwj333MPXX39tO+eX3qvU1FQ++uijWrer1Woxm824uroC1nY2K1assF2MLyVfl/Z955138u6775KamookSXz//feMHz+e7OxsbrrpJsrLy1m2bBlGo5EdO3awcePG6z725hQdHc3Ro0c5deoUBoOBd99995oSjyvV539BEISGEYlIK/Pcc8/V2I/Izp07bcuEhIQwevRo7rnnHsaPH8/9999fbTt9+vTBw8ODhIQEsrOzWbBgAX5+ftx2220MGzYMnU7H8uXLkcutH6FLVRBDhgzhb3/7G3/7299sv7aff/552rdvz6RJk+jbty/bt29n+fLldkXh9fXyyy9z9OhR+vXrx2uvvcakSZPqtZ5cLuett97iwIED9O3bl5dffpkBAwbY4q7NhAkTOHHiRL2rZa5m3LhxfPHFF/z1r38lMjKS999/nw8//JDExETuueceRo8ezRNPPAHAf//7X4qKihgwYABPPvkkffv2rTXedu3aMXv2bJ588kkSEhJ4+eWXmTp1KtnZ2ZSUlBAYGMjw4cO544472LBhAw8//DAjR47koYceIj4+nhUrVrBkyRKioqLw8fHhww8/5Ndff6VPnz4sXrzYruSkJRg5ciS33norDz74IMOHDycwMPCqJX/1dbX/BUEQGkYmSZLk6CCE5pGWlsaIESPYvn07gYGBjbbdPXv2MH36dI4ePdpo22xsFRUVHDlyhL59+9qmzZ8/n5ycHP7v//6v1vVSU1MZP348O3bssJU2NJedO3eSkJBgK834/PPPWbduHV9//XWzxiEIgtCURAov3BCUSiVPPvkkP/30E2BtD/Hjjz8yePDgGpfX6/WcPXuWRYsWMWHChGZPQgD+85//sGLFCiwWC9nZ2XzzzTcMGjSo2eMQBEFoSiIREW4IKpWKd955h2XLlhEXF8f06dO5//77a61yKS8v5+677yYlJYWnnnqqmaO1+r//+z82btxInz59mDhxIoMGDeLRRx91SCyCIAhNRVTNCIIgCILgMKJERBAEQRAEhxGJiCAIgiAIDiMSEUEQBEEQHEYkIsJ10+v1tY5UKlwmzlPjuRHO5Y1wjIIAIhFptdLS0ujUqRO5ubk1zs/IyCAuLo78/Pzr3tfUqVPZt29fo26zNbp0nq7Fc889x8svv1zjvPfee4+EhAQSExNrHeSupbvys3U959KZVP0/ba3HKAhXIxKRG1RYWBgHDx6sNkjctSgqKmr0bbZGl85TY1u1ahUzZ85k7969jdINfUOcPHmSzp07s3XrViZPnkyPHj2YMmVKoydEV362mupcOtKNcIyCUBORiDjI4cOHmTJlCnFxcQwfPpwvv/wSgNOnT/Pwww/Tp08fhg8fzsKFCzEYDID111P37t359ttvGTx4MPHx8bz55pv89ttvjBw5kri4OJ599lm7UUO/+eYbhg8fzuDBg3nzzTdtY49U/SV2abuff/45Q4cOpU+fPsycOZOysjIAfv/9dyZPnkzfvn2Ji4vj8ccftw02N336dDIyMnjuued49tln7Uph6nMste1z4cKFDB48mL59+3LPPffYjZJ7pY0bN3LLLbeQkJDAjBkzeOqpp1i8eDFg7bjs4YcfJjExkVGjRvHFF1/Y1rtaDPVZ95VXXiEhIYGlS5fW+zy9/fbbV93+vn37mDBhAr169WL69Om1Du43fPhw0tLSWLBgATNnzqwxrrrei2v5TFV1+vRplEoln332GS+88AIrV66ksLCQzz77rMblr3ZOu3TpwieffEL//v1JTExk3rx5GI1Gu89rTefyap+12rZ7tZig/p/F2pa72v6rHn9dxygIrZYkNLuCggIpISFBWr58uWQwGKTjx49LcXFx0p49e6TExETprbfeknQ6nXTx4kVp/Pjx0ty5cyVJkqTU1FSpY8eO0rPPPivpdDpp9+7dUseOHaVp06ZJJSUl0rlz56SePXtKW7dutS376KOPSiUlJdLFixelUaNGSe+//77dtnJycmzPZ8+eLWm1WunixYvSoEGDpI8//ljKyMiQunfvLu3cuVOSJEnKysqSRo8eLb377ru247npppukdevW2W2zoKCgXsdS0z537twpDRs2TMrPz5fMZrO0cOFC6c4776zxXF64cEHq1q2btH79esloNEqrVq2SOnbsKL399tuSVquVhgwZIi1ZskQyGAzS2bNnpREjRkhr1669agz1Xff111+XDAZDg86TJEl1bj8/P1+Kj4+XPvvsM8loNEqbNm2SOnfuLL300ks1noOq270yrtLS0jrfi4Z8pmoyb948aciQIZJWq7VN+9e//iW98MIL1Zat7zmdNm2aVFRUZPvMLl682O6zdeUx1/ezVtN2rxZTfT+LdS1X3+Oq6xgFoTUTJSIOsHnzZry9vZk2bRoqlYouXbrw5ZdfcuzYMdzd3ZkxYwYuLi5ERkYye/ZsVq5cabf+Qw89hIuLi20QtKlTp+Lp6Um7du2IjIwkIyPDtuyzzz6Lp6cnkZGRPPzww/z444+1xvXoo4/i7u5OZGQkiYmJXLhwAX9/f9avX0///v0pLS0lJycHX1/fqxa9//HHH/U6lpr26eHhQUFBAd9++y1nz55l5syZrFq1qsb9rF+/nvj4eMaOHYtSqeTOO++kZ8+eAGzZssXWtbtKpaJ9+/Y8+OCDttKnumKo77rjxo1DpVI1+DzVtf1Nmzbh7+/Pvffei1KpZNiwYQwdOrTO832lS3F5eHjU671oyGeqqtOnTzNmzBjc3d1t01JTU2nTpk2DjrmqF154AW9v73p9ZqH+n7Watnu1mOr7WazPcg09LkG4USgdHcCNKDc3l9DQULtpsbGxbNmyhfDwcLvhyiMiItBqtZSUlNim+fr62p7LZDI8PT1tr+VyuV0xekREhO15SEhIna3wq7btUKlUWCwWVCoVa9as4dtvv0WpVNKxY0e0Wm2tRfWX5Ofn1+tYatpn9+7dWbBgAZ9//jnvvvsuPj4+PPnkk0yZMqXafrKysqqNqhoeHg5Aeno6WVlZJCQk2OZZLBZ8fHyuetz1XTcoKMi2XkPOU13bz83NrdbWIyIiAr1eX+O2anIpLqj7vSgtLQUa9pmq6vTp09VGQD59+jTTpk2rtmx9z2lUVJTteUhICHl5eXUdar0/azVt92ox1fezWJ/lGnpcgnCjEImIAwQHB1f7pbxq1SpCQ0NJT09HkiTbl2pqaioajQYPDw/bl2rVL9yrycnJsSUj6enpDR4KfcOGDaxcuZKvv/7atu7jjz9+1fXCwsLqdSw1ycjIIDw8nBUrVqDT6fj555959tln6d+/v92XOUBoaCi7d++2m5aZmUlMTAzBwcF06NCB1atX2+YVFBTU64Je33UvHVtDz1Nd29+9ezfp6el2y2dnZ1e7YNel6mfkau/FlcvXV0FBAXl5ecTGxtrFWVhYSKdOnaotX99zmp2dbZdMXu0zW9/PWk3bvVpM9f0s1rWcQqG4puMShBuFqJpxgGHDhlFSUsLnn3+OyWTi5MmTLFiwgJCQEPR6PYsXL8ZgMJCamsqiRYsYP348cvm1vVVvvvkmWq2W5ORkli9fzuTJkxu0fnFxMQqFAhcXF8xmM+vWrWP79u12De1UKpXtl3XVY7zWYzl8+DCPPvooSUlJaDQafH19UalUdsX/l4wbN46DBw/y22+/YTabWb9+PQcPHrTFkJubyxdffIHRaCQ3N5fHHnusXo3/GrpuQ89TXdu/6aabKC8vZ9myZRiNRnbs2MHGjRuvGnNdx1Lbe3EtCcglp06dws3NjbZt29pN8/HxISQkpMY46nNO33zzTcrLy7lw4QIfffQRd955Z7VtXXku6/NZq2m7V4upvp/F+ixXn+Oq7RgFoTUTJSIO4O3tzYcffsjcuXNZtGgRvr6+PP/88yQmJrJ8+XLmz5/PwIEDUavVjBs3jlmzZl3zvmJjYxkxYgQajYapU6dy9913N2j9iRMnsnfvXkaNGmVrzzJlyhQOHTpkW+bOO+9k3rx59O/f3zbN09Pzmo/llltuISkpiYceeoiSkhLCwsJYtGgRAQEB1ZYNDw/nzTffZP78+Tz//PMMHDiQ7t27o1Kp8PLy4qOPPmLevHm8/fbbyOVyRowYwQsvvHDVGBq6bkPO07lz53jxxRdr3b6bmxsffvghr776KkuWLCE2Npabb775qjHXpq73orZ+ZurjzJkzdOzY0e5if+rUKTp27Fjj8vU9pyEhIYwePRqLxcLUqVO5//77q7VRufJc1uezVtN25XJ5nTHV97NY13JpaWn1Pq66jlEQWisx+q7QomVkZFBaWmpXFTBx4kTuvvvuBiddgmOlpaUxYsQItm/fTmBgoNNvt6XsXxCcnaiaEVq03Nxc7r33Xs6fP48kSfz++++cPXvWrnRGEARBcF6iakZo0Xr27MnMmTNtnX5FRkby1ltv1Xj7qCAIguB8RNWMIAiCIAgOI6pmBEEQBEFwGJGICIIgCILgMCIREQRBEATBYUQiIgiCIAiCw4hERLjh6fX6OsfgaY2uPOYb8RwIguAcRCIitEoZGRnExcWRn59/1WWnTp3Kvn37miEq53HlMd+I50AQBOcgEhGhVQoLC+PgwYN2I+vWpqio6Lr2lZWVxTPPPENiYiK9evViypQp1QY1dDZXHvP1ngNBEIRrJRIRoVVKS0ujU6dOHDp0iO7du/P5558zdOhQ+vTpw8yZMykrKwNg+vTpZGRk8Nxzz9kGOjt9+jQPP/wwffr0Yfjw4SxcuBCDwVDjfpKTkxk3bhzu7u58/PHHrFq1imHDhtlGta3q8OHDTJkyhbi4OIYPH86XX35pm/f7778zefJk+vbtS1xcHI8//jiFhYUALFy4kMGDB9O3b1/uueceDh8+bFuvrnlJSUk8/PDDJCYmMmrUKL744osaj7mmc1DbulfbpyAIQoNJgtAKpaamSh07dpQOHjwodezYUZo9e7ak1WqlixcvSoMGDZI+/vhj27I33XSTtG7dOkmSJKmgoEBKTEyU3nrrLUmn00kXL16Uxo8fL82dO7fG/dx7773SjBkzrhpPQUGBlJCQIC1fvlwyGAzS8ePHpbi4OGnv3r1SRkaG1L17d2nnzp2SJElSVlaWNHr0aOndd9+Vdu7cKQ0bNkzKz8+XzGaztHDhQunOO++UJEmqc55Wq5WGDBkiLVmyRDIYDNLZs2elESNGSGvXrq12zFe+rmvduvYpCIJwLUSJiHBDePTRR3F3dycyMpLExEQuXLhQ43J//PEH7u7uzJgxAxcXFyIjI5k9ezYrV66stmxKSgp79+7lH//4x1X3v3nzZry9vZk2bZptdN4vv/yS9u3b4+/vz/r16+nfvz+lpaXk5OTg6+tLdnY2Hh4eFBQU8O2333L27FlmzpzJqlWrAOqct2XLFpRKJU8++SQqlYr27dvz4IMP2pXC1KaudevapyAIwrUQY80IN4SqbUVUKhUWi6XG5fLz8wkPD0cmk9mmRUREoNVqKSkpwcvLyzb91KlT+Pv7ExkZedX95+bmEhoaajctNjYWAEmSWLNmDd9++y1KpZKOHTui1WqxWCx0796dBQsW8Pnnn/Puu+/i4+PDk08+yZQpU+qcl56eTlZWFgkJCbb9WSwWfHx8rhprXevWtU9BEIRrIRIRQagiLCyM9PR0JEmyJSOpqaloNJpq7T6USiUVFRWYzWYUCkWd2w0ODq7WgHXVqlWEh4dTWFjIypUr+frrrwkLCwPg8ccfB6x3/4SHh7NixQp0Oh0///wzzz77LP3790elUtU6Lzg4mA4dOrB69Wrb/goKCtDr9Vc9B3WtW1c8UVFRV922IAjClUTVjHDDU6lUlJaWAjBs2DD0ej2LFy/GYDCQmprKokWLGD9+PHK5/b9Lr169kMlkvP766yQnJ3Pq1Ck++OADKioqqu1j2LBhlJSU8Pnnn2MymTh58iQLFixArVZTXFyMQqHAxcUFs9nMunXr2L59O0ajkcOHD/Poo4+SlJSERqPB19cXlUqFu7t7nfOGDRtGbm4uX3zxBUajkdzcXB577DFbY9Sqx1zTOaht3br2KQiCcC1EiYhww7vzzjuZN28e586d48UXX2T58uXMnz+fgQMHolarGTduHLNmzaq2nr+/P0uWLGHBggV89913uLm5MXDgQFxdXast6+3tzYcffsjcuXNZtGgRvr6+PP/88/Tu3Ztu3bqxd+9eRo0aZWs/MmXKFA4dOsTcuXNJSkrioYceoqSkhLCwMBYtWkRAQAC33HJLrfMAPvroI+bNm8fbb7+NXC5nxIgRvPDCCzUe85Wva1vXzc2tzn0KgiA0lEySJMnRQQiCIAiCcGMSVTOCIAiCIDiMSEQEQRAEQXAYkYgIgiAIguAworGqIAiCcF0kSSIvLw+dTldrHz3CjUmpVOLj41PnnXU3ZGNVSZK4lqO+1MeVM54xZ43NWeMC543NWeMC543NWeMC542toXHJZNh19HeJJEmkpaVRUlKCQqGqdpu7cGMzmUwolXJiYmJQKmsu+7ghS0QkCfLztQ1ez9vbeltmcXH1fiIczVljc9a4wHljc9a4wHljc9a4wHlja2hc/v4e1JCHkJeXV9nrsC8eHt6NGaLQChiNBnJzM8nPzyc4OLjGZUTqKgiCIFwznU6HQqESSYhQI5VKjVKpqnUEcxCJiCAIgnAdLBaLqI4R6iSTyepsOyQ+PYIgCIIgOIxIRARBEARBcBiRiAiCIAiC4DAiEREEQRCEK+j1evLycmt93VK0hLhFIiIIgiAIV3jssWkcPPhnra+vx4YN65k16yn69YsnPz+vUbZZm6pxZ2VlctNNAykoKGjSfTbUDdmPiCAIQktz6thpflrzKyqViieenl5r51DOKCcnm3feeYvdu3diMBjo0KETr78+n6CgIEeHVquioqI6X1+PrVs3M2TIMHbv3tlo26xN1bhDQkLZtGlHk++zoVrOJ1kQBOEGo9fp2fTrVtau+onTJ87apk95YBKBwQEOjKz+Ll5MYfr0BxgxYiRvv70UFxcXtmzZhIeHR7Vljx07yltv/Y+kpLN4eXlz330Pcuedd7FlyyZWrPiYtLQ0jEYDcXG9efnlV/H29gHgvfeWsH79WgwGI9HR0Tz11Cy6dete57wLF5JZuHABJ0+ewMvLmylT/sKkSXcDMGvWU2RnZ/Haa3O4cOE8x48ft3s9cuSYWte9WjwGg4Fjx47wxBNP2R37uXNnWbx4ISdOHMfd3YPRo2/h4YcfRa1W13lugFrPz5w5L9rFfeut45k48TbWr/8Vf/+AWveZl5fHlCkTmTFjFp999ikVFeUkJCTy0kuv4ubmdtVjbChRNSMIguBk0lMzeG/Rcu4e+wAL/v2WLQmJ6dCWF//7zxaThADMnfsfevfuw7PP/ovY2M5ER8fw4IMP2y5olxQXFzF79lMMGzacX3/dxPz5/8eSJW/z558HePnlF3j88b/yyy8b+frr70lLS+X771cBsG/fHn7+eT0rVnzNhg2/ExfXm//9740655WXlzNz5pP07BnPTz/9xoIFC/nqqy/45ZcNACxa9A7BwSG89NKrPPLIE3av77nngTrXrSueS/N79OiFUqmyO/Ynn3yUbt26s27dr7z77gfs2rWDpUvfqfPcHDx4gOzsrFrPz5XHceX5rmufBoOBI0cO8/XX3/HJJ19w7NgR1q79oV7H2FAiEREEQXACZrOZnVv28NyMl7n/jkdZ+fkPlJZoUSqVjBgzlLc+fIMPvlzMTaOGODrUektNvcjBgweYMWPWVZfdvn0bXl7e3HPPfSiVKjp1iuX995cTFdWWr75aRZ8+fdFqS8nPz8Pb24fcXGsDTA8PTwoLi1iz5nvOn0/ikUce56OPPqtz3o4d21AqlUybNh2lUkV0dAxTpvyF775bedU4r7ZuXfGAtVpm6NCb7La5detm3NzcmD79cVxcXAgLC+fxx59i7drVdZ6bmJh2+Pn513l+anO1fQLcf/9DuLm5ER4eQVxcAhcvXqzXMTaUqJoRBEFwoMKCIjas+ZUfv9tATtbli0dQSCC333kLt4wfha+fj+MCvA5nz57F19ePsLDwqy6bn59HcHCI3bQOHToiSRLLl3/AmjU/oFAoaN++A2VlWiTJ2lNn585deOWV11i16hs+/vhDvLy8mTZtOnfcManWeVqtluzsbG6++XJSZ7FIeHl5XTXOrKzMOtetKx5Jkti9exczZsyipKTUtn5BQQGhoWF2gwqGhYVRVqaltLS01nMD1kEHf/ppXa3npzZ17VOrtcbm5+dnm6dUKut1zq+FSEQEQRCamSRJHD98krWr1rPl9x2YTCbbvD794xk36Vb6DkpAoVA4MMrrp1Qq0ekqMJvNVz2WwMAgcnKy7ab9+ONqNBpX1q5dzbJlHxMSEgrA3/8+y7ZMVlYmoaFhLFnyATqdjk2bfufVV18mISERlUpV47zp0x+jXbt2rFjxlW07RUWF6PX6qx5TYGBQnevWFU9RUSFRUW3x8PC0S0RCQkLJzMxAkiRbYpCenoaLiwZ3d/daz01ISChFRUV1np/aXG2fdanrGCMj21x131cSVTOCIAjNpKK8gnXf/8xj98zkb9P/yR8/b8FkMuHp5cGkeyaw4ocPmLf43wwY2rfFJyEA3bp1RyaTs3DhAi5eTOHs2TOsWPEJOl31EX8HDhyMVlvKypVfYzKZOHPmNIsXv0VaWipyuRy12gWz2cyvv/7M7t07MRqNABw/foynn57JhQvJaDQavL19USqVuLm51zrvjjsmkZeXx6pV32IyGcnPz+Ppp//GBx8stcWjVqttJQNVXw8cOLjOdeuKZ8uWzQwZMrSGYx+EwWDgww/fw2AwkJGRzvvvv8stt4xFLpfXem7UahdKS0vrPD9XHkd99imT1Z0a1HWM10KUiAiCIDSxC0kX+eKT7/n1xz8oKyu3Te/YuT3j77qVYaMGo9FoHBhh0/Dz82P+/DdZsuRtfvxxLW5uriQm9kOjca22rJeXF4sWvcOiRf/H+++/i4+PD7NnP8Pw4SNJSjrHXXdNQKVS0rFjLHfcMYnjx48CMGLESJKTzzNjxhOUlpYQEhLK66/Px9/fv855b7/9Lm+99T8++GApCoWcwYOHMXv2323x3HbbON56638kJyfz9NP/sHtd17p17XPbti0sXry02rF7eHjy1ltLePvthdx660hUKjVjxozlsceerPPc9OzZi9jYzvz55/5az0/VuKdMuade+8zPz6/zfa3rGK+FTJIk6ZrWbMEsFon8fG2D1/P2tv7zFBdXz+YdzVljc9a4wHljc9a4wHljc8a4TCYTO7fs4afVP7Nv10HbdJVaxU2jhjB+0lhiu3VyWHwNPWf+/h7I5bJq01NSUtDrjQQGhjZqfELrkZubiYuLiqioqBrnixIRQRCERpSfV8D6H35h3fcbyM+93INlaHgI4yaNZfTtN+Ptc/VGkYJwoxCJiCAIwnWSJInDB46ydtVPbN+0C7PZDIBMJmPQsL5MumccXXp0Qy4XzfIE4UoiEREEQbhGZdpyfvtpI2tX/UTK+Yu26d4+XtwyfhS3TRxDbJdowLmqjQTBmYhERBAEoYHOn7vAj6t+4refNlFRfjnB6NIjlnGTbmXoiIGoXdQOjFAQWg6RiAiCINSD0Whk28adrF31E0cPHrdNd3FxYcQtQ7l90lg6xrZv1piq9gEhCC2VSEQEQRDqkJOVy/offmb96l8ozC+yTY9oE864u8Yy+rYReHhWH8CtqRgNRk7sP8mfWw9ydM9xQtuE8PdFs0VCIrRYTp2IzJ07l4EDBzJkyBDKy8t5+umn0Wq1BAQE8Oabb7aoYbAFQWg5LBYLB/cdYc3KdezauheLxdq1tVwuZ8DQvoybdCvxiT2b7eJvMpo4+edpa/Kx6yi6iss9gFaUVYgkRGjRnPJKLkkSL7zwAnv27GHgwIEArFmzhsGDB3PPPfewcOFCNm3axMiRIx0cqSAIrUlpiZZf1/3B2lU/kXYx3Tbd19+HWyeM5tY7xhAUEtgssZhNZk4fPsOfWw5yeNdRKrSX26LI5XI69upA/JA44gb1bJZ4BKGpOG0iMmbMGMLCwmzTxo0bZ9flsVotGoIJgtA4zp5KYu2q9fyxYYvdeCM94rsxbtJYBt3UH5VKVccWGofZbObckSQObD3I4Z1HKCsps82TyWV06N6e+CG96DmgJ54+zVcdJDS91au/45NPPqKkpJjY2C784x/PER0d4+iwmoVTJiJyuZyhQ4dy5MgR27RLg/AcOXKEvXv3MnPmTEeFJwhCK2DQG9jy+3bWrFrPyaOnbdNd3VwZOfYmbp80lpj2bZs8DovZQtLx8/y57RCHth+itOhyr88ymYyYrtHWko+BPfHyEx2htUanTp1k6dIlvPfeh0RFtWX58g+YO/c/fPDBR44OrVk4ZSJSm8OHD/Pqq6+ydOnSVjEglCAIzS8zPYt13//MhjW/UlxUYpseFdOGcZPGMnLscNw93Jo0BovFwoVTKfy59SB/bjtESUGJ3fy2sVH0HhJH3OBe+AT4NGksNyLJYkEyGpp0HzKVGlk9O7CLje3MDz+sw83NjaKiQrTaUnx8fJo0PmfSYhKR9PR0WxISHBzs6HAEQWhBLBYL+3b9yZqV69m7Yz+XhthSKBQMHj6AcZPG0iO+W5M2+pQkiYtnUjmw9SAHtx2kMLfIbn6bDpHED4kjfnAv/IL9miyOG51ksaA7+ieSXtek+5G5aNB0j693MuLm5sauXTt4+umZeHh48O67y5o0PmfSYhKRjz/+mJKSEv7+d+sIh/fff/81N1aVyS4P+NQQSqW1FOZa1m1qzhqbs8YFzhubs8YFzhtbbXEVFRazdtXPfPfVj6SnZtqmBwb7M/Hu25gweSyBwQFNFpckSaQmpbP7t73s+n0/uRl5dvPbdIig74gE+g5PIDiieRrBXtLQ91LcmNP0evfuw9atu/niixX84x+zWLlyTbO0TXK0Zh19d9myZSQlJTFv3jwADhw4wCuvvEJqaipxcXHMnz+foKCgJo9DkiSMRnOD17v0j2syNXzdpuassTlrXOC8sTlrXOC8sVWNS5Ikjh85zaov1vDr+k0YDEbbcokD4pn0l3EMGd4fpappfodJkkTa+Qz2/LGfPX/sJys1x25+eHQY/W5OoO/w3oRGhTRJDPXR0PdSpVLUWGLUEkffdbaqmStJksTo0Tfx9tvvEhvbpZEja35OMfquwWBgyZIlvP/++0yYMAEAnU7HzJkzeemllxg+fDjz589n7ty5LFy4sMnjkaRrG/fBGYcav8RZY3PWuMB5Y3PWuMB5Y/P2dkVXoWP1yl9Yu+onzpw8Z5vn7u7GqNtHMG7SWNq0jQSgrNwIGGvZ2rXJSs22tvnYcpCs1Gy7eSFtguk1sCe9h8YRGnX5gu3I89jQ99Lf36PVlIrI5HJkLhpHh2Hzxx+/sWXLJv797/8C1qpEk8mMh4engyNrHs2SiMyZM4fCwkKmTp1KRYX1Q79r1y78/PwYM2YMALNmzWLAgAFotVo8PMRtaYIg1E/axXQ+WvcbP373CyXFpbbpMR3aMv6u2xgxZiiubk1TlZSbkcuBLQc5uO0Q6ckZdvMCQvyJHxrHkLH9aNM+gpKSpm2TILRcnTt34fXX/82BA/vo2bMXy5a9R7t27QkPj3B0aM2iWRKR2bNnExQUxOLFi0lPt3YSlJKSQnR0tG0ZT09PvLy8SElJoWvXrs0RliAILZTZbGbP9v2sWbmO/bsP2qarVEqG3DyI8ZNupUuP2CZpfJqfnc+fWw/x59aDpJ5Ls5vnG+RL/OBexA+Jo02HSGQymdO1pxGcT1hYOK+99l/eeGMuBQX59OoVz9y5b9wwPeY2SyJSU7uP8vJyNBr7ojGNRmMrMREEQbhSQX4hG9b8xrrvN5CTlWubHhIWxJ1Tb+em0Tfh6+fT6PstzC3iz20H+XPrQVJOX7Sb5+3vTfzgXsQN6UV0bNsb5uIhNK6BAwczcOBgR4fhEA67a8bV1dWuB0Owthu51HGZIAgCWBvuHT98krWr1rPl9x2YTCbbvD794xl3162MGjsYhULRqG0uiguKObjtMH9uPcj5E8l28zx9PYkb1JP4IXHEdIlGfo2NEgVBcGAiEh0dzZo1a2yvS0tLKS4upk2bNo4KSRAEJ1JRXsHvGzazdtV6zp+9YJvu6eXBmHEjuf3OWwiPtA4D0VgdHJYWlXJo+2H+3HaIc0eTqHpToYeXOz0H9aT3kDjad2uHXCGSD0FoDA5LRPr160dOTg7r169n5MiRLFq0iCFDhogSEUG4waUkp/Ljqp/4dd0flJWV26Z37Nye8Xfdyk2jhuCicWm0/WlLyjiy8wgHth7kzOGzSJbLyYebhxs9B3QnfkgcHXt1ED06C0ITcFgiotFoWLp0KXPmzOHFF18kPj6e+fPnOyocQRAcSJIkdmzZzQ9f/8ih/ZfHmFKpVQwfPZRxk8YS27Vjo+2vXFvOkV1H+XPrQU4dPIPFbLHN07hp6NG/O72HxNEprmOT9TciCIJVs/6HzZgxw+51z549Wb16dXOGIAiCk/lz7yE+fOdTTp84a5sWGh7CuEljGX37zXj7NM5AbxVlOo7tOcaBrQc5deCUXUdeao2a7v260XtIHJ17x6JSt/7eLAXBWYhUXxAEhzhz8hwfvvMpB/Zcvv02cUBvJtx9O336xzdKA1C9Ts+xPcf5c+shju87gcl4uaGrykVFt8SuxA+Jo2tCZ9Qa9XXvTxCEhhOJiCAIzSrtYjofL/2czb9ts03rEd+N6U89QNcena97+wa9gRP7T/Ln1oMc23MCg/5yV95KlZIuCZ2JHxJH975dcXFtvLYmgiBcG5GICILQLPLzCvhs2Vf8tPpXzGZrtUhMh7ZM/+sDJA5MuK7+N0xGE0d2H2fbhj0c3XMMfcXlrgEUSgWd42OJHxpH977dcHV3nq69BUEQiYggCE1Mqy3jm0+/4/uv1qDTWROEkLBgHnz8XkaMGXpdVTAFOYVs/2knu3/dTUnh5e7d5Qo5sXEdiRscR8/+3XHzdLvu4xAEoWmIREQQhCZh0BtYvXIdX368ktLKMWB8fL255+G7uW3iLaivsUGoxWLh9MEzbFu/naN7jttut5XJZXTs0YH4IXH0HNgDDy/RFYDQcmRnZzFv3uscP34UHx9fZs36OwMGDHR0WM3ihkxEJEkio7jhA1CVVt7hV1rqfINXOWtszhoXOG9szhoX1C82s9nM9k07+e7LteTn5QMyNP5BjJ0wirETRuPq5kpehRkq6jf8/CUVZRUc3H6YfZv2U5BVYJ2odsXD24MBo/vQb2QiCpW1zUeJBCXX8D/eFJz1/WxoXH5+7kDr6L5eslgwlzftcCIKN1dk9Szts1gszJr1FKNH38Kbby5iz55dvPjis6xf/xuurq1/rCKZVLXrwBtESYWRHq/+6ugwBEEQWowjc0bh5Vq9FCslJQW93khgYKgDomo4yWIh88c/MGnLmnQ/Sg93Qm8fUa9k5NChg7z++qusXLnaNu3s2TNERbVFrW75d3Pl5mbi4qIiKiqqxvmij2JBEARBcKCzZ08TFdWWuXNfY8yY4TzwwF8oKytrFUlIfdyQVTPuagVrpic2eD1PT2tre2crYgXnjc1Z4wLnjc1Z44LqsV1MSeObT7/j0P7DtmV6xnfn7gfuJCq64eNGFeYUsG/Tn/y57SAV2stF54ERQfQdnkCP/t1rvOXWGc6ZoUJP5tl0Mk9dJPN0KhWl5XbzFUolQTGhhMVGEpPQCZWD+y1p6DlzV7eO7u1lcjmht49wqqqZ0lItu3bt4Nln/8U//vEcGzf+wT//+TQrV67G29u7SeN0BjdkIiKTyQjzbvgtfN7e1rq6YicsR3LW2Jw1LnDe2Jw1Lrgc2+msbD5573N+37AZSZKQA527deKRGQ/Ss3f3Bm3TYrZw4sBJtq3bwYn9J20Dzbkq5MQN6sng2wbRrmtMnbf3OuKcSZJEQWouF4+e5+LRZLLPpdsazioBT8Ar0Jv2CR2JjmuPd2QwKhfn6bG1oefsem6vdjYyuRylh/M0ZlarVYSHRzBu3AQARo0aw6effsSRI4cYPHioY4NrBjdkIiIIwrUpzC/io6VfsOrLtRgreylt0zaCh/96PwOH9W/QxUpbrGXXr3vY/tNO8rPybdN9AnwYNHYAA0b3w8uvcbp3byz6cj3pJy6QejSZi0eTKS/S2s1XKBWEdoqkTY8YIrtH4x3si4+P9dbh4uKm/QUutFyRkW3Qau0/SxaLpZalWx+RiAiCcFUV5RWs/GI1qz7/wTYibkCQPw88eg+jbxuBQlm/YntJkrhwKoVt67fz59ZDdl2ux8Z1YvBtA+nWt6vTjHIrSRIFabm2xCP7XLrdAHkAngHeRHaPpk33GMI6R6JyuTHq9YXGk5jYD4DPPvuEe+65n19+2UBhYQG9e/dxcGTNQyQigiDUymg0sv77n/ls+TcUFRQB4OXtyZQHJjFh8m24aOrXRbpBZ2D/lj/Z+uN20pLSbNNd3TX0G9mXQbcOIDgiuCkOocEMFXrST6Rw8WgyqUfPU1Zo/0tVrlQQ2jHCVurhE+LXqqothObn6urKkiXv88Ybc/nkk48ICQlh3rz/w83txuiITyQigiBUY7FY2PTrVj5e+jmZ6VkAuLi4MPXBiTzw6BQsUv1KLLLTcti+fge7f99r1/g0ol0EQ24fRO+hcfVOZpqKJEkUpufZEo+ss9VLPTz8vWjTPZrIHjGEx7ZxeENTofWJjo5h6dJljg7DIUQiIgiCjSRJ7Nv1J8vf+ZRzZ84D1u7Sbxk3ivsfnUq79hFA3e0dzGYzx/YcZ9u6HZw6eNo2XalUED80jsG3DqJtbJRDSxEMFQbST6aQevQ8qUeT0RaU2s2XK+SEdIygTfcY2nSPxifMX5R6CEITEYmIIAgAnDx2mmWLP+HwgaO2aUNGDGTaE/cR2TbiquuXFJay8+ddbP9pJ0V5Rbbp/sF+DBo7gH6j+uHp49EUoV+VJEkUZeRz8WgyF4+eJ+tMWvVSDz9PIrtHE9k9hvDOUahdRamHIDQHp05E5s6dy8CBAxkyZAgGg4FnnnmGvLw8Bg4cyFNPPeXo8AShVbh4IZWPlnzGtk07bdPi+vRg+lMPEtu1Y53rSpJE0vHzbFu3nUM7jmA2Wbttl8lkdO4dy5DbB9Gld2fkiua/F9moM5B+8iKplbfXavNL7ObLFXJCOkRUNjSNxjc8QJR6CIIDOGUiIkkSL7zwAnv27GHgQOugPxs2bKBnz55Mnz6dGTNmkJaWRkTE1X+lCYJQs9zsPFYs+5Kf1/5uu1Wwfad2PDLjAXr3javzoqwr17Fv0wG2rdtOxoVM23Q3TzcGjO7HwFsGEBgW0OTHUJUkSRRm5pN6xJp4ZJ5Jw2KyH8/G3deDyMrqlvAuUahr6BxNEITm5bSJyJgxYwgLC7NNO3bsGLfffjsAiYmJHDp0SCQignANSopL+eqTlaz+dh0GvQGAsIhQHnriXoaNHIy8jt4g085n8McPW9j+0y50FXrb9KhObRh86yDih/RC3Yy3rxr1BjJOppJ1+iLJB89RnFNkN18mlxHSIcLa0LR7NH4RgaLUQxCcjFMmInK5nKFDh3LkyBHbtLKyMtzdrT3hubq6Ul5eXtvqgiDUQKfT8cPX6/j605VoS60Dfvn6+3Df9KmMnTAKlarmXj/NJjOHdx1l27rtnD1yzjZdpVaRMCyeQbcOJKpjw7tzvxaSJFGcVcjFykammadTbdVBl7h5u1tLPXpEE96lLS5uotRDEJyZUyYiNXFzc6OszPrlWVFRgb+/v4MjEoSWwWwy8/OPv/HpB1+Sn1sAgJu7K3ffdyd3/mU8rm41DzNelFfEjg272PHzLkoKLrevCI4IYsAt/ek3MhF3z6bvJttisZB1Jo3zB86QeuQ8JbnFdvNlchnhnSKJiW9PUIdI/CJFqYcgtCQtJhHp1q0be/fupUePHuzbt49//OMfjg5JEJyaJEls27iT5UtWkHYxHQCVSsm4u27lnmmT8fapPpiWJEmcOXyWbet2cGTXUVvbEZlcRrfEroyZPJxuiZ0pLdVXW7dRY7dIZJ1LJ2nfKZL3n6G82H7IdjdvdyK6RdOmRwwRXaMICvUFRDfqgtAStZhEZOzYsfz9739n8uTJ9O/fn8jIyGvelkx2ecCnhlBWdmN9Les2NWeNzVnjAueNrTHi2rfrIIvfXMaJI9Z+PGQyGbdOGMljf3uQ0PDqPZiWayvYvmEXf3y/hYyULNt0Tx9Pbho3iJvGDyYg1L9KbI1/F4wkSWSeTefUjuOc3nWS0ivucglpH0aHPp2sJR9tQ5DJL5d6OOt7Cc4bW0PjEoVMTWv79q28885b5OTk0LNnL5577l8EB4c4OqxmIZMuDXXZDJYtW0ZSUhLz5s0D4MCBA7zyyiukpqYSFxfH/PnzCQoKavI4JEnCaDRffcErXPrHNZkavm5Tc9bYnDUucN7YrieuU8fP8s6bH7J7+37btMHD+/PXZx6mfcfoasunnE3lj++3sOOXPRh0Btv0jj3aMWLiMPoMi0Olvtx2pLHPmSRJZJ/P5NSO45zaeaJatUtQdAixA7oQO6ArPiG+tW7HWd9LcN7YGhqXSqWoscorJSUFvd5IYGBoo8Z3I0lLS+Wee+5mzpzXGDJkCJ999ikbN/7OihVftYpqxtzcTFxcVERFRdU4v1lKRAwGA0uWLOH9999nwoQJgLXh3MyZM3nppZcYPnw48+fPZ+7cuSxcuLDJ45GkayvCtQ2b7YTFv84am7PGBc4b27XElZGWyUfvfsamX7fapnXr2YXpMx6ge6+udtszGkwc2nGYbeu2c/5Esm15tYuaPsN7M/i2QUTEhANQXmGCissD0zXGObs0kFzS3tMk7TtFyRV3uviFB9AuMZaYPp3wCfGzTa9rn876XoLzxtbQuPz9PVpNqYjFbMFQWnb1Ba+D2tO93v3n7N69ix49ejJ8+AgAHnhgGp999glnz56hY8dOTRmmU2iWRGTOnDkUFhYydepUKiqsH/pdu3bh5+fHmDFjAJg1axYDBgxAq9Xi4eGY3hcFoaUpyCvks+Vfs/77nzGbrb9s28a04eGnHqD/4ES7X1MFOYVs/2kHO3/ejbb48kBuwZFBDL51EH1v7oOre9NVHxSm53Fu3ynO7ztNUWaB3TyfED9iEjvRvk8svuHN2/+IcGOxmC0ceu8H9IWlV1/4Orj4etLr8TvqlYxYLBY0Go3ttUwmQyaTk56eJhKRxjJ79myCgoJYvHgx6enWRnMpKSlER18uKvb09MTLy4uUlBS6du3aHGEJQotVpi3n28++Y9WXa9BV6AAICgnkwcfv5eZbhqFQWIvdLRYLpw6eZtu6HRzbexzJYq2Jlcvl9OjfncG3DaRjzw5NVvxbnF1I0t5TJO09RUF6nt08ryAf2vWJpV1iJ9G/h3BD69evP++99w579uymd+/efPXVF+h0OgwGw9VXbgWaJRGpqd1HeXm5XQYIoNFobCUmgiBUZzAYWbtyPV989C0lxdbGnF7eXtwzbTLjJo21dSZWVlrG7t/2sn39DnIzLicAXn5eDLylPwPH9McnwKdJYizJLSJp72nO7ztF3sUcu3ke/l6069OJdomxBEQFi+RDaHZyhZxej9/hVFUzbdpE8fLL/+Z//3uD0tJS7rrrbmJiYm6Y2gGH3TXj6uqKXm9/C6BOp7N1WiYIwmVms5nfN2zmk/c+JycrFwCNxoVJ90zgrvsm4uFh/b/Jzcjl129+Z//mPzEajLb1O/Roz+DbBtGzf3cUlY0UG5O2oMTW5iM3OctunruvBzF9OtGuTyxBMaEi+RAcTq6Qo/HxdHQYNmVlZURFteWbb76vfK3lk08+okOHusd6ai0clohER0ezZs0a2+vS0lKKi4tp06Z5emgUhJZAkiR2bdvLR0tWkJyUAoBCoeDWiWO47+Ep+AVU9p9RUMyGL35h5y+7baPKalxdSLy5D4NvHUhoVOPf0VBWqOX8/tMk7T1FdlKG3Tw3b3diEjoR06cTIe3D7W61vdFYTGbkTZD8Ca1HYWEBjz02jQ8/XEFgYCCLFy8iPr43QUHVb7VvjRyWiPTr14+cnBzWr1/PyJEjWbRoEUOGDBElIoJQ6dihEyxb/AnHDp+wTbtp1BAeeuJewiOt4zBVlFXw28qNbF69xTZujF+QLyPvGkGf4Qlo3DQ1bvtalRVpObP7JMe2HCXzbBpUuflf4+lGTO8OtEuMJaRjRJ1j1rRWksVCWW4RJam5lKTmUJyaQ3leESHdouk8ebijwxOcVEREJE8+OZOnnnqM8vIyEhP78cor/3F0WM3GYYmIRqNh6dKlzJkzhxdffJH4+Hjmz5/vqHAEwWmcO5PMkv9bzraNu2zTEvrF8fBTD9Axtj0ARoORreu288vXv1Feah13ycPLndFTRzFo7EBU6sb7164oLSf5wFmS9p0i83SqrcErgIu7hujeHWnXpxNhsW3qXSfeWhjKKihJsyYdJam5lKTnYtYbqy1nuYZ+i4Qby4QJE5kwYaKjw3CIZk1EZsyYYfe6Z8+erF69ujlDEASnlZ2Zwyfvf8Fv6zdyqZ/BTl068MiMB4nr0xOw3nq45499/PT5BgpziwBQa9SMmHgTwyfehKt745SA6Mt0JP9pTT7ST6TYJx9uLkTFtaddn1jCu0Q1SZsTZ2QxW9Bm5dtKO0rScqgoqPkWUJW7Bu/IILwiggiNjcA/JpTSshvjDghBaKgW08W7ILRWxUXFfPHRt6xduR6j0dp5WJvoCB587F6GjBiITCZDkiSO7j7G2k/Wk3XR2hhUoVQw8JYBjJk6Ci/f6294Z6jQc+HgOZL2niLt+AVbWxMAlYuKqLj2dB/Wg+he7Sgrr/6rv7XRl5RRfKmkIy2H0vQ8LDX0QiqTy/AI9ccrMgjviCC8IgPR+HraGuU6W9fuguBsRCIiCA5SUaHjuy9W8+1n31NWZq1e8Q/w47G/PcC4SbdQVvkLOunYedZ8/KNdL6gJw3pz2/23EBB6fZ1/GXUGUg4nkbT3FKlHkzFXudAq1Sra9IyhXWIsbbpHo1SrqlxUW1ciYjaaKM3IpyQtx1bNoi+p+fZOF293vCoTDu/IIDxC/VGoxFepIFwr8d8jCM3MZDKx/odf+OzDryjMLwLA3cOdqQ9O4o4ptxMcbL0TJj05gx8/Wc+xvcdt63ZJiGXcg7cR0S7imvdv1BtJPXqepL2nuHjkPCbD5S7cFSolbXpE065PLG16xqCq7JekNZEkCV1hKSWpudYSj7QctJn5dtVPl8iVCjzDA/CKCLJWtUQG4uIlGtQLQmMSiYggNBOLxcLm37bx8dLPyUjLBKzju0yYfBtTH7wLL29r9UpuZh7fLfuRnb/ssbUVierUhvHTbqdjjw7XtG+T0UTasWSS9p7mwqFzmKo0qJQrFUR2a0u7PrFE9WqP2rV1JR8mvYHS9Dy7ahZjma7GZV39vPCKDLRVs7iH+N1wDXAFobmJREQQmsH+3QdZtvgTzp1OAqxdrI++/WYeePQvBAZbq1e0xVp++fo3tq3fgamyrUhwRBC3P3grPQf0aHBHYJIkkXkmjdPbjnLh4FkMFZcbS8oVcsK7RNEuMZa2ce1xaeTbfB1FskiU5xVbb52trGYpyymyjnR5BYWLCq+IQFs1i1dEEOpGauwrCEL9iUREEJqQXqdn8YL32bDmV9u0QTf1Z9qT9xMVHWldpkLPxh8288eqjegqrL0N+wb6cMtfRtN3ZKJt3Jj6MlToObvrBMc3HaKwyvguMrmM8M5tiOkTS3R8BzQeLb8RpcVkpiQth8zMfArOZ1BwIRuTroa7U2TgHuiDV+WdLF6RgbgH+iC7Afs6EQRnIxIRQWgiqRfSePW5eSSfuwBA97iuPDrzIbp0jwWs1SU7Nuzi569+obTIOhquq4cr4+6/hVF33USFrmF9TxSk5XJ80yHO7jyOsUrVS1BMKJ0GdiO6d0dcvdwa5+AcxGw0UZKWS1FyJkUXsihJzanxThaVm8vlko7IILzCA1FqWleVkyC0FiIREYQm8MfPm/nf6++gq9AhV8iZ/tcHuOveO5DL5VgsFv7cepB1n/5EXlY+ACq1imHjhzDyrhGERvgDUKG7+gCQZpOZ5D/PcmLjQTLPpNmmK9VK2vfrQpebehEY1XK7iTYbTZSk5lCUnEXRhUxK0nJrTDw8Q/zwbxeGa4gfXpHBuPp5ijFthBbns88+ITk5mZdffhWADRvWsXz5MgoLC2nfvj3/+MfztG9/be3EnJlIRAShERn0Bpb83wes+/5nAAKC/Hnpv8/SrVcXJEnixIGTrP14PWlJ1qRBLpfTb1Rfxt4zukGj4WoLSjm55TCnth6hvPjybabewb50uakXnQZ2w6UFtncwG0wUp+ZQdCGTomRr4iFV6c/kEvcgX3yiQ/FpG4JP2xACw/0AKC4Wo3cLLY/BYOCjj5bx6acfccsttwFw/nwS//vfAt5+eykdO3biiy9W8Nxzz7Bq1VoHR9v4RCIiCI0kPTWDfz87j3NnzgPQZ0Bvnnv1aXx8vblwOoU1H/3I2SPnbMv3GtiT2x4YS0hk/UosJEki/UQKxzcdIuXQOdvtpjKZjKi49nS9qRfhnaNa1ABzZoPRmnhcqmqpLfEI9sMnOgTftqF4tw0RjUqF62IxmSmvrA5tKm4+HvUe7HD+/NcpKipi4sRJVFRY7+jKzs5i8uQpdO7cBYA775zMu+8upri4CG9vn6YK2yFEIiIIjWDL79t587W3KC+rQC6X89AT9zLlgUnkpOfy4ZLvObTjsG3Zjj07MO6h22jbKape29aX6ziz4zjHNx6kOLvQNt3Vy43OQ3rSeVgPPPy8Gv2YmoJJb6QkNZui5CwKL2RSmpZbvf8OGXgE+9mVeKhayV09guNZTGbWzPmU0tziJt2PZ6A34199oF7JyBNPPEVAQCDLlr1HRYX11v7+/QfSv/9A2zK7du0gMDCw1SUhIBIRQbguBoOR9xZ+yJqV6wFrz6j/ev0fREVF8vXib9n9614sFusv/IiYcMZNu43O8bH1ar+QdzGb4xsPcW73CbtOx0I6RtD1pl5E9+7o9OO8mPRGii9mV5Z4ZFKanldz4hHib006okPxiQpB5ebimIAFwQECAgLrnH/69Cnmz3+d5557sZkial4iERGEa5SRlsVrz8/jzElrdUt8Yi9mP/dX9v2+n0/+vQKjwXrnSkCIP7c9MJb4IXHIr3K7qMlo4viWIxz8ZT8Zpy83PlW5qOgwoCtdbuqFf0TdX1qOZNIZqiQeWZRm1JR4yPAI9cO3bSg+0aF4RwWjchWJh9A85EoF4199wKmqZuqyb98eXnjhn/z1rzMZMWJkI0TmfEQiIgjXYPumnbzx6luUacuQyWTcM+1uwvyCWfjM21RorQ0mPX08GPOX0Qwc0x/lVcYiKc0r5sRma+NTnfZyg0vfMH+63NSLjgO6onbCi7VJZ6AoJYuiC1kUJWdSmpFfvfMwmQzPMH982obiEx2CdxuReAiOJVcq8AjwdnQYV/XHH7/x3/++xksvvcKwYcMdHU6TEYmIIDSA0Wjkg7c/5vuvrC3Xff18GD/+Vk7tOMWB/P0AaFxdGDFpOMPvGIZLHRdcySKReiyZ45sOcfFIElRev+UKOR0SY+k4pAehHSOc6jZUQ7megvMZpB9PoSg5i9LM6omHTC7DIywAn7Yh+EaH4t0mWPThIQgNdPbsGV57bQ5vvrmIhIRER4fTpEQiIgj1lJWRzWvPz+fU8TMAtGsfTZDGnz3r9gCgVCoYfNsgRt09Ek8fj1q3o9NWcHr7UU5sOkRJlQZzbj4edBnWkz63JuLp5+kUt6JKkoQ2M5/8s2kUnEmjODWnxsTDMyzA1rhUJB6CcP1WrfoGg8HAP/4x2276V1+tIiQk1EFRNQ2ZJNUwCIMT0uv1zJw5k9LSUrp06cKLL157ox2LRSI/v+H1g5eGQHeGC8SVnDU2Z40LGhbbzi17mP/K/9CWWqtiYiKiUFUokMlkyGQy+gxP4Nb7xuAf7F/rNnLOZ3J800GS9pzCXKVTrrDObeh6Uy+ierVHoVQ4/JwZK/QUJmWQfzaVgjNpGLT2ccjkcjzDA2yNS73bBKF08Ci9jj5ndXHW2Boal7+/B/Iabg1PSUlBrzcSGNi6Lo5C48nNzcTFRUVUVM13CraYEpFt27bRqVMnnn76aWbPnk1SUhLt2rVzdFhCK2cymVi+ZAXffvY9AC5qNUGuAah1SpBBt8Su3P7grYRHh9W4vlFvJGnvKU5sOkTuhSzbdLWrmo4Du9FlWC98w2pPXpqDJEmUZRWQfyaN/LOplKTmVGtgqvH1xL9jBJG92hHQPoyyBnY/LwiCUJsWk4hER0fz559/IkkS5eXluLu7OzokoZXLycrlPy+8wfEjJwFwVWkI9whBpVAS0yWa8Q/dTrtuMTWuW5xdyIlNhzi94xj6KkPO+0UE0nV4HB36dUblwOoLk85AQVI6BWfTyD+ThqG03G6+TCHHp20I/h0j8e8QgWuANzKZzPYrmnp0Py8IglAfLSYRUavVbNy4kT/++IPo6GiCg1vu+BmC89uzYz9zX3qT0hJrFZ6/qy+B7n6EtQ3l9gdvo3vfrtUakVosFi4ePs/xTQdJO3bBNl2ukBPTpxNdb+pFcPtwhzQ+lSSJsuxC8s+kUnA2jeKL2dVLPXw88OsYgX+HSHxjQlGoVc0epyAIN54Wk4h89tlnPProo0ycOJG33nqLtWvXMn78eEeHJbQyZpOZDxZ/wqovfgBAIZMT5hlMZEQ4t953C4nD+yBX2PcFUlFSxqltRzmx+TDa/BLbdA9/L7oM60ns4O64ejV/CZ5JZ6DwfIYt+dCX1FDqERViSz7cAr2d6g4dQRBuDC0mEXF3d8fDw3ongr+/P1pt03ZGI9x4MtOzef6pOaSmWjsSc1VqaB/WlnH33cbgWweiqlJCIEkS2efSOb7pEOf3ncZSZXyUiG5t6XpTHG16xly1A7PGJEkSZTmFtuqW4pSsaqUeLt7utuoWn5gwlC6i1KM1kyRJJJeC02sxd80UFBTw7LPPUlFRgY+PDwsWLMDV1fWatiVJEkZjwxvbKSt7yTPVMAy5ozlrbM4aF1yOzaA38tFbX7D8g88xmq1dqQd6+vPA9LsZd/9Y3Dwuf84MFQZObDvKoV/2k3Mh2zZd46Gh2029iBudgG+oX6PEVZ9zZtQZyD2TRs6JFLJPplBRaJ+gyxRy/NuFEdy5DcFdovAM8buuC5Ozvp/OGhc0fWxmgxF9cSmGwlL0xVr0RaXW10WlGMt1hPbvSXCfrtcdl0qlqPGzI+6aEa7G6e+aWbZsGUlJScybNw+AAwcO8Morr5CamkpcXBzz588nKCgIPz8/li1b5uBohdZEkiQObDvMf1/4H+fTLwLWqpgxo0Yw+5Un8KnS82J+Wi4HfznAsc2HMZTrbdOD24USP6YPsQO7omqG0gVJkijNKiT7ZArZJ1LIT8qoNlqtq48HwV2iCOoSRWDHCIc2ihWunyRJmCr0GIpKbUmGvkiLodj62lSuq3N9Q7EoPRacm8MSEYPBwJIlS3j//feZMGECADqdjpkzZ/LSSy8xfPhw5s+fz9y5c1m4cGGj7luSru2efmftDwCcNzZnjev8yWS+++B7tu7eTbnRGpu/rx+vLHieLr06A1CQryXl0DmObzpExsmLtnUVSgXt+sbS9aY4gmKsvwLLdSbQmarv6Bpcec5MeiNF5zPIP5tG/plU9MVldsvL5DK8o0Lw6xCBf8cI3IN8bb9cy/Vm0DfeuXfW99NZ44L6xSZJEuayCowlWutfaRmmykdjiRbJePXPlkypQOXlgdLLA5WnOyovD1ReHmhCAmvc97X0IyJqeYSm4LBEZM6cORQWFjJ16lQqKqz/CLt27cLPz48xY8YAMGvWLAYMGIBWq7W1DxGE65GZksWPn65j15a9pJdkY5asxdKjbhnO0y/PQKVSYTKaOLHpEId/3mc3MJZXoDddbupFp0Hd0XhcW7VgfUiShDaniIsHzlJwNo2iC1nVSj3Unm74X7rDpV2Y6Mm0BZAsFkzacozFpRhLrAmGqVRrfV5aBhbLVbch16hReXpUJhzulc/dUXp5oNC4iPYgLdxnn31CcnIyL7/8KgBz5vyLzZs32tqatWkTxaeffunIEJuEwxKR2bNnExQUxOLFi0lPTwesdY3R0dG2ZTw9PfHy8iIlJYWuXavXcQpCfRXmFrL+sw3s/n0vudoC8soLAHBzc+XZV2cz6KYBWCwWTu84xv7VOy7f/SKDNj3a0fWmXkR2i0ZWQ8+SjUWbXUDO0WTyT15Am1NkN08ml+HVJhj/DhH4d4zEPdhXXHSckCRJmCt0GIu1lQmHlvzycnSFJeiLSuHKkYhroHB3tZZmVEkyLpVwyMUt1a2SwWDgo4+W8emnH3HLLbfZpp87d5Z33nmP7t17OjC6plfvRKSoqAgfHx+MRiNr1qzBx8eHm2+++Zp3HBQUVG1aeXk5Go3GbppGo7GVmAhCQ2lLyvj1m9/Z+uM2dHodGSXZlFVWxXTu1pG5b72Eh5cPFw6dY9932yhIzwOsfX/EDulBzzF98Ar0abL4ynOLyD6WTM7R85TnFtnNU3u64d8hAr8OEfi2CxMj1joRi8FoSzQMxaV2icdVq1HkMlSe7igrSzYuJRlKL3eUHu6NMnS8UDezyUxxfvHVF7wO3v7eKOr5Xs6f/zpFRUVMnDiJigprmx+j0cjFiym0a9ehKcN0CvVKRFavXs2rr77KwYMHWbBgAevXr0cmk3H27FmeeOKJRgvG1dUVvV5vN02n04leVIUGs5gtbPxhMz9/9Su6ch1lhgoytTkYzUYAJky+jX++/FdykrNYu+Qrss6l29Zt37czCXcMxDvIt0liqygoIfvoeXKPJaPNKrCbp/HxIDKhI+G92oOXhyj1cCDJbLa20biUZNiSjVLMFfqrrq90d0Pl7YF7oA8uvl6Y1S6ovD1Rergha8bbugV7ZpOZ/3vyf+Rn5jfpfvxD/Xnm3afrlYw88cRTBAQEsmzZe1RUZAJw/nwSKpWaZ599hrNnT9O+fUf+/vdnads2+ipba3nqlYh8/PHHLFmyBJPJxHfffcfy5csJCAjgnnvuadREJDo6mjVr1thel5aWUlxcTJs2bRptH0LrV1JYyqdvfMbpQ2eQJIkSUymZJblIkoSbuyt/f+lvdI/txI//+56k/Wds60V0a0vfO4cQENX4vfbqikrJOZZMztFkSjPy7Oa5eLsT1C2aoG4x1sHkfNwA52x42dpIkoS5XIehqMSaaJSU2pIOk7YMrlKTIndRo/L2QOXtaS3d8Pa0vvbyQK60fr06c0NawTkEBARWm1ZeXkaPHj146qlZREa2YcWKj/jHP2bz1VcrUSpbVxVdvRKRzMxMBgwYwP79+1GpVPTq1Qug0TsV69evHzk5Oaxfv56RI0eyaNEihgwZIkpEhHo7c+Qsn8z7jJLCEkwWMzqNgYy8HADad4zhmef+Svq+JFZ+9YntIhMYHULfSUMJ79y4Ca+uuIzc49Zql5K0XLt5ak83grq2Jah7DF4RQU3a9kQAySJh0pZZE46iUrvHq1WlyBQKW3JhSzQqEw+FRlSXtTQKpYJn3n3aqapmahIX15u4uN6219OnP87XX39FcnIyHTp0bIwQnUa9EhF/f3+OHTvG2rVr6devHwC///47oaGN24GNRqNh6dKlzJkzhxdffJH4+Hjmz5/fqPsQWieLxcKv3/zO+s83WC86cjM5hnyK062NTm8ZN5I+MZ3Z8s56LJUdOPmG+TPkL8MJ7hzVaFUg+tJyco9fIOfYeYpTsu3mqdw1BHWNJqh7NN5tQkTy0QQks8XabuOKhMNYXFLtziM7MlB6uFcp0fBE7WN9VLi7iiqyVkahVOAXfH0dDza1PXt2U1CQzy233ApYv+PMZhMuLq0v+a1XIjJjxgymTp2Km5sbK1asYM+ePcyePbtR+veYMWOG3euePXuyevXq696ucOMoLdLy6YLPOPXnaWtRu5tEUloKFosFV1cNd9wyBnl6GacuHAbAzceDhPEDSLw1EblCft1F5oayisrkI5miC5l2xflKVxcCu7YlqFsMPm1Dqo1TI1wbi8lUmWCUYigsIb+sHF1BEfrCUmtHQbWRy1F5e6D28ULl44naxwu1jxdKLw/RSFRwMhKLFv0fnTrFEhnZhvfeW0K7du1p06bm3klbsnolImPHjmX48OEolUqUSiVarZY//vijxjtfBKE5nTuWxMfzVlCcX4zJYkbvauTiRetYMWEhwSSGdcR0rhAAtZsLcWP70nVEPCoX1XUlBcZyPbknrCUfRcmZdmO6KDVqArpEEdQtBt+YMJF8XAeLwYihqORyCUdhCcbiUkylZXWuJ1MqbMmGqjLZUPl4ovJ0Fw1FhRahb9/+PPzwozz99AyKi4vp2bMX//3vG44Oq0nUKxHJysri+eef59lnnyU2NpalS5dy+vRp3njjDfz8nLt4S2idLBYLf6zayI+f/mQtspSbyTUVUJRmrfftFBZFV79IlCY5CpWSbjfHEze2Ly7umqtsuXYmnYHckynkHD1PYVK6XfKhcFERENuGoO4x+LULF7+uG0gymzEUlWIoKMZQWGx7NF+l+3K5WoXK1wuPQF80/t6YNa6ofbxEdYrQIj3yyON2rydPnsLkyVMcFE3zqVciMmfOHMLCwoiIiADgoYce4u233+aVV17h7bffbtIABeFK2pIyPnvzC47vO2GrijmffhGz2YxSoSA+rANtfYORyWR0Gtyd3uMG4OHneU37MukN5J9KJefYefLPptm1M1Colfh3akNQt2j8OkSgUDl86CanJ0kSJm355WSjoNhWylFXlYrCTYPK2xO1rxcqby/UvtaSjku9iYo7UwSh5arXN+fBgwfZuXMnysrb0QICAnjxxRcZPHhwkwYnCFc6fyKZj+Z+SlFeEWaLGb2biZSLqQB4ubjRP6oL3hp3ont3oM/EwfiG+jd4H2aDkfzTqeQcSyb/TKqtcSuAXKnAv2MkQd1j8O8YiUItko/amPWGyoSjxK6Uo667VOQuatR+3qh9vVH7eqH29Ubl44nCRXRhLwitVb2+RdVqNVlZWbYSEYD8/HxxW63QbCRJYuP3m1nz8Y9YzBZMssqqmFRrVUxb32DiwzvQpktbEu8cQnC7sAZt32w0UXAmjZxj58k7nYqlysVSppDj3yHCmnx0ikQpLop2JLOlstFoMfqCKtUqZXWUTsjl1oaifl5VEg9vFG4aUaUiCDeYeiUi48eP54knnuCRRx4hLCyMrKwsPvzwQ8aPH9/U8QkC5aXlfPa/Lzm6+5i1KkZjISnDeleMQiYnPrwDCT27kzhpKJHd2tb7QmY2msk5dZELe06Rd+oiZoPRNk8ml+HbPpzgbjEEdI4Sg8phTQYNpWVU5BZRlJZzubSjuKTOMVSUHm6Xk43KR5W3h2g0KggCUM9EZPbs2ajVat5++21yc3MJCQlhwoQJPPLII00dn3CDu3A6hY/++wkFOYWYLWZK0ZJZ2TmYp4srN/fsy+j7x9I+sXO9++Uozysmfe9Jsg+dw1ilq26ZXIZPTJgt+VC5tb779evrUlsOfV4hhvxC9HlF6POLsOhq79pcrlZVSTYul3SIgdoEQahLvRIRmUyGm5sbbm5uaDQa3N3d8fPzs7UZEYTGJkkSm9dsZfXytZhNZgySkczSLMoN1gthTGAYj894iF6jEuvVe6HFbCH/9EXS956kMCnj8gyZDJ+2IQR1jyGwSxRqd9emOiSnJUmStROwvEL0+UWVyUcRliolRHbkMlTenrhUqVJR+3mLO1UEQbgm9cokFi1axK+//sr06dMJCQkhPT2dDz/8kOLiYh599NGmjlG4wZRry/li0dcc3nEESZIoM5aRXpKNRZKQy+TccetoHv7ndFzqUWKhLy0n88BpMvadRl9yue8JjY8HMYO706ZvLHrpxqkikCzW9hzWEo5CDHlF6AuKam1AKlMoUPt74+LvizrAB/+oEDT+3pRqDc0cuSAIrVW9EpG1a9fy5ZdfEh4ebpvWt29fpk2bJhIRoVFdPJvKR//9hLysfMwWC/kV+eSXWxuk+vv4MGfBC3SN61LnNiRJojglm/S9J8k9ceHyLbcy8GsfQXjfzvh3iMDH19rYWt9Kb/mUzBYMRSW2Eg59XiGGgmIks7nG5WUqJS7+Pqj9fXDx98UlwLdaWw437xuvxEgQhKZVr0REoVDg4+NjNy0wMJCKitb5BS40P0mS2LpuO9+/vxqz2YzepCdLm0O50VoVM2hoP/756tO4e7jVug2T3kD24STS95ykLKfQNl3p6kJo746E94nF1c+ryY/FESwms7Xx6KXqlfwiDAXFYKl5fBW5WoVLgK816QjwxcXfB6WXh6haEQQH+uyzT0hOTubll18FYOPG33n33bcpLCyiU6dYnnvuxVY5Gn2diUh+fj4Ad955J8888wzPP/884eHh5OTk8OabbzJt2rRmCVJo3SrKdHwy91OOHziJJEloDWVklOZgkSwolUr++vdHuf3OW2q9SJZlF5K+7yRZh85h1l9u1+AZEUh4YmeCukW3qs7GJEmyVq/kFKDLLUCfk4+hsKTWDsHkGhdcAi6Xcqj9fVB6uImkQxCchMFg4KOPlvHppx9xyy23AVBQUMB///tv3ntvOdHRMbz//rvMnfsaS5cuc3C0ja/Ob+eBAwcik8mQKr/gNm/ebPvykiSJDRs2iKoZ4bqc2neSj+evoKysAotkIb+8gLzyIgBCw0N4ef5zdIxtX209i9lC3skU0veepCg50zZdrlQQ3KMdYYmxeIUHNtdhNCmz3oA+twBdTj76nAL0uQW1NiRVuLnakg515aPom0MQ7JlMJvJzCpp0H/5B9b+hY/781ykqKmLixElUVFiHNcjOzsJgMGCpLNWUyWiVI+/CVRKRP/74o7niEG4wZUVaVi78hgN7jyIBepOenIp8tLpyAAYPH8DfX/4bHh72nebpS8rI2HeajAOnMZSW26a7+nkRlhhLaFzHFn3brWSxUJ5bQHlGHoUXs9DnFFi7P6+B3EWNS6AfmiA/a0lHgC9K12sfS0cQbgQmk4knpzxNZlp2k+4nNCKYd7/+X72SkSeeeIqAgECWLXuPigrrD6tOnWKJj0/g/vunVjaP8GXZso+bNGZHqfMMVW2cKgiNwVChZ/+6XWz45jcKy6x3sWiNZWRqczGZTCiVSh6f9TAT7r7NrvStKDmT9D0nyTuVcnmwOZmMgE6RhPftjG9MeL37EXEmpnId+srqFV2utbRDMtXQmFQmQ+3njSbQD5cgfzRBfqJNhyC0EgEB1UtvdTodQUHBLFv2MR06dOKDD5by4ovPsXz5ilb3f996Ks4Fp2Y2mjix+TDbV23mXHomerMJi2RBKysnvSgLgJCwYF767z+J7dYJsI52m3XoLOl7TlKeV2zblspdQ1jvToT16YTG59oGs3MEyWy2NiSt0rbDpC2vcVmluyvqAF80Qf64BFpLPOStqJ2LIDiKUqnk3a//51RVMzVZtepblEol3bv3BODJJ2dw881DOHfuLB06dGysMJ1Ci/lmkySJ//znP5w6dQqNRsPbb78txrppASxmCye3HWPLlxu5mJpJRnEREmC0GCmSacnLtTaIHjC0H/+cMwtPLw+0mfmk7z1J1uEkuzFfvNsEE57YmcCubZHXoxMzR5IkCXNZBbqc/MttO/KLar6LRS7Hxd/HmnQE+RHYLhyVpxslJbpmj1sQbgRKpZLgsCBHh1Gn3NwcTKbL339yuRy5XNEqOxJtMUe0efNm3Nzc+OKLL/jjjz9IT0+nY8fWlRW2JpIkcfHIeQ78sJ3sC1mklxRRVHm7t0ltJjUvC71ej0Kh4JEZDzLx7tvJO5HC2b2bKb54ue5WoVYS3LM94X1i8biGkXSbi/VOFi26rFwqMnPRZeViLq85kVB6uFmrVwL9cAnyw8XfB5nicmKl9hJ9dQjCja5v3368/PK/GDduArGxnfnkk+WEhobSpk2Uo0NrdC0mEdm3bx8ADz30ELGxsYwYMcLBEQm1yTqXzp5VW8k6k4bOaORiUQF6k7Uqxuhu4XzKBQCCggP5579m4F1mYdf/fYOx7PKF2y3Am/C+nQnp1cEpB5y7dAutLvNS4pGHuaJ64iFTKqwNSivbdrgE+qF0Ew1KBUGo26BBQ3jiib/y8ssvUFpaQpcuXXnjjf+hUDh3afC1aDGJSHFxMW5ubnz88cf85z//YfPmzQwbNszRYQlVGHUGtn/+O2d2HgegsLycTG0xZrMFo2SiRF5GTop1wLr4uO7c2bc/RT8foqjy9nCZXEZA5yjCEzvjEx3qVA2yJEnCWFRqK+3QZeZirmEAOLlGjWtIIJrQQDTBAah9vcQos4Ig1Msjjzxu9/quu6Zw111THBRN82kxiYiXlxcJCQkA9OvXj3PnzolExIkUpOXy29K1FGUWYJEsFJgNZBZbeze1aCRSczPR6/TI5XJG9ogjITiSisqkRO3pRlhCJ8ISOuHi5RztfiRJwlhYQkVl0lGRlVfjyLMKjYs16QgJxDU0AJWPl1MlUIIgCM6uxSQi3bt3Z/fu3YwYMYLjx4/Ts2fPa96WJElkFDe8IWBpZTvD0lLna0ToyNjO7z/Nvh+2YzaaMCqU5Jv1FJdWYHHRYPGQuJCaCgoX3P28Gd25B2E+vhQCXhFBhPRqj2+7cOQKOfkScA3vy7Wqes6q9VaaW4BFf+XAbnIUGjUugdbbZ12C/FB6emCWySgDygBKqicr1xOXs3HW2Jw1LnDe2Boal5+fOyCSbKHxySSpln6hnYzRaORf//oXKSkphIeHs2DBgmuuKyupMNLj1V8bOUJBEITW68icUXi5qqpNT0lJQa83EhgY6oCohJYgNzcTFxcVUVE1N7R1eInIsmXLSEpKYt68eQAcOHCAV155hdTUVOLi4pg/fz5BQUGoVCreeOMNB0crCIIgCEJjclgiYjAYWLJkCe+//z4TJkwArD3JzZw5k5deeonhw4czf/585s6dy8KFCxt13+5qBWumJzZ4PU9P690OzlbECs0bW/KfZ9j7/XbMBiMmi4U8i4HigmIskoROVkFGQQ4AbmoXJg4ezIi/jEEV4NvsbScsRiO6rLzLt9NWVK82UVV2HHapt1KFu+MHgxOfs4Zz1rjAeWNraFzu6ppLoJVKJWVlFRiNBlQq57vDTXAsi8WC2WxCLq996A2HJSJz5syhsLCQqVOnUlHZv8SuXbvw8/NjzJgxAMyaNYsBAwag1Wrx8PBotH3LZDLCvBt+C6W3t7V/h2InvAmiOWIzGYzs+HIjp7YewQ3QKSQy8vIw6AzILSaKKvIoKNciB9qFhPL3558i4Za+yGQyiosrmi6wSpIkYSgopiIti/K0LAzZ+cglCXfAHUABCndXXEOD0IQGENQhErW3h9N1HHajf86uhbPGBc4bW0Pjqi1B9/HxoaysjNzcTJRKlcMTecG5mM0mJEnCx8en1mUclojMnj2boKAgFi9eTHp6OmCta4yOjrYt4+npiZeXFykpKXTt2tVRoQpAUVYBv727loK0XCyShFYlkZJqHZxJZ9KRXpKFwWxCBtxx2ygefeEJVOqm/1KyGIxUZORQnppJeVo25vIrEh65HNeQANwiQ3GNCEHlfXl8Fhdv0XGYIFwvd3d3YmJiyM/PtxstVhAA5HIXfHx88PSsfTgOhyUiQUHVu9ctLy9Ho7EvqdBoNLYSE8Exzu09xdaPf8aoN2KwmMmz6MnPst6ai8xIcmEaAF4e7vzrv/8kYUDvJovl0m215ZWlHrqsPLiivbXSww23iBBcI0NwDQ0SY7QIQhNTKpUEBwc7OgyhhXKqb2hXV1f0evt6fJ1OJ8aUcRCT0cSurzdxYtMhAHRyiZT8fAwGIwBdwoIp0hdzMgd6xHXlxbnP4h/g1+hx2Eo9KpMPc9mVpR4yXEMCcY0IwS0yBJW3pygeFgRBaCGcKhGJjo5mzZo1ttelpaUUFxfTpk0bB0Z1YyrOKeT3d9eSdzEHiyRRIjORmm5thOqiVJLYrg09h8URNSyOB0pLCA0PQd5IPYhaezGtLPVIzUKXnQeWK0o93N1wjQyxlnyEBiJXV7+tUBAEQXB+TpWI9OvXj5ycHNavX8/IkSNZtGgRQ4YMESUizez8/tNs+fhnDBUGjGYzmWUlFJdZh6sP9HRnzOj+dLt9EO5BPgCE+1x/Q2KL0WQr9ahIzcJUuT8bmQxNSABulcmH6MFUaO0kSQKTCclotP6ZKh+NBrg0zWhE4eOLKiLS0eEKwjVzqkREo9GwdOlS5syZw4svvkh8fDzz5893dFg3DLPRxO5vt3Dsjz8BKDMZuJifj6my8Vlc5xgm/m0yvlEhjbI/k7acsgvplKdmUpGVB1c0clO4u+IWUVnqERYkSj2EFk2yWGpIJAxIBvsk41KCgdEEXL2/SXNREcrwCJGYCy2WwxORGTNm2L3u2bMnq1evdkwwN7CS3CJ+f+9HcpOzkCSJvHItWSUlAGjUKiY/PI4+tw+67i87U3kFZcnpaJNT0Wfn28+UydAE++MWGWot9fAVpR6C86qaWEiGK5KLKs91ZhMWvQHJZLq+HcoVyFQq2x+Vj0o/f/F/IrRoDk9EBMe7cPAsmz7cgKFCj8FsIrOkmBKdtW+NNtFhPPrqo/gE+lzz9o3lFZScTEJ7PtV6l0sVchc17lFh1oam4cGi1ENwGPuqEGtyUe15lWlcb2KhUiFTqe2SiytfX0o2ZEoVslY4/LsggEhEbmhmk5nd32y+XBVj0JFaVIjRbK0iGXXXCG59YOw1jelj1ukpu5BObmoGpanZdrfYytUq3NuG4x4dgWtYELJGauQqCFeyJReGS8nEFY+255XJxbUOvSWTVUkc1HaJhZuXG3K1mgojyNTWaSiVohRDECqJROQGVZJTxM8LV1GYXYgkSeSXa8msrIpx93TjgX/eR5eEzg3apllvoDwlA21yKhXpOXZf6jKVEveoMDyiI3END0amEMmHcG0kSQKzuTKR0CMZDGjzJSx6PfrS8isSDuO1JxdK5eVSCrW6ludXTyzcKzvOMzRD78KC0BKJROQGI0kSR9ftYu/aXZjNFoxmMxmlRZRUWKtiYrpE89BzD+Bbz6oYi8FI2cUMys6nUZ6eZXebrUypwKddJD6d2iL5+iJXiqJloXaSZLGWTFxKJPR6+5KLyqRDMhiqNWyuPopQLeySicpEwvZcbZdciJI6QWgeIhG5geSfS2fbxxvIzrT2ilpm0JNeWoy+soOymycN5/YHbkVxlYTBYjRRnpqJ9nwqFWlZSObLFwWZQoFbm1DcoyNwiwzB19/arW9zjDUjOCdJkqonE3p9lddVEoxroVShdHVB7uKCWa60TybUVyQYMpFcCIKzEYnIDUCbVcCJH3dw8sA5dAbrAERFRh1pBQUggZuHG/f9/R669619PB+LyUx5aiZlyWmUX8xEMptt82QKOa4RIXhER+LWJlR0qX6DuNz+Qo9Fr69MLmpKNK4hwZDJkKldLicStj+XK5ILa8mFbQA3kfAKQosjrhitWEVhKcl/HOD83pNkFZRhtkgYzWbyJT25+dZSkbadopj2/AP4BVfvml0ymylPy6YsOZWyi5lIxip3CchluIWH4B4TgXubMHG3SysjWSyXE4lLCYZeT6FkxqzTYSyrQDLoq1WRXJVcbp9QuFgf5bYEw/ooGnMKwo1DJCKtkEFbwYUth0jfe5K8wjIKtNb2HzrJTHp5MeVa66/Gm+4YyviHbkdZpQRDkiQq0rPRJqVSlpJun3zIZLiGBeERE4lbVBgKF3WzHpfQOCTJgqQ3IOl11iRDf6lEQ2dXqlETY20blcmqJBYudomGXCQYgiDUQSQirYhRZyB545+k7jiGvkJPZoGWisqqmDIVXEjLRpIkXN013Pv0X+g5oIdtXbNOT+mZC5ScOo+ptOzyRmXgGhqEe3QE7m3DUWhcHHBkQn3Z2mPYJRmXn19KNBpEobAlGC6ebig0GgzS5WlyFxdrI1CRYAiCcA1EItIKWMwWkrYc5vQv+zFoKyjTGckqKsNc2YhUCnQn+ehZANp0iGTaCw8SEOKPJEno8wopOZlE2flUu0anmuAA3GMicY8OR+mqcchxCdVJFos1ydDprKUYOh2SXoel8lHS6xt2u6pSidxFY00qbH8aa1WJiwsyFzUyxeWvCdEWQxCExiYSkRZOX1LG8ZWbKb5g7Zq9oExPfrF1wDi1mws3PXwLx46e5cSxcwy5fRATHh6PQg4lZ5IpOXkeQ16hbVsylRLPDm3x6hyD2sfLUYd0Q5PMJowlJZjLKzAWlFiTjCoJR4MafiqU1qqRKgnG5deVyYforVMQBAcTiUgLVnAunROrNmMs02EyWyiySBRUJiGB0SHc/PjteAX6ENWrPTdPGo7CaKTk4HFKz1zAYrhc26/288arczs82rURd7w0MclisZZm6CqsyYVOZ6060VVg0enAaKT86psBsLa70FSWYGg01uRCo7lcwqEU76UgCM5PfFO1QJLFQvKmg6RsOQQS6CWJHK2eispGqN1ujqff5GEolAoki0R5aiYlJ5OoSM++vBG5HI/oCLw6x+ASJAbNaizWNhp6pAprYiFVJhyWyqSj3u0z5PLL1SSXkgwXF7vnosMtQRBaA5GItDD60nJOrNxMUXKmtRGqXEFmRj6SJKF2c2Hog6OJSeiEuUJH4bEzlJ5KxlR2+Te20t0Nz84xeHVsi0K0/bgml9ppWCoqKhOOKo86XT1vaZVZSzM0GuQa18slGRpXvIN8kLu4UFKia/JjEQRBcDSRiLQgheczOLFyMwZthbUqRoKCDOtotsExodz+9ESMpeXkbN6DNjnNrrt114hgvDq3wy0iFJlclH5cjWQ225ILS0WFteqkMvGQ9PVLEGRqNbJLSYbGmmRYHytLNGrp5VOhEQmiIAg3DpGItACSxULKlsMkbzoIkoRegmytDl1l/yBdhvYkYVBHcn7fRUXu5cancrUKz45t8ercDpWXh6PCd1qSxYK5ogJTQSFSeTmWivLKZKPcevfJ1chkl0s0XF3tHzUa0RBUEAShHlpcIrJy5UpSUlL4+9//7uhQmoVBW8GJVZspTMpAkiTK5QoyMvORLBIqFxVxA2PxsZSTuXm/bR11gC/endvhHhN5ww80Z+tXo0qSYamowFJeTpmu4uq3usrlyF1draUZVzzKNLWXagiCIAj106ISkYqKCpYvX87NN9/s6FCaRdGFTI5/uxlDaTlms4VCSWarivHydqVbO3/c9VokrOO9+MZGo2kXhSawenftrZ0kWZAqdFjKy7CUlyNVPloqyqHKuDg1ksmsJRmubtYkw9UNuasbMldXa/WKaMgrCILQZFpUIvLRRx9x++23U1HRujtTkiwSF7cd4fwfByqrYiS7qpjwYE86RfuhUMhRerrj1TmG8N6dUbq6tPqOpiSLGam8wpZw2BKPivKrlm7IXFxsSYbczRUPfx+UHu5ojYiSDUEQBAdpMYlIXl4eycnJ3HXXXWzbts3R4TQZQ5mOk99toeBsmvWuGJmczMxCJElCIZfRuV0AoUEeuLUJxatzO1zDg5HJZChdW1fX65LFbE00ysoul26UlSHprpJoyeXW0gw3N+Ru7sjd3JC7uVmrUq5os6Gp7CVU1sqTN0EQBGfWYhKRJUuW8Pjjj5Ofn+/oUJpMUUo2J77dhL6kDLPFQoHeRGGBFgAPNxU9e4QTFheLZ2wMKk93B0fbOCRJsvazUabFUlZmLeHQapEqKoA6SjgUCluiIbMlHO7WRqKiKkUQBKHFaDGJyOHDhzl37hwlJSUUFxeTmJjIkCFDHB1Wo5AsEqk7j3L+t/1IFgm92UJWQSl6g7VtQ3iIF30nDsS/VyzyFtxbpmQ0WpMNW9JhfayzDYdShdz9cqJxKfEQbTcEQRBaB5kkNWSELMfbs2cP27Ztu667ZiRJwmi8SgPGGigr70AxmRq+bm0MZToOfP472ccvIEkSpXoT2QWlSBLI5TL6juhB/wfGXLXqpSliu1aSJFnHSikuxlxaiqG4BENxibUL89rI5ag8PFB6eaLy8kTp6YnKywu5S9MlHM50zqpy1rjAeWNz1rjAeWNraFwqlUIk/0KTcHgismzZMpKSkpg3bx4ABw4c4JVXXiE1NZW4uDjmz59PUFBQo+7TWRKRguQs9n3yCxWFpZgtFvJLKyjSWvuv8PJxZ/w/JhEaG+WQ2OpLkiTMZWUYikswFhdjLCrBWFKMZDTVuo7CzRWVp2dl0uGF0tMTpbtbs3dZ3louEM3JWWNz1rjAeWMTiYjgLByWiBgMBpYsWcL777/PhAkTmDdvHjqdjhEjRvDSSy8xfPhw5s+fT0FBAQsXLmzUfVssEvn52gav11hDoEuSRNqu4yT9shfJIiGTQU5JOYWVXXq3692BoQ+PRaVRN3tsdZEkC1J5OWatFou2FEtpKZYybe1VK3I5Km8vVN5emJQa5B4e1nYcTlK95KxD2jtrXOC8sTlrXOC8sTU0Ln9/D+SiV2ahCTjsijBnzhwKCwuZOnWq7XbcXbt24efnx5gxYwCYNWsWAwYMQKvV4uHROnoGNVboOfHtJgrOpQOgUskJCHTDqFFRbpLoO3kYsYO7O/yXh7URaQXmkhIspSWXk47axlFRKJB7eCL38EDh4YncwxOZmxs+Pm6A830JC4IgCM7BYYnI7NmzCQoKYvHixaSnWy/KKSkpREdH25bx9PTEy8uLlJQUunbt6qhQG01hUhrHv9mEscIAgLu7ipD2wQT07UGniBAAhyUgksmEpbSkMvEoxlxSCiZjzQsrlcg9PCsTDg/knp7W22NFsa0gCILQQA5LRGpq91FeXo7migG/NBpNi+/AzKw3cG7NVjKOpgAgk0FAmDdRN/fBo12bZr+AS5KEVF5mK+0wl5QglZfVvLBCicLLE7mHF3JPa+IhcxG3yAqCIAiNwzkq6yu5urqiv2KwMZ1Oh7t7y+wzw2IyU3j4NOd+P0C51loKolIraD+8F8H9ujfboGiS0Yi5pBhLSQnmUmvyUVu7Drm7O3JPb+ReXii8vJC5uomkQxAEQWgyTpWIREdHs2bNGtvr0tJSiouLadOmjQOjajjJIqE9l0LmjkNkXyzEZLK2q/CJ8KfbPaNQebg17f6NRszFRZiLi7AUFVnbdtREpULh5Y3c05p0yD08naYhqSAIgnBjcKqrTr9+/cjJyWH9+vWMHDmSRYsWMWTIkBZTIiJJEuUXM8nfd5TC1DwKCqx3wcjkMtqP7kN4/25NUrogGQ1UZBZjyM+nIifP2knYlWSyyvYc3takw9NL9EIqCIIgOJxTJSIajYalS5cyZ84cXnzxReLj45k/f76jw6qXisxcCvYfpSIrn/z8CsrLrA09NT4edPvLzXiG+jfaviSDwVbiYS4qQiovo/zKhWQya/WKtw8Kb1/kXl7NVhUkCIIgCPXl8ERkxowZdq979uzJ6tWrHRPMNdAXFFG4/xjlqVkYDGZyc8ptVTFB3aLpNH4Qygb0B1ITyWTCXFiAuciafNTYsFQuR+3rg+TuhcLHx1riIRIPQRAEwck5PBFpqSRJIn/PYUqOn0OSJLRaI4UFOiRJQqaQ0+GWvoQldr6mqg9JkpDKyjAV5mMuyMdSUlJ9iHuZ3Fri4eODwtsH34hgZAqF6K9DEARBaFFEInKNJJOZkuPnsFgkikpNlBZaEwCNryfd7h6OZ3hAA7dnwlxUiLkgH3NBAZLB/u4ha1WLNwofXxTePsi9PJHJL5d4iNIPQRAEoSUSicg1kquUePXpydlfD6ArtrbQCOzSlk4TBqG6ygB1cLkvD1Nl4mEpKa5W6iFz0aDw80Ph54/CxweZQrxdgiAIQusirmzXKPPPM5xZtxOL0YxMIaf96ETC+3WpsyqmXqUe3j4oK5MP0YeHIAiC0NqJRKSBTAYjJ7/fStbBs4D1rpiudw/HKyKwxuUlkwlTfh7m3BzMhQU1lHq4WEs8fP1Q+PiKfjwEQRCEG4q46jVAaXYhez/aQGlmAQABsW2InTikWlWMZDZhzs/HlJuDuaAApCoDxV1q6+Hnj9LPH5mbKPUQBEEQblwiEWmAvR/+RGl2ITK5jJhRfYgccLmDMslsxlxwKfnItx+lVi63Jh4BgdYqF1HqIQiCIAiASEQaJKBDOAoXFTGjE/FuE4xkMWPKL7AmH/n5YKkyfotMhsLXD2VgEAr/AJF8CIIgCEINxNWxAXpOHoZksVBwIR39qROY8vPsB4+Tyay31wYGoQwIQKZUOS5YQRAEQWgBRCLSANqk85SePYdkNNlNl/v4ogwMQhkQiEwlkg9BEARBqC+RiDRAWfIFWxIi9/a5nHyor68Ld0EQBEG4UYlEpAF8E3pjKi1F7+KB3OXqnZYJgiAIglA3kYg0gNrHG7WPN0YxnosgCIIgNAq5owMQBEEQBOHGJRIRQRAEQRAcRiQigiAIgiA4TItpI1JeXs7TTz+NVqslICCAN998E6XoJEwQBEEQWrQWUyKyZs0aBg8ezOeff05UVBSbNm1ydEiCIAiCIFynFlOkMG7cOBQKhe21WvTdIQiCIAgtXospEXF3d0ej0XDkyBH27t3LoEGDHB2SIAiCIAjXqcWUiAAcPnyYV199laVLl9qVjgiCIAiC0DK1mBKR9PR0WxISHBzs6HAEQRAEQWgEMkmSJEcHUR//+c9/2Lx5M6GhoQDcf//9jBw58pq2JUkSRqP56gteQam0lsKYTA1ft6k5a2zOGhc4b2zOGhc4b2zOGhfUHpvtq1eSbH8Skv1rSQKueF1lmlRl2UvbqnUZJJDJUfkEIFepGnzOVCoFMpns+k+IIFzB4YnIsmXLSEpKYt68eQAcOHCAV155hdTUVOLi4pg/fz5BQUGNuk+RiDQfZ40LnDc2Z40LnDM2SZKscUkWTEaT/cW52sX60mtL9XlXu9DXlihU2/al7YMkWS4FaX0uSSBxeR8OoPIPxiUwVCQigtNwWCJiMBhYsmQJ77//PhMmTGDevHnodDpGjBjBSy+9xPDhw5k/fz4FBQUsXLiwUfdtsUjk52sbvJ63tysAxU441oyzxuascYHzxuZ0cVX5te3l5YJkkSgtKa+cZrG7cFuvrRZkV1zQq/6qv7xN+4s4kmRdr8Z1apsGMgdd0B1FApDJAFnlY5XXyKwPtnn2ryWZHMkzAJTqBn/O/P09kMtFIiI0Poc1Vp0zZw6FhYVMnTqVigrrP8KuXbvw8/NjzJgxAMyaNYsBAwag1Wrx8PBwVKiC4Bh2F1xL9YtylSTAduGvc/krL/hVlqntwn9p+5UhlWVbH1tyU3Fr2lJ5oa7hYl3tseqFvNoy1LCO/fZdXdUgk1FRYURqyLo1JhpcniYIrYTDEpHZs2cTFBTE4sWLSU9PByAlJYXo6GjbMp6ennh5eZGSkkLXrl0dFapwI7P9grdUu/hXvdjL7C78V1zg7RKGKy/+Vy4roc2yrtMSL/ZStQt81Qv6pQup3O7Ce/V1qk+7ch0PDxeQydCWGerYBlXmNR9VZclDOU5SwiUITsZhiUhN7T7Ky8vRaDR20zQaja3ERBBsqiYDlspHu+TgUvXAFQlElUedVo5ksSA3mupMNJz596fdBdnu4iuHK+bZX7zlNaxj/1qq4WLu4emKTCajVGuoIVHAYb/WFW7Wiz2GFnMjoCAIlZyqHxFXV1f0er3dNJ1Oh7u7u4MiEq6LJCFZLEgWM5gMVS70lsuJgsVSZZpk91xWy3TbutfJVPl4PZdOW319tQu/3O6iL105nZqWs9bhu7u7gFxGWbmx+nI1lhQ0H4Wm8oKvu7HaZQiC0HScKhGJjo5mzZo1ttelpaUUFxfTpk0bB0Z1A7lUElA1ObBcShosVyQNV8yzm385cSjLsm66OasZpGoXeftHqfJR7aJCJpOjN5jtE4IrlrNPNKov19iUnpUXe5MoCRQEofVzqkSkX79+5OTksH79ekaOHMmiRYsYMmSIKBGpB0mSwGIGkxEk8+UkwWKukiRcfl4tsahcrjl+X1tLEeRXJAhykFufS1dOv+J57fMblhxoKuvudc5yd4ogCMINyKkSEY1Gw9KlS5kzZw4vvvgi8fHxzJ8/39FhNZ9LJQkWc+WfBZl0+TmVz2W255eTiLJMa38FTVHyINld9OUgl1dJGC6/tksWKqd5eLqCXI5Wa7QlGo6oUhAEQRCck8MTkRkzZti97tmzJ6tXr3ZMMI3pUglFlT/ZpefSFa9t0xu3RMKaQCguJwpyOZJMYZ88yBWXkwp59WTjeqsfFK6X2hQ00kEJgiAIrYrDE5GWRJIkJKMBDOVgNiOzmKokGZXPzWawmKxVH9e7P6hMFCqTCbmiMmFQ2BII5AokuRx3D1dkCgXaMuPleaLUQRAEQXByIhFpAF3aecxlpddU/WGXQMgVSFWeI7v0Wm43za7vhatQuleWPOhFewdBEASh5RCJSANIlsulHJcTCyUoFEhy5RWJhv1rUTohCIIgCNWJRKQBXNu0RzIZKS0zVja6FARBEATheoiraQPIZDLkKrVIQgRBEAShkYgrqiAIgiAIDiMSEUEQBEEQHEYkIoIgCIIgOIxIRARBEARBcBiRiAiCIAiC4DAiEREEQRAEwWFkkiRJjg6iuUmSxLUc9aU+yZzxjDlrbM4aFzhvbM4aFzhvbM4aFzhvbA2Ny9rRs+iYUWh8N2QiIgiCIAiCcxBVM4IgCIIgOIxIRARBEARBcBiRiAiCIAiC4DAiEREEQRAEwWFEIiIIgiAIgsOIREQQBEEQBIcRiYggCIIgCA4jEhFBEARBEBxGJCKCIAiCIDiMSEQEQRAEQXAYkYgIgiAIguAwIhERBEEQBMFhRCJSh61bt3L77bcTHx/PhAkT2LdvHwC///47N998M3FxccycOZOysrJmjeubb75h+PDhxMXFcd9995GUlOQUcV1y7tw5unfvTlpamtPEtXDhQrp160ZcXBxxcXH07dvXaWLLzMzkkUceITExkdGjR7NlyxaniG3t2rW283Xpr1OnTvz4448Oj23v3r22/80777yTw4cPA44/Z5s2bWLs2LHEx8fzyCOPkJmZ6fC4li1bxnPPPWd7XVcs33zzDYMHD6Z3797MmTMHs9ncbHEKNzBJqFF+fr7Uu3dvafPmzZLZbJbWrFkj9enTR0pLS5Pi4+Olffv2SWVlZdJf//pXacGCBc0W17Fjx6TExETp3Llzktlslt5++21pypQpUlZWlkPjusRoNEqTJk2SOnbsKKWmpjpNXI899pj0448/2k1zhtjMZrM0duxYaenSpZLJZJI2b94s9erVyyliu9Knn34q3X333Q7/HzCZTFJiYqK0fft2yWKxSF988YV00003OfycpaSkSD169JB+/vlnyWAwSO+++640btw4h8Wl1+ul//3vf1KnTp2kZ599VpKkuj/zR48elfr16yedO3dOKigokO6++27pyy+/bPI4BUGUiNQiKyuLW2+9laFDhyKXyxk3bhwymYwffviBPn36kJCQgJubGzNmzOD7779vtri6du3Kxo0badeuHUVFRZSUlODr68tvv/3m0Lguef/99+ndu7fttbPEderUKWJjY+2mOUNsf/75JyaTiccffxyFQsHQoUP56quv+Pnnnx0eW1UZGRm88847zJ8/n02bNjk0tuLiYoqKijCZTEiShEwmw8XFxeHv57Zt24iPj2f06NGoVCoee+wxLl68yHfffeeQuObMmcPp06eZOnWqbVpd52j9+vXceuuttGvXDl9fXx599FGHfuaEG4dIRGrRpUsXXn31Vdvrw4cPU1FRQUZGBtHR0bbpbdu2JT8/n6KiomaLzd3dna1btzJgwABWr17NzJkzuXDhgsPjOnXqFBs2bGDWrFm2ac4QV3FxMVlZWbz55pv079+fyZMnc+jQIaeI7dSpU0RHR/PSSy/Rr18/Jk6ciFarJTU11eGxVbVo0SImT55MVFSUw8+bn58fkydP5tFHH6Vbt2688cYbzJ8/3+FxWSwWNBqN7bVMJkMul7NhwwaHxDV79mzee+89/Pz8bNPqOkdXzouKirJV+wpCUxKJSD2kp6fzt7/9jVmzZiGTyey+bFxcXJDJZOh0umaNqV+/fhw5coSHH36YJ554grKyMofGZTAYeP7553n11Vft4qioqHD4+crPzycxMZHp06ezZcsW7rrrLh577DGHnzOAkpIStm7dSo8ePdi2bRvTpk3jr3/9q1PEdkl2djZ//PEHDz30EOD499RkMuHi4sIHH3zAoUOHmDVrFn/7298cfs4GDRrE7t272bFjB0ajkQ8//BCdTkd5eblD4goKCqo2ra73rqKiAhcXF9s8V1dXh3zehBuPSESu4tSpU9x9991MmDCBadOm4erqil6vt83X6/VIkoSbm1uzxqVWq1Gr1bYLamFhoUPjWrJkCYmJiXbVMoBTnK+YmBhWrFhBQkICarWau+66i6CgIPbu3evw2NRqNZGRkdx1112oVCpuu+02goKC2LNnj8Nju+Snn35i8ODB+Pv7A45/T3/99VdSUlIYOnQoarWaBx54ALVa7fD3Mzo6mjfeeIP//Oc/DBs2DJPJRPv27VEoFE7zXtb13mk0Grt5FRUVDolRuPGIRKQO+/fv57777uOJJ56wVTdER0eTkpJiWyY5OZmAgAC8vLyaJaYNGzbwzDPP2F5bLBZMJhODBw92aFy//PILq1atIiEhgYSEBADGjRuHj4+PQ+MCOHr0KJ999pndNIPBwP333+/w2Nq2bYtWq7Wb9v/t3WtIVO0aBuDbw1j9KAxMUyJDavpCQWecBgq0VDRNOw3CJCqFHREiEkKTTvonkQiULLP+lWVWlJYHyhLRSpsxoyiVMs1TeZYSYzzMs39Ew3ZvvnZflMt29wXCrGctXm/fxYLHteadsVqt2LZtm+LZvqqqqkJYWJhtW+lroKenBxMTE1NqKpUKCQkJiuYaGRmBl5cXysrK8PDhQ8THx6OtrQ0bN26cMefyW+fuP/e1tbXBy8tr2jPSn4eNyN/o7e1FYmIiUlNTERsba6uHhISgrq4OdXV1GB0dxenTp7F+/fppy+Xj44PKykrU1tZifHwcWVlZUKvVCA4OVjRXeXk56uvrYTabYTabAXxZ/hkdHa1oLuDLf4GnTp3CkydPMDk5iYsXL2JsbAzr1q1TPNvq1asBfFliabVaUVRUhIGBgRmRDQBEBC9evICvr6+tpvQ1sGrVKpjNZlRUVMBqteL69esYHh5GUFCQorkGBwcRExODtrY2jI6OIjMzE3q9fkZcA19969xFRETg9u3baG5uxvDwMM6fP69YTvrDKLRaZ8Y7e/asqNVq8fPzm/JjMpmksrJSwsLCRKvVyv79+2V0dHRas1VWVkp4eLjodDrZu3ev9PT02OpK5vp3X5fvzpRcJSUlEhYWJr6+vmI0GqWpqWnGZHvz5o3ExcWJVquVqKgoMZlMMybb0NCQqNVqsVgsU+pKZystLZWIiAjRarViNBrl5cuXMyLX1atXJTAwUPz9/WXfvn0yNDSkeK7s7Gzb8t3/laWwsFCCgoJEp9NJWlqaTExMTFtO+nPZiYgo3QwRERHRn4mPZoiIiEgxbESIiIhIMWxEiIiISDFsRIiIiEgxbESIiIhIMWxEiIiISDFsRIimmcViQW9vr9IxiIhmBDYiRL9Yd3c3NBoNBgYGAAAxMTEwmUwKpyIimhkclQ5A9P/Ow8MDDQ0Ntu3p+lp6IqLfAe+IEP0DLS0t2LFjB/R6PcLCwpCfnw8ASElJwdGjRxETEwM/Pz8YDAZb89HZ2Ynly5ejr68PO3fuRHd3N1JSUpCdnQ0AqKiowObNm6HVahEZGYmioiLb74uPj0dmZiY2bNgAjUaD+Ph4vH371rb/2bNn2Lp1K3Q6HSIjI1FeXm7bV1tbi82bN0On0yEiIgJ5eXnTMUVERP+M0p8xT/S7GBkZkcDAQMnJyZGxsTF5/fq1hISESHFxsSQnJ4u3t7fcv39fxsbG5Ny5c6LX62V4eFg6OjpErVZLb2+viIgEBQXJnTt3RETk0aNH4uPjIw8ePJCJiQmpq6sTf39/qaioEBGRuLg40el08vTpU7FYLJKWliahoaEyMTEh79+/F41GIzdu3JDx8XGpr68XvV4vZrNZREQCAwOlpKREREQaGxvFz89PGhsbFZg5IqK/xzsiRN+pqqoKjo6OSExMhEqlwtKlS7F9+3ZcvnwZABAaGorg4GCoVCrs2rULs2bNQnV19TfHvHnzJiIiIhAUFAQHBwfo9XoYjUZcu3bNdozRaIRGo4GTkxMOHjyIrq4uPH/+HMXFxfD29obBYICjoyO0Wi0MBgOuXLkCAJg3bx5KSkpQXV2NJUuWoL6+Hn/99devmyAioh/A94gQfaeuri58+PABOp3OVrNarXB2doanpycWL15sq9vZ2WHhwoXo7+//5pgDAwPw8/ObUlu0aBFqamps256enrbXc+bMgbOzM/r7+9Hd3Y2GhoYpeSYnJ+Ht7Q0AyM3NRXZ2Ng4dOoSPHz8iPDwcR44cwdy5c3/o7yci+hXYiBB9Jzc3Nyxbtgy3bt2y1QYHB2GxWJCVlTVlSa7VakV3dzfc3d2/OaaHhwc6Ojqm1Nrb2+Hi4mLb7unpsb0eHR3F0NAQ3N3d4ebmhjVr1iAnJ2fKsQ4ODrBYLGhra8OJEydgb2+PpqYmJCUl4cKFCzhw4MCPTgER0U/HRzNE32nt2rXo6+tDfn4+xsfH0dfXhz179tjedFpaWgqTyYTx8XHk5ubCzs4OAQEB/zWOSqXCp0+fAAAGgwFlZWWorKzE5OQkTCYTCgsLsWXLFtvxBQUFaG5uhsViQUZGBtRqNby9vREVFYXHjx/j3r17sFqtePfuHWJjY1FQUAA7OzskJSXh0qVLsFqtcHV1hb29PebPnz89k0VE9J3sRESUDkH0u2hubkZGRgZevXoFe3t7hISEIDU1Fenp6ejv78fnz5/R2NiIFStW4NixY1Cr1ejs7ERISAhqamqwYMEC5OXl4cyZM4iOjsbhw4dx9+5d5OTkoL29Ha6urkhISIDRaATwZdWMi4sLWltb0d7ejpUrV+L48eO2Oy0mkwknT55ES0sLZs+ejU2bNiEpKQkODg4wmUzIyMhAa2srnJycEBUVheTkZKhUKiWnkIhoCjYiRD9BSkoKnJyckJ6e/lPHjY+PR0BAAHbv3v1TxyUimin4aIaIiIgUw0aEiIiIFMNHM0RERKQY3hEhIiIixbARISIiIsWwESEiIiLFsBEhIiIixbARISIiIsX8Cw40JM4UXyxXAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## range of full signal at all rounds across c cassettes and \n",
    "ax = sns.lineplot(data = df,\n",
    "                  x = 'epitopes',\n",
    "                  y = 'bcs', \n",
    "                  hue = \"sites\")\n",
    "title = \"Epitope hungry integrated lin -- num of combinations generated from $n$ epitopes split into $c$ cassettes\"\n",
    "\n",
    "ax = plot_params(ax, \n",
    "                 title,\n",
    "                 threshold = [threshold_y2, threshold_e11],\n",
    "                 varied_by = \"$c$ cassettes/locations\")\n",
    "\n",
    "\n",
    "hide_toggle()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c7ab393",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Conserving epitope usage \n",
    "Harder :)\n",
    "\n",
    "The probability of any *specific* combination is $P^{k}$.\n",
    "\n",
    "1. At $c$ sites, there is a probability $P$ of expression. \n",
    "2. For $n$ epitopes, the chance of a combo of $n$ (e.g. all expressed, and $k=n$) is $P(bit)\\cdot n$\n",
    "3. For $n$ epitopes, the chance of a combo of $0$ (e.g. none expressed, and $k=0$) is $(P(bit)-1)\\cdot n$\n",
    "\n",
    "Eg for 10 epitopes, $ P = \\frac{1}{3}$, a combo of 10 is \n",
    "    $$\n",
    "       \\frac{1}{3}^{10} = \\frac{1}{3^{10}} = \\frac{1}{59049} \\approx 0.0000062\n",
    "    $$\n",
    " And for a combo of 0 (no expression):\n",
    " $$\n",
    "      \\frac{2}{3}^{10} = \\frac{2^10}{3^{10}} = \\frac{1024}{59049} \\approx 0.017\n",
    "  $$\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95cb7dfa",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "For a set of epitopes $n$ (here this is the number of ORF shifters integrated total) each epitope has an expression probability $P$ -- random chance in an ORF-shifter system of being turned on. \n",
    "\n",
    "The probabilty of a set of length $k$ being expressed is:\n",
    "$$ P^{k}\\cdot (P-1)^{n-k}$$\n",
    "\n",
    "The total number of barcodes potentially generated is the number of potential combinations e.g. \n",
    "$$P^{k}\\cdot (P-1)^{n-k} \\cdot  {n \\choose k}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "2cff9e86",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "## ok let's do the math guys!!!!\n",
    "# set variables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "9afd8be1",
   "metadata": {
    "code_folding": [
     2,
     5
    ]
   },
   "outputs": [],
   "source": [
    "## actually we can re use this! and then just generate probabilities on top of the thing we already have ookkkaaayyy!\n",
    "\n",
    "def vary(n,k):\n",
    "    return comb(n, k, repetition=False) #combine without repete\n",
    "\n",
    "def make_combinatorics(n = range(0,60,1), k = range(1, 20)):\n",
    "    ks = k\n",
    "    dfs = []\n",
    "    for k in ks:\n",
    "        df = pd.DataFrame(data = {'n':n})\n",
    "        df['k'] = k\n",
    "        df['num_unique'] = df['n'].apply(lambda n : vary(n, k))\n",
    "        dfs.append(df)\n",
    "    df = pd.concat(dfs)\n",
    "    df = df.reset_index().drop('index', inplace=False, axis=1)\n",
    "\n",
    "    return df\n",
    "\n",
    "def prob_specific_combo(p, k):\n",
    "    return (p**k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "5d2fce51",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = .7 #prob. of epitope expressing\n",
    "n = 40 #number of potential epitopes\n",
    "\n",
    "df = make_combinatorics(n=range(1,n+1,4), k = range(1,n+1,4))\n",
    "df = df.query(\"num_unique > 0\").copy()\n",
    "df['p'] = p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "70eba8d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "df['prob_individual_len_k'] = df.apply(lambda x: prob_specific_combo(x.p, x.k), axis=1)\n",
    "df['num_possible'] = df['prob_individual_len_k']*df['num_unique']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "b4727ac4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>k</th>\n",
       "      <th>num_unique</th>\n",
       "      <th>p</th>\n",
       "      <th>prob_individual_len_k</th>\n",
       "      <th>num_possible</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>n</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>0.7</td>\n",
       "      <td>0.700000</td>\n",
       "      <td>7.000000e-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>6.000000e+00</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.868070</td>\n",
       "      <td>3.668070e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>15</td>\n",
       "      <td>1.360000e+02</td>\n",
       "      <td>2.1</td>\n",
       "      <td>0.908424</td>\n",
       "      <td>2.751717e+01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>28</td>\n",
       "      <td>2.016000e+03</td>\n",
       "      <td>2.8</td>\n",
       "      <td>0.918113</td>\n",
       "      <td>2.542686e+02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>45</td>\n",
       "      <td>3.289600e+04</td>\n",
       "      <td>3.5</td>\n",
       "      <td>0.920439</td>\n",
       "      <td>2.055975e+03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>66</td>\n",
       "      <td>5.237760e+05</td>\n",
       "      <td>4.2</td>\n",
       "      <td>0.920997</td>\n",
       "      <td>1.728141e+04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>91</td>\n",
       "      <td>8.390656e+06</td>\n",
       "      <td>4.9</td>\n",
       "      <td>0.921131</td>\n",
       "      <td>1.442968e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>120</td>\n",
       "      <td>1.342095e+08</td>\n",
       "      <td>5.6</td>\n",
       "      <td>0.921164</td>\n",
       "      <td>1.204774e+06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>153</td>\n",
       "      <td>2.147516e+09</td>\n",
       "      <td>6.3</td>\n",
       "      <td>0.921171</td>\n",
       "      <td>1.006397e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>190</td>\n",
       "      <td>3.435961e+10</td>\n",
       "      <td>7.0</td>\n",
       "      <td>0.921173</td>\n",
       "      <td>8.405194e+07</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      k    num_unique    p  prob_individual_len_k  num_possible\n",
       "n                                                              \n",
       "1     1  1.000000e+00  0.7               0.700000  7.000000e-01\n",
       "5     6  6.000000e+00  1.4               0.868070  3.668070e+00\n",
       "9    15  1.360000e+02  2.1               0.908424  2.751717e+01\n",
       "13   28  2.016000e+03  2.8               0.918113  2.542686e+02\n",
       "17   45  3.289600e+04  3.5               0.920439  2.055975e+03\n",
       "21   66  5.237760e+05  4.2               0.920997  1.728141e+04\n",
       "25   91  8.390656e+06  4.9               0.921131  1.442968e+05\n",
       "29  120  1.342095e+08  5.6               0.921164  1.204774e+06\n",
       "33  153  2.147516e+09  6.3               0.921171  1.006397e+07\n",
       "37  190  3.435961e+10  7.0               0.921173  8.405194e+07"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby(\"n\").agg('sum')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "c571b950",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## the ful range of varying n, constrained k\n",
    "ax = sns.lineplot(data = df,\n",
    "                  x = 'n',\n",
    "                  y = 'num_possible',\n",
    "                  hue = \"k\")\n",
    "title = f\"for probability {p}\"\n",
    "\n",
    "\n",
    "ax = plot_params(ax, \n",
    "                 title,\n",
    "                 threshold = [threshold_y2], \n",
    "                 varied_by = \"$k$ values\")\n",
    "\n",
    "\n",
    "# hide_toggle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2da08d09",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0a17ba66",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "## Poisson distribution\n",
    "\n",
    "\n",
    "This math assumes no replacement -- i.e. we are only counting the number of sets of length $k$, not any of the other potential sets generated in a Poisson distribution of $k$ delivered to each cell.\n",
    "\n",
    "* CasTag is a controlled length $k$\n",
    "* original episomal delivery is Poisson (requires delivering 20 and only 20 viral genomes/cell from a pool of 40)\n",
    "    * if we are *including* voxels of varying $k$, diversity increases, but introduces dropout confound of dropout -- is this a 5-bit cell, or a bad round of antibody staining?\n",
    "    \n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5776d7d4",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# $n$ choose $k$ without replacement (sets with exactly $k$ unique elements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ce3ec48",
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def vary(n,k):\n",
    "    return comb(n, k, repetition=False) #combine without repete\n",
    "\n",
    "def make_combinatorics(n = range(0,60,1), k = range(3, 20)):\n",
    "    ks = k\n",
    "    dfs = []\n",
    "    for k in ks:\n",
    "        df = pd.DataFrame(data = {'n':n})\n",
    "        df['k'] = k\n",
    "        df['num_unique'] = df['n'].apply(lambda n : vary(n, k))\n",
    "        dfs.append(df)\n",
    "    df = pd.concat(dfs)\n",
    "    return df.reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e484e549",
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "## df test\n",
    "df = make_combinatorics(n=range(5,40,1), k = range(3,40,1))\n",
    "df.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41752656",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# variable $n$, constrained $k$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3566bed8",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "df = make_combinatorics(n=range(1,40,1), k = range(1,25,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36d1dd51",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "## the ful range of varying n, constrained k\n",
    "ax = sns.lineplot(data = df,\n",
    "                  x = 'n',\n",
    "                  y = 'num_unique', \n",
    "                  hue = \"k\")\n",
    "title = \"Unique sets of length $k$ across total pool of barcoding elements $n$\"\n",
    "\n",
    "ax = plot_params(ax, \n",
    "                 title,\n",
    "                 threshold = threshold, \n",
    "                 varied_by = \"$k$ values\")\n",
    "\n",
    "\n",
    "# hide_toggle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4982daf9",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# ax = sns.lineplot(data = df,\n",
    "#                   x = 'n',\n",
    "#                   y = 'num_unique', \n",
    "#                   hue = \"k\")\n",
    "# ax = plot_params(x,)\n",
    "# ax.axhline(threshold)\n",
    "\n",
    "\n",
    "# ax = ax.set_title(f\"Varying n across constrained set length k. \\\n",
    "# \\nBlue line indicates {threshold:.2} unique codes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf3778bc",
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# subsampling for constrained k\n",
    "\n",
    "select = range(0, 20, 5) #select a subset of k in sets of whatever\n",
    "df_ = df[df['k'].isin(select)] #use this frame from here on out!\n",
    "\n",
    "hue_var = \"k\"\n",
    "ax = sns.lineplot(data = df_,\n",
    "                  x = 'n',\n",
    "                  y = 'num_unique',\n",
    "                  hue = hue_var)\n",
    "\n",
    "title = \"Unique sets of length $k$ across total pool of barcoding elements n.\"\n",
    "x = \"n, epitope pool size\"\n",
    "y = \"y, number of unique equal length sets\"\n",
    "\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$ values\",\n",
    "                 threshold, \n",
    "                 y_len = 20\n",
    "                 )\n",
    "\n",
    "hide_toggle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92696cfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ax = sns.lineplot(data = df[df['solved']], x = 'n', y = 'num_unique', hue = \"k\")\n",
    "# ax.set_yscale('log')\n",
    "# ax.axhline(threshold)\n",
    "# ax = ax.set_title(f\"values of n choose k that solve the {threshold:.2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db54a8d1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# varying $k$ with constrained $n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37eee61e",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "df = make_combinatorics(n=range(1,50,1), k = range(1,40,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fd32f16",
   "metadata": {
    "code_folding": [
     6
    ],
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "### values as k varies with constrained n\n",
    "hue_var = \"n\"\n",
    "title = f\"Unique expressed sets as ${hue_var}$ varies.\"\n",
    "x = \"$k$, length of expressed set\"\n",
    "y = \"y, number of unique equal length sets\"\n",
    "\n",
    "ax = sns.lineplot(data=df,\n",
    "                  x='k',\n",
    "                  y='num_unique',\n",
    "                  hue=hue_var)\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$\",\n",
    "                 threshold, \n",
    "                 y_len = 20,\n",
    "#                  scale = ,\n",
    "                 )\n",
    "\n",
    "hide_toggle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4b5059f",
   "metadata": {
    "code_folding": [],
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "### sampling unique across k and holding n steady\n",
    "select = range(10, 40, 10)\n",
    "df_ = df[df['n'].isin(select)]\n",
    "\n",
    "title = \"Diversity as $n$ varies.\"\n",
    "# Diversity is maximized when $k=n/2$: each set sampling half the possible pool\"\n",
    "x = \"$k$, length of expressed set\"\n",
    "y = \"y, number of unique equal length sets\"\n",
    "hue_var = \"n\"\n",
    "\n",
    "ax = sns.lineplot(data = df_, x = 'k', y = 'num_unique', hue = hue_var)\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$\",\n",
    "                 threshold, \n",
    "#                  scale = None,\n",
    "                 y_len = 20\n",
    "                 )\n",
    "hide_toggle()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cffc034",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Synthesis constraints: cassette lengths and shuffled assembly\n",
    "___\n",
    "\n",
    "Given synthesis constraints, we can fit 3-4 epitopes on a single oligo synthesis as part of an oligo pool.\n",
    "\n",
    "However, we can combine cassettes (i.e. synthesize each cassette, bit length 3-4, and then assemble into a larger set of expressed epitopes).\n",
    "\n",
    "With some number of cassettes $c$, diversity is now ${\\frac{n}{c} \\choose k}$, and requires $n\\times c$ epitopes. \n",
    "This lets us reach more unique barcodes while maintaining a 3 or 4 bit synthesis & dropping the number of epitopes needed significantly (the point where $n \\choose 3$ = 1e6).\n",
    "\n",
    "* not currently accounting for collisions in unique space or bias in the biological assembly components"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "304e85ed",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# $k$-bits at $c$ sites"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3c031ad",
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def apply_cassette_math(unique_in_cassette, n_col, num_cassettes):\n",
    "    return pd.Series([unique_in_cassette**num_cassettes, #unique cassettets from n choose k\n",
    "                      n_col*num_cassettes, ##num epitopes needed\n",
    "                      num_cassettes]) #num cassettes we're mathing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "685debeb",
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def cassette_comb(df, c = range(1,5,1)):\n",
    "    '''iteratively apply cassette math for differing values of c'''\n",
    "    cs = c\n",
    "    dfs = []\n",
    "    for c in cs:\n",
    "        _df = df.copy()\n",
    "        _df[['total_diversity',\n",
    "           'total_epitopes_needed',\n",
    "           'c']] = df.apply(lambda x: cassette_math(x['num_unique'],\n",
    "                                                    x['n'],\n",
    "                                                    c), axis=1)\n",
    "        dfs.append(_df)\n",
    "    new_df = pd.concat(dfs)\n",
    "    return new_df.reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0b2ab75",
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "df = make_combinatorics(n=range(1,20,1), k = range(3,9,1)) #make combinatorics df\n",
    "df = cassette_comb(df) #this is a little weird actually but workable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b481c2a",
   "metadata": {
    "code_folding": [
     9
    ]
   },
   "outputs": [],
   "source": [
    "## plotting at a selection of k\n",
    "_df = df[df['c'].isin([2,4])]\n",
    "_df = _df[_df['k'].isin([3,4])]\n",
    "\n",
    "_df = _df[_df['total_epitopes_needed'] <= 40]\n",
    "\n",
    "## plotting for real\n",
    "\n",
    "hue_var = \"c\"\n",
    "ax = sns.lineplot(data = _df,\n",
    "                  y = 'total_diversity',\n",
    "                  x = 'total_epitopes_needed',\n",
    "                  style = \"k\",\n",
    "                  hue = 'c')\n",
    "\n",
    "title = f\"Unique sets from $n/c$ choose $k$ (i.e. $c$ pools of non-overlapping $n$, and assembled for final $k*c$ bit expressed set).\"\n",
    "x = f\"$n$, number of total epitopes required (split between $c$ pools)\"\n",
    "y = \"y, number of unique expressed sets\"\n",
    "\n",
    "# ax.set_ylim(0, 10e9)\n",
    "\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$\",\n",
    "                 threshold, \n",
    "                 y_len = 20)\n",
    "\n",
    "hide_toggle()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da6997bc",
   "metadata": {},
   "source": [
    "# $k$-bits at 3 sites\n",
    "Where each synthesis is 3 epitopes at 3 locations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07e3bd60",
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "## math for 3 cassettes\n",
    "df = make_combinatorics(n=range(1,40,1), k = range(2,16,1))\n",
    "num_cassettes = 3\n",
    "\n",
    "df['total_diversity'] = df['num_unique']**num_cassettes\n",
    "df['total_epitopes_needed'] = df['n']*num_cassettes\n",
    "df['assembly_solved'] = df['total_diversity'].apply(lambda x : x>threshold)\n",
    "df['solved'] = df['num_unique'].apply(lambda x : x>threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca0c0cca",
   "metadata": {
    "code_folding": [
     0
    ],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "##plotting\n",
    "\n",
    "_df = df[df['k'].isin([2,3,4])]\n",
    "\n",
    "hue_var = \"k\"\n",
    "ax = sns.lineplot(data = _df,\n",
    "                  y = 'total_diversity',\n",
    "                  x = 'total_epitopes_needed',\n",
    "                  hue = hue_var)\n",
    "\n",
    "\n",
    "\n",
    "title = f\"Unique sets from $n/{num_cassettes}$ choose $k$ (i.e.\\\n",
    "{num_cassettes} pools comprised of non-overlapping $n$, and all\\\n",
    "possible assembled for a final of a $k$*{num_cassettes} bit expressed set).\"\n",
    "x = f\"$n$, number of total epitopes required (split between {num_cassettes} pools)\"\n",
    "y = \"y, number of unique expressed sets\"\n",
    "\n",
    "\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$\",\n",
    "                 threshold, \n",
    "                 y_len = 20\n",
    "                 )\n",
    "# hide_toggle()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# ax = sns.lineplot(data = _df,\n",
    "#                   y = 'total_diversity',\n",
    "#                   x = 'total_epitopes_needed',\n",
    "#                   hue = \"k\")\n",
    "\n",
    "# title = \"Unique sets from n/2 choose k (i.e. two part random-shuffle assembly).\\n\\\n",
    "# Combinatorics addressing synthesis length (assuming 300 bp from Twist).\"\n",
    "# x = \"n, number of total epitopes required for assembly\"\n",
    "# y = \"y, number of unique sets\"\n",
    "\n",
    "# ax = plot_params(ax, title, x, y, threshold, y_len=20, x_len = 20)\n",
    "# hide_toggle()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e892cfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "## scratch work below this"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c1942e7",
   "metadata": {},
   "source": [
    "# $n$ choose $k$ with replacement -- $ \\left( n \\choose k \\right)$\n",
    "* in analysis, if set length isn't controlled we _can_ deal with that (just more difficult) -- introduces concept of dropout\n",
    "* _but_ gives us the integral -- diversity is all set lengths -- n choose k with replacement, rather\n",
    "\n",
    "* https://www.johndcook.com/blog/select_with_replacement/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e83bd1fc",
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def vary_r(n,k):\n",
    "    return comb(n, k, repetition=True) #combine with repeats\n",
    "\n",
    "def make_combinatorics_r(n = range(0,60,1), k = range(3, 20)):\n",
    "    ks = k\n",
    "    dfs = []\n",
    "    for k in ks:\n",
    "        df = pd.DataFrame(data = {'n':n})\n",
    "        df['k'] = k\n",
    "        df['num_unique'] = df['n'].apply(lambda n : vary_r(n, k))\n",
    "        dfs.append(df)\n",
    "    df = pd.concat(dfs)\n",
    "    return df.reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98450fc8",
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "## df test\n",
    "df = make_combinatorics_r(n=range(5,40,1), k = range(3,40,1))\n",
    "df.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e5b9eee",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# variable $n$, constrained $k$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78716a5f",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "df = make_combinatorics_r(n=range(1,40,1), k = range(1,40,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26635987",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "## the ful range of varying n, constrained k\n",
    "ax = sns.lineplot(data = df,\n",
    "                  x = 'n',\n",
    "                  y = 'num_unique', \n",
    "                  hue = \"k\")\n",
    "title = \"Unique sets of up to length k across total pool of barcoding elements $n$\"\n",
    "\n",
    "ax = plot_params(ax, \n",
    "                 title,\n",
    "                 threshold = threshold, \n",
    "                 varied_by = \"$k$ values\")\n",
    "\n",
    "\n",
    "# hide_toggle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78dffa56",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# ax = sns.lineplot(data = df,\n",
    "#                   x = 'n',\n",
    "#                   y = 'num_unique', \n",
    "#                   hue = \"k\")\n",
    "# ax = plot_params(x,)\n",
    "# ax.axhline(threshold)\n",
    "\n",
    "\n",
    "# ax = ax.set_title(f\"Varying n across constrained set length k. \\\n",
    "# \\nBlue line indicates {threshold:.2} unique codes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2f0041b",
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# subsampling for constrained k\n",
    "\n",
    "select = range(0, 40, 10) #select a subset of k in sets of whatever\n",
    "df_ = df[df['k'].isin(select)] #use this frame from here on out!\n",
    "\n",
    "hue_var = \"k\"\n",
    "ax = sns.lineplot(data = df_,\n",
    "                  x = 'n',\n",
    "                  y = 'num_unique',\n",
    "                  hue = hue_var)\n",
    "\n",
    "title = \"Unique sets up to length $k$ across total pool of barcoding elements $n$.\"\n",
    "x = \"n, epitope pool size\"\n",
    "y = \"y, number of unique equal length sets\"\n",
    "\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$ values\",\n",
    "                 threshold, \n",
    "                 y_len = 20\n",
    "                 )\n",
    "\n",
    "hide_toggle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f2ea96b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ax = sns.lineplot(data = df[df['solved']], x = 'n', y = 'num_unique', hue = \"k\")\n",
    "# ax.set_yscale('log')\n",
    "# ax.axhline(threshold)\n",
    "# ax = ax.set_title(f\"values of n choose k that solve the {threshold:.2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32839a10",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# varying $k$ with constrained $n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b90fb3a",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "df = make_combinatorics_r(n=range(1,50,1), k = range(3,40,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d3c7412",
   "metadata": {
    "code_folding": [
     6
    ],
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "### values as k varies with constrained n\n",
    "hue_var = \"n\"\n",
    "title = f\"Unique expressed sets as ${hue_var}$ varies.\"\n",
    "x = \"$k$, length of expressed set\"\n",
    "y = \"y, number of unique equal length sets\"\n",
    "\n",
    "ax = sns.lineplot(data=df,\n",
    "                  x='k',\n",
    "                  y='num_unique',\n",
    "                  hue=hue_var)\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$\",\n",
    "                 threshold, \n",
    "                 y_len = 20\n",
    "                 )\n",
    "\n",
    "hide_toggle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca396750",
   "metadata": {
    "code_folding": [
     10
    ],
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "### sampling unique across k and holding n steady\n",
    "select = range(10, 50, 10)\n",
    "df_ = df[df['n'].isin(select)]\n",
    "\n",
    "title = \"Diversity as $n$ increases.\"\n",
    "x = \"$k$, length of expressed set\"\n",
    "y = \"y, number of unique equal length sets\"\n",
    "hue_var = \"n\"\n",
    "\n",
    "ax = sns.lineplot(data = df_, x = 'k', y = 'num_unique', hue = hue_var)\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$\",\n",
    "                 threshold, \n",
    "                 y_len = 20\n",
    "                 )\n",
    "hide_toggle()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7ffd7fb",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Synthesis constraints: cassette lengths and shuffled assembly\n",
    "___\n",
    "\n",
    "Given synthesis constraints, we can fit 3-4 epitopes on a single oligo synthesis as part of an oligo pool.\n",
    "\n",
    "However, we can combine cassettes (i.e. synthesize each cassette, bit length 3-4, and then assemble into a larger set of expressed epitopes).\n",
    "\n",
    "With some number of cassettes $c$, diversity is now ${\\frac{n}{c} \\choose k}$, and requires $n\\times c$ epitopes. \n",
    "This lets us reach more unique barcodes while maintaining a 3 or 4 bit synthesis & dropping the number of epitopes needed significantly (the point where $n \\choose 3$ = 1e6).\n",
    "\n",
    "* not currently accounting for collisions in unique space or bias in the biological assembly components"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5def4245",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# $k$-bits at two locations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fe4e119",
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "## math for cassette combinatorics\n",
    "num_cassettes = 2\n",
    "df = make_combinatorics_r(n=range(1,40,1), k = range(3,20,1))\n",
    "df['total_diversity'] = df['num_unique']**num_cassettes\n",
    "df['total_epitopes_needed'] = df['n']*num_cassettes\n",
    "df['assembly_solved'] = df['total_diversity'].apply(lambda x : x>threshold)\n",
    "df['solved'] = df['num_unique'].apply(lambda x : x>threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1e3baeb",
   "metadata": {
    "code_folding": [
     4
    ]
   },
   "outputs": [],
   "source": [
    "## plotting at a selection of k\n",
    "select = range(0, 20, 5)\n",
    "_df = df[df['k'].isin(select)]\n",
    "\n",
    "hue_var = \"k\"\n",
    "ax = sns.lineplot(data = _df,\n",
    "                  y = 'total_diversity',\n",
    "                  x = 'total_epitopes_needed',\n",
    "                  hue = hue_var)\n",
    "\n",
    "title = f\"Unique sets from $n/{num_cassettes}$ choose $k$ with replacement (i.e. two \\\n",
    "pools comprised of non-overlapping $n$), where each pool is between 1 and $k$ bits long.\"\n",
    "x = f\"$n$, number of total epitopes required (split between {num_cassettes} pools)\"\n",
    "y = \"y, number of unique expressed sets\"\n",
    "\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$\",\n",
    "                 threshold, \n",
    "                 y_len = 20)\n",
    "hide_toggle()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4969338",
   "metadata": {},
   "source": [
    "# $k$-bits at 3 sites\n",
    "Where each synthesis is 3 epitopes at 3 locations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4a791fd",
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "## math for 3 cassettes\n",
    "df = make_combinatorics(n=range(1,40,1), k = range(2,16,1))\n",
    "num_cassettes = 3\n",
    "\n",
    "df['total_diversity'] = df['num_unique']**num_cassettes\n",
    "df['total_epitopes_needed'] = df['n']*num_cassettes\n",
    "df['assembly_solved'] = df['total_diversity'].apply(lambda x : x>threshold)\n",
    "df['solved'] = df['num_unique'].apply(lambda x : x>threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42efd5f4",
   "metadata": {
    "code_folding": [
     0
    ],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "##plotting\n",
    "\n",
    "_df = df[df['k'].isin([2,3,4])]\n",
    "\n",
    "hue_var = \"k\"\n",
    "ax = sns.lineplot(data = _df,\n",
    "                  y = 'total_diversity',\n",
    "                  x = 'total_epitopes_needed',\n",
    "                  hue = hue_var)\n",
    "\n",
    "\n",
    "\n",
    "title = f\"Unique sets from $n/{num_cassettes}$ choose $k$ (i.e.\\\n",
    "{num_cassettes} pools comprised of non-overlapping $n$, and all\\\n",
    "possible assembled for a final of a $k$*{num_cassettes} bit expressed set).\"\n",
    "x = f\"$n$, number of total epitopes required (split between {num_cassettes} pools)\"\n",
    "y = \"y, number of unique expressed sets\"\n",
    "\n",
    "\n",
    "ax = plot_params(ax, title,\n",
    "                 x, y, f\"${hue_var}$\",\n",
    "                 threshold, \n",
    "                 y_len = 20\n",
    "                 )\n",
    "# hide_toggle()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# ax = sns.lineplot(data = _df,\n",
    "#                   y = 'total_diversity',\n",
    "#                   x = 'total_epitopes_needed',\n",
    "#                   hue = \"k\")\n",
    "\n",
    "# title = \"Unique sets from n/2 choose k (i.e. two part random-shuffle assembly).\\n\\\n",
    "# Combinatorics addressing synthesis length (assuming 300 bp from Twist).\"\n",
    "# x = \"n, number of total epitopes required for assembly\"\n",
    "# y = \"y, number of unique sets\"\n",
    "\n",
    "# ax = plot_params(ax, title, x, y, threshold, y_len=20, x_len = 20)\n",
    "# hide_toggle()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc1b620c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e701072",
   "metadata": {},
   "outputs": [],
   "source": [
    "min_df = df[df['solved']].groupby(\"n\").min().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c47045a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df['assembly_solved']].groupby(\"n\").min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed609362",
   "metadata": {},
   "outputs": [],
   "source": [
    "min_df.sort_values('n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7de4c68",
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.relplot(x='k', y='n', data=min_df)\n",
    "# ax.set_title(f\"minimum nCk combo\\nthat crosses {threshold:e} threshold\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a0834b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# min_df = df[df['solved it! assembly']].groupby('epitope_ct_needed').min().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86968d34",
   "metadata": {},
   "outputs": [],
   "source": [
    "#min_df = df[df['solved it! assembly']].groupby().min().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dddffb53",
   "metadata": {},
   "outputs": [],
   "source": [
    "#min_df.sort_values(\"epitope_ct_needed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "deed2b1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.scatterplot(x='k', y='epitope_ct_needed', data=min_df)\n",
    "ax.set_title(f\"minimum # of a n/k combo that crosses {threshold} threshold\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "623fe750",
   "metadata": {},
   "outputs": [],
   "source": [
    "min_df = df[df['solved it!']].groupby('k').min().sort_values('k').reset_index()\n",
    "min_df\n",
    "\n",
    "# when does [x choose 3]^2 cross threshold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3da9682",
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.scatterplot(x='n', y='k', data=min_df)\n",
    "ax.set_title(f\"minimum nCk combo\\nthat crosses {threshold:e} threshold\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc651761",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}