attr_behavioral_metrics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.io\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as grd\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from game import Game\n",
    "from strategies import FastAttractorMemory, BaseStrategy, PerfectMemory\n",
    "from memory import FastAttractor\n",
    "\n",
    "import torch\n",
    "from tqdm import tqdm\n",
    "\n",
    "from fiftyone import ViewField as F\n",
    "\n",
    "import scipy.io as sio\n",
    "\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_trials = 20\n",
    "\n",
    "steps = 10\n",
    "\n",
    "size_range = [[3,3], [4,4], [5,5], [6,6], [7,7]]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_mat(path, df):\n",
    "    result = []\n",
    "\n",
    "    for column in df.columns:\n",
    "        entries = df[column].values\n",
    "        column_tuple = (np.array([column]), entries.reshape(-1, 1))\n",
    "        result.append(column_tuple)\n",
    "\n",
    "    # Convert the result list to an array\n",
    "    result_array = np.array(result)\n",
    "\n",
    "    sio.savemat(path, {'b_data': result_array})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_strategy(strategy, game, max_steps=1500):\n",
    "    win = False\n",
    "    steps = 0\n",
    "    while not win and steps < max_steps:\n",
    "        strategy.pick()\n",
    "        win = game.check_win()\n",
    "        torch.cuda.empty_cache()\n",
    "        steps+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collect_data(n_trials, size_range, strategy, game):\n",
    "    dfs = []\n",
    "    tot_clicks = []\n",
    "    for i, size in enumerate(size_range): \n",
    "        size_clicks = []\n",
    "        for n in tqdm(range(n_trials), desc=f'Size: {size}'):\n",
    "            game.set_size(size, 2)\n",
    "            strategy.reset()\n",
    "            play_strategy(strategy, game)\n",
    "            df, nc = game.get_metrics()\n",
    "            df['id'] = i*n_trials + n\n",
    "            dfs.append(df)\n",
    "            size_clicks.append(nc)\n",
    "        tot_clicks.append(size_clicks)\n",
    "    return pd.concat(dfs).reset_index(drop=True), tot_clicks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_reaction_times_confidence(activation_history, df, size):\n",
    "    tiles_clicked = df['tile_clicked'].to_numpy()-1\n",
    "    indices = np.tile(np.repeat([False, True, False], steps), len(tiles_clicked) // 2)\n",
    "    history = activation_history[indices]\n",
    "    neuron = np.repeat(tiles_clicked[1::2], steps)\n",
    "    x = history[torch.arange(history.size(0)), neuron].view(-1, steps)\n",
    "    max_v, _ = torch.max(x, dim=1, keepdim=True)\n",
    "    means = torch.mean(history[:, :size], axis=1).numpy()\n",
    "    df['reaction_time'] = np.repeat(np.argmax(torch.abs(max_v - x) <= torch.abs(0.1*max_v), axis=1), 2)\n",
    "    df['confidence'] = np.repeat(torch.abs(max_v.flatten() - means[steps-1::steps]) / torch.max(torch.abs(max_v.flatten() - means[steps-1::steps])), 2)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_energy(energy_history, df):\n",
    "    tiles_clicked = df['tile_clicked'].to_numpy()-1\n",
    "    indices = np.tile(np.repeat([True, False, False], steps), len(tiles_clicked) // 2)\n",
    "    energy = energy_history[indices].view(-1, steps)\n",
    "    max_v, _ = torch.max(energy, dim=1, keepdim=True)\n",
    "    min_v, _ = torch.min(energy, dim=1, keepdim=True)\n",
    "    df['max_energy'] = np.repeat((max_v.flatten() - min_v.flatten()) / -min_v.flatten(), 2)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collect_data_attractor(n_trials, size_range, game, lr, rr):\n",
    "    dfs = []\n",
    "    tot_clicks = []\n",
    "    for i, size in enumerate(size_range): \n",
    "        size_clicks = []\n",
    "        for n in tqdm(range(n_trials), desc=f'Size: {size}'):\n",
    "            game.set_size(size, 2)\n",
    "            dim = np.prod(size) + len(np.unique(game.get_grid_labels()))\n",
    "            memory = FastAttractor(dim, lr, rr)\n",
    "            strategy = FastAttractorMemory(game, memory, steps=steps)\n",
    "            play_strategy(strategy, game)\n",
    "            history = memory.get_activation_history()\n",
    "            df, nc = game.get_metrics()\n",
    "            df = add_reaction_times_confidence(history, df, np.prod(size))\n",
    "            energy_history = memory.get_energy_history()\n",
    "            df = extract_energy(energy_history, df)\n",
    "            df['id'] = i*n_trials + n\n",
    "            dfs.append(df)\n",
    "            size_clicks.append(nc)\n",
    "        tot_clicks.append(size_clicks)\n",
    "    return pd.concat(dfs).reset_index(drop=True), tot_clicks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_second_click_df(df):\n",
    "    o_df = pd.DataFrame()\n",
    "    o_df['id'] = df['id'].to_numpy()[1::2]\n",
    "    o_df['match'] = df['match'].to_numpy()[1::2]\n",
    "    o_df['random_match'] = df['random_match'].to_numpy()[1::2]\n",
    "    o_df['board_size'] = df['board_size'].to_numpy()[1::2]\n",
    "    o_df['tile_clicked'] = df['tile_clicked'].to_numpy()[1::2]\n",
    "    o_df['nslc'] = df['nslc'].to_numpy()[1::2]\n",
    "    o_df['nslc_first'] = df['nslc'].to_numpy()[0::2] # nslc referring to the first click of the trial\n",
    "    o_df['nsp'] = df['nsp'].to_numpy()[1::2]\n",
    "    o_df['correct_tile'] = df['correct_tile'].to_numpy()[0::2]\n",
    "    o_df['reaction_time'] = df['reaction_time'].to_numpy()[1::2]\n",
    "    o_df['confidence'] = df['confidence'].to_numpy()[1::2]\n",
    "    o_df['max_energy'] = df['max_energy'].to_numpy()[1::2]\n",
    "    return o_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_nc_df(nc, strategy):\n",
    "    data = []\n",
    "    for i, size in enumerate(size_range):\n",
    "        for j in range(n_trials):\n",
    "            data.append({'size': str(size[0]), 'nc': math.log10(nc[i][j]/np.prod(size))})\n",
    "    data = pd.DataFrame(data)\n",
    "    data['strategy'] = strategy\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "game = Game()\n",
    "# Use the following to have actual images from \"coco-2017\" in the grid\n",
    "# game = Game(\n",
    "#             dataset_name='coco-2017', \n",
    "#             split='validation', \n",
    "#             field=\"ground_truth\", \n",
    "#             ds_filter=F(\"supercategory\").is_in(('person', 'animal', 'food', 'vehicle', 'indoor')),\n",
    "#             dataset_dir =\"/home/ravi/datasets/coco-2017\",\n",
    "#         )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Benchmarks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Size: [3, 3]: 100%|██████████| 20/20 [00:00<00:00, 350.09it/s]\n",
      "Size: [4, 4]: 100%|██████████| 20/20 [00:00<00:00, 212.56it/s]\n",
      "Size: [5, 5]: 100%|██████████| 20/20 [00:00<00:00, 85.53it/s]\n",
      "Size: [6, 6]: 100%|██████████| 20/20 [00:00<00:00, 47.22it/s]\n",
      "Size: [7, 7]: 100%|██████████| 20/20 [00:00<00:00, 22.70it/s]\n"
     ]
    }
   ],
   "source": [
    "bs = BaseStrategy(game)\n",
    "bs_df, bs_nc = collect_data(n_trials, size_range, bs, game)\n",
    "bs_nc_df = build_nc_df(bs_nc, 'Random Memory')\n",
    "bs_df['strategy'] = 'Random memory'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Size: [3, 3]: 100%|██████████| 20/20 [00:00<00:00, 475.64it/s]\n",
      "Size: [4, 4]: 100%|██████████| 20/20 [00:00<00:00, 607.34it/s]\n",
      "Size: [5, 5]: 100%|██████████| 20/20 [00:00<00:00, 445.60it/s]\n",
      "Size: [6, 6]: 100%|██████████| 20/20 [00:00<00:00, 346.83it/s]\n",
      "Size: [7, 7]: 100%|██████████| 20/20 [00:00<00:00, 269.96it/s]\n"
     ]
    }
   ],
   "source": [
    "pm = PerfectMemory(game)\n",
    "pm_df, pm_nc = collect_data(n_trials, size_range, pm, game)\n",
    "pm_nc_df = build_nc_df(pm_nc, 'Perfect Memory')\n",
    "pm_df['strategy'] = 'Perfect memory'"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Attractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Size: [3, 3]: 100%|██████████| 20/20 [00:00<00:00, 20.54it/s]\n",
      "Size: [4, 4]: 100%|██████████| 20/20 [00:01<00:00, 12.48it/s]\n",
      "Size: [5, 5]: 100%|██████████| 20/20 [00:03<00:00,  6.30it/s]\n",
      "Size: [6, 6]: 100%|██████████| 20/20 [00:05<00:00,  3.82it/s]\n",
      "Size: [7, 7]: 100%|██████████| 20/20 [00:08<00:00,  2.34it/s]\n",
      "/tmp/ipykernel_756480/3037875155.py:10: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  result_array = np.array(result)\n"
     ]
    }
   ],
   "source": [
    "att_df_double, att_nc = collect_data_attractor(n_trials, size_range, game, .6, .9)\n",
    "att_df = get_second_click_df(att_df_double) # Only get the second click for each trial\n",
    "save_mat('model_metrics.mat', att_df)\n",
    "att_nc_df = build_nc_df(att_nc, 'Attractor Memory')\n",
    "att_df['strategy'] = 'Attractor Memory'"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Behavioral metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = att_df\n",
    "df['Trial'] = 'Mismatch'\n",
    "df.loc[df['match'] == 1, 'Trial'] = 'Match'\n",
    "df['board_size'] = df['board_size'].apply(np.sqrt)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reaction Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x1600 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 542x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 16))\n",
    "palette = ['green', 'grey'] \n",
    "# Draw a nested barplot by species and sex\n",
    "ax = sns.catplot(x=\"board_size\", y=\"reaction_time\", hue='Trial', data=df, aspect=0.85, kind='bar', errorbar='se', palette=palette, hue_order=['Match', 'Mismatch'])\n",
    "ax.set(xlabel=\"Board size\", ylabel=\"reaction-time\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Confidence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x1600 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgkAAAHpCAYAAAAIzq/nAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3+ElEQVR4nO3deXxU1f3/8feQjRAgYDZAAwTDHpaQ+MOACC2yC0itIlogLJUISlisECxrQfxaCsRWokFkUQuhlSIqCgEFkVWQCDUUkC0UAwn7oiSQ3N8fltEhBwyTSSaE1/PxmMdj5txz73zmPNS8Pffec22WZVkCAAC4Tjl3FwAAAEonQgIAADAiJAAAACNCAgAAMCIkAAAAI0ICAAAwIiQAAACjOy4kWJal8+fPi+UhAAC4uTsuJFy4cEH+/v66cOGCu0sBAKBUu+NCAgAAKBxCAgAAMCIkAAAAI0ICAAAwIiQAAAAjQgIAADAiJAAAACNCAgAAMCIkAAAAI0ICAAAwIiQAAAAjQgIAADAiJAAAACNCAgAAMCIkAAAAI0ICAAAwIiQAAAAjT3cXAAB3gvj4eGVnZ0uSgoKClJiY6OaKgF9GSACAEpCdna0TJ064uwzglnC6AQAAGBESAACAESEBAAAYERIAAIARIQEAABgREgAAgBEhAQAAGBESAACAESEBAAAYERIAAIARIQEAABgREgAAgBEhAQAAGPEUSABwUtWRVQvdt/HpxvKRjyQp43TGLe0rSWdmnbml/oArMJMAAACMCAkAAMCIkAAAAIwICQAAwIiQAAAAjAgJAADAiJAAAACMCAkAAMCIkAAAAIwICQAAwIiQAAAAjAgJAADAiAc8AUAJuOJ1xfgeKM0ICQBQAvaF73N3CcAt43QDAAAwIiQAAAAjQgIAADAiJAAAACNCAgAAMCIkAAAAI0ICAAAwcntImDNnjsLCwlS+fHlFRUVpw4YNhdpv48aN8vT0VPPmzYu3QAAA7lBuDQkpKSkaMWKEXnzxRe3cuVNt2rRRly5dlJGRcdP9zp07p379+ql9+/YlVCkAAHcem2VZlru+vGXLlmrRooWSkpLsbQ0bNtQjjzyi6dOn33C/J554QnXr1pWHh4eWL1+utLS0Qn/n+fPn5e/vr3Pnzqly5cpFKV/x8fHKzs6WJAUFBSkxMbFIxwNwe6k6smqJfdeZWWdK7LuAa9w2k5Cbm6sdO3aoY8eODu0dO3bUpk2bbrjf/PnzdeDAAU2cOLFQ35OTk6Pz5887vFwlOztbJ06c0IkTJ+xhAQCAssJtIeHkyZPKy8tTSEiIQ3tISIiOHz9u3Gf//v0aO3as3n33XXl6Fu6xE9OnT5e/v7/9FRoaWuTaAQC4E7j9wkWbzebw2bKsAm2SlJeXpyeffFKTJ09WvXr1Cn38hIQEnTt3zv46evRokWsGAOBO4LanQAYGBsrDw6PArEFWVlaB2QVJunDhgrZv366dO3fq2WeflSTl5+fLsix5enpq9erV+vWvf11gPx8fH/n4+BTPjwAAoAxz20yCt7e3oqKilJqa6tCempqqVq1aFehfuXJl7d69W2lpafZXXFyc6tevr7S0NLVs2bKkSgcA4I7gtpkESRo1apT69u2r6OhoxcTEKDk5WRkZGYqLi5P046mCY8eOadGiRSpXrpwiIiIc9g8ODlb58uULtAMAgKJza0jo3bu3Tp06pSlTpigzM1MRERFauXKlatWqJUnKzMz8xTUTAABA8XDrOgnu4Mp1Ep588kmdOHFC0o93Zfz97393RYkAbhOsk4Cyzu13NwAAgNKJkAAAAIwICQAAwIiQAAAAjAgJAADAiJAAAACMCAkAAMCIkAAAAIzcuuIiUBbFx8crOztbkhQUFKTExEQ3VwQAziEkAC6WnZ1tX4kTAG5nnG4AAABGhAQAAGBESAAAAEaEBAAAYERIAAAARtzdAKDYcDsocHsjJAAoNtwOCtzeON0AAACMCAkAAMCIkAAAAIwICQAAwIiQAAAAjAgJAADAiJAAAACMCAkAAMCIkAAAAIwICQAAwIiQAAAAjAgJAADAiAc8AYVQdWTVQvdtfLqxfOQjSco4nXFL+0rSmVlnbqk/ABQXQgKAW0JgAu4cnG4AAABGzCTAJeLj45WdnS1JCgoKUmJiopsrAgAUFSHhOkylOic7O1snTpxwdxkAABfidAMAADAiJAAAACNCAgAAMCIkAAAAI0ICAAAwIiQAAAAjQgIAADAiJAAAACNCAgAAMCIkAAAAI5ZlBlBsrnhdMb4HcHsgJAAoNvvC97m7BABFwOkGAABgREgAAABGnG4AXIzz8ADKCkIC4GKchwdQVnC6AQAAGBESAACAESEBAAAYERIAAIARIQEAABgREgAAgBEhAQAAGBESAACAESEBAAAYseIibqjqyKqF7tv4dGP5yEeSlHE645b2laQzs87cUn8AQPFjJgEAABgREgAAgBEhAQAAGBESAACAESEBAAAYERIAAIARIQEAABgREgAAgBEhAQAAGBESAACAESEBAAAYERIAAIARD3gCgDImPj5e2dnZkqSgoCAlJia6uSLcrggJRXDF64rxPQC4U3Z2tk6cOOHuMlAGEBKKYF/4PneXAABAseGaBAAAYERIAAAARoQEAABgREgAAABGhAQAAGDE3Q0AcBuYPHlyofuePXvW4f2t7CtJEydOvKX+KLvcPpMwZ84chYWFqXz58oqKitKGDRtu2PeLL75Q69atFRAQIF9fXzVo0ECzZs0qwWoBALhzFHkm4fLlyypfvrxT+6akpGjEiBGaM2eOWrdurTfeeENdunRRenq6atasWaC/n5+fnn32WTVt2lR+fn764osvNGTIEPn5+enpp58u6k8BAAA/49RMQn5+vv70pz/p7rvvVsWKFXXw4EFJ0vjx4zVv3rxCH2fmzJkaNGiQBg8erIYNG2r27NkKDQ1VUlKSsX9kZKT69Omjxo0bq3bt2vrd736nTp063XT2AQAAOMepkDB16lQtWLBAr7zyiry9ve3tTZo00ZtvvlmoY+Tm5mrHjh3q2LGjQ3vHjh21adOmQh1j586d2rRpk9q2bXvDPjk5OTp//rzDC653xeuKcrxylOOVwxLVAFBGOHW6YdGiRUpOTlb79u0VFxdnb2/atKn+85//FOoYJ0+eVF5enkJCQhzaQ0JCdPz48Zvue8899yg7O1tXr17VpEmTNHjw4Bv2nT59+i1ftINbxxLVAFD2ODWTcOzYMYWHhxdoz8/P15Urt/Z/kTabzeGzZVkF2q63YcMGbd++Xa+//rpmz56txYsX37BvQkKCzp07Z38dPXr0luoDAOBO5dRMQuPGjbVhwwbVqlXLof0f//iHIiMjC3WMwMBAeXh4FJg1yMrKKjC7cL2wsDBJP57eOHHihCZNmqQ+ffoY+/r4+MjHx6dQNQFAWfDz/+bx3z8UhVMhYeLEierbt6+OHTum/Px8LVu2THv37tWiRYv04YcfFuoY3t7eioqKUmpqqnr16mVvT01NVc+ePQtdi2VZysnJueXfAABlVfPmzd1dAsoIp0JC9+7dlZKSopdeekk2m00TJkxQixYt9MEHH6hDhw6FPs6oUaPUt29fRUdHKyYmRsnJycrIyLBf55CQkKBjx45p0aJFkqTXXntNNWvWVIMGDST9uG7CjBkz9NxzzznzMwAAwE04vU5Cp06d1KlTpyJ9ee/evXXq1ClNmTJFmZmZioiI0MqVK+2nMTIzM5WRkWHvn5+fr4SEBB06dEienp6699579fLLL2vIkCFFqgMAABTkVEj48ssvlZ+fr5YtWzq0b926VR4eHoqOji70sYYOHaqhQ4caty1YsMDh83PPPcesAQAAJcSpuxuGDRtmvEvg2LFjGjZsWJGLAgAA7udUSEhPT1eLFi0KtEdGRio9Pb3IRQEAAPdzKiT4+PjoxIkTBdozMzPl6cmDJQEAKAucCgkdOnSwL1J0zdmzZzVu3LhbursBAACUXk79b/9f/vIXPfjgg6pVq5Z98aS0tDSFhITo7bffdmmBAADAPZwKCXfffbd27dqld999V19//bV8fX01YMAA9enTR15eXq6uEQAAuIHTFxD4+fnp6aefdmUtAACgFHE6JOzbt0/r1q1TVlaW8vPzHbZNmDChyIUBAAD3ciokzJ07V88884wCAwNVrVo1h6c2XlumGQAA3N6cCglTp07VtGnTNGbMGFfXAwAASgmnboE8c+aMHnvsMVfXAgAAShGnQsJjjz2m1atXu7oWAABQijh1uiE8PFzjx4/Xli1b1KRJkwK3PQ4fPtwlxQEAAPdxKiQkJyerYsWKWr9+vdavX++wzWazERIAACgDnAoJhw4dcnUdAACglHHqmoRrcnNztXfvXl29etVV9QAAgFLCqZDw/fffa9CgQapQoYIaN26sjIwMST9ei/Dyyy+7tEAAAOAeToWEhIQEff3111q3bp3Kly9vb3/ooYeUkpLisuIAAID7OHVNwvLly5WSkqL777/fYbXFRo0a6cCBAy4rDgAAuI9TMwnZ2dkKDg4u0H7p0iWH0AAAAG5fToWE++67Tx999JH987VgMHfuXMXExLimMgAA4FZOnW6YPn26OnfurPT0dF29elWJiYn65ptvtHnz5gLrJgAAgNuTUzMJrVq10saNG/X999/r3nvv1erVqxUSEqLNmzcrKirK1TUCAAA3cGomQZKaNGmihQsXurIWAABQihQ6JJw/f77QB61cubJTxQAAgNKj0CGhSpUqhb5zIS8vz+mCAABA6VDokPDZZ5/Z3x8+fFhjx45VbGys/W6GzZs3a+HChZo+fbrrqwQAACWu0CGhbdu29vdTpkzRzJkz1adPH3tbjx491KRJEyUnJ6t///6urRIAAJQ4p+5u2Lx5s6Kjowu0R0dHa9u2bUUuCgAAuJ9TISE0NFSvv/56gfY33nhDoaGhRS4KAAC4n1O3QM6aNUuPPvqoVq1apfvvv1+StGXLFh04cEDvvfeeSwsEAADu4dRMQteuXbVv3z716NFDp0+f1qlTp9SzZ0/t27dPXbt2dXWNAADADZxeTCk0NFQvvfSSK2sBAAClSKFDwq5duxQREaFy5cpp165dN+3btGnTIhcGAADcq9AhoXnz5jp+/LiCg4PVvHlz2Ww2WZZVoJ/NZmMxJQAAyoBCh4RDhw4pKCjI/h4AAJRthQ4JvXr10tq1a1W1alUtXLhQzz//vCpUqFCctQEAADcq9N0Ne/bs0aVLlyRJkydP1sWLF4utKAAA4H63dE3CgAED9MADD8iyLM2YMUMVK1Y09p0wYYLLCgQAAO5R6JCwYMECTZw4UR9++KFsNps+/vhjeXoW3N1msxESAAAoAwodEurXr68lS5ZIksqVK6e1a9cqODi42AoDAADu5dRiSvn5+a6uAwAAlDJOr7i4b98+rVu3TllZWQVCA6cbAAC4/TkVEubOnatnnnlGgYGBqlatmmw2m30b1yQAAFA2OBUSpk6dqmnTpmnMmDGurgcAAJQSTj0F8syZM3rsscdcXQsAAChFnAoJjz32mFavXu3qWgAAQCni1OmG8PBwjR8/Xlu2bFGTJk3k5eXlsH348OEuKQ4AALiPUyEhOTlZFStW1Pr167V+/XqHbTabjZAAAEAZ4FRI4CmQAACUfU5dk/BzlmXJsixX1AIAQKmwYMECValS5Zb2qV27tmbPnl0s9biL0yFh0aJFatKkiXx9feXr66umTZvq7bffdmVtAAAUmc1mu+krNja2wD69e/fWvn37Sr7YUsap0w0zZ87U+PHj9eyzz6p169ayLEsbN25UXFycTp48qZEjR7q6TgAAnJKZmWl/n5KSogkTJmjv3r32Nl9fX4f+V65csf8P8J3OqZmEv/71r0pKStL//d//qUePHurZs6deeeUVzZkzR6+++qqrawQAwGnVqlWzv/z9/WWz2eyfL1++rCpVqmjp0qVq166dypcvr3feeafA6YYDBw6oZ8+eCgkJUcWKFXXfffdpzZo17vtRJcSpkJCZmalWrVoVaG/VqpVDYgMA4HYwZswYDR8+XHv27FGnTp0KbL948aK6du2qNWvWaOfOnerUqZO6d++ujIwMN1RbcpwKCeHh4Vq6dGmB9pSUFNWtW7fIRQEAUJJGjBih3/zmNwoLC1ONGjUKbG/WrJmGDBmiJk2aqG7dupo6darq1KmjFStWuKHakuPUNQmTJ09W79699fnnn6t169ay2Wz64osvtHbtWmN4AACgNIuOjr7p9kuXLmny5Mn68MMP9d133+nq1av64YcfyvxMglMh4dFHH9XWrVs1a9YsLV++XJZlqVGjRtq2bZsiIyNdXSMAAMXKz8/vptv/8Ic/aNWqVZoxY4bCw8Pl6+ur3/72t8rNzS2hCt3DqZAgSVFRUXrnnXdcWQsAAKXShg0bFBsbq169ekn68RqFw4cPu7eoEuDUNQkrV67UqlWrCrSvWrVKH3/8cZGLAgCgNAkPD9eyZcuUlpamr7/+Wk8++aTy8/PdXVaxcyokjB07Vnl5eQXaLcvS2LFji1wUAAClyaxZs1S1alW1atVK3bt3V6dOndSiRQt3l1XsnDrdsH//fjVq1KhAe4MGDfTtt98WuSgAAIpDbGyswwqLtWvXNj5awNTv008/degzbNgwh89l8fSDUzMJ/v7+OnjwYIH2b7/99hcv/gAAALcHp0JCjx49NGLECB04cMDe9u2332r06NHq0aOHy4oDAADu41RI+POf/yw/Pz81aNBAYWFhCgsLU8OGDRUQEKAZM2a4ukYAAOAGTl2T4O/vr02bNik1NVVff/21/SmQDz74oKvrAwAAbuL0Ogk2m00dO3ZUo0aNVKNGDZUr5/RTpwEAQClU5L/sjRo1KpNXdAIAcKdzeibhGtOtIwBKRnx8vLKzsyVJQUFBSkxMdHNFAMqSIocEAO6TnZ2tEydOuLsMAGVUkU83jBs3TnfddZcragEAAKVIkWcSEhISXFEHAOA2VnVk1RL9vjOzzpTo97mKzWbTv/71Lz3yyCPuLqVQnJpJyMvL07x58/Tkk0/qoYce0q9//WuHFwAApU1sbKxsNpvi4uIKbBs6dKhsNpvDUsw3c/jwYdlsNqWlpbm2yFLGqZmE+Ph4LViwQN26dVNERIRsNpur6wIAwOVCQ0O1ZMkSzZo1S76+vpKky5cva/HixapZs6abqyt9nJpJWLJkiZYuXaqUlBTNnj1bs2bNcngBAFAatWjRQjVr1tSyZcvsbcuWLVNoaKgiIyPtbZ988okeeOABValSRQEBAXr44YcdHkUQFhYmSYqMjJTNZlO7du3s29566y01btxYPj4+ql69up599lmHGk6ePKlevXqpQoUKqlu3rlasWFFMv7bonAoJ3t7eCg8Pd3UtAAAUuwEDBmj+/Pn2z2+99ZYGDhzo0OfSpUsaNWqUvvzyS61du1blypVTr169lJ+fL0natm2bJGnNmjXKzMy0h46kpCQNGzZMTz/9tHbv3q0VK1YU+Hs5efJkPf7449q1a5e6du2qp556SqdPny7On+w0p043jB49WomJifrb3/7GqQYApQJrRqCw+vbtq4SEBPt1BRs3btSSJUu0bt06e59HH33UYZ958+YpODhY6enpioiIUFBQkCQpICBA1apVs/ebOnWqRo8erfj4eHvbfffd53Cs2NhY9enTR5L00ksv6a9//au2bdumzp07u/qnFplTIeGLL77QZ599po8//liNGzeWl5eXw/afT+MAQElgzQgUVmBgoLp166aFCxfKsix169ZNgYGBDn0OHDig8ePHa8uWLTp58qR9BiEjI0MRERHG42ZlZem7775T+/btb/r9TZs2tb/38/NTpUqVlJWVVcRfVTycCglVqlRRr169XF0LAAAlYuDAgfZrBV577bUC27t3767Q0FDNnTtXNWrUUH5+viIiIpSbm3vDY167EPKXXP8/1jabzR5CShunQsLPz+UAAHC76dy5s/0PfqdOnRy2nTp1Snv27NEbb7yhNm3aSPpxBv3nvL29Jf24JMA1lSpVUu3atbV27Vr96le/Ks7yS0yRFlPKzs7W3r17ZbPZVK9ePfs5GgDOmzx5cqH7nj171uH9rewrSRMnTryl/kBZ4eHhoT179tjf/1zVqlUVEBCg5ORkVa9eXRkZGRo7dqxDn+DgYPn6+uqTTz7RPffco/Lly8vf31+TJk1SXFycgoOD1aVLF124cEEbN27Uc889V2K/zZWcCgmXLl3Sc889p0WLFtmnSDw8PNSvXz/99a9/VYUKFQp9rDlz5ujPf/6zMjMz1bhxY82ePdue3K63bNkyJSUlKS0tTTk5OWrcuLEmTZpUIAUCAErW7bgCYuXKlY3t5cqV05IlSzR8+HBFRESofv36evXVVx1uc/T09NSrr76qKVOmaMKECWrTpo3WrVun/v376/Lly5o1a5aef/55BQYG6re//W0J/SLXcyokjBo1SuvXr9cHH3yg1q1bS/pxKmb48OEaPXq0kpKSCnWclJQUjRgxQnPmzFHr1q31xhtvqEuXLkpPTzcuavH555+rQ4cOeumll1SlShXNnz9f3bt319atWx3ubwUA4HoLFiy46fbly5fb3z/00ENKT0932H79U48HDx6swYMHFzjOkCFDNGTIEON3mJ6c/PMZwdLGqZDw3nvv6Z///KdDquratat8fX31+OOPFzokzJw5U4MGDbIP8uzZs7Vq1SolJSVp+vTpBfrPnj3b4fNLL72k999/Xx988AEhAQAAF3MqJHz//fcKCQkp0B4cHKzvv/++UMfIzc3Vjh07Cpzn6dixozZt2lSoY+Tn5+vChQs3fQplTk6OcnJy7J/Pnz9fqGMDcD+uzwDcy6kVF2NiYjRx4kRdvnzZ3vbDDz9o8uTJiomJKdQxTp48qby8vAJhIyQkRMePHy/UMf7yl7/o0qVLevzxx2/YZ/r06fL397e/QkNDC3VsAADudE7NJCQmJqpz586655571KxZM/uTsMqXL69Vq1bd0rGuX7HRsqxCreK4ePFiTZo0Se+//76Cg4Nv2C8hIUGjRo2yfz5//jxBAQCAQnAqJERERGj//v1655139J///EeWZemJJ57QU089VejFJAIDA+Xh4VFg1iArK8t4KuPnUlJSNGjQIP3jH//QQw89dNO+Pj4+8vHxKVRNAADgJ06vk+Dr66vf//73Tn+xt7e3oqKilJqa6rB6Y2pqqnr27HnD/RYvXqyBAwdq8eLF6tatm9PfDwAAbq7QIWHFihXq0qWLvLy8fvGxlj169CjUMUeNGqW+ffsqOjpaMTExSk5OVkZGhuLi4iT9eKrg2LFjWrRokaQfA0K/fv2UmJio+++/3z4L4evrK39//8L+FAAAUAiFDgmPPPKIjh8/ruDgYD3yyCM37Gez2RyWqbyZ3r1769SpU5oyZYoyMzMVERGhlStXqlatWpKkzMxMZWRk2Pu/8cYbunr1qoYNG6Zhw4bZ2/v37/+L978CAIBbU+iQ8POHT7jyQRRDhw7V0KFDjduu/8P/88d4AsDP/fzaI65DAlzDqWsSFi1apN69exf4FzE3N1dLlixRv379XFIcgJvjD+NPmjdv7u4S7mi3ui5FURX3uhbt2rVT8+bNCyziV9pNmjRJy5cvV1pamkuO59Q6CQMGDNC5c+cKtF+4cEEDBgwoclEACqd58+Zq2bKlWrZsyR9J4BfExsbKZrPZr3v7uaFDh8pmsyk2NlbSj88K+tOf/lTCFTqKjY296en9kuBUSLjRWgb//e9/uYAQAFBqhYaGasmSJfrhhx/sbZcvX9bixYsdnhl01113qVKlSu4osVS5pZAQGRmpFi1ayGazqX379mrRooX91axZM7Vp0+YX1y0AAMBdWrRooZo1a2rZsmX2tmXLlik0NNThGUDt2rXTiBEj7J/nzJmjunXrqnz58goJCXF4smO7du303HPPacSIEapatapCQkKUnJysS5cuacCAAapUqZLuvfdeffzxx/Z98vLyNGjQIIWFhcnX11f169dXYmKiffukSZO0cOFCvf/++7LZbLLZbPbr8v773//qiSee0F133SU/Pz9FR0dr69atDr/z7bffVu3ateXv768nnnhCFy5ccGq8bumahGvTHmlpaerUqZMqVqxo3+bt7a3atWvr0UcfdaoQAABKwoABAzR//nw99dRTkqS33npLAwcOvOHF8du3b9fw4cP19ttvq1WrVjp9+rQ2bNjg0GfhwoV64YUXtG3bNqWkpOiZZ57R8uXL1atXL40bN06zZs1S3759lZGRoQoVKig/P1/33HOPli5dqsDAQG3atElPP/20qlevrscff1zPP/+89uzZo/Pnz2v+/PmSfpzduHjxotq2bau7775bK1asULVq1fTVV1853FBw4MABLV++XB9++KHOnDmjxx9/XC+//LKmTZt2y2N1SyHh2oUitWvX1hNPPHHHXygFALj99O3bVwkJCTp8+LBsNps2btyoJUuW3DAkZGRkyM/PTw8//LAqVaqkWrVqFXjycLNmzfTHP/5R0o9r/Lz88ssKDAy0Lzo4YcIEJSUladeuXbr//vvl5eXlcLFnWFiYNm3apKVLl+rxxx9XxYoV5evrq5ycHFWrVs3eb8GCBcrOztaXX35pf7hheHi4Qy35+flasGCB/XRJ3759tXbt2uIPCdc0atRIaWlpatmypUP71q1b5eHhoejoaGcOCwBAsQsMDFS3bt20cOFCWZalbt26KTAw8Ib9O3TooFq1aqlOnTrq3LmzOnfurF69eqlChQr2Pk2bNrW/9/DwUEBAgJo0aWJvu/a4gaysLHvb66+/rjfffFNHjhzRDz/8oNzc3F+8ADktLU2RkZE3ffpx7dq1Ha6nqF69usP33gqnLlwcNmyYjh49WqD92LFjDoscAQBQGg0cOFALFizQwoULNXDgwJv2rVSpkr766istXrxY1atX14QJE9SsWTOHx5N7eXk57GOz2Rzarl3sf+20wNKlSzVy5EgNHDhQq1evVlpamgYMGKDc3Nyb1lKY5yOZanF2fSOnQkJ6erpatGhRoD0yMlLp6elOFQIAQEnp3LmzcnNzlZubq06dOv1if09PTz300EN65ZVXtGvXLh0+fFiffvqp09+/YcMGtWrVSkOHDlVkZKTCw8N14MABhz7e3t4FVjBu2rSp0tLSdPr0aae/+1Y4FRJ8fHx04sSJAu2ZmZny9HT6mVEAAJQIDw8P7dmzR3v27JGHh8dN+3744Yd69dVXlZaWpiNHjmjRokXKz89X/fr1nf7+8PBwbd++XatWrdK+ffs0fvx4ffnllw59ateurV27dmnv3r06efKkrly5oj59+qhatWp65JFHtHHjRh08eFDvvfeeNm/e7HQtN+PUX/QOHTooISFB77//vn1dhLNnz2rcuHHq0KGDSwsEAJR+xb0CYnGoXLlyofpVqVJFy5Yt06RJk3T58mXVrVtXixcvVuPGjZ3+7ri4OKWlpal3796y2Wzq06ePhg4d6nCb5O9//3utW7dO0dHRunjxoj777DO1a9dOq1ev1ujRo9W1a1ddvXpVjRo10muvveZ0LTdjsyzLutWdjh07pgcffFCnTp2yX+GZlpamkJAQpaamKjQ01OWFusr58+fl7++vc+fOGf8BqTqyaonVcmbWmRL7LmcwFj8pybEYUWVEiX2XM/9hZyx+wligrHNqJuHuu+/Wrl279O677+rrr7+Wr6+vBgwYoD59+hS4YAIAANyenL6AwM/PT08//bQrawEAAKVIka4yTE9PV0ZGRoFbNnr06FGkogAAgPs5FRIOHjyoXr16affu3bLZbLp2WcO1+0Cvv2UDAADcfpy6BTI+Pl5hYWE6ceKEKlSooG+++Uaff/65oqOjb7isJQAAuL04NZOwefNmffrppwoKClK5cuVUrlw5PfDAA5o+fbqGDx+unTt3urpOwC4+Pl7Z2dmSpKCgIIcnpwEAXMepkJCXl2d/AmRgYKC+++471a9fX7Vq1dLevXtdWiBwvezsbONiXgAA13IqJERERGjXrl2qU6eOWrZsqVdeeUXe3t5KTk5WnTp1XF0jAABwA6dCwh//+EddunRJkjR16lQ9/PDDatOmjQICApSSkuLSAgEAgHs4FRJ+/jCMOnXqKD09XadPn1bVqlXtdzgAAIDbm1N3N1zz7bffatWqVfrhhx9u+mxrAABw+3EqJJw6dUrt27dXvXr11LVrV2VmZkqSBg8erNGjR7u0QAAA4B5OhYSRI0fKy8tLGRkZqlChgr29d+/e+uSTT1xWHAAAcB+nrklYvXq1Vq1apXvuucehvW7dujpy5IhLCgMAAO7lVEi4dOmSwwzCNSdPnpSPj0+Ri0JBLCAEAChpTp1uePDBB7Vo0SL7Z5vNpvz8fP35z3/Wr371K5cVh59cW0DoxIkT9rAAAEBxcmomYcaMGWrbtq22b9+u3NxcvfDCC/rmm290+vRpbdy40dU1AgAAN7jlmYQrV65o6NChWrFihf7f//t/6tChgy5duqTf/OY32rlzp+69997iqBMAAJSwW55J8PLy0r///W8FBARo8uTJxVETAAAoBZy6JqFfv36aN2+eq2sBAACliFPXJOTm5urNN99UamqqoqOj5efn57B95syZLikOAAC4j1Mh4d///rdatGghSdq3b5/DNp7dAABA2eBUSPjss89cXQcAAChlnAoJgKvdykWwZ8+edXh/qxfQTpw48Zb6A8CdqkhPgQQAAGUXIQEAABgREgAAgBEhAQAAGBESAACAESEBAAAYERIAAIARIQEAABgREgAAgBEhAQAAGLEssxuxFDEAoDRjJgEAABgREgAAgBEhAQAAGBESAACAESEBAAAYcXcDbjs+Pj7G9wAA1yIk4LbTvHlzd5cAAHcETjcAAAAjQgIAADAiJAAAACNCAgAAMCIkAAAAI0ICAAAwIiQAAAAjQgIAADAiJAAAACNCAgAAMCIkAAAAI57dcJvgoUYAgJJGSLhN8FAjAEBJ43QDAAAwIiQAAAAjQgIAADAiJAAAACNCAgAAMCIkAAAAI0ICAAAwIiQAAAAjQgIAADAiJAAAACNCAgAAMCIkAAAAI0ICAAAwIiQAAAAjt4eEOXPmKCwsTOXLl1dUVJQ2bNhww76ZmZl68sknVb9+fZUrV04jRowouUIBALjDuDUkpKSkaMSIEXrxxRe1c+dOtWnTRl26dFFGRoaxf05OjoKCgvTiiy+qWbNmJVwtAAB3FreGhJkzZ2rQoEEaPHiwGjZsqNmzZys0NFRJSUnG/rVr11ZiYqL69esnf3//Eq4WAIA7i9tCQm5urnbs2KGOHTs6tHfs2FGbNm1y2ffk5OTo/PnzDi8AAPDL3BYSTp48qby8PIWEhDi0h4SE6Pjx4y77nunTp8vf39/+Cg0NddmxAQAoy9x+4aLNZnP4bFlWgbaiSEhI0Llz5+yvo0ePuuzYAACUZZ7u+uLAwEB5eHgUmDXIysoqMLtQFD4+PvLx8XHZ8QAAuFO4bSbB29tbUVFRSk1NdWhPTU1Vq1at3FQVAAC4xm0zCZI0atQo9e3bV9HR0YqJiVFycrIyMjIUFxcn6cdTBceOHdOiRYvs+6SlpUmSLl68qOzsbKWlpcnb21uNGjVyx08AAKDMcmtI6N27t06dOqUpU6YoMzNTERERWrlypWrVqiXpx8WTrl8zITIy0v5+x44d+vvf/65atWrp8OHDJVk6AABlnltDgiQNHTpUQ4cONW5bsGBBgTbLsoq5IgAAIJWCuxsAAEDpREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGBESAAAAEaEBAAAYERIAAAARoQEAABgREgAAABGhAQAAGDk9pAwZ84chYWFqXz58oqKitKGDRtu2n/9+vWKiopS+fLlVadOHb3++uslVCkAAHcWt4aElJQUjRgxQi+++KJ27typNm3aqEuXLsrIyDD2P3TokLp27ao2bdpo586dGjdunIYPH6733nuvhCsHAKDsc2tImDlzpgYNGqTBgwerYcOGmj17tkJDQ5WUlGTs//rrr6tmzZqaPXu2GjZsqMGDB2vgwIGaMWNGCVcOAEDZ5+muL87NzdWOHTs0duxYh/aOHTtq06ZNxn02b96sjh07OrR16tRJ8+bN05UrV+Tl5VVgn5ycHOXk5Ng/nzt3TpJ0/vx543dYOdYt/Y6iuHz5col9141+780wFj9hLH7CWPzkThyLSpUqyWazlVgtcDPLTY4dO2ZJsjZu3OjQPm3aNKtevXrGferWrWtNmzbNoW3jxo2WJOu7774z7jNx4kRLEi9evHjxcsHr3LlzrvkjgNuC22YSrrk+kVqWddOUaupvar8mISFBo0aNsn/Oz8/X6dOnFRAQ4NY0fP78eYWGhuro0aOqXLmy2+ooDRiLnzAWP2EsflKaxqJSpUpu/X6ULLeFhMDAQHl4eOj48eMO7VlZWQoJCTHuU61aNWN/T09PBQQEGPfx8fGRj4+PQ1uVKlWcL9zFKleu7PZ/6UsLxuInjMVPGIufMBYoaW67cNHb21tRUVFKTU11aE9NTVWrVq2M+8TExBTov3r1akVHRxuvRwAAAM5z690No0aN0ptvvqm33npLe/bs0ciRI5WRkaG4uDhJP54q6Nevn71/XFycjhw5olGjRmnPnj166623NG/ePD3//PPu+gkAAJRZbr0moXfv3jp16pSmTJmizMxMRUREaOXKlapVq5YkKTMz02HNhLCwMK1cuVIjR47Ua6+9pho1aujVV1/Vo48+6q6f4DQfHx9NnDixwKmQOxFj8RPG4ieMxU8YC7iLzbp25R8AAMDPuH1ZZgAAUDoREgAAgBEhAQAAGBESAACAESGhGCQlJalp06b2hU9iYmL08ccf33SfO+ER2NOnT5fNZtOIESNu2q+sjsWkSZNks9kcXtWqVbvpPmV1LCTp2LFj+t3vfqeAgABVqFBBzZs3144dO266T1kcj9q1axf458Jms2nYsGE33KcsjgNKKfeuCl02rVixwvroo4+svXv3Wnv37rXGjRtneXl5Wf/+97+N/Q8ePGhVqFDBio+Pt9LT0625c+daXl5e1j//+c8Srrz4bNu2zapdu7bVtGlTKz4+/ob9yvJYTJw40WrcuLGVmZlpf2VlZd2wf1kei9OnT1u1atWyYmNjra1bt1qHDh2y1qxZY3377bc33KesjkdWVpbDPxOpqamWJOuzzz4z9i+r44DSiZBQQqpWrWq9+eabxm0vvPCC1aBBA4e2IUOGWPfff39JlFbsLly4YNWtW9dKTU212rZte9OQUJbHYuLEiVazZs0K3b8sj8WYMWOsBx544Jb2Kcvj8XPx8fHWvffea+Xn5xu33ynjgNKB0w3FLC8vT0uWLNGlS5cUExNj7HOjR2Bv375dV65cKYkyi9WwYcPUrVs3PfTQQ7/Yt6yPxf79+1WjRg2FhYXpiSee0MGDB2/YtyyPxYoVKxQdHa3HHntMwcHBioyM1Ny5c2+6T1kej2tyc3P1zjvvaODAgTd8AN2dMA4oPQgJxWT37t2qWLGifHx8FBcXp3/9619q1KiRse/x48cLPNQqJCREV69e1cmTJ0ui3GKzZMkSffXVV5o+fXqh+pflsWjZsqUWLVqkVatWae7cuTp+/LhatWqlU6dOGfuX5bE4ePCgkpKSVLduXa1atUpxcXEaPny4Fi1adMN9yvJ4XLN8+XKdPXtWsbGxN+xzJ4wDSg+3Pyq6rKpfv77S0tJ09uxZvffee+rfv7/Wr19/w6Bwq4/Avh0cPXpU8fHxWr16tcqXL1/o/criWEhSly5d7O+bNGmimJgY3XvvvVq4cKHD48x/rqyORX5+vqKjo/XSSy9JkiIjI/XNN98oKSnJ4Xkt1yur43HNvHnz1KVLF9WoUeOm/cr6OKD0YCahmHh7eys8PFzR0dGaPn26mjVrpsTERGNfZx6BfTvYsWOHsrKyFBUVJU9PT3l6emr9+vV69dVX5enpqby8vAL7lNWxMPHz81OTJk20f/9+4/ayPBbVq1cvEJgbNmzo8KyW65Xl8ZCkI0eOaM2aNRo8ePBN+5X1cUDpwkxCCbEsSzk5OcZtMTEx+uCDDxzaysIjsNu3b6/du3c7tA0YMEANGjTQmDFj5OHhUWCfsjoWJjk5OdqzZ4/atGlj3F6Wx6J169bau3evQ9u+ffvsD3czKcvjIUnz589XcHCwunXrdtN+ZX0cUMq486rJsiohIcH6/PPPrUOHDlm7du2yxo0bZ5UrV85avXq1ZVmWNXbsWKtv3772/tduaRo5cqSVnp5uzZs3r8ze0nT93Q130liMHj3aWrdunXXw4EFry5Yt1sMPP2xVqlTJOnz4sGVZd9ZYbNu2zfL09LSmTZtm7d+/33r33XetChUqWO+88469z500Hnl5eVbNmjWtMWPGFNh2J40DSh9CQjEYOHCgVatWLcvb29sKCgqy2rdvbw8IlmVZ/fv3t9q2beuwz7p166zIyEjL29vbql27tpWUlFTCVZeM60PCnTQWvXv3tqpXr255eXlZNWrUsH7zm99Y33zzjX37nTQWlmVZH3zwgRUREWH5+PhYDRo0sJKTkx2230njsWrVKkuStXfv3gLb7qRxQOnDo6IBAIARFy4CAAAjQgIAADAiJAAAACNCAgAAMCIkAAAAI0ICAAAwIiQAAAAjQgIAADAiJACl1KRJk9S8eXOn9j18+LBsNpvS0tJcWhOAOwshAZAUGxsrm81mfwUEBKhz587atWuXu0tzSmhoqDIzMxUREeHuUgDcxggJwP907txZmZmZyszM1Nq1a+Xp6amHH3642L/3ypUrLj+mh4eHqlWrJk9PHvQKwHmEBOB/fHx8VK1aNVWrVk3NmzfXmDFjdPToUWVnZ9v77N69W7/+9a/l6+urgIAAPf3007p48aJ9+5dffqkOHTooMDBQ/v7+atu2rb766iuH77HZbHr99dfVs2dP+fn5aerUqZKkl19+WSEhIapUqZIGDRqky5cv37TeM2fO6KmnnlJQUJB8fX1Vt25dzZ8/X1LB0w3Xz5Rce61bt06SlJubqxdeeEF33323/Pz81LJlS/s2AHcuQgJgcPHiRb377rsKDw9XQECAJOn7779X586dVbVqVX355Zf6xz/+oTVr1ujZZ5+173fhwgX1799fGzZs0JYtW1S3bl117dpVFy5ccDj+xIkT1bNnT+3evVsDBw7U0qVLNXHiRE2bNk3bt29X9erVNWfOnJvWOH78eKWnp+vjjz/Wnj17lJSUpMDAQGPfxMRE+yxJZmam4uPjFRwcrAYNGkiSBgwYoI0bN2rJkiXatWuXHnvsMXXu3Fn79+8vyjACuN25+zGUQGnQv39/y8PDw/Lz87P8/PwsSVb16tWtHTt22PskJydbVatWtS5evGhv++ijj6xy5cpZx48fNx736tWrVqVKlawPPvjA3ibJGjFihEO/mJgYKy4uzqGtZcuWVrNmzW5Yc/fu3a0BAwYYtx06dMiSZO3cubPAtvfee8/y8fGxNmzYYFmWZX377beWzWazjh075tCvffv2VkJCwg2/H0DZx0wC8D+/+tWvlJaWprS0NG3dulUdO3ZUly5ddOTIEUnSnj171KxZM/n5+dn3ad26tfLz87V3715JUlZWluLi4lSvXj35+/vL399fFy9eVEZGhsN3RUdHO3zes2ePYmJiHNqu/3y9Z555RkuWLFHz5s31wgsvaNOmTb/4G3fu3Kl+/frptdde0wMPPCBJ+uqrr2RZlurVq6eKFSvaX+vXr9eBAwd+8ZgAyi6uagL+x8/PT+Hh4fbPUVFR8vf319y5czV16lRZliWbzWbc91p7bGyssrOzNXv2bNWqVUs+Pj6KiYlRbm5uge8qqmsB5qOPPtKaNWvUvn17DRs2TDNmzDD2P378uHr06KFBgwZp0KBB9vb8/Hx5eHhox44d8vDwcNinYsWKRa4TwO2LmQTgBmw2m8qVK6cffvhBktSoUSOlpaXp0qVL9j4bN25UuXLlVK9ePUnShg0bNHz4cHXt2lWNGzeWj4+PTp48+Yvf1bBhQ23ZssWh7frPJkFBQYqNjdU777yj2bNnKzk52djv8uXL6tmzpxo0aKCZM2c6bIuMjFReXp6ysrIUHh7u8KpWrdov1gCg7GImAfifnJwcHT9+XNKPdw787W9/08WLF9W9e3dJ0lNPPaWJEyeqf//+mjRpkrKzs/Xcc8+pb9++CgkJkSSFh4fr7bffVnR0tM6fP68//OEP8vX1/cXvjo+PV//+/RUdHa0HHnhA7777rr755hvVqVPnhvtMmDBBUVFRaty4sXJycvThhx+qYcOGxr5DhgzR0aNHtXbtWoe7Ne666y7Vq1dPTz31lPr166e//OUvioyM1MmTJ/Xpp5+qSZMm6tq1a6HHEEDZwkwC8D+ffPKJqlevrurVq6tly5b2OxjatWsnSapQoYJWrVql06dP67777tNvf/tbtW/fXn/729/sx3jrrbd05swZRUZGqm/fvho+fLiCg4N/8bt79+6tCRMmaMyYMYqKitKRI0f0zDPP3HQfb29vJSQkqGnTpnrwwQfl4eGhJUuWGPuuX79emZmZatSokf03Vq9e3X4dw/z589WvXz+NHj1a9evXV48ePbR161aFhoYWcvQAlEU2y7IsdxcBAABKH2YSAACAESEBAAAYERIAAIARIQEAABgREgAAgBEhAQAAGBESAACAESEBAAAYERIAAIARIQEAABgREgAAgNH/B8EleT5m8quGAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 542x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 16))\n",
    "palette = ['green', 'grey']\n",
    "# Draw a nested barplot by species and sex\n",
    "ax = sns.catplot(x=\"board_size\", y=\"confidence\", hue='Trial', data=df, aspect=0.85, kind='bar', errorbar='se', palette=palette, hue_order=['Match', 'Mismatch'])\n",
    "ax.set(xlabel=\"Board size\", ylabel=\"reaction-confidence\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Surprise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_756480/3925047851.py:7: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  nslc_first['Data'] = 'First-click'\n",
      "/tmp/ipykernel_756480/3925047851.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  nslc_old['Data'] = 'nslc>1'\n",
      "/tmp/ipykernel_756480/3925047851.py:13: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  nslc_recent['Data'] = 'nslc=1'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1600x1600 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 540.25x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_df = pd.DataFrame()\n",
    "n_df['nslc'] = att_df_double['nslc'].to_numpy()[0::2]\n",
    "n_df['max_energy'] = att_df_double['max_energy'].to_numpy()[0::2]\n",
    "n_df['board_size'] = att_df_double['board_size'].to_numpy()[0::2]\n",
    "\n",
    "nslc_first = n_df[n_df['nslc'] <= 0]\n",
    "nslc_first['Data'] = 'First-click'\n",
    "\n",
    "nslc_old = n_df[n_df['nslc'] > 1]\n",
    "nslc_old['Data'] = 'nslc>1'\n",
    "\n",
    "nslc_recent = n_df[n_df['nslc'] == 1]\n",
    "nslc_recent['Data'] = 'nslc=1'\n",
    "\n",
    "nslc_df = pd.concat([nslc_first, nslc_old, nslc_recent])\n",
    "\n",
    "palette = ['blue', 'yellow', 'orange']\n",
    "plt.figure(figsize=(16, 16))\n",
    "ax = sns.catplot(x=\"board_size\", y=\"max_energy\", hue='Data', data=nslc_df, aspect=0.85, kind='bar', palette=palette)\n",
    "ax.set(xlabel=\"Board size\", ylabel=\"surprise-response\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## nsp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x1600 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 542x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 16))\n",
    "palette = ['green', 'grey']\n",
    "# Draw a nested barplot by species and sex\n",
    "ax = sns.catplot(x=\"board_size\", y=\"nsp\", hue='Trial', data=df[df['nsp'] > 0], aspect=0.85, errorbar='se', kind='bar', palette=palette, hue_order=['Match', 'Mismatch'])\n",
    "ax.set(xlabel=\"Board size\", ylabel=\"n-since-pair\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NSLC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x1600 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 542x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 16))\n",
    "palette = ['green', 'grey']\n",
    "# Draw a nested barplot by species and sex\n",
    "ax = sns.catplot(x=\"board_size\", y=\"nslc\", hue='Trial', data=df[df['nslc'] > 0], aspect=0.85, errorbar='se', kind='bar', palette=palette, hue_order=['Match', 'Mismatch'])\n",
    "ax.set(xlabel=\"Board size\", ylabel=\"n-since-last-click\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tot clicks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x1600 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAHyCAYAAAAX05LFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACly0lEQVR4nOydd3iT1dvHv9mre7dQWpBd9h6ylI0sUVCQIYiiiPLDiQMBB74oCg5UlK0iG0QRQRxskCl7Q+mgu+nOPO8fN02bNmmTNmmS5nyuK1fJOc+485A893PuKWCMMXA4HA6HYwNCVwvA4XA4HM+BKw0Oh8Ph2AxXGhwOh8OxGa40OBwOh2MzXGlwOBwOx2a40uBwOByOzXClweFwOByb4UqDw+FwODbDlQaHw+FwbIYrDQ6Hw+HYDFcaHA6Hw7EZrjQ4HA6HYzNcaXA8nkmTJmHEiBEOO17v3r0xc+ZMhx2Pw6lNcKXB8Rp0Op2rReBwPB6uNDgew6ZNm9CyZUsoFAoEBwejb9++eOWVV7B69Wps374dAoEAAoEAf//9N27dugWBQIANGzagd+/ekMvl+P7775GRkYHHH38cdevWhVKpRMuWLbFu3TrTOSZNmoR//vkHS5YsMR3v1q1bAIALFy5g8ODB8PHxQXh4OMaPH4/09HTTvrm5uRg3bhxUKhUiIyPx6aefmq1a5s+fj5YtW5b7XO3bt8ecOXOceu04HIfBOBwPICkpiYnFYvbJJ5+wmzdvsv/++499+eWXLDc3l40ePZoNHDiQJScns+TkZKbRaNjNmzcZABYbG8s2b97Mbty4wRITE1lCQgL76KOP2KlTp9j169fZZ599xkQiETty5AhjjLHs7GzWtWtXNnXqVNPx9Ho9S0pKYiEhIWz27Nns4sWL7OTJk6xfv36sT58+JhmfeuopFhMTw/744w929uxZNnLkSObr68tefPFFxhhjd+7cYUKhkB07dsy0z5kzZ5hAIGDXr1+v0evJ4VQVr1MaRqORqdVqZjQaXS0Kxw5OnDjBALBbt26Vm5s4cSIbPny42Vix0li8eHGlxx48eDB76aWXTO979eplutEX8/bbb7P+/fubjd25c4cBYJcvX2Y5OTlMIpGwjRs3muazs7OZUqk0O9agQYPYs88+a3o/c+ZM1rt370pl5HDcBa8zT+Xm5sLf3x+5ubmuFoVjB61bt8aDDz6Ili1b4tFHH8W3336LrKysSvfr0KGD2XuDwYD3338frVq1QnBwMHx8fLB7927Ex8dXeJwTJ07gr7/+go+Pj+nVtGlTAMD169dx48YN6HQ6dOrUybSPv78/mjRpYnacqVOnYt26dSgqKoJOp8MPP/yAyZMn23oZOByXI3a1AByOLYhEIuzZsweHDh3C7t278fnnn+PNN9/E0aNHK9xPpVKZvV+0aBE+/fRTLF68GC1btoRKpcLMmTOh1WorPI7RaMTQoUPxf//3f+XmIiMjcfXqVQCAQCAwm2NluikPHToUMpkMW7duhUwmg0ajwahRoyo8N4fjTnClwfEYBAIBunfvju7du2POnDmIiYnB1q1bIZVKYTAYbDrG/v37MXz4cDzxxBMASBlcvXoVzZo1M21j6Xjt2rXD5s2bERsbC7G4/M/mvvvug0QiwbFjxxAdHQ0AyMnJwdWrV9GrVy/TdmKxGBMnTsTKlSshk8nw2GOPQalU2n0tOBxXwZUGxyM4evQo9u7di/79+yMsLAxHjx5FWloamjVrhqKiIvz++++4fPkygoOD4e/vb/U4DRs2xObNm3Ho0CEEBgbik08+wd27d82URmxsLI4ePYpbt27Bx8cHQUFBmD59Or799ls8/vjjeOWVVxASEoJr167hp59+wrfffgtfX19MnDgRr7zyCoKCghAWFoZ33nkHQqGw3OrjqaeeMp3v4MGDzrlgHI6T8DqfBscz8fPzw759+zB48GA0btwYb731FhYtWoRBgwZh6tSpaNKkCTp06IDQ0NAKb8Rvv/022rVrhwEDBqB3796IiIgolxj48ssvQyQSoXnz5ggNDUV8fDyioqJw8OBBGAwGDBgwAC1atMCLL74If39/CIX0M/rkk0/QtWtXPPTQQ+jbty+6d++OZs2aQS6Xmx2/UaNG6NatG5o0aYLOnTs7/FpxOM5EwMoaXWs5OTk58Pf3h1qthp+fn6vF4dRi8vPzUadOHSxatAhTpkwxjTPG0LRpUzzzzDOYNWuWCyXkcOyHm6c4HAdx6tQpXLp0CZ06dYJarcb8+fMBAMOHDzdtk5qairVr1yIxMRFPPvmkq0TlcKoMVxocjgP5+OOPcfnyZUilUrRv3x779+9HSEiIaT48PBwhISFYtmwZAgMDXSgph1M1uHmKw+FwODbDHeEcDofDsRmuNDgcDodjM1xpcDgcDsdmuNLgcDgcjs1wpcHhcDgcm+FKg8PhcDg2w5UGxyuJjY3F4sWLXS0Gh1N9cnKAy5eBXbuAn34Czp4F7nWbdAZcaXBcwqRJk0ztVMViMerVq4dnn33Wph4ZnszcuXMhEAgwcODAcnMLFy6EQCBA7969a14wjmeSkQEcOQJ07gwMGgQ8/jjQqhUwZw5w86ZTTskzwjkAY8DRo8D27UBWFhAYCAwfTl/EMhVaHcnAgQOxcuVK6PV6XLhwAZMnT0Z2drZZz+7aSGRkJP766y8kJCSgbt26pvGVK1eiXr16LpSsYnQ6HSQSiavF4JQmNRUYNgzQaMzH164F4uKAmTMBmcyhp+QrDW/n/HmgUyega1fgww+Bb76hv1270vj58047tUwmQ0REBOrWrYv+/ftjzJgx2L17t2neYDBgypQpqF+/PhQKBZo0aYIlS5aYHWPSpEkYMWIEPv74Y0RGRiI4OBjTp0+HTqczbZOamoqhQ4dCoVCgfv36+OGHH8rJEh8fj+HDh8PHxwd+fn4YPXo0UlJSTPNz585FmzZtsGLFCtSrVw8+Pj549tlnYTAYsHDhQkRERCAsLAzvv/9+pZ87LCwM/fv3x+rVq01jhw4dQnp6OoYMGVJu+5UrV5qq5TZt2hRLly41zd26dQsCgQAbNmxAjx49oFAo0LFjR1y5cgX//vsvOnToAB8fHwwcOBBpaWmm/YxGI+bPn4+6detCJpOhTZs22LVrl8Xj9u7dG3K5HMuWLYOfnx82bdpkJt+OHTugUql4N0xX8Ntv5RVGMZ9+ClTSkbJKuLLXrCtQq9UMAFOr1a4WxfWcO8dYQABjtNaw/AoIoO0cTNm+3tevX2fNmzdn4eHhpjGtVsvmzJnDjh07xm7cuMG+//57plQq2fr1682O4+fnx6ZNm8YuXrzIduzYwZRKJVu2bJlpm0GDBrEWLVqwQ4cOsePHj7Nu3boxhULBPv30U8YY9Y1v27Ytu//++9nx48fZkSNHWLt27VivXr1Mx3jnnXeYj48Pe+SRR9j58+fZzz//zKRSKRswYACbMWMGu3TpEluxYgUDwA4fPmz1c7/zzjusdevWbMuWLaxhw4am8SlTprAXX3yRvfjii2bnXbZsGYuMjGSbN29mN27cYJs3b2ZBQUFs1apVjLGSXuhNmzZlu3btYhcuXGBdunRh7dq1Y71792YHDhxgJ0+eZA0bNmTTpk0zHfeTTz5hfn5+bN26dezSpUvs1VdfZRKJhF25csXsuLGxsaZzJyYmsqlTp7LBgwebfaaRI0eyCRMmVPC/zXEa06ZV/Pu9dMnhp+RKw1sxGhnr0KHiL1zxq2NH2t6BTJw4kYlEIqZSqZhcLmcAGAD2ySefVLjfc889x0aNGmV2nJiYGKbX601jjz76KBszZgxjjLHLly8zAOzIkSOm+YsXLzIAJqWxe/duJhKJWHx8vGmb8+fPMwDs2LFjjDG62SuVSpaTk2PaZsCAASw2NpYZDAbTWJMmTdiCBQusyl+sNLRaLQsLC2P//PMPy8vLY76+vuzMmTPllEZ0dDT78ccfzY7x7rvvsq5duzLGSm7u3333nWl+3bp1DADbu3evaWzBggWsSZMmpvdRUVHs/fffNztux44d2XPPPWd23MWLF5ttc/ToUSYSiVhiYiJjjLG0tDQmkUjY33//bfUzc5zI6tXWf7dNmzJ29arDT8nNU97K0aPA8eO2bfvvv8CxYw4XoU+fPjh9+jSOHj2KGTNmYMCAAZgxY4bZNl9//bWpuZKPjw++/fZbxJdZcsfFxUEkEpneR0ZGIjU1FQBw8eJFiMVidOjQwTTftGlTBAQEmN5fvHgR0dHRpjatANC8eXMEBATg4sWLprHY2Fj4+vqa3oeHh6N58+amJkzFY8XnrgiJRIInnngCK1euxMaNG9G4cWO0atXKbJu0tDTcuXMHU6ZMgY+Pj+n13nvv4fr162bblt43PDwcANCyZUuLcuXk5CApKQndu3c3O0b37t3NPi8As+sGAJ06dUJcXBzWrFkDAFi7di3q1auHnj17VvqZOU6ga1cgIsLy3LvvAg0bOvyUXGl4K9u327f9tm0OF0GlUqFhw4Zo1aoVPvvsM2g0GsybN880v2HDBvzvf//D5MmTsXv3bpw+fRpPPvkktFqt2XHKOmcFAgGMRiMAanhUPGYNxpjF+bLjls5T0bkrY/Lkydi4cSO+/PJLTJ48udx88XG+/fZbnD592vQ6d+4cjhw5YrZtaTmKZS47Vlausp/Z0nVQqVTl5HrqqaewcuVKAORvefLJJyu8vhwn0qgRsGcPKY9igoOBr78G2rd3yim50vBW7A1trYFQ2HfeeQcff/wxkpKSAAD79+9Ht27d8Nxzz6Ft27Zo2LBhuSfsymjWrBn0ej2Ol1pVXb58GdnZ2ab3zZs3R3x8PO7cuWMau3DhAtRqtVnvcEcTFxeHuLg4nDt3DmPHji03Hx4ejjp16uDGjRto2LCh2at+/fpVPq+fnx+ioqJw4MABs/FDhw7Z9HmfeOIJxMfH47PPPsP58+cxceLEKsvCcQCRkcD33wM3blC+xrFjwCOPALGxTjkdD7n1VuxtAFQDDYN69+6NuLg4fPDBB/jiiy/QsGFDrFmzBr///jvq16+PtWvX4t9//7XrhtmkSRMMHDgQU6dOxbJlyyAWizFz5kwoFArTNn379kWrVq0wbtw4LF68GHq9Hs899xx69epVzjzjaP7880/odDozc1lp5s6dixdeeAF+fn4YNGgQNBoNjh8/jqysrGq1in3llVfwzjvv4L777kObNm2wcuVKnD592mJkWVkCAwPx8MMP45VXXkH//v3NwoY5NUxaGlkNQkKAX34BsrOBXr3IZNW2LTdPcRxIqRakNjFihFPEKMusWbPw7bff4s6dO5g2bRoefvhhjBkzBp07d0ZGRgaee+45u4+5cuVKREdHo1evXnj44Yfx9NNPIywszDQvEAiwbds2BAYGomfPnujbty8aNGiA9evXO/KjWUSlUllVGACZgr777jusWrUKLVu2RK9evbBq1apqrTQA4IUXXsBLL72El156CS1btsSuXbvw888/o1GjRjbtP2XKFGi1WotmNYej0QB5eeTe5ZiTkgJcvQqMHAksXw5s3gy88ALwxhs054QwaN65z1thjPIwbHGGd+xIjnNut+bc44cffsCLL76IpKQkSKVS55wkPR24cAFYsgTIzARGjQKGDgViYpxzPk9k/37AWhDCpEnAe+8Bdeo49JR8peGtCATAqlVABU+5AGh+5UquMDgAgIKCApw/fx4LFizAM8884zyFkZlJN7xevYAtW4C//wZmzAC6dSPbPYfYudP63Pr1QGGhw0/JlYY3ExcHHDgAWLPbd+xI83FxNSsXx21ZuHAh2rRpg/DwcMyePdt5J4qPpxVGWZKSKJTUCTdDj6SoqOI5sePd1tw8xSFT1bFjFFZbXHtqxAgyX/EVBscVvPUWYK0ki1QKXLsGlMqr8Vr+/hvo08fyXP/+tNqozJpgJzx6ikOKoXNnenE47oC1ekoAoNdzp3gxdeuST2PfPvNxmQyYOxfw93f4Kbl5isPhuB+jRlmfGzbM4U/PHsvevcDzz9PKLDoa8PWl67NtG/B//wckJDj8lFxpcDgc96NBA8th3r6+wIIFADctE2fOAKNHA//8A7zyCrB4MUVLjR5N+RsV+TyqCDdPcTgc9yMsDPjqK1pxLFpESWtDhlB/iGrmqNQq2rWjv/v306s0TZoApWqyOQquNDgcjnsSEQE88QQwcCCg0wFBQQ5vKOTxdOkChIZSZnhZXn+d+zQ4HI4XEhJC9ZW4wihPdjawYYN5ccKAAPJnxMXxPA0OxxaWLVuG6OhoCIVCLF682NXicDjOY88eCpN//33g11+pjMiGDZQUOWuWU6LMuNLguIRJkyZBIBCYyos3aNAAL7/8MvLz86t13JycHDz//PN47bXXkJiYiKeffrrasq5atarC+lCltxMIBBYrxW7YsAECgQCxTqo8yvFSRowAHn4YeOcd4NIlMlNt2AA88AD5foKDHX5KlyqNffv2YejQoYiKijIVjbOVgwcPQiwWo02bNk6Tz1tgDDhyBJg9G5g2jf4eOeL8UPiBAwciOTkZN27cwHvvvYelS5fi5ZdfrtKxGGPQ6/WIj4+HTqfDkCFDEBkZCaVS6WCpK0alUiE1NRWHDx82Gy/uLe6ulO6pzvEgVCrgySepNtxLL9EP+LvvKMps8mTg1i2Hn9KlSiM/Px+tW7fGF198Ydd+arUaEyZMwIMPPugkybyH8+cp8btrV+DDD4FvvqG/XbvS+Pnzzju3TCZDREQEoqOjMXbsWIwbN8704MAYw8KFC9GgQQMoFAq0bt0amzZtMu37999/QyAQ4Pfff0eHDh0gk8mwdu1aU7e6Bg0aQCAQ4Na9H82OHTvQvn17yOVyNGjQAPPmzYNerzcdLzs7G08//TTCw8Mhl8vRokUL/PLLL/j777/x5JNPQq1Wm1ZGc+fOtfqZxGIxxo4dixUrVpjGEhIS8Pfff1vsmVGZXAKBAN988w0eeughKJVKNGvWDIcPH8a1a9fQu3dvqFQqdO3atVyfka+++gr33XcfpFIpmjRpgrVr15rNCwQCfP311xg+fDhUKhXee+89NGzYEB9//LHZdufOnYNQKLS7jwmnBjh/nhzhjRsDa9YADz0EdO9OORvLl5PS6N7d8T9ihzeQrSIA2NatW23adsyYMeytt94y9Vu2B94jvIRz5xgLCKi4PXhAAG3naCZOnMiGDx9uNjZjxgwWHBzMGGPsjTfeYE2bNmW7du1i169fZytXrmQymczUi/qvv/5iAFirVq3Y7t272bVr11hCQgL7448/TL29k5OTmV6vZ7t27WJ+fn5s1apV7Pr162z37t0sNjaWzZ07lzHGmMFgYF26dGFxcXFs9+7d7Pr162zHjh1s586dTKPRsMWLFzM/Pz+WnJzMkpOTWW5ursXPtHLlSubv789OnTrFfH19WX5+PmOMenoPHz6cffrppywmJsa0fWVyMUa/izp16rD169ezy5cvsxEjRrDY2Fj2wAMPsF27drELFy6wLl26sIEDB5r22bJlC5NIJOzLL79kly9fZosWLWIikYj9+eefZscNCwtjy5cvZ9evX2e3bt1i77//PmvevLnZZ/rf//7Hevbsaef/LsfpGI2MdehQ8kMNC2PsqacYe/FFxrp3N/8Rd+xI2zsIj1MaK1asYB06dGA6nY4rjWpQ9jtX0cvB3znGWHmlcfToURYcHMxGjx7N8vLymFwuZ4cOHTLbZ8qUKezxxx9njJUojW3btpltc+rUKQaA3bx50zTWo0cP9sEHH5htt3btWhYZGckYY+z3339nQqGQXb582aKsxcqgMkpv16ZNG7Z69WpmNBrZfffdx7Zv315OaVQmF2P0u3jrrbdM7w8fPswAsOXLl5vG1q1bx+Ryuel9t27d2NSpU82O++ijj7LBgwebHXfmzJlm2yQlJTGRSMSOHj3KGGNMq9Wy0NBQtmrVqko/O6eGOXy45AeqUjE2bRpjmzYxtnEjY59/zljz5uY/4iNHHHZqj8rTuHr1Kl5//XXs378fYhurN2o0GmhK1bHJyclxlngexdGjtrXSAIB//6V6ho4uTfXLL7/Ax8cHer0eOp0Ow4cPx+eff44LFy6gqKgI/fr1M9teq9Wibdu2ZmO2dNY7ceIE/v33X7xfqgCewWBAUVERCgoKcPr0adStWxeNGzd2zAcD9f9euXIl6tWrh7y8PAwePLicGbYyuYr9Ma1atTLNh4eHA4DJDFc8VlRUhJycHPj5+eHixYvlAgC6d++OJWWqxpa9dpGRkRgyZAhWrFiBTp064ZdffkFRUREeffTRalwJjlPYvp3+hodTi4OvvwbGjAEMBurW99ZbFFlV3Ilx2zaH/YA9RmkYDAaMHTsW8+bNs+vHvWDBAsybN8+Jknkmxd85W3Hgd85Enz598NVXX0EikSAqKgoSiQQAcPPmTQDAr7/+ijplGsjIysTqq1SqSs9jNBoxb948PPzww+Xm5HK5WetXRzFu3Di8+uqrmDt3LiZMmGDxIacyuYopvi4A+SKsjRmNxnJjxTDGyo1ZunZPPfUUxo8fj08//RQrV67EmDFjajyYgGMDiYn095NPgOnTqceIQECl0K9dowZM69ZRa4Pbtyks10F4jNLIzc3F8ePHcerUKTz//PMA6EfCGINYLMbu3bvxwAMPlNtv9uzZZr2Uc3JyEM1LKtv9HXLgd86ESqVCQws9jJs3bw6ZTIb4+Hj06tWr2udp164dLl++bPFcAD3JJyQk4MqVKxYfSKRSKQwGg13nDAoKwrBhw7BhwwZ8/fXXVZKrqjRr1gwHDhzAhAkTTGOHDh2yGApclsGDB0OlUuGrr77Cb7/9hn1lq6dyXAtjwNq1wMaNVOE2Lw+Qy6lRmr8/1Zry86PGVQsXAk8/Dbz5JrU7cBAeozT8/Pxw9uxZs7GlS5fizz//xKZNm6z2TJbJZOWeTjn2f4cc+J2rFF9fX7z88sv43//+B6PRiPvvvx85OTk4dOgQfHx8MHHiRLuON2fOHDz00EOIjo7Go48+CqFQiP/++w9nz57Fe++9h169eqFnz54YNWoUPvnkEzRs2BCXLl2CQCDAwIEDERsbi7y8POzduxetW7eGUqm06el71apVWLp0KYKtxMpXJldVeeWVVzB69Gi0a9cODz74IHbs2IEtW7bgjz/+qHRfkUiESZMmYfbs2WjYsCG6du1aZTk4DiY+HnjmGWDXLnrfrBnlZSxYQKG2yck0LhIBzz0HTJhAigWwXPyxirg05DYvLw+nT5/G6dOnAZBZ4vTp04iPjwdAq4TipyWhUIgWLVqYvcLCwkzhkbaYKTglDB9u3/YO/M7ZxLvvvos5c+ZgwYIFaNasGQYMGIAdO3ZYfTioiAEDBuCXX37Bnj170LFjR3Tp0gWffPIJYkr1mt68eTM6duyIxx9/HM2bN8err75qWl1069YN06ZNw5gxYxAaGoqFCxfadF6FQmFZYeTlAZcvY8C5c/hl5Ejs2bQJHTt0sChXVRgxYgSWLFmCjz76CHFxcfjmm2+wcuVK9O7d26b9p0yZAq1Wi8mTJ1dLDo6DMBqBpUupLEixwgCohEi/fsDYsSUKAyC/xuefk7lKoaAOnJ06OU4eh7nUq0BxBEzZ18SJExljFGHTq1cvq/vz6Kmq4+roKa8lJ4ex775jTCAwv8idOjGWkOBq6RhjjB04cICJxWJ29+5dV4vCuXKFsZ49Lf8wR4xg7JtvrP9w69ZlbOdOh8fMu03IbU3BlUYJrszT8FouXrR+sV97jTGt1mWiFRUVsatXr7I+ffqwsWPHukwODmNMp2Ns4ULG5PLy3xOZjLH/+z/G9HrGnnuu4h/wpUsOF43XnvJi4uIouMJa1GrHjjQfF1ezctVqtm61Prd0KZCSUnOylGHdunVo0qQJ1Gq1zSY4jhP47z8qyfDqq+WbKN1/P82/+ir5LkqFXpejQQOKpnIwHuMI5ziHuDjKwTh2jMJqs7LI6T1iBJlBy0RpcqrL3bvW53JzyX7tIiZNmoRJkya57PzlyM8HMjIovNRopJLfoaHUoKk2otEAH3xAr1KlZAAAPj5U3+fZZwFhqWf99u3pB2spvHHWLNrPwXClwYFAQDkYjs7D4FjgoYeAzz6zPNe9u1N+5B5Jfj5w/TqFl65ZQ07fPn2opWmzZkBUlKsldCxHjwJTpliuEzVgABWFsxQgERYGfP89FSu8dInGlEp637Ah9SJxMFxpcDg1SVwcmRTKhI9DKKREraAg18jlbiQnU47B0aMlY7//Dvz1F2U6h4U5xfRS4xQUAG+/Tb29y64yAwOBTz+l0FlrS/7wcFKuzz0HREdTh0ORCLh4EWjd2intXrlPg8OpSaKiqFnOjBkUDglQpdJDhyq2T3sbly6ZK4xitFpg7lwgKanGRXI4f/8NtGpFDwtlFcaoUcCFC8DEiRXbiOVyqnLbpg0p2qtXaaUxfDiVR3cCXGlwODVNdDTw0UfA5cvAzZvAL7+QbdAJ5Uw8luJ8BKGQIjV69SppKPTXX2T/91TUakrS69OHVgmlCQ8HNm2iV0RE5cdKSqLEvqtXKZGvSRPK0/joI3KYO4FasL7jcDwQmYyUB8cyQUHA448DTzxBq7DsbOCpp8jXMWeO55qmfv2VFEZx7ajSTJxov4nyxg0y402fDiQk0JhEQg7zq1dpFeLg7n0eeuU5HE6tZuxYWoE99FBJC8kvv6RooW3bPM8Rnp4OzJxZUnW2NPXqkaN74ED7jysQAOPGUZWBYnQ6Crb46CP6t4Ph5ikOxxUkJQGnT1Os882b5BDllMAY5SKU7Tl84gQpDaGH3LoYA9avB5o3t6wwpk8Hzp2rmsIA6DtUWmGU5vPPnfK98pArz6mtHDp0CCKRCAMt/Gjmzp1rsQe8vf3kq4M1GaqM0QicPAl06wa0bYu/O3eGoEEDBAYHo6jYvHCPY8eOmVrMeh3bt1tvUv/VVy5NgrSZpCRg5EjgsceosGBpGjUC9u0Dvviieg7r4jBbS8THO0W5cqXBAWMMRWlFyDyRibTDacg8kYmitCIwaz9aB7JixQrMmDEDBw4cMBWqdAQ6JyzLq4NJnvh4coDevm0271tUhK0ffGA2tmLFCtSrV6+mRLQbrVbrvIO7cRJkpTBGPbqbNy/fuEYopBXUmTNAjx7VP1fHjtbn6ten6CpH4/DCJG4Orz1ljiZTwxJ2JLDrq66XeyXsSGCaTI3Tzp2Xl8d8fX3ZpUuX2JgxY9i8efNMcytXrixXyHLlypUsJibGbKy4fWpx8crly5ez+vXrM4FAwIxGI/vtt99Y9+7dmb+/PwsKCmJDhgxh165dM5Pjzp07bMyYMSwwMJAplUrWvn17duTIEasyMMbY7du32bBhw5hKpWK+vr7s0UcfNSvwZ00etnKlWW2gv+4d9y2A9ZXLGUtKYowxVlBQwPz9/dnbb7/Nyv5MDx48yHr06MHkcjmrW7cumzFjBsvLyzPNx8TEsHfffZeNHz+eqVQqVq9ePbZt2zaWmppqkrlFixbs33//NTvupk2bWPPmzZlUKmUxMTHs448/NpsvPu7EiROZn58fmzBhAuvTpw+bPn262Xbp6elMKpWyvXv32v5lKMvu3dbrKXXrxlh6etWP7Uxu3GCsb1/LcrdqxViZa15tbt60XkDuhx8ce657cKXhxWgyNezmjzctKozi180fbzpNcSxfvpx16NCBMcbYjh07WGxsLN1YGd00X3rpJRYXF8eSk5NZcnIyKygoYKmpqaabd3JyMktNTWWM0U1apVKxAQMGsJMnT7IzZ84wo9HINm3axDZv3syuXLnCTp06xYYOHcpatmzJDAYDY4yx3Nxc1qBBA9ajRw+2f/9+dvXqVbZ+/Xp26NAhqzIYjUbWtm1bdv/997Pjx4+zI0eOsHbt2plVZLYmD5s+3aLSuAwwGcBu3+uLvnbtWta6dWu2detWM6Xx33//MR8fH/bpp5+yK1eusIMHD7K2bduySZMmmbaJiYlhQUFB7Ouvv2ZXrlxhzz77LPP19WUDBw5kGzZsYJcvX2YjRoxgzZo1M13v48ePM6FQyObPn88uX77MVq5cyRQKhUlJFh/Xz8+PffTRR+zq1avs6tWr7IcffmCBgYGsqKjItN2SJUvM/i+rxPXrjLVoUf5GKBQydvBg1Y/rLPR6xpYsYUypLC+zRMLY/PmMaZzwOzIaGTtzhrFGjUrOp1Aw9uGHTlOsXGl4KUaj0eoKw9KKo1o3ACt069aNLV68mDHGmE6nYyEhIWzPnj2meWul7wGwrVu3mo298847TCKRmJSINYqVztmzZxljjH3zzTfM19eXZWRkWNzekgy7d+9mIpGIxcfHm8bOnz/PALBjx45VLM+qVRaVRhbARiiVbN4rrzDGGOvTpw9bsmRJOaUxfvx49vTTT5sdcv/+/UwoFLLCwkLGGN3cn3jiCdN8cnIyA8Defvtt09jhw4cZAJacnMwYY2zs2LGsX79+Zsd95ZVXWPPmzU3vY2Ji2IgRI8y2KSoqYkFBQWz9+vWmsTZt2rC5c+dauJp2cOIEY7/8wtjkyXQTLC4fv3kzYx9/zFhaWvWO70guXKDVj6Wn/c6da6ZMdHIyKY9jx2j1UUqJOxru0/BSNOkaaDJsS5DSZGigSXdsMtXly5dx7NgxPPbYYwAAsViMMWPGYMWKFVU+ZkxMDEJDQ83Grl+/jrFjx6JBgwbw8/MzNXEq9p+cPn0abdu2RZAdsfEXL15EdHS0Wdvg5s2bIyAgABcvXqxQHvTqRe04LTD5mWewatMm3LhxA4cPH8a4cePKbXPixAmsWrUKPj4+pteAAQNgNBpNvdUBamFbTHh4OACgZamM8+Kx1NRU02fq3r272bm6d++Oq1evmrW67VCmJLJMJsMTTzxh+n87ffo0zpw5U/3Chz/9RE7k3FzyD2zYAAwZArzwArUvzc6u3vEdgU5HxQXbtKFcktIoFJRzcfBgzZSJjoig7PKOHYHYWMoDchI8T8NLKYi3LxSvIL4A8lDHOdWWL18OvV6POnXqmMYYY5BIJMjKykJgFfrLWureOHToUERHR+Pbb79FVFQUjEYjWrRoYXLiKqqQhc0YsxjRVHbcYjfJevWofMTDDwO3bpWMv/EGBr/wAp756SdMmTIFQ4cOtdj1z2g04plnnsELL7xg4dAlTnOJRGL6d7FMlsaM9xzKlj4TsxAIYekzPfXUU2jTpg0SEhKwYsUKPPjgg9XuPoiiIrop371LkUdKJZXJUKuplIirOXUKmDyZQl7L0qcP8O23wH331bhYNQFXGl6KQWuofKNqbF8Rer0ea9aswaJFi9C/f3+zuVGjRuGHH37A888/D6lUavaUW4xEIrE4XpaMjAxcvHgR33zzDXrci1Q5cOCA2TatWrXCd999h8zMTIurDUsyNG/eHPHx8bhz545ptXHhwgWo1Wo0a9asYqGEQqBtW3oCTU2lJ9Tp04Hnn4coPBzjx4/HwoUL8dtvv1ncvV27djh//jwaNmxY6ee3h+bNm5e7NocOHULjxo0hqqToXcuWLdGhQwd8++23+PHHH/H5559XX6BHHqHeEWfPAosWlVS53bQJ2L3b4VnONlNUBMyfDyxcSOU6SuPnB3z8MWWu1+IwaW6e8lJEUvuqX9q7fUX88ssvyMrKwpQpU8r1fX/kkUewfPlyAEBsbKypb3x6ejo09+oNxcbGYu/evbh79y6yLPURuEdgYCCCg4OxbNkyXLt2DX/++SdmzZplts3jjz+OiIgIjBgxAgcPHsSNGzewefNmHD582KoMffv2RatWrTBu3DicPHkSx44dw4QJE9CrV69y5hurREWRWaN5c3p/b8Xz7rvvIi0tDQMGDLC422uvvYbDhw9j+vTpOH36NK5evYqff/4ZM2bMsO28VnjppZewd+9evPvuu7hy5QpWr16NL774Ai+//LJN+z/11FP48MMPYTAYMHLkyGrJAoBKrHzxBfDeexSmnJND4asjRlC2eBVWotXm0CFS+AsWlFcYDz1EZc2nTq3VCgPgSsNrUdZTOnX7ili+fDn69u0Lf3//cnOjRo3C6dOncfLkSYwaNQoDBw5Enz59EBoainXr1gEAFi1ahD179iA6Ohpt27a1eh6hUIiffvoJJ06cQIsWLfC///0PH330kdk2UqkUu3fvRlhYGAYPHoyWLVviww8/ND1dW5KhOLkwMDAQPXv2RN++fdGgQQOsX7++2tdGKpUiJCTEakJfq1at8M8//+Dq1avo0aMH2rZti7fffhuRkZHVOm+7du2wYcMG/PTTT2jRogXmzJmD+fPn2+ybePzxxyEWizF27FjIHZEbcOcOsH9/+fGiIvJpqNXVP4et5OUBL75IK5+yyXTBwZTp/fPPVDDQCxAwS4bLWkxOTg78/f2hVqvhZ8Uh6Q0wxpD0a5JNznBZsAxRQ6K8MzOZYxN37txBbGws/v33X7Rr1676B5w1i3pJyGRA797k0zh1ivxAAgH9rYnExz17qCBgaf9TMY89BixZUns7CVqBrzS8FIFAgNDuoRBKK/4KCKVChHYP5QqDYxGdTof4+Hi89tpr6NKli2MUBkD+genTKWqqOLP5tdeoS11UlPNrT2VnUye9/v3LK4zISDKVrVvndQoD4I5wr0YaKEXUwCikHUyzuOKQBcsQ2j0U0kCpC6TjeAIHDx5Enz590LhxY2zatMlxBx47ltq8Dh9eMrZuHdC0KTnDndDG1MS2bdQJLzm5/NyUKeTsDghw3vndHG6e4oAxBk26BgXxBTBoDRBJRVDWU0IWIuMrDI5rOHfOeifD55+nG7ejcxFSU6mj4oYN5efq16cw2gcfdOw5PRBunuJAIBBAHipHUPsghHYNRVD7IMhD5VxhcFzHli3W51asKF81tjowRs7s5s3LKwyBgPpgnD3LFcY9uHmKw3EV6emUwBYU5NQMXo+kglBqFBQ4rsrtnTvU5e7XX8vPNWtG2ehduzrmXLUEvtLgcGqau3eBtWuBvn3phjRrFnDtWvnYf2+mtC+jLH37Wi3FYjNGI3XLi4srrzDEYuCttyhaiyuMcnCfBodTk6SmUghn2T4Lvr7A0aP0dMshxfrII5Q5XxqplK5TdRpjXbtGSXh//11+rl07Wl04svFWLYOvNDicmuTGjfIKA6DCfG+8QX85VIBvwwbKCA8PJ/PdQw8Bx4+XZNHbi8FAJUlatSqvMGQyyvSurkLyArhPg8OpSTZvtj7388+UH1Cd9p+1CaUSGDMG6NSJnNX+/pSBLa1CCPi5cxQue+xY+bnu3Wl10aRJ9WX2AvhKg8OpSSpyeIv5M5wJtRr48UeKasrPp/dXr1KrVHvaAmu1wLx5ZHYqqzBUKuDzz6lXN1cYNsOVBodTkzzyiPW5ceOcm7TmSaSmUmnx33+nvhqjRwP/+x/Qvj1w4ACgsaG/y7//Ah06AHPnUpRaafr1o9XH8887P7u8lsGvFodTk9SrR8XvyhIVRRE7VejvUSvJyAAmTQLuVRsGQCHKs2aRwqgoJLewkFYkXbpQfkVpAgKAlStJGcXGOkHw2g+PnuJwapr0dCApCUhJIeesUgk0aOA1VVJtYsUK8kFYolkz4Jdf6JqVZd8+2u/atfJzI0cCX35JtaM4VYavNDicmqagAFi6FBg2DBg0iMwut2/TOIc4edL6XKmWuiZycqheVK9e5RVGWBhFYm3ezBWGA+CeNw6nJklKIkVx4ULJ2MmTQM+elJPQpYvrZHMnmja1PhceTlVvi/ntN+CZZyi7uyzjx1OJdVd1+qspkpKotIpGA4SGUsiyk0ydfKXB4dQk//1nrjCKMRrJXp+RUfMyuSODB1uPNHv9dbopZmQAEybQtmUVRt26lOm9Zk3tVhhGI/Upv/9+yi/p3JnMd4sWkRnUCXClweHUJFZ6fwMgp29+fs3J4s7UrQvs2lW+XMikScDjj1NBw+bNqRxLWZ59llqvDh5cI6K6lPh4alJ182bJmEYDvP12xd+1asDNUxxOTVKRTd3fn4d/FnP1KkU5ffcd5a8UFVFf8D/+IGWRmVl+n4YNaftevWpeXlfxzz/WW9/OmUN1uhzsx+HfUA6nJhk5ksptW2L6dLLXezvnz5O5JTWV7PK3bwNXrlAobVgY9ewujVAIvPwycOaMdykMADhxwvrcrVuU3Ohg+EqDw6lJ6tQBVq0iM0vpaPdu3Sj6RyJxlWTuAWN0bXr0AIYOBR5+2Dwx74EHyCT12GO0bVwcrUg6dnSZyC6lova6MTFVK7lSCTxPg8OpafLzKdpl1y6KeBkwgLKfIyJcLZnrOXKEFOivv5LSsFQuvnhVsWcPsH8/rUq8lVu3gNatKeS4LKtWARMnOvyUfKXB4dQ0KhXQqBG9OOZs20alPw4etN5fZPly4JNPSGn8+qt3K4169YC//qIV2e3bNCaVArNnA0OGOOWUXGlwOK6AsZKM8IAAUiTeTE4OmZm++orCRlNSrG+blVVyvSoqJ+INCIVkojp0iHxAGg35fcLDqdKAM07plKPayL59+zB06FBERUVBIBBg27ZtFW6/ZcsW9OvXD6GhofDz80PXrl3x+++/14ywHI6jSE6m6qrdu1Nvh6lTKctZr3e1ZDXPtWtUi6tuXerFnZMDXLpUsY+ibVtyjAMUUcWh2mXFeRr16ztNYQAuVhr5+flo3bo1vvjiC5u237dvH/r164edO3fixIkT6NOnD4YOHYpTp045WVIOx0GkpFCW8osvUkOmzExg3Tqq3nrpkqulqxkYo9DZoUOBxo2Bzz4zbz515w71FLFUWwoAXnsN+PZb+veIEU4Xl1MG5iYAYFu3brV7v+bNm7N58+bZvL1arWYAmFqttvtcHE612b+fMbptln8NGsRYdrarJXQe+fmMffMNY3Fx1q8BwJhSyVh4OGO7djE2fDhjIhGNN2rE2OrVjD3xBL3v2JExo9HVn8rr8GifhtFoRG5uLoKCgqxuo9FooClVez/HUpQBh1NTbNlifW7XLkrU8vevOXlqgjt3qLrst99aTsoDAJGIeo28+CKtMnr0AEaNolXZ+vVULiMlBfi//6MyLMUlzq3lvHCchkcrjUWLFiE/Px+jR4+2us2CBQswb968GpSKw6mAimzNFXX18zQYI+fskiWkKK1FQgUHA08/TTkqpUvDHzhA+Rpff02v0nTsSAojLs5p4nOs4zZ5GgKBAFu3bsUIG22U69atw1NPPYXt27ejb9++VreztNKIjo7meRoc17B/P1W0tcTEicCCBZ5dvlujoTLkS5ZUnK3cogWtKsaNs16NlTFq0bptG0VJBQaSD6NTJ77CcCEeudJYv349pkyZgo0bN1aoMABAJpNBVpue4DieTUIC3SyXLDEfr18fGDOmfFtSTyElhVYEX31lPVxWICDn94svAn36VH7jFwgoGqhzZ8fLy6kyHqc01q1bh8mTJ2PdunUY4qTkFQ7HaQQGkhlq82Z6gs7Ophto3bpk91+92tUS2sfJk6QAf/rJep0jPz9g8mTqx33ffTUrH8fhuFRp5OXl4VqpLls3b97E6dOnERQUhHr16mH27NlITEzEmjVrAJDCmDBhApYsWYIuXbrg7t27AACFQgH/2uY85NROWrakTn0bNtBflYrCT196ibKgPaH3g15PCm/JEvI9WKNRI2DGDPJN+PrWlHTeR2EhlaU5eJB6aPTsSZniYWHOOZ8rQ7f++usvBqDca+LEiYwxxiZOnMh69epl2r5Xr14Vbm8LPOSW43Ju3mTsl18onLRHD8YWLmTs4kUKSXVnMjIY+7//Y6xevYpDZvv1o89nMLha4tpPQQFjGzcyJhab/x88+CBjiYlOOaXbOMJrCl6wkONSMjKoz8HSpebjkZHAvn3UE8LduHCBEvDWrKGnWksoFNRF74UXqN8Fp2a4epVa4xqN5efeeQd46y3qR+JAeD8NDqcmuXmzvMIAqLTIu+8CBQU1L5MljEYqBti/P4W2fvONZYURHU25EwkJ5AjnCqNm2b7dssIAyHx4z4TvSDzOEc7heDQbN1qf++knejq0Vj6jJsjNpZLan31GdaGscf/9FAU1YoTDn2RNqNXUznTtWirG9/DDVG6lTh3nnM8TKdsbvTTZ2dYVSjXgSoPDqUmKiqzPGQxO+ZHbxPXrwBdfACtWWO7NAFDJ7cceI2VRUfMfR6BWUwn0l14qGVu9mlYyu3bRCodD/cE/+8zyXPv2lGnvYLh5isOpSR56yPrc4MHWE92cAWPA3r3AsGEU6bR4sWWFER4OzJ1LT/2rVztfYQBAYqK5wijmwgXg448piZBD0XbW/GCvvOKUU3KlweHUJPXrk3Ioi58f8MYbNdO9r7CQ6kC1agX07Qvs2GHeeraY9u3J+X37NpnNarJ/eUVmvO++I3MVhzodfvEF1e0qNhM2aUImvV9/5eYpDsfjqVMHeP99cjCvWUN25wceoBIi9es7xZxgIiGBEgiXLau4cODDD5MJqls315XryMgo+XeLFlSz69IlWgkVFPCVRjGDBlHG/LhxVGKfMVqlvfce5WuEhDj8lFxpcDg1iUJBIZIhIVR4T6ulcNugICA01PHnYww4fJgiaTZvtl44MCiImkFNn+4e/oIHHqCb31NPUQ2r7GwyV6Wk0BO0M5WrJ1G3LjBrFj2IfPddyXhMDK1cnWDu5HkaHE5tRKstKRx4/Lj17eLiSgoHOrHbm92cPk2ml+nTzU0s3bqRaU2pBGJjXSWde5GZSZFuX31FZrvRo0npOkn5c6XB4dQmUlNLCgdai9EXCMgh/8ILwIMPumfF2HPnyOdi6fb0+uvk5K2gj45XYjBQiRcnF2jl5ikOpzZw6hStKtats1440Ne3pHCgO2ael+bXXy0rDIAU4vTpXGmURSSqEbMdVxocjqei11NG8JIl1KfDGvfdR6uKSZMoSssTSEy0PqdWuy6fhcOVBofjEpKTyZSk0ZADPCLCdqdlVhY5Pb/4gnInrNG3L/krBg8GhB4WXT9gAPD555bnOnem6sAcl8CVBodTkxiNwH//UVz99es0JpdTEcOpUysOkbx4saRwoLUaVQoF9dV+4QXPbofasCFFmV26ZD4uEFDOCFcaLsPDHj84HA8nPp5KPxQrDIBKi7zxBrB7d/ntjUZg50568m7enJzclhRG3brAhx9SLaJvvvFshQFQePAnn1BUl1RKY61akc9mzRrr3QE5TocrDQ6nJtm3j2zylnj7bTJbAVQ48IsvgGbNgCFDLCsUAOjenUJrb94EXnvNM5o42UJyMjByJDl2166lzzhuHCnX9eutO/s5ToebpziOJzeXel37+/MkrLIcPWp97sYNyoT+6CMq1metcKBEUlI4sH1758jpagYOJKW5Zg29StO/v9PDSjnW4UqD4zhSU6ln9KJF5KwdMQJ44gmehFXMrVtUEiMkBHj2Wbrh63Rkblq2jMp8pKcDn35qef+wMNpv2rSaqVHlSmJjgV69gH/+MR9XKChPIzDQJWJxeHKfq8WpPaSnA6++CqxcaT4eGgocOuT+eQHOhjFyTk+YQCUx5s2jns4AKYM33qBKs1Ip0K+f+b7t2tGqYswY73nCTkkBzpyhrPA1a+gh5IEHKFggNhZo3NjVEnotXGlwHMOJE0CHDpbnxo6lJ2lvjng5coSUxtKlVIq82HdRmo0bKTrokUfo76hRpCy6d3fPrG1nk5xM1y09nSq46nQURNCggfMaP3EqhV95jmPYsKHiuQ8/9G6lsX071Qi6fNmywgAolPT11+nfzz5LFWm9mchIcoanpFAiY2Cge9XH8lK40uA4Bu9asNpPVhZlZleUuX3hQkmCn7VqtN5ITfbx4FQKD7nlOIZHH7U+N2oUrxPk7w+kpQFRUda3CQ8n5QJwRy/HbeFKg+MY6tcn30VZgoKAd9/1btNUXh6tME6dIr9PcbJaWZ55piS8dMSIGhPP7Sko4PWm3AiuNDiOISSEMni3bwfuvx9o2RJ4803q5eDNkVPJyRQ6evgwvf/2W2DbNqo4W5onnqCaSgcOUHOmTp1qXFS3Iy0N+PNPihobPJhCkW/fdrVUXg+PnuI4HrWaMnYDA707yuXCBWrHWbqo4Jo1VPb7kUdKnqAbNKB8hE6dyBm+YYPnlwGpLhkZVI9r6VLz8YgIUqz33ecauTjcEc5xAv7+rpbA9fz9N5mYSpcMiYqibO716+nl70+O79RUMr106gRs3cpzEABStGUVBkCNpebNoxpcPJLKJXDzFIfjaH74gUpdlFYYIhGVMz90qGRMraabYLGt/tgxqnjLoZwVa/z0E61EOC6BKw0Ox1EwBnzwAfkndLqScR8f4JdfyFRVt671/QMCPK/vhbMoff3KYjDwEG8Xwr+hHI4j0Osp+unNN83HIyMpcmrgQHo/fLj17O4ZM2p/TSlbqSiEe+RIHpLsQrjS4HCqS24uMHQoRUaVJi6OymC0aVMyVrcuma/Krih69qRChN4cOFCaqCjLYcf+/sDcueWjzzg1Bo+e4nCqQ1IS9bs4fdp8vE8fYMsWMjmVpaCA9vvzT6qr9MADlOfCM59LOHOGyshrNMD335cULHz4YepJ8uabtrfH5TgUrjQ4zkGvr/1PzefOUf7AnTvm4+PHk9PbWhIfp3Leegt4/32KJBs1ipJDjx8HduygoIJr14DoaFdL6ZXY9atmjOGff/7B/v37cevWLRQUFCA0NBRt27ZF3759Ec3/E72b5GRKvlq+nIrzDRtGiX61Mab+zz/pqbdsF76336aQUG+sSutINBr6e+UKsGCB+Rxj3BHuQmzyaRQWFuKDDz5AdHQ0Bg0ahF9//RXZ2dkQiUS4du0a3nnnHdSvXx+DBw/GkSNHnC0zxx1JTqaqrF270lP2li3ApEnkAL52zdXSOZbvv6fPVTakdvlyYP58rjAcwahR1ueGDbNs9uPUDMwG6taty0aNGsV27NjBtFqtxW1u3brFPvjgA1avXj22bNkyWw7rEtRqNQPA1Gq1q0WpXZw4Ufz8V/41dSpjubmulrD6GI2Mvftu+c/n48PYrl2ulq52kZLC2LBh5a+1ry9jFy64Wjqvxiafxrlz59CiRQublJBWq8Xt27fRqFGj6uozp8B9Gk7i9deB//s/y3MKBXD2rGebqXQ66nGxfLn5eFQUlQUpHSHFcQx37wK7d1NNs+xsCjiYOZPKrvDe8y7DJp+GrQoDAKRSqdsqDI4TycuzPldU5NkVSnNygNGjgd9/Nx9v2ZIUBvflOYeICGqPO2hQSRMmnjHvcuwOb7l69SoOHTqEu3fvQiAQIDw8HN26deOKwtsZPtx6p7l+/QBPXdUlJtIT7pkz5uN9+wKbNvE6WzVBaKirJeCUwmaloVarMWHCBOzYsQP+/v4ICwsDYwxpaWnIycnB0KFDsWbNGm7y8VYaN6ZIqQMHzMflcop+8cQchLNnKaQ2IcF8fOJE6nlenZDa9HR6abWkUGNjqyUqh1NT2JwRPmPGDNy8eROHDx9GVlYWLl++jCtXriArKwuHDh3CzZs3MWPGDGfKynFnYmKA1aup9lK9evQEPnIkZUQ3a+Zq6exn715SgmUVxty5wMqV1VMYV68CU6cCLVoArVvTSmz7duofweG4OTYn9wUEBOD3339H586dLc4fOXIEAwcORHZ2tiPlczjcEe4k0tKodlJiItUNUqmAf/8Fdu4E/vjDs8p9r14NPPUU2dGLEYupTMikSdU79o0bZNq6ebP83O7dpEA4HDfGLp+GoIL484rmOF7AzZvUIwIob6J66y1gxQqq9urOMEatad95x3zc15fyTvr2rf45Tp60rDAAikBr2pQ71suiVlP0WkBA7a8y4AHYbJ4aOnQopk6diuPHj5ebO378OKZNm4Zhw4Y5VDiOB1G6/0HTpkC7diV9wbdsodpB7oxOB0yeXF5h1KlDStARCgMgs5c1Tp4syYTmACkpwM8/UzHIBx6g/5sbN3g2uIuxWWl8/vnniIqKQqdOnRAUFISmTZuiWbNmCAoKQufOnREZGYnPPvvMrpPv27cPQ4cORVRUFAQCAbZt21bpPv/88w/at28PuVyOBg0a4Ouvv7brnBwnIRJRpu6vv5IJp39/YNUqirF39w5rOTkUIbVqlfl4q1bkk2nVynHnKl5FCIXUE7xPH+qvDgBBQTybvJj0dODllykqb/9+Ckr44APqn371qqul82psXusFBATgt99+w6VLl3D48GHcvXsXABAREYGuXbuiadOmdp88Pz8frVu3xpNPPolRFZUNuMfNmzcxePBgTJ06Fd9//z0OHjyI5557DqGhoTbtz3Ei48dTn+thw6hJTjE9e1KRueBg18lWEQkJpDD++898vF8/Cql1tN9rxAjg0iXgscfoZqhWA08+SbksKSncNFXMrVtUrqUsmZnUO/y779zf3FlbcWk+eikAsK1bt1a4zauvvsqaNm1qNvbMM8+wLl262HweXkbESVy8yJhQaLmMyJw5jOn1rpawPGfOMFanTnl5n3ySMSvlcqpNaipjX35Z/pzt2jF2/bpzzumJvPaa9bI0IhFjt2+7WkKvxWFNmLKysrBmzRpHHc4ihw8fRv/+/c3GBgwYgOPHj0NnpT2kRqNBTk6O2YvjBH7+2XrW9+efU0kId2LPHgqpTUw0H58/n0qFSCTOOW9GBjB9evnxkycp96OiNqccQiDgZjwX4jClER8fjyeffNJRh7PI3bt3EV4mSSw8PBx6vR7p6ekW91mwYAH8/f1NL16+3UmU7SlRmqwsc5OVq1m5kpL2cnNLxsRi8mm8/bZzb0hbt1qfW7qUTFScitu9Pvoo+X84LsFmpVH2ab3sK7f0D9CJlA3tZfciKayF/M6ePRtqtdr0ulPRzY1TdYp7YFuiY0f3cIYzRsl5kyeb52D4+QG7dlGmt7OpaMWVm+vZNbocSUwM/T+VJSSEVoPFkXmcGscuR3hFuRiMMafnakRERJgc8MWkpqZCLBYj2IqjVSaTQSaTOVUuDqjKa6NG5SNbBALg009LIoRchVYLPP00Je6Vpm5dSkBs2bJm5HjoIcBalOH993PnbjEhIVR+5tFHgUWLaLU6YgQwbhy1xuW4DJuVhq+vL958802rGeFXr17FM8884zDBLNG1a1fs2LHDbGz37t3o0KEDJM6yQXNso04d8hO89Rbw00/0JN+8OfkzWrd2rWxqNTX1KZsj0bo1hQjXqVNzsjRuTCG8ZaO1RCJg4UJudilNWBitYLt3J6UfEMBLorsBNiuNdu3aAQB69eplcT4gIMBkKrKVvLw8XCvV1e3mzZs4ffo0goKCUK9ePcyePRuJiYkmB/u0adPwxRdfYNasWZg6dSoOHz6M5cuXY926dXadl+MkYmKAr7+mrGqdjsw+ri5UeOcO+S/OnTMfHzCAEhJ9fWtWnqIiqga8ejXw449AQQF1O3ztNSruWFDgHqY8d6Km/484FWKz0hg7diwKCwutzkdEROCdstm0lXD8+HH06dPH9H7WrFkAgIkTJ2LVqlVITk5GfHy8ab5+/frYuXMn/ve//+HLL79EVFQUPvvsM56j4U6oVO5jbz59mnIwkpLMx596ipzOrlidJiTQ0/Pw4VTLSiIhhfbcc/RE/emnXGlw3BqbCxbWFnjBQi/h99+BRx4p3xzqvfeAN95wXcjmrFmkGCwhkQAXLgANG9asTByOHfDqX5zax/LlwDPPmIf5SiRUNPGJJ1wnF0DlQ6xhNPKCfBy3x+5vqLX6UgKBAHK5HA0bNkTPnj0h4g4r7yQjg+oGaTTUnjMqquacl4xRiYn33jMf9/en/IhSplCX8cgjFA1kiYcfdn2UGYdTCXabp+rXr4+0tDQUFBQgMDAQjDFkZ2dDqVTCx8cHqampaNCgAf766y+3TKTj5ikncvky1VE6fJjeh4RQwcKhQynyxZloteSrWLvWfLxePQqpjYtz7vltpbjvSHEZ+WICAoCjRz2r7wjHK7E7I/yDDz5Ax44dcfXqVWRkZCAzMxNXrlxB586dsWTJEsTHxyMiIgL/+9//nCEvx12Jjwd69y5RGACtOCZMAA4edO65s7OBQYPKK4y2balKrbsoDID6XS9ZQuXiu3WjsOTXXwdOnKA8Fw7HzbF7pXHfffdh8+bNaNOmjdn4qVOnMGrUKNy4cQOHDh3CqFGjkJyc7EhZHQJfaTiJDRuAMWOADh0oIUupBI4fpyfqBg2Av/6iuHtHEx9PIbXnz5uPDxpEMrlzslxWFoUmBwa6JpKLw6kCdvs0kpOToS9dguEeer3elK0dFRVVY2VFOG7C4cP0pH/7Njmcs7Np5bFtG9VzKipy/DlPnaKQ2rIPJ1OnUkituzqVi4ooDPjoUVqNdetGZrTQUFdLxuFUjr1lcQcPHszatWvHTp48aRo7efIka9++PRsyZAhjjLGff/6ZtWjRoroVeJ0CL43uJPbvZ6xPn/JlrJVKxnbvZiwpybHn27mTMR+f8uf74APGjEbHnsuRFBQwtmULYxKJudwDBzr+GnE4TsBun8by5csRFBSE9u3bm+o6dejQAUFBQVi+fDkAwMfHB4usRYhwaicGA5mgylJQQLWWHJmw9u235FwvnYMhkQA//ADMnu3eZbMTEiiCqmwJ9F27KFTYnaoBczgWqHJy36VLl3DlyhUwxtC0aVM0adLE0bI5Be7TcBIVJa0JhcDNm2SCqQ6MUW2rDz4wHw8IoJDa3r2rd/yaYNEiiih78UWKlNLrKT9j+XLyAf33X83WwuJw7KTKRt/SisLZ1W05HkBFKwmptPpP/xoNMGUKrSZKExNDIbXNm1fv+DVFYSG1Kp09Gzhzhsb8/Kj2VNu2fKXBcXuq1IRpzZo1aNmyJRQKBRQKBVq1aoW1ZcMdOd7F6NHW5yZMqJ6TNyuL6jWVVRjt2lFIracoDIB6qE+YUKIwACAnB3jzTQq5dedoLw4HVVAan3zyCZ599lkMHjwYGzZswPr16zFw4EBMmzYNn1ozT3BqP9HRlG9QlpgYeqqWy6t23Nu3qZDf33+bjw8ZAvzzDxARUbXjuor//qOIKUssXMjbvXLcniplhM+bNw8TJkwwG1+9ejXmzp2LmzdvOlRAR8N9Gk7k9m3g4kVgzRoKue3fn0qQ169fNaVx4gQ1LSrb7W7aNOrT4a4htRXxwgskuzVu366+74fDcSJ2rzSSk5PRrVu3cuPdunVzy2Q+Tg2RnEzlvseMIbt8RATla7RsCZw9a//xdu4EevUqrzD+7//cOwejMirKTq9Tx3M/F8drsFtpNGzYEBs2bCg3vn79ejTiZRC8l3PnyE6fk0OZ2CtXkrIwGICXXya/hK0sW0Yhtfn5JWNSKbBuHfDqq+4dUlsZ/foBCoXluTffBCIja1YeDsdO7H6smTdvHsaMGYN9+/ahe/fuEAgEOHDgAPbu3WtRmXC8hDJteM3Ytw/IzaVyGRVhNFJI7YIF5uOBgZRZ3rNntcV0OfXqUVvc4cOpIjBAIcnTp1NLWk9WiByvwG6lMWrUKBw9ehSffvoptm3bBsYYmjdvjmPHjqFt27bOkJHjCRTXlRIKgfbtKQT33Dm6Mfr6VtxHAqCQ2iefpNVEaWJjgd9+A5o2dYrYNY5YTO1dT50CEhNJmdavT9eP+9g4HgDv3MdxDJcuUW/wceOoqm12Nt0cCwooC/rtt60X5cvKAkaOpGio0nToAPzyi+v7jHM4HBM2rTRycnJsPiC/EXspwcEUGvvQQ5S5DZDDukMHYONG6wrj1i2qUnvxovn4Qw8BP/3kPv3GORwOABtXGkKhsNKsb8YYBAIBDG6e0cpXGk7i0iWgWTPLc6+/DsyfX15xHD9OyiElxXz82WepXhWPJOJw3A6bfpV/WSpEx+GUZutW63NLl5Kjt27dkrFffqHw3IIC820XLqRoK+4Q5nDcEpuURq9evZwtB8fTqShHJyeHIqOK+eor4PnnzcekUkoKHDPGeTJyOJxqY1OeRnx8vF0HTUxMrJIwHA/moYesz91/P9VUMhqpMN9zz5krjMBA4I8/uMLgcDwAm5RGx44dMXXqVBw7dszqNmq1Gt9++y1atGiBLVu2OExAjofQogVlf5dFJKJS4EolMHYsmZ9KU78+df3r0aNm5ORwONXCJvPUxYsX8cEHH2DgwIGQSCTo0KEDoqKiIJfLkZWVhQsXLuD8+fPo0KEDPvroIwwaNMjZcnPcDYkE+PJLYPVq4McfqQR4587kBPf3B0aMAH7/3Xyfjh0pKZCH1HI4HoNdeRpFRUXYuXMn9u/fj1u3bqGwsBAhISFo27YtBgwYgBYtWjhTVodQ5eip1FQgLQ3Qaim8NDLSehipN7JvH9C3LymHESPo2ly4QF322ralJL0vvijZftgwUi48pJbD8SjsimmUy+V4+OGH8fDDDztLHvfk/Hkyrfz3H7338wM+/JBs8EFBrpXNHbh1i3IqdDrq0JeQQOaomzcpI3znTsr0LlYazz8PLF5MpisOh+NR8ED4yrh9m6qtFtcJAiga6LnnqJLryJGuk80dYIwUqFIJrF1L12vFCsoI792bakbNm1fi+P74Y2oNy0NqORyPhCuNyjh40FxhlGb2bCqV4WmNgBzJ0aMUKnvgAOVXpKUBjz9OSuT4cVqN/fxzSU2p++/nCoPD8WC40qiMQ4esz12+TD4Ob2b7dmqwlJICPPEE1ZFauxZQq2mlsWEDlREp9l1s20YOcg6H45FwpVEZFfWfrluXO8OzsqiqrU5HymHXrpK5VauAzZtpvKAAWLTIvr4atRWtlircnj0LZGbS9YuKogALDsfNsbsJk9fRu7f1pjmzZlHZb28mMBCQyUh5llYYxeTmkgM8NLRke2+mqIgSGZs3p54aTz4JtGoFPP10xVn1HI6bUCWlsXbtWnTv3h1RUVG4ffs2AGDx4sXYvn27Q4VzC/76i2z2ISElY0Ih8NRTpEy8/Yc+bBg5uXfvtr7Nzp0lZrwRI2pELLclIYGURVGR+fiWLWTWc/OCnxyO3Urjq6++wqxZszB48GBkZ2ebqtoGBARg8eLFjpbP9Zw/D7z3HoWIbtxIJpcdO6gC63PPlZQB90YYA374gRL5KgqfFYvJQd6xI9CpU83J5478+iug11ue++ij8j3RORx3g9lJs2bN2NatWxljjPn4+LDr168zxhg7e/YsCw4OtvdwNY5arWYAmFqttm2HnTsZo9sjYxIJYypVyfsHH2Tszh3nCuyuGAyMPfMMXQeFgrGtW0uuS9nX2LGMTZvG2Llzrpba9cyYYf06AYzdvu1qCTmcCrF7pXHz5k2LbV1lMhny8/MdocfciyZN6AkZIGdv8WeUSqmXdely396CwQBMnQp88w29LywEjh0Dpkwpv21UFNnrZ8wA4uJqVk535IEHrM+1bk2RaByOG2O30qhfvz5Onz5dbvy3335D84oijTyVBg0o2/mNN6iPs1QKDBxI+RuNG7tauprHYCDn7YoV5uPnzgHvvw/s2UMJj336UHHCP/4AevasOArNm2jfHoiOtjz38cclvdY5HDfF7pDbV155BdOnT0dRUREYYzh27BjWrVuHBQsW4LvvvnOGjK6nQQPqcT1pEr1XqegJ2tvQ64EJE0oS9Yp5+GEaE4tJOSxYQI7eoCAgIIAn85UmOpqCK2bMoGgzxmjss8+4v4fjEdhVsLCYb7/9Fu+99x7u3LkDAKhTpw7mzp2LKZbME24Gb/daRXQ6qr+1aZP5+KOPkjNcIKAM8OHDqbgjQM7xmTOph0ZxyC2HUKtLCmAGBHjnQwjHI6mS0igmPT0dRqMRYR60pOZKowpotcBjj5Vv6Tp2LJVCF4upOGGLFuXbtwJU6fapp2pGVg6H41SqldwXEhLiUQqjWuTkADduAJcueVduhkYDPPJIeYUxcSLlr4jvWTj/+MOywgCoYKE3XTMOpxZjk0+jbdu2ENholz558mS1BHJLbt6k7O+ff6ZEtgYNgM8/p25ztTkjvLCQ/BVlM72nTAGWLaMkx2KKy8ZbIiGBzFscDsfjsUlpjPDmLN6EBIoEupf5DoBWHEOGkEOzd2+XieZUCgrIP/HHH+bj06ZRhz5hmUVqly7mTZZK06gRRZ1xOBzPx6VZIoyxL7/8ksXGxjKZTMbatWvH9u3bV+H233//PWvVqhVTKBQsIiKCTZo0iaWnp9t8PruT+7Zts56I1a4dY6mpNp/bY8jLY6xPn/Kfd8YMxoxGy/vcusVYUJDl67RxY83Kz+FwnIZLCxauX78eM2fOxJtvvolTp06hR48eGDRoEOLj4y1uf+DAAUyYMAFTpkzB+fPnsXHjRvz77794yplO1j17rM+dPEkmnNpEbi4waBCtokozaxawZIn18Nl69YB//jHPx/DxoX369HGevBwOp2axRbMEBgaytLQ0xhhjAQEBLDAw0OrLHjp16sSmTZtmNta0aVP2+uuvW9z+o48+Yg0aNDAb++yzz1jdunVtPqfdK42PP7a+0ggJYSwhweZzuz3Z2Yx17Vr+c772mvUVRlnu3qVyISdO0OpDq3WuzBwOp0axyafx6aefwveew/fTTz+12SleEVqtFidOnMDrr79uNt6/f38cstL4qFu3bnjzzTexc+dODBo0CKmpqdi0aROGDBli9TwajQYajcb0Picnxz5Bhw2jPANL1Udfeqn2dO3LzgYGDKByIKV56y1g/nzbE/TCw+nF4XBqJ67SVomJiQwAO3jwoNn4+++/zxo3bmx1v40bNzIfHx8mFosZADZs2DCmreBp9p133mEAyr1sXmkUFJBfQyo1f/oeOpSxpCTbjuHuZGSQf6bsCmPePFdLxuFw3Ay7fRoikQipxRm/pcjIyICoovLYVii7amGMWV3JXLhwAS+88ALmzJmDEydOYNeuXbh58yamTZtm9fizZ8+GWq02vYqz2G1GoaAn8EuXqHXp118Dp09T7aXISPuO5Y6kp1MRvbKh0h98AMyZU7VjZmdT+1drJcA5HI7HYnftKWYlgVyj0UBqR1hlSEgIRCIR7pbpH5CamopwK+aNBQsWoHv37njllVcAAK1atYJKpUKPHj3w3nvvIdLCTVwmk0Emk9ksl0XkcqB+fXrVJlJTgQcfpGKDpfnoI+Dll+0/3p071ML0yy9JcQwZQmVGGjVyiLgcDsf12Kw0PvvsMwC0Mvjuu+/g4+NjmjMYDNi3bx+aNm1q84mlUinat2+PPXv2YOTIkabxPXv2YPjw4Rb3KSgogFhsLnLx6saaMuNYITmZFMbFi+bjixcDL75o//ESEijze/nykrFDhygJ8q+/ADu+GxwOx42x1Y4VGxvLYmNjmUAgYNHR0ab3sbGxrHHjxqx///7syJEjdtnGfvrpJyaRSNjy5cvZhQsX2MyZM5lKpWK3bt1ijDH2+uuvs/Hjx5u2X7lyJROLxWzp0qXs+vXr7MCBA6xDhw6sU6dONp/T7uip2khCAmONG5f3YXz5ZdWPeeRIxU2YsrIcJj6Hw3EddjvCe/fuzTIzMx0mwJdffsliYmKYVCpl7dq1Y//8849pbuLEiaxXr15m23/22WesefPmTKFQsMjISDZu3DiWYEfYq9crjdu3GbvvvvI39m++qd5xZ82yrjQkEsauXnWM/BwOx6VUq8qtJ1KlKrdGI5CURCadwkKgTh0KKy1lovMIbt2iRLtbt0rGBAIyKT35ZPWO/cILZIqyhEhEgQQNG1bvHBwOx+W4NCPcI9DrgX//BTp0oCY5vXpRC9h336V+CJ7C9eske2mFIRRSpdrqKgyAHN7WGDYMCAys/jk4HI7L4UqjMu7coZDUlJSSMYOBWpn+/LPr5LKHq1dJYZQuzyISUfOkJ55wzDliY6nAYVn8/Sk5MDjYMefhcDguhSuNytizx3qfiPnz3b9PxKVLpDASE0vGxGLqe/7YY447T3HL0u+/Bzp2pP7pM2cCR4/yyCkOpxZhl9LQ6/WYN2+e/QlynkxFfSLi4927T8T586QwSis2iQTYuJEaKzmaggJg2zagb1/qJZ6eTmG3ubmOPxeHw3EJdjvCfXx8cO7cOcTGxjpJJOdityN87Vq6AVqiUSNg3z73rD/133+Uh5GeXjImlQKbNwMPPeT488XH0wrDQrUA/PwzMHSo48/J4XBqHLvNU3379sXff//tBFHclJ49rTtxP/jAPRXGyZMUJVVaYchkwPbtzlEYAHD4sGWFAQCvvmp9jsPheBR2lxEZNGgQZs+ejXPnzqF9+/ZQqVRm88OGDXOYcG5BcZ+I0aPJPwBQqO2775KD3N3491+gf38q41GMQkFP+337Ou+8Bw5Yn7t0CSgqct65ORxOjWG3eUpYts1n6YMJBDBYKiHuRlQpTwOg6Km0NECjAUJCqFihu7UwPXKEiiuWLv+uUgG//OL8trRffQU895zluchI4PhxICrKuTJwOBynY/dKw2g0OkMO98fd+0QcOAAMHmzudPbxAX77Dbj/fueff8AAMoGV6l1i4o03akdFYA6HU72Q2yJucnAP/vkHGDjQXGH4+QG7d9eMwgBIQW3YAAQElIwJBMD48dQ+1gGNuzgcjuuxW2kYDAa8++67qFOnDnx8fHDjxg0AwNtvv43lpSuccmqGvXvpppyfXzIWEED5JV271pwcV6+Sn+frr4EffwS++Qb49VcgKIj6i/OwWw6nVmC3eer999/H6tWrsXDhQkydOtU03rJlS3z66aeYMmWKQwXkVMDvvwMjRpg7mYOCSGG0a1ezsmzeTH6Lxx4jx7tcTs54xqhcSVYWcK9lMIfD8VzsXmmsWbMGy5Ytw7hx48w69bVq1QqXiqOLOM7n11+pplNphRESAvz5Z80rDABQKkv+XVhYojAASijk5ikOp1Zg90ojMTERDS1UKzUajdC5c3Z0ddHpKILKaKQnZlcW4Nu+nQoElr7eYWFkqmrRwjUyjR4NbNpEORnBweQQVyjIz6FQAKGhrpGLw+E4FLuVRlxcHPbv34+YmBiz8Y0bN6Jt27YOE8ytSEigukpff022+V69gE8+AZo3JzNMTbJ5M5mASvffjoigFUazZjUrS2mio6nN66RJdL0AWmFMn05l02v6OnE4HKdgt9J45513MH78eCQmJsJoNGLLli24fPky1qxZg19++cUZMrqWpCQyA506VTL2zz9A586UF9G+fc3Jsn49MG4cVdktpk4dUhiNG9ecHJZQq8m/kpdXMqbTUfvYNm1qX391DsdLsdunMXToUKxfvx47d+6EQCDAnDlzcPHiRezYsQP9+vVzhoyu5cIFc4VRjF4PvPwyOXhrgu+/B8aONVcY0dGkwFytMAAyjZVWGKV55x33rwbM4XBswu6VBgAMGDAAAwYMcLQs7klFPTP+/pvMVc72b6xaBUyeXOJYBqh/xZ9/us8TvCXFWszt2+5dDZjD4dhMlZQGABw/fhwXL16EQCBAs2bN0L4mzTQ1SUUOXF9fCid1Jt99Bzz9tLnCaNAA+OsvqovlLnTqRD4NSzRoQP4NDofj8ditNBISEvD444/j4MGDCLiX/ZudnY1u3bph3bp1iI6OdrSMruWRR4A5cyzPTZvm3NIiluo5NWpECqNOHeedtyr07Eld+tTq8nPvvcfLiHA4tQS7H5MnT54MnU6HixcvIjMzE5mZmbh48SIYY7Uzsa9uXctP0G3bUlSQs56gP/usvMJo2pR8GO6mMICSasD33VcyplAAH35IVXc5HE6twO4qtwqFAocOHSoXXnvy5El0794dhYWFDhXQ0VSpym1uLoWRbtpElW6HDQPi4pz39LxoETnZSxMXR85mdy6aCJDDu7gacGgohQPzcFsOp9Zgt3mqXr16FpP49Ho96rjjE7Aj8PWlHIi333b+uT78EJg923ysVSvgjz88I0EuMpKbojicWozd5qmFCxdixowZOH78OIoXKcePH8eLL76Ijz/+2OECehXz55dXGG3bUpSUJygMDodT67HbPBUYGIiCggLo9XqIxbRQKf532S5+mZmZjpPUQVTJPGU0UpJfYiJVk42JobIdjirAxxjlMrz7rvl4x45UlNCVJUs4HI7bYzQYYSwygjEGoVgIkVxU+U5VxG7z1OLFi50ghhuj1wPHjlG2c1oajQmFwIsv0qqguisAxqhJ0Ycfmo936QLs2kURSRwOh2MFfb4e2ReykXslF0zPIAuVIbhTMKQBUgjFjk8JsHul4enYvdK4cYOKAFpy8C9bBjz1VNUruDIGvPIKOb5Lc//9VMXWnna0HA7H69AX6HF3711oM7XmEwIganAU5CGOD0JxcmZaLWDPHssKAyAfxN27VTsuY8DMmeUVRu/e1KKVKwwOh1MJ2mxteYUBAAzIOJYBQ5Gh/Fw14UqjMs6etT6XkFC18hhGI1V//ewz8/EHH6QVho+P/cfkcDheR0FCgdU5TZoGRr3R4efkSqMyunSxPte4MSCT2Xc8oxF45hnK9i7NgAHAjh3mzYw4HA6nAkQK6w5vgVgAgROan3GlURk9elALVUssWGBfsp3BAEyZQvWkSjNkCLBtG2VQczgcjo2o6qmszvk18XNKFFW1lUZOTg62bduGixcvOkIe9yMmBti3z7wjnq8v8MUX5H+wFb0emDiRKtaWZvhwYMsWnjXN4XDsRqwQI6RrSLlxabAU/s38IRA5fqVhd/TU6NGj0bNnTzz//PMoLCxE69atcevWLTDG8NNPP2HUqFEOF9KRVClPAwBSU0vKYwQHA1FRtted0umA8eOpiVJpRo0C1q3jFWA5HE6VMWqN0BfqURBfAEORAcq6Skj8JRArq1zEvELsPuq+ffvw5ptvAgC2bt0Kxhiys7OxevVqvPfee26vNKpMWBi97EWrpeZJmzebjz/2GLB2LSB2zn8sh8PxDoRSIaRSKaQtpTVzPnt3UKvVCLpn49+1axdGjRoFpVKJIUOG4OrVqw4X0KPRaIBHHy2vMJ54gisMDofjkditNKKjo3H48GHk5+dj165d6H+v7HVWVhbk3C5fQlER8PDD5Tv/TZpEfg2uMDgcjoPQF+ihydKgKL0IujwdjAbHh9oWY/eda+bMmRg3bhx8fHwQExOD3vecwfv27UPLli0dLZ97kJ0N3LpFN/uUFGD0aKoLVbeu5e0LC6nsyO7d5uNTpwJff+38bn8cDscrYIxBm6VF6j+p0OVQzphAJEBA6wD4NXJO9FSVyoicOHEC8fHx6NevH3zuJaL9+uuvCAgIQPfu3R0upCOx2xGenU03+rLVZ5s0IaVQtuVqfj712/jzT/Px554DPv+cKwwOh+MwdHk6JO5IhFFbfmUR2iMUvg0cVFS1FHbfwf777z+0b98eI0eONCkMABgyZAjSigv61SYSE8srDAC4fJlKgGg0JWN5ecDgweUVxosvUoiuNygMo5EaMSUk0PXgcDhOoyilCEatERJ/CQJaBSCoXRBUMSpAAGSdyoK+QO/wc9p9FxswYABu3LhRbnzz5s0YN26cQ4RyKzZutD733XcllW9zcoCBAymnozQvvwx8+mnVixp6EklJwJIlQLduQMuWlMh48SLlqHA4HIejydAgpGsI/Jr6wag3Ql+kh8RPgoi+ERBKhGBGx9ejtVtpPPvss3jwwQeRnJxsGlu/fj0mTJiAVWUT12oDWVnW5woL6ck6O5vKgBw8aD4/ezawcKF3KIyUFGDcOGDWLPL/ZGcDGzYA7doBly65WjoOp1aiiqGMcLFCDGOREfocPYQyIYw6I4I6BUEgdIMyInPmzMGwYcPQt29fZGZm4scff8STTz6JNWvW4NFHH3W4gC5n5Ejz96Wjnvr3p8S8fv2AI0fMt3vnHeD9971DYQBkrvv77/LjRUVU/l2trnGROJzajlAihDZbi5S/U5B3Iw8FCQXIPJ6JzOOZEAgETlEaVYr7XLJkCcaPH48uXbogMTER69atw/Dhwx0tm3vQtCnd9B55hDK7Cwspye/wYaBzZ+Dxx4Hjx833efdd4K23XCOvq9i61frc77+T0uANpTgch2LUGpFzMafcuD5Pj9wruQhsGwgRHBtBZdNK4+effy73GjFiBIqKivD4449DIBCYxu1l6dKlqF+/PuRyOdq3b4/9+/dXuL1Go8Gbb76JmJgYyGQy3HfffVixYoXd57WZ4GCqD/Xww9QcqV8/oH174Pp1KkD4zz/m23/4ofcpDKDi/h9yufesuDicGqQg0Xpp9Pxb+WAGx/s0bAq5FdoY9SMQCGAw2N70Y/369Rg/fjyWLl2K7t2745tvvsF3332HCxcuoF7ZUNZ7DB8+HCkpKXjvvffQsGFDpKamQq/Xo1u3bjad0+6Q20uXgA4dKJS2LF99BezfD/z4I71ftIhs+t7I2bNAq1aW5557jq4NT/7kcBxK+rF0iyuNYqIfjobE17G17Vza7rVz585o164dvirVW6JZs2YYMWIEFixYUG77Xbt24bHHHsONGzdMpUzsxS6lER8PbN8OvPCC5fmYGOD776l8+mefATNmVEmmWkF2NkVOzZ1rPn7ffcDevXStOByOQym8W4jk35MtzimiFAjrFQaR1AXmKWeg1Wpx4sQJUxmSYvr3749Dhw5Z3Ofnn39Ghw4dsHDhQtSpUweNGzfGyy+/jEJr7VhB5qycnByzl00wBuzcCZw7Z32b27epy15MDPD887Ydt7YSEEDK9cQJ4OmnKYBg3Trgr7+4wuBwnIRQIoQ8ovwKXiASwD/OH3B8t1f7HeEvvPACGjZsiBfKPH1/8cUXuHbtGhYvXmzTcdLT02EwGBBepolReHg47lrpu33jxg0cOHAAcrkcW7duRXp6Op577jlkZmZa9WssWLAA8+bNs0kmM44epdarQ4ZY3+a++yg/4/Zt4Ngxcox7M4GB9Pr6a/L38PpaHI5Tyb2eC/84fyijlci5lAOj1ghFpAL+zf2R8W8GwnqGucYRXprNmzdbLBXSrVs3bNq0yW4ByrYjZIxZbVFoNBohEAjwww8/oFOnThg8eDA++eQTrFq1yupqY/bs2VCr1abXnTt3bBNs+3bgl18oUc3fnxy9s2dTt77iz//WW2SSAajzHocQCLjC4HBqAFmYDEaNEfm38+HXxA9BbYMglAihPq+mJkxOCECx+5edkZEBfwuhk35+fkhPT7f5OCEhIRCJROVWFampqeVWH8VERkaiTp06Zudv1qwZGGNISEhAo0aNyu0jk8kgs7ePN1CS1PfOO7TqyM4GfviBVhXTpwPLllE2+JYt5ttzOBxODSELkCHh5wSAAZpUjdmcJEACRbTjW0jbvdJo2LAhdu3aVW78t99+Q4MGDWw+jlQqRfv27bFnzx6z8T179liNhOrevTuSkpKQV6qm0ZUrVyAUClHXWsXZqhIYSH+HD6eOe126UMHBH3+kpkqjRgGhoSURQcXbczgch8EYg75QD32BHka988p9eyoFCQWAlVCmnEs5MBY6/prZvdKYNWsWnn/+eaSlpeGBBx4AAOzduxeLFi2y2Z9R+ljjx49Hhw4d0LVrVyxbtgzx8fGYNm0aADItJSYmYs2aNQCAsWPH4t1338WTTz6JefPmIT09Ha+88gomT54MhcLBGnX4cIqIiosDnnyy/PylS1SEcO5c4PXXqRQ6h8NxGPoCPfLj85FzMQcGrQHKKCUCWgVA4itxSqazJ6LPt17XzagxwhnBsXYrjcmTJ0Oj0eD999/Hu+++CwCIjY3FV199hQkTJth1rDFjxiAjIwPz589HcnIyWrRogZ07dyLmXrRNcnIy4uPjTdv7+Phgz549mDFjBjp06IDg4GCMHj0a7733nr0fo3I6dyaFULbrXmnWrKHkvo4dgU6dHC8Dh+Ol6Av1SD2QiqLkItNY3o085N/OR50hdSANrJnWpu6OPEyOnEuWI0KlgVLACbq1WnkaaWlpUCgUZiXS3R278jTu3gXmz6ckPksIBMDJk1R/Ki7O8cJ6Kmo1lVwJCOAOcU6VKEotQtJvSRbnFHUUFBXk4PwDT6QwpRAp+1JgLChvhgrpHgJFhAISH8cm91UrTyM0NNSjFIbdRERQQyVrPPAARVVxhUGkpFB726FDgQcfBObNA27coJwXDscO8m9bqMBwj8LEQotNh7yR/Fv5EIot38YzT2RCm611+Dltegxs164d9u7di8DAQLRt27bCMK6TJ086TDi3oEkTMj0dO2Y+LpVS+K0dzv9aTVoa8NJLFGFWzH//AUuXUgVgC5FtHI41BOKSe4wqRgWhVIjCpELo8/UQCAVOCSX1NLRZWuReywXTW34oMxYZkbovFXUGOdacZ5PSGD58uClsdYS3OXzr1wd++glYsQL49lsKvX3gAapk26yZq6VzH27dMlcYxWRmAnPmUMMqlarGxeJ4Jj6xPhCIBVDWUaIwqRAGjQEh3UIgEAuQdzsPQpkXdMGsAMYY0g6mWVUYpu10tF3UkCiHKVqX1p5yBXYXLCxGqwXu3CFTi58flUfnlPDqq8BHH1meE4vJTBUdXbMycTwWfYEeBQkFSD+SbhZSKguRIaxnmMOL8HkaRWlFSNpp2edjiajBUZCHOqZgqHera3uQSqlsSMOGXGFYgpsLOA7EoDEg/XB6uRwETboGOZdzYNR5r0+DGZnViClrFMRbL6FuLzaZpwIDA21e2mRmZlZLII6H8uij1NrWEqNHA1WsSszxTgru0E1O4ieBqp4KArEAmgwNChIKkHMlB36N/SCUeMczLzMyaDI0KLpbhMKUQhSlFFVqliqLQeu4yoU2KQ17k/Y4XkhsLCVBrlxpPh4SQlFU3J/BsQNDoQEhXULAGEPe9TwYdUbII+SI6BuBjH8zXC2eU2FGBk26BkUpRSi8W4iiVPuVRFkcGZ7MfRocx5GaSqXRFy2igIERI4Bx4yiYgMOxg6K0ImSfzTatOIoRSoUI7xMOsUpca/wazEAricK7hSi6W4SitOoribI40qdhd+bVzp07IRKJMGDAALPx3bt3w2AwYNCgQQ4RjOOBhIUBgwZRW1ytlpL7RDwByxKMMRgKDQCjG6G3mFpshRlZOYUBUE9s9UU1gjsFu0Aqx1BdJSFSiCALk0Gbrq2wjEgxsmAZZCFVKNpqBbuVxuuvv44PP/yw3LjRaMTrr79ea5UG0+pgyKNEGYEIEPlzc4tVfH1dLYFboy/QI+9mHnIu3ut/EKVAYJtAqqkk4gEFQMWO24I7BQju4DlKgxkYitKLSEGkFJG5yY7e3SKFCPIIORQRCsjD5ZD4SSAQCKDN0iJxZ2KFCkcgESC0e6hD81rsVhpXr15F8+bNy403bdoU165dc4hQ7oY+uwDqC2rk3CoC0zHIQ6UIbscg8RdDqOB9rzm2oy/UI3V/KorultRUyr+dj4KEAkQNiYIs0HFPhB5NRQsvQSXzLoYZGIrSikw+CU2axj4loRSZFIQiQgGxr9jiTV8aKIV/nD9yr+bCUFDe0S32FSOkS4jD63TZrTT8/f1x48YNxMbGmo1fu3YNqlro7NRn5ePuvgxos0uWgUVpWiTuTkWd/mGQOb5cPacWo8vRmSmMYpiBIfN4JtVUknGTnk+sD9Tn1JbnYnzc6hoZDUZo0kqim6qsJCLkUIRbVxKWkPhIIAuVQR4qR0F8AQxaAyS+Ekj8JMiPz4c0wPGFHe1WGsOGDcPMmTOxdetW3HfffQBIYbz00ksYVlGdJg9Fm601UxgmGJBxSo3wbgJuquLYTEVml8KkQjAdA/hiA2KVGL6NfJF7NddsXCQXIbBNoNV6SzWBUU9KojCFfBKaNA2Y0Q4loRJBEa4wmZzEPrYribLII+RIP5aOgtsFkAZJIZQKUZRShII7BQjtHgqx0vEFQ+0+4kcffYSBAweiadOmpsZHCQkJ6NGjBz7++GOHC+hqCpLKPxUWU5SqAXNC43ZO7UUgsX5zEIgETill7YkwI4MsRAZ5mBx5t/LI9xOhgDxMXuOJfSYlcZdyJIrSigA7RBCrxKZVhDxCXi0lYenYUQOikPJXCrSZ94oTCoGA1gFQ1lU65BzlzmnvDv7+/jh06BD27NmDM2fOQKFQoFWrVujZs6cz5HM5ogquUEU3AA7HEj4xPsg+k21xzrehr9fXVCpGm61F+uF0iBQiKKOVEPoLUZRKYbiyUBkiHoiASO4cE5VRb0RR6j2n9d0iFKXbqSR8xCZ/hDxC7vDS5KURCASQBcsQNTgKhiIDmIFBJBdBpBA5bTVWpbWLQCBA//790b9/f0fL43aoGvgi61KhxTm/GBlEPrwZDMd2REoRAtoEIPt0ttm42FcM/xb+LjW7uBMFdwoAAUyrDYFIAIFIAJ1aR+YgB+YxGHVGclwX+yTSNfYridLRTU5UElZlUIqdYoqyeK4aOYsHI5YLEdzaBxln8szGpf4i+McFQCCtHQlGnJpBJBPBv6k/VHVVyLmSA0ORAT6xPpCHySFW8Z9jMSKlCOF9wlGYVIj0o+kUtRguR0i3EORczYHRWHUTlVFXspIovHtPSdihg8S+4pLopnDySbgaQ5GBVhpGBqFE6NTER54RbgPG3ALoi4zIu5ELgw5Q1ZFDGiCBOLAWN6DiOBV9oR5Mz8CMDAKxACK5CEIRX2UUo8nWIG1/WomdvhgBENEvAhI/CSQq226MJiVReiVRFSVRHN3kZspdm6NF5vFMFCQUAIzkDe4QDFmoDGKFGzjCvRGhrxJSXyAolCsJTvVgjEGbrUXqP6nQqXUAqOFQYJtA+N7n6zQ7vaehz9WXVxgAwICs01kIu996pWmjzkiriOLopgz7lITET1Likwh37xWgLleHu3vuQp9XEuGpz9Uj5a8URPSNgLgOVxocjkejz9cjeVeyWbtSpqccDbFSDJ/6/MEEAPJu5Vmd06RqoMvRmUwwRi2tJIqjm6qkJEpHN9WQb8ARaDI0ZgqjNJknMyHxlzjcx+I5V4fDqQUUpRRZ7W+deSqTnmw96KblDLRZWhTcrrj/Q8pfKVDFqqDL1kGTaaeS8C+zkvDg611413KQDgBoM7V25Y/Yis1XSygUVhpbLBAIoNdXXkCLw/FWNOkaq3P6XL1TfuSehKmNaSUZ1cxAJdNtQeIvMfkk5OFyp9j5XUVFpjOhTAiBExJ/bL56W7dutTp36NAhfP755/AynzqHYzcV1QESqUQQCL0790eTriHzUjWQBEhMpqbapiTKoopWIetUlsWVll9TP4hUjveR2Xw1hw8fXm7s0qVLmD17Nnbs2IFx48bh3XffdahwHE5tQxGpgEAssJhnENg60KNNJdXFqDUi678su/eTBEjMopu8KphABIR0CUH60XSz3BJFpALKOkqHVrctpkrf0KSkJLzzzjtYvXo1BgwYgNOnT6NFixaOlo3DqXWIVWJE9otEyt8p1E8DAASAfzN/KKOcU/bBnTFqjci/k4/8W/koSCqwK6kOAHzu86kwkqq2UxBfgMKkQoT3Doc+Vw+j1ghpkBQ6tQ53/7qLukPqOjz6y66jqdVqfPDBB/j888/Rpk0b7N27Fz169HCoQBxObcZQaEDmmUwEtQuCUCoE0zMIpULk386HLlfn1uGdjqK6iqI0tdn0ZAv6PD0KkwpRmFQIsUoMgUQA/Tm9ySfkUkf4woUL8X//93+IiIjAunXrLJqrajO6XB2MGiNlXMqEEClEDu27y/EONJkaFCUVQSQXwfc+qjWlzdYiPz4fmiwNIvtG1krziiMVRWmU9bxvdVaa0h35ynbxc3QfjWJszggXCoVQKBTo27cvRBW08NyyZYvDhHMG9maEGwwG6LOpcY5ZMlarQKjqq1xSZ4bjuaT/mw7fBr4oTClE7uVcGHVGyCPkCGgRgOwL2QhuE+wWZSkcgUlR3M5HQWLlikIkF0ERrYAmhfIwKkMWLEPUkCin2O09hcKUQqTtT4PETwJVrAoCkQDaTC1yr+UiuFMw5JFySJQuytOYMGGCV/7nGPIMSN5tIRnrZCZEKhFXGhy78L3PFxn/Zph37ruZj4I7BYgaEOXxpdGNWiPyE2hFUZhYWKl5RCgXQlVPRfW3wuUQCO+1Mf0tkXqLWNtPKnR4G1NPRCgVIqJvBHKv5yLrVBYMWgMUEQpEPBgBfaHeKdYQXnuqsu2v5CD9cLrFOYmfBOEPhkPqxyvdcmyjMLkQybuTLc4p6iiocY6H2ekdoSjKos3SImV/CnRZ5Vcc0iApwu4Pc5r5xZPQ5euQ+ndq+fwfIRA1KAryEMe3o/asb6cLqChmXJejsysTlcPJj8+3Omfq3OcBLYSNOiMK7hQg71aewxSF2fYyISAEJIESau3KSDlpc7QI6er4vteeij5Xbzlh1AhknshEeO9wh7fG5UqjEirqsStWOa4DF8c7EIgr6Nzn5t8luxWFTAhVjO2KojQ6tQ66DFpl6GC+2nDWzdATKbhjvdxK0d0ip7QP5kqjEhRR1pOx/OP8IfHjPg2O7ahiVFCfU1ueq6+CQOZeiqMmFUVp8u9YX5E562boiQil1svpC8TOaR/MlUYliJQiRDwYgdR/UmEoKknG8mvqB2W0d4f7cezHUGiAXxM/5FzOMRsXq+5VuNXD5TdDk6K4fU9RVFIHqlhRqGJUUEQoHFIKpaJVhLNuhp6IKkaFrNOWs+h9G/pCKHd8jxauNCpBJBFBGipF5KBIGIuMMOqMZJaSChweysap/WgyNPBp6ANFlAJ5t/Jg1BpNJTAKEwoh9XeNrd6oM6IgodSKwhZFUU8FVazjFEVpKrwZNnbOzdATESlFCOoQhMzjmWbjEn8JtQ92QmMvrjRsQCQSQeQngk6og5AJIZLxxD5O1VDFqHB3910YDUYo6yghVoiRdyMPmScyKYRUWnOP0O6mKEojVooR3DEYuTdy4RPjA4FYAE2GBtosLQKaB/Auh/cQSUXwbeQLRaQCeTfyYCg0QBWrgixI5rTqAlxp2IAuT4eCOwXIuZwDo9YIeaQcgS0CIfYVQyjmX16O7WiztCYzZ/4tc7t99rlsKOo4N3TKnRWF2XmlQihjlIAIyLlIvztFlAJhPcIgUvAHttKIpCKIgkSQBdWMXZMrjUrQ5emQdjDNPBnrRj4K4gsQNSiqxv6jPAWj3kg3RQYIJcJaWRKjOmjSKgjhVusqvYlXhSorihgVVeV1Qbl2faEe6YfSUZhU0mQo73oe8m/no86QOhVGNXKcC1calaDP1ZspjGKKs8I9MRnLWejydcj+Lxt51/LAjAzSIClCOoVAGiSFUMJXZACV8baGSOG4fhrFiiL/dj4KEgo8QlGURp+rN1MYxTA9Q8aJDFpxcBMxAMBoMMJQYIAmQwODxgB5KHUjdNYDG7/bVULebevdwTwpGcvZ6Av0uLvnrqk+F0DtJpN+T6LM1FDHZ6Z6IsooJTKFmRZDVwNaBlTL9GLUGVGQWEBFAT1QUZSmwiTIhEIYtUauNEAr+8LkQqT8nWJW20tZV4mQriFO6c/ClUYlVOSzcKcfmavRZmnNFIYJBmT8m4GIByK4qQrk4I3oF4GUv1LM6pn5NvalgnN2JvjZrSikpcJj3UxRlEYgqiAJUihw+0TImsJQYEDKXynlKlMUJBQg91ouAloEOPz/mCuNSvCJ9YH6vPVkLB76RxQkWM9M1aRpLCZHeiMCkQAipQhhPcNg1Bph1BrtDqiokqIodma7saIojSpGhez/si3O+dznQ2VGOMhPyLdaykh9QQ3f+3xd24TJGSxduhQfffQRkpOTERcXh8WLF9vU2OngwYPo1asXWrRogdOnTztNPpFSBL9mfsi5WD4ZK7BlIF8i36OiZbBQIuTJWPfQ5eqQvDsZhnwDXRMBTGaF8AfDIa5r+TqaKYrEgkqVsCcqitKIVWIqF38uu/x4qwAetXgPfa7e6pxRY4Qz6tG6VGmsX78eM2fOxNKlS9G9e3d88803GDRoEC5cuIB69epZ3U+tVmPChAl48MEHkZKS4lQZxUox/OP8oaqnopBbnRHKukooohS8hEgplPWUyDyZaXHOr6kfD5O8R358PikMgJ4QS/2mU/9ORfgD4aa2r0Z9GWe2DYpCWU8JnxgfUhQVmHjcHZFMBL84PyjrKqG+rIZRYzSZ1Hg7ghIUUQrkXMqxOCcNkjoln8WlpdE7d+6Mdu3a4auvvjKNNWvWDCNGjMCCBQus7vfYY4+hUaNGEIlE2LZtm10rDXtLo5fGqKfOfXx1UR6jzoj8+HykHUgzG5eFyhDeO9wpDjlPQ5ulRcIvCRU2IxJIBAhsHQhNusbrFEVpjHojNBkapB1KgyxIBqFYCE2mBvJwOdV8U3HFAVC3vqRdSdDnlV9xRPaPhCLS8VE6Lvsla7VanDhxAq+//rrZeP/+/XHo0CGr+61cuRLXr1/H999/j/fee8/ZYprBlYZ1hBJysMpD5ShILIBBY4AySgmxr5iHJANgjCHtYFql3euYjpUrCVEWoVQIZbQSPrG1S1GURp+vx90/7oLpGfQ5JTdEbaYWEj8J/Jv6u1A690GsEiOyfyQyjmdQxVsGiH3ECO4UbNYK1qHndMpRbSA9PR0GgwHh4eFm4+Hh4bh7967Ffa5evYrXX38d+/fvh1hsm+gajQYaTUlCVU6O5aVchcdQa2EsMCDnCmWmKusqoaij4M2XyiAUCyH0E8Lfj/+gy6JJ11TYm6UyhJJ7K4parChKU5hUaHWVlX02G8o6Skh8+WoDACS+EoR1D4NBYwAzMgglQqeu7F3+CFg2dI4xZjGczmAwYOzYsZg3bx4aN25s8/EXLFiAefPmVVk+TY4WuZdyzOyGhUmFEKsodNJVBeY4nkVBvPXoMmt4m6IojTZba3XOUGBwioPXkxFKhRWWSXfouWrkLBYICQmBSCQqt6pITU0tt/oAgNzcXBw/fhzPP/88xGIxxGIx5s+fjzNnzkAsFuPPP/+0eJ7Zs2dDrVabXnfu3LFLTqYxWnQ06fP1yD6bDW2B9S83h8OMjEp4xFtPErWEoo4CMWNiEHZ/GJR1lV6lMABUaFoR+/LmZ67EZSsNqVSK9u3bY8+ePRg5cqRpfM+ePRg+fHi57f38/HD27FmzsaVLl+LPP//Epk2bUL9+fYvnkclkkMmqbtsrW1TObO5mPgJaBlT52LUNvV4PY4GRSsjrjRArxRBIBF7ntGRGhsK7hci/lY/8+HwYNZU4MiwgC5R5naIojTxcDqFMaPHaBbYO5KYpF+JS89SsWbMwfvx4dOjQAV27dsWyZcsQHx+PadOmAaBVQmJiItasWQOhUIgWLVqY7R8WFga5XF5u3JEYDdZ/8HyJXIJeq4cuS0fNqgrNm1X5N/Ov9T9yxhiKUopIUdzOL2nYVUWU9by7wZfYR4zIfpFI3Z9qqjQgEAsQ2CoQ8gheksaVuFRpjBkzBhkZGZg/fz6Sk5PRokUL7Ny5EzExMQCA5ORkxMfHu1JEqOr5IPdyrsU5RZQCjOcYAQCMhUZTtIsJRmWtJb4S+Derfc5xxhg0aRrk3cpD/q38EmVZTWTBMqdFvngKQqEQsmAZIvpGwFhEUYtCmRAipQgiCY9edCUuzdNwBfbmaWhytMg8koHCZPOKmwKxgJdGL4X6ohoZxzIszolUIkT1i4LE3/NXG4wxaDI0tKK4lQ99vvWMXIDqJCnqKuBT3wdilRhJu5IqzdOoM6gOpIE8wILjnrg8esrdkflJEdwlGIWJhaaMcEWEAgEtAiBU8GVGMRVGu+QbwKwVyPEAGGPQZmmRfzMfebfyLCZSmSGkaraq+iqoolVmZeGDOwRbVa4CsQDhvcO5wuC4NVxp2IDUTwqpnxTySAUABoFEAKmK/7BLIwuWIReWzXhiX7FH1p7SZmvJ9HQzH7ocCxV8SyMAFJEK+MT6QFlPCZHMsgmluCyGXl1e8YQ/GA5lhHf7MjjuD1cadiDj3cKsUhztoghXQBmjhEAogDZLi9yruQhsHegxiZC6HB3ybuYh71YedNmVKwp5uBw+9X2gqqeyqfS7xFeCyAcjkX02G3k38sAMDLIQGYLaB/EVBscj4D4NjkMoDrdVn1fTzVDPIAuVIahtEEQ+Ikh93feGqMvVIf8WmZ60mZXn3cjD5GR6ilFVqUSKUW+k7F0do4KFQirQx/uNcDwBvtKwAWN6FvRMgoL4XBi1jCrcqkQQh3ClUwwrZEj9OxXarJKbriZNg+Q9yYgcGAn4ulA4C+jz9SbTky3lPWShMvjE+pCiqEZ/AqPeiMLEQqTsM++0pohSUOtgXtiR4+bwb2glGNOzkZusQ8bJLNNY9pUiSPxEiOglhCTIx4XSuQ/abK2ZwjDBgKwTWRD3EkOidG30lL5Aj/zbtKLQpFauKKTBUlIUsSqHlePWF+iR8k/5TmuFSYXIvZqLgJaO77TG4TgSrjQqoVANZJwsXwJCl2NA0u40RPRmkEW42WO0C6ioc19RahFQScCRszAUGUyKouhuUaXbSwOlUMWq4BPr45R+KcWVSC2hvqiGb0PHd1rjcBwJ/3ZWgDZLi9RD1stUGzQMSXvTUWewzOudmBXZ4wWSmn1yNmgMyI/PR/7NfBTeLbR6ky5G4i+hFUV9ldMLUOrz9BApRfBvTlnyzEjC5V7LRWFi5bJ6E0adEfp8Wh3qi/RQ1VVBGijlJjwXw6++FYr7H7DK+h/oabuoIVFeXUStop7Ovg19nd65z6g1Iv9OPvJu5qEwqfKbr9hXDJ9YH/jU94EkQFJj/3fKekoo6yiRcSLDFJ0lkAgQ0CIAiigFBGLv/Q6VxqgzIvd6LjKOluS05F7KhTRIiogHIvhqzIXwK28Fe/ofaDI0KEwqpB+9lyoOkUKE4M7BZj9ygFpO+jfzN0twcxRGnREFdwqQdysPBYkFlTY4EqvEUNUn05M0SOqS/yuxSoyknUlmhfiYjiHrVBbCeobxCKp76Av05b5LADVhUl9QI7BdoFNamXIqhysNK9jb/+DuH3chEAsg9hFD4iuhvz4Ss/fOuHG6C0KJEPIwOSL6RqDwbiGMOiPkoXJaYTjwY5v6Zt+61zfbUPGSQqQUmZzZshCZy5W6Nl1rtept1uksyCPkvNMhgPzb1qtL51zJgX9zfwhVtff35M7wb6cVDFr7i88xPYMuW2c1KUwoE5Ii8RWb/pqUi0rs0aWw9fl6JP2WZEpWE4qFyLidAWOREcFdguHfpOoFC40GClPNu5WHgjuV980WyUUmZ7YszPWKojRFadad8bocXaVK0FuoqEow0zPu+3EhXGlYwRl9wI0aI7WftWT2EtBTcdnVSfF7kVLkVje/shQml7Tn1KSZfz71WTWUUfa152QGhsJkUhT58fmUCFcBQhn1KPeJ9YE8XO62YavSCqoKiJQit5W7plFFq5Bz0XJrZnm4vMaDKzglcKVhBWU9JbLPZdu8vSxUBqPWCH2evmpPi4wK+xnyDUBK+WmBkExfxS+TUik2fUmFLlUqFnM07qHP19v0ZGjWvOh2Pozaip0UQqkQqnoqqGJV1A7VA264iihq22rpOxLYKtDpAQOegsRfAmmwFNqMMt8rARV9tFbbi+N8uNKwgixEBlmwzLZs4WAZogZR9BRjDIYiA/S5eujz9NDl6ehvLv219QZaFmZk0OXorBbOE0gE5Vcp9/6KfcQQip1r/61qwUJmZChKLULeTVpRGIsqVhQCiQCqaBV86ntm32yxSozI/pG4+9fdks8qAPya+UEVo3Lr1WRNIlaKEdEnAupLauRczgHTMcgj5AjuEAxJgOeX2PdkeO2pCtBmaZG0K6nCJ16hVIiogVE252kwI4M+v5RCKaNcHNXIpywiucjch1JaqajE1X5K1+ZokfhLokUzUkj3EPg1LLnWpuZFN/Ooy10ln1kgFkBZV0mKoo7C46NmGGMwFBigL9CD6RnEKjFEchGEUs/+XM6AGZjJvyEQC/gKww3gK40KkAZKETUwCmkH0yyuOGTBMoR2D7UrsU8gFEDiK4HEVwIFFOXmjXoycZVenRQrFH2uHkad/f2mAXIsGooM5fwNJBQ9AZdWKKWd9SJ55f4Uo94IsUpsMQgg50IOZMEyMD0zFQY0FFSiKESkKFSxKijrKp2+UqpJilekAqEAEN9rG8wXGBYRiAQ8J8PN4CsNGyhKL0LqvlToc+/VwhACfo394NvUFzL/mu3cZ9AYzM1dZVYsxRnGjkQgKvGnmEV/3VMuhnxDpSsymxACyjpK6kkRray1IcqaTA3SDqSZ/EACiQCBrQOpxpWKm1447g1X4ZWgVWtx94+75rH1RiDnUg5kYbIaVxoimQgimQiy4PLnZYzBUEj+lHK+lDw99AVV9KcYGHRqHXRqHQpRWH4DAaoeAikg57CpeZETotbcCW2OFsm7k8sl92Uez4RIIYKkAVcaHPeGK41KKEotspqMlX06G7IgmdPrFdmKQCCAWCmGWCmGPFxebp4ZyJ9S2txlUi55ukqd0FaxV2EIAEWEAqpYlc3Ni2oLRSkVfJ/OZEMeJndYRV0OxxlwpVEJmnTr0VOVtgB1MwQiASR+EqvVW406o2Vfyr2xypLqbEEeKUdYjzCvzXou/X0SKUQQiAUUUWe8l9znBPMih+NIvPOXaweSCtqUipS16wlZKBFCGii16NhnjMGoMZaL+CpIKKjUqV0aia/EaxUGAEj9pZBHyOHfzB+GQgOMWiMkARJoM7XIuZrDQ245bo/3/nptRFlHgaxTlpOx/OO8p/6NQCCASH6vJWlIyXjmiUy7kiBru8+iMhR1FRBKhUjdl2r2nVLWVSK8dzhEKu++Phz3xzvueNVAqBAiom8EhLJSl0pA0VPKaCXEYu/Wu8p6SqduX9swGIC0Q2nlHkIKEgpQkFQIZuQrDY574913PBsQy8RgwQxRg6LInKBjkPiKAREg9XUPB7grsTdzXhZSs9Fm7kbOTeud+3IuqCGt6wufIP6z5Lgv/NtpAxKJBPAHvThmCAQChHYPReJvlrPBixFKhQjtHur1NntjgfW+t0aNEQJevpXj5nDzFKfaSAOlCO0aanVeKBMi7MEwr2+JCwDSsPJVAExzgVIwAf9Jctwb/g3lOISKzFNGnRFiGV/UAoAiVGq1LEZguyD4BHJHOMe94UqD4xCM+goSA6tZXaQ2IQAQ0jUEiqiSFYdYJUZI1xDotUYYHJALw+E4E/74x3EIqnoq5F62XBpdEaWotXWk7CXnRj4KL2fDt5Ev/Jr4gRkZjFojci7nQJ+vhzhADhV3hHPcGP7ttIECtQFiGKDN1MKgMUAeKgckQsisZFZ7I2JfKl1SlGLezlQgEiCoXRDESv5VAwBjIVUqVl9QQ31B7WpxOBy74b/kSihQ68CytUjcXyYZK1qJoI7BkNrRwrQ2I/WVIrR7KPJv5yPnSg6MWiMUkQoEtAqA2Id/zYqRhitQeN1yG1NpkBTMy6PLOO4P/zVXgogxJP6TUi62vuBOAaTBMvg284PEy7OcixHKhFDWV0JZ914CnxAQioUQSfj1KUYeLEO+jxj6vPKhtz6tgrkjnOP2cKVRCQXx+daTsS6poYpVAVxpwKA1IO9aHjL+zTAblwRIENk3kjfSuUd2oRj+90ci778MaJIp0U/sK4aqZTDu5skQ4GoBOZxK4N7JStDnV5CMVWTkDdfuYSgwlFMYAKDL1kF9QQ2jgYdQAcDevUDTNhIcU4fBt080fPvURVGTKEx9TYUhw4RITna1hBxPJD0duHQJ+O8/4M4dKlfjLPjjXyXIwxXIvWI5KkgaJOXRpPfIv51vdS7nSg78m3tPcceK+Pdf4O5d4OFHhbD0zKbzrGr7HDfg8mVgwgTg2DF6HxQEfPQRMHIkEBjo+PPxX3ElyIKlViuPBrUNgtxNGjC5GkOR9Ucbpmfwsq7CVmnXjv5+8glw5Qpw8SJw6hTg7w/ExAASHlfBsYP4eKBXrxKFAQCZmcCUKcD+/c45J19pVILUX4rIvpHI+DcDhUnU6lSkEiG4fTDAO6yZUNVTIeeS5aggeYSc52nco3dv4No1+kGPGweo1UC/fsDhw2RSiIx0tYTuBWNASgpdm8BAQOndRZLLcfQoXR9LvPYa0LkzEB7u2HNypWED0gApAjuHIMjAwIwMQrHAbVq8ugsSfwmkwVJoM7TmE0IguEMwRDIeLADQTfCll4Dt20vGrlwBvv/eeU+GnkpyMrB1K/Dpp0B2NjBwIPDmm0DDhoCXdyQwUdF35tIloKjI+nxV4Y9/NiL3k0AWKIU82H16grsTYqUYEX0iENAyAEKpEBBQa9c6g+tAEsBXZMUkJJgrjGLUauDtt4HExJqXyR1JSQEmTgSmT6eVWXo6KdZ27ehmyCEaN7Y+FxEBiJzwrMaVBsdhiFVi+DT3R+TgOqg7vC6CuoZCFiyDUMS/ZsV8+631ue3bgdOna0wUt+baNWDPnvLjhYXAq68COZYtoV5Hly6A1Moz7LPPAkYnROrwXzPHYWhydMi7lIO7u5OQ+Esiso9loChDA3UWjzEDgPPngY0bK95m7FjaztvZsoX+3rxJ0UGXLpHT9/HHgV27yFzFAdatA+rWtTy3YgWF4DoarjQ4DqEwW4f0A6nIPpMFQ4EBTM9QkFCA5J1JkBl4HCljwKRJgKaSBoc5OcCTT9L23kyLFsDVq8AHHwDt29P7Bx4ABgygGyGvtkIPF19/Ddy4YXn+9m0KtnD0Q4jLlcbSpUtRv359yOVytG/fHvsr8Oxs2bIF/fr1Q2hoKPz8/NC1a1f8/vvvNSgtxxrGfB00aeXviMzIkHUyE/nZ1pMkaysaDTlzz52jH/fx47bt9++/wBtvkA1/yxZ6st63j/a/cAG4dQtITQXy8pybxOVKIiKAtm3JnJeXB+j1ZLKaNAkYPRpIS3O1hK7FaKTcjIKCirdzxkOIgLkwgH79+vUYP348li5diu7du+Obb77Bd999hwsXLqBevXrltp85cyaioqLQp08fBAQEYOXKlfj4449x9OhRtG3b1qZz5uTkwN/fH2q1Gn5+fo7+SF5L2pE0q6XRASBqeF3IAzwzgKCoiGLfi18ZGba9r+wH7SjkcgpFddRLpSo/JpHU3NP9+fNkq8/Ls76Nnx9w6BAQF1czMlnDaKTvR2Fh1f5Wdd/KVqxlOXKEwm8dgUuVRufOndGuXTt89dVXprFmzZphxIgRWLBggU3HiIuLw5gxYzBnzhybtq+K0mCM4qE3rTcgKxsIChZi1CMCdO7Ml8nFZJzIQPZZNU5fl+GPU0qo80XwVxnQt20B2jbRIuqhupC7OIqq9M2/oht/2bmauvm7MyKRY5WQpZdCQb+nTp1sW5V17Ei/S4GAViI1edMu/uspGfyvvw7YeEutFJdFO2u1Wpw4cQKvv/662Xj//v1x6NAhm45hNBqRm5uLoKAgZ4gIgJ56Jow34uQpIYCS+LWPFwHt2zOsXi1w+dOOO3C7yBeT5qtw9qbcbPzrXwPRpqkO3zYRokNHx5yrqMj2p/3S7wsLHXN+b8RgAHJz6eVMpFJAq618O4DMeCoV3bj13mf9tIusLMcdy2VKIz09HQaDAeFl0hXDw8Nx9+5dm46xaNEi5OfnY/To0Va30Wg00JRay+XYEat3/jxwf3eGbLVl18+JEwLcfz9w4IDrl8mu5Px54MEhEmSrLS+7Tl+SoF//8tepsLBqZh93vvn7+lLtn+Bg+lv8KioCVq2y/Thz5wJRUbTKqcorP98z/R22Koxi3Pm7UF1EIlp9yeUlf4v/nZxMhQltxZE1qFyeVykoY99hjJUbs8S6deswd+5cbN++HWFhYVa3W7BgAebNm2e3XMXRLtZuhMVkZ5OjqXiZbO85il9GY8mr9Ht3nzMYaOlry3Xq2pXqK2VlecbNv+yNv7L3QUHWa0cxRg5xW80uc+ZU3/Sp1VZd6ZRWPhXNOyPj2N2QSMxv3Nb+2rKNPX8ryno/coR+T7YyYkS1L4MJl/k0tFotlEolNm7ciJEjR5rGX3zxRZw+fRr//POP1X3Xr1+PJ598Ehs3bsSQIUMqPI+llUZ0dHSlPg17/1MCAug/2Z4brreHVdYEZW/+tiiCwEDnFA48fx7o3p2yv60REOBZK1ejkZR/dRRP6dfly1QF2FbCw4EGDZx3Q5fJ3LNkCWNV8/04ApddDqlUivbt22PPnj1mSmPPnj0YPny41f3WrVuHyZMnY926dZUqDACQyWSQyWR2y2ep1ENF8GQj5+LnZ9+NPyjIeTf/qhIXB/z4IzB+PK20ytK4MYXYeorCAAChkPwKKpVjjmfvw9r27Y6LCvIkBAIyd7ZvX3EklZ8fsHKlYwN2XKpDZ82ahfHjx6NDhw7o2rUrli1bhvj4eEybNg0AMHv2bCQmJmLNmjUASGFMmDABS5YsQZcuXUy+D4VCAX9/f4fK5kjHEacEiQSoU8c+04+73fyrQ05OicLw8aGbbl4ePbErFPTyZjp3Bjp0sP0JulMn58vkrsTFUfLjyy9btloolcBPPzn+IcSlSmPMmDHIyMjA/PnzkZycjBYtWmDnzp2IiYkBACQnJyM+Pt60/TfffAO9Xo/p06dj+vTppvGJEydilT1eRhuw13EUHEwJSUIhaXWhsPy/K5qr7j6u2u6XXyzXCLLGSy85LvTPEyltdS2bh3DmDI8CKn6C7tat4vpSAQGOf4L2RIYOBb74gsqtlGXLFsqgdzjMy1Cr1QwAU6vVFW53+HBpN3XlryNHaugDuBn8OtnHBx9YvzYhIYxdvuxqCd2D555jrHFjy9fJ35+xnTtdLaH7cPkyYw8/zJhIRNenUSPGtm1j7PZt55zP5WVE3JXiZbItePMymV8n+xg2zHq56unTKbqMQ1y5Qk7uwYOBvn2prAhAgQQNG7pWNneicWPg88+Bs2epSvLOncDw4YCFohoOgSsNKxQvkwMCKt7O25fJpuvkV3EoWIA/8+rrVExYGLB5M0XllGbYMArxrkLMRq1k8GD6e+MG3QT/+IPa4gIUgeYox3ttISoKaNYMaN3a+QqVK40KiIuj8EdrT9IdO3pWeKSziIsD9u7So1VDy5lZ7dsYceAgz5wHKK/h7Flgwwbgyy+B99+nCKD77+flSkrTvDnQqlX5cZEIWLiQbpIc1+DS2lOuoKq1p44dA7Zto6iqwEBKlunUiT85l0aj1uGvTfnYvh1Q5woRFCrAo09K0LqTBAHBvN0rABw8SAoCoBufSkUlrLVa4JFHgG++oYgxDq0yPvmEVrL5+RSK+9FHVCbdwcGSHDvgSoPjUAryDBDqjRCAQc8EUAXWklhZBzFrFvW8toRYDFy8yO31pSkoAJKS6MFNpeIrDHfADXMdOZ6M0keE4sKO3DzPqS5KJVei7gb3aXAchl5PLTn//pvs9Jcv80z5sjzyiPW5kSO5aYrj/nClwXEIWi0FBbRqBfTpQz6fpk0pWzUlxdXSuQ/16lEf8LKEhFBlW640OO4O92lwHML16xRFZakOzmefAc8/z4MGiomPpzIZX35JK7FBg6h1Z+PGrpaMw6kcrjTsICvdAKOBQekrgkLJ74Cl+fJLUgyWiIykmyR3YpqTlkZKNiyMmg9xOJ4Ad4TbgDpND322Bprrahi1RmjClDA28oUqmEcGFXPpkvW55GReU8kSoaGuloDDsR/u06iErFQDcs5kQH0oBUUpRdBmaVF0ORtpexKRn+4hDYJrgB49rM81b079CTgcjufDlUYlCHU66BLzy40bNUZk/5eJrAyjC6RyP7p0oYY4lli4kEwwHA7H8+FKoxIKbpdXGMVoEvIhZh7YiNkJ1KtHZb9LN9AJCQFWr6Yy1xwOp3bAfRrVgfvCzWjSBNixA0hPJwdvYCA5v61VdeVwOJ4HVxqVoIxRofCq5abOsjoqGAT8jlia4GB6cTic2gk3T1WCUSqBpG75OsxCmRABrYMQEMwvIYfD8R74SqMSAkNFELYOhr6eDzQ3KORWFKaEXyNfqIJ4yC2Hw/EuuNKwAf8QMRAiRlaAHEYDoPQT8uQ+DofjlXClYQeBodx/weFwvBtukOdwOByOzXClweFwOByb4UqDw+FwODbDlQaHw+FwbIYrDQ6Hw+HYDFcaHA6Hw7EZrjQ4HA6HYzNcaXA4HA7HZrjS4HA4HI7NcKXB4XA4HJvhSoPD4XA4NsNrT9mARgMkJQEnTwIZGdTaNCqKOtNxOByON8GVRiUUFQG7dwOPPgpotSXjw4YBX38NREa6TjYOh8Opabh5qhISEoCHHzZXGADw88/AmjWAgbcI53A4XgRXGpXw88/WFcPHHwN379asPBwOh+NKuNKohBs3rM+lp/OVBofD8S640qiEfv2sz7VtCygUNScLh8PhuBquNCqhfXsgJsby3CefAKGhNSsPh8PhuBKuNCqhbl3gzz8pWkp472rVrw/s2AG0a+da2TgcDqemETDGmKuFqElycnLg7+8PtVoNPz8/O/YD0tIAnQ7w9+ehthwOxzvheRo24udHLw6Hw/FmuHmKw+FwODbDlQaHw+FwbMblSmPp0qWoX78+5HI52rdvj/3791e4/T///IP27dtDLpejQYMG+Prrr2tIUg6Hw+G4VGmsX78eM2fOxJtvvolTp06hR48eGDRoEOLj4y1uf/PmTQwePBg9evTAqVOn8MYbb+CFF17A5s2ba1hyDofD8U5cGj3VuXNntGvXDl999ZVprFmzZhgxYgQWLFhQbvvXXnsNP//8My5evGgamzZtGs6cOYPDhw/bdM6qRk9xOBwOx4UrDa1WixMnTqB///5m4/3798ehQ4cs7nP48OFy2w8YMADHjx+HTqdzmqwcDofDIVwWcpueng6DwYDw8HCz8fDwcNy1UgXw7t27FrfX6/VIT09HpIXkCY1GA41GY3qfk5PjAOk5HA7HO3G5I1wgEJi9Z4yVG6tse0vjxSxYsAD+/v6mV3R0dDUl5nA4HO/FZUojJCQEIpGo3KoiNTW13GqimP9v7/5jqir/OIC/L1y50YVILuDFJCAvDET5Ma6jCzYjohAj1hr9GMlF6MdtFAozHG0JMwja+oEuo4HJMt1Y5miZ4g8sGbMo4seguiuTArJLgNPgUkLB8/3DvNsF1JNJ5/a979d2/jjPec55PveZ88NznnPOo9Vq56yvVCqh0WjmPKe4uBi//vqrbRsYGLg+P4CIyAnJljTc3NwQGxuLY8eO2ZUfO3YM8fHxc55jMBhm1T969Cj0ej0WLFgw5zkqlQo33XST3UZERNdG1ttThYWF2LlzJ3bt2gWz2YyCggL09/fDZDIBuDhKyMrKstU3mUzo6+tDYWEhzGYzdu3ahbfffhubNm2S6ycQETkVWb899fDDD+Ps2bPYunUrLBYLli9fjkOHDiHwr2+RWywWu3c2goODcejQIRQUFGDHjh1YvHgxtm/fjgcffFCun0BE5FT4lVsiIpLM6b5yeylH8tFbIiJ7np6eV3x6FXDCpDE2NgYAfPSWiGgGKXdgnO721PT0NH7++WdJGXWm0dFRBAQEYGBggLe2roD9JA37SRr2kzTXo5840piDi4sLlixZ8o+uwUd3pWE/ScN+kob9JM1895Psb4QTEdF/B5MGERFJxqTxN6hUKpSUlEClUskdikNjP0nDfpKG/STNv9VPTjcRTkRE144jDSIikoxJg4iIJGPSICIiyZg0iIhIMiYNCaqrqxEZGWl7acZgMKCxsVHusBxaRUUFFAoFNm7cKHcoDqe0tBQKhcJu02q1coflkM6cOYPHHnsMGo0GN954I6Kjo9He3i53WA4lKCho1r8nhUKBvLy8eWnP6d4IvxZLlixBZWUldDodAOCdd95Beno6Ojs7ERERIXN0jqetrQ01NTWIjIyUOxSHFRERgaamJtu+q6urjNE4pnPnziEhIQGJiYlobGyEn58fTp8+jZtvvlnu0BxKW1sbpqambPtfffUVkpOTkZGRMS/tMWlIkJaWZrdfXl6O6upqtLa2MmnMYLVakZmZidraWpSVlckdjsNSKpUcXVzFyy+/jICAANTV1dnKgoKC5AvIQfn6+trtV1ZWYunSpVi9evW8tMfbU3/T1NQU6uvrMT4+DoPBIHc4DicvLw9r167F3XffLXcoDu3UqVNYvHgxgoOD8cgjj6C3t1fukBzOhx9+CL1ej4yMDPj5+SEmJga1tbVyh+XQJicnsWfPHuTk5PztD7JKxaQhUU9PDzw8PKBSqWAymdDQ0IBly5bJHZZDqa+vR0dHByoqKuQOxaHFxcVh9+7dOHLkCGprazE4OIj4+HicPXtW7tAcSm9vL6qrqxESEoIjR47AZDIhPz8fu3fvljs0h/XBBx/g/PnzyM7Onrc2+Ea4RJOTk+jv78f58+exf/9+7Ny5E83NzUwcfxkYGIBer8fRo0cRFRUFALjzzjsRHR2NqqoqeYNzcOPj41i6dCmKiopQWFgodzgOw83NDXq9Hp9++qmtLD8/H21tbfjss89kjMxx3XvvvXBzc8OBAwfmrQ2ONCRyc3ODTqeDXq9HRUUFoqKisG3bNrnDchjt7e0YGhpCbGwslEollEolmpubsX37diiVSruJOrKnVquxYsUKnDp1Su5QHIq/v/+sP8rCw8PR398vU0SOra+vD01NTXj88cfntR1OhF8jIQQmJibkDsNhJCUloaenx65s/fr1CAsLw+bNm/l00BVMTEzAbDbjjjvukDsUh5KQkIBvv/3Wruy7775DYGCgTBE5trq6Ovj5+WHt2rXz2g6ThgTPP/881qxZg4CAAIyNjaG+vh4nTpzA4cOH5Q7NYXh6emL58uV2ZWq1GhqNZla5s9u0aRPS0tJw6623YmhoCGVlZRgdHYXRaJQ7NIdSUFCA+Ph4vPTSS3jooYfwxRdfoKamBjU1NXKH5nCmp6dRV1cHo9EIpXJ+/1tn0pDgl19+wbp162CxWODl5YXIyEgcPnwYycnJcodG/0E//fQTHn30UYyMjMDX1xe33347Wltb+Rf0DCtXrkRDQwOKi4uxdetWBAcHo6qqCpmZmXKH5nCamprQ39+PnJyceW+LE+FERCQZJ8KJiEgyJg0iIpKMSYOIiCRj0iAiIsmYNIiISDImDSIikoxJg4iIJGPSIHIApaWliI6OvqZzf/zxRygUCnR1dV3XmIjmwqRBTic7O9tuWUyNRoOUlBR0d3fLHdo1CQgIgMVi4eda6F/BpEFOKSUlBRaLBRaLBcePH4dSqcR999037+3+8ccf1/2arq6u0Gq18/7NISKASYOclEqlglarhVarRXR0NDZv3oyBgQEMDw/b6vT09OCuu+6Cu7s7NBoNnnzySVitVtvxtrY2JCcnw8fHB15eXli9ejU6Ojrs2lEoFHjrrbeQnp4OtVptWwK3srISixYtgqenJ3Jzc3HhwoUrxnvu3DlkZmbC19cX7u7uCAkJsS2DOvP21MyR1KXtxIkTAC6uDVNUVIRbbrkFarUacXFxtmNEV8OkQU7ParVi79690Ol00Gg0AIDffvsNKSkpWLhwIdra2rBv3z40NTXhmWeesZ03NjYGo9GIlpYWtLa2IiQkBKmpqRgbG7O7fklJCdLT09HT04OcnBy89957KCkpQXl5Ob788kv4+/vjzTffvGKML7zwAr755hs0NjbCbDajuroaPj4+c9bdtm2bbRRlsViwYcMG+Pn5ISwsDMDFT9afPHkS9fX16O7uRkZGBlJSUrieB0kjiJyM0WgUrq6uQq1WC7VaLQAIf39/0d7ebqtTU1MjFi5cKKxWq63s4MGDwsXFRQwODs553T///FN4enqKAwcO2MoAiI0bN9rVMxgMwmQy2ZXFxcWJqKioy8aclpYm1q9fP+exH374QQAQnZ2ds47t379fqFQq0dLSIoQQ4vvvvxcKhUKcOXPGrl5SUpIoLi6+bPtEl3CkQU4pMTERXV1d6Orqwueff4577rkHa9asQV9fHwDAbDYjKioKarXadk5CQgKmp6dtCwMNDQ3BZDIhNDQUXl5e8PLygtVqnbWynF6vt9s3m80wGAx2ZTP3Z3r66adRX1+P6OhoFBUV2S2BejmdnZ3IysrCjh07sGrVKgBAR0cHhBAIDQ2Fh4eHbWtubsbp06evek0izpyRU1Kr1dDpdLb92NhYeHl5oba2FmVlZRBCQKFQzHnupfLs7GwMDw+jqqoKgYGBUKlUMBgMmJycnNXWP3UpoR08eBBNTU1ISkpCXl4eXnnllTnrDw4O4v7770dubi5yc3Nt5dPT03B1dUV7e/us1RQ9PDz+cZz0/48jDSJcTAQuLi74/fffAQDLli1DV1cXxsfHbXVOnjwJFxcXhIaGAgBaWlqQn5+P1NRUREREQKVSYWRk5KpthYeHo7W11a5s5v5cfH19kZ2djT179qCqquqyK9hduHAB6enpCAsLw2uvvWZ3LCYmBlNTUxgaGoJOp7PbtFrtVWMg4kiDnNLExAQGBwcBXHwy6Y033oDVakVaWhoAIDMzEyUlJTAajSgtLcXw8DCeffZZrFu3DosWLQIA6HQ6vPvuu9Dr9RgdHcVzzz0Hd3f3q7a9YcMGGI1G6PV6rFq1Cnv37sXXX3+N22677bLnbNmyBbGxsYiIiMDExAQ++ugjhIeHz1n3qaeewsDAAI4fP273NJi3tzdCQ0ORmZmJrKwsvPrqq4iJicHIyAg+/vhjrFixAqmpqZL7kJyU3JMqRP82o9EoANg2T09PsXLlSvH+++/b1evu7haJiYnihhtuEN7e3uKJJ54QY2NjtuMdHR1Cr9cLlUolQkJCxL59+0RgYKB4/fXXbXUAiIaGhlkxlJeXCx8fH+Hh4SGMRqMoKiq64kT4iy++KMLDw4W7u7vw9vYW6enpore3VwgxeyI8MDDQ7vdd2j755BMhhBCTk5Niy5YtIigoSCxYsEBotVrxwAMPiO7u7mvqT3IuXO6ViIgk45wGERFJxqRBRESSMWkQEZFkTBpERCQZkwYREUnGpEFERJIxaRARkWRMGkREJBmTBhERScakQUREkjFpEBGRZEwaREQk2f8AnQ/NSrQFptwAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 597.875x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = pd.concat([bs_nc_df, pm_nc_df, att_nc_df])\n",
    "plt.figure(figsize=(8, 16))\n",
    "palette = ['red', 'blue', 'plum']\n",
    "ax2 = sns.catplot(x=\"size\", y='nc', hue=\"strategy\", data=data, aspect=0.85, errorbar=None, kind='point', palette=palette)\n",
    "ax = sns.scatterplot(x=\"size\", y='nc', hue=\"strategy\", data=data, legend=False, palette=palette)\n",
    "ax.set_xlabel(\"Board size\")\n",
    "ax.set_ylabel(\"N clicks per tile (log10)\")\n",
    "sns.move_legend(ax2, \"upper center\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}