{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# *(Joglekar, et. al, 2018)*: Inter-areal Balanced Amplification Figure 2\n", "\n", "[![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/brainpy/examples/blob/main/large_scale_modeling/Joglekar_2018_InterAreal_Balanced_Amplification_figure2.ipynb)\n", "[![Open in Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/brainpy/examples/blob/main/large_scale_modeling/Joglekar_2018_InterAreal_Balanced_Amplification_figure2.ipynb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Implementation of the figure 2 of:\n", "\n", "- Joglekar, Madhura R., et al. \"Inter-areal balanced amplification enhances signal propagation in a large-scale circuit model of the primate cortex.\" Neuron 98.1 (2018): 222-234." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:12.532051900Z", "start_time": "2023-07-22T05:54:12.514389500Z" } }, "outputs": [], "source": [ "import brainpy as bp\n", "import brainpy.math as bm\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from jax import vmap, jit\n", "from scipy import io as sio\n", "from functools import partial" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:12.567875100Z", "start_time": "2023-07-22T05:54:12.519499200Z" } }, "outputs": [], "source": [ "bm.set_dt(dt=2e-4)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:43.479729300Z", "start_time": "2023-07-22T05:54:43.463983700Z" }, "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'2.4.3'" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bp.__version__" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:12.568875200Z", "start_time": "2023-07-22T05:54:12.532051900Z" } }, "outputs": [], "source": [ "\n", "class ThreshLinearModel(bp.NeuGroup):\n", " def __init__(\n", " self,\n", " size, hier, fln, inp_idx, inp_data,\n", " eta=.68, betaE=.066, betaI=.351, tauE=2e-2, tauI=1e-2,\n", " omegaEE=24.3, omegaEI=19.7, omegaIE=12.2, omegaII=12.5,\n", " muIE=25.3, muEE=28., noiseE=None, noiseI=None, seed=None,\n", " desired_ss=None, name=None\n", " ):\n", " super(ThreshLinearModel, self).__init__(size, name=name)\n", "\n", " # parameters\n", " self.hier = hier\n", " self.fln = fln\n", " self.eta = bp.init.parameter(eta, self.num, False)\n", " self.betaE = bp.init.parameter(betaE, self.num, False)\n", " self.betaI = bp.init.parameter(betaI, self.num, False)\n", " self.tauE = bp.init.parameter(tauE, self.num, False)\n", " self.tauI = bp.init.parameter(tauI, self.num, False)\n", " self.omegaEE = bp.init.parameter(omegaEE, self.num, False)\n", " self.omegaEI = bp.init.parameter(omegaEI, self.num, False)\n", " self.omegaIE = bp.init.parameter(omegaIE, self.num, False)\n", " self.omegaII = bp.init.parameter(omegaII, self.num, False)\n", " self.muIE = bp.init.parameter(muIE, self.num, False)\n", " self.muEE = bp.init.parameter(muEE, self.num, False)\n", " self.desired_ss = desired_ss\n", " self.seed = seed\n", " self.noiseE = bp.init.parameter(noiseE, self.num, True)\n", " self.noiseI = bp.init.parameter(noiseI, self.num, True)\n", " self.inp_idx, self.inp_data = inp_idx, inp_data\n", "\n", " # Synaptic weights for intra-areal connections\n", " self.wEE_intra = betaE * omegaEE * (1 + eta * hier)\n", " self.wIE_intra = betaI * omegaIE * (1 + eta * hier)\n", " self.wEI_intra = -betaE * omegaEI\n", " self.wII_intra = -betaI * omegaII\n", "\n", " # Synaptic weights for inter-areal connections\n", " self.wEE_inter = bm.asarray(fln.T * (betaE * muEE * (1 + eta * hier))).T\n", " self.wIE_inter = bm.asarray(fln.T * (betaI * muIE * (1 + eta * hier))).T\n", "\n", " # Variables\n", " self.re = bm.Variable(bm.zeros(self.num))\n", " self.ri = bm.Variable(bm.zeros(self.num))\n", "\n", " # get background input\n", " if desired_ss is None:\n", " self.bgE = bm.zeros(self.num)\n", " self.bgI = bm.zeros(self.num)\n", " else:\n", " if len(desired_ss) != 2:\n", " raise ValueError\n", " if len(desired_ss[0]) != self.num:\n", " raise ValueError\n", " if len(desired_ss[1]) != self.num:\n", " raise ValueError\n", " self.bgE, self.bgI = self.get_background_current(*desired_ss)\n", "\n", " def get_background_current(self, ssE, ssI):\n", " # total weights\n", " wEEaux = bm.diag(-1 + self.wEE_intra) + self.wEE_inter\n", " wEIaux = self.wEI_intra * bm.eye(self.num)\n", " wIEaux = bm.diag(self.wIE_intra) + self.wIE_inter\n", " wIIaux = (-1 + self.wII_intra) * bm.eye(self.num)\n", " # temp matrices to create matrix A\n", " A1 = bm.concatenate((wEEaux, wEIaux), axis=1)\n", " A2 = bm.concatenate((wIEaux, wIIaux), axis=1)\n", " A = bm.concatenate([A1, A2])\n", " ss = bm.concatenate((ssE, ssI))\n", " cur = -bm.dot(A, ss)\n", " self.re.value, self.ri.value = ssE, ssI\n", " # state = bm.linalg.lstsq(-A, cur, rcond=None)[0]\n", " # self.re.value, self.ri.value = bm.split(state, 2)\n", " return bm.split(cur, 2)\n", "\n", " def reset(self):\n", " if self.desired_ss is None:\n", " self.re[:] = 0.\n", " self.ri[:] = 0.\n", " else:\n", " self.re.value = self.desired_ss[0]\n", " self.ri.value = self.desired_ss[1]\n", "\n", " def update(self):\n", " tdi = bp.share.get_shargs()\n", " # E population\n", " Ie = bm.dot(self.wEE_inter, self.re) + self.wEE_intra * self.re\n", " Ie += self.wEI_intra * self.ri + self.bgE\n", " if self.noiseE is not None:\n", " Ie += self.noiseE * bm.random.randn(self.num) / bm.sqrt(tdi.dt)\n", " Ie[self.inp_idx] += self.inp_data[tdi['i']]\n", " self.re.value = bm.maximum(self.re + (-self.re + bm.maximum(Ie, 10.)) / self.tauE * tdi.dt, 0)\n", " # I population\n", " Ii = bm.dot(self.wIE_inter, self.re) + self.wIE_intra * self.re\n", " Ii += self.wII_intra * self.ri + self.bgI\n", " if self.noiseI is not None:\n", " Ii += self.noiseI * bm.random.randn(self.num) / bm.sqrt(tdi.dt)\n", " self.ri.value = bm.maximum(self.ri + (-self.ri + bm.maximum(Ii, 35.)) / self.tauI * tdi.dt, 0)\n", "\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:12.568875200Z", "start_time": "2023-07-22T05:54:12.547682700Z" } }, "outputs": [], "source": [ "def simulate(num_node, muEE, fln, hier, input4v1, duration):\n", " model = ThreshLinearModel(int(num_node),\n", " hier=hier, fln=fln,\n", " inp_idx=0, inp_data=input4v1, muEE=muEE,\n", " desired_ss=(bm.ones(num_node) * 10, bm.ones(num_node) * 35))\n", " runner = bp.DSRunner(model, monitors=['re'], progress_bar=False, numpy_mon_after_run=False)\n", " runner.run(duration)\n", " return runner.mon.ts, runner.mon.re\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:12.580902Z", "start_time": "2023-07-22T05:54:12.568875200Z" } }, "outputs": [], "source": [ "\n", "def show_firing_rates(ax, hist_t, hist_re, show_duration=None, title=None):\n", " hist_t = bm.as_numpy(hist_t)\n", " hist_re = bm.as_numpy(hist_re)\n", " if show_duration is None:\n", " i_start, i_end = (1.75, 5.)\n", " else:\n", " i_start, i_end = show_duration\n", " i_start = round(i_start / bm.get_dt())\n", " i_end = round(i_end / bm.get_dt())\n", "\n", " # visualization\n", " rateV1 = np.maximum(1e-2, hist_re[i_start:i_end, 0] - hist_re[i_start, 0])\n", " rate24 = np.maximum(1e-2, hist_re[i_start:i_end, -1] - hist_re[i_start, -1])\n", " ax.semilogy(hist_t[i_start:i_end], rateV1, 'dodgerblue')\n", " ax.semilogy(hist_t[i_start:i_end], rate24, 'forestgreen')\n", " ax.set_ylim([1e-2, 1e2 + 100])\n", " # ax.set_xlim([-0.25, 2.25])\n", " ax.spines['top'].set_visible(False)\n", " ax.spines['right'].set_visible(False)\n", " ax.set_ylabel('Change in firing rate (Hz)', fontsize='large')\n", " ax.set_xlabel('Time (s)', fontsize='large')\n", " if title:\n", " ax.set_title(title)\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:12.599823500Z", "start_time": "2023-07-22T05:54:12.583874900Z" } }, "outputs": [], "source": [ "\n", "def show_maximum_rate(ax, muEE_range, peak_rates, title=''):\n", " ax.semilogy(muEE_range[4], np.squeeze(peak_rates[4]), 'cornflowerblue', marker=\"o\",\n", " markersize=12, markerfacecolor='w')\n", " ax.semilogy(muEE_range, np.squeeze(peak_rates), 'cornflowerblue', marker=\".\", markersize=10)\n", " ax.semilogy(muEE_range[3], np.squeeze(peak_rates[3]), 'cornflowerblue', marker=\"x\", markersize=15)\n", " ax.spines['top'].set_visible(False)\n", " ax.spines['right'].set_visible(False)\n", " ax.set_ylim([1e-6, 1e3])\n", " ax.set_ylabel('Maximum rate in 24c (Hz)', fontsize='large')\n", " ax.set_xlabel('Global E to E coupling', fontsize='large')\n", " if title:\n", " ax.set_title(title)\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:12.617125100Z", "start_time": "2023-07-22T05:54:12.599823500Z" } }, "outputs": [], "source": [ "def figure2B():\n", " # data\n", " data = sio.loadmat('Joglekar_2018_data/subgraphData.mat')\n", " num_node = data['nNodes'][0, 0]\n", " hier = bm.asarray(data['hierVals'].squeeze() / max(data['hierVals'])) # normalize hierarchical position\n", " fln = bm.asarray(data['flnMat'])\n", "\n", " # inputs\n", " ampl = 21.8 * 1.9\n", " inputs, duration = bp.inputs.section_input([0, ampl, 0], [2., 0.25, 7.75], return_length=True)\n", "\n", " # Fig 2B\n", " ax = plt.subplot(1, 2, 1)\n", " times, res = simulate(int(num_node), fln=fln, hier=hier, muEE=34, input4v1=inputs, duration=duration)\n", " show_firing_rates(ax, hist_t=times, hist_re=res, show_duration=(1.75, 5.), title=r'$\\mu$EE=34')\n", " ax = plt.subplot(1, 2, 2)\n", " times, res = simulate(int(num_node), fln=fln, hier=hier, muEE=36, input4v1=inputs, duration=duration)\n", " show_firing_rates(ax, hist_t=times, hist_re=res, show_duration=(1.75, 5.), title=r'$\\mu$EE=36')\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:13.283003600Z", "start_time": "2023-07-22T05:54:12.617125100Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkMAAAHICAYAAABNpu4dAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABvTklEQVR4nO3dd3xUVfo/8M9kUkkvJCGQhNAJVULvIB1xZbHguogs6rrEguiua9nFtsKuP1fWNaCsX0FWXbGsoC6IoHSkBERKEOkhnRTS68z9/XFzh4QkZGZy68zn/XrNK2HKnSeUh2fOec45JkEQBBARERG5KQ+tAyAiIiLSEoshIiIicmsshoiIiMitsRgiIiIit8ZiiIiIiNwaiyEiIiJyayyGiIiIyK2xGCIiIiK3xmKIiIiI3BqLISIiInJrLIaIiIjIrbEYIl1Zu3YtTCZTi7cdO3Y49VxnHD16FDNnzkRcXBz8/PwQFhaGESNG4P3332/1te+88w5MJhMCAgLaFAMR2cfouWPPnj2YMWMGQkND4efnh+7du+Oll15qUxxkP0+tAyBqzpo1a9CrV68m9ycmJrbpuY64evUqYmNjcffdd6Njx44oLy/HBx98gHnz5uHixYt47rnnmn1dZmYmnnzyScTExKC4uLhNMRCRY4yYOz788EPMmzcPd955J9atW4eAgACcO3cOWVlZbYqD7GfiqfWkJ2vXrsWCBQtw6NAhDB48WLbnymn48OHIyspCenp6s4/PmjULJpMJYWFh+PTTT1FWVqZabETuyqi5IzMzEz179sS9996LlStXqhYLNcZpMlJNQkIC5s+f3+T+iRMnYty4cRpE5JyIiAh4ejY/qPr+++9j586dTGpEMnLl3PHOO++gvLwcTz31lEZREcBiiFRSUFCAixcvNvkUJggCjhw5gqSkpEb3WywW1NXVNbpZLJZmr93acwVBaPJ4S7fmWK1W1NXV4cqVK1i5ciW2bNnSbOLKy8vD4sWLsXz5cnTq1MnR3yIiaoar545du3YhLCwMP/30EwYOHAhPT09ERkbioYceQklJiTO/ZeQEFkOkitTUVABoktDOnDmD4uLiJglt+PDh8PLyanTz8fFp9tqtPXfnzp1NHm/pdvHixSbXX7RoEby8vBAZGYnHH38cb7zxBn772982+7yePXvid7/7naO/PUTUAlfPHZmZmaioqMAdd9yBu+66C9u2bcPvf/97rFu3DjNmzAA7WdTBBmpSxaFDh+Dp6YmBAwc2uv/w4cMA0CShrVu3Dr179250n8lkavbarT03KSkJhw4dsivOmJiYJvc988wzuP/++5GXl4cvv/wSDz/8MMrLy/Hkk0/anvPZZ5/hyy+/xA8//NBinETkOFfPHVarFVVVVVi6dCn++Mc/AgDGjx8Pb29vLF68GN9++y0mTZpkVwzkPBZDpIrU1FQkJibCz8+vyf0BAQHo0aNHo/t79+5td2Nja88NCAhokkhb0lwvUFxcHOLi4gAAM2bMAAA8/fTTmD9/Ptq3b4+ysjIkJyfjkUceQUxMDK5evQoAqKmpASCuLPHy8oK/v79dMRDRNa6cOwAgPDwcZ86cwdSpUxu9dvr06Vi8eDGOHDnCYkgFnCYjVaSmpmLQoEFN7t+xYwduuukmeHgo91exrUPd1xs6dCjq6upw/vx5AEB+fj5yc3Px2muvITQ01Hb7z3/+g/LycoSGhuKee+5R7OcjcmWunDsAoH///s0+V5oeU/Lno2s4MkSKy8nJQWZmZpNPTjt37sSRI0ewePFiRd+/rUPd19u+fTs8PDzQpUsXAEB0dDS2b9/e5HnLly/Hzp07sXnzZkRERDgWNBG5fO4AgDlz5mD16tXYvHkzbrrpJtv9mzZtAiD2NZHyWAyR4qRk8sknnyAxMRHdunXD0aNHkZKSAkBchXXixAn07dvX9poTJ040u0Kja9eutuFle58bGBjo1F4iDz74IIKCgjB06FBERUUhPz8fn3zyCdavX4/f//73tjh8fX0xfvz4Jq9fu3YtzGZzs48RUetcPXcAwJQpUzBr1iy8+OKLsFqtGD58OFJTU/HCCy/glltuwejRox1+f3KCQKSwP//5z4Knp6fwySefCJ07dxZ8fX2F8ePHCwcOHBC6desmdOjQQdi3b58gCIKwZs0aAUCLt3/961+26zryXGe8++67wpgxY4SIiAjB09NTCAkJEcaNGyf8+9//tuv18+fPF/z9/dsUA5E7c5fcUVFRITz11FNCbGys4OnpKcTFxQlPP/20UFVV1aY4yH7cgZoUN2PGDOTk5ODIkSNah0JEBsLcQWphZxYp7vDhwxg6dKjWYRCRwTB3kFpYDJGi0tPTkZeXx4RGRA5h7iA1cZqMiIiI3BpHhoiIiMitsRgiIiIit8ZiiIiIiNwai6FWCIKAkpISnhxMRA5h7iAyDhZDLUhJSUFiYiJ69eqF4OBglJaWah0SERkAc4exCIKAsavHouv/64rt55seq6NnFivQ7y0g/h/A0RytozE2riZrRUlJCYKDg1FcXIygoCCtwyEig2DuMIbzhecx+d3J8DZ743DyYbTzbqd1SHY7ngvc8hEQ4A38+FvAk8MbTuNvHRERua2dF3YCAJI6JhmqEAKAfRni16ExLITair99RETktnZd2AUAGJcwTuNIHPd9fTE0MlbbOFwBiyEiInJLVbVVOJBxAAAwtvNYjaNxTK0FOJgpfj+ik7axuAIWQ0RE5JYOZhxEdV01ogOj0SOih9bhOOR4HlBeCwT7AInttY7G+FgMERGRW9p1UZwiG9t5LEwmk8bROEaaIhveCfAwVui6xGKIiIjckiv0C3GKTB4shoiIyO1kFGfgXOE5mE1mjIwbqXU4DqmxAIeyxO9HshiSBYshIiJyO9IU2U0xNyHI11j7QB3NAarqgHA/oEe41tG4BhZDRETkdqQpsrEJxlpFBjSeIjNYq5NusRgiIiK3UmOpwb5L+wAYb0k9cG2zRfYLyYfFEBERuZUjmUdQXluOML8w9Inqo3U4DqmqA37IFr8fwc0WZcNiiIiI3IptSX3CWHiYjPXf4OFsoNoCRPoDXUK0jsZ1GOtvARERURvZ+oUMOEVmO4KD/UKyYjFERERuI7csF6eunIIJJozuPFrrcBz2/WXxK/uF5MViiIjIDWWXAm+lAnd9BvznhNbRqGf3xd0AgH7R/RDezljr0itqgaO54vc8nFVenloHQERE6jlXBLxxAPjiZ8AqiPdllQJ399U2LrUYeYrsUBZQZwU6BQKxxtoaSfdYDBERuYFaC5ByCHjzEFBrFe/rGAhkloqjRILg+j0oFqsFey7tAWDQ/YUaTJG5+p+V2jhNRkTk4kqrgd98Abx+QCyEJnQGvrob2DEfMEG8r7BS6yiVdyznGIqrihHkE4QBHQZoHY7DbJstcopMdm5RDF2+fBnjx49HYmIi+vfvj08++UTrkIhI51wlb1TVAfdtBHalA36ewBvTgDW3Av0iAW8zENFOfF52mbZxqkGaIhsdPxqeHsaaGCmpBo7lid+zeVp+xvrb4CRPT0+sWLECAwcORF5eHgYNGoQZM2bA399f69CISKdcJW/8YRuQmg0E+QAfzAb6RzV+PDoAuFIB5JQBfSO1iVEtDfcXMppDmWKPV+dgICZQ62hcj1sUQx06dECHDh0AAJGRkQgLC0NhYaHhkhoRqccV8sZXPwMbTwNmE7D6lqaFEAB0CACO57n+yFBhRSF+zP4RADCm8xiNo3HcPk6RKcoQ02S7du3CrFmzEBMTA5PJhA0bNjR5zsqVK5GQkABfX18kJSVh9+7dzV4rNTUVVqsVsbH8G0Xkytw9b1TVAS+IAyFIHtLy1Ep0gPjV1YuhPZf2QICAnhE9ER0YrXU4Dvue55EpyhDFUHl5OQYMGIA333yz2cfXr1+PxYsX49lnn8UPP/yAMWPGYPr06UhPT2/0vIKCAtx7771YvXq1GmGroqpOXAlyIg+4XKJ1NET64e5549/HgLxycRn2w0Nafl6H+mIox8WLISOfUn+1Cki7In7PYkgZhpgmmz59OqZPn97i43//+9+xcOFC3H///QCAFStWYMuWLVi1ahWWLVsGAKiursbs2bPx9NNPY+TIkS1eq7q6GtXV1bZfl5Toq8IorAQ2nQF2XAJOXQEySq89ZgKwbR7QLUyz8Ih0Q828IT1XL7nDYgXe/UH8/uGhgM8NMn10ff9JdmnLzzE6q2C1bbY4LmGcxtE4bn8GIEDM7ZHGmaU1FEOMDN1ITU0NDh8+jClTpjS6f8qUKdi3bx8AQBAE3HfffZg4cSLmzZt3w+stW7YMwcHBtptehsXrrMDr+4FRa4BntwNbz18rhDzr/xQFAD/laxYikWHInTcAfeWO3elAVhkQ7APM7nXj57rDyNCpvFPIr8hHO692SOqYpHU4DuMUmfIMXwzl5+fDYrEgKqpxZ2BUVBRycnIAAHv37sX69euxYcMGDBw4EAMHDsTx48ebvd7TTz+N4uJi2+3y5cuK/wytqawF5n0OrDggbseeGAE8NRL4+HbghweBsw8DU7uKzy2q0jZWIiOQO28A+sodn50Sv87uBfi2Mv7foUHPkCAoG5dWpFVkI+NGwtvsrXE0jmMxpDxDTJPZw3TddpyCINjuGz16NKxWq13X8fHxgY+Pj+zxOUsQgMVbxJUEAd7AKxOBW3s03X001Ff8ymKIyH5y5Q1AP7mjzipOowPArB6tP19qoK6sA0pqxNEkV2PkfqH8CuB0gfg9iyHlGH5kKCIiAmaz2fZpTpKXl9fkU58RbTwNfH1O3Bxt7a3AL3o2vw27VAxddYNdZInaypXzxg/Z4gZ9ob7ATXYsmvL1vJY/clywb6i0uhRHso4AMOaS+v31o0K9I4AwP21jcWWGL4a8vb2RlJSErVu3Nrp/69atrTY83khKSgoSExMxZMgNlmEorM4KvPq9+P0jQ4EhHVt+bkj9PxKODBG1Tqm8AWifO3bWL4YbGw+Y7czwHVx4ef2+9H2os9YhITQBcSFxWofjME6RqcMQ02RlZWU4e/as7dcXLlzA0aNHERYWhri4OCxZsgTz5s3D4MGDMWLECKxevRrp6el46KGHnH7P5ORkJCcno6SkBMHBwXL8GA7bfBbIKBE/DTxw042fG1I/tM1iiEikRd4AtM8dP2SLX4ff4MPT9aIDgLR81yyGjDxFBlwrhkbqYy2PyzJEMZSamooJEybYfr1kyRIAwPz587F27VrcddddKCgowIsvvojs7Gz07dsXmzZtQnx8vFYhy+K/9U2Q9/QD/Lxu/NzQ+pGhqyyGiAC4Z96wCsCPueL3AxzYVzDaRVeUCYKAnRd2AgDGdjZeMZRbBpwrAjxMwFAHiltynCGKofHjx0NoZZnDokWLsGjRIpUiUl5xtbg8FhAbpltja6BmzxARAPfMG+eLgNIasQ+oZ7j9r3PVXajPFpxFdmk2vM3eGBY7TOtwHCYdwdGnvWs2tuuJ4XuGlKL1vP/edKDWKm6y1cOOpBbC1WREuqBl7jhZv0txn/bX9h+zh6vuNSQtqR8WOwx+XsbrPma/kHpYDLUgOTkZaWlpOHTokCbvfyhL/GrvPwJpZKikWtx9loi0oWXuOF8kfnV0F3pXbaCW+oWMuOs0wH4hNbEY0impGBoaY9/zpZEhAeIUGxG5n3P1xVCXUMdeJx3J4UpL6ytqKnAw4yAAY/YLZZQA6cWA2QQMsfP/AXIeiyEdqq67dihfUgf7XuNlBgLrN1blVBmRe5KKoW4OFkPSyFBJDVBWI29MWjmQcQA1lhp0DOqILmFdtA7HYdKoUP8occNdUhaLIR26cBWwCECQNxATaP/rQthETeS2rMK1aTJHR4YCvK99mHKVvqGGS+qv32ncCGxTZOwXUgWLoRZo2QR5plD82i28+d2mW2LbhZojQ0Sa0Sp3FFQAVXWACUBskOOvd7Xl9UZeUi8IwPf1R9uxX0gdLIZaoGUT5M/159D0cLAJMpS7UBNpTqvcIRUx7f3FaXNHuVIT9YWiC7h09RK8PLwwMr5tO4prIb0YyCoDvDzsb5WgtmExpEPOrgjh8noi9yUVMVJR4yhX2mtox/kdAIAhnYYgwNvJ3xANSfsL3RTd+oa7JA8WQzqUWb+io5ODQ908rJXIfUlFTLST//dLRVSuCxRD0hTZ+C7jtQ3ESfs4RaY6FkM6lFVfDMU4mNRCOTJE5LZy2loM1S/WMPrIUEVNBQ5cPgAAGJ8wXtNYnCEI3F9ICyyGdKbWAuSVi987spIMuHZyPRuoidxPW6fJovwbX8eovr/8PWosNYgNjjXkkvozhcCVCvFIlYFRWkfjPlgMtUCrFSG55eLGid5mILydY6/lyBCR9rTKHVfqP0RF+jv3elc5kkPqFxqfMN6QS+qlfqEhMYCPIU4PdQ0shlqg1YoQaYosOkA8qdgRIVxaT6Q5rXKH9CFI+lDkKGmarLBSXKJvRIIg2IqhcV2MeQSHrV+I+wupisWQzlypEL9GOjgqBHBkiMidSR+CQp08jzTYR5yaAYzbRH2m4AyySrPg4+mD4bHDtQ7HYVYB2C8dzsp+IVWxGNIZafdoR6fIAO5ATeTO2joyZDIZf68haVRoeOxwQ55Sn3ZFPFsywBvoF6l1NO6FxZDOSAktxImEJiXBagtQWStfTESkb9V1QEX9v3lniyHA+HsN7biwA4AxV5EB1/qFhnUEPPm/s6r4260z0qhOmBMJLcD72j8gTpURuQ9piszDBAT6OH8dIzdRl1aX4nDmYQAusL8Q+4VUx2JIZ2wjQ06M8JpM7BsickcNR5QdXXjRkJGnyfZe2os6ax26hHVBXEic1uE4rNYCHMwUv+f+QupjMdQCrZbHFrZhZAhg3xCR1rTIHW3tF5IY+bDWhkvqjehYHlBeK/4Z9orQOhr3w2KoBVovjw1zsvdPSobF1fLEQ0SO0SJ3FNfnjeA2FkO2XahL23YdtQmCcK1fyOBTZMM7tW10j5zDYkhn2tJADTQ4uZ4jQ0RuQ2qeDmjjoZ5GbaBOy0vDlfIraOfVDoM7DtY6HKewX0hbLIZ0pqxG/BrkZBNkcP3r2DNE5D6kvOHv3bbrRNfvXp1fAdRY2nYtNUmjQiPjR8LHsw0d5BqpqgMOZ4vfs19IGyyGdKa8Pqm1c/ITnm1kiMUQkduQRob82zgyFN4O8PIQjwSSzkg0AqP3C/2QI26JEukPdA3VOhr3xGJIR2ot4j8IQFwm7wypZ4hHchC5j/L6YsjZD1ESDxMQZbAm6qLKIhzNPgoAGJdg/CM4DHicmktgMaQjFQ02SnQ2qXE1GZH7kUaU2zoyBBhvr6HdF3fDKljRM6InYoJitA7HKbZiiFNkmmExpCPSpztvs3hzBvcZInI/Uu5oa88QcK0YyjDIirKdF3YCMO6oUHkNcDRX/J7FkHZYDLVAi71CytrYLwRc6xniNBmRNrTIHXL1DAFAbLD49XJx26+lNIvVgl0XdgEw7pL6Q1lAnRXoFATEBmkdjftiMdQCLfYKkWN5LEeGiLSlRe6Qq2cIAOLq/0O+XNL2aynteO5xFFYWIsA7AINiBmkdjlOk88i4pF5bLIZ0xDYy1IahbqlnqLgKsAptj4mI9E/qGXJ24UVD8SHi10tX234tpe08L06Rjek8Bl5mGSpBDXzPfiFdYDGkI3IMdUvFkACghLtQE7kFJUaGMkoBi7Xt11OS0U+pL64CTlwRv+fIkLZYDOlImQzFkLf52qdDrigjcg8VMhZD0QHiXkN1Vn3vRJ1fno9jOccAAGMTxmocjXMOZIoj+F1Dr21pQNpgMaQjlTIltBDuQk3kVqT9yXw8234ts8e1Rt50HTdR77ooNk73ieqDyIBIjaNxjq1fiFNkmmMxpCPVdeJX3zYmtBDuQk3kVqTc4eyWHNeTVpRd0nExZPRdp4Fr+wuN4BSZ5lgM6Yh0FlBbExp3oSZyL1Lu8JGpGIrT+fL6Omsddl/cDcC4S+rzK4DTBeL3LIa0x2JIR6plSmih3IWayK1Uy/RBShJfXwyl63R5/dGsoyipLkGIbwgGRA/QOhyn7K+fIkuMAML8tI2FWAzpii2htXWajHsNEbmVGhl7hoBrI0N6XV4vrSIbmzAWZg+ZKkCV2abI2C+kCyyGdESa95drZIjTZESur856bU8x2abJpAZqnY4MuUS/UP3I0ChOkekCi6EWaLGlvmw9QzySg0gzaucO6UMUIN80mTQydLUKKNbZfmU5pTk4deUUTDBhTOcxWofjlKxS4MJVwGwChnbUOhoCWAy1SIst9eXqGeI0GZF21M4d0ocoQL5iyN8biKj/UKW3JmrpYNaBHQYirF2YxtE45/v6UaF+kUCgj7axkIjFkI7UyNQzxPPJiNyH9CHKbAI8Zczoel1eL/ULjetizFPqgWv9QtxfSD9YDOmI7D1DXE1G5PLkml6/XpdQ8ev5Inmv2xY1lhrsvbgXgHH7hQShQTHEfiHdYDGkI3IlNU6TEbkPOXefbighRPyqp2IoNTMV5bXliGgXgT5RfbQOxynpxUBWmXjkyeAYraMhCYshHZFreay0A3VlHVBVd+PnEpGxyb37tESPI0PSKrJxCePgYTLmf1/SKrJBHQA/Gc6SI3kY82+Ti5KrgTrIW+wfALiijMjVyb37tKSrVAxdFad29GDnebF52qi7TgOcItMrp8cgKisrkZOTg8rKSkRERCAy0pgH5emJXNNkJpM4VVZQKe5CHc3TkElHmDvkJffu05LOIYAJQEm1mEsi2sl7fUddvnoZZwvPwmwyY3T8aG2DcVLDfiFutqgvDo0MZWZm4vnnn8eQIUMQFBSEbt26oV+/fujQoQMiIyNxxx13YOPGjbBarUrF69LkaqAG2DdE+sLcoRylRoZ8PYGO9Zsv6mGqTFpSn9QxCUG+QRpH45wzhUB+pfh7OzBK62ioIbtGhrKzs/HMM8/ggw8+gL+/P0aOHIk//vGPiIyMhK+vLwoLC3H+/Hns378fs2fPRnx8PJYtW4a5c+cqHb9LkfMTHnehJj1g7lBebX3e8FLgVIouIUBGCXCuSPvNAaUl9UZdRQYAe+tHhYbEyN/wTm1j1x9Hjx49MHToUHz00UeYNWsWvLxa7vo6f/481qxZg+TkZGRmZuKJJ56QLVhXZ6n/UGyWoZOLu1CTHjB3KK+uPm/IuceQpEsosCtd+5GhqtoqfJ/+PQBj9wtJmy2yX0h/7CqGNm7ciIkTJ9p1wS5duuCll17Ck08+iQsXLrQpOHdTV9+kKEdS4zQZ6QFzh/IsMuaN60kryi5clf/ajjiQcQBVdVWIDoxGj4ge2gbjJIv12kn13GxRf+z652NvMmsoODgYAwcOdPh17kwaGfI0tf1a3IWa9IC5Q3nSyJBZhrxxva46WV7f8GBWk0mBH1QFafniOW+B3kBfrhnQHYc/S6xbtw4HDhxo9rH8/HysW7euzUG5qzo5p8m4CzXpDHOHMuScXr+eNDJ0qfhab5LaBEG4VgwZeIpMWkU2rKMyo3jUNg7/kdx3330YM2YM3n333SaPnTt3DgsWLJAlMHck53A3p8lIb5g7lCHlDSVGhqIDxJVPdVbgcon817fHxaKLSC9Oh5eHF0bGjdQmCBnYltSzX0iXnPpvd/z48XjggQfw/PPPyxyOfqSkpCAxMRFDhgxR7T3l/ITHYoj0iLlDfko2UHuYro0OnS2U//r2kFaRDY0dCn9vf22CaKNaC3AwS/ye/UL65NQ/n5dffhl//etf8dJLL2HhwoWwWDQaP1VQcnIy0tLScOjQIdXe0zYyJEfPEFeTkQ4xd8hPyWkyAOgRJn79uUCZ67emYb+QUf2YC1TUiu0LvSK0joaa4/ROB08++SQ6duyIBQsWICsrC59++qmccbklJXqGODJEesPcIS85V6E2p2e4+PVnDUaGymvKcTDjIACD9wvVryIb3kkcbSP9adM/n7vvvhubN2/G999/j3HjxiEnJ0euuNySRcbh7oabLlp1cq4QkYS5Qz4WBVeTAUAPqRjSYGTo+/TvUWOpQVxwHBJCE9QPQCZ708WvozlFpltt/m93woQJ2LVrF3JycvDrX/9ajpjclpxLZKWeIasAlNa0/XpEcmPukIeSPUPAtWLoXNG191KLdATHuC7jDLukvrIWOFJf649iMaRbDv/zGTduHIKCGp8L079/f+zbtw9xcXGyBeZurAIgDeDIkdR8PIF29Zv9cnk96QFzhzKU7hnqFCTmkhoLcPGqMu/RnEZL6hPGq/fGMjuUJf7exQSIh9+SPjncM7R9+/Zm74+Li8PJkyfbHJC7aviJy0OmpBbqKzbtFVUB8fJckshpzB3KUHIHakDscekeJjYBny4AuoUp8z7XO1NwBlmlWfDx9MHw2OHqvKkCpPPIRsUCBh3ccgvc+kknLA2KITlWkwFcXk/kDpTuGQK06RuSRoWGxw6Hr5evem8ssz1SMcTBT12za2ToN7/5jd0XNJlM+L//+z+nA3JXDUeG5BruZjFEWmPuUJ7Sq8mABivK1CyGXOCU+qtVwMk88XvuL6RvdhVDH3/8cZPmtYqKCvj6+sLjujkdJjTnWBqs+JIrqfFIDtIac4fylO4ZAq6NDJ1WqRgqrS7F4czDAAy+pP6y2AvaPQyIMuZ+kW7DrmKorKys0a/r6urg7e2N3bt3Y9CgQYoE5m4ajQxxmoxcBHOH8pQ8qFUijQxdvApU14kLNJS099Je1Fnr0CWsC+JCjDu/1LBfiPTNqc8SRl3iqGcN5/3l+u2VdqFmMUR6wdwhPzn3J2tJlD8Q5COOYJ9T4QR7V1hFBlwrhkYbt55zG2yg1gkl9gqRpsmKWQwRuSypZ0jJaTKTCehVPzp0Kl+59wHql9RL/UIGniLLKgUuXBVX4w3rqHU01BoWQzphUSCh8UgOItdnGxlSeNCtT6T4VWoIVkpaXhqulF9BO692GNxxsLJvpiBpVGhAlDiqRvrGYkgn6hRIaOwZInJ9SnyQak6f9uLXk1eUfR9pVGhk/Ej4eBq3ithTfwQHV5EZQ5v++XD+Xz5yHtIqsZ1cz9VkpDPMHfJR+jgOiVQMpV0BBAXPO3SFfiFBaNAvxGLIEOxaExAYGNhs8hozZkyzy2OLi4vlic6NKNEEyWky0hpzh/LUWFoPiMvDvc1ASQ1wuQSIC5b/PYoqi3A0+ygAYFzCOPnfQCVnCoErFYCPGRjUQetoyB52FUNz5szhJzmFSU2Qcv42S8VQea14No63Wb5rE9mDuUN5aiytBwAvs7jE/ngecCJPmWJo98XdsApW9IzoiZigGPnfQCXSqNCQGMBX4W0ISB52/TGtXbtW4TBIOqVVzoQW6COuZLAK4ugQN/0itTF3qMdDhZqzT3uxGDp5BZjRXf7rS6fUG3kVGcD9hYyIDdQ6YZVGhmS8pocJCK7vP2TfEJFrsiowqtwSJZuoLVYLdl3YBcDY/UJ1VmB/hvg99xcyDruKoQMHDjh84crKSl2dRD179myEhobi9ttv1zqUZkn9iHJ/umPfEGnJ6LlD73kDUOaDVEtsy+sVKIaO5x5HYWUhAn0CcVPMTfK/gUqO5wGlNeJyeql4JP2zqxgaN24cfvGLX2Dbtm2tPjc3NxevvvoqunTpgq+++qrNAcrl0Ucfxbp167QOo0VKfboLkVaUsRgiDRg9d+g9bwDKfZBqTu8IsejKKxdvcpJWkY2OHw0vs5e8F1eRtKR+RCflm9pJPnb1DJ08eRJPPvkkpkyZgg4dOmDs2LEYNGgQIiMj4evri8LCQpw7dw779+/HwYMHERoaihdeeAEPPvig0vHbbcKECdixY4fWYbRIqWKII0OkJaPnDr3nDUDdkaF2XkDXMOBsodhEPTFBvmvbltSzX4g0YFfd2rVrV3z++ec4efIk5syZg0OHDuGpp57CggULcPfddyM5ORmrVq2Cr68v3n77baSnp+Ohhx5qsnTWWbt27cKsWbMQExMDk8mEDRs2NHnOypUrkZCQAF9fXyQlJWH37t2yvLdabJ/uZL6u7eR6FkOkAS1zhzvkjYbUGBkCxB2VAeBojnzXzC/Px/Hc4wCMvaS+shY4nC1+z34hY3Fo0V/v3r3xxhtv4I033sCVK1eQlZWFyspKREREID4+Hl5eygxtlpeXY8CAAViwYAHmzJnT5PH169dj8eLFWLlyJUaNGoW3334b06dPR1paGuLijPE3UlBqmowjQ6QDWuQOd8gbgLoN1AAwMAr47BRwNFe+a+66KDZO94nqg/b+xm20Sc0StzGJDgC6hGgdDTnC6R0Q2rdvj/bt1flLO336dEyfPr3Fx//+979j4cKFuP/++wEAK1aswJYtW7Bq1SosW7bMofeqrq5GdXW17dclJSXOBe0gxRuouZqMdEKt3KFm3gC0yx1qTpMBwE3R4tejOeKHODmKMFfYdRpoPEXG7bWMxfDtXTU1NTh8+DCmTJnS6P4pU6Zg3759Dl9v2bJlCA4Ott1iY9WZ+FWsZ4gN1ERNyJ03AO1yhzSqrNY0Wa8IcWfl4mrxVPa2qrPWYfdFcXqS/UKkFcMXQ/n5+bBYLIiKimp0f1RUFHJyrk1qT506FXfccQc2bdqETp064dChQ81e7+mnn0ZxcbHtdvnyZUXjlwgKfbrjNBlRU3LnDUC73KH2NJmXGehbv8Rejr6ho9lHUVJdghDfEAyIHtD2C2qkuEpcVg+wGDIil9ko/Pot/wVBaHTfli1b7LqOj48PfHzUPynZqtCnOxZDRC2TK28A2uUONZfWSwZGi43CR3KAX/Zu27WkKbIxncfA7GHcM4P2ZYh/Fl1DxZ4hMhbDjwxFRETAbDY3+jQHAHl5eU0+9emZUiNDttVk7BkisnGVvAEolztupGHfUFu5yhEc0v5CHBUyJsMXQ97e3khKSsLWrVsb3b9161aMHDnS6eumpKQgMTERQ4YMaWuIdlG6gfpq9bWkSeTulMobgPq5Q+1pMkAcGQKAU/lAVZ3z18kty0VaXhpMMGFM5zHyBKeR3fXF0Nh4beMg5xhimqysrAxnz561/frChQs4evQowsLCEBcXhyVLlmDevHkYPHgwRowYgdWrV9v2K3FWcnIykpOTUVJSguBgBY5nvo7SDdR1VqCsRjy8lcgdaJE3APVzh/QZR82RoU6BQIQfkF8pbr442MkD5qWzyPpH90d4u3AZI1RXejFwqRjw9ACGd9Q6GnKGIYqh1NRUTJgwwfbrJUuWAADmz5+PtWvX4q677kJBQQFefPFFZGdno2/fvti0aRPi441TotsSmswZzddTvFXViX1DLIbIXbhD3gCU6ze8EZMJGNQB+OY8kJrtfDHkKrtOS6NCg6KZY43KEMXQ+PHjIbQyx7No0SIsWrRIpYjkZ0toClw71BfILhOX18cp/0GVSBfcIW8Ayn2Qas3QjmIxdDATeCjJ8dfXWmqx59IeAMbfX2jXJfErd502LsP3DClF7Xl/KDjvz/PJiNSjer+hBiNDADCsfjroUCZgsTr++sOZh1FWU4YwvzD0je4rb3AqqrOKK8kA9gsZGYuhFiQnJyMtLe2G+4rIScolSiS0EO5CTaQa1XOHBqvJACCxPeDvBZTUAKcLHH+9tIpsbMJYeJiM+1/RsVygpBoI8gH6R2odDTnLuH8DXYySK0KkJmqODBG5HqXONWyNp8e1XqEDmY6/fseFHQBcp19oVCxg5v+ohuXUH91PP/2Eu+++Gx06dIC3tzeOHDkCAHjhhRewfft2WQN0F0ruFRJS39DHIzlIa8wd8lNyVLk1Q+uLoYMOFkNZJVn4Of9neJg8MCbeRZbUs1/I0Bwuho4ePYohQ4Zg586dGD9+PCwWi+2xsrIyvPXWW7IG6C6UXBESwpEh0gHmDmVosemiZKjUN5Tl2D5m0hTZwA4DEeIXIn9gKimtBo5ki9+zedrYHC6G/vjHP6J///44e/Ys/v3vfzdarTF06FDV5smVptWmi0okNNvGiyyGSEPMHcrQqoEaAPpHiYe2Xqlw7NBWV5ki258JWASgczBX6hqdw8XQ3r178Yc//AHt2rVrcq7P9YccGpnaTZBKJjQWQ6QHzB3K0GLTRYmv57XdqPdn2Pea6rpq7Lu0D4DrLKkfw1VkhudwMSQIAry9vZt9rKioSJODCl2BknuFhHI1GekAc4cytDiOo6GRncSvey7b9/zUzFRU1FagvX97JEYmKheYCqTzyMZwiszwHC6G+vfvj88//7zZx77++mskJTmx+xYpujyWPUOkB8wdytBiB+qGpF6ZvZft229o53mxX2hcwrgmI4RGklECnL8KmE3AiE5aR0Nt5fAO1I899hh+9atfwd/fH/PmzQMApKen47vvvsO7776LTz/9VPYg3YGSCY3TZKQHzB3K0GoHasnAaCDQW8wvJ6+IfUQ3YusXShivdGiKklaR3RQt7jFExuZwMXTXXXfh3LlzeP755/HGG28AAObMmQNPT0+88MILmDVrluxBugM1pslKa4BaC+Bllv89iFrD3KEMW7+hRu/v6SGOjHxzXiwQblQMpV9Nx7nCczCbzBjdebR6QSpgN6fIXIpTZ5M988wzuPfee7Flyxbk5uYiIiICU6dONdwBhzeSkpKClJSURst/laRkA3WQjzj9JkD89NbeX/73ILIHc4f8tNp0saHRcdeKoeQbLKKTltQndUxCoE+gStHJz2Jt0C/kOn913ZrDxdCuXbswaNAgdOrUCQsXLmz0WFlZGY4cOYKxY8fKFqBWkpOTkZycjJKSEgQHK79mUsm9QsweQLCvWAgVsRgijTB3KENq09GyGJJGRw5nAxW1QDuv5p8nFUNGnyI7kQcUVwNB3sCAVqYFyRgcHlmdMGEC0tLSmn3s9OnTmDBhQpuDckdKrwjhLtSkNeYOZWh1NllDCSFAx0CgxtLy0RxVtVX4Pv17AMbfX2hH/ZL6EbHiNCEZn1NL61tSW1sLDw/+zXCG9Luq1IoQ6XwyFkOkFeYOZWi56aLEZLo2OiTtvXO9AxkHUFVXhejAaPSI6KFecArYflH8OqGzllGQnOyaJispKcHVq1dtv87JyUF6enqj51RWVuK9995DdHS0rAG6C6U/3dlOrmcxRCpi7lCeHoohQCwMPjoJbLsA/Hls01HuXRd2AQDGdh5r6CX1RZXA0fr9QcezX8hl2FUMvf7663jxxRcBACaTCbNnz272eYIg4JlnnpEvOjeidEILZTFEGmDuUJ6WO1A3NCYO8DYD6cXAmUKgR3jjx3df3A1ALIaMbFe6+HveKxzoYNwecLqOXcXQlClTEBAQAEEQ8Ic//AGPPPII4uIaryf08fFBv379MG7cOEUCdXVK7xVi22uIu1CTipg7lKf1DtQSf29xN+odl4Bt5xsXQ5nFmbYl9aPiR2kXpAx2XBS/ju+sZRQkN7uKoREjRmDEiBEAgPLycjzwwAOIiYlRNDCtqb08VvFpMu5CTRpg7lCeXoohAJjUpb4YugAsarDEftdFcYpsQIcBCPIN0ii6trMKwM76nigWQ67F4Y7FpUuXunwyA1zroFaA02SkPeYOZSi9+MIRNyeIX49kAwUV1+53lSmyE3lAQSUQ4A0M7qB1NCQnpzZdtFgs2Lx5M06dOoXKysbzLiaTCX/6059kCc6dKL1XCI/kID1g7pCfknuUOSomEOjTXjyWY/tF4PZEoNZSi72X9gIAxiYYuxiSVpGNiuVO/q7G4WKooKAAY8aMwU8//QSTyWRbLttwdQATmuOUHhniajLSGnOHMvSymkwyKUEshr45LxZDP2b/iLKaMoT4hqBvVF+tw2sTLql3XQ5Pkz377LPw9fXFpUuXIAgCDhw4gDNnzmDJkiXo0aNHk2WzZB+lP91J+wwVsYGaNMLcoQw97EDd0LRu4tcdF4Gymmv9QqPiR8HsYdzhFC6pd20OF0PffvstlixZYpv79/DwQNeuXfHqq69i0qRJePLJJ2UP0h2otQN1cfW1wotITcwdytDTNBkA9I4AuoQA1RZxVZmtX8jgU2TSkvqeXFLvkhwuhjIyMtC5c2eYzWZ4eHigvLzc9tisWbOwdetWWQN0F0rvFSKNDNVYxLODiNTG3KEMPa0mA8Q4ZtZvMP35qUIczzkOABjTeYyGUbUdl9S7NoeLoYiICBQXFwMAYmJicOLECdtjhYWFqKurky86N6RUQvPzBHzqR6jZN0RaYO5Qlk5qIQDALd3Fr3vT90CAgJ4RPREVYNwTTRstqecUmUtyuIE6KSkJJ0+exMyZMzFjxgy8+OKLCAoKgre3N5555hkMHz5ciThVp/ZeIUozmcQm6txysRjqZNytPsigmDvcR89woFsYcD5vNzxg/CmyH3MbLKl3/d0h3JLDI0MPP/wwgoODAQAvvfQSoqOjce+992Lu3Lkwm834xz/+IXuQWlB7rxA1cBdq0hJzh/swmYCZ3QSYBLFfyOhTZFvPi1/Hx4tHjpDrcXhkaNKkSZg0aRIAoH379vjhhx9w4sQJmEwm9OrVC56eTm1dRCrgLtSkJeYO95IY8RNMuALAD13CBmsdTptsqy+GJnXRNg5SjkMjQ5WVlRg1ahS2bdtmu89kMqFfv37o27cvk5nOcRdq0gpzh/u5VCQuqbeahmPzWR+No3FeejFwugAwm7i/kCtzqBjy8/PD8ePHmbgMirtQk1aYO9zPrgtiMSSYxuCTUxoH0wbSqNCQjtc2ryXX43DP0IgRI3Dw4EElYnFramz9w5Eh0hJzh/sorynH4czDAABPz7FIuwKkXdE4KCdtuyB+nZygbRykLIeLoddeew1vv/021q1bh7KyMiVicmtKLo+VeoY4MkRaYO5Qlp6W1h+4fAC11lrEBsdiUpfOAIBPDTg6VFwNHMgUv5/MfiGX5tTIUEZGBhYsWIDg4GAEBgYiKCjIdpNWi5D+SLtQ80gO0gJzh/uQdp0e03kM7ugjlmkbfgJqDbbbwM6LQJ0V6B4GxIdoHQ0pyeEJ/Dlz5jQ6WJGMI5QjQ6Qh5g73se/SPgDA6PjRGBcPtG8HXKkQD2+d2V3j4BwgLannqJDrc7gYWrt2rQJhkBp4cj1pibnDPeSU5uBs4VmYYMLwuOHw9ADu6gO8eQj49zHjFEO1lmtHcHBJvetzeJqMjIsN1ESktH3p4qhQv+h+CPYVpz5/1RfwMAHfZwA/F2gZnf32ZQAlNeKo1kDjniRCdmIx1IKUlBQkJiZiyJAhWociG6kYKqkW58GJSH6umDscsffSXgDAqPhRtvs6Bl2banr/uBZROW7TGfHr1K6Amf9Tujz+EbdA7S31BRXW1gc32COjmKNDRIrQKnfooR1LEARbv9DI+JGNHpvXT/z62SmgrEbtyBxTZwW2nBO/n2GQaT1qGxZDOqNkQvP0AIKkFWUshohIZmcLziKvPA8+nj5Iiklq9NioOKBLiFgIff6TNvHZa3+GmCPD/IBhHbWOhtTAYsjNsG+IiJSyN12cIhvScQh8PBsfweFhAu4dIH7/zhHAouOp+s1nxa9Tu4ofIsn18Y/ZzUjFEKfJiEhuLU2RSe5MBIJ9gIvF16ah9MZiBb6uL4ZmdNM2FlKPw0vr09PTW3zMw8PDtpka6VMwR4ZII8wdrq3WUosDlw8AaNw83ZC/tzg69M+DwFuHgend9NHr1NDBLCC/UtyKZEQnraMhtThcDHXu3LnVjdO6d++Op59+GvPnz3c6MFIGp8lIK8wdru1YzjGU1ZQhxDcEiZGJLT7vvgHA6sPAj7niURfDdVZwfPWz+HVKF8DLrG0spB6Hi6HVq1fjlVdeQbt27XDnnXciKioK2dnZ+OSTT1BZWYnf/e532Lp1K37zm9/A29sbd999txJxk5Nsu1DzSA5SGXOHa7NNkcWNhIep5Q6MiHbAHYniEvtVqfoqhmoswP/ql9TP6qFtLKQup6bJ+vTpgy+++KLRp7ylS5di1qxZKCwsxDfffIM5c+bg9ddfZ0Kzkxqn1gMcGSLtMHcoQ8odWs82Sc3TLfULNfTAIODDE8COS8CxXKC/TjY13HVJzI3t2wGjYrWOhtTkcAP1mjVr8NBDDzUZ7jaZTPjtb3+LdevWAQDuuecepKWlyROlG1E6ofFIDtIKc4frKq8pxw9ZPwBouV+ooc4hwG09xe9f+17BwBz03/ol/7/oyY0W3Y3Df9z5+fmorGx+jqWqqgpFRUUAgPDwcAhq7CRIDuHIEGmFucN1Hcw4iDprHWKDYxEXEmfXax4bBphN4ujQ4WyFA7RDSTWwrf5g1tm9tI2F1OdwMTRw4EC88sortsQlKSwsxF/+8hcMHDgQAHD58mVER0fLEiTJRyqG2DNEamPucF3fXxKHd0bEjbD7NZ1DgNvr+6z/roPRoc1ngWoL0D0M6NNe62hIbQ73DL366quYMmUK4uPjMXHiRERFRSE3Nxffffcd6urqsG3bNgDADz/8gFmzZskeMLWN1EDNkSFSG3OH69qfsR+AY8UQADw6FPjvKWDPZXHXZy2bqf97Svz6y176W+5PynO4GBo9ejT279+Pl19+Gbt27UJBQQHCw8Mxffp0PPvss+jfvz8A4LXXXpM9WGq7htNkgsB/9KQe5g7XVFJVgrRcscdraKehDr22UxAwty/w72PAX3YDG+eKO1Wr7XwRsD9TfO/bOEXmlhwuhgCgf//++Pjjj+WOhVQQVj8yVGMBymuBAG9t4yH3wtzhelIzUyFAQOfQzogOdHx687Gh4lllx/KADT8Bv+ytQJCt+PCE+HVCZyCG+366JfbLtyAlJQWJiYkYMmSIOm+oUr+onxfgW18Cc6qMSH5q5w7b0nqNRnn3XxanyIbFDnPq9e39gYfrf6v+ug+oqJUrMvtU1QGf1i9evKevuu9N+uHUyNCePXvw4Ycf4tKlS01Wh5hMJnz77beyBKel5ORkJCcno6SkBMHBwaq9rxr5LNQXyC4DiiqB2CAV3pCoHnOH65GO4BgeO9zpaywYKG7CmFEi7k692PlLOezrs+IHww4BwLjO6r0v6YtT+wyNHTsWH3/8MYqKiiAIQqOb1arjo4gJAJuoSRvMHa6npKoEaXnO9Qs15OsJPDNa/H7VYSC9WI7o7PP+cfHr3D48od6dOTwy9Le//Q133nkn3nvvPfj4+CgREyksrL6JupDL60lFzB2uJzUzFVbB6nS/UEMzugEjOwH7MoBnvwPW3ab81N8POcChLMDLQ2zkJvflcB186dIl3H///UxmBmYbGWIxRCpi7nA9be0XashkAl6ZCPiYgV3pwIbTbb5kq/51RPz6i55AdIDy70f65XAx1Lt3b+Tm5ioRC6mEu1CTFpg7XI8c/UINJYQCj9TPtr20S9kPbOnF4kaLgHhWGrk3h4uhV155BcuXL0dmZqYS8ZAKQjlNRhpg7nAtcvULXe+3SUCPcKCgEnjmO3E/NCW8lQpYBWBcPNArQpn3IONwuGcoJSUFxcXF6NGjBwYOHIjw8PBGj5tMJmzcuFG2AN2FmicxsYGatMDcoQytjnGTs1+oIW8z8NpkYPbHwKazwKengDsSZbs8AHFUaH39cvpHVNo9hfTN4WLo2LFjMJvNiIyMRFZWFrKysho9fv2J1OQgFX77wtgzRBpg7nAt0hSZHP1C1+sfBTwxXNx3aOkOYEiMeJaZXF7fD9RZxVGhIR3luy4Zl8PF0MWLFxUIg9TEniHSAnOHa5G7X+h6v00Cdl4Sj8lYtAn47A5x09i2Op4n7ngNAL937Cg1cmHcVcENSdNk7BkiImeU15Tb+oUGdxysyHuYPYDXpwLhfsDJK8AftrV9StAqAM99J7Yl3NoD6BclS6jkAlgMuSFpZOhqlXb9BkRkXEezj8IiWBATGIOYoBjF3icmEFg1U9wM8YufgZRDbbveB8eBo7nimYzPjZUnRnINdhVDZrMZBw8eFF/g4QGz2dzizdPTqRM+SEVSz1C1Rf1zgMi9MHe4piOZ4gY9gzspMyrU0LCOwAvjxO9f/R54/5hz1zlTCLy8W/z+ieFAlL888ZFrsCv7/PnPf0anTp1s37PR0dj8PMWNzaotYt+QP0+uJ4Uwd7im1MxUAEBSTJIq7/fr/kBWKZCSCjy3XVxxdmcf+19fWg0kbxIPZR0dC9w3ULFQyaDsKoaWLl1q+/75559XKha3puZ0lckk9g3l1B/W2omHtZJCmDuUp/ap9XXWOvyQ9QMAdUaGJL8fCZTXAmt/BH6/TTxs+tGhrf/cVXXAQ/8DThcA7dsBf58KeLAmp+s41DNUWVmJjh074ssvv1QqHren1r9R2/lkXFFGKmDucB2nr5xGeW05ArwD0D28u2rvazIBS8eJq8wA4O/7gYVfAnnlLb8mvwL49efAnsuAvxew5hecHqPmOVQM+fn5obKyEv7+/NtkdDyfjNTE3OE6DmceBgAMihkEs4dZ1ff2MImn2/9lgjhV9u0FYOI64LXvG590X1wtjiBNfl88iDXIG3j3VqBfpKrhkoE43LF48803Y9u2bZg4caIS8ZBKuNcQqY25wzXY+oU6qtMv1Jxf9wcGxwBPbAVO5AFvHBRvYX5iP2RO2bXpw94RwBvTxCM+iFricDH0zDPPYM6cOfD19cUvf/lLdOjQoUlTZFhYmGwBkjK41xCpjbnD+ARBsI0MKbW/kL16RQBfzhUPW33/mLg5Y8N81j0MmNcfuLuvOIpEdCMOF0NJSeKngeeffx4vvPBCs8+xWCxti4oUx5EhUhtzh/FllWQhpywHnh6eGNBhgNbhwMMEzOwu3spqgEvFgMUKRAWwN4gc43AxZMTlsV999RWeeOIJWK1WPPXUU7j//vu1DklzPJ+M1MbcYXyHs8RRoT6RfeDn5adxNI0FeAN92msdBRmVw8WQ0ZbH1tXVYcmSJdi+fTuCgoIwaNAg/PKXv9TdcLzaG0FLI0OcJiO1MHcoQ9qWQ40yMzVD+34hIiW4/HEcBw8eRJ8+fdCxY0cEBgZixowZ2LJli9ZhtUitD85Sz9BVTpMRNctouUMNR7LEnadZDJGrsWtkaN26dZg5cybCw8Oxbt26Vp9/7733tjkwya5du/Dqq6/i8OHDyM7Oxueff47bbrut0XNWrlyJV199FdnZ2ejTpw9WrFiBMWPGAACysrLQsWNH23M7deqEzMxM2eIzKu4zRGpg7nAdFTUVOJ1/GgAwsMNAbYMhkpldxdB9992H/fv3Izw8HPfdd98Nn2symWRNaOXl5RgwYAAWLFiAOXPmNHl8/fr1WLx4MVauXIlRo0bh7bffxvTp05GWloa4uDgIzWztbLS+BSU03GdIENQbkSL3wtzhOk7knoBVsCI6IBrRgdFah0MkK7uKoQsXLiAmJsb2vZqmT5+O6dOnt/j43//+dyxcuNDW2LhixQps2bIFq1atwrJly9CxY8dGn+YyMjIwbNiwFq9XXV2N6upq269LSkpk+Cn0R+oZqrYAlXVAOy9t4yHXxNzhOn7M+REA0L9Df40jIZKfXT1D//jHP5CTkwNA/GQUExOD+Pj4Fm9qqampweHDhzFlypRG90+ZMgX79u0DAAwdOhQnTpxAZmYmSktLsWnTJkydOrXFay5btgzBwcG2W2xsrKI/g1baeYmbkwFsoiblMHe4jh+zxWJoYPRAbQMhUoBdxdCKFSuQnZ0NAEhISMAPP/ygaFD2ys/Ph8ViQVRUVKP7o6KibAnY09MTr732GiZMmICbbroJv//97xEe3vJWpE8//TSKi4ttt8uXLyv6M2jFZAJCuNcQKYy5Qz1Kz+AdzT4KALrYX4hIbnZNk4WGhiI3NxeAuAOp3ubNr4/n+hhvvfVW3HrrrXZdy8fHBz4+PrLGZw81T62XhPkBueXca4iUw9yhPDVSR15ZHrJLs+Fh8kC/6H4qvCORuuwqhoYPH46FCxdi6NChAIAnnngCISEhzT7XZDJh48aNsgV4IxERETCbzbZPcpK8vLwmn/iMQs3/KrjXECmNucM1SKNC3cK7wd+bWzuT67GrGFq5ciUWL16MkydPwmQy4ezZsy1+AlLzk5+3tzeSkpKwdetWzJ4923b/1q1b8Ytf/KJN105JSUFKSopLHw9gW1HGaTJSCHOHaziWcwwAl9ST67KrGIqPj8fnn38OAPDw8MCGDRtsn/SUVlZWhrNnz9p+feHCBRw9ehRhYWGIi4vDkiVLMG/ePAwePBgjRozA6tWrkZ6ejoceeqhN75ucnIzk5GSUlJQgODi4rT+GLtnOJ+PIECmEucM1cgf7hcjVOXwcx/bt25GYmKhELM1KTU3FhAkTbL9esmQJAGD+/PlYu3Yt7rrrLhQUFODFF19EdnY2+vbti02bNqm6MsWoODJEamLuMCaL1YLjOccBcGSIXJfDxdC4ceOUiKNF48ePb3bzs4YWLVqERYsWqRSR6wjjajJSEXOHMZ0rPIeymjL4efqhW3g3rcMhUoTLn03mrJSUFCQmJmLIkCFah6IYaWSIDdRE8tEqdyjVcXUsW+wX6hfdD54eDn9+JjIEFkMtSE5ORlpaGg4dOqTK+2mwsv5azxBHhohko3buUDp5nMg7AQDoF8Ul9eS6WAzpjJrbsIQ1OJ+MiKg5J3NPAgD6RPXROBIi5bAYcmOcJiOiG7FYLTiVdwoAiyFybSyG3Fijw1prtY2FiPTnQtEFVNZVws/TDwmhCVqHQ6QYp7rh9uzZgw8//BCXLl1CZWXjYQWTyYRvv/1WluC05Iobp13P3wvwNgM1FnF0qCNPrieFMXcYizRF1juyN8weZo2jIVKOwyNDa9aswdixY/Hxxx+jqKgIgiA0ulmtViXiVJ3qTZAaaHhYayGbqElhzB3GczKP/ULkHhweGfrb3/6GO++8E++9954mhxKSvMJ8gbxy4Cr7hkhhzB3KUmLthTQy1DeyrwJXJ9IPh0eGLl26hPvvv5/JTGZaLK0HGjRRc2SIFMbcoQylcocgCBwZIrfhcDHUu3dv5ObmKhELQd1T6wHuNUTqYe4wlsvFl1FaXQpvszd3niaX53Ax9Morr2D58uXIzMxUIh5SGfcaIrUwdxiLNEXWM6InvMxcXUGuzeGeoZSUFBQXF6NHjx4YOHAgwsPDGz1uMpmwceNG2QLUiiutCLkRWwM1iyFSGHOHsXCKjNyJw8XQsWPHYDabERkZiaysLGRlZTV63KTmFsoKSk5ORnJyMkpKShAcHKx1OIqRRoaucpqMFMbcYSwncsVjOFgMkTtwuBi6ePGiAmGQVrgLNamFucNYTl85DQDo3b63xpEQKY87ULu5UO4zROQS5BxYK6woRF55HgCgR0QP+S5MpFMshnRC0GhtfVh9McR9hoiMSYnUcTpfHBWKC46Dv7e/Au9ApC92FUNmsxkHDx4UX+DhAbPZ3OLN09OpEz6onupL67nPECmIucOYpGKoR3uOCpF7sCv7/PnPf0anTp1s37tKoyNdmyarqhMPa/XjClqSEXOHMUn9Qj0jemocCZE67CqGli5davv++eefVyoWXXGV5bGtCfAGvDyAWqu48SKLIZITc4cx/Zz/MwAWQ+Q+2DPUAlc6bPFGGh3Wyr4hojYzeu6wClZbMdSrfS+NoyFSB4sh4l5DRGRzufgyKmor4G32RnxovNbhEKmCxRBxryEiFyBXN5bUL9Q9vDs8PdjUTu6BxRBxryEiA5N7Ww7bSjLuL0RuhMWQzmix2IZ7DRGRxLaSrD2bp8l9sBgi7jVERDbSyBCbp8mdOFUMVVdX4+2338bdd9+NyZMn48yZMwCAjRs34vz587IGSMqTpsmKODJECmPu0LfqumpcLLoIgNNk5F4c7o7Lz8/HhAkTcPLkSURHRyM3NxelpaUAgA0bNmDLli1YuXKl7IGqzRX2CrGXtJqsiCNDpCDmDv27WHQRVsGKAO8ARPpHah0OkWocHhn6wx/+gKtXryI1NRXp6ekQGnTvTZgwATt37pQ1QK0Yfa8QR3CfIVIDc4f+nSs8BwDoFt6Nu4WTW3F4ZOirr77CX//6VwwaNKjJJ59OnTohIyNDtuBIHdxniNTA3KEsOWoXqRjqGta17RcjMhCHR4ZKSkoQH9/8Rly1tbWoq6trc1DuSKtT64FrxRBHhkhJzB3KkDN1nCtgMUTuyeFiKCEhAd9//32zjx08eBA9e3I5ptFI02SVdeKBrURKYO7QP9vIUDiLIXIvDhdD99xzD/76179i48aNtjl/k8mEQ4cO4R//+AfmzZsne5CkrEBvwLP+bwJXlJFSmDv0zSpYcb5QXNHHYojcjcM9Q0899RT27t2L2bNnIzQ0FAAwdepUFBQUYNq0aXjsscdkD5KUZTKJy+uvVIh7DXUI1DoickXMHfqWVZKFqroqeJu9ERscq3U4RKpyuBjy8vLCpk2bsH79evzvf/9Dbm4uIiIicMstt2Du3Lnw8OA+jkYU6icWQxwZIqUwd+ibNEUWHxLPM8nI7Tj1N95kMmHu3LmYO3eu3PGQRqQjObjXECmJuUO/pObpbuHdNI6ESH38KEYArjVRF3BkiMgtnS08CwDoEtZF40iI1OfwyFBCQkKLm3F5eHggJCQEQ4YMwaOPPorevXu3OUB3oeHKegBAuLQLNYshUghzhzLk2pZDap7myBC5I4dHhsaNGwdBEJCZmYnOnTtj2LBhiI+PR2ZmJiwWC2JjY/Hf//4XgwcPRmpqqhIxqyIlJQWJiYkYMmSIqu+r1aavodxriBTG3KFv3GOI3JnDxdDUqVPh4+ODs2fP4rvvvsN//vMfbN++HWfOnIGPjw9uu+02/Pzzz+jRoweWLl2qRMyqMPKW+s4IZzFECmPu0K+rlVdRWFkIAEgITdA4GiL1OVwM/eUvf8Hzzz+P2NjGSy/j4uLw5z//GcuXL0dwcDAef/zxFjdYI/2RdqFmzxAphblDvy5evQgAiA6IRjvvdtoGQ6QBh4uhs2fPIjg4uNnHQkNDcfHiRQBA586dUVFR0abgSD0cGSKlMXfo16WiSwCA+NDmj0shcnUOF0Px8fFYu3Zts4+9++67iIuLAwAUFBQgLCysTcGRetgzREpj7lBWW/oNL12tL4ZCWAyRe3J4NdmTTz6J3/72t8jIyMAdd9yBqKgo5Obm4uOPP8aBAwewevVqAMD27dsxePBg2QMmZdhWk1WJq1O0auQm18XcoV8Xiy4CADqHdNY0DiKtOFwMPfDAAxAEAc8//zyWLFliuz86OhpvvfUWFi5cCAB49tln4ePjI1+kLk7LU+uBaz1DdVagpBoI9tU2HnI9zB3KkCN1SCNDnUM7y3A1IuNxagfqBx98EA888ABOnz6NgoIChIeHo2fPno32EImKipItSHei1YCMjycQ4A2U1YhN1CyGSAnMHfpkmyZjzxC5KacPoDGZTOjVq5ecsZDGQn3FYqiwEugSqnU05KqYO/SluKoYRZVFAIC44DiNoyHShlPFUGlpKTZv3oxLly6hsrJxx63JZMKf/vQnWYIjdYX7AZdL2ERNymHu0B9pJVlUQBSX1ZPbcrgYOnDgAGbOnInCwsJmH2dCMy7uNURKYu7QJ2mPIa4kI3fm8NL6xx9/HB07dsTBgwdRVVUFq9Xa6GaxWJSIk1QQxuX1pCDmDmU5229o22OIxRC5MYdHho4fP44PP/yQS19dEIshUhJzhz5JI0NcSUbuzOGRofbt2ysRh9vT+tR6gLtQk7KYO5TR1m05uOEikRPF0COPPIK33noLgtYb45Ds2DNESmLu0CcexUHkxDSZ1WrFTz/9hJtuugkzZ85EeHh4o8dNJhMef/xx2QLUSkpKClJSUlTvY9By52dOk5GSmDv0p7S61HZafVwIl9WT+zIJDn5M8/C48WCSyWQyRBKwV0lJCYKDg1FcXIygoCDF3ue174E3DgLzBwAvjlfsbW7oSDYw+2OgUyCw9zfaxECui7lDGT3eBKotwN4FQCcH3+ZU3incsu4WhPmF4VDyIWUCJDIAh0eGLly4oEQcpAPhnCYjBTF36E9GSQYAoFNwJ40jIdKWw8VQfDznlV2VNE1WWQdU1gJ+XtrGQ66FuUNZzsywZxTXF0NBLIbIvTncQE2uK8Ab8Kr/G8HRISLXZyuGODJEbs6p4zh27dqFN954A6dOnWp2S/1z587JEpw70cP6GpNJHB3KLQeKKh3vPyBqDXOHvnCajEjk8MjQnj17cPPNN6O4uBinTp1Cr1690LFjR6Snp8PT0xNjx45VIk5SCfuGSCnMHfojjQx1DOqocSRE2nK4GFq6dCkWLFiAr7/+GgDw8ssvY/fu3Thy5AjKysrwy1/+UvYg3YmGK+sBcHk9KYe5Q18EQbAVQ7HBsRpHQ6Qth4uhEydOYPbs2TDVb4gjLYXt378//vSnP+HFF1+UN0JSFTdeJKUwd+hLSXUJymrKAHBkiMjhYqiiogIBAQHw8PCAj48P8vPzbY/16tULaWlpsgZI6pKKoSIWQyQz5g59uVx8GQAQ0S4Cvl6+GkdDpC2Hi6G4uDjk5uYCABITE/G///3P9tjOnTub7CpLxsKRIVIKc4eyHN29PrM4EwCnyIgAJ1aTjR8/Hjt27MDtt9+OBx54AIsWLcKpU6fg4+ODb775Bk888YQScZJKeFgrKYW5Q1+klWQdgzlFRuRwMfTCCy+gsFA8y+ahhx5CRUUFPvjgA5hMJjz33HN49tlnZQ/SHejl7MpQjgyRQpg7lOFs6pCmybjhIpETxVBERAQiIiJsv16yZAmWLFkia1CknXD2DJFCmDv0RZom4x5DRNyBWne0PLUeYM8QkbvghotE1zi1A/WePXvw4Ycf4tKlS83uIvvtt9/KEhypTxoZKq4Gai2Al1nbeMi1MHfogyAI10aGOE1G5HgxtGbNGixcuBBhYWHo0aMHfHx8Gj0u6KX5hZwS4itu/CgAuFoFtPfXOiJyFcwd+lFcVYzy2nIAQExQjMbREGnP4WLob3/7G+6880689957TZIZGZ/ZQyyIiqrEFWUshkguzB3KcmSGPbs0GwAQ5hcGH0/+WRA53DN06dIl3H///UxmLox9Q6QE5g79yCnNAQB0COygcSRE+uBwMdS7d2/bxmkkHz1NEPB8MlICc4cynJldlEaGWAwRiRwuhl555RUsX74cmZmZSsSjmNmzZyM0NBS333671qHoHoshUoIRc4er5o2s0iwALIaIJHb1DN16662Nfl1cXIwePXpg4MCBTbbQN5lM2Lhxo3wRyuTRRx/Fb37zG7z33ntah3JDWp9aD3AXapKP0XOHUfKGo6SRoejAaI0jIdIHu4qhY8eO2U6aBgCz2YzIyEhkZWUhKyur0XNNWm+U04IJEyZgx44dWodhCOwZIrkYPXe4at5gzxBRY3ZNk128eBEXLlyw63b+/HmHg9i1axdmzZqFmJgYmEwmbNiwoclzVq5ciYSEBPj6+iIpKQm7d+92+H3IPpwmI7komTuYNxpzpJZkzxBRY7rYgbq8vBwDBgzAm2++2ezj69evx+LFi/Hss8/ihx9+wJgxYzB9+nSkp6fbnpOUlIS+ffs2uV3/6ZNax2KIjIB5wzmCICCnTBwZ4jQZkciuabKioiLcf//9WLBgAW655ZZmn/PVV19hzZo1WL16dZNegNZMnz4d06dPb/Hxv//971i4cCHuv/9+AMCKFSuwZcsWrFq1CsuWLQMAHD582KH3bEl1dTWqq6ttvy4pKZHlukbCniGSi5K5Q095AzBO7iiqLEJ1nRhnVECUxtEQ6YNdI0PvvPMOfvzxR0ybNq3F50ybNg3Hjx9HSkqKbMEBQE1NDQ4fPowpU6Y0un/KlCnYt2+frO8FAMuWLUNwcLDtFhsbK/t7NEtHa+vZM0Ry0Sp3qJ03AO1yh6OpQ5oii2gXwQ0XierZVQx99NFHeOCBB+Dp2fJAkqenJx544AF88cUXsgUHAPn5+bBYLIiKavwJJioqCjk5OXZfZ+rUqbjjjjuwadMmdOrUCYcOHWr2eU8//TSKi4ttt8uXL7cpfiOSiqGiKuf2MCGSaJU71M4bgHFyB1eSETVl1zTZzz//jMGDB7f6vEGDBuGll15qc1DNuX6liSAIDq0+2bJli13P8/Hx0XSHXD2sp5GKoTorUFIDBPPDIzlJ69yhVt4AtM8d9mLzNFFTdo0M1dXVwcvLq9XneXl5oba2ts1BNRQREQGz2dzk01xeXl6TT30kD19PwL/+j7uwQttYyNi0yh3MGy3jsnqipuwqhjp06IC0tLRWn3fy5ElER8s79Ort7Y2kpCRs3bq10f1bt27FyJEjZX2vhlJSUpCYmIghQ4Yo9h56xr4hkoNWuUOrvAFolzvsHe/iNBlRU3YVQ+PGjcPKlStv+MmttrYWq1atwoQJExwOoqysDEePHsXRo0cBABcuXMDRo0dtS2CXLFmCd955B++++y5OnTqFxx9/HOnp6XjooYccfi97JScnIy0t7YY9Aq6MK8pIDkrmDj3mDUD/uYPTZETNEOzw448/Cl5eXsLMmTOFzMzMJo9nZmYKM2bMELy9vYVjx47Zc8lGtm/fLkBcFNHoNn/+fNtzUlJShPj4eMHb21sYNGiQsHPnToffxxnFxcUCAKG4uFjR9/nrHkGIWyEIL+xQ9G3stmCjGM+Hx7WOhIxMydyh57whCOrlji5viP9Wc0rte/74f40XurzaRTiQfkDRuIiMxK4G6v79+yMlJQWLFi1CQkICkpKSkJCQAED8NHb48GFYrVasWrUK/fr1c7ggGz9+PIRWli0tWrQIixYtcvjaRqG3RVvSyFA+e4aoDZTMHcwbIkdWfAqCgCtlVwAAkQGRCkVEZDx2FUMA8MADD6Bv37545ZVXsH37duzfvx8A0K5dO0ybNg1PP/00hg8frligaktJSUFKSgosFovWoWgiop34lcUQtRVzh36U1ZShsk6c+470ZzFEJLG7GAKAESNG4Msvv4TVakV+fj4AcdWGh4cuTvWQVXJyMpKTk1FSUoLg4GD13lgPa+txrRhiAzXJgblDH66Ui6NCAd4BaOfdTuNoiPTDoWJI4uHhgchIfqpwZZwmIyUwd2grtywXANDev73GkRDpi+t9LCNZcGSIyGDsGFWWRobYL0TUGIshahZ7hohcT15ZHgD2CxFdj8VQC9x900VpmqyoUjyWg4jso+fckVfOYoioOSyGWqD2xml6OxA11E8cdRcgFkREZB/Vc4cDz5WmydoHsGeIqCEWQ9QsT49rR3JwqozINUgN1FEB7n0+G9H1WAzpjE5W1gMAwtlETeRSbCNDXE1G1AiLIWoRl9cTuRY2UBM1j8UQtag9V5QRGUZro8qVtZUoqykDwKX1RNdjMdQCPa8IUQunyYgcp9fcIa0k8/P0Q4B3gMbREOkLi6EWqL0iRI84TUbkOL3mDumA1vYB7WEy6ak7kUh7LIZ0Qmcr6wFw40UiI7B3Ww5pJRn7hYiaYjFELeKRHESugxsuErWMxZDO6Gn0WpomK+DIEJHhFVQUAAAi/CM0joRIf1gMUYts02SV+tshm4gcw2KIqGUshqhFUjFUVQeU12obCxHdWGuDylIxFN4uXPlgiAyGxVAL9Lo8Vk3tvAA/T/F7TpUR2UevuUMqhsL8wjSOhEh/WAy1QK/LY9XWcKqMiFqn19zBkSGilrEY0gm9tuRweT2RvtmbO1gMEbWMxRDdEFeUERlfRU0FKmrFf8QshoiaYjGkMzpaWQ+A02RErqCwshAA4G325lEcRM1gMUQ3FM5pMiLDazhFxqM4iJpiMUQ3FMFpMiJDuFGNw34hohtjMUQ3xGkyIuNjMUR0YyyGWqDXvULUJk2TcWSIyD56zB0shohujMVQC9TeK0Svx11I02TsGSKyjx73GSqsEBuoWQwRNY/FEN2QNE1WVAXUWbWNhYicU1DJkSGiG2ExpDN6W+gR4gt41MdUyL4hIkPiNBnRjbEYohsyewBhvuL3nCoj0q8bfY5iMUR0YyyGqFU8koPI2FgMEd0YiyFqFYshIuMSBIHFEFErWAxRq9r7i1/zWAwRGU5JdQnqrHUAgDC/MI2jIdInFkM6odOV9QCAyPpi6Eq5tnEQUWP2bMlRVFkEAGjn1Q4+nj4KR0RkTCyGqFXt66fJ8lgMERnO1aqrAIAQ3xBN4yDSMxZDOqOzlfUArhVDVzhNRmQ40shQqF+oxpEQ6ReLoRbocUt9rUjTZBwZImqdVrmjpT3KrlZeBQCE+IWoFguR0bAYaoEet9TXitRAzZEhotbpLXdwmoyodSyGqFWR9dNkJdVAVZ22sRCRY2wjQyyGiFrEYohaFeQD+JjF7zk6RGQstpEhTpMRtYjFkE7o9dR6QOxFsDVRs2+ISDfsSRtsoCZqHYshsgv7hoiMiT1DRK1jMaQzelxaD3CvISKj4moyotaxGCK7cBdqIn1r6YOUNDLEaTKilrEYIrtw40UiY+JqMqLWsRgiu7TnxotEhlNjqUF5rfiPliNDRC1jMUR2iWQDNZHhSKNCHiYPBPoEahsMkY6xGNIJHa+sB8Cl9UR61NqWHNKy+mDfYHiYmO6JWsJ/HWSXhj1Det4TiYiu4bJ6IvuwGNKZlg5b1FpEfTFUawWuVmkbCxHZh8vqiezDYojs4uMJhPiK37NviEh/mvsgZVtW78vmaaIbYTHUgpSUFCQmJmLIkCFah6Ib3HiRqHV6yh0cGSKyD4uhFiQnJyMtLQ2HDh3SOhTdkFaU5XFkiKhFesod7Bkiso+n1gGQcUgjQxnFZfj65z04mXcSGcUZuFx8GRnFGSiuKobJZILZZIbZwwyzyQwPk0ej70P9QtE1vCu6hnVF9/Du6BreFfEh8fAye2n7wxG5oJLqEgBAkG+QxpEQ6RuLIb3Q+QqtzOJMXCn9Fh513+Gfew7AKtQ4dZ2s0iyczDvZ6D5PD0/Eh8SjW3g3dA3vim5h3WwFk5+XnxzhE7mk1tKGrRjyYTFEdCMshqhFVsGKb899i7cOvIWj2UcBiPOqVgDxIfEYGT8SccFxiA2ORafgTghvFw5BEGARLOLNKt6sgtX267zyPJwrOIezBWdxtuAszheeR3ltOc4VnsO5wnPAmWvvb4IJHYM62gqkbhHd0DOiJ/pF9+OeKUR2KK0uBcBiiKg1LIZ0Rg8r6y1WCzb/vBkr96/E6fzTAMQdbONDk3D26kQM6HAzNsztApOT+wBM7jbZ9r0gCMguzca5wmsFkvR9UWURMkoykFGSgZ0XdtpeEx0QjRk9Z+CWXregf3R/p+MgcnUlVZwmI7IHiyFq5EjWETyz5RmcKRCHaAK8AzDvpnm4b9B9OF0YgV/9FyitlW8/JJPJhJigGMQExWBM5zGNHiuoKBBHkQrri6SCc/gx50fklOXg3cPv4t3D7yI2OBa39LoFs3rNQo+IHiyMyG019zef02RE9mExRACAqtoqvL73dbx7+F1YBSuCfYOxYNAC3DvoXgT7BgMAiuvbhHJVWlof3i4c4e3CMTR2qO2+6rpq7L64G1/99BW2nd2Gy8WXserAKqw6sArdw7tjZq+ZuKXXLUgITVAnSCIdYzFEZB8WQ4T88nws/O9CnMg9AQCYnTgbf5r4J1sRJImuX1pfViPeArzVjhTw8fTBpG6TMKnbJFTUVOC789/hq5++ws4LO3Gm4AxW7F2BFXtXoG9UX8zqNQsze81Eh8AO6gdKpDFBEGw9QzyklejGWAy5uYziDMz/dD4uFl1EmF8Ylk9bjpu73tzsc/29gUBvoLQGyCkDuoWpHOx12nm3wy29bsEtvW5BaXUpvjnzDb786Uvsu7QPJ3JP4ETuCSzfuRxDOg3BrF6zMK3HNIS10zhoIpVU11WjxiIO57JniOjGWAzphBYr609fOY0Fny1AblkuOgZ1xHu3v4eEsBtPL0UFAKWF+iiGGgr0CcScvnMwp+8cFFQU4Oufv8YXp75AamYqDmYcxMGMg3jhuxcwOn40ZvWehUndJiHAO0DrsIna5EaHJktTZB4mD/h7+asUEZExsRhyUxnFGbj3k3uRX5GP7uHdsfb2tYgOjG71ddH+wNlC9fqGnBHeLhz3DLwH9wy8B1klWfjqp6/w1U9f4WTeSey4sAM7LuyAr6cvJnaZiFt634LxCePh4+mjddhEsmrYL8SFBUQ3xmJIb1TIWSVVJVj42ULkV+SjV/te+ODOD+w+uyiqfjAlp0y5+OQUExSDB4c+iAeHPohzBefw5U9f4sufvsTFoovY9PMmbPp5EwK8AzCx60RM6zGNhRG5DKkYYr8QUetYDLkZi9WCh798GGcLzyI6IBrv/PIdhw5xlJqojVIMNdQ1vCsWj1qMx0Y+hhO5J/DlT1/if6f/h5zSHHxx6gt8ceoLBHgHYFK3SZjZcyZGdx4Nb7MGXeJEzrjug5RtjyGuJCNqFYshN/PP7/+JvZf2op1XO7zzy3ccXmkljQzpeZqsNSaTCf2i+6FfdD/8cdwf8WP2j9h8ejM2/bwJ2aXZ2JC2ARvSNiDIJwiTu03GtB7TMCp+FEeMyFA4MkRkPxZDbuRYzjGk7E8BAPxlyl/QO7K3w9eIloohA44MNcfD5IGbYm7CTTE34Y/j/4gfsn7AVz99ha9//hp55Xn47ORn+OzkZ/D38sfYhLGY2HUiJnaZ6NBoGpEWbEdxcCUZUatYDLmJOmsdnv3mWVgFK2b1moVbe9/q1HVs02QGHhlqiYfJA0kdk5DUMQnPTXgOqZmp+Prnr/HNmW+QU5aDzT9vxuafN8PTwxMj4kZgavepmNxtMiL8I7QOnagJbrhIZD8WQzqh9NL6NYfXIC0vDcG+wXhuwnNOX0caGbpSDlisgNlFz0s1e5gxLHYYhsUOw58m/gnHc47ju3PfYevZrTidfxq7L+7G7ou78aetf8KgjoMwudtk3Nz1ZiSEJnDlDqnmRnmDPUNE9mMx5AYuX72MFXtXAACeGfdMm0YyItoBZhNgEYD8ims9RK7Mw+SBAR0GYECHAXh89OO4UHgBX5/5Glt+3oLjucdxOPMwDmcexvKdy9ElrAumdp+Kqd2nom9UXxZGpBmODBHZj8WQzijxX+fre19HVV0VhsUOw5y+c9p0LbMH0N5fXE2WU+YexdD1EsIS8Lthv8Pvhv0OWSVZ2HZ2G7499y0OXD6A84XnbWeldQzqiGndp2Fy98kYFDMIZg+z1qGTC7s+d9gaqH3ZQE3UGhed5Gjs8uXLGD9+PBITE9G/f3988sknWoekmrMFZ/HFqS8AAM+Of1aWkQpX7htyVExQDO4ddC/eu+M9HEo+hNdnvo5p3afBz9MPmSWZ+L/D/4e5H83F8FXD8dzW57AvfR/qrHVah012MHresDVQc2SIqFVuMTLk6emJFStWYODAgcjLy8OgQYMwY8YM+Pu7/hb1b+x7AwIETOk+BX2i+shyzagAALnG3GtISYE+gbi19624tfetqKqtws4LO/HN2W+w4/wOFFYW4j8//gf/+fE/CPULxZTuUzCjxwwMjxsOTw+3+GdoOEbPG+wZIrKfW2ThDh06oEMHcT+dyMhIhIWFobCw0DBJzVmnr5zGptObAACPjXxMtutG1f+2GXmvIaX5evliao+pmNpjKuqsdThw+QC+PPUlvj33LQorC7H+2HqsP7YeYX5hmNFzBmb1noVBMYPgYXKLwVpDMHre4D5DRPbTRebdtWsXZs2ahZiYGJhMJmzYsKHJc1auXImEhAT4+voiKSkJu3fvduq9UlNTYbVaERsb28ao9e//Uv8PAgRM6z4Nvdr3ku26rrbXkNI8PTwxKn4Ulk9bju9/9z3W3bEOc/vPRZhfGAorC/H+0fdx13/uwpjVY/Dy9pex5+IeVNRUaB227jFv3BgbqInsp4uRofLycgwYMAALFizAnDlNG3zXr1+PxYsXY+XKlRg1ahTefvttTJ8+HWlpaYiLiwMAJCUlobq6uslrv/nmG8TExAAACgoKcO+99+Kdd96R/Wc4npODr37+EYIgQFrwKkD8XhAa/xqQTpu+dv+BDAEmK3A6T8BnJ4T654pPERo8r+G1Gl3X9nTxfotgwZc/fQkAuH/I/bL+rFIxlJYPbD4r66XdgCeAURjdZRRGdH4ep698j9SML/Bj9jfIKc3BmsNrsObwGniYPBEX0g/dI4YiNqQPPEy6+KeqiNjgcPx6wGCHX+cKeQMA/u/wfuSVFzv1WosVMFnF7789C7TzuvaY1DPEkSGi1pkE6X9UnTCZTPj8889x22232e4bNmwYBg0ahFWrVtnu6927N2677TYsW7bMrutWV1dj8uTJeOCBBzBv3rwbPq9hciwuLkZcXBwuX76MoKCWP2H9vz1b8e8jT9oVi5r6R/XHv+/6t6zXPJAB/OZLWS9JQjVMwl6YrNthEg7ChBytI1JNsN8I7HrgLbueGxgY2OwiAK3zhvRcZ3LHsLfmoarmmF3xOGP3g7u5CzW5tZbyRiOCzgAQPv/8c9uvq6urBbPZLPz3v/9t9LxHH31UGDt2rF3XtFqtwty5c4WlS5e2+tylS5dKwze88cabzm7FxcW6zBvMHbzxpt9bS3mjId2Pvefn58NisSAqKqrR/VFRUcjJse/T8969e7F+/Xr079/f1lfw73//G/369Wvy3KeffhpLliyx/dpqtaKwsBDh4eGKbqBXUlKC2NjYVj9Fuip3/vn5s9v/swcG2jflo3beAJg7tMCfnT+7XHlD98WQ5PpkIgiC3Qlm9OjRsFqtdj3Xx8cHPj6NTycPCQmx67VyCAoKcru/2A2588/Pn13+n12tvAEwd2iJPzt/9rbSxWqyG4mIiIDZbG7yaS4vL6/Jpz4iIoB5g4gco/tiyNvbG0lJSdi6dWuj+7du3YqRI0dqFBUR6RnzBhE5QhfTZGVlZTh79toa7QsXLuDo0aMICwtDXFwclixZgnnz5mHw4MEYMWIEVq9ejfT0dDz00EMaRi0vHx8fLF26tMkwu7tw55+fP7tzPzvzhoh/f/izuxslfnZdLK3fsWMHJkyY0OT++fPnY+3atQDEzdP+9re/ITs7G3379sXrr7+OsWPHqhwpEekF8wYRyUUXxRARERGRVnTfM0RERESkJBZDRERE5NZYDBEREZFbYzGksWXLlmHIkCEIDAxEZGQkbrvtNpw+fVrrsFSxatUq9O/f37Zx1ogRI7B582atw9LEsmXLYDKZsHjxYq1DUdzzzz8Pk8nU6BYdHa11WIbD3MHc4U55A1A2d7AY0tjOnTuRnJyM/fv3Y+vWrairq8OUKVNQXl6udWiK69SpE5YvX47U1FSkpqZi4sSJ+MUvfoGTJ09qHZqqDh06hNWrV6N///5ah6KaPn36IDs723Y7fvy41iEZDnOHe+cOd8wbgIK5w64TCEk1eXl5AgBh586dWoeiidDQUOGdd97ROgzVlJaWCt27dxe2bt0qjBs3Tnjssce0DklxS5cuFQYMGKB1GC6HucN9coc75g1BUDZ3cGRIZ4qLiwEAYWFhGkeiLovFgo8++gjl5eUYMWKE1uGoJjk5GTNnzsSkSZO0DkVVZ86cQUxMDBISEjB37lycP39e65AMj7nDfXKHu+YNQLncoYsdqEkkCAKWLFmC0aNHo2/fvlqHo4rjx49jxIgRqKqqQkBAAD7//HMkJiZqHZYqPvroIxw5cgSHDh3SOhRVDRs2DOvWrUOPHj2Qm5uLl19+GSNHjsTJkycRHh6udXiGxNzhPrnDXfMGoGzuYDGkIw8//DCOHTuGPXv2aB2Kanr27ImjR4/i6tWr+OyzzzB//nzs3LnT5ZPa5cuX8dhjj+Gbb76Br6+v1uGoavr06bbv+/XrhxEjRqBr16547733sGTJEg0jMy7mDvfIHe6cNwBlcwd3oNaJRx55BBs2bMCuXbuQkJCgdTiamTRpErp27Yq3335b61AUtWHDBsyePRtms9l2n8VigclkgoeHB6qrqxs95uomT56Mbt26YdWqVVqHYjjMHSJ3yB3MG03JlTs4MqQxQRDwyCOP4PPPP8eOHTvcOpkB4u9HdXW11mEo7uabb26yCmLBggXo1asXnnrqKbdKaNXV1Th16hTGjBmjdSiGwtzRmDvkDuaNxuTMHSyGNJacnIwPP/wQGzduRGBgIHJycgAAwcHB8PPz0zg6ZT3zzDOYPn06YmNjUVpaio8++gg7duzA119/rXVoigsMDGzS2+Hv74/w8HCX7/l48sknMWvWLMTFxSEvLw8vv/wySkpKMH/+fK1DMxTmDvfLHe6cNwBlcweLIY1JQ3vjx49vdP+aNWtw3333qR+QinJzczFv3jxkZ2cjODgY/fv3x9dff43JkydrHRopKCMjA3fffTfy8/PRvn17DB8+HPv370d8fLzWoRkKcwdzh7tRMnewZ4iIiIjcGvcZIiIiIrfGYoiIiIjcGoshIiIicmsshoiIiMitsRgiIiIit8ZiiIiIiNwaiyEiIiJyayyGiIiIyK2xGCJFmUwmu247duzAfffdh86dO2sdchO7d++Gj48PLl26ZPdrioqKEBISgg0bNigXGJELY+7YoFxg1AR3oCZF7d+/v9GvX3rpJWzfvh3fffddo/sTExNx5coVlJSU4KabblIzxBsSBAGDBw/GiBEj8Oabbzr02hdeeAHvv/8+Tp48CW9vb4UiJHJNzB3MHWpiMUSquu+++/Dpp5+irKxM61DssnnzZsyYMQM//fQTevbs6dBrc3Nz0alTJ7z33nv41a9+pVCERO6BuYOUxGky0o3mhrpNJhMefvhhrFmzBj179oSfnx8GDx6M/fv3QxAEvPrqq0hISEBAQAAmTpyIs2fPNrnutm3bcPPNNyMoKAjt2rXDqFGj8O2339oV06pVqzBkyJAmyey7777D+PHjER4eDj8/P8TFxWHOnDmoqKiwPScqKgqTJ0/GW2+95fhvBhHZjbmD2orFEOneV199hXfeeQfLly/Hf/7zH5SWlmLmzJl44oknsHfvXrz55ptYvXo10tLSMGfOHDQc7Hz//fcxZcoUBAUF4b333sPHH3+MsLAwTJ06tdWkVlNTg23btmHChAmN7r948SJmzpwJb29vvPvuu/j666+xfPly+Pv7o6amptFzx48fj7179+Lq1auy/X4QkX2YO8huApGK5s+fL/j7+7f4WHx8fKP7AAjR0dFCWVmZ7b4NGzYIAISBAwcKVqvVdv+KFSsEAMKxY8cEQRCE8vJyISwsTJg1a1aja1osFmHAgAHC0KFDbxjrgQMHBADCRx991Oj+Tz/9VAAgHD16tNWfd+vWrQIAYfPmza0+l4haxtxBSuLIEOnehAkT4O/vb/t17969AQDTp0+HyWRqcr+0cmPfvn0oLCzE/PnzUVdXZ7tZrVZMmzYNhw4dQnl5eYvvm5WVBQCIjIxsdP/AgQPh7e2NBx98EO+99x7Onz/f4jWk12ZmZjryIxORDJg7yF4shkj3wsLCGv1aWl3R0v1VVVUAxCZEALj99tvh5eXV6PbXv/4VgiCgsLCwxfetrKwEAPj6+ja6v2vXrti2bRsiIyORnJyMrl27omvXrvjHP/7R5BrSa6VrEZF6mDvIXp5aB0CklIiICADAP//5TwwfPrzZ50RFRbX6+uaS3pgxYzBmzBhYLBakpqbin//8JxYvXoyoqCjMnTvX9jzptdK1iEj/mDvcD4shclmjRo1CSEgI0tLS8PDDDzv8emno/Ny5cy0+x2w2Y9iwYejVqxc++OADHDlypFFCk4bBExMTHX5/ItIGc4f7YTFELisgIAD//Oc/MX/+fBQWFuL2229HZGQkrly5gh9//BFXrlzBqlWrWnx9p06d0KVLF+zfvx+PPvqo7f633noL3333HWbOnIm4uDhUVVXh3XffBQBMmjSp0TX279+P8PBw9OvXT5kfkohkx9zhflgMkUv79a9/jbi4OPztb3/Db3/7W5SWliIyMhIDBw7Efffd1+rr77nnHrz55puorq6Gj48PALEJ8ptvvsHSpUuRk5ODgIAA9O3bF1988QWmTJlie60gCPjiiy/wq1/9qlGzJhHpH3OHe+EO1EQ3kJWVhYSEBKxbtw533XWXQ6/99ttvMWXKFJw8eRK9evVSKEIi0iPmDmNhMUTUiqeeegqbN2/G0aNH4eFh/wLMCRMmoFu3bvjXv/6lYHREpFfMHcbBaTKiVjz33HNo164dMjMzERsba9drioqKMG7cOCxatEjh6IhIr5g7jIMjQ0REROTWuOkiERERuTUWQ0REROTWWAwRERGRW2MxRERERG6NxRARERG5NRZDRERE5NZYDBEREZFbYzFEREREbu3/A2Eq99dQgb9ZAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "figure2B()" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:13.298915300Z", "start_time": "2023-07-22T05:54:13.283003600Z" } }, "outputs": [], "source": [ "\n", "def figure2C():\n", " # data\n", " data = sio.loadmat('Joglekar_2018_data/subgraphData.mat')\n", " hier = bm.asarray(data['hierVals'].squeeze() / max(data['hierVals'])) # normalize hierarchical position\n", " fln = bm.asarray(data['flnMat'])\n", "\n", " # inputs\n", " ampl = 21.8 * 1.9\n", " inputs, duration = bp.inputs.section_input([0, ampl, 0], [2., 0.25, 7.75], return_length=True)\n", "\n", " all_muEE = bm.arange(28, 44, 2)\n", " i_start, i_end = (round(1.75 / bm.get_dt()), round(5. / bm.get_dt()))\n", "\n", " @jit\n", " @partial(vmap, in_axes=(0, None))\n", " def peak_firing_rate(muEE, fln):\n", " _, res = simulate(fln.shape[0], fln=fln, hier=hier, muEE=muEE,\n", " input4v1=inputs, duration=duration)\n", " return (res[i_start:i_end, -1] - res[i_start, -1]).max()\n", "\n", " # with feedback\n", " ax = plt.subplot(1, 2, 1)\n", " area2peak = peak_firing_rate(all_muEE, fln)\n", " area2peak = bm.where(area2peak > 500, 500, area2peak)\n", " show_maximum_rate(ax, all_muEE.to_numpy(), area2peak.to_numpy(), title='With feedback')\n", " # without feedback\n", " ax = plt.subplot(1, 2, 2)\n", " area2peak = peak_firing_rate(all_muEE, bm.tril(fln))\n", " area2peak = bm.where(area2peak > 500, 500, area2peak)\n", " show_maximum_rate(ax, all_muEE.to_numpy(), area2peak.to_numpy(), title='Without feedback')\n", " plt.show()\n", "\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:14.214940600Z", "start_time": "2023-07-22T05:54:13.298915300Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "figure2C()" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:14.260281Z", "start_time": "2023-07-22T05:54:14.214940600Z" } }, "outputs": [], "source": [ "\n", "sStrong = 1000\n", "sWeak = 100\n", "\n", "\n", "def show_multiple_area_rates(axes, times, rates, plot_duration, color='green'):\n", " t_start, t_end = plot_duration\n", " i_start, i_end = round(t_start / bm.get_dt()), round(t_end / bm.get_dt())\n", " areas2plot = [0, 2, 5, 7, 8, 12, 16, 18, 28]\n", " for i, j in enumerate(areas2plot):\n", " ax = axes[i]\n", " ax.plot(times[i_start:i_end] - 100, rates[i_start:i_end, j] - rates[i_start, j], color)\n", " ax.set_xlim([-98.25, -96])\n", " ax.spines['top'].set_visible(False)\n", " ax.spines['right'].set_visible(False)\n", " ax.spines['bottom'].set_visible(False)\n", " plt.setp(ax.get_xticklabels(), visible=False)\n", " ax.tick_params(axis='both', which='both', length=0)\n", " peak = (rates[i_start:i_end, j] - rates[i_start, j]).max()\n", " if j == 0:\n", " ax.set_ylim([0, 140])\n", " ax.set_yticks([round(sWeak * peak, 1) / sWeak])\n", " ax.set_title('Weak GBA')\n", " else:\n", " ax.set_ylim([0, 1.2 * peak])\n", " ax.set_yticks([round(sWeak * peak, 1) / sWeak])\n", " if i == 4:\n", " ax.set_ylabel('Change in firing rate (Hz)', fontsize='large')" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:14.260281Z", "start_time": "2023-07-22T05:54:14.229009Z" } }, "outputs": [], "source": [ "def figure3BD():\n", " # data\n", " data = sio.loadmat('Joglekar_2018_data/subgraphData.mat')\n", " hier = bm.asarray(data['hierVals'].squeeze() / max(data['hierVals']))\n", " fln = bm.asarray(data['flnMat'])\n", " num_node = fln.shape[0]\n", "\n", " fig, axes = plt.subplots(9, 2)\n", "\n", " # weak GBA\n", " muEE = 33.7\n", " omegaEI = 19.7\n", " ampl = 22.05 * 1.9\n", " inputs, duration = bp.inputs.section_input([0, ampl, 0], [2., 0.25, 7.75], return_length=True)\n", " model = ThreshLinearModel(fln.shape[0],\n", " hier=hier, fln=fln, inp_idx=0, inp_data=inputs,\n", " muEE=muEE, omegaEI=omegaEI,\n", " desired_ss=(bm.ones(num_node) * 10, bm.ones(num_node) * 35))\n", " runner1 = bp.DSRunner(model, monitors=['re'], )\n", " runner1.run(duration)\n", " show_multiple_area_rates(times=runner1.mon.ts,\n", " rates=runner1.mon.re,\n", " plot_duration=(1.25, 5.),\n", " axes=[axis[0] for axis in axes])\n", "\n", " # strong GBA\n", " muEE = 51.5\n", " omegaEI = 25.2\n", " ampl = 11.54 * 1.9\n", " inputs, duration = bp.inputs.section_input([0, ampl, 0], [2., 0.25, 7.75], return_length=True)\n", " model = ThreshLinearModel(fln.shape[0],\n", " hier=hier, fln=fln, inp_idx=0, inp_data=inputs,\n", " muEE=muEE, omegaEI=omegaEI,\n", " desired_ss=(bm.ones(num_node) * 10, bm.ones(num_node) * 35))\n", " runner2 = bp.DSRunner(model, monitors=['re'], )\n", " runner2.run(duration)\n", " show_multiple_area_rates(times=runner1.mon.ts,\n", " rates=runner1.mon.re,\n", " plot_duration=(1.75, 5.),\n", " axes=[axis[1] for axis in axes],\n", " color='green')\n", " show_multiple_area_rates(times=runner2.mon.ts,\n", " rates=runner2.mon.re,\n", " plot_duration=(1.75, 5.),\n", " axes=[axis[1] for axis in axes],\n", " color='purple')\n", " plt.tight_layout()\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:15.747202500Z", "start_time": "2023-07-22T05:54:14.244680500Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "533e2c2870504d969075475ed4877a5e", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/50000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "figure3BD()" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:15.802744Z", "start_time": "2023-07-22T05:54:15.747202500Z" } }, "outputs": [], "source": [ "def figure3E():\n", " # data\n", " data = sio.loadmat('Joglekar_2018_data/subgraphData.mat')\n", " hier = bm.asarray(data['hierVals'].squeeze() / max(data['hierVals']))\n", " fln = bm.asarray(data['flnMat'])\n", " num_node = fln.shape[0]\n", " i_start, i_end = round(1.75 / bm.get_dt()), round(5. / bm.get_dt())\n", "\n", " # weak GBA\n", " muEE = 33.7\n", " omegaEI = 19.7\n", " ampl = 22.05 * 1.9\n", " inputs, duration = bp.inputs.section_input([0, ampl, 0], [2., 0.25, 7.75], return_length=True)\n", " model = ThreshLinearModel(fln.shape[0], hier=hier, fln=fln, inp_idx=0, inp_data=inputs, muEE=muEE,\n", " omegaEI=omegaEI, desired_ss=(bm.ones(num_node) * 10, bm.ones(num_node) * 35))\n", " runner1 = bp.DSRunner(model, monitors=['re'], )\n", " runner1.run(duration)\n", " peak1 = (runner1.mon.re[i_start: i_end] - runner1.mon.re[i_start]).max(axis=0)\n", "\n", " # strong GBA\n", " muEE = 51.5\n", " omegaEI = 25.2\n", " ampl = 11.54 * 1.9\n", " inputs, duration = bp.inputs.section_input([0, ampl, 0], [2., 0.25, 7.75], return_length=True)\n", " model = ThreshLinearModel(fln.shape[0], hier=hier, fln=fln, inp_idx=0, inp_data=inputs, muEE=muEE,\n", " omegaEI=omegaEI, desired_ss=(bm.ones(num_node) * 10, bm.ones(num_node) * 35))\n", " runner2 = bp.DSRunner(model, monitors=['re'], )\n", " runner2.run(duration)\n", " peak2 = (runner2.mon.re[i_start: i_end] - runner2.mon.re[i_start]).max(axis=0)\n", "\n", " # visualization\n", " fig, ax = plt.subplots()\n", " ax.semilogy(np.arange(0, num_node), 100 * peak1 / peak1[0], 'green', marker=\".\", markersize=5)\n", " ax.semilogy(np.arange(0, num_node), 100 * peak2 / peak2[0], 'purple', marker=\".\", markersize=5)\n", " ax.spines['top'].set_visible(False)\n", " ax.spines['right'].set_visible(False)\n", " ax.set_ylim([1e-4, 1e2])\n", " ax.set_xlim([0, num_node])\n", " ax.legend(['weak GBA', 'strong GBA'], prop={'size': 10}, loc='upper right',\n", " bbox_to_anchor=(1.0, 1.2), frameon=False)\n", " ax.set_xticks(np.arange(0, num_node))\n", " ax.set_xticklabels(data['areaList'].squeeze(), rotation='vertical', fontsize=10)\n", " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:16.845566800Z", "start_time": "2023-07-22T05:54:15.771469500Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "34ea4d6b77d147caab106b681bc77ad3", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/50000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "figure3E()" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:16.876222Z", "start_time": "2023-07-22T05:54:16.845566800Z" } }, "outputs": [], "source": [ "def figure3F():\n", " # data\n", " data = sio.loadmat('Joglekar_2018_data/subgraphData.mat')\n", " hier = bm.asarray(data['hierVals'].squeeze() / max(data['hierVals']))\n", " fln = bm.asarray(data['flnMat'])\n", " num_node = fln.shape[0]\n", " i_start, i_end = round(1.75 / bm.get_dt()), round(3.5 / bm.get_dt())\n", "\n", " # input\n", " ampl = 22.05 * 1.9\n", " inputs, duration = bp.inputs.section_input([0, ampl, 0], [2., 0.25, 7.75], return_length=True)\n", "\n", " @partial(vmap, in_axes=(0, None))\n", " def maximum_rate(muEE, omegaEI=None):\n", " if omegaEI is None: omegaEI = 19.7 + (muEE - 33.7) * 55 / 178\n", " model = ThreshLinearModel(num_node, hier=hier, fln=fln, inp_idx=0, inp_data=inputs, muEE=muEE,\n", " omegaEI=omegaEI, desired_ss=(bm.ones(num_node) * 10, bm.ones(num_node) * 35))\n", " runner = bp.DSRunner(model, monitors=['re'], progress_bar=False, numpy_mon_after_run=False)\n", " runner.run(duration)\n", " return (runner.mon.re[i_start: i_end, -1] - runner.mon.re[i_start, -1]).max()\n", "\n", " # visualization\n", " muEErange = bm.arange(20, 52, 2)\n", " peaks_with_gba = maximum_rate(muEErange, None)\n", " peaks_without_gba = maximum_rate(muEErange, 19.7)\n", " peaks_with_gba = bm.where(peaks_with_gba > 500, 500, peaks_with_gba)\n", " peaks_without_gba = bm.where(peaks_without_gba > 500, 500, peaks_without_gba)\n", " fig, ax = plt.subplots()\n", " ax.semilogy(muEErange, peaks_without_gba.to_numpy(), 'cornflowerblue', marker=\".\", markersize=5)\n", " ax.semilogy(muEErange, peaks_with_gba.to_numpy(), 'black', marker=\".\", markersize=5)\n", " ax.spines['top'].set_visible(False)\n", " ax.spines['right'].set_visible(False)\n", " ax.set_ylim([1e-8, 1e4])\n", " ax.set_xlim([20, 50])\n", " ax.set_ylabel('Maximum rate in 24c (Hz)', fontsize='large')\n", " ax.set_xlabel('Global E to E coupling', fontsize='large')\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T05:54:17.682909700Z", "start_time": "2023-07-22T05:54:16.860486800Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "figure3F()" ] } ], "metadata": { "kernelspec": { "display_name": "brainpy", "language": "python", "name": "brainpy" }, "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.12" } }, "nbformat": 4, "nbformat_minor": 1 }