02_SybilAttack.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import json \n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "from collections import defaultdict\n",
    "from tqdm import tqdm\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from networkx.readwrite import json_graph\n",
    "import json\n",
    "\n",
    "l = 153\n",
    "G_t  = []\n",
    "\n",
    "for i in range(l):\n",
    "    with open('datasets/sourcecred/makerDao_work/wg'+str(i)+'.json', 'r') as f:\n",
    "        d = json.loads(f.read())\n",
    "        G = json_graph.node_link_graph(d)\n",
    "        # Normalize the weights to [1, inf]\n",
    "        for e in list(G.edges()):\n",
    "            G[e[0]][e[1]]['weight'] *= 4\n",
    "        G_t.append(G)\n",
    "\n",
    "id_to_user = {}\n",
    "with open('datasets/sourcecred/md_users.txt', 'r') as outfile1:\n",
    "    vals = outfile1.read()\n",
    "    for v in vals.split('\\n'):\n",
    "        vals_s = v.split(',')\n",
    "        if len(vals_s) == 2:\n",
    "            id_to_user[vals_s[0]] = vals_s[1]    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Sybil Attack on MakerDAO contribution graph\n",
    "\n",
    "Two types of attacks: (1) Passive Attack and (2) Active Attack. \n",
    "\n",
    "We illustrate that the most prominent reputation functions are vulnerable to Sybil attacks, either Passive or Active. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Personalized PageRank \n",
    "# Personalized Hitting Time \n",
    "# Personalized MaxFlow\n",
    "# MeritRank\n",
    "\n",
    "from trust.pagerank import PersonalizedPageRank, PersonalizedPageRankNx, BoundedPPR\n",
    "from trust.hitting_time import PersonalizedHittingTime\n",
    "from trust.maxflow_based import MaxFlow, BarterCast\n",
    "\n",
    "from trust.seed_choice import get_seed_rep_max\n",
    "\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def normalize(rep_vals):\n",
    "    \"\"\"Normalize reputation values to [0, 1].\"\"\"\n",
    "    max_rep = sum(rep_vals.values())\n",
    "    new_vals = {}\n",
    "    for v in rep_vals:\n",
    "        new_vals[v] = rep_vals[v] / max_rep\n",
    "    return new_vals\n",
    "\n",
    "def build_aux_graph(G, seed_node):\n",
    "    H = G.copy()\n",
    "    for e in G.edges():\n",
    "        if e[0] != seed_node:\n",
    "            H[e[0]][e[1]]['weight'] = G[e[0]][e[1]]['weight'] / G.out_degree(e[0], weight='weight')\n",
    "    return H\n",
    "\n",
    "def decay_aux_graph(G, seed_node, p=0.85):\n",
    "    lvl = 0\n",
    "    cur_s = {seed_node}\n",
    "    next_s = set()\n",
    "    for f,t,_ in nx.edge_bfs(G, seed_node, orientation='original'):\n",
    "        if f in cur_s:\n",
    "            next_s.add(t)\n",
    "            G[f][t]['weight'] *= p**lvl\n",
    "        else:\n",
    "            # Start of new level \n",
    "            lvl += 1\n",
    "            cur_s = next_s.copy()\n",
    "            next_s = {t}\n",
    "            G[f][t]['weight'] *= p**lvl\n",
    "    return G\n",
    "\n",
    "def aux_max_flow(G, seed_node, rep_vals, decay_p = 0.85):\n",
    "    T = build_aux_graph(G, -1)\n",
    "    T = decay_aux_graph(T, seed_node, decay_p)\n",
    "    for i in T.nodes():\n",
    "        if i != seed_node:\n",
    "            rep_vals[i] += nx.maximum_flow_value(T, seed_node, i, capacity='weight')\n",
    "\n",
    "def simple_maxflow(G, seed_node, rep_vals, **kwargs):\n",
    "    for i in G.nodes():\n",
    "        if i != seed_node:\n",
    "            rep_vals[i] += nx.maximum_flow_value(G, seed_node, i, capacity='weight')\n",
    "\n",
    "\n",
    "def simple_pht(G, seed_node, rep_vals, decay_p: float, use_weight: bool = False):\n",
    "    pht = PersonalizedHittingTime(G, seed_node, reset_probability=1-decay_p)\n",
    "    weight_mult = G.out_degree(seed_node, weight='weight') if use_weight else 1.0\n",
    "    for i in G.nodes():\n",
    "        if i != seed_node:\n",
    "            rep_vals[i] += weight_mult * pht.compute(seed_node, i)\n",
    "\n",
    "\n",
    "def simple_ppr(G, seed_node, rep_vals, decay_p: float, use_weight: bool = False):\n",
    "    pht = PersonalizedPageRank(G, seed_node, reset_probability=1-decay_p)\n",
    "    weight_mult = G.out_degree(seed_node, weight='weight') if use_weight else 1.0\n",
    "    for i in G.nodes():\n",
    "        if i != seed_node:\n",
    "            rep_vals[i] += weight_mult *  pht.compute(seed_node, i)\n",
    "\n",
    "def reputation_cut(G, s, rand, vals, gamma=0.95, threshold = 1.0, with_condition=False):\n",
    "    res_vals = {}\n",
    "    for g in G.nodes():\n",
    "        max_neck = max(rand.coleadings[g].values()) if rand.coleadings[g] else 0\n",
    "        full_condition = max_neck > 0 and (not with_condition \n",
    "                                           or max_neck >= threshold*rand.get_number_positive_hits(s, g))\n",
    "        if full_condition:\n",
    "            rw_prop = max_neck / rand.get_number_positive_hits(s, g)\n",
    "            res_vals[g] = max(vals[g] *gamma*rw_prop, 0)\n",
    "    new_res = {}\n",
    "    all_sum = sum(vals[k]-res_vals[k] for k in res_vals.keys())\n",
    "    if all_sum == 1:\n",
    "        print('All edges are cut!')\n",
    "    else:\n",
    "        mult = 1/ (1- all_sum)\n",
    "        for k in set(vals.keys()) - set(res_vals.keys()):\n",
    "            new_res[k] = vals[k] * mult\n",
    "    for k in res_vals:\n",
    "        new_res[k] = res_vals[k]\n",
    "    return new_res\n",
    "\n",
    "\n",
    "def rep_with_cut(G, seed_node, rep_vals, rep_alg, theta: float = 1.0, \n",
    "                 gamma: float = 0.95, threshold = 1.0, with_condition=True):\n",
    "    vals = {}\n",
    "    for i in G.nodes():\n",
    "        if i != seed_node:\n",
    "            vals[i] = rep_alg.compute(seed_node, i)\n",
    "    new_vals = reputation_cut(G, seed_node, \n",
    "                              rep_alg.random_walks, vals, \n",
    "                              gamma, threshold, with_condition) \n",
    "    for k,v in new_vals.items():\n",
    "        rep_vals[k] += v \n",
    "\n",
    "def pht_cut(G, seed_node, rep_vals, decay_p, theta: float = 1.0, gamma=0.95, threshold = 1.0, with_condition=True):\n",
    "    rep_alg = PersonalizedHittingTime(G, seed_node, 1000, reset_probability=1-decay_p)\n",
    "    rep_with_cut(G, seed_node, rep_vals, rep_alg, theta, gamma, threshold, with_condition)\n",
    "\n",
    "def ppr_cut(G, seed_node, rep_vals, decay_p, theta: float = 1.0,  gamma=0.95, threshold = 1.0, with_condition=True):\n",
    "    rep_alg = PersonalizedPageRank(G, seed_node, 1000, reset_probability=1-decay_p)\n",
    "    rep_with_cut(G, seed_node, rep_vals, rep_alg, theta, gamma, threshold, with_condition)\n",
    "\n",
    "def pmf_cut(G, seed_node, rep_vals, decay_p, theta: float = 1.0,  gamma=0.95, threshold = 1.0, with_condition=True):\n",
    "    T = build_aux_graph(G, -1)\n",
    "    T = decay_aux_graph(T, seed_node, decay_p)\n",
    "    vals = {}\n",
    "    for i in T.nodes():\n",
    "        if i != seed_node:\n",
    "            vals[i] = nx.maximum_flow_value(T, seed_node, i, capacity='weight')\n",
    "    for k,v in vals.items():\n",
    "        rep_vals[k] +=  v\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def pick_seeds(new_seeds, num_seeds):\n",
    "    cur_seeds = []\n",
    "    selected_seeds = 0\n",
    "    while selected_seeds < num_seeds:\n",
    "        for s in new_seeds:\n",
    "            if s in G and G.out_degree(s) > 0:\n",
    "                cur_seeds.append(s)\n",
    "                selected_seeds += 1\n",
    "                if selected_seeds == num_seeds:\n",
    "                    return cur_seeds\n",
    "        if selected_seeds != num_seeds:\n",
    "            print('Cannot find enough seeds!')\n",
    "            print(new_seeds)\n",
    "            return None\n",
    "    \n",
    "def agg_rep_update(G: nx.Graph, seed_node: int, rep_alg, **rep_params):\n",
    "    \"\"\"Update reputation values based on the accumulated reputation.\"\"\"\n",
    "    new_rep = {}\n",
    "    rep = rep_alg(G, seed_node, **rep_params)\n",
    "    for v_node in G.nodes():\n",
    "        if v_node != seed_node:\n",
    "            new_rep[v_node] = rep.compute(seed_node, v_node)\n",
    "    return new_rep\n",
    "\n",
    "\n",
    "attack_w = 10\n",
    "num_syb = 5\n",
    "\n",
    "attack_w = 20\n",
    "max_l = 80\n",
    "\n",
    "def add_sybil_path_region(G, attacker_node, total_syb, num_syb):\n",
    "    G.add_edge(attacker_node, attacker_node*2 + total_syb, weight=attack_w)\n",
    "    a = attacker_node*2 + total_syb\n",
    "    for i in range(num_syb):\n",
    "        G.add_edge(a + i, a + i + 1, weight=attack_w)\n",
    "    return num_syb + 1\n",
    "\n",
    "def add_sybil_cycle_region(G, attacker_node, total_syb, num_syb):\n",
    "    for i in range(num_syb):\n",
    "        a = attacker_node*2 + total_syb + i\n",
    "        G.add_edge(attacker_node, a, weight=attack_w)\n",
    "        G.add_edge(a, attacker_node, weight=attack_w)\n",
    "    return num_syb\n",
    "\n",
    "def add_sybil_parallel_region(G, attacker_node, total_syb, num_syb):\n",
    "    a = attacker_node*2 + total_syb\n",
    "    for i in range(num_syb):\n",
    "        G.add_edge(attacker_node, a + i, weight=attack_w)\n",
    "    return num_syb + 1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame()\n",
    "attack_stratgies = {'cycle': add_sybil_cycle_region, \n",
    "                    'path': add_sybil_path_region, \n",
    "                    'parallel': add_sybil_parallel_region}\n",
    "\n",
    "alg_func = {'pht': pht_cut, 'ppr': ppr_cut, 'pmf': pmf_cut}\n",
    "optimal_attacks = {'pht': 'path', 'ppr': 'cycle'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2 = pd.DataFrame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 12/12 [43:23<00:00, 216.98s/it]\n",
      "100%|██████████| 12/12 [05:23<00:00, 26.92s/it]\n",
      "100%|██████████| 12/12 [03:08<00:00, 15.72s/it]\n",
      "100%|██████████| 12/12 [01:39<00:00,  8.31s/it]\n",
      "100%|██████████| 12/12 [00:47<00:00,  3.95s/it]\n",
      "100%|██████████| 12/12 [00:30<00:00,  2.51s/it]\n",
      "100%|██████████| 12/12 [00:19<00:00,  1.62s/it]\n",
      "100%|██████████| 12/12 [00:12<00:00,  1.05s/it]\n",
      "100%|██████████| 12/12 [00:07<00:00,  1.51it/s]\n",
      "100%|██████████| 12/12 [00:04<00:00,  2.60it/s]\n",
      "100%|██████████| 12/12 [00:03<00:00,  3.59it/s]\n"
     ]
    }
   ],
   "source": [
    "# Total time\n",
    "end_w = 50\n",
    "eps = 10**(-5)\n",
    "\n",
    "# Sybil attack params\n",
    "attack_w = 20\n",
    "id_shift = 0\n",
    "num_syb = 0\n",
    "attacker_node = 141429\n",
    "rewards = defaultdict(float)\n",
    "total_syb = 0\n",
    "\n",
    "num_seed_connections = 10\n",
    "\n",
    "# 'pht', 'ppr'\n",
    "for rep_alg in ['ppr']:    \n",
    "    for decay_p in [0.99, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.05]:\n",
    "        for theta in [1.0]:\n",
    "            for gamma in tqdm([1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.05, 0]):\n",
    "                for num_syb in [50]:\n",
    "                    # 0. Select initial seeds: Boostrap Period\n",
    "                    G = G_t[0].copy()\n",
    "                    score  = {i: G.in_degree(i, weight='weight') for i in G.nodes()}\n",
    "                    for k,v in score.items():\n",
    "                        G.add_edge(0, k, weight=v)\n",
    "                    # Reputation and Data Values\n",
    "                    seed_node = 0\n",
    "                    rep_vals = defaultdict(float)\n",
    "                    gains = []\n",
    "                    for w in range(end_w):\n",
    "                        # 3. Add sybils\n",
    "                        if w >= attack_w:\n",
    "                            total_syb = add_sybil_path_region(G, attacker_node, id_shift, num_syb)\n",
    "                            add_sybil_cycle_region(G, attacker_node, id_shift, num_syb)\n",
    "                        # 4. Calculate the reputation with all decays \n",
    "                        rep_alg_func = alg_func[rep_alg]\n",
    "                        rep_alg_func(G, seed_node, rep_vals, decay_p, theta, gamma)\n",
    "                        # Calculate gain\n",
    "                        score = {k:v for k,v in rep_vals.items() if v > eps}\n",
    "                        if w >= attack_w:\n",
    "                            if score.get(attacker_node):\n",
    "                                gain = sum(score.get(attacker_node*2+i, 0) for i in range(total_syb)) / score.get(attacker_node)\n",
    "                            else:\n",
    "                                gain = 0\n",
    "                            gains.append(gain)\n",
    "                        # Add new edges to the graph\n",
    "                        for f,t,data in G_t[w].edges(data=True):\n",
    "                            if (f,t) in G.edges():\n",
    "                                G[f][t]['weight'] += data['weight']\n",
    "                            else:\n",
    "                                G.add_edge(f, t, weight=data['weight'])\n",
    "                        # Update the seed connections \n",
    "                        selected_seed_connections = sorted(score.items(), key=lambda x: x[1], reverse=True)[:num_seed_connections]\n",
    "                        for k,v in selected_seed_connections:\n",
    "                            G.add_edge(0, k, weight=v)                        \n",
    "                    i_25 = int(len(gains) * 0.25)\n",
    "                    i_50 = int(len(gains) * 0.5)\n",
    "                    i_75 = int(len(gains) * 0.75)\n",
    "                    i_100 = int(len(gains) - 1)\n",
    "                    df2 = df2.append({'num_syb': num_syb, \n",
    "                            'gain_0':  gains[0], \n",
    "                            'gain_25': gains[i_25], \n",
    "                            'gain_50': gains[i_50], \n",
    "                            'gain_75': gains[i_75],\n",
    "                            'gain_100': gains[i_100], \n",
    "                            'alpha': (1-decay_p),\n",
    "                            'theta': 1-theta,\n",
    "                            'gamma': 1-gamma,\n",
    "                            'rep_alg': rep_alg,\n",
    "                            }, ignore_index=True)\n",
    "    \n",
    "# Epoch Decay: theta\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "z = df2['gain_100'].to_numpy()\n",
    "x = df2['alpha'].to_numpy()\n",
    "y = df2['gamma'].to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "def set_style():\n",
    "    # This sets reasonable defaults for font size for\n",
    "    # a figure that will go in a paper\n",
    "    sns.set_context(\"paper\")\n",
    "    \n",
    "    # Set the font to be serif, rather than sans\n",
    "    sns.set(font='serif', rc={'figure.figsize': (16,10) }, font_scale=2.66)\n",
    "    \n",
    "    # Make the background white, and specify the\n",
    "    # specific font family\n",
    "    sns.set_style(\"ticks\", {\n",
    "        \"font.size\": 10,\n",
    "        \"font.family\": \"serif\",\n",
    "        \"font.serif\": [\"Times\", \"Palatino\", \"serif\"]\n",
    "    })\n",
    "    \n",
    "set_style()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "from matplotlib.ticker import LinearLocator\n",
    "import numpy as np\n",
    "\n",
    "fig, ax = plt.subplots(subplot_kw={\"projection\": \"3d\"})\n",
    "\n",
    "\n",
    "#x = np.linspace(-4*np.pi,4*np.pi,50)\n",
    "#y = np.linspace(-4*np.pi,4*np.pi,50)\n",
    "# = x**2 + y**2\n",
    "\n",
    "# Plot the surface.\n",
    "surf = ax.plot_trisurf(x, y, z,  cmap='rocket_r',)\n",
    "\n",
    "# Customize the z axis.\n",
    "ax.set_zlim(0, 1.5)\n",
    "ax.zaxis.set_major_locator(LinearLocator(10))\n",
    "# A StrMethodFormatter is used automatically\n",
    "ax.zaxis.set_major_formatter('{x:.1f}')\n",
    "# Add a color bar which maps values to colors.\n",
    "fig.colorbar(surf,shrink=0.65, aspect=10)\n",
    "ax.view_init(30, 30)\n",
    "\n",
    "\n",
    "# Set label for x-axis \n",
    "ax.set_xlabel( \"\\n\" +  \"$\\\\alpha$ decay\", linespacing=2) \n",
    "# Set label for y-axis \n",
    "ax.set_ylabel( \"\\n\" +  \"$\\\\beta$ decay\", linespacing=2) \n",
    "ax.yaxis.set_label_coords(.9, .1)\n",
    "ax.set_zlabel( \"\\n\" +  \"Attacker's Gain\", linespacing=2) \n",
    "plt.savefig('alpha_beta_cumm.pdf', dpi=500, bbox_inches='tight');\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 351,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished with 0.99\n",
      "Finished with 0.99\n",
      "Finished with 0.99\n",
      "Finished with 0.99\n",
      "Finished with 0\n",
      "Finished with 1.0\n",
      "Finished with ppr\n",
      "Finished with 0.99\n",
      "Finished with 0.99\n",
      "Finished with 0.99\n",
      "Finished with 0.99\n",
      "Finished with 0\n",
      "Finished with 1.0\n",
      "Finished with pht\n"
     ]
    }
   ],
   "source": [
    "# Total time\n",
    "end_w = 50\n",
    "eps = 10**(-5)\n",
    "\n",
    "# Sybil attack params\n",
    "attack_w = 20\n",
    "id_shift = 0\n",
    "num_syb = 0\n",
    "attacker_node = 141429\n",
    "rewards = defaultdict(float)\n",
    "total_syb = 0\n",
    "\n",
    "num_seed_connections = 10\n",
    "\n",
    "# 'pht', 'ppr'\n",
    "for rep_alg in ['ppr', 'pht']:    \n",
    "    for decay_p in [0.99]:\n",
    "        for theta in [1.0]:\n",
    "            for gamma in [1.0, 0.5, 0.1, 0]:\n",
    "                for num_syb in [1, 5, 10, 25]:\n",
    "                    # 0. Select initial seeds: Boostrap Period\n",
    "                    G = G_t[0].copy()\n",
    "                    score  = {i: G.in_degree(i, weight='weight') for i in G.nodes()}\n",
    "                    for k,v in score.items():\n",
    "                        G.add_edge(0, k, weight=v)\n",
    "                    # Reputation and Data Values\n",
    "                    seed_node = 0\n",
    "                    rep_vals = defaultdict(float)\n",
    "                    gains = []\n",
    "                    for w in range(end_w):\n",
    "                        # 3. Add sybils\n",
    "                        if w >= attack_w:\n",
    "                            total_syb = add_sybil_path_region(G, attacker_node, id_shift, num_syb)\n",
    "                            add_sybil_cycle_region(G, attacker_node, id_shift, num_syb)\n",
    "                        # 4. Calculate the reputation with all decays \n",
    "                        rep_alg_func = alg_func[rep_alg]\n",
    "                        rep_alg_func(G, seed_node, rep_vals, decay_p, theta, gamma)\n",
    "                        # Calculate gain\n",
    "                        score = {k:v for k,v in rep_vals.items() if v > eps}\n",
    "                        if w >= attack_w:\n",
    "                            if score.get(attacker_node):\n",
    "                                gain = sum(score.get(attacker_node*2+i, 0) for i in range(total_syb)) / score.get(attacker_node)\n",
    "                            else:\n",
    "                                gain = 0\n",
    "                            gains.append(gain)\n",
    "                        # Add new edges to the graph\n",
    "                        for f,t,data in G_t[w].edges(data=True):\n",
    "                            if (f,t) in G.edges():\n",
    "                                G[f][t]['weight'] += data['weight']\n",
    "                            else:\n",
    "                                G.add_edge(f, t, weight=data['weight'])\n",
    "                        # Update the seed connections \n",
    "                        selected_seed_connections = sorted(score.items(), key=lambda x: x[1], reverse=True)[:num_seed_connections]\n",
    "                        for k,v in selected_seed_connections:\n",
    "                            G.add_edge(0, k, weight=v)                        \n",
    "                    i_25 = int(len(gains) * 0.25)\n",
    "                    i_50 = int(len(gains) * 0.5)\n",
    "                    i_75 = int(len(gains) * 0.75)\n",
    "                    i_100 = int(len(gains) - 1)\n",
    "                    df2 = df2.append({'num_syb': num_syb, \n",
    "                            'gain_0':  gains[0], \n",
    "                            'gain_25': gains[i_25], \n",
    "                            'gain_50': gains[i_50], \n",
    "                            'gain_75': gains[i_75],\n",
    "                            'gain_100': gains[i_100], \n",
    "                            'alpha': (1-decay_p),\n",
    "                            'theta': 1-theta,\n",
    "                            'gamma': 1-gamma,\n",
    "                            'rep_alg': rep_alg,\n",
    "                            }, ignore_index=True)\n",
    "                print('Finished with {}'.format(decay_p))\n",
    "            print('Finished with {}'.format(gamma))\n",
    "        print('Finished with {}'.format(theta))\n",
    "    print('Finished with {}'.format(rep_alg))\n",
    "    \n",
    "# Epoch Decay: theta\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 353,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('clean_gamma_expr.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.520605</td>\n",
       "      <td>1.370996</td>\n",
       "      <td>1.523056</td>\n",
       "      <td>1.553984</td>\n",
       "      <td>1.549583</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.243323</td>\n",
       "      <td>0.567970</td>\n",
       "      <td>0.626091</td>\n",
       "      <td>0.641480</td>\n",
       "      <td>0.646692</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.044045</td>\n",
       "      <td>0.093794</td>\n",
       "      <td>0.102675</td>\n",
       "      <td>0.105830</td>\n",
       "      <td>0.107595</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.9</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.660086</td>\n",
       "      <td>4.049891</td>\n",
       "      <td>6.187606</td>\n",
       "      <td>7.149197</td>\n",
       "      <td>7.529863</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.317676</td>\n",
       "      <td>1.845106</td>\n",
       "      <td>2.719082</td>\n",
       "      <td>3.082396</td>\n",
       "      <td>3.233015</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.062554</td>\n",
       "      <td>0.330276</td>\n",
       "      <td>0.466813</td>\n",
       "      <td>0.522196</td>\n",
       "      <td>0.548428</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.9</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.511028</td>\n",
       "      <td>1.362691</td>\n",
       "      <td>1.519738</td>\n",
       "      <td>1.547995</td>\n",
       "      <td>1.544619</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.245467</td>\n",
       "      <td>0.572243</td>\n",
       "      <td>0.628362</td>\n",
       "      <td>0.643576</td>\n",
       "      <td>0.648121</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.044234</td>\n",
       "      <td>0.094010</td>\n",
       "      <td>0.102616</td>\n",
       "      <td>0.105780</td>\n",
       "      <td>0.107474</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.9</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.674599</td>\n",
       "      <td>4.119849</td>\n",
       "      <td>6.244864</td>\n",
       "      <td>7.147313</td>\n",
       "      <td>7.523905</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.323924</td>\n",
       "      <td>1.857226</td>\n",
       "      <td>2.728394</td>\n",
       "      <td>3.086462</td>\n",
       "      <td>3.232107</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.062604</td>\n",
       "      <td>0.329884</td>\n",
       "      <td>0.468296</td>\n",
       "      <td>0.521522</td>\n",
       "      <td>0.546850</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.9</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    num_syb    gain_0   gain_25   gain_50   gain_75  gain_100  alpha  theta  \\\n",
       "0      50.0  0.520605  1.370996  1.523056  1.553984  1.549583   0.01    0.0   \n",
       "1      50.0  0.243323  0.567970  0.626091  0.641480  0.646692   0.01    0.0   \n",
       "2      50.0  0.044045  0.093794  0.102675  0.105830  0.107595   0.01    0.0   \n",
       "3      50.0  0.000000  0.000000  0.000000  0.000000  0.000000   0.01    0.0   \n",
       "4      50.0  0.660086  4.049891  6.187606  7.149197  7.529863   0.01    0.0   \n",
       "5      50.0  0.317676  1.845106  2.719082  3.082396  3.233015   0.01    0.0   \n",
       "6      50.0  0.062554  0.330276  0.466813  0.522196  0.548428   0.01    0.0   \n",
       "7      50.0  0.000000  0.000000  0.000000  0.000000  0.000000   0.01    0.0   \n",
       "8      50.0  0.511028  1.362691  1.519738  1.547995  1.544619   0.01    0.0   \n",
       "9      50.0  0.245467  0.572243  0.628362  0.643576  0.648121   0.01    0.0   \n",
       "10     50.0  0.044234  0.094010  0.102616  0.105780  0.107474   0.01    0.0   \n",
       "11     50.0  0.000000  0.000000  0.000000  0.000000  0.000000   0.01    0.0   \n",
       "12     50.0  0.674599  4.119849  6.244864  7.147313  7.523905   0.01    0.0   \n",
       "13     50.0  0.323924  1.857226  2.728394  3.086462  3.232107   0.01    0.0   \n",
       "14     50.0  0.062604  0.329884  0.468296  0.521522  0.546850   0.01    0.0   \n",
       "15     50.0  0.000000  0.000000  0.000000  0.000000  0.000000   0.01    0.0   \n",
       "\n",
       "    gamma rep_alg  \n",
       "0     0.0     ppr  \n",
       "1     0.5     ppr  \n",
       "2     0.9     ppr  \n",
       "3     1.0     ppr  \n",
       "4     0.0     pht  \n",
       "5     0.5     pht  \n",
       "6     0.9     pht  \n",
       "7     1.0     pht  \n",
       "8     0.0     ppr  \n",
       "9     0.5     ppr  \n",
       "10    0.9     ppr  \n",
       "11    1.0     ppr  \n",
       "12    0.0     pht  \n",
       "13    0.5     pht  \n",
       "14    0.9     pht  \n",
       "15    1.0     pht  "
      ]
     },
     "execution_count": 350,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.to_csv('pure_gamma_exper')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished with gamma 1.0\n",
      "Finished with theta 1.0\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.5\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.25\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.1\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0\n",
      "Finished with alpha 0.8\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 1.0\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.5\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.25\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.1\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0\n",
      "Finished with alpha 0.2\n",
      "Finished with ppr\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 1.0\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.5\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.25\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.1\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0\n",
      "Finished with alpha 0.8\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 1.0\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.5\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.25\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0.1\n",
      "Finished with gamma 1.0\n",
      "Finished with theta 0\n",
      "Finished with alpha 0.2\n",
      "Finished with pht\n"
     ]
    }
   ],
   "source": [
    "# Total time\n",
    "end_w = 50\n",
    "eps = 10**(-5)\n",
    "\n",
    "# Sybil attack params\n",
    "attack_w = 20\n",
    "id_shift = 0\n",
    "num_syb = 0\n",
    "attacker_node = 141429\n",
    "rewards = defaultdict(float)\n",
    "total_syb = 0\n",
    "\n",
    "num_seed_connections = 10\n",
    "\n",
    "# 'pht', 'ppr'\n",
    "for rep_alg in ['ppr', 'pht']:    \n",
    "    for decay_p in [0.8, 0.2]:\n",
    "        for theta in [1.0, 0.5, 0.25, 0.1, 0]:\n",
    "            for gamma in [1.0]:\n",
    "                for num_syb in [50]:\n",
    "                    # 0. Select initial seeds: Boostrap Period\n",
    "                    G = G_t[0].copy()\n",
    "                    score  = {i: G.in_degree(i, weight='weight') for i in G.nodes()}\n",
    "                    for k,v in score.items():\n",
    "                        G.add_edge(0, k, weight=v)\n",
    "                    # Reputation and Data Values\n",
    "                    seed_node = 0\n",
    "                    rep_vals = defaultdict(float)\n",
    "                    gains = []\n",
    "                    for w in range(end_w):\n",
    "                        # 3. Add sybils\n",
    "                        if w >= attack_w:\n",
    "                            total_syb = add_sybil_path_region(G, attacker_node, id_shift, num_syb)\n",
    "                            add_sybil_cycle_region(G, attacker_node, id_shift, num_syb)\n",
    "                        rep_vals_round = defaultdict(float)\n",
    "                        # 4. Calculate the reputation with all decays \n",
    "                        rep_alg_func = alg_func[rep_alg]\n",
    "                        rep_alg_func(G, seed_node, rep_vals_round, decay_p, theta, gamma)\n",
    "                        for k,v in rep_vals_round.items():\n",
    "                            rep_vals[k] = rep_vals[k]*theta + v\n",
    "                        # Calculate score with theta decay.\n",
    "                        score = {k:v for k,v in rep_vals.items() if v > eps}\n",
    "                        if w >= attack_w:\n",
    "                            if score.get(attacker_node):\n",
    "                                gain = sum(score.get(attacker_node*2+i, 0) for i in range(total_syb)) / score.get(attacker_node)\n",
    "                            else:\n",
    "                                gain = 0\n",
    "                            gains.append(gain)\n",
    "                        # Add new edges to the graph\n",
    "                        for f,t,data in G_t[w].edges(data=True):\n",
    "                            if (f,t) in G.edges():\n",
    "                                G[f][t]['weight'] += data['weight']\n",
    "                            else:\n",
    "                                G.add_edge(f, t, weight=data['weight'])\n",
    "                        # Update the seed connections \n",
    "                        G.remove_node(0)\n",
    "                        selected_seed_connections = sorted(score.items(), key=lambda x: x[1], reverse=True)[:num_seed_connections]\n",
    "                        for k,v in selected_seed_connections:\n",
    "                            G.add_edge(0, k, weight=v)                        \n",
    "                    i_25 = int(len(gains) * 0.25)\n",
    "                    i_50 = int(len(gains) * 0.5)\n",
    "                    i_75 = int(len(gains) * 0.75)\n",
    "                    i_100 = int(len(gains) - 1)\n",
    "                    df2 = df2.append({'num_syb': num_syb, \n",
    "                            'gain_0':  gains[0], \n",
    "                            'gain_25': gains[i_25], \n",
    "                            'gain_50': gains[i_50], \n",
    "                            'gain_75': gains[i_75],\n",
    "                            'gain_100': gains[i_100], \n",
    "                            'alpha': (1-decay_p),\n",
    "                            'theta': 1-theta,\n",
    "                            'gamma': 1-gamma,\n",
    "                            'rep_alg': rep_alg,\n",
    "                            }, ignore_index=True)\n",
    "                print('Finished with gamma {}'.format(gamma))\n",
    "            print('Finished with theta {}'.format(theta))\n",
    "        print('Finished with alpha {}'.format(decay_p))\n",
    "    print('Finished with {}'.format(rep_alg))\n",
    "# Epoch Decay: theta\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('theta_graph_seeds_10.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('theta_graph_all_seeds.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('theta_weights_all_seeds.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('theta_vals_weights.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('theta_weights_10_seeds.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv(\"rep_alg.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Total time\n",
    "end_w = 50\n",
    "eps = 10**(-5)\n",
    "\n",
    "cut_eps = 0.25\n",
    "\n",
    "num_seed_connections = 10\n",
    "\n",
    "# Reputation and Data Values\n",
    "seed_node = 0\n",
    "\n",
    "for rep_alg in ['pht']: \n",
    "    for num_syb in [1, 25, 50]:\n",
    "        for theta in [1.0, 0.5, 0.1, 0]:\n",
    "            for decay_p in [0.5]: \n",
    "                for gamma in [0.5]:\n",
    "                    rep_vals = defaultdict(float)\n",
    "                    total_w_value = defaultdict(float)\n",
    "                    # Calculate ground truth values \n",
    "                    gains = []\n",
    "                    G = G_t[0].copy()\n",
    "                    score  = {i: G.in_degree(i, weight='weight') for i in G.nodes()}\n",
    "                    for w in range(end_w):\n",
    "                        # Calculate the reputation with all decays \n",
    "                        G = G_t[w].copy()\n",
    "                        # Add sybils if required \n",
    "                        # 3. Add sybils\n",
    "                        if w >= attack_w:\n",
    "                            total_syb = add_sybil_path_region(G, attacker_node, id_shift, num_syb)\n",
    "                            add_sybil_cycle_region(G, attacker_node, id_shift, num_syb)\n",
    "                        # Update the seed connections \n",
    "                        decayed_score = score if w == 0 else total_w_value\n",
    "                        selected_seed_connections = sorted(decayed_score.items(), key=lambda x: x[1], reverse=True)\n",
    "                        for k,v in selected_seed_connections:\n",
    "                            G.add_edge(0, k, weight=v) \n",
    "                        rep_alg_func = alg_func[rep_alg]\n",
    "                        rep_alg_func(G, seed_node, rep_vals, decay_p, theta, gamma)\n",
    "                        # Calculate gain\n",
    "                        score = {k:v for k,v in rep_vals.items()}\n",
    "                        # Epoch decay mechanics\n",
    "                        for k,v in total_w_value.items():\n",
    "                            total_w_value[k] *= theta\n",
    "                            if total_w_value[k] < eps:\n",
    "                                total_w_value[k] = 0\n",
    "                        for k,v in score.items():\n",
    "                            total_w_value[k] += v\n",
    "                        if w >= attack_w:\n",
    "                            if score.get(attacker_node):\n",
    "                                gain = sum(score.get(attacker_node*2+i, 0) for i in range(total_syb)) / score.get(attacker_node)\n",
    "                            else:\n",
    "                                gain = 0\n",
    "                            gains.append(gain)\n",
    "                    i_25 = int(len(gains) * 0.25)\n",
    "                    i_50 = int(len(gains) * 0.5)\n",
    "                    i_75 = int(len(gains) * 0.75)\n",
    "                    i_100 = int(len(gains) - 1)\n",
    "                    df = df.append({'num_syb': num_syb, \n",
    "                            'gain_0':  gains[0], \n",
    "                            'gain_25': gains[i_25], \n",
    "                            'gain_50': gains[i_50], \n",
    "                            'gain_75': gains[i_75],\n",
    "                            'gain_100': gains[i_100], \n",
    "                            'alpha': (1-decay_p),\n",
    "                            'theta': 1-theta,\n",
    "                            'gamma': 1-gamma,\n",
    "                            'rep_alg': rep_alg,\n",
    "                            }, ignore_index=True)\n",
    "                        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.035096</td>\n",
       "      <td>0.102959</td>\n",
       "      <td>0.178213</td>\n",
       "      <td>0.224463</td>\n",
       "      <td>0.266423</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.030202</td>\n",
       "      <td>0.183953</td>\n",
       "      <td>0.296447</td>\n",
       "      <td>0.367535</td>\n",
       "      <td>0.402437</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.026289</td>\n",
       "      <td>0.167824</td>\n",
       "      <td>0.262590</td>\n",
       "      <td>0.335639</td>\n",
       "      <td>0.373974</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.030740</td>\n",
       "      <td>0.179852</td>\n",
       "      <td>0.266750</td>\n",
       "      <td>0.352887</td>\n",
       "      <td>0.394651</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>25.0</td>\n",
       "      <td>0.076436</td>\n",
       "      <td>0.176880</td>\n",
       "      <td>0.249033</td>\n",
       "      <td>0.301192</td>\n",
       "      <td>0.336652</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>25.0</td>\n",
       "      <td>0.050546</td>\n",
       "      <td>0.193918</td>\n",
       "      <td>0.296736</td>\n",
       "      <td>0.372509</td>\n",
       "      <td>0.440775</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>25.0</td>\n",
       "      <td>0.050548</td>\n",
       "      <td>0.175940</td>\n",
       "      <td>0.313402</td>\n",
       "      <td>0.402138</td>\n",
       "      <td>0.449853</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>25.0</td>\n",
       "      <td>0.055901</td>\n",
       "      <td>0.209583</td>\n",
       "      <td>0.323292</td>\n",
       "      <td>0.429285</td>\n",
       "      <td>0.490933</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.056552</td>\n",
       "      <td>0.148644</td>\n",
       "      <td>0.240676</td>\n",
       "      <td>0.286772</td>\n",
       "      <td>0.326205</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.053950</td>\n",
       "      <td>0.173824</td>\n",
       "      <td>0.257328</td>\n",
       "      <td>0.327910</td>\n",
       "      <td>0.383803</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.056042</td>\n",
       "      <td>0.209136</td>\n",
       "      <td>0.317052</td>\n",
       "      <td>0.400925</td>\n",
       "      <td>0.470136</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.047977</td>\n",
       "      <td>0.173002</td>\n",
       "      <td>0.271490</td>\n",
       "      <td>0.341268</td>\n",
       "      <td>0.399669</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    num_syb    gain_0   gain_25   gain_50   gain_75  gain_100  alpha  theta  \\\n",
       "0       1.0  0.035096  0.102959  0.178213  0.224463  0.266423    0.5    0.0   \n",
       "1       1.0  0.030202  0.183953  0.296447  0.367535  0.402437    0.5    0.5   \n",
       "2       1.0  0.026289  0.167824  0.262590  0.335639  0.373974    0.5    0.9   \n",
       "3       1.0  0.030740  0.179852  0.266750  0.352887  0.394651    0.5    1.0   \n",
       "4      25.0  0.076436  0.176880  0.249033  0.301192  0.336652    0.5    0.0   \n",
       "5      25.0  0.050546  0.193918  0.296736  0.372509  0.440775    0.5    0.5   \n",
       "6      25.0  0.050548  0.175940  0.313402  0.402138  0.449853    0.5    0.9   \n",
       "7      25.0  0.055901  0.209583  0.323292  0.429285  0.490933    0.5    1.0   \n",
       "8      50.0  0.056552  0.148644  0.240676  0.286772  0.326205    0.5    0.0   \n",
       "9      50.0  0.053950  0.173824  0.257328  0.327910  0.383803    0.5    0.5   \n",
       "10     50.0  0.056042  0.209136  0.317052  0.400925  0.470136    0.5    0.9   \n",
       "11     50.0  0.047977  0.173002  0.271490  0.341268  0.399669    0.5    1.0   \n",
       "\n",
       "    gamma rep_alg  \n",
       "0     0.5     pht  \n",
       "1     0.5     pht  \n",
       "2     0.5     pht  \n",
       "3     0.5     pht  \n",
       "4     0.5     pht  \n",
       "5     0.5     pht  \n",
       "6     0.5     pht  \n",
       "7     0.5     pht  \n",
       "8     0.5     pht  \n",
       "9     0.5     pht  \n",
       "10    0.5     pht  \n",
       "11    0.5     pht  "
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='num_syb', ylabel='gain_100'>"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "sns.lineplot(x='num_syb', y='gain_100', data=df, hue='theta', palette=\"dark\", alpha=.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.037807</td>\n",
       "      <td>0.103122</td>\n",
       "      <td>0.130355</td>\n",
       "      <td>0.150768</td>\n",
       "      <td>0.156401</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.059510</td>\n",
       "      <td>0.131387</td>\n",
       "      <td>0.161571</td>\n",
       "      <td>0.170347</td>\n",
       "      <td>0.172166</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.028409</td>\n",
       "      <td>0.105464</td>\n",
       "      <td>0.142137</td>\n",
       "      <td>0.158469</td>\n",
       "      <td>0.164553</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.035381</td>\n",
       "      <td>0.099534</td>\n",
       "      <td>0.128641</td>\n",
       "      <td>0.144648</td>\n",
       "      <td>0.154693</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>25.0</td>\n",
       "      <td>0.104723</td>\n",
       "      <td>0.197516</td>\n",
       "      <td>0.252303</td>\n",
       "      <td>0.281961</td>\n",
       "      <td>0.289543</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>25.0</td>\n",
       "      <td>0.085379</td>\n",
       "      <td>0.222527</td>\n",
       "      <td>0.253401</td>\n",
       "      <td>0.277349</td>\n",
       "      <td>0.285871</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>25.0</td>\n",
       "      <td>0.105723</td>\n",
       "      <td>0.222032</td>\n",
       "      <td>0.256967</td>\n",
       "      <td>0.289036</td>\n",
       "      <td>0.302162</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>25.0</td>\n",
       "      <td>0.095407</td>\n",
       "      <td>0.217730</td>\n",
       "      <td>0.260207</td>\n",
       "      <td>0.273789</td>\n",
       "      <td>0.287951</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.055298</td>\n",
       "      <td>0.134737</td>\n",
       "      <td>0.212206</td>\n",
       "      <td>0.241228</td>\n",
       "      <td>0.257790</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.055363</td>\n",
       "      <td>0.162116</td>\n",
       "      <td>0.216781</td>\n",
       "      <td>0.237779</td>\n",
       "      <td>0.257295</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.065261</td>\n",
       "      <td>0.173599</td>\n",
       "      <td>0.225032</td>\n",
       "      <td>0.252534</td>\n",
       "      <td>0.272746</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.095452</td>\n",
       "      <td>0.210427</td>\n",
       "      <td>0.260253</td>\n",
       "      <td>0.282539</td>\n",
       "      <td>0.293466</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    num_syb    gain_0   gain_25   gain_50   gain_75  gain_100  alpha  theta  \\\n",
       "0       1.0  0.037807  0.103122  0.130355  0.150768  0.156401    0.5    0.0   \n",
       "1       1.0  0.059510  0.131387  0.161571  0.170347  0.172166    0.5    0.5   \n",
       "2       1.0  0.028409  0.105464  0.142137  0.158469  0.164553    0.5    0.9   \n",
       "3       1.0  0.035381  0.099534  0.128641  0.144648  0.154693    0.5    1.0   \n",
       "4      25.0  0.104723  0.197516  0.252303  0.281961  0.289543    0.5    0.0   \n",
       "5      25.0  0.085379  0.222527  0.253401  0.277349  0.285871    0.5    0.5   \n",
       "6      25.0  0.105723  0.222032  0.256967  0.289036  0.302162    0.5    0.9   \n",
       "7      25.0  0.095407  0.217730  0.260207  0.273789  0.287951    0.5    1.0   \n",
       "8      50.0  0.055298  0.134737  0.212206  0.241228  0.257790    0.5    0.0   \n",
       "9      50.0  0.055363  0.162116  0.216781  0.237779  0.257295    0.5    0.5   \n",
       "10     50.0  0.065261  0.173599  0.225032  0.252534  0.272746    0.5    0.9   \n",
       "11     50.0  0.095452  0.210427  0.260253  0.282539  0.293466    0.5    1.0   \n",
       "\n",
       "    gamma rep_alg  \n",
       "0     0.5     pht  \n",
       "1     0.5     pht  \n",
       "2     0.5     pht  \n",
       "3     0.5     pht  \n",
       "4     0.5     pht  \n",
       "5     0.5     pht  \n",
       "6     0.5     pht  \n",
       "7     0.5     pht  \n",
       "8     0.5     pht  \n",
       "9     0.5     pht  \n",
       "10    0.5     pht  \n",
       "11    0.5     pht  "
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Calculate ground truth scores. \n",
    "\n",
    "end_w = 50\n",
    "eps = 10**(-6)\n",
    "\n",
    "cut_eps = 0.25\n",
    "\n",
    "num_seed_connections = 10\n",
    "\n",
    "# Reputation and Data Values\n",
    "seed_node = 0\n",
    "\n",
    "theta = 0.0\n",
    "\n",
    "gtv_norm_copy  = {}\n",
    "\n",
    "for rep_alg in ['pht', 'ppr']:  \n",
    "    for decay_p in [0.999]: \n",
    "        for gamma in [1.0]:\n",
    "            rep_vals = defaultdict(float)\n",
    "            # Calculate ground truth values \n",
    "            G = G_t[0].copy()\n",
    "            score  = {i: G.in_degree(i, weight='weight') for i in G.nodes()}\n",
    "            for w in range(end_w):\n",
    "                # Calculate the reputation with all decays \n",
    "                G = G_t[w].copy()\n",
    "                # Update the seed connections \n",
    "                selected_seed_connections = sorted(score.items(), key=lambda x: x[1], reverse=True)[:num_seed_connections]\n",
    "                for k,v in selected_seed_connections:\n",
    "                    G.add_edge(0, k, weight=10) \n",
    "                rep_alg_func = alg_func[rep_alg]\n",
    "                rep_alg_func(G, seed_node, rep_vals, decay_p, theta, gamma)\n",
    "                # Calculate gain\n",
    "                score = {k:v for k,v in rep_vals.items() if v > eps}\n",
    "            norm_scores = normalize(score)\n",
    "            gtv_norm_copy[rep_alg] = norm_scores\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "      <th>mad</th>\n",
       "      <th>sad</th>\n",
       "      <th>mrd</th>\n",
       "      <th>srd</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000514</td>\n",
       "      <td>0.231119</td>\n",
       "      <td>0.439015</td>\n",
       "      <td>197.556935</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.2</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000665</td>\n",
       "      <td>0.299310</td>\n",
       "      <td>0.477159</td>\n",
       "      <td>214.721714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.4</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000697</td>\n",
       "      <td>0.313657</td>\n",
       "      <td>0.501027</td>\n",
       "      <td>225.461966</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.6</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000741</td>\n",
       "      <td>0.333666</td>\n",
       "      <td>0.553659</td>\n",
       "      <td>249.146627</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.8</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000785</td>\n",
       "      <td>0.353122</td>\n",
       "      <td>0.599218</td>\n",
       "      <td>269.647883</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   alpha  theta  gamma rep_alg       mad       sad       mrd         srd\n",
       "0    0.1    0.0    0.0     pht  0.000514  0.231119  0.439015  197.556935\n",
       "1    0.1    0.0    0.2     pht  0.000665  0.299310  0.477159  214.721714\n",
       "2    0.1    0.0    0.4     pht  0.000697  0.313657  0.501027  225.461966\n",
       "3    0.1    0.0    0.6     pht  0.000741  0.333666  0.553659  249.146627\n",
       "4    0.1    0.0    0.8     pht  0.000785  0.353122  0.599218  269.647883"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2 = pd.DataFrame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                     | 0/1 [00:00<?, ?it/s]/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "100%|████████████████████████████████████████████| 1/1 [06:09<00:00, 369.55s/it]\n",
      "  0%|                                                     | 0/1 [00:00<?, ?it/s]/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "100%|████████████████████████████████████████████| 1/1 [06:48<00:00, 408.21s/it]\n",
      "  0%|                                                     | 0/1 [00:00<?, ?it/s]/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "100%|████████████████████████████████████████████| 1/1 [07:12<00:00, 432.96s/it]\n",
      "  0%|                                                     | 0/1 [00:00<?, ?it/s]/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "100%|████████████████████████████████████████████| 1/1 [08:13<00:00, 493.27s/it]\n",
      "  0%|                                                     | 0/1 [00:00<?, ?it/s]/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "100%|████████████████████████████████████████████| 1/1 [07:09<00:00, 429.42s/it]\n",
      "  0%|                                                     | 0/1 [00:00<?, ?it/s]/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_6550/349123326.py:41: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  df2 = df2.append({  'alpha': (1-decay_p),\n",
      "100%|████████████████████████████████████████████| 1/1 [07:34<00:00, 454.81s/it]\n"
     ]
    }
   ],
   "source": [
    "# Total time\n",
    "end_w = 50\n",
    "eps = 10**(-6)\n",
    "\n",
    "cut_eps = 0.25\n",
    "\n",
    "num_seed_connections = 10\n",
    "\n",
    "# Reputation and Data Values\n",
    "seed_node = 0\n",
    "\n",
    "theta = 0.0\n",
    "\n",
    "for _ in range(3):\n",
    "    for rep_alg in ['pht', 'ppr']:  \n",
    "        for decay_p in tqdm([0.999]): \n",
    "            for gamma in [1.0, 0.8, 0.6, 0.4, 0.2, 0.1, 0]:\n",
    "                rep_vals = defaultdict(float)\n",
    "                # Calculate ground truth values \n",
    "                G = G_t[0].copy()\n",
    "                score  = {i: G.in_degree(i, weight='weight') for i in G.nodes()}\n",
    "                for w in range(end_w):\n",
    "                    # Calculate the reputation with all decays \n",
    "                    G = G_t[w].copy()\n",
    "                    # Update the seed connections \n",
    "                    selected_seed_connections = sorted(score.items(), key=lambda x: x[1], reverse=True)[:num_seed_connections]\n",
    "                    for k,v in selected_seed_connections:\n",
    "                        G.add_edge(0, k, weight=10) \n",
    "                    rep_alg_func = alg_func[rep_alg]\n",
    "                    rep_alg_func(G, seed_node, rep_vals, decay_p, theta, gamma)\n",
    "                    # Calculate gain\n",
    "                    score = {k:v for k,v in rep_vals.items() if v > eps}\n",
    "                norm_scores = normalize(score)\n",
    "                rel_diff = []\n",
    "                abs_diff = []\n",
    "                for k,v in gtv_norm_copy[rep_alg].items():\n",
    "                    a_d = abs(v - norm_scores.get(k, 0))\n",
    "                    abs_diff.append(a_d)\n",
    "                    rel_diff.append(a_d / v)\n",
    "                    \n",
    "                df2 = df2.append({  'alpha': (1-decay_p),\n",
    "                                    'theta': theta,\n",
    "                                    'gamma': 1-gamma,\n",
    "                                    'rep_alg': rep_alg,\n",
    "                                    'mad': np.mean(abs_diff),\n",
    "                                    'sad': np.sum(abs_diff),\n",
    "                                    'mrd': np.mean(rel_diff),\n",
    "                                    'srd': np.sum(rel_diff),\n",
    "                                    }, ignore_index=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "x = df2['alpha'].to_numpy()\n",
    "y = df2['gamma'].to_numpy()\n",
    "z = df2['mrd'].to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArUAAAI7CAYAAADyGmPpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd3wT9RvH3xlNk+49oANaEMHBkiEKgoAoICpuwb1Qcc8fTsCNCop7ojgQRREVQXCBCDIEZK9SunfTldWM3x/lYpomadImHfB9++rL0lzuvne53H3u+T7P55HZbDYbAoFAIBAIBAJBJ0be3gMQCAQCgUAgEAhaixC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AoFAIBAIBIJOjxC1AkE7YrPZsFgs2Gy29h6KQCAQCASdGmV7D0AgOF6xWq3U19ej0+mQyWQoFAqCgoJQKpUoFApkMll7D1EgEAgEgk6DzCZCRAJBmyJFZ+vr6wHs/7fZbFitVmQyGUajEYVCQVhYmBC5AoFAIBB4gYjUCgRtiM1mo6qqCrlcjkqlsv9dJpMhk8mQyxsygnQ6HTabrZGYVSqV9kiuXC4XIlcgEAgEAgeEqBUI2gir1YrJZKKkpISoqCiCg4Pd5tI6Cln4L7prNpux2WzIZDIhcgUCgUAgcECIWoEgwNhsNsxmM2az2R6Rlaiurqa8vBy1Wk1ISAhqtdoerXXE+X2OIld6XalU2n+EyBUIBALB8YYQtQJBALHZbJhMJnuurPRjtVrJz8+ntraWmJgY6uvrKSsrw2g0olarAVAoFFitVq9FrtlstufnCpErEAgEguMNUSgmEAQIqRhMSheQRGV2djYGg4HQ0FCSk5OxWCz216xWK3q9noqKCrsY1mg0aDQaeyTXG3EqFZ1JOKYrKBQKIXIFAoFAcMwhRK1A4GfcpRvYbDYqKyspLCwkMjKSrl27AmAymZoIzIqKCiwWCzExMej1enQ6HXq9nvr6enuqgkajaZXIdbQPEyJXIBAIBJ0dkX4gEPgRyXvWMd0AGqK2+fn5mEwmwsLCCAkJQSaTeSwUk9wPwsLCCAsLs69HErjFxcWYzeZGkdzg4GCX4lTywZWQ0iKMRiMAcrncLnKVSmWT9AaBQCAQCDo6QtQKBH7A2XvWURTqdDpyc3MJDw8nJSWFwsLCFm9HoVAQHh5OeHg4AGaz2R7JLSwsxGKx2AVuSEgIKpXKZ5ErjT0oKMieriBErkAgEAg6OkLUCgStxGazUV9fb8+NdUw3KCsro6ysjK5duxIREdHoPZ7wFMV1RKlUNhG5Op0OnU6HVqu15+RK6QreiFxpuyaTCZPJBDREcp1zcgUCgUAg6EgIUSsQtALJe9a5GKy+vp68vDxsNhuZmZlNGi0ECqVSSUREhF1A19fX2yO5FRUV2Gw2u8ANCQkhKCioyXikfwuRKxAIBILOhBC1AkELcEw3cOwEBlBTU0N+fj7R0dEkJCS4FI3eRGH9UcMppRBERETYI8qSyC0vL0cmkzVKVwgKCmqyDm9FrnPhmUAgEAgEbYkQtQKBj7jynoWGqG1JSQlarZaUlBR7cVdzuEsH8DcymQyVSoVKpSIyMtIucqV0hbKyMmQymV3gajQar0WuzWbDaDS6LDwTIlcgEAgEbYEQtQKBD7hLNzCZTOTm5qJUKunRo4e9va0rvI3UBhpHkRsVFWUX63q9ntraWkpKSlAoFI3SFVztl6tGEM4iV6FQ2FMVJHcFgUAgEAj8iRC1AoEXOHvPOkYetVothYWFxMfHExsb6xfB1h7CVyaTERwcTHBwcCORq9PpqKmpoaSkBKVS2ShdwdFBwXE9ziLXarViMBjsDwMGg4HIyMhG7goCgUAgELQGIWoFgmbwlG5QUFCATqejW7duaDQar9bXUSK1zeEocqOjo+3RV51OR3V1NcXFxSiVykbpCt6K3IKCAlQqVZNIrpSuIESuQCAQCHxFiFqBwA2evGcNBgO5ubloNBoyMzNdijlfttMZRJxMJkOtVqNWq4GGcRsMBvR6vT1arVKp7ALXk8gF7Lm2jpFcCSFyBQKBQOArQtQKBC7w1Oq2oqKCkpISkpKSiI6O9nnd3kRqO0M0V3JO0Gg0xMTE2EWuTqeztwMODg5u5JPrqmDMXbqCXq9vJICFyBUIBAKBJ4SoFQiccNfq1mw2U1BQgMlkIiMjg+Dg4HYeacfCUeTGxsbao6+SR67BYCA4OJiQkBC7cPUkcqXXXIlcqZ2vELkCgUAgkBCiViA4inO6gaPgqqurIy8vj4iICFJSUlplUSWTybBarU227SjMOkOktjnkcrk93xawC1O9Xg/A4cOHUavV9iiuWq32WuQ6egQDjRpBCJErEAgExydC1AoEeG51W1paSkVFBV26dGnU6tYfSNvq7ALWG+RyOaGhoYSGhlJZWUn37t3thWelpaWYTCZ7pDckJAS1Wu3Ww9eVyDWbzfZlJJGrVCqRy+VC5AoEAsFxgBC1guOe5lrdAmRmZrpsRNASjhcR2xyOIhfAYrHYu52VlJRQX1/fJJLrSeRKOItcmUzWKF1BiFyBQCA4NhGiVnDc4sl7trq6moKCAmJiYoiPj/e7CDoWCsX8jUKhICwszN6JzWKxoNPp0Ov1FBcXYzabGxWdBQcHey1yzWZzIxcLIXIFAoHg2EOIWsFxiSfv2eLiYqqrq0lNTbVHEf2JEFDeoVAoCA8PJzw8HGgo1JMiuVqtFovF0qgRhEql8lrk1tfXC5ErEAgExxhC1AqOO6TorHO6gdFoJDc3l6CgIDIzMz22um0tIlLrO0qlsonI1el0dpFrtVobRXI9iVxH/1xXItfRPkyIXIFAIOgcCFErOG7wlG5QWVlJUVERCQkJxMTEBFTECIHkH5RKJREREfbivfr6enskt6KiApvNZhe4ISEhBAUFeS1yTSYTRqPR/tAjiVylUtkk8isQCASCjoEQtYLjAqvVSmVlJXq9nri4OLsosVgsFBYWotfrfWp121pEFNb/BAUFERQUREREhD36Konc8vJyu4+ulK7grvDPk8iFhgI3aVuSfZgQuQKBQND+CFErOKZx9DQ1mUwYDAa7ANHr9eTm5hIaGkpmZmarvGd9wVEAGQwGCgoKUCqVhIaGotFo7NFAIXxbjkwmQ6VSoVKpiIyMtItcKV2hrKwMmUxmF7gajcYrkSt9JiaTCZPJBDSIXEef3LY6jwQCgUDQGCFqBccszt6zjr6m5eXllJaWkpycTFRUVJuPTYocFxUV2VvMVldXU1xcjFKpRKVSYbFYsFgsjaKGgpbhKHKjoqLs0Ve9Xk9tbS0lJSUoFIpG6Qqucqod2/aCELkCgUDQkZDZRDhIcAziynu2qqqKyspKZDIZZrOZlJSUdml1W1FRQWlpKXK5nNTUVORyuX2cNpsNg8FAdXU11dXVAKhUqkYRxWNBJB04cKBNo+PNIYlcKZKr1+tRKpWN0hW8ebiQLqfV1dXodDoSEhKEyBUIBII2QkRqBccUnorBjEYjdXV1xMbG2sVkW6PX6ykpKUEmk9lFnRThA+x5nzKZDIPBQGpqKgaDwV78ZDAYGjUkkJYVtA6ZTEZwcDDBwcFER0djs9ns3c4cI+iODxeuRK70WUj/lx5YnCO5zu4KAoFAIGg9QtQKjhncec/abDZKSkqoqKggODiYpKSkdhlbRUUFJSUlREZGYjab7WLGU/6sXC63CyloiEBLxU+lpaWNum6FhIS4bUgg8A2ZTIZarUatVgPYI+h6vR6tVkthYaE9gi49XLgTuc4euZJglgrPFAqFPYor5VMLBAKBwHeEqBUcE0jFYM7esyaTiby8PGQyGUlJSWi12nYZW35+PiaTiYyMDIxGI5WVlR7f407oemotW1RU1KjrlqeGBALfkCLoGo3GngMtRdArKyspLCwkODjYfuylBytX63EWuVarFYPBYP+bJHKlSK74/AQCgcA7hKgVdGqaa3Wbn59PXFwccXFx1NXVtfn49Ho9OTk5hIeHk5KSglwut0fo/IFza1lXDQm88WoV+IajyI2NjbULU8c0EblcTllZGSEhIajVapdpBkLkCgQCgf8QolbQabFardTX17tsdVtUVERNTQ3p6en2qfu2tMlydFjo0qULkZGR9te8GUdLx+qqIYEkciWvVm9srAS+4ZwmUllZaX+IKisrw2g0NsqFFiJXIBAI/I8QtYJOh6P3LDQWAgaDgby8PFQqFT169GiU59hWotZsNpOfn4/ZbCYzMxOVSuVyH9qCoKAgIiMjm3i1OttY+VLhL2geqQtZXFwc0DQX2mQy2SO9UiTXl3QFvV7fyF5MiFyBQCAQolbQyXBON3AsBtNqtRQVFZGYmEh0dHSTm3tbiFqdTkdubi4RERFuHRbaS3S48mo1Go3o9Xp7hX9QUJBdaLkrfhL4jqdc6JKSEq8L/qRz3tFzWYhcgUAgaECIWkGnwZX3LDQIhIKCAgwGA927d7dXrLsiUKLWZrNRVlZGWVkZXbt2tU//t3QcbSHAHSv8JRsrV8VPktByN2UuaIp0jrrDORfaYrHY/XGdC/40Gk2rRK5SqbT/CJErEAiOZYSoFXR4HNMNnIvBpMhoeHh4s2b+gbqZm81m8vLysFgsbtMN2mIcrcVT8ZNzXqinKXOB7ygUCsLDwwkPDwcazikpkqvVarFYLF65WrgSuRaLBbPZbF9GagShVCqRy+XiMxQIBMcMQtQKOjSevGfdFWK5IxDRz7q6OnJzc4mKiiIxMdErgeDtONq72Z8rj1wpmujLlPnxSHOR2uZQKpVNRK6zq4WjyHXnauEqJ9dR5MpkskbpCkLkCgSCzowQtYIOi7t0A18joxL+FLU2m43S0lIqKiro2rWrXXz4i44oLORyucspc0ePXEf7MOGR6z/cuVro9XoqKiqw2WxeWbd5I3Id0xWEyBUIBJ0JIWoFHQ5P3rO1tbXk5eURHR1NQkKCTzdcf4las9lMbm4uNpuNzMxMn22x2tJaLJC4mjKXRG5lZaVdaDlGEwX+wZWrhZSuIFm3OUdyXeFK5JrN5kbOIkLkCgSCzoIQtYIOhad0g+LiYrRaLSkpKfZooS/4Q0y2RlS7Qy6XY7VaG/2tMwpfTx65ZWVljTxyO9u++Upr0w98wdHVwtm6zdWx9+RP7Erk1tfXNxG5UltfIXIFAkFHQohaQYfBOULk2Oo2NzcXhUJBjx49UCpbftq2VEzZbDZKSkqorKxssaiWcBasx6rAc44mmkwmu0cuwJEjR4RHbgBwZd1mMpnQ6/VN/ImlaK6775SUcyvhLHJNJpO9PbAQuQKBoL0RolbQ7rjzngWoqqqioKCA+Ph4YmNjW3XDbOl76+vryc3NRSaTtSjdoKUcS2JXJpMRHBxMcHAw0dHR7N+/n8TERAwGA1VVVXaPXMdoYme2D2vLSG1zOB57R5Gr0+moqamhpKQEpVLZKF3B3QOGs8jVarWo1Wr7TINcLicoKMgeyXX+PgsEAkEgEaJW0K54anVbWFhIXV0d3bp1Q6PRtHpbLZnSr6mpIT8/n5iYGOLj4/1yg/a2Te6xjOSRGxISQkxMTCOP3IqKCgwGg/DIDRDODxhSEw6dTmdvwqFUKhs9YHiKoisUCpRKpf2cNplMGI1Gez68Y7qCELkCgSCQCFEraBecW906ChaDwUBubi5qtZrMzEy/TUv7Imodc3hTU1PtnaACRUeK7LUHrjxy9Xo9er3e7pHrTVvZjkJn+jwdm3AA9gcMvV6PVqulsLAQlUplF7iOItdxPx07mkmvQYPINZlMAE1ErnhQEQgE/kSIWkGbI+XlWSyWJsVglZWVFBcXk5SURFRUVECEQXOCw2QykZeXh1wub3UOryu8jdQeS+kHvuJNW1lvOm61Jx1tPN7i+IDhHEV37DSn0Wior693e54KkSsQCNoaIWoFbYqnVrf5+fmYTCYyMjIIDg72+7al7XkStdXV1eTn5xMXF0dcXFzAhMnxLFhbgnNbWVcdt5ztwzqrqOxoeOo0V19fb5/RaC5VxJXIlfJ7HUWu1AhCiFyBQOArQtQK2gRP3rOOrW5TUlLa5UZmtVopLi6murqa9PR0exetQOCL2OpM09htiXPHLUefVsdmBO3lkXssf26Oneb0ej3R0dHIZLJGqSJSvrRGo/Eocp3tw6T8XqPRaN+WELkCgcBbhKgVBBxP3rOlpaWUl5fTtWtXu79pIHE1rS9ZhimVSjIzM/2ebuAKZ0sv5zEdq4IoUEgV9xERES59WiUh1pyFlcB3pGMrpYpI+dA6nY7S0lJMJpNX+dDNiVybzdYoVUGpVIrviUAgaIS4sgsCitFopK6uDo1G0+imVV9fT15enr0rl7etbluLs6j1p2WYL2OQ0Ov15Obmupw+F7QMdz6tzhZW3lb3t4TjJb3EVUTam3xoKZIbEhLiNh/alciVUh8kFApFo0iuELmC9kKr1do9uDsCYWFhREVFtfcw2hwhagUBQUo3qK2tpbi4mMzMTPtrkk2WP7tyeYskaq1WK0VFRdTU1AQ83cAVVquViooKiouLSUhIQKVSodfrqauro7S01C6yampqCA0NFY0JWoEnCyvn6n5/euQeDwLLmzQL53xoi8WCTqdDr9dTVFSE2Wz2quhPiFxBR0Wr1XLaaYNRKDrO+RYZGcnPP/983AlbIWoFfsfRe1Yul9ujVlLealVVVZvYZLnDaDRSVFSESqWiR48ebS4YpWnV8vJyunfvTlBQEPX19Y3M8Y1GIzk5OVRXV1NSUnJMNSZobxwtrGJiYuzCSK/X2z1y1Wp1o+lycbxd05LcYYVC0Sgf2lXRn2MjCJVK5ZPI1ev1jYrShMgVBJra2loUChn5BTrMlvafpVEeFde1tbVC1AoELcWV96wkao1GI3l5eSiVyoDYZPkyxtzcXBISEoiJiWnzm5zBYCAnJweAzMxM5HI5Foul0TKS6JLJZHTp0sVehOPYmMBx+raje7Z2dBwLnxw9cp1zQh0Ln5o73sdyoZgj/thP56I/s9lsz4fWarVYrdZGIteds4UkcqUHECFyBW2NxWLDYm5/UXs8n9VC1Ar8gjvvWZlMhtlsJisrq92EJPzXocxisZCamkpkZGSbj6GyspKioiISExMpLCxsNvonpUo4ii5o2Bdp+tbZs9VTZEvgHZ5yQouLixtNlx/vxzsQucNKpZKIiAh74ahU9CdF0iVnC+kzaI3IVSqV9h8hcgWtpeGca+9RHB+pT+4QolbQatx5z0rpBhaLhczMTL+0um0Jjh3KVCpVQDxwPeHY8rd79+4EBwdTUFDQ4vXJ5XKPnq1Wq1UUnfmR5jxyXUUSj5dILQT+BhoUFERkZCSRkZH2h2fp+JeXl9t9dJs7312JXGlmyVHkSpFcuVx+3HyGAv8go4OI2uM4VitEraDFePKelar6pXzE9hK0jtHR6OhoDh061KaV6VJurGPLX2+3721XMVeera7srKTolrCzah2ejrcksgD7eX8sP1S0tXh3dLZwFLk6nY66ujr7+e6YLuKryDWbzfb9EiJXIOhciLuboEV48p6tqKigpKSE5ORkwsPD2bdvX5uPz2q1UlBQgF6vp3v37va+9m3ZflaqrJcEtWNKBgROEDhHtiQ7q+rqaoqLi0XRmZ9xFUksLCy0P9Acyw8V7R2R9mTfVltbS0lJCQqFwiuPYleFZ5LIhYYmMaGhoajVaiFyBW7oKDHSjjGK9uDYuboK2gxpys453cBsNpOfn099fb291a3Vam1zz04p3UCj0diLsRwJ9Hgku7Da2lq6devWqih1a8fqys5KanHqqtJf8hMWtAxJZAUFBREeHk5YWFiTh4pAe+S2Je0tap1xdb678ih2TFdwd/ydRW5lZWWjmRYpkiv9CJErEDm17Y8QtQKv8ZRuUFdXR15eHhEREaSmptpfa8vIqM1mo7KykuLiYpKSkoiOjm6yTKDHYzQayc3NRaVS2dMNXCGNw9PFJxAXJin/UKPRuKz099YYX+Ad7h4q9Hq9PZIfHBzc6KGiM0XOO5qodcaTR7GvDxmSRaH0uhSVl9xeHNMVpJa+HfnYCATHIkLUCrzC0XvWVavbiooKunbtas8zdCbQNz+LxUJBQQEGg6FRuoEzgRyD1J2sPV0efMVVpb+UH1pYWOi1nZKgMe4enBwfKhw9cqV8XKPR2Gns2jpj1zRHj2LA5UOG1IhD+pwcRazjA4dMJmskgF2JXEf7MCFyj33kMrB1gM9Y3v5DaDeEqBV4xNl71rnVbW5uLjKZjMzMTJcFGdLygRS1UlFaaGioy3QD5/H4+2YsuTxUV1d73Z3Mm3G0ZZRbwtkY31URlKOzwrGUH+pvvDnfXdm1taSlbHvS0cbjC84PGY7pOZWVlY0i6RaLxeP30ZXINZlMGI1GoOGzlkSuUqlskt4g6PzIOkhObUcYQ3sh7kgCtzinGzhegKurqykoKCAmJob4+Phmp9EDIc6ci9K86Zzi77GYTCZyc3PtTSVakh/ZkW9s7orOHPMTj5X8UH/S0nPMXeTcVUvZ9vbI7eipBy3BVXqOJHKtVis5OTkEBwc3iqS7e4j2JHKl62lQUJA9XUGI3M6PXCbD1gE+QhGpFQicaM57trq62utWt4EQtRaLhfz8fEwmk70ozRv8OZbq6mry8/OJj48nNjbWpxtSe0RhW4u3+aHe3PCPB/whUFy1lHXutuVNI4JAcCyKWmccI+mVlZV069YNk8mEXq+nrKysUbqI1G3OG5ErffdNJhMmk8m+LeecXEHHQmpxDv99v4/l78DevXuZMWMGu3btYvDgwSxcuNDv26ioqODzzz9n1apV5OXlAZCSksLYsWO56qqriImJ8Wl9QtQKGuFsSO54YXUsgvIlKimTybBarX4bo06nIzc3l/DwcFJSUny++LdWTNpsNoqLi6mqqvI63aAl4+jowtdTfqh0w3eMKnbEqfPOhrtuW+2RHnI8iFpHbDabXXRKD/PuWipL5727nGjpb0Lkdg4cgzvNzUp2hK9Ea8dgMpl4++23effdd+2ph4Hgn3/+4a677qK0tJTMzEyuuuoqAFavXs38+fNZtGgRr732GgMGDPB6nULUCuy4856Fpk0M2iMqabPZKC8vp7S0lC5durSo1W1rb8JSHrFcLiczM7PFouFYFAPO+aGO7WWlqXPpdceIx7FIWwk+Vx65jh6t3tpXtYRj+fNzxt2+emqp7EtOtCuRK12PHUWuc+GZIPBIrhcA+/fvp7y8HMBeUBgSEoJWqwUacmo7wqfSmivPjh07mDFjBvv376d3797s2bPHb+NyJDs7m2nTplFVVcX48eN56aWX7Of/PffcwwMPPMDy5cuZNm0aixcvplu3bl6tV4haAeA+3cBbVwFPyOXyVt8AJQ9cs9lMZmYmKpWqRetpjcCuqakhPz+f2NhY4uLiWi1aOnuktjlctZeVoorQcFELDQ0VRWd+wlUjAmf7KqnxhnNlf2u2eTzgfF10h/M57yknWqPReBS5zo0gpM/TVeGZELmBQy6Xs3fvXpYtW8amTZs4fPgwtbW1jZZxTEnoCF+Jlo5h9erV3HXXXWg0GmbOnMkZZ5zBmDFj/Du4ozz55JNUVVURFxfH7NmzG12LFAoFs2fPZuPGjZSVlfHUU0+xYMECr9Yr7iLHOd60uvXGVcATrRVnUrqBswduW43FZrNRUlJCZWWl13nE3ozjeMNx6ry6upquXbtiMBjaJKp4POLOvsq5sr+lOdDHU/pBS/fVVU60FMnVarVYLBavCv+aE7mOqREKhcLuriBoPcXFxcycOZOtW7e6fN3R3rKzk5eXxxlnnMGsWbNITk6257j6m7///psNGzYAMHnyZPtDoCNhYWFcdNFFvPfee6xfv56NGzcyePDgZtctRO1xjKdWt62d5nekpaLWZrNRVlZGWVkZXbt2tecRtuVYHG3LevTo4ddo4rFwEWwpUlRRrVY3iSpWVVVRVFTUaHpPNCVoPZ4q+52LnrzxyO2I+xgoHKegW4NSqWy28M8bX2hXIlf6PKXPRaFQNIrkHi+flb9ZsGABW7duRalU0r9/fyIjI+2d5err6zEYDGi1Wnbv3o1cJusQflotdT+YNGkS1113nV/H4ooffvjB/vvIkSPdLjdq1Cjee+89+3uEqBW4xWw2u/SeNZvN5OXlYbFYWjXN70hLRK00DqvV6rdxSHg7ltraWvLy8ryyLfMVb9bV2dMPfMExqtjZmxJ0FtzlQOv1ens+qGPRk/NU+fEkagO1r+4K//R6PRUVFdhsNq/cLTyJXAkhclvGr7/+ilKp5K677mLixIl06dKlyTJ5eXmMHj2606cf+Oo00FJ+//13oOEa1KdPH7fLnXTSSSgUCiwWC7/99ptX6xai9jjDk/esJOKioqJITEz020XPV3FWV1dHbm6u38chjaU5HLukpaSkuJwa8cc4jhfB2hI8FZ0VFxd3KL9WV3RGwecuH1TqLmexWBpFzqUZnuOB9iz8k857R3cLR5HrCiFy/UdhYSH9+/fnlltuARqi9o7XbnEt9w3JWx4gLi4OjUbjdlm1Wk18fDxFRUWUlJSg1Wqb9aMXovY4wlOrWyln1FOr25bi7Zfe25a7gRyL2WwmNzcXm83mtktaIHAXfREXywY8FZ1VVlbaI1qO07aC1uGqu5wksCoqKuzXkaqqqmP+mLeHgHcs/HN2t6irq6OsrAy5XN6o8MxXkavX6xs5LwiR2xij0YhKpbJbSjm3SpaQjlXDK+1/3OR03PvG4cOH7b8nJCQ0u3xCQgJFRUUAZGVlNWvvJUTtcYBzq1vHL6XJZCIvLw+5XO73nFEJb8RZfX09eXl5AReTnsYiRYijo6NJSEgI6EVdCNbW4TxtK3U6k/JDHSO97VF0dix+tlL3q4iICGw2GzU1NZSXlzc65o7R82PJzcKdmGlLXLlbSOe9VGypUCgaRXLdfQaSyJX2yZXItVqtqNVqVCrVcStyLRYLvXr1orq6Gmg4Jp6vJR2pK1zHvAZVVVXZf/fG491xGelz8MSxc9URuER6urdYLE2e1quqqigoKCAuLs4vFlXuaE7ASWkP7SUmpYK08vLygEWIPSE5ALR1R6hjCXc3e2crq7YsOjuWP0fHQqTk5GSPLZQlgdWZ3Sw6YjqJTNa0w5+rz8AbRxFXIjc/P5/o6Gi7qJDcFSwWC1arNSBpWR0NjUbD+PHjef/993nsscfsx8+Vlzs0+NR2hEjt0TlYe4TTEcdgQHtQV1dn/92bTqCOyzi+1x1C1B7DeGp1W1RURE1NTas6YnmLTOa6o5hj2kOgcldd4ShqHQvSMjIy/FqQ5glJXEtNLTQaTZOOUM5jFXiHq5u9VHRWUVGBwWAQRWd+wFHouTrmws2ibWnuMyguLrY/aEifgSeRa7PZ7BZh0myf2Wzmgw8+IDs7m/nz57fxHrY9MpmMq666ij179jBnzhyuu+46kpKSOs25O2XKlCZ/mz59OnfeeWc7jKZlOB5rb+6HQtQeg3jynjUYDOTm5qJWq31qddsaXDVfCKRVliccI7WS/21kZKTfC9KaQ8ofNhqNpKenI5fLkclk1NfXU1dXR01Njb0KPSwsrFMKgY6CKysr565P/i466wwiqLV42kdnNwtXDxat8chtazpjUZy7z0Cv16PVaiksLLQ/aLhqxuFoY+YYFKmoqMBisbTLPrU1FRUVrF69mtTUVD788EMOHz7M2LFj6d69O5GRkfYGGlIzBrlMhq0DnCfSED777DOSkpIavdaeUVqgkc+71EjEE47Fjd54xAtRe4zhyXu2srKS4uLiFrW6bQ3OU/5SZ65AWGV5O5aysjJKS0v95n/rCyaTCaPRiEKhIDMz0y5mHXPmoqOj7Y0vbDabiDD6EVetTZ29QkXRWfP4Itw9PVhIHrmOBU8d7dzuCDm1rcXxM3B+0HBsxiF9Du6EvE6nC/jsXnsjCfqsrCyeeOIJkpOTUavV/PHHH/zxxx/I5XLi4+NRq9UolUr7TKRMJmu5n5YfkYaQlJRESkpK+w7GCcf7rdRd0hOOKQfe3KuFqD2GMJvNaLVaysrK6Natm/2C5I9Wt61BEpI2m43i4mK0Wq3fOnP5ilTgolQq/e5/6w3V1dXk5+ejVCqJi4uzT+25Qi6Xo1KpCAsLswsBSXxJtlbO4qsjCYHOgqsqf+eiM18LoI6HtJHW7KOrB4uObNl2LEbePTXjkKKxhYWF9s/AbDYTERGBXq9vVLW+d+9eZsyYwa5duxg8eDALFy702xgrKipYsWIF69atY8+ePZSXlwMQHR1N7969GTduHOPHjw/YdbympgZosPVyxGq1UlxcbP+39F2QI8PWYXJqOyYZGRn23yVrL084LuP4XncIUXsM4Jxu4HgBlqbYw8PDW9XqtjXIZDLMZjNZWVkoFIo2TTdwRBIpSqWS7t27t+mxkAR9VVUV6enpFBcX+3yTlMvlbm2tKioqABqJ3GOp+rwtcfYKdVcAJf24O4+ONRHkCn/toyvLNsd2st522goUx6KodcbZG3r//v3ExMRgMBjYuXMnt99+O/Hx8cTGxmI2m8nJyWHp0qW8++67dmcdf1FXV8cLL7zAN998Q319PZGRkYwePZq0tDTq6+vZtm0bv/76K7/++ivvvPMOc+fO5cQTT/Tb9iWRKlXbjxkzhujoaKqqquzNMaRUDsdot6B5pBna0tJSysrK0Ov1br1qDQYDpaWlAMTHxxMdHd3s+sVdr5Pj7D2rUCjs5tBSi1l/tLptDSaTiZqaGhISEgLqsuAOafq+pKSEyMhIv7W89BbH/OHMzEy72Gwu0tWca4SjrZXkciHl40riKzQ0VOTjtgJPRWeOU7aOxTfHuviRCKTQc24n6+yRCzQRuYGkM+bUtgbpuiM9aMTFxbF48WL++usvli5dyt9//83YsWMBiIqKQqvV+nX7RUVFfPnllwAMGzaMV199tcnU859//skdd9xBVlYW1113HUuWLKFr165+HUdVVRUajYbrr7+egQMHNnrNarVisViwWCzk5ORw/vnnd7j0g47KWWedxddff43VamX37t1Njq3E7t277fnbo0aN8mrdQtR2Utx5z0pOA0eOHAlIi1lfkKZoamtriYyMJD4+vs3HYLFYyM/Px2QykZGRYfd0bCvced/6+wbpnI8rKv4Dg6fc0NLSUurr61Gr1VgsFkwmE0ql8pg9zm0ZvXT2yHXVhMDxwcLfsxTHQk6tL7h68M/IyCAjI4PFixdTX19PSEgII0aMoLq6mr/++isg4wgLC+OVV15xmUt55plnMn36dF566SUqKyt5+eWXeeWVV/y6/erq6kaBBYvFYi+mk8vlyOVyu10gcNTQqyN83zt2+tPEiRP5+uuvgYaWue5E7a+//mr/fcKECV6tW4jaTogn71mdTofJZCIyMjLgnq+eMBqN5OXloVQqiY2NbZccQ71eT25uLmFhYaSkpCCXy9Hr9W2ybW+8bx2PiSuB0JoGDe7EV11dXaOcRSmSK/JxW4a7ojPJucKxteyxdpzba0reUxMCyZfYW+sqbxGi9j/q6urIzMzk/fffJzk5mby8PEaPHh2QcYwaNcrjlPPFF1/MSy+9BMAvv/yC0Wj0yvu0OaTzRUp56N69O8BxdQ60lEOHDnH33XdTUVHBrFmzGDNmTJNlTj/9dAYPHszGjRv55ptvuPXWW5tYetbW1vLtt98CMHjwYIYOHerV9oWo7WS48551LMKSy+UkJia22xilpg5S/lV5eTkmk6nNtu/o9JCcnNyoV3RbdPKyWCzk5eVhNpvdet+6ErCBxFl8iXzcwCAVnRUXF5OWltYokuvsQ9zZj3NHyTN1lyLiyrqqpak4HWVf2wpP+yuXy7nllltITk4O2Pajo6O54YYbOPPMMz0uFxMTQ0xMjH02qqCgwC5A/UHv3r3p3bu3/d/NnQMymRxkHUD4tuOp+uabb3LgwAEAZs6c6VLUSq9dfvnllJWV8fjjj/PSSy/ZHyYsFguPP/44ZWVlREREMHPmTK+333mvqMcZnrxnTSYTubm5KBQKunXr1qi3clvi2NShW7du9uTvtmwJ6+j0kJGR0eSpPdBj0ev15OTkEB4eTmpqqsciovaskHeVj+uqGCo0NFTk47YCd9PmUltTf0cU25KO6vDgbF3lXNUvpeI4Wog1J1aOt5xaT5FayX4tkMTExPDwww97taxjY5/W+uc6i3kpZ9ZVGpGr86GjdBRrzRgWL15sd31wbEtbWFjIBx98YP/3iBEj6NmzZ5P3O89AuiMjI4O33nqLe+65h+XLl7Nv3z67AF61ahVZWVnEx8czb948r1wPJISo7QS4856FplFRqYd3W2M0GsnNzUWlUjVp6uCq+UIgkBpLaDQat04PgRKTnqLDLaWthK+r6VyRj+t/XB1nqeOTFFHsTA0JoHM4PDhX9TvnQZtMpkZFZ8HBwU32S6QfNGCz2dDr9e1ix+gK6bsDDTNN6enprVqf8+euUCh8etCUd5BCsdaM4e233yY/P7/J33Nzc3nxxRft/46OjnYpam+//Xb27t1LZWUlTzzxhMdtnXbaaSxbtozPPvuMVatW8emnnwLQtWtXpk+fzpQpU4iJifFp/ELUdnCkYjBXrW4LCwupq6trFBUF7J6wbXXDkW7ICQkJxMTE+DU31FukdrNJSUnN2n74eyxWq5WCggL0er3XPsDtHan1hKdiKGcP0dDQ0GMqT9RfePP9c+745BhRdG5I4E5stSedVeh58sgtKipy6ZF7vKUfuItMG41GbDZbh2m+sGXLFvvv5557bqtcMHbv3k1BQQEjRoywp4xt2bKFyspKwsLCUKlU9jQXlUpFUFCQ/f+OXa86O47FWS2hR48eLF++3OvlY2JiuPPOO/3WuleI2g6Kt61uMzMzGz1JSsK3LS7CnoS1I4EUcL4KSn+PRYpQBwcHk5GR4ffp444gfB1FQHx8fKN8XMmb8VjJE21PnCOK7sRWRynuO1aEniuPXKnYT/LIlZYLDg5u9+PeFrh7YJEKbTuKqF26dCkAKpWK2267zef3SxHp9957jy+//JLa2lqGDRvGww8/TGJiIu+99x7btm0jJiYGuVyOQqFAqVQSFBRk/39QUBBmsxk4NtIPOjvi7tMBcfaedSwGk/xWPUUk2yIK6ElYt9V4jEYjOTk5qNVqrwWlP29GUuqHuwh1c+Pwxqe2I+JtPm5zzQmOZfwh+NyJLSktRIqYtVc732NF1DrjeH5Dg0duXl5eI79pxzzoY7GNsrv0A6llaUcQtYcOHWLFihUATJ8+nbS0tBava+XKleTl5SGTyVi+fDm33noriYmJHDlyBK1W26wPr3Qtd04PbC9sHWAM7YUQtR0IZ+9Zxy+Is9+qJ9uSQIpam82GVqu1T/VHRUV5Nc3q7/FIKQ+JiYlER0f71IO+tWOx2WwUFRVRXV1Nenp6h7jAtxee8nGl5gQiH9c/uHuYqKuro7S0FIVC0UjkBrrorCPMIvgTyXdUJpNhs9qQyf87TxUKBbGxsajV6ibFfo7HPRAeue2BO1ErRWrbO6fWbDYzY8YMzGYzI0aM4Oabb27ReqR9vPHGG3nqqaeoqqpi0qRJdvcgk8lEYmIi/fr1szcAMRqNGAwGDAYDRqPR/u+amhpkR/9rf2Qd3Kk2cHT+b98xgnO6geONv66ujry8PCIiIux+q56Qy+UBKRaTeoH7kjsK/hW13qY8BGosUrRGLpc36g7mK95GajubcPCUj1tSUkJ9fT0ajcZe/NjR8kT9QXsV90lFZ1VVVRQXF9tN4QPZUa4zfXbSdVUSrkaDEZsN1Opg1Bo1VquV2to6lEolBoORyMhwzGYzNltDZFJ6v6vjrtfrA+aR2x64i8LrdDqg/UXt008/zbZt2zjxxBOZO3duq8/tcePGcfLJJ1NTU9PIV9xoNDJkyBAeffRRVCqVfQbVbDZjsVgwm832SP4tt9zij10TtBIhajsAnrxnS0tL7Qb+rrqquCIQYshgMJCTk0NISIhbZ4FAj8fRYaG5lIdAjKW2tpa8vDx77+rOdENvL9z549bV1VFQUAAcu/m4bXl+OBedSVXqkj+u0Wj0e8S8I6YfSKJVLpdjs9owGk1HH7TUmM1mCvKLyc46wt7dBwgLC2XY8MHEJ8ZhsVhY+dNvLPnye3bv3Mefm5dz9dQ7+ODDeTz77KvcdddNKIOCmgQMHI+7cyc/Z0cL6WGvM6TjeIrUyuXydutSCfD666/zxRdfkJGRwYcfftjEtL8lyOVyUlNT7f+W7hFlZWVYrVaioqI8fm7SzKlc1jEe9GwyaJ25Wefl2LmDdEIc0w2ci8Gkpz+bzUaPHj18ytvyZ6TW0arKG2cBV0ite1tDa/JXnfFV1EoPFxUVFaSkpPjlIuqtuO5skdrmkKbQi4uLSU9Pt3fgcuXberzm4/oDx7xPaBApUj6us4OFVOHv63eqPTuKScLVYrZgqq9HIVcQEqKhrk5Hbn4BWQey2bv7AEcO59p/qqtqGHH2MG64bSpXXXspQUFKlv+wiiVf/sD6dZvsxT7f/Pgxv/66lu++W8H5S5dz3vjR9DrxDO6443oenXEPIEMmc/3ddJypABo5WgTq4SIQWK1Wl/ccnU7nla9voHjvvfeYP38+3bt355NPPiE2Ntav63cOLD355JOkp6d7n97WgdIPjleEqG0nPHnP1tTUkJ+f3+KIoL8io1IjA6PR2Gweryda41PrrqFDS/H12JjNZvLy8rBarWRmZvq1KKSzFor5i2M1H7cjRjDlcnmTojMpkitV+PtadBbI/ZRSBORyOfX1Zsz1ZpRKJZoQDVXaavJy8zm4L4v9ew9xJKtBtOYcyUOva2qtdM74UfzvqXs48aQTAPjhu5+Z99Jb/L3+nyYP26cN7kff/ifTr+/ZADz/3HzWb1hOREQYc+e+w4IFX/LUkw9wzTWXHfUE9xwP8+SRK6XjOJ7jHSUdx52ll16vb7cagg8++ICXXnrJLmjj4+P9vg3nfb7yyiv9vg1BYBGith1wl25gtVopLi6murqa1NTUFuct+SMyqtfryc3NJTQ0lIyMjFZFzFoqsqVOaUqlsklDh9aMxVuk7mAREREkJSX59WbTEW5cHQ1v83FbE10UNKBUKgkPD7fnDkrFT5JHrqMYc1d01lpRK0Vb5XI5RoMJi8Vy1AtURVlZBblH8jiwN4sD+7Iaoq3ZueTnFGAy1Te77vMnn8vVN1xGz96ZmOvNfPftTzwzay5bNm33eC2a/87zvPH6h+TnFwJw8OBh1q7dwOuvP8cVV9xKZaWWu+95jNdee59XXpnJmcOHoJDL7VFeb/bZ2SNXOu6SbZuUqtCe57g7Sy+dTtcuonbBggW8+OKLdOvWjU8++YSEhIRGr0tpTWq12q+pERaLxf6A5Q1yOoj7gYjUCtoCT96zUr5oUFBQqwqQoHWRUUfbsC5duhAZGdnicUi0RNRWV1eTn59v75TmrwuFN2MJxDFwtx1PdMZCMXcolUoUcrm9IjchIcF+w5b20bm9olwuJzw8vImlVV1dHZWVldhsNrtna0fKx+2Mn1lQUBCRkZFERkbaZ5F0Op29+MlV0VlzotaxMAvAaDSBDYLVwSgUcoqLSsk5nMe+PQc5dOAwOYfzyD6cQ2F+cYseyi+5chJXXnsxPU7IQKfTs3TJjzz2v+fYvnWnV++/5vrLCY8I58UXX2/096efnstPP32BWq22m+wfysrmgguvZdiwQbw+/zlSU7ugVCp8btOqUCgaPVw4e0C3l22bu5xag8EQ8Ba5znz88cc899xzbgUtNDRJuOaaa3juueeYPHmy37bt+DDnqXXwf3SM9AMhagUBx1O6QXMduXylpWLIF9uwQI0n0HZZzY3FarWSn5+PwWDw6zFwNY7jAaVSicImAxus/2glZqOZII0KZXAQRSFqgtQqgtRBKIMb/hYUHIRCFYRSpUShUqJUBaEIUqBQKglSqQnThCI/GjW3WixYzVYsFkvD7xYr2ADbf8dX+qRlkif60e+eTC5HppA1OR+a+93bvuad+fOVyWT2zknOxU+ObZPr6+sxm832aCs27IVZak0wVquNooJiDh86wr7dBzl86MjRiGseJUWlrR6nXC7nymsmc9nUi+jeI50qbTVLFv/Ag/c+xa4de31e18OP380D9z+JTqdv9No/W/5lz+79vPzSU9wx/ZFGr/311yYGDBzDpZdO4uWXnkJ9VLC39MHGlUeuYwTdMVc6kA9y7gSclFPbWg4dOsTdd99NRUUFs2bNYsyYMS6XW7hwIc8++yzp6el88skndquttkR6eJPL5ZhMJmpqaoCGcyYoKAiFQmG34ZQjQ94hBGVHGEP7IERtGyDZfkBT79nCwkJ0Op1f8kUlWlIoptPpyM3NJTw83CvbMF/wVtQ6phu0NlrdkrFIzRw0Go3PDg8twXEcFosFhULRRAx1xqgfgFKhRGEFkFNdUsknN75E6aECv61fJpc1CF5VEMpgJcrgIJRHxfB/f//v3w3LqOxC2f53jQqVOpggzVFxrVYRFKxCqXYU2JLIDiJIrSI0OtzuYVpvMGE21SNXKlEoj0aibTb69O6DDOlcs2H/GG02+zIN/webJL2P/uG/j1wS0o57bqPR4m6x4enG9t9pJrP/T9b0xYbzUQahIaFEhkeATIZOp0cmkxEaGoJebyDncB5Zh45wYG8W2VlHOHI4jyOHc9FWVnkcYUsICgpi6o2XcvEVk+jWPZXS0gq+/nIZy279if37DrV4vS+88iSFBUUsXrzM5euzZr3Mwk/f4M67Zri8tn711TKWLVvJXXfeyCOP3AXY/DLT4i6C7lhY6ZiS4y/7ME+WXv4INLz55pscOHAAgJkzZ7oUtZ999hlPP/00MpmM8ePHe2zfmp2d3eoxuUMmk5GTk8P69es5cuQIZWVlmEwmFAoFarWaoKAgTCZTwLYv8A0hagOIJ+9ZKWc1JCSEHj16tIuIlMZYXl5OaWmpT7Zh/h6PVBwXGxtLXFxcQCNdrsYiuSv42syhpTjmURcVFVFRUYFSqWw0nd7Z0g9kMhkKmRylXIFFZwRNMNuX/cWyJxZgNjafB+kLNquNeoOJeoP/byaqEBXpg04krX9PknunEZ2agFKtQh2mIUgTTE1ZFeU5xRTtz6Vwfx4njR5Al5O7M+O8B9GWapHJQCaXI5fJkMkbosJyuQyZTG5/TSaX/fc3uRQ9/s9DVfodGcilZaT1OK3LcT3yBk8hp785bEPWdD2N39PwelK3ZAaMHEB8aqI919VssbBj604+fncR2YdzyMnOo65W5/fj74xaHcx1t17FBZeMJy29KwUFxXz1xVK+X7qSrENHWr3+uPhYLrp0AuPHX+X2+/brr39SWlrO44/dy8xZL7tcxmg0MuelN/nwoy+YPethrrxyMjab1W9ONK4i6O68iSWh29L7iqf0g5CQEBYvXmyPWFZXV9tfLyws5IMPPrD/e8SIEfTs2bPJepqb8di8eTOzZ8+2v/7WW2+1aD9ai81mY/369bz66qts377d43JwNGjVAaKknXmmqLUIURsgvGl1m5ycTFRUlN+37W2k1mw2k5+fj9lsJjMzM2Deg57Emc1mo7i4GK1W26riOF/G4oi/3RV8wWw2c/jwYXtkWsqnk25QMpmMoKCgdrfRaQ6ZTIbCJiNIoeTwD38T0T2JqBNTWXzfm+xasam9h+cSV8I1JDrMLlzrKmrswnXf+l2UZhdRll1ERV4pVvN/eZNDrzib9AE9efzS/1GUXdiOe9Q6evTtyVmXjqbP4D7EJMWiVCnZv20/P3+9ml2bdnHf3PspKinlmktux2QMfFQqNCyEm26/mgkXjqNrajI52Xks/mIp33+3ktwj+X7d1gefzOPnn39n86ZtHpebNfNlXpk7y62olSgvr+T2Ox5h3rx3mTt3NkOHDkSh8L6YzFtceRM7u4dIHrmSe4i3ItdT+kFISAhvv/02+flNP4fc3FxefPFF+7+jo6Nditrbb7+dvXv3UllZyRNPPNHkda1W2yEe6Hfu3MlDDz1EWVkZUVFRdOnSBaPRSEFBATabjcjISHtnMb1eL9IPOgBC1PoZ51a3jhcGRxEZ6HzN5i4IUpeyyMhIUlNTAzrVLo3HeUrLsTtXjx492qTQx/HYBMJdwVvq6+uprq62F8KZzWYUCoU9CmO1WikpKcFkMlFaWtohK//lcjlyiw2FTMGej1eR88s2Rr41ndrKGuad+zDavLJ2HZ9duPbrQXKfdKLTEgiJaixcyxyEa1l2EaUuhKs7eg47iQueuIZXbn+R7F2H22CP/MfJw05h+EUj6TXwRKITYkAGuzfvZvnnP7Fjww6O7DtifzB+Y9WbVGi1XHPJbQEVtBFREdwy/RrOO38MyV2TOLg/i48/XMTy71dRkF8UkG0OGtqfk/v2Yco1dzS77NKlPzFnzhPccsvVvPvuwmaX338giwkTpzB8+FBen/8sXboktaiYzFtcuYdIIresrMwnj1x36Qd6vZ6oqCiPqQDe0KNHD5YvX+729TFjxrBv375WbaO11NTU8NVXX1FWVsbIkSOZOHEiPXr0oLi4mGeffZaIiAiefvppCgoKKCkpcSnOBW2PELV+ROrHbrFYmqQb1NXVkZub22Yi0l2k1mazUVZWZu9SJlXdBhLpWDheKNurO5e0nbZMd3BEOv7V1dWEhYURHx/v8gFE6tqjUCiIj49vZP3T3pX/CoUCudmGTW9m2/xl7P/8d3pNHcW4zx7i789/ZcXzX3glCv2BKkRF+mm9GiKufdKJTo0nJDq8ccQ1t4SifTktEq7uiO+ezPXv3s/CZxew9bctftyjwDBw9CDOuGAEPfr2JCo+CnO9mZ0bd/LN+9+y8++d5B7Mdfm+V5e/hsFsYspFt2DQN/WAbS2xcdFMu/t6xpw3kqSkBHbv2s+7b33C8u9XUVIc+Iei+W8/z6uvvueVaLZarTz77Ks8/PB0r0StxNq1G+jXfzSXX34BL815CpUqqFXFZN7i7JFrsVjcWuRpNJpGHrnNRWqPZaR9P3jwICtXrqRv377MnDnTXqQWERGBUqkkOTmZXr160atXL/Ly8gCRftAREKLWT3hqdVtSUkJlZWWbiUh3ll6BbCTQHI7RWul4+Ks7ly9IxyU/P79N0h0ckdwl6uvriYmJ8em9jtY/0sOTTqejpqaGkpISl5ZL/kapVCI329AXVbH1pSUc/nEjMoWccZ8/THTvND69dS4H1u7w+3YdhWtS73Ri0hqEa3CYBpUmmLrKGspzGoTr/g27KT1cSGl2EZX5pVjq/S+uNeEh3LnkKVZ/sYqfF/7k9/W3FoVSyZDzhjJswhl0OzmTqLgodLU6dmzYwaL5i9jx9w6KcpoXcS8tfRm5SsEV517v19zZpOQEbrvnBkaNHU58Qizbt+1i/ivvseLHXygvr/Tbdprj+puuJDQslJdfetPr93z66RJmzX6ECy44l+++W+H1+2w2G4sWLWXp0hXce+8tPHD/7dIrPo665SgUikYNOBwflLVaLRaLxX79cCe4pZzaYxlp33Nzc6mqqmLcuHEkJiai1+vRaDTU1dWh1+vt9w5pVhaOGqx0BFHb3gNoR4SobSWevGdNJhN5eXnIZLI2FZGuIrVSZDQ6OpqEhIQ2f5KTyWTU19dTWNiQd9jWohr+E/UA3bp1Q61Wt9m2DQYDOTk5hIWFkZKSQkVFRaOLoavpPndpJJ46cUmtOB1TFVrbpUipUKJERvmOI/zz8jcUrtsFQGzfDMZ+fD9l2UW8MuYBaktbXu2uClGRPrAXaQNcC1ddZQ1lOSUU7c/lwN8NwrXsSDEVeSUBEa7ukMvl3Pfjc+zZvJeFz3zUZtv1hEqt4oxJwxly3jDSeqUTGRdJVXkV2//azscvfszOjTspK/Qt6vncl88RGh3GRedcTU11bavHmJLWhdvvvZHho4YRFx/N5o3befG5+az66Xe0Wv+7JDSHXC7ngRl3ct+9T6D3IQJtNBp5dd47PPPMDJ9ErYTBYOC5517j/fc/Y/bsR7j8skkAAUtJ8ISzR259fT16vZ66ujoADh8+bHdUKCgooHfv3k0itXv37mXGjBns2rWLwYMHs3Ch9xFsX/n555+ZOXMmZWVlTJ8+nTvvvDNg2wLsHQ2lnGDpfmWxWDCZTHZR63htlXWQnFrhUytoEZ68Z6XmAXFxcW06vQ0cbS1Zbx9jaWkpFRUVbRYpdoXNZiM7O7vdRLVkWRYZGUldXV2bCmrJhzgpKYno6Gi/r985l06aZqyrq6OwsLBFLVBlMhkK5AQpFOT+tp1tc5dSsSfH/vqABy7mpFvH88dby/ht/lKvplKDNCq6nSYJ1zRi0hIJiQ5rKlwPtK9w9cSdS2ZSXVXLvOlz2q2QJSQ8hBGTRzLonCF07ZFKREwEZYVlbP1zKysWr2TXxl1oy7QtXv/Mj2cSl5LARedMbZUtV0aPbtx+7w2cPnww0TFRbPhrM8889TKrVv5ObU1di9frD156bRb5eQV89ZVrCy9PvPPOQh548A6GDh3Ihg0tSz0pLS1n2rQHmTf3HebNe5rTTuuLUqnwezGZLwQFBdlnfOrq6khNTUWn07F161YefvhhFAoFcXFxbN68mVNPPZU///yT999/v9HDeSAoLy9n5syZrFy5MqDbcaaurg61Wt1kNs9sNmOz2eyF1cfzVH9HRIjaFmI2mykuLkapVBIZGdnEoqmmpiYgzQO8QYrw1dfX2yOT7REZhf9EtdVqJTk5OSCirrntS24TkmWZlJPaFtuWGkk4Oyt4U8zXUksv52lGKVWhrq6O0tJSlEplI5HrOLsgl8uRW0EpV3Jg8Rr+ffMH6grK7a8rw9SMXzwDTdc4Ppz6HEe27G+0baVaRfdBroVr8NFUgf8irnscclw7jnB1x9TX7iQsMZoHz7uHej9blHkiIiaCkZeOZuDoQSR3TyYsKpyinCK2/LGFbz5cyu5Nu6mtan00FeDRdx4lrXc6F46ZSllphc/vP/GkE7jt7usZPGwgkZHhrP1jA0/873l+Xb0WXV3g7b+8ISExjkkXncu5517RovdXVVXz4Ydf8Oq8pxky9LxWjWXvvoOce94VjBw5jPmvPUtSUgIqVRBWa4MVWHs8OFmtVhQKhX02aNSoUfzyyy9s2rSJuXPnsm3bNqZMmQJAWFhYQEXtsmXLeOaZZ6iqquLEE09k717fmmq0huDgYPR6PUajEcA++6lUKgkODrZbmjkWGIuc2vZHiFofcUw3cGyoAP+1ulWpVG1eTe+ITCbDaDRy6NChNi/EcsQxh1eKALQljh3SHC3L2sL/VXJ2UCgUXp8LzbUdbSnOBu6St6Vk+yNZAoUHh6CUw453lrPn41WYqhqLkC7DT2LkW3eSvzubnx//kMwzTubMm8cTk5ZgTxVoJFwPdD7h6o5x91zCiSP78fCE+6jV1gR0W3Fd4hh12Rj6njWAxLREQiNCyT2Yy5bft/D5/C/Ys2UP+jp98yvykQdefYBep/XmwrFTKfah41ff/idx693XM3BwX8LCQvntlz955P5Z/P7LnxgMRr+Ps7W8/8mrrFjxK/9s+bfF65g3921uumkKPXtmcOBAVqvH9Pvvf/HkU3P44P25bFi/hfj4WBIS44mOjsRsNmMwGI+KTbnd+UQSvdKPv3B1HQoPD+fss8/msccew2w2Exoayvjx49Hr9fzwww9+27Yjzz//PB999BHp6em8/vrr5Obm8r///S8g23JE2vf4+HhMJhPbtm3j9NNPt98/oqOjiY2NZcOGDezZs4fevXvb39tRLL1E+oHAK5y9ZyU/WJvNhlarpaioqM3M+91hs9morq5Gr9eTnp7e5oVYEo6WYYmJiRw8eLBNow5SDmtoaCgZGRmNopGBFrWS04WnBwrHMTi6Qzjj73E6e1sqFApk9VaUQUoOfLWWnFVbUQYHkX7OQFQRIagiQglJjKL7BUORKRXIFXIyhvYhY0hvCvfmkrPjEAc27qHscOcXru4YcMEZjLxlIrOuepxiLwqsfCW5ezJnXz6WU87sR3zXONShGrL3ZrPp1038u/5f9m3dF3Bv2Dufv5P+Zw1g8rhrKMhr3m930ND+3HzntfQbeAoajZpVK37n3umPsfb39ZhMbRfF9pWhw07jpFN6ccVVt7ZqPUVFpXz7zXLefON5xp5zWavHdd11V/DKyzOZduuDfLPkx0avxcZGk9wliS5dEklOTqRr1yS6d08nPT2F5C6JxMXFEBISgtFoxGYDuVxmj/S2BHfOB1Ix9Kmnnsprr71GcnIyeXl5ARO1+fn5XH/99dxzzz2o1Wpyc107dPgb6XrdrVs3kpOT+eKLL4iLi2PMmDFERESQmJhIYmIiO3bs4L333uOOO/6zgxOitv0RotYL3HnPSrmreXl5GAwGunfv3qbFR85IhWlSDmV7CFp3HcrasjuWNzmsgRiLtO9lZWVe5S97k34QKBQKBcHKIORBSqwKMxaTmYzzh9Lt3NOwmsxYjfXI5DJCusRiA6wWK/rKWiK7xGKs1aOv1pF0Qgpx3ZIw1uqpq6qlMr+Mov155Gw7wMG/91BXEdiIZlvQbUBPLn3uZubfM5cDW/c3/wZv1tkng5GXnc1JQ08mNjkOlVrFgX8PsHb5Wv5d/y8HdxzEXN92uZW3PHkLw8afwcXnXsuRw+6Fw/CRQ7nx9qs5uW9vglRB/PTDaqbf/BDr1m5s11xQX3j1rWeZ+8q7FBWWtHpdL7wwn/UblpOQEEdJScvtx+6791Yee+w+rp56Bz+v/L3J6+XllZSXV7Jzx55Gfw8JCWHW7AeZfPFEwsPDsNlsPPnkHPr06cW5544iKioSk8lEcLAKi8Xi9TXPUzcxgMcee4zk5GTfd9RHZs6c6bNLjD+QrruDBg0iKiqK3bt38/jjj3Po0CFuvfVWoqOjGTp0KOvWrWP58uUsX76crl27tvk4Ba4RorYZPHnPms1mtFotkZGRZGZmBtR7tjkcfVfVajVlZW1vfO+pQ1lbiFqr1UphYSF1dXUeHzACMRZHu66MjIxmu7O1Z86TShmEwgb/PvIhOYvWglNEJ+Hsvpz81BRCuydjM1uwmq18fvXz5G85wBl3XsjQWydQmlXA+1c+jcVsITY9kdhuicRndiXt5O70n3g6EQlRWOrNGGoN6KtqqSgop2h/Lrn/ZnFww25qSrXts/M+ENU1lpsXPMLiVz5n48oNLV5Pr9N6c9bFozhxUB9iEmOQK+Ts27qPVV+tZsffO8janYXV4p9Wqr5y3cPXMfrSMVw24XqyDmY3eX3MuWdx3a1X0efkXshkMn74biWvzn2Xv//a0i4V+63hxlunoNGoeeUV/7RcPXjwMGvWrGf+/Oe4/PKbW7SOWTMf4o47bmDyhdezbt1Gr97Tr//JPP/CY/Tvfwp79uwnNzcfjUbN+PFXsmnTf61cU1O7MHr0cM4/fxwjRgzFZmu47jRXkCbNRDqj1zekvLRVGll7CFoJKQXjyiuvZNu2bWi1WsLCwuz3+EsvvZR169bx22+/AfznU0vHsNPqCGNoL4So9YAn79ny8nIqKytRq9Xt+pRmtVopLi6murra7rtaV1fX5gUGkrtARESEy+YSnhpC+AOTyUROTg4qlYrMzEyPOaz+FpQGg4Hc3FxCQkJISUnx+uEmUIVinghGjqlIy59Xv0TtwYJGr3W7biwn3Hk+QdHhIAeZTI7FYmbxjS+Tv+UAAOvmL2XTRyuY/OZd3PXT8/z5wXJ+e30ph/7a1WTs4YnRxHZLJK5bEvGZXUg5MY2+4wYTkRSD1WzBWKdHV12HtrCC4gN55Gw/xMG/d1NV6HuBkr9Rhai4Z+kz/LlsLd+/951P7+13Vn/OvGAEPQf0Ijo+BqvVyq5Nu/j+4+/ZsWEHOQdyOkQL0CvvvpIJ107gygtuZt+eg/a/T7hwLNfceAUn9O6BxWLhu29X8PzTr7J547YOMe6WoFQquf+R6dx15wy/5vk+/fRcVqxYREhICDqdb4Vwr732LFdcfiHnnXslW/9p3t95+vQbuO3264hPiGPxl99x912PcullF3D77dcxduylbNvW+DuYm1vAggVfsmDBl8hkMk49tQ9jxoxg0qRx9Ot3EjqdnuDghodvxwcUm83mtvECtJ2obU+ke8Sll17K5MmT7cVz0nEJDg62dxDbvHkzRqMRo9HYkJbYASSlVRSKCRzx5D0rFT9ZLBYSEhLsT6/tgWOb18zMTHtXKSnXty1w5S7gikBGaiX7NKnlbHOi1Z9jqaqqoqCgwGe7rraO1CqVSoKsMvKW/sWOGR9jlar3lXL6PHI5aVeehc1soWztDhLGDsRqsWKzwdfT5nFk/e5G6zLVGlh0zYt06d+DC+ffwaArRvHt/95nz+p/7MvYbDaqiyqoLqrg8IbG06YA4QlRxHZLIjY9kfjMLiT1TuOkswcQmRSDzWrFUGdAX11HVVEFRQfyyd2RRdbfeyjPbf20sTfc/+MLHN6dxQePv+NxOblczmljB3PGpOFknJJJVHw0RoORHRt28NVbX7Pz753kH85vkzH7wkW3XMTkWy/mmktuY+f2PUy+fCJTrr+UHidkoNcbWLpkOU88+gLbvBBbnYGX58/iyJFcvvnmx+YX9oGt/+xg9679vPTSk9x++8Nev2/hwjcYM3o4o0dNZu/eg26XS0yM5/kXH2fs2BFUV9cyb967fP7ZEmpqapk1+2FuumkKo0ZNZtcuzy1lbTYb27fvYvv2Xbz88luo1cEMGzaICy88jxtuuBKDwYRKpcRoNHrsJga0acOajoBCoXAZJElOTuatt95i+/bt/PXXX8ybN6/tBydoghC1TnjynpUaGERFRZGYmEhNTY3dqLqt8STk2ip/1Z27gCvcdTlrDTabjeLiYrRaLWlpaV5fbP1xfDzZdbXVGLwlWKFEZoZ/7nqTwp82A6CMDOGUZ68j+ZwBGPLL2fXQByRNGkLS+CHkrfqHLmMHsPTON8j6w32FeMHWg7x55r0MvXUil71yOwW7s/nm4fcoP1Lc7JhqSrTUlGjJ3tjUoicsLoLYbskNKQ0ZySSdmErvEacS+fSNAA05vTU6qoorKT6YT+6OQ2Rt3Efp4eYLnLzh9kWPYzCZmHPLc00eDpUqJadPOJOh44fR7aTuRMVGUltVy/b1//LpvM/YuWEnJfltI7xbyoRrJjD1vqksWfQ9Tz7/EBk9ulFTXcs3i7/noftmsvPfpg8hnZmk5AQmTDqHc/xQ0OWK2bNfZuGnbzJ9+v+8CiZ8v2whp57ahxFnXkB2tusc5nHnjuKppx6gR88M1q7ZwJVXTGPNmvX2159/4XGuvvoShg+/gP37D/k0Xrlczo03XsWNN06he/c0amt1BAer7Ncjd6K2rdMPOjqS60Tfvn2JjY1l3rx5yOggll4dYAzthRC1DkjFYJ5a3Tq2dm3LiKiENz64gZ7qh4YLXE5ODuHh4V5NuftbxJnNZns1bI8ePexRam9o7Vgkuy65XN4oQu5vWjtOuVyOyiqj7lAxG697GX1+OSHdE+n3wo3EnNaTyi0H2DzlReqrahn0xf8w1Rn4Z/bn9Hv8Kn546F32r/LOWH7DOz+weeHPTH79Lu5a8TzrP17JL69+S72+ZdO8tWXV1JZVc2Rz0+hTaEy4PcIbl5lMUq80ep5+EpOfikUul2Oo1WM4KnhLsgrI23GYQ5v3Urw/z6ttX/HCrcRlJPPAufdgMpgIDlEz/KKzGDJuCCk904mMjaSitILt67bz4bMfsnPjTiqK2zddIiQ8hNDwUDShGjRhGkJCQ9CEalCHqlGH/PcTrA6m/4j+pJ2QhtVq44prJrN+3Sae+N9zbFi3meKiUnS69pt5ChTvL3yVH39cxbatOwOy/l9//ZOSklKeePx+npo5x+Oyf/y+lKSkBM484/wmxWoqlYrHn7iXK6+ajEaj5r33PmXyxTdQkN/YcWPeq09zySUTOeOMiRw6dMTrcU6aNI777pvGySefSFlpOR99tIjffvmT7374hJLiUhKT4gH31oJ6vd7uX3ssIl1rnV1p3OHq9Y7iftARxtBeCFFL861uHf1GHQVMW4hHR7z1wQ1EVFTCMd2gS5cuREZGevU+f4payTKrNd3JWjoWf2wbAh+pDQoKQmmVkbVgJXufX0z0oJ4M+fh+wjK7UPTTRtaNm0Ht/nx6PHAxGXdMYv/Hqyn8YwfDP7iHlY8vYM/3vhVGmXUmFt/wEkknd+OiN+9i4KUjWfroB+xascmv+1VXUUNdRQ05/xxo8pomMpS47knEpicRl5FMYq9URlx/LpMenYoiSHE0wqunplRL8aEC8nceJmvTXgr2NnRKG3Xr+fSbNIxVn63g3tcfpEtmV8KjwynNL+GfNf/w/afL2bVxF9WV1ahD1GhCNYSEh9Dj1B4Nv4eG2IWkJlRDsDq4QUxqglGpVQSrG/6vCm74CVIFoVQpUQY1/CgUChRHbdMUiob/y+UNPzKFHLm84drk/LrVYsVsNmMxWzDXm6mvN2M21VN/9CcoOIgu6V3Q6/SYTGbMZgshIQ0zC8PPOp3BQwZgsVob8ittDQ9t9WYz5nrJj9tMvakeo8mEQd/gcVxbW0dNdS3VVTVUVlZRWVFJRXklZWUVlJWWU1JcRllpRZs/9Dtz5ogh9O7dk8suuymg25k96xVemTvLraiVy+Vs2rgShULBWcMvoLy80v5anz4n8PyLjzF48AAOH87hkYefZunSn5o0NZDJZLzx5vNMnHgOgwefR25u82ktAweeymOP3cuQIQOw2eCLz77h3rsfZ9fOvchkMn5auYh9ew9xOOsIF108Hviv+YIzzi1yjzWka3lz1/Samhrkcrk9x9bxfiuTdYwo6XGcUitErbP3rOMJLeVLusvVDKR4dEYaS0JCAjExMc0+QQZiXBaLhYKCAoxGIxkZGQQHB3v9Xn9N+Ut2YSkpKS1u+duSsfhr277Q0mMWLFOC3szfN81DnRTD6L9eJjgukpxPVrP5yucxlmhRRodxxq8vEJwYxW9TXsRSb+HsLx/h1+e+4N+v17R4zEU7s3lrxH0MvvFcLn7xFs68aTzfPPwepYcKmn9zK9FX1ZG77RC525pOx6ojQolNTyC2WxJx3ZNIOjGNM6aOZcJDVxCkVmEymlAEKTHXmxl56Wg4enMyGUxExUcz5tKxnHPFOLugtFkbbP4k4WeuN2M2me1C0mSqp95Yj8loot5owmgwYTQYqa2uw6Arx2gwYtQbG16XlpWEqNGEyXj0/y7+5rj+eg+esBOmjueimy4iPjmeX1es4ZN3v2DjXw15z6f0P4kpN17KaUP7E58YS1FBMSt//JU/f9/AgX1ZaDRqQsNCCQsLISw8jNCwEPu/Q8NCiYyKIDIqnC5dkjixd0/CwkIJDQtBE6JBo1GjVgejDFJiNjfMftmP01GRbDKaMBpN6PUG6uoaBHJVVQ1V2mq0lVVUVmgpL6+grKyC0uIySopLqa31vSPZK288w0svv0WRD80kWsLSpT/x4pwnmDbtWt5+++NGr6nVav7ZsorKyirOnzCVmpqG7m/XX38F99x3K126JLF06XLGjrmUf//d7Wr1yGQy3n3vZc45ZySDBo2joMC9X3JKSheeeOI+zjlnJOHhYXy/bCVTr7qddX9ubHQ9eeCh2zmhVyannjiCN955wf53qVmOM8eyqD106BB//fUXarUalUqFRqMhMTGRvn37NlrOZrMxZ84cQkJCCA4ORqVS2TuPCToGx62odfaedRS0kjVUbW2tx1a3bZF+4GhT5W3uZiDG5amZgTe0VtRaLBby8vJc2oX5iq/RVUcx39ptO47B3w8eUrpB1b+H0W4/zMC3piNXyDn0+jJyPl6Npa7BZzL5wmGcNOcmiv7cxYaLnyEsLZ7R3zzGmrlL2LJwtV/GsvGDFfzz2a9c8NodTP/hGTZ+9gurXvkKk659OkwZquvI33GY/B2Hm7w2eMpoxj82lfXfryUkPJSYpFhCIsNQhzZEWdUharBBRWklRblF5B3KJfdQHmVFZZQVllFaWEZ5UblHgdlWJKUlcvOjN9N32KnodAY+eXcR3yxahraiqtFyO7bu4pHpDdXyarWKS6dexPiLzuGKqycTrA7m7z8389P3q1nz23pKWigI5XI5oaEhdkEcGhZiF7+hYaGEh4c2/D8ijMjoCCIjI+jaJYnwiLCG5UND0ISoUWvUbqPI5nozpvp6TMZ6DAYDdXX/RZFT07oSHx/LwYOH6dYthexs71JQWoLVauW5Z1/l4UfubCRqIyLC2frPag4ezOaSyTcQEqLh7XfmMH7CaExGE6+++h6ffLIYrbba43H86KNXOWvkMAYOHEtxcdPPIywsjIceup3LLruApKQE1v35N/ff+yQ/r/wNo4vGHUOGDuT+B27ngglXYzKZUKuDG02/u0s/8LV2oDNgMpn4+OOP+f7771Gr1SgUCoxGIwMHDuTtt99utKxer2fx4sVN1iEdO5F+0P4cl6LWOd3A8Qss2TOp1epm25sGWtQajUZycnJQq9XN2lQ5Igkmf7RdtdlsVFZWUlxcTHJyMlFRUS1aT2tEnF6vJzc3l7CwMJd2YYEci/QZaDSaFon5tiJIqSRIpsBYWU1EnzQ0XWLZ+9SnFH63Hpv5qF2PUs7Ajx8gZmhvNj78Ednf/kVEzy6MXvIoG975gb/fW+7XMZkNJpbcMpf4E1OZ/Nbd9L94ON89/hE7fmi556u/GXDxCMY/OoX5d77MllWufULlSiVpJ6SSdlJ3UnqmkpiWRI8JGYRGhaEOaWgNHKwJxqA3oC3TUlpQSsGRQgqPFNpFb2lhKWVFZdQbAyN8J149gYtuupCELgms/W0906970B6VbQ6DwcTC979k4ftfAtD75BOYetPlTL//ZmbPmUFRYQk///grv/y8ln82bve60YLVaqWmptYemWwtqmCVXRSHhYce/T20SRQ5Lb0r4y88B4vFwu5d+3ju2UeJjY1GoVSg1xnQ6fXU1emorNRSkF9MdnYOBw5ksWvXPnbs2OuzNZfEp58uYdbsR7jwwvNYuvQnkpIS2LhxBZs2buO9dz5hxc9fctJJvdi48R9uuP4eVq9e0+x1SKFQsHDhGww9fSD9+4+mrOy//G25XM4tt1zNzTdPJSMjnb17D/DynDf5bulPHkVydHQkny96mzfnf8jWo62Cg9X/zbp5cj84FkVtTU0Ny5Ytw2Aw2COuZ5xxBmeddVaTZaUGFMHBwfZuotBwzBps0TpGodjx7FR73IlaT96zknhLSkoiKiqqTa2hnKmsrGxx213HtqutEbVWq5WCggL0en2ru6W19FhJx6E1grqlY5FSPgLR+th5DK7G5O04g5GjVAVjM9ZjLK5k5/1fUfZ7Y9eCyAE9GPjJg9QVVPDjqEeoyy8nND2escueZMvCX/jztaV+2S9XlO7N5Z1RDzBg6mgueuZGzrxxPEseeoeSA+1rdTXw0rM4f+a1vDb9Zf75xX3ur9VsJnv3YbJ3N43ySsjlcrqekEq3kzLo2iOFxG7J9Dgxg/DocIKliK9GjdFgRFumpaywjIKcQgqyCygrbIj4lhSUUl7UkJrgDUlpidzy2M2cOqwvujq926isr+zZuZ9H75kNNBQvXTzlfCZcNI5LrrwAdYiaTev/4afvV/PH6nV+6czlLSajiQqjiQqHfFRnZsy6j3MnjWHlT7/yvwdnU1pabn8tNDSE5OREkrskknS05Wy3bqmcckpvxo0bRUJCHBGR4UfTIvTodHqqq2spKSkjLzefQ1lH2LvnADt27HYZ9TUajbw67x2eefp/bN++i3V//oDFYmHAgFP49PO3+PjjxVxz9R0cOeJdxFipVPLForfp3/8U+vYdZReqEyaM4f77b+fUU3pTXlHJgo8W8eUXS8nL8y7F56OPXyMvt4Dnn3kVgCdmPsDZo4fbAz2e3A+OxfSD7du3YzAYUCqV9O/fn+nTp5Oenk5CQkKTZSXRO2DAADIzM6mrq8NgMKDVavnrr7+QAx0h7NERxtBeHDei1jHdwLkYzNGayhfxFohIrSQkdTpdq4RkawW3FLHWaDR+6Zbma1GdPwW1KzwdG8kqrKqqymP6SSDH4A1KpZIgmwyZXE7pz1s48PISqndkN1mu99PXkDplNLte/55dr32HzWojJDmGc5fPZsc3f/LbC4taNQ5v+efTX9i2+A8umHsbdyx7ms1f/s7PLy3GWNv2+WiDrhjFhCeuZt7tc9j2m3cuD56wWq3k7j1C7l731ehyuZwuPbqS3ieDrj1TSEpPJmPMMMKiw1CHauypDiaTCW1ZFaUFpRTlFlGQXdAQ7T0qegedPZAJUyfYo7J3XPMAm9Z7F5X1FZPJxBcfLeGLj5YAcELvHky58VKm3XU9Tz73MKUlZaxa/ju/rPyDzRu2Ut+G7X0dOeOsIbz0xiz0egOXT76JDes3N1mmrk7HwYOHOXjQ88NJfHwsyUdFb1KXRFJSkunWPY3zJ57DzTdNbRr1rW2I+uYXFFFaWk63bqls/Wc1FouV/PxCXnn5bb7++nufmj6oVCq++vo9evc+gb59z6Z79zTef/8+hg07DZDxxeff8MB9T7BzR1NLPE/ccecNDSK5z0gAFnz6OhMnnYPNZrMLNk/pB8eaqK2rq+Ovv/4CYMiQIbzyyisui5+lY1Jb2zDrcNFFFzFp0iT763l5eYwePbptBi3wyHEhaj15z0qdsLy1pnLEn9P80FRIeptu4GlsLUGKjnobsfYGX4rqJJeH4OBgMjIyWnUcXOHp2EhWYTKZLOB2Xd4s426carUaudlG3uLfyXr9e/S5TfPs1MkxDP7mcWRqFasmP03Fvw038+DYcM79+Wn2rtzEz0990rod8RGrycy3d8wntkdXLn7nbvpdeAbfz/yEbd/+2WZjGHLVaM57bApzp73A9j+2ttl2rVYreftzydvv2ptUIjmzK936dCftxG6cMrwvIyYMB8CGDWyAXIZCLkevN3Byvz7MfPl/VGmrKSksJS8nn+xDuRzcd4i9uw6g1xn8ug/79xzkyQeeAxoeqi68fDyTLh3PBZecR2hYKP9s3M7yZav4ffU6CvL84xvsiYioCN795BVO6tubOc+/zttvLPA6PcIVDR0aSykuLnVrARYVFcGoMWcyctSZDBh4Kl1TkomLj6HXiT1Qq4OxWCwEBalQKq0kJMTx6GP3Mm3atRzOzmHXrr1s2rSdDeu3uPU4Dw4O5ptvP+SEE3rw229/sn37r0RGhPPDD6u4esodrPtzY4uCKf37n8Ljj9/HFZfcgk6n45e139K370nYbDa7WJOOgbtI7bGWflBdXc2mTZtITEzkgQceIDIyErPZ7Pa6L6WmSMffbDY3FI462oB1gKn/9mzD3t4c86LWU7pBWVkZZWVlHjtheUKK+LqzQPGWlqQ+NEdLosiORWn+jo56G6mVmkp44/LQmrG4QqfTkZOT02q7Lm+RLoSSTZhCoSA0NJSQkBCPNw+NSoXMbGXbbfMp/qlpRAog7bqx9Hp8Cjk/bmTTjI+xHPWMVUWGMP7X5zi0dgc/PvKB/3fKS8oP5vPu6Ifoe/lIzn/yGs684Vy+fvAdivZ6FnytZejVYxj3v6t45dbn+XfNtoBuyxdUIWoGjj6NU8/qT/eTM4iKjyY0Mgy5Qo7Z1CDSrDYr1dU17Pl3H2mZqdww9U4SkxJITk4kMTme1PQUep7UkxFjzyQuLoaIyHBMRx0GDHojdbV1VFZoKS4oISc7n8MHs9m/5xBZB7JbJATNZjNff7aMrz9bBkD3HulMvelybrptKo/Ovp/KCi2rf/qd1Sv+YOP6fzC5KFhqDfc8PI0bpk3lzz//ZsiAcRQVNt/0w1u6Z6Qz5PSB9O3XhxNOyCS5SxKRkeGEhoUSHBxMaUkZ2UdyWb9hM/v2HmLixLH0H3AK69ZtxGAwYjSauOGGe+jePY2MjHQyMtLp0+cExo0bxS23XENsbDQ6nYHa2jq02iry8grYu+cAO3ft5d57b6Vrl2RUwSqSkxJ56IFZrPjpF5cFX94SERHOoq/e5eOPvuSvdRvZuW8tScmJTQQteM6p9Uc3sUOHDnH33XdTUVHBrFmzGDNmTKvX2VLKy8s5cuQIo0aNonfv3m4FraQfKisbUl+kZRQKRSNdIQrF2p9jVtR68p6tr68nLy8Pm83ml0r61lb1FxQUYDAY/CokfR2XY3S0tVHiloynrab8XY3F21a/gRhDeXk5JSUlJCUlIZPJ0Ol0lJaWUl9fj0qlwmKxYDKZCAoKQiaTEaJQYLPA3lmfuRS0crWKQV/OILxPGuumv0n+z/9NSyvD1Iz/7Xlytxxg2b1vQRvZ0Xli+5e/s2PJGs5/eRq3fTuLrd+sZcULizBUt6xYxxOnX3sO5zx8BS/f9Cw717nvlBZoQiJCGXTuEE45sx/pvbsRERdFSHgI2pJKsv49yIZl6+gz7GTS+nRHLpfzwyc/oFAqGH/NBG6YfAclRWV8/+cipl53GU888pzb7cjlcmJio0lKTiApOYHEpAS6dE0iLT2F087oz4SLzyEuLgZNiMYufPV6PbU1dZSXVFCYX0Rudh6HDmSzd+d+8nM9R14PHzzC7EdetG/7/EvO44LLxjP+gnMIDw9l25YdLF+2mj9+WUdOK5wIBg7uy7x3n0Mmk3Ht1Dv447e/fF6HUqmk/4BTGDS4Hyed0puMzHTi42MJjwgjLCwUq9VKfn4Rhw4d4Z+tOznw1TIOZ+WQlXWEgoIi+wP6tddezqzZD6HVVnPxJTfw22/reO21Z0lOSqCuTsfOnXvZubNpioBSqSQtrSsZGWl065ZOr16ZXHb5BdwQfhUKuYK/N2zh2qunU1nZuvxoiXfff5nKCi2Pz3iOnKLthIRoXApawD6j6YxerycuLq7VY3nzzTc5cKDBZ3rmzJntImolkSpda/v37w+4D3hIf4+IiGDQoEEkJSW12VgFvnFMilpP6QY1NTXk5+f7LRrXmrxaqao/NDTUL3mrLR1XIAuiJDyJ2rbq0OVqLA03r/wWee+2BmkGobKykszMTHskOyQkhLi4OCwWC1qtFq1WS15eHkqlkl7p6dhscnIW/MyRj35uss7YESfT79270e7N4/vhD2Io/e+GKFerGP/r8xTuzeWbO+Zjs7a/oJWwmq18d/ebRHdP5JJ37uWhP1/lh1mfsnVJ89Xh3jLshnMZ+8BlvHTTs+xqQ0EbFR/FoPOGcfKwU0g5IZWI2EjUoRrK8ks5tP0AqxauIHtnFjl7skk9MZ0rZ1zLBXdeQva+bOb/bz5/r/6bAWcN4JE3HuG2q+4j+1BDo4jbp97Ppz+8y8rlv7Juzd8ut221WikrLaestNxj69ugoCDiE+NISoonKTmRxKR4uqQkk56ewtnnncUV119MdEw0QUFKdDr9fw0YqmopLSknP6eAI1m5HNx/mL279lNZrsVqtfLd4h/5bvGPAKSmd2XqTZdz7c1X8MiTd1NdVcMvK9ew6qff2bBus1fFcaFhIbz50RwGDunP/Hnv8eor72DyYKMWFRXB0GGnMWDAqZzYpyepaV2JjokiLCyMsLAQaqprycnNZ//+LJYv/4WsrCMczs7hcNYRKiq0HscybNgg3n3vJSIjI3j4kadZuPArn+4DZrOZrKwjZGUdoWvXg9x669UEBwezds0GTjrpRE45tQ8/rvicC86/htKS8uZX6IEbbryKYWcM4rRTR1NcuQeFQoHVanWb/mCz2TwWii1evJiamhqgYWZNorCwkA8++G/2Z8SIEfTs2dPl+l397kxtbS1ffvml/d87d/6XDrJ169ZG27r88svtnT59oby8vCHXvUsXoHlRe9ppp7Fw4cImf7f/u4O4H3SEMbQXx5yobTD3du09W1JSglarbdTqtrW0RNQ6Rgb9WdXviDeRWseWu9564Pp7PLW1teTl5RETE0N8fHyb5AJJY2kvuy6TyURBQUOlsrRd5+5BCoWCkJAQ6urqGiLXMjlWmYKSVVvYO+uzJus8df7tJE0cwrbnvmTfB40Fb/yQXoz85H5kQQqse8yMuO9iSvbkkL/1IFV5ZYHbUR+pPFzMe+c8wikXD2f841PsKQkFu7Jbtd4zbxrP6PsuYc4NT7N7fWBapQIkpCYy6LzT6TP0JLpkphAeE0GwWkXRkSIObt3PD+9+R/bOLPL259hTCuRyORNvvZDpr99HeHQEvyz5hbkPzyPvUEMkM61nGg/Nf5inH5nD5vX/5f/u23WAec++xbsL5jLk1DEtakwgUV9fT0FeYbM5sJoQDUlJ8SQmJZB4NPqbmtqF1PQU+g/pS0JiHFHRkVitNvQ6PQaDEX2dDm1lNcWFJeTnFvDhG5+SdSCbtO4pTJx8Li/Of4qIyAh2bNvNT8tW8fvqPzl8VLg7csv0a7njvpv4Z8u/nDlkAjlHHQS8SRM4nJ3D3r0H+P2P9WQdPsLhrCNkZ+f6VLglkZralU8Wvs7JJ/di7rx3mTPnjVa1Fp49+xFuu+1avl36E6NGX8x1115OQkI8Q4ecx7xXZ7P939949tlXef21lqUK9TmpF888N4MbrrmLA0c2IZPJsFgsbm3LbDZbszm1b7/9Nvn5TZ1LcnNzefHFF+3/jo6Odilqb7/9dvbu3UtlZSVPPPGE27FrtdpG63Nk3bp1rFu3zv7vcePGteieXltbi0ql8imtwlMNjYyO4Txw/EraY0jUevKelVrdKpXKJq1uW4uvotbRaSGQkcHmclhNJhM5OTnNttz153icn9DLysooLy/360OGt+j1ekpLSwManXZFTU0NeXl5REdHU11d3ayQjoyMJEShxIaM6u1ZbL/9jUavh2QkM+irGVhMZlaMf4Kq/f/dbGL7ZzD0pZsI7ZZI2d5cDv64kajuSaQPPIGTJw0jND4SmVyGSWfEVGfAUFVHdWEFFVmFlOzNofDfLEr3t73t1o4la9nx7TomzrmZW79+ku3fr+enZz5DX+U6suSJ4bdM5Oy7L+LF62az5+9dfhtjygmpDDr3dE4c3IekbsmER4WjUCkpPJjP/n/28vcPf3F4ZxYFh/KwWpp+D+NTE7n6yRvoM/RkKksr+fy1L/h96e8Y9f8JrbCIMJ7/6gUWffQ1333Z1EP4s/cWM/zs0/lq2QLOO/syv+2bO/Q6PYezcjic1VR0OhIZGUFickPUNykpgcTkeNK7pXKCm3xfbaWWXr17cGr/Pjz85N0YdAY2rNvMih9/pSC/kJdff5quqcns3LGHkFAN3yxbcDRNIAyr1fJfmsA292kCrUWtVvPeey9x7nlns/S7FVxy6Y0UFbXczqxfv5NZvPhdZHI5ky64hjVrG3s3V1VVc/11dzNu3Ejee38uU6ZezIXnX+uy8YI7QkI0fPX1+3zz9Y98ueR9oOH6U1hYSGhoKBqNpknnMOfaE0f0ej2hoaH8+uuvLdjj/+jRowfLlzfviZ2SksK+fftatS1vCAoKOuox6x2e7hUip7b9OSZEradWt1qtlsLCQretbluLL7mrrXFa8BVPbgNtUYzljONxcu4O5qolY6Cw2WzodDqMRiPdunVrM4sam81GaWkpFRUVpKWloVAo7FN47ggNCSEuPBxLZRVGnYVNV73wXyMFIPPuC8i85yIOfv47W59ehPVo9C+qTxqnz72FiB7J2IDKgwV8c8VzmPVNI1PBkSGEd40jomscEanxRHZLJKlXKieMGUBoQhQKlZJ6nZF6nRFDdR3VRZVUHimmZG8uRTsOU7w7G6s5AA1IrFZ+uP8d/pz3DZe825CSsPzZz9m86Devv29n3TaJkdMv4PlrZ7Nvk+v2o96Q0bcnp50zmF6n9SY+NZHwqHBkMsjbn8u+zXv448tfOLwzi+LswmbHNvzikUy6/WLiUuLZuHojj055lH3bmt645XI5ry5/lS0btjL36Tfdru+haU/w/boveXDGdOY8+3qL99GfVFVVU1VVzf69TdsVS8jlcmLjYkhMirfn/CZ3SSQtPYWuqV3odVJPRo4djtViwQZUV9eQmtq14TqCjcrKKnbt3Ef2kVyKikooyC/iyJE8srNzyMrKaZUDgjNPPHk/06Zdy65d+xg+/AJ27HSfygEgl8ncpqvL5XI+/HAekyaNY/7r7zNr9lyMRvcR45Urf+eUk89i7rxZbN3+C889+xrzX3vfq3G//ubzmM0Wrr72UqChbsJkMqHRaKitraWkpMQ+IyT9gOdC2mPF0ksS70FBQRgMhkZpFILOTacWtc6tbh1FoqPfayCn1r2J1EoFQaWlpXTp0sWlD56/cSW2G+xqiqmurg54MZar8VitVvR6PTk5OURERPilO5gvSHZdZrOZmJiYNtt/VyLeYDB4FEBqhQK5qR7jzr3IM3qw4cKH7W1ulREhDP7mcTRd4/j92lcoXtcg2CJ6dmHYq7cS2SuFI5//jiJIQb0Mllz+rEtBC2Cs0mGsyqFst+voW1BIMOEpDaI3vGsckd0Sic1MpvvQ3oQlxRAUEky9vkH0Gmt01JRWUXmkmLL9+RTuyKLw38OYDS2v2tbmlvL+eTPoc/5Qxs28ljOuP5evH3ibvH+zPL5v1PQLGHHbJJ67Zib7N3vv5dl76MkMHDOIngN6EdsljvCocMxmCzl7s9m3aQ8rP/qRwzsPUZbnfcQsLCqMq2Zcy4Cxg7BYrHz7/rf8vOhnqivd30hf+OoFtFXVPDjN/fQsQHVVDXdf9zDvffUaq1f+wdYtO7weV3titVopLSmjtKTMZb7vTdOu5qHH7uLaq6ezbdtOYmKiiY2NJiYmmpiYqAZBnBBHYlICw04fRGxsNFFRkUREhqPRNHj9Go3SjxG93kBNTS2VlVWUlVVQWFhMYUExubn5HD58hEOHcppMyV922SSef+FxdDo9U6bezs8//+7DHjb9bo8fP4Z33plDQUERQ4eNZ/fu/V6tqaqqmhuuv4dzzhnJ+x/M5aqpk5uN2l551WTOPe9swsIaptX1ej1msxmVSoVKpSIqKsqegqXT6aiqqqKoqIigoCBsNht1dXVoNJpG12eDwUBISAhms5lvvvmGZcuWcejQIXQ6HYmJiQwbNowpU6a4TDloKZs3b+brr7/mn3/+obS0YX8TExM588wzufLKK8nMzGzReiXhnpKSYp899QfC0qv96bSi1mazUV9fj8Vicdvq1h9+r83RnKg1m83k5+fbBU1rnBZaMy7HFIy2KMZyhclkIjs7u82EvSNSlDwyMrJNxbzBYCAnJ6dJi19PFx2NXI6tpAzd+k2oJ5zHX+c+iulo0VfixMGc8sqtlGzcx6rLn8ekrSOsWyLDXptGzElp5H79J5uvfZkBb9+FNVjJ15OewtSK5gb1OiMV+/OpcJOGoAgOIjw5pkH4psQTkRZPTGYyKRcP58zpFxAcEYLZaKK+zoixTk9tWTVVOSWUHsinePcRCrYe9MrpYPf3G9j940bOe+Z6bl70ODtXbOTH2Z+iq2wa7T777smcecsEnr36KQ5scT19KVcqOXVEX/qPGkhm357EJMUSFhWOoU7PkT3Z7Fizjax/D3F45yG0Je47WHnilOH9uOyhKaT0TGXv1r28dM/LbPljS7PR3Lvn3E18agIXn321VzZY2zbv4P3XPuHjRW9y2kmjMZn8a53V1txxz03c/cCtXHbJTaxd0zAtX1Lsfe63XC4nKiqCGCcRHBMT1dBYITmRfn1PYvTZw4mOiSIyIpzQsBAsFgsGgxGL2UJoWCg2m5UDBw5z/wNP8FsLHBYkwsLCWLLkAwYOPJUZjz7LW29/3KICyJ9/Phq1nTuLrf/+2hC1ffW9Jsv16Nmdua/OJiSkIZDjbkZIJpOhVqtRq9XExMQcbWtcQ2lpKeXl5faagzVr1nDaaaeh1+upr69nypQpbNu2jaioKCZOnEhUVBRbtmzhiy++YMmSJcyYMYMrr7zS5/1zRK/X89hjj/HDDz8AcOaZZzJp0iTMZjPr169n4cKFLFq0iIceeohrrrnG5/VL19+MjAzS0tL46aefmDRpEomJiW5zir1BdBRrfzqlqPXkPSsVYCUlJREdHR3wsXjKXZWEVHtEJR0jtVK6QaBSMJrDarVSUVGByWSiR48ebeYwAI09gCW7rtLSUp9yqFqKdNxdnYvOkXTpISRELqd+xx50v64h4p7b2XjpM9QdKgS5nAEf3kvsiFPY9OjHHF68ltCUWEZ8eC+xfbtT8N0GVt/yKoaCCoYueoTg1FgWnf8kxhbkofqCxViPNrsYbbZrj1C5UkFoUnRDpDcljsjUeKIzk+lz7iCG3HAumphwLCYz9ToDxjoDuooaqvLKKDtYQPHubPK3HqKuVNuwMquVn/73AeteX9rgkrB2HiteWMTfn622uzmMufcSht14Hs9OeZKDWxsiYSq1iv5nn0bfkf3pfnImUQkxhEWFUVtZQ/auLDat2MDhHYfI3nWYmorWTUMqVUouvudyzrx4FOpQNSs+X8HsaU9Tkudd/uVFt1zEGePP5Ipx11NZrvV6u+/OW8CwkUNY9O17TJ5wbQtH3/7c/8gd3HLHtVx0wXUuu4J5Q8P1RnvUwcB99zBn7nvgNu6YfgMREWHIZDJefvltBg3qzxefv4NGo6GsrILDh4/w+x9/sXjxMvbvd59eITFt2rXMnPkgGzdu5aRTziI/v3UNKaqqqrnhBilq+wpXTZnMhedfY4/aqtXBrFy1uFlB6wq5XE5wcDBBQUGkpaVhtVoxGAyUl5czZ84cDAYDjz/+OPX19SQnJ7Nw4UJSU1Pt7//000+ZPXs2M2fOJCoqivPOO69F+2i1Wrnnnnv4/fffUSqVzJ07l3POOcf++j333MMHH3zAiy++yDPPPENYWBiTJ09u0XZSU1Pp06cP33//Pd9++y3Tpk1DLpd7bMDgCn+5tAhaj8zWiT4NT8VgZrOZgoICTCYTqampbSac8vPz0Wg0xMTENBpnaxs7tJaCggJUKhVms5mqqipSUlL8YpztK9LTvpSM39Lpopbg2Go3LS3Nfk6UlZXZL8yBwNFzNzU11WVk2GQycfjwYXr16mUfa7DNRt33K9D//hcxLz/NttvmU7JiC+End+O0zx/BUFbFmhvnYTaaGfbaNOJP60HhT5vZ89yX6HMbIlmDPryXiAE9WHT+49QVawOyf35FJiM0IbIhrzclnoiUOKIzk4nqlkR411hC4iKxWa3UHy1m02lrqMovpyKrEFWomj4XnE5teQ1LHnyHXmf354wbz2Plxz8SkxhDep/uRMZFERIRaveA3bdpD9m7sjiy+zA6P3rhpp6YxtTHbqDHgBMozC7k63e+5s/lf9pdDrxh0NmDeOTN/3H7lPvY9JfvbW9j42NY9uciXnv5Hd5+fYHP729v/vfkvVx74xVcMPFqNm/e3ibbVCqVPPHUA0y9+hJMJhMymZzk5AS2bdvJoMHj7Mt16ZLEaaf1ZeiQgYw463ROObnBqL+srJzdu/fz86o/+Prr7ykrq+D1+c+RmdmNpKONMW6Z9gBLl/7k1XjuufsWrrziIkYMn9TsshER4cybN5sJE8fywnPzeXXeu2zcvIITe58A+CZoJXQ6HeXl5Y3EKjTUpjj6ySqVSmw2G/3792f+/Pn2+9/NN9/MmjVriIqKYvXq1YSHh/s8hq+//ppHH30UgKuvvprHHnvM5XI33XQTa9euJTw8nJ9//rnRPdgbpKDY6tWreeyxx6itreXmm2/mzjvvbBSAkgIgjnrDOUAltck90ZiBytY2s7GeMMlM7A3O4pdffiElJaW9h9OmdJpIrSfv2bq6OvLy8oiIiAh4AZYzztP8ZrOZvLw8u4Brq3QDZ6xWK+Xl5fZmCu2RbuDofxscHExRUVGbbdu5mYTzORGoZznp85cae7g77o6RWrlcTpDVhnb+uxg3bSV+wZvsnfU5JSu20OvxK0m/4Vz2vLOcA5/8wtBXbiZh6IkUr97G76Meoc4hQtr/jduJGnwCi85/onMIWgCbjbpiLXXFWor+OehyEU1M+H95vSlxRGckkdqvBxEpcajUwcSmhXDj5zMw11tQKBUMOfd0Dm0/yOpPV9o9YI1ucopby7jrJjDuhglEJ8Sw5oc1vD35XQ7v8T46KJHaI5WHXn+YZx6Z0yJBC1BeWsF9N81g/sdz+HX1n+zf6/p4dkSeevYRLr/qQsafeyXbt/nPpcIdERFhvPTKTMZPGENebgF3TZ/BeeNHc8GF52KxWLj7nsZCqqCgiGXLili2bCXQ8P3t2TODQYP6ceYZQ7ht2nW8NOcpampqUSqVaDRqsrNzGH7WBezbF5jPobq6hhtuuIexY89i4aev8+jj96BWq902VfAGd1PvVVX/eV7369ePjz/+mK1bt7Jnz55GDYOuvvpq1qxZg1ar5eOPP2b69Ok+j+Hjjz+2/37ZZe5dPa688krWrl1LTU0NH3/8Mffee69P25GuwWPGjGHlypV8//33fPLJJ+zatYsxY8YwZMgQ0tPT3aYvWq1WdDodJpPJ7pkr6yDuBx0hr7e96BSiVorOuko3kCrKu3Tp0i4RUUdRK7U7jYqKIjExsd2StWtqaqiqqiIkJIT09PR2STeQCtKkIj29Xt9mUzTNuTsE6nhIRXCRkZFef/5yuRxFfT3lj8zCtGc/CYsXcGTBaop++Jsz176MMiKENTfNo+d1Y5i07mVK1+7kj7GPUnuwoNF6Tn3pJuLP7seXk56gJr91Zu0dDX1FDfqKGkr+bRCLmthwBtwyntCkhpQOq9VKXVUd8+98hYNb9/kUHW0J0YkxTH38ek4Z0Q9drY5v3vmG1UtWo6tpWeQ3LCKMF75+kUULlrD0yx9bNba/125m0Udf8+W37zPwpLP9ZmkVSF6Y+yQTLxzHOWMvY/euwFo4pad3Zd78Zxg69DT+2fIvl11yE3+t28Sjj93LpAvG8cUX3zJu3Ej++muTx/XYbDb27z/E/v2H+OyzJQCoVCrmzp3FVVdO5ptvf6R/v5PZumUVer2Bysoqso/k8vfGf/h55e+s/fPvFn02J57Yg/vuu40xY0cQGxtNXZ0OhUJh74LWGkEL7ruJrV271v77yJEjUavVnH766Zx++umNlhs2bBhqtRqDwcAPP/zgs6gtLy9n//6GtKGQkBCPRWdSFzCAH3/80WdRC//dC2bMmMGBAwfYu3cva9as4d9//6Vnz56kp6eTlpZGTEwMkZGRBAcHo1ar0el05Ofn888///DLL7+g1zfULYic2vanQ4tayX5Jq9USGxvrstUt0Oa2UI5IZtYlJSVUVFTQtWvXFk25+AObzUZJSQmVlZVERkbaW6u2Jc6ewNJTbmvbCXuD4/57cncIxFgk6zhvi+BkMhndU1OR19RScvuD1OfmkrjkU0r/2EndoQLO2jCPwrU7kSkUjHjvbsr/3sea8U9Qsze3ybpOmjmVLucP4cuLZlJ1pOXemR2ZmJ5dGDhtIilnnERIbATFu7LZv+ofTrn8LI7szWbuzc9TVx3Y/OFB5w7l4nsvJ7FbMtvXbWf2zbPZsaF1bgNyuZx5y19ly4ZtzPNg3eULrz77NkNHDOLjL9/k6kun+WWdgWLeW88x+pzhjDn7Evbvaz5HtaUMHNiXl+bOpE+fE1j+42rOHjmZPUfdB2648Sqm33UjE8ZPYdGX7zBr1sst2sbll01iylUXM+mCa/hjzXqg4fPt2bM7p556Ev37nczpQ0/jxhuuIjwsDK22iuKSMnbt3Mvvf/zFDz+usq8rISGO++6fxsSJ55CW1pW6Ot3Rwq5gigpL2PrPDjZv3s7uXftISorn6WdnoNGoWyVowX03sY0bN9p/P+mkk9y+X6lU0rt3b7Zu3crhw4fJzs6mW7duXm+/sPC/nOO4uDiP96+YmBiCg4Pts3KFhYUtTimLjo7m1VdfZcaMGWzZsgWtVsumTZvYtMnzw41EW9zfBN7RYUWt5D1rMpnQarWNek5XV1dTUFDQpl2o3GGz2aiuriYoKKhdxbWjyO/RoweVlZVtUgzliNQdLDY2tskFKdBfesdp/+YabPhzLDabjcLCQmpra+nevXujqThPqAFrZRVFdzyItbyShM/fpy63AlVCFH2euZ7avDK6jDiFii0H+POCmVTtPOJyPb0fuYy0q0bx1SWzqXSK3nZ20oafTN8bxpHYNwNVqIYjf+3it+cWcej37fQY3Z9znrmOVQtXsOiFT7EFKCKpDlNz2YNTGTpxGAqFkmULlrH8s+VUttARwZnnFz9PVVUND0573G/npMVi4a5rH2Lpmi+Yet2lfLrgK7+s19+89eHLnH7mIM4+azJZWa7P79Yy4fyxzJr9MF27JrPwk8VMvfK2RsVaE84fyzPPzeDKK24lMSkepVLJe+9/6vt2Joxh/vznmDL1drughYb72L59h9i37xBffbXM/vfo6ChOPaU3p5zSm6FDBnL/fdOY/9qzAMhksP/ABsrKytm75wBfL/6eXbv2snv3fg4dzG7kwXvhReN5+tkZqNXBrRa00nhdidrs7Gz772lpaR7XkZqaytatDd3v9u/f75Oodeys6I1rkUqlsvv87t+/v1V1Eunp6Tz//PMsWbKEL774olHKhSOO9w/JQeKUU07h77//Fm1yOwAdTtQ6e89Kfaqh8bR2ampquxQ+OVJbW0t5eTkqlYru3bu3m7iWxGR0dDQJCQnIZDKXrVcDhWMaiLvuYM11OGsNLZn294eAqK+vJzc3F4VC4ZN1XJDZjHHrDsofmYXNaCT29TkokpMJiTOjigrFojdirqhm3V1vod3m3o+1510X0O2mcSy54lnK9nju8tQpkMvpc+mZnHTFSGJ6dMVms3Hg5y1svPdtcjbswXI0reDc526g9wXDeOu+V9m0YkMzK20ZPQf24soZ19KtT3cO7z3M/P+9zt+r/3bZHayl3P3i3SSmJzF51FSvrLt8oaighEfueIoX3pzJ2t/Wc+RoW9mOwoefvU6/ASczasSF5OT4v2vdLdOu4d77biUsLJT5r73Pu29/glbb2Nli8JD+vP/BK9w5fQa//LKWP//8ni8Wfevzts48czCfLnyTO6Y/0ija6onKSi1/rFnPH2vW8/obH3Lhheex4MNX0WjU5OYWMHjgORibOSduunkqs595hOBgFXV1/pmlcJV+IBW+SiQkJHhch+PrWVme/aSdcXSJaa4hgpTTKuEY5W0pqampTJs2jSFDhrBp0ya2b99OXl4eNTU16PV6FAoFCoWC4OBggoODycjI4JprriE9PZ3Ro0eLjmIdgA4naoFG7gZSzqo0xSBFRNuj8EnCcZo7JiaG+vr6dhG0nsRkW02HSBFSq9XqMVIdqPFUVFRQXFzsk/etP8ai0+nIyclp9CDhzXaVZgt1S5ejffUdsNmIfuwBNIP6NVhSyaByy0F2PvUplZsPeFxXxs3n0vOeC/h26gv2XNPOSFC4hv43jKPnxCFEpMajr6xl97L1/DzzUwr/PYxjayalWsXUb54gOCacxy94kPwD/hVqcrmc82+fzNlTziEsMoxflvzCyw+8Qn6W/0XXRTdfxBkTzuTKc2/wybrLF35fuZYfvv6Jr35YwOBTxjT/hjbisyXv0LNXJiNHXNhqiytHFAoFTzx5P1dfexn1pnqef+41Pv9siUtxmNmjO98sXcDs2XP58sul9Ot/Mj1PyGDEyAt92uapp/Zh2XcLeezx5/n0aG6tL6jVar779iOGDx+KSqUiJyefgoKiZgXtIzPu4u57biEoSNmkaURrcJV+oNPpGjkANOfz7fi6u2inO9LS0ggPD6empoby8nLKy8uJjY11uezhw4cbzUb6Q9jbbLZG+cI5OTnk5+dTVlZGZWWlPTLbpUsX+vbta7/nSrOksqM/7U1HGEN70eFErSRkHSvDLRYLWVlZbdrW1R1SdE4mk5GZmYler6ey0j9Tkb4gdceSquydxWQgI6MSjg0NmouQemrb2xIc7boyMjJ8snBrzfnjyvfWG+RyOQqLBe3ct6hb2lAMFHnHjWjOHYNFb6L2UCE7n1xI+frmu1+lTRnFif+7nGU3vExhM+K3IxKeGsfAWyeSPvIUwhJjKD9UwL9fr2X/yi1UHnHtdxt3QleuWDSDI3uOMO+KR/1qx5WYnszUJ66n95A+VJZq+WzuZ/yx7I+AOSacNuo0pt4/ldun3s/hg4GZdpd4/vF5LDljIG9/9DLTrr8/oNvyhiU/LKBLSjIjR1xIcZH3Xdk8ERERxpyXnmL8xDEUFhRzz12P8cP3P7u9/sUnxPLLr1/z0UeL7C1nH3roDtasWY/BYPB6u927p/PL6q+ZO+9dXn/jQ5/HPfmi8bz91hzCw0MJCgpi27ad/PbLn/Trf7Lb98hkMl565SmuvGoyCoXcp/F6g9VqbXIvcRTN3rj5OF6LfRWacrmcsWPH8s033wCwYsUKpkyZ4nLZVasaR8X90XREujdIaRhpaWke0y2k4nVBx6HDiVr4L5JmsVgoKCjAZrMFtNWtt9TU1JCfn98ol7e5dqeBwBuXBX+LSEccm1x4K+z8Gak1mUzk5OTYp3987RjX0rG0VEjLZTIUpnrKHnoS48YGu6a49+ahOrEXdVmF7HziU0rX7vRqXV0vPoOTZ1/Dj9NeJe+v3T7vQ3uR1L8H/W85jy6nnYA6KozczftYN/87Dv6yDV2552nGUy4ZzphZ17BywY8snvO5386jEZeezaTbJhPbNY6/V/3No1MeY9+2wFbfp/RI4eE3HuGZ/73MpnUts+7yhXpTPXdMfYAlv37CpMnnsewb7/xSA8F3P39GTEw0I8+6iLLS1jt0pKZ2Yd78pxk2bDBb/9nBFZfdwro/N3p8T0hICH/+9QM/r/qDGf97BoDkLomcc84oTjp5hNfbTkiI4691P/DpZ0uYNdu3wjK1Ws13SxcwZPAAdDo9QUFBlJaWMfbsS5n9zMNuo7RKpZIPP5rHmHPOQi6XBaRzXGu6aUm09v3Tpk1jxYoV6HQ63nrrLcaMGUNiYmKjZXJzc/nww8YPEv7sFCntg81mc3m9cdcZUoYMeQcQuSKntgOi1+vJzc0lNDQUmUzWbn6v8F9OkVarbZLL21ybXH+Po6ysjPLy8mZdFgI13S89aBiNRp+Enb/GU1NTQ15eXqu6o7VkLJKrQ1BQkE9CWmm1ga6O4tsewHz4CPKICOLfexllcle0O7NZO/Epr8eQdN5A+s65iZV3v8WR3//1afztQY8Jgzl16mhi+6ShCFJy6LftrHhsAdlrd1LvZRR0/Jyb6TVhMG/cPY8tqzwLFm8IiwpjymPX0X/0IMxmM0vfX8rKRSup0fpuVO8rIeEhvPj1HL78eAlLF/0Q8O1J5Gbn8dT9zzNn3kw2rNvkU8tZf7Hi969QqVWcPfKio52+Wk7/AafwytxZ9DmpFytW/MroURd7ZQUml8tZt+EHdu/ezy03/xe1nn7HDezff4jcXO/STMLCwti86Wd+XvU799z7uE9jv3jyBN5660V27tjDvn0HGTiwL3V1OiacNwWTyYRGo8FgaPrd0GjULP76fU4b1BegUbGYP3EVeXQUi94IacfocUvqXtLT05kzZw733XcfpaWlXH755dxxxx3069cPq9XK5s2befPNN5HL5Zx11ln88ccfAC5rOVqLsyd+cwhLr/anQ4rasrIyiouLSU5OJioqipqaGqxWq88ROX9gMpnIy8tDLpe7rKpvK1Hr2NQhIyOjWZEfiHEZDAZyc3MJCQkhIyOjRU/kLZ2uccwfTktLa1WRoK+iVirEi4uL80lIK81mLPmFlN75CNaKSkImnkP0g9OxIUeuCebIp795PYaEUacy4I07WP3w+xxa2bL2oYFGrlLS95ox9LroDKK6J1GvN7J3+Ub+mPcNeVsOYPOhyEoZouLqb55CGaHhsfMfpOBQ6/JaTxnRj8sfmkLXHqns+WcPc+6ewz9r/mmzWRa5XM5ry1/jn7+3M3e2f6y7fGH5tz8zYswwvvnxE848bXybbVcul/Pz2iVYrVbGjLqYqqqWPzycN340s595hJSULny68GuunnIHeXneO3789se3VFfXcNmlN9lzMTUaNTfeNIWLL7nBq3WoVCq2bf2Fbdt2cf0N93i9bbVazbLvPmbwoP7cd/+TXHP1pZxySh/MZjMP3PcU+442ytBo1E1EbWRkON//+Ckn9OqB2RzY4l9XkdqQkBD7/USy2fQUFXVMOWipd/yYMWNYvHgxr7zyCn/++WejrmJBQUGMHTuWBx98kAULFthF7fHWOUvgmg4papVKZaNuXG0ZDXVEMvGPi4tz65nXlrmrERERJCUleV2U5M8btuTDmpSU1KhC1VukJ96WiFpvi9F8wZtjY7PZKC8vp6yszK2rgzuCzGYMm7ZS8dgz2GwQ//Ycgk/pgw0ZsnorVoORnK/XNr8iIHZobwa+fw+/P7mQ/d+tb/4NbYgmLoKBt0yg+zkDCO8SS3V+Gbu+W8++nzZRtr9lhVzxvdO44vNHyNqZxauXvIi+Vt+i9ShVSi6570rOnDySYE0wK75Ywaxbn6Ykr+29fJ//8nmqa2p54NbH2s3PcuaDz7N0zRfMeW0mD971ZMC3p1QqWb3uW+rqdIw/90pqa1tWyHPTzVO574HbCA8P44357/PO259QWelbAdKSbz8kMiqC4Wee30g0TplyMVptFb/9ts6r9Wze/DN5eQVcfOmNXlsmXnLJ+bz1xvPs2LGHU04dyRdfvE1K1y7U1tay+uc1fO5QYKZWBzeKZCckxLFy1Zd0TUkOSLqBM65ErUwmIywszO5GUFJS4tGmq6Tkv+9XRkZGi8dy4okn8u6771JTU8P+/fupqakhIiKCE044wX4t1mq1jZZvb4SlV/vTIUVtdHR0owtGW4taR+swTyb+0tgCmbtaXl5OaWmpT0VJ0rj8ccysVitFRUXU1ta2Oq+5JUJbsuvyRdD7YxwWi4X8/HxMJpNXkXHHdSvNFmq/XkbVGx+gPmMIsbMexlp8BJteB6oQtEtWETx8EJib/3yi+mcw+LMH+euFL9n95R9ejSHQxPZKYcCtE0gZ1sfeCGHThys5sOofaooqWrXuvleO5OwnprL8vWUsmbuoRd+ttN7dmPr49WT260lBdgHvzX6PdSvWBbzTmDvuevEuErsFxrrLF/Q6A3dMvZ8vfvqAFT/8wi8/rwnYtlQqFb+u/47S0jImTbwanc63BxO5XM7jT9zHtdddjtls4YXnX+OzT5e4nJpvjtfffJ5T+57EGWdMbGTrJZPJeOjh6cx5ybvI+fq/fqTeVM/4iVO8EpghISF8t3QBg07rx733PcGCBYtYv3454WGhZGUdITExjptvuq/Re9TqYPv0fbduqaxcvZjY2Gi/F4S5w11HsfDwcLuozc3N9Shqc3P/axBzwgkntHpM4eHhDBw40OVrR440FFr26NHDa/ebQCLSD9qfDilqnWlLUevYEcsb67BAjc1isZCXl4fZbG4UtfYWf0RqHfNIffFh9deYKisrKSoq8smuy9txeMJoNJKTk4NGo/EpzUIul6MwW6icMx/d8lXEvvAkmmGDMP64AGW/4RAUQvGz7xE+fjjFvzXfiSq8dxqnL36Uja8tZfsC7/wvA0XaWafS7/pzSDi1O6pQNdnr/muEYPSTE8GEudPoec5A5t/xMlt/9T3FYtz1Exh3/USiEqJY8/0a3pz5Ntl7s/0ytpZy4U0XcuaE4Vx13o0Bs+7yhYN7s5jz5Gu8/u6LDO13DlVaz0V6LSEkRMOv67/jyJE8Jl94nU9CNCwslDkvP8XE88dSWFjCvfc8wffLVrb4GvvoY/dywYXnctaICyksaOyscc64kWg0at7wwrlgxU9fEBUdxdDTx1NX1/z5fuml5/Pm6y+wffsuTj7lLPLzC9m0cSUqVRBLl/7ELbdcTb9TRjV5X3BwMHqdgZNO6sWPK74gIiLMr5ZdzeGuo1h0dDT5+Q0pQDt37mT48OEu3282m9mzZw8A3bp1o3v37gEbq06nY/fuhmLZiRMnBmw7viAite1PhxS1zqKjrURtVVUVBQUFPhUhBWJsUnQyPDyc1NTUFuWutjYtwh8FWS0dk9VqpbCwEJ1O51OXLl/G4U5cSykniYmJREdHe73fCkBuMlF23+PY6uvpsuJLqKtE9+p9BI2ajLxrT+r+3ErVN6tIfOxWsu7/xOP6QjOTOOO7J/jn/Z/4P3tnHd7k+X7xT7Spu0BbnOEuA4YNZ8Bwd9kYG7DBgCEb7u4wBgx3d3d3dyjUW0q9aRr9/RESUuptKnx/O9fVq+2rT5L2fc97P+c+5/aKnGsqMkIopEynupTuXA+nYvn1WffHb3H9syAEc0BqI6Pn3okILCWMazmCYJ/06ySd8jnT48++lK1TgbiYOHb/vZvTu09nWrJgTlStX5WeI3ryS88RvHn5NreHY8SODXup06gWuw+vp9E3bc16bBsbK85cO8CL56/p2H5AuqfMvbzys3DxFL6p/TX37j2iW5efuHgha8Eahvjb5s278vJl0hCA0X8MZdeutP+3tm5ZSalSX1Ht62ZERqYue7CysuLA/vVUqVye34b9xYYNOxAKhdy9cwqtVseff85i48altGvdJ0kYBOi1twUKenH81A6sra148+YNVlZWWFlZ5UhPSUruB7a2tojFYtRqNefOnWPQoEHJ7n/lyhVjVblFixaZGkN8fDwnTpygSJEilCtXLsXtTp8+jVKpxMrKinbt2mXqXP/hfw95ktR+juwmtYYp9piYmDTlBp/DQJDM4VdnapWV1epkZmURpsESWW3I+hzpqdRm1mUgq+MwbUTL6N+AWKtFFxtHyKDfse3RCevvGqI8vQvV+X1I6rVGUuVbNB+iCRwxB8uqZdHEyIl7E5zi8Sy9XalzeDKPtp7l+oI9mX6dGYXU1pKKxiAEN+LDo3ly8BonJm4k6GHiIARzwb10QTpt/oNX91+y+Je5KOLSN8369Xe1aPtrJ9wLeXD34l0m95/Moxvps0XLCXgW9eSP5aOZMW4+Ny7dzu3hJMGYXyZy8PJ2xk8dyeQ/55jlmPYOdpy5sp979x7RveugdCUaVqhYlgULJ1OmbElOHD9L44YdePQwba/mtPBdy0bG+Nvbt+4nWV+2bEnKlC1B46adUj3O0iXTqV//G2rU+o6QkNR9dTt1/J5lS2dy794jyparR2BgsJ7Q3j1NgkJJ795DOH9+L3NmLePateT/JtzcXahcpTxisciYVhkdHU1ISAgSicRIcC0tLbNsnZUcUpIfqFQqKlSowO3bt7l37x4PHjygfPnySbbbuHEjAPb29vTp0yfJ+rCwMH755RfevHnD8OHD6dq1a5JtoqKiGDVqFJUqVWLbtm3JjjM+Pp5ly5YBMGjQoCSWX7kFAXlj6v//b532P1JrTCqTSqUUK1YsU56nmW2AMsXnGs6MhAmkNK6MklpDoAOQrNNDVpEW0Tb4AGfUZSCj+Py9MUg9NBpNhhvRJGo1at8AIuYtw3XpLIQiLfHLx6INeouo7NdIG3dBl6DCb9BktLFybBvWIPJpyg1UFm4O1D0+lecHr3Fp2tYsvc70wNbbhSo/taRgvfLYuDvy4VVAmkEI5kLF7g349s9uHFy5l72LdqS5vcxGRpc/elL9u1oIRUIO/HuAo5uPEvE+58NPUoPBumvHhr3s2XIwt4eTLGJj4hjSayT/7l3OscNnuHE1a8TbydmR05f3cvXqbfr0GpJmE1XTZt8ydfoYvL092bJ5N717DsbPL/0V+tRQvXol1qxZYIy/TQ6/j/iZq1dvpjq1P2nSSLp0aUudeq15+9Yvxe2srKw4dGAjlSqV5bff/mTDxp2AvlHu/r0zREfH0KpVT44d28bdOw9ZMH9lssd5538HBwd7tFotsbGxxihWR0dHdDod8fHxyOVyPnz4QEJCApaWlkaSa2FhYZbrZUryg/j4eOrXr49CoeDx48eMGTOGjRs34uTkZNxm06ZNXLig12lPmDAh2R6QDRs2cO/ePQCmTZtGmzZtUuzTuHv3Ljt27KBTp8QPHuHh4YwcORIfHx+aNm1K//79M/tyzY7/YnJzH/+vSa2hoz+rSWWG8WX2ydnUkzezVlkpjSm9MAQ6ZCT2NaNIiWibVkk/9wHOLhjGoVAo8PX1xcbGJsNSD4lag+LaLdQBQbgtm4Xq2jEUx7eARo3QswiyTr+iU6oJW74dxX29j6Zt45o8mLYz+eM52lDvzEzenLrD2XHrsvwaU4JHlWJUGvAd+asWR+Zgg/+tF1xavI9Xp+8SH579fq0A3y/+mSINK7Jo0Bzun0s9hOCrqiXpNrYXBUoXxueJD0tGL+H66etoM2ARllMQCoUsOryYezcfMH/y0tweTqp4dO8py+euYe2mxVQv1yjDzVwGuOdz48SF3Zw7c4kB/Yenet3p178bI0b9jJ2dLcuWrOHvlRuy7FtriqLFCrNn/zqmTlvI9u37kh+vuyutWjWhStWUo4OHDhnA0CE/0KhxR548eZHidp07t2bZkhncvfupOgv6Rrn7987w4UM4zZt3Y+7ciTg7O1K/TptkjxMW8RyJRIxGo0mWaBviaQ0zSBqNxkhyg4ODUavVxvVWVlaZ8nVPbcZRLpdjb2/PihUrGDx4MA8ePKB58+a0atUKBwcHbt26xdWrV5FIJIwZMyZF6YHp9T+lYANT/PXXXxw4cIBKlSphYWHB27dvOXv2LHK5nJ49ezJq1KhcsfpMCf/F5OY+8iSpzW5NrUGzGRcXZ5akssyOzzRy1eDJay6kVxZh6rDg5eWVaqCDucZkiqxUSbM6DoOGOqM2ZfqGMDVxx04iq1oRWdVyxK+djPbtx2lTGwdkAyai0wmIf/yKD6v0JFbi5Y7IwRb/PVeSHFNsZ0X9c7Pwu/aUkyNXm+V1mqJ4y68p16MhLqW8EUrEvD5zL8NBCOaA1NaSnvsmoJOIGfvd74S8S16GIRQKaT24Pd92bYy1vQ2ndp1izvD5BPhkza82uzFj+wxi4+IYMfCvXLPuygj+XbaJ2t/WYMf+tbRsnHQqOC14euXj2LmdHDlyml8G/ZFi+tK4v4bRp28XNBoNs2cuZdPGnZlyMkgNrm7OnD6rj79dvOifFLf7aVBvXr95y8uXPsmu796tPZMn/0HrNr25dTupdAH01dnDBzdSsWJZhg4dx6bNu4zrZDIZD+6fITAwhBYtutO+fUs6dGhFjWpNk71PRMa8QiAQoFKp0u1yIBKJsLGxMVpbqVQq5HK5sZIrFAoTkdz0ED9DYSa5+0V8fDxWVla4u7uzdetWdu/ezYEDBzh06BByuRw3Nzc6d+5Mjx49UnU86NmzJ9euXcPHx4dhw4YlK/NydXVl1apVXLt2jbt37+Lv78/9+/eRyWS4u7vTvn172rZtS6lSpdL1XmUGOp0u0WeVl4jzf0gdeZLUfg5zklpDgIBMJjNLRz9krinLkMylUCjMIjdIbkxpySIMkgeVSpUph4XMjMn0pmeoUNva2uLu7p4tGrGUoNFoCA4OzvBDjcHhIOH2fWxaNEb98Ary1WtB+fFmJBZjNXQOqJTo0BEweJpRi2pTtyrygA/w2d+K0ErKt+dnE/zAh2NDlplFuyqWSSnXsyEl2tT6FIRw+AbnF+zOcBCCueBRvgidNozk+e1nLBkynwR50hu4R+F89Bjfj5LVSvMh5AMb52/iwoELJJiZAGUHhs4aikeh/LRv0OOLGK8Bv/84joOXt/PriIEsmvt3uvcrVNibQ6e3s3vXQYb/Nj7Jehsba2bN+YvvWzcjJPg9I4ZPYP++Y9ky6yaTyfTxtyc+xd8mBwsLC376qTfdeyTf6NSiRSOWLZtJ954/c+580odPgK5d2rBk8XTu3HlImbJ1CQr6JNOxsrLiwf0z+Pj40bp1b0qUKMrixdP4of9wAgISP8DJZDJCwh4DehlcVnxoJRIJ9vb22Nvbo9PpUCqVyOXyDOlxU7tXGEgt6GUVnTt3pnPnzhkep5ubGzt3Jj9TZYBIJKJevXrUq1cvw8c3BwzvQ0rcwLBep9MRFxeXiJ/oLb1yv06aF3S9uYUvgtSKRCKzGE8bLKIy2tmeFjLalGUg1paWlhQtWjTbyFxqulrTaXcvL68cIZSm4zF8FuauUKcFQ5CDTqdLl2WbKUQIEGo0aGOikVUug2LLfDTPE0+dWw6egy5ejsDOFf9Bk9GEf+qWtmleO4mVl1Aq5ttzs3n/MoDDAxdliWxauthR5acWFG70MQjBP4zH+6/w/NitTAchmAtVejem3ujO7Fu6i/3LdidZX79zI1r+1Abn/C5cO3GNMV3H8PLBy1wYaebQul9rarfUW3eFh+UtjW9aiAyP4re+o1m5dQFnTl7k4f0nae5T/Ksi7D++mU0bdzFm9NRE6zw987Fw8RRq16nBg/uP6d51EBfOZ19oiFAo5OqNIzx9+jJR/G1y6NylNTExsRw7ljTNr1atamzauJxfBo/m0KGkFno2NjYcOrCBChXKMGTIWDZv2Z1k/YP7Z3j+/A3t2vXFysqS/fvXs2H9Dg5/djw3d1devta7O8THx5s19lYgECTR4yoUCuLi4lLV46YmoTMltf/LMLwHN27c4P79+8b3qHbt2ri6uhoJbUxMDMeOHePUqVNERUUZZ/r+86nNfeRJUpuc/CC96S3JQaPREBQURHx8fLZYRGWkkmwgc5lN5soIUiK1uUUoDRfOwMBAYmNjs+WzSA2mQQ7x8fEZIrRijQaRlRW6hHh0732IW7EM5LGJtrHo+yeIJCCxJHzzIeRX7hnXCaQSrCqV4s2vJp6YQiH1z80iKjicg/3no1Vn/G/cuaQ3lQd+h1dNfRBC8CMfswUhmAttVgyhUJ1yzP9xJg8vfprOtXWyo9u43lRqWBW1Us3e1Xs5sf0EMZE5o+s1F6rWr0qvUb3ynHVXRnD72j3Wr9jKph0rqVKmQaokq3TZr9h9aAP/rNrIpIlzjcvLly/N/EVTKFeuFKdOnqdJo448fPA028d+5vxeYmJiE8XfpoQ//hjC0mR8acuWLcnBAxsZP2E2mzYnfejq3rUdixZN5dat+5QuU4fg4MSpdHZ2tjy4f5aHD5/RseMA1Go127ZtIDg4lNGjpiTatlz50ly6om8gjInJ/r91gUCApaWlcUYqJT2uRCJJttCjVqtRKpU50uuQ2zC8/g0bNnDq1Cnj8k2bNuHq6gro349JkyZx6NAnO7gvQWr0/wV5ktR+jqzID3KiKpqe8RnIXHZ5r6ZnXKZa4pwmlKD/xw8ODjar9CO9MA1ysLGxITw8/YRPrFYjlFmgU8STsHcl6ntJO6qlrfoh8iqKNsgXtdqK9/PXJ1pvVb0s6hg58nefbIHqnZ1BXLScfT1mo0lIf6Z7wfrlqdDnUxCCz6XHnJm+lTfn7pMQk/v+rAbI7KzouX8SagGMaT6cUD/9NG2F+pXoOKIbnsW9eXrrCbOHzObuxbtf5I3BaN31Z9607soIls9dTc361dm6ZxUdv++X7DaVqpRj657VLF78D7NmLAGgcdP6TJ8+Fu8Cnmzdsod+vYfi65sz2uddu9fg6GBH7dqtiI9PXY/aoEFt7O3tmPtZgljBgt6cPbOHxUtWs3hJYj27jY0Nhw9uoHz5MgwePIYtW5Na7Dk42PPg/lnu3HlI584/fiQ9IylTpgRlS9VNtG2z7xqyfccqIGcIbXJITo8bHx9PdHQ0SqUSHx8frKysUCqVxMTEkD9/fgCsra1Rq9Xs2bOHAwcO8Pr1a+RyOe7u7tSqVYvu3btTvHhxs43z6tWr7N27l/v37xMaGopKpcLOzo7ixYvTsGFD2rdvb1aibajCPnz4kOfP9Y29HTt2pEyZMsa4X4FAwNq1azlz5gygl5AYZpL1s8l5I3zh/3Or2P8sqTVtwsruqmhamlpDQlVOkznTSq2pdVlOE0qA2NhY5HI5dnZ2eHl5ZZtd1+cwjfk1EPmM/C1JNFoEYhHad89RbFuILupDkm3ENZshqdoQ5fkDiL9phV+Ln+GzqqtNo5pEPv5kC1T35DRUGi17us5ArUhDWiMUUqZzXUp3ro9T0XyfghB+W8G7a0/RqjI/i5FdyF+pGB3WjeDJ9Ucs/3UhWq2WrmN68U27eljILDi86TCTfpjC+8DUvT/zMqxsrZizaw47N+5lz+a8ad2VEWi1Wn7rO5r9F7fS78furF21OdH66jWrsHHHCmbPWsrC+X/Tp19XRo76GXt7O5Yv+5eVy9eZ1ckgLSxZOp2KlctRq1aLZIMMPsfoMUPZv/9oomUuLk5cu3qErdv2MnHS3ETrundrz6KFU1KszgI4OTlw/95Zrl27TffuP6PRaGjWrAGDB/ej0bcdEjV+/fhTL+bMnQDkHqFNDhKJBIlEgkgkQqfT4ebmhlwuZ9++ffzzzz/Y2Njg5OTEoUOHGDduHE+fPsXBwYGWLVvi4ODA7du3jc1jY8eOTdZ7NiNISEhg1KhRHDt2DNBH7bZr1w4HBwd8fHw4efIk165d499//2Xp0qWUKVPGHG+DkdRevXoVPz8/fvjhB37/PbGcRaVSceTIEeRyOQKBgA4dOtClSxfev39Pnz59/pMf5AHkSVKbVfcD0yasnKhIpqapNdiGmVvHm95xabVaY0pWVq3LMgOdTkdYWBgfPnzAysoKGxubHDu/SqXC19fXGHlsIPLpcYYQCoWItFoEYgEJRzagvnos+e2KV8Tiu14oti/Hot0gAkfNQx2Y9OZn27AG9yfpjcRrH5qIztKCXW0mokohbEBqa0mlAc0p9l017L3diPvwMQhhwoZsC0IwF6r1b0adER3YvXA7jy494Pc1YylasTgBPgGsmrSKK8euoFaZT0OYGxAIBHrrrlsPmTcpb1t3ZQTvQ8IYOfAvFqyZzvmzV3j90SGgTr0arN60mGlT5uPg4MArnxvodDqjk0FaVVJzY9yfw2jTrgX16yWNv00OJUoUpVKlsnzfupdxmY2NDXfvnOLU6QsM/fXPRMsPH9xIuXKlGDx4DFu37U32mG5uLty9c4rz56/Ru/cQtFotRYoUZMOGpYwdPT2RFdj0GWP5ZUh/dDodsbGxyR4vt6HVahGJREY97sCBA2nXrh2HDx9m7dq1bNiwAbVajVgspm7dutSpU4f69esD+un5KVOmMGnSJBwcHGjevHmmxzFx4kQjoR04cCC//fZbohnWt2/f0qtXLwIDA+nfvz9HjhxJ5JebVdy5cwdHR0e6d+8O6OUGIpEIgUDA8ePHCQ3VX99bt27NiBEjkMlkxkbv/yy9ch95ktR+joyQWlPP1+xswjJFcuMzrRCawzYsswgLC0Mul2c4JcscMNh1qdVqihYtSkhISI5NMRt8d52cnHB1dU1EXtMi1UKhELFWjTY8lPhNs9GFBSW7ncDVC8seI1HsXoWkSTeijlwg5kTSjmlJAQ9E9jYE7L9GzZ1jEbvas+37CSijE/tR2nm7UmWQPgjB2s2BsFcB3N95gRfHbxPpm5Qo50W0/fs3CnxTmhvHrtGwRzPaDevMhQMXWD5xJW+fv83t4ZkNM7fPJDYujt9//POLlE2khstnr7F78wF27FtDtXKN+LZRbVaunUdQcCijx/xK6PswRo2YxP59x7LU65BZ9OnXlV+G9OO777rx4sXrdO3z++8/c/PmPaKj9RVSsVjM3bunuHv3Mb37DDV+hj26d2DRwilcv36H0mXqpJgi5uHhxp3bpzh9+gL9+g1Dq9ViaSlj//4NnD51gXX/fkrC2rx1BS1bNcnThBaSdz9wdXWlevXqLF366cGtZ8+evHv3jjlz5vDNN98gkUjo0aMH58+f58KFC0ycOJHatWtnyh4yJCSEvXv1DxHFihXj119/TXIPL1SoEKNGjeL3338nIiKCDRs28Ntvv2X8BaeA169fU7ZsWaM8QywWG5PWTpw4QXS0flagZ8+eOS7h+w9pI8+SWtOp8/SQWtOI2ZxugPp8fLk91Q/6KqXBMSKjXf7mQHKhBpmN7s0ITP8OUvPdTcnuTCQUItJpUV7Yj+rMriT2W0ZY2mA5aCrKi4cRFSmDVqElZOLyZDc1WHlVXz8cy6L52NZqPIoI/c0tX5XiVPqhOfmq6IMQ/G4+5+KivTkahGAOyBxs6H1gEg7erijiFHxVrRS7/t7Fmd1niI/LOzpfc2DIzCHkK5Kfdt9+WdZdGcG8SUv4unZVjp7bQbHiRdBqtbx//4Fhv/7FubOXc21c37VoxIyZ4+jW9adk42+Tg7OzI+3at6BGzU/Vwzu3TxIYEEz7jv3RaDTY2tpw+OAmypYtyS+/jGZbCsENoHd3uHXzBEeOnGLgwJHGa9qaNQsQCgT06TXEuO35i/uoWKlcnie0QIruB6b9BxUrVmT06NHJ7t+zZ08uXLhAZGQk69evZ/DgwRkew4MHD4zvZ+XKlVO8d1arVs3487Vr1zJ8nuRguBfExcVhY2OTyDNdKBQil8u5desWarWaypUrU7hw4ST7/pcolvvIs6TWFGmRWnNHzGYUpppag6F/bkz1GxAbG4u/vz9isRg3N7ccJ7QGycXnWubMRPdmBIZmPIVCkabvbnJjEQqFCBPkxK+ZgjbwTconEoqx+nUumpcP0bx9hqz77/i0+w2dMvlmL9vv6iCwkmFXoQjbWo3Hq2YpynVvgHNJfRDCqzP3ODbuX3wuPkpbX5vNkNrIkFpbfvpuZYHE2gKplQyJlQUSSwukVhaILS2QWEqRyKQ4FHbHu1oJhCIRWo2WN0/e4P/an8IlC9N3TF90Wh0ajQadVodWp0Wr0aLT6NBoNXqTc43WuI1Wq19v+K7TftxO83H9x3U6ncnvai0arca4vVajNR5Lo9Z8OvfH5YYv4zE/bqfVfPyu1SY6tqkTQOt+ran7fV16fT8QhSIBR2dHZDIpUgspUqkUmaUFEgsJUqkUqYUECwsLvWZRKsFCKkFiIUUiFSOWSJBK9cslYjFiiRipVIJYIkYs1q+XSMSIxCLEYpF+mViMUCRELBYjEgkRiUQIxUJEQhFCoQCh6ON3gRChSG+iLxQKEQgFCAUCBB+N9Y3LBQIEwo+/G38WIhQKEIn1zS9ikZh4RQKxsbH4vH6Hs4sjMpks3SEB5kS1apVY8+8Chg4Zx6lTF9K9348/9uTdOz+jHODK5UOoVGqat+iGUqmkV8+OLJg/mWvXblOqdG1CQ8NSPJa3tyc3bxxn//6j/PzzJ3L38899adCgNpXKNzAue/r8Mvk9Pb4IQgspk9rbtz81QBrkBsmhVq1axr+NQ4cOZYrUqlSfrqGpzSyarouIMI+FnuFeLZPJCAsLM/IIjUaDSCTiwIEDxs+xbdu2yc6+/q9oar/khsAvntTK5XKjgX9O+a1+DsP4goKCiI6OzjW5gal+1dPTM0Md/uZAck1ZpshOUqtUKvH19cXCwiLdUcOfj0Ws06DYPC91QgvIfp6OLjoSxc4VWI1ZSfCUlShfJ58NL7CQIitfEqFETOS7EHqenoVSnsCzIzc4t3APYc/8kVhJkVpb4lrSGwtrPXmUWn8ikRJLC8QfCaREJkUkkyKRSRBZSBBL9d9FEjEiqQiRWIxALEIkEiIQ66vjgo9kRyDSExyB8CPpMRAekRCBSPiRlGrQqrVo1Rq0ag0alRqtSo1GpUGjVKNRqlAr1agTlGgUKmzzOWHn7YpOq8Pfxw+/F74IhULsHe2M5EkoNCFXQiF8JFCG6r3+ZxPS9ZGY6ccqMCFiptsYCBrGn4WGbYV6ZdsnMvfpGMZ1iZZ/vKEJPv3+6WeB8Wan0+lQJiixkFmw89QGPVHWatFotGg/kmqNKUE2EGi14bt+mVqtRq1Wo1FrUH98j1Vq/XusVqtRqdSolSoUcfGoVWpUSpV+mUqNWqXS7/fxuGq1Bo1abTyPWqX5eI6P31Wf1um3V3+2v/73Il8Vol3P1pQoVxxbe1tCg0JxcHZEaiGlXes+lC5TgprfVGPy5D/4e9U8oqKiCA5+z507Dzh29Awnj583i5d4SiharDB7D6xj6tSFbEtB45ocpFIpgwf354eB+oafo0e24OTsSI2aLRCJRFw8v58yZUrw889/sH3H/lSPVbhwQa5fO8KOHQf41USDW6NGFaZM+YPOHX4wNsoFhTzEytoKrVZLXFxcxl9wLsAwxf45Hjx4YPw5taYssVhMqVKluHv3Lj4+Prx9+5ZChQplaAwlS5Y0/vziRcrxxKbrnJ2dM3SOtODl5cXz5895//49rq6uiEQiEhIS2Lp1K2q1GgsLCxo3bpwrBaucwPv37xk8eDD37t37IhsC8yypTU5+YDpdbBrvmj9/fuzt7XNtrFqtloiICKysrChWrFiuyA1M9atFihRBKpUSGRmZLek9ySGlpixTZBepjYmJwd/fH1dXV5ydndN1sUkiO9BpUT+4gubNo1T3s+g+AqG1HXGzhiAbMou4y/eJ2pXUqN2Aote2oFHpiYONuyMCoQBLBxsq92xE1T5N0Kg16D4SDq3qcxKpJ5AapQpNggp1ggq1QoU6QYkqToE8LBq1Qok6XolaqTKSTo1SjToh8e/GY308TqJtjduoM9SAVqxJFVosGsSOSetIiI2n+6yfWDJsIW+fpP5Q8CVi8PzfqNbka0b0G8ftK1+m/djn+LpeVboO6EipCiWwtLbi8tlrTBszl/APESzbNI95s5bxx7hfuXzpBpcv3eCfvzcCYG1tRfkKpalYqRzf1KnO/PmTcXZxIjIiksDAEG7dusfRI6c5feqiWa4/Li5O6Yq/TQ4dOrQkXqFg376jbNm8gjJlSlLt62Z836op8+dN5OrVW2lWZwGKFy/MlcuH2bRpNyNGTDQud3d3Zc+etSxe+A8XL+qnwSOiXyIUClGr1cTHfznSG51Ol+x1OzAw0PhzgQIFUj2Gt7c3d+/eBfTEM6OktkiRIjRt2pTjx49z9epVbty4QfXq1RNto9VqWbJkifH3Bg0afH6YLKFevXrcuHGDKVOm0KJFCywsLDh//jzPnz9HIBDQqFGjVOWNXzLVVSgUDBo0iIcPH1KsWDE2btyYqAnvS2gIzLOk1hSfR76q1WoCAgKMDUjZHe+aGqKjowkPD8fCwoICBQrkytObaaiAQb8K2T/db4BB7pBcU5YpzD0e08p0gQIFMjRFYToWgUCAUKVEfmBNqvtImnRDXKw8cbN/RdK0C0hsCRo9P8Xtv3qwB50OEsKiCXsXypERq9AkKI1EMi9acaUXZdp+Q6Ppfdk8+m9uHtBrLF0L52PStqkMbTCIqLCoNI7wZUAkFjNl90zs3Rzo1fwHfN/kbjJbViAQCPiuQxPa9PieIsULATpOHTnHv4O2cOvqHVQqNUW+KsSWw2tYMGclB/YeZdiIpHGycXFyrl65xdUrt1ix7F8A7OxsKF+xLJUrl6NW7eqsWDkbewd7IiIiCfAP4saNuxw5dJLzGUwWk8lkXL52mJMnL6Qaf5sS/hg9hL9XbWTx4mk0aFCHxk07sWvHakqVKs6gn/9g584DaR6jZMniXLywn3//3cYYkzGIxWL27v2Xx4+eM3PGYgQCAZExrwD9zFFCwpelt9ZqtYl0pPCpeGSAm5tbqscwXf/mTeYebmfOnIlEIuHQoUP88MMP9O/fn5o1a2Jvb4+Pjw9r167l3r17AFSoUIGePXtm6jwpoXnz5qxevZoTJ05w+/ZtBAIBYWH6hx5ra2v69u2baHuNRmOU43zpmtrVq1fz8KE+9XLGjBlJSOSX0BD4RZBa+FStjY+Px9/fPwmBy2kYggSio6NxcnJCpVLlOKE19eJNrlqdldCK9J7fQCq9vLyM3aIpIS0/34zAoKNWqVQULVo0ycU4LZiSWrFOS8L2RaBMWScorlwfae2WyJeMQeDggrRmc951+wNtbDKVGLGYEg/3oFVquPnb30Q8fEuTU9PxqlqcZ4euZ2iceREVezSk3riurP11MQ9O3jIuP7pkNx5F8zPn0AIG1f4RjRmjP3MD9i72zDw4n5Dg93Rr1JfoLyzpDEAqk9K5X3uatW2MV6H8REfFcHTfSWaOX8Cju08SPWR6eudj08F/WPvPZpYtWk3Z8qVQqtInKYiOjuXShWtcunCNxQv11VQHR3sqVixL5Srl+aZOdTp1+h5rG2siwiPw8wvk2rU7HDpwnGvXkg+tMI2//WHA8Ay/9jp1auDq6oxEIqZb13YsXbaWs6d3c+XKTUqVrs3790k9pz9H2bIlOXd2L3//vYHx42cnWjd37gQ8PNwoU7IOtra2+AfdA/TVLlNt6JeC5DS1crnceM0WCARpOuiYro+KytyDrZWVFfPmzaN3797MmTOHZcuWsWzZskTb2NnZ0aFDB4YNG2b2olb+/PmZNGkS8+fP5+3bt8blbm5udOnShbJlyxoLbAEBAcyePdtIsr9kTW1sbCxr1+rT9ipWrEj58uWT3S6vNwTmWVL7OUEUCAS8f/+eyMhIPD09sbOzy6WR6Z/C/fz8EIlEFC1alLi4uGzVkyUHQ1NUfHx8is1x2VmpNSWVBrlDWjDXeAxhFlZWVpnWURvGItJp0Ty9iebFvRS3FRYqiUWbH1FsmIM28B1WE9bxftEmFI9eJt3Wxoqvrm9Fk6Dm5epj+B/Uk9hbo9bQbGZ/fK89RR6WtlF8XkX1gS2o+WtbVv44h2eXHiZZv37EcoZvn8iM/XMY1WJYLozQPChavjh/bpzIpdNXmTx85hflq+vo7ECPQV2p1/QbPDzd8X8XyMHdxzh1+Cw+r94lu4+zixPbTqxj986DzJiyEAB7BztUKTQ/pgeREVGcO3uZc2cvM3/uCgBcXJ0+Et0KfFOnOr16dcRCZkF4eATv3vpx5cotDuw/xr27jzIUf5sc/vhjMEFBIfw+fBBBQSEM/qUfA38aye7dh9LeGahYoQynT+9myZI1TJmSeEamU6fv6d69PbVrtcTbOz8PHp8H9LNmqUUM52Uk5wYjl3+yHUzPNd70PpRZLbFSqWTp0qVs3LgRhUJBy5YtqVmzJlZWVrx584YzZ87QsGFD2rRpk22ztE2aNMHBwYGbN28SEhKCVCqlRo0aNGrUKBH5Dw4O5vjx4znenJ4dOHv2rPEz+5IbAvMsqTWFWq02Cu5zW24QExNDQEAAzs7OuLi4GJthckq7CkkTylIideasjJrCYNdlbW2dIVJpjvEYgiTc3d2zZLhtbGLSqpHvW5Xyho6uWPYZh+LQBtQPryP7dQ6KJz6Er0kalynO70bRE6vQanWEXnnKo1m7jOv89lwhX6OKdN/5F/98OzLT485N1Pm9A5X6N2VJ72m8vvU82W20ag3L+s5g7OHZ/L7yD+b9NCuHR5l11G1bnx+mDWLNwvWsX7Ylt4eTLhQs6k2vn7tRrU4VnF2dePLwORtWbePMsQuEBqee2mZjZ8Pusxs5feI8Y0dONS53cLAjIcG8D+th78M5dfICp05egJn6ZR4eblSsVJYqVStQq3Z1Bv7Uy6hJDQ15z6ZNy3n67CX37j7i8uUbBAWlHbZQpEhBatSsgkgkRqVS8fTpCwb8MDxd1VnQOy0cP7aNefNWMHPmkkTrSpf+ihUrZvPLoD/w8HDj+MkdADx79gzQT1FbWVkhkUi+qGailNwPMoKs7q/RaBg0aBCXLl1CIpGwevVqvvnmm0Tb9O3blwEDBrBixQp+/PFHhgwZki3vc/Xq1ZPoeXU6XaLXWKlSJWMCWceOHb/o8IVz584Zf/6SGwLzPKk1mOgLhUI8PDxyjdDqdDpCQkKIjIzE29s7kX4zJ0mtwTIsPQll2eELazh/ZqKHszIenU5HaGgokZGRZgmSEAgEWIpFJGxbAAp58htJZVj9MgvlzbOozx9A0rgTAidPArr9mGRTWfniFNw8G0Qi4t6GcG3gkiRNV7d/X0PTC7NpMqMvJ8b8m6Xx5zQaTOxJmQ51WNBlEr4PU9fKxUfLWdB1EmMPzaLL793ZNm9zqtvnJfQa15fG3Zvx15ApnD92KbeHkyoqVi9H94FdKFulNLZ2Nly/fJsF05dz4eRlYqLTZyElk0nZf34Lt27e49efxyZaZ29vT3wOWHcFB4dy7OgZjh09Q6HCBThyYiuBAcHMmrEE7wKefFWiCJUrlaN9uxZ45HNDo9EQGxNHdEwswcGhvHrlw4P7T7h+4w737z1Gq9UycuQvaLU6lMr4dFdnra2tsbW1pnr1iqz7dwkzZy5h3rwVibaxs7Pl4MGN7Ni+H6FQaCS0MTExuLu7I5fLkcvlfPjwwThdbyC5udFAnBEkR2pNr7PpmY00tXrLSI+DAZs2beLSJf3/Xffu3ZMQWsNx58yZQ5MmTVi2bBlqtZrhwzMuT0kLprILw3uTXNqpo6OjscL5JWtqnz//VKj4khsC8zSpDQ0NJTw8HE9PTz58+JBrHccqlQo/Pz8EAgHFihVL4vuaEw1Zphre9FqGmbNSm5nzJzeezLxParUaf39/dDqd2YIkPFxd0L68h+bprRS3sRw6F43fK5S7VyHMXwhpo074DZiAJjyxfMCmcU08549CKLNAGRnLhc4z0MQnbRLRxCdwuddcGhyaxIsjN3l7MXWnhbyC5nN/pEjjysxt/xeBL5K3Lvsc4f7vWdJ7GsO2TiDgtT8X953P5lFmHePWT6BwuaIMaDuYF8lIS/ICGrasT4febShWqihiiZhzJy4yfvg0rl28leEgCLFYzL7zW3nx/DU/9B6W5Frh4GCHPC6FB75sQLsOLVm4ZCpbNu9m9KipKUoO3NxdKFy4IEWKFKBwkYKULv0V/fp3Y/yEEVhZWaJWqxAKhcTHK1Cp1CxeNI1lS2boZ2ZEQqOVnEgkRCgUGT1/1Wo1Oh1IJGLOnr2UhNAKBAK2bFlORHgkfr4BrF23CNATWtC/n3Z2dtjZ2ent35RK5HI50dHRhISEIJFIjARXJpPlWj9ISkhOfmBlZZUoVlwul6daUDCVHGRGIrh161bjz23atElxOy8vL6pWrcr169dZs2YNnTp1wsvLK0PnMrwmwz0pWd/yj59Reh9IBIAwDxijZLRwrdPpkuiHU0NebgjMs6T2/fv3xMbGGpuAIiIicnSK34D0dPZnd6XWQKoNGt70kjqhUGiWhgXD+YVCYZYsyzJDak2dHTw8PMwyzSQQCHCwsSJ+xYoUt5ENnALKBBRrZoBA/3v4+v3IbyTWkTr0aoX7iL5oomLQauFi9znEB6bsDxz11I8HU7fSeukQVtT+DWVM3rb8+X7lUDyrl2BWm7G8fxucoX3f3X/Nv8OW8NOCIQS/C+Ll3ZSnmXITMhsZMw/OR6VW07VRX8JC0jdFnRMQi8W07dGKlp2bU6CINwmKBI4fOM2iWX9z7+aDLF13dp/dSMj7MHp2GZSsDtTJxZHIyJzRfy9YPJWOnb9n8M+j2b0r9apqaEgYoSFhXDdpMBOLxUybPoaevTthaSkjNDSMHwb8jkqpIkGpRKlUolKqUCpVJCQoUao+/a5UqlCpVDg42OMfeA+As8mkpo0ZM5RKlcpx/OgZxk8ckWqogkAgwMLCAgsLCxwdHdHpdMTHxyOXy3n//j0qlQqZTGYkuVKpNNelCslVagUCATKZzGhNFhoammpVLjT0U5x3kSJFMnT+2NhYfHx8jOdNy+C/RIkSXL9+HbVazblz5+jRo0eGzmfqQZ0SkiP6/4uIi4szcoUvvSEwz5JaFxeXRNPrOa1bNUx3R0REpNnZn51jM5BqUw1vemGOCrJB/pGWXVd2jMeQTGbu2GOxTkPC7hUgT/6GJOkwGKFzPuSzhoAqAdnASSgDwni/cGOi7VxHD8Cp23ckPH2N+Ksi3B69lvA7r9I8/+t/T5KvQQW6bhvH+hZ/prl9bqHDxlE4lfBi5vdjCA9I3cczJdw/fpPDC3fx54ZJ/NboFyJCcjYQJC3kK5yPKbtn8fj+M0b/MB5FfM4nZX0OG1trug3sRMOW35Lf24PQ4Pcc3nOCk4fO8vyJeSrI20+sI0GppFOb/inqZl1dnYn4GCaQXbCysuL46e04OjnQoH47nj7J2IOPVCpl5uw/6dS5NSKRCJ83vnxVoihjRk/LcJyvgdA+evgkyXvSqFEdfv99EM+evaRbjw4ZTgkzEAUrKytcXFzQaDRGqUJERAQ6nc5IcK2srHI8BRJS1tSaklo/P79USa2f36eZnK+++ipD5zet8kql0jTfA1NiFRAQkK5zGEjqnj17GDt2LAULFkQqlRrfd70ExRatVkvDhg1p0qRJhohtXnM/CA5OWogwzCaY4vP3Pi3k5YbAPEtqRSJRIqKYk6RWrVbj5+dnnO5Oyy4qO8am0+l4//494eHh6bLLMve4TMMtvLy8MuVF9znSS2oNUoeYmJhkk8myAhE6tG8eo3mUvD2IpH5bpOVqEDd3GLrYKMS1miIsWAr/5j+B5tN7mX/pWGzrVCXu/HUsqlbAZ8s5fHemX4N5ffByml2cS52RHbk4Z2eWX5e50XX3X1i6OzKj5Wii30dm6VgnVx3AvWh+Zh+czy91f0SZy1HABlRuUJVfl4xg76YDLJ6yIlcDFdw93en9SzdqNfgaV3cXXj1/w85N+zh99BwBvkFmPde/e5djaS3ju4ZdUpUXOLs48eZN8m4J5kC58qXZe2Ad9+8/plmTLkRHp98yTSaTMWfuBNq2/w47O1vk8ngWL17NyxdvmD5jLLt2HszQWAKD9alZX1dpwtr1ixOR2oIFvdi8eSXx8niqVKlglthbkUiEra0ttra26HQ6VCoVcrmcmJgYQkNDEYvFRpJraWmZI1KFlMibpaWlsfP80aNH1KlTJ9n91Wo1T58+BfQeo4ULF87Q+U2JVkJCAkqlMlUyY5B9QPqImCkMr+fdu9T/vps0aYJarU63ZWReaxTr3r17knWDBw9myJAhWTp+Xm4IzLOk9nPkFKk1VCYdHR1xc3NLdzqVOW+IBg2pVqvNlAdrVsdlsOtSKpVmdZtIz3jUajW+vvqo1ZSSybJyfpFWg3zXsmTXi8rWQNqwI/HLJ6ALDQAnNyy+H0DAsNmogz9VKgvsmo9l8YLE7D+JtEo5Ip76c39SxpqhVFFyLvedT70dY3l16i5Bd9Ou8OYIhEJ6HpqMwELMzO/HEBdhHm/WLWNX8evmv5h5YB7Dm2TtgmoOtB7Yjg6/dWHOuIUc3H4kV8ZQstxX9Py5KxWrl8feyZ57Nx+wfN4azp+8RMSHyGw559KNc/EskJ+m9TsQFZW6tMDR0YHQkOQ9ZLOKAT/2YOKUUSxa+A+zZixO93XKysqKBQsn0/L7Jvj4+BIfH49CoaBbl0Fcu3abW3dOsm7d9gyN5cjRLdjZ2fLTDyN48fwNEomE+I8Ve5nMggMHNmBhIcXe3jZbYm8FAgFSqRSpVIqDgwM6nQ6FQmFsOEtISEgkVbCwsDD7lLhOp0uxUisWi5FKpSiVSs6dO8egQUkDOQCuXLlibBRr0aJFhsdgaWlJoUKFjNrOx48fU6lSpRS3f/z4sfHnjBLo0qVL0759eywtLVEoFHp5ikovQ9FoNAQHBxs9UvOa9jkj2Lx5Mx4eHomWJad1Nm3q+9IbAv8jtR9hWhn19PTMUGUyuRjfzEIul+Pn54e9vT3u7u5Znu7P6Htm6gFbpEgRs/5Dp0Vq5XI5vr6+GXqgyAjEWg0Je/9GF5tUAyT0LIKs0xAUWxajeaO/WFr+MpOo/WeJPfMxMEEspujJVYidHIjcvB+xlwcaCyuu9JsK2ow/PITffsXTRfvosGY4y2oMRavMXX9LoVhIn+MziE9QMr/tOBRm1PtqNVqW95/F2EOzGLP2L2b0m2K2Y2cUQxcN11dpu4/k7vX7OXrumg2+pkv/DpQs9xWWVjIunbnK9HHzuHz2GnJ59uqrZy6fSNmKpWhSvwNhYWnLQOwd7AgODk1zu4xi/aZl1G/wDT27/6y39koHbG1tWLRkGs2aN+DBgycsWbKGX37py8UL1xj44wiiomKoWbMq+fO7M23KgnSP5Y/Rg6lbryabNu5i+9Z9gJ7EKT423a1cOQdvb09kMgujZCC7IRAIsLS0xNLSEmdnZzQajVGPGxQUhFarNU6XG6zDsgrDvSu5a65CoaB27dqcOXOGe/fu8eDBg2SN+Tdu1Muz7O3t6dOnT5L1YWFh/PLLL7x584bhw4fTtWvXJNu0atXK2PG+ffv2FEnt06dPjU1ElpaW1K1bN12v0/D6atSoQZUqVdBqtajVauOXgdjK5XJcXV2B9DeJQd6TH3h4eKSrgc7a2hqJRIJKpfriGwLzwvufLmQnqVWr1bx7987YmJbRqXbTGN/MwjDd/+7dO/Lly2eWpqiMWmhFRUXx5s0bnJ2d8fT0NPsTamokOzw8nHfv3pE/f/4sk/nkIEKH1u8F6nsXk660dUQ2YCLKk7tQ39HfZC16jUAToyRk6koAhNYyil/bhNjZgfC/t6CNikb2TTUudJqOOrlUsXTi2ZKDxL0OovOm0Zk+hjkglknpd3YuUVGxzO0w3qyE1oCEOAULuk6iROWS9BzXx+zHTwsisZiZh+bxVbVS9Gz2Q44QWqFQSKsuzVmzfxmnnx5m8pI/CQwIZuSgv6hRvCG/9R/DycNns53Q/jlzJLW/rUnLJt0ICkzb5xX00beBAeaTPji7OHH7/mlKlSlO7Zot0kVoHRzs2LB5Gc9fXcXVzZnm33UlKDiEoUMHMGrEZLp0HkhUlH42YdQfgzl54ny67xM1a1blr/G/8+6dP0MGffr/E0vEKBQKBgzoQatWTbCysjQSndyASCTCxsYGNzc3ChcuTIECBbCyskIul/Pu3Tt8fHwIDQ0lNjY2UyEVoNfTpnTNVSgUNGvWzOhdOmbMGMLDEz8Ubdq0iQsX9J/nhAkTkiU6GzZs4N69e0RHRzNt2jSjTtcUffr0MVZd9+3bx/btSavuQUFBiSp2Q4YMybBnuaE6LpPJsLGxwcHBARcXF/Lly0eBAgUoWbJkun1REx33o6VXbn8JMiiCEAgEFCxY0Pi7acNfcsjphkDA2BCYFvJspTY5P7jsILXmqowaxpcZIqjRaAgMDCQhISHFdLDMIKMa1qzYdWV2PFqtlqCgIORyuVlf++fnFem0yLcvTrpSLMVqyBzUD6+hPKG/gIoq1EJc+mvefD8EnVKN2MOFoqdWg1ZL2LzVqHz8cV8yiYs9ZhPnm7qxfZrQ6bjSfyHNLs6h2o/fcXNVzk+FS20t6XtyJkGvA1nWfybqhOyL+IwMDmdRjyn8vmMyAS/9ObPjVLadyxQOro7MPDiPwIBgfmzUl5iorGkiU4PMSkanfu1o1qYRngU9iYqI4ui+k0z7cx6P7z/Lce3u0DGDaNG+Ka2adOPd2/RZsgFY21jj728eUlu7Tg02bl3OmdMXGTRwpHF6PyW4uDixdPlM6tWvxdWrt2jUuCNyeTxHj2wlOjqGWjVaJNL7FirkTe06X1O6VPJ6z89ha2vDydN6LXvFMvUTrROLRRQvXpixY3/DysrSqO/MK5BIJNjb22Nvb49OpyMhIcHYcBYUFIRMJjNWcWUyWbruaZ+HCphCLpfj6OjIihUrGDx4MA8ePKB58+a0atUKBwcHbt26xdWrV5FIJIwZMyZF6YHp372plZYpbGxsWLt2Lb/++isPHjxg/Pjx7N69m5o1ayKTyfDx8eHkyZPI5XLEYjGDBw+mf//+6XznUn/9AoEAPz8/YmJikMlkiMViXF1dM3Q/zGua2oygZMmSvHqll8F9yQ2BeZbUfg5zk1rTRihzxO5m1hNWoVDg5+eHpaWl2af70/Oemdp1mcsDNrXxmF7IDHHDEomEIkWKZJs5uVirIeHgGnQxSWP2LIfMRhsaQMLWj4TXxg6Lzr8SNGEZqneBWJQsTJGDy9DGK3g/eQnxN+7juW8V9yduIuzqM7OMLyEsmqs/LqbOuuG8OXOPD68CzXLc9MDSyZY+J2bw5t4rVg2ah1aduUpPRuD/+C1rhixkwNLfCHobxNMbj9PeKQsoXukrxq6fyPnjF5k6YjaabHiNTi6O9Py5K3WbfoN7Pjd83/pzaPcxTh0+x9vXvmY/X3rRf3BPug/oSLsWvXj+LP26bf0UuAzfd+nrKk8No0YPZuiwH5k4fg5/r1yf6rbu7q4sWzmL2rW/5vz5q9Sr34aHD58yatQvjP5jKGtWb2HC+NlJrAp/G/YjDx484X1o+lw6gkL01nz5XcsmWScWi/nzz2HIZDI+fPiQqwmWacFguSWTyXByckKr1RqlCiEhIajV6iRSheRIbkoFGZVKZTyGu7s7W7duZffu3Rw4cIBDhw4hl8txc3Ojc+fO9OjRI1WC07NnT65du4aPjw/Dhg1LcXo7f/78bNu2jVOnTnH06FEePnzI+vXrUalU2NjYUKJECapVq0aHDh0SVRezAq1Wi0gkYs2aNVy9ehUPDw9CQkIYM2YM9erVM8s58jrq1q3LoUN6O70vuSHw/yWp1Wg0+Pv7o1arzdYIlZm0LINlVWbSudKDtCq1mWmKM9d4smJVlhEIAW2gD+pbZ5Kss+j7FwhFxK+aDB//tiwHzyL2/C2i953Buk5lCqydijZeQcjoOcSdv0aBExvx3XeVNxuTHi8rCL34mNfrT9Fl8xiW1fzVOJ7shE0+J3odnsqTSw9YN2wJukzogjOLR2fusH/OVsau/YvhzYby3t/82k2ABp0a0XfSD/wzbx0bV2xNe4cMoHDxgvT8uRvValfGycWRR/ef8u/yzZw9fpH3IZmzQDMnOvVqy0/D+9G1w488uP8kQ/va2tmgVqlJSMhYoIMphEIh+w6up0y5krT5vnciX9nP4emZj2UrZ1KjRlVOnb7AN7Vb8eTJc2xsbLh86SCFCxekU4cBnD9/Ncm+dna2dOvenqZNO6drXH7++iSkb75ukaRiXLJkMVxcnFCr1QQGBqJWq/M0qf0cQqEQa2trrK2tcXV1Ra1WI5fLiYuL48OHDwiFwkQk11BISEl+YJAIGJqBxGIxnTt3pnPn9L3XpnBzc2PnzvQ5vYhEIpo2bUrTpk0zfJ7MwHBfevr0Ke/evePdu3fY29tn+LPPa5rajKBBgwZGWcuX3BCYF97/ZPH5P5hIJMq0XsgUcrmcV69eIZVKKVy4sNkuWBkh3VqtlsDAQKORdXYQ2tTGZKhS+/r64unpmS0a1uRgqGaHhYXh7++Pl5dXlr1v0zqfGC0J2xcmWSdp1R+RVxHil4yFBP2FW9rhJ3QCGUFjF2HfobGR0AYPnUzcyUvk37SA6Hdh3B2zLlvG+3D6DpRhUbRfPSxbjm8Kx8Lu9Dk2nbvHb7Dut5wltAac/fcoN/ZdZOa+uVhYmc+2zYDef/Wnz8QfGDdoktkIbeUaFZj773SO3tvLhuOrsXOyY96UpdQt25yerX5kx4a9eYLQfte2CSMn/UrfHkO4fjXjDgYODnYkZGHK3bugJw+fXsDWzpbqVZumSGgLFvTk8NEt3Ll/ioiIKGrUaE7HjgN48uQ5TZvU59XLq0RERFGpQoNkCS1Av35dCQoK4e7th8muN8W+A+txdHJg6OCxPHn8PNG6bxvW5uqtYwiFQhISEoiLi/uiO9/hU8pZvnz5KFKkCPnz50cqlRr7J3x9fQkLC0OhUCR7HTZMFWeXJC2vwPDaDRxjzJgxbNy4kcqVK2foOEJd3vnKKGxtbenXrx+AsSEwOaSnIbBz585Uq1YtUUOYKVq1amX8OTndtAGZaQjM05Va08peViu1Op2O8PBwQkNDyZ8/P/b29uYaJpD+8Rmm3MVisdktqz5HShrWgIAAEhISzGrXlR4YbGMiIyMpUqRItp9brFWTcHQjusjEJENcsznSqg2QLxyJLkqfHiUsXh5JtUa87TwCpz5tcRvWE608nsCBf6K4/QjXab+DkzOXGoxGp8meKqpOreFK3wU0OTuTcp3q8nBH+jrDMwrXUgXosmMcl7efYfe0jWnvkI3YPmEtrgU9mH1oPr82+Nlsxx2/eQreJQswoPXPvHzyOkvHavz9t7Tv3YaiJYsgFos4c+wif/42leuXbqFMIbggN1G/SW0mzRvLLz+O4vzZK5k6hr2DPSpl5rTV37duytKVs9i+bR+jRkxONq2saLHCLF8xk4qVyrL/wHEGVhnJ6zdvjetX/zOfdu1aMG7MdFavTtkuTyQS8dvwHxn9x7Q0x/XbsIE0alSXndsPsHHdjkTrevftwsIlU4FP053/a2lSn6ecabVaFAoFcXFxREZGolKpCAgIMIY/iESiRJVatVrNnj17OHDgAK9fv0Yul+Pu7k6tWrXo3r17mg0/aWH06NHs3bs3w/uNGTMmWXKVERg+Z5VKRalSpejSpUum+ju+ZE0twIABAzh79iyPHz82EnvTJryMNAQCTJs2jTZt2iR5KOrTpw+HDh3Cx8eHffv2UalSpSTV/8w2BOZpUmuKrJBaU9/V7GxGSkt+EBMTQ0BAAC4uLjg7O+fIdL/pe2aw68oO/W5aMJxbp9PlyLmFAgHaEH/U108kXl68Ihbf9ST+n6loA9/qF0plyHqPIXTuehy7t8ChUzM0sXEE9htNwqMX2HVthVWjOpxq/heqqOztgJb7h3Hz15U0WvQTby8/JibAvJGt+asUo8OGPzj5z0GOLNpl1mNnBjqtjr8HzmX0gRmM3zyZyd3HZ+l4VrZWzDw4j/iEBLo26seH0Iy/f1KphLY9vqdFp2YUKOJFvFzBsQOnWDh9BfduPcyVuO70omrNSsxeOYVRwydy9FDmm/Ds7e1QZoLUzpo3ge492jN08Fh27jiQZH3JUsVZtnwmZcuVYvfuQ/Tp9ytvTZrXChcuwPFj21CrNdSr05pnaeiAW7duhlarY9vW1MlQtWoVmTptNEGBIfzYP7HX5fiJIxg24icgsX7vf43Ufg5TKYKFhQUxMTHY2dkRFxfH/PnzOXHiBMWLF8fR0ZE7d+6wZs0a7t+/j4ODAy1btsTBwYHbt28bdbZjx45N1qYru+Hi4pLlYxg+Z2trazw8PEhISMgWnpDXYWlp+cU3BP7Pk9r4+Hj8/PywsbHBy8sr28hUauMzjdz19vbOlFlxZsdk+IOKjo4mICAAd3f3RPHDOYGYmBj8/f1xdXUlODg42wmtQXYg37oATP6hBK5eWPYYiWL3KjTP7xmXy36ZTvyDl1jXq4xN7Spoo2MJ6DUC5cu3yCqVwen3AVzpt5DY1+ZNdkoJAUdu4dHgGt22jePvOmmbTacXBb8pQ5t/hnFwwQ5Orz5ktuNmFcr4BBZ2m8yfx+bQf/KPrBm/KlPH8SzqyaSdM3h45wljfppAQnz69aC29jb0GNiFb1vWI5+nOyFBoRzac5yTh87y8mnWKr05hdLlS7Js0zymTpzHru1JCWVGkFH5gUwm4+jJbXh4uNGoQQceP0rcRFm2XEmWLp9FqVLF2Lp1L127/4SfX+KGyF9+6cfkSaPYumUPo/+YmmJ8rylGjxnCxo2p6zStra04e15Pekt/ldjkffW6hbTv0DLZlLDUbK7+12BolDKknI0bN47GjRtz7NgxXr9+zdChQwE96Rs4cCDfffed0dR/06ZNTJkyhUmTJuHg4EDz5s2zNJYjR9J2gLl37x5jx47F3t6exo0bZ+l88InUVqtWjTNnzhgTPDP6YCMgb2g6s/JX+6U3BP7PklqdTkdERAQhISHky5cPBweH7BscKY/PELkLZCkdLDMwVI+Dg4OJioqiYMGCqRoqmxumgRYFCxbE0tKS4ODgbK+AiLRqEk5uQxdu4sdpZYPloKkoLx5GffVT9VbSrCsCBw8k6gikhb3QREQT0GMYqneBCJ0dcV8+hUezdhJyPm29njlxd9x6mpydyXcLfuLIsJVZPl6xJlVosWgQu6as59LW02YYoXkR/T6Shd0mM3LPVPxf+nF849EM7V+lYTV+Xfw7O9ftZdmMVelq2sxfwINeg7pR49uvcXF35tWz12xft5tTR88T5J80Mz0vo3CxgqzdvYzF81fx7z9bsnw8ewd7FOn0zi1d+iv2Hd7I0ycv+L5lDyIjPyWVVapcjiVLp1OseBE2btpF+w79CAxM/N7KZDIOH9pI2bKl6dVzMCeOn0vXeatXr4SXtydTJs1PdbuQ9/pGE2+PComWHz+9g+pfV04x9jY1m6v/NXz+WmUyGXXr1kWn03HmzKem2KpVq7J27Vp27tzJ0aP6/9EePXpw/vx5Lly4wMSJE6ldu3aWYtWLFi2a5jYrV+qviW3atDFrRbVDhw5s2LCBQ4cO8f333xvvoYbrieG+ldL960tuFDPFl9wQmKdJbXKa2vQQIoPvq0KhyDa5QXJj/ZzUmjMdLDMwiN7j4+Oz3a4ruXP7+/uj0WiSkPlsJbU6LdqwINSXD39aJhRjNXQumhcPUB5c92mxVzGkDTqgUyqRFPJE8yEC/26/oQ56D0IhntuXEHDyDi9XHcuesaYCbYKKy73m0ujYVF40qcKrE5mPKy3VphZNZvRj8+i/uXngshlHaV4EPvdj1U/zGPj3CALfBPLwcvrCEdr+0oF2gzsya8x8Du88nuq2pSqUoOegrlSoXg57R3vuXL/H8rn/cO7kJSLDkybNfQnI5+nO5sOrWbdmK4vnZ67K/TkcHOyIjUtbatOrT2emzxrHsqVrmTZlgfF6Xf3rSixaMo3ChQvy779bafl9T0JCkno616lTg+1b/+bZs1dUrtSQ0Aw02f0xeghnzlxMVrNrgM+7WwDUr92G2NhP/pj3Hp+jYEGvFAkt/O/LD0yRkqVXRESE8f2tWLEiq1bpHxg/t1Tr2bMnFy5cIDIykvXr1zN48OAMj8HGxiZdUoLIyEiOH9f/n3fp0iXD50kN3t7eLFiwgLVr16JWq6lfvz5OTk7/b/4O/heQp0mtKUxTu1L7A1MoFPj6+mJtbU3RokVz7EnbdKrf3B64mYGBUIP+HzUnCa3hM7CxscHb2zvRZ5AZ67P0IiEhAWupBMXW+YlkB7Kfp6ONikCxce6njYViLH6YADodQpkMdfB7/LsPR/MxPjTf+rnEvY/h1vB/smWs6UHMqyDujFtPy3kDWVlnOIrIjAcGVOzRkHrjurH210U8OHkrG0ZpXjy9+IBdUzcwatUYRrYYRvDb1CUfvy0ZQcX6lRnSbQT3byRfTa/dqCad+3egRNniWMgsuHj6ClNHz+HK+evEy1MPAcjrcHJxZMfJ9ezbc4RpaVQsM3RcZweio6JT3WbNuoU0blqfvr2GcuyYvppXu87XzF8wGe8Cnqz6ZyNz5y5PMZJ30aKp9OrZiSmT57N0yZoMXRcKFPCkbr0alC2dsofozt1rcHV1ZuTwidy/98i4/F3gXezsbNFoNERGRqbo3fofqYWHDz/9T9WvXx/4lMZlilq1aiGTyVAoFBw6dChTpPbPP//kzz//THO7ffv2kZCQQPXq1TOcZpUa1Go1kydPxs7OjoCAAKZOncrly5cpW7Ys+fPnx87ODisrKywtLY3ewDKZDAsLC2NBK7POA+ZGXqgW5xa+GFILaad2RUREEBwcnG2+r+kZm2lTWk67C0BilwdPT08CAgJyNMEoKiqKwMDAFD+DrMYJp4SIiAhsLaSozu5HF/aJCFn0GIHQ2o64WUPApKJj8fMUhDJLEApR+gYS0PN3tB/jNp3H/YLI25OLDUajU2V/GEFqeLf9AvkaVqT7zj9Z0zhjUbrVB7ag5q9tWfnjbJ5dyln5RFZwacsp3IvkZ/qe2QyuNxB5TNKKoVgqZvreOVg6WNOj6QAC3n3SZxqiaVt3bUmh4gXRqDWcPHyWVYv/5fa1e6hzIGAiJ2BjZ8Oes5s4e/oSo3+fbNZju7q7EJ5C5drBwY4TZ3cjEgmpU6sVb968o0HDOsyeO578+T1YvuJfFiz4m/DwyGT3z5fPnVMndyKVSmnUsEOGPXQBhv76A48fPU+2+gsweHB/mjdvwIF9x1i9apNx+fvI54jFIpRKJe/evTNG31pbW6fbu/V/ESlJLZ4//2R7ZojJTQ5isZhSpUpx9+5dfHx8ePv2baqJVFmBwQLK3E1pcrmcHTv0rhh2dnYoFAoOHz7M4cP6WT+hUIhQKNT3bIjFCIVCxGJxooeiL9394H8BeZrUpjcq1+D7Gh8fT+HChZHJzO95mRaEQiFKpZLXr19jbW2d4+4CkNiuyyC7CAoKyhFSq9PpCAkJISoqKtWoXXOTWoNmWCISISOB+PP7jeskTbshLlqeuNm/QrxJNF/z7kgKFEeHAOXLtwT0/QPdx6lW2zaNsW3ThNMtJ6L8EJPkfLmBW8NW0fTiHBpM7MmZiemz4Kr9ewcq92/K0j7TeXXTPMlnOYk90zbiVjgfcw4v4Je6AxOtc3R3YsaBufj7BtK/wxBio2ORWcnoOqADTVo3xLNgfsI/RHJ07wmmjJnN4/tf3utPCzKZlL3nNnPn9kOG/DTa7P/jzs5OvHr1JsnymrWqsnn731y8cJUfB/xO3Xo12b3vX9zcXFi8ZDWLFv1DVCoV3j59ujB3zgQO7D/OsN/+Qp5O3a4pbG1t6NmrIy2/65Hs+kqVyzJz9p+Evf9A7x6fKoYRsXonBaVSSUJCAh4eHuh0OpRKJXK5nKioKEJCQpBKpVhZWf2/IrUpFYtCQj71JRQoUCDVY3h7e3P3rj7Y4sWLF9lCaq9fv86bN29wdnY2S4OYKQz2ZaBvrP4cWq3WyD8+l18Y8L+iqf2SkadJ7edIjtSaxszmpNzgcyQkJBAdHU3+/PlzvEpsOL+fnx8WFhaJCHV2VUZN8XkzXGpSB3OOx3BeiURCwfwexC/9A3T6vw9xlW+RftMS+ZIxiRrGJE06IW3YHp1Gi+LxC4J+HIdOoe+Sl5YpjvO4wVz7eRnRz/ySPWduQB2n4HLveXy7bzwvj93C79rTVLdvMKEHZTrWZWHXybx78GV07n8OnU7H6p/nM2rfdCZvn8H4zmMAKFG1FGP+/YszR86zau5afhjehzqNa+GWz5V3Pn4c2HWUk4fP4euTdz4/c0MsFrPn3BZev3rLgF6/ZovFmKOjA6Ehie3Qho8YxO+jfmbK5Hn4vgvg6o2jODs7MX/+CpYuW0tMTMryGLFYzIH966lWrRIDfxzBgf2pa59TQ+8+nQkNDePmzbtJ1llZWXHx0kEAihf+GtDbFAW+189UKBSKRIQkNe9WjUaDr6+vsYJrbW2do42+OYnkCLxOpyMq6lO13s3NLdVjmK5/8ybpA5E5YKjStm/f3uyfhSFool27dlSqVInw8HDi4uKIjY0lLi7O+CWXy40pbQqFAoVCQUJCQqra7v+Qc/iiSa0hZjY3bKoM0Gq1BAUFERsbi62tba4QWoNdl5ubWxJRuznjhZNDfHw8vr6+6W6GMxepNT2vl7sryvP70IboiYywUCksWv9A/PrZaH1fGvex6PwLkuqN0Kk1xN98SNCQSfDxBid0sCXfqhk8XXKAoBN3sjw+cyPy4VsezdpB25W/srzWUNTy5O2Oms35gaJNqjC3w18EPv+yiZ0qQcXiHlMYd3QOP80azMt7L+g7YQBREdFUr1uVZm0b8/DeE9Ys28jZ4xcJy4Qn7ZeIXac38OFDOD07/5RixSirsHewIyhI/zAoFArZtXctFSuXZdXKDQwa1Ad7Bztmz1nGihXriEujoaxatQrs2b0O33f+VK3ShMCAzDtLCIVChv/+E3/9NSvZ9aFheqeDwl76JKh8+d158kLfHBkfH58m8TD1bo2KisLb29uYLmYaM2ttbY2lpWW2hufkJJKTH8jlcuO9QyAQpOmcY7relAybC+Hh4Zw4cQKhUEinTp3MdlyDdtrQMFi3bl2aNWuWoWM8f/5c75ZA3qiS/v+YX0geeZrUJic/0Gg0RiIZFxeXa3ID0E9j+fr6IpVKcXNzSzR9kRMw+N9GRkamaNeVnZVag4Y5Iwlt5hiP4WEmf/78ODo4QFQYqjO79Sud3LDsO46EwxvRPLph3Ec2cCLiEhXRKdXEXbhByMgZYJIM5rl9KcGXnvBs0X7yKl6uOoZHg4p02zqODa0nJFn//cqheFYvwey24wj1yRlPXXPBysEGp/wuOHg44eDuiJ2rI7bOdtg426OIVfBtx4bUaVMfqVSCvZM9l89c5eDuYzy6+4SggJC0T/A/gm3H1qLWaujYph8KRfp9eDMKOzsbAgKC8PT04NipHbi5uRARGUXvvl2YMWMRq/7ZSHx82k12M2aM46eBvZk3dwVzZi/L8gN2q1ZNEAgEbN6YNDjk5etrADRu0IHIyGgqVSrLmYv7gMShCumFVqtFIpFgYWGBnZ2dUapgSOAKCgpCJpMZSa6FhcUXK1dITn5g0BsD6eoNMXUZMlQ9zYk9e/agUqmoU6cO3t7eZj++SqXC3t7e+BkqlcpkZ35Nbb10Oh0ikcj4cCnQ6b9yG1/mX6F5kKdJ7ecQiUQkJCQQEhKChYVFtsfMpgZDddTV1RVnZ2eio6NzNGkovVP+2VGp1Wq1BAcHExsbm+GHiqyQWoN+Njo62nheMTriN88FrQakMqx+nonqxhlU5z6RU8tRixHlL4ROoST22HlC/0ocyuCxegaKWBU3hqzI1LhyEtcHLaXZxTnU+q0dVxbuMS7vsHEUTiW8mPn9GMID0m+LZC5Y2VnhmN8Vx3xO2Ls7YufqgK2zPTZOtljZ22Bpa4WFtQyJTIpYKkYsESOSiBFLJYilYnRaHcr4BARCAZY2VqhVahLiE7CwtECn05EQn4BQKOTyuWsIEOBd0Itx00Zg52CLSCwmIV5BQoISRbwCuTyeqIhowkLDCAoIwe9dIL5vfHn13IfQ4OQbi74ErNm9DBs7G5o37ExcbPYm21nbWFOsWGG2bF+JTgcxsbHMmrWENWu3olCkTWZdXJw4eXInTg4OfNe8G7du3jPLuEaPHcrmTbuTLN+8dQX58rkzbvR0bt24R8vvm7Bxy3Igc4T2c19Sw88GqYKTkxNarZb4+HjkcjnBwcGo1WojwbWysvqipAqpNWCnF9kp/dPpdMYmLnPbeBk+4xIlSvD3338btcMZafI23H//09TmPr4oUqtWqwkNDcXd3T3XvONMG6JMq6PJ+dRmFzLif2vuSq1KpcLPzw+RSJSph4rMjic5Ei/WaVBdOYo26C0Alr/OQ+v3ioTdH706pTKsxq1A5OiKVq4gatdRPsxMHGTgPLw/khLFONtgDNqE7JnKNSeUEbFc6b+QOlv+4PWpO4Q8ekvX3X9h6e7IzFZjiAqNyNRxZbZWOHk64+jhjL27E3au9ti5OHwipXZWWFgZSKnEhJTqv9BBQnwCCXHxxMfIkUfLiY2MITY8hrBn74iNiEEeHWf8io+WI4+Jw/OrglRoUJlCFYri4O6EVCzh+e1n3LtwhyfXH1OsYnE6DOnM711GUad5bZp0aEzzKu0STSPLLC1wcnXC2cUJZ1dHnN2ccXZ1Ip+3ByVKFeebejVwdHHAzt4WoUiIIj6BBIX+Ky5WTmRkFGEhHwgKCCHANxCfV+94/cInT8kZFq+bTYHCXjSp34HIyOz10/Xyzo9MZsHkaaOxsJBy4uQ5Tp++hFgi5tehA7CwkCKVWiC1kCCzsEAqlSKVSpBKJUgkEvLlc6NcudIcPXqawT+PSVVrmxFUrVaRQoW8mThhTqLlP/7Yk9atm3H82FmWL13Lz4P7MW3mWCBzhBY+TUmndm0VCoVYW1tjbW2Nq6srKpXKqLcMCwtDJBIZpQxWVlZ5OsghOfsy05k/ZTrS5Uwfdsydmnn16lXevXuHh4cH3377rVmPbYCNjQ0VK1Y0/m4IXUjP52ZIIPsPuY88TWoN/2SGyqBCocDJyQlnZ+dcGY9KpcLf3x9IWh3NTv9VA0xT0tLrf2tOsh0XF4efnx9OTk64urpm6qEiM+NJTrcrEAgQxMWgPKlvHJD9NAWUCuLXzNA3izk4Y/3HUoTWtmjjFUSu20340g2JjmvdrC623b7nbNspKEIjM/xacgth15/zfOVhOq4bSVRIOAJLKYu6T8bayQav0gU/kVJne6yd7LC2t8bSzhqplQVSmRSxhQkp/VgtBVNSGo88Oo64qFhiw6MJe/6OuIgY5NHyRMRU/6Vfpk7HA4FYKqZq85rU79YYr1KFsHd1QK1U8ezWU45vPsqzm0959+wt2o+ykPodGtBhaBfG9B7Hs3vPefHwJZVrV2LJlrkM6vSb8biK+AQCfYMI9E1bciGzkuHs4oSLm5OeCLs64eLujIenO2XKlaBuw1o4OusJsEAg0DeBKJQo4vW6yqiIKEKD9RVg/3cBvHvty6sXPoSHZe5hIj2YsWQC5auWpdm3HQl7n3mi7ZHPjdJlSlC8RBEKFy6Ip1c+3Dxcsbe3xcrKEpmlDCsrS1QqFVqtlrCwcNRqNUUKF6JAH09UKjUqlQqlUpXoZ6VSiVKlIj5egbu7K+XKlUan03HnzkOzEVqAkaN+4eyZy4keaMqVK8n8hZOJjIyiS4cfmDV3PD/+1CvVUIX0IDMetRKJBHt7e+zt7fWzCwkJyOVyIiIijFIFQxU3r0kVkqvUWllZJUrUksvlqepqTSUH5vZm37ZtGwAdO3bM1tlZUyJruM8Y/IwFAgG2trapVuD/q9TmPvI0qYXEulUHB4dckxsYCJ2joyNubm7pthszF0xtyzKSkmYOsm3qfevl5ZWlCMSMVmoNvrefRx1L0BG/eR5o1Eg7DkbolA/5rCGgSkDoVQyroTMQyCzRxiv4sGQDUesST1lKihXEdcrv3PxtFZEP3mb69eQkZPmdKNLjWzzqV8CqoBtIRTgXzY9IImbS2UUkyBNQxCmIj5UTHy3Xk9KIaPxe+BEbGfOxQvqJiMqj4oj7SE7TQ0ozCjsXe2q1q0e5byvjXjgftk52RIZG8OjqQ7Yt2MKzm0947x+a7L7VmnxN/yk/MXnQVO5ffQCAVqPlr/4T+PfMGroO6MDW1Ul1lWlBIVcQ4BtIgG9gmttaWlkmIr/Obk64uDmT38uD8pXK8G2TOkYCrNPpSFAkoFAkoIhXEBcXT2R4JO9DwggKCMbvbSBvX7/l9XMfIiNSDzUwxZipw6nb+BuaNehEgH/ypN3FxYlSZUpQomRRChUpiHeB/Li7u2LvYPeJrFpaokNHRHgkoSEfCAoMxvetP1cv3yQkKJTqNSrzfbvmRv/NM2cu0aJl93SPE/RxuRfO72f8XzN5cP8pe/evQ6VUsXzZvxk6TnLw8spPgwa1KV+2vnGZTCbj6nV9VGthryps3bmKZs0bZJnQQtY9agUCgdGc3yBVMFRxg4KC0Gq1iaQKORmOkxySI7UCgQCJRGKs0oaGhqZq0xUa+ul/2ZyhCGFhYZw5cwaxWEzHjh3NdtzkoNVqjRzj6tWrPH36lJCQEEJCQnB3d6d9+/Z89dVXREVFERkZiYuLS6KqtCCPhC/kncelnEeeJrVyuZzXr18bdavv37/PUd0q6AldWFgYHz58wNPTM0VCl52k1kDsDTrijExjZVV+kFkynRLSS7JT870V6zSobpxG6/8KSf22SMrWIG7uMHSxUYjKfY1lnz8QSKRo4xWEzVxJ9M6jiQ9uZUm+dXN58c8x/A9ez9LryS44VilOofbf4FqzJBbuDuiEQiSWFggEoFap0ag1HFi4kxsHLhEXFYcqIe3pweyGd8mC1GxXj5I1y+CU3wVLWysCXvnz4NI99q3aw/Pbz4iNSptslK1VnqGLfmfuyPlcO5348wkL/sDkn6cy6e/xXD13g7evfLPr5RAvj8fvbQB+bwPS3Nbaxuoj8XXG2dURJ1cnXN1dyOflTqUq5WnUvD4OTg7Y2tug0+pQfJQ/KOIVxMbK9QQ4OIzAgGD83gbg8+odjb/7lo692rJm1Sb6/dANrwKeuHu44uBgj7W1FZaWMiwtZQiEAiLCowh7/4GgwBD8fAO4ee0uIUGhhASHEhz8ntCQ98TGJG3e6dilNX9OHoFUKuHe3YfUrlsDlUpN9x4/Z+i98vTMx5nTe1ixYj0rV+hnRDq278/O3WtQq9SsWpU+f+WUMPTXATx58tzoyAAQFq63titasBrnrxygfPnSZiG0kHIYQWYhFAqxsbExTlOrVCqjXVRoaChisdhIcC0tLXNcqpBSZVosFhtJrZ+fX6qk1iAPA/jqq6/MNrbdu3ejUqlo1KgR7u7uZjvu59BoNIhEInx9fVm/fj1nz54lMPDTw6+3tzcNGzYE4N27d/zxxx9otVomTZqEl5dXto3rP2QMeZrUWlpaJiI0QqEw2yxskoNGo8Hf318/BVekSKrC8ezS1MbExODv75+sXVd6kBWynRUynRLSQ7LVajX+/v7odLpkZR6CuBiUxzYjKlsTaYOOxK+YgC40AEm977Fo3Q+BWIw2XkHoXwuIPXIuyfG9dizlw53XPJ6d8UqfuSG0kpK/UWU8m1XBsXJRpI42aHUgkUlJiI0n8JEPPvsvodPqqNKtATYu9hxZuY+Taw6TkMsRr+W/rUy1lrUoXLE4Dq4OCMUiXt9/yaXDl3h68wlvHr5ClcEKcJHyxRj1z1hWTvmbM/vPJrvNzXO3OLj5MKt2LaFZ5bY5/qCbHOJi5cTFyvH18U9zWxtb60Tk18XNGRd3fQW46tcVadqyIV6F8qPVaomOiqVBwzoEB+nJ6r1bDwgJCSMkWE9YQ4LeEx2dcd1o244tGDN+GDJLC2ZNXUxUZDTzl04lLk7O+fNXM6TbtbOz5drVI+zfd5TJEz9FUV+4cI3OnX5k+45VKJVK1q3bnuFxAtjYWNO7T2daf9/LuOzp80sAtGjalcvXDuORzw2tVmu2rvvsjsiVSCQ4ODjg4OCATqdDoVAgl8v58OEDSqUykVRBKpVm61gMU+7JncN0ZvTRo0fUqVMn2WOo1WqePtU/ZBQqVIjChQubbWzZ1SD2+XlEIhGvX79mzpw5nDt3Lsk29vb2Ri4ilUrJly8fV65coV+/fsZY4P8SxXIfeZrUCoXCRBW67J7iN0V8fDx+fn7Y2Njg7e2dJqEzt6bWYNcVERFBgQIFMi28z2ylNjY2Fn9/f1xcXHB2djbbRTWt8SgUCnx9fbG1tcXDwyPJecU6DfFb5iF090bWaQiKrYvRvHmMtN0PSOu2RCAUoY1XEDxiBvKz15Ic333pJFQ6EVd/XJLIASEnYFXQFc+mVXGvXw67El5I7a311QGpBLVSRdDjd/jsuYj//dcEPHiDPDyGfKUL0nbeTzgXdOfUuiMcWbmP+Ojs7XxPDhbWFnzdqjYVG1fHs4Q39i72xMfG8/TmEw6u3sfTm08IeOWfpf8Bz6KeTNgyhU2Lt3Bg46FUt101fTWValVk8cbZDO4+ItPnzA3ExsQRGxPHu9fJV5kXb5qDnaMtndsM4Onj58luk1m0atuMPyf9jrW1FXNmLmXTuh1UqlKOzTtXsWL5On4a1JuBP6X//ZRKpdy5fZIb1+8wZPDYJOvPnb1M926D2LxlBSqNJlkrrrTQq3cn3oeGce3qbQA2bFqKt7cnkyfOZde+tVhaWqLRaBJZUGUV2U1qTSEQCLC0tMTS0hJnZ2fja5HL5URGRqLVahPF+JpbqmCQHiT3erVaLRYWFiQkJHDu3DkGDRqU7DGuXLlibBRr0aKF2cZ28eJF/P398fb2pnbt2mY77ucwvPYNGzZw7tw5rKysqFGjBvnz58fNzc1YLTbwkZIlS/LXX3+xZs0aDh06xOrVq4H/NLV5AXma1H6OnCK14eHhhISEJNFxpgZzjs1QqdRqtRQtWjRL1jAZHZep3MLLy8vsXZ2pkdqU9LMGiHVaVHfOo414j9WwhShP7kR95wKyH/5CUk6fHqSNVxA0eCLxV5OmDTn+3B2LKuU40XAMmvjs8/hEKMS1Rgk8GlbEpXoJbAq6Iba1RK1SIxSJ9NZkT315u/cSfvdeEfDgDTEhiRuNXIrko+fakbiX8ObCtlMc7D6JmPD0azGzCidPF75pV58ydSvgWtADWwcb3ge85+GVB5zefYrnt54SHhJutvO5eLoydc9s9m84yNblaVf0NGoN4/qO598z/9Chdxt2rd9ntrHkFqRSKRuP/YNEJqFpvQ4EBZrPf7d5y0aMnzoKWzsb5s9azoZ/t6FQJFCiZDE2bl/JpIlzaNykPmfOXCQiIv1V2ps3juPrG0DPHoNT/L8+dfICvXsNYf2GJSgTlOzccSDdx9eHLQxi6uR5APTt35V27Vpw7sxl/hw/HKFQiFqtNrtHuDksrjILkUiEra2tUepmiPGNiYkhNDQUiUSSSKqQVfKdkn7YUEH+7rvvOHjwIPfu3ePBgweUL18+ybYbN+rlJfb29vTp0yfJ+rCwMH755RfevHnD8OHD6dq1a7rGZkgQ69SpU7Y9ZBgeYK5du8bZs2dxdXVl6NChNGrUyBim9OTJE168eGGU32m1WgoXLszUqVMpXrw406dPB/R62rygqf2P1H4hyMlmrIz6rxrGltUn/IwmdKWFjFRqNRoNAQEBqFSqLJPpjIwnNf2sAUKhEEG8HOWJrVj9tgD1w2soT+3GctRixF76pgRtnJzAH8ahuPckyf5W9b/Gvl9nzneaTnyA+ayaxPZWeDapgludMtiXLYiVh5OewCqU+u5ZkZDQF/683f8U3zuvCHjwmkj/lH1k7T2d6TD/ZzzLF+HagUss+HEWkZm06coIilQqTs02dfmqeikcPJyRWVnw7vk77p+/y5NFW3lx9znxsdkTLmLnZMesg/M5e/Ac/8xYk+793ge9Z+rgGfy1fBzXL9zEzydt7WtehaOLA1tO/Iuvrz+9mg9KVv+aGTT57lsmTvsDewc7Fs5dybrVW42hCR753Nh/dBN/r1jPpQvXmTBxJMWKf53uY184vw+1Wk27Nn3TlIUdO3qG/v1+Y83ahajUavbtOZKuc7Ro2QixWMS6ddspXbo4S5ZMJy5OTv0G3wD6ePD02E1lFDlZqU0Less0qVGqYPDGDQsLQ6lUYmlpmSjGN6PjTkk/rFQq0Wg0tGvXjjdv3vD48WPGjBnDxo0bcXJyMm63adMmLly4AMCECROSdT7YsGED9+7dA2DatGm0adMm2eu8KUJCQjh37hwSiYQOHTpk6DVlBIbmsCtXrhAaGsr06dNp164doJ85lMlkREREIJPJjPdEw/ul1Wrp3bs3R44cMb6+/5C7yNOkNicdBhISEvDz88PCwoIiRYpkyn/VQNgyezE0VIgzktCVnnFpNJo0t0tISDDmnHt5eWVbleJzUqvRaPDz80tWP2sKsU6DYut8LAdOQRsaQMK+f7GesAqhoxs6rRZtXDyBfUaR8PRV0n298+E2ewx3xvxL+O2k69MLuxKe5G9aBefqJbAtmg8LZzsk1jKU8QrQgUgqJux1EG8PPsPv9kv8H7wm/G1Iuh4qrJzt6DB/EIWql+TuyZssb7yYD/7ZExQgFIuo3LgaVZrXoGD5oti76G+WL+484/Su0zy98Zi3T3zQqNP+u8kqZDYy5h5bzK1Lt1k4dkmG9792+jrHth9j9e5lNKvSNttt9bIDxUoW4Z+9Szl3+hK//TzOLBnyDZrUZcqMMTg5O7Jo/t+sXbUZufzTQ4mdnQ0nzu/m4MHjTJk8nx27V3P27GXCwyPTdfw9u//Fw8OdOt+0SjMm14BDB0/y08CR/P33HNQqFYcOnkxznz9GD2Hb1r1IpVJu3DoBgLW13lYqPbG3mUVeIrWmMMTVGqy1DFKFuLg4IiL0D7+mUoX03MdSqkobqt9OTk6sWLGCwYMH8+DBA5o3b06rVq1wcHDg1q1bXL16FYlEwpgxY1KUHpj+Xxo0vGlh165dqNVqWrRokYhEZxeeP3+Ol5cXNWvWBPTvreF+JJfL9WE/KdyfypQpw7179/7T1OYB5GlSC4lJUHaRWsO0d2absQzIrH7VEPsrl8vN4jBgivRofQ3paIZQi+yE6XuUln7WAJFOi/rBFcT124FQiGL331j/uQKBWIJOo0UbE4t/z99RJadRlEnJv3khb7ac492Oi+kbpFiIR/3yeNQvj2OFIlh5OiF1tEUsk6KUK9BqtEhkUsLfhfDu9gt8b70g4MEb3r8KMHqsphcyWyvazh1IsTrleHL5IRNbjCT4Tdp2UxmBlZ01NdvVo0LDyuQr6oWdsx3RETE8ufaI3Ut38PTmE4Lf5nysrlgqZv7xpbx49JLpQ2dlmpAun/w3FWtWYMH6WfzWa5SZR5m9qNv4G6avmMA/KzYwd8ayrB+vQS2mzR6Hq6szSxeuZtXKjcg/I51isZjTl/Zx+9Z9hg4eR+kyX1GnTg2Kf1UjXedYsWI21atXonatVukmwQbs3XMEsVjMmrUL6dVzMMePJd8MCFCpcjmKFStMg/rtCY9MrC2Wy+XpeljPLPIqqf0cplIFnU5ndFWIjo4mJCQEqVRqrOLKZLIUdbPJkVqDRtnKygp3d3e2bt3K7t27OXDgAIcOHUIul+Pm5kbnzp3p0aNHqo4HPXv25Nq1a/j4+DBs2LBU/W4NY9q1S6+/zs4GMVMEBwdToEAB4/1XJBIZ/8bkcjkeHh5JSK3h/TR45wvQIST3H6wFeWAMuYU8T2pNYW5Saxq7apoOllkYxpeRKq+pD29mKsRpITWibWhGi4yMNMvrT+94tFqt8UHCw8PDqFtKaXuhSolap0PsWYSE7cuwHjYHnSIOLKzQRETi320Yav/gZPf33LqYyGcB3J+0Odn1MjcH8jetjGut0tiV8kLmYo/UzgqhRIxKoUSjUiORSYkK/IDvnZe8u/mMgAc+hDz3RaPK/E1VLJPSZkZ/Sjapypu7L5nWbhz+z95l+nim8CiSn1rt6lGqdnlcvFyxtrchyCeQB5fuc3jDYZ7ffkb0h+xNpUoLQqGQeccWE+QfzPgfJmX4YcAUGrWGsX3Hs+bkKtp0bcm+rak3meUVdBvQkV/GDmTciKns3LY/7R1SwTd1qjN93l+4e7ixfMlaVi1fn6KE4dTFPQQGhtCrx2C0Wi0TJo7k7NnLhIWlrZGeOGEk7du24Nv6bQkIyNyD0M4dB5CIxWzYuJRuXQdx+tSFZLcbOfIXLpy/yp17pxItz2xKWEaQm5razEIgEBilCo6Ojmi1WhQKBXFxcYSGhhobnUxdFSBlAm8gtYYmyi1KuQABAABJREFUZbFYTOfOnencuXOGx+bm5sbOnTvTvb1QKOTs2ZQfeMwJw2sXiUTI5fJkq7EKhQKpVJpipdbcmu7/kHl8caTWXE/nhrhXoVCY6rR3RpBR0h0TE0NAQIDZHQbSMybDtL+hGS0nzb9jY2OJiIhIUT9rCrFOi+b5HSQVviHh9B5kPYejDQ9B6OyJ+n04/t2GoQlJXqPqOncMWktrLvedBlodjhWLkK9RJZyrfYVNQTekjjZI7fREXp2gQp2gQmIpJfp9FP73XvH2+lMCHvoQ9Pit2cIJhGIhLSf1pVzrmvg/82VOt0n43M+8JAKgVK2yfP19bYpWKYG9myNSCwlvHr3h1pkbPLn+mJf3XqBU5L6PrSlmHpxHnDyeP3qMRaXM+nsb4h/CjN9mMXbxH9y4fDtd6WK5idEzhtOiYzP6dhvM5QuZ90quUasqM+aPJ7+nByuXrWPl0n+JiU7Zp3XvkQ0gENCuTR+USiWlSn9F3Xo101WlHTSoD0OG9Oe75t148eJNpscMsGXLHiRSCVu2rqBjhwFcOH810fr8nh40blKP06cuUKiQt3F5VFRUjpDNL6VSmxqEQmEiqYJarTa6Knz48MG4PiXnAwNRy4liR27C8Nq9vb05d+4cUVFR2NnZodFoEs0qWlpaplipvX//PvBfo1heQJ4ntaaVRpFIZJZKrcGuKitxr8khvV61Op2O9+/fEx4ejre3t9lzsj8f0+eVWoVCwbt377Czs0t12t/c0Gg0REdHo9VqKVasWJpEWqTTogsPRlyuJuont7Fo3AFtwGsE+YujCgwhoPswNOHJVByFQlwn/Ypds7rE+ITQ9OJspA42iGX6yoRapUYVn4BQJiEmNJKAB2/wuf6UgAevCXz0FmWc+f1fhUIhTUZ3oXKXbwnzC2VR/5m8uJ60oS0tSCwkVP2uJlWafY1XqULYudijUqp4dvMJRzcc5tmtp/g+e5cnvFtTwuSdMxBZSBj6/RASFOZzobh8/Aond59mzd5lNK/SzmzHNTeWbZtPibLFad20O8+T0YCnB9W+rsSsBRPw8s7PPys3smzxGqKjUq9grl6/EO8CXtSt/T2xsfoq7oSJIzh37kqaVdr27VsyfeoYOnX6kTu3H2RqzJ9j/brtiMViduz8h3Zt+nLlyk3juiFD+hMREUHLVk2MBPPx48dmaYxKD/4XSO3nEIvF2NnZYWdnh06nQ6lUGqUKSqUSPz8/rKysjD658fHxxmQ0tVrNnj17OHDgAK9fv0Yul+Pu7k6tWrXo3r07xYsXz/L4Ro8ezd69e9O1bffu3Rk/fnyWzwmfiGn16tU5fvw4s2fPZtKkSYmkeIaGseTuWRcvXvxEaskbhDIvjCG3kOdJrSmy6jBgSiazw64qPfpVQ6CDRqPJNoeBz8dkSnAiIyMJCgrKkF2ZOWDQz4rF4lQF9wYIBAJEYgk4e6CJ/IC4VCU0Po8RFiyLysePgN4j0X6sSAltrLBp1QCrejUQFy6AxNURgViETqvDuoArqnglCATIw2MIeOTD2+tP8b//msCHPsRHmafLPDV8+2s7avRtSnRYFCuHLODR+Xvp3tfe1YFa7etTrn5F3Arpo2YjQsJ5dPUhF+dt4unNJ4QFZE9DWXZg9No/cc7vwsDvfiEuxvx+u0snLKdCjfLMXTONEf3Hmf34WYFUKmXziTUIRAKa1G1PSHDGP7dKVcozZ9EkChTyYu2qzSxduDpdQQnTZ/9JzdrVqV+nNR8+EtiSpYpTr36tNKu09erV5J9V8/jxx5GcO3s5w2NODWtWb0YqEbNn379837InN27cxdrair79umJjY228nsbExFCgQAGzNEalB/+LpNYUAoEACwsLLCwsEAqFKBQKbG1tkcvlzJkzh4sXL1KgQAEcHR05efIk//zzDw8ePMDBwYGWLVvi4ODA7du3jTrbsWPHptumK6+iZcuWLFmyhJMnT6LRaGjatClly5bF29sbpVKJhYUFWq0WpVJpdIY4e/YsU6ZMISFB/3D+X6NY7uOLIrVZcRgwp/drSkhLfmCw68rJCqnh/TLVD6dn2t+cMDSieXh4oNVqjReA1CDWaUGtBaEIoZU16tcPERWpiPLZG0ImLsK+dzssv66E0NMDqbM9QrEIrUarb+TSgUaeQODjt7y98RT/e68JePiGuLCc83kFqDXgO+oM+h6FXMG/f6zgzvEbae5ToHQharatR4maZXDK74yljRX+L/24f/Euu1fu5sXtZ8RFZz8Rzw4MWTiMIuWKMfC7n4lKrsJuBqhVasb2+ZPVJ/6mZadmHNpxLFvOk1G4uDmz+cQaXr9+S5+uvxAXmzFCX6FSGeYsmkyhIgVYv2YbSxasSneT1m+/D6Rj19Y0btgRX99PtmcTJo7g/IWrqVZpy5crze5daxk3dgb79qbPhiujWLFiPRKphP0HN/Ddd92o8XUVbGw+zV6Zxt5+3hhl8HCNiooiODgYmUxmrOJaWFhk+hqbknfr/yIMfSDW1tZYW1sze/ZsHjx4wK5duzh//jxDhgwB9DKEfv360bp1azw8PAC9ndeUKVOYNGkSDg4ONG/ePEtjcXNzY926dWluZy53oM+POWrUKMaOHcuZM2e4efMmpUuXplChQqjVal6+fMnGjRtRKBT4+fkZLcAAihcvzsuXL80+pv+QcXxRpBY+EceM6KpyikymRmojIiIIDg42q11XemCw9PLx8TGrfjg9ME1FMzSihYeHp1nNFul0CIQCEArQRYahif6A6KsqqKPiEBb0pODeFfon5jgFQpEIdYKK4PuveXvjmT7M4P4booPNFwyQUVTuXJ+Gv3dEp9OxdfK/XD94GV0yfxdCoZBy9St9jJothr2rA0KhiFf3X3Dx0AWe3XjC64evUCuzx7YoJ9Fv0g9Uql+FQS0HExZsPp/g5BDkG8ys3+cyZt4Ibl2+S3CA+UIMMoMSZb/i712LOHnsHL8P+StDfQFlypVk3pIpFC1eiI3rdtKxdV8+fEi/b3GX7u0YMvxH2rbuw9MnLz6NqWQx6n/7DSVK1kpxX29vT06e3MHSJWtY/c+mdJ8zM1i8aDUSiYQjh7dgY6sntDqdLhGh/Rym1UZDY1R8fDxxcXEEBwej0WiMBDejSVyG2NT/D/j8fioWi6lcuTJv377l2rVrxiJEzZo12bZtG3fu3OHvv/8GoEePHpw/f54LFy4wceJEateubQyNyAwkEglFixbN2gvKAtq2bUtoaCjLli0jJiaG69evc/36dcRiMbdu3eLWrVuJthcKhXh5eTF16lQ6d+6MUKdDmAdsBfOCA0NuIc+T2qx41ep0OsLDwwkNDc0RMpmcftVg1xUXF5fhQAdzQKlUolAocHV1xc3NLUf1s8nJLNKyPRMIBIiEQnRCIaqoWMQ2Loid8+l1rjIpQpGIgPuveXfzGb73XhNw/w0RfqE58prSQtmWNWg2rjsiCwm7Z2/m8q5zibxeZdYyqn9fh0qNq+JZogB2zvbIY+J4cuMJ+//ey9NbTwh8HfBFeq2mhs7DulGvfQMGt/6VwHc508B14fBFqtevxpp9y2hRLfuM29NC/eZ1mLp0PMsXrWXR3JXp3q9k6eLMXzKV4iWLsmXjbrq0/4Gw9xl7GGjUpB7TZ4+jd68hXL92O9G6CRNHcOnSNUJDk2+ydHS05+qVw+zadYhpUxdm6LyZhUAgMBJarVZLXFzGZiSEQqGx2ggY7a1iY2ONSVwGkptWEtf/uvzAFCmFL0RERBgfKipWrMjy5cuTvTb17NmTCxcuEBkZyfr16xk8eHC2jzm7IBAI+Omnn3B1deXo0aM8fPiQqKioJH7IFhYWyGQyvv76a6ZNm0ZUlH7mSUDe0LP+//jLTR55ntR+jvSSWq1WS0BAAAqFwuzer+kdm0F8b3j6zOknf0OYg1gsxt3dPcfOawhysLa2xtvbO9EFMzlSKxQKEWh1aBNUiK1kKBNUoFMjsrHi/atA3t16jt/dV/g/eMOHN0F5jvQVr1+BlpP7IrO3Yv/CHZzbfAK1Uo2zpyvfdPgYNevtjrWDDe8DQnl4+QGndp7i2a2nRITmXkU5J9ByQGta/NCa4Z1G8PaFeSzL0otFfy5hzYm/mfn3ZEYPNE9TSUbQa1BXBo7szx/DJrF3Z/psxop/VYT5y6ZRsnRxtm/ZS48ugwgNyYz2thwr185j+PAJnDh+LtG6r0oU5dsGtSlVunay+1pYWHDr5kkuX77BsF//yvC5MwIXFydmzR5Ps2bfYu+gT6LKDKFNDhKJBAcHB2MSl8HeyjSJ63N7KwP+P5FarVabrBzv+fPnxvtZ/fr1gaRFJoBatWohk8lQKBQcOnToiyW1BsmJQCCgffv2VK9enevXr/Ps2TOCg4ON5NbS0pJy5crRrFkzSpUqBZCI1OaFv5q8MIbcwv8kqTWQKktLS4oWLZpjfoOmYzM4LGSnXVdKMA1z8Pb2JiAg5+JD0wpyEIvFODs7I9IBWh1aQKNU6b1gQyPxvfUc3zuv8H/wmvcvMx5mkJMoVL0U38/oj627I0dW7MXn7ksqN/uavw7MwtHDCQtLC94+fcu9C3d5ev0xL+4+RxH3/8fPsEGnRnT+vRtjev3J8/sv0t7BzFAlqBjT5y/+ObaCZm0bc2xv2glW5sKfc0bRpE1Denf+mauXb6a5feGiBVm4fDqly5Zg9/aD9O0xmOCgzM1AFC5cgO171zBr5hK2bt6TZP2EiSO4fPk6wcFJjy8UCrl18zhv3ryjT6+h2fYAWaVKBebMHU+58qW4feuBkdCq1eps8fwUCARYWloaewlMG85M7a0MJPdL9KnNLFJ6rW/efLJtK1OmTIr7i8ViSpUqxd27d/Hx8eHt27cUKlQoy+NKSEggMjISmUyGnZ1dtt9DTd8DnU6Ht7c33t7eqezxH/Ii8jypzaj8wGDq7+7ujqOjY46SSYOPbmhoaLY5LKQFlUqFr68vEomEIkWKGN0ishumzhKmQQ4CgUB/sVBp0Gi0WEsskVjqwwz87rzk3e0X+N9/TchzPzRfiHY0X9lCtJv7E+7FvUiITyA2Mobvfm6LVqPlxZ3nnNp+kmc3n/D2ac5EzeZF1Ghei36TfmTiT1O4f808FlCZQYBPAHNHLeDP2SO5ffUu74OTn243J1buXESREoVo1bgbr9Lwcy1YyIuFy6dTtkJp9u85wg99fiMwIPkgkfTAxdWZw6e2sWH9DhYv/CfJ+uJfFaFBwzopVmkvXtiPQpFAh3b9siWCtk+fzowY+TNu7q5s27KHcX9M5+Q5fXKUUqlMVxOpOZBcw1lcXJzRHcZw35BKpVlqOPsSkFJTXHj4p1mkAgUKpHoMb29v7t69C8CLFy8yTWo1Gg2bN29m586diSrFVlZWVKlShS5dutCwYUOzfx5hYWGcPHmS2rVr4+3tbZxRNJzftEndINcwjCEhIYHTp08Dei1rXtCz5oUx5BbyPKn9HCmRWq1WS3BwMDExMTne3W+ATqcjMjISkUiUI3ZdnyMuLg4/Pz+cnZ1xcXFJ8o+ZXTDoZ9VqNSVLlkQsFqOJV6LRaJFaWRAb+jHM4OZz/O+/JvjJO1QZCAMQioSIpGJEErH+u1SMWCJBJBEjFIsQf1wmEos+ftdvK5SIEIkN3z9+SUQITZYJRSL9zyIhQsnH38UiRCIRQrEQoUj4aZlERJFvyqLRaBFLxUSEhvP42iPuX7zH81tPCc4hvWheR7lvKvDL/F+ZPWIe18+k7fiQ3Tiz/yzV6ldl7f7ltPq6U7adx0ImZcvJf1FrNTSp2573oSlrYL29PVmwYhoVKpXl4P7jDPphJP5+WYtHtrKy5NSF3Zw8eZ5xY6Ynu834CSO4cuVGslXaA/s34OzsRN3a3yOXm69aamVlxZSpf9ChY0tUKjVLFq5my6ZdeHp6cOm63lFBoVCgUpkn4CSjMG04c3JyQqvVGoNpgoKC0Gq1mW44+xKQnKZWp9MlSm5zc3NL9Rim600rvBlFcHAwkydPpmbNmowZMwYXFxfCw8M5deoUFy9e5OLFi3z77bfMnTvXLAUjg8zk9evXzJkzBxcXF7y9vY3LP5cMmpJpwzaxsbEcPHgQ+OhTmwf4pPB/9xksTXxx/53JpYoZtKtisZhixYrlSteqQqEgMjISiURC4cKFc3TqSqfT8eHDB8LCwpJUh9PjnZsVJCQkEBsbS+ECBVElqNAmqFEmqDE8KCqi4xBJxRT6uhSFa5aGj0+8AoHe3UAg+HihMCwXfvqOocoLaDX6irNOq0Wn1aHT6oxVaJ1Gi06rRavVr9caftfo0Go0n37WatGqNcZtNCY/a9VatNqPy9QaNBoNWo0WlVqDRqnCxtmOQjXLIJKIQaiBj0/s1nbWCAQQFvTleMVmJ4pVKM6of8ayfNJKzh44l9vDMWLBmEWsObmKaUvHM27wZLMf39XDhc3H1/D82Sv69RiCPAWZSX5PDxYun06lquU5eugkQweNxvdd1uVBQqGQ05f28eTJCwYNHJXsNsWKF6Zxk7qUKl0nybp/Vs2jYsWy1P6mFRER5rFbK1asMPMXTOLrGlV49vQlv/4yjpPHz6HVamnc9Fu27NA3zsXGxuYpnbxQKEQkEuHg4IC1tbWx4SwmJsbYcGYguGk1nH0JSE5+IJfLjZ+JQCBIM1XMdL1BX5oZiEQiZs6cyffff59oeY8ePdiyZQuTJk3i7NmzDBs2jL///jvL91kDMY2MjEQul2eIOxg+d4VCgUJh/sCe/5A55HlS+/kF4/NUMUPUrGl1MqdhmLKytbVFKBTmKKE1NMQlJCRQpEiRJA0PplMm5n5vYmJiiI6OxtvDE/n7aORyBfsmrTeSR61Wi07zkTR+JIl6wqlLTCg/rtdp9MTy0zL9/rl9wytRrzy9lv3GyXVHePvoDX2nD2Rkk6F8Vbkk5etWpNNvXRk4/ReiPkTh+/wt145c4dKBC3kumja74VnMm782T2bDwk0c2pw9nqaZhVKhZGzvP/n76HIatfyWU4fMlytfukJJlm9fwNFDp/hj2KRkLbvc87mxcPk0qlaryIlj5/i2Vmve+viabQzHz+0kMjKKrp0HpmgZNn7C71y+fJOgoMQWZ1OnjOH775tRv24bggKzbn/WslVjJkwcSaFC3hw5dJLvGnfhyePnxvU/DurFtJn6YAzTamBeginR+7zhLD4+Hrlczvv371GpVMaGM0PC2ZeGlEitAZ/fU5KDaSN2Zpv8evbsSZcuXahYsWKy67t168bNmzc5cuQIFy5c4MCBA7Rp0yZT5zLAcG8xyF6io/Ve5mq1Ol2f5dOnT1m4cKHRo1aADkEemPrPC2PILeR5Uvs5TFPFDB6o2R01mxIMkofY2FgKFy5s9EjMKSiVSnx9fZHJZBQpUiRZMp2VwIqUYNDPajQavD08OTl2LX7XntH39CysnW25d/Bq2gf5QvBNzya0HNONjZPXcm7rKQBa/dKOTiO6s2rkUm4c1b9WW0dbSlQvTfm6lWg/pBM/TBtE9Ico/F74cvXoFS7uPfc/TXJdvNyYtmcW+9YfYNuKHbk9nGTh98afBWMWM3HBGO5ev8+H91l3nmjc8lsmLBrLkvn/sHRBUg2rm7sL85dN4+salTl98iIN67Tjzeu3WT6vKbbtWY2VtRXf1m2DIoXY4aLFCtGkSX1KlUlcpR08uB+DBvWmWdMuvHrlk+kxCIVCxowdSt9+XZHJLFi1YgNr/9mcxFN35tzx9P+hO5B3CS2k7H5gqFpaWVnh4uKCWq1GLpcjl8uNDWemCWdfQrOZOe4N5nidqTWjGdCjRw+OHNE/MG/atCnLpNYAQ6V1+/btlCxZkpIlS6JWqxNJTUzfp/DwcLZv387KlSsTyWb+s/TKfXyRpFatVvPu3btsTQdLC4aGLLFYbLTrUigUOVZVjImJwd/fHzc3N5ycnFK9KKXlDZsRaDQaAgICsLS0xNMtH8dGrOL5oesAnPpzHZ2mDuDp2XskxH75Xf5tJvamWof6LPhxFo8u3jcuXztmJeO2TWbbrI1Eh+mn2mIiYrh1/Dq3juvfCxsHW0pWL025OhVo+1N7BkweSEx4NL4vfLl+7CoX9p4jQf6/MWVl52zPrIPzOL3/LKtnrs3t4aSKk3tOUf3bqqw9sILWNTtn6Vh9h/RkwLDejBjyFwf2Jk4uc3ZxYsGyqdT4phrnz1ymcb32vHqZedKYEpb+PZOSpYtT95vviYpKmSSOn/A7V67eSlSl7dy5NZMn/UHH9v25d/dRps7v7u7K3PkTadiwDiHBoUz6aw779x5NVh+7bfc/NGxUN81QhbyA9BI9sViMnZ0ddnZ26HQ6EhISkMvlREREEBQUhEwmM1ZxpVJpnpQqJFepNZUTKJVpP4ybTr9nZ4GpQoUKSKVSlEoljx8/JiYmJkthDwYYJBN3795lwoQJLFq0CA8PDzQajVGSIBAIUKlUXLlyhSVLlvDo0SOjVMUwOyIkb5DavDCG3EKeJ7WfXwTUajWRkZE4OTnh7u6eKxcJg13X55KHjARDZBamLgMFChRI1wXEMK6sao0NVmmurq442Tpw+NcVvDr+KWHlye5LlGr1NT9tGMOidjnvC2pO/LB+NJ5lCzOp3Rj8nyeeJn5z/xX3z9/lt+WjmNxpXLL7x0bGcOvEdW6d0JNcazvrjyS3It//0IZ+E38gJjwav5d+3Dh2lfP7zqKI/fJIrqWNJXOPLeLWhdssGrckt4eTLswduYC1Z/5h0oKxTBiWfENVWpi4YAwNWtanR4eB3Lh2x7jcwdGeBUun8U29r7l04RrNG3Ti+bNX5hp6IoyfNIKGTerxbd22hKTiZVu0WCGaNP2WsuXqGZc1+LY2K5bP5ocBw7lw4VqGz12rVjVmzv6LUqWKc+nCNbp2+JEb1++kuP3Fa4coWar4F0FoIXPVS4FAgEwmQyaTGRvODLZhgYGBaLVaYxXX2to6zySWpUVqdTodcrk8VV2t6QylnZ2d+Qf5EQbPdUMjX2BgICVKlMj08QzFnvDwcFxcXGjSpAmHDx9m3LhxLFy4MBFhfv36NZs3b2bbtm3G+7yjoyMlS5bk9u3b2WJF9x8yjjxPag0wpINFRkZiaWlpzJ7O6TGEhYXx4cOHZO26spvUppTSlRbMUak1VIYLFiyIjYUVB39ZwpvT95Jsd2T4Kvqfn0utHo25sinnfEHNBbFMyrAD00AsZGyz4USGJh9Junnyv8w+s4QiFYrz5n7amd9x0XHcPnWT26f0nqVWdtaUqFqKcnUq0KL/9/SZMICYiGgCXvlz/fg1zu0+nedJrlgqZv6JJTx/8ILpQ2fluvY5vUhQJDC295+sOLyUM8cvcP7YpQzt/8/epXgX9qJFwy68efUWAHsHO+YtmULdb2tx9dJNvmvUmWdPsi8LfuDPvejVvwvNm3TBJw1t7p/jh3P9+m0CAvTuHBUqlGHnztWMGT2NA/uPZ+i8gwb1YfDQ/rg4O7Fpw0769xqapmvDk1dXcHV1/mIILaTs3ZoRCIVCbGxsjPcJpVKJXC5P0nBmbW2NTCbLlQJNSv0Whs5/QwUyNDQ0VZuu0NBPbhpFihTJlrEaYJrKaS65X1xcHFKplK5du1K0aFGmTJnCtGnTmDFjBnFxcRw5coQ1a9bw7p0+QEYkElGhQgUmT56MQqGge3e9pOY/TW3u44sgtYYpb6VSiZubW648ERnGoFKpkm3IguwltQqFAl9fX2xsbJKkdKUFgUCQ6XGZEvnixYsjFYjY/+NC3l54mOz28eExHB3+N60W/sTD4zeJeR+ZqfPmBuzcHfntwDQCXwcwf8AMFHEpk8oPgWGc+PcwgxcNY3j9nzN8Lnl0HHfP3OLumVswaQ2WtlaUrFaKst9UoHmvFvT+sx+xETEEvPbn5snrnN15GnmMPO0D5xCEQiHzTywh0DeY8T9MyvYZCnPj3UtfFv+5lKmL/6JVzc5EfohMcx+ZlYytJ/9FkZBA03odCHv/AVs7G+Yumkz9RrW5deMurZp24/HDZ9k69rYdWjBq3K906jCABw+epLptkSIFadasAeXK1wegYEFvThzfwYL5f7N2zZZ0nc/GxpoZM8fRpk1z5PJ4Fi1YxfYte9Nl++UXch+ZTPZFEVrInkQxqVSKVCpN1HAWFxdHaGgoKpXKqMPNyYYzw+tM67X6+fmlSmr9/PyMP3/11VfmGl6yMG1iy2pV2KCZ/eGHH2jbti0FCxakePHi+Pv7s27dOiwsLFAqlezduxfQk1k3Nzf69OlD9+7dEYvFvH79mvr163Ps2LH/5Ad5AHme1Go0Gl6/fo21tTVFihQhNjY2R5uxIDGh9PLySpFQmlO7agpDoISHhweOjo4Z3j+ztl5arRZ/f39UKhVfffUVIq2Avf0X4Hv5car7vT55hzen7jBowxhmN/8jw+fNDXiVK8LATeO4dfwaa0avSFeS2b4lu2jQvQl12n/Lxd1Z66aPj5Fz98xt7p65zcYpa7G0seSrqqUoV7sCjbs2peeYPsRExhL4xp8bJ65zbucZ4qJzjyTMOryAmJg4/ug5FrXqywjN+BzHdpygWv1q/Lt/OW1rd0t1Ww9PdzYe/YfHj57Rv+eviEVClq2eQ6Om9bh7+wFtv+vJg/upE0xzoE69msxdNJkfB/zOpYvX09z+rwm/c+PmXfz9A3FycuDK5UNs37aPWTPTloqULlOCefMmUqVqBR7cf8ygH0Zy5vTFdF9LgsOfIhIJzRZ7m5PI7phc04YzwNhwZkg4E4lERoJraWmZbQ1nKVWkdTpdIheNR48eUadOUis4w9ifPn0KQKFChShcuHCGxzFjxgyOHj3KqVOnUnVbUCgUBAfrw0kkEgn58+fP8LmSw+fpYUOHDiUmJobt27cD+s/Lzs6OmjVrMnz4cAoUKGD8PyhatCgjR47k2LFjH2Nyc79KmveU2zmHPE/oRSIR+fPnx9PT02iXlZNVocjISHx8fHB1dSV//vypXlzMPTad7v/Yu+4wJ6q3eyaTujXbewcFEcSGCqKoqICigAURUBRFECyAqDTpFhR/nxVEQZqAIqgIWCjigoD0Lm3Zku0lW9KTSeb7I9xhkk2ySTbZTWDP8+xD2GRmbrKTmXPfe95zWJSXl6O8vByZmZleEVrAO7JtNBpx8eJFCAQCq/evhcKGER81SWgJtk5djvBYOR54dZA3Q25R3PDw7Xh57Tv4deEGfD3pC7ejeQ1aPdbMW4GhU0b4fEw6tQ7Hdh7GqrnfYtL9r+LFrsOxaOInyD92Ab0H348lh5bjmwPLMfuH9/DIqAEIk7dcct2cH9+HQCTAxMGTYHDSbR8s+PCNBZBJpZj2oWNvVwDofHMnfL9jOX7fsgOjn5uA+f83E4dO/4X4hFg83n8EHn/kuRYhtNd36YBvv/sMU96eh02//tnk67OzM9C337144YUJkEqlOHRgK3L/3os3Js50ud3jTzyMw0e34e/cn1GiKMX9vR5D/z5DsX1brlvXEYFAgMq6M6Bpa1NvMFVoAedL8v4EaThLSkpCdnY2EhMTQdM0lEol8vLyUFxcDKVSCYPB4NPCibM0MWJxRZb6d+7c6XQfe/bs4RrFHnroIa/GUV9fj4qKChQVuZbS/PvvvxzZvvHGG5v0z3UF8ndmWRYMw4BhGFgsFhiNRshkMowfPx4PPPAAACA8PJzT2aanp8NsNnOfm06nQ3W1/5MK2+AeAr5SS1EUF2UItEwzFmBr1+VuQpkvx8YwDLekk5OT06wUG0/HRRrh4uLiEBcXB9bA4Mfh81F6yH2NoFGtw6axn2PgtxNx6Jd/UFPYfP9Lf+D+VwbhnjGP4Os3Pse/m/d4vP3f63bg4TEDMHTqCHw3b5nvB3gJeo0ex3OP4njuUXz37nJIQqS45uYOuL5HF/R67F4MmTQcmno1SvNLcXj7Qez4YSsalA0+H8fkb9+BPDEao/uNhSaA5BDeQq/VY/KIafhi42fY+ccu7N5ma0f34ID7MH3B2/jif98gMycdB07twOmTZ/DEgJE4fPCYk736HqlpyVj/63J88n+LsezbtW5tM+2dCdi//yhKSspw4vhOnDt/Ec8/97pDUiQUCjF9xgQMH/4EhDSNhZ9/i2XfrkWdh0EMMpkUReXWz0Wr1eLChQsB2yDlDO4uyfsL/IazmJgYmM1mTqpQWloKlmVtEs6a83k6ShMDwEn8BgwYgLVr1+Lo0aM4fvw4unTp0ui1K1euBABERkZixIgRjZ6vrq7G2LFjcfHiRUyYMAFDhgxxOp6ff/4Zb7zxhtPnv/76sm3e888/7/R1jmA/UeE/5t9fSaU4JiYGM2fOhF6vh0KhQEJCAvca/me+fft2TJw40brPAInJDYRqcWsh4EmtPVqC1JpMJigUCi7u1t2Lhq/GptPpUFRUhMjISJ84PLhbqbVPJouIiIBFz2Dd0++h/Jjn0YeKff/h1A87MWblFMy96zVvhu5XDPn4ZXTqfTM+GDYL5w+dbXoDB2AtFnw79Su8vvhtrP9kbYs1dxm0epzYdRQndh3FmvdXQCKToP1N1+L6O29Az0fvwuCJT0PboEFZQRkObduPHeu2ob66eUlRr306EZmdsvBSv7FoqPU9YW4t5J8pwJezFuHdL2ai/+1PoP7Se3tx/Ag89+pwXLxQgDGvPY+z/13AkMdexIF/j7To+ORRkfj9r3VY98NGzH//c7e2ycpKR7+H7sMNXe/DP7s3Qa3S4InHRoJhbKUiKSlJ+Ph/s3DX3XegqLAEU96ci82/bm30OneQkpqEo6d2ArBW+sxmM7Kysho1SInFYo6QtVaDlCu0dJW2KdA0zTWcsSzLJZw1NDSgoqICYrGYI7mefp7O5AdELjJs2DCcOHECp06dwuTJk7Fy5UpER0dzr1u1ahVyc3MBADNmzHCocV2xYgWOHj0KAJg3bx4GDBjgtEj07bffokOHDnj44Ydtfm80GvH+++/jwAFro+2gQYNwzz33uP0+AeDjjz9GeXk5IiIiIBKJuGhk/o9UKoVYLIZUKgVN00hISMADDzyAefPmYeLEifjoo4/QsWNHAFYiHBoaamNnJkBgRNQG/BK8H9FGau2g0WigUCgQHR2NuLg4jy4QvtDU1tbWory8HMnJyYiMjGzWvgjc+czsk8mkEgksehO+H/wuKk8WeH3sv9/9Hs/dfzMGzhyBn2Yu83o/voRAIMDYdTMRkRyN6Q9PQkVhebP2d+qfE8g7eh6vfDIRH46c56NRegaDzoCT/xzHyX+OY+0HKyGWitH+pmvRqccN6NG/J56cYCW55YXlOLTjIHZ8vxV1VY6dHRzhhTkvoUvPrhjz8DjUVNT48Z20DjZ9txndet2CpT9/icfuHoa5n09H30EPQKfTw2g0YfjgMdi352DTO/IxJBIJduz+Gf/s3o83Jsx0e7up08fjwIFj+PKL9xEZGYG77uwPne7yzfeee3pg3ntT0L59NnZs24XHHhmBI4cdN3+6g1tvuwlb/lwDwDop55NifoOUxWKBXq+HRqNBRUUFGIbhHABCQkKatSLlKwQaqeWDoiju84yKinL4efKruE01nDmTH5BKbUxMDBYuXIhx48bh+PHj6Nu3L/r37w+5XI6DBw9i7969EIlEmDx5slPpAf+eSJb77dG1a1ds27YNKpUKEydOxLfffovbb78dERERqKqqwo4dO1BSUgKKojB8+HC89ZbnvRpbtmxBSUkJRCIR5+5AfGbJvzRNQygUco/JZxAaGorq6mq8+eabyMrK4kivTCZDSUnzY67b4DtQbBD48JhMJo6UMQyD8+fPc7MlX4FfpUxJSfHK0JllWZw6dQqdOnXy+KLIlzukp6fb2JY0FwqFAuHh4ZDL5Q6fJ8lkEokEKSkpENI0zDoT1j4xF9VnFA638QQJnTPx1I/T8dkTM1DcDILsC0jDQzBh83tQN2jw/tCZUNf5Ru+XlJ2MuVsWYPJDE1CWF3gXOZFEjPY3XYNO3bvgxntuRuq16dCqtCgvLMeRnQexfe1W1FY4Ttga8sYwPPjsQxj36KsoPO+7aNfWREiYDLLQEEhDpAgNk0EaIoM8Vo63FrwBs8UCAS1A3vl8zJo+H//s2t9q49x9YAvKyiswoP+zbldPMzPTsO/A79ixIxc339wVPbo/jIpyq4/ta+NHYcyYEYiMDMeyJWuweNEKlJdVNrFH13hi8CP4cvGHADxPCTOZTFyDlFar5WyuQkJCIJPJWoVcGo1GFBcX+92ayh9gGIb7LDUaDVdNJJ+nfVVWrVajvr4eKSkpNr8/duwYRo4ciePHj0MikYBhGKxfvx4bN25EXl4etFot4uPj0b17dwwbNsyl40FlZSXGjh2L/Px8jB8/nrO/sodOp8POnTuRm5uL06dPo6SkBFqtFqGhoUhOTsatt96KwYMHo3379l59Nj169EBNje8n5DRNc9/N9xuuRSzbdKywv1FNGfF2xFls374dqamprT2cFkXQkVqLxYL//vvPrUg9d8G360pLS3Mr69oZTp8+jWuvvdYjnRNf7pCamupzzVlxcTFCQkJslo0IiH42NjYWMTExEFACWHRGrHl8DmrO+Y6c9Zj4GK5/qhdm3DbGZ/v0FHFZSRj34yycO3QGn49bAJOhcepRc/DcvJfQ7qZr8Xbf1326X39AJBGhXddrcF33zrjx3luQfm0GdGotKhQVOPzXIez4/k/UlNXgkZcG4vFXB2P8E2/g3AnPfFfFUjFkITKEhIVAFiqFLEQGWagUEpkUshAppDIpJDKJ9V+pBGKZ2PqvWAyxVAyxRASRWASxRAyhSAiRWAShiAbNVVIEEAhJlUUAivevtamU4ppLyXMCgQC00Oq/aWbMYBgzzAwDxmSG2WxGeGQYTCYGEokYjNkMjVoLVYMKFRVVuJhXgJMnzuDQgWM4cey032VQm7ethUQixv33PeGWfRbB10s+xn297wItEOCuno9CqazF/A/fQb+HeqOhXoX/fbQIP/6w0Wmkrid4e+prmPim1dKuubG3xOaKEDJic+Vu1dFXMBgMKCsrc2lhFQwgCWcajQYajQZGo5FLOAsJCYFYLIZKpYJGo0FSUpLNtvv27cOrr76K06dPB2zV2lPceOON6NatGwYPHgyLxQKdTge9Xm/zo9PpYDAYoNPpuB/+/41GIwwGA4xGI4xGI0wmE/cDAPMDiNS+eZWS2tZf6/EQZKbpC3NsAJwIPCQkxKVdlyfj8yS9S6vVoqioyCu5gydjsp+72Otnw8LCIGABRmPA6kGzUXuxzKdj2PvJz2jf51YM++QVrHqt5ZOn2ve4HiO+moC/1mzDmnnL/WK9tu7D7/B/e77CTffdgsPbW36p2hOYDCb89+8p/PfvKaz/31oIxULk3HANru/RGTffczMGvfw4GJMJoCloVVrM+Gp6I/JIyCJHIC/9TkBbl/KILZCZuUQgTQxMJmuXsclosv7faILRaLL+azDCaDDBZDTCoDdCrdTAoDfCoNfDoLt0AzGaYDIy1huK0QSTiYHJYITx0v6MBtvfm8gxeI9NxsaTGaFQiBXbv0F5eSWGD3gJarUGcQmxSMtIQVpGCjKz09G+QzaeHTEYb099DSGhMmjUWqjVGtQq61BUVIIzp8/h2JFT2P/vYdQq65r191m5diFi46Jx952PekRoMzJS0f+RB2E2mzH+9en4avGH6Nr1ehw8eAwjn30NuTv3Nr0TN/HVkgUY9LhV+9hcQgvY2lzFxsba2FxVVVVxVUeiHfWXzVUgyw88gaOGM61Wy8X4AtbznqIomzhYwHpfkslkMJvN2LBhg02FNiEhAd27d8fQoUO9rpq6g9zcXLz44osAgJSUFOzYsaNZ+zMYDMjIyMA999zD/X35DggWi8XmsdlstvmXYRiYzWbr9esSkTWbzVi1ahU2bNgAAKCoAAlfoFp/DK2FoCC19hcYQhybe1Frrv+rI3jSlKVUKlFZWYnU1FSf5Fe7OyZ7/axYLIaABUxqA1YPnIU6PzgVWBgzNo7+BMM3z0X7Htfj/D/eZc17gzue7o1Hpg3D6nnLsX2VZwlKnkBdp8b6/32P5+eNweHtI/12HH+AMTI4e+A0zh44jZ8+X4+pq2chrUMGwLA4fzoPv3y3GSajESYjIaKXH5PfW4ml6RIxNbWo9V5zIBYLsXLHUtQq6/HMY6Oh1VhJZFVFNaoqqnF4f2OXA1mIFClpyUjPTEV6ZgpyrslGz553YMiwxxAbFwOT0QiNRouGehXKyiqRdyEfJ46fxsH9x3Dm9DmX41nw6Rx0vel63HXno6j10H1g6rTxEAgoaLVGfPLpPPz4/Ua8Pm4aLuYVeLSfprBl61rc2u1Gv4YqEJuriIgIsCwLvV4PrVaL6upqznaJX3X0Fa4UUmsPmqYRHh7OuQmZTCZUVVXBYDAgPz8fYrEYx45Zz3W9Xg+pVIqhQ4fi6NGjkMvlePjhhyGXy3Ho0CGsWbMG69evx5QpU1y6GXgLnU6HWbNm+Wx/xAZMLBY3ckAg//d2hdSZrK8NrYOgILX2aG6zGPF/bWhocNuuy5djI5nVOp0O2dnZkEgkPjt+U2Pi62ezs7OtlTUWMDbosHrgLNQrnGfINxfKvDLs/nAdnvnsVcy8bQzMJnPTGzUTj0wfjtufuhefjP4Qx//2f9f6n8u2oN8L/fHoy4/hly/X+/14vkZahwxMXjUT5YoKjLp3FJIzkzFv5Vws/b+VOHGg5SYiLQWxWIjvdi5DRXkVRjwxFnqde+4VOq0eF85exIWzjV1BKIpCQmIc0jJTkJ6Ziowsa5W3R49uSJyTAIlUbJU1qNSoqalFUYECZ/67gCOHjqHHXbdjwGP98NKLE5GVnY4bb+qMyMgIREaGIzwiHBHhYQgLD0VYmLWiGRIaAplMCqlEguSUBERFydHQoMZn//saK1f8gIb65ldQ7XHoxA6kp6e0aEoYRVGQyWSQyWQ2VUcSViAQCLgqbnPDCq5UUssHaTiTSqWQSCSIjo6GTqfD2bNnsXHjRmi1WggEAtTU1CAlJQVr165FfHw8t/2qVaswZ84czJo1C3K5HH379vXp+D7//HMUFxf7bH80TePgwYM+l/YRu7rExESUl5eDogLE0usqrtQGhaaWlP0Jzp8/j7S0NK+aqYh+VSAQIDU11efdtnl5eUhKSnJqCs0nlcnJyS3i2VhZWQmWZREaGmqjn6UoCgILoK/TYPXAWVCVtkBXO0VhyIZ3oFJpsHjE+3491AtL30Ra13Z47+mZKPqvwK/H4uPmB7ph1IJXMPrmZ8EYgydtq98Lj+CJiU/j56U/Y/mHK7mJ0OMvPYbB4wbjsdufgvoK8KYlEEvFWLNzORRFJRj51CstFiQRFhaK1IxkpGWkIj0zFe2uzcJd93ZHRGQ4hCIhGMZ8SbtnhF5vgF6nh06nh06rg1arg0ZjlT2o1RqoVRqEhEox7JknIZVKUF+vglgswo/fb8Qb42f4fOwXFYcQHhEWULG3RDtKSK5er+equCRy1hOS6qx56kpEVVUVaJq26bdgGAYvvvgiTpy47IYRHh7ONYV169YNgDVaNjc3F3K5HNu2bfPZauPZs2cxaNAg5OTk4OxZq9WiL+QHTcFsNtusaNI07fZ5o1Ao0Lt3byxQt0dcAGhqqygjJoadb9PUBgu8rdQ2x67LXVAU5XRs9k1ZLVUNoCgKarUatbW1nH4WAAQWFjqlGqsHzIK6wn17p2aBZbFp7Od4btv7uOGh23Fs8z6fH0IoFuK1jfNAS8SY2ncilOUta0F16M/9qMgvw6gPxuHL8f/Xosf2BgKhEJNXTEfm9TmY9cJsHN5lW9H+8av1uL7b9fhq4xcYes9zrTRK3yIkLATf7ViKvAsFGPX0azA60Nn6C2q1BmdOnceZU+cxbOST6HH3bYhPjINeb8Dr46bi+zU/u72vDz+eiccHP4K8vAJ07NgeAx9+BmKxCF98NR+nL+zBxNfewW+bt/lk3KXVpyASCQMu9pavHY2OjnaoHeXbhjVVxb0aKrUEFoulUWFHr9fjzJkzAKxWWwsXLsQ///yD3bt348yZMxypHT58OHJzc1FXV4fly5dj3LhxzR4Py7J45513YDabMXv2bAwePLjZ+3QX7haYGIZpRHivlvMlGBAUpNaZptZdkKaoqqoqv+tXnTVlVVdXo6amxoZUtgQsFgsaGhpgNBqRk5PDac8EZhba6gZ8N3AWtFXNM+X3FKrSGmx/ZzkGv/si/tt5FEaN7wILwuPkGP/ruygvLMOC59+FTu1+k40vsXTKIkxfNxdr3o92apUVCEhtn4rJq2ejqrQKL973EpROxvrBq/Px1baFmPLRJLz7xoctPErfIiw8BKv++hZnTp/HmOETYDK1bDVdKBRi4tSxGDSkP0wmEwx6AzRqLZ575lX8tX2XW/u47rprsP7XZZDJZJg29T0kJSdAJBLi1EkrGbnztofw3Mgh+PKr+Th39gKGDXkZVZXeRXlSFIWK2v9AURQYhkF5ebnPPLT9AXvtKAl/qKurQ1lZGecAEBoa2khjCVxdpNZRotju3bu5bv5evXohOjoa/fv3R//+/W1e1717d0ilUuj1emzatMknpHbNmjU4evQonnrqKXTt2rXZ+3MXKpUKixcvRlVVFSIjIxEZGYnu3bs3GoPZbMaRI0dQUlKCPn36NFotFgSI/EBwFcsPgjJ4whNSazabUVxcjLq6OuTk5PiV0Doam9lshkKhQENDA7Kzs1uU0BqNRuTn54NlWYSFhXGEljKzUJfXYtUjM1qc0BKc+nE3yo5cwJiVU3y2z9TrM/Hmto9wcs9xvPf0zFYjtABQcPIiDm87gNcWTmq1MTSFPs/3x+xfPsTWddvw+oAJTgktAOg0OkwdPh29H7kH9w+4rwVH6VuER4Zh9d/Lcer4GYwe1rKENkIejgWL5mL/2e3oeV93TJs4F1u37IQ8So5H+g11m9B+/e3/sHnrWlRW1qD7HQ9h1aofMWbMCLwz5QPuNRaLBUu+/g7dbrwfiqJSHDiyFbPnve3xmMVisQ2hvXjxYlARPoqiIJFIEBUVhdTUVOTk5CAqKgoMw6C0tBQXL15EeXk5VCoVJ3FzFkhwJcJRw/Xu3bu5x66sM4VCIecXn5+fj4KCgmaNpaqqCh9//DFiY2O52NmWwqlTp/D111/j559/xvLly/Hpp59yTXP8+znLsjhw4ADefvttPPXUUzh+/LjNfiiKDZifqxVXNKk1GAzcRZh0+bfk2MjxBQIBsrKyWuT4BBqNBhcvXkRERARiYmK431MMC1VJDb4bMAs6pe+bSDzBltcXIaFdCroPu7/Z++rStxte/n4mtny9EYvGfwoz4/8mtKaweu5yZF6XjWtu8W1QSHMhEAgwZdVMPDZ+MGaPmoul738Li7np75PiggIfv/E/vP3BBKRkJDX5+kCDPDoSq/9ehsMHjuPlZ9/wKgrWG2TmpGPF+oXYfew3xMRFY+SQcXi412A8PLAP+j7SG/f0HIDjx043uZ+ed9+OC0UH8ECfe/DFF0txx+39cOFCPp4dMRi1yjqHpLiqqgYvPPc6nnr8BfR9qDdOnN2Fu3t1d2vcMTFRKKk6AYqiYDKZoNPpgr6KKRAIEBYWhvj4eGRlZSEtLQ0SiQQNDQ3Iz89HUVER1Go1Z+90pcMRgT937rI7R3p6usvt09LSHG7nDebNmweVSoW3337bYdyuv6DRaDgiHxcXh5EjR2LBggXo3bs3ANiQfuIlL5fLcebMGYwbN46LAAYuVWoD5OdqRVCQWm/kB/X19bh48SJiYmJ84j/rLsjYGhoauOOnpKS02PGJ1KKoqAgpKSmIi4vjJBEUY0F9USVWD5wFvY+StJoDnVKF38Z/hf5vP42wWO8vYve9/CiGLHgZS97+Er989qMPR9g81FYoseXrjXj549daeygcUtql4rN930ASEYJR943G4dzDHm2fu2kXtv24HQvXf9pi57QvEBMfje/++hb/7j6EV0e+ZdN46i90634TNv61Br/+tQYVFVXof98QDBs4CiePn8HK9YvQ9ZbOuOPWvigqdN3lLZVK8cPPS7ByzUKo1Rr07TsEs2ct4LR9b701Dh9/uNDlPvbtPYQ7bumDRV8sw/LVX2Djb6sgj3IuIbi2YzucuWjVuxOTeuDKW5oncbMpKSnIzs5GTEwMLBYLtFotLl68iLKyMjQ0NLTYBKilYS8/YFkWRUWXUwP5jgeOwH/+4sXGTiDuIjc3F7/99hu6d+/eSObgL5BJS0VFBXbu3ImoqChMnDgRkyZNwkMPPeSwUZCiKDzyyCP4888/MWTIEFRWVuLzzz9vkfG2wT0Ez12JB1eklth1lZeXIzMz02GKlr/R0NCA0tJSZGRkIDo6usVuAsR/VqlUIjs7m5NaCAQCpMQnovZiOdY8NgeGhsDpYM/behgXtx/By99N92r7pz4ajXvHPIr5z8zB3o27m96ghbHpyw0IiQjBvUOaX41uLh4c8RDmbPwI2zfswGuPjkeNlw10i2Z9hbqqWnyyJji0tbEJMVi5bQlyd+zB+Jem+N0/d8CTD2H7wY1YvPoT7P57H+66+SGMHz0FeefyIY+KxPrfViA2IRbdbnygyZCGx57sj9MX/sFtt92M9T9uQtcb7sXBA0cvP//YQ2BZ4LuVTU/mGIbBF58uwe03P4i6ugYcPrEDb015tdHr7n/gbuzetxmA1YSfT+iuNFLLB98WTC6XIz09HTKZDGq1GgUFBSgsLER1dTVXsb4SYC8/sP97O3PxcfR8fb13UjbiSSuRSDBz5kyv9uENyN+wpKQEeXl56NevHwYMGAAALicxFosFERERmDx5MgYNGoSjR4/i33//tT5JAVQA/ODK/Iq6haAltY4qLQzDoKCgAHq9Hjk5OT71n3UHZrMZarWaa8pq6oLgS5hMJuTn58NisTTyvg0Ty1B/sQJrn5gLYyvqTJ1h6+RvER4TgftfGeT2NgKBAGPXzUT7nl3wziNv4uyB//w4Qu9h0Bnw3ZxleOrN4a02BoFAgLdXzMDjE4dg7ui5+ObdJW7JDZzBzJjxznMzcO317THiVcc57oGChJR4rNz2Dbb9/jfeHDfDr2Rk3BsvYs+pPzB59nisXLIWt113H959ZwGqKqwNWknJCfh1xxpodFrccUsfGAzOLcSiouX4Y8c6/N9n88AwDIY+PQZjxrzZKF1s2vQJWPbNao/GWV5WiWeGvIwRw8bh6WGP4eipneh2+00AgFFjnsXqdYsBwEZnSnAlk1oCQvREIhHkcjmSk5ORk5ODuLg4sCyLyspK5OXlobS0FPX19UFdxbWXH2i1lwse7rgB8O8z3jpiEE/aUaNGISMjw6t9eANyLSgrKwNFUVxTGMMwLq0+Cf8Qi8W49957uao+QEhl6+tpr/CvqEsErfuB/YWExM1GRUUhPj6+xS+8er0eRUVFEAqFkMlkLZZTDly2KouJiUFsbKyt1YjJjOqzxfhx2HyYdC3jw+kpjGodNr38OQYum4jDG/9BTROJZuJQKSZueR86rR5T+kyAStnQQiP1Dv9s+Bv9Xx6EZ2e+gOUzv2nRYyflpGDamjmoqVTipfvGoLrcuw54eygrazFz5CzMWzkXh/YeC8hghpSMJCzZvAibf/kTMya955djhIRIMXXeJDz48L2oVdZh3vQF2Pzzn42uTznXZOH7X5fiwP4jGD7kZZf7HPfaSLzxlrWTPDd3H14Y+Tpqahpb7vXufRdiYqLw4QdfeDX23J17cWvX3njl9Rex7qelUNbUIjUtGYBvYm+DFY6IOz/CF7ASH41GA61W2yjCVyaTBQ3xd+R+QODOe2iuBOns2bNYtmwZsrKyMGrUqGbty1solUqEhIQgISEBgHtknrxvuVyO0NBQNDRY70ECBIaeNRAcGFoLQVmppWmaW0IkGtLCwkIkJycjISGhxS8odXV1yM/PR3x8PCIjI1tsaYpE7fL1s/aEtuJ4AdY9/X7AEloCxb7/cGrdribdEGIyEjA19xOU5JVgxqNvBzyhBax/p6WTF6HXk/chJCK0xY57//C+mPfrR9jxy194tf9rPiO0BCf3n8LK/63CR8veRVh4y61KuIO0rBQs3fIVfvlxi18IbWJyAr5e/X/Ye3or2l2bhXEjJ+GeW/vjlx+3NCK0XW/pjJ/+WIVNG/90SWgzMtOw58BvmPrOBLAsiwnj38HAAc86JLQAMG36ePy84bdmvQ+j0YQF87+ETqtHaloyWJZFYWEhDAaDw+vY1VCpdec9CoVCREZGIikpCTk5Odx9p7q6Gnl5eSgpKUFdXR1njRWosJcf8FcX3dGdE601YPUC9gTEk5ZhGMycObNFG6n5IO+T/OtuzD1gJf4CgaDVxt6GxghKUks0tRaLBcXFxaitrUV2dnaLdkwC1hO7rKwMFRUVyMzMhFwuB0VRLUJqSdRuTU2NjX6WgDKZUXr4An58Zj4YQ2BfWAn+nrsatECAATOedfh8zu3XYcKm97Dnl11Y8Py7MBmMLTxC73F2/2mcPfAfXv3c/1Y1AoEAby1/B4PfHIa5o9/F13O+aZbcwBV+XLQe/x08jcUbvasW+gOZ7TPwzeaF+GHVT5gzxbe6385dr8OPfyzH1n0bYDAa8cRDz+GxPs9g907HISJ339cD3234Gl9+tsRlwtfc96dg175NSE5JxPHj/6HbrQ9i1SrnOtkbb+qMjh2vwfTJzSfsReXHEBMbxfUjuLK7aiO1jUEifGNjY5Geno6srCyEh4dDp9OhqKgIBQUFqKyshEaj8bue21M4IrVk6Z1lWRs5giPwJQee3n+JJ+2AAQNw++23e7StL0D+xjExMVCr1SgsLAQAjlu4ArnHFxYWQqPRIC4u7tI+A+fnakVQyw/y8vIgk8mQnZ3d4p3YDMNAoVCAoijk5ORwFwJv0848gclkQlFREUQiEbKzsxstl1BGM4r3n8XPo/4PFlPrW1u5C8ZgwsaXPsFT66bj4Pq/UXyygHvutsG9MGDGCKx9fyW2Lm9edaq1sOKdb/DuH/9D6jVpKD6n8MsxkrKSMHXtXNTV1OGl3qNRVebb6qwjvDfug4AJZmh3XTa+XP8Jvlv6AxbM8x3Rvv+hezBp2itITI7H+rW/Yuxzb6CkuMzlNgOeeAjzPp6OqW/Nw6oV6xy+5sabO+PblZ8jOTkBOp0e8+d/jo8XLGryGjJ16uv4+69/bCpl3qBceRo0TXOxt2FhYZyXttFohEajQX19PcrLyyGVSsEwDEwmEyQSyRVLbpvrU0vTNCIiIhAREcFF+Go0GiiVShgMBpvwB08jfH0JfrWRgKIopKencxrRyspKZGZmOt1HZWUl9zg7O9vtY9fU1ODjjz+GVCrF0KFDUVzs2gGEYZhGr2lu/Ct53zk5OUhOTsaSJUvQqVMndO7cucltaZqGVqvFb7/9BolEwmmBKYoFFQBL/4EwhtZCUJBae+h0Omg0GiQnJyMqKqrFLwparRYKhQJyubyRftffpJZoh51F/VImCwr/OYVfX/4clgDwavUUFScKcPCb3/DCkrcw87YxAID+k4fijuH347OxC3B0x6FWHqH3qCgsx9/fb8erX0zCm/c37jpvLu4b+iCGTh2B31b/jm/eXdJiXr0kmOGzTZ/gwK5D2PqLfzPaneHaztfg83Uf49tF3+HT+V/5ZJ8jXnoaI18ehpDQEHzz5Qqs+GYt6uualry8OO5ZvPbmaLz0/AT8/lvjz0MgEOCrJQvQ96HeMJvNKCxQYMiQ0Th+vGm/2uzsDNx9d3fc0qV5IRiVdWe4lSW1urHFn1gs5iyviM1VeXk5qqqqUFVVhZCQEC561t2I0WCAK52pp+BH+MbExHARvhqNBrW1tZxW190IX1/CUfACALRr144jtQqFwiWpVSguT86vueYat4994cIFTrf9xBNPNPn6iooK3Hef7fl+9uxZt4/nCOTcv/XWW9GhQwfs2LEDM2bMwKOPPopu3bohLS2tUViS0WiEwWCAUqnEggULsGvXLjz66KM2fr1taF0EDamlKAoWiwUVFRWora2FRCJpFbsupVKJiooKpKSkOFxuIeP057GdRf1SRgvydx7Dple/BOun5eaWwN7/+wnt+9yCoZ+Mg1gmRdat12LuE9NQcNJ7H8RAwY8LVuOTxxajW987sP+3vT7Zp0AgwBtLpuCaWzvi3Zffw/4dB3yyX0+guKDAx5P+D2/Pn4jTR/9DSaHrKqav0enGjvhk7YdY9Mm3WPR/3zZrX2KxGJPeeQWPPtEPep0e/zd/EX76YROMbspdps6ZiMHDBuKxR0fg0IFjjZ5/oE8vfPLFe4iNjYZWq8OKFT9gyuR3Xboh8PHmW+Nw9MhJVFV5Z8kGXCa0FovFra51ElogEAi4Cpl9FddV9GwwwZ8SC0cRvhqNxu0IX1/CGant1q0b/vzzTwDAyZMn0bNnT4fbMwyD//6zus5kZmYiKyvL7WO3b98eX3zR9ErK2LFjAQDR0dGYM2eO2/v3FC+++CKOHz+O06dPIz8/H9deey2ys7ORlJSE6OhobpVCqVTi5MmTyM3N5VYsBg0aBLlcDiCAYnIDYAythaAhtQzDcKbQ6enpKC0tbdHjWywWlJWVQavVNrLM4oMEHbT0sSmjGRe2HsZvE74CawmeE5qiBZBFhSEkJgIhsZEIiY1ASGwEas6VoEufbhCKhFj7/kowRga0SAhzC8aa+gPaBi3WfbQaz80e5RNSm5CRhOnfz0GdsgEv9R6DqtIqH4zSO+T+movOt12Phes/wYBuT7WYfrDzrdfjf6s+wGcfLcaSL1Z6vZ/oGDlmzn8bPe/pjqICBd56dQa2/f63299nmqbx0RdzcNe93XF/r8eRl1dg83xYWAhWrFmI226/CWazBVVVNXj2mXH4+2/3z4P4+Fg8/vjD6H33Y568NQ5isRglVScAwG1CywchfCKRqFEVV6PRoLS0FCzLBnUVt6V0wyTClxRoWvpzdPY+b7rpJu7xzp07MWbMGIfb79mzh5O/PPTQQx4dOzo6mkvscgcymcyj17sLUq298cYbMXXqVMyePRu1tbU4evSoTVKYs21nz56N22677bI0QhAY8gMExBhaB0FBalmWRX5+PsLCwpCQkACTydSigvumNKx8+Fp+YDKZoFAoQNO002NTJgvObt6PP95aAgSAKbg4THaJpEbY/BueHI3wpBjIYiMQEh0OmTwMQpkEZqMJZhMDM2OGVqeDWCZGSHgYKIqCiWHwyNjH8OgrT0AsFaO+qg7F54pw8dgFKM4Uovi8AhX5ZQERi+sutq/6A/1GPYpBrw/Ghv/73uv93Dvkfgyb/jx+X/sHvp77TUB8BotmfoWON3XAJ2s+xCuD/d8Ud1P3rvhw2TwsePcLrFi81qt95FyThdkfTkbnrp1wYN9hPPP4aBw5eLzpDXmQSCX4etUnuKZDDrrf2reRY8GwZ57AzLlvwmy2wGg0Ydu2XLw85i3U13vm3vHKKy/gYl4hzp3N82g7AIiKjsK5fGtDm8lk8lqP66jHgWhxWZaFyWQK6ipuczW13sKdz5GQXF9omp1Vavn7PXr0KI4fP44uXbo0et3KldYJZGRkJEaMGNHo+erqaowdOxYXL17EhAkTMGTIkGaN118g77dv374ICwvDunXrsGfPHoeSHAAICwtDVFQUpk2bhrvvvttuX4GRexAIY2gtBAWppSjKphmsJZqxCFx5wDqCL8fWlH4WsBLa0xv+wbZpy3xyTEcQCGnIYsKtBPVSRTU0NgKh8XKEp8QgLD4KIbERkMrDIAm3Bl4wBhOn6aVoAWiJENSlKnZ9fT0adDpIRREwMSZAANRpVSgvL0dqaiqkoSE2n6FQavX8NVvMCI+NwHVxndHxjuth1ButdipSMeoqa1F8tgh5x86j+GwRis8pUFFQ5reu/+bAzJixbNpivPzJ69i06CcY9Z65OFAUhYnfTEHH2zrhvXEf4N9t//pppJ7DzJjxzogZWLz9K4x4dSiWffqd347V7e5b8N7Xs/DBzE+wepnn8cjd7+6GKXMmICMzDZt+/gNvvz4L+XmFHu8nIjIcq35ajLDwMHS76QGbgIT4hDis/XExMjLToFZrER4eirEvv4Uff9zk8XHCwkIx6qXhGPbUaI+3vb5zR/y1+2cAgMFggNHonXNIU1VMiqIcanE1Gg1KSkoAgKs8BmoV15eaWm/h6HMkvSRlZWWwWCwcwQ0NDfXqc3RGaonjwbXXXouzZ89i8uTJWLlypY3cb9WqVcjNzQUAzJgxw6EUb8WKFVy1c968eRgwYECLByJ5ip49e6J9+/bYv38/Tp48ibKyMtTX18NkMsFsNiMhIQE9evTAoEGD2my8AhRBQWoBqy8gITotQWqJB2xlZaVTDasj+EpTW1tbi/LycqfaXcBKaE9+/zd2zFrl8f4lESFWghoXyZHV0LhIhCVGIjw5DqEx4ZBFh0EaGQZaKobZwMDMMFZpg4ACLaIhEAm5pVmWZcGyLBjLpWqhSACB6PIF08KywCVbIJPJxN1UiY2QSqVCVlYWpFKpy3GT4wCAiEd2I+Ii0Sm+C67r0RlGvRE0LYBIIkZtuRKKs4W4eOw8is8qUHyuCBWFFWBb2Vrn6I5DKD6vwOiPXsWn4z5ye7v4tARMXzcXqjo1Xrp/DCpLKpveqIWhrKzFzBdmY96KOX4LZrjjvtswd+E7mDttAdat+tmjbZ8Y+ihenvgCoqIiseKb77F00UpUVym9Gkd8Yhx+2PQt6urqcfvND9p89ye9PQ4vv/I88vIKYTZbUFhYhOHDx6Gs1HW4iDM8P/JpVFfV4J9d+z3a7vEnHsHCb6yuFHq9vlneqZ4uzQdjFTcQbcv4Eb4AuM9RpVKhsrISYrGYI7lSqdSt8TurSOt01knZl19+ifHjx+P48ePo27cv+vfvD7lcjoMHD2Lv3r0QiUSYPHmyU+kBX7bDv267wvnz5zmyzIdarcaSJUu4/991111o3759k/vzFCzLIjExEY888ggeeeQRsCyLhoYGiEQitxJCSaJXa4MKgBXb1kLQkFo+iA7G2UyzubBYLCgpKYHBYEBOTo5HM7LmamqJ961arXap3aVMFhxduQ2571mXr2mx0G7J30pWw+IjEBYbjrBLWlVpdAQkMVGwmBgw1dUw19eDjouHQCwEas5DlHEDLPoGmJUKQFcJi9oIOq0rhLJQWIyXlzVYuGfO7QjkMzKbzVAoFGBZFtnZ2S6jCZuCM7IbmSCHPDEKne7sAqPeYNWxyaSoLa9B0X+FuHjsAorPFaHknAKVisoWJbvfTvkKM39+H7GpcagubloL22twbzwzYyT+XLcVi2d/DSaA9cUn/z3JBTM8dvtTUKtc+116grv73ol3Pp2CmZPew08/bHZrG4FAgFffegmDhw8CwOKLj7/B96t+gk7rfWx0Vk4Gvt+0FMePncZTj7/I/f6aa3Ow6vtFkMmkOHs2Dx06tMOsmR/iyy+XeX1tEIlEeOONlzH17XkebTdj1hsY97p1bGq1utl6/+YQPneruK3hBMBHIJJae5AIX7lcDpZluSpuRUUFGIbhPsPQ0FCn11VnFWmdTgeappGamoo1a9Zg/fr12LhxIzZt2gStVov4+HgMHjwYw4YNc+l4MHz4cOzbtw/5+fkYP368W6TwxIkTmD9/fqPf19fX2/w+KirKL6SWzy1IsEJkZCSAy/cYV+dlwJBasFetrDZoSK29l54/GrIAq2VHUVERJBKJV/63zakik2Y4mqaRk5PjdEmJtgAQ0si49RqM2jkfsthI0FIxjDX1MNXUw6zSQnZdNpB/GpZTh8GW1cJyphZsfR1w/Y1A/6dQ++RAQCyGfMGnEIgYGPesguSuZ2DWNcBccuLysaJSQUlkMBp9F+BAURTnMxwWFoakpCS/3UTIhUirs0o5YmJiECsRQZ4YDak8BGk3ZEIqlkIsFkMkFqK6tBqKM5fI7iUZQ3VxpV/ONcWZQhz4bR9e+2ISpj/6psvXTvh6Mjp174wPXp2PvX86NvoPNPy4aD263N4Fi3/5Ak/f+5xP9nlf/16Y+vGbmDJ+LjZt+L3J14eGh2L6vDdwf797UFVZjVmTP8BvG7d6PSEj6Nz1OqzasBhbNm3DKy+/zf3+409m47En+mPrtr/RrdtNCAsLQc87++OsFxpYPp54oj9MJhPW//Cr29us/v4r3N+nFwDfxN76+jvgrIrbGk4AfPirWOIv8CN84+LiYDKZuMlCVVUVV2W0j/B1JT8gBFQoFGLw4MEYPHiwx+OKj4/HunWO/ZmdYdCgQRg0aJDHx/I1yGdErhMURXG8g4/CwkJUVFQgOdkaLy2gAigmt/WH0SoIGlJrD4FAALPZ7FNNlkqlQnFxMeLj4xEdHe3VRZTM9Dyd7bvyvuVDYLbA8F8+lEt+grmmHqqaOjA19bA0WEXtlFiE7E2fgTpzGNqP37EdW2gYJIMWQP1/HwMiEeTzP4YgLgrGXSsgvuMJQCiEueCyDywlkoGOzwbjY12qXq+HVqvl7FL8jfr6epSWltpIOSwWC1iWhUqtQpm6jLPakcvluP7uG5B1czvAzCI0PAxCkRDVxVUo+q8AF49dQMl5q4yhpqS62Tf6Ne8ux4LcL9Hx9uvx377Gy/RxqXF4Z927UDdoMPr+MagoDjy5gSu8N/Z9fLVtEaYsmIR3JzYvmOGBgb3x9vwJeHPcTPz+6zaXr01JS8Lsj6bglttuxMnjpzH62QnY6+GyvTP0uPs2fLXi//D1Vyswb/b/AADde9yKxUv/h/qGBmz5bTv69bsPixatwOxZC5odlUpRFKZNG4+vF61we5t//t2Mazq0A+AbQms/Hl8jkKq4wVCpdQWRSITIyEgusl2v13ME12QycQSYYRiH75NPaq8mEJJPCKw7WL16NVasWIGtW7f6eXRtcBdBS2ppmvaZrpZlWVRVVUGpVCI9Pd3jDGs+yBfCYrG4Tbjd0c+SfQtYoHj0HJiVjrumk957FXQIDbUdoQUA6dOjYK6ogGH3LkR+8BEESfEw/r0coq4PgIqMhynP9qYvTOkE+NB3l+iUlUolpFKp3wkty7KorKxEXV0dMjMzuSYFs9kMi8UCoVCI5ORk7sKvVqtRXFwMg8EAoVCIuLg4SCwMWIZFVHI0olNicMM9N4IxMhCKRaBpAaqKKxvJGGpK3U/xqq+qw6aFP2HMR6/i1TtH2Tx395P34tkZL2Lr+m34atbigJYbOIM1mGGaNZgh1/tghocG98XEua9g/EtTsf33v52+7oabO2Pm+2+i3bXZ2PFnLh7rMxxnTp/3dviN8PDAB/HBJ7Mwe8aHWPL1dxCLxViy/BPc1et2fL14Ffr2uw933nkbHn5oGP7997BPjvnAg70QHhGOT//3tVuvP3txH6JjopyGKniLliR79lVco9EIrVbr9yquNwWJQAaJ8CUxvgzDcJMFtVrNVR9DQkIglUpB0zR0Oh1kMhkYhsGGDRuwceNG5OXlQavVIiEhAd27d8fQoUN9svxvMpnw77//Ys+ePThx4gTy8/NRV1cHmqYRExODDh064IEHHsDDDz/cLHmaOyCrvydOnEBtbS0sFgskEgkXnkHs18jvKIqCXq+HSCTi9kEJAiOilmIBBF6PdIsgaEitIxsZX5Ats9mMkpISmEwm5OTk2Jyg3sJdaYSnTVICowlV//vOKaGVD+6D8N63QTV+WONtM3Ig7nk/al8ehch574NOS4Vx17cQtrsFdPK1MBYcBP9b4GvZAd9rNzExEXV1dT7Zr6vjFRcXw2QyITs7GyKRiNNKEb0UOafIhV8gEKC+vh5yuRxSqRQqlQoVFRWQSqXcDVYsFkMgpmGBBRazBdEpsYhJjcMN994Es5GBSCwCJRCgSlGBwtMFyD9+AcXnFCg5p4Cy3LFZ/uavfsEDI/rhgWf64c8VWwAA4796C9ffeQM+eP1D7P3DNyENrQV+MMOpI6dRWlTu0fYDh/XHKzPG4NUX3sbOrbsdvqbPI/dh4tRx1satVT9h1PDXvW7IcoZnRw3Bm9NexdjRb2HTxj/w6MC+mP/xTORdyMfnny/FmDEj8Ouvf2L869OhVnvm/+oK77wzET/+sNGt1xZXHodEIvE5oQVar4LJ93NtqSrulUJq7SEUCrkI36qqKq46WVNTg8mTJ0Or1SI9PR0sy2LIkCE4fvw45HI5Hn74Ycjlchw6dIjT2U6ZMqVZNl0nT57EyJEjuXtBu3bt0Lt3b8THx6OmpgZHjhzB9u3bsX37dixZsgQLFy5sdjSuK6xfvx5//fUXysrKUFtbC51OB5ZlIRaLQdM0BAIBhEIhhEIhaJqGUChESUmJjaMDRSFANLVXL4KG1NrDF6RWr9ejqKgIYWFhSE1N9dmSljtjI/pZgUDgUj9LQFEULLUqKFc5tgKSXt8OidNehPaTGUBDXaPnQ0a/Cf0//yBs9DjQ2Vkw5i6DIKEdhNd2h1FxHGAuW/z4WnbA1wpnZ2dDr9f7RaNKQHyFxWIxsrKyuEmGxWKB2Wzmlpj4UKvVKC0tRXx8PJcOw7+BqlQqFBUVgaIohIWFITw8HCEhttZjAjENMyyAxYKYtDjEZSTgxt63wGxiIJJYmw0riypQeDof+cfzUHLOKmOoq6zFyplL8OycF3H0r0OY9v1caNRajH7gZVQofEvMWgskmGHRhs8woNtgt7+7jz83EGMmv4iXR0zC7r8ak/tRrzyLZ0YNgUQixuLPl2HVkh+gUvmWzAHApGmvYPgLT2Hw4y/izOlz2PznGnS87hrMmvURHnvsYbw06hk8//zr2LLZtSzCU3TrdhNycjLx0P1Nk4cK5X8Q0AK/EFogcJblHVVx+VpcmUzGaUg9reIGm562OSCELSoqCjExMZg7dy62bt2KP//8E4WFVmu7kJAQPP/88+jTpw8yMjIAWO285syZg1mzZkEul6Nv375eHV+pVHKEdvLkyXj22Wcb/a1+/PFHTJ8+HefOncOYMWOwYcMGnxSe+DCZTPjmm2+wdOlSj6Q6RGqYlJTk0/EEAlqiSs+HWq3GL7/8gq1bt6KgoAA1NTUIDQ1FbGws2rdvj9tvvx133303EhMTm9zXVUtqGxoaUFJSgsTERERFRflwZE2PTafToaioqEn9LB80Y0bxlE8BBwb7tDwc6UtmwrDtZzBHG+sGRXf2hiAuEYLKatDXtofx729BRcZBfNNDYMrPAXrbL7IvZQd6vR6FhYU275VcDPwBnU6HwsJCG29f4rRAOlftP2+lUonq6mqkpqY20pLZ30ANBgPUajWqqqpgMBgQGhrKPc9fHiMVYVCXyC5r/bvFZcQjISsRNz9wK8wmM8QSMVgAlYXlCIkIxft/foLaSiW+nvsNJFIJwiLDoK73PUFpDXgazDBk1BN44Y0RGD18PPbuuhz9K5VK8NbM1/HwoAehVmnw0bzPsPHHLT5tZiQQCAT44JOZ6N23F/rc9yR63dsD332/CPv3H8FXX63AtGkTIBTS+PLLb31OaAFg6rTXsX1rbpO+siT21l+EFggcUsuHq1Qub6q4gfge/QX795qVlYVRo0Zh797Lk8fu3btj7dq1+PjjjzFhwgS89NJLGDZsGP7++2/k5uZi5syZuPPOO922vHSEe+65x2F4AwA8/vjj2LVrF37//XecO3cOe/bsaRR40Fzs27cPn3zyCQCrVVh2dja0Wi127dqFhoYG3HHHHaivr4dOp4NWq0VDQwPq6uq4vgybFVaKBSVo/UotmpEqWlVVhXHjxuHo0aN+q9Lz8ffff2PatGlQKpXo1q0b+vfvD5lMhrKyMmzduhXnz5/Hli1b8Mwzz2Dq1KlN7i9oSK2v5Ad8nWVGRoZfBPGuSBvRzyYnJ3NWIU1BwLLQ7j8FzZ7GOfIQCJC6cBpYZQUM333V+HlZCGTPvQJWb4Sw03Uw5i4DJQ2D5I4nwCgVsKhsG498KTsgE4ekpCSu+gn4zsvXHqQhjP/Z8gmtfQMAy7KoqKiARqNBZmZmk9ZtFEVx+iqiT1Or1VCr1aioqIBEIuEIrrPEH3uyyxCym5lgbdwQAOFR4Xjrs0mgBTREEhEEtADqeg3qa+qgrFSisqQKFYoKKCuVUFYqUVOpRG1VLWqragMybILAk2CG4WOfxrOvDcWLT7+G/Xus2tSYuGjM/nAyetx9G/IuFGDCmKnYuW233yZIYokYC5d9jOu7dsTgx17AkuWfIjEpDrt2/Ytu3W5E584dUFFhNcIfPfpZXLxYhJUrfvDZ8a+5Jgfdu9+Krp16uXwdIbTexN56An+urvgKzqq4tbW1XBWXEFxHVdyridQ6qkqr1Wr8999/AICuXbviiy++AMuyuHjxok3xZ/jw4cjNzUVdXR2WL1+OcePGeXz8sLAwdOjQAY8++qjL19166634/Xer08m5c+d8SmqVSiXWrrUmEY4ePRpPPfUUEhMTuZW5uro6fP7559wKn8FgwLlz57B8+XJs3boVI0aMwKhRo7iKs1V+4LPheQ1vx6DX6zFmzBicOHEC7dq1cxi64YsqPcG2bdvw2muvITU1FUuWLGlkETd58mSMHDkShw+7358QNKTWHt6QWoZhUFxcDJZlkZOT4zfhuaOxeaqf5YNmKZS/84XD5+LGD4O0XQpUrzzp8Hnpk8+BEomtF/hdywFKAHGPp2DW1MFSY5ue5CvZAb/xztHEwdeVWnK82tpahw1hjqxYiJYaADIzM71y0RAKhZxXJEn8IQ4aLMtyN9fQ0NAmK0Qc2QVAiy6PhTEzgBmQhIiREJqAxIxEdOpGgbWwMBlNsJgtoAQURCIRxBIxdFodGmobUFtVh6rSKpQrylFTXnOJANeitkqJmgolDDqDx+/XF3AnmOH58c/g6dGD8fyT43B4/zFcc107zJ4/GZ26dMDe3QcwdOAoHDvs+0AHPsLCQ7Fy/VeIjo3CLxu24KdNK2AyMWBZC3r2vA1isQgMw6CmphoWiwXV1VX46KN3UFOj9FnF9q23X8HBA0dRq6xz+LxYLEZJldV+j2EYzjTfnwgmwueqiltba40xtq/iXu2kdvfu3WAYa0Nqr169AFg/x5ycHJvXde/eHVKpFHq9Hps2bfKK1N5000345Zdfmnwd/+/hzLfdU5C/c3l5Ofbs2YOePXvi9ddf557XarVcwxwArvFbKpWiS5cu+OijjzB16lRs3rwZI0eOvDxWQWBUaikv/by++eYbnDhhvaa89957jZq5fVmlLy4uxsSJEyEWi7F06VKkpKQ0ek1ISAgmTZqEkSNHup0XcNWQWrLkHxkZiYSEBL9euOzHxjAMFAoFF/frCZkWmMyoWbkJJgfJUWG9bkHMiEegfmcswDTujBckp0Fy38NgGROMu1cAZhMkdz4NlrXAXPZfo9cLUzqBRfOqqCS4wmg0Om2886XHMP94TTWEERiNRigUCoSGhvrsXOAn/pAKkVqthlKpRGlpKUJCQjiS640mzFEij0AogEBovSlZYIHeoAdFU5DHyREVH4Wc67NBURRMRgZmxgyAhVAohFgqhoWxQFWvQl11HarLa1BRXIGqkiqu+qusqoWyQomGWsdNic3ByX9PYtX/vnMYzPDSWyPxxPMDMeLxMYiUR2LL7nVITU/Gxh+3YMLLU1FUUOzz8dgjNi4aa39dCqFICAEtwIujnwEANDSoIJFIYLFYuHNIIpHY+CwvW/YpBg4YgX/+aZ59WGJSPB59tA/uvqO/w+fj4mJw+sIeANYo73PnzkEkEnHnoLupUp4g2AmfO1VccuMM9vfqDhwliu3efbkRs1OnTk63FQqF6NixI44cOYL8/HwUFBQgMzPTL+M8cuQIACu57d69u0/2Sf6+lZWV0Ol0uO222wBYI6QlEgkYhoHBYEBMTAx3bAJiJTpo0CDs2rULf/75J+644w6fjKs1oVarsXTpUgDWKn2XLl0cvs4XVXoAeP/996HX6zFy5EiHhJbgpptu4s4Bd3BVkFrSQODJkn9zwB9bc8g0RVGgjCZUf7620XOitESkfPIW9KsXwqLId7i9bPQksBYWht0rAaMOolsfBWQRYPIb33A52UEzPDUdNWg5e1++ILWuGsKcEVqtVovi4mLExsb6zVKMXyGKiYmB2WzmZAqVlZUQiUQIDw9HWFiY38gH//OlBIBQfLn6S/SZIREhCI0MRWq7VOvytdkCk9EaYUzTNGQhMghFQmgaNKhX1kNZobxU/a1ATYW1+lt7ifzWVtd5ZDm2btGP6Hx7Z5tghrHTXsKAYQ/jx9Ub8ck37yM8IhzLFq/Gt19957Ra6WukZaRg3eZlCA0LgUgsgkQigapBDZFYCKGQtiG04eHhnG6bgKYFWL9hKR64/0kcP37a63G8/toonD+bh/z8okbP3drtBmzZapU56PV6WCwW5OTkcH6k/FQp8uMLP+8rieg5q+LW19fDZDIhPz8/INLN/AlH6Vjnzp3jHqenp7vcPi0tjSMb586d8wup3bt3L7ZssTrCDBs2DO3atfPJfsn1saamBkKhkBs7+Z6YzWYYjUaH9p7kM4uIiEBMTAzOnz/PkdpgrtT+9ddfnHyJVOkdwRdV+rKyMmzbZl3R6tOnj8fbu0LQkFpHmtqmUoGas+TfHBB9W3PJNG1kUDZzIVi97VIxJREjfeksMCcPwLjVccKQbOTroNNzYNi1AtCrIex4FwSxGTDlH2j0Wl/IDrRaXmJXbKzLm58vSC2ZLERFRTlsCHNEaOvq6lBZWYnk5GSEhYU16/iegKZpGzN0IlMoLS2F2WzmqkdhYWEtevO0J78WiwVlFWUwm81ITU2F2WKG2WCGSCpCXEoc4lPj0fGWjtb0JyMDi9kMiqK46q9Rb7wkfahFdVkNyhXlqC6rtlZ9K5VQVlirwDqNdZn8vbHvY/H2RZjy0SRoNVo8/twgaDQa9H2kNz7/+GusW/0L9Dp9i30eHa+/Fms3LoGAFiAsLJRzUaCFlyeper0eCoUCMTExDidFFosFIpEQW35bjZ53PuKQlDaFiIhwPD/yaTw5aGSj54aPeBIffzIHgPU7QJaK7f1ISTqXSqVCZWUlxGIxR9Kc6b2bwpVEau1BqrjkvpKQkOBQixsaGgqRSHRFfA728gOWZVFUdPl8jY+Pd7k9//mLFy82ezwmkwnl5eVcs+/27duxceNGSCQSjBkzBi+++GLTO/EQer0eQqGw0XWXk4JdIrn2vRgURcFkMkGpVNo0cQazpnbnzp3cY39X6Tdv3gyWZbl9EZjNZiiVSkgkEpee/a4QNKTWHgKBwGVSj8lkgkKhaDJy1h+gKAp1dXUwGo1ek2kBKBjzS9CweVej55Lffw20lIL6fzMdbit7cQJEd/aG6djvgK4edHpnCLNvgrHwCGBpXE1rruyAkPemwiMImktqSQOaJw1hVVVVaGhoQEZGhs90Wd6AH2mZkJDAyRT4dkR8T9yWApHIiMVipKWlNbrZNZI+0BQEtPXywcLqCgEKiIiJQGRsJLKuy7LGIZsYMCar9IGmaYgvWZup6tSoq6mDVq1DvycfhF5vAE0LcPzIKfz0wyaoGtS4udsN0Gi00Kp11n81Wmg0WhgNrp0AvEH3u27D16v+DxKpBHq9AQaDdTz8iTPpqE9MTHR5nlssFkilEmzb/iN6dH8I5eVVHo3lxVHDUV5eif37bJsj3v/oHYx8cSgA63eONK+QHz5EIlEjvbdGo0FZmbWxjV+FdPfaeCWTWgJSveRXcc1mM7RaLbRaLWpra7nvcLBXce3lB1qtlpskAWiyiZr/fH19fbPHU1RUhH79+nH/pygK9957LyZPnoy0tLRm758P8r7Dw8Oh1+tRUWG1TmQYxjpJF4sRERHBedYSe0f+vaWoqAiVlZXNCmsKJJw9e5Z77O8q/cGDBwEACQkJEIlEyM3NxdKlS3Hw4EGO18nlcvTs2RMvvfSSRxZiQU1qnZEwUjWMiopy2zLLV2AYBhqNhhPXe9uMRlssKHr7k0a/lz/VB2H33ArVhMYBCwAgHTUR4h73gSk9A0v5eQjiMiDq3Bum0lOAUdvo9XRspteyA+IeUF9f7xF595bUsiyL6upq1NTU2DSguWoII5pbi8WCzMxMv6fSeAqxWIzo6Gju5kmSfqqrqyEUCjmCy89s9zUMBgMUCgUiIiIaLad7ikYEmLKVPpgY63kmC5ciJCKJOxckEjG0Wi1uuOl6dL7hOut+wIICBYGAgoCmIaRpq85VIIDBYIRBb4Beb4BOq4NWYyVtapUG6gY1GhrUqK9rgFqt4ciwVn3pX40tSX78qUfw+ttjAFirLxSFRqtADQ0NXOqfOzcxlmURERGGP7euQ887H0F9vXvaZLFYjAnjX8KE16bb/H7Dr8vQ8y7rEqdWq+WqS2azmfsBwFnW8b8HfL03AE5LWl9fj/LycrfTuYLB/aC5cKQzJRHa4eHhLh0Vgq2Kay8/0Gov3x/cuU7yiwO+cN1ITEzEF198AZPJhIqKCuzatQvbt29Hbm4uBg4ciEmTJnldvXMGIkPbvHkz+vbty7n0xMfHIyUlBZs3b8avv/6KZ555xuazKi0txa+/WldJk5OTud9TAWLpRXn4XWVZFgUFBdz//V2lP3PmDABro+bcuXOxcuVKXH/99Zg0aRLi4uKgUCiwbt06/Prrr/jtt98wc+ZMPPHEE27tO7Du8C7gjvyAZVnU1taioqLC7aqhL0GWxAkZ8ZZACcwW1G/aBcMZW62stHN7a8DC/95pHLBAUZCNegPi7vfAYtSAObEVVHgsxN0GgqnKB6upbXQcOqE9BJGJMJpcyzgcwWw2o7i4GGaz2WPyToiMJ5Ufi8WC0tJS6PV6rgGtKf0sqdZLpVKkpqYG/M2Gpmku7YdE96pUKpSXl3MayfDwcJ9pJIHLGmN+6ERLgE9++d9jmhaAph1XviysxWapTyIVQyIVQx5l/Z7z/77kscVsAWM2w2K22EyCKYq6dCxr9ZhhGJjNjjXBtbW1qK6uRlpamk16kDtITIzDli2r0bv349C5IaUYMmQgtDodfv3lD+53+49uRVaWtXJCiAepzgqFQs4vk4SLANbPlJBb+4meWCzmTPc99XUN9O9Qc+FIZ8qHvRaXVHEJyQ2mKm5zgyZ8/d5CQ0PRu3dv7v8jRozArl278Morr+CHH37A0aNHsXr16mZ54hKQsWdlZSEnJwcHDhzApEmTMHToUNxyyy0ICwvjqpWLFy9GZWUl1+lfUlKCZcuW4fDhw0hOTkZWVha3X0pg/WlteBpqptFouAopOYddoTlVepIuClirvOfOncOgQYMwb948m3Nq+PDheP7553HkyBFMnz4dCQkJuOuuu5rcf9CQWsC2wmdfqSWkR6fTITs7u8WXmIlHalJSEoxGo9dL+RRFQWBhUfnBUpvf01ERSP9mJgx//gTm2AH7jSAb/SbEt98N0BSMu1YBklBIegyGub4ClroS+6NAmHIdqJAomByEOTQFo9GIwsJChISENFqqdvc9Au4vZ5JEMqFQiOzsbLcawnQ6HYqLi7kqaLDdjPkayfj4eJhMJhuZAj+619tznVQfW1pj7CuQa0FTFUSBgIJAQANoPBHgpBNO9l9dXY36+npkZGR4JQehKAo57TKx7sclGPDoszbLu45eO2Xqa/jys8vf/byiA4iItE5yjh496tALmXz/aJqGSCTiyC2R5JDHNE07rOK64+tKXD2C7XvkKTx9j8FaxXVUVOATlab6VQCrHpXAX0vwPXv2xKRJkzB79mycO3cO7733Ht59912f7NtisSApKQkpKSk4cOAAdu3aBZVKhfnz5yMsLAz3338//vzzT+Tl5eGbb77BN998w21LPrd77rkHXbp04fnUsgiImNxLYygvbxxJTgonfPAr7e5c55pTpbcPh4mOjsb06dMb8YiQkBC8++67eOihh2CxWDB79mz88ccfTRZ0gorU8kHTNEccSTeySCRCdnZ2i+pn+UvwxCO1urrarYuCIwiMJlR+uALmOl7Kl0CA1IVTwdaUwrB6se0GFAXZy29B3K0nIBbDuHcdwLKQ9BgMi1EHc+UFuwPQEKV1ASsOhcmLxjC1Wo3i4mLExcU1iyy6K0FwlEjWVEMYIWtJSUk+mdUHAkQiEaKiorjqGpEpkKhlQkxCQkKa/JuwLAulUgmlUon09PQWa6AMJpAmU51O12zZCk0LcMstN2Dpt/+HZ595xel5/9DD90Mmk+KrL5cDAEqqTkIsFnHNhe3bt4dWq+W+g868kPnVWVLFJRIdwHkV11UVUqlUcvvWaDSQyWQBXYX0Fs0h7k19fkQGQjT1rfn5Obp2hoSEQCgUgmEYsCwLrVbrsmLHJzP+XBV94okn8OGHH0Kn02Hjxo14++23fXI88vmPHTsW/fr1g1qtRnh4ONcAet111+GZZ57BZ599hurqapttWZZF165d8dRTTyEsLIwjtYGGoUOHNvrduHHj8MorrzRrv805d/kyFwB48MEHnZ5n2dnZuPnmm3HgwAEoFArs3bsXd955p8v9By2pJZVacoGPjY1FTExMi+tnHYU5eJt2RlEUzDUNqF2zxeb3cROGQ5rjIGCBoiAbOxmim+8AaBqmi4dgqVZAfMcTgEgCJv+g7etpEUQZN4KlxV45HSiVSlRUVCAtLa3ZlT13vGodJZI11RBWU1OD2traK5qsCQQCm+qQXq/n7MKIDQ2RKdiTMXuy5usc9SsBZNXHbDYjIyPDJ5NkmhbggQd64aMFMzFxwgyHr3ln+gSs/e4nAEBF7X/cd4SEKvAnLwC4JsPa2lqUlpZyTYbE4YBsYz0+zb03QnCb0uLaVyGVSiVUKhVqampgNBobVSGvBDR3SZ4PT6q4LdkUCjh+nxRFITU1ldNWVlZWumwAqqy87J2enZ3tj2ECsFYOO3TogCNHjsBkMuH48eNNEhtPkJaW5rQRbfDgwYiIiMD69etRVlYGo9EIs9mMu+66C6+++mpjB5QAkR8QR6/vvvsOiYmJNk85mhDwK+1NRXIDzavS25/rnTt3dvn6G264AQcOWFenDxw4cOWSWmKpUVxcjNTU1BZfPtXr9SgqKkJ4eDgSExNtyJW3pJZmLFBM/gTgEc6we25FzLP9oZ7+sm3AAiWA7JUpEHXtBtagAmuiYT61E6IuD4CSJ8CUZ+dFK5JCmN4VFkoIs4eElmVZlJWVQaPR+Eza4apSS8hpdXW1TUMYy7Lc8q2jhjBy0bmayBpfphAXF8dZOZFqNX+5WiQSobS0FCzL+oysXWkgWnGapr2S1rgCTQswbNjjqKyowgcffG7zXPfutyItLQVzZ33Mxd7yCa0j2DcZkipuTU0NKIqyqd57UsV1RHCJdZtUKkViYiLX1KjRaLimRkLQ/NnU6G/4S2IRaFVcZ+Q9MzOTI7UKhcIlqVUoFNxj+3hTX4NviUnS4HwBImEjn4WjQknfvn3Rt29fKJVKmM1mxMXFOd1fwPjUXrq3JiYmIjU1tcnXk4mpyWTye5XengTHxsa6fH1SUhL3uLS0tMn9BxWpJRd6i8WC8vJyWCwWtGvXrsVnuXz9rKPmGm+6+wUWFtq9x6H99wT3O1FaIlL+703oVn0JS3EB7wAChLw6FcIbboW58hyEqZ2g/3MR6OxbQKd2hLHgIABeU4wkDML0G1BVrYScl9/tDuzT0HxFhJx9RvyGsOzsbIjF4ib1s6RiLhQKkZGRcUUui7oLeysnQnQUCgUYhoFYLG5xR5BgAWksJHZr/viMaFqAiW+8jMqqGny7dA33++nvTMAfv+9AafVJzueaXw1per+2VUGDwcC5aBgMBoeJdq6quPymM/I8//vqqKlRo9GgqqoKJpOJa5ZytFoQyGgp3bCrKq4jRwpfw9n77NKlC+dXevLkSfTs2dPh9gzD4L//rKmUmZmZNs1S7mLs2LGIiorC3Llzm3ytSnVZjudLSZmjRko+yHcRsGo/jUYjqquruZ6Gxq8PjEot5WFNjaIoZGRk4MIFq1zRn1V6iUQCuVzOSTaaOr/5RTR3osCD52pzCQaDAUVFRVwXcksSWkf6WUfwplJLAyif+SX3fy5g4cR+mLZvuvxCSoCQ16ZD2OUmmM7vgrjz/TDu/RGC2HSIOvaEUXEcYHhm0CFyiFI7Q63RorauziNSS6rRERERPr/JOyK1pCGMpmlkZWWBpukmCa1er0dxcTEiIyObDH242kCWq0UiEVQqFeRyOUQiEWpqarjoXiJTuFoq285AbM3kcrlfZUzW7noKH3wwHTU1Smz85Q9cd901uOWWG7gKp9lsdtq85g4oioJUKoVUKkVsbCxnM6hWq1FVVeXUKs6+imtPbsm/9lU+++AHcjxCcv0d3+tLNOV+4A+4W8UlVXBfjM9Zpfb666/nHu/cuRNjxoxxuP2ePXu4SddDDz3k1Rj+++8/t5a6jUYjR6AB31SFyft/6aWX0KVLF7z44otOuQT/c9q/fz/mzJmDpKQkvPzyy7j11lsD+nz2BB06dOBIrb+r9Ndccw3277euJjfVaMYnsu5MaIKK1DY0NEChUCA+Ph5RUVGoq6trsZm12WyGQqHgIildVR88JbW0yYyab3+BqfSySXvy/NdBSwVQ/98s/o4R8voMCK/vCsPx3yC9qT9MFw+DNZsguf1xMBXnAP1lP0xBeDyEyR1gYsxWWyMPxqRSqVBcXIzExEREeVjddQf2pJY0hPHjhJsitCqVCmVlZUhISGiR+ONgBLFq4lt28YmHSqVCRUUFxGIxR3QCnXj4GjqdjruutIStGSG233zzPzxeOxKjRz/LLfWZTCaXoTLeQCgUNkq0U6vVNlZxRIvL7wvgE1y9Xo+6ujou9tmVZZij45H4XrPZ7FXwQ0vBmgjXuhM8R1V3rVYLpVIJg8HgkyquM1LL/94fPXoUx48fR5cuXRq9buXKlQCssoARI0Y0er66uhpjx47FxYsXMWHCBAwZMsThOKqqqrBr1y6nFWEAWL16NddcdPPNN9v4wnoL8j53797tkZyOhD7t27cP+/btw/Lly3Hbbbfxdsx67qflD3gxhrvuugubNlkLaP6u0t92220cqeUTZEcoLi7mHrtTFQ6AQrn7MBgMyMjIQExMDHcx9dY6yxPo9Xrk5eVBIpEgKyuryeU0T8ZFURRgMKJ64Q/c7+RP90PY3TdD/c7L/J0iZPxMK6E9/DPE13SHRa+CpeAoJHc8Caa2GJaGy0sCdFQqhEnXwsRcbqpyRxJBbIxKSkqQkZHhF0IL2JJalUqF/Px8xMfHc/pkvtbPkc5JqVSivLwcqampbYTWCerr61FSUoKUlJRGZI0Qj9TUVFxzzTWIj4/npB8XLlxAWVkZVCpVi3y/WhNEmuFMSuQvWC22BFj34zd4dIA1+9xoNPqc0NqDeFDGx8cjOzsbWVlZCAkJgUqlQl5eHgoKClBVVQWdTsd9Pw0GA4qLi5GQkICYmBiIxWKOjJrNZo6Imx1MnMnx4uLikJmZyTVwNjQ0ID8/HwqFgiNrgRDuEGi2ZaTqHh0djbS0NGRlZSEyMpJbWcjPz0dlZSU0Go1H31VHIRPA5WAPEpM6efJkzvmCYNWqVcjNzQUAzJgxw6GmcsWKFTh69CgaGhowb948l8vGb7/9No4dO+bwuc2bN2PBggUArO4M06dPd/g6T0Heu1gsRkxMjNuTq65du2LBggV47rnnIBKJ8PXXX9vG5AoC58dT3Hvvvdzkmh+Zaw9fVOn5yXGE3DoDSR8D4HLyQxBUldr4+HgbqyxCHv052yf6WU8qlp5oamkjg9LpX4C9FP0p7dweiZNHQvu/6YDqkqmxQICQCbMhvO56GA7/DDrxGgjC46D/aykkPYfCrKuHpbrg8j7jcyCQJ8PI86B1Z0yO9Kz+AtEqVVdXo7q6Gunp6ZyA3FVDWFv3ftMgjXZ1dXVuxQJTFMVVfhISEjg9plKp5Lrqw8PDbfSYVwLq6+tRUVGB1NTUJs3G/QGLxWJj2dUasLeKI1Xc0tJSWCwWSCQS6HQ6JCYmcpNHby3DyPEcxfeSBkZXwQ8tgUAjtfZwVMUlMgVPqrjOZBZarRahoaFYuHAhxo0bh+PHj6Nv377o378/5HI5Dh48iL1790IkEmHy5MlOSQ3/XuMoZhsA7rjjDvz888+orq7G4MGDccstt6Br166IiIhAXV0d9u3bh1OnTgEAUlNTMX/+fHTs2NHTj8zp+CiKgsFg4K5pjiZk9o9DQkJw44034sYbb8SFCxdw/PjxK6aHIzw8HM8//zw+//xzv1fps7Oz0adPH/z+++/YtWsXFAqFQweKY8eOcedAjx490KFDhybfR1CRWnv4s1LLsiwqKytRV1fnUj/bnHEJQMFwoQiqP/YAuBSwsGQmDH+uB3P80uyEphEycTaE13aC4dAvoEIiIcq+GcZ9GyC+dQBYFjCXnr60RwrC5A6gwmIahSo0NSaTyYSioiLO67clvqikqcTdhjDSmS4QCNq6952AT/ozMjK8IqFE30eWmt3RYwYbampqoFQq3SL9/gTDMC4DGVoSfO1mQkICl84okUhQXl6Ouro67m9P4nSdNZu5G/zAD3Ygzh0kYKQ1ggucVTADEXztNPmuuqvFdSY/0Ol0kMlkSEhIwJo1a7B+/Xps3LgRmzZtglarRXx8PAYPHoxhw4a51FIOHz4c+/btQ35+PsaPH+9w0jhv3jy89tpr2L59O/bu3Yvz589j9erV0Ov1nB78wQcfxL333ou+ffv69HvKJQ5aLIiIiPDqXpKUlIS9e/farNwGTKKYl2N44YUX8Ndff+HUqVOYPHkyVq5caWNb5kmVHrD+jQcMGOCQP02ePBmHDh1CVVUVJk6ciMWLF9usllVUVODNN98EAMjlcsyZM8et9xBUpNZRVK4/SG1zImA9GRdtsaBo8qdkI6Qtmga2ugSGNZeSS2gaoW/MBX1NRxgO/wJQgKTz/TDlHQadcQOoUDlMF/+1vpYSQJjWGZCEw8Q0PrarSi2J942KikJcXJzfL+oMw8BgMEAikXCOCk0RWhKwERYW1ta97wRms5mLOs3MzPTJxMS+y91ej8k3/w+GSQaZrKrV6rZKvwvU19ejqqoKGRkZkMlkjQI/vLUMYxiGe419s5mz+F4SP+vrZilHaI1GMV/BWRWX7ytMXCmckXdCagGrRGnw4MEYPHiwx2OJj4/HunXr3HrdkCFDnGpufQW9Xo933nkHEREREIlE3DkNWPWjP/30E2dZJxaLuYm9RCLh/i8WiyEUCiESiaDVarF3795GkqWAcT/w8vYok8lapEoPWO3Gli5dinHjxuHYsWPo27cv+vTpg4SEBCgUCvz+++/cdfrLL79ESkqKW+8hqEitPQQCgdfJXc5AOv5J9rM35MkdUitgzKjb+DcM5woBAPFvPANxdhLUr1y6gNBChL45F3S7DjAc+gmwMBB36QOLTgWKNYOOz4Qx/wD3WlH6jWBpidNQBWdjIvKK5OTkFtGmGgwGFBYWgqZpxMbGukVoSbNTXFyc3zS+wQ5iRyWTyRr5JvsKRB9JNJnE/J8f3UtkCi1ts+cOiN+y0WhERkZGUFlNtSRqa2s5SRAJMLEP/GiuZVhTwQ/O4nvJMru/gh8CXX7gLpqq4rIsC5FI1CgdjviTMgyDDRs2YOPGjcjLy4NWq0VCQgK6d++OoUOHon379j4f8/79+zFt2jQUFhZi4MCBeP/99322b5VKhY0bN0IikdisHADAv//+i5MnT4KmaZsfkUgEmqYhFAo5MkvTNLRaLS5cuACtVotevXrZHkiAwOhUasYYWqJKT3DNNddg48aN+P777/HHH3/gt99+g1qtRmRkJLp27YoHHngAAwcO9Oh+EtRXdX5Uri9AEqya2/FPqqLOLpAURUFgASrnLwMAhN3bDdHDH4Z62hhrwAItROib80C3u4YjtHRaZwjCY2E6/TdE198DY+ERwMIAQglEGTfBQglgdvFZ2FdqmyOv8BakKScxMZHzHWwq8ra2thZVVVVISUnxW754sEOv10OhUCAqKqpFU/X45v+kkqdSqVBdXQ2apj2K7vU3LBYLiouLQVEU0tPTg7Ya52+QRL6MjAynNxJ7yzB3JSrNCX5wZHlFgiZomvZZ8MOVQmrtYV/FLS8vh9ls5qq43377LSIiImAwGEDTNIYOHYqjR49CLpfj4Ycfhlwux6FDhziyM2XKFJ9VV9VqNT766COsXbvWb82CpLHJ3iqPoijodDqvNO3R0dF46qmnfDK+QENLVOkJpFIpnn32WTz77LMeH8sRgorU+kt+QAgeuZg3t2mEkDNnF0iBkUHFB0thaVBDlJ6IlP9Ngm7lF7CUFFoJ7dvvgs5qD8OhnwELAyoiDqKsm2A6sxui6++FqfQ/wKgFJQmFKL0rzCxgtri+GPCJNsuyKC4uBsMwXskrvEFNTQ2qqqq4hjC1Wg2LxeKyIYwsE7e27jGQQZp6WtvWrKnoXkJywsLCWlymQAJEJBIJkpKSrkjS0lywLIuqqiqoVCqPtdiOghjUajUqKiq42Gbyt+dbhpFt+aTWUfCD/bXBnqD5MvghmDS13oJMGqRSKaKiomA2m9G5c2f89ttvOH36NEcs4+LisHjxYlx33XXctqtWrcKcOXMwa9YsyOVy9O3bt1lj2b17N6ZPn47S0lJ07NjRxo/Wl4iNjcXixYttmjLPnj2LhQsX4oEHHkCHDh2gUqmg1+u5H51Oxz02GAzQ6/WcQ0liYiJGjhzZqFIb7JraKwFBRWrt4QtSa6+f9dVSFhmbo3xtc1Ut6r7/A5RUgvSls8Ec+xemHZsBochKaDPbwXD4Z64SK+n8AJiSsxBd0x2m6nywmhpQskiI0rqAMVtgcWN2S4g2seeRSqU+0126gn3ELr/6o1arOQ0TH2azmeu+zszMDAqtZmugrq4OlZWVrda97wyOonvVarVNdC9fpuBPEkEaIMPDw1tELx6MIKEyWq222bIMZ7HNhOQ68kPm63EB2BDbpmQKvg5+CGZNrSfgv0+apvHUU0/hqaeewpAhQ3D+/HkA1u/OwIED0a5dO0yfPh233347hg0bhr///hu5ubmYOXMm7rzzTq8TvlauXIm5c+ciLi4On3/+OSIiIvDMM8/47D3yIZPJcNdddwGw3l9omkZUVBQWLlyIe+65BwMHDuSqufbBI+SH6MGjoqI4WU4jXAHyg2DHVU1qSTpZaGioz3PenY2NZixQvP0JYLEg+YPXQYtZqD+dDYhECH37fdAZWTAc3gBc2lbc6R5Y9BoI4zNhVlWBrS2BIDwWwqTrYLq0bO8JCgoKEBsb2yLL1GazmWsqsW8Ii4qKglKpREFBAYRCIUdyaJpGcXGxX7WhwQ7iJVxfXx8UVWx72yitVguVSuWy4cgXILKMmJgYmw7eNlyGvc7Y1xNIvoUXyZQnqwtms9lhoyGRKQiFQk6mYJ9s5m3wA7+K6+i9XqnyA3s4Krio1WpcvHgRgNWPde3atTh79ix2795tswo0fPhw5Obmoq6uDsuXL8e4ceO8GoNCocCjjz6KqVOnIjIyEv/++6/3b8gDkPdNURQSEhK4a4NTomoHcj46Dq8IjCrpVXAKO0VQkVpfyg+IfpZ/UvsSjtwGBBYWmt2HoT14ClFD+yHs7pugGj/MSmgnzwedngHD4Z84QitM6wJBWCxYgwYWxghzxXkI5MkQxud4TGhra2vBsiwSExNbxGSeNISFh4fbBCqQGbBUKkVKSgp34yEJZgzDcLnaV8sNxhMQEmIwGJCZmRl0zU72DUD2DUeOlqq9gVar5QID2sI5HIP4UlsslhbRGdv7ITtqNHRlGSYSiTyyDOM3NvKrxiqVCpWVlRCLxdx4JBKJS8nYlQZHMovdu3dzE4devXqBoih06NChkTdo9+7dIZVKodfrsWnTJq9J7ejRo1tlskned5cuXbBixQrExMR4vP3VcI4EK4LrjmgHb9wPiHaMeFT6a9nWEeEWACiftQjSLtcgYfJIaBdMBfRahE75EIK0dBtCK4iIhzDrRrDaBkAoBlNwEHRsFujoVJtQhaZAmgJUKhWEQmGLLFOThjD+hMFZQxi58ZhMJtTX1yMhIYELDygtLfUZybkSYO/TG+zLpPYNRwzDQK1W2yxVkwo+IR3ugMQnJycnIywszM/vIjhBGucEAgFSU1Nb5Vxy1GjYXMswb4IfysrKYLFYOKurQEg28zccySx2797NPSaJYo4gFArRsWNHHDlyBPn5+SgoKEBmZqbHY2jt1ROWZREREeF2k7TJZOJCQpKTkx03UrbJD1odQc0SSA6zuyA+niaTyaf6WWdj45NaVmdA9bcbwRpNSP9mBgy//QjmzEmETv0IgtQ0GHmEFkIJxJ3vh8VoACUJgeniAQiTOoAKj/OI0JrNZigUCrAsi+zsbOTn5/s99lSpVKKiogJpaWkcoeATWkcNYWQpnW8hFBMT04jkSCQShIWFITw83O9azEADsewKCQlBQkLCFfnehUJho6VqUsFnWdZmqdoZCSN2VGlpaS3i6BGMINcFsVgcMI1z9o2GpIpbU1ODkpISyGQymyou2QZofvADAM4yrKGhAQUFBY2SuQLhM/IlHC2fnzt3jnucnp7ucvu0tDQcOXKE284bUttaIJran3/+Gd9//z3mzZuHTp06NVmlVyqVmDZtGg4cOIC7774bEydObGxtJaBACQLgXAmEMbQSgp7UukvSiH42JCSkRSoTJAaWZVmo1WpEmCkol2xAxvK5YCuLYfhpFUKnL4AgKdmW0AIQd7oXEAghoAQwFh2BMLUTKGlEo5QwVyDL/2FhYdyNy5P4Xk/BrwhnZ2dzOk9SRbG/qQDWC2tZWRlMJpPDpXQ+ySFaTH4lh1TxAsEyyp8g2lBS1bqS3ysBf6maT3JIdK+9L6q9zjgQfXIDAQzDcNfBQJ0c8S287FPtXNnFeRv8AFirxiKRCFVVVcjOzuaquCTMpLXje30Ne1LLsiyKioq4/8fHx7vcnv880eEGC8g9sLS0FPn5+W4XxoRCIXJycnDmzBn8/fffYBgG8+fP91i+0Ab/IqhIrbeaWlLt8Zd+1hGINKK4uBipsfGomPYJ4l4dCklmIlRvPIOwaR+BSkqC8fDPAHv5PQjTu0AQab1gmErPQJR8HViRDCYnoQqO4Gj5H3CdKtYc8CvCOTk5bgUqEJslsVjslp6Pr8VMSEiAwWDgtHEmkwmhoaEIDw8PmmQrd0GaahITEx1GEl4NcERySAWf+KJSFAWz2ex1NPDVgGB1gnBmGUbs4pqyDAPcC34glTo+aeYHP9TW1qK8vLxRFTcYYa+p1Wq1nL0ikYS5Av/5+vp6/wzSz9Dr9YiMjHS7QSwmJgYzZ87ESy+9hFmzZmHXrl04dOgQHnjggcsvapMftDqCitQCtsSsKVLL188Sf9SWREVFBRITEmDOKwZrYRE9rB80s19D2JT5oBISYDz0C4DL4xdExEOYeRNAUTBX5UOY2B4WSgSzm4SWZVkolUobP1g+/BErzHeQIBXhpggtqTzK5XLExsZ6fHPlazH5llH8zHgiUwhmgkOCJwLNsqu1QdM01+FOJlQmkwkCgQD5+fk2nrhXQlXNFzAajVwUdjBXluwtwxzpsO0tw4DGVVz+DyGzjpafnQU/kGQuXwY/tCTspWBarZZ77E5RgO+4otFofDs4P4PcAxsaGrgJMWCd9PHfO/9vyX9NUlISHn/8cezevRs1NTU2+6aowJAfBMt56A8EHanlwxVJa0n9rD3IMnlkZCRiI+QoXrQIKf/3JvRrFkP2wnhQ8fGNCC1EVh0tSwlgaagAHZN+KVTBPRJKlvK1Wm0jP1gCX1dqNRoNFAoF4uLiuBtlUwlhpInHl5VHvmWU/VIl3y7MHZ/KQACZjDU0NCAzMzNoq0H+BlkJEQqFXLXfvqPekRbzagOZRMbGxl5xMdOOdNhqtRplZWVgGMalZRhwWaZgsVhQX18PmqZhNBq5im1TwQ8GgwEajQbV1dUwGo3c+RYSEhKwE2pXllSAe4QomCeL5DrAMAxXjOH/3p1tiW9to+bltkptq+OKJLWkeiiTyZCVldWiX0CyRBUWFoaEqGjUb85FwtQXYT55EOJeD4KKjW1MaAGIO90HCMVg9SrQ4XFgLKzbVVWik6NpmvODdQRfVmrJ+3TWEGZPaEkVWalU+rWJx36pUqfTcUv4FovFrWaj1kRTOuM2WOGscY7fUe9oguMovvVKhk6n46RIV7q1GV+HDVxu/qqvr0dZWRnXaMp30yDXAJVKhdraWqSmpkIkErkd/EBWjEhjK6niehP80FIghQ3+ePgrQUSG4AokqABAQMeXk6awyZMnIzc3FwkJCdxE6MSJE7BYLJgxYwbi4+MhkUhsqu7EDo6sDMhkMk6q8OuvvwIAEhISWvPttcEBgu6OaS8/sLf0IvrZ+Pj4Fm2qsW+U0mg0kApFQHw0aCkFxCWAiomyamjtIEy/AYKIOIAxQSAJdTslDLBeXAoLCyGXyxEfH+/y/fqiUutNQxjxVtXr9cjMzGyxCgbfpzI+Pp7zROU3G5EqbiCQR1J5pGm6RXxDgxVkKV0ul7sMEXGkxVSpVCgvL+eqNFeiDpuANDolJSV5nfoUzBCLxRCLxTahH2q1upGbhtFo5CRq5HrmbfCD/fmm0WhsdP+k2aw1rzeOXGjImBiG4SreriRPfMlBIGv9yf2uuLgYNTU1qK+vt+EMLMvit99+c7o9Kc6Qv7fRaOSey8rK4qq8HARUYDgPBMIYWgmtfydvBvi54aT7uaampsX1s6TpiaIorlFKbGZhKiqH7MYOQEMNqJhoa/StHQSRCRBmdgVYAEIRTIz7oQokQCIpKcmtQAXiyOAtCOmyWCzIzs6GUCh0qyGspKQEAoGgRWJ5XYHfbETiNFUqVUDYhRmNRigUCoSFhTU5ObmaQSqPcXFxHi2l87WY8fHxjXTYfOP/QE9ocwdE5pOSkhLQlbSWgn3oB5GpVFRUwGQyQSaTQaPRgKIoh5Zh3gQ/8ON7TSYTR6qdBT+0FJzFtycnJ3MOCJWVlS5tuiorK7nH2dnZfhmnL0A+V6IZdqcKzQfLstw9jkAikcBgMOCZZ55BTk6O7fECxNIrEMbQWghqUkuW04mRuMlkcqon9RdIpTQyMpJbBqUoCuLIcLAyKcAYwYbJHBJaiKQQX38/WNb65XOX0HobIEE6fL2B0WhEYWEhQkJCkJyc7FZDmMFggEKhQHh4eMARNX6cZmvbhel0OhQXF7fFuTYBIiPxReXRPrqXb/zPJ0DBaBdXX1/PeUW3efU2Bmn+ItXGzMxMbpLTHMuwpoIfHMX3lpeXw2w221Rx/b1q4ExPm5aWxpFahULhktQqFArucSOv1gAC+SzXr18Pk8nErdaFhobikUceQXJyMkaMGAHA+r0h9wG1Ws1dEzQaDbRaLXQ6HWiaRnJyMp544gncdtttjT9HCoGhZw2uS5ZPEdSklhCrvLy8VtHP1tfXczdZfqWUNltAiQWARAyLvh7GIxsdbi/udB8goAGKcjtUwWKxoKSkBEaj0eMGOG/lB/yGMCLpaKohjCx9xsfHt0gsb3PQmnZhpKJ2tS4RuwtC1PzhBGFv/O/IMor8/QNBpuIKJHyCH2TShsaoqalBbW0tZwEnk8matAwLDQ3lrrfeWIYR2Mf3Go1GaLVa1NfXO7QM8/WkylnIwPXXX49//vkHAHDy5En07NnT4fYMw+C///4DYJ0QZGVl+XR8/oJIJIJIJOJ6QDQaDWJjY3H//fe38sja4EsE9hXaAfhfRjLT9tYayluwLIvKykrU1dUhMzPTphoisLCgZVJYjCaw2lqnhFaY0RWC8FiwgNuhCiaTCYWFhZBIJF4ReG8axUhDWGpqKke6miK0xIoqGJc+3bUL80U3vVKpRE1NTVtFrQmQz6kliJozy6iGhgaUl5c7bDYKFPCJ2tXq9OAOqqurUVdX59DT2NHfn1TsKioqOFJk32zoTvCDI5kCcFn7yw+Z8Wfwg7NKbceOHbnHO3fuxJgxYxxuv2fPHq5R7KGHHmr2eFoa5L7Vp08fXHvttTAajZy8hDzvCKSYIxQKcfLkSRw/fhyPPfaYrVypTVPb6gg6UgtYT7qamhpUV1dDIBBALpe32M2FWIUxDIPs7OxGF0WhWASLVgfW0ADj0V8d7kMQmQBhRldYWBaMmx60Wq0WRUVFiImJ8ZrAe1KpZVkWFRUVqK+vR1ZWFkcm+E0TjhrCKioqoNForhgrKvtlarI0xe+mDw8P96i7mUyK1Gp1GwFxASKzUalULdpgyIezVLvi4mIAsFmmbi29OP9zagufcA1ilefu58SXKfHdVPjNhuQc4FuGAY6ruPzrp/3ryWNnwQ9kUt3c4AdXdl40TcNsNuPo0aM4fvw4unTp0ug1K1euBABERkZyS/d8VFdXY+zYsbh48SImTJiAIUOGeDVOf4FcpydOnAihUMh9jp6swu3cuROff/45HnnkERtS26apbX0EHakl+lmDwYDs7GwUFBT4PFDAGfi6UkdRu7TJDJYFWKOqMaEVCCGISoJAngRh8rWwWFgwbo6bVAlTUlKa1WkqEAjcigQkDWFmsxk5OTluNYQRsg9Yl6SuxG5ygUDg1C7MbDZzOlxXdmEWi4V7/ZX6OfkCxDHDYDAgIyMjIJb9HREOlUqF6upqGAwGzk2Dv0ztb5CJpFarDZjPKRBhT/y9+Zzs3VTIKk5TVXxnwQ/81S5nMgVXwQ8CgcDGgsrdSZUz+YFGo0FYWBhSU1Nx6tQpTJ48GStXrrTR+a9atQq5ubkAgBkzZji8H61YsQJHjx4FAMybNw8DBgwIyJUodyzu7D8rhmE4eQqANolPACLoroDV1dUArB2X5GLREqSWRM86swoTCASgQ0SwaOrBlJ6G6JoeoMKiQcnCQdESQCAAWBaUQACzmQFjblpy4Kxa6i3cqdQSuySpVIq0tDSuucwVoTUajSguLoZMJkNiYmJALcn6C/Y3OEJwXNmFMQyD4uJiiEQi7rNtQ2MQ3TjLssjIyAjIz4lPOGJjYxstUztLtvIlCPE3Go3IyMhomyA5ASG0ZGXEV8TffhXHmWUYf5LrLPiBT3SdNZs5C36oqanhgh8IyXU1qXJWqdXpdAgNDcXChQsxbtw4HD9+HH379kX//v0hl8tx8OBB7N27FyKRCJMnT3YqPeDfY4h7gDMsWbKEe0ya1ADg/PnzNs/169evsX2Wn0D4BJloAFa3B6VSiX379mHLli04fvw4hEKhg/CFNvlBayPoSG18fDwYhrGZBfuT1PKjZ/lBA/YQCgRgGQaCMDnE1/aAhTGCZQxg9Sqw5hqAZSGMTAJjMruVEuaoWtpcNGXpRSQOsbGxnP9nU4RWq9WiuLiYSyu6GgitI4jFYsTExCAmJgZmsxlqtdrGLkwmk6GhoQEREREB5wQRSCDEXywWc7HLwQD7ZWpCcPwV+kEq/haLpc3T2AWI1Eej0SA9Pd1vlWxnlmFkkutIi9/cZjN+8AMJGiEk11V8rytSK5PJkJCQgDVr1mD9+vXYuHEjNm3aBK1Wi/j4eAwePBjDhg1z6XgwfPhw7Nu3D/n5+Rg/frzLxs758+c7/P3Jkydx8uRJ7v/XX3+9X0ktuc/xU+QqKipQWFiIs2fPYufOnVwTHYFD+QeFwCCUATCE1kLQkVp7YuVPUktuHHq93qVVmJCmYWGMsGiqAIsDHzwBDWFkCswW1i1Cy5c5+LKi58rSy5HEoamGMNKRnpyc7JTsX42gadqG4JBJEUVRUKlUABC0dlH+hMlkQlFREcLDwxEXFxe0nw0/2Yq4aTgiOOHh4V7JFIgESyAQOJRBtcEKstKl0+latJLNr+I7IpyEANs3fzXHMsxR0AhJNjOZTAgJCeHOSVKgsAc/cEEoFGLw4MEYPHiwx+8/Pj4e69atc+u1Z8+e9Xj/vgS/WEPTNNRqNQ4fPoyzZ8/i6NGj2LNnD3Q6nc02pNjjSFLh6D7ZGgiEMbQWgpLU8uEvUktusCKRCFlZWS6jZwUUC0ZVDmuCgv0LPCO0ZPmKb5/lKziSH/CdHPgSB5ZlOaNqRw1hpOGizTrINVQqFWpqapCamorQ0FAbuzCj0chVb/iNJlcjSLR1dHQ0YmJiWns4PoUjguNtdK/ZbIZCoQi6SnZLgyQf6vV6pKent+p3y55wkkkOX4tNzoGmLMMI0SXXZneCH4g0hpBcEjCh0+lspDGkUsswDDZs2ICNGzciLy8PWq0WCQkJ6N69O4YOHYr27dv77LPR6XRYu3YttmzZgqKiIhiNRiQlJaFXr14YOnQoUlJSfHYsAiKJ4E8Odu/ejYMHD+Ls2bM4ffo0KioqGm0XERGB8PBwJCcnc9fvNgQeKLa5uaktDIvFYtPsVFxcjJCQEJ+a1pNl+OjoaJcVI4qiIBIKwdSXAGYHDVgCIYSRyW4TWqVSyZmm+6PySQgWMdUmFR+GYbiluabkBqR6zTAMUlNT2xpTnIBUaJVKJdLS0hwSf9JoolarodVqIZVKOR3u1eSIQCQsCQkJbjVvXCngNxuq1WowDGMjU7AnYgzDoKioCCEhIVzQSxsag681TktLC+jJIl+LrdFo3JrkOKri8kmaq8o9y7KcbIVIHFatWoWEhASUlZVBqVRCp9Ph6NGjkMvlePjhhyGXy3Ho0CHs3bsXYrEYU6ZM8YmjQV5eHsaOHYv8/HwkJSWhb9++kEql2LVrF06cOIHw8HC8//776N27d7OP5QhHjx7F1q1bcfz4cZSWlnKNznzIZDK0b98eqamp6NmzJ+6//36EhobixRdfRFFREf78808AVh5y3333YWP3NCTLWt99pFRnwiN7FNi+fTtSU1NbezgtiqBnJPyoXF+A+LK64zQgFNIwa6qdElpBRKJbhJZchDUaDbKzs/0W08mv1BLPW6lUysXXNkVoTSYTiouLIZFI2nR8LsDvSHdlReUo1Yp003trFxZsIOETV6OExVGzoX10L5nkUBR1RUgz/A1yLTWZTEFxjXLXMowf/NFcLS7R28rlchiNRsTFxeHPP//k0hRZlkViYiJWrVqFtLQ0bttVq1Zhzpw5mDVrFuRyOfr27ev1+1YqlRg1ahSKi4vRrVs3LF68mFvOf+211/DBBx9g6dKlGD9+PJYtW4abb77Z62PxoVAosH79evzzzz+orKxETU1No+jc0NBQtG/fHhcuXEBSUhLWrl1r8xkqlUpQFOWYH7Q1irU6gq5SS0T4BBUVFaAoCvHx8c3eb3l5OVQqlVtL6kKaBhgdLOqqxk9eqtAqSkqbbApiGAYKhQIURfm9qqDVarn0KnvP26YILYlyjYqK4prI2tAYpHPfYrEgNTXVq78n/+amUqnctgsLNtTV1aGysrItfMIB+JMctVoNs9mMkJAQxMbGtmmxnYBUIRmGuSLcRexXctwJ/nBUxQVsCW5ZWRlCQ0MbkbJBgwZxDgRisRgsy+KWW27BlClTuMawF198Ebm5uZDL5di2bZvXKYiTJ0/Ghg0bIJFI8PvvvyM5OdnmebPZjAEDBuDcuXPIysrC5s2bvb43lpWV4ffff8fmzZuRl5cHi8UCg8HQ6HU33ngjunbtiptuuglRUVH48MMPIRKJsGrVKhgMBpt0N7VaDZPJhKioKAC8Su2d6YFTqd1d1FapDUYIBAJuZuotiE6NZVlkZ2c3uaRuvUCwMKurHTwphFCeDMbMorq62mVVRa/Xo6ioCBERES2ynEhRFBiGQWFhoUcNYcSHMTExsVk+uVc6yARFIpEgNTXV67+nN3ZhwQQSnkJSnfy1MhHMING9IpEIarWam0i2abEdg2VZbjJ5JRBawLFlGEkaI44apPnLUfAD0Y7aBz+QyiTfBUGtVnPL7127dsWKFSuwf/9+7Nmzx4YcDx8+HLm5uairq8Py5csxbtw4j99XUVERfvnlFwBA7969GxFaMv6nn34aM2fORH5+PjZu3IiBAwe6fQxyL/vzzz/x6quvQigUNqrIAkBGRgYefPBBdOnSBVlZWcjJyQEAbqWNOC4Q7TKB01UlgcD609oIhDG0EoLvjmgHdwMFnIEQy/DwcLc8VimKgpCmrTpa+8YwWgRhZDIY8+WKp7NCuEqlQnFxMRITE7nZnj/Bsixqa2thMpmQk5PDVcaaaggj0Ztt1TTXMBgMUCgUiIyM9HlksyO7MOKHGsixrY5gHxbQln7lHDqdDgqFwkZrzI9u5pv+87XYgX4O+Bp8QnulukHwLcMSEhIcSlX4lmGkOMGXH1gsFqhUKhgMBgiFQk6qIBAIkJubyxWHevXqBYlEgp49e6Jnz5424+jevTukUin0ej02bdrkFandsmWLzbGc4d5778XMmTMBAJs2bfKI1BLU19cDAPc5WCwWyOVy9OnTB/fccw+ysrKQmJjI9TAQoq/RaLjJo0egAkR+cJVdA/gIOlLrS/eDhoYGlJSUeEQshUIaZnVVYx2tHaHlj41fSeFH/GZkZLj08PMVyJI4uZjJZDK3GsLKy8thMBhaLaI0WEAaneLj4yGXy/16LHu7MK1Wy02QAHA63EBcouanqbWFBbgGqcglJSU1WuJ1VMFTqVScJjIQontbCuTaBuCKJbSOIBaLER0djejoaE6qolarXZ4DWq0WFRUVSE9Ph0Qi4e4BZrMZu3bt4vbdqVMnp8cVCoXo2LEjjhw5gvz8fBQUFHCNx+5i586dbh0rISEBcXFxqKqqwr59+6DX6z122iHkmXi09+jRA2+99ZaNzy6pZvPPHYZhYDAYEBoa6tHx2mJyWx9BR2rt4Q2pJZZUSqXSI2IpFNJgDRqwRo3tE4TQMmZYeJVZ+7G563vrSxBrMrFYjLS0NOTn5zdJaIkBvlAoDNhEp0AB8epNSUnx+ALYXPD9UPlWQYG4RE3CRGiavmKWh/0F0jznzjllb/pvbxdFGo2CVariCny/3pSUlICbxLUUiFSFnzRmbxkmEolQX1/faMWNpmnQNI19+/Zxv0tPT3d5vLS0NBw5cgQAcO7cOY9ILcuyOHfuHABwfSSukJ6ejqqqKjAMg7y8PJckmA9yLjz11FPo1KkTli9fjq1bt+Kff/7B2LFjceedd+LJJ59Ex44dueY5vozRZDJ5V6ltQ6sjKK9y/GV9T0ktuRCSZXh3K5ACgQAUa4FZU2P7BC22JoXZEVr7sfF9b0nEr7+h0+lQVFSEqKgoxMXF2cQxOiO0ZBk9IiKircvaBfjSjEDw6uUnDMXGxjZaom5NuzBiRXU1xSh7CzJJ8kbuY38OMAxjI1URi8XcORAMUhVXINdxmqaRnJwc1O/Fl7A/B8xmM5RKJWpqakBRFMrLyxESEoL//vsPnTt3RnR0NObMmcOFwgBosuma//zFixc9Gh9JdwMAuVze5LXI/ljuklo+OnfujI8++gjl5eX45ZdfsGLFCqxZswZ//PEHbr/9dvTr1w+9e/e2mfjrdDobUuv2+SVAYMgPruKaQVCSWj48IbVGoxFFRUWQSqXIyspym1hyOtq6YtjoaF0QWrId6WTnk8uWuADX19ejtLQUycnJNt6fLGttYAsPD2/UoENiPVtiGT2YQZwydDpdwEozAsUujHzn/KE1vtJQW1uL6upqn02ShEIh5HI55HJ5I6kKy7I+j+5tKVgsFigUCgiFwjZC2wQMBgPXExESEgK9Xo+SkhLMnj0bdXV1SE1NRVlZGfd60qTqCvzniWbVXdTV1TncjzvHamho8OhY9khMTMTIkSPx5JNPYu/evfjuu++wZcsW7NixA3fccQfuvfde3H333YiPj4dYLOYs1TwCJbD+tDYCYQythKuG1Go0GigUCsTGxnpsSSUiOlp+BG4ThJaMjXSt25NLf4EvrcjMzLRpCCONFCqVCoWFhTbkRqvVcslXLaHzDVaYzWZOwxcsulD75Um9Xs8tcRPD//DwcJ+TG2IDFxsb2yLNkMEMUvXPyMjwSyXdXqpCGo34jhr2qVaBCCJjEYlEbYlqTYB8/5KTkzlyJpPJ0K5dO2zduhUzZ87EoUOHkJCQgNLSUgDW8+SPP/7AAw884PSz5RdDSNXVXfBf747rSXOO5QhCoRBRUVHo168fbrvtNpw5cwZbtmzBTz/9hL/++gu33HILHn30URiNRhgMBsTGxgKAwyROh59PW6NYqyMoSa0n8gOS7ET8MD3VyAiFNCwGtY2OlhKKQUe4JrQsy8JkMjUil/4EaZowGo020gpi6cJvIEhMTIROp+MaTCwWCyIiIjifw7abRWOYTCYoFIqgXkbnR2jyDf/tyU14eHizNJik0anNBs41yCRUpVK1mBsERVGNonuJTKGqqgpCoZCTKQRS8AexXpRIJEH7/WspEOeMpKSkRvc8lmXxxRdfYNu2bVi4cCHatWuHu+66i3t+5syZyMzMxLXXXutw3y1Z1ecfy9eW+jExMejRowe6dOmCgQMHYteuXfj1118xffp0LtKYVJb510KFQoHc3FzcddddTWqC29DyCEpSy4crUmuxWFBWVgatVutVUhctEIBizTY6WkoouURoGaeElui9zGYz4uPjW4TQEv9ZkUjESStcNYSRG1t1dTVkMhni4uKg0WhQXV2NkpISm+pdMFQj/Q29Xg+FQnHFhU/wu6j55KaystJrDSbR8bZG81wwwd7erLUauewdNchklzhVuIrubSmYzWZOOtZGaF2DXKscOWcAwKJFi/Ddd9/hiy++QI8ePaBWq7nnWJbF3r17m9w/gaffb/7rHQUg+PJY7iI8PBy33HILbrnlFjz44IPYvXs3du3ahWPHjmHRokUoKChAnz59kJWVhZiYGJw4cQJz5szB119/3ZjUtiWKtTquWFJLmlNomkZ2drbHF2NrR6QATB1Pb+QGoeXrdkm8pb9BNLtyuZxLMOPbtZA0GftxKhQKhIaGcsEPMpnMpsmIeCDKZDKO3ATy0qS/QKqOfL/QKxG+sAsjTSmB0DwXyCBxrkajMaBkLPzgD0d+qDKZzMYPtSVACK1MJmuRkJpgBvFdT0xMdEhov/nmGyxduhSffvop7r77bgBWsigSiWAymbjvvSsJGl8G4OkqDP/6qdVqm3x9c47lCYg/7XXXXYfrrrsOjz76KLZt24YdO3Zg/fr1WLVqFW644QaMGDEC1dXW0CVHJJsSCEAFgD49EMbQWghKUsu/qBFSy18yd0TyPIVIKIRZVcnpaAmhNTGM02UQe91uWVmZz5dM7EG8dpOSkrjmLn5CmCNCS3xVY2NjER0d3Wif/CYjs9nMNRnxq3eOGs2uRJAo16ut6uipXZj9MnpLOywEE4i1n8ViQXp6ekA3adlX8okfanV1NWia5ia7MpnML2STFCdCQ0O9vpZfLSDONQkJCQ4J4LJly7Bo0SJ8/PHHuO+++7jfUxSFjIwMXLhwAYDVocCVTVdlZSX3ODs726MxJiQkICQkBFqtFnV1dTAajS6vFc05licg30GSwpaQkIChQ4di6NCh2LlzJzZs2IDDhw9j/Pjx3AS0TVYVmAhKUssHPymEpmmuotCcxiyRkIZF3wDWZJ1JUkIp6IhEl4S2trYW5eXlSE1N5WbIzQmGaArExaCmpsbGa7epyFtC0pKTk93SF9M0jYiICE5jxDd6Jw1I/ryptRbI51tfX3/VR7m6YxdGZC6tuYweDOB7qwZbWID9tYA0HJaXl3Od4r70RSaENiwsrM1esAkYDAYUFRUhPj7e4X3vu+++w2effYb58+ejT58+jZ7v0KEDR2oVCoVLUqtQKLjH/BADd0BRFK699locOXIELMuiuLjYJVklxxIKhVyErT/Bv2eazWbQNI1evXqhV69euHDhAtavX49NmzahqqrKcTW7TX7Q6rgi7j4CgQBmsxlVVVWor69HVlaW10uftEAAWBhYtEoAACWSgg53TmiJvZNKpWqk2/UXqeWHODhrCHMUeVtVVYWGhgavSRq/epeQkNDopkYIbrBZBNmDLA2TNLU2kmYLfiWfYRgoFAowl74fhIRciROd5oI0OonF4qDv3LdvOHQ00eHHN3sK0iMQERHRZgXXBIjkLS4uziGh/eGHH/Dxxx/j3XffRf/+/R3u46677sKmTZsAACdPnmwUj0vAMAz+++8/AEBmZiaysrI8Hu9dd93FhTecPHnSKamtqKjgKrW33XZbi8e0k4kZkfK1a9cOb731FuLi4jB//nzHHIOiAsNO6yr+vgTAp998UBSF4uJi6HQ65OTkeE1oiY7WrKqw/l8kc0lozWYzCgsLOXJpf/HmuzT4CgzDoKCgABaLBdnZ2RCJRFx11lXkbXFxMbRaLTIzM31SdSQ3tfj4eGRnZyMzMxNisRhKpRLnz59HcXEx6uvrbVJaggGEeJAo1zZC6xzEXkksFqNdu3Zo3749kpKSAADl5eU4f/48SktLoVKp/LZiESwgJE0qlQY9oXUEMtFJS0tD+/btER0dzZGtvLw8VFRUQKPRuHU9NJlMHKFtq9C6BvmMY2NjHXqL//TTT/jggw8wa9YsDBw40Ol+7r33Xq7yyI+xtceePXu45q2HHnrIqzH369ePK3q4OtaOHTu4x94eyxcgiWPk3GUYBkKh0DmpFQTAz1X8nQlKUsu/yBkMBu4ka25V7bKO1nyJ0CY4JbQGgwF5eXmQSCTIzMx0uNzm60qtXq9HXl4eQkNDuajRpiJvTSYTCgoKQNM00tPT/UbSxGIxYmJikJGRgZycHISFhaGhoQEXLlxAYWEhlEolTCaTX47tK5CbqUgkCrql4ZYGOa9kMhlngO9ooiOVSrmJjkKhQG1tbcCfB74GOa/Cw8OvikYnIktKSkpCu3btkJKSAoFAgMrKSpw7dw7FxcWoq6sDwzCNtiWfVWRkJOLi4lph9MEDklIZHR3t0Ad606ZNmDt3LqZNm4Ynn3zS5b7Cw8Px/PPPAwCOHj2K48ePO3zdypUrAVgbvkaMGNHo+erqagwePBi33nor1qxZ43AfmZmZePTRRwEA27Zt4zxy+TCbzVi9enWj17cmyPd2xIgRyM3NbfNzD1AE9V1bpVLh4sWLEIlEzbZZsupo68GadE0SWnLc2NhYl1UXX5JalUqF/Px8JCQkcDfGpiq0Op0OBQUFiIyMRFJSUouRNJJkxK/a6PV65Ofn4+LFi6iqqoJer/d7E50n0Ov13GfVZhnkGgaDAQUFBZDL5S5JGmkyysjIQLt27RAREQGtVouLFy8iPz8f1dXVAXce+BpGoxGFhYWQy+VXZdWR6LHj4uKQlZXFTXjVajXy8vJQUFDAnQcGgwGFhYWIioriTO/b4BiE/EdFRTls9v3jjz8wc+ZMvPXWWxg6dKhb+3zhhRe4GNrJkydDqVTaPL9q1Srk5uYCAGbMmOGwUWrFihU4evQoGhoaMG/ePOh0OofHmjRpElJSUmAwGPDWW281et1HH32Ec+fOQSQSYd68eQG1Ykauaw4hEATOz1WKwDlTPADRhxLroKqqqmaRR5omOtpaUKIQ0OHxDgkty7Koqanhoiyb6ob3BanlH9OThjCibXPmVdhSsE+z0mq1UKvVnE0U0eG6sonyN0g8cFtQQNMgzhme2pv5wi4s2ED8QtsS1S6DH91rsVi46wHRZctkMkgkEs5iqQ2NQRroiGe2PbZv346pU6fi9ddfd1hNdQaZTIaFCxdi3LhxOH78OPr27Yv+/ftDLpfj4MGD2Lt3L0QiESZPnuxUDsC/ZxInAUeIiYnB119/jZdffhn79+9H37590bdvX0ilUuzatQsnTpxAWFgY3nvvPdxyyy1uv4dWR1ujWKsjKEltQ0MD6uvrkZ2dDbFYjJqaGq/JI0VRoAUCMLWloMQhoMMcE1r7IAd3LIuaq6klx9TpdDbHbKohjERuBppXKL/RLD4+HgaDgbMKM5lMNjZRLXVDI24QbfHATYNE67rrnOEMntqFBSNIolPbRMk5BAIB53fb0NCAmJgYCAQCVFdXw2AwBE10b0uCaLMjIyMdEtq///4bb7/9NsaOHYtRo0Z5vP+EhASsWbMG69evx8aNG7Fp0yZotVrEx8dj8ODBGDZsmEvHg+HDh2Pfvn3Iz8/H+PHjXV5Tc3Jy8NNPP2Ht2rXYsmULfvzxR5hMJiQlJeH555/HsGHDkJKS4vF7aFVQggBpFAuAMbQSKDYI1/7MZjOMRiNHfIqLixEaGupVNUQsEsGsKgcogVNCyw9ySE1NdftGS2InvekQdXTMpvSzhAQbjUakpqYG1Y3AZDJBpVJBpVJBr9cjJCSEq+L6Y+mJ7waRlpZ2VVt2uQNC/tPS0vzahcwwDNRqNVQqFbRaLddFHx4eHjTetySso7VXSYIBxIrKvprNMAzniatWqyEWizmCG0jRvS0Jck8IDw93qDf+559/MH78eIwcORLjx493up8zZ85gypQpOHXqFLp168bpZH0JpVKJ1atXY+vWrdxqTGpqKu6//348/fTTzpfvgxTFxcW47777sGlQVySHtf69pFRtwMMbjmL79u1ITU1t7eG0KIKyUmtfofR2mV8kFMKsqwMoGnRYnENCq9frOU2cp+bf3o6LHDMyMtJGP+uK0DIMg+LiYgiFQmRkZATd0p1IJGoU16pSqVBRUQGJRMJJGHxBbPjkv82yyzVI5b+urq5F/Hrtl6cJsSHNjoHui0yq2VdbWIc3IIQ2Li6uUee+UChsJFchMiGLxWIT3Rts1zpvQFLVwsLCHOqN//33X0ycOBHPPPMMXn/9dYf7MBqNWLRoERYvXuzXZs3Dhw/j1VdfRVVVFXJycvD0008DsDaFffbZZ1i7di0+/fRT3HTTTX4bQ6uBQmAs/QfAEFoLQXk3t7+ZEZ9aT0DTAsBsBCyMU0LrKK3LE3hDaonOMDExkatcNKWf1ev1KC4uRmRk5BXh6cjXXxLdnUqlQkFBAYRCIVe586ZiQ2yoaJoOSvLfkmBZFhUVFdBqtcjIyGjxyj9fj52YmNjIF5mcB4FCbOrr61FRUeH3avaVABLn6o42294fm8hVlEolSktLueje8PDwoFqdcheE0IaGhjpsNjx06BBef/11PPnkk5g0aZLDa+KJEycwZcoUnDt3Dh07duS8Zn2NgoICjB49GvX19ejXrx8++ugjbmXz9ddfxxtvvIEtW7Zg9OjR+OGHH1yGPAQj2mJyWx9BSWrt4Sl5FFzS0Zr1GtChsY0ILVmaViqVNs1ZnoKiKLfHxbIslEolqqqqbJrQmiK0pHrhaeNOsIDo7sLCwpCYmAidTmdTseEHPjRFcI1GIxQKBcLCwtoiN5sAqWabTCZkZGS0urbV3uzfaDTaEJvW1l/W1tZyDaSBpGMPRBBC663eWCKRQCKRICYmplF0L5n0BnI13xMQQkvOe/v3c/ToUbz66qsYMGAApk6d6vD9btu2Da+++ipkMhlmzZqFHj16oHfv3n4Z74wZM1BfX4/Y2FjMmTPH5rpB0zTmzJmD/fv3o7q6GjNnzsSyZcv8Mo42XL24YkitI89DZxAKhbAY1aBDohsRWovFgpKSEhiNRpu0Lm/H5Y5kmWVZlJaWNmpCY1kWDMM4bQirra1FTU3NVdPkRFEUQkJCEBISYtNoVl1djZKSEpvKnT0J0+l0KC4uRkxMzBWn5/I1zGYzSkpKQFEU0tPTA6IKag9iq8OXq5BmM6K/DA8Ph0Qi8Tuxqa6u5uQZwaL7bS34uoHOPrqXTHr51Xwy6W3tiZmnsFgsUCgUkEqlDq3zTp48iXHjxqFv376YMWOG0/O8uLgYPXr0wOzZs5GUlMRpXH2Nf//9F/v27QMADBo0yGEzaVhYGAYOHIivv/4ae/fuxf79+9GtWze/jKdV0OZ+0OoISlLrSH7gbkVUJBQCFgYCcVgjQku8/yQSCbKyspp9M3dnXCRmlKIoZGdnu9UQRqJ5dTrdVX0jJRWb2NhYLqazrq4OZWVlkMlkXBVXr9ejrKysrRPdDZDzUSqVBo1fryO7MGIbx7KsR9V8T0BWdFQqVavIM4INhND6q4HOftJLqvnkmiCVSrlzIdCvmYTQSiQSh9/DM2fO4OWXX8Z9992HuXPnurxXPfLIIx5Ze3kLErMLAL169XL6unvuuQdff/01t80VRWrb3A9aHUFJau1B07RbpJamBRDQNFgL1YjQarVaFBUVISYmxme61KZILTEbJ5pBdxrCiCZUIBAExLJwoIDEdEZFRXFLkqTRjGVZyOVySCQSTsbRhsYgkZvBrM22t40zGo021fzQ0FCO2DTnu0P0xmRi2dZs6BrE37i5dnCegF/NJ02H5FygaZqr4gaaNzIhtCKRyCGhPX/+PEaPHo0777wT77//fpPFl5ZamSKRtwKBANddd53T13Xq1Ak0TcNsNuOvv/5qkbG1GNoqta2OoL0S8z1g3amICigKQqEIrMUCo13nJ5nJp6Sk+LSSRy5GjogUMRxPSEjgLjpNEdo2Tah7IF3yOp0OQqEQsbGxnI6PaHTDw8OvCM2dr3AlBgVQFGVTzSd2YSSYxFu7MJZlOfeM9PT0tollEyAWZy1JaO1hHwKj1+sdeiOHhoa26gTFYrFwLjaO0iovXryI0aNHo1u3bjZNWK0NpVKJyspKAEBsbKzLRkmSMFdeXo7KykrU1dV51YjdhjY4QtCSWj7cIbVCkbARoSXVlvr6emRlZfmlwYOMjX/xqamp8bghjNwY4uLirhjS4S9YLBaUlpaCYRgby66EhATuZkY0d/yl6UDUjrYEyLl1pcszfGEXRjT3LMsGrN44kEDOrUCyOOM3HcbFxXHSJTLZIRaCRKbQUhNfQmgFAgGSk5MbHbewsBAvvfQSunTpggULFgTU6kB+fj73OD4+vsnXx8fHo7y8HICVqF8x9l4UFRgRtVdxsSZwvhXNQFOkViQUAixsCC1ZxrdYLMjJyfHbBYJPakmFR6PRICsri/P8JA1h5PX2qK2tRVVVVUDdGAIVfL9ee9JhfzMjS9Okg95XS9PBBHIjv9rOLXfswuzT7fikIzU1ta3K3wSIS0mgN7LypUt8C8GioiJQFGUjU/DXJIZlWZSUlEAgECAlJaXRuVVcXIyXXnoJHTp0wKeffhpwYTH19fXcY3f+1vzXNDQ0+GVMrQKKCgxCGQhjaCUELal1V34gpGlQFGVDaI1GIwoLCxEaGupwicfX47RYLDCbzVAoFP/P3nmHR1Guffje9EayIRVCCoTQRIoUIUDEJKggHEE9ogdQlA5BOgpYUESxgQXxgEgREMsRFRESQEosoCBEkEMN6b1nN8lms7vz/ZFv5mySTe/J3NfFxSY7O+/sZnbm9z7v8/wegFoVhKWnp6NWq5vE+L61I6ZniB13qvu7WllZ4eLigouLi8mlaVH0tNUCoOzsbLKystq9DVVldmHGRYf29vbk5+djbW3d6NeMtkBrEbTlMbYQNG7hLLbutbe3l55vqECIKGgBk4I2OTmZ2bNn07VrVzZv3twi7wMFBQXS45ocn/E2xq+VkakvrVbUGlNlpLacoBWrot3c3Ez2zm6MY6trQZjoxern59duIod1Raysrmt6hqmlabGoxMLCQhK4TWER1diUr9pv6ZXgTU15u7D8/HzS09OlSXRmZmabORcaA7GrWmtvQqFQKLCxscHGxqZMTrZarSYtLQ0rKytpZaeu54Jo52gwGExG/9PS0pg9ezZeXl58/PHHrfrzNMY44l0T28tWg5lZy0g/aAnH0Ey0eVFr7F+bnZ0tdfxpqoIFcRZem4KwkpISEhISsLW1bTW2Ss2JGF1tKKug8kUlRUVFUqc3QCouamlV0zVBtIPTaDRy1X4NMBgMZGdn07FjR1xcXCQf1PJ2YY25NN2aEL+LrV3QmsJ44itax4nXBUEQat26V0xH0+v1dOnSpcJrMjIymD17Nu7u7mzdurVFR7yNU5eKi4ur3V6j0Zh8batHFrXNTqu9oxmLCVHUVmbXZJzL2q1btyZbvsnOzkar1VYQtFUVhIlNAsRIUWsTTU2NuITeWDdRUw0fxKrpkpISk7mXLZXyRU5y9L9qRIszZ2dnaVWnMrswcWlabP7RHicLoqBtD+ksxtZxgiDUusOdeE8qKSnB29u7wrUjOzubuXPn4ujoyCeffNJsrhE1xbjAtLCwsNrtjVMO2lRxqqKFWHq1Y93QJq68ojg0JWpNNTdobMRomEqlwt7evsYFYWLv+MYyJ29LiM4VBQUF+Pn5NUnea/nlyJKSElQqlZR7aWdnJ0XuWpqoEXO6LS0tTVZWy5SlOouzxrILa62I1672IGjLY3wuiK17xTSFjIwMKX3JwcFB+mxSU1MlS7jy94KcnBzmzp2LtbU1n376aau4F3Tr1k16LFp7VYXxNsavlZGpLy3rzlsPxGit8QVC9CZ1dHQ02WawMRDFgyAI+Pv7S5ExvV5fZUFYZmYmeXl57fKmUFtEyy69Xt+s+caWlpYVWrWKDR9EW6CWIGrEdBYxwigL2qqpSyvXyuzC4uLipHSW6uzCWiu5ublkZGTIxaz/T/kOd2LKinjNEq9XpgRtfn4+8+fPR6FQsGPHjlbj39qxY0fc3NzIyMggMzOToqKiSlfONBoNGRkZAG3PolKhaBndvNrYNaY2tFpRa6pVrl6vlyJkYq6Tp6dnk31pTLkqmJmZodPpKhW0BoNBWoYy9lSVMY0YebeysjK5bNdcGN/IjG2BYmNjsbCwkKJ2NjY2TSpqiouLSUhIwNnZWU5nqQGir2p9VksqM/qvyi6stZKTk0NmZiY+Pj6yoDWBcfqSm5ublAZnZWXF7du30ev1HD9+nMGDB9OrVy+effZZtFote/bsabJOYA3FPffcw3/+8x8MBgP//e9/GTRokMnt/vvf/6LX64HSlrltCjmnttlpMwpKbJUrRj2zsrLw9fVtsuT6goICqfpezL8TBAFzc3OysrLQ6XQ4OjqWidoZCzTZyL16RIHm6OhYI8uu5sLYFsjYA1WschYFrr29faO+BzHi6O7u3moiPs2JWLXfkJ69poz+jVNWbG1tpShua7OOEwWt7KBRPaI9Y3FxsZQGJ3ql//nnn+zevRtLS0vMzc1ZsmRJq7wXjB8/nv/85z9AacvcykTtiRMnpMcPPvhgkxxbk2GmQNEScmpbwjE0E63vm1MJYkQ0KSmJvLw8unXr1mSCNicnh/j4eLy8vMoIWr1ej4uLCx4eHpSUlBAbG8vt27fJyMggLy+P27dv4+DgQOfOnVvlRawpKSwsJC4uDldX11a1hC6KGnd3d/z9/fHx8cHS0pLMzExu3LhBUlIS+fn5UuSioRDbMHfq1EkWtDUgLy9PsqFqzGpsMWXFx8eH7t27o1QqKSwsJCYmhpiYGDIyMtBoNC3e5kgs0JQFbfWIFnoFBQV4e3tL6Qfm5ub4+vry8ccfc+edd+Lm5kZgYCCbN28mMDCQxx9/nG3btqHVapv5HUB0dDTjx48nMDCQ48ePm9xm+PDhDB06FIADBw6gVqsrbKNWq/n2228BGDp0KMOGDWu8g5Zpl7TaSK0pUZOSkoKNjQ3dunVrEpEoFivl5+eXcVUwLggzNzcvE7UrKioiKyuLzMxMKbos5h+1FqHW1IjFN83ZO76hKF9c1BhRu9zcXNLT09ukrVJjYBxxbMoldHNzcxwdHXF0dJQsolqDXVhWVhY5OTn4+vq2uuhyc5CZmYlarcbHx6dCeplGo2Hp0qWkp6ezd+9eunTpgk6nIyoqipMnT3LixAlCQkLw9/dvpqMvZcuWLdy8eROAV155hdDQUJPbvfLKK0yePJnMzExefPFF3nnnHUnE6/V6XnzxRTIzM3F0dOSVV15psuNvMhRmLSSntgUcQzPRakWtMUVFRRQVFdGhQwe8vb2brCBMbLPbrVs36WJVVUGYeKyiR6iZmVmZ1pxiHl5jL0u3FgRBIDs7m+zs7DZZQGdhYSG159Tr9VLDh/T0dMnYXSw0q8n5YPx5yUU7NSMzM5Pc3NxmjzgaW0S1ZLsw489LFrTVk5mZSX5+vklP6OLiYpYvX05sbKwkaKH0ujB48GAGDx7cYMfx1VdfoVKpgLJtaVNSUvj000+ln4OCgggICKjweuOVg6pWEbp168bHH3/M4sWLOXz4MNevX5cE8LFjx7h9+zZubm689957bdP1QNFCcmplUdt6ycvLIzk5WYpyNYUYFAvC7Ozs6NSpE2ZmZjVqeZuSkoJGoyljQWVjY4Obm1uZm1hSUpKUd9kWiknqgmiLVlRU1GSWXc2Jqaid2H9ezNHt0KFDpRF9MWevKS3OWjPlu6q1pM+rMrswcQIsOmuInayaioyMDEmgtaTPq6WSlZUlOdqUF7RarZbnnnuO69evs3fvXnx8fBr1WP79739LrXiNSUhI4K233pJ+dnZ2Nilq58+fz7Vr18jJyeGll16qcqzBgwdz8OBB9u3bx7Fjx9i7dy9Q2gI4LCyMKVOmtLoiOJnWg0Jo6clblaDX60lKSiI3NxcfHx9ycnIkn8DGpLCwkPj4eFxdXXFxcSnT8lav12NmZmbSKzcpKQkzMzO8vLyqFaliMYlaraaoqEiK0jg4OLQLw3zjJgFeXl7t4j1XhnH1vEqlkqrnxaidOKFKTk6WjNzb8+dVE8S0oaKiIry9vVuV44ixs4Zara7RhKe+iMW3lUUcZSpivGJSfgKg0+l47rnniIqKYs+ePXTv3r2ZjlKmoUhMTCQkJIQf59+Hl7L5O6Ql5Rbw4Jaj/PTTT9IKQHuh1V6diouLKSwsxN/fHwsLC/Ly8iptldtQ5OTkkJqaSpcuXSS7H+MOYaYErVix36FDhxoXOJX3P1WpVFJeaWuulq4JoiOEtbW1ZIvWnilfPS9G9I07F2m1WiwtLWUHjRpgPAFojV3VjJ01qrILs7e3b5D3Jka01Wq1LGhrSFWCVq/X88ILL3DhwgV2794tC9q2hkLRMjxiW8IxNBOt9gpla2uLn5+fJHrE5guNgRjZycvLo2vXrlJuZ3Utb0XPy/pYKpmbm5cxdRcjdunp6S3K4L8hECcATk5OuLq6tntBaworKytcXFxwcXGRPi/4n32XeD60xQlPfSnfJri1TwAa2y7MOKXF1BK6TEVycnIkV4jyn7nBYGDt2rX89ttv7N69m169ejXTUco0GrJPbbPTqq9SxqLHzMyMkpKSBh9DLAjT6/VSVFj8vZg/a+rmmJOTQ0ZGRoN6XpqZmZXJuxQLi0SDf1HQWFtbtzpB2BATgPaEVqslMTFR8uw1Ph8yMzNb/fnQ0BgMBhISEjA3N6dLly5t8vMov8Ijng8ZGRlYWlpKUdyaNAAxTtHw9fVtdRHt5iA3N7dS316DwcBrr73GqVOn2LFjB3fccUczHaWMTNum1YrayjqKNSRarZb4+HhsbGyk7lU1KQhLS0uTCnYaK4KqUCgqWIWJXdQASdC0BqswsW98Q04A2jIajYaEhARcXFykgguFQlGmi1X580HMu7Szs2vx50NDI7autrKyajcpLeULD8XzQYxUG58P5SflYpGmRqNplSkazUFeXh4ZGRn4+PhUuOYLgsCbb75JREQE27dvp3///s10lDKNjmzp1ey0WlFbnoZOP6iqIKwyQSsWrwH4+fk12c3AuBWju7s7xcXFUqW0Xq9vsg5WtUUQBLKysiSLINmCqnrEiLanpyeOjo4mtzF1PqjVatLT0ykpKWlTbVqrQ6fTER8fL1lltaTzv6kofz5otVrUanUZuzDxfDA3Nyc1NZXi4mJZ0NaQ/Px80tPTTbYKFgSBd999l4MHD7Jt27ZKu2zJtBEUipax9F/P65xOp+PAgQMcPHiQ6OhoCgsL8fDwIDAwkClTpph0yGgoIiMjmTVrFlDqmGHcga4mtGpRKwpNaFhRK+akeXl5ScKhuvxZcTnY1tYWT0/PZrt5KhQKbGxsTFqFJScntxhBY2zZJVsE1QyxWLA2EW3j88HV1bVC3qWdnZ2Ud9nWciZLSkqIj4/H0dFRztH+f4ztwlxcXCS7MLVaTVpampRO1aVLF1nQ1gDxO1mZoH3//ff5z3/+w7///W/uvvvuZjpKmSajDeTUZmRkEBYWRlRUFEqlkvHjx6NUKvnzzz/Zv38/33zzDatXr+aJJ55owAMupaioqN5NOdrMXawhRK1YGJGbm1urgrDCwkISExNxdXXF2dm5Rd08jQuLREGTk5NDSkpKs1mFlY9ot/VoYUMgdr2qbxOK8nmXYuFhWlpamyo8FIvonJ2dG93mrzVjYWGBUqnEycmJpKQktFotNjY2JCQkNIldWGtGXA2r7Dv58ccf8/nnn7NlyxYCAwOb4QhlZGqHRqNh3rx5XL58me7du7Nnz54ynsJ79+5l3bp1vPLKKyiVSsaOHdug42/evFlKmasrbUbUii1n64rBYCAxMRGdTlemIEz0nwVMii8xH7Q1tHBtCVZhJSUlJCQkNHtEu7UgeoTm5eU1eNcrc3NznJyccHJyKuN/Ghsbi7m5uSRwa1JY1JIQc47d3NzkosMaINqcGQwGaZLZFHZhrRm1Wk1KSgre3t4mBe0nn3zCzp07+eCDDwgKCjK5j6Zc4j1z5gzffvstf/31l5SG5OjoSEBAACEhITzyyCNyPUND0MotvbZv387ly5cBeOONNyo0yZg6dSqnT58mMjKStWvXMnLkSMnetL5cv36dXbt20bNnT65fv17n/bRqUdtQ6QclJSXExcVhY2NT5qJeXUGY2GGnNbZwbQ6rMFFsiNGz1iSUmgPjgh0/P79GTQ8w9j/19PREo9GgUqkksdNS87LLI1qbVZVzLPM/BEEgKSkJg8FAly5dpIl7TezCxHOivaUOqdVqkpOT8fb2xtbWtsLzu3btYuvWrWzatImQkBCT+2iqJd7i4mJWrlxJeHg4AD169ODhhx9GqVQSExPDsWPHOHv2LDt37mTz5s2yK0N9acXpB2q1mh07dgAwYMAA+vXrZ3K7adOmERkZSW5uLrt37yYsLKxehwql16GXXnoJvV7Pq6++yuTJk+u8r1Ytao2pq6gtKioiLi4OFxcXKe+uOkFrMBhITk5Gp9M1uthoCprCKky8EXh4eODk5NTA76DtIZ5jer2+yQt2jAWNcaGZcQtn48KiloJYRNcaVk1aAqJvL1BG0JrClF2YeE6I14ia2oW1ZgoKCkhOTqZLly4mBe2+ffvYvHkzb731Fvfff7/JfTTlEu/atWslQTtnzhwWL15c5u8cGxvLk08+SXJyMjNmzODw4cNyC9t2ysmTJykoKABg9OjRlW4XGBiIjY0NGo2GQ4cONYio3b9/P1FRUTz++OMMGDCgXvtqAVOKhqEuojYvL4/Y2Fg6d+6Mm5tbjQStGNVVKBRt0pBctArr1KkTAQEBeHp6SqkZ0dHRpKWlUVhYKEXIa0Jubq50I5AFbfXo9Xri4+NRKBQtou2tWFTk5+eHv78/dnZ25Ofnc+vWLeLj48nJyWkUj+jaINpVeXl5yYK2BojfaYVCUa2gLY9oF9a5c+cy14jk5GRu3bpFSkoKarW60Ts8NjWFhYXSOWZnZ1fh+a+++oqNGzeyfv16xo8fX+l+arLEGxQUhCAIrF27FpVKVafjTUtL49tvvwWge/fuLFq0qMLf2c/Pj5UrVwKlefufffZZncaS+X/ESG1L+FdLTp06JT2uKmJvYWFB7969AYiJiSE2NrbWYxmTkZHBxo0bcXV1ZdmyZfXaF7TySG355gsGg0Eq5qoKMXUgJycHPz8/acZdXUFYUVERiYmJ7Wb5vL5WYeXzQWXLruoRc47t7Ozw8PBoceeYhYUFzs7OODs7lzH4T09Px8rKqkzaSlMdu5jXXtlysExZREFrZmaGl5dXvf5OxtcIDw+PMlH98nZhrTkAIBYDV+Y88u233/Lmm2/yyiuvMGnSpEr305RLvJcuXZKCD3fddVelk+MhQ4ZIj8+ePVvrcWSMUbQQj9jaf6eN81h9fHyq3Nbb25uLFy8CcOPGDfz8/Go9nsj69etRqVS8/PLLDZIy1nqvMuUQRWh1olZcctNqtXTr1k3KBxMEAZ1OB5guCBMLqtprrl5lVmEZGRkmrcIEQSAlJYXi4uI2kaLRFIgV+0qlslVMmsob/IuFZmKUuSkagGRnZ0ttSeVJU/WIndUsLCzo3Llzg/9dqrILE3P1HRwcmnTSU1/EYEbnzp1NCtpDhw7x2muv8cILL/DYY49Vua+mXOI1Xj0xFVk29VxOTk6tx5ExopXm1AqCUCbi6u7uXuX2xs/fvn27VmMZExkZyZEjRwgMDGTChAl13o8xbUppiNHaypbSRN9KKysrunbtWuOCsKysLHJycuRIkBFVWYXZ2dmh1WqxtLTE19dXtuyqAWKBU2ttE6xQKLC3t8fe3l6K2IlRfbFyXozqN9T5kJmZKTXuaO0WZE2BKGgtLS2bpLOaaBcmFqMaT3pai12Y+L3s1KmTybSW8PBw1q5dy3PPPceUKVOq3V9tl3gvXrwoLfHWNhrWq1cv6fGNGzcq3c74Odn+rn1SUFAgTYLE1ZeqMH4+Ly+vTmOKnrTW1tasXbu2TvswRasWtaZa5VaWx1VUVER8fDzOzs41zp81GAxlqs/bW5VvTTEuIhEdDhQKhRThECN2crTWNGIRXadOnRrMHqU5MRXVV6vVZGdnk5ycXO8laTF9SKVSyY07aojYKtja2rpZrPSM3TUEQZAmPWlpaZSUlEie2S3JLky8llX2vfzpp5944YUXWLJkCdOnT6/RPptyibdbt27cf//9REREcObMGf744w+GDh1aZhuDwcCHH34o/RwcHFyrMWTK0cLa5KamplZ4SlxdM0ZcPQBqFCAwXhUzfm1tED1pFy5ciK+vb532YYo2pTIqE7X5+flSVbRYqFSdoNXpdCQmJmJhYSE3CKgh4k1AFLiCIDSJVVhrRswH7dKlS7Wz49aKlZWVdE6UX5K2sbEpsyRdHcY2Z76+vvJEqQaIhYc2NjYtwhu6/KSnpKQEtVrdouzCNBoN8fHxeHp6mhS0p0+f5vnnnycsLExq6VkdzbHEu2HDBiwtLTl06BCzZs1ixowZDB8+HCcnJ2JiYtixYwdRUVEA9O/fn2nTptVpHJn/p4WlH5haPQgLC2PhwoX13H393qPoSdu1a1dmz55dr32Vp03dEcqLWrFQKSsrq1YFYWJuo6OjoxTVlakaMdponHOsUCga3SqsNZOVlUV2dna7ygctvyQtnhPG1lCVnRNikwCdTtfkNmetFVHQ2tratsjCQyhd6SlffNicdmHi9d/Dw8Nk/cSvv/7KihUrmDlzJvPnz6/xfptjidfOzo53332Xp556irfffpuPPvqIjz76qMw2jo6OPProoyxZskQONtQXRQspFPv/78m+ffvw9PQs85Spc9o4V1yr1Va7e41GY/K1NUH0pNXpdKxdu7bBz7lWLWpNpR+I3b/EgrDi4mL8/f1rXBAmirPWmtvYHOTk5JCRkVFltFG0ChPN/YuKilCpVFJLvKYoKmopiO2Y1Wp1u05rMTMzk/7ugiCUOScEQZCes7Ozk5oECIKAt7e3vHJSA3Q6HfHx8djb2+Pu7t4qvlfliw/Fc6J8ExA7O7tGOQeKi4uJj4/H3d3dpP3g2bNnWbZsGU8++SSLFy+u1b6bY4lXq9WyefNm9uzZg0ajYfz48QwfPhw7Oztu377NiRMnCAkJYeLEibKgbYN4enrSpUuXarezt7fH0tKSkpISqei3qkmX8flY28J50ZN24sSJDBs2rFavrQmtWtSWR2yVq9PpiIuLw9LSkm7dutWoIAxKK6kzMzPb9FJwQ2LcVc3Pz6/GF8X6WoW1ZsRoY0lJCX5+fnK08f8xdU6o1WrS09PRarUoFAosLS3x8fGRBW0NEAWtg4NDq11tamq7MK1WS3x8PG5ubiYF7fnz51myZAmTJ09mxYoVjf6Z1vc81+v1zJs3j19++QVLS0u2b9/OiBEjymzz9NNPM3PmTD7++GNmz57NwoULW+W50mJQtJD0g1pGixUKBb6+vty6dQuA9PT0KnO409PTpcfdunWr8ThZWVls3LgRGxsbpkyZIgW1KkNMAzWmOpHepkStmZkZxcXFpKamolQqpehETRwO0tLSKCgoqJU4a88YDAZSUlIkcVbXm0r5/DpR4BpbhTV01XxzYWx4L4uzyjE+J5ydnYmPjwdKv9+3bt3Czs5OOi/knNqKiJN6R0dHqUtiW6C8XZiYuiLahYnnRF3swrRaLXFxcbi6uppcoYuKimLRokVMmjSJ1atX1+kzbcolXijtTPbLL78ApbmV5QWtuN+3336b++67j48++gidTsfSpUtrPZbM/9PCcmprQ69evSRRm5CQUKWoTUhIkB736NGjxmPcunVLaibyz3/+s9rt09LSKrSaNi62NEWrviOYKu7Kz8+nc+fO0oWpOkGr1+ulVpFy5Kxm6PV6EhMTMTc3b3BxJt64XF1dJasw46p5Mb+utf2ddDqdVH3eFHZKbQFTy+d6vV4uPqwC0bZQrAdoq1hYWODk5ISTk5NkF6ZWq8t4JDs4OGBnZ1ftd038zFxcXHB2dq7w/N9//01YWBjjxo3jpZdeqvN3tymXeKF0mVdk4sSJlW7XpUsXBg8ezO+//86nn37KY489VqMla5m2RVBQEIcOHQJKz/lRo0aZ3E6n03H16lWgVDN17dq1xmMEBARUyOk2xYIFCwDo2LEj69atq/H+oZWLWhGxIKywsFAqQhF/X1VBmFarJSEhQfLWlIVG9YifmYODQ6Pn6RlbhYlV82ITDFtb21ZjFSZ+Zh06dGi1S8FNjbE4M442mpubVxAzKpWKuLi4Mjm6TVVU1JIQW3grlUpcXV2b+3CaDGO7MGOP5PT09GrtwsTPTLzOlOfq1avMnz+fkJAQ1q1bV68JfFMt8UJpbUhMTIw0bkBAQJXb9+zZk99//x2dTsepU6eYOnVqrcaT+X9amKVXbQgODsbOzo7CwkJOnTrFvHnzTG7322+/SasIDz74YK3G6NixI6GhoTXe3tbWtlbbA7SAT79+iAVheXl5ODs7SxctsSBMEATMzMwq3OAKCwuJjY3F2dm5RdjctAaKioqIi4vD2dm5yScBYtW8t7c3AQEBKJVKCgsLiY6OJjY2lqysrBot6TU1Go1G+sxaS7FOc1NcXCx9N6uaBIhiplOnTnTv3p3OnTsDkJyczK1bt0hJSUGtVlfqXd2WEMWZs7NzuxK05RFTV9zc3OjatStdu3bFzs6O3Nxcbt26RXx8PNnZ2ZSUlEgTJ2dnZ5OC9saNG8ybN49Ro0axYcOGBlmRMm6IYLyEa4q6LvFCxaK06ib+xhFjceVSpg6YKf6XgtCs/2p/n+nQoQPPPPMMUJpuc+nSJZPb7dmzBwAnJyeT/syZmZlMnjyZIUOGlFktaCpatajV6XTExsZiMBiklrcGgwG9Xo9Op0OhUJi8EOXm5kptD01dzGQqolKpSEhIwNPTs9k/MzMzMxwdHfHy8iIgIABXV1e0Wi2xsbHcvn2bjIwMNBqN1Pe8uSgsLJQqqZv7M2stiP6gbm5utfrMFAoFtra2uLu74+/vj4+PD1ZWVmRmZnLz5k1p4iu6o7QlxHzQjh07yh2hyiHahfn4+EiTYY1GQ0xMDNHR0VhYWEjuGsZER0czb948hg4dyttvv91g6U5BQUHS47///rvS7eqzxAtl0xWKi4urnfCLeY5QM2cGmUoQI7Ut4V8dmDlzptTpbtWqVWRnZ5d5fu/evURGRgLw8ssvm0yL+eyzz4iKiiI/P5/169dTVFRUp2OpKy173bYazM3NUSqVODs7S+kFer2+yoIwsVq/PXmD1pfs7GyysrJaZJtg46XHyqzCHB0dm3w5WkyT8PLyqlORR3uksLCQxMTEMl7HdaV8UZFKpSqTutLc5v4NhXGBk6l8UJn/IU6G7ezsKCoqklwTkpOTSUxM5Ouvv2bw4MH06dOHNWvW0L9/fzZu3Nig6U1NscQLpcu2fn5+UrOHK1euMHDgwEq3v3LlivS4tgJapu1ga2vLxx9/TFhYGJcuXWLs2LFMmDABpVLJ+fPnOXPmDJaWlqxatarS89J4gigIQo2CSzdv3pTEsjFqtZpPP/1U+jkoKKjaVJpWLWrNzMxwcXGRPjgrKyvS0tLQ6XRSbp04wxbTFPR6fb2q9dsTxn6qvr6+LX4Gb8oWKj8/n5SUFMkqTLypNabAzcnJITMzs0VOAloqBQUFUtc/BweHBt23hYWFZO5vMBikQrOMjAysrKzKFJq1pvQQ0VNVFrQ1R2xGYZzfLnrSnjhxgj179pCdnY29vT0BAQFcu3aNvn37NlgxrLjEu3nzZmmJt1+/fhW2q8kS74IFC7h9+zZLly7liSeeqLDNhAkTpBa4X375ZaWi9urVq1JXMVtb2zLRZJla0kotvYzx8PBg//79fPPNNxw8eJBDhw5RWFiIu7s7kydPZurUqVWmw0ybNo2zZ88SExPDkiVLamSPevnyZd56660Kv8/Lyyvze2dn52pFrUJo7jXaeqLVaqWUA9HpoKCggPz8fAoLC7G1tcXOzo68vDxsbW3x9PSUrZRqgMFgIDk5Gb1eT5cuXVqd20B5xOIRlUpFSUlJo1iFiQWLeXl50vK3TPWoVCpSUlKa3B9arEAXzwuxar41NAERBa2bm5vcJKaGiIJWnPSW//smJSUxc+ZM3N3dGTFiBJGRkVy5cgU3NzeCg4NZtmyZSf/a2lJUVMSUKVO4cuUK3bt3Z8+ePWVSbfbu3StVfG/cuNFkRGzjxo1s3boVKE2xOHfuXIUJtFqt5tFHHyUmJgaFQsErr7zC5MmTy2yTkpLCM888I7XhXblyJTNmzKj3e2xvJCYmEhISwo/r5+LlWv9zpL4kZebx4Jp/89NPP7U7J4tWH64s73BQ3upFbKgApRGb3NzcNrHs2JiIhseWlpZtpntTY1uFCYJAamoqRUVF8kpALcjLyyMtLa1ZotoKhQJ7e3vJ/cS4CYhOp2uxHsli3rGHh0eDiKz2gHG7YFOCNi0tjTlz5uDt7c22bduws7Nj8eLFpKamcvLkSf744w/y8vIa5PNuqiVeBwcHduzYwaJFi7h06RIvvfQS33zzDcOHD8fGxoaYmBiOHTtGYWEhFhYWhIWFyYJWptXTqiO1Fy5cYPny5QwfPpzQ0FAGDRokiQlBEDh9+jSenp5SXqMYwVWr1VhbW+Po6CgL3HKIXXVEn8uWHK1qCESrMJVKJUX2a2sV1tai2k2FmKvt4+PT4vLbtVqtdF5oNJoG715VV0RB2xB5x+0FvV5PQkICNjY2Jl1b0tPTmTVrFi4uLmzfvr3B018qQ6fTSUu80dHR0hJvYGBgtUu86enpLFiwQFrinTJlSqXb6vV6jh8/zpEjR7h8+TJZWVnSalXXrl0ZMmQIjz76KL6+vo3xNtsFUqT2jXl4uSqb+3BIyszlwVUft8tIbasWtSUlJXz11VccPXqUc+fO0aFDB0aPHk1QUBA//PADv/32GwcOHJCsfkREf0tR4FpaWkoCtz0vGYuFOm5ubu0yR88431Kc+FRn7G/ciKJz584tKqLXksnMzCQ3N7dVpGmIEx+1Wk1BQQE2NjZSZL8pj72oqEhyIJEFbc0wGAwkJCRgZWVl0roxOzubWbNmYW9vz86dO+nQoUMzHalMa0YUtYc3hLUYUTvu+c3tUtS26jVSS0tLpkyZwpQpU8jOzub48eP88MMPrFixAltbW0aNGsWNGzfo2LEjNjY20uuMK+YFQZDaLcbGxmJhYSEJ3JYWPWpMxMrwxijUaS2I1dGOjo5ljP3F80IUuNbW1igUCkpKSkhISJB607f1qHZDIDqQqFQqfH19W8UqieiRrFQqpZx9lUpFZmamyfOiMRAFbadOnWThVUNEQWtpaWlS0Obk5DB37lysra359NNP5c9Vpv604ja5bYVWLWqN6dixI/379+fjjz8mICCAhx9+mN9++43nnnsOS0tLRo4cSWhoKIGBgWWKURQKRRlLKFHIxMfHSyKnsW9YzYkgCGRnZ5OdnY2Pj08Z8d+eqc4qzM7ODrVaLZndt8Vzo6ER8441Gg2+vr6tMu/YuGuZIAhlzgtBEKTnGtJhQ1xBkQVtzTEYDCQmJmJhYWGyLXV+fj7z589HoVCwY8cOOTdZRqaN0PruKpVw5swZ5s+fz6hRo3jzzTextbXlqaeeQqVScerUKSIiInjxxRcBGDFiBKGhoYwcObJMVLJ84Uh5ISMK3LbSglMQBNLS0igsLMTPz69VRM2ag/JWYXl5eaSmpmJubk5ubi56vb7BhUxbQxAEkpOT0el0+Pj4tIm84/LnhVarNdme1cHBoc5pKaKgbc8rKLVFFLRiSlD576RKpWL+/PlotVr27t0rN0aRaTgUipYRJW3H96E2I2pv3brFrFmzmDt3bpkbSIcOHZgwYQITJkygoKCAn3/+mfDwcNatW4dOp5OKzIKCgsrkqZW/YWk0GlQqFcnJyWUiMi3d+qcyRN9eg8GAr69vmxAZTUFBQQHp6el4eXnRoUOHCn3mW2rFfHMinmuCILQZN43yKBQKkw4bubm5pKSkYGdnJ50bNY1Qi969cgOPmiMIAklJSZiZmZkUtAUFBYSFhaFWq9m7d6/cgU2mYalHN68GP452SqsuFKsPGo2GX3/9lfDwcE6cOIFGo+Huu+8mNDSUe+65p9JCKUEQynieilG61hSp0+l0JCQkYG1tbXJpTsY0ov1UZX6qopAxrpivr1VYa0fMazQ3N8fLy6tdnmt6vV4qNDMuQHRwcKg0b1+tVpOcnCwL2logClpBEOjSpUuFc62wsJCFCxeSkZHB3r178fT0bKYjlWlrSIViG5fh5db8RdZJGTmMW/puuywUa7ei1hitVstvv/1GREQEJ06cQKVSMXjwYEJCQggODq5yNi8K3Pz8/DKdzOzt7VvkDby4uJiEhAScnJzkXNBakJWVRXZ2Nt7e3jXKO24Iq7DWjugNamNjY7JQpz1iXICoVqvL5OiKaU2ioG3qZhStGTG9RbTVK78aoNFoWLx4MQkJCezduxcvL69mOlKZtogsalsO7ePuWg1WVlaMHj2a0aNHo9Pp+P333wkPD2fr1q1s2LCBgQMHEhISQkhICO7u7mVea7zkKObUZWRkkJyc3OKWosX8PHd3d7kLUQ0xrtavTd5x+Yp5UeCmp6fXyCqstaPT6YiPj8fe3t6k2X17pbzzinFak8FgwNramqKiIry9vWVBW0OqE7TFxcUsX76c2NhY9u3bJwtamcZDTj9oduRIbRXo9XrOnz9PeHg4x48fJz09nX79+hEaGkpISEgF/1tjxKXo/Px8iouLJYFbn6KR+iAuncvLmTVHEARSUlLQarV06dKlQSKsxpE6lUrVZJZQTUlJSYnUwENeDag5WVlZZGRkYGVlVaHQrL2mr1SH+B0tKSkxma+t1WpZuXIlV65cYe/evXTt2rWZjlSmLSNFat9/Di+35i88TMrIZtyiN9tlpFYWtTXEYDAQFRVFeHg4R48eJSUlhT59+kgC18fHp9LXmsq1dHR0bBKBKwgCWVlZ5OTk1HjpXOZ/FdSAyehPQ2BsCZWfn49CoWj1DhvFxcXEx8fj4uIiV5XXAtEnWrTV0+l0UoqCmL4iToxll5JSRIu44uJifHx8KnxHdTodzz33HFFRUezduxd/f3+T+9HpdBw4cKBMZy8PDw8CAwOZMmUKAQEBDXrcarWa77//nmPHjhEbG0tWVhb29va4uroSEBDAsGHDuOeee1pEzq/BYJA+V+PHMmWRRW3LQRa1dUAQBC5fvkxERAQREREkJCTQo0cPSeB269at0teKNyuVSkVRURF2dnaSwG3oaIx40ReXM+WbYc1ojkI646VolUqFwWBodQWIGo2GhIQE3Nzc5PSWWiCuolTmEy2mr4j/LC0tyxSatYZzo6ER7Qg1Gg3e3t4Vrp16vZ41a9bw+++/89lnn9GzZ0+T+8nIyCAsLIyoqCiUSiXjx49HqVTy559/cubMGaysrFi9ejVPPPFEgxz36dOneeGFF8jOzmbo0KH07dsXW1tbUlJSOHbsGDk5OQA8+eSTrFmzpkHGrCs6nQ4LCwtUKpXsj1wNkqj9YFXLEbXPvtEuRa2cU1sHFAoF/fr1o1+/fixfvpxr164RHh5OeHg4W7Zswd/fX8rBDQgIKHPTsbCwwNnZGWdnZ/R6vRSlS01NxdbWVhK49V3q1uv1JCUlAciWXbVAXDrv0KEDbm5uTSYYFAoFtra22Nra4u7u3uqswsR8bbmFa+3Izc0lIyMDX1/fSp0QjDvdCYIgpa8kJCSgUChavb1gbREFbVFRkUnPY4PBwNq1azlz5gy7d++uVNBqNBrmzZvH5cuX6d69O3v27CmzurB3717WrVvHK6+8glKpZOzYsfU67uPHj7No0SK6dOnCp59+So8ePco8v2rVKmbMmMGFCxfqNU5DIAra7OxsHnroIcaOHcvq1aub+7BaPooW0lGsHefUyqK2nigUCnr37k3v3r1ZsmQJN2/elFIUtm3bhq+vL8HBwYSGhtK7d+8yNx1zc3OpmEi0/VGpVKSlpdWrWl5s32praytXndcCMdLYEpbOTXmeZmdnk5yc3OJyLUU/VblBQO0QBa2Pj0+NW3KXbxAjTn5SU1PR6XQtfvJTXwRBID09vUpBu27dOk6dOsXOnTvp06dPpfvavn07ly9fBuCNN96o8J2fOnUqp0+fJjIykrVr1zJy5Mg6RywTExNZtmwZVlZW7Nixw2Sxmp2dHStWrGDGjBnNWkBqHKGdOnUqJSUlDBw4UPq9TBXIhWLNjnyGNjABAQEEBASwcOFCYmJiCA8P59ixY+zcuRMvLy9J4N55550VBK6TkxNOTk4VquVtbGwkgVtdCoEozJydnXFxcZEFbQ0RI40eHh4trmWmpaUlHTt2pGPHjpJVmHF0vzmtwlQqFSkpKbL9VC3JyckhMzMTX1/fOgsYhUKBjY0NNjY2uLm5odVqUavV0uTHzs5Omvy0BTEiOpEUFBSYXH0SBIENGzZw9OhRtm/fTr9+/Srdl1qtZseOHQAMGDCg0m2nTZtGZGQkubm57N69m7CwsDod+4YNG9BoNMyYMaNK94W77rqLixcv1mmMhkCv12NhYUFBQQH/+te/uH37Nr169WLEiBFYWFggCIJ8T5Fp0bT+K10LpmvXrsybN4958+aRkJBAREQER48eZc+ePXh4eEgCd8CAAWWiKsbLjQaDgYKCAlQqFZmZmVhZWVVqByVGzFqiMGvJiMKsNUQaja3C9Hq9dG40h1WYmAvq7e2Nra1to4/XVsjOziY7O7tegtYUVlZWFSY/arWatLQ0aWLs4ODQam3kMjMzUavVJiO0giDwzjvv8MMPP/DJJ58waNCgKvd18uRJCgoKABg9enSl2wUGBmJjY4NGo+HQoUN1ErUpKSkcP34cgAceeKDWr29KzM3N0Wq1jB8/nuLiYnx9fYmOjubKlSsMHz5cFrXVoFCYoVA0/+qZQo7UyjQ23t7ezJw5k5kzZ5KSksLRo0eJiIjgiy++oGPHjgQHBxMSEsKgQYPKRFWMzdkFQZBETGxsrFQw0qFDB4qKiqT2rbJlV83JyckhIyOjVQozc3PzMpMfMdcyNja20a3CsrOzycrKqjIXVKYiohOJj49Po4rL8j7JxhNj8dxwcHBoNS4bmZmZ5Ofn4+vrWyHqLAgC77//Pt988w3//ve/GTp0aLX7O3XqlPT4jjvuqHQ7CwsLevfuzcWLF4mJiSE2NhY/P79aHfuPP/6IIAjSvkT0ej3Z2dlYW1u3qDz0P/74Aw8PDyZOnIiXlxcLFy7k4MGDDB8+vE2mtDQoZi0kp7YlHEMzIYvaZqBTp0489dRTPPXUU6Snp3Ps2DEiIiJYsGABHTp04N577yUkJIShQ4eWSTdQKBSScbunpyeFhYXk5+cTGxuLwWDA2dkZc3NzeTZdA0Srs9zc3DYhzIxN/T09PSkqKiI/P5+EhASTXavqSvnPrbVG/ZqDzMxM6XNrSieS8hNj0UZObCnb0l02srKyyMvLw8fHx2Qaxccff8znn3/Oli1bCAwMrNE+r1+/Lj2uyo4RSgMSYkrAjRs3ai1qz58/D4CHhweWlpZERkayY8cOzp8/T0lJCQBKpZJRo0YxZ86cBrcQqy2DBw/m7bffplOnTmg0Grp27cp3333HP/7xD4YPH96sx9bikXNqm51mEbVN6QtYVFTEF198weHDh4mPj0er1dKpUydGjx7NlClTmr27jLu7O1OmTGHKlClkZ2dz/PhxwsPDWbx4MXZ2dgQFBREaGsrw4cPLCAiFQoGdnR15eXlYWlri5uZGYWFhg4uYtohYPV1YWNjkAqMpEM8NOzs7PDw8KnStqquIMe6u1hY/t8YkIyNDijQ25+dmfG64u7tLXRDT09PRarVlCs1aQhFidnY2OTk5lX5un3zyCTt37uSDDz4gKCioRvsUBIHY2Fjp5/JdIstj/Pzt27drduBGXLt2DQB7e3tee+019uzZQ9++fVmxYgVubm4kJCTw9ddf88MPP3DkyBHWrl3LP//5z1qPUxdMFX/Z2Njg7e0NgIODA7Nnz2bJkiVERUXJolamxdPkorYqX8D9+/fzzTffNJgvYHR0NAsWLCAmJoZOnTrx8MMPY2Njw88//8ynn37KV199xYYNGwgNDW2Ad1Z/OnbsyGOPPcZjjz1Gbm4uJ06cIDw8nJUrV2JpacmoUaMIDQ0lMDCQjIwMFi9ezD//+U8mT54sCVl3d3dJxIiWXh06dMDR0VEWuJRWR4stNduD1VlDWYWJnscajcbkErCMaQRBqHLpvDlRKBQVXDbUajW5ubmkpKQ0exGice6xKUG7a9cutm7dyqZNmwgJCanxfgsKCqQIqSjyq8L4+by8vBqPA6XXm5SUFKA0ynvjxg0efvhh1q9fX+b7Nm3aNJ555hkuXrzIiy++iIeHR41Fel0xFrTvvfceI0aMYMiQIRW2GzhwIP7+/nzyySeEhoY2eyS5RaNQtIyl/3Z8n2/SK1VT+gJmZ2cze/ZsEhMTGTp0KNu2bZNyJhctWsSbb77Jjh07WLJkCbt27aq2sKCpUSqVPPzwwzz88MOoVCpOnjzJ0aNHeeGFFxAEAUtLS7y9vQkODi5zcTQWMW5ubhQXF5Ofn18mSufo6NhuPC2N0ev1JCYmYm5ubrKlZnugLlZhgiCQnJyMTqczWaQjYxoxsq1Wq1ucoDWFpaVlGQ9tsdDMuAhRbPjQ2OTk5Eg526YE7b59+9i8eTNvvfUW999/f632LRaIATVKnzF+v8avrQlqtbrMzx07duTFF1+scO2xs7Pj9ddf58EHH8RgMPDqq68SERHRaN81Y0H7r3/9i0uXLtG7d2/0en2FMT09PRk3bhwffvghZ86cISAgwOR2MsjpBy2AJn3nNfEFDAoKQhAE1q5di0qlqvNYb7/9NomJiVhbW/Pmm29WKAJavnw5PXr0QKvVsmbNGvR6fZ3Hamw6dOjAP/7xDzZv3szrr7+OwWCgY8eOxMbG8tBDD7FkyRIOHTpEfn5+mdeJlj/u7u74+/tLgiQ1NZWbN2+SkpJCQUEB7aGpnE6nIy4uDisrK7y8vNqloC2PaBXm6+uLv78/Dg4O5Ofnc+vWLeLj48nJyUGr1ZKYmIherzfZuUnGNKKfqlit39IFbXlEi0EvLy8CAgJwdXVFq9USHx9PdHS05BXbGNeO3NzcKu3OvvrqKzZu3Mjrr7/O+PHjG3z88tTnWlFYWFjm5/vvv7/SyHC3bt2k4EpCQgJnzpyp87hVYSxow8LCuHDhAsuWLWPEiBGYm5uXuRcaDAYAHnvsMXx9fTlw4ABarVa+Dsi0WJrszl4bX0BA8gWsC/Hx8Xz//fcAhIaG0rlz5wrbmJub869//QuAmJgYDh48WKexmpI9e/awfPly5s6dy9GjRzl79iwbN26kQ4cOvPnmm4SGhrJw4UK+++47cnNzK7ze2toaNzc3unXrhp+fH5aWlqSnp3Pz5k2Sk5NRq9VtUuBqtVpiY2Pp0KGD3IyiEsRqeW9vb7p3745SqaSgoIDo6GiKioqwt7dHp9M192G2CsrnbLc2QVsesQixU6dOdO/eXbqeJicnS5NjtVotCaD6kJeXJzWkMCVov/32W958801effVVJk6cWKcxjN1htFpttdtrNBqTr60J5d/DnXfeWeX2/fv3lx6fO3euVmPVBGNBu3TpUo4fP46ZmRmpqancvn27gmAVr5VOTk4MHTqUa9eu8fXXXyMIQpu8V9QbM/OW86+d0mSitra+gACHDh2q01iHDx+WZptVjRUcHCw9rutYTcWff/7Jhg0beP311wkLC5OisKGhobzzzjucOXOGzZs34+bmxnvvvUdoaChz587lP//5D1lZWRX2Z2VlhaurK127dsXPzw9ra2syMzO5ceMGycnJqFSqBrlJNTdFRUXExcXh4uLSpG1vWzPm5ubY29tTUlKCk5MTnTp1ori4mNjYWG7fvk1GRgbFxcXyTc0E1bVwbe2I6U3i6o+fnx9WVlZkZmZy8+ZNEhMTycvLq9PKV15eHunp6ZV2WPvhhx947bXXePHFF+tVSGVvby+lNIhth6vCOOWgttZb5UWwq6trldt36tRJepycnFyrsWqCKGiXLFnC4cOHgdJorNhYYsaMGZw6dUoqpBOvl1ZWVsyePRsnJyfOnDmDQqGQr6WmENMPWsK/dkqThRCa0hewpmN5eHjg5uZGRkYGZ8+eRaPRSIK6pTFgwACOHz9e5qJnjJWVFaNHj2b06NGUlJTw+++/Ex4ezscff8wbb7zBwIEDCQ0NJTg4uEK1r5WVFS4uLri4uFTIsxQLiRwcHFrdkr1arSY5OZlOnTrVub1le0Sn0xEfH4+9vT3u7u4oFIoydlD5+fnEx8fLLhvlEIvpiouL26SgNYXxtcNUtzvx+lGd40N+fj5paWmVCtrw8HBeeeUVnn/+eWmFra4oFAp8fX25desWAOnp6VXeY9LT06XH3bp1q9VY1tbWKJVKaeWsuhxe4/deVFRUq7FqyieffMKRI0d4/PHHSU1NlQIZ6enppKenc+PGDZycnHjiiScYMmQIffv2BZAcio4cOUJ4eHiLbyTRLJi1kEIxs/Z7LW4yUdtUvoCCIHDjxg2g9OIlWpNUho+PDxkZGeh0OqKjo6sUwc2Jubl5pYK2PJaWlowcOZKRI0fyyiuvcO7cOcLDw9mxYwdvvfUW/fr1kwRu+dSM8i1ZVSqVVA1dWSFRS0TsdiW3b60dJSUlxMXF4eTkhKuraxmh2lhWYW0BQRBISUlBq9W229zj8g0fxEKzzMxMqVGMWGhmfH6oVCpSU1Px8fExGVQ4fvw4L7zwAkuXLuWpp55qkGPt1auXJGoTEhKqvMckJCRIj3v06FHrsXr06MEff/wBVF9oZixkG2si/uijj+Lm5saYMWOwt7fn4sWLnDt3ji+++AKVSkVeXh55eXm8+eab+Pr60qNHD55++ml69uzJM888w5EjR/j5558ZM2YMCoWi1QU7ZNo2TSJqm9IXMD09XbpwKJXKamfG5cdqqaK2rpibmzNs2DCGDRvGSy+9xMWLF4mIiGDfvn28++673HHHHYSGhhISElJhAmBhYSFVQ5ePwoh95Tt06NDibuBit6vKbpIypikuLiY+Ph4XF5cKRZzlaSirsLZAeXeItv5+a4Jxq29xiV+lUpGYmAggXTt0Oh2pqal4e3ub/K6eOnWKVatWERYWxsyZMxvs+IKCgqSUs7///ptRo0aZ3E6n03H16lUA/Pz86Nq1a63HuvvuuyVRayyQTSF+PlD7qHBNcXZ2LpOPPHDgQAYOHEhwcDDR0dHs3r2buLg4srKyiIuLIy4ujosXL+Lm5sbUqVPp06cP4eHhTJs2jV69ejXKMbZWStvkNv/3vyUcQ3PRJO+8KX0BjQukahKhM96mvHtAW8PMzIxBgwaxevVqTp06xddff82wYcM4cOAA//jHP3j88cfZvn07MTExFV5bvpDI0dERtVpdplK+uQuJxIpz0axdFrQ1R6PREBcXh5ubW7WC1hSiTVjXrl3p2rUrNjY2ZGdn1zvPsqUjClrRHUIWtBVRKBTY29vj6emJv78/Xbp0wczMjOTkZJKSkrC1tUWn01XI4f/ll19YuXIls2bNYv78+Q16TMHBwdK13zhdrTy//fabVCj24IMP1mmscePGSY9FcVsZYvcxoFKhXReqqo8Qc+O7d+/O/fffz549e3jjjTd4+umnUSqV2NjYkJmZydWrV1mzZg03btygoKCAzz//XM6tL4/C7H+tcpvzXzsWtU0SqW1KX0Dj7Wvip1ifsVozCoWCfv360a9fP1asWMG1a9c4cuQIhw8f5qOPPsLf35+QkBBCQ0Pp3r17meVC0e7HyclJWmYUo3Q2NjZSFKYpOyeJy7/FxcVtouK8KSksLCQxMRFPT88G6UFfPoWlfJ5lcxr6NySCIJCUlITBYJCEmkzViAWuer2enJwcvLy80Ol0ZGdnc+TIEb755hvuvvtuvL29eeedd3jyySdZtGhRgx9Hhw4deOaZZ9i8eTNRUVFcunTJpCPPnj17gNLq/+nTp1d4PjMzkwULFnD79m2WLl1qsmlQt27deOCBBwgPD+fnn38mISHBZFrcX3/9xZUrVwAYMWJEvaKg5Vullz83jZ833k70nw0KCiIoKIixY8dy7do1du/eTWpqKgUFBVLw4tKlS2i1WqytreXW7DIthhZ5V2nKm4PxWO11xqlQKOjduze9e/dm6dKl3Lx5kyNHjnD06FG2bduGr6+vJHB79epV4WIpLjMaDAYKCgrIz88nIyNDMmx3dHRsVIFrMBikPva+vr6yuKgFYjFd586dcXBwaPD9G+dZ6vV6CgoKpAmQeH506NChRpPdloR4zgGyoK0lBQUFJCUllcl379ixI05OTqSkpHDy5Eni4uKwt7enuLiYs2fPMnjw4Aa/hsycOZOTJ09y5coVVq1aZbIZUGRkJAAvv/yyyQnfZ599RlRUFADr169n4sSJFTzRAVatWsWff/5JRkYGy5YtY9u2bSiVSun5tLQ0Vq5cCZSmza1bt67O78tgMEjnY3p6Ordv3+bcuXNS4d6ECROwsrLC0tKyghgVU8nE34uBj3HjxhEZGcnPP//Mjz/+iCAIXLt2jU8//ZTFixfLglakpTgPtIRjaCaaRNQ2pS+g8fbFxcWNOlZbJSAggICAAJ599llu375NREQER48eZceOHXh5eRESEkJISAh33nlnBYErihRBECSBGxMTIxWKODo6NqiA0ev1JCQkYGlpSefOneWLay0Qo6dNVUxnbm5eYQKkUqnIysrCwsICR0dHSeC25L+jKGgVCgVeXl4t+lhbGoWFhSQlJeHl5VXhnFMqldxzzz189dVXPPTQQ9xxxx2cOHGC/fv3Y29vz7333svq1avLiMH6YGtry8cff0xYWBiXLl1i7NixTJgwAaVSyfnz5zlz5gyWlpasWrWq0tQD40BIVd6tnp6e7Nixg7CwMP766y/Gjh3LAw88gIeHBwkJCYSHh6NWq/Hz82PLli14eXnV6T0ZC9offviB/fv3c+HChTLbHDhwgPHjx/PAAw/g7u5uMspaPnrr4ODAuHHjGDduHBMmTODKlSts27aNX375henTp6NUKuVoLfz/8n8LqDFpx5PsJhO1lpaWlJSUSEUDVd1E6+ML6OTkJD2uzn+wvmO1B7p168a8efOYN2+edPE9evQon332GR4eHpLAHTBgQIV2vQ4ODjg4OEh/8/z8fGJjY7GwsJAEbn1abpaUlBAfH4+Dg4NkPSVTM3Jzc0lPT8fb29tkZKmxKT8BEguJWrpVmMFgIDExETMzM1nQ1pKioiISExPp3LmzyQDC33//TVhYGA8++CCvvvoqZmZmPPXUU+Tm5nLq1CnOnTtXJgjREHh4eLB//36++eYbDh48yKFDhygsLMTd3Z3JkyczderUKh0Ppk2bxtmzZ4mJiWHJkiVV3td69OjBwYMH+fLLL4mIiODIkSOo1WqcnJwYMGAA9913H5MmTarzpN9Y0H7yySe8//77KBQKgoOD6dChA3FxcVy/fp1Lly5JEdwZM2ZU6xAkRm/F/QcGBjJ8+HAsLS3ZsGEDp06dYuLEifJ3AeRIbQugSURtU/oCenh4YGdnR2FhIbm5uWi12iovEvUZq73h7e3NrFmzmDVrFsnJyRw9epSIiAj279+Pi4sL9957L6Ghodx1111l8iXFQhGxWMSU16kocGt6YRQr9Tt27IiLi0tjveU2iegO4evrW69JRUNhfH60ZKswg8FAQkICFhYW8qpALSkqKiIhIaHSNJerV68yf/58QkNDJUErolQqmThxYp07iFWHhYUFkydPZvLkybV+rbu7O19//XWNt7exseGpp55qMGsyEUEQpM9s586dvPvuu4wYMYJZs2YxbNgwAGJjYzl37hwbNmwgNTWVw4cPU1xczNy5c/H19a12jPJBi/79+2NpackXX3xBUFAQzs7O8ndCptlpspzapvIFVCgU9OzZk4sXLyIIAomJiVWKVXEsCwsL/P39azVWe6Zz585Mnz6d6dOnk56ezrFjxwgPD2fevHk4OTkxevRoQkNDGTJkSJlcOFNep/n5+ZKVjbgEXVWETixs8vDwKBOZl6kaQRDIysoiNzcXX1/fFpnH2lKtwkRBa2lpSadOneSbdy3QaDQkJCTQqVMnk4L2xo0bzJs3j1GjRvHGG2/I+cl1QDwfT506xQcffMA999zDsmXL6NGjBwaDAYVCgZ+fH/b29vz6668cPXqU/Px8Tp48icFgYM6cObUO6gwcOJCpU6eyb98+UlJS6uSa0uYQ3Qeam5ZwDM1Ek73zoKAg6fHff/9d6XYN4QtY07HS0tKkSO3dd9/dLMuwbQF3d3emTJnCnj17+OWXX1iyZAlpaWksWrSI0NBQXnrpJSIjIyvkU4sCxsPDA39/fymPLDk5mVu3bpGWlkZhYWGZPDXR67Jz586yoK0Fot1Zfn5+ixW0pmgJVmF6vZ74+HhZ0NYBjUZDfHw8np6eJpsJREdHM3fuXO6++27efvvtFud53ZpISkpi37596HQ6pk+fLgWExFxXjUbDjz/+yIkTJ/Dx8ZE6nZ06dYotW7ZIQaeaFEwbDAYEQWDYsGFotVp++OGHNtFWvb4oUEhetc36j/Z7jWoyUdvUvoDibL+qsU6cOCE9rutYMmVxcXFh8uTJ7Ny5k19//ZXnn3+evLw8li9fTnBwMKtXr+bEiRMVWkAa95Tv1q2b5PmZmprKrVu3SE1NJS0tjeTkZLy9vRulUr+tIrZvLSwsxMfHp0mt1hoS0SrM19cXf39/HBwcyM/Pb1SvZLEQ0draWha0taS4uJiEhIRKreJiY2OZM2cOAwYM4N133231Fm/NhShCr1+/zsWLFxk4cCDDhw9HEATJoqu4uJgvv/yS999/nz59+vDtt9/y2muv4eLiQl5eHpGRkWzZsoVr165J57hKpap0TIVCgUKhICgoCFtbWwoKCuQIOzS/P63xv3ZKk71z0RcQkHwBTVETX8DJkyczZMgQ9u/fb3Iffn5+PPTQQ0Bpi8Xk5OQK2+j1ej7//PMK28s0HEqlkkceeYRPPvmEM2fO8PLLL1s2EpgAAGg2SURBVFNSUsLq1asJCQlh5cqVREREVPAHFr0s3dzcJIFbXFxMdnY2UFrkpFar260FW20QmwNotVp8fHzajHAo3wxEqVRSWFhIdHQ0sbGxZGdnSw1f6ooYobWxscHT01MWtLVAzHl3d3c3KWgTEhKYM2cOffr04f333281KwctEYVCgcFgYPPmzajVaqnpjEKhwNzcnJKSEr777js++OADunbtyr59+7C1tWXYsGGsWbMGNzc38vPziYyM5OOPPyYmJobExETWrl3L999/X2G8/Px86bvw008/odfr8fDwqNL9QUamqWjSO1xT+gKuWLGCP/74g6SkJJ577jm2bdtWZrt33nmHGzduYGlpyfr16xv8Zq/T6Thw4AAHDx4kOjqawsJCPDw8CAwMZMqUKQQEBNR7DLVazfHjxzl9+jRXrlwhIyMDnU6Hk5MTvXr14t577+Whhx5qEVHNDh068NBDD/HQQw+hVquJjIwkIiKCV155BYPBQGBgIMHBwQQFBZX5uxcVFXHt2jWcnJzo3r07giCgUqnIyMggOTm5XbVjrS3GXqptudtVZVZhmZmZkpVcba3CdDod8fHx2Nvby84atUSr1RIfH4+bm5vJFKGkpCTmzJmDv78/mzdvbhHFiq0dMzMzpk2bxqpVq/jtt9/473//S58+fYDSzmxbtmyhc+fO7N+/H3Nzc3Q6HQ4ODoSEhKDVatmwYQO5ublERkZKUdfIyMgKDSCuX7/Ozp07cXFxwd3dnQMHDmBra0toaKj8HQHZ/aAFoBCaeGqVlpYm+QIqlcpKfQGnTJli8vXvvvsu27ZtA0qjNefOnavURiU6Opr58+cTGxtLp06dGDt2LDY2Nvz8889cvnwZBwcH3njjDe67774GfY8ZGRmEhYURFRWFUqlk/PjxKJVK/vzzT86cOYOVlRWrV6822X2mJhgMBt59910+//xzCgsLsbW15d5776V79+5AaSXxiRMnpBn022+/zd13392Qb7HBKCoq4pdffiE8PJxTp05RXFzMsGHDCA4Opn///jz33HPY2tqyY8eOCvl2JSUlqFQq8vPzKS4ulgSug4NDmxVwNUWv15OYmNiuK/WNrcJUKlWNrcJEQevg4ICbm1u7/OzqilarJS4uDldXV5ydnSs8n5qaysyZM+ncuTPbtm1rEn/k9sR3333H999/z7Jly+jbty8ajYZFixYRFRXF3r17CQgIQKfTlQnipKens2jRIi5evFhmX0uXLmX27NllfqfRaHjqqaf466+/gFI3h48++ogRI0a0a5/axMREQkJCiPjPLrw6eTT34ZCUksb9j07np59+okuXLs19OE1Kk4taKL1piL6AYhTT3d2dwMDAan0B09PTWbBggeQLWJn4FSksLOSLL77g8OHDxMXFUVJSQqdOnRg9ejRTp06ts8l1ZWg0GqZOncrly5fp3r27yWj0unXrUCgUbNq0ibFjx9Z6jOLiYqmlY69evdi2bRseHmW/SFeuXGHGjBnk5ORgY2PD3r17ufPOO+v35hoZrVbLr7/+Snh4OD/99BMlJSUolUoef/xxJkyYUGV1rU6nkwSuRqPB3t5eErjtrfhEXjaviCAIklWYSqWq1CpMp9MRFxdHhw4dZEFbS0pKSoiLi5NaJJcnPT2dWbNm4eLiwvbt21vEClJrxNiPFv7X2lYkLS1Nuh/s2bOH9evXM3r0aD744AMsLS3LnNOiEH3ttdf47rvvMDc3Jy8vr4ygFccT/9doNMyZM4esrCxefvllhgwZ0q4FLfxP1H625W083N2a+3BIS8/gyfkrZFErU382b97Mhx9+CMDXX39tsp/4rFmziIyMRKlUcvz4cZNVwVUhilozMzN+/PHHSq1YDh8+zJIlSwAYMGAAX375ZS3fTfNw7do1Zs6ciYuLCz179iQyMpK8vDzuuusuQkJCCA4Oxt3dvdLX63Q61Go1+fn5FBUVYWdnJwmYti5wS0pKSEhIkJfNq0G0ClOpVJJVmJ2dHZmZmTg5OeHm1vw3ptZEdYI2KyuL2bNnY29vz86dO2t9zZMpi06n46+//mLQoEFARWELpWJ08eLFHD16lIkTJ7Jhw4YK24lCdcWKFVy7do0ZM2ZQUFAgBYvKC2gxyqvX60lJSaFLly7tXtBCaZ3HfffdR15eXnMfioSTkxNHjx5tsA58rQVZ1DYgarWaoKAgCgoKqhSRkZGRzJo1C4CFCxcSFhZWq3FEUXvXXXdVWiwHpRekoUOHSlWsJ06caPDIdENz7tw55s2bx8iRI3nrrbewsrJCr9dz7tw5jhw5wvHjx8nKyqJ///5SN7NOnTpVuj+9Xi8JXDFVw9HREQcHhzZTNCUi5jI6OTnh6ura7m80NaWkpITc3FyysrIAyqSxtPVJUEMgdvZTKpUmG6Hk5OQwe/ZsrKys2LVrl2zFVwdE4Ziens7ff//NJ598ws2bN/nnP//Jc889B1QUtgUFBfzjH/8gKSmJAQMG8MUXXwD/E6biPqOjo5k1axaPPvoo8+fPl15vSihDRaErU4pYwNxScHBwaHeCFpq4UKytc/LkSamSf/To0ZVuFxgYiI2NDRqNhkOHDtVa1Jqbm/PMM89Um05gZmaGn58fly9fBiAmJqbFi9qPPvqIiRMnsnr1aunCaW5uzrBhwxg2bBgvv/wyFy5cICIign379vHuu+/St29fSeCWb/lobm6Ok5MTTk5O6PV6CgoKyM/PJy0tDRsbG6nZQ2sXuGK1uYuLi2yCXgfy8vKkwiZxEpSamoqtra0U5W/t50hjIOYfOzk5mRS0eXl5zJs3D3Nzc3bs2CEL2jogisjr16/z0Ucfce7cOXJycrCwsGDnzp0IgsDzzz9fQYBaWlri4eFBamoqUVFRvPjii6xbt046jxUKBQkJCezZswczM7MK95PKJnSyoDWNUqlslyKypSFfpRsQY0/cO+64o9LtLCws6N27NxcvXiQmJobY2NgqO6yZer04O68OY0Psxjapbwh27txZZYTRzMyMwYMHM3jwYFavXs2lS5cIDw/nm2++4f3336dXr16EhIQQGhpa4TMtXyWvVqulblXW1taSwG1tPq6iwb27u7t8Ua0lYnTbeNlcvDkZT4LS09OxsbGRBG5rO0caA1HQOjo64urqWuF5lUrFggUL0Ol07Nmzx2ThmPG+GtstpjKMV868vLzK+Jc3N6KgjYqKYvHixaSmpjJ48GA6duyITqfjxIkT7N69m379+jFu3Lgyr7WysmLgwIFcuHABKE2Hy8/PZ8GCBSgUCjIyMvj000/59ddfmTNnDqNGjWqOtygj06DIorYBuX79uvTYx8enym29vb2latMbN27UStTWBmOP3vL2LC2R2iyZi/3H+/fvz8qVK7l69SpHjhzhxx9/5KOPPqJ79+6SwPX39y+zbzMzsyptoESB29L9M8WWwZUZ3MtUjlipX1l0uzGswtoKYjGig4ODSUFbUFBAWFgYBQUF7Nmzx2QUV6Qqt5j9+/fzzTff1MstpiqKiop45ZVXGny/DYEoaK9cucLTTz+Nu7s7L774opTvKggCV69e5dSpU/Tt29fka6dMmcKtW7c4ffo0ABEREZw7d46CggKKi4sBeOKJJ6TaCzm1QKa1I4vaBkIQBGJjY6WfqypkKv/87du3G+WYbt++TU5ODlDaBri8Q0JbQqFQ0KdPH/r06cPSpUu5efMm4eHhREREsHXrVnx9fQkNDSU0NJSePXtWELiiQBEEQRIvsbGxWFhYSAK3pflpqtVqkpOT6dy5s1xJXkvEdI3KrKfKU/4cEa3C4uPja2wV1lYQBa29vb1Jh4jCwkKeffZZcnJy2Lt3b5XXQo1Gw7x586p1i3nllVdQKpV1coupis2bN5OYmNig+2woxI6KL7zwAq6urqxYsYLQ0FCg9H5jMBjo06cPPXr0qJAaIwpTT09PZs2ahY2NDREREQBSExtvb28eeughKf2tshxaGZnWhCxqG4iCggKpg5FCoajWf9H4+caqmPzuu++kx88++2yjjNESUSgU9OjRgx49evDss88SHR1NREQER48e5dNPP8XLy4vQ0FBCQkLo27dvmZuyQqHAwcEBBwcHPD09y4gXc3NzSbxYW1s3q3gRcz67dOkie33WElHQurm51SldQ6FQYG9vj729PR4eHpJVWHJycqVWYW0FUdCKLa3Lv7+ioiKWLl1Kamoqe/fuxdPTs8r9bd++Xcr5f+ONNypEzKdOncrp06eJjIxk7dq1jBw5ssGcE65fv86uXbvo2bNnmVW2loAYMT148CBXr15l7ty5ZQSt2C0MqDTXWywIGzRoEP369WP48OHcvHmT9PR0hg0bRs+ePRk8eDAgC1qZtoMsahsI41avNVmyNo76lW8T2xBkZ2dLzgiTJ0+WLl7tEX9/f+bPn8/8+fOJj48nPDyco0ePsnv3bjw9PaUis/79+5dZeisvXoqKilCpVCQkJDRrdC43N5f09HS8vb1NdtOTqRyNRkNCQgLu7u4NUrSkUCiwtbWVRJ5oFZaeni5ZhbWVjnd6vZ6EhARsbW3x8PCocM4XFxezfPly4uLi2Lt3b7VFqWq1mh07dgClloOm7A8Bpk2bRmRkJLm5uezevbvWhbWmEASBl156Cb1ez6uvvsrkyZPrvc+GRDxXfvvtNywsLHjkkUeAmqcHpKWloVar8ff3x2AwYGVlxeOPP25yW4PBIAtamTaDLGqbica+wa1du5b8/Hx69+7N6tWrG3Ws1oSPjw+zZ89m9uzZJCcnc/ToUcLDw/n8889xcXHh3nvvZcyYMdx1111lLvRi9N3Ozg53d3cpOie2oRUFrq2tbaMK3OzsbLKysvD19W1x6RAtHbGgzsPDo9Gq8K2trbG2tsbV1VXqeJednU1ycnKrbghiMBhISEjA2trapKDVarU899xz3Lhxg3379lVwITFFU7nFmGL//v1ERUXx+OOPM2DAgHrvrzFISEjg8uXL2NraSgW/Nbm2ZGdn895773H16lX27t2Lg4ODFN0VBAFBEMrcf1r7ZEtGxhhZ1DYQ9vb20mOtVlvt9hqNxuRrG4JPPvmEiIgIOnXqxNatW7GxsWnQ/bcVOnfuzPTp05k+fTppaWkcO3aM8PBw5s6di1Kp5J577mHMmDEMHjy4TLW7cXTOzc1Nis6lpKRIy8+Ojo4NKnAFQSArK4vc3Fx8fX1bfAFbS6OoqIiEhIQmLaiztLSUXBXEhiB5eXmtzipMFLRWVlYmO9TpdDpWrVrF33//zZ49e2pc9NpUbjHlycjIYOPGjbi6urJs2bI676exKS4ulkT/77//jq+vb42uJ+bm5vzyyy9kZGRw5swZxowZI71OoVC0uZQYGRlj5ClaA2Fvby8JH7GQpCqMUw4a8ib77bff8u677+Lm5sauXbvadHFYQ+Lh4cHUqVPZu3cvv/zyC4sWLSItLY1nn32WMWPG8NJLL/Hzzz9XmLAoFApsbGxwc3PD398fHx8fLCwsSE1N5ebNm6SkpFBQUEB9epwIgkB6ejr5+fmyoK0DoqDt1KlTszlEWFhYoFQq8fHxoXv37jg5OVFQUEB0dDRxcXFkZ2dLOfktCYPBQGJiIhYWFnTq1KmCINLr9axZs4YLFy6wc+dO/P39a7zv2rrFiNy4caPGY5hi/fr1qFQqnn/++RbtGGJhYYG9vT0WFhacPXuWzMzMal9jMBhwcnJi/PjxQKk3uYxMe6JlhwhaEQqFAl9fX27dugWU9jmvKpqQnp4uPa6szW1tOXToEGvWrMHV1ZXdu3c3mk1YW8fFxYXHH3+cxx9/nJycHH766SciIiJYtmwZVlZWBAUFMWbMGIYNG1Yhp9V4+Vmr1Uoep2J+paOjI3Z2djVe8hMEgdTUVDQajSSYZWqOaHnWqVOnFtOa1bghSFVWYc2dXiIKWnNzczp37lxB0BoMBl5++WXOnj3L7t276dmzZ4333VxuMZGRkRw5coTAwEAmTJhQ5/00BV26dMHPz48rV65w9OhRgoKCmDhxYpV5teLvxXtKS5woycg0JvIdsgHp1auXJGoTEhKqFJUJCQnS4x49etR77MOHD7Ny5UqcnZ3ZvXt3rSImMpXj7OzMo48+yqOPPkp+fj4nTpzg6NGjrFq1CjMzM0aOHEloaCgjR46s4EJgZWWFq6urlF+Zn59PZmYmxcXFksCtqoBIEASSk5PR6XT4+Pi0ujzM5kYUtC3Z8qylWoUJgkBSUhJmZmaVCtp169Zx+vRpdu7cSZ8+fWq1/+ZwixE9aa2trVm7dm2d9tFUiDmw/fr148qVK+h0OtasWYOnpyfDhg2Tni9PSUkJlpaW0jXFzc2tqQ9dRqZZkdMPGpCgoCDp8d9//13pdjqdjqtXrwLg5+dH165d6zXukSNHWLFiBUql0qSgNRgM5OfnS2bbMnXD0dGRiRMnsmXLFn777TfWr1+PmZkZa9euJTg4mGXLlnH48GFUKlWF11paWuLi4oKfnx/dunXD1taW7Oxsbt68SWJiIvn5+WW6v4lRMoPBgLe3tyxoa0lBQQGJiYl4eXm1WEFbHtFtw9PTk+7du9O5c2egtIHKrVu3SE1NrXcqS00QBS2UdtgqL54EQWDDhg0cPXqUTz75pFLXgqpoDrcY0ZN29uzZ+Pr61mkfjYHx31N8LFp2Pf3001JRo16vZ+bMmZw5c8akoDUYDFhaWlJcXMz333+Pu7t7nf42MjKtGVnUNiDBwcFSRMG4CKI8v/32m1Qo9uCDD9ZrzIiICJYvX46TkxO7d++me/fuFbZJTk5myJAhbNu2rV5jyfwPBwcHHnzwQT744APOnDnDO++8g62tLa+//johISE8++yzfP/99yajSmIBka+vL/7+/tjb25Obm8vNmzdJSEggJydHitR16dJFrk6uJWq1mqSkJLy8vBq8CLOpEIsR3d3dy+Rqp6enc/PmTZKTk1GpVGUmQg2BKGgNBkOlgvadd97hhx9+YNu2bdx1110NOn5l1Pc7IHrSdu3aldmzZzfQUdWNqv5m4uctCAIlJSX4+PiwZs0aaWKm0+l4+umn+fHHH8ukFmi1WszMzNBqtezdu5cLFy4QFBTUIKuAMjKtCTn9oAHp0KEDzzzzDJs3byYqKopLly6ZnCnv2bMHACcnJ6ZPn17h+czMTBYsWMDt27dZunRppe0hjx07xtKlS3F0dGT37t2N2h9dpnJsbW257777uO+++9Bqtfzyyy+Eh4ezceNG1q1bx9ChQwkJCeHee++tYC5vYWGBs7Mzzs7O6PV68vLySE9Pl/Lm8vLycHBwkHNpa4jYZa2tNaVoCqswMd3FYDCYnEwJgsD777/PN998w9atWxkyZEidx2pKtxjRk1an07F27dpmLbQUmxwIgkB0dDS//PIL169fR6vVYmdnx5gxY/D19cXX11cqPL7nnnuYO3cuW7dulVaBli1bxlNPPcXdd99NcHAwlpaWaDQatm3bxr59++jRowcvvvgiZmZmcutbmXaFfKdsYGbOnMnJkye5cuUKq1atMtn2MTIyEoCXX37ZZPXtZ599RlRUFFBaqTtx4sQKBUnHjx9nyZIl6HQ6xo4dy/nz5zl//rzJY8rNzW2YN1cOnU7HgQMHOHjwINHR0RQWFuLh4UFgYCBTpkxpVJEdGRnJrFmzgNIl0hMnTjTaWLXBysqK4OBggoODKSkp4ezZsxw5coTNmzfz+uuvM2jQIEJCQggODq6Q75afn09WVhZKpRIXFxepgCgtLa1VWUA1F6KtWltvSlHeKkylUpWxCnN0dKz1REgQBFJSUtDpdHh7e5sUQVu2bOHzzz/n448/Zvjw4fV6D6JbTElJiZRLXNUkpD5uMaIn7cSJExk2bFidj7m+iB2+xPSNn376qUKL3mPHjqFUKlm+fLnUQczJyYmHHnoIR0dH3n//fbKysgDYvXs3X3/9Nf7+/uj1enJyckhJSWHgwIF88sknWFtby53CZNod8t2xgbG1teXjjz8mLCyMS5cuMXbsWCZMmIBSqeT8+fOcOXMGS0tLVq1aVWnqQfkcq/I5dAkJCSxevFhaftq3b1/jvaFKyMjIICwsjKioKJRKJePHj0epVPLnn3+yf/9+vvnmG1avXl1plLk+iAUfLR1LS0tGjRrFqFGj0Ol0nDt3jiNHjrB9+3befPNNBgwYIHUzS0xMZNGiRaxcuZJ//OMfKBSKMhXyarVa6lRlY2MjCVxj/9z2jNg2uK0L2vKUj/SL50laWlqNzxPRYaOkpKRSQfvJJ5+wa9cuPvzwQ0aNGlXv424qt5isrCw2btyIjY0NU6ZMqSAiy6PT6Sps06VLlxqPVxl6vV6aZIh5sV27duWxxx7DysqKc+fOkZycTG5uLrm5uYSFhbF06VKmTJmCvb09bm5uTJo0ib59+7J+/XpSU1NJSkqisLBQajPcr18/JkyYwOzZs3FwcJBEtIxMe0I+4xsBDw8PSdgdPHiQQ4cOUVhYiLu7O5MnT2bq1KlV5jpNmzaNs2fPEhMTw5IlSypEMNRqdbNatWg0GubNm8fly5fp3r27yWj0unXreOWVV1AqlYwdO7ZBxxcLPloTFhYWDB8+nOHDh7N27Vr+/PNPIiIi2LNnD++88w6WlpYMHDiQAQMGVMhjNDMzw9HREUdHxzIWUBkZGVhbW0vCpb3617ZXQVueuliFiYK2uLi4UkG7a9cutm7dynvvvUdwcHCDHW9TuMXcunVLWrL/5z//We32aWlphISElPmdsZ9uXRAEQYqWzps3j/PnzzNv3jyefvppKVc2ISGBP//8kw8//FAq0jty5AijRo2id+/eQOk1pE+fPmzfvp2EhASioqIoKirCysoKJycngoKCsLa2xtLSsoyIlpFpTyiExi6llWlzbN68mQ8//BCAr7/+2mTe8KxZs4iMjESpVHL8+PEG8wi9fv06Dz/8MP7+/tLNpiWlH9SWiIgIli5dSu/evcnKyiI5OZnevXsTHBxMaGholTd6QRAoKCggPz8ftVotCRdHR8d2I3Dz8vJIS0vDx8dH7pxXCcZWYSqVSrIKc3BwIC8vT/JANrVMvXfvXt577z3eeecdxo0b16DH9f3337Ny5UoAFi9ezLx580xup9PpGDRoEBqNBj8/PyIiImo8RnZ2NhcuXKh2uwULFgDQsWNH1q1bV+Y5MQ2gvmzbto1NmzYxffp0FixYgIODg2TBJea9nj59mjlz5jBgwADJStCYmkRfK7P7kpFpD8hTOZlaoVar2bFjBwADBgyo1DJm2rRpREZGkpuby+7duxukX7tY8KHX63n11VeZPHlyvffZnHz77besWbOGZ599ljlz5gDw3//+l/DwcA4dOsRHH31E9+7dCQkJYcyYMRWs2hQKBQ4ODlJv98LCQvLz84mNjcXCwkISuM1t4t9Y5ObmkpGRIQvaahCtwuzt7fHw8ECj0ZCfn09CQgIGgwGlUolGo8HOzq6MGPryyy/ZtGkTGzZsaHBBC/9ziyksLOTUqVOVitr6uMV07NixVqLU1ta2VtvXVECq1Wp+/vlnHB0deeaZZ6TvrJhXbGlpSXZ2Nq+88gqdOnXiscceY9KkSQBER0dTUlJCr169ahR9lQWtTHtGLomUqRUnT56UijZGjx5d6XaBgYGS0Dh06FCDjC0WfEyePJkBAwY0yD6bi6SkJFavXs3q1auZO3eu1JP9jjvuYNmyZURERHDw4EHuu+8+fvrpJx599FEmTZrE5s2buXbtWoU8a1G4dOrUiYCAADw9PdHr9cTHxxMdHU16ejoajabRPU6bClnQ1g2xrbNCocDCwkKqsk9PT2fjxo08+eST7Ny5k127dvHWW2/x6quv8tBDDzXKsYhuMYDkFmOKmrjFTJ48mSFDhrB///5GOdbKUCgU6PX6are7du0a586dw9PTEzc3N0pKSlAoFOh0OiwtLcnLy2Py5MkUFxezaNEiJk6ciEKhICsri88//5y1a9cSFxfXBO9IRqZ1I4tamVph7L97xx13VLqdhYWFlAsWExNTpiVmXcjIyGDjxo24urqybNmyeu2rJdC5c2eOHz/O1KlTTT6vUCjo2bMnixYt4scff+Tw4cP84x//4Ndff+WJJ57gH//4B++99x5///23SYFrZ2dXxsRfEAQSExOJjo4mLS2NoqKiVitwc3JyyMjIwNfXt81GoRuTzMxM1Go1vr6+2NnZ4erqSteuXZk4cSLdu3dn7969vP/++3h6epKdnU10dHSjHcvMmTOl68iqVavIzs4u83xt3GLy8/NZv349RUVFjXa8Ivv27ePNN98ESnOZqxO2omOBOAGztLREq9ViYWFBQUEBkydPRq1Ws2TJEiZMmCBZcRUVFXH58mWioqLIyMho3DclI9MGkNMPZGqFcdGEj49Pldt6e3tz8eJFAG7cuFFlfmh1rF+/HpVKVemNrbWhUCjw8vKq8fb+/v4sWLCABQsWEBcXR3h4OEePHmX37t14enoSEhJCaGgo/fr1K1PsI5r4i0b+xcXF5OfnS36kjo6OdOjQAVtb21axbJmdnU12dja+vr7tJm+4IcnMzCQ/Px9fX98KS9n+/v4MHTqU7777jqeffhpra2u+++47Nm7ciL+/P+PGjWPu3LkNWoDUFG4xprh586Yklo1Rq9V8+umn0s9BQUEVrAn37NnD+vXrpaK7xYsXS8K2MvssMX3i6tWrnDhxgqCgIKysrCguLmby5Mnk5OSwbNkyJk6cKPnYmpmZ4eXlRbdu3bh06RInTpxg8ODBsu+sjEwVyKJWpsYIglAm4uru7l7l9sbP3759u87jRkZGcuTIEQIDA5kwYUKd99NW8PX1Zc6cOcyZM4ekpCSOHj1KeHg4+/btw83NjXvvvZcxY8YwcODAMjdZcenZxsYGNzc3tFqt5Byg0+kkgVs+t7KlkJWVRU5ODj4+PrKgrQNZWVnk5eVJ3cnKc/z4cV544QVWrFjBjBkzAFiyZAnR0dEcO3aMv/76C41G0+BthxvbLcYUly9f5q233qrw+7y8vDK/d3Z2LiNqd+/ezRtvvAGU+iJ//fXXlJSUsHz58iqFrXhMWq2W3377jeDgYLRaLZMnTyY1NVUStKKPrUKhkMRrcHAw3333nWTLJgtaGZnKkUWtTI0pKCiQrMTEJe6qMH7eVLvYmiB60lpbW7N27do67aMt4+XlxdNPP83TTz9Namoqx44dIyIigjlz5qBUKhk9ejRjxoxh0KBBZbxKFQoF1tbWuLm54ebmRnFxseSDW1JSItk/2dvbtwiBKwpa405LMjWnus/v1KlTPP/88yxcuFAStCL+/v4VihQbGgsLCyZPnlyn4k93d3e+/vrrWr3m4Ycf5uGHH67Va7744gveeOMNxowZg1Kp5OuvvyYrK4tvv/0WvV7P8uXLsbCwMClsBw0aREBAADdv3mTv3r307duXL774gri4OJYuXcojjzyClZVVmcIzMeIsRnlliy4ZmeqRvyUyNca4q09NImXG+Y7Gr60NoiftwoUL8fX1rdM+2guenp5MmzaNadOmkZmZKQncsLAwHBwcuOeeewgNDWXYsGEVhI1xG1atViv5myYnJ+Pg4CAJ3OaIEmVmZpKXlycL2jqSnZ1dpaD95ZdfWLlyJXPmzKnUgUCm1IXg/vvvZ968efTq1QsXFxf+/e9/k52dzffff49Op2PlypVYWVlVELb29vb4+Phw8+ZNAJ5//nmsrKx4+eWXefDBB7GysiqTVmDsbXv+/Hmsra0l/1zZsktGpnJkUSvTaNRXAF2/fp1du3bRtWtXZs+e3UBH1T5wdXXliSee4IknniA7O5uffvqJo0ePsnTpUmxsbAgKCpIEbvmGBVZWVri4uODi4kJJSQkqlYrs7OwyAtfBwaHRBa4gCFIOqI+Pjyxo60BOTg5ZWVmVCtqzZ8+yfPlynnrqKZ599tlmOMLWw5o1a0hLS8PDwwOAhQsXYmFhwebNm8nJyeHQoUPo9Xqef/55rK2tJZEqCALW1tasWbOGq1evkpycjLm5OVqtluLiYmxsbKRtDQYD8L9r57Fjx/jpp58YOnQonp6egGzZJSNTFbKolakx9vb20mOtVlvt9uKyWfnX1gTRk1an07F27Vo5h7IedOzYkX/+85/885//JD8/XxK4zz//PBYWFowYMYIxY8YwYsSICikllpaWdOzYkY4dO6LT6VCpVOTm5pKSkoK9vb0kcBu6v7wgCGRkZEhV+vLSa+3Jzc0lMzOz0qK68+fPs3jxYh5//HGWL18ui6UqEEWnKGjFSGpYWBiWlpZs2rSJ3NxcDh8+LAlbOzu7MmK1c+fOrFy5kjfeeIO0tDQAXn31VbKzs5k4cSJdunQpM1H8+eef2b59OxqNhgULFpTp2igjI2Ma+U4hU2Ps7e0ls3DR7L+qvFrjlIPaOhaInrQTJ05k2LBhdT5mmbI4OjoyadIkJk2ahEql4vTp00RERPDSSy8hCAKBgYGMGTOGkSNHVugCZ2FhgbOzM87Ozuh0OtRqNXl5eaSmpmJnZyfl4dZX4AqCQHp6OgUFBZUWNclUTV5enuTja0rQRkVF8eyzz/LII4+watUqWdBWQ2WrEgaDgTlz5mBtbc2GDRvIy8vjxx9/RK/Xs2rVKhwcHMqkFYwYMYL58+ezdetWkpOTgdIUqz///JOePXsybtw48vLy+PPPPzlw4ADZ2dls3ryZAQMGyGkHMjI1QG6TK1MrHnzwQalfe0RERJU2XStWrODgwYMAfPDBB9x///01GiMrK4v777+fkpIS9uzZU2mEQswx8/Dw4PPPPy/zXJcuXWo0lkwphYWF/Pzzz4SHh3P69GlKSkoYNmwYISEh3HPPPTg5OVX6Wr1ej1qtJj8/n8LCQmxtbSWBW1tBKgiC5KNbWetWmarJy8sjPT0dHx8fkz6+f//9N3PnzmXcuHGsW7dOFkq1xFikFhcXk5OTg0qlYseOHXz77bdAaQBgzJgxrF69GkdHxzI5tmq1mgsXLvDOO+9w48aNMvu2tbWVfHb9/f15/vnnGTVqlCxoZWRqiCxqZWrFsmXLpA5h27dvZ9SoUZVu+/jjj0s+teHh4XTt2rVGY/z+++88+eST9TpOYz9dmdpRXFzML7/8Qnh4OCdPnqSoqIihQ4cSEhLC6NGjq1wGNRgMksAtKCjAxsZGErjV5cTKgrb+iBZtlXVau3r1KnPmzCEkJIQ33nhDtoeqJcaC9vDhw0RERPDLL79gb2+Ps7NzmeuOg4MD9957L6tWraJjx44ViseKi4v58MMPuX37Nr/99hsGg0FaCZk0aRIjRoyge/fukguCLGplZKpHFrUyteL7779n5cqVACxevLjSammdTsegQYPQaDT4+fkRERFR4zGys7O5cOFCtdstWLAAKM0ZXbduXZnnatO/XaZytFotZ8+eJTw8nJ9++gmVSsWgQYMIDg4mODgYNze3Sl8rClyVSoVarcba2lrywi0vcAVBIDU1leLiYry9vWVBWwdUKhUpKSmVCtobN24we/ZsRo4cydtvvy1/xrXEOFq6Z88ePvroI/r27cukSZMYOnQotra2HDhwgAsXLhAeHg6UCtugoCDWrFmDi4uLJGzLC9zExEQMBgMODg44OjrKKTcyMnVEFrUytUKlUhEUFERhYSEDBgzgyy+/NLldZGQks2bNAkrFZ2NUVvfs2RMo9Wo9ceJEg+9fpiw6nY4//vhDErhZWVkMHDiQ4OBgQkJCpOpsUxgMBgoKCiSBa2lpWUbgpqSkoNVqZUFbR0RB6+3tXcHNAkrtqGbNmsWQIUPYtGmTLJrqweHDh1m6dCn33nsvCxcupE+fPmWeT05OJjw8XGri4ODgQGBgIC+88ALu7u5lXBEqi77KXcNkZOqGLGplas2HH37I5s2bAfj666/p169fhW1mzZpFZGQkTk5OHD9+vEKhWGZmJgsWLOD27dssXbqUJ554otbHIYva5kOv1/Pnn38SERHBsWPHSEtL484775Ta9VbVAlgQBEngqlQqqZLcy8vLpCCTqRq1Wk1ycnKlgjY2NpaZM2fSv39/3n//fdlJpB7ExsYSFhbGrVu32LFjB4GBgQAmUwQOHDjA6tWrgdIc28DAQFavXk2nTp1MNmiQ82ZlZOqPLGplak1RURFTpkzhypUrdO/evUIx1969e6V0gI0bN5rs2b5x40a2bt0KlNpGnTt3rtaCpilFrU6n48CBAxw8eJDo6GgKCwvx8PAgMDCQKVOmVOgPX1/UajXff/89x44dIzY2lqysLOzt7XF1dSUgIIBhw4Zxzz33VBkdbSoMBgN//fUXERERREREkJycTO/evSWBW1nTDEEQSEpKoqSkBBsbG9RqNWZmZlIE19raWr7JV0NBQQFJSUl06dLFpBNJfHw8s2bNolevXmzevNlk4ZhMzfnll19YsGABXbt25bvvvgOqFqMHDx5k1apV6PV6bG1tGTZsGKtXr8bb2xuAjIwMDAaDZBUmIyNTP2RRK1Mn0tLSCAsL49KlSyiVSiZMmIBSqeT8+fOcOXMGS0tLVq1axZQpU0y+/t1332Xbtm1AqVXUuXPnqm27e/PmTSIjI6WfxeU9Jycn5syZI/0+KCioQUVmRkYGYWFhREVFoVQqGT9+PEqlkj///JMzZ85gZWXF6tWr6xRtNsXp06d54YUXyM7OZujQofTt2xdbW1tSUlI4duwYOTk5ADz55JOsWbOmQcZsKARB4MqVK4SHhxMREUF8fDwBAQGSwBXbrebm5rJp0yaeeOIJevToIS3HFhUVSRFcQBK4NjY2ssAtR3WCNikpiZkzZ9KtWzc+/vhjk3m2Ik0xaVOr1Rw/fpzTp09z5coVMjIy0Ol0ODk50atXL+69914eeughHBwc6j1WQyMK13feeYft27dzxx138M0339TotV9++SXr1q1Dp9NhY2PD0KFDee211wDYtGkT5ubmLFu2DGdn58Z8CzIy7QJZ1MrUGZ1OxzfffFPmRuju7k5gYCBTp06lR48elb42PT2dBQsWEBMTw5IlSyoVv8YcOHCAVatWVbvdG2+8Ueu+7pWh0WiYOnUqly9frjIqrVAo2LRpE2PHjq3XeMePH2fRokV06dKFDz/8sMJnWFhYyIwZM7hw4UKLFLXGCILA9evXCQ8P5+jRo0RHR9O1a1dGjhwpTU72799vMkIvCAIajQaVSkV+fj6A5KJga2vb7gVuYWEhiYmJeHl5mWxskpqaysyZM+ncuTPbtm2rcsLY2JM2g8HAu+++y+effy5Zvt177710794dKHVkOHHiBHq9Hg8PD95++23uvvvuOo3V2HzwwQds2bIFKP3uDx48uNrXZGVl8f777/Of//wHg8GAlZUV/fv3x9HRkZ9++olly5ZJ9QcyMjL1Qxa1MjJVsHnzZj788EOg+vxhpVLJ8ePHKzQtqCmJiYk8+OCDmJmZcejQoUrzUi9cuMCMGTP417/+xYoVK+o0VnMQHR3NgQMH2LNnD9bW1jg5OREcHMyYMWPo06dPpUJVEASKi4ulCK5er5cErp2dXbsTuEVFRSQkJNC5c2eTUc309HRmzZqFi4sLn376aZXd/Jpi0lZcXCx9b3r16sW2bdsqLLdfuXKFGTNmkJOTg42NDXv37uXOO++s9ViNhRip/fe//817772HtbU1M2bMkBovVMfRo0fLFMuKXcbCwsIICwsrM4aMjEzdkcsrZWQqQa1Ws2PHDgAGDBhgUtACTJs2DShdUt+9e3edx9uwYQMajYYnnniiykKru+66i4sXL7YqQQulkdaTJ08SEBDAjh07+Oc//8n58+eZOnUqDz74IO+88w5RUVEYDIYyr1MoFNjY2ODm5ka3bt2kLmNpaWncvHmTlJQU1Go17WF+Xp2gzcrKYu7cuSiVSj755JNq21Nv376dy5cvA6UrHOU9iKdOnUpQUBCCILB27VopLaQumJmZsWnTJpP5o3fccQcvvfQSUCq0xeX5loIoNoOCglAqlRQXF7N//37ps9Pr9SZfJ56T9913HwEBAQQHB2Nvb4/BYODZZ5+VBK3BYJAFrYxMAyCLWhmZSjh58qTU6nf06NGVbhcYGCjlK4qNKWpLSkoKx48fB+CBBx6o0z5aMtnZ2UybNg0HBwd27tzJnXfeyZw5czhw4AA//fQTTz75JFeuXOHpp59m7NixbNiwgfPnz5sUC9bW1ri6utKtWzf8/PywsrIiIyODmzdvkpycjEqlqiCM2wIajYaEhAQ6depkUtDm5OQwd+5cbG1t2b59e7UrBk09aRswYADdunWr9PkHHnhAOuaoqCiSkpLqPFZj4erqSufOnYHSz3vx4sXExcVJ3rPlUSgU0u8LCgoYMWIE7733HosWLWL+/PmAbN8lI9OQyN8kGZlKOHXqlPT4jjvuqHQ7CwsLevfuDUBMTAyxsbG1HuvHH39EEIQy+4LSCFBGRoaUV9paSU5Opk+fPuzYsaOCvVuXLl145pln+PLLLzl9+jSzZs0iOjqaOXPmcN999/Haa69x9uxZdDpdhf1aWVnh4uJC165d6dq1KzY2NmRlZXHz5k2SkpLIz89vEwJXo9EQHx+Pp6enSbGal5fHvHnzMDc3Z8eOHVW2NRZpqkmbubk5zzzzjCSOK8PMzKxM2+2YmJhaj9XYuLu7s2jRIunnzMxMpk6dyu3btyv1VzY3N+fSpUukp6fTqVMnRo0aJTWt0ev1sqCVkWlA5G+TjEwlGLe89PHxqXJb0aIHqNDPvSacP38eAA8PDywtLYmMjGT69On079+fkSNHMmTIEO6++26WL1/OzZs3a73/5qZv375s2rSp2sp2T09PnnzySfbt20dkZCQLFy4kOTmZsLAwQkNDWbt2Lb/88gslJSUVXmtpaUnHjh3x8/OjW7du2NrakpOTw82bN0lMTGy1Are4uFgStOUnBFDaGnf+/PnodDp27dpV4yr6ppq0WVhY8NxzzzFu3LhqtzX++1S2pF9f6pOmIggC99xzD4sXL5bSBTIyMpg8eTJnzpxBq9VK24qTsJSUFPbv34+/v38Fezu50YiMTMMii9p2Rmu8qTcHgiCUuXm7u7tXub3x87dv3671eNeuXQNKTdpfe+01Zs2ahUqlYsWKFWzatImlS5fSoUMHfvjhByZOnMjXX39d6zFaG25ubvzrX/9i165d/PLLLyxfvpzs7GyWLFlCcHAwL7zwAqdOnUKj0VR4rShwfX198ff3x97entzcXG7evElCQgJ5eXmNJpoaElHQenh4mBS0arWahQsXUlRUxO7duyvkxFZFU07aakpycrL0uFevXg2676KiIoB65a6Kr33ooYeYPn26JEpVKhXz58/no48+4ueffwZKxXxMTAxbtmwhPDycMWPGSJZ2MjIyjYPcK7GNU75zjbjUZTAYpE5OMhUpKCiQooEKhaJaD13j5/Py8mo1lsFgICUlBSgVDDdu3ODhhx9m/fr1ZZYmp02bxjPPPMPFixd58cUX8fDwICgoqFZjtVY6duzIY489xmOPPUZeXh4nTpwgIiKC5557DgsLC0aOHMmYMWMIDAys8LeysLDA2dkZZ2dn9Hq9ZBOWmpqKra0tjo6OODg4tLjWsVqtlvj4eNzc3EymExQWFrJo0SJycnLYu3cvbm5uNd53U0/aasLt27clD+a77767QRoSaLVaDh06xB9//EFCQgIdO3Zk1qxZ0kSnrnTq1IkpU6agVCrZvHkzJSUlFBUV8emnn/Lpp5/St29fiouLiYuLo7CwkEceeaRMUZicciAj0zi0rKu4TINjbm7Of//7XwoLC4mJicHZ2ZnBgwejVCqb+9BaNGKuIVCjtqLGtj7Gr60JarW6zM8dO3bkxRdfrHDjs7Oz4/XXX+fBBx/EYDDw6quvEhER0e4mJk5OTkyaNIlJkyahUqk4ffo04eHhvPjii0BpDuiYMWMYOXJkhXQHc3NzlEolSqUSvV6PWq1GpVKRlpaGra2tZBXW3AJXq9USFxeHq6urye9qUVERS5YsITU1lX379tW6s1xTTtpqitihCyhjf1VXSkpKWLFiBWfPni1zzGK+9gMPPFCvDmtdunRh+vTp9O3bl/Xr15OXl0dWVhZQWugGpd0On3zySRYvXgxUDDLIyMg0LLKobWOIXof5+fkcP36c7777jsuXL1NUVIS9vb0kuIYPH84TTzzB6NGjK4g2vV6PQqGQowm1oD6fVWFhYZmf77///kpFRrdu3Rg0aBDnzp0jISGBM2fOMHLkyDqP3drp0KED48ePZ/z48RQWFhIZGUl4eLjUwWn48OGEhIRwzz33VFi+Nzc3x8nJCScnJwwGgyRw09PTsbGxkQSupaVlk76nkpIS4uPjcXFxMZkfW1xczPLly4mPj2fv3r1SNX5taMpJW03Izs5m//79AEyePLlGTQ2qwmAwMGvWLM6ePYtCocDc3BxbW1uKi4u5ffs227Zto2fPnvTq1ateQtPKyooRI0awe/du4uLi+PXXX1GpVGi1Wu6880769Okj5SvLglZGpvGRRW0bQhS0f//9N+vXr+fixYtA6YXXwsICBwcHnJ2dSUpK4syZM8TGxqLX6xk7dmwZ42/5wkuZpUnj4o/KMM7rrO2yZnlRUZ3pfP/+/Tl37hwA586da9ei1hg7OzseeOABHnjgATQaDb/++ivh4eG8/fbbvPrqq9x9990EBwczevToCrmnZmZmODo64ujoiMFgoKCgAJVKRUZGBtbW1pLArYkArA8lJSXExcXRsWNHk/mxWq2WlStXcvPmTfbu3Vsm17UxaewJ7tq1a8nPz6d3796sXr263vtbsmQJZ8+excnJiXvuuYdJkyZhZWXF8ePH+c9//kN0dDTr1q1j586d9fqbKhQKBEHAzc0NNze3SsW4wWCQr6syMk2ALGrbEAqFgps3bxIWFkZqaioKhYKOHTvy+OOP89BDD6FWq0lOTub777/n2LFjpKSk8P777xMQEED37t3RarVERERw48YN/vWvf9GpU6fmfkvNhr29PZaWlpSUlCAIAoWFhVUu0RpHr0wV9FQ3ljGurq5Vbm/8dzEurJH5HzY2NoSEhBASEoJWq+XMmTNERETw4Ycf8vrrrzNo0CBCQkIIDg6u8HmbmZlJIlYQBEngxsbGYmlpKT1Xn6VrU4gRWmdnZ5OCVqfTsWrVKq5cucKePXvK2F/VlqactFXHJ598QkREBJ06dWLr1q2SfVhd2b17NydPnsTW1paHHnqIxx9/XPLH7dixI0lJSZw4cYIrV65w6NAhHn744Xp18xJfZ7yP8nmz8qqXjEzTIIvaNoC4rBUVFcWWLVtITU0FkKIextGDPn36MHLkSKZPn86VK1eIjY0lNzcXgK1bt7J3717y8vJITk5mzZo1taqmro7W1AZSoVDg6+vLrVu3gNLWo1WJiPT0dOlxVQbzprC2tkapVEp/h+oiR8ZiSqzolqkcKysr7rnnHu655x50Oh2///47ERERbNu2jQ0bNjBw4EBJAJcvTlIoFDg4OODg4ICnpyeFhYWoVCri4uKwsLAoI3Drc27rdDri4+NxcnLCxcWlwvN6vZ41a9Zw4cIF9uzZU+8q+qactFXFt99+y7vvvoubmxu7du1qkOKwCxcuoNVq8fX1ZcKECWW+j127dmXSpEkcPXoUnU5HVFQUDz/8cINcl4z3IYtYGZnmQf7mtQHEZa1t27Zx9uxZAIYNG8YLL7zA4MGDMRgMktuBwWDAxsaGYcOGUVJSglKppKCggG+//ZYtW7aQl5fHuHHjWLt2bYMKWvifP+S6det49tlnOX36dIPuv6ExthRKSEioclvj53v06FHrsYxfU13OorGQra5rlExZLCwsGDFiBK+++io///wzn332Gb1792b37t088MADPPXUU3z22Wcmu1kpFArs7e3x9PQkICAAT09PDAYDCQkJ3L59m/T0dIqKimrtgyoKWkdHR5NReoPBwMsvv8zZs2fZtWtXnc4vU+/F2DPVeFJmivpM2irj0KFDrFmzBldXV3bv3l2vyLPItWvXiIiIAGDcuHFlUnnEv8u9997L0KFDAfj1119Rq9UmG3vIyMi0PmRR20Y4c+YMJ06cQKvVYmFhwdKlSxk4cCBQGjUwMzOT8r8AKSro4eHBgQMHePPNNxEEgeDgYF599dVGEUtmZmbo9XpsbGy4fPkyc+bMYeDAgSxZsoTff/+9wcerL8Z2WX///Xel2+l0Oq5evQqAn58fXbt2rfVYd999t/S4OgGdmJgoPW4ogdEeMTc3Z+jQobz00kucPn2a/fv3c9ddd/HFF18wfvx4pkyZwo4dO4iLi6vwWtExwMPDg+7du0vFWklJSURHR5OWllYjgSsKWgcHh0oF7bp16zh9+jQ7duwo022uvjTlpK08hw8fZuXKlTg7O7N79+4G8281LroUHSFEP2Lj659okaZWq7GysqoQWZX9vGVkWieyqG3FiBfohIQEvvrqK6B0qfXRRx+lX79+Jm+oYlT3119/BSA+Pp5Tp06Rm5vLY489xnPPPYeDg0OjGdObm5szf/58/v3vfzN16lSKioo4cuQIH374YaOMVx+Cg4OlJVnj7kvl+e2336ScwwcffLBOYxl3W/rjjz+q3FbsPgYwatSoOo0nUxYzMzPuuusuVq1axcmTJ/nPf/5DYGAg3333HRMnTmTy5Mls27aN6OjoCq9VKBTY2tri7u6Ov78/Xbp0QaFQkJyczK1bt0hNTaWwsLDC91Gv10uC1s3NrcISuCAIvPHGGxw7dozt27dXW0BYW5py0mbMkSNHWLFiBUql0qSgNRgM5OfnU1xcXOt9m5mZYWFhgZmZmWSvZapLmUqlAkqbTuh0On7++Wd++OEHrly5glqtxszMTBa2MjKtEFnUtmLEm+D58+elavjevXvzyCOPABXbQYoX6Rs3bpCQkICFhQVFRUUUFxcTFBTEypUrpSXJhqjUFdMeymNvb0/Pnj2lAhWlUsn9998PNF5rzLrQoUMHnnnmGaDUd/LSpUsmt9uzZw9QGv2ZPn16heczMzOZPHkyQ4YMkWyLytOtWzceeOABAH7++edKI2d//fUXV65cAWDEiBEN3nVJpvR7deedd7JixQqOHTvG999/T3BwMBERETz66KM88sgjfPTRR1y/fr3Cd0yhUGBjYyMJXB8fH8zNzUlNTeXmzZukpKRQUFAgRWjt7e0rFbRvv/02P/74I1u3bpVWXRqSppy0iURERLB8+XKcnJzYvXs33bt3r7BNcnIyQ4YMYdu2bbXev2iBZjAY+Ouvv4DS7nJi6pWFhQUGg0Hyrb19+zb33Xcfc+bMYcWKFSxYsIBVq1aRkZGBmZlZvVrqysjIND2yqG3lqNVq/vzzTzIzMzE3N+fuu++WlijLC1NRYB4+fLjMz2PGjGHDhg04ODjUuy+6MWLaA5SKVePns7OzOXnyJFBaeCLmuLW0QrKZM2dKPpOrVq0iOzu7zPN79+4lMjISgJdfftlkEc1nn31GVFQU+fn5rF+/vtLirlWrVuHm5kZJSQnLli2TUkRE0tLSWLlyJVA6EVi3bl19355MNSgUCnr16sWSJUs4cuQIP/74Iw8++CA///wzjz/+OBMnTuT999/nypUrJr871tbWuLm50a1bN/z8/LC0tCQtLY2bN29iMBhMFmcJgsD777/Pt99+y7///W+GDBnSKO+tKSdtAMeOHWPp0qU4Ojqye/duAgIC6v8mjBAEAR8fH0JDQzE3N+e3337jm2++ASjju/3pp59y9epVFAoFGo1GunYCpKamcvr0ad544w3y8vJa3PVIRkamamT3g1ZOcnKy1O7S09OTO++8EwsLC5NOA2KXpJ9++gkoFbUPP/wwc+fOpWPHjvVu36hQKEhJSSE5OZmbN2+i1+sZNGgQvXr1qiCwL1++TEZGBhYWFnTr1o2ePXsCLa9q2NbWlo8//piwsDAuXbrE2LFjmTBhAkqlkvPnz3PmzBksLS1ZtWpVpVEsY7EjCEKlEwdPT0927NhBWFgYf/31F2PHjuWBBx7Aw8ODhIQEwsPDUavV+Pn5sWXLFry8vBrlPet0Og4cOMDBgweJjo6msLAQDw8PAgMDmTJlSoOKkTNnzvDtt9/y119/kZ6eTklJCY6OjgQEBBASEsIjjzzS4BZS9aF79+6EhYURFhZGbGws4eHhHD16lF27dtG5c2eCg4MJDQ3lzjvvrHAuW1lZ0bFjR9RqNR06dMDW1pasrCySkpLYt28ffn5+PPDAA3z33Xfs37+fLVu2MGzYsEZ9PzNnzuTkyZNcuXKFVatWsWfPnjIForWZtAGsX7+eiRMnYmtrW2ab48ePs2TJEnQ6HWPHjuX8+fNl0miMKT+Zqyni9W7w4MGEh4ej1+s5ffo0Q4YMwcfHB4DTp09LUWlBEHB3d6dz58707t2bzMxMwsPD0Wq1REVF8euvvzJu3Di5ra2MTCtCFrWtHEEQJK9SQRDo0qVLhW3Ei7Jareb777/n5s2bWFpaMnToUF588UXpBlSfC7dGo+HgwYPs37+fq1evYmVlJaUX+Pn58eijj/Lwww9LN8wTJ04ApX6iYpS2pd48PDw82L9/P9988w0HDx7k0KFDFBYW4u7uzuTJk5k6dWqVxTPTpk3j7NmzxMTEsGTJkiqtk3r06MHBgwf58ssviYiI4MiRI6jVapycnBgwYAD33XefZCTfGGRkZBAWFkZUVBRKpZLx48ejVCr5888/pc9g9erVPPHEE/Uap7i4mJUrVxIeHg6Uvu+HH34YpVJJTEwMx44d4+zZs+zcuZPNmzdL0fKWhJ+fH3PnzmXu3LkkJCRw9OhRIiIi2Lt3L+7u7pLAHTBgAObm5qSlpbF+/XoWLFiAr68vCoUCFxcXtFotHTt25Msvv2Tz5s1YWloyfvz4Mu4EjUVTTNoSEhJYvHix1JZ33759jfJexIn81KlT+euvv/jhhx84evQoffr0Ye7cuWi1Ws6dO8eff/4JwH333ccjjzzC8OHDsbKyori4mLvvvpt169aRnJzMt99+y7hx41rkNUlGRsY0CkFOGmrVxMXFcf/996NQKLC2tubHH3/Ey8sLvV4vXYzFZbZNmzbx+eefU1JSQkBAAMuXL+eee+6ps5gUX5eVlcX27dvZuXMnUNrZqV+/fgwZMgSNRkN0dDS3b98mJCSEFStWoFKpmDBhAqmpqXTp0oUPP/yQ3r17t1hR217QaDRMnTqVy5cv0717d5NRu3Xr1qFQKNi0aRNjx46t81irVq3iwIEDAMyZM4fFixeX+dvHxsby5JNPkpaWhrOzM4cPH25wi7nGIiUlRRK4Fy5coGPHjgQGBnL+/Hkpl9TUpGTnzp3s2rWLu+++mxs3bhAXF0fv3r257777mDBhQqN2D9PpdNKkTYzOu7u7ExgYWO2kLT09nQULFkiTtilTppR5/urVq0ycOLHWxxQWFsbChQtr9RpR2P7666+8++67/Pe//wXgvffe44EHHiA8PJzFixczadIk1qxZg4ODQ5nXpaen8/rrr3P06FEEQeCTTz6RO/bJyLQmBJlWTUJCghASEiL07t1b6Nevn7Bjx44K26jVamHhwoVCv379hJ49ewo9e/YUFi5cKKSkpAiCIAgGg6FOY4uvW716tTBo0CChZ8+ewsCBA4Uvv/xS0Ol00nYZGRnCnj17hEGDBgl79+4VoqKihJ49ewp33HGHMHPmzDqNLdPwfPjhh0KPHj2EHj16CH/99ZfJbWbOnCn06NFDGDp0qJCfn1+ncVJTU4WePXsKPXr0EMaNG1fmXDHmhx9+kI5n06ZNdRqruUlLSxO2bt0q9O/fXxg8eLAwZMgQYeXKlUJERISQm5srFBQUCAUFBcLWrVuF3r17Cz/++KMgCKXfratXrwrvvfeeMG7cOOGJJ55o5nfSutBqtcLGjRula96kSZOEq1evCnl5edJnXBn79++XrpP79+9voiOWkZFpCOT0g1ZOly5dGDVqFPv376e4uJiPP/6YwsJChgwZgrOzM//973/ZuXMn165dk3Jqrays6Nevn+TjWJ/2kFFRUWWKMebOncvEiRMxNzdHp9NhYWGBq6srU6dORa1Wc/z4cS5cuACUph6IRTBylLZ5UavV7NixA4ABAwbQr18/k9tNmzaNyMhIcnNz2b17N2FhYbUe69KlS9IS9V133VWp04ZxgZTYVKS1YWFhwQ8//EC3bt3YtGmT1M1syZIl2NraEhQUhJ2dHd988w0bNmyQrN3EArVevXqxaNEiuQq/FgiCgKWlJQsWLODixYv88ccfxMTE8P3337N48WLpMy5/zRF/Dg0NZdu2bSQnJ0sexfL1SUamdSCL2jbA6tWrKSoqIjw8nPz8fHbu3El4eDixsbEIgoBOp6Nz587k5OSg0+lwdnaWin3qc7HOzs7myy+/lH4eOHAgjz76qLS0Kopo8Yb8zDPP8Pnnn0uNFhwdHRk+fHitxhQtvxrCckzmf5w8eVLqZDZ69OhKtwsMDMTGxgaNRsOhQ4fqJGrF3Eqgyvxi4+dycnJqPU5zU1BQwDPPPIOZmRk7duxAqVTi6+vLY489Rl5eHidOnCA8PJwjR46wcuVKHnrooUr3JVfh1xyFQoFer8fKyoq33nqLmTNncuvWLb799ltGjBjByJEjpdbixojXwaKiItRqNfC/Jg2yoJWRaR3I39RWjhiVePbZZ5k7dy6+vr6o1Wpu3rwJlObKDR8+nLfffpu+fftiZmZGXl5eg1ysb926VSaC9sgjj5jMe1QoFCgUCvLz81EqlRgMBhQKBV27dqVv377VHkdWVha3bt1Cp9Nhbm4u3YzE1r8y9cfYp7SqoiwLCwvJMi4mJkZy3qgNxt66N27cqHQ74+dcXFxqPU5zk52dTZcuXdi5cydKpbLMc05OTkyaNImtW7dy9epVnn766eY5yDaKubm55G7wzDPP4OHhQW5uLmvWrCElJUV63hjx56ysLKkzWfm/m4yMTMtGjtS2csQITufOnaVK7CtXrnD69Gn0ej3Dhw+nd+/e2Nvb4+Xlxblz59BoNHz++ecUFxfTv39/bGxsaj2uTqeTzOSh9CZi3BXLFCUlJbi5uXHjxg1sbGwYNGgQCoXCZLQ4NTWVn376ia+++gqFQkFmZibW1tb4+/szceJEQkNDG80BoD1y/fp16bFof1QZ3t7eXLx4ESgVnn5+frUaq1u3btx///1ERERw5swZ/vjjD8kBQ8RgMJTpMhccHFyrMVoC3t7ebN68ubkPo90iTqZHjBjBmTNniIiIIC0tjbfeeouXXnpJatQA/ysUy8nJYefOneh0Ovr06VOvYkgZGZmmRxa1bQQxamlubs4dd9xhMtr20EMPcfLkSfLy8jh48CAajUaKlNZlPGMhNGzYMGxtbU0u6xkTExMDlEZAAgMDpd8LRr66x44d44MPPpCiza6urgQEBGBtbU1sbCwrV64kICCAp556qk5V1TJlEQShTMTV3d29yu2Nn799+3adxtywYQOWlpYcOnSIWbNmMWPGDIYPH46TkxMxMTHs2LFD8j7t378/06ZNq9M4MjIeHh7MmDGDM2fOkJmZyV9//cXRo0d55JFHsLCwkHL/1Wo1hw8f5vLlyygUCgYNGiRPnGVkWhmyqG0jlC94EAWuMQMHDmTx4sV89tlnxMTE0KNHD+zt7U02aqgKg8GAlZVVmQ5EISEh1b4uLi6O5ORkzM3N8fHxkXrZi33WFQoF+/btY+fOnSQmJqJQKJg+fTpTp07Fy8uLoqIi4uLiiIiIYPv27XzwwQdYWFgwfvz4Wr8Hmf9RUFAg5bkqFIoq81yhbK6r2G60ttjZ2fHuu+/y1FNP8fbbb/PRRx/x0UcfldnG0dGRRx99lCVLlsjiQqbOCIJAr169eOONN5g3bx7Jycn88MMPjBgxAi8vLywsLMjOzubzzz8nIiKC5ORkfH19mTp1aoUmEjIyMi0bWdS2QSrLT7WxseGJJ57giSeeICEhodqIXFX7LygoQKVSoVAoEARBKjyrKkr7888/A6WtQ4cMGYK5ubmUemBmZkZaWhrvvPMOxcXFAEyfPp0FCxbg4OCAXq/H1tb2/9q79/iY7+zx469JZuQeIZWLJBKXRmgpLVGEEMHS0gqllbaL+iqpUqVVWiSsB7bddntN25RSSte67LaS1lJUlVJKxKVoEpWkSEYaErnOZH5/5Pd5d0YuxD1xnv+YZN7zec+MmcyZ9+e8z1E7wr28vIiLi2PevHk0a9as2t364vK0DWLAFQWPDg4OVd62NkpLS3nvvfdYvnw5xcXFPPzww3Tt2hVnZ2fS0tLYsmULffr04dFHH5WAVlwT7W9U165dGT9+PB9++CF79+5l6tSp+Pv74+HhwQ8//EB2djaFhYU4OTnx5ptvEhgYKFUPhKhjJKi9g1gsFpUeEBAQoDZGXO0KZ0hICFlZWTRp0sRmR3tVLl68qDYjubu7q/af2odGUVERK1asoKioCIA2bdowevRonJ2d1elBbXx5eTkjRoxg1apVHD9+nDVr1hASElKr4Mf6uZAV3tq51g95s9nMhAkT2LFjBwaDgU8++YTu3bvbjBk9ejRjx44lPj6ecePG8fzzz8v/k7hqOp0OvV5PREQE+/fv58cffyQ5OZnk5GSbcQ0bNiQ+Pp577rlHAloh6iB5x95BtD/sWnBwtUGCxWLBxcVFVTrIyclRwWh11Qj27t1LamoqdnZ2BAQEcN999wF/ruympqaydetWNf6ee+7By8sLOzs7FdCazWbKy8tVHpyvry8A33zzDcXFxTXe57KyMs6cOcP+/fsxGo2Vnovy8vKrei7qAxcXF3VZa21cE+vn2vq2V2rFihXs2LEDgOjo6EoBrXbc119/nfLyct5//33eeuutWs8jxKXatm3LI488ooJV7W+Lr68vffv2JSEhgfvvv18CWiHqKFmpFbWmBYL9+vXjq6++ori4uFKRcuuqBhkZGXz11VdAxanr+++/H4PBoK63WCycOHGCX3/9VR1/zZo1JCYmEhYWxpAhQ4iIiLBJbSgpKVFBtZOTEydPnqwyBeHUqVMkJiayZs0adDod58+fx97eHm9vb/r378+jjz5K06ZN7+gPMBcXFwwGA2VlZVgsFgoLC2vMq7VOOXB3d6/1fKtWrVKXa9ro5+/vT6dOndi9ezeLFy9m+PDh+Pv713o+IeDPzaiDBw8mPT2d+Ph4TCYTrVu35vXXX6dJkyY0atQIi8VyR/89EKIuk3euuGpdunRRFQxWrVqF0Wis8nT+ypUrVT6tm5ubuo22qms2m1VACxAUFMTf//53IiMjOXz4MDExMbRr147x48ezceNGTCYTbm5uqpJCXl6e2rBkMpnUsRMTExk1ahRvv/02Z86cobS0lO7du9O9e3ecnZ354IMPGDJkCAsXLlQ1Ue/Eurc6nY7AwED1c3Z2do3jra9v0aJFreYqKChQ/286nU7lYlendevWQMX/q3UtXSFqS/uiDTBu3DhVgvDYsWPs27dPlfi6E/8GCFFfyEqtuCpaBYTZs2djb2/Ppk2beOKJJxg7diz33nsvzZs35/z586qagVYz0t/fnw4dOgAVqQdmsxm9Xs/hw4fVsYcOHcrgwYPp1asXWVlZHDp0iJ9//pm9e/cyefJk9Ho99957ryr5VFJSooIf7QNp2bJlLF++nN9//x2dTsdTTz3F6NGj8fb2BiArK4udO3eydOlSli5dyu+//05MTIxNY4A7SUhIiPpikZGRUWPt2YyMDHU5ODi4VvNcuilNO/1bHesV46ysrFrNVVeYTCbWrVvHl19+SWpqKoWFhXh7e9OtWzeio6MvG/jXRlFREV988QVJSUmcOnWK0tJSfH196dWrF9HR0fj5+V23uW5H2gqsk5MTjz76KCdPnuTIkSPExcXh6elJv379ZJVWiDpMglpxVbS0AR8fH55//nk8PT1Zt24df/vb32jevDn5+fnk5OTQtm1b/P39yczMxGAw0LlzZxwcHNTmL62zj9FoVMfWAkt3d3fc3d1p06YNgwYN4rfffuPIkSP8/PPPpKSk4OPjw5kzZwgMDFSdfwwGA2fPnuXtt99WuZ8jR47k2WefpVGjRmpePz8/HnvsMcLCwhg3bhz/+9//+OGHH3jjjTfo3bv3ZR+/2WxGp9PVmw/Anj17smHDBgAOHTpEjx49qhxnMpk4evQoULGi3rx581rNY52uUFJSQmlpaY0b/PLz89Xl+lgFIScnh4kTJ3LgwAE8PDx4+OGH8fDwYN++faxatYq1a9cyc+ZMnnjiiWueKzU1leeee4709HR8fX2JiorC0dGR77//nsWLF7N69WoWLlxIZGTkdXhkt7/u3buzb98+VW972bJl+Pr6qlKDQoi6R4JacdW0NIPg4GBiY2OZMWMG27ZtIzk5GVdXV4KDg2nXrh0xMTFkZmbSsGFDtUprvUJXVlZGu3bt+PXXXyu1pdTy4BwdHWndujWtW7dm4MCBpKenc+TIEX766SdCQkJUcFlYWMjKlSvVxrVmzZrx1FNPqVOL2rwWi0VtNuvbty+ZmZlcvHhRHUerm6vT6SguLsZgMJCRkYGTkxPe3t42+b1ms1nlEddVERERODs7U1hYyLZt25gwYUKV43bu3Km+LDz00EO1nsfJyYmgoCDV7OHw4cN07Nix2vHWK/i1DaBvd8XFxUyYMIGUlBRatWrF8uXLbdpMr1ixgnnz5hEXF4eHh8c1dbfKzc1l3LhxZGZmEhoayscff6xqsE6ePJlFixaxZMkSpkyZwtKlS3nggQeu+fHdzrQ63pMnTyYlJYWdO3dy5MgRvvnmGwICAqQ9rhB1VP1YZhK3VHl5OWazGQcHB/r378/LL79MTEwMkZGRlJSUqMDEaDSSmJjIv//9b3Uq2WKx0KBBA1XJoKCggNzcXHVc60BRSy1wcHAgJCSEqKgo5syZw9ChQ1WQefLkSZvcy8GDB1d5Kl2n02EwGADo0aMHRUVF+Pj40KVLF8C2bNXkyZMJDw9n6tSpjB07luHDhzN79mz27t0LUC/Kgrm5uTFmzBgADhw4YNNYw9ry5cuBitJHo0aNqnS90WhkxIgRdO7c2WZDmLVBgwapy//617+qvU9Hjx5VKSZOTk707NnzSh5KnfHJJ5+QkpICwIIFC2wCWoAnn3ySnj17YrFYiI2NtVm1rq3XX3+dzMxMHBwcWLRoUaWmAtOmTSM4OJjS0lJeffVVzGbzVc9VF1hvZJ0/fz4hISEUFRWxevVq9b6u78+BEPWRBLXimtnZ2amg0mw2q+CzvLycZs2acfToUT766CP69+/P119/zdy5c9mzZw/w52rvQw89hKOjIyaTSaUiaJ3RLlVWVsa5c+coKCjA0dERV1dXdZy0tDSbTWfa7vqaNn9oK49du3bF0dFRbSbR6XScPXuW7du3YzQayc7ORqfTUVpayrfffsuTTz5JVFQUa9asUSvDddnYsWNVe+UZM2aoLxeaFStWsH37dgDmzJlTZeWDzz77jAMHDnDhwgXmz59f5fMyatQoter6n//8p8rA9vTp07z44ovq5+eff75S0FeXFRQUsGTJEgA6dOhQbfMQrT1wXl4ey5Ytu6q5Tp06xX//+18AIiMjadq0aaUx9vb2jBw5EqhoZf3ll19e1Vx1ifbF1cvLi6effhpfX1/y8/N58cUXSUtLq7GRjBDi9iTpB+K6sv4g0Nrf2tnZER4eTnh4OFBRs1ZLB9Cub9myJf/3f//Hu+++S0JCAoMGDaJJkybqWNopfoBt27bx7bff0qBBA0aPHq0CJIvFQnp6ulphadWqFf7+/pdtoevv789LL71E586d1XE0e/fuxWKx0LdvX6ZOnUpQUBDnzp0jPT2djRs38sUXX/CPf/wDk8nE448/Xu0cJpMJnU53W39QOjk5ER8fz8SJEzl48CADBgxg0KBBeHh4sHfvXnbt2oXBYGDGjBnVph5YP3cWi6XKLxOurq4sWbKEyZMnc/DgQWbPns3atWvVl4r09HQ2bdpEYWEher2eiRMn8swzz9ywx23tl19+YebMmRw+fJjQ0FC1Mn095ebmMmfOHLVp7siRIzzyyCP07duXkSNH2gTv3bp1w9HRkeLiYjZs2MDEiRNrPV9SUpJ6T/Tq1avacREREcTGxgKwYcMGhgwZUuu56iJ7e3vCwsL46aefWL9+PaWlpVfdKU8IcWvpLFK/RNwE2odqTUHdH3/8wYIFC9iwYQPBwcHExMTQqVMn9SFfVlbG0aNHmTRpEmfOnCE0NJR33nkHDw8PtQFs/PjxKv3g2WefZcqUKTYdyWpr9+7dHDt2jIiICPz9/Ssda+fOnUyZMoXz58+zcOHCSnVXq8q3vZLn4lYymUysXbvWZje+l5cX3bp148knn6yx4kF2drbajDRlyhSio6OrHWs2m9m8eTNff/01KSkpnDt3jrKyMlxdXWnevDmdO3dm2LBhNuXGbpTS0lI+/PBDPv74Y9Ud70YEtT///DOTJk0iJydH/W7AgAEcO3aMtLQ0mjRpwjvvvMP999+vrn/88cfZv38/ABs3bqyxMkVVrG+flJREy5Ytqx0bFhZGTk4Oer2effv24ejoWKu56rJffvmFZ555hkWLFhEWFnbZL8NCiNuPBLXitnL69GkWL17M2rVrsbe3p0OHDvj7++Pu7k5aWhrbtm3DZDIRFhbGnDlzCAgIsLn9iBEjVOvL995774p2cl+ue5DWmte6s5n2ttHr9cybN4/PP/+cnj178uabb+Lq6qpuu3PnTsaMGUOvXr0YNmwY4eHhKpcXkA/O20BKSgozZ87k+PHjtGnTRlV3uN5B7cmTJxk+fDjnz5/H1dWVgoICoCJQDQgIYNq0aSQlJdGwYUNWr16tgteXXnpJpQO8++679OvX74rntFgsPPDAA1y8eBGdTsfBgwdrrCIxcuRI9u3bB8C6detUOsqdoqCgAFdXV+koJkQdJekH4rbi6+vLa6+9xtChQ1mzZg1bt24lOTkZk8mEnZ0dgYGBjBgxQuUGWgeF5eXldOjQgeTkZNzd3a84WKzpw6usrAyDwYCdnR3FxcU4OjpWWmFt3rw5Li4u/PDDD2RlZamauVDRrWvAgAFs27aNbdu2qVOdf/nLXxgwYMAdtRJ2O9q8eTOTJk3CycmJuLg4unfvfsNKWs2ZM4fz58/j6empmoVARU6nvb098+bNY8+ePRiNRmJjY1m6dKm6XpOWllarObOzs9WpdA8Pj8uWRbt0rjstqNXaPktAK0TdJEGtuK1oQWqbNm2YNWsWs2bN4uTJk2RnZ+Pv74+bmxtubm5qvHXgamdnp9qo5ufnq41OtVkN1caWlpayefNmdu/ezaFDh/Dz86NJkyYEBgYSHBxMixYtVADg5ubGxYsXVd1da/fddx9vvfUWY8aMYefOnZjNZg4dOsR3333Hp59+yqJFi2jTpk2l+6GtDteHygq3s8zMTLp3787cuXPx9fUlMzPzhsyze/dufvzxR6Ci+oMWsOp0OtVgwtXVlSFDhpCQkMCuXbvYs2cPoaGhNg0orIPhK5GXl6cu19T6uKoxFy5cqNVc9YG814So2ySoFbcV61VX7ZR/UFCQTR5hTacGIyMj+eijjzAajZw9exaoSBewDg612xcUFFBYWEijRo1USoBWl/aFF16wKQ2WlpaGXq8nPz8fFxcX2rdvT2hoKHfffbdqARwQEFCpYoDGxcVFbZx77bXXKC8vp6SkBB8fHzXm9OnTHD16lI4dO9KoUSObmrkgq0c3wuDBg6ssTXa9aY0tADp37qyC2ktXTnv37k1CQoK6TWhoKA4ODur62m5gsh5vfZzqXMtcQghxq0lQK25LdnZ2Koi7dKW1puDO19eXiRMnEhsby/Lly4mKirIpYaSlE+Tn5xMbG0t6ejovvPACoaGhODo6UlhYyOLFi1VA6+npyfDhw+nduzd+fn6cPn2ab775hqSkJHbt2oWDg4O6P40bN1ab2rT7rP0bHBzMpk2b8PDwoFGjRjz44IOVgvPMzExmzpxJXl4eHTt2JCoqij59+tSrUla3m5v13GqvJzs7uxrb3t5zzz2qffTWrVvVbW4W67lku4UQoq6RpR9x26vtKcGhQ4cybtw4SkpKePrpp1m7di2nTp0CKtropqamMmfOHBITEzly5AjOzs4qtzU1NZVNmzapY0VHRzN58mTat29Po0aNuPfee5k2bRpbtmwhMTGR8PBwioqKsLOzIyAgQO3U1+6zFhhop4Hz8vJUN61LH5fWmS06Opr9+/cza9YsunXrRnR0NIWFhbV70sRtIzc3l+zsbADuuusuPD091XWlpaU2Yx0dHVUpu+zsbPLy8lQdZfgz5/NKWY8vKSm57PhrmUsIIW41WakV9Y7BYGDMmDE4OjqycuVK4uLiaNGiBe7u7uj1eo4fP47RaMTPz4+pU6fSqVMntaKam5tLamoqUFG3NSoqCvgzhUHrnmYwGGjZsqWqvqAFvAaDwWZl2XoVV6/XYzKZqlwdtFgsNGzYkF69eqnGFL1796Zt27ZcuHABZ2dnqZRQR6Wnp6vLXl5euLi4YDAYKCsrw2KxUFhYaJPL6uXlxZkzZ4CKtBfrNICqGl7UpGHDhurylXwxupa5hBDiVpOgVtRLHh4exMTEMGLECL766is2btxIVlYWDg4OeHt7M2zYMAYPHkyLFi2AiqBVr9dz/vx5VUc2KCgIHx8ftWELbNMi0tLS2LJlCwA+Pj506NABoFJFBm0Dm8lkokGDBhw/fpx+/fpVGaC++eabrFy5koEDBzJ9+nS8vb2vqT2quPWsN3c5Ozuj0+kIDAxUne+ys7NtcsYv3aylrfIC6vV6pby9vXF2dqawsJC8vDxKS0trrIBwLXMJIcStJkGtqJfKy8vR6XR4enoyatQoRo0aRUFBAbm5uTRr1qzSeK0GrV6vx8HBgZKSEry9vVUpsUtXSS0WC6mpqaSnp6PT6WjevLlqSlBVDqS2k7y0tFS1jtVWf6Gi4cF3333HZ599RmBgIK+++qo6Ta1Ve5BV2rqpqs1aISEhKqjNyMiwCWov3ayVkZGhfq6p8UVVdDodrVu3Zv/+/VgsFjIzM2sMVrW59Hp9jU0ahBDidiQ5taJe0rp4WSwWTCYT5eXluLq60qxZsxo3wPTv318FGDt27ODAgQM2HcG0HMjs7Gy2b98OVKQetGvXjgYNGlQ6thbg+vr6quBUW4nTqiEAbN++ndmzZxMUFMQrr7yCp6enWjEW9U/Pnj3V5UOHDtlcZ/2lyGQyqWYQQUFBqiX09ZrL2tmzZ9VKbZcuXXBycqr1XEIIcStJUCvqNZ1Oh16vtwkUqlvxtFgs2NvbM23aNFq2bInJZGLBggXs2LFDra5qp24///xztaHM29vbJvXg0mNqY/Lz87G3t+fEiRPqftjZ2fHbb7/x1ltvkZuby8svv0zv3r2B27eNrqidqjZrRUREqC831qXjwHazVkZGhvr5oYceuqr5Bw4cqF7/l85lTUuluZa5hBDiVpL0AyH+Py3Y7dGjB/n5+Xz00UccPnyYKVOmEBERQUBAABaLheTkZHbs2KHGBwUF0apVK6D68kt//PEH7u7uXLhwwWbHe3Z2NvPmzSM1NVXNI+oX6w1X2mYtNzc3xowZw3vvvceBAwc4ePAg7du3B2zTFbSzAQ0bNqyynq7RaOS5554jLS2NF198kSeeeKLSmKCgIB555BHWr1/P5s2b+f33323K3EFFKszKlSttxgshRF0jK7VCVGHgwIGsXbuW999/ny5durBv3z4SExNJSkqioKCAu+++W1Us6NixY7Xlj7TA19fXV63MGQwGiouLKS4u5sMPP2THjh2MGDGCcePG3bTHJ24e6xxW641YY8eOVW1oZ8yYoRp3WI9JTk4GKlrsVlWN4LPPPuPAgQNcuHCB+fPnqzMKl3rppZfw8/OjpKSE6dOnVxr3xhtvcPz4cQwGA/Pnz1c55kIIUZfIXy4hLmGxWLBYLOj1evr06UOfPn2wWCykpaXh4+PD+fPnGT58OFDRzCEnJ4dffvmFZs2aVduK1NPTE6PRiE6nIy0tDUdHR95++22++OILIiMjGT9+PDqdrsZuaaJuaty4MU2aNCEnJwej0UhRURFOTk44OTkRHx/PxIkTOXjwIAMGDGDAgAGqEx5UfAGaMWNGtekA1uku2uu2Kp6eniQkJBATE8OePXvUXI6Ojnz//fekpKTg6urKggUL6NSp0/V9AoQQ4iaRT08hLqHlukLFaVmz2YxOp6Nly5a4uLjQtGlTFi5cyODBg9HpdCQkJBAdHW1Tj/RSRqNRpS/Y29uzadMm4uPjCQgIYO7cuapdrgS09VN4eDhQUZXjyJEj6vfe3t6sWrWKuXPn0qpVKzZs2KAC0xYtWrBu3Tqio6OrPe5TTz1F+/btcXNzY+bMmdV+qQJo2bIl69evZ/r06dx1112sWbOGTz/9lIsXLzJmzBi+/PJL+vXrd50esRBC3Hw6i/RCFOKabN++nS1btjBlyhSbYvcai8VCWVkZjz32GMeOHcPZ2Rmz2YyPjw/Tp08nIiLCpryXuHUyMzPp06cPAKGhoSxfvvy6HHfXrl0qJ3bcuHFMnTq1ynFvvPEGCQkJACxbtowHH3zwuswvhBB3AlkWEuIqmM1mTCYTUFEyKTY2tsqAFv7Mqy0oKACgqKiIkpISZs6cSa9evQCpdFCXpaam8vDDD9OtWzc2b95c5ZiuXbsSGhoKwLp169RrwVpBQQHr168HKgJqCWiFEKJ2JKgV4irY29urzTTW9WSrO/FRUFBASEgIULGTfezYsYSHh0u6QT3wwQcfcOLECc6dO0dcXFy14+Li4nB3d8doNDJr1iyb143ZbGbWrFkYjUbc3d1rPI4QQoiqyUYxIa6R9SprdTVwXVxcVL3RYcOG8dxzzwFU6lQmbr7Vq1erVsRa5zeA06dPs3jxYvVzz549ufvuuyvd/tLNWtVp0aIF8fHxvPDCCyQlJXHs2DEiIyMB2LRpE2lpaTRp0oR//vOf0qJWCCGuguTUCnGNtIoFJ06c4NSpU/To0UM1aYCKQGfFihUsXLiQsLAwFixYQOPGjW/hPRbWIiIiyMrKuuy4BQsWEBUVVen3v/76K5MmTeKPP/4gLi7usputcnNzVfOOzMxMAPz8/OjXrx/R0dHy2hBCiKskQa0Q18hkMqHX65k6dSppaWm8//77NG3aVAW7W7duZcKECYSEhPDuu+8SEBBwq++yEEIIUe9I+oEQ10jLrf36668xGAyqsL2dnR3fffcdixYtwsvLi6lTpxIQECC1aIUQQogbQIJaIa6D1NRUGjdujNFo5JVXXqF///6YTCYSEhK4ePEiS5YsUbvfJaAVQgghrj9JPxDiOjl06BDr168nMTGRgoICDAYDwcHB/PWvf2XgwIGyKUwIIYS4gSSoFeIGSE5Opri4mLZt2+Lm5nar744QQghR70lQK8R1Ul5ertrgCiGEEOLmkqBWiBtAUg2EEEKIm0t2rAhxA0hAK4QQQtxcEtQKIYQQQog6T4JaIYQQQghR50lQK4QQQggh6jwJaoUQQgghRJ0nQa0QQgghhKjzJKgVQgghhBB1ngS1QgghhBCizpOgVgghhBBC1HkS1AohhBBCiDpPglohhBBCCFHn/T82EArRq6O5QQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1152x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "from matplotlib.ticker import LinearLocator\n",
    "import numpy as np\n",
    "\n",
    "fig, ax = plt.subplots(subplot_kw={\"projection\": \"3d\"})\n",
    "set_style()\n",
    "\n",
    "#x = np.linspace(-4*np.pi,4*np.pi,50)\n",
    "#y = np.linspace(-4*np.pi,4*np.pi,50)\n",
    "# = x**2 + y**2\n",
    "\n",
    "# Plot the surface.\n",
    "surf = ax.plot_trisurf(x, y, z,  cmap='rocket_r',)\n",
    "\n",
    "# Customize the z axis.\n",
    "ax.set_zlim(0, 1.2)\n",
    "ax.set_xlim(0, 1.0)\n",
    "ax.set_ylim(0, 1.0)\n",
    "\n",
    "ax.zaxis.set_major_locator(LinearLocator(10))\n",
    "# A StrMethodFormatter is used automatically\n",
    "ax.zaxis.set_major_formatter('{x:.1f}')\n",
    "# Add a color bar which maps values to colors.\n",
    "fig.colorbar(surf,shrink=0.65, aspect=10)\n",
    "#ax.view_init(30, 30)\n",
    "\n",
    "\n",
    "# Set label for x-axis \n",
    "ax.set_xlabel( \"\\n\" +  \"$\\\\alpha$ decay\", linespacing=2) \n",
    "# Set label for y-axis \n",
    "ax.set_ylabel( \"\\n\" +  \"$\\\\beta$ decay\", linespacing=2) \n",
    "ax.yaxis.set_label_coords(.9, .1)\n",
    "ax.set_zlabel( \"\\n\" +  \"Attacker's Gain\", linespacing=2) \n",
    "# plt.savefig('alpha_beta_cumm.pdf', dpi=500, bbox_inches='tight');\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "      <th>mad</th>\n",
       "      <th>sad</th>\n",
       "      <th>mrd</th>\n",
       "      <th>srd</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.100</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000512</td>\n",
       "      <td>0.230577</td>\n",
       "      <td>0.435532</td>\n",
       "      <td>195.989365</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.100</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.2</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000607</td>\n",
       "      <td>0.272988</td>\n",
       "      <td>0.470253</td>\n",
       "      <td>211.614055</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.100</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.4</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000710</td>\n",
       "      <td>0.319713</td>\n",
       "      <td>0.511783</td>\n",
       "      <td>230.302395</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.100</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.6</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000724</td>\n",
       "      <td>0.325731</td>\n",
       "      <td>0.545808</td>\n",
       "      <td>245.613661</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.100</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.8</td>\n",
       "      <td>pht</td>\n",
       "      <td>0.000791</td>\n",
       "      <td>0.355983</td>\n",
       "      <td>0.599234</td>\n",
       "      <td>269.655307</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>499</th>\n",
       "      <td>0.001</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.4</td>\n",
       "      <td>ppr</td>\n",
       "      <td>0.000157</td>\n",
       "      <td>0.072809</td>\n",
       "      <td>0.280344</td>\n",
       "      <td>129.799138</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>500</th>\n",
       "      <td>0.001</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.6</td>\n",
       "      <td>ppr</td>\n",
       "      <td>0.000269</td>\n",
       "      <td>0.124699</td>\n",
       "      <td>0.360836</td>\n",
       "      <td>167.067285</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>501</th>\n",
       "      <td>0.001</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.8</td>\n",
       "      <td>ppr</td>\n",
       "      <td>0.000356</td>\n",
       "      <td>0.164956</td>\n",
       "      <td>0.487227</td>\n",
       "      <td>225.586283</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>502</th>\n",
       "      <td>0.001</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.9</td>\n",
       "      <td>ppr</td>\n",
       "      <td>0.000396</td>\n",
       "      <td>0.183292</td>\n",
       "      <td>0.532032</td>\n",
       "      <td>246.330946</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>503</th>\n",
       "      <td>0.001</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>ppr</td>\n",
       "      <td>0.000429</td>\n",
       "      <td>0.198602</td>\n",
       "      <td>0.576151</td>\n",
       "      <td>266.757701</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>504 rows × 8 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     alpha  theta  gamma rep_alg       mad       sad       mrd         srd\n",
       "0    0.100    0.0    0.0     pht  0.000512  0.230577  0.435532  195.989365\n",
       "1    0.100    0.0    0.2     pht  0.000607  0.272988  0.470253  211.614055\n",
       "2    0.100    0.0    0.4     pht  0.000710  0.319713  0.511783  230.302395\n",
       "3    0.100    0.0    0.6     pht  0.000724  0.325731  0.545808  245.613661\n",
       "4    0.100    0.0    0.8     pht  0.000791  0.355983  0.599234  269.655307\n",
       "..     ...    ...    ...     ...       ...       ...       ...         ...\n",
       "499  0.001    0.0    0.4     ppr  0.000157  0.072809  0.280344  129.799138\n",
       "500  0.001    0.0    0.6     ppr  0.000269  0.124699  0.360836  167.067285\n",
       "501  0.001    0.0    0.8     ppr  0.000356  0.164956  0.487227  225.586283\n",
       "502  0.001    0.0    0.9     ppr  0.000396  0.183292  0.532032  246.330946\n",
       "503  0.001    0.0    1.0     ppr  0.000429  0.198602  0.576151  266.757701\n",
       "\n",
       "[504 rows x 8 columns]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('informativeness.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "gtv_real_copy = ground_truth_values.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "gtv_norm_copy = {}\n",
    "gtv_norm_copy['pht'] = normalize(ground_truth_values['pht'])\n",
    "gtv_norm_copy['ppr'] = normalize(ground_truth_values['ppr'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "gtv_real = {}\n",
    "gtv_norm = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "gtv_real[theta] = ground_truth_values.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "gtv_norm[theta] = {}\n",
    "for r in ['pht', 'ppr']:\n",
    "    gtv_norm[theta][r] = normalize(ground_truth_values[r])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.19156431970009868 1.0 84.47986498774353\n"
     ]
    }
   ],
   "source": [
    "vals = []\n",
    "\n",
    "for k,v in gtv_norm[0.0]['pht'].items():\n",
    "    vals.append(abs(v - n_vals.get(k, 0)) / max(v, n_vals.get(k, 0)))\n",
    "print(np.mean(vals), np.max(vals), np.sum(vals))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mKeyError\u001B[0m                                  Traceback (most recent call last)",
      "\u001B[0;32m/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_21244/442999938.py\u001B[0m in \u001B[0;36m<module>\u001B[0;34m\u001B[0m\n\u001B[0;32m----> 1\u001B[0;31m \u001B[0mground_truth_values\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0;34m'pht'\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0;36m0\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m",
      "\u001B[0;31mKeyError\u001B[0m: 0"
     ]
    }
   ],
   "source": [
    "ground_truth_values['pht'][140799]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.613099483786722"
      ]
     },
     "execution_count": 261,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gtv_real[0.0]['pht'][140799]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.613099483786722"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gtv_real[0.0]['pht'][140799]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.18891320372082e-06"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Total time\n",
    "end_w = 50\n",
    "eps = 10**(-6)\n",
    "\n",
    "num_seed_connections = 10\n",
    "\n",
    "for rep_alg in ['pht', 'ppr']:    \n",
    "    for theta in [1.0]:\n",
    "        for gamma in [1.0]:\n",
    "            for decay_p in [1.0]:\n",
    "                # 0. Select initial seeds: Boostrap Period\n",
    "                G = G_t[0].copy()\n",
    "                score  = {i: G.in_degree(i, weight='weight') for i in G.nodes()}\n",
    "                for k,v in score.items():\n",
    "                    G.add_edge(0, k, weight=v)\n",
    "                # Reputation and Data Values\n",
    "                seed_node = 0\n",
    "                rep_vals = defaultdict(float)\n",
    "                gains = []\n",
    "                for w in range(end_w):\n",
    "                    # Calculate the reputation with all decays \n",
    "                    rep_alg_func = alg_func[rep_alg]\n",
    "                    rep_alg_func(G, seed_node, rep_vals, decay_p, theta, gamma)\n",
    "                    # Calculate gain\n",
    "                    score = {k:v for k,v in rep_vals.items() if v > eps}\n",
    "                    # Epoch decay on weights\n",
    "                    for u,v in G.edges():\n",
    "                        G[u][v]['weight'] *= theta\n",
    "                        if G[u][v]['weight'] < cut_eps:\n",
    "                            G.remove_edge(u, v)\n",
    "                    # Add new edges to the graph\n",
    "                    for f,t,data in G_t[w].edges(data=True):\n",
    "                        if (f,t) in G.edges():\n",
    "                            G[f][t]['weight'] += data['weight']\n",
    "                        else:\n",
    "                            G.add_edge(f, t, weight=data['weight'])\n",
    "                    # Update the seed connections \n",
    "                    selected_seed_connections = sorted(score.items(), key=lambda x: x[1], reverse=True)[:num_seed_connections]\n",
    "                    for k,v in selected_seed_connections:\n",
    "                        G.add_edge(0, k, weight=10)                        \n",
    "                i_25 = int(len(gains) * 0.25)\n",
    "                i_50 = int(len(gains) * 0.5)\n",
    "                i_75 = int(len(gains) * 0.75)\n",
    "                i_100 = int(len(gains) - 1)\n",
    "                df2 = df2.append({'num_syb': num_syb, \n",
    "                        'gain_0':  gains[0], \n",
    "                        'gain_25': gains[i_25], \n",
    "                        'gain_50': gains[i_50], \n",
    "                        'gain_75': gains[i_75],\n",
    "                        'gain_100': gains[i_100], \n",
    "                        'alpha': (1-decay_p),\n",
    "                        'theta': theta,\n",
    "                        'gamma': gamma,\n",
    "                        'rep_alg': rep_alg,\n",
    "                        }, ignore_index=True)\n",
    "                print('Finished with {}'.format(decay_p))\n",
    "            print('Finished with {}'.format(gamma))\n",
    "        print('Finished with {}'.format(theta))\n",
    "    \n",
    "# Epoch Decay: theta\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('full_exper_2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>88</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.052579</td>\n",
       "      <td>0.378252</td>\n",
       "      <td>0.520527</td>\n",
       "      <td>0.609404</td>\n",
       "      <td>0.627821</td>\n",
       "      <td>0.80</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>89</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.396889</td>\n",
       "      <td>6.043617</td>\n",
       "      <td>7.352099</td>\n",
       "      <td>7.540415</td>\n",
       "      <td>7.472467</td>\n",
       "      <td>0.80</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>90</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.077451</td>\n",
       "      <td>0.427042</td>\n",
       "      <td>0.612517</td>\n",
       "      <td>0.728879</td>\n",
       "      <td>0.773798</td>\n",
       "      <td>0.60</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>91</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.900741</td>\n",
       "      <td>8.230935</td>\n",
       "      <td>10.819074</td>\n",
       "      <td>11.534682</td>\n",
       "      <td>11.734204</td>\n",
       "      <td>0.60</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>92</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.109868</td>\n",
       "      <td>0.520324</td>\n",
       "      <td>0.755434</td>\n",
       "      <td>0.910008</td>\n",
       "      <td>0.988665</td>\n",
       "      <td>0.40</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>93</th>\n",
       "      <td>50.0</td>\n",
       "      <td>1.575998</td>\n",
       "      <td>11.075830</td>\n",
       "      <td>14.638651</td>\n",
       "      <td>15.616195</td>\n",
       "      <td>16.008877</td>\n",
       "      <td>0.40</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>94</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.129515</td>\n",
       "      <td>0.578173</td>\n",
       "      <td>0.867810</td>\n",
       "      <td>1.057427</td>\n",
       "      <td>1.170205</td>\n",
       "      <td>0.20</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>50.0</td>\n",
       "      <td>2.454199</td>\n",
       "      <td>13.898528</td>\n",
       "      <td>18.388047</td>\n",
       "      <td>19.616141</td>\n",
       "      <td>20.207282</td>\n",
       "      <td>0.20</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.138601</td>\n",
       "      <td>0.616522</td>\n",
       "      <td>0.930998</td>\n",
       "      <td>1.137840</td>\n",
       "      <td>1.274988</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>97</th>\n",
       "      <td>50.0</td>\n",
       "      <td>2.835891</td>\n",
       "      <td>15.428279</td>\n",
       "      <td>20.843700</td>\n",
       "      <td>22.379600</td>\n",
       "      <td>23.141415</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pmf</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>184</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.004771</td>\n",
       "      <td>0.015100</td>\n",
       "      <td>0.018298</td>\n",
       "      <td>0.021415</td>\n",
       "      <td>0.021226</td>\n",
       "      <td>0.80</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>185</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.013991</td>\n",
       "      <td>0.056551</td>\n",
       "      <td>0.090023</td>\n",
       "      <td>0.094710</td>\n",
       "      <td>0.102271</td>\n",
       "      <td>0.80</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>186</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.026709</td>\n",
       "      <td>0.106978</td>\n",
       "      <td>0.132798</td>\n",
       "      <td>0.128842</td>\n",
       "      <td>0.124068</td>\n",
       "      <td>0.20</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>187</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.152151</td>\n",
       "      <td>0.861469</td>\n",
       "      <td>1.203291</td>\n",
       "      <td>1.374353</td>\n",
       "      <td>1.457669</td>\n",
       "      <td>0.20</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>192</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.002143</td>\n",
       "      <td>0.019302</td>\n",
       "      <td>0.015830</td>\n",
       "      <td>0.016029</td>\n",
       "      <td>0.019392</td>\n",
       "      <td>0.80</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>193</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.007344</td>\n",
       "      <td>0.055188</td>\n",
       "      <td>0.076348</td>\n",
       "      <td>0.088501</td>\n",
       "      <td>0.099081</td>\n",
       "      <td>0.80</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>194</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.020776</td>\n",
       "      <td>0.096842</td>\n",
       "      <td>0.115710</td>\n",
       "      <td>0.114311</td>\n",
       "      <td>0.109013</td>\n",
       "      <td>0.20</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>195</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.130082</td>\n",
       "      <td>0.652663</td>\n",
       "      <td>0.835341</td>\n",
       "      <td>0.898541</td>\n",
       "      <td>0.927403</td>\n",
       "      <td>0.20</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     num_syb    gain_0    gain_25    gain_50    gain_75   gain_100  alpha  \\\n",
       "88       1.0  0.052579   0.378252   0.520527   0.609404   0.627821   0.80   \n",
       "89      50.0  0.396889   6.043617   7.352099   7.540415   7.472467   0.80   \n",
       "90       1.0  0.077451   0.427042   0.612517   0.728879   0.773798   0.60   \n",
       "91      50.0  0.900741   8.230935  10.819074  11.534682  11.734204   0.60   \n",
       "92       1.0  0.109868   0.520324   0.755434   0.910008   0.988665   0.40   \n",
       "93      50.0  1.575998  11.075830  14.638651  15.616195  16.008877   0.40   \n",
       "94       1.0  0.129515   0.578173   0.867810   1.057427   1.170205   0.20   \n",
       "95      50.0  2.454199  13.898528  18.388047  19.616141  20.207282   0.20   \n",
       "96       1.0  0.138601   0.616522   0.930998   1.137840   1.274988   0.05   \n",
       "97      50.0  2.835891  15.428279  20.843700  22.379600  23.141415   0.05   \n",
       "184      1.0  0.004771   0.015100   0.018298   0.021415   0.021226   0.80   \n",
       "185     50.0  0.013991   0.056551   0.090023   0.094710   0.102271   0.80   \n",
       "186      1.0  0.026709   0.106978   0.132798   0.128842   0.124068   0.20   \n",
       "187     50.0  0.152151   0.861469   1.203291   1.374353   1.457669   0.20   \n",
       "192      1.0  0.002143   0.019302   0.015830   0.016029   0.019392   0.80   \n",
       "193     50.0  0.007344   0.055188   0.076348   0.088501   0.099081   0.80   \n",
       "194      1.0  0.020776   0.096842   0.115710   0.114311   0.109013   0.20   \n",
       "195     50.0  0.130082   0.652663   0.835341   0.898541   0.927403   0.20   \n",
       "\n",
       "     theta  gamma rep_alg  \n",
       "88     1.0    1.0     pmf  \n",
       "89     1.0    1.0     pmf  \n",
       "90     1.0    1.0     pmf  \n",
       "91     1.0    1.0     pmf  \n",
       "92     1.0    1.0     pmf  \n",
       "93     1.0    1.0     pmf  \n",
       "94     1.0    1.0     pmf  \n",
       "95     1.0    1.0     pmf  \n",
       "96     1.0    1.0     pmf  \n",
       "97     1.0    1.0     pmf  \n",
       "184    1.0    1.0     pht  \n",
       "185    1.0    1.0     pht  \n",
       "186    1.0    1.0     pht  \n",
       "187    1.0    1.0     pht  \n",
       "192    1.0    1.0     ppr  \n",
       "193    1.0    1.0     ppr  \n",
       "194    1.0    1.0     ppr  \n",
       "195    1.0    1.0     ppr  "
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2[(df2['theta'] == 1.) & (df2['gamma'] == 1.)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>104</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.010198</td>\n",
       "      <td>0.043608</td>\n",
       "      <td>0.058779</td>\n",
       "      <td>0.062329</td>\n",
       "      <td>0.061096</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.75</td>\n",
       "      <td>1.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>105</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.015330</td>\n",
       "      <td>0.070110</td>\n",
       "      <td>0.098830</td>\n",
       "      <td>0.121712</td>\n",
       "      <td>0.138980</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.75</td>\n",
       "      <td>1.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>106</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.074996</td>\n",
       "      <td>0.302736</td>\n",
       "      <td>0.377197</td>\n",
       "      <td>0.392703</td>\n",
       "      <td>0.387458</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>1.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>107</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.207407</td>\n",
       "      <td>1.096353</td>\n",
       "      <td>1.414371</td>\n",
       "      <td>1.586952</td>\n",
       "      <td>1.700385</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>1.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>108</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000022</td>\n",
       "      <td>0.000249</td>\n",
       "      <td>0.000477</td>\n",
       "      <td>0.000581</td>\n",
       "      <td>0.000581</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>109</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000093</td>\n",
       "      <td>0.000863</td>\n",
       "      <td>0.001195</td>\n",
       "      <td>0.001229</td>\n",
       "      <td>0.001339</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>110</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000711</td>\n",
       "      <td>0.002778</td>\n",
       "      <td>0.003522</td>\n",
       "      <td>0.003658</td>\n",
       "      <td>0.003651</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>111</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.001981</td>\n",
       "      <td>0.009351</td>\n",
       "      <td>0.012061</td>\n",
       "      <td>0.013439</td>\n",
       "      <td>0.014338</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>144</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.002202</td>\n",
       "      <td>0.036736</td>\n",
       "      <td>0.052788</td>\n",
       "      <td>0.057303</td>\n",
       "      <td>0.057419</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.75</td>\n",
       "      <td>1.00</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.010881</td>\n",
       "      <td>0.067490</td>\n",
       "      <td>0.100125</td>\n",
       "      <td>0.116574</td>\n",
       "      <td>0.128242</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.75</td>\n",
       "      <td>1.00</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.074231</td>\n",
       "      <td>0.277897</td>\n",
       "      <td>0.356801</td>\n",
       "      <td>0.369383</td>\n",
       "      <td>0.361764</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>1.00</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.166796</td>\n",
       "      <td>0.738620</td>\n",
       "      <td>0.887312</td>\n",
       "      <td>0.963993</td>\n",
       "      <td>1.007651</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>1.00</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000239</td>\n",
       "      <td>0.000415</td>\n",
       "      <td>0.000433</td>\n",
       "      <td>0.000432</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000067</td>\n",
       "      <td>0.000577</td>\n",
       "      <td>0.000849</td>\n",
       "      <td>0.001089</td>\n",
       "      <td>0.001222</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>150</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000772</td>\n",
       "      <td>0.002712</td>\n",
       "      <td>0.003348</td>\n",
       "      <td>0.003426</td>\n",
       "      <td>0.003391</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>151</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.001556</td>\n",
       "      <td>0.006193</td>\n",
       "      <td>0.007508</td>\n",
       "      <td>0.008128</td>\n",
       "      <td>0.008480</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     num_syb    gain_0   gain_25   gain_50   gain_75  gain_100  alpha  theta  \\\n",
       "104      1.0  0.010198  0.043608  0.058779  0.062329  0.061096    0.8   0.75   \n",
       "105     50.0  0.015330  0.070110  0.098830  0.121712  0.138980    0.8   0.75   \n",
       "106      1.0  0.074996  0.302736  0.377197  0.392703  0.387458    0.2   0.75   \n",
       "107     50.0  0.207407  1.096353  1.414371  1.586952  1.700385    0.2   0.75   \n",
       "108      1.0  0.000022  0.000249  0.000477  0.000581  0.000581    0.8   0.75   \n",
       "109     50.0  0.000093  0.000863  0.001195  0.001229  0.001339    0.8   0.75   \n",
       "110      1.0  0.000711  0.002778  0.003522  0.003658  0.003651    0.2   0.75   \n",
       "111     50.0  0.001981  0.009351  0.012061  0.013439  0.014338    0.2   0.75   \n",
       "144      1.0  0.002202  0.036736  0.052788  0.057303  0.057419    0.8   0.75   \n",
       "145     50.0  0.010881  0.067490  0.100125  0.116574  0.128242    0.8   0.75   \n",
       "146      1.0  0.074231  0.277897  0.356801  0.369383  0.361764    0.2   0.75   \n",
       "147     50.0  0.166796  0.738620  0.887312  0.963993  1.007651    0.2   0.75   \n",
       "148      1.0  0.000000  0.000239  0.000415  0.000433  0.000432    0.8   0.75   \n",
       "149     50.0  0.000067  0.000577  0.000849  0.001089  0.001222    0.8   0.75   \n",
       "150      1.0  0.000772  0.002712  0.003348  0.003426  0.003391    0.2   0.75   \n",
       "151     50.0  0.001556  0.006193  0.007508  0.008128  0.008480    0.2   0.75   \n",
       "\n",
       "     gamma rep_alg  \n",
       "104   1.00     pht  \n",
       "105   1.00     pht  \n",
       "106   1.00     pht  \n",
       "107   1.00     pht  \n",
       "108   0.01     pht  \n",
       "109   0.01     pht  \n",
       "110   0.01     pht  \n",
       "111   0.01     pht  \n",
       "144   1.00     ppr  \n",
       "145   1.00     ppr  \n",
       "146   1.00     ppr  \n",
       "147   1.00     ppr  \n",
       "148   0.01     ppr  \n",
       "149   0.01     ppr  \n",
       "150   0.01     ppr  \n",
       "151   0.01     ppr  "
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2[df2['theta'] == 0.75]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "54974.97003203991"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([rewards.get(attacker_node*2+i, 0) for i in range(total_syb)]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.003609</td>\n",
       "      <td>0.039768</td>\n",
       "      <td>0.053297</td>\n",
       "      <td>0.090601</td>\n",
       "      <td>0.115392</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.002510</td>\n",
       "      <td>0.022078</td>\n",
       "      <td>0.033258</td>\n",
       "      <td>0.038025</td>\n",
       "      <td>0.042991</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.010375</td>\n",
       "      <td>0.030755</td>\n",
       "      <td>0.081962</td>\n",
       "      <td>0.123225</td>\n",
       "      <td>0.158039</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.016149</td>\n",
       "      <td>0.051161</td>\n",
       "      <td>0.074125</td>\n",
       "      <td>0.088710</td>\n",
       "      <td>0.114145</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.018034</td>\n",
       "      <td>0.098358</td>\n",
       "      <td>0.178836</td>\n",
       "      <td>0.284550</td>\n",
       "      <td>0.344097</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.030577</td>\n",
       "      <td>0.106475</td>\n",
       "      <td>0.186993</td>\n",
       "      <td>0.249667</td>\n",
       "      <td>0.280013</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.030558</td>\n",
       "      <td>0.301716</td>\n",
       "      <td>0.477844</td>\n",
       "      <td>0.583056</td>\n",
       "      <td>0.656580</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.064645</td>\n",
       "      <td>0.423590</td>\n",
       "      <td>0.751337</td>\n",
       "      <td>1.034387</td>\n",
       "      <td>1.337082</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000986</td>\n",
       "      <td>0.019737</td>\n",
       "      <td>0.017840</td>\n",
       "      <td>0.032036</td>\n",
       "      <td>0.039610</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.004659</td>\n",
       "      <td>0.008062</td>\n",
       "      <td>0.011019</td>\n",
       "      <td>0.013137</td>\n",
       "      <td>0.014477</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.005245</td>\n",
       "      <td>0.065625</td>\n",
       "      <td>0.111346</td>\n",
       "      <td>0.154556</td>\n",
       "      <td>0.192098</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.010217</td>\n",
       "      <td>0.032071</td>\n",
       "      <td>0.043489</td>\n",
       "      <td>0.054661</td>\n",
       "      <td>0.058351</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.009793</td>\n",
       "      <td>0.107210</td>\n",
       "      <td>0.202706</td>\n",
       "      <td>0.270241</td>\n",
       "      <td>0.320088</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.021211</td>\n",
       "      <td>0.053128</td>\n",
       "      <td>0.099466</td>\n",
       "      <td>0.135971</td>\n",
       "      <td>0.156800</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.014154</td>\n",
       "      <td>0.271364</td>\n",
       "      <td>0.478351</td>\n",
       "      <td>0.585841</td>\n",
       "      <td>0.645503</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.035797</td>\n",
       "      <td>0.202899</td>\n",
       "      <td>0.457623</td>\n",
       "      <td>0.655448</td>\n",
       "      <td>0.849751</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000309</td>\n",
       "      <td>0.000867</td>\n",
       "      <td>0.001180</td>\n",
       "      <td>0.001212</td>\n",
       "      <td>0.001149</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000295</td>\n",
       "      <td>0.007747</td>\n",
       "      <td>0.006285</td>\n",
       "      <td>0.005639</td>\n",
       "      <td>0.008231</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000296</td>\n",
       "      <td>0.001350</td>\n",
       "      <td>0.001798</td>\n",
       "      <td>0.016035</td>\n",
       "      <td>0.030574</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.001171</td>\n",
       "      <td>0.002460</td>\n",
       "      <td>0.004060</td>\n",
       "      <td>0.009332</td>\n",
       "      <td>0.009478</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000989</td>\n",
       "      <td>0.002894</td>\n",
       "      <td>0.003500</td>\n",
       "      <td>0.003949</td>\n",
       "      <td>0.010512</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.001690</td>\n",
       "      <td>0.004286</td>\n",
       "      <td>0.005771</td>\n",
       "      <td>0.008221</td>\n",
       "      <td>0.010622</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.001294</td>\n",
       "      <td>0.077629</td>\n",
       "      <td>0.203477</td>\n",
       "      <td>0.280222</td>\n",
       "      <td>0.339086</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.003676</td>\n",
       "      <td>0.009727</td>\n",
       "      <td>0.032153</td>\n",
       "      <td>0.040332</td>\n",
       "      <td>0.072562</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.004270</td>\n",
       "      <td>0.016971</td>\n",
       "      <td>0.020857</td>\n",
       "      <td>0.031075</td>\n",
       "      <td>0.041852</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.002838</td>\n",
       "      <td>0.016103</td>\n",
       "      <td>0.030106</td>\n",
       "      <td>0.042528</td>\n",
       "      <td>0.044608</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.010876</td>\n",
       "      <td>0.047966</td>\n",
       "      <td>0.107308</td>\n",
       "      <td>0.175664</td>\n",
       "      <td>0.211685</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.021653</td>\n",
       "      <td>0.059771</td>\n",
       "      <td>0.077639</td>\n",
       "      <td>0.101866</td>\n",
       "      <td>0.122118</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.020506</td>\n",
       "      <td>0.185651</td>\n",
       "      <td>0.304366</td>\n",
       "      <td>0.388138</td>\n",
       "      <td>0.442040</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.030091</td>\n",
       "      <td>0.112986</td>\n",
       "      <td>0.188668</td>\n",
       "      <td>0.235137</td>\n",
       "      <td>0.283481</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.028551</td>\n",
       "      <td>0.354055</td>\n",
       "      <td>0.503537</td>\n",
       "      <td>0.616164</td>\n",
       "      <td>0.653162</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.054433</td>\n",
       "      <td>0.255146</td>\n",
       "      <td>0.437622</td>\n",
       "      <td>0.577940</td>\n",
       "      <td>0.691673</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.004773</td>\n",
       "      <td>0.006016</td>\n",
       "      <td>0.007447</td>\n",
       "      <td>0.010286</td>\n",
       "      <td>0.016710</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.002872</td>\n",
       "      <td>0.007241</td>\n",
       "      <td>0.010680</td>\n",
       "      <td>0.011428</td>\n",
       "      <td>0.011459</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.004525</td>\n",
       "      <td>0.015664</td>\n",
       "      <td>0.032941</td>\n",
       "      <td>0.055603</td>\n",
       "      <td>0.066164</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.006196</td>\n",
       "      <td>0.020587</td>\n",
       "      <td>0.038420</td>\n",
       "      <td>0.044299</td>\n",
       "      <td>0.048141</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.009306</td>\n",
       "      <td>0.094028</td>\n",
       "      <td>0.240496</td>\n",
       "      <td>0.315008</td>\n",
       "      <td>0.363139</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.016552</td>\n",
       "      <td>0.067882</td>\n",
       "      <td>0.094574</td>\n",
       "      <td>0.125346</td>\n",
       "      <td>0.131126</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.015571</td>\n",
       "      <td>0.291726</td>\n",
       "      <td>0.467176</td>\n",
       "      <td>0.567475</td>\n",
       "      <td>0.619749</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.027978</td>\n",
       "      <td>0.084046</td>\n",
       "      <td>0.193796</td>\n",
       "      <td>0.338347</td>\n",
       "      <td>0.439925</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000194</td>\n",
       "      <td>0.000637</td>\n",
       "      <td>0.001026</td>\n",
       "      <td>0.000991</td>\n",
       "      <td>0.001018</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000653</td>\n",
       "      <td>0.000856</td>\n",
       "      <td>0.001089</td>\n",
       "      <td>0.001274</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000500</td>\n",
       "      <td>0.001549</td>\n",
       "      <td>0.002079</td>\n",
       "      <td>0.014878</td>\n",
       "      <td>0.022636</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000668</td>\n",
       "      <td>0.001868</td>\n",
       "      <td>0.002613</td>\n",
       "      <td>0.002772</td>\n",
       "      <td>0.003105</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000856</td>\n",
       "      <td>0.002717</td>\n",
       "      <td>0.003390</td>\n",
       "      <td>0.035433</td>\n",
       "      <td>0.075592</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.001430</td>\n",
       "      <td>0.004470</td>\n",
       "      <td>0.021058</td>\n",
       "      <td>0.025112</td>\n",
       "      <td>0.031881</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.001455</td>\n",
       "      <td>0.246195</td>\n",
       "      <td>0.350783</td>\n",
       "      <td>0.430824</td>\n",
       "      <td>0.495559</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.002706</td>\n",
       "      <td>0.013186</td>\n",
       "      <td>0.035883</td>\n",
       "      <td>0.052577</td>\n",
       "      <td>0.063318</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    num_syb    gain_0   gain_25   gain_50   gain_75  gain_100  alpha  theta  \\\n",
       "0       1.0  0.003609  0.039768  0.053297  0.090601  0.115392    0.8    1.0   \n",
       "1      50.0  0.002510  0.022078  0.033258  0.038025  0.042991    0.8    1.0   \n",
       "2       1.0  0.010375  0.030755  0.081962  0.123225  0.158039    0.6    1.0   \n",
       "3      50.0  0.016149  0.051161  0.074125  0.088710  0.114145    0.6    1.0   \n",
       "4       1.0  0.018034  0.098358  0.178836  0.284550  0.344097    0.4    1.0   \n",
       "5      50.0  0.030577  0.106475  0.186993  0.249667  0.280013    0.4    1.0   \n",
       "6       1.0  0.030558  0.301716  0.477844  0.583056  0.656580    0.2    1.0   \n",
       "7      50.0  0.064645  0.423590  0.751337  1.034387  1.337082    0.2    1.0   \n",
       "8       1.0  0.000986  0.019737  0.017840  0.032036  0.039610    0.8    1.0   \n",
       "9      50.0  0.004659  0.008062  0.011019  0.013137  0.014477    0.8    1.0   \n",
       "10      1.0  0.005245  0.065625  0.111346  0.154556  0.192098    0.6    1.0   \n",
       "11     50.0  0.010217  0.032071  0.043489  0.054661  0.058351    0.6    1.0   \n",
       "12      1.0  0.009793  0.107210  0.202706  0.270241  0.320088    0.4    1.0   \n",
       "13     50.0  0.021211  0.053128  0.099466  0.135971  0.156800    0.4    1.0   \n",
       "14      1.0  0.014154  0.271364  0.478351  0.585841  0.645503    0.2    1.0   \n",
       "15     50.0  0.035797  0.202899  0.457623  0.655448  0.849751    0.2    1.0   \n",
       "16      1.0  0.000309  0.000867  0.001180  0.001212  0.001149    0.8    1.0   \n",
       "17     50.0  0.000295  0.007747  0.006285  0.005639  0.008231    0.8    1.0   \n",
       "18      1.0  0.000296  0.001350  0.001798  0.016035  0.030574    0.6    1.0   \n",
       "19     50.0  0.001171  0.002460  0.004060  0.009332  0.009478    0.6    1.0   \n",
       "20      1.0  0.000989  0.002894  0.003500  0.003949  0.010512    0.4    1.0   \n",
       "21     50.0  0.001690  0.004286  0.005771  0.008221  0.010622    0.4    1.0   \n",
       "22      1.0  0.001294  0.077629  0.203477  0.280222  0.339086    0.2    1.0   \n",
       "23     50.0  0.003676  0.009727  0.032153  0.040332  0.072562    0.2    1.0   \n",
       "24      1.0  0.004270  0.016971  0.020857  0.031075  0.041852    0.8    1.0   \n",
       "25     50.0  0.002838  0.016103  0.030106  0.042528  0.044608    0.8    1.0   \n",
       "26      1.0  0.010876  0.047966  0.107308  0.175664  0.211685    0.6    1.0   \n",
       "27     50.0  0.021653  0.059771  0.077639  0.101866  0.122118    0.6    1.0   \n",
       "28      1.0  0.020506  0.185651  0.304366  0.388138  0.442040    0.4    1.0   \n",
       "29     50.0  0.030091  0.112986  0.188668  0.235137  0.283481    0.4    1.0   \n",
       "30      1.0  0.028551  0.354055  0.503537  0.616164  0.653162    0.2    1.0   \n",
       "31     50.0  0.054433  0.255146  0.437622  0.577940  0.691673    0.2    1.0   \n",
       "32      1.0  0.004773  0.006016  0.007447  0.010286  0.016710    0.8    1.0   \n",
       "33     50.0  0.002872  0.007241  0.010680  0.011428  0.011459    0.8    1.0   \n",
       "34      1.0  0.004525  0.015664  0.032941  0.055603  0.066164    0.6    1.0   \n",
       "35     50.0  0.006196  0.020587  0.038420  0.044299  0.048141    0.6    1.0   \n",
       "36      1.0  0.009306  0.094028  0.240496  0.315008  0.363139    0.4    1.0   \n",
       "37     50.0  0.016552  0.067882  0.094574  0.125346  0.131126    0.4    1.0   \n",
       "38      1.0  0.015571  0.291726  0.467176  0.567475  0.619749    0.2    1.0   \n",
       "39     50.0  0.027978  0.084046  0.193796  0.338347  0.439925    0.2    1.0   \n",
       "40      1.0  0.000194  0.000637  0.001026  0.000991  0.001018    0.8    1.0   \n",
       "41     50.0  0.000000  0.000653  0.000856  0.001089  0.001274    0.8    1.0   \n",
       "42      1.0  0.000500  0.001549  0.002079  0.014878  0.022636    0.6    1.0   \n",
       "43     50.0  0.000668  0.001868  0.002613  0.002772  0.003105    0.6    1.0   \n",
       "44      1.0  0.000856  0.002717  0.003390  0.035433  0.075592    0.4    1.0   \n",
       "45     50.0  0.001430  0.004470  0.021058  0.025112  0.031881    0.4    1.0   \n",
       "46      1.0  0.001455  0.246195  0.350783  0.430824  0.495559    0.2    1.0   \n",
       "47     50.0  0.002706  0.013186  0.035883  0.052577  0.063318    0.2    1.0   \n",
       "\n",
       "    gamma rep_alg  \n",
       "0    0.20     pht  \n",
       "1    0.20     pht  \n",
       "2    0.20     pht  \n",
       "3    0.20     pht  \n",
       "4    0.20     pht  \n",
       "5    0.20     pht  \n",
       "6    0.20     pht  \n",
       "7    0.20     pht  \n",
       "8    0.10     pht  \n",
       "9    0.10     pht  \n",
       "10   0.10     pht  \n",
       "11   0.10     pht  \n",
       "12   0.10     pht  \n",
       "13   0.10     pht  \n",
       "14   0.10     pht  \n",
       "15   0.10     pht  \n",
       "16   0.01     pht  \n",
       "17   0.01     pht  \n",
       "18   0.01     pht  \n",
       "19   0.01     pht  \n",
       "20   0.01     pht  \n",
       "21   0.01     pht  \n",
       "22   0.01     pht  \n",
       "23   0.01     pht  \n",
       "24   0.20     ppr  \n",
       "25   0.20     ppr  \n",
       "26   0.20     ppr  \n",
       "27   0.20     ppr  \n",
       "28   0.20     ppr  \n",
       "29   0.20     ppr  \n",
       "30   0.20     ppr  \n",
       "31   0.20     ppr  \n",
       "32   0.10     ppr  \n",
       "33   0.10     ppr  \n",
       "34   0.10     ppr  \n",
       "35   0.10     ppr  \n",
       "36   0.10     ppr  \n",
       "37   0.10     ppr  \n",
       "38   0.10     ppr  \n",
       "39   0.10     ppr  \n",
       "40   0.01     ppr  \n",
       "41   0.01     ppr  \n",
       "42   0.01     ppr  \n",
       "43   0.01     ppr  \n",
       "44   0.01     ppr  \n",
       "45   0.01     ppr  \n",
       "46   0.01     ppr  \n",
       "47   0.01     ppr  "
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('exp_with_fixed_gamma.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(140799, 8593.663704755954),\n",
       " (141429, 3234.631734859039),\n",
       " (142117, 2680.9617993889565),\n",
       " (141627, 1892.289091445653),\n",
       " (140820, 1860.343326164415),\n",
       " (142079, 1478.429602838717),\n",
       " (141701, 1407.1004451020906),\n",
       " (140397, 1364.179034994765),\n",
       " (141798, 1351.0849957600253),\n",
       " (140557, 1224.89251342836),\n",
       " (140869, 1175.6332912286753),\n",
       " (140957, 1136.740297967511),\n",
       " (141586, 997.1761924626345),\n",
       " (142258, 992.2030872657327),\n",
       " (142141, 991.4645430054493),\n",
       " (141821, 911.9485645210559),\n",
       " (140433, 784.2130263226934),\n",
       " (140904, 724.1975341270587),\n",
       " (140571, 677.2060820320085),\n",
       " (140860, 649.611841639523),\n",
       " (141957, 581.6054198651958),\n",
       " (140401, 559.7002255902074),\n",
       " (141648, 559.2699978812577),\n",
       " (142271, 475.546900335661),\n",
       " (142377, 406.62256631776825),\n",
       " (141043, 357.0011091615008),\n",
       " (142238, 342.8102213991092),\n",
       " (141389, 327.3099938601355),\n",
       " (141362, 326.7519360243608),\n",
       " (140836, 322.0885170082688),\n",
       " (140514, 310.886682924666),\n",
       " (141945, 307.50772422182),\n",
       " (142378, 305.30328066677305),\n",
       " (141291, 295.6439760347054),\n",
       " (141940, 254.20276055941514),\n",
       " (141289, 250.2710143436306),\n",
       " (141174, 231.71202152914972),\n",
       " (142078, 231.22935957176102),\n",
       " (142050, 228.97534636642374),\n",
       " (140773, 228.2139136789588),\n",
       " (141747, 226.5346673962498),\n",
       " (142368, 225.9181074153052),\n",
       " (141231, 225.33278742219142),\n",
       " (141008, 218.22587423392417),\n",
       " (141735, 214.82594882135308),\n",
       " (141121, 211.6747335132045),\n",
       " (140709, 207.60679649112362),\n",
       " (140714, 206.0688122265325),\n",
       " (141801, 200.47739809977847),\n",
       " (141086, 189.8091838091498),\n",
       " (141280, 183.73002866034201),\n",
       " (141824, 177.0330177897087),\n",
       " (141204, 151.36831107956877),\n",
       " (140933, 149.63183652178714),\n",
       " (142231, 149.03237801905402),\n",
       " (140494, 144.34778088739006),\n",
       " (140554, 143.6682404695197),\n",
       " (141324, 142.44881477545346),\n",
       " (141519, 140.37449354405072),\n",
       " (140465, 138.7248364870707),\n",
       " (141448, 131.69185119343786),\n",
       " (142150, 128.78676956017583),\n",
       " (140408, 127.60060297701213),\n",
       " (140968, 121.79914478897295),\n",
       " (141563, 121.76737538876039),\n",
       " (141909, 120.43999507349518),\n",
       " (140513, 119.3315358484376),\n",
       " (141525, 118.6353264538712),\n",
       " (140614, 116.79149600367413),\n",
       " (140587, 113.11210425641572),\n",
       " (141073, 112.99500848691639),\n",
       " (140993, 111.69255009006616),\n",
       " (141722, 110.90358004187689),\n",
       " (140719, 110.50759651937351),\n",
       " (142390, 101.14611413277149),\n",
       " (142062, 98.17004477474525),\n",
       " (140916, 97.97433079676783),\n",
       " (142033, 85.58730336607991),\n",
       " (141920, 84.92398988270779),\n",
       " (140454, 83.27853273318247),\n",
       " (141229, 75.31117403624542),\n",
       " (141911, 73.46889244576762),\n",
       " (140752, 71.58466902825666),\n",
       " (141876, 70.04922887886906),\n",
       " (141269, 68.3025014957035),\n",
       " (141098, 67.94444021971768),\n",
       " (141005, 64.1998122705307),\n",
       " (142280, 56.96226019130855),\n",
       " (140621, 53.34180406945069),\n",
       " (141038, 51.67642370651508),\n",
       " (141654, 50.30972387266557),\n",
       " (140569, 50.297027602501295),\n",
       " (142212, 47.13167099830279),\n",
       " (140686, 44.80561598141381),\n",
       " (142138, 44.790202068187384),\n",
       " (141203, 44.183912945789096),\n",
       " (141020, 43.86225827578086),\n",
       " (142181, 40.469699286324584),\n",
       " (141453, 40.258892973137975),\n",
       " (142278, 39.19928992676397),\n",
       " (142242, 38.940065472657935),\n",
       " (140606, 38.6871288821838),\n",
       " (141176, 38.011072723138575),\n",
       " (141993, 37.710770551052725),\n",
       " (140716, 37.25549112379222),\n",
       " (141539, 35.0074420715658),\n",
       " (140786, 33.633998202155404),\n",
       " (140934, 33.417362171968165),\n",
       " (142262, 32.67345174921902),\n",
       " (140482, 31.919584961661045),\n",
       " (141113, 31.497045784782028),\n",
       " (141367, 30.842709374924084),\n",
       " (141931, 30.808649358899892),\n",
       " (140495, 30.70868323727391),\n",
       " (142081, 29.740451957858532),\n",
       " (141154, 29.005215069795895),\n",
       " (141147, 28.97367521378376),\n",
       " (140703, 28.92019276657399),\n",
       " (142037, 28.262098973780468),\n",
       " (141638, 27.99184021163058),\n",
       " (140502, 27.209863996232517),\n",
       " (141573, 27.004164951221753),\n",
       " (141499, 26.90421492175142),\n",
       " (140823, 26.34310769099257),\n",
       " (142335, 26.299482423220542),\n",
       " (140864, 26.136179065901356),\n",
       " (142176, 26.047908111158304),\n",
       " (140570, 25.628764465192482),\n",
       " (141520, 25.482509063270548),\n",
       " (141355, 23.740427648779942),\n",
       " (140760, 22.828245491930346),\n",
       " (141616, 22.827865670906665),\n",
       " (141466, 22.19601316788575),\n",
       " (141927, 21.993827229208083),\n",
       " (141424, 21.947966367860737),\n",
       " (140396, 21.495619684047604),\n",
       " (140902, 21.15244400535026),\n",
       " (141849, 20.506713010803793),\n",
       " (142371, 20.252974071688477),\n",
       " (140986, 20.158104550910657),\n",
       " (142263, 19.882394435049044),\n",
       " (141169, 19.777981800992528),\n",
       " (141858, 19.31171212162287),\n",
       " (141047, 19.165057070369137),\n",
       " (141168, 19.072003791960107),\n",
       " (142112, 18.720484859684078),\n",
       " (140385, 18.456463978022427),\n",
       " (141983, 17.818406041820932),\n",
       " (140685, 17.818338320535485),\n",
       " (141607, 17.38330322075122),\n",
       " (140402, 17.29261121747529),\n",
       " (141090, 16.684924997916045),\n",
       " (141202, 16.653782792232764),\n",
       " (140404, 16.514152183696478),\n",
       " (142180, 16.260772256583977),\n",
       " (142084, 16.069714051205175),\n",
       " (141647, 15.609035422408219),\n",
       " (140892, 15.59858309738874),\n",
       " (140576, 14.958032077120462),\n",
       " (141895, 14.917350925608305),\n",
       " (142060, 14.518065617702138),\n",
       " (141237, 14.412730443776578),\n",
       " (141642, 14.309834800762152),\n",
       " (140687, 13.95578413563528),\n",
       " (141236, 13.85839381272434),\n",
       " (140840, 13.559907386570115),\n",
       " (140516, 12.958450391951985),\n",
       " (141966, 12.720158433866628),\n",
       " (140943, 12.609742309744927),\n",
       " (141220, 12.60462105736033),\n",
       " (141390, 12.028944163473774),\n",
       " (141096, 11.827449981228888),\n",
       " (141283, 11.812567316348238),\n",
       " (141130, 11.792748644057884),\n",
       " (141928, 11.721101341071257),\n",
       " (141212, 11.65034577897508),\n",
       " (142024, 11.629955329064883),\n",
       " (141253, 11.62708669891059),\n",
       " (141568, 11.611639562204635),\n",
       " (140539, 11.456175700827844),\n",
       " (142382, 11.01257340752328),\n",
       " (141326, 10.780377373882983),\n",
       " (140559, 10.4880269269146),\n",
       " (142299, 10.380204381729026),\n",
       " (141995, 9.83525530417433),\n",
       " (142329, 9.35172474631427),\n",
       " (141166, 9.21997432884071),\n",
       " (142211, 9.088921682201413),\n",
       " (140859, 9.07770570885344),\n",
       " (140789, 8.917246672606316),\n",
       " (140706, 8.142510892710066),\n",
       " (140671, 7.970079498285379),\n",
       " (140830, 7.5811713643214045),\n",
       " (141019, 6.592671978913288),\n",
       " (140972, 6.534606283984491),\n",
       " (141475, 6.279257156423399),\n",
       " (141435, 5.830663989098531),\n",
       " (141003, 5.812356210285437),\n",
       " (142043, 5.696386648154061),\n",
       " (142189, 5.385237354283102),\n",
       " (142414, 5.3713027180404795),\n",
       " (141904, 5.370249335412191),\n",
       " (142269, 5.362789327504318),\n",
       " (141288, 5.077504948415148),\n",
       " (141198, 4.956831024263516),\n",
       " (142097, 4.925100178563979),\n",
       " (141871, 4.797405411063696),\n",
       " (141000, 4.777472050788842),\n",
       " (142392, 4.728653366154347),\n",
       " (141114, 4.544970725378797),\n",
       " (141576, 4.508407598957682),\n",
       " (141215, 4.237311592159233),\n",
       " (141049, 3.924016433140947),\n",
       " (141246, 3.727591191428566),\n",
       " (141754, 3.583814509052735),\n",
       " (141619, 3.2919188103190553),\n",
       " (141954, 3.286344292242452),\n",
       " (142145, 3.216628720701718),\n",
       " (141751, 3.16186058588238),\n",
       " (142317, 3.1597459986222045),\n",
       " (140512, 2.830559268232112),\n",
       " (140912, 2.556791276403941),\n",
       " (141879, 2.5448713760951622),\n",
       " (140473, 2.4641271990569025),\n",
       " (140999, 1.7842612806864344),\n",
       " (141050, 1.7834334052813998),\n",
       " (141892, 1.7105280429598582),\n",
       " (140953, 1.7067298984057362),\n",
       " (142241, 1.7044258449823735),\n",
       " (140846, 1.6435618686512299),\n",
       " (140945, 1.6355448251813163),\n",
       " (141175, 1.6355448251813163),\n",
       " (282858, 0.8718731808747908),\n",
       " (282859, 0.504854377900022),\n",
       " (282860, 0.29233318022644117),\n",
       " (282861, 0.16761374530513326),\n",
       " (282862, 0.10346851443133881),\n",
       " (282863, 0.059070957066844655),\n",
       " (141398, 0.052424127508878135),\n",
       " (140897, 0.028225043308799755),\n",
       " (282864, 0.02713316011726012),\n",
       " (141882, 0.01829289968724761),\n",
       " (141622, 0.013275833957495622),\n",
       " (142356, 0.013235410914337277),\n",
       " (142364, 0.013162737244521966),\n",
       " (141991, 0.012049240507643217),\n",
       " (282865, 0.009691132884301408),\n",
       " (140461, 0.00964024840956347),\n",
       " (140627, 0.009222724520820565),\n",
       " (142144, 0.008758087984549103),\n",
       " (142217, 0.007382133947103745),\n",
       " (141478, 0.00659553971192302),\n",
       " (140541, 0.006400137758022587),\n",
       " (141443, 0.006268668961197297),\n",
       " (142339, 0.006264068755786962),\n",
       " (140718, 0.0060905736448165744),\n",
       " (140738, 0.005907830800196714),\n",
       " (142220, 0.0058806714201332655),\n",
       " (142325, 0.005623478238912024),\n",
       " (282866, 0.005576137726372877),\n",
       " (141874, 0.005554328423606284),\n",
       " (142147, 0.0052750544598090835),\n",
       " (141724, 0.00501322740638715),\n",
       " (142196, 0.0048474030148785655),\n",
       " (141161, 0.00469761619692424),\n",
       " (140692, 0.004668320809700444),\n",
       " (141377, 0.004647485033868646),\n",
       " (141411, 0.004518576834788563),\n",
       " (142216, 0.003986753647478081),\n",
       " (141461, 0.003977020218020155),\n",
       " (142118, 0.0038672286343718713),\n",
       " (141910, 0.0037866523435751333),\n",
       " (140937, 0.003692399190921894),\n",
       " (141697, 0.003675626565619725),\n",
       " (140903, 0.0036632313092626106),\n",
       " (141230, 0.0036621548481673045),\n",
       " (140427, 0.0036585781731529985),\n",
       " (141710, 0.0034511952386123076),\n",
       " (141582, 0.003430815129966604),\n",
       " (141467, 0.003246799547970078),\n",
       " (141213, 0.0031173852514539313),\n",
       " (141919, 0.0030769993257682452),\n",
       " (140946, 0.003053488861294702),\n",
       " (141222, 0.003053488861294702),\n",
       " (141157, 0.0030488151442941655),\n",
       " (140507, 0.002844505670232261),\n",
       " (282867, 0.0028213061624665398),\n",
       " (140452, 0.0027729705977351956),\n",
       " (142168, 0.0026727923811569686),\n",
       " (142336, 0.0026571945874138067),\n",
       " (142075, 0.0026294707667028783),\n",
       " (141912, 0.002478704931530465),\n",
       " (141464, 0.0023916693622155804),\n",
       " (142346, 0.0021333792526741957),\n",
       " (141433, 0.0021333792526741957),\n",
       " (141679, 0.0020779437243837796),\n",
       " (141870, 0.002074308951077892),\n",
       " (140572, 0.002057580508971143),\n",
       " (141306, 0.0020236311983971994),\n",
       " (140942, 0.002003210760935051),\n",
       " (141297, 0.0019933768237390403),\n",
       " (140919, 0.0019721030750271583),\n",
       " (141171, 0.0019721030750271583),\n",
       " (141867, 0.0019599240068668253),\n",
       " (140882, 0.0019480797287820466),\n",
       " (141942, 0.0018590286986478488),\n",
       " (140850, 0.0018320933167768213),\n",
       " (142063, 0.0018292890865764992),\n",
       " (140491, 0.0018292890865764992),\n",
       " (141224, 0.0017990677253272075),\n",
       " (140807, 0.0016878453384182087),\n",
       " (140697, 0.0016842481826691757),\n",
       " (140563, 0.0016842481826691757),\n",
       " (141743, 0.0015468116597426237),\n",
       " (141447, 0.0015355166691261072),\n",
       " (141375, 0.0014222528351161305),\n",
       " (140831, 0.0014222528351161305),\n",
       " (141054, 0.0014222528351161305),\n",
       " (141569, 0.001397382276596491),\n",
       " (140484, 0.0013925554477537828),\n",
       " (141244, 0.0013925554477537828),\n",
       " (141512, 0.0013925554477537828),\n",
       " (140535, 0.001349087465598133),\n",
       " (141270, 0.0013389220314198532),\n",
       " (140497, 0.0013267257155382968),\n",
       " (140980, 0.0013190633397908923),\n",
       " (141617, 0.0013190633397908923),\n",
       " (141866, 0.0013190633397908923),\n",
       " (141597, 0.0013190633397908923),\n",
       " (140390, 0.0012997716008263153),\n",
       " (140391, 0.0012987198191880313),\n",
       " (142003, 0.0012987198191880313),\n",
       " (140608, 0.0012987198191880313),\n",
       " (140645, 0.0012451575784893799),\n",
       " (141188, 0.0012213955445178808),\n",
       " (141178, 0.0012195260577176664),\n",
       " (141494, 0.0012195260577176664),\n",
       " (140971, 0.0011958346811077902),\n",
       " (141717, 0.001162796948709594),\n",
       " (141645, 0.0011228321217794503),\n",
       " (140856, 0.0011228321217794503),\n",
       " (141066, 0.001116553782361013),\n",
       " (140591, 0.0008439226692091044),\n",
       " (142142, 0.0008280962984611957),\n",
       " (141281, 0.0008142832729038164),\n",
       " (142135, 0.0008091448180323178)]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(rewards.items(), key=lambda x: x[1], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.020273391616490936"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_vals[282872]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{282908: 6.510416666666667e-05,\n",
       " 282871: 0.010992164843360328,\n",
       " 282872: 0.020273391616490936,\n",
       " 282873: 0.026374362169973516,\n",
       " 282874: 0.02107799557177973,\n",
       " 282875: 0.028951800219479032,\n",
       " 282876: 0.03448804766592538,\n",
       " 282877: 0.04571408981617098,\n",
       " 282878: 0.04891592838623347,\n",
       " 282879: 0.04615926246148681,\n",
       " 282880: 0.058687835291889104,\n",
       " 282881: 0.06630217359929663,\n",
       " 282882: 0.07442349906725158,\n",
       " 282883: 0.07625364774394704,\n",
       " 282884: 0.07251874141170499,\n",
       " 282885: 0.07612965029527706,\n",
       " 282886: 0.08306231198275546,\n",
       " 282887: 0.0794288099543654,\n",
       " 282888: 0.0801202108657585,\n",
       " 282889: 0.0631382774236282,\n",
       " 282890: 0.04737997538662439,\n",
       " 282891: 0.04381840671275603,\n",
       " 282892: 0.036547035570893484,\n",
       " 282893: 0.027794411088636273,\n",
       " 282894: 0.017677304992391778,\n",
       " 282895: 0.013470900460002136,\n",
       " 282896: 0.011326141441489197,\n",
       " 282897: 0.013163153003069599,\n",
       " 282898: 0.0008029645994566434,\n",
       " 282899: 0.00059433803536193,\n",
       " 282900: 0.0005169864712672169,\n",
       " 282901: 0.00016695052561747296,\n",
       " 282902: 0.00014245573076137987,\n",
       " 282903: 0.00013020833333333333,\n",
       " 282904: 0.00013020833333333333,\n",
       " 282905: 0.00013020833333333333,\n",
       " 282906: 6.510416666666667e-05,\n",
       " 282907: 6.510416666666667e-05,\n",
       " 282863: 3.341846935682738e-06,\n",
       " 282864: 0.0008956504810110285,\n",
       " 282865: 0.00016577482504078733,\n",
       " 282866: 0.0008625953218937492,\n",
       " 282867: 0.0031929795130745493,\n",
       " 282868: 0.004931042981116386,\n",
       " 282869: 0.0051250969434142165,\n",
       " 282870: 0.007760211721284018}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.019489</td>\n",
       "      <td>0.064515</td>\n",
       "      <td>0.102627</td>\n",
       "      <td>0.143751</td>\n",
       "      <td>0.171412</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.029538</td>\n",
       "      <td>0.144289</td>\n",
       "      <td>0.355026</td>\n",
       "      <td>0.679895</td>\n",
       "      <td>0.858605</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.033231</td>\n",
       "      <td>0.645085</td>\n",
       "      <td>1.637432</td>\n",
       "      <td>2.300099</td>\n",
       "      <td>2.569006</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.071155</td>\n",
       "      <td>2.025227</td>\n",
       "      <td>2.816605</td>\n",
       "      <td>2.809292</td>\n",
       "      <td>2.827476</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.086427</td>\n",
       "      <td>2.712383</td>\n",
       "      <td>2.942688</td>\n",
       "      <td>2.995304</td>\n",
       "      <td>3.187006</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.016209</td>\n",
       "      <td>0.065361</td>\n",
       "      <td>0.099932</td>\n",
       "      <td>0.128239</td>\n",
       "      <td>0.148757</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.021745</td>\n",
       "      <td>0.145166</td>\n",
       "      <td>0.296148</td>\n",
       "      <td>0.536252</td>\n",
       "      <td>0.745913</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.031508</td>\n",
       "      <td>0.343696</td>\n",
       "      <td>1.008542</td>\n",
       "      <td>1.538685</td>\n",
       "      <td>1.721433</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.052252</td>\n",
       "      <td>1.335236</td>\n",
       "      <td>1.873888</td>\n",
       "      <td>2.043249</td>\n",
       "      <td>2.009580</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.060036</td>\n",
       "      <td>1.931565</td>\n",
       "      <td>1.988110</td>\n",
       "      <td>1.999122</td>\n",
       "      <td>2.026937</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.015328</td>\n",
       "      <td>0.177271</td>\n",
       "      <td>0.378519</td>\n",
       "      <td>0.565418</td>\n",
       "      <td>0.707687</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.027159</td>\n",
       "      <td>0.718509</td>\n",
       "      <td>1.849109</td>\n",
       "      <td>3.194972</td>\n",
       "      <td>4.757290</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.039627</td>\n",
       "      <td>1.806651</td>\n",
       "      <td>5.495580</td>\n",
       "      <td>12.332599</td>\n",
       "      <td>22.257787</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.045738</td>\n",
       "      <td>9.143638</td>\n",
       "      <td>39.281940</td>\n",
       "      <td>253.905763</td>\n",
       "      <td>6170.426550</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.073999</td>\n",
       "      <td>73.562036</td>\n",
       "      <td>3366.306748</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.017930</td>\n",
       "      <td>0.219147</td>\n",
       "      <td>0.391383</td>\n",
       "      <td>0.533393</td>\n",
       "      <td>0.663264</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.031349</td>\n",
       "      <td>0.575303</td>\n",
       "      <td>1.295088</td>\n",
       "      <td>2.357430</td>\n",
       "      <td>3.731640</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.029482</td>\n",
       "      <td>2.066477</td>\n",
       "      <td>4.513092</td>\n",
       "      <td>11.594831</td>\n",
       "      <td>15.375027</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.060499</td>\n",
       "      <td>9.444907</td>\n",
       "      <td>28.994940</td>\n",
       "      <td>186.963166</td>\n",
       "      <td>266.892450</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.075531</td>\n",
       "      <td>72.214503</td>\n",
       "      <td>88.587184</td>\n",
       "      <td>12225.280816</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.1</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    num_syb    gain_0    gain_25      gain_50       gain_75     gain_100  \\\n",
       "0      50.0  0.019489   0.064515     0.102627      0.143751     0.171412   \n",
       "1      50.0  0.029538   0.144289     0.355026      0.679895     0.858605   \n",
       "2      50.0  0.033231   0.645085     1.637432      2.300099     2.569006   \n",
       "3      50.0  0.071155   2.025227     2.816605      2.809292     2.827476   \n",
       "4      50.0  0.086427   2.712383     2.942688      2.995304     3.187006   \n",
       "5      50.0  0.016209   0.065361     0.099932      0.128239     0.148757   \n",
       "6      50.0  0.021745   0.145166     0.296148      0.536252     0.745913   \n",
       "7      50.0  0.031508   0.343696     1.008542      1.538685     1.721433   \n",
       "8      50.0  0.052252   1.335236     1.873888      2.043249     2.009580   \n",
       "9      50.0  0.060036   1.931565     1.988110      1.999122     2.026937   \n",
       "10     50.0  0.015328   0.177271     0.378519      0.565418     0.707687   \n",
       "11     50.0  0.027159   0.718509     1.849109      3.194972     4.757290   \n",
       "12     50.0  0.039627   1.806651     5.495580     12.332599    22.257787   \n",
       "13     50.0  0.045738   9.143638    39.281940    253.905763  6170.426550   \n",
       "14     50.0  0.073999  73.562036  3366.306748      0.000000     0.000000   \n",
       "15     50.0  0.017930   0.219147     0.391383      0.533393     0.663264   \n",
       "16     50.0  0.031349   0.575303     1.295088      2.357430     3.731640   \n",
       "17     50.0  0.029482   2.066477     4.513092     11.594831    15.375027   \n",
       "18     50.0  0.060499   9.444907    28.994940    186.963166   266.892450   \n",
       "19     50.0  0.075531  72.214503    88.587184  12225.280816     0.000000   \n",
       "\n",
       "    alpha  theta  gamma rep_alg  \n",
       "0     0.4    1.0    0.1     pht  \n",
       "1     0.4    0.9    0.1     pht  \n",
       "2     0.4    0.8    0.1     pht  \n",
       "3     0.4    0.5    0.1     pht  \n",
       "4     0.4    0.2    0.1     pht  \n",
       "5     0.4    1.0    0.1     ppr  \n",
       "6     0.4    0.9    0.1     ppr  \n",
       "7     0.4    0.8    0.1     ppr  \n",
       "8     0.4    0.5    0.1     ppr  \n",
       "9     0.4    0.2    0.1     ppr  \n",
       "10    0.4    1.0    0.1     pht  \n",
       "11    0.4    0.9    0.1     pht  \n",
       "12    0.4    0.8    0.1     pht  \n",
       "13    0.4    0.5    0.1     pht  \n",
       "14    0.4    0.2    0.1     pht  \n",
       "15    0.4    1.0    0.1     ppr  \n",
       "16    0.4    0.9    0.1     ppr  \n",
       "17    0.4    0.8    0.1     ppr  \n",
       "18    0.4    0.5    0.1     ppr  \n",
       "19    0.4    0.2    0.1     ppr  "
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0840204717047782,\n",
       " 0.5441070324130122,\n",
       " 2.04058133410856,\n",
       " 3.8749549888640114,\n",
       " 6.0288146269541185,\n",
       " 10.728648614661491,\n",
       " 20.258097417983933,\n",
       " 40.41646528647062,\n",
       " 67.1712358927405,\n",
       " 137.51952671485296,\n",
       " 89.91491391735781,\n",
       " 195.14386017128896,\n",
       " 63.8449327185811,\n",
       " 99.20917659284255,\n",
       " 390.2970677245838,\n",
       " 247.9532673821184,\n",
       " 513.7640258561705,\n",
       " 1033.0948414004988,\n",
       " 508.94790340339193,\n",
       " 2557.1948943029834,\n",
       " 12753.961767199537,\n",
       " 64274.17788743765,\n",
       " 322214.471073217,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.177505</td>\n",
       "      <td>50.311660</td>\n",
       "      <td>515.413291</td>\n",
       "      <td>34726.811355</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.2</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.084020</td>\n",
       "      <td>40.416465</td>\n",
       "      <td>247.953267</td>\n",
       "      <td>322214.471073</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.028158</td>\n",
       "      <td>0.187148</td>\n",
       "      <td>0.409843</td>\n",
       "      <td>0.598170</td>\n",
       "      <td>0.738176</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.2</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.015306</td>\n",
       "      <td>0.123465</td>\n",
       "      <td>0.252038</td>\n",
       "      <td>0.381478</td>\n",
       "      <td>0.464114</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   num_syb    gain_0    gain_25     gain_50        gain_75  gain_100  alpha  \\\n",
       "0     50.0  0.177505  50.311660  515.413291   34726.811355  0.000000    0.4   \n",
       "1     50.0  0.084020  40.416465  247.953267  322214.471073  0.000000    0.4   \n",
       "2     50.0  0.028158   0.187148    0.409843       0.598170  0.738176    0.4   \n",
       "3     50.0  0.015306   0.123465    0.252038       0.381478  0.464114    0.4   \n",
       "\n",
       "   theta  gamma rep_alg  \n",
       "0    0.2    0.2     pht  \n",
       "1    0.2    0.1     pht  \n",
       "2    1.0    0.2     pht  \n",
       "3    1.0    0.1     pht  "
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df.to_csv('exper_with_gamma.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.011670</td>\n",
       "      <td>0.099671</td>\n",
       "      <td>0.143211</td>\n",
       "      <td>0.162440</td>\n",
       "      <td>0.170650</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.75</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.015527</td>\n",
       "      <td>0.155614</td>\n",
       "      <td>0.252609</td>\n",
       "      <td>0.308813</td>\n",
       "      <td>0.359828</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.75</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.009456</td>\n",
       "      <td>0.097973</td>\n",
       "      <td>0.144566</td>\n",
       "      <td>0.161029</td>\n",
       "      <td>0.173069</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.50</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.010100</td>\n",
       "      <td>0.136176</td>\n",
       "      <td>0.230940</td>\n",
       "      <td>0.284856</td>\n",
       "      <td>0.317835</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.50</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.003589</td>\n",
       "      <td>0.090376</td>\n",
       "      <td>0.140123</td>\n",
       "      <td>0.161543</td>\n",
       "      <td>0.168428</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.25</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.006285</td>\n",
       "      <td>0.107937</td>\n",
       "      <td>0.180879</td>\n",
       "      <td>0.231572</td>\n",
       "      <td>0.258134</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.25</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.002306</td>\n",
       "      <td>0.080003</td>\n",
       "      <td>0.119351</td>\n",
       "      <td>0.135888</td>\n",
       "      <td>0.143149</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.002337</td>\n",
       "      <td>0.037942</td>\n",
       "      <td>0.088433</td>\n",
       "      <td>0.121618</td>\n",
       "      <td>0.144687</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.354436</td>\n",
       "      <td>2.576923</td>\n",
       "      <td>0.631868</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>0.365854</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.75</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.629153</td>\n",
       "      <td>97.374930</td>\n",
       "      <td>503.817842</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.75</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.255753</td>\n",
       "      <td>3.352941</td>\n",
       "      <td>0.716981</td>\n",
       "      <td>0.349057</td>\n",
       "      <td>0.208333</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.50</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.361637</td>\n",
       "      <td>65.573474</td>\n",
       "      <td>115.827182</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.50</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.109299</td>\n",
       "      <td>2.883117</td>\n",
       "      <td>0.497585</td>\n",
       "      <td>0.481132</td>\n",
       "      <td>0.227723</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.25</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.149682</td>\n",
       "      <td>77.481748</td>\n",
       "      <td>508.472812</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.25</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.039578</td>\n",
       "      <td>3.384615</td>\n",
       "      <td>0.520408</td>\n",
       "      <td>0.589744</td>\n",
       "      <td>0.192771</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.062548</td>\n",
       "      <td>30.672448</td>\n",
       "      <td>265.276771</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.260424</td>\n",
       "      <td>3.230819</td>\n",
       "      <td>0.511141</td>\n",
       "      <td>0.396152</td>\n",
       "      <td>0.307034</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.453544</td>\n",
       "      <td>30.026855</td>\n",
       "      <td>275.885460</td>\n",
       "      <td>18254.397262</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.164974</td>\n",
       "      <td>2.225783</td>\n",
       "      <td>0.592806</td>\n",
       "      <td>0.570331</td>\n",
       "      <td>0.307256</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.50</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.217941</td>\n",
       "      <td>24.776186</td>\n",
       "      <td>169.139060</td>\n",
       "      <td>564.962733</td>\n",
       "      <td>94329.057778</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.50</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.089487</td>\n",
       "      <td>3.096987</td>\n",
       "      <td>0.559105</td>\n",
       "      <td>0.521090</td>\n",
       "      <td>0.384252</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.25</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.122276</td>\n",
       "      <td>27.057122</td>\n",
       "      <td>125.665212</td>\n",
       "      <td>664.428258</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.25</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.027985</td>\n",
       "      <td>2.676444</td>\n",
       "      <td>0.558587</td>\n",
       "      <td>0.325600</td>\n",
       "      <td>0.338786</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.036394</td>\n",
       "      <td>10.938952</td>\n",
       "      <td>61.174754</td>\n",
       "      <td>5578.808141</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>60</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.462079</td>\n",
       "      <td>7.241770</td>\n",
       "      <td>1.613921</td>\n",
       "      <td>4.015381</td>\n",
       "      <td>1.727917</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>61</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.635575</td>\n",
       "      <td>65.085403</td>\n",
       "      <td>286.198811</td>\n",
       "      <td>1434.115107</td>\n",
       "      <td>19115.371132</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.75</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>62</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.299096</td>\n",
       "      <td>5.194945</td>\n",
       "      <td>1.651751</td>\n",
       "      <td>4.154199</td>\n",
       "      <td>1.518220</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.50</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>63</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.417641</td>\n",
       "      <td>80.681595</td>\n",
       "      <td>356.228381</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.50</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.135289</td>\n",
       "      <td>7.044517</td>\n",
       "      <td>1.839522</td>\n",
       "      <td>3.827465</td>\n",
       "      <td>1.887051</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.25</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>65</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.179764</td>\n",
       "      <td>67.833488</td>\n",
       "      <td>219.502926</td>\n",
       "      <td>749787.688566</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.25</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>66</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.043419</td>\n",
       "      <td>7.185975</td>\n",
       "      <td>2.153296</td>\n",
       "      <td>2.804426</td>\n",
       "      <td>1.683578</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>67</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.078224</td>\n",
       "      <td>45.788237</td>\n",
       "      <td>325.593574</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.10</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>68</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>69</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.00</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    num_syb    gain_0    gain_25     gain_50        gain_75      gain_100  \\\n",
       "0       1.0  0.011670   0.099671    0.143211       0.162440      0.170650   \n",
       "1      50.0  0.015527   0.155614    0.252609       0.308813      0.359828   \n",
       "2       1.0  0.009456   0.097973    0.144566       0.161029      0.173069   \n",
       "3      50.0  0.010100   0.136176    0.230940       0.284856      0.317835   \n",
       "4       1.0  0.003589   0.090376    0.140123       0.161543      0.168428   \n",
       "5      50.0  0.006285   0.107937    0.180879       0.231572      0.258134   \n",
       "6       1.0  0.002306   0.080003    0.119351       0.135888      0.143149   \n",
       "7      50.0  0.002337   0.037942    0.088433       0.121618      0.144687   \n",
       "8       1.0  0.000000   0.000000    0.000000       0.000000      0.000000   \n",
       "9      50.0  0.000000   0.000000    0.000000       0.000000      0.000000   \n",
       "10      1.0  0.354436   2.576923    0.631868       0.666667      0.365854   \n",
       "11     50.0  0.629153  97.374930  503.817842       0.000000      0.000000   \n",
       "12      1.0  0.255753   3.352941    0.716981       0.349057      0.208333   \n",
       "13     50.0  0.361637  65.573474  115.827182       0.000000      0.000000   \n",
       "14      1.0  0.109299   2.883117    0.497585       0.481132      0.227723   \n",
       "15     50.0  0.149682  77.481748  508.472812       0.000000      0.000000   \n",
       "16      1.0  0.039578   3.384615    0.520408       0.589744      0.192771   \n",
       "17     50.0  0.062548  30.672448  265.276771       0.000000      0.000000   \n",
       "18      1.0  0.000000   0.000000    0.000000       0.000000      0.000000   \n",
       "19     50.0  0.000000   0.000000    0.000000       0.000000      0.000000   \n",
       "40      1.0  0.260424   3.230819    0.511141       0.396152      0.307034   \n",
       "41     50.0  0.453544  30.026855  275.885460   18254.397262      0.000000   \n",
       "42      1.0  0.164974   2.225783    0.592806       0.570331      0.307256   \n",
       "43     50.0  0.217941  24.776186  169.139060     564.962733  94329.057778   \n",
       "44      1.0  0.089487   3.096987    0.559105       0.521090      0.384252   \n",
       "45     50.0  0.122276  27.057122  125.665212     664.428258      0.000000   \n",
       "46      1.0  0.027985   2.676444    0.558587       0.325600      0.338786   \n",
       "47     50.0  0.036394  10.938952   61.174754    5578.808141      0.000000   \n",
       "48      1.0  0.000000   0.000000    0.000000       0.000000      0.000000   \n",
       "49     50.0  0.000000   0.000000    0.000000       0.000000      0.000000   \n",
       "60      1.0  0.462079   7.241770    1.613921       4.015381      1.727917   \n",
       "61     50.0  0.635575  65.085403  286.198811    1434.115107  19115.371132   \n",
       "62      1.0  0.299096   5.194945    1.651751       4.154199      1.518220   \n",
       "63     50.0  0.417641  80.681595  356.228381       0.000000      0.000000   \n",
       "64      1.0  0.135289   7.044517    1.839522       3.827465      1.887051   \n",
       "65     50.0  0.179764  67.833488  219.502926  749787.688566      0.000000   \n",
       "66      1.0  0.043419   7.185975    2.153296       2.804426      1.683578   \n",
       "67     50.0  0.078224  45.788237  325.593574       0.000000      0.000000   \n",
       "68      1.0  0.000000   0.000000    0.000000       0.000000      0.000000   \n",
       "69     50.0  0.000000   0.000000    0.000000       0.000000      0.000000   \n",
       "\n",
       "    alpha  theta  gamma rep_alg  \n",
       "0     0.4    1.0   0.75     pht  \n",
       "1     0.4    1.0   0.75     pht  \n",
       "2     0.4    1.0   0.50     pht  \n",
       "3     0.4    1.0   0.50     pht  \n",
       "4     0.4    1.0   0.25     pht  \n",
       "5     0.4    1.0   0.25     pht  \n",
       "6     0.4    1.0   0.10     pht  \n",
       "7     0.4    1.0   0.10     pht  \n",
       "8     0.4    1.0   0.00     pht  \n",
       "9     0.4    1.0   0.00     pht  \n",
       "10    0.4    0.0   0.75     pht  \n",
       "11    0.4    0.0   0.75     pht  \n",
       "12    0.4    0.0   0.50     pht  \n",
       "13    0.4    0.0   0.50     pht  \n",
       "14    0.4    0.0   0.25     pht  \n",
       "15    0.4    0.0   0.25     pht  \n",
       "16    0.4    0.0   0.10     pht  \n",
       "17    0.4    0.0   0.10     pht  \n",
       "18    0.4    0.0   0.00     pht  \n",
       "19    0.4    0.0   0.00     pht  \n",
       "40    0.4    0.2   0.75     pht  \n",
       "41    0.4    0.2   0.75     pht  \n",
       "42    0.4    0.2   0.50     pht  \n",
       "43    0.4    0.2   0.50     pht  \n",
       "44    0.4    0.2   0.25     pht  \n",
       "45    0.4    0.2   0.25     pht  \n",
       "46    0.4    0.2   0.10     pht  \n",
       "47    0.4    0.2   0.10     pht  \n",
       "48    0.4    0.2   0.00     pht  \n",
       "49    0.4    0.2   0.00     pht  \n",
       "60    0.4    0.2   0.75     pht  \n",
       "61    0.4    0.2   0.75     pht  \n",
       "62    0.4    0.2   0.50     pht  \n",
       "63    0.4    0.2   0.50     pht  \n",
       "64    0.4    0.2   0.25     pht  \n",
       "65    0.4    0.2   0.25     pht  \n",
       "66    0.4    0.2   0.10     pht  \n",
       "67    0.4    0.2   0.10     pht  \n",
       "68    0.4    0.2   0.00     pht  \n",
       "69    0.4    0.2   0.00     pht  "
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df['rep_alg'] == 'pht']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "end_w = 50\n",
    "\n",
    "G = G_t[0].copy()\n",
    "score  = {i: G.in_degree(i, weight='weight') for i in G.nodes()}\n",
    "# Reputation and Data Values\n",
    "seed_node = 0\n",
    "rep_vals = defaultdict(float)\n",
    "\n",
    "w = 0\n",
    "# Initial reputation calculation \n",
    "G = G_t[w].copy()\n",
    "for k,v in score.items():\n",
    "    G.add_edge(0, k, weight=v)\n",
    "\n",
    "G.add_edge(140799, 20, weight=20)\n",
    "\n",
    "pht_cut(G, seed_node, rep_vals, 0.6, 0.2, 0.5)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(float,\n",
       "            {141701: 0.04024496937882764,\n",
       "             141957: 0.04199475065616798,\n",
       "             140557: 0.017497812773403322,\n",
       "             141520: 0.01137357830271216,\n",
       "             142176: 0.00699912510936133,\n",
       "             142117: 0.1714785651793526,\n",
       "             141798: 0.1163604549431321,\n",
       "             140799: 0.32195975503062113,\n",
       "             140591: 0.0,\n",
       "             141362: 0.00699912510936133,\n",
       "             141747: 0.0,\n",
       "             142258: 0.0,\n",
       "             141429: 0.03412073490813648,\n",
       "             140860: 0.0752405949256343,\n",
       "             141821: 0.03937007874015748,\n",
       "             142271: 0.06824146981627296,\n",
       "             20: 0.045909849749582635})"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_vals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "rand = r.random_walks\n",
    "with_condition = True\n",
    "threshold = 1.0\n",
    "s = seed_node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140557 40 25\n",
      "140799 612 232\n",
      "140860 150 33\n",
      "141821 83 63\n",
      "141701 109 80\n",
      "141798 263 157\n",
      "141362 14 6\n",
      "142117 323 127\n",
      "141957 116 58\n",
      "142271 150 80\n",
      "141429 80 38\n",
      "141520 28 16\n",
      "142176 13 8\n",
      "20 342 342\n"
     ]
    }
   ],
   "source": [
    "for k in G.nodes():\n",
    "    if rand.coleadings[k]:\n",
    "        print(k, rand.get_number_positive_hits(s, k), max(rand.coleadings[k].values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int,\n",
       "            {141821: 142,\n",
       "             141701: 173,\n",
       "             140799: 393,\n",
       "             142117: 235,\n",
       "             141798: 314,\n",
       "             142271: 75,\n",
       "             141957: 176,\n",
       "             140557: 39,\n",
       "             141429: 79,\n",
       "             142176: 8,\n",
       "             141362: 7,\n",
       "             141520: 18})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 563,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "609"
      ]
     },
     "execution_count": 563,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand.get_number_positive_hits(s, 140799)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "286 140557 116\n",
      "2984 140799 1725\n",
      "322 140860 228\n",
      "491 141821 218\n",
      "739 141701 300\n",
      "1423 141798 674\n",
      "17 141362 15\n",
      "760 142117 651\n",
      "610 141957 292\n",
      "215 142271 212\n",
      "334 141429 150\n",
      "54 141520 39\n"
     ]
    }
   ],
   "source": [
    "new_vals = {}\n",
    "for g in G.nodes():\n",
    "    max_neck = max(rand.coleadings[g].values()) if rand.coleadings[g] else 0\n",
    "    full_condition = max_neck > 0 and (not with_condition \n",
    "                                        or max_neck >= threshold*rand.get_total_hits(s, g))\n",
    "    if full_condition:\n",
    "        print(max_neck, g, rand.get_total_hits(s, g))\n",
    "        rw_prop = max_neck / rand.get_total_hits(s, g)\n",
    "        new_vals[g] = max(rep_vals[g] *gamma*rw_prop, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 560,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{140557: 0.0,\n",
       " 140799: 0.0,\n",
       " 140860: 0.0,\n",
       " 141821: 0.0,\n",
       " 141701: 0.0,\n",
       " 141798: 0.0,\n",
       " 141362: 0.0,\n",
       " 142117: 0.0,\n",
       " 141957: 0.0,\n",
       " 142271: 0.0,\n",
       " 141429: 0.0,\n",
       " 141520: 0.0}"
      ]
     },
     "execution_count": 560,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_vals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 551,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(float,\n",
       "            {140557: 0.03908554572271387,\n",
       "             140799: 0.2245575221238938,\n",
       "             140860: 0.084070796460177,\n",
       "             141821: 0.06637168141592921,\n",
       "             141701: 0.08333333333333333,\n",
       "             141798: 0.14638643067846607,\n",
       "             141362: 0.0055309734513274336,\n",
       "             142117: 0.14343657817109146,\n",
       "             141747: 0.0,\n",
       "             141957: 0.08296460176991151,\n",
       "             142271: 0.058997050147492625,\n",
       "             141429: 0.045722713864306784,\n",
       "             141520: 0.014011799410029498,\n",
       "             142258: 0.0,\n",
       "             140591: 0.0,\n",
       "             142176: 0.0055309734513274336,\n",
       "             0: 0.3687315634218289})"
      ]
     },
     "execution_count": 551,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_vals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 543,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.035380</td>\n",
       "      <td>0.133178</td>\n",
       "      <td>0.247781</td>\n",
       "      <td>0.283860</td>\n",
       "      <td>0.297989</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.0</td>\n",
       "      <td>0.069653</td>\n",
       "      <td>0.320772</td>\n",
       "      <td>0.593680</td>\n",
       "      <td>0.703143</td>\n",
       "      <td>0.745371</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10.0</td>\n",
       "      <td>0.101153</td>\n",
       "      <td>0.484468</td>\n",
       "      <td>0.857577</td>\n",
       "      <td>1.029344</td>\n",
       "      <td>1.138606</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>20.0</td>\n",
       "      <td>0.124586</td>\n",
       "      <td>0.605919</td>\n",
       "      <td>1.110348</td>\n",
       "      <td>1.411940</td>\n",
       "      <td>1.600808</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.139207</td>\n",
       "      <td>0.793357</td>\n",
       "      <td>1.410041</td>\n",
       "      <td>1.861290</td>\n",
       "      <td>2.234245</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2155</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2156</th>\n",
       "      <td>5.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2157</th>\n",
       "      <td>10.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2158</th>\n",
       "      <td>20.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2159</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2160 rows × 10 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      num_syb    gain_0   gain_25   gain_50   gain_75  gain_100  alpha  theta  \\\n",
       "0         1.0  0.035380  0.133178  0.247781  0.283860  0.297989   0.05    1.0   \n",
       "1         5.0  0.069653  0.320772  0.593680  0.703143  0.745371   0.05    1.0   \n",
       "2        10.0  0.101153  0.484468  0.857577  1.029344  1.138606   0.05    1.0   \n",
       "3        20.0  0.124586  0.605919  1.110348  1.411940  1.600808   0.05    1.0   \n",
       "4        50.0  0.139207  0.793357  1.410041  1.861290  2.234245   0.05    1.0   \n",
       "...       ...       ...       ...       ...       ...       ...    ...    ...   \n",
       "2155      1.0  0.000000  0.000000  0.000000  0.000000  0.000000   0.95    0.0   \n",
       "2156      5.0  0.000000  0.000000  0.000000  0.000000  0.000000   0.95    0.0   \n",
       "2157     10.0  0.000000  0.000000  0.000000  0.000000  0.000000   0.95    0.0   \n",
       "2158     20.0  0.000000  0.000000  0.000000  0.000000  0.000000   0.95    0.0   \n",
       "2159     50.0  0.000000  0.000000  0.000000  0.000000  0.000000   0.95    0.0   \n",
       "\n",
       "      gamma rep_alg  \n",
       "0       1.0     pht  \n",
       "1       1.0     pht  \n",
       "2       1.0     pht  \n",
       "3       1.0     pht  \n",
       "4       1.0     pht  \n",
       "...     ...     ...  \n",
       "2155    0.0     ppr  \n",
       "2156    0.0     ppr  \n",
       "2157    0.0     ppr  \n",
       "2158    0.0     ppr  \n",
       "2159    0.0     ppr  \n",
       "\n",
       "[2160 rows x 10 columns]"
      ]
     },
     "execution_count": 543,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 547,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_syb</th>\n",
       "      <th>gain_0</th>\n",
       "      <th>gain_25</th>\n",
       "      <th>gain_50</th>\n",
       "      <th>gain_75</th>\n",
       "      <th>gain_100</th>\n",
       "      <th>alpha</th>\n",
       "      <th>theta</th>\n",
       "      <th>gamma</th>\n",
       "      <th>rep_alg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>150</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>151</th>\n",
       "      <td>5.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>152</th>\n",
       "      <td>10.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153</th>\n",
       "      <td>20.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>154</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.05</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>pht</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2155</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2156</th>\n",
       "      <td>5.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2157</th>\n",
       "      <td>10.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2158</th>\n",
       "      <td>20.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2159</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>ppr</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>360 rows × 10 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      num_syb  gain_0  gain_25  gain_50  gain_75  gain_100  alpha  theta  \\\n",
       "150       1.0     0.0      0.0      0.0      0.0       0.0   0.05    1.0   \n",
       "151       5.0     0.0      0.0      0.0      0.0       0.0   0.05    1.0   \n",
       "152      10.0     0.0      0.0      0.0      0.0       0.0   0.05    1.0   \n",
       "153      20.0     0.0      0.0      0.0      0.0       0.0   0.05    1.0   \n",
       "154      50.0     0.0      0.0      0.0      0.0       0.0   0.05    1.0   \n",
       "...       ...     ...      ...      ...      ...       ...    ...    ...   \n",
       "2155      1.0     0.0      0.0      0.0      0.0       0.0   0.95    0.0   \n",
       "2156      5.0     0.0      0.0      0.0      0.0       0.0   0.95    0.0   \n",
       "2157     10.0     0.0      0.0      0.0      0.0       0.0   0.95    0.0   \n",
       "2158     20.0     0.0      0.0      0.0      0.0       0.0   0.95    0.0   \n",
       "2159     50.0     0.0      0.0      0.0      0.0       0.0   0.95    0.0   \n",
       "\n",
       "      gamma rep_alg  \n",
       "150     0.0     pht  \n",
       "151     0.0     pht  \n",
       "152     0.0     pht  \n",
       "153     0.0     pht  \n",
       "154     0.0     pht  \n",
       "...     ...     ...  \n",
       "2155    0.0     ppr  \n",
       "2156    0.0     ppr  \n",
       "2157    0.0     ppr  \n",
       "2158    0.0     ppr  \n",
       "2159    0.0     ppr  \n",
       "\n",
       "[360 rows x 10 columns]"
      ]
     },
     "execution_count": 547,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = df[(df['gamma'] == 0.0)]\n",
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "sns.lineplot(data=df2, x='gamma', y='gain', hue='decay_p', ci = 40, estimator='mean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 498,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1384918567178657\n",
      "2.8833408567484455\n"
     ]
    }
   ],
   "source": [
    "# With 1 Sybils\n",
    "print(gains[-1]/ gains[0]) # Advantage gain over time \n",
    "print(gains[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 478,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.241125174606536\n",
      "0.07312698776860053\n"
     ]
    }
   ],
   "source": [
    "# With 2  Sybils\n",
    "print(gains[-1]/ gains[0]) # Advantage gain over time \n",
    "print(gains[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 480,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.725621641176467\n",
      "0.21566857120140653\n"
     ]
    }
   ],
   "source": [
    "# With 2  Sybils\n",
    "print(gains[-1]/ gains[0]) # Advantage gain over time \n",
    "print(gains[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 481,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.238404356449423"
      ]
     },
     "execution_count": 481,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.21566857120140653 / 0.05088437842728046"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.8646335421000093,\n",
       " 5.6344895084657995,\n",
       " 12.532088371008918,\n",
       " 23.731887477261463,\n",
       " 29.63205118049989,\n",
       " 37.33409999660246,\n",
       " 59.61438420841222,\n",
       " 88.57533224150984,\n",
       " 104.84436214753212,\n",
       " 110.08830230061433,\n",
       " 95.06479126005665,\n",
       " 109.1664400692735,\n",
       " 100.14443941816508,\n",
       " 87.08944804622969,\n",
       " 66.18355173102495,\n",
       " 64.24514548299433,\n",
       " 72.47773434922715,\n",
       " 72.72440532471346,\n",
       " 59.299926197767476,\n",
       " 65.61563965163005,\n",
       " 71.77626252381472,\n",
       " 59.38719105987331,\n",
       " 51.53826591352075,\n",
       " 46.599147594862025,\n",
       " 40.80500841140467,\n",
       " 40.692994879241255,\n",
       " 39.045268820774076,\n",
       " 26.186667017217502,\n",
       " 21.355814891741684,\n",
       " 23.825799787725305]"
      ]
     },
     "execution_count": 440,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate Gain of the attacker \n",
    "gains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140799 @LongForWisdom 8.54130946666104\n",
      "141627 @hexonaut 3.2460021737748423\n",
      "141429 @cyrus 3.0227426588876676\n",
      "141031 @SebVentures 3.0166506472535652\n",
      "140820 @MakerMan 3.005883915188721\n",
      "140557 @Davidutro 2.8937267171117265\n",
      "142079 @psychonaut 2.8635990196338597\n",
      "142117 @rich.brown 2.8118645734635277\n",
      "140587 @ElProgreso 2.7582289044542665\n",
      "140957 @Planet_X 2.6032943659795316\n",
      "140397 @Aaron_Bartsch 2.5861717590330664\n",
      "141957 @mrabino1 2.1839319357473315\n",
      "141701 @jernejml 2.1439536881620955\n",
      "141945 @monet-supply 2.1423988468609205\n",
      "140968 @Primoz 2.1305523293092343\n",
      "142325 @ultraschuppi 2.1255511283072317\n",
      "142141 @rune 2.045638846106539\n",
      "140904 @NikKunkel 1.9946741942373127\n",
      "140571 @Derek 1.9709956490505802\n",
      "141648 @iammeeoh 1.9382153467900394\n"
     ]
    }
   ],
   "source": [
    "for k,v in sorted(rep_vals.items(), key=lambda x: x[1], reverse=True)[:20]:\n",
    "    print(k,id_to_user[str(k)],v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "for w in range(end_w):\n",
    "    # Initial reputation calculation \n",
    "    G = G_t[w].copy()\n",
    "    for k,w in score.items():\n",
    "        G.add_edge(0, k, weight=w)\n",
    "    # Calculate with Transitivity Decay: alpha and Diversity Decay: gamma\n",
    "    simple_pht(G, seed_node, rep_vals, decay_p = decay_p)\n",
    "    score = {k:v for k,v in rep_vals.items() if v > 0}\n",
    "    if w % (end_w/10) == 0:\n",
    "        print('Finished w = %d' % w)\n",
    "\n",
    "# Epoch Decay: theta\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Pre-run the reputation \n",
    "rep_vals = defaultdict(float)\n",
    "seed_punish = False\n",
    "\n",
    "G = G_t[0]\n",
    "num_seeds = 3 \n",
    "\n",
    "score  = {i: G.in_degree(i)*G.out_degree(i) for i in G.nodes()}\n",
    "sorted_score = sorted(score.items(), key=lambda x: x[1], reverse=True)\n",
    "initial_seeds = [k for k,_ in sorted_score[:num_seeds]]\n",
    "new_seeds = initial_seeds.copy()\n",
    "\n",
    "for w in range(40):\n",
    "    cur_seeds = []\n",
    "    selected_seeds = 0\n",
    "    G = G_t[w].copy()\n",
    "    # 1. Select seeds based on gained reputation \n",
    "    cur_seeds = pick_seeds(new_seeds, num_seeds)\n",
    "\n",
    "    # 2. Build auxiliary graph. Weights for indirect edges are change to proportional. \n",
    "    for seed_node in cur_seeds:\n",
    "        # simple_maxflow(G, seed_node, rep_vals,)\n",
    "        # simple_ppr(G, seed_node, rep_vals, decay_p = decay_p, use_weight= False)\n",
    "        \n",
    "        # aux_max_flow(G, seed_node, rep_vals, decay_p = decay_p)\n",
    "        # 3. Seed punish\n",
    "        if seed_punish:\n",
    "            intro_rep = G.out_degree(seed_node, weight='weight')\n",
    "            rep_vals[seed_node] -= intro_rep * seed_decay\n",
    "            rep_vals[seed_node] = max(rep_vals[seed_node], 0)\n",
    "\n",
    "    new_seeds = sorted(rep_vals.items(), key=lambda x: x[1], reverse=True)\n",
    "    new_seeds = [k for k,_ in new_seeds]\n",
    "\n",
    "seeds =  new_seeds[:10]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame(columns=['active', 'passive', 'num_syb', 'weeks', 'decay_p'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "--- Finished 0.4 ---\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "--- Finished 0.6 ---\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 30 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 20 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 15 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 10 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 5 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "Processed 0 our of 30\n",
      "--- Finished 0.8 ---\n"
     ]
    }
   ],
   "source": [
    "rep_vals = defaultdict(float)\n",
    "old_rep_vals = []\n",
    "\n",
    "num_seeds = 3\n",
    "\n",
    "seed_decay = 0.1\n",
    "seed_punish = False\n",
    "attack_w = 20\n",
    "syb_rep_gain = {}\n",
    "\n",
    "contrib_decay_w = 8 # 2 mounts \n",
    "contrib_decay_val = 0\n",
    "N = 30\n",
    "\n",
    "for decay_p in [0.4, 0.6, 0.8]:\n",
    "    for num_syb in [30, 20, 15, 10, 5, 4, 3, 2, 1, 0]:\n",
    "        for total_weeks in range(1, 10):\n",
    "            total_syb = 0\n",
    "            rep_vals = defaultdict(float)\n",
    "            new_seeds = seeds[:num_seeds]\n",
    "            attacker_node = np.random.choice(G[new_seeds[0]])\n",
    "            for w in range(40, 40 + total_weeks):\n",
    "                G = G_t[w].copy()\n",
    "                cur_seeds = []\n",
    "                selected_seeds = 0\n",
    "                # 1. Select seeds based on gained reputation \n",
    "                while selected_seeds < num_seeds:\n",
    "                    for s in new_seeds:\n",
    "                        if s in G:\n",
    "                            cur_seeds.append(s)\n",
    "                            selected_seeds += 1\n",
    "                            if selected_seeds == num_seeds:\n",
    "                                break\n",
    "                    if selected_seeds != num_seeds:\n",
    "                        print('Cannot find enough seeds!')\n",
    "                        break\n",
    "                if w >= attack_w and num_syb > 0:\n",
    "                    total_syb += add_sybil_parallel_region(G, attacker_node, total_syb, num_syb)\n",
    "                \n",
    "                # 2. Build auxiliary graph. Weights for indirect edges are change to proportional. \n",
    "                for seed_node in cur_seeds:\n",
    "                    # simple_maxflow(G, seed_node, rep_vals,)\n",
    "                    # simple_ppr(G, seed_node, rep_vals, decay_p = decay_p, use_weight= False)\n",
    "                    # simple_pht(G, seed_node, rep_vals, decay_p = decay_p, use_weight=False)\n",
    "                    # aux_max_flow(G, seed_node, rep_vals, decay_p = decay_p)\n",
    "                    # rep_alg = PersonalizedHittingTime(G, seed_node, 1000, reset_probability=1-decay_p)\n",
    "                    rep_alg = PersonalizedHittingTime(G, seed_node, 1000, reset_probability=1-decay_p)\n",
    "                    rep_with_cut(G, seed_node, rep_vals, rep_alg, gamma=0.0)\n",
    "                    # 3. Seed punish\n",
    "                    if seed_punish:\n",
    "                        intro_rep = G.out_degree(seed_node, weight='weight')\n",
    "                        rep_vals[seed_node] -= intro_rep * seed_decay\n",
    "                        rep_vals[seed_node] = max(rep_vals[seed_node], 0)\n",
    "                \n",
    "                #old_rep_vals.append(rep_vals.copy())\n",
    "                #if len(old_rep_vals) == contrib_decay_w:\n",
    "                #    old_reps = old_rep_vals.pop(0)\n",
    "                #    for k,v in old_reps.items():\n",
    "                #        rep_vals[k] -= v * contrib_decay_val\n",
    "                \n",
    "                # Choose new seeds\n",
    "                new_seeds = sorted(rep_vals.items(), key=lambda x: x[1], reverse=True)\n",
    "                new_seeds = [k for k,_ in new_seeds]\n",
    "            df = df.append({'active': sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]), 'passive':  rep_vals[attacker_node], 'num_syb': num_syb, 'weeks': total_weeks, 'decay_p': decay_p}, ignore_index=True)\n",
    "            if num_syb % 5 == 0:\n",
    "                print(\"Processed {} our of {}\".format(num_syb, N))\n",
    "    print('--- Finished {} ---'.format(decay_p))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 385,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def reputation_cut_experiment(alg, alg_label:str,df: pd.DataFrame, syb_attack_func, num_exp:int = 10, **kwargs):\n",
    "    for decay_p in [0.05, 0.2, 0.4, 0.6, 0.8, 0.95]:\n",
    "        for _ in range(num_exp):\n",
    "            total_syb = 0\n",
    "            rep_vals = defaultdict(float)\n",
    "            new_seeds = seeds[:num_seeds]\n",
    "            num_syb = 5\n",
    "            total_syb = 0\n",
    "            # Choose a random week after 40 \n",
    "            w = np.random.randint(40, 150)\n",
    "            G = G_t[w].copy()\n",
    "            cur_seeds = []\n",
    "            selected_seeds = 0\n",
    "\n",
    "            # 0. Add Seed node and connect\n",
    "\n",
    "            # 1. Select seeds based on gained reputation \n",
    "            while selected_seeds < num_seeds:\n",
    "                for s in new_seeds:\n",
    "                    if s in G:\n",
    "                        cur_seeds.append(s)\n",
    "                        selected_seeds += 1\n",
    "                        if selected_seeds == num_seeds:\n",
    "                            break\n",
    "                if selected_seeds != num_seeds:\n",
    "                    # Find other seeds - random? \n",
    "                    other_seeds = np.random.choice(G.nodes(), num_seeds - selected_seeds)\n",
    "                    cur_seeds.extend(other_seeds)\n",
    "            # Add Sybil Region\n",
    "            attacker_node = np.random.choice(G.nodes())\n",
    "            while attacker_node in cur_seeds or G.in_degree(attacker_node) == 0:\n",
    "                attacker_node = np.random.choice(G.nodes())\n",
    "\n",
    "            if num_syb > 0:\n",
    "                total_syb += syb_attack_func(G, attacker_node, total_syb, num_syb)\n",
    "\n",
    "            # 2. Calculate reputation \n",
    "            for seed_node in cur_seeds:\n",
    "                alg(G, seed_node, rep_vals, decay_p = decay_p, **kwargs)\n",
    "                # 3. Seed punish\n",
    "                if seed_punish:\n",
    "                    intro_rep = G.out_degree(seed_node, weight='weight')\n",
    "                    rep_vals[seed_node] -= intro_rep * seed_decay\n",
    "                    rep_vals[seed_node] = max(rep_vals[seed_node], 0)\n",
    "            # Choose new seeds\n",
    "            new_seeds = sorted(rep_vals.items(), key=lambda x: x[1], reverse=True)\n",
    "            new_seeds = [k for k,_ in new_seeds]\n",
    "            df = df.append({'active': sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]),\n",
    "                            'passive':  rep_vals[attacker_node], \n",
    "                            'num_syb': num_syb, \n",
    "                            'weeks': w, \n",
    "                            'decay_p': 1-decay_p,\n",
    "                            'alg': alg_label\n",
    "                            }, ignore_index=True)\n",
    "        print('Finished experiments with decay_p {}'.format(decay_p))\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished experiments with decay_p 0.05\n",
      "Finished experiments with decay_p 0.2\n",
      "Finished experiments with decay_p 0.4\n",
      "Finished experiments with decay_p 0.6\n",
      "Finished experiments with decay_p 0.8\n",
      "Finished experiments with decay_p 0.95\n",
      "Finised Experiments with gamma = 1\n",
      "Finished experiments with decay_p 0.05\n",
      "Finished experiments with decay_p 0.2\n",
      "Finished experiments with decay_p 0.4\n",
      "Finished experiments with decay_p 0.6\n",
      "Finished experiments with decay_p 0.8\n",
      "Finished experiments with decay_p 0.95\n",
      "Finised Experiments with gamma = 0.75\n",
      "Finished experiments with decay_p 0.05\n",
      "Finished experiments with decay_p 0.2\n",
      "Finished experiments with decay_p 0.4\n",
      "Finished experiments with decay_p 0.6\n",
      "Finished experiments with decay_p 0.8\n",
      "Finished experiments with decay_p 0.95\n",
      "Finised Experiments with gamma = 0.5\n",
      "Finished experiments with decay_p 0.05\n",
      "Finished experiments with decay_p 0.2\n",
      "Finished experiments with decay_p 0.4\n",
      "Finished experiments with decay_p 0.6\n",
      "Finished experiments with decay_p 0.8\n",
      "Finished experiments with decay_p 0.95\n",
      "Finised Experiments with gamma = 0.25\n",
      "Finished experiments with decay_p 0.05\n",
      "Finished experiments with decay_p 0.2\n",
      "Finished experiments with decay_p 0.4\n",
      "Finished experiments with decay_p 0.6\n",
      "Finished experiments with decay_p 0.8\n",
      "Finished experiments with decay_p 0.95\n",
      "Finised Experiments with gamma = 0.0\n"
     ]
    }
   ],
   "source": [
    "df = pd.DataFrame(columns=['active', 'passive', 'num_syb', 'weeks', 'decay_p'])\n",
    "for g in [1, 0.75, 0.5, 0.25, 0.0]:\n",
    "    new_df = pd.DataFrame()\n",
    "    new_df = reputation_cut_experiment(pht_cut, 'rep_cut_pht', new_df, add_sybil_path_region, num_exp=10, gamma=g)\n",
    "    new_df['gamma'] = 1-g\n",
    "    print('Finised Experiments with gamma = {}'.format(g))\n",
    "    df = df.append(new_df, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df['gain'] = (df['active']) / df['passive']\n",
    "# df\n",
    "df2 = df.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df.to_csv('gamma_syb.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df.to_csv('gamma_syb_neck_only.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2.to_csv('gamma_syb_neck_only_2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df3 = pd.read_csv('gamma_syb_neck_only_2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df3 = df3.append(df2, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='gamma', ylabel='gain'>"
      ]
     },
     "execution_count": 390,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "sns.lineplot(data=df2, x='gamma', y='gain', hue='decay_p', ci = 40, estimator='mean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='gamma', ylabel='gain'>"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEGCAYAAABvtY4XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAB8jklEQVR4nO39eZwkV3mniz8nttxrr+q9JbU2pNYGkhAgLAthQGZAhjEDeEMsHi8DF4yHMTAe2/xmmGH8gxkG2+B7scGAMWCbxWCMZVZdY0AgCaMdtZDU6r32JbfYz/3jRERmVmVVV3fXXuf5fLpzi8w4mZX5jTe+5z3vK6SUaDQajWbrYaz3ADQajUazOmiB12g0mi2KFniNRqPZomiB12g0mi2KFniNRqPZoljrPYB2hoaG5Pnnn7/ew9BoNJpNw7333jshpRzu9tiGEvjzzz+fe+65Z72HodFoNJsGIcRTiz2mLRqNRqPZomiB12g0mi2KFniNRqPZomwoD16j2SwEQcCxY8dwXXe9h6LZJuTzefbu3Ytt28t+jhZ4jeYsOHbsGJVKhfPPPx8hxHoPR7PFkVIyOTnJsWPHuOCCC5b9PG3RaDRngeu6DA4OanHXrAlCCAYHB8/4jFELvEZzlmhx16wlZ/N90wKv0Wg0W5Qt4cFLGRO5HsI0MEwLDENHVxqNZtuzJQQeKYkDD0JBlPQvEaaBsCwM00IYJsLQJysazUrwrne9i3K5zNve9rb1HormNGwNgU8wTPV2pJRK9D2fWPjqQSGU2JsWhmnqKF+j0Wx5tmRYK4RAGAZGEsEbpoUQBjIMidwmQaNGUJsjqNeIPI84DJFxvN7D1mg2LP/9v/93LrnkEp773Ofy6KOPAvD4449z6623cu211/JTP/VT/PjHPwZgdHSUl7/85Vx99dVcffXVfPe73wXgZS97Gddeey0HDx7kwx/+MAAf/ehH+a3f+q1sP3/2Z3/GW9/61q5jOHz4ME972tP4pV/6JS677DJe8YpX0Gg0VvFdbwGklBvm37XXXivPhjgKpTc7LYN6bdn//FpV+tU56c3OZP/86qwMGnUZ+b6Mw1DGcXxW49FsfR5++OH1HsKacc8998grrrhC1ut1OTs7Ky+88EL53ve+V95yyy3y0KFDUkop77rrLvm85z1PSinlK1/5Svn+979fSillGIZyZmZGSinl5OSklFLKRqMhDx48KCcmJmS1WpUHDhyQvu9LKaV89rOfLe+///6u43jyySclIP/lX/5FSinl6173Ovne97531d73RqTb9w64Ry6iqVvKojkThBCQRPopUkpkGBIGQbIRCNPEMG2EqXx87eVrthvf/va3efnLX06xWATgtttuw3Vdvvvd7/Lv/t2/y7bzPA+Ab37zm3ziE58AwDRNent7AfijP/ojvvCFLwBw9OhRHnvsMZ71rGdxyy238OUvf5nLLruMIAi48sorFx3Lvn37uPHGGwH45V/+Zf7oj/5IzwUswbYV+G4IIcA0SZ15KSXEkihMFxdIJfKmjWFZSuy1l6/ZhsRxTF9fHz/60Y+Wtf2dd97J17/+db73ve9RLBa5+eabs0U7v/qrv8r/+B//g6c97Wm87nWvW/J15v/W9G9vaXQ4ugQdXr5lYVg2CAMZBoTNBkG9SlCbI2zUtZev2bLcdNNN/N3f/R3NZpNqtcrf//3fUywWueCCC/jbv/1bQAVD9913HwDPf/7z+dM//VMAoihidnaW2dlZ+vv7KRaL/PjHP+auu+7KXv+GG27g6NGjfOpTn+IXfuEXlhzLkSNH+N73vgfApz71KZ773OeuxlveMmiBP0OEEMq2SQRfGCYyjok8l7BRV5O3tSqh2yQOAmQcqTMBjWaT8oxnPINXvepVXH311fzsz/4s119/PQB/9Vd/xUc+8hGuvvpqDh48yBe/+EUAPvCBD/Ctb32LK6+8kmuvvZaHH36YW2+9lTAMueyyy3jHO97Bs571rI59vPKVr+TGG2+kv79/ybFceumlfPCDH+Syyy5jenqa3/zN31ydN71FEBtJfK677jp5Nh2dZBwR1Koqwt4ASBmrSF4CyFaKppXk5JsGQuhj62bmkUce4bLLLlvvYWwZXvKSl/DWt76V5z//+Ytuc/jwYV7ykpfw4IMPruHINhbdvndCiHullNd1216rzCoghFpR2xnlR0Ruk7BRI6i2RfmhjvI125eZmRkuueQSCoXCkuKuOTv0JOsaoDJ2TIRhZvfJOCYOfGLfSzdqRfmm2lZPIGm2On19fRw6dKjjvsnJya5i/41vfGNbR+9nw5YQ+M0Y/QrDQDAvRTOOiN0g3UJtk0zwCsMAoTN2NFufwcHBZWfnaJZm0wu8lJLqT34MhoFVLGHmi5j5/KbzuJcX5RsYpqmjfI1GsyxWXeCFECZwD3BcSvmSFd+BlJjFEkFtDm9yPN0pZq6AWShg5YuYhUKHcG4Wukb5UUQczovy7VZRNYTQoq/RaIC1ieDfAjwC9KzGiwvDoLRnP0GtCkIQNZtEboOw2cCfnsRnEgAjl0vEvoiZL2JYm+/kpbUQSx2sZFpUzfeJpQcIMISK8pMaPHohlkazfVlVH0MIsRf4N8Cfr+Z+UgzTwi5XyA/toLzvAioHLqW4ez9O/xDCMPHnZmieOk7t8GPUnnqc5ugJ/LkZYt/fnD5+uhDLVNk6hpUWVYuIPJegnmTs1KuEXpqxoxdibSXuuOMOLr30Ui666CL+5//8nwse9zyPV73qVVx00UXccMMNHD58GFAph4VCgWuuuYZrrrmG3/iN38iec++993LllVdy0UUX8eY3vzn7bUxNTfGCF7yAiy++mBe84AVMT08DKtB485vfzEUXXcRVV13FD3/4w+y1Pv7xj3PxxRdz8cUX8/GPf3zb7yPl7rvvxrIsPvvZz3bcPzc3x969e3nTm97U5a99FixWpGYl/gGfBa4Fbga+vMg2v4aycO7Zv3//WRXgWW6xMb9Wlc3JcVk79pSc/ckjcuqBH8rJ++6Wk/fdLace/Fc5+/iPZf34EelOTUi/Vj2j4mUb9V9HUbW55F9aVC0MdEG1s2QjFBsLw1AeOHBAPv7449LzPHnVVVfJhx56qGObD37wg/LXf/3XpZRSfvrTn5avfOUrpZSqcNfBgwe7vu71118vv/e978k4juWtt94qv/KVr0gppfxP/+k/yfe85z1SSinf8573yN/5nd+RUkr5D//wD/LWW2+VcRzL733ve/KZz3ymlFIVF7vgggvk5OSknJqakhdccIGcmpra1vtI/27Pe97z5M/+7M/Kv/3bv+347N/85jfLX/iFX5BvfOMbu/5tzrTY2KpF8EKIlwBjUsp7T3OA+bCU8jop5XXDw8OrNZx0TFj5Arn+QYq79lG+4GJK+w6QH96JWSgSuU3ciVHqR5+k+uQhGieO4E1NEDYbmzbyXax0chwGhPUaYb1K5Hub9v1tZ37wgx9w0UUXceDAARzH4dWvfnW2mjTli1/8IrfffjsAr3jFK/jGN76x5NnqyZMnmZub41nPehZCCF7zmtfwd3/3dwte6/bbb++4/zWveQ1CCJ71rGcxMzPDyZMn+ad/+ide8IIXMDAwQH9/Py94wQu44447tvU+AP74j/+Yn//5n2dkZKTjs7/33nsZHR3lhS984en/+MtkNY3oG4HbhBAvBvJAjxDik1LKX17FfZ4RQgjMXA4zl8PpVUuk4yDIPPzIbRBOtU/c5jMP38oXEObmm7iFtNxC0hwljolcl4gmhm1j2DmVoaN9+2VTP3GEqLmydcnNQpHS7v1LbnP8+HH27duX3d67dy/f//73F93Gsix6e3uZnFTzUk8++SRPf/rT6enp4d3vfjc/9VM/xfHjx9m7d2/Hax4/fhxQdd537doFwM6dOxkdHV10HMePH1/y/u28jy984Qt861vf4u67786eG8cx//E//kc++clP8vWvf52VYtUEXkr5TuCdAEKIm4G3bSRxXwwlcr3YFVXiNI7CBRO3pBO3Tg6rsMknbpMSyFJKZBgRBjUV8Tu5ZBXu5ko31SyPXbt2ceTIEQYHB7n33nt52ctexkMPPbTs54s1yNbaivv4rd/6Lf7wD/8QY97v6kMf+hAvfvGLOw4YK8HmU6Q1xjAtjHIFu1wB0oi3TfDnZmBWTaAYtq3y8FPBt+1NEwm3Z+hIqYqnRa6O6pfD6SLt1WLPnj0cPXo0u33s2DH27NnTdZu9e/cShiGzs7MMDg4ihCCXywFw7bXXcuGFF3Lo0CH27NnDsWPHur7mjh07OHnyJLt27eLkyZOZxbDYOPbs2cOdd97Zcf/NN9+8rfdxzz338OpXvxqAiYkJvvKVr2BZFt/73vf49re/zYc+9CFqtRq+71Mul7tOnJ8JaxKeSSnvlKuRA78OiGRBVW5gmNKe86gcuJTS3vPJDY5gODnCeg137CT1I49TO/wYjZPH8GamiDx302TqpLV0hGmpqL6RePWe9uo3Etdffz2PPfYYTz75JL7v85nPfIbbbrutY5vbbrsty/r47Gc/yy233IIQgvHxcaIoAuCJJ57gscce48CBA+zatYuenh7uuusupJR84hOf4Od+7ucWvNbHP/7xjvs/8YlPIKXkrrvuore3l127dvGiF72Ir371q0xPTzM9Pc1Xv/pVXvSiF23rfTz55JMcPnyYw4cP84pXvIIPfehDvOxlL+Ov/uqvOHLkCIcPH+Z973sfr3nNa85Z3IHt27JvNbNW3OlJWT9xVM498aiceuhHWabO5AP3ypnHHpa1o4dlc2JM+tW5dR/v8t/XnMrAmZ2WQaMmo2B7Z+BshCwaKVXmx8UXXywPHDgg3/3ud0sppfy93/s9+cUvflFKKWWz2ZSveMUr5IUXXiivv/56+fjjj0sppfzsZz8rL7/8cnn11VfLpz/96fJLX/pS9pp33323PHjwoDxw4IB84xvfmP2dJyYm5C233CIvuugi+fznPz9rwRfHsfwP/+E/yAMHDsgrrrhC3n333dlrfeQjH5EXXnihvPDCC+VHP/rRbb+Pdm6//fYFWTRSSvkXf/EXK5ZFo8sFrwGdE7fNVukBBGY+n9k6m2HiVkoJcYyUsfLq7ZyyoraZV6/LBWvWgzMtF6w9+DWg68St2yRqNoiaDfyZSZhpTdwqsVclFjbaQavTq5dEvkvkNdVCK8dBmJb26jWaDcKWEngZR5ui4qJhWhilCnap28Rtk2BuhiCZuBWW3ZapU8CwnQ3z/tJ0S5nUyAkbdRAGppPDsK1NWf9Ho9lKbA2BFwZmvogMA+IoVDZCssBnM1SVTCdurWKJHMoGiT23lYtfrxFUZ9W2ptlh6Ri5/LoL/oKo3msSeUItrtJRvUazbmwJgRdCYDoOOE5HxUUl+AGq6qLYFNE9JO8nX8DMF4BBJfiBrywdt0nYbBDWq3iQHNwKSZRfwMwV1tUPF0IgLDurbx82GqqZieNg2raO6jWaNWRLCHw7SmCsZNFRQTXRCCMl9mGIJI3uN09etzqA5TCdHKQrbsOAqNmauPXSFbcdE7eqXPJ6TNy26tunZyQesefpqF6jWUO2nMDPRxgmpmMuEt3HbLboPsWwbIxKa+JWRhGh20gmbpvJxG2ybTZxW8AsFNd84jY96ALzonob03Z0VK/RrBIb36BeQYRQvrCVL2CXe7DLFcy8agaihD9sefibDGGa2CVVKrm07/ysVHJuYAhhWgRzMzRHT1A7/BOqh39Cc/wUodtc8/cqDDNrQRh7PkGtSlCvqYPuJvzc15vTlQv+53/+Z57xjGd0LU379re/nSuuuIIrrriCv/7rv87u/+Y3v8kznvEMrrjiCm6//XbCMARgenqal7/85Vx11VU885nP7OiP+oEPfIArrriCgwcP8n/+z//J7r/vvvt49rOfzZVXXslLX/pS5ubmAPB9n9e97nVceeWVXH311R0rRf/6r/+aq666ioMHD/L2t789u/+pp57i+c9/PldddRU333xzxyrSzfZeAP7mb/6Gyy+/nIMHD/KLv/iLC/52K8JiCfLr8e9sFzqtBHEcyygIZNBsSL86K73ZaenNzki/OrslSgf7tap0J8dl7bgqlTx5/z1y8r675fTD98na0SelNzO1fmNLP++5GRk0GzIOw3X7HiyXjbDQaTnlgp988kl53333yV/5lV/pWFTz5S9/Wf7Mz/yMDIJA1mo1ed1118nZ2VkZRZHcu3evfPTRR6WUatHUn//5n0sppXzb294m3/Wud0kppXzkkUfkLbfcIqWU8oEHHpAHDx6U9XpdBkEgn//858vHHntMSinlddddJ++8804ppVos9F/+y3+RUkr5J3/yJ/K1r32tlFLK0dFR+YxnPENGUSQnJibkvn375NjYmJRSyte85jXy61//upRSyle84hXyYx/7mJRSym984xvyl3/5lzftezl06JC85pprsrLDo6Ojy/qbb5hywZuN9ujeKlWS6D6/JaJ7aE3c5vpUqeTK+ReTH9mFsCy8qQlqTz1O/dhh/NlpZLKEfc3GZphJYTOT2PcJ6lWCepVokzZiWSuWUy74/PPP56qrrlpQ3Orhhx/mpptuwrIsSqUSV111FXfccQeTk5M4jsMll1wCwAte8AI+97nPZc+55ZZbAHja057G4cOHGR0d5ZFHHuGGG26gWCxiWRY//dM/zec//3kADh06xE033bTka42MjNDX18c999zDE088wcUXX0xaOvxnfuZnuj7nec97XvZeN+N7+bM/+zPe+MY30t/fnz1vNdAC3wWRTMKaTg6rWMKu9GAVSxi2AzImTtMx42jTCpAwTZyePkp7zqN83kXkBoaRUYQ7forqk6qGTlCbQ8q1qz2THmQNywYJkdsgqM0pK2mNDzpnwuR9D3Ly//3Oiv6bvO/B0+53sTK2y+Hqq6/mjjvuoNFoMDExwbe+9S2OHj3K0NAQYRiSrij/7Gc/mxXguvrqqzOx+8EPfsBTTz3FsWPHuOKKK/j2t7/N5OQkjUaDr3zlK9lzDh48mAnx3/7t33a81pe+9CXCMOTJJ5/k3nvv5ejRo1x00UU8+uijHD58mDAM+bu/+7uu+//CF75AtVplcnJyU76XQ4cOcejQIW688Uae9axncccddyzr73ambPlJ1pWgPTNHynwi8iEyDJPMHECwqTJz2jFsm9zAEE7/ILHnqjZ/tVnCehUMQ81XVHrVfMUavb/2Msax7xP7HsI0W6URNuHnvJF44QtfyN13381znvMchoeHefazn42ZVAz9zGc+w1vf+lY8z+OFL3whZpKF9Y53vIO3vOUtXHPNNVx55ZU8/elPxzRNLrvsMt7+9rfzwhe+kFKpxDXXXJM956Mf/ShvfvOb+W//7b9x22234TgOAK9//et55JFHuO666zjvvPN4znOeg2ma9Pf386d/+qe86lWvwjAMnvOc5/D4448D8L73vY83velNfOxjH+Omm25iz549mKa5Kd9LGIY89thj3HnnnRw7doybbrqJBx54gL6+vhX9O2uBP0PS9D+VmZNDyhgZxZ2ZOUKoBVZrUGt6JWnPv88NjRA26gTVWfVvbgZh2dhJ5o6ZfLnXYkytDJyYyG2oRVS2ozJwNkDtnsGrr1iX/S6nXPBS/O7v/i6/+7u/C8Av/uIvZlbGs5/9bL797W8D8NWvfpVDhw4B0NPTw1/8xV8Aau7uggsu4MCBAwC84Q1v4A1veAMA//k//+esrvnTnvY0vvrVrwIqav2Hf/gHQDUfef/735+N5TnPeU62/5e+9KW89KUvBeDDH/5wJrC7d+/Oou5arcbnPve5TBA323vZu3cvN9xwA7Ztc8EFF3DJJZfw2GOPcf3115/mr3ZmaIvmHBHC6PTuSxXMXF5Fn5vYuxdCYJfKFHfuoXKB8usN28afnqB+5HHqRw/jz04RR+HajckwWl59kHj1tdSr335ljJdTLngxoijKOjvdf//93H///VmruLGxMUA17P7DP/zDrCH3zMwMvu8D8Od//ufcdNNN9PT0dDznyJEjfP7zn8+yQtL74zjm3e9+d/ZajUaDer0OwNe+9jUsy+Lyyy/veM709DQf+tCH+NVf/VVA1U+Pk3LV73nPe3j961+/ad/Ly172sizbZmJigkOHDmUHmJVER/ArSLpk3zQXRvdxGCA3aXQvDOXXOz19xGGgLJzqLO74KIyPYpXK2JVerGJ5TVbRLmw52CByVVRvOPamtcrOFMuy+JM/+RNe9KIXEUURr3/96zl48CC///u/z3XXXcdtt93G3Xffzctf/nKmp6f5+7//e/7gD/6Ahx56iCAI+Kmf+ilARbOf/OQnsZIzpfe+9718+ctfJo5jfvM3fzObQHzkkUe4/fbbEUJw8OBBPvKRj2Rj+fmf/3kmJyexbZsPfvCDWWT96U9/mg9+8IMA/Nt/+2953eteByjhe9GLXoRhGOzZs4e//Mu/zF7rLW95C/fddx8Av//7v59Fw3feeSfvfOc7EUJw0003Za+7Gd9LWmP+8ssvxzRN3vve9zI4OHjG34HTsSXKBW8GZFJmN47CxM5JJg03qXevvHEvsXDmkFG4bn59Oh4ZRyClyspxclm+/WqgywVr1gNdLniD0h7dm1sguhdpE/JcntzgCFGzm1+fiL2TW5PxdEb1TSKSUs2OsykPohrNuaIFfp0QwkBYRiszJ43ugwAZhUjEponuhRBYxTJWsUx+OFbe+Nws/vQk/vQkRi6PU+nFKvesSWPyjgycMCAOgqSRuKMbiWu2FVrgNwDdo/tkgjaN7lFiv9Gje2EYOJVenEpvp18/MQoTo1jFxK8vrb5fvzCqd4lwdVSv2TZogd+AtKJ7u3t0n4jSRhcow7LJ9Q+S6x8kSvPrq7OEjZry60sVZeEUiqv+PhZG9X7i1euoXrN10QK/wVkQ3cexKoEchG0FuuSGj+5bfv0wUbOhvPpalaA6i7As7HIvds/q+/Xdo/pm0lYxhzA39kFTozkTtMBvMtJIdNHoHnUGgLExyx8rv151r8oPx4R1JfL+zCT+jPLr7Uov9hr49e1RvQwjwqCWePU5HdVrtgT6G7yJUdGoiuztUhm7rGrmCMtGxnHLw4835iIgYRjYlV6Ku/dTPv9ickM7APAmRqkdfoz6iSME1dlVH3/6Oao6+YLIdVUNnGZdlaLYQKnE8zldueCUz33ucwgh2KppyJru6Ah+C7F4dO8Th4HaZoNG94ZlkesbINc3QJTl18/SHD0BwsAur41fv1RUvxbpnmdCFEW88Y1v5Gtf+xp79+7l+uuv57bbbstWUaZUq1U+8IEPcMMNN6zTSDXrhY7gtyid0X1lkeg+3JBL/E0nR35whPJ5F1HcvR+7XCGoV2mcOELt8E9wJ0aJPHdVx9AR1Quh8uoDf1X3eaYsp1wwwO/93u/x9re/nXw+vw6j1KwnOoLfJnSL7qMwQAZ+W2NyY0P5zh1+fRwT1muJXz+FPzOF4eSS4mc9q9qGUJ31QOy6GObC1bE/+cp3qZ2aXNF9lncOctGLn7PkNt3KBX//+9/v2OaHP/whR48e5d/8m3/De9/73hUdo2bjowV+G5Jm5limiXRyysoJ51k5hrmxxN4wkpWxPcRRSFidw6/O4k2O4U2OYRZKyeRsZVXGLQyDOIqIPBerUFzx118N4jjmt3/7t/nYxz623kPRrBNa4Lc5HWmYuZxaYBWFqgZ7GGTlEzaS2BumhdM3gNPh18/hjp3AHRdtfn1pRf16YRjqc7E7SyWfLtJeLU5XLrharfLggw9y8803A3Dq1Cluu+02vvSlL3HddV1Ll2i2GFrgNR2Ijpz7ZDWt7xMnzYo3mo1jOjnMwRFyA8NEbjPJr58jqM4hTCurh2M4uXMW+/RgGLkNYP0za9rLBe/Zs4fPfOYzfOpTn8oe7+3tZWJiIrt988038773vU+L+zZCC7xmUVTbwtYCq3QFaLvYb5TFVUIIrEIRq1AkP7SDsLE6fr2yakI2QubkcsoFa7Y3ulyw5oxJs3DUBG2ImqAVIDZe+mUchYS1OYK5OSKvCYBZKLb59WfeEUpKyWOHn+Kyyy/fcO9Xs7XR5YI1q44wDNWyz3FaYp+WPWZj5dobpoXTO4DTO0Dk+1l+vTt2Enf8lOrCVelVKaTLHG+6nYzjDfM+NZpuaIHXnBPzxV5GUWbjSOSGEnvTcTAHh8kNDHX49WFtDmGaqh5OpQcjl1/meCVICRvgvWk03dACr1kxslx7226VPA584iCtkSM2hNh3+PXDO5L8+jn82Sn82SkM28maixv2Un69UAvF5MaYh9Bo5qMFXrMqdJQ8zktkVjIhTILejSL2SZvBcg8yipIMnFm8qXG8qfE2v75nQfaQACRCWzWaDcuqCbwQIg/8M5BL9vNZKeUfrNb+NBsXIQTCspNVtLLNxknKHQuxIWrbC9PE6e3H6e0nDjr9en92mtLe8xeMUYm8tmo0G5PVjOA94BYpZU0IYQP/IoT4RynlXau4T80GR4m9lbQqTMU+maCV8YYRe8N2yA0M4/QPtUR+Zopc/2CXrbVVo9mYrNqKFamoJTft5N/GycnUrDtCCAzLwioUsMsVrGIZw3ZaOfcboFSvECJpMVjBmxon8r2F2yT/yzhe8/Eup1zw3/zN33D55Zdz8OBBfvEXf3FNx6dZX1bVgxdCmMC9wEXAB6WU3z/NUzTblI7IPpdPVtEGSSMTJZrr1W1JCEF+eAe1I3XcsZMU95y3cBvW3qpZTrngxx57jPe85z185zvfob+/n7GxsTUZm2ZjsKprzqWUkZTyGmAv8EwhxBXztxFC/JoQ4h4hxD3j4+OrORzNJkEIgWFaWLmCKnVcKmPkciDbI/u1LXNsWDb5oR0qvXJuerGRq+yhNYril1Mu+M/+7M944xvfSH9/PwAjIyNrMjbNxmBNsmiklDNCiG8BtwIPznvsw8CHQa1kXYvxaDYPS1a+jNa28qVd6VVFzSbGwWg1//jnj3+N8cPzIuNzDOKHz9/JT7/uhUtus5xywYcOHQLgxhtvJIoi3vWud3Hrrbee2+A0m4bVzKIZBoJE3AvAC4A/XK39abY+7ZUvDcdZWOZ4lStfCiEojOykduQJZBSp3P6uWy7+yFoThiGPPfYYd955J8eOHeOmm27igQceoK+vb72HplkDVjOC3wV8PPHhDeBvpJRfXsX9abYRC8ocr1HlS8N2yA+OwPgkMo4QhslNt7+gYxuZ/L/a2UCnKxcMKqq/4YYbsG2bCy64gEsuuYTHHnuM66+/ftXGpdk4rGYWzf1SyqdLKa+SUl4hpfyvq7UvjUZVvsypWvDlMmY+D4JWa8IVbNxt9/aDMJBhoCZW548lvbLKWTXt5YJ93+czn/nMggqSL3vZy7jzzjsBmJiY4NChQxw4cGDVxqTZWGycwt4azQqRiX2pgl2uYOYLIERrgjaOzkl4036tSJBB2H0bRCurZpVoLxd82WWX8cpXvjIrF/ylL30JgBe96EUMDg5y+eWX87znPY/3vve9DA52y+XXbEV0uWDNtmF+5UtIa9qfeZmBQ08e5tKLL0KGIYZtdy07vFZWjWb7oMsFazSLsNKVL4VpZQcNwzEXTKuq3HhAxiDOvO68RnOuaIHXbEuWrHwplMVyOrEXqPz42PeQYYDo0ilKIJQdFMcbqtWhZnuwZQReyiX8zrb7FzWkTmdVyUVvLPISi43lNNss8vhpnyZl5wPzt5n//oTAsEyEZSmx28YWwrlUvkxX4MowRC6ajy+y7+d2/pw1a8+WEPg4ivAmpxZkSqiJrpTTzTWIZW7TtnUqmqL7Nme0z+5Xz+L1ujxtMbLxC0zHwXAcDMtCWOa2Ff1FK18GPpimsnHmP8e01HZhoJp7z3+ctIyBtmo0a8uWEHikRMYxZi53+m01C5BSEochke9DLEEk5QJS0bctDNNUmSPbiPb6OJFpEboNTKuLwAOGbRP7/qJWjSpGJkHEXQ8SGs1qsDUEXnNOpELWjowT0fd80pWZQgiMnJ1F+ttJ9A3bxgxt4ijEMBf+bIQwkkg+RHaJ9AUgRSLyhrZqNGuDDiU0XRGGKuVr5hzMXA4z5yAsizgICeaqeFMzNMcnaI6P483MEjSaRH6woguKNhJCCMx8ASFZNIdeWJbKtw+CrmZa0qp7RXPjT1cu+MiRIzzvec/j6U9/OldddRVf+cpXVmzfmo2PjuA1y0YYAmFY0BbtyzgmDgIi103uAGGZGLaK9E3bUmV+t0AGiTAMjHyByG10f5wkqybwkWG44Kwo3WqlmoMsp1zwu9/9bl75ylfym7/5mzz88MO8+MUv5vDhw+e0X83mQQu85pzI6r3MF30/IHI9Apl4+qal7B3L3tSib9g2Mlj8ZyMMA2GaiVVjdLdqVqiPa3u5YCArF9wu8EII5ubmAJidnWX37t1nvT/N5kMLvGbF6VbkS8YxsesRxS5Bup1lJtk7tvLzLWvDe9NCCMxCAWjVjPz4//5rDj92tHPD1Ko6zUFMLJLudN6l+3jtf/yFJZ+7nHLB73rXu3jhC1/IH//xH1Ov1/n617++5GtqthabL4TSbErSRUXK01f/BILIdfFn5nAnp2ieGqM5MYk/VyVyXbXoaAOV0kgRhqm6Ni01tvRAdZrxdytWtpJ8+tOf5rWvfS3Hjh3jK1/5Cr/yK79CvEXnSTQL0RG8Zt0QpoEwWzGGWvEpiVyXsNHyuQ3bwnBymLatcvTXqXVfO0IoD10Ct//2q7puE4cBMopUbnyX8abSfrZrDpZTLvgjH/kId9xxBwDPfvazcV2XiYkJ3dlpm6AFfouRrpiUUaQW30Rxdl2m1+MIM5fD6e3ZUGmOqsa76CL6MVGjSSjriS8iMGwrs3eEuU6ibxgQR8hFjBZhWVkDccN2llgAdXZ9XNvLBe/Zs4fPfOYzfOpTn+rYZv/+/XzjG9/gta99LY888giu6zI8PHzG+9JsTrTArxOq2FWsSte2CXAcRQsFOb0ed94fd9sujk6/4DXFEDg9PTj9feQG+rEr5Q038Zk29mg/EKWiHzQaUM/iYEzHVn6+vTaiL4RQdeFlTLelwwKVaqoah4eILvnz55JV014uOIoiXv/612flgq+77jpuu+02/tf/+l/8+3//73n/+9+PEIKPfexj6372o1k7tkS54DgMcScmV3wlq2yLhDvFNlKR2WJC3Ca2i4n2GedCG0aysMhoiZdhJGUFktvJY+kCpAXbtt0f1hv40zN40zOEtToAwjRx+nqV4Pf3YZVLm0YMZLKaufOzTUVfrcZdybo7adnWdL9qb13GBcjAR8bxqlk1mu3DtiwXrFq1Ba2ouFsUHEfEYZSJwFLCHCfCzJlORhkiE9t2MTYdZ57YzhfjdvFNbhtmm3iv/A/fKhTID6nGD7Ef4M3MZILvTU5RRVkMuf6+TPDNYmHDClDWhGNepB9HMVG93ll3x3YwcitTdyctRCYXsWoEgG0jfW/VrBqNZjG2hMAf+8evL1+MEyHIRNUwMUxDRXj5XHexNc024V7icWNz/jgNx6YwMkxhRHmzkefhTSvB96dmcMcnku2cTOyd/j6sQn49h31aVAkGE5gv+iFRbfG6O+mB90z2czqrRpi2avEXRYvMe6zcAiiNJmVLCHz/5U8jaNQxc7kOS8LoKsQby2PeiJi5HMWdOyju3IGUKqvFn1LRvT81jTs6prbL5zsE38w56zzy03PWdXcSe2eJFwYpstz4BQ+bZmLZBWoB1Lyt0gVQxDFSWzWaFWJLCHzlwvNXxYPXKEG0CgWsPQWKe3Yhpezw793xCZonTwFglYotwe/rxbC7VVXceLRKMLTuk7EkDkIi1yOVbLtcwioVF60LfzqrJmsOEgSwmFUjJUJbNZoVYksIvGbtEEJgl0vY5RKlfXuQUhJUa8rOmZ6heeIUjWMnALArZZwkund6ezGsjZOSeTrm192RsXqfYdPF6a10f87prJq25iAijqBLH1eEtmo0K4cWeM05IYTA6ang9FTgvH3IOFbVJhPBrx89Tv3IMRACu6eS2TlOb8+mssuEITDzOeIwwpucVpP13To0ndaqae/juphVg7ZqNCuCFnjNiiIMQ6Va9vXCBechowh/di4T/NrhI3D4CBgGTm9PJvh2pbIpJqkNy0SaRtYkxTBV2YJUiM/IqgnDxfu4sjyr5o477uAtb3kLURTxq7/6q7zjHe/oePypp57i9a9/PePj4wwMDPDJT36SvXv3AmCaJldeeSWgFkR96UtfOrsPRbNhWZbACyFuBN4FnJc8J7EL5YHVG5pmKyBMk9xAP7mBfkCltPrTs5ngV584nG23WXLw0zIFQgjiMFIHprZFVWdi1Szdx3Vpq2Y55YLf9ra38ZrXvIbbb7+db37zm7zzne/kL//yLwEoFAr86Ec/OtePQ7OBWW4E/xHgrcC9QLR6w9FsdQzLIj88SH5Y5eBHvo8/PbsgB9+wbZz+luCbhY2Zgy8MVXQsDsOsiqYS+GVYNaft4wrIGEl3q2Y55YIffvhh/vf//t8APO95z+NlL3vZCrxrzWZhuQI/K6X8x1UdiWZFyGrRxMnCGSmTSDJlXktv01qVhVTLxXQcCjuGKexIcvBdN4vuvekZ3LEkBz/ndC66ym+cHPz//7s/xKOPPJ4tpmoJfKtWZPdVrjLJxV8YpV962YX8zu+/Sfn8dLdqllMu+Oqrr+bzn/88b3nLW/jCF75AtVplcnKSwcFBXNfluuuuw7Is3vGOd2jx34IsV+C/JYR4L/B5wEvvlFL+cFVGpclIBVsJdfsldBadUYIiDAHJ4i0MQ2WuGAaGYaqVtolHjJREfkDsNlWzbVi/ol1tmPk8xV07Ke7aqXLwmy7e9LQS/MlpmqeSHPxCvjVh29+H6WyAHHwhko58idAz/3A6b3MEUpmdSQ21rrH+OWXVvO997+NNb3oTH/vYx7jpppvYs2cPZrLQ6qmnnmLPnj088cQT3HLLLVx55ZVceOGFZ7wPzcZluQJ/Q3LZXu9AAres7HC2B2l0rYQ6bon4AhJP11Sn/ulim2zhlhDKv22/PAMRMCwLigVkFBH5PlHTI/K9ZJ/rL/ZCCKxiAatYoLRnd5KDX8+i++boOI0T7Tn4/W05+GuXP/A7v/fGBfdlIm8YZIunujxXAnHymZ/OqkF0plUup1zw7t27+fznPw9ArVbjc5/7HH19fdnzAQ4cOMDNN9/Mv/7rv2qB32Is61cgpXzeag9kMyPnRdiZRaIeZb4RK4SBsNRKW0w7ia4NFXULodq8JdH2WqQSCtNUi5kKhaTdnk/YdLOVnVldnA1Qg90ul7HLZUr79qrc9Fo1W2XbOHGSxrHjANiVSmLn9GL39Z5R6YGVGiuAjGLlrgiJFEb3rBrbJvZ9ZBh0zapRUbwKBtpbAC6nXPDExAQDAwMYhsF73vMeXv/61wMwPT1NsVgkl8sxMTHBd77zHX7nd35n5T4AzYZgSYEXQvyylPKTQojf7va4lPJ/r86w1pfMAmmLrjuj7LYTb0lSZCwR7I5LA4ShbJOzjLLXGmEYmPk8Zj6fNdQOm00l9rFUZw4bpLWeSMsd9/RQPn8/Mo7xZ+eyCL9+9Bj1I0chzdUfUBG+3VNZsxz8dBJWRjEIqbJt5m8j0j6uEdI0l+jjKsFo5d4vp1zwnXfeyTvf+U6EENx000188IMfBFRVwl//9V/HMAziOOYd73hHx+SsZmuwZLlgIcSvSyn/HyHEH3R7XEr5/1vJwaxmueAzm3wUCFO07BCjrdyuITLRTv3sjSB2q00m9q5H5LqJ379xxL4bcRjhz85mq2yDag1QBzG7r7ctB798xu/h8RPHedqll57Rc2SkEtBEmjvf/hhLWzVqG5mc1W2eFcGalWVFywVLKf+f5HJFhXxVkFJNFnabfEx+GNnko9kWZWeTjy1bZKNH2euBMAzMXA4zl0P2VIj9gNBziZquiuxTsd9Ai5UMyyQ/OEB+cACAOAjwZ9py8B9/EgBhmTh9bVUyF6k3c64IIy04FqkJ2bZoPlsAFfinaQ6ighP9/dQsh+UudMoDbwAOAll+mpTy9as0rjNCGAZ2uayi6RWYfNQsjRAia5wtKxXiICByPaJmkziWYIjTV19cBwzbJj88RH54CIDI8zM7x5+ewZuYzLbrqJJZyK/M90eQZTAhQYahum0obz49S8wWQM3bZ8uqibfNmaPm3FhuqsFfAj8GXgT8V+CXgEdWa1BnijAM7Ep5vYexLRFCYDoOpuMgK2VVgdHziBpNYhmA2JhiD2DmHAo7RyjsVA2ow6bbIfju2HiyXY78zhEq5+9f0DrwTEVWiCQKF0Aq1lJmgi0sO6lV42PYi2XV6OYg25Gz6b63XIG/SEr574QQPyel/LgQ4lPAt894b5otjRJ7G9OxkeUSMlRiHzabxH4i9vbGFHsAq5DHKuykuDvJwW801eraqSnqTx3FHRun92mXkOvvI2fbTE1NMTAwcPYir24AiT9vpGsXVq+Pq2ZzIqVkcnKS/Bku8FuuwAfJ5YwQ4grgFDCy1BOEEPuATwA7UKb4h6WUHzij0Wk2LUIIhK0aYFulEjKMWmIfqK+TYVmLdDdaf4QQWKUiVqlIae9uvKlpZh99jKl/vZ/Crp2MXLCfsdlZxicmzur1s6ysdoHOcueFyrqRckFzkgXj3KAHS83Kk8/ns0Jxy2W5Av9hIUQ/8F+ALwFl4PdO85wQ+I9Syh8KISrAvUKIr0kpHz6jEWo2PUrsLQzbwioV1cIqz1di76mGGoZlblixB8gN9DP8zGupPnmE+tGjeJNTDF5yIfldu88qipZxTOQ2AKNjYlplK4UIy8CfGce0LYp7zuu6jzgMMXIOVq5wLm9Ns4VZrsD3Aq9Lrn8wuQyFENdIKX/U7QlSypPAyeR6VQjxCLAH0AK/jUkrKRqWhV0qqlZ5vk/YaBK7npoQt86sJ+paIUyTnosuoLBjiJlHHmPmwUfIDQ3Se+lFZ9xNTBgGhpMj8lxE289QZSs5xGGI6ZSI3Cr+zBS5/sGu44k9H2k5G/rgqFk/lnt+dy3wGyiB3g38GnAr8GdCiNMufxNCnA88Hfj+aTbVbDMMy8IuFikMqQqTdk8FIYSaqPU84jA8q8ml1cSuVBi67ulULrwAb2qa8bvuoX78xBmP07Bs5bdHCwu0GpaFWSojLBtvcpyg0ViwjcoWE4RuY8N9RpqNwZILnbKNhPhn4MVSylpyuwz8A0rk75VSLroELtn2/wX+u5Ty810e/zXUAYP9+/df+9RTT53N+9BsMeLExlHF0JRnvxHq48wnbDSZffQx/OkZnL5eei+9GKtUXPbzM6tGdE97lFGINzWGMC2cgRGccmlBtB6HAWauoHsSb1OWWui03Ah+hLYqkqhJ1x1Syua8++fv2AY+B/xVN3EHkFJ+WEp5nZTyuuHh4WUOR7PVMUwTu1ggNzBAYXgIp7cHw7SIfX9DRfZWscDANVfS+7RLCGp1xu++l9rhIyr9cRkIw8Cwc8i4e5sFYVpY5R5kFBDW5nCnZgibbsd7F6ZF5DWzlbIaTcpyPfi/Ar4vhPhicvulwKeEECUW8dSFCkc+AjyyVWvWaNaGhcXQ2urjbIBiaEIIirt3khscYO6xn1B94jDNJKXS6eneoLvj+ZaFESurxuhShsDMl4i8JpFbw8wXCGo1ItfDLpdU2mnSQSpym5jFjdsJS7P2LMuiARBCXAfcmNz8jpRyyaIxQojnonLlHwDScOY/Sym/sthzzrYWjWZ7slGLobnjE8w++hNi36e0bw/lA+efdtJYxjFRs7HoClXV6nAUw8lj9wyowmRRhFUsYhULCMNQVk2+gOloq2Y7cda1aNpJBH3Z6iul/Be6N7LRaFaEjvo4G6gYWn54CKe/j+rjT1I/ehx3fILeSy8ml9TE6UaWVeO7XRc3GZaFVeohrM8R+y5mroA0TcKGS+S6WJUypuMQuc1k5bDOqtEs34PXaDY0qdjnensojAyTG+jHyOeyOjmxH7TV6F99DMui99KLGXzG1WAYTN33IDMP/zhb5NX1PViWmmdYxI83CyqrJqjOIOMoqQlkIwyTYLaKP1dFxpKo2dwQ8xOa9UcLvGbLkdbHyfUkYj/Yj1nII8OkKJrvL3sS9Fxx+noZvv5ayufvpzk6zvhd99A8NdZVgIUQGE6uo+3f/MftSj/ImKA227rfVLnzMgjwZ6v4tVrWhlGzvdECr9nSpGLv9FTIjwyTGxzALhaz0glrIfbCNKgcOJ+h65+BWcgz8/CPmb7/IWUlzd/WMFThtkXGZFg2ZrFC7DWJvM7nG7aNYVtETQ/31Ckid9EEN802QQu8ZtuQFkOzK2XyI0PkBwewS0VkHKnI3vNVDZhVwi6XGLz2GnouPoA/PcP49++lfuz4gmhdWDaGYSwq8laxgjAtgtrMgm3SUs6xgMboKbzZ2TU7W9FsPLTAa7YlQggM28Yul8kPDZEfGsQul1QVyWQV7WrklQshKO3by9AN12H39jB36HEm772PoF7vHFsuj0xbRnZ5DbvSD3FEWJ/ruh/LdsAQBNU6zfHJBbnzmu2BFnjNtkckZYztconC8KAS+0oFCYnY+ysu9lYhz8DVV9B72aWEjQYTP/gh1SefyqJtZdUsvgDKsB3MQpnIrRP53a0Yw7QQIkYYAn9G1biPw3BF34dmY6MFXqOZR1oIrTCUiH1PGSkhcr0VjYKFEBR37WD4WdeRHxmi9uRTTNz9Q/xZFZUrq8Zc3KopVRCGSVidntdfuPX6UqpyB2Y+n/UuDmp1Hc1vE7TAazRLkBZDyw8NYFfKxL634lGw6Tj0H7yM/quuIA4jJu/9EbOHfoKMotNYNQZWpR8ZR4T1atfXThdAxWGgJmEdh6BWw52Y1Jk22wAt8BrNMhBCYJdL5AeHEIZB5LkrnlefHxpg+IZrKe7dTePYCca/fy/e1AzmErVqTCeHmS8SNWvEwULBFkIghEmcZAupSdgcCIE3OY03O9u1mqVma6AFXqM5AwzbIjfQj13pIQ78JRcundXrWxa9l1zE4LXXYFgm0/c/yOyhx5FRvIRV0wuGQVCd7h7pGwKJ7DgAGKaJkXOIXE/ZNg29OGorogVeozlDhBDYpSL5oUGEaSpvfoVTEZ3eHoaufwblC87DHZ9g6kcP0RybIO6yH2EY2OV+ZBQSNhaxaoSR9HmN2u5TawQMyyKYncObmiYO9CTsVkILvEZzlhhWEs339hAH4YpH88IwqFxwHkPPfAZWsUjtiaeYfeRQ1wVMZi6PkSsQNarE4cJxqOYgprKW5k3ICsPAzOeQUYw7MYlfrZ3VAUtKSRxGhJ5P0FzZCWnN2bHsYmMajWYhQgjsYgHTsQmqNSLXxXCcFW2GbZdKDF57NfVjJ6g9/iSTP3qQ8v49FHbt6CikZpd78XyPoDqN0ze8oMiaMARxUpStW8VJw7aQlklYbxA1mzi9PQuaiMRRjIwi4jAijmIiPyD2AkI/UJPPiabLWJLvr1Ac7tPli9cRLfAazQpgWBZOXy9hM0dQVTaJ6Tgr9vpCCMr79pAf7Gfmx4eoHT6KOzFFz4XnZx2khGFil3sJqtNEzRpWcWEtemXV+EtWnBSmQeQHVI+dUh20nBykYh7LpESsRCIwDKFKNJsGlp3LxFxKiTtTBSkpDvd3NBbXrB1a4DWaFSKL5nMOwVyVyPUwHHtFo3mrWKTv4NNwR8eoHT7G1P0PU9yzk9Le3arkcK6A4TUJ63MYTgHDWvgTlzH4czWEo2yZyA+Igog4CIjDZKEVSTAeRSAEdqWEVSxgmct7L2qeIo87W0NKSWmkf0U/B83y0AKv0awwhmni9PUSuR7+XBUIMWx7xawK08mRHxrC6e2jfuQojWMn8SamqVx4Pk5vBbPYQ+x7+HNTCKei7JQwIvZDojBKqlVGCNNS4zIMDNPAsExMx164w1gSey5BFKouUl0OGt0QQuCUC3jVOjKWlHcOaJFfY7TAazSrgBACq5DHdGz8Wo2w0cS07QUNs88KKRGWReS65HfvxiiVaR47zsxDP8YoVTB7e7Fsge0E+LMzxNJCGAJhGFh5O1nhKpFxjJVTNWuWxBAYjoOMIvyZWcx8HqtYXLbt4pQKBPUGtVOS8o5BxDLPAjTnjhZ4jWYVEaZJrrcXM5dT0XwUnTaal1Iio7g1oZnaKH5IHIbEYYwQEAUBMowwLANn1x6iuRnC2Vmk28AYGUY6FpYTE2MyP2Eu6+Pqe5i5/LJ6rwnTTDJxfCLfxy6WMHLLOzOxSwX8hkv15DjlXcMYWuTXBC3wGs0aYOXzmI6DX60RNZqQWBVKxGOiIBHwICIOQyQgZOKDC7raKFY+l9WEF4bAyo9g9fTgj47inTxFWC6RHy5jWD4xOearuDAEcRQhwxBhL1MKhMq2IZYEtRqGb2MVixjW6c9MnGKeoOlRPT5OZffQsp6jOTe0wGs0q4CMY+IwjcAjIj9M/vkE9aYq+BVLDNtEICDNRjEMzLyzPL9eqEyd0HNBqmbdZj5Pfv9+gulpgqkp6o0m+aEezB4TxEJ/XRgGUehjmebprZp2DIHh2MgwxJ+ZxSoWMAv5047bLuQImh5zx8fp2T2kDhaaVUN/uhrNWSClRCa54HGUTGAmUXjkJStGhVCROBIMA8NQ6YROTwmnUiJsNIncpmoMfraTj4aBYdrEcZiJqxACZ2AAq1zGGxvFHZvBrDZwRnaqloBtZFZN4GE6y7NqOp5vWQiJei+ej10uYthdJmrbsAs5wqbP3PFxKnuGMbXIrxr6k9VouiBjNQkZR1FioYTEQagW9HhhYqNIBKrOixBtEXjOQhinyYEXYJeLmDmboFYn9lW1xzMVWEgWKHkRMpYdE5+G45Dfs5dwbhZ/YoLmkaPYg4PYfZ2LjzKrJgoRy8yQmf9eDMdGxjH+bBUjn8MuFJacTLUKDqHrM3dsjJ49I5iOlqLVQH+qmm3J/EnMOAi7+OCpgCuyRT2WieXkViTt0bBtnN5ewqZL1GyoicwzzbRJasqErgvC6BRvIbB7+7BKDv7YJMHEBFG1ijMygpnPt7YzDKLAxzLO0KppH4ZhIGyD2PPxPB+np7xkNG/lHULPZ+7YqBL53NKRv+bM0QKv2XK0slCiTMgjPyDOBDzMVmQqC0X9l0bghmVgrJCALwdhCOxS4dyiecPAsCziOOo6bmEVyO8aJKw18cZncY8exe7vxx5QuempVRMHHsZZWDWtHaWTsCqat8pFrLYDyXysnEPkB8weG6Nn77BK29SsGFrgNZsOZZ3EmYjHQUTsB4RBSJykEgKtCFyCMEXmgZs5B2sDLp03LAunt4eo6RI2mkkJgOVH84ZlI/14gVWjEEiRw65IzGIRb2KOYHqasFYjNzKCmeS1x1GEOFurpmMw6kAZ1hrIMMYqFRY9YJqODUHI3NExevaOYOW1yK8UWuA1G4o0+m6PwKMgTCJvFYHLKEIK0QoykzRCZZ8YK2afrAdCCKxiAcOxCWoNFc1b9vLqvhoC07EJXW+BVaMwkdiYZkBuxyBWpYI3NoZ7/DhWTw/OkGpmEgcB5jlYNa3xKAsqcl1kFGGXS4v68ulE6+zRUXr2jmAXFhZD05w5WuA1a4qMZeZ7yygmClXUHQZBK/qW7dOXiXgbKgJf1gTmFkBF8xUi1yOsN9RK1OVE1YaprJooQpgLBVpiIwkx8KFYoLB/P8HUFMH0NFG9jjM8jCgWEaGPYefO3qpJSSZg4yDEn5vDrlQWzX83bQshBNWjo5T3DOOUCue4c40WeM2K0j5xKaOoLfpWk5gyaEXfqYwLU2QReHtFwu1OWu7AsG3C1Ju3rNNG1oalMloWs2pichi4CHwwcjhDQ5jlMv7YGN6pU5ilEgwOIgzz3K2adEy2lZQ6mMOulDAX8doNy4S8Q/X4OOXdQ+TKxRXZ/3ZFC7xm2WSpg2HUir6Dtgg8CJXfDa387yR90DAMFaHpSbQzxrBM7N4KkecR1rpH81JKdeYTS2VzSUnk+ZAeLNseQwLSh7hBLB2kFCAlcb6HKKjSPDUNp6Yxy2WsSi8I9bcned32652v27qe76/Qs7ezJr0wTYSQBNUqMi5h5rsfzA3LxCo41I6Pw+4hcpXSan68Wxot8JqMpVIHVd2TePHUQcPAKmyd6DsOQvx6E7/WJKg1ifwgE7eWwMWt66nIxa37W7fTx+NsW9peS4lj6zmne00ZxQsEdnWYOqdn9563k93PfFrnQiZDYNgOYb1OHEXYpWJ3kTdN7GKe2slJZCTJ95XPaSzbFS3w24w4jJRwh9FpUgdb0bcwDEzLAkdsCQGXUYzfcAlqDfxaS8T99Ha9SeT6p38hVIojQrRSDQ2RtMdLPivDQCSTwIi2x9LnCVVjBmG2PUfd33m7/TlJNcggTKJ5M0lznLcdIOMwGUPbmER6GWOKEGlYIOx5j0HUqBPOzAISZ3AAe2AQI30f7a81/3WB8YefZOyBJ2lMzLLvxisoDvW2fWhg2A6x6xGEEVal3LX4mDAN7GKO+ugkJGcFmjNDC/wWJe2PGQchoecTNZM+mXFE2pMnnbjcyKmDZ4qUkrDpJcLdSIQ7EfF6A7/aJGi4C55n5myccgG7VKC0Y0BdLxdwykWcsspRT0W8XXTXkziKVSTs+0mmTZdJ1TAkCnyMRdItBR6CkJg8MG+bwR7iHUP4ExNE9Tmi0MPeswezcPrJz5ErDlDeMcDR7z7IE1+7hx1XXcjQ5ee1PrN09WsQEszOYvdUutaZF4aBXcpTG5tCSklhoOe0+9a0EBupMe51110n77nnnvUexqZDxjFxoCY0Q88nbHqEro+UMlvEY1gmhmlu6lrcUkoiP+gQ7Q4Rr6tIfH7DaGGZOKUCTrmQCHex7boS8c1aD0VKSewFBPU6oLJvOjJfJMSBRxzHKvpe+AoYNFGTr3m6pc3EsSRuNPDHx5BhiD04SG5kx7Lq50R+wPEfPMLckTFKOwbY++yD2MXOFEiZ2IJ2uYy5SA68jCVB3aUw1EthoGfdD64bCSHEvVLK67o+pgV+c5F25wn9gMj1CJoesRe08sINocQ8PW3fRMRhlNkkQbuA11uCHgdh55OEwCmlQp3+K3bcNnPLrM64iWlF810ybWJJ5LsdFkonISYeMTaShQKb+v6mbeONjxNMTyFsm/zu3Vjl09smUkqmnzjByXsexbBM9jzrcnr2DM97A5I4DJesSimlJKg3yff3UBzSzbxTtMBvQtotlsgLCL1EzMMom+RM64MLs9uilo2FjGOCutvyuWvNRLhbgh528b2tQq6LaBczO8Uu5nVD5zYi1ydo1CFOSgakSTSntWpcBBExBbqtqkoncs1cjrDRwDtxnNj3sXr7yO/cuax0Sm+2ztHvPIA7U2Pwkn3sePpFneOREAcBRs7BLpW6/l2VyLvk+ypK5PXfXgv8Rkcm0UsUhOoH2vSIXJ84Vp17EALDNDMx32i0+96taLvRMXkZNFyY91UzHbsj0rZLRZxKIbNT7HJhUUHSLI6MJUGjQdR0lfVkGMu0ahqAsYRVE2MYVqty5Pg4/sS46lq1axdWT+9pA404ihj90U+YfPQo+b4ye2+8knxvZxpk7IcIy8ReZPI1FflcT4nSyMC2F3kt8BuINP0wDkKCpkvo+qp+OAAyKXaV+OUb5IsbeYFKGaw2Mp+7Q8DrTZW614YwjYWRd6nT/+7a4FmzYsR+QFCrIWXizUtJ6LmtrJd5CEIMPGIcJAv/Nq0+rvmsI1XkurgnjhM3m5jlCvlduzCc0691qB6f4NhdDxGHEbuuvZT+C3d3jEkmXa2cSqVrUxApJUHDxSmXKO/o39bNvNdF4IUQHwVeAoxJKa9YznO2ksCnDSGiMFIWi+sSNgOiIEQItYqzPSpfL4tF+d6ddsn8tMFuvrddyrcEvLTQ/7aW25VIs6rIWBI2GkSuh7BMiOMlrBqJgQfLsmpaFSellARTk3ijoyAEuZEdqkrlaf7+QdPj2Hcfoj46Rc/+EfY887KOg76MYzWpWy5j5rvXpgnqTexSYVs3814vgb8JqAGf2OoCn1oscRARej5BwyXylMWCasiGsFQ517VuNiylJHR9vJka3mwNd7amrlcbBLVGd9877+BU2oW70/+2i7ltHTFtRuIgUG0CoxgZRwCLnCHGSVbNElZNFKvv8rxa77Hv4544QVSvYRQK5HftPm1KpZSSiUeeYvS+x7ELOZUzP9zX9qKSKAiwikWsYvfJ16DuYhVylHcNbctm3utm0Qghzge+vJUEPuvuE4aETZ+g6RJ5gVpRmCz6UJOf1ppaLFEQKgFPhNybaYl55AetDQ1BrlIi11NqSxNsE/FSYds3Q07LEcdhpFaRtlYOABIpBYYpsnK+m0VUZCwJm03CRl012rasRayaAAP/jKya9sfC2Vm8UydV6uPAgEqpPM1cSmNilqPffZCg7jJyxQUMH7yg9fuREAc+huNgl8tdf1dB08O07W3ZzHtDC7wQ4teAXwPYv3//tU899dSqjedMicO0WFZA2PQJXY8oCCH5wQvTUF75GqUkxlGMP1dXwj1PxOcv3nHKBXK9ZXJ9ZfK95ex6rlLU0XdCq6+qKs2QlkAThomZs7EKOaycg2GrOZG0Dk8cxUSeP699n2J+/9WNmOEUByHe7Ayx62F0TSGVGLhAfEZWTcfjUYQ3NkowNYWwLHI7dmL1Lj0JGwUhJ37wY2afOkVxpI99z7kCu9hqFhIHoVrdWi53FfGg6WFaFpU9w9tK5De0wLezXhG8lFI1jQhCQj/JYmn6ygNMWv4YVmvyc7XHEtSamXBnlsqsslVo+3tZeadTxNPLnpLuVt9Ge4enOIzTLqqqWmPOxsrnsPIOhm1lawjO6PVjqWrXJweLyFdBQfpPlT+GzK5LhN9IykCsB3EsCWamCRsuwrIwrPnjSK0ak5gc3a2aCNNyEEt816JmE/fkCTUJWyyS27W7o1XgfKSUzDx5kpP3PIowDPbccBk9+0Zaj4cRUspF2wGGTR9hGtuqmbcW+DbaqyCGbrLq02v9CEW66tMyV+3HJ6Ukcv1OEW+zV9ozUgzL7C7ivWXd+aYLLSGPssqWAIZjZUJu2lYm5qsdXXe0DwzVdy/yfHUQ8AKVCqu2RCJaxdsS8V/N8ckoJqjNqXmYKELYnZZNy6rJIbtUNUkLoymrZvFxSikJpqfxxkYhirAHh8gNDy9p23hzDY5+9wHcqSoDF+9l59Mvbh14kzMpq1zC6jL5Gro+QiQivw2aeS8l8Fv63We1WPwgE/PYD5BCxVIiWfVpFVYn4yP1xbuJeOR18cX7yvTsHekQcbvUfWJpu5NGze0+OQgMy8DO5TB7HSwnsVdW8WB9OoRQxcAMy4QcCxzt9gNS1jvWC7KVymn1TvVibbbgClg/wjSwCiUwTWQQEjVdZJKmCyCxkIQIPCQm86P4rChZ4GEu0cdVCIEzMIDV04M/OkowOUE4O0Nu5y6snu5lB3I9RQ684HrG7n+ciUeeoj42zb4br1RVJbN2gHVkGC1oB9jRzHvvyLZOx13NLJpPAzcDQ8Ao8AdSyo8s9ZxzieCjJLe8a2EtCYa9OhaLjGK8ar1DvNPLoN7pi9vlQibc+b42X7xc3LYpXqcji4ATAQSlI8IQqkBa6pNbporKt9Dn2N79Ss0HBUReSOT7xH6oSggDLetHqEnfxP9f1j6kJHKbWVnjsNFERu0TsMqqkZhIulsrcRRh2s6ym4NEjYaybVwXs1Qiv2s3Rm7xFn3VE5Mcv+shoiBk5zMuYeCiPWps6cpX28auLJx8jfyAOJJbvpn3ll/oFAUhs0+dIj0nX+nCWmkNjG4ZKvN9cTPvdBXxvPbFT0tmrYQxtPnkpmNh5R2sQh4zFfJtNIm2GGnjlTjpnBX7SYCTdM5CpHX7kwV0i1g/MooJm3WEqb6fsecRNpsgklIY+BgEROTodtLfyqopLLuPq8qdn1K2jZQ4g0OqXeAiZ1ph0+PYXQ9TOzlJZe8we264LBPtOCmb3K0dYOQHxGG8pZt5b32B9wNmnzqFXVp88mY5hK63IApXuePqVDBFWOYCEVeX3T1BTSedPrmyVoSUGE5rwtN01s4n34qojJ84m/wN26yfOAgXWD8yipBRgOk4CEMQhzFhs6FqzlsmpqHORlVWTZcaMbFU81dLWDXdiIMAb/QU4eysKmCW2DZd35OUTP74CKP3/QQz77Dv2VdQ2tGvHosiZCS7tgNM20Zu1Wbe29aD74byxdstlWp2fTFfvLJnmFxvJRNz7Ysvj/bsEpks+kqLpFn5HLkeBzNnY1oWhr1+PvlWRBgGpmNgJj/xdsnrtL0iYj8k8HyC2TlC10NNUkmkYSGFJGp6xJaB7UQI4SNZKJLCECrVNLF3loth2xT27iPsH8A7eYLm0SOLljwQQjB02XmUdvRz9DsP8uQ372X44AWMXHFBqx3gXBVZ7mwHaNoWAqgeG6WyZ6Qj9XKrsyUj+G6+uDdbx52pEdSbHc+1S4WWldJuq1S0L75cOgQjTDKAhMQQBmbeUfZK3klWP24tn3wrIaOIoF5T81bpYq8k28ybmUWGLrYj8T2TOBJZIbzU9knbgZ0uq2bR/UtJMDmJNz6mbJuhYZyhoa4H/igIOXnvo8w8cZLiUC97b7wCp1SAGOLQx8znsea1A4zDiND1N2Qz7yiIMO2zsx23tEUj45jj33+ImcMnCepNJeZz83zxnN0m4pW266Vtkyu7UsRRnOV7t1eHNHO2slbyOazUWtH2yqYj9JrEnr+gu5KqGNqkeeoYSIlZHkzKCIRZgkMUREgZITARjo3l2Gc1VxIHAd6pk4RzcwjHIb9r16J152cOn+LEDx4BIdhzw2X07t/Rmny1LDX52hZQxFFE2PQp7xpc92beURjRrDaojs8SuAG7L9uHdRZ6tLUtGiE4/M17iMOIfF+ZwmAvfQf2dHjj2hc/c9pXbcq2mjqGZWEVHKxcDjNnq6jc2jiVLzXnhunkkUGIjCOE0RJnIQR2sQgju2ieOoZ0q9g9/R3dmdLJ1sj3AQu/4RE2VJGzM8lHN2ybwr79hLUq7smTNJ96Cqunh9zOnRh2p23Td/5OikM9HP3Ogxz9lweoXTjJrmsvzdoB+vPaARqmiVXIUT0xgdzJglLFq42MJW69SW2ySn26CoCVcxYETCvFpo/gAZpTczQmZnDKp+8VqekkbSwiuy3XLzjY+VzLJ9+g9eg1K0schYT1GsLsXqumOXaSYG4Gq9yPYdoLFkgpoY8wLIc4krizdULXQ5hK6M/krE7GMf7kBP74uOreNTyMMzC4wLaRcczo/U8w8fBhcj1F9t54JYX+SjL5Gi9oByijmKDhUtoxQL5vdZt5Synxmz6N6RrVyVniMMa0Ley8kwVGzWqdvZefj3UWC7O2dgSPqrvSnJxd72FsCKSUWU6zlFKt0I3brksgWRQEbT55sXBOy/U1WwfDtDByOWLP7zphmh8aIWzUiL06Zt9wZumkB3/VlNwkjtQK8eJAmTguZ/0EDMPEyC1P6IVhkBsewe7twzt1En90lHBmRjUYKZU7ttt5zUWUdw5w7HsP8sQ//YCdT7+YgUv2YQhD1cWPW+0AhamaeddHp5Hx6jTzDr2AxmyduYlZQi9AGAZOIbemc1BbQuC3Ei0hnifU2fVWFpqEbGJLINUdRmvSS9WbT/Kek1LFhmGobQwDU/vkmkVQVk2AjOMF0bIwTPLDu2iePIoMPezeHsJqjTiKMJJoXv0z1RliIvT5njy5niJezcWvNhBCzd0sJ3vKcBwK+88jrM4p2+bwYazeXnI7dnbUpCnvHOCin30Wx+96mJP3HqJ2coo9z7ocK+cQNhrEcYRdVO0AhaFEvjE+o8a3As28ozDCrTaYG5/Fq7lgCJy8Q6Fnffx+LfCrQGfErHzJLHqOJekiHuhMGU7NsnQlomEamKYJyfX2ypXpF1RFS63r2gvXrARCCMx8kbBR69qs2y6VCSu9+NMT2OUKuYF+wnqDsNFUIp+sGE+FHpIGHjIkV7TJlfsJ3ABvto6UEtOxlxXZWpUeSqUy/sQ4/sQEYbVKbmQEe2AwG6OVd9j/01czdegYp/71MX7yj3ex99lXUN4xQOwGBGEVK2kHKAyBXc7TmJwhlpLi4OnbDs4n89WnqtSnUl/dprDG/n43tMB3YfHouS26JhHnZMl0WgslXUYvjCR6tkx1SmoZrToi88VZGMl9QueCazYMhmVhODniwM9WubaTS6ya5thJSnvPVz1UczmCuSpxGGDM89uFYSAwkhIMAZZjYI/0Efoh3lydwPOV0J/GHhSGobpG9fbhnjqJd+oUwcyMajBSVOmPQggGL91HcaSPY995gMPf/CFDl5/PjqsOIOMIf3YWJ5l8FUJglwq4k3MQy2U1817MV8+XixsqyNqSAn9amyNWupxtn1yK1JtuK+pkmCZGzsAwkug5sTlEanV0i6a15bFliNoyiaxlRplbCTOXQ4bdrRrDtMgP76R56jj+zBS5/kEl0AN9hE2XqNkkjmXWGCX9XQhDILCS32WIaUFpuJcoiPDmVIN2w7ZOm8Js5HKZbeOdPEnjySew+/pwduzMsmYK/RUuvPUGTt57iImHD1MfnWLfjarOvD8zm7UDFEJF8u5MFeKY4iLNvEMvoDHXYG58hsANMMy199XPhC0i8EqUg7qr8t9TwU1E2jQMhGW0CjElaX1KnNusDW1zbBtU9lCcCHjSOzeICJLl/KHnE3oRUsateQ4hyJULlPpKOMU8TlsWxFZFCGNJq8YqVbBKFbypcaxSGdPJJd52EatYIA4CwqZL7PmA6Fix3O7TyzjEMCTFgRJxBO5cg6DhIUxjycwbIQR2Ty9WqYw/Po4/OUFQraoIv78fIVTF2D03XEZ51wDHv/8IP/nK99n9zMvo278Dv1rDiuKsHaBdyuPO1YklWTPvzFefmMOrNjNfvbgBLJjTsSXSJEEVHEJom0OjPNF24Y7DmNAPlHh76jIKo6Q4XdY5Wlll2XxHUpxrXvpf6KumMEgViRYqJYp9RZxCHjtvb9mzt7DZULZLF6smDgNqR57AdHIU95zX9TOQUUTk+0m1yjiZ+DcXfL7qzDtGCJM4Br/uEtRdJfS503++kevinTxJ1Kh37Qvr15sc++6DNMZn6btgF7uuvRSBqoPU3g7QrzaRhiA2bRpzap7AztnYq1SVcrXSJLeMwGu2B1np3MQ6CYOQMIm6Ay9QjTSSwnAi6d2URp5G+2T1Mq20OI6VZ4zEmr+6M5YEvtonSAzToNhbptBbxCnksHNbpw65lDFhLYniuwRQ/twM7thJ8kM7cPoGlngdiQxDItclbHoAyfqKTt9dJSpEIAyQAr/h4ddcVSbasZYM4rK+sKOnkGGI3T9AbkerL6yMY8YefJLxh57EKRXY99wryVWKqryCncNretSmVLlvp1igZ8/q93nVAq/Z0qSWSRZ1R3ESLSfC7YUEfpCsqiWzTRCo+ZH2yLvtxy+lJI5j4jhZZRkpwVb3qdtRGBIGEWEYESX7D5MzABVUqt+I7dj09pcplUvkCznMeT/6OIoJ07MDITEti2JfmUKlgFPIndWPdyMRhwFhvd61WbeUksaJo0Ruk/L+A13b6c0nXfUaNV1kegbebdGUjJO/tUHohnjVBjKWaiX1Et636gs7RjA1iTBN1Re2ry97/frYNEe/+yBh02fg0v2ISpEwiHEqRXKlAoZpELo+pm2piddVbNepBV6zaZGxJEq7FiW+d5jULg98FYFHQUjHdzH5ERqmCSK1UpSqd4h0FBNGUadIJweIIAhbTUJE20pwITpqFalJ86RdnmFgCJHUXgkImh5+w8O0TPIDZSQqqkdCoZSnt79CoVQgl3c6DiygJmhDL0jGILHzNsXeMvlKASefO+viUuuJsmrCro1z4sBXVk2hSHHXvjOyq+IwJPI8ooarkoiNzonZLN1YLfYgCmLc2TrEMcZpMm+69YUVtoPbcKmOV5n58WGCmSpOX4W+p+1X83aFfFZ2OHTVQq7S8OqJvBZ4zYYks0zays/6rrItAs/PonApIYqU7x1FrVRTDKGEWkol1mEq0mESXUfZtmkZhVaSanJNiK4irW7PX9IuCVwPv66E26+7yaWH33DVZd1VfXq7kKsUqIz0UhruJd9fxinl1QS+MKj0lqj0ligU89jOQr84CiMC18/6sDrFHKW+MrlSfkNnYrQj45iwvoRVMzOFOzFKbmgHTm//meeUS0nsB4RuMjGbTJKm+2r36ZHpBGgTGUZLZt5kfWFHR1WapJHDMwpYjoNpmzROTjD3+DEM06Tv0vNweksYjoNZUBk2YZIxUxruR6yCXaNLFWjWnDQSjkOVXRL4Pn7Tx2v4BJ6H5/pJBcGYIFBZKFEUEceSGCXYEtoEmix6zsKKZLIy9cjTLCZDCBzHRuSX1y9XSknkh22C3UW4Gy5+w++I3tOB2YUcTimnBHxHH04pj1NU9znFPKHnUxubpTo+y9ypGSYeP5U8V1AcKFMe6mVmoITTUyTXU8TJO/T0lSlXSuSLOSzLwrRMzLZ6SWEQMnNyWn0+AvKlPMW+MrliDqeQ25AZOsIwMPJ5omaj+wKo3n6CWhVvYhRvchyrWMQqlrGKpQWFwrq+vlCtGM2cg4wi1aGq0Uy6NqUZcK18etMWlJLMG6/aJKi7qg9vYvWkE+PNapP6rEdsVCgIFydycWRARA8xBUq7h3F6y8w88iRTDz5Oae8I5X0jKj22WMDK20SeT318muJw/6Yp5aEj+G2I7/l4DU/ZI4HyuH1X3desu/hND7/pEYYhURgTRWr1LSS9UE0TDLIFWun9hjAwzNbCLaMtsj4XojAiSEU7EWqv7hE02kS87mZ2TDtWzs6E2i7myc27dEo5nIJzxplXfsOjNj5LbWyW2vgMtfG5LOo3TIPSUA/5/jKF/hKFgQo9Q730DlQolovkC7mFZxaJEEV+oBbOCSj0FCn2lsgVc6ow1QbK0Ambjawk73xkrFoAhvUaYaOODJPPxXYysTcLxWV/5h0Ts66PmtBuTcy27BuIYwjqHs25Jr7n06x7RGGIwMBu8+xF6GM2ZzGigNhyCAu9YNrIKGbuiWM0Tkxgl4v0XrIPq1TAKhYxLCP7+5R2DHR972eLtmg0Z0QcxXiuj1tr0Ky7VKerzE3NUZ+p43l+NkEpARFLtdrWNlV5BMvEStcNpKmnqyAuMo7xm/4Ce8RvKPFWIu51tUsM01BRdhJhq8tcW+Sdxy4unAhdLaSUuHONNtGfpT4xlx10rJxNYaBMYaBCabDC0P4dDO4aoFDK4+QWireMpcrHD0JARbbF3iKF3hK5Qg5rGSmDq4myaqrJ2pGlM1riwCds1AkbNRX5J+mpVqGIWSxjFcsY9vLej4xjIs8ncl0V1bdNzEZhhFtrUpuu0qx6xL7qJGbZNoZjLhynlBh+A9OdAymJc2WifBmEgTsxw8yjT0Es6bloD/mhPuyy6qsc+yEylhR39GMuYzJ5PoEXUB2fYXZ0hrkx9S/wAv7df7tdC7xGIaVsW5zj06w2qM81qc1UmZuu0qg2CMNIzU1KgWmbODkbO2erpgKrKA5SSkIvWGiPtAm43/AImt7CGthCKIHuEOtO4XaKuTMuO3smYw/8gGbDpVl3s0snZzOye4hKb3nZ+43jmMZUjdrYjBL+8Vka07XsPdulHMWBCqXhXobOG2HXgV2Ue8vYzkLRiOM4m4wGMC2TYm+JQm8JJ+9grUNKZuT7RG4Dw1r+vlV03yBqqOg+DnwAhGVjlVR0bxVKy4ru4zAkbLg0p+eozdZpVj2kQH3HrcSzjyH0QgJXBTVdUyzjCNOdw/SbSGESFnqQdp7ID5h55DD+bI38cD89B3Zhl8sYOTtpehNTGhnA7PL3AnWWNzdPyGfHpmnM1LNtDNOgMtRDeaiHn3vnL5xVaq0W+E1KnEwyRkm3HLfu0qg2EjGv06w38Zo+fhAAKtK2bAsn53Scjq4kURC2+dlep2i3ibfsZpfk7bZoe17Undxnr+DqUCmlOotpF+vkX7f7mnV1f9Rl7Cn5Qo6R3UMM7xpix+4hhncNMjjcv+zPOgpCahNzWZRfG59VqyNB+fA9RcojfQzuG2bHgZ0M79/RXfCjmMALiEMl+JZjU+pTGTp2wTmrzkBnipSSyE2zas5ufyq6rxHW64TNejI/IjALRSX2xTKGs/AMx2/61Gfr1CbniIIIQ4AhVLcxkvkclUOvJmRlrFr2+XVfFTezF+bei9DDbMxixCGxlSMs9CINk9qRU9QOn8TMO/Reso/8YB9mIY+MYiI/xCoVqM00mBubZm5sltmxaebGZnCrrfagpmXSM9KX/esd6aNnRx/lgR4M09AWzVakPQpPW5/5boBXb9KsNvFcD88NcJsuzYbyxNNKk6ZpYDlWNnl3rsRxnPjc7ULtdmab1L0sgmzHsE1yxTx2F5ukfaLyXA44Mpa4rpeJcLsoLybabsNTKY1dEIagUMyTL+YpJpeFUp5CMd+6v5TcX8zhNjzGTk4wdmKCsZOTTJyaJEwWVJmWydCOAUZ2DzGya4iRXYMM7xrCWWY05je9DmunNjab2VLCNCgN9jCwd4jh80YYObCLnqGFFQ9bKZlqTE4+R6GvRKGsBH+1rKqWVXPuZaeljImaTSX4jTqxrxZCCcvCKpYRTgE/FNQmawSuj2EK7Hxn9pHKrQ+IXS9ZEavKlKSPyVi17fMbATKKkt4HVvsgMLw6plsFUtumgjdbY/z+x6nXmshiiQCDxlyT6lRVnR0kWDm7JeAjffTu6KNnuI9if3nBvEs7WuA3KfOjcN/1CZoqC8V3lcca+iG+7+O6Ab7n4/thq7okyl6xbAtz3tL50yHjmMANCFyfMN1v0ydwfSXmbVF30PQXPF8YosPPzrVdOsUcdilHrpg/o3Zs6WfiNr0FkXOjq0i3xHqx76phGpkwF0rdRXv+fbnc6c8UZCSJZYyMYmUbJxPMwhTEUczUxEwi+Er4x09O0my4yYcH/QO9DO9uRfoju4YoL6MuuJQSr9pUWTtjM1THZqhPVrOzIitn07d7kMF9w4ycv5PBfcPkK53dzNIVvunkY66UVzn4ZXWWtJJnd5HvE7oNzDOwapZDHAT4tTmCWo3Ya6jEWAkxJrHhEAsbidnVbpRICCPl1wcBIJNeCEZStjhpwt0MCMMo642AhGa1SW1qjsbYJLXpGrU5j+qcRxhE2eublkFloEzPyADlwQrFSoGRi/dQGTnz1FDQAr9hmR+Fh77y+9J/6bL5MDmljqII3wtwPR/fD7KUQYHAsAws28JapAlHh2CnQt1+2UyEPLm9WC43gF1wFrVJ0tvWMmqrRFGE2/Bo1Ju4Da9DmBv17oLtJkvUu2FaZibU7dF0++0OIS91zzlf4g+morg4TiI62Rblp38LAKHSGi0T01ZVRUM/UJkuYftZTJLimTRWadQajJ2cbAn/yUlmp+ayrYvlgoryd6tIf2T3EH2DvUtGd6D+9o3pGnOjM8ydmqY+MacW+iQ/30JPkYF9wwztH2Fg7zADewezuilSyuS7GSR55JCvFFesaJqUkqjZII7O3qrpfK8Sr+FRn6lRn64hY4nlWDgOmIQYMsBA/a4kgkjYxNjEwla2zILxxcR+SOx7xGGEEIJYQGNGFRCbG68yNzFHbapGfbbRkY2VKzhUenJUehzK/WXyw4NYUUTzyCmEadB78T7Ke3eAaRJ5AcWhPuxi/ozfsxb4dSSOYhWBJ0LeHoUHXgixVDm3ySrLOJZEcYzvB5mtEEdxtprSNE0sW1W5DP0wE2kl2h5BM+gQ71TMlxJsK29jF3LYeRs772AXcsl9TnJbXVoFB3uR6DUMwixabjaaNBsezXrr0m14NBqJkCf3+97CyD8bk20tKsztt9vvt+2znDyVMitHIOMkB1+mP9TWoqhUuC3bUsJtWZiOiZmWhzaEyh4yF88ciiPZUcgs8FURs9Dzs6yXdJ9CGPh+wNTEDBOjU4yenGD8xCQTY1OtDBvbYninEvtU+Id2DHT13tuJgpDq6Awzp6aoT1RpTlbx6272eE/i5Q/sG2Zw7zC9O/sxLTNJyVT1e1aqaJqMY8JaFcyzt2raffU4ijFNc/E5GRljygCDAEMGadUhJJYS/CS6j6KY2mSVufFZ9W9sltnxGWpT6sCRUqgUKA+UKfUWKZRzVPoqVEZ6cfJOYtvUMN2a+tzzZfzIYvqRw4T1JsVdg/Rdej5GLkfk+RQG+864P7QW+FWkaxTe9NTinrYoPD0VTBfjREktE9/zaTZc6tUGbk2tgoyaahFQHEbJyrwgi76DpkfoBosLtlCd1ueLs11wsLLbqaCrDIpuP4LAD6jXmjRrTeq1Bo16k0Yt+VfvFOpmo0ngL/TXU5yc3V2Y50fYbZaIvRITfbHMVrmSRNtKuNtFOz0DSoVbibZlW0nXnqQypGkoAV/NDKLk4BIlJROyFb1eEkEnY46imOnxWSbGp5kYm2L81CTjJyfxEj9XCMHAcB8ju4YY3j3Ijt3DDO8apFhaWjgac3VmT07TmJyjMVXDnaplHrFhmfTvHmBg77AS/r3DVAZ7kKQ5+OdWNO1ssmrSRUjViblFffXTIiWR71Ifn2ZufJq5iSqz4zVmJ2rUphsd69rKA2UqQ730DPdQGShT6slT6il0/IZkFBN4EaHrq7Mzx1IplnGI1ZzDCFykYRHkKswenaBxfByrlKfv4AXk+/sTke/FKReX/Ra0wJ8jWRQeqGXwvht0RuFps1MJiGQxD+C5Hs1qg8ZMXUUXMzWa1QZ+3UuitoAovVxMIAVKiPNLCXZyWXCwnO6CLaXEbXqZSNdrjQ7BbiS36zV1fTHBdnIOxdLi0XQ3S2TFJ+naCn7JWP2o0hgsqwIJCAxMx8C0rJZ4J/n6qXAbScS90ZEyFf9Y1V7xQwIvJPDVASCOI+ZmakyMTjN+apLJsWnGRyepzrbS6so9pdZk7m7l6/f293T/vsQSz1NdhxpTVdzpOt5sndr4LFHiJ9t5h4F9QwzuHc6EP1fKt4qmIVWxrbRoWjG3aIaOlJKoUVfNQZao2RJHMW7dpToxpzJNhMDJ26dt8AEqyq9OzDI3PteKyifmOlIPhSGoDJTpHS7TN1Skd6hM71CJ8mAPhpMnEjaSVqrw/IlZhIBkFWzsh/jN9hRLExG4WM1ZRBwR2XnqTcHsoaPEUUTvhXspX7CH2I/ID1TIVZZXM14L/GlQPmOUTWimUbifeNJxpCoVeg1fTSq6vlqx6arbXt2lWW3i1pp4ycTjUhG2nW+zPE4j2kstSomiiGbd7SrY9WqjTbzVv25ZIUIICqU8xXKBYqlAqVxU17N/RUrp9VJhVVPoZGKTLBRu6Ii4DQPLsjAcs7WM37aUNWKamG1WyXqTWj/z68OvNFFSTTMOo2SSVE2Uzk3PMXZygvHRaSZOTTI+OsX0xGw26ezknCxzR9k8gwyODGDNOyin8z+hH+LONgiqTYJqk9r4LHNjM5llUegtMbh3qMPaEUJ0Fk3rK5MvqyqZ7Qd/GUcEtSrCnFcVMpZ4TY/6dI36tKqvbtkWVq67JefV3QUiPjc+25F6mOaQ9wz3Jv/U9fJApXUGICWCCEMGmDJAEKbmGXHi3UeJd59OzIaeTxwEkNSll8REfkTQ9ImlmicyTDOxbaqAwDcKTD05hj9TIz/Uy8CVFxNLKPRVyPWWSGd2FkML/CJIKTn12HGOP3KE5lxDiXWaIdJMryerIt1F/GIhsHIWVs5W/xJhVgtu8jiFRMhTH/s0qwh9P0gEudEWbTdb99WT29XGohOOpmVSLCdiXSpQrKTi3RLtVMALxfxpJ+nOlY6MkmxiMp2S7KzMaDoWpmVl2T+GpTppGVar3eF6C3ccJ5F0nJQojuKsdo5oe08SMIWBaZuEHRUv1VmGkeRcW8mP3rSUj7/i442kivqTYmzNWpPRI6OcPDrG2IkJJkanmBidIkjmAAxDMDDSz47dw0r8k6g/X8hlrxkEIb7nq79nGIEfElRd6hNzzJyYojY5l75Veob7GNg7xOC+Yfp2Dqi0P1Plmc8vmiajgKjZRJgmvhvQnGtQTXx1wzSzSV0pJW612RLytsjcb7R+F6ZtZeLdLuSlvuUtiOpAxhiEGNJPBF/9PWNMJfjCJsZCoqL32POI4ygrHyHDmKDpEyU9WA0BVnMWI/SIhMnsdED1yBiGYzNwxUXYlRK53gr5vqVFXgv8Ikgp+eAv/WFHfrYwBLlSXuVmF9SEo+mYYJmQNAywcjZm3k62y2Hb3W0RSHKwm14izG1Rdocl0hLvxayRXN5ZGFWXChQrxQXi7azFUvTTZJS0i7dpqlIGptXyt82k8FN7Hfb1KpCV2h+tGu+Rel9RYr11HodU9GibalGYY7dW+VpWh2Cry1YlwyiKCJMzxTBQNeo918d3veQyIIrjVuZeZvmptQtp9GeuYJpiOukb+AGTJ6c4fvgEJ46MMnpsnPFTkzRqrai3p6+cTOgOs2PPULY6F9ScjZ+ctZqmQT7nENY8Jfgnp5g6Oo6bvJZhGvTtGlCCv2tQCe5AJfnt5XAck9qkEmphQOhF1KaqVCfmkmhcXbafJdt5m57hvjYx76FnqJdCb3F1fgtt0b3KzAmzr0malRMJGxlBFPjEnlokFSf9nQM3IA4idTZqRFiNOYSMaHoGk4cniFyfygW7Ke7fRaG3TL6/wmIirwV+CX5y1yNMHBsn31sCQ+BHEW7TIwqj7A9mmK0URMMwMmukXmvQqDa7iHfL527W3SWtkVK52GGRFEstO0Rd5skXC2r5dPvHLZObyd+g428h6WJttHW56Ejoa4830xPQ1Meep2zQ8Vh7KmA6OWmaZqe/baxPn9o4VsIVR3GSnRQnJYdb70Shspgs28LO2TiOhZ1zcBwb27GT96jE1TTNBU1BVpp0gjUMQ8IwIvBVpOw1fbXOIZm4l2nLwOTvbhjpGNMDwblbQjKWzE7OcvzwKU48dYpTSdQ/PTmTfY75Qo6hHQMMp4u19gwzMNhHJFWrQyEElmPT01fCiAWNyTmmT0wydXSCqWMTKhsHVSKgf+8Q/bsGMSyT+nRV+eVjsx0BWK6UzwS8MtRDz2CFnuEKuVK+VS9GiOTALJIzqjVAyiwrR0X3SQEzDCX2WESRaOXWxxIpySaoBQJbuphenTiSTJ5q0JyoYveW6b/sAMXhPvL9PV3z9rXAL0Ftpsa/fOlfCJIURs8L8H0Pt+HTqDeVx11v0qw3aSQ52UtaI6VCNglZLCkLpFguUCzmKZQKlMp5CsUihXIe0zDasmtofSENJaQi/aImi5bU/I1ISq0CScPw9D6jrfO8eg2jY7tsP9D24297jWSD9u9QWqY3K9ebjHO1M0q6kVohcRS1bJKkxvcCu0eoCoBOTgm37Tg4SS2dVATN1BZZZX98pVHvXZ0FqMsIz/XwvSC79NOicEAr7VLMOwicnSXkuT6njoxy/PBJThw+xckjo4ydGM8W85imyeBIH8M7Bhna2c/AUD99Az1Yjo1hGZTKRXr6yuQLObyqy/TxCaaOjTN5dIKZk5PIWFLoLWUrOttXdeZK8/PEJUi1+KhVWkBCmjEVJxOfMtkWsonQ5Eu98gcBKRHESXTvL4juIyyCQBK6akWslDGhpxI5RByTixoYkU91xmf66AwYgt5Lz6Pn/L0UBysL8vW1wC+ClJK3vOydTI5Nt+Ugd5Iv5ihVSpR7SpQqRcq9JUo9xex2padEqadEpafUVoc7Ec00Sm7X0k0kJKtNlhmSRtjLsEZsx1K2iKNsESfvZELdLtyboQHGapKm74ZtBwLf8/HcAN9NEgTcgFjG81P9F3yeyzljiaKYiZMTnHhqlBNPqYj/5FOnaNY7V+cOjvQzMNRL30AvA0O9FCtFevt76OmvUKoUsZJc+5VrUJ0EAFJmLfwWHADSAXb8NFfwLKAtuld2Tlt0L038APxmgIykmpD1Akzp4wQNmvUmp56coVFrYg72UrpwL1a5gJ/8PX1fWXw/98sv1Q0/5iOE4IpnXkZ1tsbAcD/lXiXk6WWpp7Qgm0CzNKe1Rtr63wlBVqEyX8xjO5bys+2F1oi5yApdTXdS28myLWibHJ1PagelZwJBECZzAgFe08NteAsWYEnA7GIJ7dg7wo69Izz9xisBdZCZnZrj5FOjnDhySl0+dYqfPHI423+xUmR4xwD9g730DfYwPDLAzr3DOLajzlzTs9LsGWoBGAJ1xmoYyXbqPRuCpAyxyNacdP3WZA1H2g8A6TtUwi/jWC2Ci2J831dn+UGA7wcEUag+qyAg8COC9P4wULZa4CeXAX4QZo/7fkAYBIRhQBj46v4gTJyDEM8P8DwfPwgJw3BBf5luVCplXvILL8ZaYUne9AIP8JrffjU//tdD9PRXVnU/MvPKO+5deF+6HV3uO5fnLvl6cv5DXWu3ZPdJ2qyRTgzTwLbVxGMx1/Kzu1kja1VvXbM4y/k7pO0Q0961URglxewSW6iphGp++WZhCJycw4HLz+fiKw9kllCz7nLq6GgS5Svxf+CeR7pW4uwQaSFASGQqzEJ9J6VIovN0NYSMs9txErnHyX2xjLP7Iqmi+ChJzY1jSRxHRDIJTNKU3XN0KkxDzUeZhqG++8mlYRhYpkE+71AsFBgZzFMsOORyNkIYBH6E56nJ2D1DPZRtB7/qYwqDqgF+IYdtOyBjGnWX3BIH8rNhVQVeCHEr8AHABP5cSvk/V2c/6os4N1NVuUykc1fzv60s+AKn6W7pw8m4W2Letg8Ag3QSiMyuaY9Ks9sdHnjiiXd45+l2IjmLFC1Lsc1sz6zGTo8ouz/bjrYfELQ6LYnW/tr3bxqqGmW7UJ/J6bxmYxPHqoRCEIRJ1Omr234rCg2CIMucSbfxXA+3qTKCXFfNVbkNt3W/5xMkkWl6mZ49BL0RblM9xw+C1llFlLZyXLwM83JQ0b1ajWwII7stkrkrgYEhDCzTzOa/0t9FOpclpGg9JgRGx/XWWYMhROdrnO7M01P/ajMhNbpbxTMnJhZ9un0W1sxyWDWBF0KYwAeBFwDHgLuFEF+SUj680vvK5XNcds0l7Ttvv0jHk1xpuy/z1+fPSHbep20FzWKkQpqJZiKcSjT9REjValX1eJiJrb+Y4PpqgrXjeUnOevactNWi7yci3vaaQbjofNTZYlomdrKa2LJUuqyV5f0bKsJNgoaevINhGGp7q7WQzbJa5a0tM7nfNrHNJLst2YdtW1i2g22ZWI6tLm0Ly7SyjC4jDZKMRPCTZutpgJTmJWQJB0K0HkvOHqRMSl/EkjhU9aNk3EoAUGnD6RxThEzqTKkm86rBfByEqol8upZCqvkntb5CnSEXCjblskOp4JBzLOIoojlTpz5ZpzHrEgPTqzQXupoR/DOBn0gpnwAQQnwG+DlgxQUeUEWBNMviN37lbZw6MbbwZEbTHamKyAV+S7TDxLvN6hStEFYiorZtZUXp2gXSTlf9WiaFUp5KbznZzkoEWNln6etYyWPpugXLtLDTMzbLwrZNbEeJqWlbyoqzbHW/rdJMbdtSaxzS7Kv2M8/kfjEvkytOSixLWt44qQWTuoSxKk2hnML262QTqqh7iSM1uYpM1m1IZePEkcz2oez2SK2gTixIGSUefFJFM7NrYoiJs1P0LOk4PRiYFsKSGB2n8Glec8sKEEIQS6nuSd5D9mIxQKTSKZGIWCJyJsOVPIO9BfoLNrWjk4w9NqEKFHqLV1k96+/Tir9iiz3A0bbbx4Ab5m8khPg14NcA9u/fv4rD0aTs3b9bTZpqlk1qZaVRqIpME/HMBDgRY1PVzsnE2DTaolclqlZbNJxeN09TiTHzstfhjDLRXCWWHaHBOXyP2tJ/W/H12iLTI0p6kEkOSun6FIlUB6JU29ODUJweqNrXsLQOVurxpMFImv2TlO+YCUOmx5vIuE7JsRg5uAOzGVLsKa/4+1v3SVYp5YeBD4NKk1zn4WwL/st//+31HoJGo1kDVnM27Tiwr+323uQ+jUaj0awBqynwdwMXCyEuEEI4wKuBL63i/jQajUbTxqpZNFLKUAjxJuCfUGmSH5VSPrRa+9NoNBpNJ6vqwUspvwJ8ZTX3odFoNJru6BUtGo1Gs0XRAq/RaDRbFC3wGo1Gs0XRAq/RaDRblA1VD14IMQ48dZZPHwIWr+azfuhxnRl6XGeGHteZsRXHdZ6UcrjbAxtK4M8FIcQ9ixW9X0/0uM4MPa4zQ4/rzNhu49IWjUaj0WxRtMBrNBrNFmUrCfyH13sAi6DHdWbocZ0ZelxnxrYa15bx4DUajUbTyVaK4DUajUbThhZ4jUaj2aJseIEXQtwqhHhUCPETIcQ7ujyeE0L8dfL494UQ57c99s7k/keFEC9a43H9thDiYSHE/UKIbwghzmt7LBJC/Cj5t6IllJcxrtcKIcbb9v+rbY/dLoR4LPl3+xqP6/1tYzokhJhpe2w1P6+PCiHGhBAPLvK4EEL8UTLu+4UQz2h7bDU/r9ON65eS8TwghPiuEOLqtscOJ/f/SAhxzxqP62YhxGzb3+v32x5b8juwyuP6T21jejD5Tg0kj63m57VPCPGtRAseEkK8pcs2q/cdk2k7qQ34D1Vm+HHgAOAA9wGXz9vmPwD/d3L91cBfJ9cvT7bPARckr2Ou4bieBxST67+Zjiu5XVvHz+u1wJ90ee4A8ERy2Z9c71+rcc3b/v9ClZde1c8ree2bgGcADy7y+IuBf0R1k3sW8P3V/ryWOa7npPsDfjYdV3L7MDC0Tp/XzcCXz/U7sNLjmrftS4FvrtHntQt4RnK9Ahzq8ptcte/YRo/gs8bdUkofSBt3t/NzwMeT658Fni+EEMn9n5FSelLKJ4GfJK+3JuOSUn5LStlIbt6F6mi12izn81qMFwFfk1JOSSmnga8Bt67TuH4B+PQK7XtJpJT/DEwtscnPAZ+QiruAPiHELlb38zrtuKSU3032C2v3/VrO57UY5/LdXOlxreX366SU8ofJ9SrwCKpfdTur9h3b6ALfrXH3/A8n20ZKGQKzwOAyn7ua42rnDagjdEpeCHGPEOIuIcTLVmhMZzKun09OBT8rhEjbKm6Izyuxsi4Avtl292p9XsthsbGv5ud1psz/fkngq0KIe4Vqar/WPFsIcZ8Q4h+FEAeT+zbE5yWEKKJE8nNtd6/J5yWUffx04PvzHlq179i6N93e6gghfhm4DvjptrvPk1IeF0IcAL4phHhASvn4Gg3p74FPSyk9IcSvo85+blmjfS+HVwOflVJGbfet5+e1oRFCPA8l8M9tu/u5yec1AnxNCPHjJMJdC36I+nvVhBAvBv4OuHiN9r0cXgp8R0rZHu2v+uclhCijDiq/JaWcW8nXXoqNHsEvp3F3to0QwgJ6gcllPnc1x4UQ4meA3wVuk1J66f1SyuPJ5RPAnaij+pqMS0o52TaWPweuXe5zV3NcbbyaeafPq/h5LYfFxr7uTeWFEFeh/oY/J6WcTO9v+7zGgC+wctbkaZFSzkkpa8n1rwC2EGKIDfB5JSz1/VqVz0sIYaPE/a+klJ/vssnqfcdWY2Jhpf6hzjCeQJ2ypxMzB+dt80Y6J1n/Jrl+kM5J1idYuUnW5Yzr6ahJpYvn3d8P5JLrQ8BjrNBk0zLHtavt+suBu2RrQufJZHz9yfWBtRpXst3TUBNeYi0+r7Z9nM/ik4b/hs4JsB+s9ue1zHHtR80rPWfe/SWg0nb9u8CtaziunenfDyWUR5LPblnfgdUaV/J4L8qnL63V55W8908A/2eJbVbtO7ZiH+5q/UPNMB9CieXvJvf9V1RUDJAH/jb5sv8AOND23N9Nnvco8LNrPK6vA6PAj5J/X0rufw7wQPIFfwB4wxqP6z3AQ8n+vwU8re25r08+x58Ar1vLcSW33wX8z3nPW+3P69PASSBAeZxvAH4D+I3kcQF8MBn3A8B1a/R5nW5cfw5Mt32/7knuP5B8Vvclf+ffXeNxvant+3UXbQegbt+BtRpXss1rUYkX7c9b7c/ruSiP//62v9WL1+o7pksVaDQazRZlo3vwGo1GozlLtMBrNBrNFkULvEaj0WxRtMBrNBrNFkULvEaj0WxRtMBrNBrNFkULvEaj0WxRtMBrtjxCiN9L6pD/ixDi00KItwkh/r0Q4u6kKNbnkiJUCCE+JoT406Sw2RNJffOPCiEeEUJ8rO01a0KI9yY1vr8uhHimEOLO5Dm3JducL4T4thDih8m/56zTR6DZpmiB12xphBDXAz8PXI2qm35d8tDnpZTXSymvRpVwfUPb0/qBZwNvBb4EvB9V+uJKIcQ1yTYlVE3xg0AVeDfwAlT5h/+abDMGvEBK+QzgVcAfrcZ71GgWQ1eT1Gx1bgS+KKV0AVcI8ffJ/VcIId4N9AFl4J/anvP3UkophHgAGJVSPgAghHgIVe/kR4AP3JFs/wDgSSmD5DnnJ/fbwJ8kB4UIuGQ13qBGsxha4DXblY8BL5NS3ieEeC2qE1FKWm0zbrue3k5/M4Fs1fnItpNSxklVU1BnAKOoswcDcFf2LWg0S6MtGs1W5zvAS4UQ+aQm90uS+yvAyaSU6y+t0r57gZNSyhj4FVTbOo1mzdACr9nSSCnvRvno96NKsj6A6vr1e6jOOt8BfrxKu/8QcLsQ4j5UKeT6Ku1Ho+mKriap2fIIIcpSdRgqAv8M/JpM+mRqNFsZ7cFrtgMfFkJcjuod8HEt7prtgo7gNRqNZouiPXiNRqPZomiB12g0mi2KFniNRqPZomiB12g0mi2KFniNRqPZovx/IMn/hFCwO7IAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "sns.lineplot(data=df3, x='gamma', y='gain', hue='decay_p', ci=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Finished 40 ---\n",
      "--- Finished 41 ---\n",
      "--- Finished 42 ---\n",
      "--- Finished 43 ---\n",
      "--- Finished 44 ---\n",
      "--- Finished 40 ---\n",
      "--- Finished 41 ---\n",
      "--- Finished 42 ---\n",
      "--- Finished 43 ---\n",
      "--- Finished 44 ---\n"
     ]
    }
   ],
   "source": [
    "df = pd.DataFrame(columns=['active', 'passive', 'num_syb', 'weeks', 'decay_p'])\n",
    "df = reputation_cut_experiment(ppr_cut, 'rep_cut_ppr', df, add_sybil_path_region)\n",
    "df = reputation_cut_experiment(simple_ppr, 'ppr', df, add_sybil_path_region)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>active</th>\n",
       "      <th>passive</th>\n",
       "      <th>num_syb</th>\n",
       "      <th>weeks</th>\n",
       "      <th>decay_p</th>\n",
       "      <th>alg</th>\n",
       "      <th>gain</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.046525</td>\n",
       "      <td>0.529052</td>\n",
       "      <td>5</td>\n",
       "      <td>40</td>\n",
       "      <td>0.40</td>\n",
       "      <td>rep_cut_ppr</td>\n",
       "      <td>0.087940</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.004099</td>\n",
       "      <td>0.026476</td>\n",
       "      <td>5</td>\n",
       "      <td>40</td>\n",
       "      <td>0.40</td>\n",
       "      <td>rep_cut_ppr</td>\n",
       "      <td>0.154823</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.007877</td>\n",
       "      <td>0.074215</td>\n",
       "      <td>5</td>\n",
       "      <td>40</td>\n",
       "      <td>0.40</td>\n",
       "      <td>rep_cut_ppr</td>\n",
       "      <td>0.106140</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.082699</td>\n",
       "      <td>0.262881</td>\n",
       "      <td>5</td>\n",
       "      <td>40</td>\n",
       "      <td>0.40</td>\n",
       "      <td>rep_cut_ppr</td>\n",
       "      <td>0.314588</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.021325</td>\n",
       "      <td>0.031566</td>\n",
       "      <td>5</td>\n",
       "      <td>40</td>\n",
       "      <td>0.40</td>\n",
       "      <td>rep_cut_ppr</td>\n",
       "      <td>0.675558</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>395</th>\n",
       "      <td>19.383635</td>\n",
       "      <td>5.296806</td>\n",
       "      <td>5</td>\n",
       "      <td>44</td>\n",
       "      <td>0.95</td>\n",
       "      <td>ppr</td>\n",
       "      <td>3.659495</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>396</th>\n",
       "      <td>26.898086</td>\n",
       "      <td>10.135507</td>\n",
       "      <td>5</td>\n",
       "      <td>44</td>\n",
       "      <td>0.95</td>\n",
       "      <td>ppr</td>\n",
       "      <td>2.653847</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>397</th>\n",
       "      <td>7.048318</td>\n",
       "      <td>1.459089</td>\n",
       "      <td>5</td>\n",
       "      <td>44</td>\n",
       "      <td>0.95</td>\n",
       "      <td>ppr</td>\n",
       "      <td>4.830628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>398</th>\n",
       "      <td>19.545310</td>\n",
       "      <td>6.016506</td>\n",
       "      <td>5</td>\n",
       "      <td>44</td>\n",
       "      <td>0.95</td>\n",
       "      <td>ppr</td>\n",
       "      <td>3.248615</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>399</th>\n",
       "      <td>0.117206</td>\n",
       "      <td>0.045592</td>\n",
       "      <td>5</td>\n",
       "      <td>44</td>\n",
       "      <td>0.95</td>\n",
       "      <td>ppr</td>\n",
       "      <td>2.570733</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>400 rows × 7 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        active    passive num_syb weeks  decay_p          alg      gain\n",
       "0     0.046525   0.529052       5    40     0.40  rep_cut_ppr  0.087940\n",
       "1     0.004099   0.026476       5    40     0.40  rep_cut_ppr  0.154823\n",
       "2     0.007877   0.074215       5    40     0.40  rep_cut_ppr  0.106140\n",
       "3     0.082699   0.262881       5    40     0.40  rep_cut_ppr  0.314588\n",
       "4     0.021325   0.031566       5    40     0.40  rep_cut_ppr  0.675558\n",
       "..         ...        ...     ...   ...      ...          ...       ...\n",
       "395  19.383635   5.296806       5    44     0.95          ppr  3.659495\n",
       "396  26.898086  10.135507       5    44     0.95          ppr  2.653847\n",
       "397   7.048318   1.459089       5    44     0.95          ppr  4.830628\n",
       "398  19.545310   6.016506       5    44     0.95          ppr  3.248615\n",
       "399   0.117206   0.045592       5    44     0.95          ppr  2.570733\n",
       "\n",
       "[400 rows x 7 columns]"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df.replace([np.inf], 0, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.201247460189953"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(df.loc[(df['decay_p'] == 0.95) & (df['alg'] == 'rep_cut_ppr'), 'gain'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df.to_csv('rep_cut_comp_ppr.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 526.625x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "g = sns.catplot(data=df, kind='bar', x='decay_p', y='gain', hue='alg', palette=\"dark\", alpha=.6, height=6)\n",
    "g.despine(left=True)\n",
    "g.set_axis_labels(\"$\\alpha$ Decay\", \"Total gain)\")\n",
    "g.legend.set_title(\"\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df2 = df[(df['weeks'] == 4) & (df['decay_p'] > 0.4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "\n",
    "# g.set(yscale='log')\n",
    "# g_results.set(xticks=sample_count)\n",
    "#g_results.set(xticklabels=sample_count)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Passive Sybil Attack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "rep_algs = {'ppr': PersonalizedPageRank, 'pht': PersonalizedHittingTime, 'pmf': MaxFlow}\n",
    "rep_args = {'ppr': {'number_random_walks': 1000, 'reset_probability': 1 - decay_p}, \n",
    "            'pht': {'number_random_walks': 1000, 'reset_probability': 1 - decay_p}, \n",
    "            'pmf': {}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Calculate the deserved reputation \n",
    "deserved_rep = {}\n",
    "rep_vals = {'ppr': defaultdict(float), 'pht': defaultdict(float), 'pmf': defaultdict(float)}\n",
    "new_seeds = {'ppr': initial_seeds.copy(), 'pht': initial_seeds.copy(), 'pmf': initial_seeds.copy()}\n",
    "cur_seeds = {}\n",
    "new_nodes = set()\n",
    "old_nodes = set()\n",
    "\n",
    "rewards = {'ppr': defaultdict(float), 'pht': defaultdict(float), 'pmf': defaultdict(float)}\n",
    "used_rep = {'ppr': defaultdict(float), 'pht': defaultdict(float), 'pmf': defaultdict(float)}\n",
    "\n",
    "\n",
    "H_t = [G_t[i].copy() for i in range(max_l)]\n",
    "\n",
    "for w in range(end_attack_w):\n",
    "    G = H_t[w]\n",
    "    # # 1. Pick seeds for reputation calculation \n",
    "    for r_n in rep_algs.keys():\n",
    "        cur_seeds[r_n] = pick_seeds(new_seeds[r_n], num_seeds)\n",
    "    # 2. Insert Attack edges \n",
    "    if w >= start_attack_w and w <= end_attack_w:\n",
    "        # The attacker known the current seeds. \n",
    "        new_nodes = new_nodes | {g for g in G.nodes() if g not in old_nodes}\n",
    "    else: \n",
    "        old_nodes = old_nodes | set(G.nodes())\n",
    "    # 3. Insert Sybil edges \n",
    "    # 4. Update reputation\n",
    "    for r_n in rep_algs.keys():\n",
    "        for seed_node in cur_seeds[r_n]:    \n",
    "            new_rep = agg_rep_update(G, seed_node, rep_algs[r_n], **rep_args[r_n])\n",
    "            for k,v in new_rep.items():\n",
    "                rep_vals[r_n][k] += v\n",
    "        # 6. Choose new seeds: maximum reputation \n",
    "        new_seeds[r_n] = [k for k,_ in sorted(rep_vals[r_n].items(), key=lambda x: x[1], reverse=True)]\n",
    "    # 7. Distribute the rewards \n",
    "    for r_n in rep_algs.keys():\n",
    "        rep_sum = sum(rep_vals[r_n].values())\n",
    "        for k,v in rep_vals[r_n].items():\n",
    "            # rewards[r_n][k] += (v - used_rep[r_n][k]) * reward_per_w / num_seeds\n",
    "            rewards[r_n][k] += (v / rep_sum) * reward_per_w\n",
    "            used_rep[r_n][k] = rep_vals[r_n][k]\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "142079"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0015793189915621754\n",
      "0.030742049469964665\n"
     ]
    }
   ],
   "source": [
    "G = G_t[45].copy() \n",
    "\n",
    "seed_node = 140799\n",
    "attacker_node = np.random.choice(G[seed_node])\n",
    "\n",
    "decay_p = 0.85\n",
    "\n",
    "total_syb = 0\n",
    "total_syb += add_sybil_parallel_region(G, attacker_node, total_syb, 10)\n",
    "rep_vals = defaultdict(float)\n",
    "\n",
    "rep_alg = PersonalizedHittingTime(G, seed_node, 1000, reset_probability=1-decay_p)\n",
    "rep_with_cut(G, seed_node, rep_vals, rep_alg, gamma=-0.5)\n",
    "print (sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]) / max(rep_vals[attacker_node], 1))\n",
    "\n",
    "\n",
    "rep_vals = defaultdict(float)\n",
    "simple_pht(G, seed_node, rep_vals, decay_p, use_weight=False)\n",
    "print (sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]) / max(rep_vals[attacker_node], 1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0002876755059903514"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]) / max(rep_vals[attacker_node], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0011342155009451797"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]) / max(rep_vals[attacker_node], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]) / max(rep_vals[attacker_node], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.657560950585459"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.012697538562874897"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2100840336134455"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]) / rep_vals[attacker_node]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1381312337832369"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([rep_vals[attacker_node*2 + i] for i in range(total_syb)]) / rep_vals[attacker_node]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "InEdgeDataView([(142117, 284242)])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G.in_edges(284242)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(defaultdict(int,\n",
       "             {142117: 14,\n",
       "              141627: 8,\n",
       "              284238: 1,\n",
       "              284239: 1,\n",
       "              140571: 1,\n",
       "              141362: 3,\n",
       "              284236: 1,\n",
       "              141269: 1,\n",
       "              140968: 1,\n",
       "              140904: 1,\n",
       "              142079: 1,\n",
       "              141174: 1}),\n",
       " 11)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_alg.random_walks.coleadings[284242], rep_alg.random_walks.get_number_positive_hits(seed_node, 284242)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "attacker_node = 140799\n",
    "deserved_rewards = {r_n:rewards[r_n][attacker_node] for r_n in rep_algs.keys()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "rep_vals = {'ppr': defaultdict(float), 'pht': defaultdict(float), 'pmf': defaultdict(float)}\n",
    "new_seeds = {'ppr': initial_seeds.copy(), 'pht': initial_seeds.copy(), 'pmf': initial_seeds.copy()}\n",
    "cur_seeds = {}\n",
    "\n",
    "H_t = [G_t[i].copy() for i in range(max_l)]\n",
    "\n",
    "rewards = {'ppr': defaultdict(float), 'pht': defaultdict(float), 'pmf': defaultdict(float)}\n",
    "used_rep = {'ppr': defaultdict(float), 'pht': defaultdict(float), 'pmf': defaultdict(float)}\n",
    "\n",
    "syb_count = 0\n",
    "\n",
    "for w in range(max_l):\n",
    "    G = H_t[w]\n",
    "    # # 1. Pick seeds for reputation calculation \n",
    "    for r_n in rep_algs.keys():\n",
    "        cur_seeds[r_n] = pick_seeds(new_seeds[r_n], num_seeds)\n",
    "    # 2. Insert Attack edges \n",
    "    # We mimic the attack edges as a real user - attacker_node\n",
    "    # 3. Insert Sybil edges\n",
    "    if w >= start_attack_w and w <= end_attack_w:\n",
    "        a = attacker_node*2 + syb_count\n",
    "        G.add_edge(attacker_node, a, weight=weight_attack_edges)\n",
    "        # G.add_edge(a, attacker_node, weight=weight_attack_edges)\n",
    "        for k in range(1, 10):\n",
    "            G.add_edge(a+k, a + k + 1, weight=weight_attack_edges)\n",
    "            # G.add_edge(a + k + 1, a + k, weight=weight_attack_edges)\n",
    "        syb_count += 10\n",
    "    # 4. Update reputation\n",
    "    for r_n in rep_algs.keys():\n",
    "        for seed_node in cur_seeds[r_n]:    \n",
    "            new_rep = agg_rep_update(G, seed_node, rep_algs[r_n], **rep_args[r_n])\n",
    "            for k,v in new_rep.items():\n",
    "                rep_vals[r_n][k] += v\n",
    "            # 5. Optional seed punish\n",
    "            if seed_decay:\n",
    "                rep_vals[r_n][seed_node] *= seed_decay_p\n",
    "        # 6. Choose new seeds: maximum reputation \n",
    "        new_seeds[r_n] = [k for k,_ in sorted(rep_vals[r_n].items(), key=lambda x: x[1], reverse=True)]\n",
    "    # 7. Distribute the rewards \n",
    "    for r_n in rep_algs.keys():\n",
    "        rep_sum = sum(rep_vals[r_n].values())\n",
    "        for k,v in rep_vals[r_n].items():\n",
    "            # rewards[r_n][k] += (v - used_rep[r_n][k]) * reward_per_w / num_seeds\n",
    "            rewards[r_n][k] += (v / rep_sum) * reward_per_w \n",
    "            used_rep[r_n][k] = rep_vals[r_n][k]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "79999.99999999994"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(rewards['ppr'].values()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4135226136274182"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_alg = 'ppr'\n",
    "rewards[rep_alg][attacker_node] / deserved_rewards[rep_alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4778968456239872"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_alg = 'pht'\n",
    "rewards[rep_alg][attacker_node] / deserved_rewards[rep_alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.354375273922803"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_alg = 'pmf'\n",
    "rewards[rep_alg][attacker_node] / deserved_rewards[rep_alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.6081649900454678"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_alg = 'pmf'\n",
    "(sum([rewards[rep_alg][attacker_node*2+i] for i in range(syb_count)]) + rewards[rep_alg][attacker_node])  / deserved_rewards[rep_alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.556249479447597"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_alg = 'pht'\n",
    "(sum([rewards[rep_alg][attacker_node*2+i] for i in range(syb_count)]) + rewards[rep_alg][attacker_node])  / deserved_rewards[rep_alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.150150708325874"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_alg = 'ppr'\n",
    "(sum([rewards[rep_alg][attacker_node*2+i] for i in range(syb_count)]) + rewards[rep_alg][attacker_node])  / deserved_rewards[rep_alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'pht'",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mKeyError\u001B[0m                                  Traceback (most recent call last)",
      "\u001B[0;32m/var/folders/n0/63hch3z94vddb4z27p5zh8j40000gn/T/ipykernel_77828/393543798.py\u001B[0m in \u001B[0;36m<module>\u001B[0;34m\u001B[0m\n\u001B[1;32m      1\u001B[0m \u001B[0mrep_alg\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0;34m'pht'\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 2\u001B[0;31m \u001B[0;34m(\u001B[0m\u001B[0msum\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mrep_vals\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mrep_alg\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mattacker_node\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0;36m2\u001B[0m\u001B[0;34m+\u001B[0m\u001B[0mi\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;32mfor\u001B[0m \u001B[0mi\u001B[0m \u001B[0;32min\u001B[0m \u001B[0mrange\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0msyb_count\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;34m+\u001B[0m \u001B[0mrep_vals\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mrep_alg\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mattacker_node\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m)\u001B[0m  \u001B[0;34m/\u001B[0m \u001B[0mdeserved_rep\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mrep_alg\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m",
      "\u001B[0;31mKeyError\u001B[0m: 'pht'"
     ]
    }
   ],
   "source": [
    "rep_alg = 'pht'\n",
    "(sum([rep_vals[rep_alg][attacker_node*2+i] for i in range(syb_count)]) + rep_vals[rep_alg][attacker_node])  / deserved_rep[rep_alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.845723050009196"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_alg = 'pmf'\n",
    "(sum([rep_vals[rep_alg][attacker_node*2+i] for i in range(syb_count)]) + rep_vals[rep_alg][attacker_node])  / deserved_rep[rep_alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(140799, 5.67325003604163),\n",
       " (141429, 3.7490466432844545),\n",
       " (140820, 3.681206877219496),\n",
       " (142079, 3.6185979168741196),\n",
       " (142117, 3.6138402338344005),\n",
       " (141627, 3.5571027952496475),\n",
       " (140397, 3.549948792423523),\n",
       " (140869, 3.5011648439566985),\n",
       " (140957, 3.4450984426805578),\n",
       " (140433, 3.1298624603557124)]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(rep_vals['ppr'].items(), key=lambda x: x[1], reverse=True)[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(140799, 4.744707178942078),\n",
       " (142079, 3.776979398347164),\n",
       " (140820, 3.7232587212692745),\n",
       " (141627, 3.6897183384048233),\n",
       " (141429, 3.598835733814079),\n",
       " (142117, 3.5261789929659955),\n",
       " (140869, 3.4590409405864007),\n",
       " (140397, 3.39027368089579),\n",
       " (140957, 3.3858486282993145),\n",
       " (142141, 3.344792391531886)]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(rep_vals['pht'].items(), key=lambda x: x[1], reverse=True)[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(141429, 3.21334108601447),\n",
       " (142117, 3.1318252048059176),\n",
       " (142079, 3.118224840264968),\n",
       " (142141, 3.1094687420077496),\n",
       " (141798, 3.0901714718476914),\n",
       " (140820, 3.0754017647102128),\n",
       " (140957, 3.07156733902436),\n",
       " (141701, 3.0499514246228356),\n",
       " (140799, 3.0441087777507465),\n",
       " (141627, 3.0276227928769512)]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(rep_vals['pmf'].items(), key=lambda x: x[1], reverse=True)[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.21334108601447"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_vals['pmf'][141429]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "74cbd192829565fa346022b3141b0fd27063780b621ec0011e4ed21cf4d7d415"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}