synthetic_experiments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from ortools.graph import pywrapgraph\n",
    "\n",
    "plt.rcParams.update({\n",
    "    \"text.usetex\": True,\n",
    "    \"font.family\": \"sans-serif\",\n",
    "    \"font.sans-serif\": [\"Helvetica\"]})\n",
    "\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "from scipy.optimize import linear_sum_assignment\n",
    "import matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def num_correct_matches(pie, pie_star, num_inliers):\n",
    "    return np.sum(pie[:num_inliers] == pie_star[:num_inliers])\n",
    "\n",
    "def num_in_out_matches(pie, pie_star, num_inliers):\n",
    "    return np.sum(pie[:num_inliers] >= num_inliers)\n",
    "\n",
    "def num_out_out_matches(pie, pie_star, num_inliers):\n",
    "    return np.sum(pie[num_inliers:] >= num_inliers)\n",
    "\n",
    "def num_out_in_matches(pie, pie_star, num_inliers):\n",
    "    return np.sum((pie[num_inliers:] < num_inliers) & (pie[num_inliers:] >= 0))\n",
    "\n",
    "def dist(x, y):\n",
    "    d =  np.linalg.norm(x - y) ** 2\n",
    "    return d if d > 0 else 0.0000001\n",
    "\n",
    "def error_rate(p1, p2):\n",
    "    return np.sum(p1 != p2) / len(p2)\n",
    "\n",
    "def precision_k(pie, pie_star, num_matched):\n",
    "    pie = np.array(pie)\n",
    "    pie_star = np.array(pie_star)\n",
    "    k = len(pie_star)\n",
    "    return np.sum(pie[:k] == pie_star) / num_matched\n",
    "\n",
    "def precision(pie, pie_star, k):\n",
    "    pie = np.array(pie)\n",
    "    pie_star = np.array(pie_star)\n",
    "    return np.sum(pie[:k] == pie_star) / k\n",
    "\n",
    "def recall_k(pie, pie_star, num_matched):\n",
    "    pie = np.array(pie)\n",
    "    pie_star = np.array(pie_star)\n",
    "    k = len(pie_star)\n",
    "    return np.sum(pie[k:] != -1) / num_matched\n",
    "\n",
    "def dist_nosquare(x, y):\n",
    "    d =  np.linalg.norm(x - y)\n",
    "    return d if d > 0 else 0.0000001\n",
    "\n",
    "def kappa_all(theta, theta_hash, pie, sigma):\n",
    "    n = len(theta)\n",
    "    m = len(theta_hash)\n",
    "    min_dist = np.inf\n",
    "    for j in range(m):\n",
    "        for i in range(n):\n",
    "            if i in pie and pie[i] == j:\n",
    "                continue\n",
    "            min_dist = min(min_dist, dist_nosquare(theta[i], theta_hash[j]))\n",
    "    return min_dist / sigma / np.sqrt(2)\n",
    "\n",
    "def kappa(theta_hash, pie):\n",
    "    n = len(pie)\n",
    "    m = len(theta_hash)\n",
    "    min_dist = np.inf\n",
    "    for j in range(m):\n",
    "        for i in range(n):\n",
    "            if pie[i] == j:\n",
    "                continue\n",
    "            min_dist = min(min_dist, dist(theta_hash[j], theta_hash[pie[i]]) ** (1/2))\n",
    "    return min_dist\n",
    "\n",
    "def kappa_hat(theta_hash, sigma_hash, pie):\n",
    "    n = len(pie)\n",
    "    m = len(theta_hash)\n",
    "    min_dist = np.inf\n",
    "    for j in range(m):\n",
    "        for i in range(n):\n",
    "            if pie[i] == j:\n",
    "                continue\n",
    "            min_dist = min(min_dist, \n",
    "                           dist(theta_hash[j], theta_hash[pie[i]]) ** (1/2) / ((sigma_hash[j] ** 2 + sigma_hash[pie[i]] ** 2) ** (1/2)))\n",
    "    return min_dist\n",
    "\n",
    "def kappa_outlier(theta_hash, sigma_hash, pie):\n",
    "    n = len(pie)\n",
    "    m = len(theta_hash)\n",
    "    im_comp = [i for i in range(m) if i not in pie]\n",
    "    min_dist = np.inf\n",
    "    for i in range(n):\n",
    "        for j in im_comp:\n",
    "            min_dist = min(min_dist, \n",
    "                           dist(theta_hash[pie[i]], theta_hash[j]) ** (1/2) / ((sigma_hash[j] ** 2 + sigma_hash[pie[i]] ** 2) ** (1/2)))\n",
    "    return min_dist\n",
    "\n",
    "def kappa_outlier_outlier(theta_hash, sigma_hash, theta, sigma, k):\n",
    "    m, n = len(sigma_hash), len(sigma)\n",
    "    min_dist = np.inf\n",
    "    for i in range(k, m):\n",
    "        for j in range(k, n):\n",
    "            min_dist = min(min_dist, \n",
    "                           dist(theta_hash[i], theta[j]) ** (1/2) / ((sigma_hash[i] ** 2 + sigma[j] ** 2) ** (1/2)))\n",
    "    return min_dist\n",
    "    \n",
    "\n",
    "def outlier_detection_error(star, prediction):\n",
    "    return sum([1 for i in prediction[:len(star)] if i != -1 and i not in star]) / len(star)\n",
    "\n",
    "def kappa_max(theta_hash, sigma_hash, pie):\n",
    "    n = len(pie)\n",
    "    m = len(theta_hash)\n",
    "    max_dist = -np.inf\n",
    "    for j in range(m):\n",
    "        for i in range(n):\n",
    "            if pie[i] == j:\n",
    "                continue\n",
    "            max_dist = max(max_dist, \n",
    "                           dist(theta_hash[j], theta_hash[pie[i]]) ** (1/2) / ((sigma_hash[j] ** 2 + sigma_hash[pie[i]] ** 2) ** (1/2)))\n",
    "    return max_dist\n",
    "\n",
    "def mincostflowcost(X, X_hash, pie, k):\n",
    "    s = 0\n",
    "    for i in range(k):\n",
    "        j = pie[i]\n",
    "        if j != -1:\n",
    "            s += dist(X[i], X_hash[j])\n",
    "    return s\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greedy(X, X_hash, num_to_match=None, return_cost=False, progress_bar=False):\n",
    "    costs = [0]\n",
    "    cost = 0\n",
    "    if num_to_match is None:\n",
    "        num_to_match = len(X)\n",
    "    n, m = len(X), len(X_hash)\n",
    "    M = np.zeros((n, m))\n",
    "    if progress_bar:\n",
    "        iterable = tqdm(enumerate(X), desc='Calculating pairwise distances', total=n)\n",
    "    else:\n",
    "        iterable = enumerate(X)\n",
    "    for i, x in iterable:\n",
    "        for j, x_hash in enumerate(X_hash):\n",
    "            M[i, j] = dist(x, x_hash)\n",
    "    pie = -1 * np.ones(n, dtype=np.int32)\n",
    "    for _ in range(num_to_match):\n",
    "        i, j = np.unravel_index(M.argmin(), M.shape)\n",
    "        pie[i] = j\n",
    "        cost += M[i, j]\n",
    "        costs.append(cost)\n",
    "        M[:, j] = np.inf\n",
    "        M[i, :] = np.inf\n",
    "\n",
    "    if return_cost:\n",
    "        return pie, costs\n",
    "\n",
    "    return pie\n",
    "\n",
    "def LSS(X, X_hash):\n",
    "    M = np.zeros((len(X), len(X_hash)))\n",
    "    for i, x in enumerate(X):\n",
    "        for j, x_hash in enumerate(X_hash):\n",
    "            M[i, j] = dist(x, x_hash)\n",
    "            \n",
    "    row_ind, col_ind = linear_sum_assignment(M)\n",
    "    return col_ind\n",
    "\n",
    "def LSNS(X, X_hash, sigma_hash):\n",
    "    M = np.zeros((len(X), len(X_hash)))\n",
    "    for i, x in enumerate(X):\n",
    "        for j, x_hash in enumerate(X_hash):\n",
    "            M[i, j] = dist(x, x_hash) / (sigma_hash[j] ** 2 + sigma_hash[i] ** 2) ** (1/2)\n",
    "    \n",
    "    row_ind, col_ind = linear_sum_assignment(M)\n",
    "    return col_ind\n",
    "\n",
    "def LSL(X, X_hash):\n",
    "    M = np.zeros((len(X), len(X_hash)))\n",
    "    for i, x in enumerate(X):\n",
    "        for j, x_hash in enumerate(X_hash):\n",
    "            M[i, j] = np.log(dist(x, x_hash))\n",
    "    \n",
    "    row_ind, col_ind = linear_sum_assignment(M)\n",
    "    return col_ind\n",
    "\n",
    "\n",
    "def MinCostFlow(X, X_hash, k = None, scale = 10**4, sigma=None):\n",
    "    n, m = (len(X), len(X_hash))\n",
    "    M = np.zeros(n * m)\n",
    "    for i, x in enumerate(X):\n",
    "        for j, x_hash in enumerate(X_hash):\n",
    "            M[i * m + j] = dist(x, x_hash)\n",
    "    \n",
    "    if sigma is not None:\n",
    "        M = M / 2 / sigma / sigma\n",
    "\n",
    "#     if sigma is not None:\n",
    "#         scale = scale * 2 * sigma * sigma\n",
    "\n",
    "    min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n",
    "    \n",
    "    start_nodes = np.concatenate((np.zeros(n), \n",
    "                                  np.repeat(np.arange(1, n + 1), m), \n",
    "                                  np.arange(n + 1, n + m + 1))).astype(int).tolist()\n",
    "    \n",
    "    end_nodes = np.concatenate((np.arange(1, n + 1), \n",
    "                                np.tile(np.arange(n + 1, n + m + 1), n), \n",
    "                                np.ones(m) * (n + m + 1))).astype(int).tolist()\n",
    "    \n",
    "    num_overall_edges = (n + 1) * (m + 1) - 1\n",
    "    capacities = np.ones(num_overall_edges).astype(int).tolist()\n",
    "    costs = (np.concatenate((np.zeros(n), M * scale, np.zeros(m))).astype(int).tolist())\n",
    "    \n",
    "    source = 0\n",
    "    sink = n + m + 1\n",
    "    if k is None:\n",
    "        num_to_match = n\n",
    "    else:\n",
    "        num_to_match = k\n",
    "    supplies = [num_to_match] + [0] * (n + m) + [-num_to_match]\n",
    "    \n",
    "    # Add each arc.\n",
    "    for i in range(len(start_nodes)):\n",
    "        min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n",
    "                                                    end_nodes[i], capacities[i],\n",
    "                                                    costs[i])\n",
    "    # Add node supplies.\n",
    "    for i in range(len(supplies)):\n",
    "        min_cost_flow.SetNodeSupply(i, supplies[i])\n",
    "    \n",
    "    status = min_cost_flow.Solve()\n",
    "    assignment = -1 * np.ones(n, dtype=np.int32)\n",
    "    cost = min_cost_flow.OptimalCost() / scale\n",
    "    \n",
    "    if status == min_cost_flow.OPTIMAL:\n",
    "        for arc in range(min_cost_flow.NumArcs()):\n",
    "        \n",
    "            if min_cost_flow.Tail(arc) != source and min_cost_flow.Head(arc) != sink:\n",
    "\n",
    "                if min_cost_flow.Flow(arc) > 0:\n",
    "                    assignment[min_cost_flow.Tail(arc) - 1] = min_cost_flow.Head(arc) - n - 1\n",
    "    else:\n",
    "        print('There was an issue with the min cost flow input.')\n",
    "        print(f'Status: {status}')\n",
    "\n",
    "    return assignment, cost \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_theta_sigma_hash_outlier_both_sides(m, n, k, d, pie_star, tau=1, sigma_amp=1):\n",
    "    theta_hash = np.random.normal(0, tau, size = (m, d))\n",
    "    theta = np.random.normal(0, tau, size = (n, d))\n",
    "    theta[:k] = theta_hash[pie_star]\n",
    "    for i in range(m):\n",
    "        if i in pie_star:\n",
    "            continue\n",
    "        theta_hash[i, :] += np.ones((d,)) * tau\n",
    "        \n",
    "    for i in range(k, n):\n",
    "        theta[i, :] += np.ones((d,)) * 2 * tau\n",
    "    \n",
    "    sigma_hash = np.ones((m,)) * sigma_amp\n",
    "    sigma = np.ones((n,)) * sigma_amp\n",
    "    \n",
    "    return theta_hash, sigma_hash, theta, sigma\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experiment 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def precision_vs_separation(n=100, k=50, d=50, tau=1, sig=1):\n",
    "    m = n\n",
    "    res = {}\n",
    "\n",
    "    pie_star = np.arange(k)\n",
    "    \n",
    "    theta_hash, sigma_hash, theta, sigma = generate_theta_sigma_hash_outlier_both_sides(m, n, k, d, pie_star, tau, sigma_amp=sig)\n",
    "#     theta_hash, sigma_hash, theta, sigma = generate_theta_sigma_hash_outlier_both_sides_cauchy(m, n, k, d, pie_star, tau, sigma_amp=sig)\n",
    "\n",
    "    X = theta + (sigma * np.random.normal(size=(d, n))).T\n",
    "    X_hash = theta_hash + (sigma_hash * np.random.normal(size=(d, m))).T\n",
    "    res['kappa_all'] = kappa_all(theta, theta_hash, pie_star, sigma=sig)\n",
    "#     res['theorem1_rhs'] = theorem1_rhs(n, k, d, 0.1)\n",
    "\n",
    "    MinCostFlow_pie, cost = MinCostFlow(X, X_hash, k)\n",
    "\n",
    "    res['precision'] = precision(MinCostFlow_pie, pie_star, k)\n",
    "    res['cost'] = cost\n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recovery_for_k_lessthan_kstar(n=100, k=50, d=50, tau=1, progress_bar=True, sigma_amp=1.):\n",
    "    m = n\n",
    "    res = {}\n",
    "\n",
    "    pie_star = np.arange(k)\n",
    "    \n",
    "    theta_hash, sigma_hash, theta, sigma = generate_theta_sigma_hash_outlier_both_sides(\n",
    "        m, n, k, d, pie_star, tau, sigma_amp=sigma_amp)\n",
    "    \n",
    "#     theta_hash, sigma_hash, theta, sigma = generate_theta_sigma_hash_outlier_both_sides_cauchy(\n",
    "#         m, n, k, d, pie_star, tau, sigma_amp=sigma_amp)\n",
    "\n",
    "    X = theta + (sigma * np.random.normal(size=(d, n))).T\n",
    "    X_hash = theta_hash + (sigma_hash * np.random.normal(size=(d, m))).T\n",
    "    res['kappa_all'] = kappa_all(theta, theta_hash, pie_star, sigma=sigma_amp)\n",
    "    res['precision'] = []\n",
    "    \n",
    "    for i in range(1, k + 1):\n",
    "        MinCostFlow_pie, cost = MinCostFlow(X, X_hash, i)\n",
    "        \n",
    "        res['precision'].append(precision_k(MinCostFlow_pie, pie_star, i))\n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6628be378bc74e1ab606acf184589294",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2748a505784d491d9e349f1e07567871",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_exp = 200\n",
    "n=100\n",
    "k=60\n",
    "d=100\n",
    "amp=1.5\n",
    "\n",
    "precision_vs_separation_sig_1 = [precision_vs_separation(n, k, d, tau = amp * (1 -  i / num_exp), sig=1) for i in tqdm(range(num_exp))]\n",
    "precision_vs_separation_sig_2 = [precision_vs_separation(n, k, d, tau = 2 * amp * (1 -  i / num_exp), sig=2) for i in tqdm(range(num_exp))]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a9873291aeaf41febbdea935bd837235",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "20ad2a9260404eb59689bc90522e3676",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_exp = 200\n",
    "n=100\n",
    "k=60\n",
    "d=100\n",
    "amp = 3\n",
    "\n",
    "recovery_sig_1 = [recovery_for_k_lessthan_kstar(n, k, d, progress_bar=False, tau = amp * (1 -  (i / num_exp) ** 3), sigma_amp=1) for i in tqdm(range(num_exp))]\n",
    "recovery_sig_2 = [recovery_for_k_lessthan_kstar(n, k, d, progress_bar=False, tau = amp * (1 -  (i / num_exp) ** 3), sigma_amp=2) for i in tqdm(range(num_exp))]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAB/AAAAI7CAYAAAD73gNPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC8c0lEQVR4nOz9eXxb933n+78BUKI2EyDlJZatyATjLE5iWyCVJk7SNBZYu/XUbWJC6vS26UwTkU46t00zMWF25je3nduGAp3UnZlmalDubZt0k8DaiZM0jgEpjZN4moiEvCSObZmgbNmSZUvkIayNFMHz+wMCxAU7seP1fDzwIAWc7/l+zvccgDr4fBeLaZqmAAAAAAAAAAAAAABARVkrHQAAAAAAAAAAAAAAACCBDwAAAAAAAAAAAABAVSCBDwAAAAAAAAAAAABAFSCBDwAAAAAAAAAAAABAFSCBDwAAAAAAAAAAAABAFSCBDwAAAAAAAAAAAABAFSCBDwAAAAAAAAAAAABAFSCBDwAAAAAAAAAAAABAFSCBDwAAAAAAAAAAAABAFSCBDwAAAAAAAAAAAABAFWiqdADVIBQKye12F32/w8PDCgaDamtrkyRNTk6qr6+vJHUBAAAAAAAAAAAAAOJqNQfc8An8kZEReTwejY+Py+l0Fm2/3d3dcjqdCgQCyecMw9D27dvldrvl8/lWtP/5+XkdO3ZMl112mSwWy0rDBQAAAACUmWmaevPNN7Vp0yZZrUyQVwrcOwMAAABA7VrJfXOt5oClBk3gG4ah0dFR+Xw+hUKhou/f4/FIkvx+/6LnHQ6H9u/fr/b2dnV0dKi3t7fgOo4dO6bNmzevKE4AAAAAQOUdPXpU1157baXDqEvcOwMAAABA7cv1vrkecsBSAybwOzo6JCnZA2LXrl0Kh8NF238oFNLIyIiCwWDK1x0Oh3p7e9XX16cdO3bI4XAUVM9ll10mKX7BtrS0FBouAAAAAKBCotGoNm/enLy/Q/Fx7wwAAAAAtSuf++Z6yQFLDZjAHx8fL+n+Ez0uMq1xsHPnTg0NDWnfvn0F98BITP3X0tLClxAAAAAAUMOY2r10uHcGAAAAgNqXy31zveSAJYlF9opsZGQk6zoKideXTq8AAAAAAAAAAAAAAKgu5cwBk8AvosQ0DNlOXmLKhGJO2wAAABrUfEya+L70zEj853ws56Kmaeqpo4ZM0yx5XWWTJsa8j7Va5Nrm8zGZE4/rpX/9W5kTj1fnuclXjsdejee20JhWfCxV+B5ddkwrjDGvNqrC9gAAAAAAALWn3DnghptCv5RGR0clZT95iW0ikYjC4bBcLlepQwMAAPXo2UekR71S9Nil51o2Sbf7pBvuzFr84UOv6nP7ntL9O2/Sx7ZeW9K6yiJDjA+fd+V+rNUi1za/uJ0lekxbMm1XS/K43vK6jsuk0JhWdCxV+h5ddEzN4RXHmHMbVWl7AAAAAACA2lPuHDAj8IsosbZCondFJoltJicnSxgRAACoW88+Iu37xOLklCRFj8eff/aRjMXnYvO6P/iCJOn+4GHNxeZLVldZZIjR3PcJjT36t5JyONZqkWubX9zOXLKdWU3nJl95XG95XcdlUmhMKzqWKn2PLjymsW9/ReYKY8y5jaq0PQAAAAAAQG0qdw6YBH6FGYZR6RAAAECtmY/FR5Yq1RTSF5979N6M00U/8tQxHZ06J0l6efKsvvH0sdQbFqGuksshxt+d+StZNZ/5WKtFrm0+N5vczrJkK0u1nJt85Xm95Xwdl1GhMRV8LFX8Hk0ck1Xz+szMHq00xpzaqIrbAwAAAAAANI6V5IBJ4BdRISci194XMzMzikajix4AAKBBvfTE8pGli5hS9NX4dikkRrEmkr4WS4bRrCusqyyyxGiRqU2WU3qf9bnMx1otcm3zg3uq/9zkK4/rLa/ruEwKjWlFx1Kl79GFx/Q+63PaZJlc1tHkkuwx5txGVdoeAAAAAACgcEtzpDMzM2Wtv5Q54FRI4BdRKafDHxwclN1uTz42b95csroAAECVO31iRdslRrEmxqeaZobRrCusqyxyrPtKGZmPtVrk2pZTR4q7v2qQx/WW13VcJoXGtKJjqdL36MJjulJGboUyxJhzG1VpewAAAAAAgMJt3rx5UZ50cHCwrPWXe0l0Evg1YmBgQNPT08nH0aNHKx0SAAColA1XFbzd0lGsCWlHs66grrLJse7X5ZBUHSO1M8q1LVuvK+7+qkGOscbWXZnfdVwGeb+3VlguqQrfo0uPKfHeyypNjHm1URW2BwAAAAAAWJmjR48uypMODAxUOqSSIoFfRG1tbSUr09zcrJaWlkUPAADQoLbcIrVsktJOSG2RWq6Jb7fE0lGsCWlHs66grrLJEuO8KR0zN+rH8++UVB0jtTPKtc237dLZNVdpPtVS34of99m1b6nsuclXjsf+dWNLftdxGeT93lphuaQqfI8uPaYfz79Tx8y2tNdqthjzaqMqbA8AAAAAALAyS3Okzc3NZa2/lDngVEjgAwAAlJBpmnrqqCHTXJB6mo9JE9+XnhmJ/5yP5bdTq0263XfxH8vGpMZ/3L47vt0C6UaxJkumGs1aYF1llSHGRMLwjy/8luYX/Ne3qkfh59jmc5Ym/en8b0vSssRo4t9fiP225sz0K49XnRyOPfaLg7o/NJ7fdVxiBb23VlBukSp7j6Y6pnlZ9ccXPhH/fVkSP3OMebdRlbUHAAAAAABAvkjgF5HD4ZAkGYaRddvENokyAACgPj186FX96pd/qK89+Wr8iWcfkf78PdLf/jvpnz8Z//nn74k/n48b7pR2fEVquXrx8y2b4s/fcOeyIgePTKUcxZqQGM168MjUiusquzQxvqaN+vSFz+o78+9b9HzaY60WObT5wSNT+vvozfr0hc/qNS3u0Zs47r+L3lS9x5hOlmP/8doPFXYdl1Ch762C35NLVdF7NN0xfWf+fSmv1WwxFtRGVdQeAAAAAACg9pU7B2wxFw0HazydnZ0Kh8MaHx+X0+lc0b5GRkbk8XjkdrsVDAYzbmuxxEd/TE1NFXQCo9Go7Ha7pqenmU4fAIAqNReb10e/+K86OnVOb21bp+/+clS2kd+WlqWiLo4KLSSxNB+TXnpCOn0ivqbzllvSjiydmYsp9Ozrmo2lH/G/2maT+4Yr1dyUYh951FUxF2O8MH1co6dW67XWrZIldYwZj7VaZGjzRefTjOnyU2Nac/4NnV9zhU5u7JQstto4xnTSHPuKr+MSKDSmoh9LFbxHsx6TGdNbpg6pa+OsVtmvzhrjitqoCtojG+7rSo82BgAAAIDatZJ7ulrNAUtSU0GlkJLL5ZIkTU5OZtxuYc8LRuADAFC/Eus2S9Irk6c18817tC7lOFJTkkV69F7pnXfkl2Cy2qT2D+e0aXOTTXfceHX2DYtQV8VcjHGVpA9UOpZiyNDmy8/nlvLEVC5pjn3F13EJFBpT0Y+lCt6juR1T7tfqitqoCtoDAAAAAADUvnLngJlCv4icTqccDocikUjG7RKv79ixoxxhAQCACli6bvP7rM9p3fkTGUqYUvTV+GhRAAAAAAAAAEBVKHcOmAR+AcLhcNrXent7ZRhGxm1CoZAkyePxFD02AABQHRKj7xPj7a+UkVvB05mS/AAAAAAAAACAUqiWHDAJ/Dx5PB51dnaqtbU1OQ3CQj6fTw6HQ36/P+0+/H6/3G633G53CSMFAACVsnT0vSS9LkduhTdcVYqQAAAAqt4PDp+U+8++px8cPlnpUAAAAAA0mGrKATd0Aj8SiSSnMkj0iMgmsZ1hGBodHU25zZ49ezQ8PJyyB8bQ0JAmJycznlwAAFB5pmnqqaOGTDPVmvWZLR19L0k/nn+njpltmk+7O4vUco205ZZCwgUAAKhppmlq6DvP6cXXT2voO8/l9X+wek381+txSfV9bAAAAKi8Ws8BN1wCv7u7Wx0dHWptbVVHR0eyB0VfX58sFos6OjrU0dGRdg2DRO+KTL0nenp6FAwG5fF4NDw8nLxIvF6v9u7dq4mJCTmdzlIdIgAAKIKHD72qX/3yD/W1J1/Nq1yq0feSNC+r/vjCJy7+vtTFrW/fLVlthYQLAABQ0x4/fFJPvzItSXr6lWk9nmNit9DEf6EJ5HIlnivRoaEWjq2c6GTQOOr1XNfrcdWzav/8BoBqV0854IZL4AeDQY2Pj2tqakqmaS57jI+Pa3x8PG3j9vb2ampqSsFgMGM9brc7uZ+RkRGFQiHt3LlTY2NjcjgcJTgyAABQLIkkvCTdHzysudjylHs6B49MLRt9n/Cd+ffp0xc+q9fMtsUvtGySdnxFuuHOFUQNAABQHfJNJJimqS899rysF/s0Wi3Slx57PqfEbiGJ/0ITyOVMqpe7Q0M5O0IUemzlTGzVa8eQWsG5Xnm5cncCqvb2qIUYa+FvU6Flyl2Oz2KgcdVTDrjhEvjl5na71d/fr97eXrlcrkqHAwAAcpCYAl+SXp48q288fSznsq4tDn35N1y6f+dNKR+3e3bp0Me/r9nffES666+k3/6m9NlnSN4DAIC6UEgiIZHQTSw1NG/mltgtNPFfaAK5XEn1cndoKLRcIee60GMrd2KrXjuGFFqmnOU418UpV85OQLXQHrUQY7X/bSq0TLnL1ftnMSqHjiFIpZQ5YBL4AAAACyydAt9iyW8UfnOTTXfceLU+tvXatI87brpWq9/2Eem9PVL7h5k2HwAA1I18EgmvTZ/Xvzx9TJ/f92TK1+/+6ph+669+pM/+0yH98Td+qv+5/7C++m8v6VtPH9cT4yf19z96Oe/E/0oSyOVKqpe7Q0M5O0IUemzl7phQjx1DCi1T7nKc65WXK3cnoGpvj1qIsRb+NhVaptzl6vmzWKrfmQzoXLbyGAsts5JyKC0S+AAAAAskRt8n/kttmvmPwgcAAGhEmRIJ52Zj+vHEpIYfH9en/25M7//Cfr1/cL8+8w+H9Mbp2ZT7O3chpu8fPqmvPXlMf/3DI/qz4Av6/33tJ/rdfwjrN/b8SP/1az9JWe7ur47pNx/8N33m78fkHXlaf/LNZ/U/Qof1Vz+Y0J9862cpE8jffuY1zc6l77BZ6qT62dk5vfj6m/rucyf0hw89k+xMmmCR9Ad7n9QfPfITDT36nP7n/sPa83hEX/0/RxQYPapvPn1M/yN0OGWMjzx1TNNnL+j8hZjm55d/cVzIseVzXEcnz+rQy1MK/vQ1/ZeHlx+b1SIN/svP0naYrVTHhHrrGFJomXKW41wXp1w5OwHVQnvUQoyhn51Iec6+8sRLirxxWq+/eV5nZ+eW7YNzXdkYpfJ+FtfrTAZ0LitOjJXoZIDSaqp0AAAAANVi4ej7hf9dTYzC/5UbN6nJRv9HAABQHD84fFJ/9I2f6o9+5d360PWXl6xMucot/JJSupRI+IX7/lWvGOcUW5I8tkhqXmXVzIV5pfqq0GKRrnWs1W+9f4umzl3Q1JlZTZ2d1dSZCzo6dVbHp8+njOPchZh+8OKpnI9Rkj7zD2FJ0iqbRWtX2bS+uUnrVtu0bnWT1q6y6mfH31wenyTvyFPq/Xmn1q5u0ppVVq1psmnNqsTDqp8ei6Zsk96vjEkW6ZhxTq8a52ScvZAxPlPS5JlZ/c0TL+V1XJL0+//05KJ/r7ZZ1dxkVfMqq1bbrDqZpgPF//0PYf38269Qc5NNq5ssWm2zanVT/HHMOJ/yuH7tyz+UJJ08PatTZ2Z0/kL2WazmTem5197U2//rt3Vt6zptblurza3rtLltna5tXauTp2dS1vX44ZP6yNuvSLvfdNdjopxpmnpzZk7GmQvx6+rsrKbOzOq+7zy//H5A0ucDT+nXu67VqiabmmwWrbJa1WSzqMlm1cQbp1PW9RfffVFbN7fKZrVolc1y8adVNqtFTVaLwi8bBR3bwmTTvHkp2fTz118ui2VpF4nCy5S7XLpz9u2fvKaff/sVslnibWizWmS1KLmfdOW+/uQxvfdau87MzOnMTCz+czbx+wU9+P2JlOf6P+97Une5rlWTzXKxTqtsVslqtejlU2dS1vUn3/qZbri6JR6bNVFOslosarJZ0n4W/PUPJ9R1XZusi47t0jEePDKZstz//tcXdf2Vl+nchZjOzsYf5y/Ej2vv6CvLjkuSfv8fD+nWd14ZPy6rRRaLJdmmVotFx6bPpqzr84Gn1HHlhuS28XKSzWrReJpr/77vPK93b7In28CaLBsv95NXp1OW+8oTL6nzutYF7aBknFaLRQePnEp9jTzzmj709svjZSzxeuL1Sj94MfNnQTrZPkPyLfeVJ17SVfY1Omaciz+mz+lV47xemTyrU2dSfw7/P9/46aJ/Wy3S+tVNF/9GWXV8emZZGYukz/7TIW1/55VqsllludgOiTa1XPzbkyrG3d9+Tl3XtWn9apvWNTct+jn20lTa9vhgx0bNzM1ffMQ0cyH+++zcvH40kfqc/cV3X9RN1zqS5ykRp/Xitf/k0dSfj//wo5f1vva25PbJchaLfpymrm89c1wfetvli7a1LPj5wwKvkXJ+Fkupk8GZ4ltJuXqtq5By5f77WeixlbsdUXoWk+4UNSkajcput2t6elotLS2VDgcAgLrwUPgVfW7fU2lfv3/nTfrY1mvLGBEAoJ5xX1d61dzGpmnqV7/8Qz39yrRuvNaur//uB7N+mVdImXKVi8XmddufP67xN86kTMZL0lUtzdq6uVU3v9WhrZsdmj53Qb1fHcsax9/+zvsWfZGYiOsnr14adbhQIvH/yQ+168xsTNHzF/Tm+TmNv35aP5qYzFpfpWxotmkuZup8mpkALJIuv6xZd7z3LZqZm9f5C/M6NxvT+bmYjhvn9PyJ0+UNOEfNTVZtXL9aU2cv6NyFWNH2u261Te/e1KLVTVbZrFatssYTpU0Xk62PHz6p6bMXll2PzU1WbWi2afrcnOZSXUBVYO0qm27paNOVLWt0xYZmXXFZ/HH5xd+ff+3NlO+dpe+Vhb73whv67f/vx3mVyafc/Lyp07NzevP8nN48f0HfP3xSf/qtny0r1/2uq2Rft0qnz8/p9Myc3pyZ0+nzF/Tm+Qs6eXo25Xs6nXgiTorNL09WA9lYLNK6VbZkp4uFiWSLTE2dvaALseVXVnOTVVva1l0qY00kguPlXjhxWmdni/dZt3aVVefn5kUWp/xW2yxqv3y91jc3ae1qm9auiv9ct8qmtatteuP0jL719PFl5T73i2/X+65r09pVNq1bHe/UFy9v048nJvUf/+bgsjLZPouX/t/HapHec032/9MVUq5e6yq0XKn/fhYjxnK3Y7lV8z1dKTECHwAAQOlH3ycwCh8AABRTLYysyVYuNm/q4JFJPfqT1/T1J1/VVIZR5Es7Qia+MEyMSkon1WilpaMblzJN6ejUObVfsSEZb7b6rBbpXVe3aM8nOnXuwrzOzsR0ZnZOZ2fm9Eff+Gl8iaVUnQUktaxdpa4trReT6vGE+vkL85o6M5t2VKUkfeIDW/QL77hCmxxrtcmxVodeNlJ+0Zs8LklvvDmjj77zqpQdGjId27s32fWPu35OszEzOTry/IWY/tM/HlLkjdOpO0JIutq+Rr/1gS26EDM1Ozev2di8Jt44o+DPTqSN8/e3X6+PvOMKXb6+WRs3rNa61TY9fvhkxmNLGPild2rjhmYdnTyro1Nn9ZNXp/VCmo4JZ2djOnhkKus+l0qMEk1Ys8qq1nWrZV+7SkenzurMTOrEm0VS2/rV6r7hSsXmpbl5Uxdi8zo+fV5jL6WP49rWtVqzyqa52Lzm5k3F5k1diJk6f2FOp9PUde5CTPufeyPvY7v7q2N6+1Ub1GSzJkeZJkZyP3k09Xvm9/7xkH7++ssvjtRVcqSz1Ro/5u/89ETKe6RP/92YrnWsjSfhz8/p9OxcTgnGTNdOvubNzJ8fkrRulVX2dfHrcENzk9atjs+uMfbSlKbPLe/gIcWPe+OG1brjvVdr3pRipqn5eVOvTp3T919MP/3xe66xy7F2lWLzZrJMzDRlnJ3VxMmzacu1rVulVU1WxealedPUvBm/TmaXXKtLdVyxXm+xr9HaVfFjWtNk1f7nXtfkmdm0x3WVfY1+6/1vlWnGOz4k4pw4dSZlIjLhw2+7XFe0NF8sFz+uE9PnNZrh2n/7VRvUsmZVvA4z3skjNm8qev6CXpk6l7acY90qNVmtMs1L7Wia0mwsc3vkyzSlMwUk2mfm5vXC64V1mHJevl7vurpFmxxr4p/99jX64mMvaDzN57DVIl1/1WX62mdu0bkL8zozE+/4cvr8nD6790lNnDqT9m/TVS3N+s33b4mfs4vnwDRNHTl5Rt/IcK47rlivJqs1/jdwNj5zRT7tnpitpbkpfg4nM/zf4K1t67RutU2meenaN03pzMycTry5fHaBhA3NTWqyWZLXhinpQpGvD0majZkFdY77s8deyLvMp/9uTDdvtmvd6iY1r4on+9deTPyvabLq+HTqmW8Gv/0zvevqFlkUn01ASnRCiX+P9bNjb6Ys9+ehF/SeaxzJ7SwWySKLZJGeSTNDxgPfG9dN1zqki9vGy1yszyI9lWbWhL954ohcb21N1nEpTqWd2eFfnjmuW995lZqbrLIm1jZYINsMGbNz88n3SvT8heTfqtE0s3h86iujumJDc/L/OrNz8xevqZieSvP3s+8ro9qycZ2sVuvydpSpF18/k7Lc7/3jId36jiu0ZrVNzU02Na+yxn9efN+8PJl6NpQvPfaC3r2p5WL7WZJtaJHSzvLyv777ot57jf3SedLCGKVnXi1sJiCUBwl8AAAASQePTOlohi8RTFN6efKsDh6Z0gc6NpYxMgAAUG9qefrrDzjb9KOJSX37J6/psZ++lnb69YWsFumvf3hEv3bzNTkn4RNSTXu+MK5MdS48zmz1zZvxLz8Pv35m0ReW33vhDb08meH/iJKmz13QJ265LmVSfeps6hHFiemB//jOd8tisRR8XFL2tpw341/Gj71sLDu2FzMkoUxJx6bP64ZN9rw6Qnz3+df1Wff1yfjyObZvPXM8OeorW10Wi7S5dZ0+13295ual2Py8LsRMzcXm5X88otemz6dMYlotUscVG/S3v7NNbeubtWaVLdke2TpQnDozq19676a82qNt/eplI9lymUVik32tPJ3X6uSZGb3x5oxOnp7VG2/O6Pj0uZSjgqV44v+pHN5XC02fu5AxmZfO2dlYyiRmYomGN2fm0pbd0XWtbrzWoQ3NTdrQ3KT1zTb9t6//NGMS84ZNLfrHXe+/lAg2TcVi8/oPf31Qz594M225t1112bL2/94Lb2j/c6+njc9UfBmIW991VV7n2mqRvvrJ96U815nKXdu2Lu9rxGqR1jc36e8++XPJct974Q3tG3sl43G9Nn1e77nGkXcnoOnzF/SVBceWS5k1q2wK3P2BlMd1zDiXttxbC2yPd29q0b6+D8jUxU4G86b+rwd/pJ8dj6ZPjl95mb78f22VlOgQEv8M+YO9T2W8Hq/buF5/dOcNMmW5mHQ2FYuZ+pN/+ZlenjybMqlutUgb1jTpL35j66JzdjjD53Dib+D3Xzylj7z9Cq1vbtKVF8tFTqZODkoXz3V0Ru+9Nv9zvb65aVH7m6apO//ih/rpsfRt/66rWzRy9wfU3GRLJlsTdRnn0pdzrFuV9ly/cXombTnnFeuXxZj9+rDrnz8dvz4SHQZi86Z+ffjfMl4jWzaul/f2d8RnvblwabmK545HM352Xm1vlkUWnbsQ07kLsaxLypydjemJ8fxnCRp+fCLvMpL0P/a/mHcZ36PPF1TXH3/j2bzL/O4/HEr+vtpmTSa516yyarXNomNpllH6nb85KJsl3vkiH/t/lv5vQjrn5+YL6uAxfe6CHn7yWN7l/uK7+Z+zQjqT5DPVP0qLBD4AAIAk1xaHvvwbLs3G0vfAX22zybXFUb6gAABAXSpkXd1ir8VbaLmt/29w0Qhl+9pVeu81dv0gw6jUdEl4i0U5jdi1LPgisZDE/89ff3lByfFSJ9UXtkm5OzSUsiPE0uur0GPLZaaFlyfPqnV987KOCcfTfLGfqOfw66cvdtZYd3Ff5WsPKbdZJF41zmnrltblybe/+KF+kiaRZrFIW9rWyXv7OyXFR93Oxeb1pcde0CtG+lkk3mJfo9/54HXJEe3zF5Pjf/+jl/X6mzNpZyi7buN63b/jJrWsXaXL1qzSZWua1NxkzZpIe+61N+W768a8kpg/eTWqcIpOKD977c2M5Za2f7Wd62KVK+fnVTmPK59yz7wa1Y+PTCXLfe+FN/TTY9GMZZ4/8aZeNc4vu66yXY+Rk2dkyrKs3Eun0s+0UOnPb6nwc/3Mq9k7wC1s+0LrWkmMuXRk+z+RyWXnLNs1MnHyjNaubtLt78mvI8QVl61Z1MkgFpvXr375h3o2TWcBiyU+Y8tnPtKhmbl5nbvYYWDmQkwvvnE6Y4L5PZta5Fi3WqYuzkhgSqZMTZ2ZzZhgdl6+XpetXSWZZrJjQ/T8hYzX8TWONVq3uuni9vFyMqUzs3M6EU0/a8LG9avjszLoUnznL8xr+lz6GRoSZmPxUfFvKn3HsITYvKmF3+qtX23ThjXxzmLmxfduOj2d1+rtV23QaptVq5riS/P8r+++qFfSzMKU6ODxR79yg3TxvWlKMudN/fdvPquX0nTmSfzd/ffbNl+aGWluXjMX5vXy5Bn9n0j6jhyJmU0Wtv/02QsZj2tL2zqtb750zhJOn5/TK8byTqqMwq8eJPABAAAkNTfZdMeNV1c6DAAAUOcyffH+e/94SB9628Zlo11M09QPXjyVcn/pypSq3JmZmNrWrdJt77lav/Set+j9zjb1PPB/8kokzMbmdSxNMjEV05SOG+c1MxcrKPFvmmZJEsjpyuWbXPnw2zaWtUNDocdWSEcISQUdW6JNqqVjQkJVdAzJkEgzTenIqbNa19y0KImZcaYxScenz+vtb2lZltj6s9DhjHVNnDyj6fNzuvmtrYvKlSPxXM/nupBy5ewEJKnq26MWYizn5zfnuvIdIX4wfko/ydBZwDSlo5PntKl1Xd6zJlitloJm/9iwpklf+8wtec2ssXFDc/pZE95MP2vCNa1r85414V1Xt+hv/+M2zcRMnb8QX/7n3IU53RN4Ou3yEVaL9ParLtM/9b5fl61ZJZs192N74cSbuq9nceeyoxlmYUp08JBleWeeIxk6QST+7t701hSd9PKc2SSXMvYMM10cm04/Gwqj8CuPBD4AAAAAAECZZPrSd/rcBX3rmdfy2l8hZVZSTpK+tONmffSdV0rKnqxLWPpl9iP/6UOazLA+/FIbN6yWxWLJO/F/bOrcihLI5UiqH3j+jbJ2aCj02ArpCPF+Z1tBx3bg+dfL3jGh3jqG1EryrRKdUKr9XOdb7nsvvKE/C75Qtk5Akqq6PWohxkLPWbk7fEnV3Y6ViLGcn8VS9c1kUM66fnosqp8ef3NZcjzTaPN5Mz7Ly1OvTFdkVpN6nw0F5UUCHwAAAAAAoAyyfalnkXS1fY12fbh90ciaPd+f0PE063mnKlPKclaLdH/oBf3CO+Jf5hWaSNjkWKtNjrXZCy2Rb+L/sjVNuusvn8g7gXxmNla2pPr/3H9YX//dD2rqbPZpZBMK7dBQ6LEV2hHi67/7wbzPWdv6Vbr778JlS2z9XHtrXXYMqYXkW7mTmLVwrgsp98XHntdr0+fL8nn1xe88J4ss1d0etRBjgeesnH+baqIdyxxjuT+L63Umg3LWVQudy2qlkx7KjwQ+AAAAAABAGWRd91rSsenzcl552aLpr49lWM87VZlSlivG6OrZ2Lyam2y5FVqikMR/IaP9L1uzqmyzBBw3zuvyy5p1Teu6nOtKKNexFdoRYjY2n/c5m5krLEFVaGLLYrHUZceQmki+lTmJWQvnupByJ6ZnNHL3B3R6Jpa9wEUr+bwyczzHC8uUsz1qIcZCz1m5/zZVezuWO8ZyfhaXO4ksla/DVznrqoXOZbXSSQ/lZzHNXD+mUE2i0ajsdrump6fV0tJS6XAAAAAAAHnivq70qqmNs631mWC1SO+5xq6v/+4HJSnvMomRNeUqd3z6fN6JhKvt+Y+8ryXHjHN12SblPK5C66rXGNvWr9YHdx/QydO5l7t8/WqZFulUHmWu2NCsA5//iD76xX/Nq66VlAvc/f68k5j1fK5r4dhMU1XfHrUQY7k/9+u1HcsZYzk/i7/v/QXt8P+bnnl1Oudk8Huvsetrn7lFv/a/n8ir3Hs2tcgii545Vl91FVru3Zta9Nr0+bL9HSzkXJe7HRP3CpVSTfd05cQIfAAAAAAAgBKrhZE1hZYrZCr8elbo8gDVrpzHVWhd9RxjIaNuC0lsFTrCt9ByhSYx6/lc18qxlbOueo2xnOq5Hevxs7icy+SUeyaDap/ZgRkylpdbyexZKBwj8GtUo/Y4AQAAAIB6wX1d6VVLGydGtlfzyJpaHZEDAABQj+p1JoNamNmBGTKWl6ukarmnKzdG4AMAAAAAAJTQbGy+6kfWMCIHAACgetTzTAa1MLNDOdVCO6L8SOADAAAAAACUUHOTrW6nvyZ5DwAAAADFRQIfAAAAAACgxGphZA0jcgAAAACg8qyVDgAAAAAAAAAAAAAAAJDABwAAAAAAAAAAAACgKpDABwAAAAAAAAAAAACgCjRVOgAAAAAAAABUofmY9NIT0ukT0oarpC23SFZbpaMCAAAAgLpGAh8AAAAAAACLPfuI9KhXih679FzLJul2n3TDnZWLCwAAAADqHFPoAwAAAAAA4JJnH5H2fWJx8l6Sosfjzz/7SGXiAgAAAIAGQAIfAAAAAAAAcfOx+Mh7mSlevPjco/fGtwMAAAAAFB0JfAAAAAAAAMS99MTykfeLmFL01fh2AAAAAICiI4EPAAAAAAAA6cI56acP57bt6ROljQUAAAAAGlRTpQMAAAAAAABoOPOx+Cj20yekDVdJW26RrLbil8ml3MkXpbG/lp78e+ncVG7xP/E/Jdsq6R2/HP9Z6hiLWa7QugAAAACgDEjgAwAAAAAAlNOzj8TXmV84VX3LJul2n3TDncUrk6ncL/6pZLFIo/+fNPH4gtc2SzOGNHNayTXvUzn+lLTvE/EEuOsTkuu3pWOHihtjKcoVWletoHMCAAAAUPMspmlmuBtDtYpGo7Lb7ZqenlZLS0ulwwEAAAAA5In7utKryjZ+9pF44ntZctwS/7HjK8sTyYWUyVhuKYv09tukrk9Kb9suPfeti+W0pOzF+u74khR9VQp/VTrz+oLXUtVTaIwlKFdoXQnlTI4XUle9d04AAABAw6nKe7oyIIFfoxr1ggUAAACAesF9XelVXRvPx6Q/f8/iBOtSzXbp5z8vWazxf5vz0uP3STPR3MvkWs5ilT70B1Lnf5Acb138Wspk8DXS7bsvJYPnZqXnvyUd/CvpyPfT17OSGItVLmsZSzzZ/dlnUifKy5kcL3RmgVrpnAAAAADkqOru6cqEBH6NatQLFgAAAADqBfd1pVd1bTzxfelv/12lo1jst78ptX849Wu5JnWr8bgK9Z4e6R2/JF31Hmnj2yRbU3mT44XUlbVjSIk6JxSa9KezAAAAAHJUdfd0ZdJU6QAAAAAAAAAawukTuW23+f2XRsQbL0tH/y2/MvmUyxST1ZY+uZ/rPhYqNMZilMu1zE9G4g9JsjVLl79dmhxX6uUBTEkW6dF7pXfesfLk+Hwsvm3auiR9/XelEz+NzyhgxuJljJcyz+ogM77kwUs/lNp/fnl8qToMRI/Hn8+0hEEhSf9ydxYAAAAAahAJfAAAAAAAgHLYcFVu2936Xy8lznMd3b6wTD7lco2pGPsoNMZilMu1zNtvl85OxpPkF85IJ57JUuBicvzQV+Oj95s3XHopl+T4dR+SXn9WOvGs9GIoSyJe8SUAvrc7+3Gk8tWPS61b4ksh2DdLLVdLP96zPL7EcaXrnLCSpH85OwtIzBIAAACAmkQCHwAAAAAAoBy23BJPPEaPK3XS9OJU51tuWVmZlZQrRLljLGU7/vo/xBO18/OScSSe4P63/5320JO+8fvxx4arpLYOqe066WffTFPXxecCvx0fSZ+v9o9Il18vWWzxWN88Lv304ezl5i9Ip16MP3JysXPCtz4vbfmAdNlbpHVXSN/uV95J/6yzCxS5s0CibDlnCQAAAACKxGKaZqr/OaPKNeqaDwAAAABQL7ivK72qbONkQlJanJTMsMZ5IWVWUq4Q5Y6xXO2Y68j95pb46PhCON4qXfluqfky6Zl92bf/7W8unpFgPib9+XuydE64Wvqtr0unX5OmX5WmX5GOPC5NPF5YzNm0tku21VJsVopdkGZPS+eN7OVu+DXp6puk9ZdLa9qkb/6+dPZkmo0vdrr47DPLR8enS/znfF3lWU5itH+x0B7L0SYAgAZWlfd0ZUACv0Y16gULAAAAAPWC+7rSq9o2TjnC9xrp9t15jibOUmYl5QpR7hjL0Y45JccvJpFnotJkRDoVkX72SPyRzZ3/S3J9Iv+60iaspaJ3Trju5+P7fPO1eOJ/7lz2MuX07o9Lb3mvtK5NWtsqNdulhz4lnXkjTYGLHRru/mG8zWMz8Y4Gs+ekr/5qlnIZ2r/co/0LSeqWu5NBvuVqZbmEctZVaJvUa3sA9YBrH8hL1d7TlRgJ/BrVqBcsAAAAANQL7utKr6rbuF6TJNWeICykTCmT40tH069k1oRSdk5ItE+ux+X+79I1rvgofNsq6bWfSN/4v7OXe/fHpKa18VH3b7wQX8ag2nR9Urr+F6WNb5Nat0jPf7v8o/0LSeqWu5NBvuXK3R6Flit3XYVeW/XYHgn1+vez3GqhHesxRjoqFU89vz+xSFXf05UQCfwa1agXLAAAAADUC+7rSo82RtGUIzleaF1L6y1l54RCj6uUnQVu+DVp1Trp3FT8YRyJzxaQK+sqqalZMk3pwpncy8ULSxaLZMbSvG6RLnuL9PtPS02rLz2dbI9j6csVc3mAci8pkG+5crdHoeXKWVehbVKv7bGwLJ0MVl6uFtqxHmOko1Jq5ZydpND6qr1jSJ1r1Hs6Evg1qlEvWAAAAACoF9zXlR5tjKIqx8j9QutaiXw7DBR6XOXqLJBr4v83H5KcH5Ws1vzKbfmgdD4qTY5LF85m3z5h1XqpeYO0ekP835Pj2ct89L9I126Ll1m9XmpaI/31L0mn03VQuNhh4Hcek+YvSHPnpdkz0j/++/isBumsvzI+G8Say6RVa+OxWm35JZDnY9LcTLy+Bz6UIUZJa9vi19f8hXiZ138mHdyTvT0++AfSppviHTaa1ki2Zmnfb+a/7EEhyfGcylwt3f2EZM7Hl2WIzUoXzkl/+yvSmdfTH9faVsn9x/GOILEL8XInD0vhv83SIJI++Nn4EhJNa+KdUb7+mQznutztUaS6EuhkULy6qr0d6zFGOioVb8aQen5/rqRcHXcWaNR7OhL4NapRL1gAAAAAqBfc15UebYyKW8lo+nIqyhTAORxXOToLlGuWANOUDj4o/cvn0x9vLbNY44nobGxrJHNOmp8rfUyF2vAWaV1bPMm9am2848WxQ9nLXX1TvPPE3Ix09pQ0NVH6WMvBYrvYCWJ1vE3mY5k7XCRctkmyNsU7XsyekWai2cusu1xqviw+y4VtdbwtTz6fvdyNvx5fpqJpdbyjhtUmHfgT6byRvsyGK6VPfENatSZel8UmDX9EevN4mgIN2MmgFjprlCvGuVnpnCH5PxT/25fO2lZp+3+Lfx7Ox+KfdbFZ6ft/lvk9sGqd9O5fi/+tmI/Fr8Mj30+/fYLzo5L9mniHHNuq+Gfxob+TZk+nL7PGIf3in8TfZ1ZbvKzFFl+65uyp9OXWbZTuuF/SxWOLzUqPDmR+n62/QvrNh6U1LfHPx+YN8br+x3vLM2NIPb8/V1qu3DONlFGj3tORwK9RjXrBAgAAAEC94L6u9GhjVIUaGNlUkIquF5yls0C5ZgnIddT+zr+XrrpBmjkdT8K8/CNp/x9lL3f5O+JtM3sm/jg/HU+eZmOxXRyx3xxv73OT2cs0rY0nb9IuB1BkV7xTsm+Ox3h+OrfE1ibXpQT8hfPxkfeZZhaoJGtTPIksMz4KP5u33Cg53hovY1sVT7q9GMpeblOntHpdPDH+5nFp+uiKQ284LdfEE6C2VfH2v3BWOvGT7OXe45E2Oi+Vs9ikx4fi13M66y6Xdv7dpQ4NFqv01V+VTqeboWEFSe7L3iL9x29f+uyYiUpHfyz94M+yH9umrfHk7Pxc/Fo8+UL2Mle8K54QtjXFE8gzUenoj7KXu3ab1NwS/2ybj0lnTkknn8te7i03Sesvj7f/OUM6+m/Zy6y/Kt7haObN+OcdiiPXDl83/XvpynfF/z6tWid9579k/vu0tk267U/jn6GJv4NvPCc9+7Xsdd24M17XqvUX61sj/cs9mTs0rL9C2vFVSWb82p+bkR7uy1xmw1XSf3w03qFh1br43yhzvrydXiox00iZNeo9HQn8GtWoFywAAAAA1Avu60qPNgbqRNHWxy3yLAHlGu2fkGuHgd/+ptT+4cLKzM1KF85I4/8qjfyH7OU+vke67kMXp7RfLb0yGk9I5hNjqdvjl4aky98eT8bMnZOOPSX98P7s5T70n6Wr3xsfAX7yBSn0/2Qv85sPS85fyH9phoXtIRXWJrnW1fM38aUI5mbij6M/lr59T/Zyt/viyVZbk/TaM9LXfzd7mX93v3Tlu6XYTPzaOnZI+u6fZC/3jjviydnYbDzGqYncZk1YtVaSJV6ummeFyJet+eJ77GJy3IxlWDoCRXf1zfEONtam+GP6FenlJ7KXe/fHpU03x8tMvST92J+9TOfvSI5rpdjFmU1OPCM9/+3s5a56T/w9M39xKY7TJ3KbNaTtbfHOHlardOak9Pqz2cusvuzSMi1YwhJ/v8ZyaJuWzfFZRubn4udt9ox0fip7uU1b4/8vWbUu3hnopw/Fy6aztlX65S9enNHBdnEWIUmP/G6GzgkZZjKogEa9pyOBX6Ma9YIFAAAAgHrBfV3p0cZAgyvHLAHlGu2fiCvfpG65OxkUWq6al0sod10J+bZJPbdHIR0hIt+TvpLD6NHbBqUr3xlPesZmpePPSI/7spd7153xEbuJzgKnxqVXfpy93PrLLyb4Li5FcCFD4m2lLLb48hFr7PFR7ua8dPzJ7OU+9DnpqnfHE35vHJa++/9mL/PRP4wvexCbiyd3Tzwr/duXs5e75fekK2+4OGtFk3TysPTdP81e7sOflzZ2xNvxjeekf/vf2cv88helLR+ML+vQfJl07Mn8OxxJhV2P5bz2Cy2Xb5nYXHxWmfHv5tbh6x2/HL8WZ0/H3y+5dBa48gapzRmfEWL1OunclPTTh3Oo6w5prSNe1+xZyXgpt5kk1l8Rn5HDaovPmhN9JXsZ66rcZsepRUuvqwpp1Hu6pkoHAAAAAAAAAABFZ7UV9sVzPuVuuDOeSE25hmyG0f6FlLPa4qOg931C8SRuiqTu7bsXJ38KKVOJcuVqj0LLlbs9pPzbpJ7bY8st8ePOlvzccsulp677UG5lfq5vcX3v+GXpya9mL+f5m8ISrT1/k3/C9K4Hpau3xpOEsVnp6Kj0L5/LXu4TXy9sZodb/+vizhpjf5W9zIc/v7yzxrMPZy/n/qPl5cb+Onu5j/7h4hif/Vr2Ml2/s7iu9g/nf11JhV2P5bz2Cy2XbxlbUzxJfsOduZXb+Xf5zxjyS0PLr+GjP8qhrq8W+P786/zfn7/1cLxNLpyNdxaY+J700K7s5W4blK5xXRoV/9oz0jd+L3u5D31Osl8bX1rglYO5LSlw+TvinXnmYxdn8DgZ79SQzekT2bdByVgrHQAAAAAAAAAA1Kwb7pQ++5P4SLW7/ir+87PPZF87tpByiaRuy9WLn2/ZlH60fyFlKlWuHO1RaLlyt0eibD5tUq/tkUh+SkomO5OydDLIp8xKyiWSn8vKLCjbck3qhGm2Mu/+uHT52+Jrel99k9T1H/Kvq9BjK3c71muMUvmu/ULLlbOuQt4vK4mxlO/PxCw9zZdJl10lveeu3Mr9XJ/01vdLm7fFE/lbfzO3crf+V2nbJ6Vb/pO07VNptl3iji9Jv/Oo9KmgtOuA9Ks5zI4hxWchQsUwhX6NatQpIwAAAACgXnBfV3q0MYC6VcjyAOVYUqAY5QpRzhhpj8rV9ewjKWYkuCbzbBeFlFlJXfkuBVHOZTgWlq3mdqznGKXyXfuFlitXXZW4hqv9/VnNS6dUUKPe05HAr1GNesECAAAAQL3gvq70aGMAAOoMnQxWXq7QY6uFTkC1EGOh6rEdy30N18L7s1wdIVbSgaLMGvWejgR+jWrUCxYAAAAA6gX3daVHGwMAgLKr5oQpUG3KfQ3XwvuzXB0hVtKBoowa9Z6OBH6NatQLFgAAAADqBfd1pUcbAwAAAKh7ddwJqFHv6ZoqHQAAAAAAAAAAAAAAoABWm9T+4fKVQ8lZKx0AAAAAAAAAAAAAAAAggQ8AAAAAAAAAAAAAQFUggQ8AAAAAAAAAAAAAQBUggQ8AAAAAAAAAAAAAQBUggQ8AAAAAAAAAAAAAQBVoqnQAAABA0nxMeukJ6fQJacNV0pZbJKut0lHlrsjxm6app1+Z1o3X2mWxWIoYKAAAAAAAAAAA1YsEPgAAlfbsI9KjXil67NJzLZuk233SDXdWLq5clSD+hw+9qs/te0r377xJH9t6bZECBQAAAAAAAACgujGFPgAAlfTsI9K+TyxOfktS9Hj8+WcfqUxcuSpB/HOxed0ffEGSdH/wsOZi88WIFAAAAAAAAACAqkcCHwCASpmPxUeuy0zx4sXnHr03vl01KlH8jzx1TEenzkmSXp48q288fSxLCQAAAAAAAAAA6gMJfAAAKuWlJ5aPXF/ElKKvxrerRiWIPzH6PrHqvcXCKHwAAAAAAAAAQOMggQ8AQKWcPlHc7cqtBPEnRt8nxvSbJqPwAQAAAAAAAACNgwQ+AACVsuGq4m5XbkWOf+no+wRG4QMAAAAAAAAAGgUJfAAAKmXLLVLLJmlZyjrBIrVcE9+uGhU5/qWj7xMYhQ8AAAAAAAAAaBRNlQ6g0oaHhxUMBtXW1iZJmpycVF9fn9xud9HqGBoaUjAY1OTkpCSpra1NHo9Hvb29RasDAFCDrDbpdp+07xOKJ8Evpa7NRFL89kFZrLaKhJdVhviTSf3bd8e3y2Lh6PulCXzp0ij8X7lxk5ps9D8EAAAAAAAAAKRXyznghk7gd3d3y+l0KhAIJJ8zDEPbt2+X2+2Wz+db0f4jkYj6+vrU19enYDC4qA6v16uOjg6NjY3J4XCsqB4AQA274U5px1ekR71S9NII83NrrtIfRH9dt8906mMVDC+rNPGrZVM8eX/DnTnt5uCRKR2dOpf29cQo/INHpvSBjo0rjRoAAAAAAAAAUKdqPQdsMU0z1UC3uufxeGQYxqJGTTAMQ+3t7fL5fCvqIdHZ2an9+/enPTnDw8Py+XwaHx/Pe9/RaFR2u13T09NqaWkpOEYAQJWYj0kvPSGdPqHYuit1a2BGLxmzemvbOh34zx+p/lHnC+LXhqvi0+bnMXPAzFxMoWdf12wslnab1Tab3DdcqeamKp2RAACAPHFfV3q0MQAAAADUrkLu6Wo9Byw1aAI/FAqpu7tbwWAw7TQJXq9XQ0NDmpqaKqh3hNfr1caNG9Xf359xu87OTu3cuTPrdkvxJQQA1K+Hwq/oc/ueSv77/p036WNbr61gRAAAoBS4rys92hgAAAAAale+93T1kAOWpCofzlcafr9fkjKucbBz505J0r59+wqqIxQKyeVyZd3O7Xbr4MGDBdUBAKg/C9eCly6t/T4Xm69oXAAAAAAAAAAAVLN6yQE3ZAJ/ZGRETqcz4zaJ1xMnOl+RSEThcLigsgCAxvXIU8d0dOqcEtPjJNZ+/8bTxzKWAwAAAAAAAACgkdVLDrjhEviJBs128hJTJhR6ApxOpwYHBxWJRDJul5jKAQCApaPvExiFDwAAAAAAAABAevWUA264BP7o6Kik7Cdv4TaFnEC32y3DMNTZ2amRkZGU2wwPD8swDPX29ua9fwBA/Vk6+j6BUfgAAAAAAAAAAKRXTznghkvgj4+PS7rUuyKTxDaTk5N51zMwMCCn0ynDMOTxeOTxeGQYRvL1UCgkr9erQCCQ974BAPUn3ej7BEbhAwAAAAAAAACQWj3lgBsugV+IhY2eK4fDoWAwKJfLJSm+5kJ7e7tGRkbk9Xrl9Xo1NjaWfB0A0NgOHplKOfo+ITEK/+CRqbLGBQAAAAAAAABAParWHHBTwSVrVCEnopDeF1J8+oWxsTH19fUlp0rweDxyu90aGxsraJ8AgPrk2uLQl3/DpdlYLO02q202ubY4yhcUAAAAAAAAAAA1oJ5ywA2XwC/0RKxEZ2en3G63RkdHZRiGQqGQuru7FQgEcprGQZJmZmY0MzOT/Hc0Gi1RtACASmhusumOG6+udBgAAAAAAAAAAFSVpXnR5uZmNTc3L3quVnPAqTCFfgkZhqHu7m5JUjAY1MTEhHp6eiTF1z9ob29XKBTKaV+Dg4Oy2+3Jx+bNm0sWNwAAAAAAAAAAAABUg82bNy/Kkw4ODlY0nmLmgFNpuAR+W1tbWcoYhqHOzk55vV719vZKiq+JEAgEkr0uEic3HA5n3d/AwICmp6eTj6NHj+YdEwAAAAAAAAAAAADUkqNHjy7Kkw4MDCzbplZzwKk0XAK/XDwej/r6+uR2u5e91tPTo4mJCblcruS22TQ3N6ulpWXRAwAAAAAAAAAAAADq2dIc6dLp88up2DngVBougZ9Yb8AwjKzbJrbJd42C4eFhjY6Oqr+/P2McY2NjcrvdikQiK5pGAQAAAAAAAAAAAAAaVT3lgBsugb9t2zZJUiQSybptYpuurq686ggEAtqxY0fO20oqeAoFAAAAAAAAAAAAAGhk9ZQDbrgEfmLKgsnJyYzbLex5kW/vi0gkoo6Ojpy2dTgccrlcGh8fz6sOAAAAAAAAAAAAAEB95YAbLoHvdDrlcDiy9r5IvJ5rL4qFHA5HXiejra0t55MNAAAAAAAAAAAAALiknnLADZfAl6Te3l4ZhpFxyoLEegQejyftNunKu93uvNYzCIVC6unpyXl7AAAAAAAAAAAAAMAl9ZIDbsgEvs/nk8PhkN/vT7uN3++X2+2W2+1O+brH41FnZ6daW1uTUy0kDAwMaHJyUkNDQ1lj8Xq96u/vl9PpzOsYAAAAAAAAAAAAAABx9ZIDbsgEviTt2bNHw8PDKXtQDA0NaXJyMuPJTfSuMAxDo6Oji15zOBwKBAIaHBzMeAK9Xq/C4bB8Pl+BRwEAAAAAAAAAAAAAkOojB9ywCfyenh4Fg0F5PB4NDw8rEokoEonI6/Vq7969mpiYyNgjItGDI10PDbfbrYmJCR08eFAdHR3q6+vT8PCwhoeH1dfXp46ODnV0dCgYDJbyMAEAAAAAAAAAAACgIdRDDthimqZZcOk6EQqFFA6H5XA41NXVJZfLVdT9J3poFLOOaDQqu92u6elptbS0FClSAAAAAEC5cF9XerQxAAAAANSuld7T1WIOWCKBX7P4EgIAAAAAahv3daVHGwMAAABA7WrUe7qGnUIfAAAAAAAAAAAAAIBqQgIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqQAIfAAAAAAAAAAAAAIAqUFMJ/AMHDlQ6BAAAAAAAAAAAAAAASqJmEvgTExPq7u5WNBqtdCgAAAAAAAAAAAAAABRdzSTwDcOQJLW0tFQ2EAAAAAAAAAAAAAAASqAmEvjRaFR+v7/SYQAAAAAAAAAAAAAAUDJN5arooYcekt/v1+joaHI0PQAAAAAAAAAAAAAAiCt5An96elput1vhcFiSZJpmwfuyWCzFCgsAUA/mY9JLT0inT0gbrpK23CJZbZWOCgAAAAAAAAAAoCAlT+Dv2rVLY2NjkiSXy6Wuri45HI689mEYhvbt26fp6ekSRAgAqEnPPiI96pWixy4917JJut0n3XBn5eICAAAAAAAAAAAoUEkT+NPT0xoZGVFfX592794tu91e8L7cbrd27txZxOgAADXr2UekfZ+QtGRWl+jx+PM7vkISHwAAAAAAAAAA1BxrKXceCoXkdrv1l3/5lytK3ktSZ2enJCkajRYjNABArZqPxUfeL03eS5eee/Te+HYAAAAAAAAAAAA1pKQJ/MnJSe3YsaNo+9u6dWvR9gUAqFEvPbF42vxlTCn6anw7AAAAAAAAAACAGlLSBL5hGHI6nUXZV3t7u0ZHR9XS0lKU/QEAatTpE8XdDgAAAAAAAAAAoEqUNIHvdDoViURKWQUAoNFsuKq42wEAAAAAAAAAAFSJkibw3W63gsFgKasAADSaLbdILZskWdJsYJFarolvBwAAAAAAAAAAUENKmsC32+3q6urSgQMHVryv6elp3XbbbYpGo0WIDABQs6w26XbfxX8sTeJf/Pftu+PbFZFpmnrqqCHTNIu6XwAAAAAAAAAAgISSJvAl6Z577tHu3bv11FNPrWg/k5OTCoVCRYoKAFDTbrhT2vEVqeXqxc+3bIo/f8OdRa/y4UOv6le//EN97clXi75vAAAAAAAAAAAASWoqRyWPPfaYduzYoY0bN8rn86mlpSXvfUQiEUkqqCwAoA7dcKf0zjukl56QTp+Ir3m/5Zaij7yXpLnYvO4PviBJuj94WL9y4yY12UreBw4AAAAAAAAAADSYkibwjxw5kky833333XrsscfU2toql8slp9Opbdu2yeFwZNyHYRiSpAceeKCUoQIAapHVJrV/uOTVPPLUMR2dOidJennyrL7x9DF9bOu1Ja8XAAAAAAAAAAA0lpIm8IPBoO6+++5Fz5mmqXA4rHA4rJGRkZz3ZZqmLJalax0DAFBaidH3FkmmJIuFUfgAAAAAAAAAAKA0Spp5aGtrk2maix6Slj2XywMAgEpIjL5P/CUyzUuj8AEAAAAAAAAAAIqppCPwnU6nJKmjo0MPPPCAnE6n2tra8trH5OSkJKm/v18PPfRQ0WMEACCdpaPvExiFDwAAAAAAAAAASqGkCfzE+vZer1fbt28vaB92u12SNDAwQAIfAFBWidH3Sy0chf+xrddWIDIAAAAAAAAAAFCPSj6FvnRpJP5KtLa2yjRNRaPRFe8LAIBsFo6+TyUxCn8uNl/WuAAAAAAAAAAAQP0qaQLfbrfL7/erq6trxftqb2+X3+9XS0tLESIDACCzg0emdHTq3KKp8xdKjMI/eGSqrHEBAAAAAAAAAID6ZTFNM11uAlUsGo3KbrdrenqaTg0AUAIzczGFnn1ds7FY2m1W22xy33ClmptsZYwMAADUC+7rSo82BgAAAIDa1aj3dE2VDgAAgGrU3GTTHTdeXekwAAAAAAAAAABAA6lYAv/JJ5/U3r17FYlEFIlE1NbWJofDoe7ubrndbl133XWVCg0AAAAAAAAAAAAAgLIrewL/oYcektfrVSQSSfn6yMiIJMnj8Wj37t0k8gEAAAAAAAAAAAAADcFazsp27twpj8ej8fFxmaaZ8REIBNTR0aG/+qu/KmeIAAAAAAAAAAAAAABURNlG4G/btk1jY2OSJLfbre7ubjkcjuTU+YZhaHJyUoZhKBgManR0VIZhqLe3V5L0yU9+siRxDQ8PKxgMqq2tTZI0OTmpvr4+ud3uotZjGIYGBwc1MjIih8MhSXI6nfL5fHI6nUWtCwAAAAAAAAAAAAAaVS3ngMuSwN+5c6fGxsbU39+vgYEB2e32jNvfc889kuLT6Xu9XvX29srpdOqjH/1oUePq7u6W0+lUIBBIPmcYhrZv3y632y2fz1eUeoaHh+X1euXz+TQ+Pp58PhwOy+PxaP/+/ckTCgAAAAAAAAAAAAAoTK3ngC2maZpFiTCN/fv3q7u7W6FQSLfeemve5aenp3XrrbfqzTff1AsvvFC0uDweT3K0/1KGYai9vV0+ny85A0ChhoaGNDg4qLGxsWW9LBI9MgzDkN/vz2u/0WhUdrtd09PTamlpWVGMAAAAAIDy476u9GhjAAAAAKhdhdzT1XoOWJKsK4osB/fee68CgUBByXtJstvt2r9/v06ePKmHH364KDGFQqHk6P5UHA6Hent71dfXJ8MwVlSP1+vVnj17Uk6R4PV6NTQ0pEgkUnAdAAAAAAAAAAAAANDo6iUHXNIE/vT0tKampnTXXXetaD8Oh0O7d+/WP/3TPxUlrkRPh0xrHOzcuVOStG/fvoLr6evrk8vlUk9PT8rXOzs75XA41N3dXXAdAAAAAAAAAAAAANDo6iUHXNIp9P/5n/9ZkUgkuab9Sl1//fU6fPjwivdjsVjkdDoXrUWwlGEYam1tlcvl0tjYWN51DA8Pq6+vT36/f8VTMKTCNIAAAAAAUNu4rys92hgAAAAAale+93T1kAOWSjwCPxKJqLOzs5RV5C0cDktSyukMFnI4HIu2z1eih8eOHTsKKg8AAAAAAAAAAAAAyK6ecsAlTeA7HI4VrR9QCqOjo5Kyn7yF2+R7Ag3DUDgclsPhSF4EAAAAAAAAAAAAAIDiq6cccFPJ9iypra1NkUikKPuanp5WMWb7T0yZkEujJraZnJzMq45QKCTp0sk3DEODg4PJ1yORiLZt26b+/v689gsAAAAAAAAAAAAAWKyecsAlTeC73W51dXXp85///Ir3tWfPHnV3dxchqvzlO4vAwYMHJcU7MCROnM/nW7RNX1+fOjo6NDY2xih9AAAAAAAAAAAAACijas0Bl3QKfbvdrvb2dn3pS19a0X4mJiY0ODgoj8ez4pgKmdI/394XiTocDkfKEyddWh9h+/bteccDAAAAAAAAAAAAAIirpxxwSRP4krR792719/fr4YcfLqj8kSNH9Iu/+ItyOp269dZbVxxPvidiJXWEw2F1dHSk3c7r9SocDmtkZCTrPmdmZhSNRhc9AAAAAAAAAAAAAKCeLc2RzszMLNumVnPAqZQ8ge9yufSpT31KPT09+sxnPqMjR47kVC4ajeqLX/yiOjs7FYlEtGfPntIGWgKRSEQ7duxI+7rb7ZYUP4nZDA4Oym63Jx+bN28uWpwAAAAAAAAAAAAAUI02b968KE+6cN35SihmDjiVpoJK5cnv9ysSieiBBx6Q3++X0+mU2+2Ww+HQxo0b5XA4ZBiGTp06JcMwNDo6qnA4LEkyTVOBQEA333xzUWJpa2sreZnE9k6nM+PaBk6nU1L8JEcikeS/UxkYGNDnPve55L+j0ShJfAAAAAAAAAAAAAB17ejRo2ppaUn+u7m5edk2tZoDTqUsCXxJCgaD6uvr0549ezQ+Pq5IJJJxe9M0k+VqbZ34xAnLdOIWbmsYhsLhcMaT19zcnPJiBAAAAAAAAAAAAIB61dLSsiiBXymlyAGnUvIp9Bfy+/0aHR3V1q1bZZpmxkdvb6+mpqaKnrxPNKhhGFm3TWyTy0lYaOPGjZLy67VRjnUZAAAAAAAAAAAAAKDe1FMOuGwj8BNcLpfGxsY0PT2tffv2aWxsLBm40+nUtm3bdNddd5Ws/m3btklS1hkAFm7T1dWVVx0ul0sSSXkAAAAAAAAAAAAAKLV6ygGXPYGfYLfbtWvXLu3ataus9ebasAt7XuTb+yJxsnO5QBL15Dt1AgAAAAAAAAAAAACgvnLAZZ1Cvxo4nU45HI6sDZt4fceOHXnX4XA45HK5ZBhGxmkaFr7mdrvzrgcAAAAAAAAAAAAAGl095YBrKoH/0EMPFWU/vb29MgxD4XA47TahUEiS5PF40m6TqXxfX9+i/WSqo7e3N2O8AAAAAAAAAAAAAID06iUHbDFN0yyoZJlNTEzobW97m6amptTS0rLi/bW2tmrHjh3y+/0pX+/o6JDT6VQwGEz5usfj0cjIiBwOhyYmJlJOsdDR0SGHw6GxsbGU++ju7lYoFNL4+Hje0ydEo1HZ7XZNT08XpT0AAAAAAOXFfV3p0cYAAAAAULsKuaer9RywVEMj8BPTGRTrhnvPnj0aHh5O2YNiaGhIk5OTaU+sdKnnhGEYGh0dTblNIBBQOBzW0NDQsteGh4cVCoUUDAYLOnEAAAAAAAAAAAAAgEvqIQfcVFApSQ8++KDa2tr08Y9/PO02Tz75ZNoDy9cDDzxQlP0k9PT0KBgMyuPxyOv1Jtcf8Pv9CoVCaXtUJPh8Pnm9XnV1daVdu8DlcmlsbEwej0cHDx5Ud3e3JCkYDCocDmtsbEwul6uoxwUAAAAAAAAAAAAAjagecsAFTaG/c+dOjYyMSJK8Xq++8IUvpNzu3nvv1X333VdwcAuZpimLxaJYLFaU/S0UCoUUDoflcDjU1dVVkqR6og4pflLTnfBcMQ0gAAAAANQ27utKjzYGAAAAgNq10nu6WswBSwUm8K1WqywWi0zTVEdHhw4fPpxyu/vuu09er3fFQSaUKoFfi/gSAgAAAABqG/d1pUcbAwAAAEDtatR7Omshhe666y4l8v6ZehEk5vXv7u7W2NiYpqamCnqMj4/rrrvuKiRUAAAAAAAAAAAAAABqQlMhhQKBgPbs2aO2traMiXWHwyGLxSKfz6ebb7650Bhlt9s1MDCghx56qOB9AAAAAAAAAAAAAABQzQpK4EvSrl27sm7jdDplmqYcDkeh1SS1trbKNE1Fo9GGmiIBAAAAAAAAAAAAANAYCppCP1ft7e0aHx/XddddV5R9BQIBkvcAAAAAAAAAAAAAgLpU0gS+FE+8F0um6foBAAAAAAAAAAAAAKhlJU/gAwAAAAAAAAAAAACA7Koqgf/ggw/q+uuvl81mk81m07Zt2/SHf/iHikajlQ4NAAAAAAAAAAAAAICSKmkCf//+/Wpra9PGjRuXPQ4cOLBo2507d6qvr0/j4+Oy2+3avn27TNPU7t271dXVpZdeeqmUoQIAAAAAAAAAAAAAUFElTeBv375d9957r6amptTa2qpdu3ZpdHRUp06d0q233prc7tOf/rQCgYBM01RfX58mJyf12GOPaXR0VJOTk7rpppvU09NTylABAAAAAAAAAAAAAKiokk+h39HRoZ6eHr344ovavXu32tvbF71+6NAh+f1+WSwWeTwe/eVf/uWi1x0ORzK5v3TUPgAAAAAAAAAAAAAA9aLkCfzdu3dr3759aV/3+/3J330+X9rt9uzZo0AgUNTYAAAAAAAAAAAAAACoFiVN4O/fv1+9vb0ZtwmFQrJYLHK73bruuuvSbrd161ZFIpEiRwgAAAAAAAAAAAAAQHUoaQI/Eolo27ZtaV+fnp5OJuVdLlfW/U1OThYtNgAAAAAAAAAAAAAAqklJE/iGYcjhcKR9PRQKJX/v7u7Our/W1tZihAUAAAAAAAAAAAAAQNUpaQLf4XBknPb+4MGDyd+7urqy7s9isRQlLgAAAAAAAAAAAAAAqk1JE/htbW0ZE/gjIyOSJKfTqZaWloz7mpiYkN1uL2p8AAAAAAAAAAAAAABUi5Im8F0ul8bGxlK+NjExoUgkIovFop6enqz7uvfee3X33XcXO0QAAAAAAAAAAAAAAKpCSRP47e3tOnjwoF566aVlr/X19aX8PZWBgQGZpqlbb7216DECAAAAAAAAAAAAAFANSprAl6Tdu3fL7Xbru9/9bvK5T3/60wqFQsnR99ddd13KsgcOHND111+vkZER7du3r9ShAgAAAAAAAAAAAABQMU2lrsDtdmvXrl3avn27LBbLotdcLpf27t276LkDBw4oEAgoFAopEonINE1ZLBa9733v0759+9Im+wEAAAAAAAAAAAAAqGUW0zTNclQUDoe1d+9eHTp0SA6HQ93d3dq1a9eibe67775lCf2FOjo6Mr7eSKLRqOx2u6anp9XS0lLpcAAAAAAAeeK+rvRoYwAAAACoXY16T1e2BD6Kq1EvWAAAAACoF9zXlR5tDAAAAAC1q1Hv6ayVDgAAAAAAAAAAAAAAANRYAv+hhx6qdAgAAAAAAAAAAAAAAJREzSTwJyYm5PF4FI1GKx0KAAAAAAAAAAAAAABFVzMJ/EgkIkkNtb4BAAAAAAAAAAAAAKBxNBVa8MEHH1RbW5s+/vGPp93mySef1OjoaKFVLPLAAw8UZT8AAAAAAAAAAAAAAFSjghL4O3fu1MjIiCTJ6/XqC1/4Qsrt/umf/kn33Xdf4dEtYJqmLBZLUfYFAAAAAAAAAAAAAEC1KWgK/UAgICmeVE/8nsrGjRtlmmZRHgAAAAAAAAAAAAAA1LOCEvh33XVXMqnudrvTbud0OiVJ3d3dGhsb09TUVEGP8fFx3XXXXYWECgAAAAAAAAAAAABATShoCv1AIKA9e/aora0tY2Ld4XDIYrHI5/Pp5ptvLjRG2e12DQwM6KGHHip4HwAAAAAAAAAAAAAAVLOCEviStGvXrqzbOJ1OmaYph8NRaDVJra2tMk1T0WhULS0tK94fAAAAAAAAAAAAAADVpKAp9HPV3t6u8fFxXXfddUXZVyAQIHkPAAAAAAAAAAAAAKhLJU3gS/HEe7Fkmq4fAAAAAAAAAAAAAIBaVvIEPgAAAAAAAAAAAAAAyK4qE/gTExN68MEHFY1GKx0KAAAAAAAAAAAAAABlUbYE/v79+7Vt2zbZbDa9733vy7hte3u7XnzxRbW3t+tLX/pSmSIEAAAAAAAAAAAAAKByypLAf/DBBxUIBDQ2NibTNDU2NqYDBw5kLLN7926Nj4/rjTfe0G233VaOMAEAAAAAAAAAAAAAqJiSJ/APHTqkYDCoBx54QFu3bk0+39XVlbWsw+HQ7t27tX37dn36058uZZgAAAAAAAAAAAAAAFRUyRP4u3fv1p49eyRJBw4cUCAQ0IsvvqiWlpac99Hf369Tp07pySefLFGUAAAAAAAAAAAAAABUVkkT+NPT05qamkom6+12u+666y61t7fnva+BgQH5/f5ihwgAAAAAAAAAAAAAQFUoaQJ/dHRU3d3dRdnX1q1bNTo6WpR9AQAAAAAAAAAAAABQbUqawI9EImptbS3a/gzDKNq+AAAAAAAAAAAAAACoJiVN4EvFTbpPTk4WbV8AAAAAAAAAAAAAAFSTkibw29raFAwGi7KvQ4cOqa2trSj7AgAAAAAAAAAAAACg2pQ0ge92uxUMBvXSSy+teF/33nuv3G53EaICAAAAAAAAAAAAAKD6lDSBb7fbtX37dnk8nhXt57777lMoFFJfX1+RIgMAAAAAAAAAAAAAoLqUNIEvST6fT6Ojo3rf+95X0Ej8u+++Ozn6/uabby5+gAAAAAAAAAAAAAAAVIGSJ/BdLpd2796t0dFROZ1O/fqv/7oOHDiQscyRI0c0MDCgjRs3as+ePbLb7fL7/aUOFQAAAAAAAAAAAACAimkqRyX9/f0aHx/Xnj17FAgEFAgEJElOp1MOh0NtbW2SpMnJSUUiERmGIUkyTVMOh0MHDhzQddddV45QAQAAAAAAAAAAAACoiLIk8CXJ7/ers7NTd999d/K5SCSSclvTNCXFR+8HAgG1t7eXJUYAAAAAAAAAAAAAACql5FPoL9Tb26upqSndc889cjqdMk0z5SORuB8dHSV5DwAAAAAAAAAAAABoCBYzMdy9AiYmJhSJRBSJRNTW1ian0ymn0ym73V6pkGpGNBqV3W7X9PS0WlpaKh0OAAAAACBP3NeVHm0MAAAAALWrUe/pyjaFfirt7e1qb2/X9u3bKxkGAAAAAAAAAAAAAAAVV9Yp9AEAAAAAAAAAAAAAQGoVGYH/5JNPKhQK6dSpU+ro6NCnPvWpZds8+OCD2rFjR0NNhwAAAAAAAAAAAAAAaFxlTeB/8Ytf1ODgoAzDSD7ndDpTJvCnpqbU3t6uoaEhffKTnyxjlAAAAAAAAAAAAAAAlF9ZptCfnp7W9ddfL6/Xq6mpKZmmmXykc8899+jUqVM6fPiwbrvttnKECQAAAAAAAAAAAABAxZQlgd/V1aXx8XGZpqne3l4FAgGNjY1pcnJS7e3tGcvu3r1bN998sz796U+XI1QAAAAAAAAAAAAAACqi5FPo33vvvRofH5fX69W9994ru92+6PXW1tas+/D5fOrq6tKRI0d03XXXlShSAAAAAAAAAAAAAAAqp+Qj8IeGhjQ8PKzBwcFlyft8+Hw++Xy+IkYGAAAAAAAAAAAAAED1KGkCf//+/XK73frUpz614n1t375doVCoCFEBAAAAAAAAAAAAAFB9SprAj0Qi2rFjRymrAAAAAAAAAAAAAACgLpQ0gW8YhpxOZ9H2Nzk5WbR9AQAAAAAAAAAAAABQTZpKuXOHw6FIJKJbb711xfuamJhQa2trEaJabHh4WMFgUG1tbZLinQT6+vrkdruLXtfSesfHx+Xz+UpaDwAAAAAAAAAAAAA0klrOAZc0gd/V1aV7771Xn/rUp1a8r6GhIXV3dxchqku6u7vldDoVCASSzxmGoe3bt8vtdpcsuW4Yhvr6+tTf31+S/QMAAAAAAAAAAABAI6r1HHBJE/hbt27VwYMH9fDDD+tjH/tYwfvZv39/spdEsXg8HkmS3+9f9LzD4dD+/fvV3t6ujo4O9fb2Fq3OhF27dhV9nwAAAAAAAAAAAADQyOohB2wtyl4ySIzA/+53v5vyddM0M5Y/cOCAduzYIZfLVZSp+CUpFAppZGREXq835esOh0O9vb3q6+uTYRhFqTNhZGSkqPsDAAAAAAAAAAAAgEZXLzngkifw+/v75XA45Ha79ZnPfEZHjhxZ9LrFYklZ7siRI9q5c6e6u7tlGMaiKQ5WKtHjItMaBzt37pQk7du3r2j1SlIwGEzuGwAAAAAAAAAAAACwcvWSAy7pFPoJY2Njam9vl9/vl9/vl9PplMvlktPpVDgc1oMPPijDMHTq1CkZhqFQKKRIJCIpPkI/GAzquuuuK1o8IyMjcjqdGbdJvO73+4s2hYLX65XP51MoFCrK/gAAAAAAAAAAAAAA9ZMDLksC3+FwaGJiQtu3b9ehQ4c0Pj6eTNBLUl9f37IypmnK4XAoEAho+/btRYslHA5LUtaT53A4Fm1fjHo7OjqS+wUAAAAAAAAAAAAArFw95YBLPoV+gsPh0NjYmB544AE5nU6Zppnx0d/fn0z6F9Po6Kik7Cdv4TbFOIHF7MUBAAAAAAAAAAAAAIirpxxwWUbgL9Tb26ve3l4dOnRIoVBI4+PjmpyclBRvrO7u7qIn7RcaHx+XpJx6QSS2ScRXqKGhIXm93hXtAwAAAAAAAAAAAACwXD3lgMuewE/YunWrtm7dWqnq82IYRsFlI5GITp06lVNvDwAAAAAAAAAAAABA6VVrDrhiCfxKKeRErKT3hdfrVSAQKLg8AAAAAAAAAAAAACC9esoBW0uy1wUefPBB2Ww2XX755Tpy5Eipq8tqpVMh5GN4eFh9fX1F2dfMzIyi0eiiBwAAAAAAAAAAAADUs6U50pmZmWXb1GoOOJWSJvAnJibU29sr0zQ1NTWlkZGRUlZXVQzD0NjYmNxud1H2Nzg4KLvdnnxs3ry5KPsFAAAAAAAAAAAAgGq1efPmRXnSwcHBisVS7BxwKiVN4IdCoWTwpmmW9EBy1dbWVpYyXq9XPp8v73LpDAwMaHp6Ovk4evRo0fYNAAAAAAAAAAAAANXo6NGji/KkAwMDy7ap1RxwKk2l3LlhGLr33nuT8//b7fZSVlc1RkZG1N3dLYfDUbR9Njc3q7m5uWj7AwAAAAAAAAAAAIBq19LSopaWlkqHUZIccColHYHvcrkUDAaT0xms1IEDB1a8j0SDGoaRddvENvmehL1796qnpye/wAAAAAAAAAAAAAAAeaunHHBJR+Bv375dXq9Xf/iHf6jLLrtsRfuamJhQd3e3pqamVtTDYtu2bZKkSCSSddvENl1dXTnvPxQKKRQKqaOjI+02k5OTkqShoSGNjIwknx8fH8+5HgAAAAAAAAAAAABAfeWAS5rAl6R9+/app6dHIyMjK07iS1rx9Agul0vSpQZMZ2HPi3x6X7jdbk1NTWXcZnh4WH19ferv7y/5GgkAAAAAAAAAAAAAUM/qKQdc0in0JcnpdGpwcFB33XWXvvjFLyoajRa0n1x6S+Qaj8PhyLq/xOs7duwoSr0AAAAAAAAAAAAAgOKrpxxwyUfgR6NRve1tb1MgENDg4KDa29vV1dUll8uljo4OOZ1OtbW1ZdxHJBLRF77whaLF1Nvbq6GhIYXD4WRvjKVCoZAkyePxpN1PpvIAAAAAAAAAAAAAgPKolxxwSRP49913n+69995Fz5mmmVwjIB+macpisRQlLp/Pp+HhYfn9fvn9/pTb+P1+ud1uud3ulK97PB6NjIzI4XBoYmIirykWElMzJH4CAAAAAAAAAAAAAApXLzngkk6h73Q6ZZrmooekZc/l8ii2PXv2aHh4WOFweNlrQ0NDmpycTHtipUu9MwzD0OjoaF51Hzx4UJLyLgcAAAAAAAAAAAAASK0ecsAlHYGf6JHQ2tqq3bt3q6urq6D9TE5Oavfu3Tpw4EDRYuvp6VEwGJTH45HX6032svD7/QqFQll7VPh8Pnm9XnV1daXtobHQ0NCQ/H7/onUXwuGwLBaLnE6n3G53xosFAAAAAAAAAAAAAJBePeSALWYphrdfNDExoY6ODg0PD+tTn/rUivYVCoV02223KRaLFSm6xfsOh8NyOBzq6uqqiXXto9Go7Ha7pqen1dLSUulwAAAAAAB54r6u9GhjAAAAAKhdK72nq8UcsFTiEfhtbW2S4lPpr1RHR4dM01Q0Gi36TXemdQ4AAAAAAAAAAAAAALWlVnPA1lLu3G63y+fzFTx1/kJtbW3y+Xz0mAcAAAAAAAAAAAAA1KWSTqGP0mEaQAAAAACobdzXlR5tDAAAAAC1q1Hv6Uo6Ah8AAAAAAAAAAAAAAOSGBD4AAAAAAAAAAAAAAFWgKAn8AwcOaOfOndq4caNsNps2btyo2267TQ8//HAxdg8AAAAAAAAAAAAAQN1rWknhaDSqXbt2aWRkRJJkmqYkaWpqSqFQSKFQSN3d3dq3b19DrUsAAAAAAAAAAAAAAEC+Ch6BPz09rc7OzmTyPp1gMKiuri5Fo9FCqwIAAAAAAAAAAAAAoO4VnMD3eDwaHx+XaZoyTVN2u10ul0s9PT1yuVyy2+3J18bHx+V2u4sZNwAAAAAAAAAAAAAAdaWgBP6ePXsUCoUkSb29vRofH9fk5KRGR0e1b98+jY6OanJyUlNTU9q9e7dM09TY2Ji+9KUvFTV4AAAAAAAAAAAAAADqhcVMLFyfh7a2Nk1PTysQCOjjH/941u0jkYg6OztltVp16tSpggLFYtFoVHa7XdPT02ppaal0OAAAAACAPHFfV3q0MQAAAADUrka9p8t7BP7+/ftlGIb6+/tzSt5LktPpVCAQ0NTUlB5++OG8gwQAAAAAAAAAAAAAoN7lncAPBAJqbW3V4OBgXuXcbrfcbrcee+yxfKsEAFS7+Zg08X3pmZH4z/lYpSMCAAAAAAAAAACoOU35FhgdHZXb7S6oMo/Ho+Hh4YLKAgCq1LOPSI96peixS8+1bJJu90k33Fm5uAAAAAAAAAAAAGpM3iPwI5GIuru7C6rM7XYrEokUVBYAUIWefUTa94nFyXtJih6PP//sI5WJCwAAAAAAAAAAoAblncA3DENtbW0FVdbW1ibDMAoqCwCoMvOx+Mh7mSlevPjco/cynT4AAAAAAAAAAECO8k7gS5LD4SioMrvdXlA5AEAVeumJ5SPvFzGl6Kvx7QAAAAAAAAAAAJBVQQn8QkfgAwDqyOkTxd0OAAAAAAAAAACgwRWUwAcAQBuuKu52AAAAAAAAAAAADa5mEvjT09N68MEHKx0GACBhyy1SyyZJljQbWKSWa+LbAQAAAAAAAAAAIKuaSeBHIhH19fVVOgwAQILVJt3uu/iPpUn8i/++fXd8OwAAAAAAAAAAAGTVVOkAAAA17IY7pR1fkR71StFjl55v2RRP3t9wZ+ViAyBJmp+fVywW0/z8fKVDAYCaYLVaZbPZZLXWTH93AAAAVCHuxwHUK+6bS6+gBP7U1FSx48hqdHS07HUCAHJww53SO++QXnpCOn0ivub9llsYeQ9UkGmaOnv2rKLRqM6ePSvTNCsdEgDUFIvFonXr1qmlpUXr1q2TxZJuySAAAADgEu7HATQK7ptLq6AEfm9vb8HT2ZumqYGBgZy3NwxDk5OTCgQCnHwAqFZWm9T+4UpHAUDS7OysXn31VcViMTU3N2vjxo1avXq1rFYr/5cCgCxM09T8/LxmZ2f15ptv6vjx47LZbLrmmmu0evXqSocHAACAKsb9OIBGwH1zeVjMPLuAVeqPjWmaslgsisViZa+7GkWjUdntdk1PT6ulpaXS4QAAgCowNzenV155RVarVVdddZWam5srHRIA1LSZmRmdOHFC8/Pzuvbaa9XUVNxV6LivKz3aGAAAlAP34wAaFffNpVHw4gSmaZb1AQAAgPRM09Tx48dlmqauvvpqviwAgCJobm7W1VdfvegzFgAAAFiI+3EAjYz75tIouBuE2+2Ww+FQW1tbMeNZZnJyUoZhKBQKlbQeAACAWnb+/HnNzMzommuu0apVqyodDgDUjVWrVuktb3mLXn31VZ0/f15r166tdEgAAACoItyPA2h03DcXX0EJ/P7+fg0ODhY7loyGhoY0MDBQ1joBALkzTVNPvzKtG6+1s64XUAFnzpyRzWbTmjVrKh0KANSdNWvWyGaz6cyZM3wRAQAAgEW4HwcA7puLraAp9Lu7u4sdR1XWCQDI3cOHXtWvfvmH+tqTr1Y6FKAhnT17VuvXr6cDDQCUgMVi0fr163X27NlKhwIAAIAqw/04AHDfXGwFJfArhXUTAKA6zcXmdX/wBUnS/cHDmovNVzgioLHEYjHNzs7SuxUASmjt2rWanZ1VLBardCgAAACoEtyPA8Al3DcXT94JfJ/Pp66urlLEkpHT6ZTP5yt7vQCA7B556piOTp2TJL08eVbfePpYhSMCGsv8fLzTjM1mq3AkAFC/Ep+xic9cAAAAgPtxALiE++biyTuBf88996ilpaUUsWRkt9t1zz33lL1eAEBmidH3iUnCLBZG4QPllvhPsdVaU5MrAUBNSXzG8kUEAAAAErgfB4BLuG8uHv6qAABWJDH6PrHIiWkyCh+oFNbbA4DS4TMWAAAA6fB/RQDgs7CYSOADAAq2dPR9AqPwAQAAAAAAAAAA8kcCHwBQsKWj7xMYhQ8AQOFGRkbk9XqXPW8Yhjo7OysQEQAAAAAAAMqFBD4A1Jr5mDTxfemZkfjP+VhFwkg3+j6BUfgAABRm79696ujoWPZ8KBRSW1tbBSICAAAAAABAuTRVOgAAQB6efUR61CtFF4xsb9kk3e6TbrizrKEcPDKlo1Pn0r6eGIV/8MiUPtCxsYyRAQBQ28LhsHw+37Lng8Gguru7KxARAAAAAAAAyoUEPgDUimcfkfZ9Qlo6YX30ePz5HV8paxLftcWhL/+GS7Ox9DMArLbZ5NriKFtMAADUOsMwNDk5KafTuey1UCikvr6+CkQFAAAAAACAciGBDwC1YD4WH3m/bLV5XXzOIj16r/TOOySrrSwhNTfZdMeNV5elLgAAGkUoFJLb7V72vGEYikQicrlcFYgKAAAAAAAA5WKtdAAAgBy89MTiafOXMaXoq/HtAABAzQoGg9q2bduy59Ml9gEAAAAAAFBfSOADQC04faK42wEAgKqULlEfDAbV3d1dgYgAAAAAAABQTkyhDwC1YMNVxd0OAABUHcMwNDk5mXKa/FAopL6+vgpEBQAAAABA44lEIuru7tb4+HjOZSwWi3p7e+VwOLRx40Y5HA5JUltbW9ayTqezKMvmhcNh+f1+hUIhTU5Oqq2tTS6XSwMDAyzLV0NI4ANALdhyi9SySYoeV3zN+6Us8de33FLuyAAAQJGEQiF1dXUte94wDEUiEW60UyjkCxUAAAAAADIJh8Pavn27DMPIuUwkEpEkDQ8PF1Rnb2+v/H5/QWWl+HcHu3bt0sjIiHw+n7xer5xOpyKRiPx+vzo7O9Xf3y+fz1dwHSgfEvgAUAusNul2n7TvE5IsWpzEt8R/3L47vh0AAKhJ6abJTzetfqMr5AsVAAAAAABSMQxDoVBIe/fu1cjISN7lw+FwwXU7HI4VJdYNw1BnZ6cikYjGxsYWDQBwOp3y+Xzatm2bPB6PJJHErwHWSgcAAMjRDXdKO74itVy9+PmWTfHnb7izMnEBAICcDQ0NqbW1NeVjeHhYXq932fMej0ehUGjZ86mS/fXOMAyNjIzI4/Gos7OT5D0AAAAAYEVGRkZksVjU2tqqwcFBbdu2raCR8AcPHlRvb6/Gx8dlmmbOj56eHgUCgeR0+4XweDzJkfbpZu/r6emR2+3W0NDQijoboDwYgQ8AteSGO6V33iG99IR0+kR8zfsttzDyHgCAGtHf36/e3t5lz0ciEW3fvl0TExPLXmtvb1cgEFg2vf5Kbu5rTSJpL0kul0s7d+5Ud3e3+vr6KhwZAAAAAKTm9XoLmk59YGBA/f39JYgIqfT09GhqamrRPXYhI/AjkYh8Pp+cTmfOZUZGRtTW1raiWfdGRkYUCoXkcDhSft+wkNfrVSgU0q5duzQ2NlZwnSg9EvgAUGusNqn9w5WOAgAAFChV4j0Sicjtdi97zTAMGYbR8FPoF+sLFQAAAAAoF5/Px1TlNaIYHeQNw8greW8YhgYHB1ecSB8cHJQk7dixI+u2ie8WwuGwIpFIXvGivJhCHwAAAAAqLBgMppwSPxQKNXzyPqGRZhwAAAAAANSWfO9ZPR6P9uzZs6I6DcNIToff0dGRU5lE0r6QZQJQPiTwAQAAAKDC0iXq0yX2AQAAAKBcfnD4pNx/9j394PDJSoeCGjM0NKSOjg5ZLBZZLBZ1dHSor69vxWuwG4aRXGatWgQCgZy3HR4elsvlSrtefa5GR0fzLpOoc6XnAKXFFPoAAAAAUCZDQ0PJ6e0WMgxDnZ2dKZ+XlLJMV1eXgsFg0WMEAAAAgATTNDX0nef04uunNfSd5/TBt31QFoul0mGhyoXDYXk8HkUikUXPRyIRDQ8Pa3h4WG63W36/v6Bp3Pft21ezCehIJCK/31+UNegXtm+uMwC0tbVJKiz5j/IhgQ8AAAAAZdLf36/e3t5Fzw0PD+vgwYPLps6LRCLavn27JiYmUu6LKeUBAAAAlNrjh0/q6VemJUlPvzKtxw+f1EfefkWFo6ot4XBY27dvl9PpzJi0jUQi8vl8CoVCikQi6u3trclpzkOhUHImOYfDod7eXnV0dKitrU2RSETBYFChUEihUEgdHR3q7++Xz+fLq45AIFCz67cXY+r8lUh8l2AYhgzD4LuFKsUU+gAAAECDMQxDQ0ND6uzsVGtra3Iqu2yPVCPEG0Ux28zhcCx6HDx4UN3d3cuej0Qicrvdy55PPAAAAACglEzT1Jcee17WiwPurRbpS489L9M0KxtYjfF6vTIMIznyOZW+vr7klPCJUdX79u0rS3zFljgOv9+vqakp+Xw+9fb2qqenR/39/QoGgxofH1dPT4+k+Ex1ra2tGhkZyWn/ieR/LS43Nzw8rK6urhVPnZ9QSCeGxEx/kpbNkIDqwQh8AAAAoIF4vV4NDQ0VVDbTlw31rNRtFgqFUo42CAaDNfmFBAAAAIDsTNPUuQuxSoeR0Q8WjL6XpHkzPgo/+OwJfej6yysYWWZrV9mqapr/UCgkSSnv7yKRiDwejwYGBuT3+xUKhTQ8PCxJeY9KrwYjIyMyDEOBQCCZoE/F6XQqEAgoFAqpr68v2Q4ul0t79uxJm+AeHh5WX1+fJC2b3a4W+Hy+okydn9DV1ZX8fWFiPhOS9rWBBD4AAABqgmmaevqVad14rb2qbsRrhWEY2r59e3KNuN7eXnV3d8vpdCoSiWjv3r3J3u6JdeiWqtXp6QpVjjZL3Din2i4UCsnr9a70MAAAAABUoXMXYrrhv32n0mEUpPerxUtAlsKz//02rVtdHemvRPJeit83LjQ8PCy/379oOni3263x8XFJxbkHT0zHPz4+rp07dy5KjGd6rVB79+6Vy+XKmLxfKHG8Q0ND8nq9CofD6uzslMvl0s6dO+V0OjU5Oanx8XGNjIwk76EDgUDNzUzn9XqTs+wVi8PhSH5HkbhushkdHU3+Pjk5WbRYUFzV8QkGAAAAZPHwoVf1uX1P6f6dN+ljW6+tdDg1xTAMdXZ2KhKJyOVyLVsrLnFznRhpnviCoRQJ+1x7hBeqWDfC5WqzUCi07EscKZ7Yn5ycLEuniVo5JwAAAABQa4LBYPL3hQlyj8ejtra2lKOxi3kfmFhvPhwOq6OjY1EMmV4rlGEY2rlzZ97l+vv71dvbq127dmlkZEThcDjZmX4hh8OhPXv25NxBoFokluVbeD0Ui9frVV9f36LOIuks3abU3wegcCTwAQAAUPXmYvO6P/iCJOn+4GH9yo2b1GSzVjiq2uHxeJKJ6ExTtfl8vuRU8X6/v+jT9ZVj5gS3212UG+JytVm6afLTJfaLrZbOCQAAAFBP1q6y6dn/flulw0jJNE3t9P+bnj0e1XyK5e6tFumGq1u0t+/9VTlD3tpVtkqHkJRImCbu78LhsHbt2qWBgYGyJKF9Pp8Mw1Bra2terxXK5XIVfC/rcDgUCAQUDoeTywksnLWup6dHAwMDNdlJfHBwUA6HoyT3+b29vfL7/QqHw1m/SwgEAurt7U1+j1GLbdkoSOADAACg6j3y1DEdnTonSXp58qy+8fQxRuHnaOHo8EAgkHV7l8ulcDhckjXRxsbGSj49WzFGKpSzzUKhUMqkf7rEfrHVyjkBAAAA6o3FYqmaad6X+t4Lb+gnx6JpX583pZ8ci2r0JUMfefsVZYysthiGsWgUeXd3txwOh/bv31/WxGmmuoodRzEGArhcrpRL1NWy4eHhknbSDwQC6uzsVF9fX9qp9EdGRtTZ2blo1H1bW1vJYsLKVOdfBwAAAOCixOh7iyRTksXCKPxcGYaRXEO9v78/p0Rq4uatFAn8YkzHV2rlbLOFIwmWSpfYL7ZaOCcAAAAAysc0TX3psedltSjl6PsEq0X60mPP6+evv7wqR+FXg4XTlS9cdq2zs1NOp1Mul0vd3d1lmX2tkiKRiCKRiAzDkMvlarhO3iMjIzIMo6TH7XQ6NTExoe3bt6uzs3PZMoBDQ0NyOBzq7e1NfuchMQK/mpHABwAAQFVbOPpekkyTUfi5Gh4eTv7e19eXU5lSJO5rSTnbLN3UdpkS+wAAAABQSo8fPqmnX5nOut28KT39yrQeP3ySUfhpJJYSczgcmpqakhTvNB6JRLR3716NjIwkE6uBQKDuEvkjIyPyer3L7pkTieSVTIcfiUTU19dXE8u1JWYT2LZtW0nrcTgcGhsbSw4ISMy219bWpr6+vmQH/oUj8PneoXoxZAkAAABVa+Ho+4USo/DnYvMViatWJG4SnU5nzjdljZ48LmebjY+Pa+fOnSn3t2PHjrz2BQAAAAArlRh9n+uAesvFUfimmWGofgNLjLrv6upKPudwOORyueTz+TQ+Pq6enh4ZhqHu7u5F0+3Xur6+Pnk8npQd3g3D0NDQkNrb2xd1os9HKBSqmQEIieugXDPgud1u+f1+BQIBBQIB+f3+RXUn2q3eOozUGxL4AAAAqFqJ0fdLvwpYOAofqSWmqJOknp6enMosXZuv0ZS7zXw+X8p6EjfbAAAAAFBOs7F5HTPOKdd8vGlKx43zmqVz/TKJkfZS5nvFPXv2JH8fHBwseVzlMDQ0lEzM9/b2amxsTKZpyjRNjY+PJxPKhmGor69PnZ2deSfjl04RX60WfmdQLevNj46OSmrM731qCVPoAwAAoCotHH2f6ruDxCj8X7lxk5ps9EtdauHNb643ZQvX5yvVCPCFU7WVwkrWb6vWNiu1aj4nAAAAAMqnucmmR/7ThzR5ZjbnMhs3rFZzk62EUdWmhfeKmTqIOxwOORyORQn/hbxe77Kp5iORiPx+vzZu3KhTp04pEonI5/NVRULbMAx5vV45nU4Fg8FlMTmdTvX29qq3t1fDw8Pyer0Kh8Pq6OhQf3+/fD5f1jqGh4cVCoVqouP7wuugGu6NI5FI8juA3t7eygaDjEjgAwAAoCodPDKlo1Pn0r6eGIV/8MiUPtCxsYyR1YaFN/653sQnbn57enpKcmNpyXUexhVwu90Fr4FXjW1WatV+TgAAAACU1ybHWm1yrK10GDVv7969kuJJ22z3l4mEaqrthoeHFyW1E8n7pc91dnbK5/NVPCm7b98+SUqZvF+qt7dXO3bskNfr1fDwcHLk/p49e9J2ehgaGkp2EKj0seai2u6FR0ZGJMXv02vxO4xGQgIfAAAAVcm1xaEv/4ZLs7FY2m1W22xybXGUL6gasvBGOZdk9MjISDKBnUuP90KMjY1pcnKyJPtOWLi2YL6qsc1KrdrPCQAAAADUosTI62zrjC+cEW3btm2LXguHw8vK+3y+ZSPPnU6nBgYG1NfXpx07dlQ0MRsMBtXT05Nzp3iHwyG/36++vj55PB5FIhF5PB45HA7t2LFDHR0dyVkGQqFQsr0CgUAJj6J4EvfbpTwnoVBIHo9HTqdT+/fvz1hX4tqphdkLGh0JfAAAAFSl5iab7rjx6kqHUbMWJk0Nw8h6s+j1eiWppNPuuVyukuy3WKqxzUqt2s8JAAAAANSahdOUZ1uebeF959L7ysHBQQ0MDCx6LjF9/Pj4+KLnE4n+0dHRrJ0GSskwjILWVne5XBofH0+OsDcMQ8PDw8u2czgcCgQCNXMvm2pZhHwkZifo6upSIBBI+T1FIBCQYRgKh8MZz//w8LAikYj6+/tr9juMRtLwi4UODw/L4/Gor68v2cNn4ZoUK2UYhvr6+tTR0aHW1lZ1dHTI4/Ekp6kAAAAASsHhcCRvaEdHRzNu29fXp0gkop6eHvX395cjvKpEmwEAAAAAVmphjimXZHqqZGokElEkElmWqHa5XCm3TyR2F47or4Tu7u6009/nor+/X1NTU/L7/XK73XI6nXI6nXK73fL7/ZqamqpoB4V8Jc5HW1tb3mVDoZCGhoZkGIZCoZAGBwdTbtfZ2SmHw6Genp60bRMOh9XX1ye3212zMwgWopZzwA2dwO/u7tbY2JgCgYD8fr/8fr/27Nkjr9ebHE2zEqFQSNu3b5fH49H4+LimpqaS03p4PB51d3evuPcNAAAAkM6ePXskZZ7ePdGbu7e3t2amoCsl2gwAAAAAsBKJdc8dDkdOI50T05knyhmGIY/Hk/J+c2xsLLldKBSS1+vV0NBQch+lXiItm2KM7nY4HOrt7VUwGNT4+LjGx8cVDAbLsuZ9YiT7wmS51+stKJdXrs4UO3bsUFtb27LZGhJGRkbU2dmpnp6e5LXTCGo9B9ywCXyPxyNp+ToPDodD+/fv1/DwcMrpOXJlGIa8Xq/GxsYW9XhxuVwKBALy+XwKhULq7OyseI8oAAAA1CeXyyW/369QKKS+vr5FryX+Lzo8PJy8mQFtVguK+YUKAAAAABRbd3e3HA5HziOd3W63gsGgRkdH1dHRoe3bt2dcqs3r9aqjo0PhcFgDAwPq7+9Pm7xFduFwWBaLRRaLRa2trers7FQ4HE6+PjQ0pI6OjuQ2HR0dOe3X4XAkZ0YopFOD2+1Odlpwu91pz7HD4VAwGNSuXbvU2dkpj8cjr9ebHBnu9Xrl9/sbagBCPeSALaZpmgVHWKNCoZC6u7sVDAbTTieR6LU0NTWVde3LVBLTMWRahyPxIdDT05P3Gycajcput2t6elotLS15xwcAAOrHzMyMjh49qs2bN6u5ubnS4aAKRSIReb1ehUKh5LRtTqdTHo+nLD3YaxFtVl3C4bA6Oztz3t7pdC5bE3KlSvFZy31d6dHGAACglLgfR7klEoJjY2OLcleGYai1tVV+vz/lPavFYinoNaxMYl36HTt2FJRrzFckElE4HFYkEpHD4VBXV1fGPGWxVcN9cz3kgCWpKe8SdSDR4yLTOhk7d+7U0NCQ9u3bl/eHViQS0ejoaNYROQMDA0VbCwEAAABIx+l0NlRP62KgzaqLy+VSA/Y9BwAAAICkoaEhhcNhBQKBZUnHpVPnG4ahycnJFU9nj5VxuVxlTaA7nc6GP+f1kgNuyCn0R0ZGsl7AidcLmRYzHA5r586dWbdb+KZdOB0HAAAAAAAAAAAAkLB3715JUk9Pz7LXli4pFolEWGYMDalecsANl8BPNFK2k5fovVRIoyam2+zu7s64XWIqTml57ygAAAAAAAAAAABAWpxTWiqRy0qstz05OZlxe6Ae1VMOuOES+KOjo5Kyn7yF2+R7Ak+dOiUpvs5Cph5OC09Yo09pAQAAAAAAAAAAgNT6+vokxafSXygUCsnpdMrlcungwYOS4nmtxAjgRFI/8XOhTK8BtaaecsANl8AfHx+XpGXrg6SS2CbfnhEDAwPq6emRz+fLeFIWXhQk8AEAAAAAAAAAAJBKT0+PgsGggsGgPB6PhoaGksn8np4eBQIBhcNhdXd3J3NOnZ2dam9vlyR5vV51dnYqFAplfQ2oRfWUA27Ku0QDyrfnkcPhUCAQyLpdYr2S3t7eQsICAAAAAAAAAABAg3C73XK73SlfczqdyQRmwtjYWNp9ZXoNaBTVmgNuuBH4hUwDUor16Q3D0MjIiCTJ5/MVff8AAAAAAAAAAAAA0AjqKQfccCPwS3EiCrFr1y5Jkt/vz2kqh5mZGc3MzCT/HY1GSxUa/v/t3V+MI+l57/df98xqsJtxT3VvfJQZabCeIgIIC0XBKfYEOYvoImeK0B6svYYRsgdwAB0gxpDIRYJzdMFy58Y3B2mRASIhiGCQjVxYQAD3kIadVYAoYU1uHG8AT7NsycYisMEarce7m40xzdr2HK9XUk/lglsU2c2/3WyyyPp+gEYPq95ivUO+qK63nvd9XgAAAAAAAAAAAACxcDoueu3aNV27dq1v27LGgAdJ3Az8OHBdV/V6Xfl8fuLUCXt7e7px40b35/bt25dcSwAAAAAAAAAAAABYrNu3b/fFSff29hZdpYHOEwMeJHEz8Le2tuZyzDC+7yuXyymbzapSqUx83O7urr71rW91Xx8fHxPEBwAAAAAAAAAAALDSnj59qo2Nje7r07PvpeWNAQ+SuAD+omUyGdm2rVqtNtVxg1JBAAAAAAAAAAAAAMAq29jY6Avgx9F5Y8CDJC6FfrTWQBAEY8tGZc67PsFpmUxGlmXN5IsDAAAAAAAAAAAAAKxWDDhxAfy7d+9K6qQxGCcqs729feHzFgoFGYZB8B4AAAAAAAAAAAAAZmiVYsCJC+BbliVJOjo6Glmud+TFRUdflMtlHR0dEbwHAAAAAAAAAAAAgBlbpRhw4gL4pmnKMIyxoy+i/Ts7Oxc6X71eV6PRGPnFVatVeZ53ofMAAAAAAAAAAAAAQBKtUgw4cQF8Scrn8wqCYOQH5rquJCmXyw0tM+4D9zxPBwcHajQaI8s1m02ZpjmyDAAAAAAAAAAAAABgsFWJAScygF8qlWQYhiqVytAylUpFtm3Ltu2B+3O5nNLptDY3N7upFnr5vq+9vb2xKRN839fh4eGFUzQAAAAAAAAAAAAAQFKtSgw4kQF8Sdrf3x+atiBar2DUlxuNzgiCQIeHh337giBQJpNRvV7X2trayJ9UKjXb/xgAAAAAAAAAAAAAJNAqxIATG8DPZrNqNBrK5XKqVqvyfV++78txHB0cHOjJkycjUxpEIzgGjdBwHGfs+gq9tre3z/3/AAAAAAAAAAAAAACsRgx4LQzD8FxHrhDXdeV5ngzD0Pb2tizLWnSVxjo+PtaNGzf0ySefaGNjY9HVAQAAC/TZZ5/p6dOnun37tq5du7bo6gDASrqMay39usvHZwwAAC4T/XEA+IU49puXMQYsSVcXXYE4GLXOAQAAAAAAAAAAAABguSxrDDixKfQBAAAAAAAAAAAAAIgTAvgAAAAAAAAAAAAAAMQAAXwAAAAAAAAAAAAAAGKAAD4AAAAAxEi9XpfjOGe2B0GgdDq9gBoBAAAAAABgXgjgA8AChWGoHz0NFIbhoqsCAABi4uDgQKlU6sx213W1tbW1gBoBAAAAAABgXgjgA8AC/eGffaBf/96f6I/+/INFVwUAAMSE53mybfvM9kajoUwms4AaAQAAAAAAYF4I4APAgvz85IW+0/grSdJ3Gn+tn5+8WHCNAADAogVBoKOjI5mmeWaf67oDA/sAAAAAAABYHQTwAWBB3vnRh3ra/lSS9DdH/6Af/PjDBdcIAAAs2rAgfRAE8n1flmUtoFYAAAAAAACYFwL4ALAA0ez7tc9fr60xCx8AAHTS5N+9e/fMdmbfAwAAAAAAJAMBfABYgGj2ffj56zBkFj4AABgeqG80GspkMguoEQAAAAAAAOaJAD4AzNnp2fcRZuEDAJBsQRDo6OhoYJp8ZuADAAAAAHC5XNdVoVBQOp3W5uam0um0crmc6vX6Sp4X8UUAHwDm7PTs+wiz8AEASDbXdbW9vX1mexAE8n1/YGA/aYIgULlc7j7UiB5sFAoFua676OoBAAAAAJaQ7/vKZDIqlUrK5XJ69OiR2u22arWa7t+/L8dxlE6n5XneSpwX8UcAHwDmaNjs+wiz8AEASK5hafKZfd9Rr9d1584dPXv2TKVSSc1mU48ePZJt23r48KEymYzS6bR83190VQEAAAAAS8L3faXTaTmOo0ajIdu2ZRiGJMk0TWWzWbVaLdm2PdNg+qLOi+VwddEVAIAkefyTtp62Px26P5qF//gnbf2z1KtzrBkAAJiHcrmsvb29gfuCIJCkM/uj7Zubm33bt7e31Wg0Zl7HOKrX69rb29OTJ0+6DzQilmVpd3dXuVxOrusqlUqp2WySsQAAAAAAMFYul1OpVBo7cL5UKsnzPOVyObVaraU9L5bDWhiGp7M4YwkcHx/rxo0b+uSTT7SxsbHo6gCY0Gc/P5H73v+nn56cDC3zhStXZL/+T3Tt6pU51gzAMvvss8/09OlT3b59W9euXVt0dQCMEQXke/m+r3v37unJkydn9t25c0e1Wu1Mev3TgexVFaUUbDabY//Pm5ubCoJAhmEMDPZfxGVca+nXXT4+YwAAcJnoj2MUx3FUrVanPm53d1fFYvESaoTTPM9TOp1Wu92eqP8YlY9mzC/beS8b/ebZYQY+AMzRtatX9NbXbi66GgAAYIEGdc593+9LlxcJgkBBEMS6g37ZHMdRqVSa6KFGqVRSoVBQEATa29tTqVS6/AoCAAAAwAClUok+Scy5rivDMCYe/B1lervo0m2LOi+Wx/qiKwAAAAAASddoNJTJZM5sd1030cF7qTPTIJvNTlQ2n893/32emS4AAAAAgOR49uxZd+D8NLa2tpbyvFgeBPABAAAAYMGGBeqHBfaTIggC+b6vzc1NlcvliY4xTbN77LQPQwAAAAAAs1Mul5VKpbS2tqa1tTWlUikVCgV5nneh9w2CQLlc7sL1S6VSkqQHDx5MVD6qdzQjftnOi+VBAB8AAAAA5qRcLmtzc/PMj+/7SqfTZ7ZXq1U5jjPwmCQE9g8PDyV1Hs44jjPRMb0PNEgvCAAAAFzQixPpyR9Lf1Hv/H5xsugaYQl4nqdUKiXHcfr6Zb7vq1qtKp1OK5PJnLvP9vDhwwsPApDUHUhfr9dVKBTGlnccR7ZtdweOL9t5sTwI4AMAAADAnBSLRT158qTvZ3d3V9ls9sz2R48eyTAMtdvtM/uePHmiRqOx6P/Opdve3u6uCTjpTIPeWfeTricIAAAAYID33pG++1Xp935V+oPf6vz+7lc72zExz/O0ubmpdDo9spzv+yoUCt0Z65MEduPIdV2l02n5vi/DMFQsFlWpVFSr1VQqlbrBa9d1u0H+adVqtZkEs03T7C7ZVq1WlUqlhg4MKJfLOjw8VK1WW9rzYnkQwAcAAAASJggClcvl7ozvKJXduJ9xDxtW2Sw/M8Mw+n4eP36sTCZzZrvv+7Jt+8z26CcJogEMzWZTzWZzomOiWfuSmJ0AAAAAnNd770gPvykdf9i//fijznaC+BNzHEdBEIxcv7xQKHRTwkez0h8+fDiX+s1a9P+oVCpqt9sqlUrK5/PKZrMqFotqNBpqtVrdAHaUqa5er0/0/q7rynXdmWWlq9Vq3QHjUXa804MKqtWqDg4O9OTJk5n1xxd1XiwHAvgAAABAgkTp2B3Hked5U60RPuphwyq77M/Mdd3uDIRejUYjEWnyJzHN7Pvo+4keBgEAAACxFIbST/9tPH/+8Vj634qSwkEV7/z6odMpt+i6DvoJB9V7cVzXlaSB/bsocJvJZNRsNvvWdS+VSnOr46zU63UFQaBaraZ8Pj+0nGmaqtVqajQaMk2zu6Z9Op0emRq/Wq12P8dR7z+tZrPZ937lclmpVEqu6yqXy6nVaqnZbM48iL6o8yL+1sIwZlcyTOT4+Fg3btzQJ598oo2NjUVXBwAALNBnn32mp0+f6vbt27p27dqiq3M5XpxI778rPf9Yuv5F6bU3pPUri67VUgmCQPfu3et2hPP5vDKZjEzTlO/7Ojg46I52t21blUrlzHskbTbzPD6z6GFNu90+sy+VSnUfZmAyjuOoXC5Lklqt1kw/u8u41tKvu3x8xgAA4DJd6B7xp/9W+m9vXU7Fku6/+VD6wr+z6FpIUt9M8Waz2Tc4uVqtdlPL9/Zdohn4s+jPuK4r3/fVarV0//79vvOP2ndeuVxOvu9PnEEtUi6X+2afW5al+/fvyzRNHR0dqdVqqV6vdz+bWq12KYO26/W6Hjx40DdwP5vNXnr6+kWdd9boN8/O1UVXAAAAABjpvXc6I/t70/Zt3JLeLEmvv724ei2RIAi6689ZlnXm4YBlWcpms93gZzQ74DICx9PMXj+PWY1Kn9dnNmz2ve/7Ojo6mkvwflm+k0lUq1VJnQcdDHwAAAAAsGiNRqP7794AeS6X09bW1sBA9yz7Mo1GQ67ryvM8pVKpvjqM2ndeQRDo/v37Ux9XLBaVz+f14MED1et1eZ43cCa+YRja39+/1Ixrpmlqa2ur28+v1+tKpVJ9Ke9X6byIJwL4AAAAiK9ozb3TafuiNfd2vk8QfwLRCHjLskaOgi+VSt3Zy5VKZebp+tbW1mb6foPYtt33gOS85vWZDUuTPyywP2vL9J2ME60raZqm9vf3L/18AAAAwIW89Epnpngcvf+u9D9PECD9z+udDHlx89Iri65BVxSMjfp3nufpwYMH2t3dncuyX6VSSUEQaHNzc6p952VZ1rn7soZhqFaryfM8VSqVboYAqRPczmaz2t3dvZRB4lEKf9M09ejRIxmG0TcrPsqeVyqVVCwWl/68iD8C+AAAAIinFyedmfdD19xbk37429JX3iKd/gi9s8MnSb1mWZY8z+t2kmep2Wzq6Oho5u/baxYzFeb5mbmuOzDoPyywP2vL8p2M43meyuWyDMNQo9FgfUAAAADE39pabNK8n5H6553Md8cfaXCffK2zP/XP6Y+PEARB3yzyTCYjwzC6gdp5GXWuWddjFhMBLMsauETdZfE8T/fu3VOpVOpbjz6bzcq2beVyue4zAsdx9OzZs5n8Pxd1XiwHAvgAkom1lAEg/t5/tz9t/hmhdPxBp9ydr8+tWsskCILuGnLFYnGiQOrW1pYkXUoAfxlSvs3zMxu1ruGwwP6sLcN3Mk40YyF6EEbqfAAAAOCC1q90lq17+E1Ja+oP4n+exevNb/M8dYwo+Nr7b9M0lU6nZZqmLMtSJpOZS/a1RfJ9X77vKwgCWZYVqz6b7/u6d++ednd3+4LokWiQeLVa7WZ9K5fLSqVSA8vH/bxYHuuLrgAAzN1770jf/ar0e78q/cFvdX5/96ud7QCA+Hj+8WzLJVC0HrgkFQqFiY65jMD9MpnnZzYsTf6owD7OyuVyOjo6UrPZXIkBCQAAAEAsvP52Z9m6jZv92zdusZzdhKKlxAzDUBiGCsNQzWazu6Z5vV5XJpPR5uZmX7B/VURruKdSKWUyGeVyOaVSKW1ubnaD0ufl+/5MstYVCgVtbW2NTU+fz+fVbDa7/fRo4P+ynRfLgwA+gGSJ1lI+PaMzWkuZID4AxMf1L862XAJFKedM05w4GJz04PE8P7NWq6X79+8PfL+dnZ2p3iupCoWCDg8P+x5oAAAAAJiR19+W/tVfSv/yf5X+s/+p8/tf/QXB+wlFQfnt7e3uNsMwZFmWSqWSWq2WstmsgiBQJpPpS7e/7AqFgnK53MAB79Fs8jt37vQNop+G67oXnoDged5U2e9M01Sz2ZRhGAqC4NyDLhZ1XiwXAvgAkmPsWsrqrKX84mSetQIADPPaG52R/VF6vjPWpI0vdcrhjChFndRZP20Sp9fmS5p5f2alUmngeWzbnut6f8vKcRw9fPiQ4D0AAABwmdavdJat+w+ynd+kzZ9IEATd/uWovuL+/n7333t7e5der3kol8vdwHw0gzzKQNBqtVSpVGRZloIgUKFQUDqdnjoYX6vVLtwPjALh0yxhYBhGN/B+kWx8izgvlsvVRVcAAOaGtZQBYLmw5t6F9HboJg0s947ivqwZ4BdJkTcJwzDOfWxcP7PLFufvZJhqtapqtUrwHgAAAEAs9fYVRw0QNwyjO7N6UGDWcRzt7u729at831elUtGrr76qZ8+eyfd9lUqlWPSNgiCQ4zgyTVONRuNMnUzTVD6fVz6f767v7nmeUqmUisXiRLPSq9WqXNe98MD3Vqslafo+687OjgqFQvf4ZTkvlgsBfADJwVrKALB8ojX3fuj0D8LauNUJ3pO2b6jejv+knfio85vNZi8l6Lq2NiybwuzYtt1dZ3BacfzMLlvcv5NB6vW6HMcZG7z3PE+maS7l9wIAAABguR0cHEjqBGnH9S+jQdWDylWr1b6gdhS8P70tnU6rVCopn8/PoPbn9/DhQ0kaGLw/LZ/Pa2dnR47jqFqtdmfu7+/vDx30UC6XuwMELvp/jfqKQRBM1W+MyqZSqaU6L5YLAXwAycFaygCwnF5/W/rKW50MKc8/7lynX3uDmfdj9HaUJwlG1+v1bgB70nXYptVsNnV0dHQp7x3pXVtwWnH8zC5b3L+T0zzPmyh4L3XST/amowQAAACAeZk0TXpvRrS7d+/27fM878zxpVLpzMxz0zS1u7urQqGgnZ2dhQ5ibjQaymazEw+KNwxDlUpFhUJBuVxOvu8rl8vJMAzt7OwolUp1swy4rtv9vGq12oXrGn3eh4eHU6Wzj5bSm+aYOJwXy4UAPoDZenES3wBLtJby8UfqT8McWevsZy1lAIifaM09TKw3aDrJqG7HcSTpUtPuWZZ1Ke87K3H8zC5b3L+TXtGDnElmckidhxvMvgcAAAAwb77vdwPN45Zn6+2znO7n7O3taXd3t29blD7+dBr1KKg7bVB41oIgmHhJul6WZanVanVn2AdBoGq1eqacYRiq1Woz6ctGmfSiQeKT2tvbGzlIIcoosL29rVqtdqZfelnnxWpZX3QFAKyQ996RvvtV6fd+VfqD3+r8/u5XO9vjIFpLWVJ37eQu1lIGAKwWwzC6HdrDw8ORZQuFgnzfVzabVbFYnEf1YonPLL6CIJgqeD9tKkIAAAAAmJVo9r002WzpQX0c3/fl+/6ZQLVlWQPL96ZlX6RMJjM0/f0kisWi2u22KpWKbNuWaZoyTVO2batSqajdbs90gEKtVpPneSoUChOVL5fLcl13aLY313VVLpcVBIFc19Xe3t5czovVwwx8ALPx3jvSw2/qzMz2448623e+H491illLGQCQIPv7+9118IZ1cKOR4fl8/kwaviTiM4ufIAiUTqeVzWbleV43beAgR0dHarVacl13pqn7AQAAAGBSjUZDUieoPskA5Eqlokwm000/Hw1gHpQmvnfGtuu6ajQaevXVV/Xs2TNJuvQl0saZxQB3wzCUz+cvvMb9JGzbVq1W04MHD3R4eKharTZ0QIXjOPI8T81m88IDxhd1XiwPAvgALu7FSScgPjAtfShpTfrhb3fWL47D7HbWUgYAJIRlWd215AqFQl+w2XVdOY4j3/dVq9UuNEJ+lfCZxc+9e/fk+77K5fJUx92/f/+SagQAAAAAw2UyGbmuq1KpNL6wOsHcRqMhx3GUSqVkGMbIpdocx1G9XlehUNDu7q4Mw1AQBFP3mdCRzWZl27b29vaUSqVkmmY300GUCcH3feXz+YGDKnrZtq18Pq9qtSrbts8sgXBZ58XqIYAP4OLef7d/NvsZoXT8QadcXNYvZi1lAEBC5PN52bYtx3G0ubmpra0tSZ0UfYVCYS4j2pcNn1l8uK47csb9KLNYExEAAAAApnWe2eO2bU+0Hno6nVYQBMzGnrFo0ESpVJLned3geSqV0vb29lT9y0qlMnG2vlmeF6uFAD6Ai3v+8WzLAQCAmTJNk9HaU+IziwfbthWGg7I8AQAAAECylMtleZ6nWq12Jnh/OnV+EAQ6OjqaKIU/+lmWtZDA+aLOi3haX3QFAKyA61+cbTkAAAAAAAAAANB1cHAgSQOXc/N9/8zr09sALA8C+AAu7rU3pI1bktaGFFiTNr7UKQcAAAAAAAAAAKYSLe82SLT0WBAEkjoz8keVBxBvBPABXNz6FenN0ucvTgfxP3/95rc75WIoDEP96GlAelYAAAAAAAAAQCwVCgVJnVT6vVzXlWmasixLjx8/ltQJ6Efp2KOgfvS716h9ABaHAD6A2Xj9bWnn+9LGzf7tG7c6219/ezH1msAf/tkH+vXv/Yn+6M8/WHRVAAAAAAAAAAA4I5vNqtFoqNFoKJfLqVwud4P52WxWtVpNnucpk8nINE1JUjqd1p07dyRJjuMonU7Ldd2x+wAs1tVFVwDACnn9bekrb0nvvys9/7iz5v1rb8R25r0k/fzkhb7T+CtJ0ncaf61f+9otXb3C2CYAAAAAAAAAQLzYti3btgfuM01TrVarb1uz2Rz6XqP2AVgsAvgAZmv9inTn64uuxcTe+dGHetr+VJL0N0f/oB/8+EP9xj/98oJrBQAAAAAAAAAAgCRimimAxIpm3699/nptrTML/+cnLxZaLwAAAAAAAAAAACQTAXwAiRXNvg8/fx2Gv5iFDwAAAAAAAAAAAMwbAXwAiXR69n2EWfgAAAAAAAAAAABYFAL4wDJ4cSI9+WPpL+qd3y9OFl2jpXd69n2EWfgAAAAAAAAAAABYlKuLrgCAMd57R/qhIx33BJQ3bklvlqTX315cvZZY7+z70wF86Rez8H/ta7d09QrjnAAAAAAAAAAAADAfRKaAOHvvHenhN/uD95J0/FFn+3vvLKZeS+7xT9oDZ99Holn4j3/Snmu9AAAAAAAAAAAAkGzMwAfi6sVJZ+b9wDBzKGlN+uFvS195S1q/MufKLTfrNUPf+01LPz0ZvhTBF65ckfWaMb9KAQAAAAAAAAAAIPEI4ANx9f67Z2fe9wml4w865e58fW7VWgXXrl7RW1+7uehqAAAAAAAAAAAAAH1IoQ/E1fOPZ1sOAAAAAAAAAAAAQKwRwAfi6voXZ1sOAAAAAAAAAAAAQKwRwAfi6rU3pI1bktaGFFiTNr7UKQcAgKQwDBddBQBYWVxjAQAAMAz3igDAtXCWCOAj8cIw1I+eBvG7sKxfkd4sff7idBD/89dvfrtTDgCQaOvrnVu6Fy9eLLgmALC6omtsdM0FAAAA6I8DwC/Qb54dPkEk3h/+2Qf69e/9if7ozz9YdFXOev1taef70sbN/u0btzrbX397MfUCAMTKlSudwVw/+9nPFlwTAFhd0TU2uuYCAAAA9McB4BfoN8/O1UVXAFikn5+80HcafyVJ+k7jr/VrX7ulq1diNq7l9bf183//X+hf/3e/q7XnH0u/9EX99//Vf6mrL7206JoBAGJifX1dL7/8sp4/f64bN24sujoAsJKeP3+ul19+mZkEAAAA6KI/DgC/QL95dvgEkWjv/OhDPW1/Kkn6m6N/0A9+/OGCazTYO3/xsX5wnNI7L97QO5+k9IO//HjRVQIAxMz169f16aef6uTkZNFVAYCVc3Jyok8//VTXr19fdFUAAAAQM/THAYB+86wRwEdiRbPvo9Xl19Y6s/B/fhKv9YqWpZ4AgMW6fv261tbW9PHHHysMw0VXBwBWRhiG+vjjj7W2tsaDCAAAAJxBfxxA0tFvnj0C+EisaPZ9dEsVhvGchb8s9QQALNaVK1d08+ZNffrpp/roo48Y+Q8AM3BycqKPPvpIn376qW7evMk6fgAAADiD/jiAJKPffDmuLroCwCL0zmrvHRMZzW7/ta/d0tUrix/fsiz1BADEwyuvvKKbN2/qo48+0pMnT/Tyyy/r+vXreumll7S+vq61tbXxbwIACRaGoV68eKGf/exnev78uT799FOtra3p5s2beuWVVxZdPQAAAMQU/XEASUG/eT4I4ONShWGoH//tJ/ral2/E6iYlmtXea10v9B+t/T/6J0Gg//v/bOvr935dWl/sSKFB9ZT6Z+H/xj/98gJqdro+8fyeASCJXnnlFf3Kr/yKnj9/rufPn+vv/u7vFl0lAFhKL7/8sn75l39Z169fZwYBAAAAxqI/DiBp6DdfnsQH8KvVqhqNhra2tiRJR0dHKhQKsm17qc4RV3/4Zx/oWw9/pO/c/w9jEWiWBs9q/8b6n+p3Xvq+bq0ddTb8iRT++JbW/kVJev3t2NSzV5xm4cfxewaAJLty5Ypu3LihGzdu6MWLFzo5OdGLFy8WXS0AWArr6+u6cuWK1tfJdAUAAIDp0B8HkATL0m9e5hhwogP4mUxGpmmqVqt1twVBoHv37sm2bZVKpaU4R1xFAWgpPoFmSXr8k3bfrPZvrP+pfvel754t+PcfSQ+/Ke18fyFB/NP1PC2ahf/4J239s9Src6xZv7h+zwCAjvX19djfTAMAAAAAsGrojwPA4ix7DDixAfxcLidJqlQqfdsNw9CjR490584dpVIp5fP5WJ8jznrTv8cp3bv1mqHv/aaln56cSOGJvvF//Gut/aN0OvH7mkJJa9IPf1v6yltzT6ffV88hvnDliqzXjPlVaoC4fs8AAAAAAAAAAABIllWIAScygO+6rur1uhqNxsD9hmEon8+rUChoZ2dHhmHE8hxxdjr9e5zSvV+7ekVvfe1m58WTP5b+8eMRpUPp+APp/XelO1+fS/0iffWMqTh/zwAAAAAAAAAAAEiOVYkBJzLCFo2GGLX+wP379yVJDx8+jO054iyalR2t3R6le//Bjz9caL3OeD4qeH+OcgmzNN8zAAAAAAAAAAAAVtqqxIATGcCv1+syTXNkmWj/6dQHcTpHXPXOyu4Vzc7++cmLhdRroOtfnG25BFmq7xkAAAAAAAAAAAArbVViwIkL4HueJ0ljP9gonUFUPm7niLN3/vypvvRJU7+2/q7+4/X3tK5OIDeWs7Nfe0PauCWdCUNH1qSNL3XKoc/p2feRWH7PAAAAAAAAAAAAWFmrFANOXAD/8PBQ0vgPtrfMtB/uPM4RVyd/+b/oP/nBf6rf/8K/0f/whf9Rv/+Ff6P/69p/rW+s/6mkGM7OXr8ivVn6/MWZueSdX29+u1MOXcNm30di9z0DAAAAAAAAAABgZa1SDDhxAfxWqyXpFyMfRonKHB0dxe4csfTeO1qv/0v9u+Gzvs3/no70uy99V99Y/9Pu7OzHP2kvqJIDvP62tPN9aeNm//aNW53tr7+9mHrF2OOftAfOvo/E8nsGAAAAAAAAAADASlqlGPDVqY9IoCAIVuIcl+rFifRDR1Ko9VPTstfXpFBr+s6N39f/nvkv9IWrX5D1mrGIWg73+tvSV96S3n9Xev5xZ837195g5v0Q1muGvvebln56cjK0zBeuXInf9wwAAAAAAAAAAAAovjHgxAXwz/MhTTsy4jLO8dlnn+mzzz7rvj4+Pp76HJfq/Xel4w9HrCQf6pVP/1/9xubfSHe+PteqTWz9SnzrFjPXrl7RW1+7Ob4gAAAAAAAAAAAAcAGn46LXrl3TtWvX+rYtawx4kMSl0J9HqvrLOMfe3p5u3LjR/bl9+/bMz3Ehzz+ebTkAAAAAAAAAAAAAiXf79u2+OOne3t6ZMssaAx4kcTPwl9Xu7q6+9a1vdV8fHx/HK4h//YuzLQcAAAAAAAAAAAAg8Z4+faqNjY3u69Oz71dN4gL4W1tbl37MZZxjUCqIWHntDWnjlnT8kaRwQIG1zv7X3ph3zQAAAAAAAAAAAAAsqY2Njb4A/iDLGgMeJHEp9HFJ1q9Ib5Y+f7F2aufnr9/8dqccAAAAAAAAAAAAAOCMxAXwDcOQJAVBMLZsVCY6Jk7niKXX35Z2vi9t3OzfvnGrs/31txdTLwAAAAAAAAAAAAAra5ViwIlLoX/37l1Jku/7Y8tGZba3t2N3jth6/W3pK29J778rPf+4s+b9a28w8x4AAAAAAAAAAADApVilGHDiAviWZUmSjo6ORpbrHRUx7ciIeZwj1tavSHe+vuhaAAAAAAAAAAAAAEiAVYoBJy6FvmmaMgxj7MiIaP/Ozk4szwEAAAAAAAAAAAAAWK0YcOJm4EtSPp9XuVyW53ndkRKnua4rScrlckPfZ9TxszrHMGEYSpKOj4+nPhYAAAAAsHhRfy7q32H26DsDAAAAwPKatt+8CjFgSVoLE/qkYHNzUzs7O6pUKgP3p1IpmaapRqMxcH8ul1O9XpdhGHry5MnA9AcXPccof/u3f6vbt29PfRwAAAAAIF6ePn2qL3/5y4uuxkqi7wwAAAAAy2+afvOyx4ClhM7Al6T9/X3lcjkVCoUzoyPK5bKOjo5GfqjRyIkgCHR4eCjbtmd+jlFu3bqlp0+f6pd+6Ze0trZ2rvdAsh0fH+v27dt6+vSpNjY2Fl0dLDHaEmaBdoRZoB1hFmhHmIVJ21EYhvr7v/973bp1a461S5Z59Z25dmAc2ghGoX1gHNoIRqF9YBzaCEaJe/s4T7952WPAUoID+NlsVo1GQ7lcTo7jdD/8SqUi13WHjqiIlEolOY6j7e3tgV/cLM4xyvr6OjM0MBMbGxuxvChj+dCWMAu0I8wC7QizQDvCLEzSjm7cuDGn2iTTvPvOXDswDm0Eo9A+MA5tBKPQPjAObQSjxLl9TNtvXvYYsJTgFPq9XNeV53kyDEPb29tD1yuI+zmAaRwfH+vGjRv65JNPYntRxnKgLWEWaEeYBdoRZoF2hFmgHSUP3znGoY1gFNoHxqGNYBTaB8ahjWCUVW8fyxoDTuwM/F62bQ8dQbFM5wAAAAAAAAAAAAAALG8MeH2m7wZgaVy7dk2/8zu/o2vXri26KlhytCXMAu0Is0A7wizQjjALtKPk4TvHOLQRjEL7wDi0EYxC+8A4tBGMQvuIJ1LoAwAAAAAAAAAAAAAQA8zABwAAAAAAAAAAAAAgBgjgAwAAAAAAAAAAAAAQAwTwAQAAAAAAAAAAAACIAQL4AAAAAAAAAAAAAADEwNVFVwAAACRXEATa29tTvV6XYRiSJNM0VSqVZJrmYiuHpVAul9VoNHR0dCRJ2traUi6XUz6fX3DNEDeu68q27amOqVarajQa2trakiQdHR2pUChM/T4AVhPXCEj8fcFgQRDIcRy5rqujoyNtbW3Jsizdv39f2Wx2ovegnaw+x3Hked65+zK0kWSqVqtqtVoqlUoTlaWNJNMk9ye0j9V3keeutI8YCAEkQrvdDvP5fGiaZmgYRmiaZpjNZsNarbboqmGFVCqVsFgsLroaWBKVSiU0DCOsVCp925vNZmhZVthutxdTMSyFVqsV2rZ95u9Y79872hAitVotlBS2Wq2Jj7FtO8zn833b2u12aFkWf+sSrtFoTFWe+/DVxDUCYcjfFwzWaDRCy7L6/l40m80wm82GkkLbtse2GdrJaovayOl7gUaj0b1XGNeXoY0kU7vdDiVN9B3TRlaXZVmhZVlhqVQKm81m2Gq1wlarFTYajbBUKnX7G6PQPlbfRZ670j7igQA+kACz6DwC40zTiQBKpVJoGMbAa0+73Q6LxeKZG0Wg17jORqVSCU3TnF+FEDvtdjtsNBqhbduhpKkCLNlsNrRte+j7DuoEIxmmDdZxH76auEYkG39fMEr0cHuYUqkUSgoNwxh6L0s7WW2tVmtkXya61xjVjmgjyRXdQ4579kYbWW2WZXXvQQb90D5wkeeutI/4IIAPrLhZdB6BSUzaiQAajUYoaejMw3w+3w1qAIMUi8WwVCqNLReNSEfymKYZmqYZ5vP57ujySQMs0TVq1CzrYrEYSuLeKSHOG6zjPnw1cY1INv6+YJyobYwStZtBsyNpJ6svn8+PzeYT3W8M6jPTRpKrVqtN9OyNNrL6LMsK8/l8aFlWaBhGd9BPPp8fe09C+1h9F3nuSvuIl/VZpuMHED+O42h/f3/o/mKxKMuyFASBHjx4MMeaYZXU6/VFVwFLpFAoyLKsoWs/ptNpGYahTCYz55phWbiuK8uyxpazbVuPHz+eQ40QN61WS61WS5VKZaK20qtSqUjSyHXd7t+/L0l6+PDh+SuJpZBKpZROp1Wr1VQqlaZqT9yHryauEcnG3xeM4vu+Dg8Px7aN3d1dSYP70bST1ee6rnK53MjnKFEbajQaZ/bRRpKr0Wh0v9tRaCOrb2trS5VKRc1mU+12W2EYqtlsqlKpjF3XnPax+i7y3JX2ES8E8IEVNovOIzCJSTsRQLVale/7KhQKQ8vk83m1220Vi8U51gzLxPd9eZ636GpgRdXr9bEPPaL9UecWq+u8wTruw1cX1wicF21n9XmeN1G/uPdvw+l7WtrJ6js6OlIQBAOD85Gtra1u2dNoI8nkOI5KpdJEZWkjGIX2sdou+tyV9hEvBPCBFTaLziMwzjSdCCC6udvZ2VlwTbDMTNPU3t6efN8fWc51XTI5YCrRfdC4DqthGH3lgdO4D19NXCNwXrSdZPB9X47jjL3/jIKzUn+AlnaSDLVaTcViUY7jDC0T9XPu3r3bt502kkye5ymVSnW/13FlJdoIBqN9rL6LPHelfcQPAXxghV208wiMM00nAgiCQJ7nyTAM2gwuxLZtBUGgdDo9dNZqtVpVEATK5/Nzrh2W2eHhoaTxHdbeMnRaMQj34auJawTOi7aTDM+ePZPUGUQ6aqBp7/W+t03QTpLBtm2VSqWR33PUfk6nMKaNJFOlUpm4X0sbwSi0j9V20eeutI/4ubroCgC4PKc7j8MuvsM6j8A4lUqFdDmYmOu6kn5xnQmCQHt7e939vu/r7t27pM7HWLu7u6rX6/J9X7lcTtlsVvv7+90Oiuu6chxHjx49WmxFsXRarZYkTdTZjcoQdMUg3IevJq4ROC/aTjLs7u52+zSjrum9D7t7y9FOIHUGIktSNps9sxQPbSR5yuXyyGwNp9FGMArtY7Vd9Lkr7SN+COADK+yinUdglGk7EcDjx48ldWYbRjeRp5dfKBQKSqVSajabzNLHUIZhqNFoKJfLyfM81et1ua6r/f19PX78WK7rqtls8jcNcxEEwaKrgBjiPhwRrhE4L9rO8jEMQ7VabWy5g4MDSZpJpijayepxHEemaWp/f38m70cbWV6+7+vZs2eXfo9IG1leQRDo4cOHCoJAz549UxAEyuVyZ7J3XPQcWA6LeO5K+7hcBPCBFbaIziOSYV6dCKyW6KbOMIyBN5FSJ6tDKpXSvXv31Gw251xDLBPTNNVsNlUoFLrp8qOOKm0H53WezicjzjEI9+GriWsEzou2g0gQBN0loE73h2gnyRZlF7Nte+g9BG0kWRzHmeh+shdtJDmirIT5fL4biI2ei1QqlYFth/ax2i763JX2ET/ri64AgMUa1XkEhnEch/aCqUU3dZ7nKZVKDS3nOE53VjUwTjqdlm3bfenzM5kMo4BxLnQ+MU/chy8frhE4L9oOIg8ePJDUeYB+euYb7SR5qtWqcrmcUqmUUqmUCoXCyIAtbSQ5qtWqCoXC1MfRRpIh+p6LxWLf35IoW2H0XGTYcVhNF33uSvuIHwL4QMKN6jwCg5y3EwFEfN/Xzs7O0P1Rqi+WaMAoQRB0O6SNRkNPnjxRNpuV1Ani37lzp7v+FwDEEffhAJAsruuqXq8rn8+TeQWSOhl4arWaWq2W2u22tra2tLm5qXK5vOiqYYGCIFCz2ZxpGnSslkePHnWffwyyu7sr13V5JpJQPHddHQTwgQSj84hp0YnARWxtbUnqpD4fFaiIlmbwfV++78+jalgyQRAonU7LcZzu368oXXWtVpNhGN0Af+/60sA40XXqso8BuA9fTlwjcF60HUTp0bPZrCqVysAytJNkMwxD2WxWzWZTjuMolUqdySpGG0mGi2S9pI0kw7jBv9Fz29MTsGgfq+2iz11pH/FDAB9IqEk6j8BppM7HRUQ3j5PMMozKEHzFILlcToVCYeBgomw2qydPnsiyrG5ZAIgT7sMBIHkymczItc2BiGmayufz8n2/m60HyVGv15XJZMjOhAuJnocwKSZZeO66egjgAwlF5xHTohOBi3r11VclTTc6k/WXcFq1WtXh4aGKxeLQMoZhdLOF+L5P2jhMLPobd3q20yBRGf4uYlrchy8vrhE4L9pOsmUyGVmWNfa6TztBJJo1W6/X+4IrtJHVd3BwMDI1+ji0EZzGNSQ5LvrclfYRPwTwgQSatPMI9LpoJwKIRgATlMdF1Gq1kWt5nS4rMaIYk7t7966kyWYqRGW2t7cvtU5YLdyHLzeuETgv2k5yFQqF7lJP49BOVl+9Xlc6nR67xn2U3lhS32Bk2shqi9YsT6VSQ3+irAzlcrlve4Q2sto8z9Pm5uaZ1Pij9D6Do32stos+d6V9xM/VRVcAwHxN03kEIr2diGGim4Nyuax6vd7d3mq1Lr1+WA7RTd0kN4LRSM7eBxeA1Gk/mUxmorKGYciyLK5DmNikHd7e0eaMOMekuA9fflwjcF60nWQql8s6Ojqa+LpPO1l9e3t78jxPnueNzSgW6e3L0EZWm23barfbI8tUq1UVCgUVi8WBS1zSRlbbwcGBgiBQtVqdeCmu3tnYtI/VdtHnrrSP+GEGPpAg03YegUjUiWi1WkN/oo5DsVjs2w5EomBqEAQj0zH17hu0xjmSzTCMqa4tW1tbIwcfAb1M05RhGGM7vNH+SbNBANyHrwauETgv2k7y1Ot1NRqNkdf9arXalymKdpIco4L3Un/wpbcvQxvBOLSR1ZZKpZTNZtVoNEaW6/3+o6CsRPtYdRd97kr7iB8C+EBCnKfzCACzFqX5GrUmebQvn8/PpU5YLrZtT7Wmveu6LP+BqeTzeQVBMPKeKGqDuVxuXtXCEuM+fLVwjcB50XaSw/M8HRwcjA2wNJvNMxnHaCerzbZtVSqVgTOne/V+/6f7MrQRjEMbWV22bWtra2vsZJdRz9VoH6vtos9daR8xEwJYec1mM8xms2PL5fP5sN1uX36FsJIqlUooKSwWi4uuCmLONM3Qsqyh+23bDiWFrVZrjrXCsmi326FhGGGpVBpbtlgsck1CGIZhaFnWVNcVwzDCfD4/dL9pmqFt27OqHpbItG2J+/DVxDUCEf6+4LRWqzXRdb/Vag3tE9FOVptlWWP/5kfXlmF9GdpIcpVKpVDSyO8/DGkjqyyfz4fNZnNkGdM0Q8Mwhl5raB+r7aLPXWkf8cEMfGDF+b6vvb29sek6fd/X4eEh65bg3KL0O6NS9ACSVKvV5HmeyuXymX3ValWu66rRaJyZjQJI6q4fvbe3N7ANRRzHked5Y2e3YPX5vt9N8TZp9ob9/f2hM6KjVOiTrjmI5OI+fHVxjYDE3xecFQSBMpmM6vW61tbWRv6MWuKJdrLaarWa0un00OtGuVyW53mybXtoX4Y2klyPHz+WJB0eHo4sRxtZXaVSSQ8ePBg6QzqXy+no6EiPHj0a2r+gfay2iz53pX3Ex1oYhuGiKwHgcgRBoHQ6PXbdkohlWWo2m5dcK6yqXC6ner1OO8JEPM9TLpeTZVnKZDKSpEajIc/zVKvV+tboAgYJgqDbabVtW+l0WlInFanrunIch2UYEiyTycj3fR0dHQ0cWBZ1VEd1Wl3XVaFQkOM43RSFlUpFruuOfBiC1eX7vtLptIIgUKVSGXmN4T589XGNSCb+vmCUQqGgarU6cfl8Pj/0ATjtZLUFQSDHcXR4eKj79+/LNE35vq+DgwN5njf2PkOijSRJuVxWpVIZeF9pmmZ3aYbTaCOrLZfLdQeORdeQSqUiy7K0v78/9vulfay2iz53pX3EAwF8YIXNsvMIDHLeTgQQcV23O6LTsqyx63gBpwVBoMPDQ3meJ8MwtL29zQAQzFR0naJ9JdN5g3XchycH1wicF20Hk6CdrLaoL+P7voIgOFefmDaCcWgjq8v3fbmuqyAIZBiGbNueOpsl7WO1XfS5K+1jsQjgAwAAAAAAAAAAAAAQA+uLrgAAAAAAAAAAAAAAACCADwAAAAAAAAAAAABALBDABwAAAAAAAAAAAAAgBgjgAwAAAAAAAAAAAAAQAwTwAQAAAAAAAAAAAACIAQL4AAAAAAAAAAAAAADEAAF8AAAAAAAAAAAAAABigAA+AAAAAAAAAAAAAAAxQAAfAAAAAAAAAAAAAIAYIIAPAAAAAAAAAAAAAEAMEMAHAAAAAAAAAAAAACAGCOADAAAAAAAAAAAAABADBPABAAAAAAAAAAAAAIgBAvgAAAAAAAAAAFyQ7/va3NzU2tpa308ul1t01QAAwBIhgA8AAAAAAAAAwAVtbW2pVCqpWCzKNM3u9t5/AwAAjHN10RUAAAAAAAAAAGDZGYahfD4vSXr11VflOI4kKZPJLLJaAABgyTADHwAAAAAAAACAGWo0Gt1/27a9wJoAAIBlQwAfAACcm+M42tzcnPqnXC4vuuoAAAAAAFwa13UlEbwHAADTWwvDMFx0JQAAAAAAAAAAWAWe5ymdTkuSSqWSisXigmsEAACWCTPwAQAAAAAAAACYkWj2vcQMfAAAMD0C+AAAAAAAAAAAzEij0ej+27KsBdYEAAAsIwL4AAAAAAAAAADMSDQDn9n3AADgPAjgAwCAC/M8T5ubm901/obxfV+FQkGpVEpra2sqFApzqiEAAAAAAJevN31+LpdbYE0AAMCyIoAPAAAuzHEcBUGgra2toWUKhUL34YXv+5Kkhw8fzqV+AAAAAADMQ2/6/GEz8F3XVSaTUTqdViqVYnA7AADoQwAfAABcWDTDIJPJnNnn+77S6bQymYyazWbfDIRSqTS3OgIAAAAAcNmi/rFhGDJN88z+XC6nWq2mWq2mZrMpx3H08OFDOY4z76oCAICYurroCgAAgOXWmx7w9OyCarWqSqWiWq3WfXBh27ZarZYkDXyYAQAAAADAsvI8T9LZ/nEQBLp3755KpVJ3X7Va7c6+j44DAAAggA8AAC6kNz2gZVndf+dyOW1tbanZbJ45ZpaBe9d15fu+Wq2W7t+/31eHUfsAAAAAAJil3gHuvRnqouD9/v5+X7+0t7/cm60OAAAkGwF8AABwIdEDimgGged5evDggXZ3d5XNZi/9/I1GQ67ryvM8pVKpvocho/YBAAAAADBLvQPcd3Z2JA0P3kudZeVSqZRM05xL/zkIAh0eHp7JDgAAAOKFAD4AADi3IAj60vxlMhkZhqFHjx7JMIy51KFUKikIAm1ubk61DwAAAACAWarX65I6WecMwxgZvJckwzBULBbnVr979+7J8zzVarW5DBgAAADnQwAfAACcW296wOjfpmkqnU7LNE1ZlqVMJnPpo/tHDRaY10ACAAAAAEByBUEg3/cldTLU1et1VSoV1Wq1mS4jdxG2bcv3fbLTAQAQc+uLrgAAAFheUXpAwzAUhqHCMFSz2VStVpNlWarX68pkMtrc3OwL9gMAAAAAsEp6+7wPHz6U4ziqVCqxCd5LnSx17XY7VnUCAABnEcAHAADnFj2g2N7e7m4zDEOWZalUKqnVaimbzSoIAmUymb50+wAAAAAArIpogLsk5fN5maapVCqlzc1NFQqF7ux8AACAcQjgAwCAc+lND5jJZIaW29/f7/57b2/v0usFAAAAAMC8RQPcowHtjUZD7XZb+Xxe1WpVqVRK9Xp9wbUEAADLgAA+AAA4l970gNlsdmg5wzC669APmnHgOI6CIJh19QAAAAAAmIveAe62bXe3G4ahUqmkfD4vScrlcszEBwAAYxHABwAA53JwcCCp80Bi3Pp5UYB+ULlqtdoN8Ed835fjOCqXy3Ich4ccAAAAAIDY6h3gPihDXaFQGFh22PFR6v1oxn61Wu32jzOZjKrVare853kql8sql8vK5XLKZDIDB8kXCoXue/ceP8k5c7ncmWMAAMDlubroCgAAgOUUPWDonV0wSO+Dg7t37/bt8zzvzPG+76tSqahUKvVtS6fTfTMXAAAAAACIg2iAuzS+j3xaNIC92WxKkmq1mqrVqhzHkdTJWre7u9uX2S6VSkmStre3dXh4qGKx2H0/x3F0584dtdvtvvM4jqN6vd59317TnJM+OQAAl48Z+AAAYGq+73cD84NmF/TqnV1/egb+3t6ednd3+7aVSqW+4H103O7urgqFAun2AQAAAACxEg1wtyxr4P7ejHLb29t9++r1uu7fv999bRhGN0heqVRUKBTO9Kuz2axKpZIODg7OBNSjfnM0k773uGHB90nPWalUBh4PAABmiwA+AACYWm96v0lmFwxKne/7vnzfP/OAo1qtdkf294rOc3h4OG11AQAAAAC4FL0D3M/TPx4UhB9VPtrm+/7AAfVR+cePH5/Zd3r5umnP6XneRMcDAICLIYAPAACm1mg0JHU6/4M69qdFo/Sj44IgUC6XU61WO1PWsqyB7xk9aGAGPgAAAAAgLnoHuPfOpO/VO3C9N4her9e1vb09NLA+rr99ejb/LEzSxwcAAJfr6qIrAAAAlk8mk5HrumdS3Q9j27YajYYcx1EqlZJhGCqVSgMfDETr/kmdByGNRkOvvvqqnj17Jkk6OjqazX8CAAAAAIAL6h3gPiyFfpSCvl6vy/M8WZYlz/O0t7enR48eDX3vQdnpek06o34a484JAAAuHwF8AAAwtXw+PzLF3yC2bfcF50dxHEf1el2FQkG7u7syDENBEKhcLp+nugAAAAAAXIq7d++qXq+PHeBeq9XkOI5yuZykTlD/0aNHlxKEBwAAy40APgAAiJV0Oq0gCNRsNnmQAQAAAACItWKxqGKxOFHZUqk0cSY7AACQXATwAQBAbJTLZXmep1qtdiZ4fzp1fhAEOjo6Yn0+AAAAAAAAAMDKWF90BQAAACIHBweSpGw2e2af7/tnXp/eBgAAAAAAAADAMiOADwAAYmNra2voPs/zJHVm3kudGfmjygMAAAAAAAAAsGwI4AMAgNgoFAqSOqn0e7muK9M0ZVmWHj9+LKkT0LcsS9IvgvrR716j9gEAAAAAEDfREnLPnj0buH+S/u20/eNZnBMAAMwGAXwAABAb2WxWjUZDjUZDuVxO5XK5G8zPZrOq1WryPE+ZTEamaUqS0um07ty5I0lyHEfpdFqu647dBwAAAABA3KTTaaXTaUmdwe29/dh6va5UKqVqtSpJ2tzcVCaT6R6byWS0ubkpSapWq0qlUqrX6933Pd0/jpalu8g5AQDA7K2FYRguuhIAAAAAAAAAAAAAACQdM/ABAAAAAAAAAAAAAIgBAvgAAAAAAAAAAAAAAMQAAXwAAAAAAAAAAAAAAGKAAD4AAAAAAAAAAAAAADFAAB8AAAAAAAAAAAAAgBgggA8AAAAAAAAAAAAAQAwQwAcAAAAAAAAAAAAAIAYI4AMAAAAAAAAAAAAAEAME8AEAAAAAAAAAAAAAiAEC+AAAAAAAAAAAAAAAxAABfAAAAAAAAAAAAAAAYoAAPgAAAAAAAAAAAAAAMfD/A8+5rfosNWlVAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 2400x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(24, 6))\n",
    "\n",
    "ax[0].scatter([r[r'kappa_all'] for r in precision_vs_separation_sig_1],\n",
    "              [r[r'precision'] for r in precision_vs_separation_sig_1],\n",
    "            label=r'$\\sigma = \\sigma^\\# = 1$', marker = \"^\");\n",
    "ax[0].scatter([r[r'kappa_all'] for r in precision_vs_separation_sig_2],\n",
    "              [r[r'precision'] for r in precision_vs_separation_sig_2],\n",
    "            label=r'$\\sigma = \\sigma^\\# = 2$');\n",
    "\n",
    "kappa_mean_1 = np.mean([r['kappa_all'] for r in recovery_sig_1])\n",
    "kappa_mean_2 = np.mean([r['kappa_all'] for r in recovery_sig_2])\n",
    "\n",
    "ax[1].plot(range(1, k + 1), [np.mean([r['precision'][i] for r in recovery_sig_1]) for i in range(k)],\n",
    "         marker = \"^\", markersize=8, label=r'  $\\bar\\kappa_{{\\mathrm{{all}}}} \\approx {k:.1f}$'.format(k=kappa_mean_1));\n",
    "ax[1].plot(range(1, k + 1), [np.mean([r['precision'][i] for r in recovery_sig_2]) for i in range(k)],\n",
    "         marker = \".\", markersize=12, label=r'  $\\bar\\kappa_{{\\mathrm{{all}}}} \\approx {k:.1f}$'.format(k=kappa_mean_2));\n",
    "\n",
    "ax[1].set_xlabel(r'$ k_{\\mathrm{min}} $', fontsize=30);\n",
    "\n",
    "ax[1].yaxis.tick_right()\n",
    "ax[0].set_ylim([-0.02, 1.02]);\n",
    "ax[1].set_ylim([-0.02, 1.02]);\n",
    "\n",
    "ax[0].set_xlabel(r'$ \\bar\\kappa_{\\mathrm{all}} $', fontsize=30);\n",
    "\n",
    "ax[0].tick_params(axis='both', which='major', labelsize=25)\n",
    "ax[1].tick_params(axis='both', which='major', labelsize=25)\n",
    "\n",
    "ax[0].set_ylabel(r'$\\mathrm{Precision} $', fontsize=35);\n",
    "\n",
    "# # plt.ylim([0, 1.1])\n",
    "ax[0].legend(fontsize=30, loc='lower right', framealpha=0.7);\n",
    "ax[1].legend(fontsize=30, loc='lower right', framealpha=0.7);\n",
    "\n",
    "plt.subplots_adjust(wspace=0.1, hspace=10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experiment 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def threshold(n, d, alpha=0.01):\n",
    "    return  4 * max(d * np.log(4 * n * n / alpha) ** (1/2),\n",
    "                   np.log(8 * n * n / alpha) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def k_star_estimation(n, k, d, tau=1, progress_bar=True, sigma_amp=1):\n",
    "    m = n\n",
    "    res = {}\n",
    "\n",
    "    pie_star = np.arange(k)\n",
    "    \n",
    "    theta_hash, sigma_hash, theta, sigma = generate_theta_sigma_hash_outlier_both_sides(\n",
    "        m, n, k, d, pie_star, tau, sigma_amp=sigma_amp)\n",
    "\n",
    "    X = theta + (sigma * np.random.normal(size=(d, n))).T\n",
    "    X_hash = theta_hash + (sigma_hash * np.random.normal(size=(d, m))).T\n",
    "    res['kappa_all'] = kappa_all(theta, theta_hash, pie_star, sigma=sigma_amp)\n",
    "    \n",
    "    thr = threshold(n, d)    \n",
    "    MinCostFlow_pie_prev, cost_prev = MinCostFlow(X, X_hash, n)\n",
    "    \n",
    "    for i in range(n - 1, 0, -1):\n",
    "        MinCostFlow_pie, cost = MinCostFlow(X, X_hash, i)\n",
    "        if cost_prev - cost <= (d + thr) * sigma_amp * sigma_amp:\n",
    "            break\n",
    "        MinCostFlow_pie_prev, cost_prev = MinCostFlow_pie, cost\n",
    "\n",
    "    res['k_alpha'] = i + 1\n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "74842d159b9847e68fbd6b34f9a44e44",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_exp = 200\n",
    "n=100\n",
    "k=60\n",
    "d=100\n",
    "amp = 6\n",
    "\n",
    "kstar_est_rs_1 = [k_star_estimation(n, k, d, progress_bar=False, tau = 1 * amp * (1 -  (i / num_exp)), sigma_amp=1) for i in tqdm(range(num_exp))]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "af46d076f2e849719da92e78a2f6e5a6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "amp = 12\n",
    "\n",
    "kstar_est_rs_2 = [k_star_estimation(n, k, d, progress_bar=False, tau = 1 * amp * (1 -  (i / num_exp)), sigma_amp=2) for i in tqdm(range(num_exp))]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 5))\n",
    "\n",
    "plt.scatter([r[r'kappa_all'] for r in kstar_est_rs_1], [r[r'k_alpha'] for r in kstar_est_rs_1], s=20, marker='^',\n",
    "            label=r'$\\sigma = \\sigma^\\# = 1$')#, c=[r[r'k_alpha'] for r in rs]);\n",
    "plt.scatter([r[r'kappa_all'] for r in kstar_est_rs_2], [r[r'k_alpha'] for r in kstar_est_rs_2], s=15,\n",
    "            label=r'$\\sigma = \\sigma^\\# = 2$')#, c=[r[r'k_alpha'] for r in rs]);\n",
    "\n",
    "plt.xticks(fontsize=20)\n",
    "plt.xlabel(r'$ \\bar\\kappa_{\\mathrm{all}} $', fontsize=30);\n",
    "\n",
    "ticks, labels = plt.yticks()\n",
    "plt.yticks(ticks[1::2], fontsize=20)\n",
    "plt.ylabel(r'$ \\widehat{k}$', fontsize=25, rotation=0);\n",
    "plt.legend(fontsize=20, loc='center right');\n",
    "\n",
    "plt.gcf().subplots_adjust(bottom=0.15)\n",
    "\n",
    "plt.subplots_adjust(bottom=0.15)\n",
    "\n",
    "plt.savefig('k_alpha.pdf', dpi=10, format='pdf')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experiment 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lambda_nmda(n, m, d, alpha = 0.01):\n",
    "    return 4 * max(np.power(d * np.log(4 * n * m / alpha), 1 / 4),\n",
    "                   np.power(8 * np.log(4 * n * m / alpha), 1 / 2) )\n",
    "\n",
    "def k_sig_joint_est(X, X_hash, matcher=greedy):\n",
    "    n = len(X)\n",
    "    m = len(X_hash)\n",
    "    d = len(X[0])\n",
    "    lambda_nmd = lambda_nmda(n, m, d)\n",
    "    lbd = np.square(lambda_nmd) / 4\n",
    "    gamma = np.square(lambda_nmd) / 4 / d / 8\n",
    "    res = {}\n",
    "    \n",
    "    _, costs = matcher(X, X_hash, num_to_match=n, return_cost=True)\n",
    "    \n",
    "    for k in range(1, n - 1):\n",
    "        sigma_hat_sq = costs[k] / k / d\n",
    "        if costs[k + 1] - costs[k] > (d + lbd) * sigma_hat_sq / (1 - gamma):\n",
    "            break\n",
    "            \n",
    "    res['k_alpha'] = k\n",
    "    res['sigma_hat'] = np.sqrt(sigma_hat_sq / 2)\n",
    "    return res, costs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimate_sigma_sq(X, X_hash, k, d, gamma = 1.95):\n",
    "    _, cost = MinCostFlow(X, X_hash, k)\n",
    "    return cost / (d * k  - gamma * np.sqrt(k * d)) # / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def joint_estimation(n, k, d, tau=1, progress_bar=True, sig=1):\n",
    "    m = n\n",
    "    res = {}\n",
    "\n",
    "    pie_star = np.arange(k)\n",
    "    \n",
    "    theta_hash, sigma_hash, theta, sigma = generate_theta_sigma_hash_outlier_both_sides(m, n, k, d, pie_star, tau, sig)\n",
    "\n",
    "    X = theta + (sigma * np.random.normal(size=(d, n))).T\n",
    "    X_hash = theta_hash + (sigma_hash * np.random.normal(size=(d, m))).T\n",
    "    \n",
    "    res, _ = k_sig_joint_est(X, X_hash)\n",
    "    res['kappa_all'] = kappa_all(theta, theta_hash, pie_star, sigma = sig)\n",
    "    \n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'k_alpha': 98,\n",
       " 'sigma_hat': 3.422835401082145,\n",
       " 'kappa_all': 15.598447567373634}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joint_estimation(n, k, d, progress_bar=False, tau = 4, sig = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "928198681a7d479589ce404c05d9015e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b059dace2aef4294b3dddc3ce7556e77",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_exp = 100\n",
    "n=100\n",
    "k=60\n",
    "d=100\n",
    "tau_amp = 16\n",
    "\n",
    "joint_estimation_rs_1 = [joint_estimation(n, k, d, progress_bar=False, tau = tau_amp * (1 -  (i / num_exp )), sig = 1) for i in tqdm(range(num_exp))]\n",
    "joint_estimation_rs_2 = [joint_estimation(n, k, d, progress_bar=False, tau = 2 * tau_amp * (1 -  (i / num_exp )), sig = 2) for i in tqdm(range(num_exp))]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, 1, figsize=(8, 6))\n",
    "\n",
    "ax[0].scatter([r[r'kappa_all'] for r in joint_estimation_rs_1], [r[r'k_alpha'] for r in joint_estimation_rs_1], \n",
    "              label=r'$ \\sigma = \\sigma^\\# = 1$', marker='^')#, c=[r[r'k_alpha'] for r in rs]);\n",
    "\n",
    "ax[1].scatter([r[r'kappa_all'] for r in joint_estimation_rs_1], [r[r'sigma_hat']**2 * 2 for r in joint_estimation_rs_1],\n",
    "              label=r'$ \\sigma = \\sigma^\\# = 1$',  marker='^')\n",
    "\n",
    "\n",
    "ax[0].scatter([r[r'kappa_all'] for r in joint_estimation_rs_2], [r[r'k_alpha'] for r in joint_estimation_rs_2], s = 15, \n",
    "              label=r'$ \\sigma = \\sigma^\\# = 2$')\n",
    "\n",
    "ax[1].scatter([r[r'kappa_all'] for r in joint_estimation_rs_2], [r[r'sigma_hat']**2 * 2 for r in joint_estimation_rs_2], s=15,\n",
    "              label=r'$ \\sigma = \\sigma^\\# = 2$')\n",
    "\n",
    "ax[1].set_yscale(matplotlib.scale.LogScale(ax[1], base=2))\n",
    "\n",
    "ax[1].set_yticks([1.000e+00, 2, 4.000e+00, 8, 1.600e+01, 32, 6.400e+01])\n",
    "\n",
    "ax[1].set_xlabel(r'$ k_{\\mathrm{min}} $', fontsize=30);\n",
    "\n",
    "ax[1].set_xlabel(r'$ \\bar\\kappa_{\\mathrm{all}} $', fontsize=30);\n",
    "\n",
    "ax[0].tick_params(axis='both', which='major', labelsize=15)\n",
    "ax[1].tick_params(axis='both', which='major', labelsize=15)\n",
    "ax[0].set_ylabel(r'$ \\widehat{k} ~~\\, $', fontsize=20, rotation=0, labelpad=10);\n",
    "ax[1].set_ylabel(r'$ \\bar{\\sigma}^2_{\\widehat{k}} $', fontsize=20, rotation=0, labelpad=15);\n",
    "\n",
    "plt.gcf().subplots_adjust(bottom=0.2)\n",
    "\n",
    "plt.subplots_adjust(bottom=0.2)\n",
    "ax[0].legend(fontsize=20)\n",
    "\n",
    "plt.subplots_adjust(wspace=0.3, hspace=0.)\n",
    "plt.tight_layout()\n",
    "# plt.savefig('joint_estimation.pdf', dpi=10, format='pdf')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}