Fig5a-syt-decomposition.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "import networkx as nx\n",
    "import pyemma\n",
    "import mdtraj\n",
    "import pyemma.util.contexts\n",
    "import pickle\n",
    "from pathos.multiprocessing import Pool\n",
    "from contextlib import closing\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load data from disk\n",
    "topfile_0cal = 'hsynapto.pdb'\n",
    "trajfiles_aligned = np.loadtxt('trajfile_list.txt', dtype=str).tolist()\n",
    "\n",
    "# reference mdtraj trajectory object\n",
    "ref_0cal = mdtraj.load_pdb(topfile_0cal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_resid = 5  # truncate n and c-terminal residues\n",
    "system_integers = np.arange(first_resid, ref_0cal.top.n_residues - first_resid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-236-8899c88b1cea>:5: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  for n in tqdm(system_integers):\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "86da288934764c6ba63004da95d9aa97",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/118 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# compute feature vector for each residue and store in a dictionary\n",
    "# ATTENTION: the features should be carefully chosen, this example reproduces \n",
    "# a featurization that was previously published and might not be optimal for\n",
    "# other cases. Cf. Chignolin notebook for flexible torsion angle featurization.\n",
    "\n",
    "res_heavyatomxyzs = dict()\n",
    "\n",
    "with pyemma.util.contexts.settings(show_progress_bars=False):\n",
    "    for n in tqdm(system_integers):\n",
    "        f = pyemma.coordinates.featurizer(topfile_0cal)\n",
    "        f.add_selection(f.select(f'mass > 2 and resid {n}'))\n",
    "        res_heavyatomxyzs[n] = pyemma.coordinates.load(trajfiles_aligned, features=f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save or load from disc to increase efficiency\n",
    "# pickle.dump(res_heavyatomxyzs, open('res_heavyatomxyz.pickle', 'wb'))\n",
    "# res_heavyatomxyzs = pickle.load(open('res_heavyatomxyz.pickle', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [],
   "source": [
    "# choose lag time for vamp computation (in ns)\n",
    "msmlag = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all pairwise combinations of residue indices\n",
    "args = list(itertools.combinations(system_integers, 2))\n",
    "\n",
    "def get_edge_vamp2(n1, n2, stride=1):\n",
    "    \"\"\"\n",
    "    Compute normalized dependency between two feature\n",
    "    vectors using the VAMP2 score.\n",
    "    \n",
    "    :params:\n",
    "    :n1: int, residue index of residue A\n",
    "    :n2: int, residue index of residue B\n",
    "    :stride: int, optional, used in covariance matrix estimation\n",
    "    \n",
    "    :returns:\n",
    "    float, dependency for this link\n",
    "    \"\"\"\n",
    "    with pyemma.util.contexts.settings(show_progress_bars=False):\n",
    "        v1 = pyemma.coordinates.vamp(feature[n1], lag=msmlag, stride=stride)\n",
    "        v2 = pyemma.coordinates.vamp(feature[n2], lag=msmlag, stride=stride)\n",
    "        v12 = pyemma.coordinates.vamp([np.hstack([t1, t2]) for t1, t2 in zip(feature[n1], feature[n2])], lag=msmlag, stride=stride)\n",
    "\n",
    "    s1 = v1.score(score_method='VAMP2')\n",
    "    s2 = v2.score(score_method='VAMP2')\n",
    "    s12 = v12.score(score_method='VAMP2')\n",
    "    \n",
    "    # note that pyemma returns the vamp score in the non-whitened space (+1)\n",
    "    # i.e. we have to subtract 1 from each computed score\n",
    "    d =  (s1 + s2 - 1 - s12) / min(s1 - 1, s2 - 1)\n",
    "        \n",
    "    return d\n",
    "\n",
    "def get_edge_vamp1(n1, n2, stride=1):\n",
    "    \"\"\"\n",
    "    Compute normalized dependency between two feature\n",
    "    vectors using the VAMP1 score.\n",
    "    \n",
    "    :params:\n",
    "    :n1: int, residue index of residue A\n",
    "    :n2: int, residue index of residue B\n",
    "    :stride: int, optional, used in covariance matrix estimation\n",
    "    \n",
    "    :returns:\n",
    "    float, dependency for this link\n",
    "    \"\"\"\n",
    "    with pyemma.util.contexts.settings(show_progress_bars=False):\n",
    "        v1 = pyemma.coordinates.vamp(feature[n1], lag=msmlag, stride=stride)\n",
    "        v2 = pyemma.coordinates.vamp(feature[n2], lag=msmlag, stride=stride)\n",
    "        v12 = pyemma.coordinates.vamp([np.hstack([t1, t2]) for t1, t2 in zip(feature[n1], feature[n2])], lag=msmlag, stride=stride)\n",
    "\n",
    "        s1 = v1.score(score_method='VAMP1')\n",
    "        s2 = v2.score(score_method='VAMP1')\n",
    "        s12 = v12.score(score_method='VAMP1')\n",
    "        \n",
    "        d =  (s1 + s2 - 1 - s12) / min(s1 - 1, s2 - 1)\n",
    "        \n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature = res_heavyatomxyzs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-240-723c12f03652>:9: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  pbar = tqdm(total=len(args))\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "44812ecaad634bea94a8078a4984402f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/6903 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# VAMP-1 graph\n",
    "# initialize networkx graph object\n",
    "graph_vamp1 = nx.Graph()\n",
    "\n",
    "\n",
    "# multiprocessing w/ progress bar\n",
    "pbar = tqdm(total=len(args))\n",
    "pool = Pool(processes=8)\n",
    "with closing(pool):\n",
    "    # compute pairwise dependency on each pair of residues, populate graph edges\n",
    "    res_async = [pool.apply_async(get_edge_vamp1, a, callback=lambda _: pbar.update(1)) for a in args]\n",
    "    [graph_vamp1.add_edge(*a, weight=x.get()) for x, a in zip(res_async, args)]\n",
    "    \n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-241-a0aea468303d>:6: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  pbar = tqdm(total=len(args))\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "534d35eb197b493988d0e6e64a157d9b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/6903 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# VAMP-2 graph\n",
    "# initialize networkx graph object\n",
    "graph_vamp2 = nx.Graph()\n",
    "\n",
    "# multiprocessing w/ progress bar\n",
    "pbar = tqdm(total=len(args))\n",
    "pool = Pool(processes=8)\n",
    "with closing(pool):\n",
    "    # compute pairwise dependency on each pair of residues, populate graph edges\n",
    "    res_async = [pool.apply_async(get_edge_vamp2, a, callback=lambda _: pbar.update(1)) for a in args]\n",
    "    [graph_vamp2.add_edge(*a, weight=x.get()) for x, a in zip(res_async, args)]\n",
    "    \n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save or re-load graphs\n",
    "# pickle.dump(graph_vamp1, open('syt_graph_vamp1.pickle', 'wb'))\n",
    "# graph_vamp1 = pickle.load(open('syt_graph_vamp1.pickle', 'rb'))\n",
    "\n",
    "# pickle.dump(graph_vamp2, open('syt_graph_vamp2.pickle', 'wb'))\n",
    "# graph_vamp2 = pickle.load(open('syt_graph_vamp2.pickle', 'rb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 550,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set node sizes and edge widths\n",
    "nodesize = 20\n",
    "edgewidth = 1\n",
    "\n",
    "# define color for edges\n",
    "# color map scale adjusted individually\n",
    "_c = (0., 0., 0.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fruchterman-Reingold (FR) node positioning\n",
    "# please note that FR is stochastic and results might be slightly different\n",
    "# for each execution\n",
    "\n",
    "ks = [.01, 0.012] # FR hyperparameter\n",
    "\n",
    "pos_dicts = []\n",
    "frugold_projections = []\n",
    "for n, graph in enumerate([graph_vamp1, graph_vamp2]):\n",
    "\n",
    "    # use networkx implementation of FR algorithm\n",
    "    pos_dict = nx.spring_layout(graph, k=ks[n], \n",
    "                                iterations=5000, threshold=0.00001)\n",
    "    pos_dicts.append(pos_dict)\n",
    "    frugold_projections.append(np.array([pos_dict[r] for r in system_integers]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 499,
   "metadata": {},
   "outputs": [],
   "source": [
    "# color definitions\n",
    "sns_pal = sns.color_palette('hls', 3)  # highlight important subunits\n",
    "sns_pal2 = sns.color_palette('bone_r', 6)  # grey palette for less important subunits\n",
    "vmd_colors = np.vstack([np.array(sns_pal), np.array(sns_pal2)])\n",
    "col_pal = ['#80aee7ff', '#e68082ff']  # for histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 479,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "initialize kmeans++ centers:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "kmeans iterations:   0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "initialize kmeans++ centers:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "kmeans iterations:   0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# cluster FR projected data with k-means\n",
    "# remember that k-means is stochastic and might produce slightly different \n",
    "# results each for each run. this step further depends on the result of\n",
    "# the FR algorithm, i.e., it might be necessary to adjust hyperparameters\n",
    "\n",
    "n_clusters = [7, 7] # number of nodes for vamp-1 / vamp-2 projections\n",
    "\n",
    "assignments = []\n",
    "cluster_objs = []\n",
    "\n",
    "for n, (k, xy) in enumerate(zip(n_clusters, frugold_projections)):\n",
    "    # cluster in projected space\n",
    "    cl = pyemma.coordinates.cluster_kmeans(xy, k=k, tolerance=1e-7, \n",
    "                                           max_iter=100)\n",
    "    cluster_objs.append(cl)\n",
    "    assignments.append(cl.dtrajs[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 553,
   "metadata": {},
   "outputs": [],
   "source": [
    "# color-matching. numbers have no physical meaning\n",
    "# and are manually sorted for readability.\n",
    "# assignment from VMD visual inspection.\n",
    "\n",
    "cassignm = [np.array([6, 3, 2, 0, 4, 1, 5]),\n",
    "                  np.array([4, 3, 1, 5, 0, 6, 7])]\n",
    "\n",
    "matched_assignments = []\n",
    "for n in range(len(assignments)):\n",
    "    matched_assignments.append(cassignm[n][assignments[n]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 556,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to quantify the differences between a) dependencies of\n",
    "# nodes in a cluster and b) dependencies between nodes of different clusters, \n",
    "# each node has to be viewed from its strongest embedding into the network. \n",
    "# \n",
    "# Example: network consisting of 3 nodes [n1, n2, n3]. If dependency scores \n",
    "# between (n1, n2) and (n2, n3) are very high, the network cannot be decomposed\n",
    "# irrespectively of how low the dependency is for (n1, n3).\n",
    "    \n",
    "# This means that the dependency between a single node n and a set of nodes C\n",
    "# should be viewed by taking the max of all edges between n and all nodes of C. \n",
    "\n",
    "intra_cluster_edge_list, inter_cluster_edge_list = [], []\n",
    "for assignments, graph, _n_clusters in zip(matched_assignments, \n",
    "                                           [graph_vamp1, graph_vamp2], \n",
    "                                          n_clusters):\n",
    "        \n",
    "    # group cluster nodes together\n",
    "    node_groups = [np.array(list(graph.nodes))[np.where(assignments == n)[0]] \\\n",
    "                   for n in np.unique(assignments)]\n",
    "\n",
    "    # extract edges within each cluster and between two clusters\n",
    "    inter_cluster_edges = []\n",
    "    intra_cluster_edges = []\n",
    "    \n",
    "    # iterate over all combinations of clusters\n",
    "    # -> extract inter-cluster edges\n",
    "    for cluster_i, cluster_j in itertools.combinations(range(_n_clusters), 2):\n",
    "        \n",
    "        _inter_cluster_edges = []\n",
    "\n",
    "        # max link between (each member of cluster i) and (all members of cluster j)\n",
    "        for node_i in node_groups[cluster_i]:\n",
    "            w_to_all_cluster_j = [graph.get_edge_data(node_i, node_j)['weight'] for \\\n",
    "                                  node_j in node_groups[cluster_j]]\n",
    "            _inter_cluster_edges.append(max(w_to_all_cluster_j))\n",
    "\n",
    "        # max link between (each member of cluster j) and (all members of cluster i)\n",
    "        for node_j in node_groups[cluster_j]:\n",
    "            w_to_all_cluster_i = [graph.get_edge_data(node_i, node_j)['weight'] for \\\n",
    "                                  node_i in node_groups[cluster_i]]\n",
    "            _inter_cluster_edges.append(max(w_to_all_cluster_i))\n",
    "        \n",
    "        inter_cluster_edges += _inter_cluster_edges\n",
    "\n",
    "    # iterate over every cluster\n",
    "    # -> extract intra-cluster edges\n",
    "    for cluster_i in range(_n_clusters):\n",
    "        \n",
    "        _intra_cluster_edges = []\n",
    "        \n",
    "        # max link within a single cluster of nodes, i.e., get max edge between node and \n",
    "        # all other members of the same cluster\n",
    "        for node_i in node_groups[cluster_i]:\n",
    "            w_to_all_in_cluster = [graph.get_edge_data(node_i, node_j)['weight'] for \\\n",
    "                                   node_j in node_groups[cluster_i] if node_i!=node_j]\n",
    "            _intra_cluster_edges.append(max(w_to_all_in_cluster))\n",
    "\n",
    "        intra_cluster_edges += _intra_cluster_edges\n",
    "\n",
    "    inter_cluster_edge_list.append(np.array(inter_cluster_edges))\n",
    "    intra_cluster_edge_list.append(np.array(intra_cluster_edges))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 506,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_dependency_graph(ax, _graph, pos_dict, assigments, edge_lcutoff=.3, nodelabels=False):\n",
    "    \"\"\"\n",
    "    Plots the dependency graph using networkx and matplotlib.pyplot.\n",
    "    :params:\n",
    "    :ax: plt.Axes object, populated by this function\n",
    "    :_graph: nx.Graph object, graph to show\n",
    "    :pos_dict: dict, contains positions of graph nodes\n",
    "    :assignments: list, assignment of colors (to match VMD output)\n",
    "    :edge_lcutoff: float, cutoff value for edge weights; everything \n",
    "    below will not be shown\n",
    "    :nodelabels: bool, optional, default: False. for matching clusters with VMD representation\n",
    "    \n",
    "    :returns:\n",
    "    :ax: populated plt.Axes object\n",
    "    :pc: matplotlib.collections.LineCollection of network edges\n",
    "    \"\"\"\n",
    "    # remove invisible paths from graph (decreases SVG file size later)\n",
    "    graph = nx.Graph()\n",
    "    graph.add_nodes_from(_graph.nodes)\n",
    "    for edge in _graph.edges():\n",
    "        w = _graph.get_edge_data(*edge)['weight']\n",
    "        if w > edge_lcutoff:\n",
    "            graph.add_edge(*edge, weight=w)\n",
    "    \n",
    "    weights = np.array(list(nx.get_edge_attributes(graph, 'weight').values()))\n",
    "\n",
    "    nx.draw_networkx_nodes(graph, \n",
    "                           node_size=nodesize,\n",
    "                           pos=pos_dict, \n",
    "                           ax=ax, \n",
    "                           node_color=vmd_colors[assigments])\n",
    "    \n",
    "    if nodelabels:\n",
    "        nx.draw_networkx_labels(graph, pos_dict, font_size=6)\n",
    "\n",
    "    pc = nx.draw_networkx_edges(graph, \n",
    "                                edge_color=weights, \n",
    "                                width=edgewidth, \n",
    "                                pos=pos_dict, \n",
    "                                node_size=nodesize,\n",
    "                                ax=ax, \n",
    "                                edge_cmap=edge_cmap, \n",
    "                                edge_vmax=1, \n",
    "                                edge_vmin=0\n",
    "                               )\n",
    "    \n",
    "    return ax, pc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUoAAAEECAYAAABOe30ZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAA9hAAAPYQGoP6dpAACkxUlEQVR4nOydd5xU1fn/3+fOzM72Ciy9Lr2LYANFsZvYjahRN8Zoyi/Rr8k3iWliYmKqSUz5qrGA0Yi9xYZdFCtSBYSl97K978zc8/vjOWfv7DBbgGV3Wefzes1rd+7ccm77nKc/SmtNAgkkkEACzcPp7AEkkEACCXR1JIgygQQSSKAVJIgygQQSSKAVJIgygQQSSKAVJIgygQQSSKAVJIgygQQSSKAVJIgygQQSSKAVJIgygQQSSKAVJIgygQQSSKAVJIgygQQSSKAVJIgygQS+gFBKnaiUel4ptUMppZVS57dhm5OUUouVUnVKqQ1KqW92wFC7BBJEmUACX0ykAcuA/9eWlZVSQ4AXgYXAZOA3wJ1KqYsO2wi7EFSiKEYCCXyxoZTSwAVa62daWOd3wLla69FRy+4CJmqtjzv8o+xc+Dt7AAkkkEDboZRKBpLauHq91rq+nQ59HLAgZtkrwNeVUgGtdailjZVSQSAYszgJKNZHgLSWUL0TSOAIgSHJWqA8zmd7nGU3t+PhewO7Y5btRoStHm3Y/uY449tbXl7uAroTP21CQqJMIIEjBy1JkulAf6Ayall7SZMWscSimlkeD7cDd0R9zwC2tcegOgIJokwggSMMjuOglGr8rrXGdV2ASq11xWE67C5EqoxGLyAMFLe2sTEBNBJ39PiPBCSIMoEEjjAopTqDaN4Hvhyz7HTgk9bsk90BCRtlAgkcYfD5fPt9DhRKqXSl1CSl1CSzaIj5PtD8frtS6sGoTe4CBiml7lBKjVZKXQN8HfjjIZ7OEYGERJlAAkcY4qneB4GjgTejvlv74TygEOgDDIw6xkal1NnAn4HvADuA72mtnzyYgx9pSMRRJtAqbr1zXgpwITAM+Bx45pbvXd3ejoIEWoFSKhMoT01N3Y8oa2pqALIOo42yXWHPpby8nMzMzE4dSltWSqjeCbSIW++cNw7YADwE/ByYDxTdeue8EZ06sC8wrI0y+pPA4UWCKBNoFrfeOU8BTwE9zSJrqukNPGZ+T6CDkSDKjkeCKBNoCccCw4FYb4EfmAiM7/ARJYDjOPt9Eji8SDhzvoAwNseLgFGIWv3YLd+7uip2Pdd1e7TyEvZs6ccEDg/ayZmTwAEgMRV9wXDrnfNGAkXAv4EfAvcBm269c95kACXwK6WC2zdvWK21dpvZVRhY3iGDTqAJEqp3xyNBlF8gGJvifCSjAiAAoLXO1lo/NWBIQTKQbJbr4r27tiql5sUWLTBf/3bL967e23GjT8DCcZwmMZQJ1fvwI3GFv1gYC0wixuSilPIppQZfcd3/HAc0zPnr3OCcv879+6Rp08uBr7lupFK7bh1AJBKu2rZ5/by7/zhnTkcPPgFBQqLseCRslN0It945rx9wMlADvHLL966ujv69dN+eATk9esXdFmDXjq1jh40c9yFSPmsKxonjOL4MpZRqqK+7/s+3/mBxbXVVT2CgUuqzI6FEVndDwoHT8UgQZTeAUal/C/wAT0uovPXOeVfPuaHwVUSKPDMtI3PaTbfeoX0+/34iiNZav/rcY32HDB/9d2Ba9G9KRBYdSAp+v6G+7gxEPc9GnDl7Dtd5JRAfsVJkQqI8/EhMS90D1yCOmcb7qbVO1677RN8BQx4BfgmMqa6seK2seN/9sUKg1lqXlxY/vWPLxo8GDBk+wDWlaGKglFIjpk4/RQFVQAPQTynV1iKyCbQTEuFBHY/EFe7iuPXOeam33jmvtRyv78WqwEoppdHqmJNOHYpUpn4BKP/H7T9ZtvSjd1+rr6utBQg1NNQt/2TRR3/79Y+LgIm1NVW1qnkRpb50354KRLWvRpw+fQ/l/BI4cCRslB2PhOrdRXHrnfOGAn8BzgGcW++c9wnwg1u+d/Xbdh2lVAYw+md/+tdwvz+w39uilEOvPv3rkKrYSUC967p1z/7nvheenz/36fy+/TeX7Nuzvb6uth6REPf27jcwEzhTa+2PJkytdUQp9e/PVy6tBeoQkiwB8pRSJUdKjnF3QHeSIus3b4Hx4zp7GK2ie1ztboZb75yXCywCzsK7R0cBr37rh786SSl1mlLqJwiR/qhk355K7brxnCrajUQ+Bd5CpMqXgdeBD1w38uTObZtfrK+rXQ6sRypj67v/cMv2cKjhSiCstXa11mGAcDi0aue2zT9G4idrgFDUp59SKvEsdRDao8xaV0HZk08dEQHzCYmya+JaxFESTT6O67qqrq7mEaTNaDmSVfNm0eoVa3v17vdjrXWjGiaB4rq6V5/+P9da7wIJAwL6IRJmJd79j5jvqYDz6/+9/tWzL75y4rQZs87QWudt3VS0/qH/+9Py+rpajRAliFQZRJw5fZHYzF2H6XokEIXu5MzR9fUQiYC/a1NR1x7dFxfHEKf8k+M4qu+AIRmIh3sjUlq/74Jn5n8+adr0nimpaV/DI9fSndu2XHXPH+dU3PaDb9hdJAGZiH1RAy7gaq21UsoSXw9Av/jEv9e/8PiDfwEp8goMQvqchMx2NUAKQrIVQC+lVGk7dv1LoBl0J9UbgCNAouxGV7tbYR9CQE2gtdZJweAmrfXbSAe8HoD7g9v+OiI1Lf3rNCXX7N79Bv4oKZicopQKKqX8CNEFEWk0pLWOWCeQ+VsLZCHk2RC1L+u8CSLk6EMIM4xMtqUI8fZrv0uQQEvoTo4cHTfIomshQZRdEw/QjLTvRiL3GglvFKDSMjLXpaal/9JIhY1vjVLK5zjOid/60a+ORWIe0xHVugaRAPfzkiNEWA802ZdZtwTveUkyH6uuh8zvGUqp7EM58QRaR7cLD4rsJxN0ORzhV7h74pbvXf1BeWnJbVprtNbaNY4ard3H7rztR88AYxAb4abjZp6R7zi+ofFCerTW4czs3Klm3SyE1CqJ39M4gBDlPvNbaszvNnYyGVG9MxAp04dIsrXme9+EY+fworsRpT4CiDJho+yi+POcm4qGjhz7k2NOPG18dVVFQTgU+uuLT/z7DWAAIhUWA4HKirJKE7oTz/Xp+Hy+YkRKVIh9cjtYZ4/AbJuK59GOAGlKqXqtdThKWi0B8s3fDIQ0GxB1vMYs74cU9t3R3tckAUF3cuYA6HC49ZU6GQmi7IJQSo0C+m/4/LMnNnz+2RYkNMjaAPcgUmEAqP3w7VeTTjnnomeTkoLnRZOlMT1GQg31jyFqcsR8fERJk4YAk5BnodLYKuuUUslAGmLPxGxTjthFMxFiTEOk1XSEJNMRibSnia2sa/eLk8B+UuSREF7TEnSo63e7PbJl9m4Io7aejMQ2bkEIKoiQZClCVjWIM8cBei79YOHNoYb6LQCRSATXddFa63Wrlv3y1/97fa3ZRzIi5fmA9ChV3Y9IhKEYj3UV4DeE2Tg8M4Z0RNUGUcP9ZowRPBW9fztdkgRi0O1U77quHyiRkCi7Ho4CcoAnEQLrbZbXIzZAa2P0I5Jg6KWnHg69+dLTP51y/Myrc3v0mlxbU12/YvH7b+zesa0OUZXLEQnUeqfTELKsQQgOs+9GaK3DSql6IFUp1aC1dg25lgG5eE6cEEK+mcBehER3AoOVUrla65J2vj5feHQ3idKtrW19pU5Ggii7EJRSQWAGUjm8FulL40fsirXmf2U+LkKU+4B+dbU1vd57/cUVeARWjJDjdOBdPIdLACHbdEQi9QENNgMnBjXmGKmIpIg5bjlClmWI9FgN5CEB5xGzTinQRylVrrXu+tb6IwjdzUbpVu3XhaTLIUGUnYxb75znR5rR+9Mzs1KrKsqTEKIci0h72xHJUiHktstIexlmF9osDyBEGELIMxnYCgxBvOQrzf5chNzqEXtjHUJ4+8FIkTWIY6cOIUHr1MlGCLTaHK8nQp7lZjx7ECmzD7Dt0K5SAtHobhJlpLy89ZU6GUe2ceMIx613zjsbIbP3gYU3/OIPz1zw1et6AwMRwtuKEFE1QmzJgM+owGlRy3oiJFZqtmtACFEjJHUsQmC2zYODeLjDiETZ7IRpHDJhhPzssjASi5mBEGeD2X++WTdijrMLKZoRG2qUwCGgu1UPCpeWdvYQWkVCouwk3HrnvDHAs0S1gvX7AykTjj7uRp/Pt/SJef/3NCKh2ZCdFLysmFSE7DRCSD3xQnaq8STLgcDL/QYNPXrWORf9acDQ4bvKS4rfv+8vt71eW1PtIOp0BLFXVjSjfmP2mYVIpA1RoUK9EclyJyJBFiD2Vaval5lz6K+UWpeoht4+6G4SZXh316/9nJAoOw/fMX+js2kAImMmTb0IkRYtGdpqPWlm/QxEYrTqeCpCSjYH2zp90i/9+ne/ee3//PxbQ0aMudLvD9zUI7/P09//5V9eGDpybK5Z15JlZjOxmFaCrDPHUWaZlSLzzPa1Zl/ZyAQcQSTYbQjB5x38pUogFt1FmgQI792LW9+1Pd8Jouw8jCGORG8afY1B7o29P7WIZKkQIrKhOPWI1FiDF65TY/6WDRs1LmPU+KOuUx78AD6//4SLrrz+RsAxUl4FJtumhayaGryMHft27sErtGFDg2y4Udj8Vo84lnrb4ydwaOhu4UEADZs3d/YQWsSRf4WPXBThlSxrhPEQr0XujSUkmy0D4oAJmG1rEaLcipCSMus6wL6p00+ZGK8vt1LKSU3PuAxIUkolR5GlQsgybk8dPC+43yyrNsusjbQKzyufhBBrCmKr1CSqobcLulM9Sou6z9d29hBaRIIoOw//xJPoGqGU8rlu5E680J0wonZb8spCSKkGSWdMQmyEFvUIKVUGk1PSaQameEUtHlm6iLruI8pxEw0TkB5CvOB2PPvw0hkrzTL7XPnwCHMnkGMKeiRwCOhuzhyAulWru3QqY4IoOwm3fO/qJW4kcgVefCKhUINe+emH//7VTde+SlOitK0XIoiaa1XxoXiZMK5Zx7Z1YPvmDducOHqZ67o6Eol8qLUO4ZFlirFFVpnvac0MvdqMLcV8LzdjyTPScAViHqhCCDIJSDGB59VINfQj/83uRHRH1VvX1VG7YmVnD6NZJGxGnYhf3vT1ZwcOHb54+JiJ16RnZFa98sz8C+pqazIRdboEkSLDCPEl4ZFnlfk+ANhw4ZXXHzd4+KjvJienjquvq634bOlHixc8++jid197cdmU42dOCyan5DuOY50wGlDPPnLfvl/d9PVeWus9hrdSlFJorWuVUtWI1OhqrZukTZgCHLVm/XozvnLEcx5EQpRyzPhsr55Us802YASJNreHhFhy7A5ECVD13nukTJyA6oLn0/VG9AWBcZr4t2xYF3n9v08sffaR+x+vq615F6kkPgtRZW28o63QA17mSz8g+ZobflowfsqxD2ZkZh+dFAympWdm9T72pNO/9LXv3vztutrqHff/5dcPrVu1bHckEtEAbiSy4vX/PvH35R8vCgI3KqVG4tk7A0aytA3JUg35xcLmj9uKQ1YqzjXEWm/+tx74FESqrENU9XyVaHN70OhuqrevVy8AIsUl1Cz+tJNHEx8JibLzYLNkgnhB4v9F2kCcBHyOqNz2NxuXmGO2GaaUquw/eNhtSBEgBxqrATFgSMGJYyZNfWnV0o8HPfKvv77i8/mHpWVk/q2irORphIyvRLJ2LgVeARYjBGglyxqzz3QjWTaWeDFl16rNmOrNeVQgIUb7EKmyl/FyVyGEmmukyt2Iat4X2NSuV/QLgu6WwhicNImaBQsAqHzjTZJHj8KX3rVM2QmJshNgCMiHEGAQT0JbC6xCiGwsQophvADzPWa9XKDPmElTw47jNFe0V4+ZePQEs21RJBKmoqykzuxnK9KNcbvZ35nAaXhpkFayrEKIOiNOjGUDXmxnGJEcI3gB5xqxp9rq6D4g29gxdwBZSqnW+pUnEAftZaNUSn1bKbVRKVWnlFqslJrRyvpXKKWWKaVqlFI7lVIPKKUOOT7W6dGTpKFDAbFVlj/33y4XRJ8gys6BlSYdxIYXNt/3AAsR2+RYxJ7nx6v/qBBCGgr4klNSt7ZwDFVfX6cQqdQGoPdEPO31CCGvM/tcgVQtOh/xqtcgZGkroruItBj7vFSb7QMIEZbR1CufDvijgtOzlVJJWusys99Em9uDQHuEBymlLkXaHf8amIw8dy8ppQY2s/504EHgPuTZvASYCtx7UCcRBQ2kTp2CSpaKfvXr1lH9/geHutt2ReIh7WDEkSZBJDNt/q7sN2ho+SWF3z7nxlv++NMbfv6HO2df+70TENU2gKiyQ4DyxYve2t5QX7fYjdPTW2tXv/faC1WIA2UgEsuYj7nnWut9wNtm9Z7A84jd82KklmQ9XvB4hVmvMcbSOIVsQzJLlOV4QfEV5vx85pxtHnoPs4/tZrteB3kpv9BoB/vkTcB9Wut7tdartdY3IprGt5pZ/1hgk9b6Tq31Rq31u8DdSEGXQ4J2wUlOJm368Y3LKl97nfqi9Ye663ZDgig7HlaajCBqawjPQaO/+s3vD/z6DT89Y/TEKYOzc3v0zsrNmzpq/FF3X/2dH52D16+mN1L7Mfj8o/OeCIUaQtrAdaWx4oJnH9tTsm9PH4Sg+iPZMRl49S1BXgzrQMoF5iOEdz4wHK/uZTJCfD6zDwuNSKz1eOaBMkT9tsHnqXi2cFvVKMNItXsQW2Y8h1ECzaAF1TtDKZUZ9Yl7XY0jbQqwIOanBcDx+28BwCIkZ/9sk+WVj0yqL7RlzEo6gTaOjajnyDUF95P69SN5wnhZqDWljz9BaFfXaBWfIMoORIw0CV6qXwRwZ555vh46cuwc5Tg+x/EpABsHOXj4qK9Omja9H15wdxgYumLx+yl3/e7nT2xev/bhXdu3rPlsycfbH777jmc+eOsVW8NyANDbcZxtJ8w6e8S3f/zreT//071P/eLP9109569zAZYiPcJPNOP6D0J2ZyJpljYTJ4hpQRETNG7NAQ5CiqV4hFqNTAaYZbVmH1lKKqfvQSaKRJvbA0ALXu9tiFRvPzc3s4seyP3YHbN8N00n0kZorRcBVwCPIs/JLuQ5+W4bh31zzNgaS+9FmyNTJk0kMHCALG9ooOThRwiXdH7t5wRRdixsjra1T9r2sAB65lnn93ccZ3wzAdlq/JRjT0dIpQ5Rp7OB3NLivSvm/u32J+7+wy3/fvLBuz4sWr0ChLDeAFzlOLnX3PDT75x27lcu7Jnf5zif33+ez+efGwmHF15wxTciZj0HOBd5+B/BI8+JeP3AreofNM4e+4jb8KJM838FnlPHhjXZlEzr6LEFPraTaHN7QGhBouyP2Ijt5/ZWdhVrslFxlskPUn/gTuCXiDR6JmICuquNw749ZmyNrUIiUZYjpRTpM6bj79kTkKK+JQ8+RLisrI2HOTxIEGUHwXiNfXj2yID5WCeNrQbULKoqK3oi0p21HfYw+9uBENlOvEK+5cB7wJbJx0xP7T942HAA5TiOdaA4Pt/Rg4eP+hFCch8hTqITjFr8NCJtTkaM9lkIufnMmGNjLMvxSsCVmHOzL166+evDa2kRRAi40mybaHPbRrQgUVZqrSuiPs2V5NmHTNix0mMv9pcyLW4G3tNa/0FrvVxr/QrwbeAapVSf1sasta6PHhteuiuRmGoEyu8nfdbJ+LKz5ffyckoefKhTC/wmHsyOg+2E6BpJzI+XoqjMb1td110Vr5AFoD9859VdSPxhPSJV9kMql+cg5FWKEFU9Qpp9gNXjjjo2PZ7DB1AZmdnnIs+BVdvOVEr1MmN4DXgTkRymIxJsnhmv7b5o+3qHzLI0cy7VeLZKK2kqc6xaRH3zmfVt07O4al8CTXGo4UEmCmExEhIWjdMQW2Q8pCKTeTRsoZZDCuSMFwrkBINknH4qTqZEkEVKSyme9+9OI8sEUXYA4kiT0NTjDRC55XtX622bin6qtY5YYnNdeTaXf/L++zu2bByGPJTrEfVnD14bWutsSUMIczuinqempqbXxFPnlVIqHAlnITbPamAZQlb/Tyk1AvGSbwLeMv+fbv4OxnMsZZnj2rJvtvp6iTlHW27NThRWqrTjDpptdiMe8eiuj21C4XVz+hReN+d/C6+bc0fhdXO+WnjdnAPex5GEdsrMuQO4Vil1jVJqtFLqz8jzcpc5xu1KqQej1n8euFAp9S2l1FCl1AmIKv6R1vqQerhHmumo5KSkkHn6aTiZ4veJlJZSPPfBTlHDE5k5HYNG22SUXc+m/9nHJGLiFrePO+qYW6ZOn3VhXs/8fqUle/l44Rt7l3+yyBra1yFElYvEvtkmXxHkQbcxk7sRiS5ny8Z1G/P7DdgvPs51Xb1j88a1SIjHJry+OmeYZZ8hkl8xkr1zBiJ1LEYkyxJzDr3MGKzUkYFIkgE8x0EvhNjt5FyHmA8aEGItNufSHylB1yYUXjfnS0jHSlssOAD8svC6OSfNvWdOS3GmRyxiYyftZHog0Fo/aoLFf4FoHiuBs7XWtjBkH+R5suvPVdKn6f8Bf0Lu9xvAjw7uLDyE4yo7AictlczTT6diwQLcikoiZWWUzPs3uVdfid+o5h2BBFEeZhhp0qqbdpkfrxpQBK93dxrQb+WnH25f+emHd5jlwxEnSzZCQoOQlgtlZr91eM6RPoi06TPLsoBBb7/y7JIxE48el5aekatMcQzXdXV9XW3DGy8+9TRCViMRkqpG1PZRCBFbibAE8YjPQrzhn+KFDdWYY1abdS35VSGmApuCaZuT+c1+M8z4/Was1cAgpZTtIunGfqLNEoXXzclEQpqsPdSS8ABEMjqn9Tt05KG9imJorf+JlPuL91thnGV/A/52UAdrAS0RJRiyPON0Kl55FbeiopEs8wqvwpeV1d7DiT+GDjnKFxtW/bQB2iAvtq2uY2s2piCB3z0Qm10JIhW6weTkuuNPOXPAxYXf6nv6ebO/0yO/TwpCJLYKegOSLVEBrEYku2GIhFZRXVmx976/3Pa3lUs+WlFdVVlZX1dbsWv7llfv/+tvntiyYe1J5jhL8RwyOxGC/roZ717EROBH1PBtiOqfbc7PhiuBqNV7EJIsM9uWm/8rzW97zVj34jVFs/pjFTIZZJn955pr0gupkt5XKdVbKdWrqrLsCjzveTT8wFmF183p0fxtOXLR3cqshSOtpys6qalknnGaZ7MsK6P4wYeIdFCr24REeRgRJU3WQ2M2C8h1twSXjBBbDqJalyLElQukDhw6vM9l37jxqOSU1FTtui5KOcecdNrwN1986v53X3thM15l8z5I8PhIRFKzWTM7gF6lxXu3PvngXZuQ0J9FiFqlEbvj9cCvkFxzq1KnIgU6LgDWmDHtQQjxA4Q4j0XU88/N+C3R2orp1vve05x3lrkW1rFjg9Kt8ykVmQCGmuU78CYD+/FhIgY0uocp0BE3nAr4TeF1c/4y9545q1q6T0caultRjFAbu75bsqx4xajhJSWU/Pth8r52NU7y4TVLH9lTUddHPGkSPKIEISbr0EhB4hfTMaE/F1/9rVODySkpSikcn88xEoRv5lkXXJWT16uvz+fPQNRkB69Vw05EgsvGC+rua45RhpDRArPNm2abHyCEVWS2WYJk7oxEJMEcYBJev/H3EWKeAMww+8g162WYcmsN5mPNA8lmLLZ0nJ1EUvDa62Ygk0VvxFtuw6isQyhg1qt3I5HXmikIYv/9GrCy8Lo5X49d50iGUqqJNHmkE2VbJEoLJzWVjNNPw0mTPIbwnj2Uzn/0sFdHTxDlYUKUNBkCT5o0L7aNg8xCXnpbubwe8VaPATjnkqt2Z2bnjrRFd6P2jd/vD97wi9//9qd/uPuPV1x/0xX5fQeUISRXhJBhLzzbYh0i1ZUhZBXRWu9Bwn9cJOe7B0KWSYhjZxVCppnAqWa/S8z+BiGB6NVmHzlmnRyzn8HGMVWNl5Fji2fYTB1rn7Vl2mwwu/VSKISk0/Da9Lpm/Rqg+pnH//FRRXnJ4ujwEq11NHH4zX7uKrxuTrcJPWonr3eXQUNsIGUr8KWlkXH6qY1FNBo2b6H8+cNbcShBlIcBhgxtVaDYu+dHCCUdUU8jZt0MhCRHI+SwZOzkaa0ey/H5fMNGjRt43fdv+fqXvnJ1GUKKLl5wuFXBdV6v3uqo406adMo5F/UF0FrvRMqt1SAS4jCkKEI2QoiLgFcRe+UpiMS4G3HyrMRzIq1CCPgURH0eiBBpOl45tghCeNl4jhfbUsKHSNYpeHbb7WYbR2tdjKjw1XihRQr48vNP3bV688bVi1w3Um2ufbzL5AMuavViHiHobkQZOghh0JeZScasU8Av82rt8hWHteJQwkZ5eGBtadbTbaVJPyJx5SLqbAVCEFmIupmBSIKbgd3bt2wIDS4YVR0IJDXXv0YO5jhKKzV49IQpX/3vY/O24cVmKqB/ckpq8uXX3XjcgCHDbXrk1bfeOe814Aqt9Xal1JvAyYhD5yhgNuJNLkHi5waY5RvxqgmVInGXAUStr0KI8izEbhlGMno24vUOT0YkW9tS16Y1avM3GS8Y3Qauj1JKBRDytznnAcQ+eno4HKp/+/XHH8rr2Xf+l87/xp3NXCI7cXQLdLdWEKEDUL2j4e+RR/r06VS9JUWwKl97nUC/vgQHDWrP4cmx2n2PX3DESJONaYlKqRTkJU/HI440RAJLw6iJqekZ5Vd9+3/Pz+/T/x8a3aOqojwUyM6NVSnjIdLQUH8W8DBe4DfAoMuv/5/TBgwuiM0hnwk8d+ud847TWm9RSr2NFyx+CqKmL0DsmU8B1yFS4lt45F6FkKZ19GwAvgycgMR6bkfU571mXWuLjSASotW5rB3ShhT5zP6D5lhpZh821XOEOUYxItl+XLJvZ4+6upq9wWBKzzjXyQcsKrxuzkkISS+ee8+cAw8+7CKIjaM80tvVHixRAiQNGkjyhPHULV8BWlP21DP0/OZ1OCkprW98ADiyp6KuiegsHIVHPklmuW3vYG1uvTAxkj6ff+P1P7j1lvy+A65XjtPPcXzB9MzsNK011VWVNdDEc94EWmtVvHd3BuJwmYCkN/bNzM4Z3n/QsGlxnB5+4JjiPbtOMmWvypECvlsR8puNBJePMWP+DJEqh+Bl5Aw2v49H1PZkhFxfMOfb05xnP0TqDJrlQbPPaH+nzSrKNuvUmHV24oUcrUEmoLFIvOgnwCqfz793yLBxI9au+mRv3Dsiuc0vIyT/EbC+8Lo5JzSzbpdHd1O9G8KHZltMmTgBf+98ANyKCspferk9htUECYmyHWHIKIAnTSab71ayDCEvfQ5eBstIxPb2+ZcuvXp6Vk7ucdH7dBxHaa11ONQQnnND4SsXfPUbPSYcffxRscTnOI6z8tMPX0bIJ9+MoUduj/yMWGdQNLZsXDfb/LsPkSKXI6Q1DbHrFSOk9RJCeDOAfyASXi5edk2N+VQjpLQO6f0TBLaYMQ1EJOohiJq/AzFB1JqPtdnu1VqHjcqdiXjAU801PN8cZy9QfsKJ52YPGjr2jUAgqaC5c0TMHdEYCCwovG7O8Ln3zDmk9LvOQEL1bgrlOKRPP0FaSDQ0ULdiJXVjx5I8ckQ7jTAhUbY3rKc7ghCC7bMd7bEN4klUU5GXfwMQyMjMPi9e8QqllMrO7ZGZnpmV8uITD60o3rNrE4Druq7W2tVas/DV/65e+uHCHgj5pvbuN7ByxulfTh8z6ejk5qRQgNXLPpmCpKXdAFyDSKMaIbFU4JuIg2kAEkqUAZyNEOJ2xI6ZhnjCh5vtJyCTxNvmeoxApNXXEKkwGSHZfuZvxOxnr7lGAYCovuOlSGzld8312goUF4ycvGPo8An/8fv9w1q6KXFgS9xde4DbdQl0N4nyUIkSwElLI3WaV2y9/MWXcBsaWtjiwJCQKNsJUdKk9eS6iOSTlpqerv/y+JPjKkrLBr/z0gvbnvv3gw0I+eQjKmQImL5rx9aCYaPGxn3qXdfFjUT6paZnZNz75199MHLc5C3HnnTanuSU1O1vv/LciqUfvTvluJPPmHzMiaePzczK7mFTFTG2zVgbp+u6bnnJvuq1ny1fjkiNWQgZ2vzedIQAhwG3IFLiXoQgzzLnudGcozUl+JEJwJZ42Yu0CzgDmRQ+AN5BVHgrFeYjJFuGqNnFgFZK1QFkZuU5R0095SKlnGsikbC7b8/2e1et/KAE2DVo8Kj/VcpJaybgvC0YeZDbdSoSEmV8JA0dSv2GjYR37MStqKDq7XfIPO3Udtl3gijbD36EXKwUFAZSf3zHX0eMGD/+IaXUyLxevTj/qkJO/tK5a373/Rvn7dq2zRa4mAn0/Xjh6ynHn3wmsa+9dl23prqq5IZb/jgkGEx2wuHQpM+WfLxj7j9+t7S+tnYTsOe8y7+eN/mYGTO1dmlS1tHsLJZL3Ehk1VMP/etJ0EchBP8xQnY55rvtDqkQye9cRF2uN+f5JeAxhNj2IQ6dVERC7Gm2y0LU8s/MPmcBqzIyc8smH33yuX36DclzHN+ubVvWPr/wzadDyORhW9xu6tNvaPXJp33l4UAgeJzruq5SiiHDxv1z6PAJD/z36XuW+QNJk6Q+9kET5YaD3K5T0d0ycw7VRmmhlCLtmGmUP/s8uC7VH3xI6uRJ+HsceiZrgijbAUp6kGQhKqQtSJo6YdoxwRHjxz+DSE12XbLz8kbddt/c2+793W8//eCN12zFnXXlpcXbPlvy0cJxRx1zLZ5H2Ke1rktLz+hhXwi/P6AmHH1c3x75fU7/159ufTaYnDx43ORjzpf9x5cutNa6urJy4/o1Kx4q2bd71zuv/ne1dt16JDf8fKSa+QKk2IWtM+lHpK7J5m86EhJUh1QXugAJRI/gSZIleLGhCpESfUjIU2pmVt4ZZ517zfnBYEq2WY+hBRO+07vP4J8+/p8/P4Ko2KOBEeMmHH+83590LHgtMQDyevT52sDBo//bUF+3i4OTCl1kIjvkDoKdge4oUbYhqqNN8GVmkjxurHjBXZeKVxaQc/llh7zvBFEeAozKZ8N+okNe0gHnO3NuPVkpFbcfjOM4vmt+8L9Hr12xbGHJ3r2fI3nWzpMP3rW2aPWK1eOOOubc1PSM5LLifVtGTzzqwtgbrZRS/QYOGZ3fb0BNcnJKaiApqcUGXUopFYmE+j398L9OQMh8Kl5jsB2IXfE7CKGtwPPYazwP9BRE4lyK2Cd7I/bCKrPcZgPZcJ9kRKIsRQizYsbMC45KSkrOMufTGNeSkprx6959hyTv2rFxJyLJpuXk5p8ZT612XVePHX9szscfLFjXf+CIk6DZfO9GGOeQfd6LgSvm3jNnc0vbdFU4jtMkJOhIJ0qQKuf+dopyShk/job163Gra6gvWk/92nWH7NjpUkRZVDh7HKLSRYBnC+bOX9vJQ2qEeRGjizMk4XUeVIiEkoU4O/xAfXVFxcRAXg9XxRHzlFL4/H4148yzCp7994PJiJfZB4SWffxe6rKP3/MBkcEFo/qPnTy12fs0YFBB5rbN62ua+93CjUTYvmVjLV6lnyBib6xFzAXrzfcChACXIMRv19tozmsoXmOqdKRwxkd4ErA2+7fpmz7Eyz3GcXxubo8+45vxwutRY6ZO2LVj43qzjyF+fyAp3rkopdDQc9/e7RtXrXj/r2PGHXu98vlSYL8URhtOVd7QUDcuGEyZYs7lnbn3zAnF2/eRgO4mUQI0RDR+X/uYEJTfT8qUKVS/sxCAilcWEBw2FOU/eLrrEkRZVDhbAX9FvJo2tu73RYWzbyuYO//n7XksQ1qxpNfSR0X9tUjGq6lovbQRvBCWciBz0auvZp9z2eXNPsXadXVur3wXkdZq8Qrh2qo7qramOo+oRkyx6NW33z8Xf/D2svq62n8lBZOHxCNlrbVGoT9657VPzDhrEQnPSsAhRPLbiqQjTkUkzCWI7VKZc9uLOGIyEafMSiTHOx1JgSzB6wGeh0iZYYQsU/z+QA/HcU5u5mrolNT0BnOMoUBJTU3VysxA0qQ40qLauX1Dfa/8gYuCyak5ny1fdFuf/sN6Z2blnhkIJA0D5Zi6lQqoa2iou+SReb/bjkjBRzy6m40SIBzWInq0E5IGD6L+87WEd+8mUlpK1aL3yThxxkHvr0sQJXAZXtvLaAH8Z0WFsxcVzJ3/UuwGhhBaIrbmPs0htkhsOM4yG1ZSjeftTY75rR9wHnDU0/MeSJlx5lkVGdnZmfEeZp/fr9IyMv6N2P1SEcIcZf5WAP1379i6at+enaNye+T3i5bEtNaRSCS8+9XnHl+qXTe89KN3fzht+qz7tUi0LuC3x6ytqd7yzivPPb2paM02xNnSG69q0Qak9aiLkKXC68A4GbGvvoEEfO9D1OxTzTk+g8RdjkXU9x545dP2mGU7zH4DDQ11yXV1NV8JBlOGxZKfUo6zdvXiAGIvze7dZ3B1SkraOEBFS4laa11XV1PRK39gaOJRJ/3dTgwmAspVSjmm9JrT0FD/+to1i6/75IMFR6TTpjl0R6JsL8+3hVKK1GlTqfjvC6A1VQvfJWXC+IOuit5ViNI6L5oQmdY6Uh9xv6mUslJNa4Sn8UjN/h+P8GKrZrd4l8xLHcTLrKnTWrsmINqq4ccgAdaDEamtLBIOb/3HL2/ZeMOvfnNNanp6E9eb67puOBTaff8f/1CChOA0Fq/AVPrGSGfPPHTv3Ku+88OrkoLBgVrriFLK50YiZUs+WHh9qKF+BVDx0pMPB2praqZOPmb6FcFgysi6utqdu3ds/e+OLRtLFr76fKbruj7EnpqPEF42IqmORbJm1iEEaavzrECyfL6ExE1+jEica8y9OB2pIP4wImH2BeYhhN8Tr3VqGLEJFgO169Z8Om/cxBNuNd55BUJ+5WX7Nqxft2wXkukTOeaEs8/1B5ICMWo0kUg4snvnpnWDhow5Oo7d1om6XwQCSTPT07OVIc8jNmUxFt1R9W5vogTw5+YQHDWS+tVrIBym4pUF5F76lYPbVzuP7WCRTxzyU0r56iLhIUhsXyVeLcOw+T8Uvaw1wjsYmHJpKYDz18efGp2Zk/Nb4PgHXnszcs+Lr6y49/e/e/Sjt94YjkhTFXjdDCuA9WtXrGj4zvlf3nbDr35zxpgpU05JSkpKAdi8du3eZ/4975aaqkqNkFYDIum5CPF+jpBzzbbN65f+ec73H7roqutnpmdmjaosL9v15otPPb5j66YtWmtbeyUErFNK/dKMtxdeD5lqJE4xC48k+5hleeb/qQhhr0EIsxJJEVyNeLcnmP0sRKTECBIydLVZNgm4Aimm8QEiVeYhBJphPkmffvz6inC44WdDho3/RmZWbr9IOFyzZfOaNR+8+8JuJGC9Mjev9+TsnJ77OaekvFzAP2jI6KPikGTce9e335CTzT1prnXrEYfuKFG2V4hQLFImTaRh02Z0bS31az6nbt06kocPP+D9dBWiXIRkbzQZj6u1u2JfSTESArIFjyzrzd8mUoJSytY4tB835nvkQMhUSd/qIBC558VXxgSSkhbaMSql8AcC067/yU+nKcUzH775xkqEHIoRz3EZ4hgZA1T89ec/eSWYnPzapOOOD2/dsH7gjs2bpyEOkd7mU2nGuAoht15IXciPgbzamqq0h+7609tIIy2FSH2OkWqt9KyNpBtGPM0VyCRkPdG1iFS423yyESIrRYi+D1JsYjQiUa4x43oEiYGcjkxa84A/mN+/iUjRHyP2ywsR++devNTEzchklgLkLF+yMLx8ycLHENW9GCHpr5h1RiWnpLVY81qptotQjuOzbXG7DRISZdvhJCWRevRRVC98D4CKl14hOGTIATt2usoV/hMQilGPIgqqX9y09Q6EnMYiRn6bGpiKkJjGs+nV4HlcbaWeHIQE8oG+Snqu5CuleiilcpRSmUqpNKVUslIqSSnlU0o5Sqk0s496rXW1PxD4nda6ydVVptL0VTfedIpSajvSnfBz5MU8GpGy9iAB15X1dXXbPnzzjVd2bN68EKjo0bv3V2ae8+UpI8ZPsO1iLXnlI5Lcp3iOnE1ICFEpXtXw6ApFfiBgiDMFr91CA0Jcu6O2DSFEtgkJ9Vlkxr4Ukb6ykYIYsxHyCwMPAfeZa/kz4EpzXv8x62cgKY4NiM212Bwn19y7qQgB275AFYh5YSbi8Q+Y9VytdVlz89mBKg2Oz1+EaONdRSg4ZHS3FEY4fEQJkDRkCP78XoC0vK3+8KMD3keXeHgK5s5fU1Q4e2ZpfcPc3OTgaLP4baXUjY+v27DCvPwFiKNjNCKtbUaknWTkJQXPvlYD1Bp7nsKr6GNzse3/tr5htFfbZqWEEPJKTwoGj7/7hZdPbO6BTE1LyzztwouqFjz5hK2qMwAhuM+ADxGJLhmR0pKDyckDvvXzWwaPP3rqOMcnMRG7t2/b+I9fznli6/r1OxFJbSti+9sDbDZN621wO1rraKkrYn6z5+E347fFe63NtlZrXWPMCUFksmkw51mCEGcvJJxnsDmHLwPHISFA7wL/CxQi9SsHmmXvITbLZHNvMhEJM4DXXbHSXAebfVOLEOVRiMrf14xRH3P8WUPjXeeDCErWjuMcc9HsGxqSk1NnFF43pxR4du49c0oPZCddDd2tzBpA6DCp3mAdO9OaOHZSJ0/CSU1t8z66BFECFMyd/5FS6h+9UlLGzz3tpB+f9exLZfY3UxxhtVJqDfJCjUZqI9YhUtZ6vBxrK0WilLLEWQvUaK2btVMZ8khHXuYK5GW/ADghFAqlu67r+ny+ZiXwvTt3HoeQWwZCDsu+ct31VcecPOuKfbt2ZTw99/5ta5YtdYGUH/7hjrOGjBo1Ltrz27NP38E3/eZ3V/3vVy+7JhwK7USkQBByi87u99G0PFkjohxMYXPe2eYaWfJEKWX799iQJB9eF8gKhOi2m+s6CJmghiHe6OmI5PksIu1eiHjA30JIeSZiv8wwf7cikquDkCjmuO8h4URfQSTObEyoUk5ur7Ss7B5xi+weqORkpM/L0jOy79ACpZSqK7xuzpVz75nzxAHtrAuhO6reDYdRogTj2CkYRv26InR9PVXvLTqgPPAuQ5QGg/bU1m6MJsloGPvidmC7UioLkTBtPcRNwGqt9YYo9TOV/YmzFiN1WqnMrJ+MEFAvxJs7yRz2M7TevqWoaPDgESMmxXtZqyrK3WUffnAGot5uc3y+D2/5512XDhxWMEtrrXN69FD/+4c/6fcWvPLyM/PmPjt4xIgzYsNjHMdR2Xl5+Tfd/rvM3//gptfxajfWxhzOxm82B0uUNjqgWmsdMseLjgm1917jqfIOQpS2G2I0YY5FSPMcpNTaR4i99ETgTIT8tPktiIR8PWn+34OYJHoj0moV4vg5EzEzlCAS55rsnF5JwDeaO7mDkCqPBs8TbsbzSOF1cz6Ze8+cTQeyo66CbunMOcxECVK3sn79BnBdaj5ZTPqM6W3u3thliFJJ8dhcRGJpFVrrcuBDpdQSROIZBZytlNqHqK6btNYVZt/+X95z3wnZeXkXRcLh5A1rVr/7z1/d+qFSqgGvudc4RJ0ciqiKi5H4whHAlHt/f/uCW+/61zB/IJARE9fH03Mf+MSNRDQSQ9nvjIsvmTRg6LAR5tjK/p1x5lln7d21M+L4fIFmzkkPGDrMqqDJQFW0ih2VHdSSsyOAkF6S2U90czPr9KEF4gzj9eAuMdfAhgUNRiaQUQjJnYgEpe9EQqM2IHbOSQgh9kWk/eGIB9xOYMMQ55Ct9l6FxGPu3r61aEQo1OAGAklxA+cbGuprgsHkNrV1cN1wg88XiPWe2/MuBOa0ZT9dDdY2Hv39SMfhVL0tnLQ0kSrXrkM3NFC7fAVp06a2adsuQ5SIvSuAhKa0GUYttWp5P0Qtnw5MUUqtzcrNW/vAa2/ejtRbDAMcdcL0b/zfcy88t/zjj17JzMq6uqa6uvfS9xdVvfvKy2vCodBKRDodgEgjO4GXd2zevHztyhW/HjFu/AM+v//LWusAQEVp6abtmzbtRV7+ImDv8aeefn48yScSiejBI0ZOjYTD2uf37/d0K6VUOBTagEh0NmMnGtYYFZcojcPCplNmAA0tVERviTjtWxhGCLMakQq3Itk4QxHb4kRE3a5FpOkJSPjRDmB4MJhy4dnnff2TYDBlcm1ddf3yT99Zu3H9ysnIPXLw2tjWIOR7akNDXcpnyxdtmzRl5kAdVSIOYOvmz1cvWvh86dnnfX1CZmautUvHOzdCofqqQCDYnBHKRTz8RyS6pUTZAUQJSFzl2nUA1K787IgkygGICrjnYDY2L/42YJtRy0cDY0+/6OIrEZKEqPP1BwLnTjlh+rmRSEQrYOIxx6ovX/HVwM+/8fWimqqqE5GXfw3iNOoJzHrlicfzR4yfcKbW2mdn9IysrMH/85vfDvjld771wY7Nm4YCYzOysvzx7EaO46iR4yesVkq9oLUuVFHphlrriNZ6y99u+fnrCFGWxQmS9tl1m7kMNpXSrttqDnjU8VsiTpvmaFMUtyGEOQAJtD8WmShAHEBVGZm5tWd+qfDslNT0LwORpGCKOvGUi5yU1PSyVSs+2IlXOCOMSPO2te6iZZ++vWD4yMlXpaVnnW5JUilFZlbeMIV6/+lH/3776HHTnF75A/vl9egzMSMz5/goUnUBtXrlh0+PGDXlxOSUtAFq/7ROPyIJH5HojjbK+g4iSn9ODk5WFm55OaFt29h5668y+tzy88rWtutKV3gYYherPtQdaa3LtdYfAE/MOPOssfGyMuws7PP5lPU85+T1GH5B4TWnIg6IDYhqOBVRK8844fQzvuM4Tkp0yS/H58MfCPhOv/CicZgQnfWrV7mRSFyji5uWkfGG4/N9t7amekHMmIvWLl9+4YY1q5Pwcq9j0awjxyBgtm2idh8MjPPD1VqHjTPNBvZbe+ZOhGzmAb80fzci5Dpw2vFnDk1OSfMZ6cdnyeroY07P7tV7YB5eGbYMRNV/G3gc+HjAoJEFaelZp0NT6SkzKy94wszzckHXrl754eq3X3/8iace+9t9y5e880plRUlJOBwqr64qX7Fj2/rLli5+6zfri5Y/FUuSZkLaiWQUHZHojuFBDeGOS5wKmFAhZBIe15ZtuoREaTzOA/AqaLcLtNYND7z2pp+2TghKMWHaMSMfFsnGPn1hRLqsHzh0WL94lW98Ph9jpxztAj8GPlz16eJLJx173G3WzQqmbYPrVvv8/nsKZ82sUUpde8X/++7IURMnD6urrdl2x80/WlRbXW3jP0uaUZl9NOPIMdfQwSuq0azafTBoRuK0RUEqEJJcABwTSAqe1a//sJHN1caceeolPR976I7doMuQ8KK3EMk9AGSPGjP1NOPBb7IDx3Ho22/oSJSq8Pn89TNmnj8qKSn56JLiXXtefO7+X9bX1ZQiz9B6YM/iD19dmJmZWzVw8KivYeJRw6GGD+vqaq55cv5fW5Uiuiq6o0TZ0IG1nJy0JibuXm3ZpksQJeINTUPiDmO9vAcFk1WT/6t/3b+23+DBp9AGslRKkZySopEYwE2IVLkPoyampKUN0FrnxpFSXETCeltrvR34zXU3/7R45IQJv8nrlZ8LUFVRseze393+9oqPP0r/mpgX6h7++992IF5lG8ITRPLI95Mm2+DIsRk6mgNUuw8GcYgzhFyzrWPGHbtIKefKeNsppUhJSVcDB4/atmXT6reQ61uAZF85gNLoXs15t5VykoYVTNw07fgz70tKCg7WWrt9+g11Ro879pz3Fz5/V9HapSAOKB/w+ZuvPpqeld1zwohRk8esWfXJJZUVJc8B25j/1/a9IB2I7hhH2RBx2614b6toKj+0SZTtKkQ5ECGKLYcqBRnveT6mIMN7C17+58XXXneJ4zi5RuqCOAU4QFou7Ny6dRlCMiOR0KMQYpPbuvHzNc9OOu744+Mc0/l00bsfABcqpT5A0i3/FUxOeTIjO+uf9XV1vSvLyh5ApOXzgAfwmo4FEcnMjxBPc5JOi44c2lHtPhjEEOfmq79xy+dKqWarj/fqPaB4y6bVdkLYhZy3eMA1pY7jHBvnGG5NTeX6yVNP/kMgkDQQvEIYjuNkHTv9nOs3bvjsj5FwaCdeVaSa8rK9Yz7+YMFSxNOeAWQppepasPV2aXRHZ46rIRyBQAcwUqSsLPrrlrZs01Vk9gHIi3JQ6pBJOeyplBqHhPNY7/nylx9/bPeT9917WTgUehovP/wVJNul8UUxtqvKj9564zeIvewxJG3vOUSdG33nL37Wc9mHH3wCQqp2+8rysoeevO/enyGe3x5IXOf0+rra7H27dj1QWVb2CRJ/OBIhk4vw+n6nICSZjMkmauY0fTLM/X+Pyj4KIcTbrmr3wUAp9eOWfteu+xbwXyTwfCMijZYB6u03nlhRX1+7Otq2bIl4x9aix9PSMo+K46Dx+Xz+vLHjjx2MeNB9yPVdi4QqOcgEmIyXBntEwqre0Z/ugI5w6OhwmNB26VCsgkEQLbZVdBWJcgBi56o6kI1MOl8+Qk4+JJd5k9a6yvyeCeS99Nj85S89Nv8rIydOdOprapM2rVsbuPBrX+8967zzv5+cmnq+UipQW1396pvPP/t/bzz37ELkJcrHy2zZADyjtfb/5ac3P3DGxZecOOaoKWfV19ZmLXrt1S1L319UgsTl1SNS42tmH/0R7/taJC7zZDOu0m//Ys4fJkw75lSfz9e3oaFh5bYNG+78zY3fbSlbxKYixoN96V06QO1uC+beM+eZwuvmPINk9DRCax12Xbdo6eK33kC8+1WIuaUc2DnxqJPc4SMnjw2F6m9wHOcCvz/pMiC9rq76s3Vrljzk9wc2t3Tc/N6DSmBhP+Tab0JClUYhRvu9yESSAiQppeo7e0I5GHRHiRKsQ+fwkn7dms/RIVG2kkePIvu8c1tK3mhEpxOlUspmzuykjY4cpVQGHpFFEJvf3mjbnlIqGYmVs2XZ8j5ftszehdBTD9y346kH7vsu8M0op0tvoIfWejewWSlVgrxwfRCVbTew+uXHH1sF3GWkmoFIXOFgM6YpSMFbm4aYac5vI9Lydda1P7r5gqNnnDjMHjfZ5zu2YOzY4x947c1LEc9vPDTryMELs+kUtbsFXAbcA3wVzzn2SXV1+WWRSNgW+u2PBKPnTTvuzGkjx0y91XEc64ksBX4095459yil8oAR0447c4/Wus7c3/3g+PwvAscjsbSrEBPMOoQoq/D6iGfitcE4otAdnTkA9aHDO2dFKiqpXba88XvacftZd5pFpxMl8qIkIbN9sxKlIaVchIxSkId8E+Ihtg4FP172xxCzaWPONBLaErdupSGtfUAfQ962TFsRcp3yEVLMV0rtxsQ5KqW2IV7yT816/ZGXMrqEWgZCCpEho0bp42adOsyM12bt+MyY/jz39beeKpw1s4l63ZIjx/wWQKTIVLqA2m0x9545dcBVhdfN+QmSArntwXt/uRoT76m13qGUKgb69u0/bMTIMUfPU0pFB4nnAHcXXjdn30mzLn4mJzf/q5lZuV9TSiXHGv61FEB5+ZX/zv0UUa9PQe5FMWJjHoGQZi6m2AlehaMjCt1Voqw/jCFCOhSi6q23ISyyRurRUwj0apPDG+gaRDkQr1LPfhKlUa97mo8fsWNt0VpXGmJMVpKrbePyNEJOtYihtiZeHGU8mJzoGkSC3I7YDG2w9SalVIrZtyXMXYjKGMELzN6EvIwlSAuF9QhJ7gOGnHTWOWfG9+YqhWQWjUBKrEWjJUdOtIOqS6jdsZh7z5xtCFkx9545KKmX6VdKaS2FSjZeXnjzZUo5aSrm4phYzp8PGDRyvOP4vm1/thk75m8oEgn/2+8PfA8xf6xDModmIIWEkxDzyQxkEtWYKlFKqYYjzanTXimMSqlvI9Wg+iC2uhu11gtbWD8I/ALREHoj9/TXWuv7D2oAMahvkxJ84NCRCJVvvk2kVIpG+fLyyDh11gHto9OIsqhw9hDg4ntnnXjCgi3btjxZtLEh7LqNs7uR6nohUoWLEE2x+TmglOqJR4yWaEOIGleH2Kbq20qS5gW1RSjSgTStdRPS0VrXAhuN1JOPFIuoQ0ixAVF/IwjJDjV/XbPPZcDWqSfNDCAPWnOIFx7VrCPHjNlWMu9KanezMNKfg5BlSGutk5KCw835xdb8dIBRSvl+EEsI9vu2Leu+88aCRxZorasNEVchRThs2NEmZNKsQPLO7TXLQK73EUWU7REepJS6FPgL8G2koMn1wEtKqTFa6+Y8wY8hz/3XEU2rF+3IIQ2h9pcodShE5VtvE94piqVKTibn0ktwgi12d94PnUKURYWzbwT+pLVmRr/enNS/j3PDpHETXj7/rLfOevZla39MQ176fYg33JZBs9VuqhE1s3EeUkrlILanXWadNr0A5mW0dSnrEXU9XymVGkuWAGaZJczeiCToILZSq+r17z906FFf+cb1x2it+6RnZtX96v99a/cDf/rD0m/+7Odhx/H5Y178CLCscNbMTXGG2Jojpx7TQ7urqN1tQBgZu62duSVWmjTQSqmdeKaUWLg5efm9kZAfZc6/Hi8CYQxClGG8rpH5SIB7GkLWR9J1ay/V+ybgPq31veb7jUqpM4BvATfHOeaZSIbaUK11iVm86WAO3Bzau4KQW1tL5RtvEdm3DwCVlETu5bMJ9Ox5wPvqcCtwUeHsKcCfkTYGjmPCPHqmJJ9YH3H/iDzYKYiUthNRJSMIMRZrrfeaFMWaGJJMQ9TzEkRKaLVpmNnOb44HomqHjTpYBewXXB4NM4YNiKpXizh0RgHBm//81/5z/nn3s+OnTrt1/NRp1w8dNeqdPz/6+L0rPv7oGy888p+XMRKidl0bsF6FNFmLh7iOHBMXqsz18RE/7bFLwtybMPIc+IH7jZode88U8Head2Q5fp9/PUK4NuWiHjHR7EGuy0SzbDPyHE1ETCY2jrUrmKDajBbCgzKUVOy3n7hikzFnTUEyqaKxAHGExcO5SA+lHyqltiul1iql/mjMUa1CKRWMHhtese1GtCdRRsrKqHjxZY8kg0Fyr7icpAEDDmp/neEuKyT+Q68KsjPPR2ap9QhJxhJjc1VzkhA7i22i1ZyaGr2NUl5PnJDW2tojLUoRKS6vtRPSWlcjZLkZCEw45pjpw8eOu8fx+ZLssQCycnJnXP+Tn417eu4DlyulJpTu2/fwhs8/X7d66ZIngdGFs2buV6ihJUcOnrp9xKjd0TDXOwz45v3r1q3Fe3dc67pudMUkjUyqf0FysyMx20eA3ckpaU8i555tltsCHiDS/UCERBsQW+VoPDNJOkcYUVqJMvpjYBvb2c9+kqGBDafbHbPcOiDjYSgSSTAOKWh9I3Ax8I82DvvmmLFti10h3E5xlA1bt1Hx4su4VeIbdjIyyCu8iqSBB0eS0DkPiO393ARKKZIcJ0Nrvd8FbAlG4uuLPPi78PKdW9vGhpfUR0umFsYLXkwLKri1s5mPg2mkdfWNN52DUv5YVVI5DhOPPW7SoOEjar926smfAb9Hqnzv1FKoIR5acuTYAhpJHFlqdyOi7JV5Lzx779pgMPVng4aMvnDk6ClP5Pbo8+Tce+ZsBSi8bs73tNYDlFKnWCeO60bK0Zzz7/tvq5/3r1vLEaK0z08dMnHWIqQ5BckpX4PYLUfhhW856ghqadtCeFB/miZttNZ5Mp703twz5JjfrtBSCxal1E3AE0qp7xj7fUu4Hbgj6nsGMWR5qH1ztNbULV9B7dJljcv8vfPJvWw2vszMQ9p3ZxDlB8ClsQvNC/PeQeyvD0ImWzCe55YII8pD7iJ51Rpg7utvBZD+MKMRqeNpE69nVXDbyzuWHMGrqhMBMpKCyT3xPOFN4DhOZp+BA9M3r1tribcUyGzhRbWOnNiOk7ZupFW7u5y3+wAQQEguq76+Rq1ds3jD2jWL79JaN0qXc++ZU9G77+DTZ8665Jhgcur4nTs2qjcXzK8OhRo2/Pv+20A0iR5KqRTz0lr1uydSTPgUxJa8y/w2BtFccvCasR0RLW1bsFFWalOsuhXsQ56bWOmxF/tLmRY7ge2WJA1WI+TaH9GomoUxZzVe33h21dAhuNR0KETVu4sIbfH8UMljRpN13rk4SUkHv2ODziDKucD/aq3zjW0qOk/41weyI+P5TkNmJhvWH1cqMNJdEJPqFx2cPvf1t4YgoTyD8fKud899/a3TEAdACtBLKWXtWvYuW0JOxqsUHiwvKVmdnpm5X4qc1lq7rrvhg9dfsx52jcSPDsHLUolFc6XV/FG/H3Fqt4WZuDIQyU4h12E3MfZWa4J49KE/fqS1XmS2+zIwQin1CV6732y8mNlihBxt2NZEpJJ6CUKQg8y6aUBNlDOoS+NQA8611g1KqcVIp82no346DemHFA/vAZcopdK1yXxDQtlc4qjRB4Owe3CXPlJZSdWbbxEpLWtcln7yTNJnTG+3GNMOt1EWzJ1fDpwQct2XXPNQVoXCRUqpMwrmzv+grfsxBuEcxGBfi5Gu4j3oxumRYtaJV53nEby2sJa8e2itn+k9YEAa3uybh5BiIOqjkJeyCuNAeHreA4+7rrsx1k6qlFIVpaW/M9tZoixGyC6nmVNtjiiji2AckWq3Ib9s5FySEek6GwntiqcWNqqGxg65Ablv6eb8K5Cgcjv5liMTXw9EqrRJCyHkfo0xf1PMvo+IMjztlOt9B3CtUuoapdRopdSfEVvuXQBKqduVUg9Grf8f5Fl9QCk1Ril1ItLb/f42qN0tn4/hsvBBqN6h3XuoeOGlRpJUwSA5l88m48QZ7RqI3ylG7IK58zcrpb6dHvDvzQ4GF2+rqv5Ya/1xW7dXkr6WD5RrrcuMZLqfemrWtaQUQeyRTe7G3NffGoVU6Y7dzgcM/dpNPzj19v+54T1EYklDpJEwkuETtyDw4oXv1C1d9N6XJhxz7F98fv+pSilVVV4e8iclfe+m2Zc8YvZjnQtVyMufg7RaiN5XXEeOWW574yRz5KrdWcj5ZeL1G7cSZSwsSUZf8/WIk2GIUuozZKIaopRKMpOhrZXZU2u92qwzES+5IQVRN0Pm/wit2Le7AtojhVFr/aiStNBfIOarlcDZWmubS98HIU67fpVS6jTgb4j3uxiJq/zZQZ5GI3yOwnUPnCjrN26k+t1F4Moj4cvLI3f2V/D36HGoQ9oPnenty6kKhUNVoXAtB1Cs15BiX4Qk9iivl3U4Zr1oVbvBSCDx0GIe06DhI5IQm84+c9wUrXVxC5u4QP3f5vxiJ3D52Zde1rto1WffLFr12Sw3ElmNR3ppyHnXm7Fnx9lXc46cJmp3HAm5y8PEoCYjJJWD53ENIqqcja+Mtsfq6IlOS3bWTkS93oSQokYIeC9ybUuBoSZ87HOkkn66Oc4ORH1cgtyP2iPBqaPaKTNHa/1P4J/N/FYYZ9kaRD1vV/gcCLlwIBmMdatWU/PxJ43fk4YOJeeSi9rcVfFA0ZnZ9HYmV7SxapAhv77m6w7z10eMAyeOqt2S/W4lzccf6mBy8sfaAJEm01QzBRmgUeULIS+s8+Kjj5StXbH8FTcSCSOdC+3v6XhSVC3NE2U8Sdn2xgm0MPYuCyPlZyITRT6eTTELmTS24cVXgidNxhM5NiAaQz5CrpV4YUIuXixlD2MKWWK+90eqOqUi6riNwezyoUIthAcdkfAZ3TvSRhtl7fIVTUgy5ajJ5F5x2WEjSegkorThIMiDb0uTtQVW4thuHnoHmjbbMjGVyZjUwdbiKQtnzSwB/krMS6hdl9J9e18snDVzY+MyscXUAHmxoT8x0AiR+ZGXeBfywk7ECx5PxiPKOiRYeL8aizRvnwxzhAWZQ+O9z8ZzPuUgxJhultswrzDgi7omiviOur2Iyt0XIb0KIF15RZqtxtIDwISfbULCgyoRSXYg8iylcgQQZXerR+kzww9HNLoVU3vtipXULlna+D39xBlkfekc1GG+Bp11hdPxbEJtUr2VUrmId3SX1ro+1n5nAshTMFKW1rpOt3bVPdwM3IK8cEQikfp3F7yy4UdXXVmqlOobs24p8tI253wBeaEbzPh8yGSwGi+lzr7EVrqsRSaA2ClxP6JUXjbOkap2ZyHjL0MIqgavFUYWpqKPmeBcvGInxLufRmrchKlcbvZn9wWe+t0rinQXIdd7DBLWkobcmzTkUerSZNntJEozfg1EWlC/69auo/ZTLycj49RZZJw8s0POv7OIMhMhBQ1UR8fLxYOxL/VASqrZgNpGtVR5aYgKkSIPKFSmcNbMSOGsmb9CzAF9bv3W9RPu/+Pv7ws11CcjKVuN3YjMC1yCSC1xZX3zQtsX3Y+8rMvM/yfgtX2waXzVZlljVGxzjhw8b7mfI0+aTEMIqhwhpWwk/jUTuVa2LqklRGt39tNyb5MdyGTTC7k+dXje7zBewd5cs/4mxOZ8FEKse5Hi0bbEW5cmyu4mUfp9HtE1F3Qe2r6Dmg8+bPyeMesU0k9oLtuy/dFZV9jmebq0Ik0qLz2xSmu9zyxrzHFWXhpiBK8s2kGhcNbMUOGsmbu2bli/DvGofozYvr4XpcrZohi1SCB6c9OZTc+zmUKbEMlmGkLqDXhqeLREZdGcI8faJ48otTsqXrLaBB8PQu59CaJh2MpP0aFByiy3HSbjwuxvO56tsRZTJMOsUopcM6t+VyIEnYo4d9bhVaRPRVT+LiumdTeJMhBFlA1x0hgjlZVUvbOwsSlY2rHHkj79hA4bH3SuRAlesYu4MOTUD89uFS1paUQq9SNhP+1W1t/sZ5kZ2zvABPYvjVZixtGSCh7GI0z7cvZG7GO1Zuw257gxV9lgP0dOlPdXcQSp3dF2SeOpzkaegS0IsfnMJ5Wm99k6cWzxjJae1x3IdcxCJPgkvAnZZunkR62/B7mHA/Cq5Pc329j8+S6J7iZRRleJiyVK7bpUvb0Q3SCPenDkCDJOP7Ujhwd0AlGah92qsppmPN7mRemDjHF7FGFY6cJWRqnVcXK12wHrEElkNyJZnqqUarxDRgUvRVTwlorbRfBe+JXIC3wUnhQJnlSZHbVdPEdOIOq3I4IkDaLtkiC2yUot5boykEmiJ3Id9iDXyl4bK5G7SEm0uOKT1roMuR+5eBla2ea3BkTVzlJetZtiPAIdhXjAk5G4TJum2iVh61FGf45kJLUgUdYuX0GkWKLxfLm5ZJ9/XqdI0J0xFaUjL4GVppqTKHsgEsZOa3NUXt1IPxLwfUiqdkswRLgKeYFfR3rezFZKjY1apxohuHhecPs9uqDvRrP+OPPdEqHGFAyOUvGbI0qrdh8pecmNdkkt+fw5CDnapNxMxFPdG7lOe/GI0qWpVAktE9gOc6wgYnuMjjzebba1y/aZ/xcjhJqMqO/DkedORZtbuhK6m+odTZR1UcV7w6Wl1C1fIV8ch+yLLjisIUAtoTOIMgt58FMRcthPolRKZWHSE409MFoSVRhVuwPGuhoh8t5I068a4JoYT3gxch2z42xvbWy2Te4+RLXsi6h51k6J2bftDrifI8css4U49IE6rDoDceySINJkhcmosq16GxDS2osQon1zrLfbxslG16+Mh90Y2zEm20ZJpXyQ61uFl2BQjBBqNZIRNRKp2p2Kl8PcJdXv7qZ6B/weUdoGY1prcd4Ya1r69BNI6hsbgNJx6CyJsgohlnpi0u/My9MLk55olgXw1PWaw6Rq7wfzchchxFaF5IRnIDmy6WadCKK+ZcSo4JbsrI0yhFc8Noioe9ZRETH795n9x3PkRAdfd3m1O8ou2WAjFUzKXDpNpckwMnHm4nm8rRRpbdFA0/qV8eyV5l7sQp4VS8yWGG2YUL7Zdp9ZnocEofuRa78Tkfh9dFGnTneTKINRRFlrJMqGzZsJ79kLiMqdPmN6p4zNojOI0rYJTUc6GUZXKY9NT1SGfGyudnUnpJetQghtIJIF8iLisS00BA4ildTR1AtunRERhNjqkJdxq1k2Go8IFPIia+T6xMvIscV5jxS129olo8tyDUTuuV2WiTi5UhBS3Y1X9MKq3U3ud1R8ZXP2yu1mHxnIdc9VSvmNRLoLUbGzaVqYuQqpUzkEsVXmIrZK6IK2SmVSGO3nSCfKJL9HQ7UNLtp1qV3sxUtmnnk6yt+5t6FDiTJKfY4g5Fca9ZvCK4m1A3lJUjBl0RDJpMNzcLXU99uOOJaSgXeB9xFP+EVKNZbmKjFjjQ7xsZJRCM+zbdvy9kQI15aHs3ZMS5Tx7JPW292l1e5Yu6RZZm3OW8x3OwFWItcsBXHkKKRPjn0240UyNGuvNNlTJXgpkml43u9i5Hr3MM9SqflfIxNiHUKS+4CpeCX3uhS6m+qdFHWFaxs09UXrG6uTJw0ZQrCgoJNG5qGjr7B15Fii3Bf1W2+zbIcZl20rWoeXEthZ+Awhqp4IiS1AJI/pSEFYG9hchqeCR6veVqoMI6aG3cgLPBFPOrQV0vcjSiNp2/11abXbxL02sUuaSXAgUBqVMGCDzKvxKtRbR06j+t1MNk5r9sodyLNUj1zLbCP91yMkao1dxXitPsJISFgPJOa1D2JHdrqaU6e7qd5JPtVYaq2uIew5cICMU07uEufX0URpHTkQRZTKS0/cibwgtsVBHXGKXnQC9ppPP0SqLAZeRV66M5VS48161Rh1D88h4eLZKesRCcXG/I3F8+yCSJo23zh6YrDSpFXRuyTi2SUNeiIT35aoZRnI+SYj1yuMkfjMvW62CDO0aq8sQZ4da6vMwatqvwchzmQ8zzfIc7kNmcTSkXt5NF52VZdBdwsPAs/znbVvG261BMIEhw0jqX+/zhxWIzpDoqzCI5K9xinSA89mFF1cd7+iF50B8+KuRl7uNITw1yBhQxGk8nP/GBXcVuy2EpJVvZMRW2cdEgBtpakk5Npk4tlkLY4UtduaHcrsAiNNDkDST6vMsgBCnBXmbx5CYC7gtqJ2NyLKXhmItlea+7ADIe0y5HmLLlBiw4SKkTYcAUO8GinwG0RItMDso9n4zc5Ad5MoAZICCrRmQMmGxmVpMzo2+6YldOhMOaVXj36/OX7q2VnBpDP21tRl90hJvvTiF159dXt1ja3K42KK66qmPWG6ArYi9rS+iLSRhKhq2cAM4DKl1N1a6wolLSPy8bzZlizrEcLbjhBlEuLU2Y68nCXmb7K1xxq1z2bjdGVp0tZ4LImxJfdCJoc1Ucts9ksVYnLJxGTk0IraHQex/cEtduK19rA9eYrxwoTyo46ZZ/7XiPOpCK9T49FIm5DY/Xca2qNwb1dDkl+RV1dCVkMFAIF+fUkaOLCVrToOHXaFP7z0/J4PnHbSvCGZGTfkBoNjRuRk9clLDt7533PPvPuY3r3K2L/ij40X7BJFVM041iAvmEJevAokYHkJ8sJfZmx0VXgpiVaVtKqiQqSdMrPrUWa5jekDrzgDyEtu71OXJEpzzulIPn5D1HIHkSb3meB8C+tocRESzUFMG1aqaxIW1BKas1cam/Ees+8y5L65iLS/D7lf0SFCRB1zBV5R5ZFmvF1G/e6WEqXPYVDF5sbvacdM61Ln1WFEmeL3/yzZ5+utlHKUUjgS+kN6UuDEB0496exolVJFFb3oqPG1EesRG2RfvCIWuxB1bQ2iql1ofitFJEYb8Gwr/oSQl3A3IlX2Qgg1CXHmKLyYUcw2XVbtjrFLxiYP5CMTwJao9W1OdwVyXhkIWe6J2bbNE2QL9korqVfjpTb6zLFS8Bq6RdspbZzqSrwCy2NpPde8w9DdvN4AqbqePtUi4OuUVJLHjOnkETVFh13hJJ9zYXNBwgGfc579Hp2V0skOnP1gpJR1iAe3Hi/sZCPiGd+MhA3NwiuEkWEkLpvpYeMp1+NVKR9k9mNLsqVDk2ycrhxknm3+lkUvNPe6P7BXN20+lYGcj42fzMMrStEoTR7ovY9nrzTEXYHnHOxjjlVh/uYT5fmO0l4Uon5vMf+PQSbFLpGp0x0lyrzS7ThGoK8rGIvqYg6qDiNKreN3uDMPdfSdbq79QVfB5+ZvH0wNRZNmuQoJGSpGwoYmImRgva62Ik058uJuMvupR9RT276iFggaNTKA1462y6ndxi6ZhASRx96v3sj4t8Qsz8TLrkpBrk0YUYOjs3IOGEbitpK7xXZEQreSozLHq0Du4T481ZuoY2ukGEqF+X0MXSRTpztKlFn7vMekfMjYFtbsHHTYFd5WVf12M95rB3gOGqWQrqhyN8JIR5sQNbsSSDVxkxWIVLkOkRrPRMKJihEyScPzbPsRAqnEyw7JwSPKZLOutU92ObW7Obuk+c32pNmjo4oym/ubjpw3yHnaquYRmhbDOFjE2iv34uXUB/GqFRUj6ngFTYuaRFcu2o1EOyQj9zuLLtDSttsRZXUVwaoyAPam9KAipaXKhZ2DDrnCSinnlx99+kRE611W8jCqlQbeRNpeQteImWwLViMvXR/kJcwx57UXkTjXIOdyNl4YjA0tsl5wFy/dzm/2lYTnUbf9w6GLqd2t2CVBzsWma0bDJhxUGGKy6YQ2ftaqzAd9/2PtlWZfO/GKJecgz71NZ7QOnmy7CzypViGZWCUI8Y+lC6jf3S2F0dm5rfH/DVlDqanvespkR01F6e/u2FX27IbNJ7y9feeC8vqG9cAHwA3AWQVz54ds9kNnx0y2BSZXeRviES1DVOU0I1ltN78VIS/iJcgLGkFexirzfxAh1QAiRfY1y6z6mE3XVbuzzd+y2B+UV2x5d5wKTxlI+JeV8AJ4rWqjA/QPCXHslTvwYliTEfW/BK+3N8S3U4JIv0uRyWsUEnfZqSJcd5MonT07G//flDWImoauR5QdFfKQBbg/fu+jBqRi+He11kX2x2gHTgeNpz2wGjgd8VrXINkeNVoaxa9HpKpNiF3sPOBtPHU6ZP5uQ6SfWoRcbPqcxivWEO5KaneUXTI2XtKiL3Ivt8ZsZz3cJWZRMkJSQTyitFrGIUNrHTLmAb/WukEptQ8pemEzv6z3uzdeGwr7TMbWw/wEsVH2RyoLLaQTpfxYB86RLlGqEonSKk/KpDyYTV4XJMqOmooykZd+BGK/izXwd3UHTjzsQ1TtMUgoUHRzsArEE16GEN8IJCi9GiEGm4G0A3Hu2MybQZgCIIjU5tCFpMmW7JLmdz9C+Lvi/J6K3OeKqO/ZyLVoJMp2fgZCePbK7XhFRxxk8t6CmEPqaFrkVwMqygRQisRWamAyUU3gOgPdTaJU5jJvz5B0xS+y6m3zeocjITTRBR+6vAMnHqIC0HMRaaQSUct8yMtfjjh29iGS49EIiYTwSMPWp7R9uvsi0k4Dnj2vS9gno+yS9c3YJUHOz2YexSIT6ZlTZ6TLFISkXLzix+36DEQFo/uQ+xPt4Q4gE5k1A8R6vpUZpyXLNUjqaT9gfDPFODoE3TE8CKAkszcA1V9EolRNe+REqzdWHTtSHDjxsA2RkMbg2etsHcYGhAC2I46DEmBK1O9ZCElsRq5BNWKvs9JKKuDrQmp3tvlbHu9Hk7/dB2ndEY/cM/CkyWhHTnTrh3Z/BqLtlci9sOmMdchktAu5/vlR2zTaKaOeyzIkqqECCf+yiQQdju4mUVpUZcktqK536Wp00BFX2AZl90Qe2I14L4RVuY8oadLCjHstQhBZCIlk4IX1lCPqdSliDytDPOEKr/jFToRUrTo+wPwN0A6OjfZAK/GSFrbMy37SpJKq9QG8sCB7fawj57Cmq0bFV5Yi92QgYhcOIJOZRrSB6NTR6DAhjdihS4BPkfs9pbNiKrsjUWp/gEhmNgCuhpqGLx5R2rqD/ZGXKLoHzqHGzHUFbESkk1EIEYTxQlCsCr6RppPEDOQl7YFIpVU0zR5JMusldeB5xIWJEU1HuibGNQMor/f6jmYk4ExEra6JUrs1YrbYjefdP5ywZLkJr/93HUKYZeZ7dFOWRqKMkirLEfV7B5J91SlSZXdUvXV2DilBL0S1srZryU4dRZQR5EWKliYdROU+oonSkMcGREpJQ6SWVEyMniGOGoQQ6xG7ZQbSsjYbeRlt+p514uQhhJtCJ8LYW7MQu2Sz/deRSdCWNouHDIRoLfnYTpopeBLlYX0zrL0ytU/arsk/nTrhy+9e8tBX1lx5/zmvX3h52oD0WuSe9VRekV4Xz04Jcn4VZvnrSLRDp9QB6471KHVGFmlJHh1VdDGi7AiDdCZeRkMRnjpzxDlwWsA6JKayQGu9VCnVgNi8bKGHMCI12nTGlYid62iEKPbi2TX9yEu4Ac9s0VmwhZbj2iWhUZrsDWzVcZq+GYk0COyOSlcN4tlibfuHwz5hXrrualdH9J3Kp67UrnZRqLQB6eec8fy5W18685nXa3fV5GKKk5hSfxBV8k0pVYtIplsGnTu0dtR14+66dN3V/ZRSNcBDwC/mF8wtPtzn0d3CgwBITSMt2SPKspquRQ2HVaI06nUqXitSa8zvkkUvDhZG2toEFBhiKEFeOCsR2t4wOxGJM4SQ5WhgPF4qo5088hCCSlVeA7MOhVIqAxl3eStS/wBkzC1Jk7blg32jbdB3BC+usiOehTOUT10JoBxlClgp5U/195/8i2mTe8/oO3byz6blRHm0o+2UFuVTf3P8scf8cfr1WcOzB5p1M4HrgbdnFxUe9sbT3S0zB6RiUEbQo6PS6q5FlIdborSOjR5IzcYG8/2IV7nj4HOkc98QxMRQizgI9uKF/FTgpSxWIR7vqSkpKUUXXn75wDHjx+dVlJfte+D/7tq5Z9cum0VibZcdBkP2abRglzTrJSOS8+YWHHKZSNyla9RaW4g4G5k8oR0DzVvBJcRpGKaUcvqfOnDSgNMGTdJa/7rg8hFPXLT0im/jlYKz0EB5/9MHfgdwlNOEoXxIiuNsYO7hPIluKVEGg2SkeCaE4qovFlFm4QXyWrW7O6nc0bAe7pFIIHMFQgjWu21b1voQIs0E9o4ZPz7wl/vu/VuPXr3yIpGI6ziOc8Fll4X/8pvbI/Pnzn0ZL/+7Q3AAdkkQaTKMVyk8dl+25UNxVNpftCPHmiY6iiiT2F9CBDyyUUr58TuX+H3O4LHfnXj8Z39b5ldKOm0a9bshkJE0TcVvOBYGZnKYibI7VjjXgSRSkxR+B8Iu7Kvaz4rTqTjcVzgDkRzKkTCMIzlmskWYc1qDSGIDkcmgHCHEVIQobZhJDVKPMnjHv+45P7dHjxwAn8/nKKXw+/2+G27+8dfy+/TJomm1845ANq3YJaEx5KcnsK0FaTK65YO1QyYjhNKTpsV6O+KZeIk2VP9RSvmUo44d850JJ9pFUT9rdGOYUzy0eN3aA+0VHqSU+rZSaqNSqk4ptVgpNaON252glAorpZYe1IHjwe9HKUVWqtye0uoIDeGuo3QebqLMQext2/AyTLrO2bc/bFrjaPO9DK+MWj2eHbIUqBo3aWJNz/z845yYJ91xHBUMBpOu/MY3TqQDQ1CMXTJAy/GSFgMQk0BcadIguuWDRTLy3KXiqd7QMUT5BPAebXgGtdau2+BOI8ZOqbXW2nXnNnN9/MDD7TXY5tAe4UFKqUuBvwC/RtIyFwIvKaVabFSjlMoCHkQ8/+0HRwgyJ82bx/ZUdB2p8rARpVFNBiAP2Wa8/tbdFlEB6DmIycHFa0ELHhm4QOX4yZNtOl+8fRFMDvZF7JyH3QgVY5ds0SZqArN7Ip7uuKSjvJYPlXg9cGI93rvN8kMqrdZWzC+Y24AUMvkZUmh5C80QtFLKqS+uKzVjbvKehCpDt0XqIkvsV0RCBrhlfsHcjw7H2KPRTuFBNwH3aa3v1Vqv1lrfiBQy+VYr290N/Ad4/2AO2izMOeRFEeWOsq6SlHZ4bZTpSNiIzUqJrhzdnbETIYcCJIvDvkhpiIPHvnQ1r7/08vobf/KT8kAgkBW7E6UU7731djlCugEOY873AdolwWuFsbuFdWzLBxvpoBGStI4cF5HAD0vqYnOYXzC3BrjdfJhdVPgQ4oBpfEO1q7Ubcmtfu/TF6lHXjfvS2O9OnHzpuquDSqk3gFefnja/OntkztmTfzrt0l7H5I9SPqcKeGR+wdylHXEOLThzMmLm1Po4pe5sSNcU4LcxPy0Ajm/huF8DhgFfRSabAxmzDRNrHGuTFYxEmZfhUdL2kpC4R7sADidRZiEe0Q+RlypCM4b07gRT0msL8iDm4tkqHeRBaQxg3rNr175PP/xo3jHTT/ie1rrxgXddlw3r1m18a8GCGpoWymh3GGk1mzbYJc36aZic/VakwAxkYmgs1Gy85JqmXRc7IiunJXwXeR2PM+Nx3LBb/cnP3n9k8k+nXTjgrEEXo6XfOPBD4LXZRYXnlq8tK37r6gVvAA9rrUua3337owVnzraYVW8F5sTZRQ/kusdOdLsR4WY/KKWGI8Q6Q2sdPggl52bgluZ+1EaizE3z4XMg4sKW4q4jUba76l1UONtfVDh71t9nnvC1CT1y8zBpi93RgdMCbN/uEXjtH2rxCkuAaV/7ra9+9ZFPP/rotqrKygqAUCgUeunZZ7d+7aKLVw4ZNiz1Wzfd9KXnF75z0ZLNm4IcHqTTdrskiDRZx/5dExuhvJYPNrxGG0JORiRs68ixNttOezbmF8wtRTJsZgI/AC7zJfl6ZRZkvT3w7MEXK6VszKUfQGt9itb6x5euu1qf8cK5p1+0/IqXZhcVrppdVHjX7KLC4R0x5hZslP0RAcV+bm9lV7HXPe69MBrHf4BbtNZrD3LYt8eMrX+TXw1R+hxFj3SR38pqIl0m8LxdJcqiwtlHA88A/c4Y1J/TB/ajMhTKyExKutKs0qkvRQcihNi/+iEOnSrEBJGBRyAaIYqGa79y6dtKqVCffv0iZaWlO+tqa6fe+qc/nn32+ecPNC/BRcADSzZvegC4bvKgwe3y9BgJLw2oaEuVIlMcIxdY18rEl4ZMwpXQKE06CFHWIVJLkVne6fn+8wvmaqSw8tt22aXXXT3FSE77xVxGGiLfcxvccdkjci6MSsscDnx1dlHhjPkFc5dwGNGCRFmpta6Iu1FT7EM0nVjpsRfxzSkZSBbZZKXU3+1hEYUkDJyutX6jpQMaE0CjGWA/idTvXebe2X52G0fOxj31TB7c0YEf+6PdJMqiwtkZiI2j8eIrpcgIBL4C/CJq1W5NlObFd5AURI3YdBoMEdlwIVswwzo5srTW1Tu2bVtfU1296Se33TYyiiQbdw1cgxjT22Oc1i5Zp6WLZFtgq+7sbWW9TOSlCNOUBJPwcrytt7xLTp5KqdzmfnMCTnYgPXChWc/eJD8yEfzhcI/tUMODTBLBYuC0mJ9OAxbF2aQCySCbFPW5C0mymISY1w4Nfi8BrW+293/Rni5RjrVdVe+v4PV5aYR5kP5fUeHsIz9zv+1QiDS1BRiMd03KzN8chBx8eOl8e4H68y/9yrbzLv3KiS3YgL62ZPOmPoc0OM8u6eI5W1rbJtOMe0tL0qTZdwZR0qT5ydpnbT3OnVEk0+WIEngvVppsA3zArI5KYzzY0CCDO4BrlVLXKKVGK6X+jEyEd5n9366UehAkVEprvTL6g5hO6sz3Q06I0EleoaweGT6Cfjmvot31RNzOfzzakyiH4IVJxCKbTix02sGwEqWL5H8H8KTsCEJMmXjtH9LM31qg/Hs//vENjuO0NKk4dXV10w4xZCgDkYDaapcEeYmqtdb7WlnPVm+33SYteVryyEGek2gHSOe/CfvjYZppw9HKpXc5zOfTHnGUWutHgRsRbW8pcCJwttZ6s1mlD3LPOwZJngneUYp+OSJVNoQ1G7qAVNmeRLmK5lt57nlp09ZYCaM7w6ZpWqfHQKVUkjn3SvNbD4RU/MjLVQPUZWZlXdTag//2q6+mAP2UUj2VUplKqWSllL8t5Gnskqm0IV4yahtrgI9tPxsPmYiNti6GhJMRz30+0qHROnKgCxKlCSN69yCe1zBizztsaK8ya1rrf2qtB2utg1rrKVrrd6J+K9Raz2xh2zla60kHdeDYfSnVRPUGGJjnfV+1vS52kw5HezpznkLCE3rH2e/vvvf2oniVWLojrERpi19sQjx8A5C0RVvXMBeRtG1BWRfxDqftt0cDrTVa69pf/fjmTxGyS0Ik0rDZR1gpZZuTRcwnbAnrQOyShbOL0pACw2525vCSsop1VVrrtpQQy0CycaIJxgaa12GIMmp5l508Q9WhewJpgVkHuJkf+O/sosL+8wvmHpYc/W6X6x1MgZg5vl9OgIAPQhFYvaOOsydlEvB1Hn202xUumDu/DjjZ1brR4+dqXa+1/iXw5/Y6zhGA6MIfSXhpjSMMUWlEzVYIadQhROcAQa11qDneMAJjaU11dTFCRmE8QgzhxSXaHPscIEcplW3SE3vjNdpqFoWzi65ByOwl4JUvn/HcWxd/eeG0Vk/ca/lgvfrR1ySIqLL5dHFHDojk/cwxj36w79M9/wUOpIeLDai/8DANrdtVONfJ+5t0/T7FoDyxW9aHNWt2dK5U2a7hQQVz5xcppS48oU/+988cNGDZW9t3LH596w4JTJ736BE+7R0QbMiLrfyzHjgGCR6PDuq2ZdQcIDhu0qQGx3Fymtup1lrX1dVtRKTCBrOddQhFoj7h6Sef7PvRrbeeGUwODti9c9fq6y+/fGlNdbWtlZmplNIx20SAyNWXrjsRuK/JyShfalpq77sLZxctnTu/4OMWzrux9mSMlGgt9cl4fbztdepyRGnCoLLd+sjw1y996aGLVlyR5gv6ZtJ2jSiC10Oo3dHtJMrk+IX8h+UnNXq9P91Uy/gBnVfw/3Bk5uS/t3N3yXs7d/8XCQNJRSQo6IIvxWGAlShtz5tKRMIqR2LtPsaT+uqR4OsywF9bUx2KztDZb8dKqaI1a+ZG7Ru8MCN7L323/vEPR519/vn3+/z+PK2126NXL+e1Tz5e8+df/+aqxx96KNqBFO14cAEdDtf9wOcLRlRUGTFj+wwD3wEKWzj3TKKcOFHb2ifcevu7LFEae2w6MtZcYKVS6lng5APYjQ+pv3pY0N2IUjdDlPmZfjJTHCpqXTbta2BvRZiemZ3TJfhwXOF8hBhqEQdF50eLdiysfdJKlA1a61qkBmUecn36IS/h9hmzZvV4+L/PF770/vt/+NM99/x21YoVkXB4/+ABrTV79+z5R+GFFz2JSKm1eGq7tUv68/v0ST37/PP/5fh82dCYJUMwOXn4TT/76W0IYVvVOxuJVpgMnAt8q76h9AQVv9aiX2s9Mt4JF84uSj595rzejvInI8HrsWq3deT0NGMtifqtSxClEuQiJKkRj+9eYN/LX3p2d31JXZl2PeeUsRfH21UY8SK/ehjH2s1U7/hEqZRiZG/PG/7h+g4ry7ofDgc990cesDqELDJNQrx1OHR32MnHko2NbdgBjENKsBUDDT//7e39v3zRRXc4Pl/AcRwnEg4P8/n91FRXN5b7ByJKKV9DQ8NtZ0w75h6EaMrN/v2ITdBWDk/63T/+frrP7+8VOyillC8pGDx92IgRc9avXetHpMpU8zfN7CeltOxzJyW5J47T9NFwdUSXlKxylRoxFViuta4vnF2UB/wJuLxv7xMCl1+0bItSzg+BR2MOb+2TvYA9UUTaJYjSTCZ5yDWoAiYiYysHTqraVDnpna+/NmfmvNOPCmQmnQ8Ea3ZUL1n/6NoPx31v0jjlUzOUFJpwgWeBb80vmHvYso1iyfFIJ8rmVG+AgvwgS7bUEo7Asi21nDwmnbTgwXn5DwXtKlGaAN2eSPiHDY9x2b/MWHeGvYtWNa43Tg4fUlmoJyJRpp169tm3+gxJAvhMGldKSgrz586r3rp58yfhUPhB4IRjR4z8OfISZwOOcfrUmpS1coSQB25av/6k5gamlCI1Le0UhAgGI+olZvu9wN7P1/9nhVK+Jp5oLX24WLbqbxuAi4EfBALpX3bd0NtIJZkAgOMEBjiOf37h7KKLog+LV/0oNkWu04ky6pn1IyaQgea7QqrVjwU+K/2s5LGnj55/zWMjHsx+bMSDacqn7hh/w+T/p3zqZOR+aCRN9RfzC+a2lrl0SOhufb3jOXMskvyKEfkiVYZd+KCorUlk7Yv2lijzEYLYCuJ8uKhgiPrGuNFXDM5M9yv4qKhw9vsFc+d3Z8KMDg2ykpv1gu9GCjD0mXr88YszMjMnxN2DUgQC/u3nzzz5e8ASrbV1+ZUhamy+ccaMQFLLhiIe7X5P/ueRfudecknc3dbV1bmb1q9fh2cztm9YFqbaz7Ydb368au0D60cVXHGJzxdMBWhoqHA/WnLbpm073kwzx2fEsEuvd5zA2KbDVpb4fgU8ab7b0mp1CFGujFq3U2GkwDy8km99EInfVqQfjLQwWWB+dwHn7AXnp6T2TrtPa+1EpayCTGIPII67w4bY2Mkjvl1tsOVEpjH9klmzsx5Xw0cbajiuII3UYMdODu1ClEWFszOBK16/8JyTPtq1J7dXasq9ZvnJvz1h2jNKqUwtzaUc4I2iwtnnFcydX9Uex+6CsJ7oPPO/LQaRjLxoe5KSkoZ+839uHN/STr500UWDXnr2uYplixcrpVQOIumMBsYgTiFb9cfmTqcC9SuWLNm4+IMPe0+aenRq9AukteaR+x+oqayoGISQlS1Km4cQ+EKkKETNJ0tvT1q9dt7dY0dde1Rt7Z6en31+32muG8pCiC4F8GVlDB3humHtOP5YwlPA6MLZRSkIOVq9qrFtbdR60EkSpZHycxBCLEVIbjpiO96HXO9NwGvmO5hJMGNI1pnsX/sR5L5Pm11UOGR+wdyNh/kUug10K0SZFnQoyE9i7a4GGsKa99ZVc9q4ju3kfMhEWVQ4exzwJpDXPz3NHVAwxAFWFxXOvgR4DKN2K6+51EnA74FvH+qxuxqMGpeNl3HjR168hgsvu6z6W9+/6bxQQ8PFOXl5JwaDzT8dSilSUlODJ59x+m+XLV68FSGzLORFDOM1KbN1EncgmVF1wJk3fuPaz++87/7IxKOnTHYcxxdqaKh9c8GCd//xxz/mICFKKUjV+RDiGNphxnym2X9tdc2O8Eef/lIjUuwOM4Y0c06ldfXFEaWc5qTCGoSAFF4XSWs37XSiNOE/Wcg4y5B7dDZy73YhDq6tiEOmGC+SwdVa69lFha29pZ3dj/3IQiCp1VUmDEihaHeDSJXrq5k2NLWxv05H4JCIsqhwtkIav+cAyvG8pSnAo1rrtDgqlg/4WlHh7P8pmDs/bi7tkQbjJU5BSME2E7M9YXZ+sPbz3klJSe8BA9oauByJROiZn38MIjmWI9LNPoSsegGRr157bdKV37i2f3pm5rgN69ZNuPO3v+PjRYt0dWXVu1//yleW9czP/8/AwYOz13z2WX11VVWD2fY0pPp6DlL9ZanZb705h1xE5QwgJFaJkKq141UByes3PfvO+NHXDzaV0hrvsdauq5Rz/9z5BZF5jzbGeNYhdtkQIr1BJ2XlKKWyMS0vzGcgUtU7GbEhj0Guy2uId74JSSql1MkPnfFJz2n5uhnzwT6kyVwCbUR0QYzmkBZ0GNU3yKrt9YRdeHNVJecfnX34B2dwqIr+aMQxEEvtDpDRwhuQfNtHn45QSvUyWSOpB1GppdNhQkrSEEkkDyGZIKbABSKduD6f70GtdV+zTZu8lAoo3rvPFssoRYh3lDnOur/cey83/eynX87r2XNcSkpKn1Fjxoz4v4f+PeKq665bA7wB1O7dvbtq8YcfLqmuqnoLL097GVIWay9i15yOZ+NMQioevQA8DbyMBMvXIfc0DyHLlRWVG7Zs3fHmL4Cw1i6uKyFNxaWr6p57+cvPF84uUhee80bvPvnH55lzsDneneLxNvfKSsWliDQ5DikTBhLSNhEhuVcRknRoSpIpQO83v/pK2q53dyw3IULRcagAN5vePAm0Ff62vfoT+ieTZCw9y7bWsa2k4y7zoZJTdks/OnEYQWuNC7ueWb+5FHloGzNRlFIuorJFf+qBUFfKBzZmhFS8VMEgIi3V4PXgDgKB7/7oh0f5fL4TDmT/WmuU4/DMo4+WIS9vAE8a2963f//UE06eeSFIx0YQj7nWmm/+z43TH5037+H6+vqNZiwjEQdShhnfNmAdkns+Crn+oxFy/RAhNRt0be2gO4EPENtoCuKY6vnmu9+q7dXj6K8VDL3o4ob68mN27F6UvmPXwvoRwy69JeKG7s5IHzD4tJPmaq0jL73y5pUf7tn3SbSk1WFEaSR+S/LF5pym4BXwcIAJwAqEJMvMMm1s60lGEk1Grts5717/xjNnv3bBM2l9069CpOXPgF/PL5j7ZEecU7eCr7laOk0RDDhMGpjMRxvEF/nSsgq+PjMPpwP8godKlMuQl3G/Qg5aa9fVushRalhMlgehcOS28oaG6FYCNh4waP4P4jWnsts1IA91PVFEqpvvKX3QMEQY/VE0dcxk4xXgrUakszLkxR+LSGiDAbVyydI2t0eyc4EbifC33/9h+YZ162xweAS5HnnA0KnHH5/h8+1fIUApRXJKSt7M00+f+Mrzz1cgL3XQjO0zRFrcYPaZjqiZ08xYTzRj/xy5zkmIJLkRWG7O9VyzbgMiaY7es++Tk/bs+yRgtsvp1+ekgmOn/LKxQZWop74zTplx9/SXXr/00ujh0gFEqZQKINcN5D7lI/enAZEixyATxirgRbz+RtoM3wahhxGv+BlApRtyH37+xCe2EL8nTQIHAO33tTk3dGTvIGt31VNW47KjLMzijbVMHXr4c1oOiSgL5s6vLiqc/Uvgd0T1P9Za69L6+gd/9dGSubceO+XHGYHA6UopJ6J1yTPrN73100Uff4K8jNEFJBoQiQc8gvThEWjAfLLNuDVSbcduG/tpVgqNCulo8vn9P//R+9gZJ1734bq1x2jXLd67e/fDl3/py69VVlTYNMFcRNrSiC2q0oxnFEIgfZAX0dr2Pl2/du17rute5jhOq/U4y8vL3Ufuf6Duuccf37l7584tCFFZO+5u5GXuqRw1yRwnLrZu3nw6YtPcjkiDFWa8tg1DPp63vA4hgh7mHMYhpLrUHDOAZO7Y/jdhhHg2AO8iUuZw5B4VTxz73TEaFycquUcp5UsKZGTOOPZP0xB1HrwUysMGk+iQi9fgbYQ5z93I8zcLsdd+jgSKV+CRZAYyGWqz7RiEJMuAZ7TWWw7n2L9QOIDwJsdRHDMslVdWSNDM659VMrJPkMyUw+vYaQ+74B8QdebHyEO3XSn1l9zk5Dv+u3FLyn83bvnuSf365M/o21vtqqn59N7PPp8EHHfWoAGld848fipCPO8UzJ2/MnqnhsysBFmNR56WXJNiPlaNt5KKY0qO2Xax9mPLmllowJ3/4otDh48e9SaQpZTyaa0j/QYOvPCNTxf/dmrB8L/jqW620rclHKsW70Lye+sRFbn8ym9cW3zdDTdcHw6Ha5KSktJbyuN2XZdH7r+/7F93/i1stk9GXlpbIciWZfO/+cqCmh/feiuBpKQm+4tEIuzYts1dtXz5cESa3Am8Zz6f4OWI98OTNmsQwhuF1+umN+L5LTX31oc4kDLNOPzAsUg73gCeOh7JzRnjd+JmQLpuVsbgYVELDqtEqaT3eDZeyblJyLmtNd/PR8wSnyGSpJ0IrMbgII6rasR0MR2pLfoaImUn0F5osU71/uidFaAgP4mi3Q3UhzUvLq3g0mOzD2uG0iETpQkevw+4r6hwtlMwd76XDzt3fjVQpJQqfnv7zt6IyrPxJ1MnnffVUcOXIy+qBlRR4exHgKsL5s4PQRNv6H4vkyFRm/njw4tdtBKorcpjCdSP1xbVliSrQ+xxDUB9wcgRt2NI0hzDB+Dz+3980mmn8farr9bgBY83IBLaKiR0xvanDiBe1JEpqamhwm9+8yepaWmTosbd7HXUrktGZlYNQm4vIaSUhad6277g/ctLS9P+/Jvf7PzhnDl9IpGI9vl8KhKJ6Eg4wu0/+9kehKw1Qu4XAucgUtRqxIO9DSHAdYg01dP8Zm2WIYRMj0NiKzcg9rvPEPU7HS/lbzmivisgORSqbPAFc+N0jFTK50vZGnX/4DARpZKScpnIJJCJTAo2cgCkbck4pG/MOwgBBpHrnYQXNuRHpM7JyH3+AFjflezl3QKNkYNtx9GDU9hWEqIupPl8Vz0rttUx4TBWF2rvMmtxVSmtdalSqhzoefnIYWOuHj3iJuUd2740lyIex19CXDthrM0wGjae0Nox6/DsipY8owOzraqZCgRze+SlKsc5K164RyQS0dNPnnnm26+++ibyQm1HPKIuXs3JvKhjh4Ha7//8ZzNy8vImteW6gThjPli40PbZeR0hSFtAY5Q5jx6IRFf26LwHN28sWr/9ym9cm53fp0/y3t27N9/3j398+umHH6UjDc1y8NrB5iDq8SiERMsQgvwUaSb1MUIUK4GpiJr5ETKxnYoQShZCrruQycCPVPLONssbgN47dr33wZCB55ykoh5+yytKqXlm0WEhSnP/spH7WocQZCZyTXcjz8NF5hwXmnPcg1xXW7hjt/lrQ6mGIxLkZ8Daw2ET/8Kj2XDc5hEMOBw7LJW31ojv9KVlFQzpkUTGYVLBOywkx1TZ3r36yq9cq+I7xJ2Q696glHqNpoUerMQY61SJlST9HHi4UwQI+xxfUnMpdUopPXT4cBtyY6VRS4q2WK79+BHSnN6nX78z3EhEO3GcLrHQWlNRXl5/4WWX9Rw4eHDlU/Pnb2qor89AiMqq97kIAWxFXvATP3rvvU0fvfdeHSLt1eIFub+HqJoTzLYbEQLPRFToXCTNbiqSq70JMRusQ6TNzYgUtdWc1xlmX0sRcqtGCLYAT11fBfR6/5OfPx9Myp7Yr8+MbOEUhdaaPfsWP9O717Qie1ntqbd2bdoKc//ykIlLIQTnIhKv1TzOQRIe3kBMEWGEJMNAsda6WnlV4E9HiHatuT5r29o6I4EDxcGpzIN6JDG4RwOb9olk+dySci4/LuewqOAdHrsY8Dl9EMLZj9T8SuUqOEabkCA8G6UlpzCeuhxtf2wsWHsAf91oFWrJ5k1XIa0PmkxJjuM4q5aveAHJ92Xmaacl/eCWX5weSEoasHXTps+/c9XVy+vr6qw3/GTgFCDZ7/dX6ygHV3OwQ8jIzAyedOqs4ClnnlF49oUXZF113vlr8DJFksy4KhAym4mokv9CnA5hhACtdDvCbPcWMAivTqQNhg6Z9Xri2SNHmf1UIVLzXoRUdpttRiKe8Q8QiXyvWW+A2W4vUBcOVx/92jvXfDRu1PVTJ4+/MVuydzS9e027AHijcHbRlxHiardg85jwnyyE/IoRklNm+WkI4b+HJyHbaIUKEycZMMvPMNdmpVmnKCrfPoH2xiEQ2zHDUtldXkFtSFO0u4HFm2o5ekj7e8E7I8h7CXGakGkROVdpsXdGS4rR/8e7ohE8NTj2/ybfW3kx/xexVwWQ2ouuUsr5bPnyD//0q1/1AC7+w//9c9uss856ECEfevbqxaLVq979f1cX/vz9d945BSGTIFDzxiuvrJ96/PHj4pxn44wXpZLKMlMFZtzEiRccO2P6mx8sfHcHUrbOOqnW47VzeBVRfTMQyc9OKiuQF9zGdlYiMYM9MS1x8bJl9iDEaDsnZpjPMHOO+8z/KYgUezRwHjJZFThOoGLooPMm5WaP7hkIpEcWL/9DpK5uX0pqSu/QpHHfzVZKakbY6DCt9Qyl1G+B/6GdpMmo8J9kc45JCLHtNAQaQCavs5Bwtk/M+tuAHVaVjvKQn4ZMLIsRW+VGrXV3rUvQNXAIRJkccDh+eBqvr5JbtGBFJUN6JpGX3r7U1hlEOR+JPetDlPSm5Km+1ZQNiwujXsWq5LH/J0V9j93eOnPiEerqZ95849h+Awfe4DjOiUqpvSX7iv9zzUUXbwQiScFgzjHTpz+ttc6OFu211sdfff31j7z/zjufIVJcBbDm2Ucfe/Pq669P792376xIJILjOGitiUQibiAQcKLGtN95uq7rXvH1a/lg4bvWy56KSG9ViBNiB3AUkrddiZDOWqTSjYsQwUCEKDeabScjRJ5uvlci5FuNkElPvDAsW3osFyHJQea4ixBSHp6W2qf/WbMeG5OW2jvXdcMo5RsyeMBZ7rsf/vCj7Kzh2Y4TUCrGSG+I65qxI6/94Wef33vItj4lHSVtNEAuQv5LjQrtIM/CyUgO+ybEu+8DNmutd5h9WE93T8Rxk4wE3keAbVrrUhLo0uifG2BEbymaEYponv6knGtOzMU5CNtnc+hwojSxlyciauMss3g38JOCufMfb2lbIxHaMJ9WYV7MWEKNJVX7vzr/5FPKMc4kgwjyEk7+4Zw5vdMzMnJjj+E4jnP0ccf2Hj5q1D/XrVnzLkJqm+rq6vZcOOvUH1x42WV3Hn3sMSekpqVH1q5etfqlZ5+7uVfv/Eh1ZdXwu/7z8F/3YxNzquFQKBevXNvLiPPhIrNsB6JabkVUx1S84HEHLyjf2nrXA/9FnDZWCt2B5xVWiISVipeVs9l8XHMNxiM2vgqg7NgpvxydktwzTa6BPEY+X9CZcewdU8vKP9/TgsUhpW/vE1I/+/zeZifEtsCE/+QhE66tSrReax0x5JeEqNCzkAnsDUSCdsxf6zBMRqT0U8yu3zH726O1jk6KSKAL4+ghqewsC1NZ57K9NMR766qZMbLV0OU2o1Pyqwvmzt8InFpUOLs38qJuKJg7v03kdyAwalWbJJcoL3ssodYAvmAw2GxBXMdxOOm007asW7PGh9jsFFBQV1s79j/333/Uf+6/vx5Rh58C1q9esSIL6Ltty5bKAYMGZcVKlY7j+F569hkf4ih50Wx7HGJ7XIC8zH7E2VOCEFstXh3FcoRAMxGpsy9e4PVWxB45ESHbzeYcM/Dad2SbbbIR0qhGpKzBQO9gMDezX58T0/aXGB18PseXlzuuT7zrpLUm4jbsWPTxz6wUfFBQSmXiRQQ0AJ9bUjMkGQQuQK7ZViTEaZW5BuVa67CpLRBETBsnIZPLIuSalyFSdwJHCAI+xfQRaby8vBINvL2milF9ktutx06nFqIomDt/F17r0k6F8cq7xJdWS35z519fAr7ezLZ1oYb61/EK9W5HyOvriGSzHnGCvI+JtTz3kktmDBw8OCvabGr/X77408pXX3zJRUJ4FBLcfTwSY7kNIbF0RJqyWSdFePbGXub3UoSQbPyn7da4HpkEBiHEvgshzWQzvmrEgZOKqKQDEEIpB8Kjh189Or4g3DysbXb12rkfVdds99HGCSwaUeE/QxBpch+wOsbRkoVI3uOQCWYZQpJpGJutkoK9AWSiOcGc1yK80mubErGSRx56ZfoZ0y/IZ9vribjw/JJyvnZibrt4wQ880vMLirPOO++pqsrKxdp1m8SKGm/pnXPvunsbQlSV5nM5YicsQwLI5yIk1xMYfPX1141xXVdH30T7//sL3ynTrrsQif9zEKKqRqRLhaiKQ/HqXmYihS2mIPna+QiRjEbIcDDiCa5GiGAnkmGyACF1G19aipBmOkKM2Qi57MGkLvp9KTljRly9X0+e1qCUorJyc+TT5X9MRUKXDoiIjMSfj5gAchCyX2pJUikVVEoNAC5DJO/3kSD6DcgEGDTnZ+2wo5Fsm72IxGnzuTeYSTOBIxCTBqaQmSy0trUkxLIt7ROskCDKNmLyoMEaOLV43743rLQRDoXCC994473VK1b81KxmUwPygasQqWkBEpISQKSXgUBy/0GDspw41uZIJMLYiRMjCNGNNOsPRSS+iQjJ9EEkJJuxk4FXzSjdjMM12xQjKvUwhBzyEIm0wKxbZfYx3ozvKLyGY73MRyHSW3WvnlNUIJB2wM+N60Z0Td0+fcr0u6ede8Z//33lJau/Xzi7KLst2xpb81DEIaURgtxgJim/UqoHQuznIOr4m4gNdgte9fIaPHPKRMSeuwVx8GSY34q01u1uAkqgFbSj8O73SS64xeurKgmFD33/R1wNyM7EjHHjy5RSZx47Y/pZQwoK+i39+JO1q1euvCYjM3Ps6OXLBrz0/qLzdmzbFvzVj388Y9P6DUlIKEoRQmj9EWmmEghVV1VVZ2VnZ8axT7rpGRmLgccRlfAiJCvkScSRUozY08aZ/20hB+vFt7nNNpzKplaORoKwbSyq9fzvQFTUgQjB23jNSuT5GIBXfWc3mgaEaA4IjuNT+T2n+F03kq2Ukw38Fvh24eyi4+bOL9jZ3HZGTR6PEOBW4DOtdYORMDPxSO5EM/4F5vpUIg6eTPO7LS4yzVyLtUgwegYysazVWifqSHYK2tfK0TcnwIDcAFtLQlTVuXyySfrsHAoSRHmAMF7VBR8sfHcG4OTm5W2b9/RTzwMDevXuHe7Zq5fviVdfVX/65a+qH5k7dw2i2to8cRdRY0e9++ab751zwQVnEuUeNhISSz/+5P8QAjsdUTP/jNjabPZPBkKSaxCJ0FY3sg6gNPN/svk/BSG/vYgdTuFJnRGzT5vR0gchTbv+J4g6ngzU7dr7UW0kUj/JcZJ6R3vsWyz4oSON1YQcrwCC0lr3U0rdClwXbzuTsz0VkZaXAVvMNUpHpERlru1ZZswvIKYCP2Lm0GY96zyagdg3P0PU8mSMM1Fr3Tnt/RJoV4nSYvKgFLaWSCLVh0XVHDMs9ZDqViaI8iBgJJr3gRl/vPvuiX369+8P0jNHmZJRP7jlF2mbN24sWfT2258j0mQIITYNpNz+s58/OOGoo/wDBw8+zXVdHMfBdd3w0o8/uflvv//9XrPNFCSsZxVeNSEXzzkTQOyPtghEKt7LbwuDRHvwbXB2FV7V8hqEEK2k6uLlchcjxL7L/O3lug29Vq75150TxnzrVq0dkzaqNSjHkmU4Uhcq2vDUnvqG0nWRSG1adtbIIYMHnNUjtle48TxfUTi76M9z5xesjvmtH2IGqAMWaq3LlVLJShqtWYdTJWKTHIJUZK/BKwFXidhnXUSCPgWZBJYiUr6NFd2itS5v9aYncPhwGIgyJ81Hvxw/20vDlNe6bNzbwLBecWq1tBEJojxIaK1rlFIfjp04YUY8W6PW2r3+xhv6Lnr77RHAzrsefmjIuMmTbw4EAsP37t5dvXbV6voLTj5l5+jx4xYff+JJWYMLhr087+673123es065CX/EkISnyLqr7VDpiK2yx6I1BdACM/W6IwgxBAyfyvxVPZKM7xMhHxDCJn0wbNDbkeyeybipT/mIbbKNcCGpSv/urasvGjT6BFXXZSVMTSrvqFs9/uf/LyspnZXRmpKfkpx6WdloVDVUET1dU+e/n92H/Gm9FRgVeHsoleB2fMeHV6KqNrDEKn6UwClVC+E/OsR4tZInvogxCxRjEwuuxEHWk9zbYqReMocJNtmk9m2L7BTa207LCbQWXAPj++sID/I9lIxOX++sz5BlJ0FrXXZp5s2xk0sVUqpSCTSB1j39JtvzBg0ZMivbFpk77590/r27//z//npT9fdcdttq1YtX1GBhKf4EUKajrzcS5C6iSnIS29rOGYipFeLkEkpYs+sjPpURIfNRBUrDiJxlNMQz/EehDwyETvgCISMNpr9DEcIKsVstx3YsmnrC09u2vrCOiTQPcWsm15RuWkgEs5UjkhzvffuW/rxwH6njmzlcp7iupGHgduReMeViGRoA+DDwD4zQSUBVyITyGOImj0MkTL3mXPMROy1p5nxf4yX6lmAFMFo1jaaQAfiMBFl3+xA4wtzqP11EkR5iFBK1Wit02Ptc0oplZ6RsX785EklAwYN+rFZ5oDX52Z24dXD5v7f/5WXFBfXIWqmDRg/DpECKxA1eTOiHlcgZDAQibHc2JZQFnNca7sMIOQYMMfbgxBJCCHMLPNJw1O9JyAEXoxIcHmIRLoNL8UxDSGzMjNm2642bdXn9+0d2P+0PT1yx/eCZpur+RzHd+aQQec+vnHzc8+Z7W3geilQZeyTQYQk+yIkuR4hPsdcIxeRHpORCkkgdtadyMQyAiH1La1dtwQ6CIeJKJP8ivRkh8o6l5KqQ8uYTYQHHQKWbN6UBuxHkiDODa114EsXXnS84zhxXW5+v985Zvr0bEQK2oy80MUICf4M+KfW+m9a6/9orV/VWn+ISHq7gV2tkaSx6dlwoCyEDEsQ4tmKODps9Z8avOK2y80xkvFiFm3dxnSEFM9AQnaWINJatdlvjjn8OvM3ydXh/Ffe/OpLyz77+9ZIpL7FqX3imO+UIrbVbLPPHVrrSkOSyUjYVV/gUcQU0N+MZx9eqbk+CEmGEXV7B0LeBQgBb0wElHcdqMjhi8iyXRvrw5pDueUJojw02DJv8eAOKShYfcmVX13c0g58fv8G4N/AM4g3tj/wHyR8JV60bCqiTdTG259SyqeUylRK9cGz01Ujkp6L5+Sx2TyBqP1JAUn57EE8wzuQ56QOIU9bBNhByHe4WcdKwKVm2zyzvQv0ikTqwus2PFbu8wVabLm3bcebtp/NTq11qZ0MDEkWIiQ431yfXuY41txQh5gCjkEmhE/xCpUUmPMsShTfFSilvq2U2qiUqlNKLVZKzWhh3QuVUq8qpfYqpSqUUu8rpc5ol4FEDt/tCEeEHP2+ljsMtIYEUR4CJg8a3IDEO+5Hlkop/H7/I8jLaotLNEJr7dbX1VW/+sILWxE1MIjYI/ciWTPWvBKLVKAuWppUghSlVE9E2spESM+qwNbj3YDYLku11tWmgk4FxsuttXZNwHUYrxixbSGxBa9yfCYixTUAmT3zJk8/efr/nTzrxHsvH9T/jGHAw3g54zuBQG7O2J5nn/rECKWaL2QcjtR/8smy336qtd4bXSRXST/tryHE/wgiraaZc3URci5DCn4cb8a6AiHsckTyDSAkmSi+CyilLgX+AvwaCeRfCLyklBrYzCYnIqX9zkaiMd4EnldKTT7kwRwmiTIc0VTWyWuSk3poVsaEjfLQ8X1EghmKR5h+4IbJgwZvAliyedOVSAWgIB4Bun//wx+eqa+rK0Ze9OMQZ8odURVw4iEV0zvchNek49WT1Igjxk7R9ntDCxknW/AygNZDY5WmCGDH4SIEnmy22Y1IvqOPn3p774IhF/4QVBDQ/fucpOrqS4c//cKp9zeEKsYCex3lTzrtxPtOSUrKTmrpQvp9wR/EFshVSqUBVyOS7CNmjD4kLCrZjH8P4pw6HiHRz4C9WusKpdQQc43WJYrvNsFNwH1a63vN9xuNhPgt4ObYlbXWN8Ys+olS6jzgy4j55eAROjxEuaMshGtEjQF5LSoyrSIhUR4iJg8avBNxdnwDUaH/AkyYPGjw36PWWYh4jH8DPAH84cF7/nXqw/fdX4GorQHEO/sRIn1aNJEojVMmxfzfC1FDc/BKq9nq77VAmda6TGtd01JanvltC5Bh9hn7u0ZU9Z6IervIfJb0yT/eKRhywU9BBU3xYQUQTMo+9fSTHzzDcQLlI4ddNvDUkx4YmZycl+40021Pa621dj9HqiJFn286cA2i4j+MIXJkUspC1Oq9SOrlcYgpIZok+5nrs+kLUnw3w5hd7CduPIyJGpiCqdofhQXIZNMqzLOYgZg42rJ+MHpsZlv5LXx4hPw1O+sb/x/VJ7mFNVtHQqJsB0weNLgauNd8mltnK/AL+/2o228fjbzEWxDHCEjRCzt5NVG9zcPdE7HLWY9yCFGdw2ZZw8HY37TWlUqpPUAfpVRVdJaKIaseCPnuMcRZoZRacuKxd1wAzn62H6WUys4suPgr5753WjCY009rt8XMHaWUCoWqq3y+5HMKZxfVAu/Oe3R4ELFJpiAkuc2s3h+xS+5BHDgzEE92kfnsMefTE0lp/CIV390W8/1WpEh2LHogUvnumOW7kYIrbcH3EfPHY21c/2bglri/hNo/c3RnWYidZSIf5KT5GJbfojLTKhJE2Xnog1x/FwmwfhPPnmihDFFlIA9lHvKA70XshVatbo/4ip2IijpYKbUer1FaTzynUoGS1gsBIKkhVDkyGMxx4/Ub9fmC6Y4TSJWTaF1x8fvTpiilngeJT508/qZnlqy4YzXi2LLxjrZQrw2in4FMHBsQ4tymta5SSmUj3vwvWvHd/nhJBeDltzeHWBt4c3bxpispdRlCwOcdwPW9Hbgj6nsGhthVKNSu2d7hiOaD9V5G6okj0w4pfRESRNnhWLJ5UxZw1SMvvvCVNSs/y3v2scfOWvrJJ2sQldEPhIzKlIeovLYZWjVi46xHVMs2k6NRif0IwQXMfgNxvqcggdsjzfFsdaFS87tt6FZj/i4CdXHs8YzUqZRy2mzaiZE2s8ePvv7q7KwRZ7z57jdtvdJ0xIZbj5DkCYhttgi5PkWGJNMQ+2WZ1jpWwuruqNQttFKJwj7kuYqVHnuxv5TZBMYJdB9widb6tbYOTGtdTxRxN7nf7SxRfrShhopaeT365wSYOPDQ+30niLIDsWTzpgLEu5g/fORIXTBypPryxReN2rJx43cunHWqg6jivRCSykYIagci0TUgdrnokBlbzCIe6cV+j0WEpq13a/HKso1ECPJToCQeKSulei546+ot55310l6/LyXXlEKzKvYhTd9KKbQm0r/PSZcitSKTkJdamXFOx2tFm4GQZKWZYIZhiu8eyhi6M0ytgsWIXfzpqJ9OA55tbjsjSd4PXKa1fqHdBhRqPxvl2l31rNstxOv3wXlTstqlcG+CKDsWdyOqrLL9vrXWetDQoX8ZMWbMdWtXrdqHhLPsQIigBq+PTRApD1aspP6iTWmMhkvTVr5VMd8bibEZ8nPwMnBcJBvGjbPOeGBkdc2OvcUlK2f07jXtL4idVWkd2b2veOXfeuRN+IEpp3ZQkElAjTDnaQt+KESSrEA8rT2ArVrrfWbSKCBRfLetuAP4t1LqE6TI8XVI5MNdAEqp24F+WuurzPfLgAeBG4APlFJWGq091KIi7eXM2V4aaqJyf2lSFj0yukEriC8Slmze1AuvgVUjlFJKa5106VVXzvzVj29+A7FBRhDpsgavwIV1Ge9DiCKWAEOHEkhtJMJ8hJiWImmJg5RS66Ik2GwkFCoDKXu29uU3LtfAWYWzi3rU1ZdmPvfyOeHaur3JF57zejAjfeDPdZP2vK6uqNy8ITmYkx0IZORZL3g8R4/WOuy6kXUIOeaZY45H7FrLkcmjGNhhyNumMX6eKL7bOrTWj5qsrV8gdt+VwNlaaxt1YcvtWVyP8MU/zMdiHuJ0O3i0A1HurQjz1uqqxkJExxaktovKbZEgyo5DS5VD9cDBQ8qRghP7kDTFbETNrgJRdTFtddtbWjLSWG+EaHYa1Wwz4k3uq5Tabv4fjzgLXtNal0XvY+78gn1KqWJMNtCzL59993lnvtSQntb3u+Dr5brhcFlF0asL3rxqdUpyj7Tjpt72pZ55k/op5RhVu0m/cw2ocKT274iDoi8SXrUBIclkxDyxx1yToWZZovjuAUBr/U/gn838VhjzfeZhG0j40Oa1kqowr62qImzeitF9g5w2LqPljQ4QCaLsOGxG8qv7E6MyK6XU9m1b/4vXPbEaUTWjJcT9MnLaAybsqDem2rmVxrTWtYYgC5D2E6lIDvqK5sZg8rFrgcxIpN556oVT/pGakv9AUlJ2YXXNjupQqPJp4IT6htITtmx/bUtaap/8tNQ+fq0jLigXlH0ei0F/Y/7TR5cg5d4KzLGXI89sLaJiVyLe7UykVW2i+O6RiENIYSytjrBgZRUNpt3DkJ5JXHh09iF7uWORCDjvIEweNNgFfoCQZAQauy5q4N9zfvC/1usN8e9LY0ZOe8GkBvZBSGdnHJU1HSHJQUjx3GVtIOo6s78kwKmp3V1bVv75tlCoMg2RAN84dsovk4+e+MPjUlN6+2UcPgeUz3UjtYZse7hu+H9GDLvsIkSSXIWYA/zIZALi6MpH7JRb2ujtTaALQh1k9aCymggLVlZSb0hyQG6A2cdm428+S/agkSDKDsTkQYMfQ3JlPzTpdJvcSOTHSPaJjaG0dSPBxLRFZeS0m8RkwmjyMYVwo+2bJoviBCQtcBnSgCutjd5s6023VdUVIiUHgUBG+qDq4UO/cnqsXVIppRzHl2KP4Tj+6dOO+vntBUMu3okQZRIST2mvQype8d3iQ7gUCXQ6DjyKsqI2woIVldSFZNu+OQEuPz6HJP/hobSE6t3BmDxo8EtI+1pM8LY2klw98sTY9g3gPUEpeP1hDhkmhcy2hNgXXXJMKdUX6VMD8J7WersJei9AiLXFPuxaihM34DX9Ai8GtHbSuBv6O46vf+tjdBwH5TtqwvdPL9r4xEIkEsDaeSNI+4dE8d0vIKrqIryyopJaQ5J9sv189fgckgOHT+5LEGXnQuPZKxsQO2ES+0v6LZZWOxAo6TmTDZRrrUuilvsRNXsoQkqf2CISJpB7F9BbKVWptW7NBFCDVCkP4vU69wHJOVkjdmutw+Z4rY3VlxTInGbGoxCirEVMAYniu90GbVeVaxtcXl1ZRU2DkGR+pp+vHp9LStLhVY4TqnfnwsVUSUPUVY2E58RKlIfsyFGCnghJlsSQZA8kDnIgQpDvxqm0sxuRDAfb4PIWUG/OJ4DnfAHIeu6VL9UB82NDmXScoqpaa9dx/DvNvnKQ69HH7H+DjrdRAkccdBsTuEIRzeurqqgwpdPy0n1cOT2H1ODhp7EEUXYioojPMS99A0Is8STKg3bkGCLuhUhke22AsFLKUUqNB05GyGyB1npDM2PVSLaLQ9P4uniIIE4dKx3b/OMsgLq6fTcqpZab/doYzXjjdpRy7kXU+CAipWrEw50IKO8u8Leu2GqteXdtNcWmpUNGssOVJ+SSFmxtzm4fJIiy8+HSVP32EyVRHqojx0h/fcw+dkfFZWYBpyJe5ZXAm62VItNS9HYLkGWk0ObW03jtcH1m7LYpGo89d3wpMHX33sXXah2paEEy/O9bi773qNmuB3KdEsV3uxt8rRPlym31bCmW257kV1xxfA5ZqR1DkpAgyq4AjXcf4kmUB+3IMXZAW6Vop4mNVEqpEUher4MEj69uqxprpNF9QD8l7Rmag20tYQt71GMkSoC58wsiK9fc85nj+LPjedONav7J5q0vZSPFMFxEkkwU3+1uaEWi3FsRZslmzzx/8dRs8rMOrRDvgSJBlJ0Pq3ra4rtNJEoO0pFjAsn7IiS7U2tdr/5/e+caW/VdxvHPc05bWtpSCx0tl3I6ODCIGCkLZk4nWeKmI9FMNLGLe0G2vdg06rLsxfaGRI3CCwNmb4YJmmZbtIozJN4Gbomi2dTIWLxm0o3Lyv0yOEBpS3t+vnh+//7/PZzT09HTnn97nk9yApz/vz3PCaffPr/nKjIX2IgmbXqB39/irMaT3tYOKTxDLWixjMYpx7RLXM70yjhtl0nnsl2f+Nj2zejn9EiFDN+tONw4a5RGso4/H742Gqz/1B31rGy79f3ct4oJZZnxnlyQ/R5CRTJXKD9QIsd7eotQT+6kc+6GiKTQhE0D8Afn3Fu32hvubTmKeotLCtwzQlgWFCw4C6dai8y5cvX4cDY79DJjO5Ai7YyyckXH5ucffGDf6tyWSWMWUV14qO5/TgyMjkxb0lzNxtUN02XVGEwo40Fw/A76lKO/Mj9QIscXkrehHt8pICkid6PDLE4C+0oxzNYfgU8AC/ywjHxcR38BVKGhg+invA7g0uXDT6HtidH3EPyZBGiat/xbW7p6py8gZUwrhTzKweEs/+zTSIsAn+ucRyJR+q6biWBCGQ+ChM4g4UrZgAknckSkEc1u96PlPK3AZ/1zbzjn/lrKRIjviLkEtPujfi7XCd9PP2OP3rVA9lf7HzyBbgHcle81fPyyHR3KYcxGCniUb58a5IY/a6xL1U17XDKKCWUMiByrg1rKQCgnnMjxheQt6Ai2i8B6dFXCJdSLfK+0Vo/yHnp0TuVJytxAxb8WFc3oBKU6/xzdPekhtE1yPCyJM1vJ41E65/jf6XAQ1D13jDd8a+oxoYwPQbx6iPDoXUeRRI7PYrcQTkQHuB9dh3DQOXfAOTfpjp5C+FjkMTRE0JZzLYt25iQJ6yqDn4pRofT8hvxiOAIc6u5JHymt5UZccFU3C+XZzAjXBtV/SLfW0Fxf3iZCE8r4kCVcO1uDepLjJnIiheSNaMnOUnQ48BBaPP5Ovq8rNb6l8TTQ6vvCo1wlTFQJKuiQI5TdPelL6HBYh04fCnaL96OrgI3ZSh6h7Hs/9CbXLi3dAN5bxYQyPgRiOIB6XQnGSeT4spw2VHCuAXehqyL+DbzmnLuS7+umCufcGbQDJ5XTxx1MaB9B31MT4fsb40F296RfQEuXdqG7W74LrO7uSR+cavuNMpKnjvL05XDiX3qSq2ZLgQ3FiAl+DiOo5xVMEKpDPcUxeCFqRf//5qLL7PtRgZzQQvop4ji6mGwZOo0c1DsMxFLQLpvARbgpJNDdk/4H8PUpt9SID8mxBQ0jWcdF36q4oCE5bW2K42EeZbwIloNVEy7TGpPI8aPZgpbEFcBadHXE/jKLZLTFcZ4fwBHUiWYIM/tNqO1ZpytMjQrHJcYKYeZ6lqyP2C/6UPky3VHMo4wXWcLunHpyEjl+HWsbGpdchorqAefcuDMipxPnXEZEzqG7dq76RFIG9ZBvoB5lLZbFNgJypgdd7g/7D26bFw+JiocVRoAjXBLfhA6xCFoc56JdMKvQwu1jwJsxXaZ1ErWxQ0TeRkVxEI1TNnJzxtuoZHKO3pevh0LZ0hAPibKjd4zwx9TBzg0bmj95773La+bUXIPRQvIPowmbGrR4/C8xFcnoSLZqYKkvIcqgQtlEWFdpGJBTfhu0LILGKONAPOTaAODQsaPrDh5593kRuQtgeHj48C9fe/UZ1BtrQwdZ/G0q6yJLhR/C0QcsE5Er6FKwYXQAbxITSiMgRyijHuV88yiNKIeOHV0K/JFwXw3JZDKdWr58z5ce/sqdwAE0HjljBMYnly6iLYjX/eM2f3nGvA9jiokIZda50Rhlc32S6inYqHgrxEOuDYAn0E2Ho2cNERHnXPbprVvX7XnxpW+X0bbJ0AfUt8z/aHv69s1ra2tbNsxrSFXNa+zYhu28MWCMUGauZxn2J+/WmCRywIQyTtxJOF5tlEQikaypqVlfBntKgnMuu+nTPx9Z0Lz21USierFzI04kuUJEHtvS1ftQd0/6F+W20Sg3oVCey4SF5oub41EaBHb0jhMn0RheLll0nNmMZWHL+p2JRHWriJBIVInvKkoCL27p6m0ut31GfIh25KQWlL8jJ8CEMj7sJr+Hn6DACLKZwJau3vnAA3k2Nwo6/OML02+VERfO1y0YraPMOseJ98O9OEvmm0dp5NCZ6ngd+CZaQhNMPQfYCbxULrtKQAOFFzc7Int0jMrjlY7PjMYoz2aGGRzWj/2KhTUkyzSkNx8Wo4wRnamO5w4dO7oH+Dxag/hKZ6qjt8xmTZY+NGmTb8VtAs30GxXKjWR4vD5yLiwLXrN4vL11048JZczoTHWcAn5YbjtKRXdPOrulq/cZ4CeEo+Twf9/b3ZN+s2zGGbFhJOs4el6P3dVJYVUZFoiNhx29jSmnuyf9UzQW+RYqkGeB7wAPldEsI0Ycv3CDIX/sXrN4DnOq4yVN5lEa00J3T3ovsHdLV69096QntEPcqBwOnw4HSa1LlX9Qby7xkm1j1mMiaeRyZSDLKV8WNL8+SUdLfMqCAkwoDcMoK71nwiROZ6qOm3fUlR8TSsOoUETkqyJyREQGROSgiNxT5P6N/r4BEXlXRB4vhR3vnB303z+ex24woTSMikREvgz8AN1L1An8CfidiOQr40JEbgd+6+/rBL4HPCciX5ysLf1DGo1Z2TqHhtp4jFXLxYTSMCqTp4AfOed2O+f+65x7Et3R/kSB+x8HjjvnnvT37wZ+DDxdKoM+0h6v2skolvU2jBlGJpMp9O/GnPjeYL69RCJSgw5h2Z5zaT9wd4GX/bi/HmUf8KiIVPt9SQXxa0yixZGN0etVCWJXOxnFPErDmDkMAafb29tpamoafbS3t4PuT+9DByQHj2cLfJ8WdCjJmZznz6ADovPRVuD+Kv/9ivFsjm190YvDWX5dU5UQtN11Oh8TwjxKw5ghOOcGfKxwovUzxbZc5pZqSZ7nit2f7/l8bAN25DxXs/3hVRf86pBYY0JpGDMI59wAk99geR4dvpLrPS7kZq8x4HSB+4eBC8Ve0IcAZux6Yjt6G0aF4ZfSHQTuy7l0H/B6gS97I8/99wN/LxafnA2YUBpGZbIDeExEHhGRNSKyE53wtAtARLaJyAuR+3cBKRHZ4e9/BHgU+P60W14G7OhtGBWIc+5nIrIA2AosAv4FbHLOHfO3LCIyGs85d0RENqHzUb+GTuT/hnPu5em1vDzIDIijGoZhlBU7ehuGYRTBhNIwDKMIJpSGYRhFMKE0DMMoggmlYRhGEUwoDcMwimBCaRiGUQQTSsMwjCKYUBqGYRTBhNIwDKMIJpSGYRhF+D9ieicxN2zjoAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 400x300 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# VAMP 1\n",
    "fig = plt.figure(figsize=(4, 3), dpi=100)\n",
    "gs = fig.add_gridspec(65, 140)\n",
    "fullax = fig.add_subplot(gs[:, :])\n",
    "fullax.axis('off')\n",
    "\n",
    "# network plot\n",
    "ax = fig.add_subplot(gs[:, :95])\n",
    "edge_cmap = plt.matplotlib.colors.LinearSegmentedColormap.from_list(\"uwe\", [(*_c, 0), (*_c, 0),\n",
    "                                                                            (*_c, 0.5), (*_c, 1)])\n",
    "ax, pc = plot_dependency_graph(ax, graph_vamp1, pos_dicts[0], matched_assignments[0])\n",
    "ax.axis('off')\n",
    "\n",
    "# colorbar\n",
    "cbar_ax = fig.add_subplot(gs[:, 102:105])\n",
    "cb = fig.colorbar(pc, cax=cbar_ax)\n",
    "\n",
    "# histograms\n",
    "ax = fig.add_subplot(gs[:, 125:])\n",
    "sns.kdeplot(y=inter_cluster_edge_list[0], fill=True, ax=ax, color=col_pal[0], linewidth=2)\n",
    "sns.kdeplot(y=intra_cluster_edge_list[0], fill=True, ax=ax, color=col_pal[1], linewidth=2)\n",
    "\n",
    "\n",
    "ax.set_ylim(0, 1)\n",
    "ax.set_xticks([])\n",
    "ax.set_xlabel('')\n",
    "\n",
    "# comment following line to verify that axes are matching\n",
    "for loc in ['top', 'right', 'bottom']:\n",
    "    ax.spines[loc].set_visible(False)\n",
    "ax.set_yticklabels([]);\n",
    "\n",
    "fig.savefig('syt_vamp1.png', dpi=400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 558,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUoAAAEECAYAAABOe30ZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC/OElEQVR4nOydd5hdVbn/P+vU6T2Z9N4bKRBqIKE3UcCCoBDrVfTar1d/Nuz3WsB2LYgaUBQEBAWkBkKHBEhIJ70nk8lk+sype/3+eNeatefkzGQSJm047/OcZ+bss8vaZX339+1Ka01OcpKTnOSkawkc6wHkJCc5ycnxLjmgzElOcpKTg0gOKHOSk5zk5CCSA8qc5CQnOTmI5IAyJznJSU4OIjmgzElOcpKTg0gOKHOSk5zk5CCSA8qc5CQnOTmI5IAyJznJSU4OIjmgzElOcpKTg0gOKHOSk7ehKKXOVko9qJTapZTSSql39WCbc5RSrymlYkqpTUqpTxyFoR4XkgPKnOTk7SmFwBvAp3uyslJqJPBv4DlgBvAD4BdKqauP2AiPI1G5ohg5ycnbW5RSGrhSa/1AN+v8L3CF1nqib9lvgZO01qcf+VEeWwkd6wHkJCc56bkopfKASA9Xj2ut47106NOBxzOWPQZ8RCkV1lonu9tYKRUFohmLI0CdPgHYWk71zklOThAxINkONGb57Myy7Ku9ePgBQE3GshqEbFX1YPuvZhlf7Ztf+X9ew/0PaOBYfXokOUaZk5ycOBIBUEod8IPWuggYAjT7FvcWm+w4TMZ31cXybPJD4Gbf92JgB0CyJhN/jz/JAWVOcnKCSSAQ6ASWWmvS6TRAs9a66Qgddg/CKv3SH0gBdQfb2JgAOoDbP/7U3lq8eJxANFMzP34kp3rnJCcnmASDwQM+R0FeAi7IWHYh8OrB7JMHFa1JbN36lnZxpCUHlDnJyQkmoVDogM+hilKqSCk1XSk13Swaab4PM7//UCl1h2+T3wLDlVI3K6UmKqU+DHwE+MlbPB0AYm+u643dHDHJAWVOcnKCSSAQOOBzGHIysNR8QOyHS4HvmO8DgWF2Za31ZuBSYC6wDPgG8Bmt9X2Hc/BMia1eg06lemNXR0RyNso+IhvmX6OAM5EHuQm4Z8yCu3Yf00Hl5IhIMBg8wEZ5qKK1XoRzxmT7fX6WZc8AMw/5YD0ZTyxG+6rVFJw07Ujs/i1LjlH2Adkw/5o84GEka+JbwC3Atg3zr7nhmA4sJ0dEeolRHnfS+vLLhwX6R0P6xhXOydeAi8z/IeS+hoA/bph/zZhjNqqcHBFRSnUCyWzhQieSBCsrAEjtqSG+bv0xHk12yQFl35CPk/1eauD6ozyWnBxh6WuMMn/q1I7/m596Gu15x3A02eXEvsI5QSlVpLWuzPab1toD+h3lIeXkCMsxCg86YhIeNpRgpTzCqb17aV/2xjEe0YGSA8oTUJRSlSaU4x3A1ftisc0GFDMlXBeLvaGUCh/tMebkyElfY5QABSfP6vi/eeFTeO3tx3A0B0rO630CiFIqiGRFDDWfAiCBpICtaEmkWqryuEdrrZUxWHlae22p1L6PPvns80CpUioJtGutE8foNHLSSxIKhTqBo3ccqqqHIlprwgOqiQwfTmLrVry2NpqfWkTpZZcc66F1yIn/KuqjopSKKqVGK6XmAtcA5wODgS1I1Za7tdbPAXsvfODfa17YXfOfKU9vNJunG+KJJ65/7OlfrayrHwQUIS/FEqVUmankkpMTVPqa6p1Ky9/8U2aBCZ5ve/VVEjt3HsNRdZYcozyORClVjAT5DkXyaBWwD1gObNdaN2SsnwcMB2IfeuKZ+wtCobveuO5qgPbZd93ftkKps4CTALvdPiAIFCulChCGGTviJ5aTXpW+om5bSXqaCBAsLCR/+km0v/oaAI0PPkzVxz6COg5eBDmgPIZi1OR+OJW6FEgDu4GXEXDMaqxRSkWAEYgKvhcob0ulmscsuMuvWr9o9jnF/N8fqEWAswAoMoDZhtQuPD6D2HLSSWx4kJUT/balUrqjUmXexAkkNm4iXV9PqqaG1pdfoejMM47tAMkBZa/JhvnXVAAfRbJjGoA7xiy4a2HmekqpEJIeZsExD4gh9sbXgV1a625zuYxzZiQCqluBSiCWaX/UWntKqSeBK5Hy/c8iYNmIVHwJAvmIal6glGo3+zmxZ14fl0xGeaLfrrTnxq8CAQrPOI2mhx8BoHnRM+RNnkSorOwYjU4kB5S9IBvmXzMMqa4yAFGX08D1G+Zf84MxC+76mlIqH6kVOAwBySACVhuA7UBtT8HJAO0IJEZyi9lXBGGKB4jWOq6UegS46r9nnfShGyaNuyio1AxP61rgl6FA4Odjb7+7DQHMQjoD5ontJeij0hfskn5JpDt/D1VVEZ0wnvjaNyGVounfj1L+/vcd08D6HFD2jvwvwtTsa95e1/93/cRxu4AWBNj2IoUHth9O3UDj/R6BgOMmrXVSKdUPSHZna9RaNz50xcVqfHnpdwFPKRVQonr/JOV507XW1wMtSikLmPlAvlIqhtgxc4B5HElfY5TJ1IGPV8GM6SS2bkO3txNfv57Y2rXkT5yYZeujI33HInyMZMP8a4LA1WR56Xhae5eMGDoPWAcsQkCyFogqpapMPGSF+ZQbj3SpUqpEKVVsSmEV2g8wDmF9OwEMUy0EWpVSAfM54LW7Yf41gQkVZV8HtFIqYLZVSikVCgQ++OAVF50CoqprrVuBeqTlQB5QYcbRdyjMCS69UWbteJJk6kCgV5EIhbNP6fje9OjjeIljF9l2Yl/h40MUXVxHBboyL9qKqOIDzboaV7XFo3PvjjRd9/IYhADXTmCUWVaCmMFLOx1XsLKjL8j8ieOqvzZ7xsguWgjocCDwTqXUJq11HcD6G96nAV7Zs7fhA489HUEYZp5SKo4wzOO3HtbbQPqa6p1MZ18eHj6M8OBBJHfuwmtqouXZ5yg5/7yjOzgjOaB8izJmwV2pDfOvWQjMQ1TiDlFKBYcUFS0AXkPYu/J9gr7/Axm/Z8pgxKa5AmjFge0As7w1Y9/+/ajSaKSLR1F+3x+LA4xVSg185urLTx1QWPCVgFJjZlf3a33z+vfe1hBPfO3Uux9II+p6VCmVANq01qkN868JADcCn0TA/FXgB2MW3PV0Dy5fTg5D+prqnciieoO88Atmn0LjPx8Ez6P15VcomDGdUGXWjN0jKjnVu3fkK0DCMi3jmNHA/ZFgYJHWOq21TmqtE1rruNY6prVu1Vq3aK2btdaNiKe8AQG+JqRJVAtQDoSBjWa5ZaHF5m+bGYMHJJG+JO0IeDYDTT9ftrK+JZF8RWvdCTC11mhI/fKNVYuByK/nnfn+QUWFtykYDaCUKlTwn0Xh0CPF4XAU8c63m/FUKKXK0p6+FfglMBEoQ14YCzfMv+ZdvXZ1c9JJ+lr1oES6a6APlpSQN3mSfEmnaXr8iaM0qs6SA8pekDEL7noNOCWeTt/XlkzVt6fSm4DPA+8bs+CuHr3utYintU5ZUEXCfvKADVrrGq11kwHVZpxzqBUBsAROdbdl1qqAScCQ29esuymtdaM5TtqAum5Npj758p69r+QHg41zBg38qNYav51TKRWIBINz/nDB2XMRcC42+w5+/4xTZgUD6iN2VfM3qLVGa/3TX849M6vN9FBlw/xrBm6Yf81XNsy/5jcb5l/zqQ3zryk9+FZ9V/paZk482f0UyZ86BZWfL+uuW09806ajMaxOklO9e0nGLLhrlVLq88BZwDbgtbdiy1NKVQMVwE4Djn4pRACxMZMlmm3zgGpEVd4H7PvZspUDdrS0nvOtU2ddFAqomSlP12xuav7LFQ8+tg4I/ODMU1rzQsH+2cZivN6XI4zWmgrUoMKCd/nzy33HV8Co53btfgewUSnVgrDjFoT1dthhDxYWtWH+NRcA/0JCoNLIM/utDfOvmTtmwV2ru9u2r0qm6n2iZ+lk83r7RYXDFMyaSevzLwDQ9NgTVP3Hx1BH8bxzQNlLYrzJIRyziyCtPA9nX1VIxs4erXV9xm8KYXVtmSBpPNP9EHU9gQB2G2LLTN+7YfOae9ZvWmnXn4LzGv307NNCWut0F95tFQ0EtyMtS60tNRwOBOrppp3A0r11ZwDTfYs0ApQdwGlA1JoZmny/ta+/4X1R4C7kWlo7LsgL5A6k78vbTvoaUMa7s6AbiYwaSWzNWtJ1dR2l2ApmzjjygzOSA8rekzAykS1QHlZpM6VUBQJse7XW+7KsUoA4gpoztitHQFIBNUC9YXvliPq+OwuwBnBxk8ELhg55MD8UfIcfLA3ji4cCgd+YYwbNh3X1jX+cXd3vy1rrcEYPl3RbKvX6hsam/0NspvkIuBeZT6H5lCOB+EUIGNqdaMD72dIVwz43Y2pFlmsQBGZtmH/N2DEL7jo+S2IfQelzQJk8eJiuUoqCk2fR/NjjgGTs5E+dggofnQqCOaDsPfFfyzgy8Q9JlFJliOe4Tmu9t4vVipEQnaTZpgBRs/MQZ1CtVflNnGUZsN8fkG7yxAuQ0CKN2DjTt65c841PnzR5QkipCWb/QSDVmEhcf9m/HrXnpBGmHPrO4tfbLhw++PP98/N/aUDYztj6DY1NnzTr5iEOqm3+wHXDjP1e/xDOBloEFI0rL33nQS5ZyUF+75MSDoc7xU6e6M6ceJY4ymwSHlBNeOgQktt34DU30/rKYorOOvMIj04kB5S9JyGcJhvjEBmlqRw0GGGCWbsnGttjGKg3+d79EbBoB7b4C2iYVMf+QKvWujGTPSJg12y2jQLl/7d89e7LRw6bNrio8EpgdnMi2fj8rj1/++8XFu9GVGZrSihBALD9rHse/N1TV132UlV+3oeCSg0MBQJLAkrddvVDT9QhxyxB4jyLlFINQItxKGXGjybNWDpeEBvmX7NDa/2lLhxCDcCqHl7ePiV9jVEmegiUAAUzZ9C4YydoTcsLL1IwayYB4+g5kpIDyl4QM5GDdAbKHjNKpVQRkgfeDOzqZtUSRLUvRjziHlJEo5Ozx4ynPwJAjUqpUjrqsxBHnECWkeYjKnAKaL/kn4/mA48iXR2DdGavEVxwe73JI1fn/uPhdcB/m3NuBVJ6wV3WCdSglGo2x6hEamLWa61tWFOXMvb2u7e9/v4rby8Kh2+wp+VzHn1jzIK73pYl4jKrB53ojDKZ1nieJhA4+HkEy8qIjB5FYsNGdCxGywsvHpUg9BP7VXT8iLXpWaC0sYYHFaM6D0MAZntXXmADUhWIHbIKYVQbs3jEMeuVIEBZZsbSAuzTEiKUNOmOpYiqH0TAHfO32aQyxn3HL8IBap3W2v5ms40SCHADBJVSIZtSacKR9iEvgRTQXyk1QHVTQNiAYb8LH3jkpnja+wqwQ2vttafSW9pTqRvGLLjrV11t29elL7aCOBRWmX/SSWDOuW3xEtItLUdqWB2SY5S9I2EEJAI40FBKqbBlY9lE+QrvIja87kByAsLmtiLe8AMSX406Xok4SOoRj3dH+wcDXFFMtXOEmTYhJddSWY6vgZAxC4QRtbk1Yx1rcvCnX6ZxtkeUUhrxCyWAGh+LHaiUakXYaUeEgAVJILqvPbZn6p33/hS42fx8KrBB/yXblXp7SGbs5IneCgIgltTk9VAHCxYVEh0/jviatehkkpZnn6P00iPbNuLEfxUdHxJCmFIQAQkLYl2yStW58O7WbBV6DLBVA2MRYFuvtd7mB0lT2yJfKVWJqNsDkMIbmw3bTClpK2E9ztaRE0YAd48JcM8G0iEEsAKIQygTJP3n3iH+4HlzPQAChmUGkRJuu5AYzzxgsJLCIDZAvQoxFdQa5qrMbq1dtbyr6/p2kL7IKLMVxuhO8qdOcW0jXnud1P79R2JYHXLiX+FjLGZihxBnhAXKFMKssr4jVUbh3S6CxkuRVMIyhHFuRsJ+7O8hpVQJAmRWzbZ1KXcC4QxwTCMMUyEguV93UerNgG8JziZan40ZGweRAtI+oO1kaMrIBPKr5kEznh2IV7wYYcLDEfCs1VrHfN5xu+1+oKw3Mn5OVOmLQBlPHxorDuTnu9RGz6P5yQNqZPeqnPhX+NhLB1hggNKARpIsjFJlFN7NzN4x7HAEYjtsQwAyjtgYUUrlmVjLSoR1tSHMLGqO14Ywxg5w1JJP3o7ELhYhzpyshh0zvgpcWE8jXQeVhxAs7EHIcEcZtzSdUy1tTOgOcw6DzF+rWyqzrQXievPb2zI0CPooUB4kjTGb5E+ehMrLAyC2Zi3xzZt7e1gdcuJf4WMvfhudZZQgQNmJUarOhXe3+FmaYYgDze8BhGnuRADLetSrEDulRpw59RjniPk0IY6kDnD0xVSWI0DZ0IUKbT3gNsB7vwFXa3vNJv7zhc4l5LqUDNXcUolKcy6rzHn0M9cjz7cOZuwJ3sbqdzgcPuBzosuhOHOsqHCYgpnTO743PvxvdOrIVADMOXPeuoQxLNIAoQWOBMLegA41dbhZf5PPwaKQSd8PAZo9mK6Jxtkz2OwzioBgAtf+wYYllQA12YLUffvPQ1ToA5qVmXU6YiMRr7d9cj0yysf5zsdmIh22aOnrYxnsXoQ9t+IqJw0CmpVS++2L5eNTJkQvGzHsPzfMv6YVeAZ4qqfFR/qC9LXwIOi+glB3Ehkzhtj6DaRr95Gu20/z04soueD8Xh5djlG+JfHFT9rXWCZQho29TyEhQHkIk4yb7QsRW2U1ouLaUmqFCHu0/XVqEOBQOIaZQNTsQkR1PaBnjjluBQKy+7sASespjyIqeVOGY8czu8qcjdnU7h4xyozjVyAvlDotpeesAyiOAGe9GdsgpVTFmuvf+5EvzZy2aGJF2ee01l8FngSe3DD/moJDOe6JLH1R9U4chuoN8pIoPP20jnCh1hdfOiIq+Il/hY+t2BAYq0Jnqt4gDHIoAmhbtdbtSqmwUso2G0sjdsh6xKFRhdgYrRfd9tux7K3F2BcTCAgGyNKczABbJcI8O6Uw+tYpNPvwEKDKFsBt1d7MZyVT7T5kMeaAIjI86tYBZI7dhDinmr9+yoyTQkr9XikVNB5yqxHNBb75VsZyIklfK7MGh88oAULl5eTPmN7xveG++0k3HXJLqm4lB5RvTewT6vm++xkliLpdjFTyaVfSDGw0kkpoQ2SKEO92BAFYmwIZQJhii2FbcV8YUTECqHWZHmmjFlchrM8fHN7xuw+kWrXW+7tyyBgA7sQUfWp3pkGox4xSSV57MWIO6CpiOABYB1D9dRPGzMNnr8xY76M9OW5fkL7IKA9Wau1gkjd5EqFBAwHwWlvZf9fdvdpj58S/wsdWQsjEPQAojQrZz3x2IAAyCmF5TbgYwjKznQXIuPmrMI6XzBhLY7usAJoyHTM+kAwiIJnI+D1ixhCie5DyS6ZDJ8gheLszxYQ+lZjjN3exjr+vEFprHQoEbNpmNnnbOHf6JFC+Jd1EVPCiOWcRKCoEILV7Dw33/QPdS8H4J/4VPrYSxmS0LFi4aPiN37zp3E9+/ZvTFyxcZAPFCxDHTBkSI6gQkAzgHD3NuHqMNnVQIezyABAxQNgPAdTMWpVBBCQVkq6YyTQz0xB7+sq1qr+VENnV7oMyShOfWYq8BLKCpJEAdC7sW9PWttzYVDPFA17p7rh9SXoLKJVSNyqlNiulYkqp15RScw6y/nVKqTeUUm1Kqd1KqT+ZRIe3LG9F9bYSyMuj6Nx5HaXX4uvW0/jgQ73SUygHlIcpVv08753vYsHCRX8ENp9y9jnfmz133h1eOr35mk/cOAcBs0E4cEoi17wNSRvcj4Bjm5Z+OvaOFiO9utszjmlT+xQZdkljr/ODpD8lMGicJoWIGl+fyVIPIh0OHZ/afcgcwIBkGcZpdLDVzXFRSkWUUhOveuiJXW3J1PYMJuuZdb91qOM5UaU3woOUUu8DfgZ8H5gBPAc8opQa1sX6ZyHFkv8ATAbeA5wC3HZYJ5EhqV4AShB7ZdG8czqcO+3L3qDpscffMljmgPLwJQCo99/46a8D8/Hb8AKBIee98123VVZXW29yg/nsxRXVbdNZUgcN4OWThU0iTCwfX81Js00YAUmNgGTa91seomp3l4Z4MPE7dILQYVrIlC4ZpZJ88TLEXJCtkId/XZuNo5VSg5H87qF722Mb/rV567mxdPofPra8Erh8zIK7jk3XqWMgNjzoLTYX+wLwB631bVrrNVrrzwHbkW6a2eQ0JGLjF1rrzVrr54Hf0UtV5pO9BJQA4YEDKZpzFpjr0vbKYlqeXvSW9pkDysOX0Lip04KBQOBGMsBBKRUIhkKln/jaN8YBuxEbZW1X4JghNh2xUxky5YrwNurOdSdteE8aH0j60hBLEWZ7gNOnp+Jz6NgCu91F9R4wa30qf5PWuqEHh1SIaWI6UgwkhrT83faNl17dO+3O+z5i9lkyZsFdJ41ZcNe/D+F0TnjpRvUuVkqV+D5ZqzMZO/Us4PGMnx4HzujisC8CQ5RSl5pnqxp4N1KO76CipN5Ax9gQralDeotRWomMGC5hQ0ZannuelhdePOz95QLOD19Ccy6+pNDc9GySGjZ6TBFiewx0wcA6ibExFiCAkqlW90MAo8G33Dpmkghb9HzrlyLsrylb/ORhiHXo+MOhMuWAp90XgtTcE5A0Yx+NmCziSGxpHRJFYJ/X+JgFdyV4i8HuJ6pkhgT5/t+Rseq3gZuy7MI6+2oyltcgRVUOEK31i0qp64C7ESdkCGn69p89HPZX6cY80puM0kp07Bh0KkXb4iUAND+5kEBhIQXTTzrkfeUY5WGIsdMFX3j8sX2InTHbOiGllK3A3dMivtbB0+GJ9tklNT67pGELlQhY1PlAMlsaYm+IhzuP7uyT/jCiQjPGFp3RJC3rhkr1R1S5AUiG0jpk8sZwaZw2j/5tK90wyiHIC9J+fniQXWWik8qyTH5QahLwC+A7CBu9GEmW+G0Ph/3DjLEN8f/oaXrF6ZIpeRMndIqxbHzwIeJbthzyfnJAeXgSAAJr31iWBH6S+aNhj9vDkcj9CMAc1NpuALEIARXPt6wMV3LMqtU2PCiOgKE2sZFluNYQ+3vCYg9BbCqj143pwM+CCxCQbNVad1sDS0khkGmImt2GsMgaJFspgVw/W53pYKaLPi/dAGWzyayyn3gXu9iHvOwy2WN/DmSZVr4KvKC1/rHWernW+jHgRuDDSnLyuxUTA9wxNrLY4FNvMUSoK8mbOoXo+PHyxfNouOc+0s3dBVwcKDmgPDyxb9408L+e5/1vOp3uuM3JRGINMG/+eXPjZCmO0YUUIffDH9eYj7x9623WjI8xxnCdFsNmWQQTdnMEwETTs2wcZcZYhYBkXTcrBpRUSjoZUefWI0yyHTExWBbrj+PsavK/beStZuaYsLDXgAsyfroAsUVmkwIOjGG1z0KvJJunvCPz/lNKUTD7ZBeQ3tZG48OHZtbO2SgPT2xFc2/+eXO1Uuq3ldXVXPzu9+6I5uev/uNPftQGbJ4vWGUZ0cGkCKn6Y6v9hBGVu916iY0qW2rWa/AtK0IAuf5wg8B7ILZKUndPs+26mGfG2B1IlgNjzLrbETtkFNf0zH/MBDJR3/ZsEnqtudjNwJ+VUq8CLwEfR1JqfwuglPohMFhrfb1Z/0Hg90qpTwKPIXUIfgYs1lKE+S1L+gjYKa2oQICiOWfR+K+H0O3txN9cR3zjRqKjR/do+xxQHqIYdThI59YJI+tqaprv/L9fPooY1GchamctAmDdtokzamoIUYn8QeVpsw/rOS6hc1fFUkxDrx5m2LwVsdlD3c1KazetM58DxDigRiPn1wCsRl4kNsDeZjqFcI6jEMJa3pbOm0wJBoOd2tWmDqO0mNb6bhMs/k0E9FYCl2qtt5pVBiLAaddfYEK8Pg38FLl3TyFN5XpFjhSjtBLIy6Pg5Fm0Pvc8AC0vvtRjoMyp3ocuNpbQ2guDSGriXoRFxRDbWrVZP4H0nenuWhcj7RGSBojLEfCo1VKGrBgByWYDkhaQDiUN8bDF93JI0MUzY+ymVYhJYF+W+FBlYiJPQeyua4E1CKNUyDXzV2Gy2T9pjI3yEIPk+6z0VmaO1vrXWusRWuuo1nqW1vpZ32/ztdZzM9b/pdZ6sta6QGs9SGv9AS01U3tF3mK6d48kMnIEgSLxmSY2bWb3t7/bo9TXHFAeuthrZm/rAATo9uBiH/cCpQbQ/FWEDhADMBGk5qJCVExbLCLuizlrAlp8gdtJDi0N8a2INYLZtrWdnhtznjatso4D40qLkeyP0ci1WYKwx1IEHBuMycEGmgeR62urxL/lupd9Sfpi9SCAQ+wGcViilCI8ZLB/UY9ihXKq96GLDVOxtsARyGTfg2NEdQjL7I/r0x0huyPCpivGfHGRbVrrJuPFLkDYVgzHNJt1D/pi96KEkOLEnskCCeBLL6QzSHbUhVSu7cUgxEm11PwtwrSxsOfhY61W7LUM43oQ5YRes1Eed9LbQeddSSC/kyWstCfb5IDyEMRM5hASIuMZILCtYeO4ykFppdQ+oFprvV0plTVEyDhs8oC6DLvkPuPsyMd5f23lnI5K30dDMtRu8HmgDUj2R5hfLT4NxcREjjbLNiIvjADChgNIILyfJdpgdg9TWs3sP4CYJXJAaSQHlG9NvM59wPf1ZJscUB6aZGamlCO2wy0IkPg9znuBaiUlxRJkDxEqNtvEkPCeEJLyWIapSm62yzfrZFYfPxpiWZ5leB7SRdGCZAoTCK+kf3ceApAlCHhuMiaECHK+HqJq+/PRbWqkDbtKGYC2bDJnm/RJXwXKI5Gdkyk6nSax3SQwBYOQTr/Rk+1yQHloklk5Z6T5W4/0eem400Z1bkfApIUMRmmcQIUIY7QhPvsQMIkg6nYhvZuGeDhi1W5/D508nH1xr2HXtifQWMT+uNIGmpsQpnxMN8mM9EzLWC2bTPliQxW5kKADpJsUxhNajgajjK1Zi45JIf+88eMof8+7e+QIzQHloYllPH61ez/CMJMcaEfbi7SBaMBnuzNi2VUcCcVoRQDItpwtQgC5tzNseixZ1G4QQOuPBIVbkKxAYiKjSNuGdcaDH0DOM4yEMGUD+6Bvv/4K7jbQPMcmMyTHKA9PUvUNtC9zBLLorDN7vG0OKA9NbEXzNKJ2lyH5yEmyT+i9uFYQQaVUwMe+ihBw7MeBjos8BCxbjjGb6qR2m5dDf4wdFWmeNgoXE7kC80yZdW3BkMZsdlWzjgXjdEawvUJeIjk2mSGZcZR9hVH2RvHersSLxWlZtAhMAl3BKacQHnjQzMsOyQFlD8UWwsC1ph2GAEgjLt6v053WWieUUg0IqDYjLCmGqNQKYWBhhLHl4WyfDd3k6R5NsY4r7QNJjeQDD0Ja6XrAWm1a5ZpQoKj5pBGzwQEvEWN6sGFEATpHBETMtt3llb9tpa+q3m+1HURXopNJmp96Cq9JEr5C1dWUXHDeIe0jB5Q9lwCm6rZP7W5AQC5GFqA0UoMUe7Dta+MIwwwg6rhGQCVuPk1HMA2xx+JXuw2o9Tc/tQJTcU6sLRmmAfsSaEbU7Wyl16yt1+aPdzhs/LZJcmwyq/RZ1fsIRJzrZJLmhU+TrhXndqCoiPJr3tvRLqKnkgPKnot9GtMI0FUgmSU2ta8rO6K1YZYhTKkAcWzY7JMk4uw5oFHYsZB5864NAFPOOuvq6KpVL7xZX7/HQ7KMrPNpDGIWeANfBo4BvxJcD/GsRnIfANs0xY7mYWaVMOalk2OT2aWvAmUi1bu3WycSNC98mtTevQCovDwqPnAtobKyQ95XDih7Lv7WtIPM/w24Se+RhQH96cmn2b19+2UVVVUfi+TlVaRTqXVr31j2559+5csLEcBpQrJwjnnmybx5185FeqKMCoUiTJs2d29bW9M3liz598sICGpcTGQeJgLAsEBbsbqBLrJofHGolklq38faLAMIQ885cbqQvgqU8V4ESi8ep/mJhaTrpOSAysuj4oPXEa6uPsiW2aVvXOEjLD5V0QZbD0ZUS1tGzQaaZ7vTPxswZMg3Inl51UqpSDAUmjzl5FP+91u//u07kWye2uMEJMcAjyKZNFb6FRSU/Hb06BlzkaybJVrrneY8NRAwJdVKkWvQQPdtIiw4glOv/cVirW0yxya7kb6WwhgyKBTvJdXba2+n+bEnHEjm51N5/QeIDBp0kC27lhxQ9kz8hTCKkSyZbRwkvW7BwkXDgU8rpTr6VNu/w8eO+/Sfnny67Tgq9HAjLp4R6BirN3jw2Iu1NKDyA7qHsMxCTCk437lk65tjPdy2AHDKt572sclcuuJBpK/19Q4HZfyJ5Fu/7V57O02PPUG6XgrqBwoLqZx//SF5uLPJiX2Fj574C2FU4UqiWftkV/F+c+i6K2E50vbzeJEpZDHFKKWCgUBwYuYy5IWRh+tFbiWb88Z6uFOYWp7GYaVw7LHD051tHzlxYsOD7OdEZ5Rh89TFU/ottYMQkHwcr1GafAZKSqj80A2E+/c/yJYHlxxQ9kyU7+8gxLbYiCuO0ZXH+2BR/4dWj/7IyhayqM0G0DbZ7yYVsQw53way2yP9fXP82Uwh2WVHTGUAYZOWySbJqd0Hlb6mekeC8rhoIHGYqRVeIkHzEwvxGqVdfLC0lMr51xOqrOyVMeaA8iCS4aW1zbJ2IQyoOzZJQ13dY1rrRu11/tmAz9L5581dfwSHfkjied5vtdbBTIxSSgU9z/uV+b8AUbeTSNqmv0WDlWzpiR4Cnla17jBB4No92JdNDiQPIn1O9Q658R+OnVKn07Q8tcip2yUlVMy/nlB5j0pN9khO7Ct8dMTvyClF1M0a89dfKOKACf759707+Y8//fGvac/TnudprXVKizQBNxyd4R9clFLq2WfvXppOJz+CpCYCoLXnxePtP3j22bsf95V8a9PSIMrf6zvbLv0ebo2vVJtZJ+D7a22WXTnEcuKTvgaUER8hjicO7fZrrWl7ZTGpGumJFigooPKD1x1WCFB3kgsPOrjYQPMgUqQ3jqkMhFOtDwBKo3K+56G//mXAkmcXPfuBT3+2dtLMmU31+2q33v6zWxauWPzKmvnHGBN8rA4g/Pzz9/29sLBsR2lp1XfD4eiempotu2Ox1rtw7W9rtWlyZqQrRmmvl9Zap4y67mUEplvHjj+n+3hxbB3X0tfCg8JB9xjGDpFRxtdvIL5+g3wJhSh//zWEqqp6c3iy617fY98T+xQWIoCxD7HL2WIRtip3hxgAmgecBSRrduxY9dOv/NctiK0vBIwDqpRSNceKQWWApDr11HecmZdX+J62tqYpe/duY9eu9Y8kk/ExwGzgCcQeGVJKBX2ZQ9nqbFr2mETKpfkzbfzHtscPInGTOTbZQ+lrKYzhkHsU44fg+U43NtK2eEnH97J3XE6kc/XyXpMcUHYjGRO6AAHLjYjabRmQXUf7tpkKvANx+iSAF4A9Ru1MKKXqEdCtwwcgR0v8IKm11mef/b7vB4PBr2qtUwUFJYERI6YEhgwZP/j11x+/o729uR8uFzsA5CulYoYd2rTDQIZKbT3cHfU7M0DQHt9m5uRsk4cgfY1RRnyMsqdB51prWl98yRW5mDWL/GlTj8j4IGejPJhY+1kQAbYUYp/Mx8UBdjghDAANAT6AxFlGga1Iv2p/0Yf95m95Zv+ZIynKCBjXstb6zDOvmh0MBr9qfg8p6bVNKBQeNGnSmbOQcy3DpRamgDylVCjT3mjOxarUcKBdEv/65nfrNc8BZQ+lr9koOzPKnqneiQ0bSO2tBSBYUUHJRZktyntXTuwrfOTFTnyrdjch3t48RF3s6MZopBT4CK5NbQBYjvSt9hf1bUdCg8rJXvm81yWTRZplwWAw9P5s9S6VUoGiorKzENAbiIAlyPkmEbC0/c0DGR5ujQCr7qKWZkdLDbt+Tu3uuYRCIcLhcMfHX3LtRJTwITJKnUzS9vqyju+ll196yEUuDlVyQNm9+IGyAHHi2BYF7fiabJllHzXLnkXaIWww2zRxIGPab/ZVZOIIj5h0AZIKiCoViHazaQRxWPXD9bqxIT5JhDHbZdbDbeMlO9klfWPxO8cyUxhz0gPpc4zSB5Q9KYzRqUr5xAlER448yBZvXU7sK3wExWeftL1egojabdunWhCwDOo6xBO+AMnIieEKSGRLy2tDwLYEiGY4V3rtHLKBpJEooD0v/bRJH+wkWmvP89LPIWBfhZxzBQ4IE+YTRtRzyx4tCKa6YIn2RdPRyTLHJg9N3s5AqZNJYqtWyxelKD7v3CM5tA45sa/wkRULlIUImLUhHu88XKodyIS/DEkB/BsClkOR1qwJnD0ys6ivRtT4iNlnr7LKTID0g5EBxhBQtHjxQ6uSycRyvx1Raw+tPbVr1/o/AZuRaxDGsUoNhE3udwIB3aAvdrK7UB9r87URA7mQoEMUUzug0+dEllDAefcOFnAeW7cenRCzdv60qb2WeXMwyQFl12JVyiJMS1nDmKwjxwLG6cDZwL+RthAXIp0UaxEgbIQuWVMzAhhFCKt8y/fjICzSAmgpAujliUSs+fXXH/9Ka2vj7YlELJ5KJb36+r31S5cu3Lxx47ILEdNBGokhVQirTJpd2YyaNnONbCHirIlo5th+p1COTR6G9DWgRClChlV2xyi15xFfvabje+GZZxzxoVk5sa3AR1YCCNuLYrJxrF0PUZmDSEmyK4FXgecQwCwDHjbb19KN/c20WNiPVA+3LSEOm2Flqu9ZQDKE2BvLEXDbDUxvb2/e9+qrj/wMGIVr9dDffL8eKQc3BilUbMOa0si1iCEefXutrHc/m+0xYM6zFfeiyUlOCAUUybTuFigTW7bitbUBEB03lnC/fkdreDmg7EZsxe5iBMD24iZ6PcLI3oeopg8hTPMc4E3EeRNBgrQPpl42I/njBUiAtq2sc0jSHUgappqHgF+ROZd9SPWiIOKZn2f+34uEMxUgHRUvDASCjw8ZMn7GgAGjRieT8drduzf+Zc+eTTsQVmidOApx/OSZc89Wrd320fEz8pwcomSyyBOeUQLhILQnpROj1vqAc9JaE/OzydNPO6rjywFlFvGpwIXIxG/SWrcrpfJwzor5CDDcjbCqdyAguhgB1zoEMP3Fag8QrXXaF4DehPTV6XFTrYMApFV1C8z+I8AOxBwwBHHSLDfnNMBsVo+A93Ygv6io/NUpU+Z8Ky+vsEBrnc7PLwqWlFR8eeTIae948cX7Fxn1O2rO0fa5KcB1kvSPJYKwcX95tZwcovRFoLSqt6ch7UEow2Kfqq3tKMQbGlBNZPjwozq+nI0yu1gGZkGgxiy3NrgPIgzyDgQMqoFZwGsIW0ojoOd3+HQnTeZvIc7ZcVA5CEiGcABZbsawQ2vdgDDlkQho1vvWS+GqlC8HSqZOPfvCaLQg3+wzaIIBCiKRvPtOP/2dFiDtOdpyau1IumO+b4x2XevEyYHkYUqfs1EiqreVbOp3bOXqjv8LTzv1qJ9zDiizSwBxeBQiYGeBMg+4COnVfQ8usPxixDb3OgKgbTi1+6AOC+MkakTUYo2wym7vTVcgaTJr8szYbUB7sxlrqwkSn4Sw4U0IKEcQ9T+Oq7O5s6CgpD0aLZiReSxzjAqt9dWIVmJjSi179hCWHUAC0y2btCCZc+K8BemTQNlNiFC6sZHk9u0ABIqLyZ8y5aiODXJA2ZVYb3c+MuGbzGSfi4QB/QNhYzHEzjcGyee217MdAaLAZ777/fwFCxcV9eCYjQiIFOBA5wDJ9GpDJ5CMmDEX4vrY1Jrx2Ko/483+VxtbaNQcs8i3XgygsLB0e3cDTqeTw5GXh83t9mcZeTgALTHrxMmxybcsfREow76nPZkBlO0rV3X8X3jqbNQxKAKSs1FmiGFyUcS2FwW2Ge/0DOA84JGBQ4et+eQ3vnnJwGHDxz3/6CNTH77rr6v37dnzBpLqlwKa//Tk0xM9z/tZIBA4H2DBwkXPAZ+ff97c17IdV2udUEq1IIDVgrNVdjh2ugHIoG/M1mTQgoBvFAn+TimlRiAq9mog7rNhlpjtWhEwaweijY37lqfT6UQwGMyaZtnQsHe1WT8fVyDEPlNKa+0ppdoRtmoLXyittTdv3rUFwMeAd5r1/wH84emn/9pOTrqVvmyjBEikHVCmW1pJbNoMgIpGKZg186iPDXKMMpsoXH/qABIWNBSxS775oS9+acl3b/vj00NHjf5LMBj82jmXXX7l/95x55e++rNfnGfWj33pf39cCLyglJrn2+8ZwLMLFi4a182xGxGgycOUK1M+8a9owFsZNdt+Cs32dYjt0WbAJJT06BmCeLL3G5C1AFuEA9e0WT4gkWhP1NXtfDxzkFprL5VKPr5hw+vbEDbabo4bJaNBGZ2zeAoBPW/etYVImuctCEufC/wCeHrevGvzu7k+Oemj0jnf2wWJxFasBNMhoHD2KQTy8o762CAHlNkkgHito4j9MYnkcNcBD515wUU/CgQCk8E5N5RS4TGTJt86YfqMCJCaNHPWh7XWmTnc1hb4ha4ObIpltJvjWyALmt/8RTW0sTUW4FII8zFhTFrrNt+2NsZxLMIYt/uycCJmnTJMpR9cCE8b4K1e/cLdW7euWpVIxDyAdDrt1dfXvLhy5XOfNOsMMtfM9v8pMPtVPsaaxHnA87XWNwIzcdlP9jMbYZk56Ub6pup9YE3KdEsL8Q1SlFdFIhSeduoxGRvkgDKb+MGnEQFJb8CQof/6xX0PfDMQDL43AwCtcyP/6g995HwgprU+M3MdI6FUMnmeUqq/UqpUKVWglIoqpfLsBweUxQjgFCAOkTwExPKVtGUoNr+VI4wwhoBRULle25YxTjPns83+btYpx3nAbWpmAldKbhxQv3nz8u0vvvjAnsWLH/76Cy/c98/ly59e39BQMxTx1ucjgfdliPodRVTtAWb/ZWZ8FQijrPa89LVa665m99Vd35qcWOkNkFRK3aiU2qyUiimlXlNKzTnI+lGl1PeVUluVUnGl1Eal1IcPewA+iWQptRZbvqKDTRbMPoVAQUFvHOqwJGej9IlhQNbxkI8ATGU4EvnVt3/3+6fCkcjYbh5Mr721dRxQ3d7a2lZQVJTOBEvtebqlqSkGnIIAks1qsappHFPCDAk52ms2DeGcJTbA2zpuUghgJXHVxqO4WpnjEZDaaLbLN+tFEJuq7VOeRtR1jWTvDEBAW8s6ur2trakfAqLDgAm4smpluMIhSXOMQWbbZjp3qgxr7UW78lWRe3kfVHrDRqmUeh/wM6Sf+wvAfwCPKKUmaa23dbHZ35Hn8iNIsZT+9BKG+IGyPalJNzUR37BRxhqNUnTG6b1xmMOWHFB2FuvtjiJxkSXA735+zz+ui0SjY7vbUCkVqN2z+0Wgbt2K5Q/OOOPMAyqJqkBAvfb8c68gtkCrilpwsIwxiDDFMgR8Yrhg7gQuG0YhQNaGy3QBAcGw2a4fDnDbEQCzNlDrwLGtG+Jmm2KEjdabY0wwv29FJsZShEFa5r3b7HcfDqwTCDDa8VsHjQd4nufdFwzy9czrYzIyTp0379q/A19/+um/ruvygr+NpZecOV8A/qC1vs18/5xS6iLgk8BXsxzzYiTzbJTW2hZ62XI4B84mnYAy4dG+7A0w1qbC008jkH9sTde5tzewYOGi8IKFi867+a573n3y2ef0B05G1M77gA2RaPTj3W2vtaautrbtL7/8eT4Q/fV3v/3QhlUr7wcw3Rc9gOcfe7TxL7/8+TikkMYYBMhKEADqjzA7WxQ4Yf4P41ifZXKjEcbXD2FuA83/pbie24VIrnYC40VHwC0fAcA2hB1a4G0zxy1USu2ZMOHUvOnTz7tqypQ5N1RWDg4CS3DxofvNuC0brjX73IMwyDCidsdw4UcJ+9srrzz0+ba2RrTWnT5mwoeBq4BX5s279sgXGjwBpRsbZbFSqsT3yVpr1ISRzQIyHXWPI07HbHIFUtPgy0qpnUqpdUqpnxgTTk/GHPWPDXmmOyQaUq7xVFMDic1bZLv8/GNqm7TytmeUCxYuOhcpj9a/vKqKG7/+zfQz/354wx0/v+X/tNbLEEDqtpaTUoqKqqqCMy+8eP7zjz1SmUomN33/s//5+tgpU705F19cPWbSlKX/+ssdTS8/tXAKYg88HeeZTiKML4VjeqXmmKUICNlujwlEzW7HqbNWjbasNGX2McZsswGXox4z27cgQKYQxmltk9HS0n6hyZPPujESyZslAK9VVdUQ1dS0L/b66088hDiFahBwDiHAayMEPFyspI2jbMKx5vHAK+l0svD1159MnHbaO34UCkU+CgzIYEVBhNl/Efh0d9f+7SjdMModGat+G7gpyy6qcPVV/VKDS2XNlFFIs7wYUgimCvg1YtbpiZ3yq8C3uvpRKUU0pIilNAN3re1YXnTWmQSi3dWWPjrytgbKBQsXDUEq/XTECapAIDj38neMHzlhQvFNn/j4cKB8f23tlqoBA046mIoz/wtfnLhuxRt1e3ftGg8sXb9yRWz9yhUPIfnfg3H2wRHA+4EXkYc7gXik95r/GxCAqcZUQUce7DYEgCywaZxdM4ALGB9mltWY7UrMd6vWWydPAgkZKuvXb+iwsWNPfmckkjeo41oo1VEpsKSk6qwJE057Yu3al4sRNXs4AuYJXHiQ7Xleas7B2lsDyAtiIcJ0k+l0cvwLL/xjzznnvO9MUNkmZwgpWZeTnssQXPQBdO7TlE0yA/+7SwawRUyu01o3AiilvgDcq5T6lInY6E5+CNzs+15MBrDnRRSR1gaqW/bIAYuKKDzl5IPs9ujI2xookTehrVjeIVpr+g8a9B/ASqDt9Reev/3Cq999c7aqJlaUUgQCgeDXf/nrWTs2bUwuefaZ4YsefmiP9jybwbMeeQs3IoA3AHEWtSCOFlu2LWbW8RBQK0EA1IKhZZzgqoRrBPhakQewv+84+xDQjeOCvvNx7RuGlpRUjZ448Yy5mbGaGdfEKy8fcA7wMgLcIOr+bqC+rKx6YHFx+ej6+j3NLS0NIACaNOuehJgxihDGey6ipisEUA/oD27CoRq7Gs/bWbphlM1a66asG3WWfbgao37pz4Es08puYKcFSSNrkHs4BHm+uxStdRwfcGd71AoiQQbVu90UzTnriPfC6am8rYFSaz0K6Z7YablSimhe/iDgDaDurt/+ugLFrXMuuuQDBUVFXcYoKKUoLi0tmnDSdG/ijJmzJs2YWfOb733nVs/z9iIPyWIENBYiakwJMB0BrzW4AhUlCGBagGw1nzAuPtKq6R2tGBCwHIirl5mPMD97graorrWDRoHJw4ZNHJstqD1DAkqpYsRWeTYChMPLyqo3T5p0xi/D4eiFSqmA1l5jIhH7yapVL97S1FQ7AFHV/SB5GVJwowiI7d27bWl19Ygrsx0wlUrcrTq3ws0Jb92ZY7LAXgMuAO73/XQB8M8uNnsBeI9SqkhrbU1B45CXXKbKf1hSnmpiYJvgtFdQRMHMGb2x216Rt6Uzx2BCZN+ePbbGZCcxzDH0Xz/6yXDEiD3yrt/8eu9n33PVbf+84/anrPOhy/2bJiYnn31O9ennX/he5I2bRIpm7ARWIYbz7QjrG42wxN3AMoTJ1iCsaynytn7NbP8GsAJ4CXgUWAQ8jxjaaxAQetb8XY/YKDchMZS7zPECCLs9BRhaWFhadRCQBNAtLfXrcWAbAjVoypQ5N4fD0QuUKeKhVKA0Gi347owZ57WcccaVj5WVVT+MA8kPIi+ENALeN6xZ89J5+/bt2GKue8qXsvnvNWte+gPSfO1t+Zx2Jb0UcH4z8FGl1IeVUhOVUrcgJpvfmmP8UCl1h2/9vyJ29T8ppSYppc4Gfgz8sQdqd4+kumZDx//7xs1CHUfdJd9WD6BylXVGA+f85nvf2Z4N9MyD5xWVln4NAbAdQCSVTK574I4F25cvfuWlnjycnud5s+bMmQS8C8k6GYyo2UOAV5Civ3UIeJ0BnIk8rK04hhk129nqPq2I6rQfF4u5BVHh1wKPIerxqzhQfQNhgi+azyJz7FXAm6lUsqG7aj5aa51Op/Zv3LjsUQQotwChfv2GTg6FwuOyBdcrpQiHIxNPOmleXllZdRqJvVtozqkScdS8B1izevULc7dsWfH1WKz1npaW+icbG/d9cPHih96/f/9uG0KVA0uf9AZQaq3vBj4HfBN5OZ8NXKq13mpWGYg8i3b9FoRxliHP1p3Ag8BnDvtE/NLeRsFeqcESC0bZ0G9ir+y2t+T4gewjKMpV+B6O2AErgfDmN9fWeOl0fSgcPsCrrZQK9BswcEJldfWaupqaM83iciD6y29945ff/u2tDYNHjLzE8zybc33AcbXWKr+gwNoN34V4CLea76OAJ5CCv7bT4zSEecVwAeCtCFhPQICwHlGpbfphg/m9AAH0JqDdl+aYj8sDL0ScKqNxXuqGmpotrxcXV1yW7dp5XjrV2Fj75pYtK3/R2tpg22I8C0woLi6fYXPOs1/3AFp7TJhw2raXX/7nE+Zc+gP/D1HbHgd+43leeMuWlUu3bFn5MmJOWIEzDSTMuRYqpVpy5dl6ryiG1vrXiOc622/zsyxbi4Blr0twywaUubWrKyeyq+UgGxxl6bNAaSavDV8ZibCyKgSAmhHAqY3HYquDweCZKqPnp9aavIKCYd/53W1/+fL11z3X2tS0AbEHbkqnUju//tEP3zHjjDO3T5t96smz5pzdv6ikZGAmswoGg2rhPx8oRVjjSAQsVyDsrxphf1uQvOc6BIQm4YLAbSD3EgREh5vzqEfChizjGmTWazDfCw1IBnE2TFufcqjZdgMSrlOyY8ebmwoKStYMHDi602t827bVOzZvXr7AjLcOsX1ONeNbkkolL8bZP7u4DwHy8gpGRiJ5yUQiNhkJdK4CfoPYLksQ0G4w55ECirXWSQMANuc+gjDLtz1Y9hZQHjeiPQJbNwHgqQCrKyfR1pomlvTICx8fisTxMYpeFGt/RFjjZKQyzXQEJGoQ1lWHMJaSF5984kEVCASyqd9KKQqKigb/+M9/vXLWnDn7ETtfM6J+FCx98YXY7T+7+YVH7/n7f2rPa9WeJKZadX7piy8kX3vu2RGIA2OX2XYCAlrDkRJjNhxoKE6Vno4AYwWipg9H1O4GxI5ZYNYvMfuzhXJLcEHlBQgg9TfLUwjorASeRuyj1gs+bN26JfqVVx7auWnTspqNG5ftfuWVBzds3rx8HfJiqcGxu5XAkPHjT509YsSU0T2ZpFrr9kQifibwNbOf7wAP4PrspMy1sWFapUqpiNY6ac7LpkYGkJfACY4MOfGL2rMLFZdyqXX9R9IWLgRgV33yWA6rk/QZoDT2xwLEtjIFsfdNR1Ta3YhNzlbY3o+EnjT/9f9++e/Nb679CgIIWSWvoCD6ya9989PBYCiFS9MrRABpy7/v+uuLd/ziZx/YsGb10w11dXX7a/duff6xR+/69Xe+/UetdTNi67kKVwh4Ci7oO4DYEPcjbDFoxjIbiSMciYBdwIy9FQH6KBJmM4XOoT8lSNhHf7OfXUjDM9v9cD2ueEW+OeZooDkWa2nfvn1t7Y4da9tisdZGXDHhNgTIqoGaoUMnNAwYMPJTSgUO+vxorfXevVsbQH/L7OOrCEO25dwCZv82r92y4CqlVMhUf7fV0lO4WNC3rfSSM+e4keD2LR3/t4111cu37z9+gPKEV72NuluE2OmqEPZl+7/sw2W/RHCeZFt/cS9Q8Z1PffLBX9z3wPuKSkpmZHvolFIEQ6FR573rXTMev+/e9chkLUYAaitQ9czDD2175uGH/ok4aWoRD3UcAekrEMCbgwD2bvM9hQDdM0hf8JPN2Gw71/EIe91gziWEgO5qHLgoJARnCGKfbEYArt4cP4io8yBgbKnzAIRxDzP7qENANogrtLEHAfQWM+ZJwJD+/Ye/GwmrOuBiCTPXgEoppUKxWGvd+vWv2b7fTWac23Geb1v0t8mcty1cnA8UKKXiWuu4kgLA+Wa7sFKqUGudrdNjn5e+pnqrmt0A6PxCCseMgtfFQLmtLnEsh9VJTligNOp1Oc72NhIBSI0ASC0y+Wyzr33mt6qR4ycEvvCD/5mVTqcHL3lmUe1dv/31ijVLX990yjlzuw3cKikrH44BRgTAapDJXYCAU6U5XtwcfxMCaHWI+n0S4sQpRcBCARMRc4BVQaNm/LYIxXAE1DTCtIYiLDCKgKJV6W1l8n3mo8z6k8z/e802KYQZzkHAvh8SslRhxlpmzqXBfGyldHv9RioVGE432kh7e8u2ZDK+fu/ebaFduzZ4WnvPIZ74SxDv9ynAI4hzyjLLBA6sE7gMojzzMrS1Om05uLBSqsDU3nxbSZ8DShMm640ZT1F+iPyIoj2h2V6XJO1pgoFjf34nFFAaBmMr6xSav6MQoARng7SqNbjUvhKg7BNf+8ZJp5wz93eBQKBQa835V17F1NmzN/70K19+c8S48Yl+AwdGunrwli9+pRyZ5I2IOrgfYUDbzRgqcKC3CwGoWkzrBfP/bFzTr1oEBNPAU2b9KAL6u8x+m806yizrj8vgiSOg3WT2YbN2+pt1B+DCh8rMeCsR55FtxRsYNHRoQ6y9bfD+fXVxhN214gLdYwi42urp5c3Ndbqw0CYHHXCPCARC/ZcufXi3Gft9SAxeAQL+cxDm/EkEPJeaa2YbrNk2tzZVM4QApm1iFsfllkeUUrq34vhycmwlPXIsSikGlIbYXJskmdbsqk8ytDJrJ5KjKsclUC5YuEghhSOuAHQymXjws+++ajWuCGwxojJWIyxnG8LebLpeEvGgluFqO+aNmjgpNPucuberQCAI7k3cf9Dg0e//5KeC3/vPTz33pR/95PSho0YV+MFSa52ur61dvW7Fcssa+yMgNhxXnGIccj1bEIAJIeASRVTnekR93Y6UqxqK8/KeYs7j32b78bgWs7ae4zScZ3sXkuXTjABKEgFMa1IYAlxq9vWCWe4hQDrLXKP6M+fOnfbf375pyJDhw6cDrFmxouWH3/jGnpXL3vDXyEyb/Q0w5zR669ZVsepqKeyT7aUSCAQi5tyeRcBtghl7HAmSX4H0H5pjrttypdTGqVPPGRMMhj8YjeY3x+Nti+rra369ZcuKFMKMbftd+4KwhT7ylFIaiL9dvOGBQAB/kEbg4Kbi4150OIIeOASAAaVhNteKfXLzvkQOKBcsXFQKfAPJ2ChA4gq/DXwW+JAx5BMOR77y/T8suO+/r7/uZ8lEYgTOUbEeYUvW6tsfqZpTga/JFQJSm7/wg//5kQVJvyilOOm004dp7f3zu5/6pLr2U5+eOefiS0pD4bDyPA+l1D0//8bX7kKcJ8W4Rlq2eG0bYie0DiGNAGorAkoBXJ9vO8GnIczRsqNTEBvcw4iaPBYBtnZEJa0x+4wgQBM2vyXN8VaYYxcijNGysLPM+GxKYyOwZubs2Z+85fe3Tg74OtqNmzSp6Hd//euoD7zjii2bN25M+rZRCCj3B4bGYq3Dt29fy7BhBwYFa+3R0LC3GQmYjwEzEFtoAwKWWxAAf9Rcg5nAedOmzf1sefmA00y6os7LK7y0uLjyfSNGTJm7aNHfrMptm6fZIiK2JmaB3EZlC4VoGUvfBM6+pnoDeIOHgnkWB5Y5WNq8N8HZ44/VqJwcM6BcsHBRFAlTmYYrd30FYsuLACilOsZXXlV19WXvv8574PY/vYEwql3mJxtuY5tb2ckTpXP5sbxgMHhOV+MJBAKBqgEDk1vWvRm74+e31N33x9u29Bs4aGD9vtraxv37v4AAThABvDWIdz2O2PdGIoBgay7uwdV5tA4Sm5u9DwGJ/YhjZybCeG3LhiGIc6cZZ4fUiNqah7DDiebcrAc8jNgaG83fPWYfAYSZXmiuU4PZ5r3XfGj+aUqYSccsCwaDRKLRwPwbPznsW1/80i4EJG2R4XGI2WAC0G/r1pVUVQ2hoKAImzSjtYfneenduzf+0Ywraf5GzLkPwzmdrB301YEDR19eXj7gNHPPO+iRUmpGKpX8OvBdnMc7gitk0o68fGxztTS+IsYGQCxY6r4KnH1B9KChHf8X5wUpygvQEvPYVpcgkfKIhI4taz6WjPK9CLj4Jai17qQWW/E8j6mnnHL2A7f/KYYAhS37ZNVD67ywzhRbOccGl7cHw6EPIBPqAPHS6fTOLZstqAVbm5sDrc1vNiPAOxoBoCACcHUIu1qPeLcnmN0os24CAbQ9CBO0jhbbD6ceUUstcE8x2ykEUM43v6fM+ikEqPaY9QcioBpC1PptZp2TzLIlvmthHUzPmXF4wFVTp0+PBIPBA6hIMBhk3ISJFbi2E62ITXQGYg7pJ/cjzdKlT8THjj15d2XloEFKqXBDQ03Trl0bf1tfv2cTLid8GwKItmFbJSYO1XxPDho0pr9pbdtpNkjIV+AG4FcI6FqwjJp9tOMiBOyL0V8pyd4TRYeJu+fAOf/jNw1CbKmzzLX/w4Jbb3qhu22OhvRJRlk9qNP3QWUh1u1J4GnYsi/BuAHHpvuilWMJlOfiWFeHdHXTA4EAeQUFturNFsTWtxsBLX9PFg8BSTthgsjkLoi3tT8SKgm/N9sx1r7xRl04Ehl87Y2fnjJrztkD8/Lz1cY1q2P3L/hT27oVyyciNjcQhmXHsRmXYtiKgEICAej+5riDETa4C9cXx9ZxXGHGbMN5piCAEEJSxVbiwK7eHLvZbDvYfBoRkCgxY9iIa/8wHQG5enPNgghjr4i1t+/3PC/fzyhBKrIHggEViUSCiUSiCbF9zkDsiVW+VZOpVOK5NWteDJr7sA/nBMrHMeEic/7bzL2pMtelP2IiGZ5KJYfShRdda68U6eeyCXF+pc1+bBUlC5Y2m8kG5tvanPblYD/2GfFXjdJkAOf8j980DXlZ2VqgKeBD8z9+0xcW3HrTLdnGejSlL4CjX3RV/07fB5WFWbdHwoM21hx7oDyWfLbLGLhsL3rP8/Se7dvXIhNxOOI5nQtchEziUxBQsA+1bYUwBjnP7aFI5GtAU0brV+KxWNOvv/vtVV/+8c1zz770ssHFpaWBcCSixk6Zmv/lH/+0csYZZ77f7KcUAYFqnPc1H5lM+xGw2IZU7nkVWIewnGnAPKTwxWizfh4SaP4wAohLkOIENs87abYbZj7F5vw8BAx3Imr1WFxqYzFiBhiJmDEmIExoN8JsNRIu9OKiJ558PhMkAQKBgBo7YULlwy++cOnUGdPHmOt8Np1BMmXOMYKwteVIea4Gcz0qcA3Oisz4rHOqCWfffQ/w7n37theRRbTWXjze+prZZqjZTwoB3u3mmocQ4K0yn7HIszAbeS7ORxxH8xAGfwZwKmLymIzc12FIlfVyJR0qQyYP2oIkuBf6T+Z//KbB2cZ7tKSvBZzrklIId3bYDCwLd+TGbtx7sPrDR16OJaP8G/CpzIVaa884cYI2d9pLp3UymUg8ds/f70Imow0w74dMIBs60oAAcBwXJL3efI988h2X1vy/n/3inCGjRn1VqcCVqWRSrVuxfMULjz/2H+dfeeUnho8dO88/lmAwiJdO844PfHDm0hdfeBLnbW/FxRiWmeM3I5NqJ8IeS3COhSIz1oFm+R6zfJBZdzmuGZeNZbRGmwFmWRoHQiuQkJoChIUOR6oC1ZqxjEVAbAMCuFsR5vkpM+b1v/if/9lfVl6+553vfc8A+97wT7iy8vKCm378k6uvPv/8NJ1bYaQQdueZa7AGeUFYm2MEeUlVIi+NOAJGQ8y1m4K8aEIIAD61d++2ZSNHnvTVYDA03Krf5jlI7N696VdIeNUQs58Z5v8VSPWjOK4xmy0hZ8PFEji7pv3Ywh5F5v8QLuspCAQrqwYWKaVsIZRMUUjqadZiEjk5dNGl5Qcsi4QU/UpC7G1KUdeSpqE1RVnhsYOrY3bk+efNfeGWu+/5bXlVv094nucppbRSKtiwv27Xw3/76y/f/8lPnRUIBC4FqN2z5/Xbb/npy+tWrtiJTJp+yKSzQcoKVx2nFJnMrQjIjENAdD/Q/IPPfWYf8pBrhHGuAgZd9v7rBqbTaZ1ptwsEg4wYO670v39yy8wVry7eufCB+3fFY7EArtiG9V7XIGywzBwzhYsFrEcYUAhhfsPM/2kEWLcjILcZAdNtCIjMxE32Meb8diBsabU5hxpznBEIcBYggLHabGfZzwBEFX8C6Ke1zv/2l7/c+trLL7V+5+abCzPvTzAYVCPHjC4fOXo0mzdutItttlMjAvD3m3MeZK7vbnOcJMIYB+IapylzH5oR9rwaUxg5mYzX1tXtfLiqauiXAwF1rda6qLW1ce3mzcsX7d+/e6Q5j+1I3c1ixEZ9NgK6G3B561FcAY98M45mc2wbj+n/hOicjhoFItG8wu4Yo8bXOuRYSF8LD9LF2WNyB5UJUAJs3Jtg1si3IVAatlgza87Z93/4i/+1P9be3m/DqpVrF9zy0zfbW1tjCx+4/3uf+NrXPzp51ilztm1YP7Rm1846hGVtQ0AFRAUN4MqM2QDlQvPd/o0i4GpZRQUCcLaIxMDd27cOGDF2bJfjHTdt2ogJ06ePPO+Kdw246ZMf/3lzY2MaF+pj0+sseBchE7QBAZCUWWZrOW425zIUUYUH+c5rD8IIdyPFeSfgwH8QrinU6WadvQgwliJqciuS2z3EN4b+CJu0oDbIXIOyWCze7Swrr6qyQJlCAL8RAbk/mGsXR8Cxwlzj6eZa9DfjsjU06xHm/AoCsjbdMgEk16x5qQle+gpSp/IMc71qcL2GTjJjqDPnZ6/3KYg5Y4/vPiQRwAzQGSwVzkZpP2lzjWyDt2Rz0/4XPS/9DaUC47KkaQaQrKJjJn3NmaOLirMuH1QeZtk2KZaxcW+cWSOPXYr/sVS9TwXGvfbcs7e99tyzTyMMoQGZIE2f/ta3PzTjzLM+HAgEoqecM5dZZ81pf+6xR+9YcPNPBiH2v83IxG9DWGETolL1wwVIVyLn2B9RxyyDKEAmSQKZHPnPPPTQnjMvuOikbAM1D6YCKO/Xb/QH/vOz5//me995Fpk0Bcgka0Em6xYzjgIzjoHI5LbhMhaY1pnPCISRDkcAZZ3ZrtjsawMSmjTUnK+NpbTtEazaWIjLqilHALXcXJ9RZpsnEHCxGT3hNStXxLTW+dkmWzqdZse2bRrHitsQNf7v5lijzPhtmmTMjCOAAKpNBlhr7s8KBCTrgAbTksDGkdoCGSFcJ8ld5rirzHhHmuOdhHPaxBHgH4xj5wq557YaUxxnBrDmEAuUQOeYS6XUiNcXL3xi1uzzx2rwzEvdxsD+csGtN715wMXKyWGLzsvPuryyKEg0pIinNJtrE3haEzhGL4VjApRKqSLgauThfQFXHWc3UPKJr33jtFlzzv5kp20CgbyzL7n0P1a99uqflzyzaDIyiVoQQBqMgEI5wijATdztCPO0zY3SCEs7GwGkfZFotHXyyacMqNtb01zZv7rY89IoFejqTa1GT5p8BsKqFAKKLbhQmj3mODa0ZzCuXFoMV2TCZtTsQdTZMsR2N8iM0Xq6S3BOngk4hrzbrG/75bQg9sKIOf5GnOPrdCRVcI9ZP4Fk7uid27YnFj7ySP25F19c7lfhtNYEAgF+d+df1Iff/Z6W+v37axFgeg1hcQORl04JAoJFZow2K6kBl7feYMY3wvxNIOmH1oQBLpypo/YkwpID5lptMeeUj4DmGHNtC3CB95VmPBtwFZOKcBlaexF22eprOdFJlFLTgLmrVry0WQUCn51x8rlzlVKnIM/bb4E7sm13NKWvMUq6AMqAUgwoC7F1X5JYUtIZh1QcG6vHsWKUFyHgsQDnWWxAJvz2STNn/kJrnfYXwlVKKS+d1udfedX0Jc8sstXK1+EcKw0Iy2w0HxueojB5wXQuLbYbKItEo/Gv/fxX84aOHl2ltUYycQJkc3DY74FAIA8HFLb8VytO9Ss3y1qQSQsCahU4x04ABwIxXB/sGjP2aWY/Dea3xQjQnW2WF5vvgxCg2mD2bQsAz0JU+Wnm9wYEVFKIt9cCbOJrn/v8ru/dogsuuOyyqP88AYYMG8anv/xl9d2vfCWCS9V8A2GJ9nyi5po3IQA1ypxTEQJcwxGQKzTXwQbuW3dmzJx7m/kkzbr2HrbjcvebEcBbiXOuTTL3wzL5UxAg3YQ48+z+CpHnoEopZdVzm88O4iWfYe/ByjdeeH3Fsud/xXEmfQ4ow12D36CyMFv3mXTG2sTbByiVUsOQMI01CFjlIRO+HJmITXkFhUMzq4UDBIJBFQqGrE0P5MGuRSZPG65bYYvv0+r724xMulJk8qTfcd0HBg4dPbrqUB6+hv11tvCvzUEegOuzPQqn0qdxsY/1uKIdCbNdMY4hlSHq9Q6kRcJWxJmTNr9bM8L9CEOcYrbfgADVSWYby5orELAYj7DJDQjgzsQFq8eBhlAwWDl0+PBItna8wVCI8y65uPi7X/nKBsTGGPaNRyP3LoEwvv4IiMZwHvo0Aoq2PJ2HC5BP4WpLBs352Awmm6O/13xvwTnIbDxkg/ksN9dvAuLoGWzuwzgE+NaY4yfD4cj+K9/3mQvD4cj1aF0Ri7UteeP1Z/66Yd2yMeZ4LyMAv0NrvZvjUPoaUOrQAVO9QwaU+tIZaxPMOUbpjEcVKI2qdbn5uhqZRPZhjAEBrbX+3UOPrNKh0MhMsPTSad3a0rwRaaEwGJmYFvzyzPcC38fG+eH7Cy47Jzh2ytT87vp1Z5NNa9duRSZTAAGIAALYq3DFgW0Yii0DZ73BKXOuluVZ1XSgGW9/JPavwZzXBrPtTFzxi03m+KMQu90ys/1wc7waM4bp5njtCJDYWMsynP1uwM2//33VuEmTuiwcHg6HLSsfYPa1GbEH5uHU2nqcHc+WSSs055ePgNZqXMV1WyQjYc7LHtyq31W4PPhiXC9xK+mMTztiu15ijjEFl/E03oxv1Tuu+sT5+fmF77YaS2EofMqpZ156Q1Nj3a17a7Y/hjDUGLDLVzg4J0dSDiy/0CHFeQEKowFa4x7b6xKk0prQgQllR1yONqM8GXlotyA2HxvaYvN2i5VS/f7rRz/9w8QZM67wN67yPA8N6vnHHvsH0kagDXFyVOOcO9brbT9BZFIWIyBUYL5PNcvGRvPyRxqHQo9lyTNPL0HYUgQBCmtDsyBp1W7LmkK44OtKXCk0uxycPa8NVyHJVjHfhFM1KxFA3Im8ZE4DZgeDwTc+/Kkbx1525VUzy8rLQqtXrGj77S0/iy1//fUVZv1hQMvYCRP6zTx1dsGZc+eGJ02dWuF5XqCqf+esCL+kUyleeeGFVuR+vYoAzgYETEpxJpM0zknUbs6rH64Q7xhc7Oc0s48EzqlmM6sSuGB163yzZgl818uaLmxvICt2LK8h6aVDkft92uAhY64tLik/GzqiLlBKBYLBUOEFl3xg1J0LfrjPXOM1yP2tVEpZr32r1jpGhsz/+E2jkU6ENgrh9wtuvemhLi9oL0hfY5TdiS27tnFvgpQHO+qTjKg6+ur3UQNKpVQhkpYXQyb5BkwgOC7EJwrs+vGXv/jvH9/5t4+UV/W7ORgMlgE0Nzbq22/5aXzpiy9chTho/onkL1+IeNCrkAc1jquhGMNV+rZMxbKZPCC+c+uWXcPHjr00c7ye5xEIBDr+Wpvl2jeWLX3zjTcSZtyNyDUsRdiWVclBJlxHJRszhiQCqPbJ7o+AWD9cMYcBCBOzoD8cAQLLxoYiKnYb8pJYDkz67i03n3vRO94RtU6Yk08/PXLb6afzpU98ovbZJxe2FRYV1fzsD7fNnXXqqZ2TaunoY571viWSSe/3v/jFWlyl+HwEtLYhYFKCgNsIRA23uddlSGjUbAR4JiOgudGcbxuuYEY7rgWEzee23vxSBCgHmePgu3464xOgswYRMON5BXh92syzv+d5ns7MSFJKBYKh8OVKqdu01q9rrbcY7acA5wyqUEpZW3Qr0HbDx741Cyk+YvPi08AV8z9+03cX3HrTN7Ne0F6QvhZHyUFqlVigBNi6L9H3gHLBwkUnI6p2+pzLLm985uGH+iET7BWEZdjYxoT5HtNaNwIopf5cVT3g9cuv+8D0dCrFX//vl59Mp9MTETX2C8gD/DASa3iy2U8M1+7AAqUFIOthLcM5E1r+8ac/LJky6+STi8vK+tkJ5KXT1NXuTT527731577jiooBQ4eGmhrqUyuXLHl2wS0/fdzsfx+uFUMIAYkorgBtCJf5oREQsGE8ad8yazpoNOdgM3yqzHg344rtluB613hm3+EZs0+pv/iKKwab6wZAKBTCS6f5zH//97h5F11Uc9mVV87OVgTDv02meJ7HjR+8/pk1K1auQACr0IyzEGGSJeY+bEPAI4W8xPohwLYGcSpVm+s1BGHGhQjI2vz3VnM+YXPPFK4KlPXi24r19l4q3//+71ZzyDPXz6aYFqF1RKmOPPFMCeKKZwzHVSKy8aP2fpaasafT6dRvAoFg1Gcisn+/Mf/jN92+4NabNpKTg4v2uv252men3LYv0c2aR06OCFAuWLgoANyKlP1Paa3V/M9/MXjSqae98KubvrnQ87x6XIpeHcIuIsAgpVQ/zAO+r2ZP2YKbf7LP/P4QwlqsavZBZII+igCNdVDU4zy8+bhmXRY8rd0yCAT3790b+vaNn/jjOz94/aVjJk+ZopRSS196sf2xe+7e1tzYGF74wD8CyETbgKhydgI3IxO3PwIeryCTvNocaxcCAPkIoOTjyr/5g+I9BFyS5jgKYaMBxDTxGhIloBGnTApRo4eabZvnzDt3TDqdJhjsPP8DwSCjxo6Njhg9etjBWEcmq0yn0/r5p59ufOPVV7ch5fAm4KqoVyLqbJ4ZbyMCZAXm+ttMH5tGOdRcu4mITdWGQ9lCHtax5Bdrt7QaR9R0ZbRqs60WZG3BNo0xhCvFZtXwfcDOlpbGe/sPGHZJlnP3Wlsal2itV5jj2qwdayP1g7ICQgMHjRwQDIZO7uJyekiu/REpntHnVO9090BZFA1QEFG0JTTb9yfxPE2WMgVHVI4Uo/wgApIAIXsjZ5xx5pmf+c73h/7s61+tQh5Gm9VhnQIDcHF2MUTFtPGEKcQedzLCSkYCnzPHeBABGZuHHcd1KrQgZcNbIjhHQisQr99Xm1hwy0/fRAz/YVyVHwtuNuZxJ+IQKcRl0dic5VJzHvsRwBhulm8z47dpc2FcXGUIV5Q3iPPwFiFsrB3x2rab8bxufrMsZwCQKC0vL1BKDcl2I6wq3hPRWpNOpQiFw+zdsyf2w69/Y7sZU425JoXmGk3BZbrY1M1ac85hXL1JC5CjEPBvNutsx3n51+BeXH6xDqGouV7FSilrtw371vNn2STNWCxLtc4igPwXn/3XvrLyfkvLK6pnYJqjaa3TWnvxfbU7v4xr35HpALSmgA6g7Fc95NhQG/oeUKpUiu6Ub6UU/UtCbNkn7SFqmlIMLAt3s0Xvy5ECyo/inDQd4nmeN3zc2KsRZmRzmNtx+cMxxHFhMygsuGlEBX0UmahDkDCO2cDHkInzEK7CDsiEajD7rcMV8B2FnHceLj+4znccv63LMlKrJjfhgpqjCHsEmezLzPcyXK/uEsR5ZTNMbJCzTa3baT75OJY50FyPNoTFpcx5D0QAo9FcPw9JdZx4/113rXnX+957XuZNOJQ6tUopXnzmmW27duyo2rhu3dYH7rq7JR6Pb0WAsBx3Lxpw4Uc2PGoJrlxcIXIftyEvNpt7XYG8RGzm1H6z3zJzrpYh2iD+/uY3m/7ZYK5VG75SaThgS5qP9aJrM7Yi81en06lTHrr/1qap0+csnTr9LK09r19LS8PyzRtX/nLFsueX4O41vmNgxmCXaYDlS5/bP3naGavD4ejELtIcj5hDp68BJankQVfpVyxACbB9f6LPAGUVWUq4BQKBQEFRUQESlNyEL4UMAYtKOr/NFTJBqpBJaNXfM5EJ8DwCltci7OMZhIENxWf3BDyjtsWVUtaJUImLUWzCOV8smCVwgGknnVW7wwiYF+AcUcW4ykHVOCdHKeLxrUdeAlGzXRPiBdZmXyUIQ6wx5zzLLNtijlFk9rMQp5KuAWIrly27+I5bf7/yhv/4+JR0Oq0DSikN2kun04FgMJBZEDebvPrSS6s+95GP7tJaR9Lp9C4ErJaaaxg252GdVe1m3IPNdZxuzrvRjDmFK1g8EGGQ43GMfry5VtXm+tuUwJQ5d5suaa/HCFxtUQtkfmBM+JZjrpcNLrcOmBnARVrrwPKlz35++dJntyLxvGuBN7J5tLsSEyVxxUvPPbR4zryrxsoiZZ05QeB/F9x60/qe7u9tLz0ByhIHVTv3J4XuHEU5UkD5HDKpO+1fa+3t27NnNZDQWqcy3sSWBWS+1a0aHkUe6sUIkxqHvLVfQ+xlVyAAZI9tw1S2IABpwaIAmfAFCKsJ49Lt/KEnEZw66JnfEoj6aJmmBbw4Lq97P6KS70dYVDuuqtHZZn97EbNCM9bR4MqSNSGZJe1I8YVmHLMMmvPejQt0rwYafv7DHz68af36Z656/zUzk4nEqI3r1+/Sntd8zfz59phdSjwe9zRUvvTm2slKKVYsXRr91Y9/8vJrL79s40HLcJ0tU2YMO3GV5PvjSp/lIUzR2hgtGBXj7IbgXgLFCMjuN9ehDWfLtemRfq9yLZ0rmGf+tQ4cjYvtnITYsCcAixAH4Dlmnc2HCJIDgCuBAVs2rVpwxtlX/E84HPkcwp73ILb5B3q6v8ORvsYoVfLgVoyKwiABBZ6GnfUHB9beliMFlD8BrvM8L2g9ydrzvHQ63Xb37377ODBLKbUH2GZbjZrQC4CQLVDgewAaEECoQ0DiVaQY60wkiyWNTIYzEJBbgqh4pQi73IxMcDvxrfpmU9sy1TnMcptJAq7/TRxhgoU41roJV7BiKGKHa0AA0QaZpxEgqMbVULTq/TAEEJMI84mbc0jgnDarzV97XBu4bT3N+x68997JD95772vA5uqBAwff+8TjZ9nwpq7E8zzQmpmzZw+wzqAp06eX/frPd5z7qetvePPVl15K49TZKGIWGICAZZ65xnGMGQCxH4cR0Nhq1m1E0k0LzLXGnG+jWWY1gFJzPWzO+H5cb6Ri5AWbteCzkj7v9p61m30EEO4xCXn51AO/M8sKkeeiLdv+suw/gIQ4XWwW3QWsvfNPP9BIu4ijJn0NKEkeHPiCAUV5YZC6ljR1LWniSY9o+OiFRR2RI80/b+662j27z9+2YcN+EFvZvpqa5ffe9vuPLn/l5TUIgFQBJyulRiuloqb7ng15yRRroC9F4vC2IoBZhTy8DyFZMQMQoDkLmdjVyIQYhrNRglMdUzg7m70W6YxxWDYZQsAphctHLsJN6H0Ic3oVAc4gwmwH4WxupWbdelwBDOuAakcmc9jsx46/yJx7u9l2DKLqNpvr8ASiju9BQKoFKH/fDdePzc/PD2aCpNZanDZpsTDs2r49HQqHA36PeTAYVMFgMPwfn/vsGeb445GA6rHISyCBy6u2+e0v4EBtlxnbKgSMCnFxszZEKorYm9MIcEV916YGYY4t5r7YkCl7/zpEKRVUSpUgLw0PFzerENPAdHOdBwL3IPd9APIM7s/cXzYxqvZ5SMHeBuBOrfWaY9WszAKl/3NCSw+AEqSakJU9jUc3YeqIxVF++QPXlgBrisvK7tRaJ1oaG6uRST0cAb61yMM9CCnDvxMHSH6x9rgUAhxbkQf8JaQCTj/ETvkbJL6y2uw/D7F99UNAZyiixoELCrdiPdLggNGq3jY90tq9/LF9JThWGMPE3mmtdxvGXIKo30Nx6XzW4VFllu9BVNAxvv9t4Q4bt5hEgDaKgMdgRE3fjgCKjSKoRdjuhPGTJuWRZQIppWhva9O3/epXLa+/sjj5ma/8d+GQ4cMPzKsPBAKjxo4dZc7bhvy0Ii+BZnOskxA7aT5iR3wNUbtHmWu22pzTRFyqYRWuL7eNIU0ggFzru/Y2BtYfW5qvlAqYRmQ21jIfl09uY2Yx12u62fepZiyLzNiakWfI7+HOKiZc7UIkymI58KzWuqG7bY609DlG2QMbJUBlUQgbxLC7Icnwoxh4fiS560XAzuaGhk0tjY2LcY6QXTj7UwPCwGoQG9d4YJhSKmqM43m4/jJtCGgEEQ/zboStVCDgOx3pEd6Eq0U5A2FsZeb41gQcwzloLABasWEm1pHjv4sBnNMibb5X4HKobVqc0iKN5hzbzDGt6WC72XedGdtlZrz7EGCwYUm2tuQ4nMr+vDl2tbkuk825aYTxjQHqWppbarMxHs/z2LVjZ+pPv/5N4xuvvdbe0tycSKcOrDjmeR6JeLzZjMmywXyEFWtzneuR+/O6GdPpCIDvNPdjHi68qgApTNGGAGIYZ5eMI/cp4rv2Nmc8igBbHLlPeUopawe1z0UDzpGizbU8yWwz3ez3TlwxlW24VrdZ54BhqhOBdyPP01PA08caJK30GTYJqHTP2GF5oXuf1zQdXUZ5RIBSKTUQiXdch6jKW3B2LMuqLAgWISxlKTJxhiMMcSwCPrYcVhsyMfMQNtqO9IkJIIB3BsJW/p8ZRn/z20xccHQVLjMGXJHYYjt0ZPJYxwl0nriYbW1q5EZzLuUI4xhqjpunRApwjo2V5jqUIADeiKuT+aY59ykIKA7G2TPLzLEbcNXS95nrVGXOoRphTeMRoNj7wN13vxoQwO50bwKBAPfe+RcbCJ948N5724JZqrcopfjbnxYkETZonVaVZjw2KcCquRMQpl+ERCTU48q+FeGcQGnk/pfhUjTbcM+CjQW1TDKBAGoSActinDkiaY7TjnupeeZ6T8TFPp6M2LFbca00mukcCpZ57gUI6F9kxvkYsExr3XzAhToG0udU7/SBL+psUlbgntPavgCUiKoSQtjiHmQybAbGGpZjPaZR86lCHnJb6KEdF29XhvOWtiEPbhRhJ9ZJ0B+ZWDaX/Ju4DBLrRT4dF6tXgWOUlu3YMCAbImRj+qwqHsDFU2KWW7CzYS1N5vf+iCo6CpnYTQhrtrnmtebYk3BdG1vNMQeZ65GHS+mrRUCyFAHkXWY8g8w2kxF7X545VttLzz674W8Lbv+753lpcDGV//z7PfV/v+PPNk0w/eQjj9bd85c7G0AKYKRSKQ3wzJNP1v/lD3+IIwBsIwqKEAAaYcbe35yXzYpZjIB4KQKcNpC+Hw5gN+JSPYtxlek9hFVGcR5zyxJtdpVlkY0+0PKDpA3FKjHHvwp5pl4y29bictbtNh1zwLzcqhCAPNls+ySwXmvdI6dPTg5DvO4zc6yEg4qiqNyu2ubUIcUJv1XpdRulsR1djkyItUDS2JTWAZcqpfK01jGl1A5kwhUiAOQ3xq9GJtYIZPKUIEykCWEDpQhQjkfsTh9BHv5JiKq1CPg+ooq3IeB7FgJKixFVqhg3WfJ9p3BAcDHOlmVBMw/ngNlixlmCMN9dOMCzOdkgzoRRuKyfYoRFB5AXgo2ntIHchbi2tO1mf2XmGrQhQDDV7DNlljfhvPdNP/nOd9b+7U9/+ul5l1xyYTKZGJFOpWKXXXV14dPLlpbV7Nrt3XvnnfreO+9c98Ovf33NEw89VHXOBRdMDIaC6pknnmxc/MILTVrr7QhLHmvOL4lzWlUgwGmdIjPNb7vN9bAqsx1zNQJ4W8zyctyLz2Y2hc15rsOBWQECsDZMzNNaJ40X2r68PFyyQT9EQzkHeVH+ydzfVlzRDvtStOYTlFJhhKXPMeu/gbDiPTZ18niR3rJRKqVuBP4LeTZXAZ/TWj/Xg+3ORGKWV2qtpx/Wwf1yCIBXWhCgJe6RSGmaYx4l+dnS9ntfjoQzZxrCehYA27XWNkhqPSZcQym1HgETWwGnFpkEVUDYeMD3K6XakYe9ApkEzbiKMw2IGtUfYWTjEBX2XMQG+CLwS+CziJNhHTJ5ksgksGzMZudY8Wd7pHFVzBWuuo0tdNFsPvvM2K2aWYDrpbMDZwIowJWAW4UARBkyecciE3Q/zhllQdPaQmsRIK7EFb0NIqC5C8eS4+YeDNu5ffveO2699c2rr7224ms/+P4wmxNeVFwc/Or3vls5Zfr0ym996Uv/ePXll0e9+vLLYTMGmw1TafY9CmefPAtfIL+5jnvNMasR507UbLMDV0quP86mugd5qVk7dB2uaO8oBEzT5pjFZjzbMC0/DKjZF5mHS18daK5DEKnpuRin9u8C2s1L247JAzCpkRMQFtmGZH3VICDZM73wKEpvAKVS6n3Az4AbkYiF/wAeUUpN0lpv62a7UqQdxkJcZtpbk0MByvwgO+uFy9S1pI4aUPaa6v3tX9we/fYvbh+WX1j0boQBPUnnQgfWsTENV/yhBlHJrSoWRyaCDQPxEHBYg2v3OhQBl0EI2wogRRusIb8KAaVRWut/AbcjEyCNTLbZyCRSOK91ZniQ9v31B0nn+ZZbb7AyY0wjQDLQ/LU55c0IY2zDxezZXOfJyAvAeuQ3IqDRjEzsNoQ1zzbHaUcAcCzCOK0Jo8Zsvx1hqXt9Y0iHI5HST/3XlwZprTsKZ9iwocuuunLsuEkTRyIAbT3H1pQQxUUo2MyYEQhYTkNYoQ3basH1CNpoxjDYbL8Hx9StSSHPXCvP7KMJF4I1yuyz1VyDlHnhWjulTT+1ZhMb7G9tox/FdX2MIyy3VWvtfx7t9v0Qu+pss94r5u/u4xEkoddslF8A/qC1vs2EOn0OeX4OFhP6O+CviDmjd+QQysQV57l161uP3u15y4zy27+4PYjYBD8PFH/xO7foTW+ueqO5qXHXv/72R9vBztoGtyGTvMk+hEqpejOOCmRiJIH+Sqm9GIAyqtZuBET6Iw/3YFyxDBtkfjLiFT4V2KSUagD+jEy6qxBQfgO4BFexpxCZeDa43DIVO7H9SaXWlmlVsRYccNqiEAVmP3vMeCfjCl2AMEltzqEQV4vSBknXmGNUmN+iCIiUm+92bG3mHIYhzKsWUTm12RYESHdMPmnajLLy8qz3OhAIqLkXXDB+3eo1z+DshzYLxoYl7cbUvTTfbUZQGa45mk0VHIG8FNebazocAeH1yL23429B7Im7cG13B5pzHIsrhDwAKDL3st6cb57ZPg8BSRsSthKxpw4G/m3GX4czV1ix5pNK5KUaNttuN/vNGjFwvEg3jLI4AzTjGS8Hu34ESZH9n4yfHkecol0d90OILfwDwNcPcczWH9Ex1o7/DgEoi/Icg2xoO3pA2RuM8n8QW2AxQCgUVmMnnTRtxqlz/qCk22IJzimxDNcjBuhoE1qHa1dgs0DK8dkOTbhNHJn8a5AJVopMuirkDZdGHn4QhjACmRD/h9hUZiGT7TUEVIfjwkmsY8favWzcnwUYjSteYT3fCRy41iPAYIPbdyLmAFtEI4BMfsvKqpAJuxUxC9Ti2rQOQphjGJm89ebYg3ChT2EEoPaY8SzFxSROwRUoTra1tPrDnw6QeCxug9tbcH137DlbT3KeuW77cXGk/ZC0zAlmvPaFM8qMZRMC/KPMuTbh0kb3mXWn45qtWTArRZ4nD+f0C+FssDaPeyiuPsAas5/Lzf82FGsf0GbMOfj2Pwpx8EWQl+x2pIXu3uMZJKFbRrkD11yvEfhqF7uwcbc1GctrkOcr2zHHInP9usNsj/HVjLHt6Pglozxgd1IYdZDVdKIA5bd/cXs5Uga/02tMKRUIBALv/ujnvzEaaNFaN5p82q0ICI71r2/Y5T5kUpTiymSVktErRWvtmbTHtQjw7MSV4lqKxM9tQkBqKMJaNKIyrENsmE1m29E4MLVM0KrwljXaCabozLYazRjtW7KQzmEtE3BOIwt4xYgqbe1urWYsdbgKQ/k4e14M1w4h4DteiW8si4FdZ86dW/adm386+5wLLrgEeQnYAPgz1q1dW7Rl48Z4OiMMw/M8Yu3t+v677oriuhkGEbU7iSs2bOMWQ+ba2vz13eY8xpprPRJhhSeZZfsRptZg9m8955vMsmYE/KeY/a0116DC3L+AGYe1ZTbjan4Ow8XYbjL342PIM7QWYah7kbTHBIBSKqSUGoQ4wWaYMSzBVDjSWvcoU+dYSzdAOQSZM/bzw4PsKvOFoLIss/U//wp8S2u97jCH/cOMsdlQMHQw3NU2B0hh1EFNc6xn3vLekLfKKCchwJBVKvsPmIqLWcS8iSyIdRLDFv3hJG2YohHGgJwpCQRctyEAGEGKMsQRdaoOUSNs/nUIyc9djWT0xBHwGoEAmr1bQZy91DpxwNVMtA6gFlxlnQIcwG8z+5yAUy924Zp/WVubDTjfg4DBILNdPgL+Neba5eHiDhNm/Z3mu8ovKEj+4Z6/v/9nf7jtmcuvuuovt/z+1lv++tCDZ0+aOrUOeRhHonX7/3zzWy8nE4mU53l4nkc6ndZorX/w9a/vbWpsrDT7KzZjtFlJebiohApzntY80IhzKm0x18GaEcJI3/ZzzX181WxnTQ0Rs486XL64VYWt3dd62lO4aAPPXLvxvmu+x9zHi5GX4jKcvTZmjm9jI4cgz8Y4M+alZv/7bGX9E1yatdZNvs8BareRfcj9zmSPNtwrU4qRl++vlFIpU5fhm8BJ5vu5BxuY1jruHxtyH0VCPbcAhoOKoEGtlvjRA8q3aqPc092Pm95cFQDGKOmhHEOYyFbgAhsmlLGJDSovQiZmM8Zgb8JBGqxaZBqPteCKGxQjD8CziPq1Gpn0JyGTzHqov4mo4lNw3QRn4jzdIVxBBf8bVuHiCK3H24b5VCKT1toSh5ptdiKsxnrYm8z2UQRQG5GH1WbitJj1rKpqwbkG53G3WUVxoPI7N//0a9NPPvk8v21q3MSJJX+8957PBEOhQDKZ1K++9NKGH9307dfed/ElDe//0PxJI0aPLtlbU9P+8D/uf3zJiy8WIQHa1YiNstKcUxxnyrCseQDCEpO4DpFTzbVaadYdhXP+nIkA43pzDoXmWowxy9aYazUAVyjEpiQOQABxuzm+fWlEzPj6I0C7FnkJvdvczzqz72ZMsRMTG9kPeRZsvKfVHvZwYErrcS1v1euttU4opV5D4o7v9/10AdKLKlOakPvslxuRF6G97ocv3fT1zhSlFHlhRWtc03qiAOW3PnPDxm//4vbnEFtPx7601l46nd75r7v+9Cyd27fadLVK4Cyl1ErkIbV5vTaIG1wlGBsuU4Z4xOt9NqQkMhms/QrgX4hadToCmjMQRmcDtVuBXwE/RlTvzWaZtfvZDBIblG2dO8qMydokG3GMvB8uxa8alw9eaPbbbo5hAWijWcfaSNvN8jLE+WNfKkGzXRjXt7wjZa+8sjI259xzz8qcKIFgUEWCwRBAMBjkjHPOGXf7P+7rf+V55z32o5u+vREHEo0ImK9DIgEmIXbICM7rbBlz2lwv61wKIS+mNxCGdioSVrMLmVSWsQcRJmdttTa75lVcSutEBEBfw1VPL0WAbTsuDXKouS7FZhwrzT2Yb/5uRF7Ee3A1Kofg2tfGkLCWqLnWW/DFUp4o0ktxlDcDf1ZKvYrY9z+OmDN+a/b5Q2Cw1vp6Y99dmTGGvUiPq5W8VQn3XPUGiIQCtMbTxJInjuoNcB3ygIJRsxPxeMvmdauvi8faraoaR970W3HexcE4x84wBDSG4BwfCeRhLjPbWydCpWGXmBtoPc91Zt12pEpMsdlPCxJEXIVMGBua9C9k8o3EsUgL6AGc19s6dwLmtyCuWGwRwiBT5lxG42pQBs0Y0rjyaG3IJM7HBai34sKeTsZ1jMzDFQW2oUFxxAi+F0ifNHNmaSQS8XsSs0ogEFBlFRXl13/s4zbg3XrqQ2acm5AwqlYkiymOeLl34kBR4XpsV+KYszWnhBCGUWyurU1HHWT2uwtX6m40vv7ZyAvPho1tQJ4TjbzkJpj/R9C5eIkNyTob0QhWI8D9Ju5FMBRhuNPM+o/hYmCtycOq9SeM9EZ4kNb6bqSVyjcRc8XZwKVa661mlYHIPTrioiOHVtwiYnrkpT1IpY+O3+0tA+W3PnPDdoQFXQ58pWb3jo//5Bufue3O392cRIz9SQQYrCE/goTIVCFv9C3I5K/D5fb2RyZiBfKgj6BzSEh/5TrfWTWwAZmIFcgbchOi+j2CANxwhMmMQkCrHil0EDHjCuMApBzXO8evftuA7Gazz2KzL2X2OxQHgPvNdnbfdpl9edTjgHA8wsL8qrmHa2dRj4BXsznG2cC81155ZVIikejRa1VrrafOnDHQfE2Zc7OgEUaY9T0IcM1GXlqbEODZh3N4FeKqvw/0Xae15v/3IIH9i5H41n6ITdhDbMg7cGmX9rokzL4Gmeu722wfQkK5JuLsvUXmWDaP/v1mn3vMcvsCq8Y1M1uNRD2U41pw2HvdKY3xRJDeyvXWWv9aaz1Cax3VWs/SWj/r+22+1npuN9ve1CtZOXBIqjeAvzRBInV0gLJXMnO+9Zkb0kjr2IcBfvM/X/8AYu94HVcEwaq1AWQynoVQ+x24uEBM1kQJYsPrj7CX/pgiDrh+LeVKSpnFcE2kmhHb1hbgbiQkYRYCnO9C3pzTcKxkF6ICXoYrfGHtqTbMyB8ulIdMWOuNLkMm3wCEIYMwFxsCMcYss8brJC6jZgAyoYeb82tCANcGfNuQngoETBvMMWzY1JDmpqZpD//j/sZ3vvc9Zf5e1TpLn26tNQ3768O4thohs99GXE3OJiTu9F2IqlqMc5YpBPQqzPXYi2PfloG/ZK7vxQhrfBn4BwKc5+K82vvMMUeZ/WxEnocJuNCkncj9Os+suxB5LtYBZaFQeFwoHPlwrL21BGG/28y174/c30lmfM+ZY1QjzHYfnZ10JyxQ+r+f0HKIqnfA3y30KEVyHYkURhAW92XgLK31U0qpOlwlmTjCXhLANKVUM5JaZlMdUwBa6xbjBGpEgMGGxyhche+xCIDYWLs0rlDvCkTNPxdXfm0YMnkn4+I263GFdP2OGmvHCpkxJXFVbuIIYA1BwGugGZsdC7iMmVJcMHvE7DNixm9ZbjMCniDgZFMdU7hGYwPNuZUgYFQBbPj1T37y3bkXnP/R8srKC7u7IcFgUD103311OAZts6GSZuyN5rjNiEH/XITlFpjrsx/X1zof11ytBQEqzL4WIy+nyeZ+PI9ku8xCXhz5uG6V23F9cVLmeiwy12iYOfcYrubo6tPPunzN8FGTvhgOR64JBIKh9raW2i2bV21a/OKjT5l9hRDAbUeCzm1wf5PWep95EVux9uccUB5D0aFDBUr3fw/rabxlOSJAqbWuU0q9DMxTSr2stW4zgGiZUgCXu+shIUDWgZLyjUshE9Ha+IJAvcnU2YNMDOtoaDPbRpEJWYtUPv8q0nxsNcJgBuGCye1+bRmvKhzYWpArKiwu0WdfeEVk5NiJZaFQ6IaW5sbo3X/45SutLc0TcK1rd2bs19oy0wi4DcQ5KQbjbLRtdA7HsWmSzbgK3OW+8xppjvd74Nm6ffuC5806+Xtzzjv32RmnzB6XTqd2XPuhD83LLyg4XWud0lqrQCAQfPj++1c+99RTe8z+k7jydIUI4FsgbzL34SGczbIISJWWl+t3XH11QfXAgRU7t21LPfD3v++Mtbfb0Koacw2WIur6RQiglyKe1SUIEA43+xyIqPbbzDi2mvVHI064Wea6LUMY/45QKBwcPnLS05FI3khresnLL6yaOPnUrxQVldU89fhdbyAAuwNhkiXmU6+1rseJdc6By/cOZASl5+RoySEC5bGQI8UoQXK9T0aYyUPGU92mlPKQyboNUasCuFJbheYTUa4ZmGV4CgHFMqXUfq11Wim1C2EfebjCDPkICFUhKt0KJJ6yAfHQzkWKAJTjVG0/qNkA78oRYyY0zjz9nIETT5qVFwqF85RSaK2ryqv6f3r+f3716t/95KaHU8nENoQZtZqx5iF2RIXLtrHOCxtiVIxz0LQhL4MQDqgaEJC0YxmAeIA18Hekj3kKAaERQPVzC5/a+NzCp+4C6u/9y53/9+d//fP0UDB4+bYtWyruvv2OrY/8858xBBArzDlHcEWK68wYBuJiIxsRG24rcM6pZ5018Ke3/m5MXl5ewEunCYXDpR/7zH+O+o9rr3txw5tvgmPHKSQVbiWiwl+BVHd6GFd4uB0xzVyNAOE2s3w8Yn+1WTr1QDIQCDZMnHLqlCnTzjgzmpdvzRmAK5Lcf8CwzwHfMvtbjjD2QiQdsdm/CZ0bkvkTCk4I6WuM8lDiKKFzRHzgKJ36EQNKrXWzUupZYK5S6gX7Rjcl1tJIDN0FiC1pFa5smXWYVGJ6xWjp2NiK645owVID9SYgvQiZpDtwhRNeA25D0uRmIyrlHESl3IqoZDbrxcOlJBadPu/ikovedU2l53mdHkz7t9+AQQPPvvAdlU89fN9qZELazJVi5F76gS5qzsdO2FZc8LRVeQO4HuQ282UAEnZTgjCyfyDg65nfhiIg/wYCDjGgqGb3bn3hKbOfMNuchjDpKpyH3b4QbNZLIa4Q7zZczc8osCw/P1/9769++aVoNBoIBAIdBTVKysryvnfLLbOuufTSh811L0I81f3NtX/Y7O9axG75PMLo9yG2xlY6qsOrvSfNPLti9NiTTi8oLP5gIh7btnb1kmc3rFu6/dJ3fnR6YWHJEJOVdQAwKKVUNJo/vH/10Of21mzfggB+FKn+08aBcgCjNNf/6OXEvQXpa0CpDxEo056DylDw6Jz7kbbNPIOwiE72M1PfbxfiqRyBTPYSBFQaEXYDJvvCVBNKIABi2VCZb392G+uBbUGAoQIB4VeQCTkUYUmlOI9vhe9/gKaSsvKWC654TyVIlZ1sD6L2PD120rRROFCxmTNbEaeFBaVGBMCCOKeHZ363nv4Yrh1sGAGTs5EXyX7gR0gK5m5z7uMQhlqL9CFa4gMEO9kjdK7XaAPYrS21Fbk3rTgVvxIBmRACfMuBVV/9/vcaSsrKwsGMnNxgMKjGTZpYNmrsmKG4wiC7zc8zEUYZQdLfWhGnjg0st+FWS4DwOee9+5rps+bOLCouKwwGQ9G8/MIxM06e95ELL73+2oKC4sEg6nFXoKC1jlVUDdyB3OcwsKsLkPTvwM8oTxg7ZW95vY8bCfQ81xsg6XudhY8SUB5J1RtkUiwELldKPaO17sjkMXUBVyEMxHrDC3CAFUcAL4prImU93ABRpVSJSYeyDNaq9Qlkgg5HQPJxhJldh8QLrkDMAm8g6qhNj1NAcvrsOe1O8+9ClNLG2WQNLK04kG5FgLES55SJIeDdhoDpZlxv7og5vxZE/Zxs9nEHEmJjwXUkot4mEMZmVX5bMNmKtfNacLYnY88TXFB7m1nWjlPBS5CXyW5gx7iJE7stglBQWDTZnEctwpJtrn4rYne0DHsAEj60ZciwccVjJ8ycWlbeb16svbWuX/8h0815YM9Ha01JaeW4gwGB1jqttXf72lWLB5pj7TpIsd0OSmIyvOAEAso+J4dQFAMgaUKCgoGjxyiPKFCah/BlJPTjEqTatF/WI/bDMlyDKKsK2lhH66Sxjg7rhEghXfnS2vR61lq3KqVqEJU6iICKTS182oxhGqISzkacIzY32aaxJUrLKw5q1FdKBdavXr4aAZdGs5868/MQXCB9Che2koeonGsRVX0MLkOmGLGfhhHWew8CNCkEYIbhnGDbMEHndGZIljVap1kQl5ZpQ5ygs8OpHQEx69iKIWDXH2H7o397yy3Rm2+9Net1aGtt1RveXBev6jeoOBSOBGtrduSl06lWXPO4Tbj41u1AZMLk2WecesYlA23P8eLi8pHZwLA7gLSZrAKo3hvPLLz3N+Y4XRbbVQfu0ALmCRUi5Dd/2O8ntBzi+GMpmZ4FkaN33keaUYI8vE8A71VKjdRa+/NCtyHsYwRSkbwAF8dYbP5vNt7INqVUDAeWxWbfyoClBboWBIAHIwAzCAGER5G0xgsRj+4S838cOlqkAnhKqeTBWMyubZs3P/v4g39GWFeeWZyPhKYMxlX/8RDQTOKyRibhmGHSjKsKYboLcKXTShFWbNMGtyBg3JplSH4Hhc2AsSYBvz0u7fvY5XkIYEbp3IBtI9Cy6PEn2Ll9+xODhgw534KNtRX+8Ve/T172zo9VFxWXBQFSqWRizcpXnnl9ycI9CLhPQ152dUBLQUHxqpNPvfAsrXXHBM8CYAcVpRSe5z3U3tZy+7/u+82qeLw9hhTbPRzP9QmXndOn5GDam088rYkl5FH3l1w70nLEgdKwyqWIE+VSpdSvfYUtUkqpzUjTseeMw8YWRbDe6FKlVKOpPmIB09oqK5DJnaeU2qW1ThiVvhEBy2pcCtw6JOzkSsQTuxwJU5mIa2IVANJNjQ1t2ZwGVta88epd997x2x3pVGoeAl6tuOo3pWZ/O3ElyJQZTxjxXhchLG4EYhPcidT6W4prFTHS7KsdsRfWI2BjAc6ON5MVWRYZMMex3nSrgnu4XHRrG47jWvBuRoDaBqbvA2Kfuv6Gz3z5ppt+Ov3kky8sKCwIxWKxugW//n1dPFY4rsDXRjQYDEWmTj/rgkAg8D+vvvLEk4gpAXO84UOGj5scDAZ79IR3dQ+01mita59ZeO9Htm1ZU4wrV2fPryvpE4yyz8khuK7bE7rjppUepTYQcPQeDg9hdMMRNuWX9cBQJdWEPIR9WIN/G8K6CpVSxb4cb1uUogYXWjPcrBPEAdUOBIhsnOAbCEu6zBzblmcrKCkr9wYOHRHMyy9Qy155rklniWTVnkd7W+uWv//p139Lp1I1iMnAFl0Yj8ugsTX7hpvz2I1M5EEIE65AbLNFSL/p/4eopYPMfs5AzAf7cemdVq23pgeFy6gJ4bzUeeavLWZhIwWiuL43hbi89ZjZd725lnXmuDXm2hcARds2bw59+oYbFp49deofLzn9jE+dPXXapdu3NKwMBoLar/pZYJswafaXSkor5yHmhRnmfOrD4eh+uhHj2fbMC6/L1Zoa657btmXNYOQ5sGFY4R6y02yAmQPKYyWHoFC0xJxVpbTw6AHl0VC9Latcj4DUJUqpNT4VaT2m6Riw2qxrGVoU5xgoRNhlm2GX2jBLO9kLERbUhHME7ULU4ArziSM1KW9CquXUFRWXtlzx/g8NGzvppAqlFKlUcuqS558a+/i/7tYXX3mtss24PC+Nl/a8R//x18e19kpxFbpHI/bG3QjI7ERY5AgEsN805zIHl88cRtL9foS8DCw7HGDW3YIAQBJXRNeq9x5OvbapeJ7vN+uFzzPnPAgXUWAZV4tvOxuqFDbL8nG2zkbzewniaS/0PK+hZvfuXUC8qLisqquHPBAMhs4+9+oLHrr/1gdwmUibdm5fv3DW7PNP9+XqA8ISU6lkS13trqcLi0qKYrG29cUlFZdEo/lDMsFPKaX21e58HXnR2PhVqxXYsKds0h2jPCpzISdZ5BCAsqndEZiKvgaURtJI9ZYbkayLJQBa6walVC0CLqvNutbL2obrt9OETOJCJT0/Wg3raEVYWrNZz8YJ5uOaZYVxqYRvIBVqzgK16IM3/tfIftUDg3YuhkJhddo5F+Y//+TD3p9+8cPYrDPOiZaWV3n1+/buWfz8wqd2bdu8A5n0FpBsgYgd5vscc+xGBPBCiIo/waz3hrkOtgRYMx2xhOxHVF9bem6/b/+2co5VoS2w+Qt2RHG54MXmeqRwoUq2yEcC1yzMw3nJ7fUL49Ry6xSrxhXBGAUk4u1t+woKiv0xiR2ilKKyauDgisoBan/dnucR0K5vqK99qa52V/+q/oM/aV52SmvPA6XeXPPqn1575Yka8xzsmHfB+wYOHT5+qF8F11p78VjbptcXL/wLApQjkZettbuGjM26KxU823hzNspjKj2/9P4+OVXFRw++jtqRzKTYgTgsLlRKLfOFcKwHptosC9zEtYzHesJjGFUcH7v0gaVV2TWuEo9GQLIKYXt5iBng05NnnHJe9aAhRZljVUpx2jkXqGcff9Db+uc3bUjS84h63IiAURHCXFYiQHcWnRuN7UfUzQsQVrcV+COSsTQAeTEMNPtqN/uxThgLlDZ43dbI9Hz/5+MAMYyr2Wj/2vAcG66Ub04vhHPc2LjOJK6yUymuh7jNkBlg1rcstxFo2bRxxd9mVVa/K/P6+aW4pCJvf92exYgKPwE49eF/3rZs8rQz/j556umjA8HgsOam+totG1f+ddWKl5YhDH3ovAve98FhIya8Q2tPKxXocCC1tTa98OSjd/6svb1lCK448xBcoHzQXIP4gaPJ2ShPdPF3Xqwu6YNAacRDYho/j5RAW2SW2zChalxr0w5ebXLFrTppJ2ohPnaJTOgCBAQKcAUldiNxiaMRJqmB3R/4xBcKRk+YOqirgYYjUTV99lmqqv+AUCqVYtObK9XGN1dZhmpBJoYrptHfjG01Yu+bgWTFtAN/QGo0BnEl3CoR8F6MqOdhXKiOncDKdyxbps7aF+31tI6vBhx7tvZJcFXDLVu0tswC81sVrtxb0OwnZvYbxzX4akfYbwNi0oivWv7i3gEDh982ZNi4j2e7hul0ytuze0slkqr6DPKSnAdMW7X8xZWrlr94G1KlqAFh2mOAlv4DhuUPHT7+XQAWJO35RvMKBjc11tmohpHI/a3GtaiwtspgF2FCXTHKXL73MZBEXiGRHoYHaa2pa5FbWpQX6NSR8UjLUQVKoyrXIWr3PKXUK1oahdkwobE4oLSeW89sGzepj9aGZgO8C3DVuOMIILQjoJLGeW6rMOEyH/vit94zeNjILkHSHI/L3vPBgnQ6BajImedd8r43lrww4v6//P5xXJZQhTl+gTmHUnMOIxFAXINk1LyJy/MehgDUDmRiR8z2e+kc9mOr7NhgewuK9XQuKgwCcLbQha0OZAtC2P8jvo81RdjsGFuQxDLIJuTZyMeFCnm4PuVbMG0jFj72t5cvv/LjF1VUDhjmtyVqrVm7anEsHmvrh7wwCpEsqX3m+pQhL4siXKHe/UBy/MSTTyO7Oh8IhcKjps04p3LZa0/XIy+nuBmvBctGHKvMBEprqrD71hl/D+Y1z0kvy/qZlzCjhzbKpnaPhCnUO6js6BbSOBbqhocEVIcQdmGbjm3GdWe0QNAJyM16bci47QS26mAR7kFXuI6OYQRcbMGK0MDBwy7X3dSx85OKYDCETd076ZQzT51x2pxyBMxrca0fmnBFdc9CwO02pHq0rUI0EmFMeQjIrEXA1toBFQLmQxD2OxgBE1sUpBHXn9q2g9iLAE+TGW7U7K8fAiK2ALIFWwuoSQTsU7j8dmv3tMDZav42IQyyGTFdWFZp70HpE4/85a5dOzau8jwvbe5T85url2x8bfGT2lyTMKJBvANRlfcggD0F16RtOGKKSAcCgW4zgQIBZUG73Vz/AnMetvBvEvH5ZCMC2W78CZfG2Fekvbjy4CsZ2dvkHoshFUcXKI+6p8+wyhakDNbZpmCGjXu81OR1ZwVKs31aKdWGY1sxU7syQudslHbz19oAm4BRSgW2BYLBvMz9+iWVTBHOUp7e8zzvlLPOG7/05efeRFTrGMKSTkWArRlRpWuQECFbS3GgGVctwsYCyISuQYBpvPnbiuscaNmQtbOCY9kluJqQQVz4j4cLDdK4+MICXBm1JK5+p2XG9loV4tTtPHPt4mZMRYiaW+G7roOA0nisrf3JR+/8Z3lF/8+OGjMttXnjyr376/YkkOD5WcUl5emp0+d4xSUVk9rbmhMb1i1bumvHxmeRyIAQYp9Nm3HWrlm1eNXwkZMOsBtqrXUymdix7LVnbD75PpwJo8Gc8yCcvTJsHDv+69dpl+bvCVdB6O0oNT6gHF55aFXR36ocq5AIW9D1VMTZcS+dw4TeNOtlHZ958Nut3dKEmtig6QJcNR9bSTtq/i/T2mvW0oXugCuttaZm9/Z0aVllIByJZFH9AK2rkGpEDeYYp+JAbx1SGBjE0z0M573egDheZuGAO4ZrlRFFmJbNOrKhLtYbHcFlJWWmIlpwDeB6f9uQokKEseXjQLHdt09bJMPmrfsdSRas8nzrlyD3CKTwhc1T31S/f+/61xY/2Ygr0vyZ6oHD7zn/omvHBIIhAoEAnufpEaMmX7j01aerVix77mkEeGfjnFmte/dsC25Yt+z5seNnnG1ejEHJ59Z66ZKF//K89CzEdGHZdB7CvltwbSB2kz1c6AAbpXE05mIpj2PRWrO7QW5jKAiDyvs4o4QOVhlH8q8vU0o9q7Xea8OEtNarzYPb7fh8dss8ZFK0GXaZQJjGcNxErjX/V9TV1jxT1X/ABRn7AqC4uCzQ0tzoRaJ5wcxqOaACmzes3Y8AywSEvWxAnBTViFd8DwJUYxG18xVkAvc359OGAGcLzhY7EAHfIThbo59J2lqZ/r9JXEiMVafDuELE/spBKZz3PIErmAEuPtMuCyKmAstQ7b5aEIC1YytCWLQFeltmzR5jfyAQTJ974TUhC5Igjc601kyfdc70DW8u3dfe3pIACoeNmDBixsnnTi4oKB4Xi7W1bd/25tMb1i3757AREy8KhUIDUqnkGyuWvfDvtauXtONMGdW4zpoKF/mgcXU2Q+YZ8avcmTZK+38OKI9TaWz3aDOpi8MqI0etGIaVYxlk6yFq6plIsYrb8YUJ0bnSeZdi0iCtKl6olIoZxmiLYwxHVOLNkWhe5VnnXTonmYgXtrW2xAsKi6L+fSmlKCwuUQWFRUENeF6agCkB5XkeLU0Nbc8+9i+FlEDbYcZchgDInQgzmoOwy+W4AsLtCHjsQEClHwKiEUyvIIQJhxGgtSmaFgzx/bWB5pZN2mWW/dnfrTNLm48Nt9K49EXLUm2IVAjXTjZlltvr2IwDyTTClm3Y0R6zXgBh2REgb+ToKeMikbwRmfdMSoMFAxMmz25d+upTpUOGjZt0znnvGakUWqlAIByJVkyeevr1Wns/veO2717rO2YFEqpkq0qVIC8sy9htdICNH02a62vL70F2GyXkQoSOa9lV75SC0f2j3ax5ZOSYAaVRqQK4ghnD6Rwm1COgNPvyTJZOFKkolKSzrS4+aNjI1Ps/+tlPF5eWjfI8T2utFUAqlSQYDHUuhBoIoID9+/bGyyurIqlUitXLXm158l9/3xmPtRcjsZArcdWH6pBiwNaJlIeL45yJMMXtCGincCXNNDKBtyEAYMNzGnGTNrOQhTXU+Itf2I8NQvcHjVtPr/3Ya2NDsGw9TBtfaffVjitMEkE80wXm/ApwL4Ai5KVQj7B2zLELItG80Qe5c8XFJeW7Tjvz0jOVEXBFMpQKfPHK9376D/f//Vc2IiBmjm2ZYzuuonwxUqkojrBq2/JjjznHbLEkftDMBZ0fx7LDB5Rjq99GQGnE5l/PQVqa/h4XJrSTQxifsVvGzByrpnOR3H3v/dCn3l9UUjoSRP2z24W66Nehtaaiqn/0xacf3fX4A3fZUm1PIl0bxyOVhxoQdjMdAYrdyIQejsQO7kS8+aUIs1mB875bD34prjdQmfm+HwEBqzJbu5r9WGZn2zlYscwriGNUcfNJ4mIhPd+2VlVtwmXzJM1v+3Ee8AYEYDXCGm0s6x6EzTXg6nCmgYr1a19fevKpF+xWKjAwMwVba4/qgcOnTJ0+5/yu0rO11rqouPx8JA610IxxHZJOab30YSQMazgSL1uLvISsep40yzSQttlAWQ5ny87l5DiTREpT0yj8oKwgSFXx0b9NxwNQBpBMmQ8hAGnDhLbiAqt7JMZjXoazq1Wav1tKSst/fCjlvOyqZ8y7eNBJp5yp47F2vWnd6sKH7r79ZNBDcYyv2YzVBrfbdMYhyMRej6iuoxAAt2XmbErhDlzPcqs62jCejuHg7I3+vx0quAEAG5MJjonaPOgEjsH6A9Yt6Np8Z6vyF5hzK8Gp/RacIr4xrTfr2dqZINddp1LJpjdXv/rnCZNn/5dh/UHzNxCPx/b36z90wMFuieel0wjAW7NAA2KX7IeER9mwIPu8jDK/7ULMAuNxoG+zdbLZKG1WU06OM9lVn8R2fxg3IHpMKrofU5uMYYEeMtk2IbbKDbheMD0CcqO1FSMT1KqN1o4FUKfRhYc5RgqLilVFVf+ik8+Y+6EPfearVyBq9BNIDc3lSIGLHTgvdRMSNhRBQN+C6HBkMtbiYh/DCMA0I6y0EFHDbV1O66W2qZQ2/tGq4X511d5Pa5P0T3wLnB4ONC3YWhMFZp/WC9+Oi+VM44prhHH57Lt9Ywrh2tk2AUMXv/Roy+tLFn4zEY89k06najwvvaS1pfE7eXkFFQcrOKuU8mLtrQ+a4zWbcdiceBvitA55fkrMeF834xlnxlKKVKzqT/fVhXLOnONUtu13nGH8wKOvdsOxZ5TgmMwjwKdwPbwHk71AbScxds4ynLfXgkm7UqrQgHHlji0bdw8dObbCr3b3RDLn1fDR44adce4l8RefemQrAmwVyKQEAcQdyMRuQMBtJALgaxDVcDICsLYFg618BAI6tgpSFVDjiwG047F5zxpT4Run7lp2aAHSFgixtkq/Hc7+7w9BskBRius1XmHOpdB8ynDq/3Zcdo+NY61C7sNgpEdOcuUbLzyy8o0XXsN0mJx3wfuuLCwqzXq9zbmllVLBeLz9G/fd9fMaBMQsWNoY0hrEoVSIsMkUEqgfQ5yEExB2GTTb2SiCWFW/wcFAIBCt2bPtABulr95ATo4DSXuaHQYoo2HF8KqjGz9p5ZgDpVEZPcSetxLxgtch7Gtdd9sqpWzOtK3Q3X76vIsSF1zxvi8oxWeUClS3tjTtW/HayxOffPCeN67/1JfHKRWOvBXqrrVm9pzzLnzxqUf+jQBIG67PjE2hs9d1BwIkI8z5bEFAdSZSpLcQmbztCMBoXNGN8eYcLZPKOPVO52BBoBCXdlhkrkvI97tGQM2OL4Rre2szdDDbtiDMNt9sZ4sAV5h19+DCcsII0+uHq5c5zRz/BQRcU4iqHG6or60bNmJCV5eY9vaW5za8uezBpa8+tRxJf7QhUDbGM4Dr71OFAOFuM5b+5nyX4Zxsg4Hq8orqyosuv+HbkUje1Uqp6PyP37QM+NqCW2/6t+/crUkhJ8eB7GlMkTRpi+MGRAkerf60GXK8qBqW3TyKU+9GmN+yWm6VUgVI/KG1pTUDsbkXX/l7pdT3lApUAxQUFledds6F146fMmPivbf/5hlwMZOHK4XFJQqZuEPN2NcgqnYpwmRshaMoombvNOc1AGFhRYjHPG3WU2Y9y/oaEYZWaf5a1deq2/40RJtdkzS/pXzr2hhKz7d+u289u59Mx45nPhVmfcvS7b2x1Y4SdE5ptKmVQ5H7stycexCxzTYBhctee3pjS0tjnZdRHFlr7e2v27P1njtv/uXSV5/6DQJ2m5GogHoEgKsQJnkq8tKZjvSOH2WOGTPrlCAq+bPA8mAwlHfuhdf8KBLJu8YkKoCA+UPzP37TJeTSGI9L2VaX6Ph/wsBuE+qOqBxzRgmdMiP2IwUzzkYmYyUZYzRUqsz8ZisEAZSfc9E7J0ai0ev8dMv+O3vO+VOLyypeBq0zKtJ0AKev5iGZ2/ulbu+eTQiY2X47YCrqIPnLwxD2FDV/LWu0+dv7EMdOHAFOC5C7cQUsbFaNVYstwNmXiv3g2z5KZ3Xa73ix7NGq6kkcGwya/Qd969miHPUIALbimrbVIABYjmvFa1t4DDfr1SGMegAuV30QMEZrfepjDy1IXXDJB2MlpRX+p/+VJS899mMkCmIKEpu6C1ecOY2r7l6B87oPN2Ox8aMKsQ3HzDjrTzntolBRcVlV5zvZURvgu0iNULssJ8eBaK3ZbtTuYADGVB8btRuOr4cijTzgTwKtoXB4yMzTz5nz4c9+7aRv/+L2AHTYIwci6lUbTmUdAuTNPP3scV0Z6yPRaHjoiDHV2ULllOmNrLXG8zy9ffOGza+/tGhHtl1pz9P/+POtKcREYAtHWACsQwpe2P45FvSaEKa1GedpbkQAtRpnp/WnFCZwL4QIAgSlCDjY6u82rdCCR4DO8ZeWMVpvdxznnY7RuQpRnM4qrjVp2PjFwbjiE2txAGsdLJhzGWS22YcD8K3mt9OQHPnLW5ob9v3z3l9PQeyY84FTlVJn7t61+X6kf1AL8FkkbAwzFuv4si/V/ciLxlYlegVxrL2MONtsmJCuqBowXmsvW9m1ADDr8is/FvB9z8lxIPta0rSbbJzR/aNEQsfu1hwXjBI6scrWd8+/MTRm4tT35OXlR5B+Mpv+63u/+Dhi47N5zGW4wg/bgLaikrJd3R0j1tbSpCsqu4qjs4Cpdm3fHHz0H3/dFAiG95108unTAyaVMR6LxR++545Fe3fv2IuobdXIxNyPgF4xwrZAwLwUAZcVONV2H8KA6pFJPxUBgDdxTLIFxzr7I6BqM3is2p82oTYqYzkIQNtQnzycKm2D1K167c+0sd9tzGYZnTOERuKcKJsQppjC1f4sQ15Ybea7zfnehrzczsUVMk4Dn0qnUxuRF8uz/vtg0ll/hoDoOxB2eTfCUC27tAHyBciLaCAC7o1AUGu9xWRnjQcioVBkSzc9B1orqwbZUKpc0PlxIjt83u5xA46Nt9vK8fb29L76v785b8qM2f8VjeZ18Gyt9YjCouKHZ5w25yQck2lC1KoGBGD6/fk3P16qPa8hs/iq1jrd1tr85svPPP50oAdNkE8+Y96QopLS1/7519se+fHXP/P8wofu/dVjD9z1wx9/7T+/v/zVF7djcpkRlncZUujCVtuZZMZYh6iFAxEwtBWBrM2tFNcTfBQCiLbkWAABpP3IxC2hs9c6DwiauERrJ7Bs0sYDRjgw/dGmRNoKQX5gtGmNVr23AGidPQPMurbIcAjn4Ck2v3vIi6sd56UuAy5CQP9Ucy7fJwMcM8U0GHsa+CFyrz+FsMuoGZsFd2v+aELU8RAQMCXWkuY6Vry+ZOGbZr+Zx0kDf1xw603+l0dOjgPpBJTHKCzIynH1UGitvUg074smPKRjuVIqgFLhM+Zd8k6camg93qWYwg5b1q9t2Ve7Zz6QMBMtpbUmnU41PXDnH+5e/upL3tP//scKz/NX3jpQQuFwYMapc3YBs9vbWl987omHnnrp6UcXp1LJVxGQ0+a4NQgzHI/UoaxEwM96nZOIo6cfwjg1wsrWICBvM348xKZWZi8F7mVg62oG6GyXzMNU8jbfg751LPiFfN8tq7QOoXxc+JC/YpG/oIa9SKOQl4BVdYM4x46N+4yYc7LMNmy2Oc+sOxxx0N0B/LmnITha61rg58B9iOr+WbMfWzrOOrHacT3Uwwi7HWHOc/mObete3LVz0w+R4HzP1DYlHm9fD3zdHC4HlMeJtMY99pu2DwPLQhQfxWrm2eS4Ub19MllldOgzEigqKR2Km8iW+YBzUAT+7wf/75XzLrv65OmnzXmPQo1sa21e99dbf7atYf++8cDwZx77V/OyxS88d+5lV4886ZQzhnY1iK0b141HgOtlpL3DQAQ4liK9ua0HdisCaFVIIeJKJC3TQ1hiLcIsbS63rcKzDWGmQ3Ge2mEIY7OB3iAMrRQB28248B6bhhjA5TJbRum/fjYQ3F+k175orJfbssKkb1+2KpPG5ahvx8V9FuHSMcPmfCyQ2/jL/rj4y1OQalHfOdQ4RaMhLFJKrQKuAz6BxKI+RueqRmkE1C0z34EL7N//5CN/aa0eMKz9pFlzxxYWlaZ3bd+wY8nLjynP8/IW3HqTfWHlgPI4kF0Nxza3O1OOO6BUSm3WWg8wjhu/pKJ5+asQ+5hGzJpdTbg9wCqTrZOHqH5DEFBKNdbXvfzKs0/Ex00+aVA0Lz/o18a9dJraml1N2zatm41M/gJEdW7AZdVswRVmqDbHs7a4qQiorUA8tmWICmqzVkrNfnYiXu4Q4gCxdsBWc477cSmYaVyNRxs65H96bOyiZYI208beX8/314JZ0Lc8bMa11RzXeowtMxuAgM5es22lOS/rENpjxjUGVws0hLC5VuC9iAPoE28lmFtrXauU+jkSFfFOYCLwD4TZF5tzsAxzF9BuUyfNuTbU7Nm26fGH71iCqxR/IXCxUurPOCb/thCl1I3AfyHP7Srgc1rr57pY9yrgk0g4VtSsf5PW+rFs679V2e0DytE5oMwqP1dKnelfYCZXIN7edhsmr/lgO/n2L26v+H8/+u1/eJ531q5tm/s989g/C7duXJcsLCp+/gOf/NKVA4cMH+vbP57nEQwGaWttif/jz79bgmR5NCNA0Y5M/jYEBBsRAN1gfrcAthNhhv2QKkjWWWGdKDbPejRy7S3AWpZYgtg442a5DX0agbMD+h0sBTh2WYTLyLE9dmz8pQXGOC5Lxz6JthBGkTlfW7Q3hQNKZcYaN+sNMn/bEFPDXjNG24ohZfa5C1GV64DrrLr7VsTc+2eUUhsQb/kXEAb/IJKgkG/GbDOEbH63Rq7fWuS6jjHrrEHK440x431bOHOUUu8Dfoa0j34B+A/gEaXUJK31tiybnI1EEvw/hDR8CHhQKXWq1nppb45NivTKoxIJKQYf5SK92eT/t3fmcXJVZd7/Preq973TWZoQQkKzJSEGQgTCJgEEAeUFFRDRZIAXAZVBxw2HMcEZRHx5YT7REWRAAwzzBkFxYwfJALKoKAkRAoGEBBOydKfX9FLVXef94zmnz02neglZutKc3+dTn+6qe+69596q87vP/uQcUc6/au791y2861pjzAJrkMcY0xFF0T/c+O0vLUedGIYBCPO6hXdNBp7Pyy8YDbD/gYfI5IOnyrNP/G7p1Bmz5lTVjKmLjzfG0NmxNf2nZ3//0PNPP7o81dU5B138b+LbIzh7aAtKbC7zZS1KEI6I1qNEUY5KPONRslyOElADSpj72f1X2WO4KuJOgjWoFNeESrHj8C0PmlASaLXzy8MXL3bOHqeGxzNNXIm1yP7vYi1dVaBmu08RSiaT7TWvt69ye45qlIC32Ps0Bg3+LsE7WFYC19jjzrXtPnYaIlKCt0vfiz5YTgHmopXyXYxrJbBVRDrxGUlVwApjzAZbim+qvT/tqKPoDj44qvdXgTuNMXfY91eLyGmo1HhN38HGmKv7fPRtETkbjUrYpUTZ0pGhM60/2f1G5Q1bNk4cOUeUAPOvmnv9N773o//Mz8+f09nRkbnn1ps2bHrv70utk8dJRwlbuZoshPlDoMap787kedwpZ34oW2RQFEWUlJbnbanfuDHV1flX4HRULV6BkkA+qt4VoYTpikrE4zmdZCcowY1GF2YRqq7UoOpKDz4PfDwqyaxBiaUCnzN9iD1eA76RmbNVOq9yF77Ngwv1cRXdXRhQvDJQ3KabtvNzek0KX4g3iZeekyhJOqLpwkuLG+39mGa3GZQ4VwHfsvP9gjHmre1u+g7Afo/l9nhJO4dNQJsNA/ojaru8FI2lfAolyn32nzyl9cijTxv1hyW/Kn1v/eoeey+xZNmNxnU2VFaN/vDxJ33yxxUVo8bP/d/z14jIHYtuX/DCzsx7GFDW5/fdZYzp6jvIVpmaicarxvE4qgkNCvuduAIlQxlfwLbmorL+xm4axt44/SEniRLgB9/+0iYR+QW6uF31l2ZLit3W7pRAC0NkQAnzuoV3laJViHb4MTSmdt9KlLjeQ9MpDwceRlW5UXgJahRekjsEJbkifAOxIpQsamNj69CFvs5uc86GcpQwN6Aq5JGotDQGJUSX1dOBz+XOQ4nMSaGuZw6otFeIL7HmgsJ78Cl+zg7nCv122vdxp04SJb/19rprYtva7XydiuvU/r+jDwPnmf6uMWbAMKCBYHP5K+x5BSXyZpQAeh+Oxph6EVmIZvScAxwqIk+cdubcc0ePnfDZKIoqTz3jcz2dne2/LioqWWaP4fb745TDjj7o8CPnfDaRSObZohjdwMXzLlvw5UW3L/jR+53/MODvfd5fByzIMq4Gn2EVx0ZUcxkK/gn9Pf58iOOvAeYPZeDmVk+UE3KEKHNdzXBeyI1ApcQagtn4t7j9TUREujo7XcredhisGMbG9e9uQr2zTwL/haqfc1ACewsloApUInwbLeJbiIYHuayhWlQ6K0NV6uUoOXaj5HcISoaT8Gp9F/rj7UY97G0ouU3A2/2ch7oQX727w07dSYateJXbFcRwGTsu3Mc5O0rxHnKXvliML592AP7ej0YlNHfslL2WYpTox6CL9C+oZDcTuMfewx2GiBSLSC1qnihFzR1rgU3GmM5sJhejeAaN0dww65jT/21s7cQvRlFUaY+ZKCwsPhv47bzLFkhsv+aZHz51biKRTLrgffFtbv993mULhkocuYB98Q7DCjQGdSD0vY+S5bPtICKfQQn4fGPMpiHO7YY+c9u3v4ENbT29k6mtzA1Zbm8gSlCJxqALthd2cbgwoQiIXnj60UZjzCt9g84HgjGGDevWtr36l5cyKMH9FiUdt9BPR73Yr6GLtgIlh1bgN6iEVY4Szv748l6ONF9Ew1k68M6GaajEOg7fmmE0Kt29jarc+ajtzzlXXOWcatTbLiiBurhIF2jumo85m2cS30TMwZEoKDEXo9Kvi02cjK/7OBYf4F2AL2lXYq93DWqnOgP1Iv8P8K874uEWkUhEKkRkP3vfkqh0vhbYYmNiBz2eMab+nPO+fOvBh86cluUcCeD4jva2j4hIkYiUnHTq+XVRFM3KEmUB+h1+YqjXkANoNca0xF7bqd0W9ej32fchMIbtpcxtYJ1AdwLnGWOeHOrEjDFd8bmha2c79GQMje1KlDVlyWFNW4wjN2bRD+zCcHa/emB0tvRDS4o9AEse/VUi09PzddTZ4zJSBlxgW+o3Nd/7k1vewJhJqANnA97Tey9KYB9DYxzfRBevq39YhqYxrkcX9hZUlZ6MSkOHoZLhMjTub62da6X9fAqaDukenS54ey0at1iIxm2W2fctdvtkewxHji6Lphhvg3TphBV4m6ULNXIZOu7lSqW5OVSiD4cKfJVzl5LZjK/wtB6VrGcAF9l7dNlQSVJEkiIyCo3VdJ7q91AJtdUGh+9QSFF3d6ouihJZbWDGGJNOpz6Ckv/opqbNYwY4lEHv7YiCMSYFvIymk8ZxKvpAzworSS4CLjTGPLQ75tbSkcF92+MqckOahBwnSgsnGW5Gf7SV2QZZ6bIHyPzrP126JJ1OnQg8bIxpMMasMMY8niV9LbO1tWXDfXcsXCkipehCfRCfcZKH2h8fQD3Yc9Cg75UokTWgT+Hx+PjHFWjISSlKLBlU1T4WJZg/ocS6CS917odm9pShT9oKO5cGVG0vQ9XZfVDprwElrhpUknT20QJ8kLi7WFcxKImvf+mKS/TEXkX2eC4I3uWbOwfTaHz/mVKUTJtQm+Q+wFfstotiD6h+YSW6cShBltvrXgtsMMa02+9zKGpgJCLVInKgiBwvIhc+/fh95/a3r4hIcUnZG+hDZ+2HDj/hBZTcs2kggtqqRyJuBi4VkYtF5FARuQX9Hd4GICI3iMjdbrAlybtR2+SLIjLOvip25aSa2v1PZ3R57hBl7sykHxjTW9jXeXjHoGmD/Y3PiIj53te/8BJwLjZl7egTP5p/zEmnLayoqp4nEhUYY0xnR/vbefkF1Vdec/2RABvWvdu4tbW5455bb9qKD7nJQ9XKGlStrEclqBZUEkyhUtYElIj+hC9iMcmOa0edOcWotGRQCbMMJeBqu28xGsy+Bl95qBHf4rYOJWMXzlOGJ1zneXehO06C7JsDXomvEuQkS0eeJaj6XYRKxmPstip73iZUkt1sz+tiLa+192GeMaapv+/GagPuAeKKm9Sj3+uQJEcRKbLzqcIXDSnDV4nvaGtreq2rs/2xgsLiU/tkeWWA5mQy78E4mc+7bMFVwENsGx0QAbcsun3BTnnscxXGmPusJP8d9GG9HDjDGLPGDnEPcIcvoPfmP+zL4S40nnWXoKXDE+Wo0tyhp9yZycBwP+DNwCQRKRjA/uJUdtcON7ILNHrpmSduHj9x8j2nn3thIpFITq/dd+IPianlY/cZX4EZ/7tjTz5j9h+eeng9PlymGC3iMAo4CyWMN1FSnGnntxzNRRbU+fMO3oHzrt13PN6TnYeS6IsoAe5vxxTYvxvxHulGO94FnDfiCwO7H/N7+BhG8PGSefiF77JtXBGMLnucqHB0UVWiMNG69d22SfiCwOXow6IdlfgmoQT6GkrcKeCf7T26sr8wIEtWToVP4L3mHQyQYWW/vwqUFKvxBXmL7BBnbnA595vtq6mwqOR/0PYis/DtMFqAjy+6fUFH7DQsun3B4/MuWzAb+AYafL4OlazuyTavkQJjzI+BH/ezbV6f9x/ZA1OitdML9tWluZMkJTto/hk2WE+koDa/zcaYd4e4n/P6lqFOlAhY/a0bb/19QUHhEX2N+MaYTKqr89obvnnFnfgybt0o8RQAn0PJ7w589e5ZqKTWhbZ52GS3daISWB5KLnXok3qdHVuOSlVOgj0AJYE0vrXsO/b8EUq0efiybS5EKo0SRTEq5W7Bh/cU2/OuQ+2JTfazw4HU2GNrDznyuqOPLJ1YPgGgdU1L47Kb/vL83x9ds9nOv97OuRWV/J5HCXIU8HnUi/9dY0yvmha79wUo0bm88FaUrLrJQpCiXTQdKVbZe+q8967whaup6ezS7agEvwXYxiM+77IFEZp/fwT6IHlw0e0Ltvad594CESkHmpubmykvL+/9vKWlhYqKCoAK6yjJebhruffpNcyeOrb388debWWDbU37zbPGUJi3262DQwoj3FskSvDVrZ1T5+9D9ILGpctCbCHb/Pz8Kf14Oo1E0eEoKRSiBNuDL9L7ABrYfBFwO14V/xBKHitRac2lPq5Dpb46lGQORqVHl2vs0gqdWl6MLyRRYf+utuffjJLlFNSe57zgGZQoyuz+7pgJlFgjlKS68QTdUzmluvK4W+d8PFGQ6H10l04oqzrmlhM+9kzbU/+98bn1bSgBH2rP/469L+OB/4VmtiyKk6R9MMWzZ7rt3FqJ5ehb22IlXo12wflO9XWxoZvxTeZM7G87tpe4McYnBsew6PYFGTT4/Kls2wNyD+0plSjzErInSHLI2GuI0i4ugzoyxqFSR8MOHMJdazdQ0J1Ob8nLj4qyedFbGrd0okTniCgeAN4K3I/mul6Ehkq0oE6NA1D1NEJjCqfg29VWoJLNy/YYY/F20A5UFa1GSdaRigvZKcPbBTfjHUj1dlwNSqaOQNrsZ450I+ht47vVbuuecsX0mYn8REKiWOsMmy427csfmrrxufXN+AK5bbHjnoaaGZ5A2yg49doVpnD7OPUafJX2KhFx0qJbCZ12XAu+5UUX21ZDcpJzm70/nTsSAhawd8BVNC8rzB2ShL2IKC1csHMLShY7SpSOLMreXf3W7yYfPPXy+AArfcrLzy95BCWtFrz9qwhd3BXogv098EngYlTKbEWJqwO1cx0MLEFV4Sn4bJeD0eB1F24j+KwZF19WjBLeWPx3NB5fts3VqIyH+IxHSSxCybEDJVlHOE4aK7L/91QeXDlWEts/KCSSqHRi+f7AXyoOqmw7cO6htWUTy4/IdGemLbvpL02Nyxs+gjqjrgSS1vPpwnEckRXa+celRfCS4no7tzS+rFsn21Y0co4oR6KdNrQlYAQikzG9HReL8wNRvm9Yj3aELdggIsXGmPbB9rNwCy8NVC++84cPfOP6Hxbm5efPs9KqiEiqs6P98heWPPYE3kZ2KLZRltH84EJUdXXFMc5E48/+gEpCJWjA+Ew0pW4ZShxH4eszNuNDfPax79+w/7uYxQ2o2j4FdZy4EJ4D7LldwHcaVcPzUbJqwTtNXFsJ5+RJ4gsKp9Nt6RbTkzHSp+qAyRiTbku1jDthn+j42+Z8X5JRqckYROTQU+4/Q/74zT+8seY3q75g5+VCk5yDaB987++MvbbNePui4KscpVByTOPjQV2NzW5Ute5ACXLQkKOAvRupHm9JKwpEudNwiy+NLtQ1Aw/vRRLvFChPp7qar//6ZVf8y8133AhysjGZjs729l//n2uvavj+t650cYab8RW8DxORFtSO6PK5n0Mlu6NQ1fcVPFH9EXV0ONX7ebQHzAEoYT6Jzx3fz17PUntNtXZMF2r/HG2P46Ral6vbDUjVtFHlM6458qMiMjnVklr22q1L1295dcsqMqYW7/V28ZSFQFQ9vaYiUZTM60uSABKJbHppw0Ozrp99jiSiEhERSfhhH77x2P22vFp/WOvqlt4CJXZTh72mDSgBpti2t7gLhHdE7yoXleBtk85u20mfnO6AkY1Ut/+qC/KGv2JQHHsdUcakyga8U2dAacOOL8DnhpegBJX+7lcuWQGscKFEN/3LPzoCarHj2lGPdSlKYHXoQt6AEuCDqJp+rt1nNUoQ6/AetYT97OfAMWjw+dmo+r4RlfpmoFLsSrzzphZVqbvQIPWxqCOoxp6zZv9zDqib9b3ZU62dURBmjz95Aum21Huv3frqsytuX74Etbc22HuQXzNzTM0Jd55yRbIo2ZvW6PhIRGhe2fRLScgfiseVXLndvYwEiaTo4EumzvnztS/8DjVLbLH3SVCzgSssnIcvB+dSLZN4cnS5xd12/xQqPWZ1zgSMbHTHJMr8ZG4RZW7Jt0NHBiUpVxtxMCTRxZtGJRwBmuIEG0+DtMfFGOMK2TqHywo0frINlQJnoNLjT1HCuxAlN6eCt6NEsAoljTFo3OTPUSI83n72BhryU2WPW4CXNtvwgemRPf/fgDcLqgvqZ3736CkSSSSRiETSW/gjWZJXO/1rR5w37eoZh9j9Gu1cWo74zoePTxYlCyXyXn+335a/Nfy8s77jxUnn1t010A2d+PFJb6ISsMuYcqYKV9+xAf2OGux7FwzvMn1cimUbqiE0GmNaA0l+cNETc80lE4EodxqW1JwKN3aQ4eC9yy7v2Uk5fY/bmwaJBqonUKJsw7c26EADyJfhi9YeiGZ2pIBPoyTpMmNKUBJZihLxBFQa/QVKhsehqnszakZwNtD3UEn2LVT9XoOSUCmW+A6+ZGp5sjCZkCyFTS3xmQPOP+hsfH+dImBr2f4VR8RJMo6S2pJDxhw97nsM0BLBGGPevPv1N/BdDzvwdtcm+7/rY+PiIgvt/enAe7lb0QdWe/BgB/TErCzJHCjWG8deSZQWPajEUixa9XogOPtkGl8mrV/JJYt02YPvluhi/Qzquf0rvkjGi6iqfA6+kZfzSJejhNdk37ejqvd6VJ2fZY/diHqr6/DFdFtRidNVMHobaCyoKhwwYUBEpLCmaKJE4tIUi0fPGlsR5UeV/eyXkbyoEi2KnK34CMYY0q3pO1/9v399HR8f2Wbn6eIdXXWl0tg1ONW7E60r2mwrygQbZAAAmdijMpFjzJRj0xk6LJk5p85gUmUevuGW8zp3D7RDX+nSvtrQhe5scAl8zcalaHmxR9Csl/PsOdrs2Gn23K+j9stqO/dXUMIpRAtE1Nl9xqFZPU14Yt6CSpqbgBWb/7zxpcFqbJqMMYdcPm0SYJIleQXH337yTZKQ0mz7iUiUbk29h39I9N1OujV1zWOf+M3X8MWEW+09KkPNDlV2f0egrgJUO6pet5ld0DsnYOQh/sTMMYFy73Pm9EEGW8FHRNYOsABdDGWR/dswVEnGErLr5OecMs4G6QrqCpA2xjQA94u2GDgXJYoV+IZdB6EkuQElkon2WO+gpFiPSpMzULvmWHvOVfialCmUmKvf+eXbrx/4+UNfrppSPbM/wpRIZPpXjjhz2pc+dFx6a3dXXmnedmXFjDGICC1vN73U+HrjwxPPKj0qyxiD4fUHZy6+CSXCPFRiLMa3zHWkmRe7Vy3B7hgwFMRX5GACwJ7GSCDKzfjGWxv6GReXJl2u8A7BbNuvx+C94i4tUkQkbYn1VyiJHI0PX6pAibLJ7teJSpcHohLqZpQ4l9prmYQSpyOdd/FhNh32ONN+f8EjTxz7o5NWj51d+zFJqgkiq7SYjCoKKgt6SXGbbfb9E596+GYyJlV92KjW0n1LS13okIsz7enq/g4+2yeJEmYb2zYqM/jQnhD7GDBkmJhMmVs0uRer3tCbSRPP1OkP5SipljCIfXKw81mp1ZUva8dX5CkC8kQkYef1/9BQnzmoTfENVCqcgaqno+y83kZJsgEl8Zmoer3cHrcWJdg6fDUgsB7zns6eV5+59Mmf3j/lntkmY1r6lSzt5/1tNxmTOf4nJ5+dX1Fw6e8veOTPHZs6HsLdJ8NbLaubL3ngsHv/aOecsnNutHNyknobql63B5IM2FFsK1EO3zyyYW+XKEEJcCNwkIiU91M9xbVDKEDV7p3ysPaRLtP4FMQSoMNKlt0icifaFvSzwM9Q1bnW7ldpX012/q6U3HQ0zvJFtIzbGJQojwDKJ32qrmn/c+u+n1eaN6Ono3tj04rG51+e/+IyoCbdkmrIrywo31G1xRiDRBKNPnLMhR/99VmpP137wqW/PeGB+8cet09V0ZiiqrUPvdOa6epxqYddqBRdbHd3sY/B7hiwy5BjPLn3E6VVC1vQBTwGlS57YcuzudQ4UHV2l5wX7QbppPI2fO3KlGg/6Ta0wtBXgU+hOeFVqOr/Fur9LkNVbVfhOx/NFT8eWHLcbXOakiXJ9Kr7VlZ3b02fecT8o+Ym8hP59pd00KjDR59YeWjVdU+d98jWtb97p/HAzx0yaUevpVfajIT8ioLkUTcee/YvH1+7ZONz69NoS4at+L47hSipu9TC4LUO2CUINsrdD2erHC8ieX2cB44oi1AyGmpu+JBgM4WcKt6Bb8AVL1D7M+BytEL6i2g+9EZUNU+gKYr7oHbNJuBvBaMKjzvxzlNuq5o6ajLA2KNr6Un1dEUJKYjFTSaMMVRPr/lOyYTSn1RPH9Xs7IlDmDew/Q9SIomSJXlnlU4su7BtTWs3vvOkSz9sDYUpAnYH4kSZa17vvdpG6WClms3oYh7dZ7OzH+Zju/ntjvPHQom68GTsKoSvQEuzTUfzv3tQL3cGSBlj3gZeQu2S7UDTiXeeMqvykOptpMNEfqJA+gSYiQgSSTRz/lGtFQdVVQ6FJHv3639olGrqKkCl30J7TU1GO+gFkgzYLYgHnIc4yt2HNLbPSx+ycBk1eQzSinNnEQtUd1XLXV+aErQoxlPACSiBjsaG/1gHUMpo1fbnZlxz5KrKKdVTspVA6w8l+5a1YszqwR4Eg2nKxphMpqvn8VRzysWNNhpjtgbnTMDuRkhh3AOwUuVGlBTjneFcrF8XO1a/8n3Pw5KKq4regari5cCvUalxjp3nQfjyb27/noMvnlqyIzYaEaG4tvi+ZHHeLdYm29+8hmL76eru6P5WyJwJ2NOIF8XIC0S5W+FskPFQoVLUYdKIb7y12xGTLl1V8Qj1ct+Dpi0ea+e5PxpWFP9lvM0Avcid1z7mvf/hA9PvXbm4btFzwBWoJ9qN7c5kMk/YepuDzRkROf3BWYuX78ClBgTsEqRD9aA9g5hUOco2tgIvUW7a04UXYtJlFz5XvBBt8dmOBqQfhErAvd/F4rpF64H7+qq7JmMy6fb0ykwq85QxZpOILEX79/xjbN/b0BCkzwCfFZF9oihaOgTbrBGR/1xct+iZnbzsgID3hXg9ylzqlwMjx+sdh8twGY2GtlSj0tnm4ZpQLA2yGSXtBPDfwGVol8AGVOLtJcZ3fr3qixNOn1gc5UefcJJgT2f3i/V/3nTBM5c8uW4g0l9ct2gLsNi9v+CteelBpMl64GbgB+/zEgMCdhqdaU+UJQWBKHcrbDD4ZmCsiKxHw2460UISwwo7tzZ8CbZfAXMLRxede9J/nXbC+SvnThaRTV1NXXe/9LVn61/62rNPV0+vWb/fWZPWl04offy5K55+2RjTzcU7fOpfANdk+bwHuH9x3aLP7MRlBQTsEnSk/LM/EOWewYZTPv7pE4845sR/2Lju3envrVvz7OyTTs+JeofWPNBhC2e8UvuRface9YPjbsyvzC8AeowxJr8i/ysz/nnWQ69c/6elW5bV/2zLsvqlxpguLh/k4P1gcd2ily94a94twFdQckzgY0+/tUsuLCBgJ7F1m1a1uWWjHLCe4d6I6xbeJcD3gW8YY3qMMRJFUQQ8Dnxi/lVz95hDZzCIiHz6tYsek0R0ct9CuiZjMssXvvLh1/5j2V93hW31grfmCfAx4PNofOQzwE8W1y3aJZlKAbsfIlIONDc3N1NeXt77eUtLCxUVFQAV/aTw5hzctdz79BpmTx1Lxhjufb6JjIEx5UmuOLlmj01lKINGokR5EvAN0F7TMdvcKcDVwI3DM63tcf7KueXovLKU+0EOu/rwY/72o6Uv74pzLa5bZICH7SsgIKewtStDxsps1SX9FtcfNuSWIWDX4CKyF+WNgHl7diqDwvXv2Q4iksEXnggIGNFoavcBHjVluSe/jUSirKD/fi+Ve3AeQ8EmNL0xm/0jgWbyBASMeDRu9UQ5tiIQ5Z5Af3GA3Wgv7ZyBVYe/Zt+6X4qxr8WL6xbtErU7ICDX0dDmiXJcRd4AI4cHI5Eof4a2Voir3z1otsoNwzGhgbC4btFDaErj02hm0SrUxvq54ZxXQMCeRH2rLtf8pDCqNPdslLkn4+4k5l81t+W6hXfNBv4NzU7JBx4Frp1/1dzXhnVy/WBx3aIlwJJhnkZAwLBga1eG9pRan8ZX5eVcLUoYgUQJMP+quRvQ1L5Lr1t4l8y/au7IioEKCBhB2Njilb8J1bmndsPIVL23QSDJgIDcxqY4UY7KH2Dk8GHEE2VAQEBuY1OzEqUQJMqAgIAcg4hcKSKrRaRTRF4WkeMHGX+iHdcpIqtE5H0m1Xp09hgabQxlbWWSghyrGuSQm7MKCAjYrRCR84F/B64HDgeeBR4Rkf36GT8Jzep61o7/HrBQRD65M/Oob/ZhQfvlqNoNgSgDAj6o+CpwpzHmDmPM68aYq4F30cLP2XA5sNYYc7UdfwfwU3wc8PtCY4cnyok1uUuUI9LrHRAwktHS0tLf+7I+oTVdxpjtisCISD4wEy0eE8fjwOx+TnuM3R7HY8AlWTqfbgdbSLsg9lFZ3zG5LFEGogwI2HuQAjZMmDBhXJZtbWih6jiuAxZkGVuDpsj2bba3Ech2bOzn2cYn7fHe63fWimuA+X0//P5FB+0VFY8CUQYE7CUwxnRaW+FQRa/BSgr2DZ2TLJ8NNj7b59lwA1pFP458NBst5xGIMiBgL4IxphOt2L8zqEfTevtKj2Pov6Xzhn7GdzOE7qbWBJAztWB3FMGZExDwAYMxJgW8DJzaZ9OpaP/5bHghy/iPAn8ezD45EhCIMiDgg4mbgUtF5GIROVREbgH2A24DEJEbROTu2PjbgIkicrMdfzFwCXDTHp/5MCCo3gEBH0AYY+4TkVHAd9D2xsuBM4wxa+yQWpQ43fjVInIGcAvwRbQ3/VXGmF/s2ZkPD0Zcz5yAgICAXY2gegcEBAQMgkCUAQEBAYMgEGVAQEDAIAhEGRAQEDAIAlEGBAQEDIJAlAEBAQGDIBBlQEBAwCAIRBkQEBAwCAJRBgQEBAyCQJQBAQEBgyAQZUBAQMAg+P9luCSGWJGktAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 400x300 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# VAMP 2\n",
    "fig = plt.figure(figsize=(4, 3), dpi=100)\n",
    "gs = fig.add_gridspec(65, 140)\n",
    "fullax = fig.add_subplot(gs[:, :])\n",
    "fullax.axis('off')\n",
    "\n",
    "# network plot\n",
    "ax = fig.add_subplot(gs[:, :95])\n",
    "\n",
    "# tune down color-scale for visibility of nodes\n",
    "edge_cmap = plt.matplotlib.colors.LinearSegmentedColormap.from_list(\"uwe\", [(*_c, 0), (*_c, 0),\n",
    "                                                                            (*_c, 0.25), (*_c, 1)])\n",
    "ax, pc = plot_dependency_graph(ax, graph_vamp2, pos_dicts[1], matched_assignments[1])\n",
    "ax.axis('off')\n",
    "\n",
    "# colorbar\n",
    "cbar_ax = fig.add_subplot(gs[:, 102:105])\n",
    "cb = fig.colorbar(pc, cax=cbar_ax)\n",
    "\n",
    "# histograms\n",
    "ax = fig.add_subplot(gs[:, 125:])\n",
    "sns.kdeplot(y=inter_cluster_edge_list[1], fill=True, ax=ax, color=col_pal[0], linewidth=2)\n",
    "sns.kdeplot(y=intra_cluster_edge_list[1], fill=True, ax=ax, color=col_pal[1], linewidth=2)\n",
    "\n",
    "\n",
    "ax.set_ylim(0, 1)\n",
    "ax.set_xticks([])\n",
    "ax.set_xlabel('')\n",
    "\n",
    "# comment following line to verify that axes are matching\n",
    "for loc in ['top', 'right', 'bottom']:\n",
    "    ax.spines[loc].set_visible(False)\n",
    "ax.set_yticklabels([]);\n",
    "\n",
    "fig.savefig('syt_vamp2.png', dpi=400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Please note that results are subject to stochasticity from Fruchterman-Reingold and k-means algorithms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 559,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "####### VAMP 1 #####\n",
      "color #0:[108 109 110 111 112 113 114]\n",
      "color #1:[32 33 34 35 36 37 57 58 59 60 94]\n",
      "color #2:[  5  22  23  24  25  26  27  28  29  30  31  61  62  63  64  65  66  67\n",
      "  68  69 121]\n",
      "color #3:[  6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  70  71\n",
      "  73 115 116 117 118 119 120]\n",
      "color #4:[ 72  74  75  76  77  78  79  80  81  82 106 107]\n",
      "color #5:[ 44  45  46  47  48  49  50  51  52  53  83  84  85  86 102 103 104 105]\n",
      "color #6:[ 38  39  40  41  42  43  54  55  56  87  88  89  90  91  92  93  95  96\n",
      "  97  98  99 100 101 122]\n",
      "####### VAMP 2 #####\n",
      "color #0:[108 109 110 111 112 113 114]\n",
      "color #1:[30 31 32 33 34 35 36 37 38 39 55 56 57 58 59 60 61 62 63]\n",
      "color #3:[  5   6  12  13  14  15  16  17  18  25  73  75  93  94 119 121]\n",
      "color #4:[ 46  47  48  49  50  76  77  78  79  80  81  82  83  95  96  97  98 103\n",
      " 104 105 106 107 120]\n",
      "color #5:[ 40  41  42  43  44  45  51  52  53  54  84  85  86  87  88  89  90  91\n",
      "  92  99 100 101 102 122]\n",
      "color #6:[20 21 22 23 24 26 27 28 29 64 65 66 67 68 69 70 71]\n",
      "color #7:[  7   8   9  10  11  19  72  74 115 116 117 118]\n"
     ]
    }
   ],
   "source": [
    "# resids for VMD figure coloring\n",
    "for n, (assignm, nc) in enumerate(zip(matched_assignments, n_clusters)):\n",
    "    print(f'####### VAMP {n+1} #####')\n",
    "    for n in range(nc + 5):\n",
    "        whe = np.where(assignm == n)[0]\n",
    "        if len(whe) == 0:\n",
    "            # some color assignments are unique to one of the graphs\n",
    "            continue\n",
    "        print(f'color #{n}:' + str(whe + first_resid))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}