{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# aLAP code\n",
    "This jupyter notebook contains three approaches to approximating the solution to the Linear Assignment Problem, wherein one finds a weighted matching of some graph that minimizes/maximizes the weight sums.\n",
    " The following approaches are listed below, and can be found in the linked papers.\n",
    " 1.  [Parallel aLAP](https://link.springer.com/content/pdf/10.1007%2F978-3-540-68111-3_74.pdf)\n",
    " 2.  [Greedy aLAP](https://link.springer.com/content/pdf/10.1007%2F3-540-49116-3_24.pdf) (algorithm 1)\n",
    " 3.  [Sequential aLAP](https://link.springer.com/content/pdf/10.1007%2F3-540-49116-3_24.pdf) (algorithm 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.  Parallel aLAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parallel_aLAP(cost_matrix, maximize = True):\n",
    "    if not maximize:\n",
    "        cost_matrix = -cost_matrix\n",
    "    num_vert = cost_matrix.shape[0]\n",
    "    n = 2 * num_vert\n",
    "    matched = np.empty(n)*np.nan\n",
    "    cv = np.zeros(n)\n",
    "    qn = np.zeros(n)\n",
    "    col_argmax = np.argmax(cost_matrix, axis = 0)\n",
    "    row_argmax = np.argmax(cost_matrix, axis = 1)\n",
    "    \n",
    "    # remove full zero rows and columns (match them)\n",
    "    col_z = np.count_nonzero(cost_matrix, axis = 0)\n",
    "    col_z = np.arange(num_vert)[col_z == np.zeros(num_vert)] \n",
    "    row_z = np.count_nonzero(cost_matrix, axis = 1)\n",
    "    row_z = np.arange(num_vert)[row_z == np.zeros(num_vert)]\n",
    "    mz = min([len(row_z), len(col_z)])\n",
    "    col_z = col_z[:mz]\n",
    "    row_z = row_z[:mz]\n",
    "    \n",
    "    \n",
    "    cv[:num_vert] = col_argmax + num_vert  #first half points to second, vice versa\n",
    "    cv[num_vert:] = row_argmax\n",
    "    cv[col_z] = row_z + num_vert\n",
    "    cv[row_z + num_vert] = col_z\n",
    "    cv = cv.astype(int)\n",
    "    \n",
    "\n",
    "    dom_ind = (cv[cv] == np.arange(n))\n",
    "    matched[dom_ind] = cv[dom_ind] #matched indices, everywhere else nan\n",
    "    qc, = np.nonzero(dom_ind) #dominating vertices\n",
    "    \n",
    "\n",
    "    while len(qc) > 0 and np.isnan(matched).any(): #loop while qc not empty, ie new matchings still being found\n",
    "        \n",
    "        temp = np.arange(n)[np.in1d(cv,qc)] #indices of qc in cv\n",
    "        qt = temp[~np.in1d(temp, matched[qc])] #indices of unmatched verts in cv and qc\n",
    "        \n",
    "        qt_p = qt[qt>=num_vert]\n",
    "        qt_n = qt[qt< num_vert]\n",
    "        \n",
    "        m_row = np.arange(num_vert)[np.isnan(matched[num_vert:])] #unmatched rows to check\n",
    "        m_col = np.arange(num_vert)[np.isnan(matched[:num_vert])]  #unmatched cols\n",
    "            \n",
    "        col_argmax = np.argmax(cost_matrix[np.ix_(m_row, qt_n)], axis = 0)\n",
    "        row_argmax = np.argmax(cost_matrix[np.ix_(qt_p - num_vert, m_col)] , axis = 1)\n",
    "        \n",
    "        col_argmax = m_row[col_argmax]\n",
    "        row_argmax = m_col[row_argmax]\n",
    "        \n",
    "        cv[qt_n] = col_argmax + num_vert\n",
    "        cv[qt_p] = row_argmax\n",
    "        cv = cv.astype(int)\n",
    "        \n",
    "        dom_ind = (cv[cv[qt]] == qt)\n",
    "        qt = qt[dom_ind]\n",
    "        matched[qt] = cv[qt] #adding new dominating indices to matching\n",
    "        matched[cv[qt]] = qt\n",
    "        #mate[dom_ind] = cv[dom_ind]\n",
    "        \n",
    "        qn = np.zeros(n)  #store new matchings\n",
    "        qn[qt] = qt\n",
    "        qn[cv[qt]] = cv[qt]\n",
    "        qc = qn[qn>0].astype(int)\n",
    "        \n",
    "    matching = matched[num_vert:]\n",
    "    rows = np.arange(num_vert)\n",
    "    matching[np.isnan(matching)] = np.arange(num_vert)[np.isnan(matching)]\n",
    "    matching = matching.astype(int)\n",
    "    return (rows, matching)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.  Greedy aLAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aLAP_greedy(cost_matrix, maximize =True):\n",
    "    if not maximize:\n",
    "        cost_matrix=-cost_matrix\n",
    " \n",
    "    n = cost_matrix.shape[0]\n",
    "    M = np.zeros((n,n))\n",
    "    U = cost_matrix.astype(float)\n",
    "\n",
    "    while (~np.isnan(U)).any():\n",
    "        a, b = np.unravel_index(np.nanargmax(U), (n,n))\n",
    "        U[a,:] = np.nan\n",
    "        U[:,b] = np.nan\n",
    "        M[a, b] = 1\n",
    "\n",
    "    \n",
    "    return np.nonzero(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.  Sequential aLAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aLAP(P, maximize=True):\n",
    "    if not maximize:\n",
    "        P=-P\n",
    "    n = P.shape[0]\n",
    "    M = np.zeros((n,n))\n",
    "    U = copy(P)\n",
    "    C = np.zeros((n,n))\n",
    "    #R = np.zeros((n,n))\n",
    "    def try_match(a, b):\n",
    "        nonlocal n, M, U, C, n_init\n",
    "        i, j = np.nonzero(U) \n",
    "        n_init += 1\n",
    "        a_free = (M[a,:] == 0).all()\n",
    "        b_free = (M[b,:] == 0).all()\n",
    "        a_matched = (M[a,:] != 0).any()\n",
    "        b_matched = (M[b,:] != 0).any()\n",
    "        while (M[a,:] == 0).all() and (M[b,:] == 0).all() and \\\n",
    "                (np.count_nonzero(i == a) > 1 or np.count_nonzero(i == b) > 1):\n",
    "            if (M[a,:] == 0).all() and (np.count_nonzero(i == a) > 1):\n",
    "                c_ind = np.nonzero(i == a) #indices of vertices adjacent to a\n",
    "                for c in j[c_ind]: # first vertex not b, assigning to c\n",
    "                    if c != b:\n",
    "                        if U[a,c] > U[a,b]: # checking edge weight\n",
    "                            C[[a,b],[b,a]] = U[[a,b],[b,a]] # moving {a,b} from U to C\n",
    "                            U[[a,b],[b,a]] = 0\n",
    "                            i, j = np.nonzero(U)\n",
    "                            try_match(a, c)\n",
    "                            break\n",
    "                        else:\n",
    "                            C[[a,c],[c,a]] = U[[a,c],[c,a]] # moving {a,c} from U to C\n",
    "                            U[[a,c],[c,a]] = 0\n",
    "                            i, j = np.nonzero(U)\n",
    "                            \n",
    "            if (M[b,:] == 0).all() and (np.count_nonzero(i == b) > 1):\n",
    "                d_ind = np.nonzero(i == b)\n",
    "                for d in j[d_ind]:\n",
    "                    if d != a:\n",
    "                        if U[b,d] > U[a,b]:\n",
    "                            C[[a,b],[b,a]] = U[[a,b],[b,a]] # moving {a,b} from U to C\n",
    "                            U[[a,b],[b,a]] = 0\n",
    "                            try_match(b,d)\n",
    "                            break\n",
    "                        else:\n",
    "                            C[[b,d],[d,b]] = U[[b,d],[d,b]] # moving {a,c} from U to C\n",
    "                            U[[b,d],[d,b]] = 0\n",
    "                            i, j = np.nonzero(U)\n",
    "                            \n",
    "            i, j = np.nonzero(U) #reset i,j\n",
    "        '''\n",
    "        if (M[a,:] != 0).any() and (M[b,:] != 0).any():\n",
    "            C[a,:] = 0\n",
    "            C[:,a] = 0\n",
    "            C[b,:] = 0\n",
    "            C[:,b] = 0\n",
    "            n_init += 1\n",
    "            \n",
    "        elif (M[a,:] != 0).any() and (M[b,:] == 0).all(): #if a is matched, b free\n",
    "            #R[np.nonzero(C_a)] = C_a[np.nonzero(C_a)]\n",
    "            C[a,:] = 0\n",
    "            C[:,a] = 0\n",
    "            ic, jc = np.nonzero(C)\n",
    "            d_ind = np.nonzero(ic == b)\n",
    "            for d in jc[d_ind]:\n",
    "                if (M[d,:] == 0).all():\n",
    "                    U[[b,d],[d,b]] = C[[b,d],[d,b]]\n",
    "                    i, j = np.nonzero(U)\n",
    "        \n",
    "                C[[b,d],[d,b]] = 0\n",
    "                    \n",
    "            n_init += 1\n",
    "        \n",
    "        elif (M[a,:] == 0).all() and (M[b,:] != 0).any(): #if b matched, a free\n",
    "            #R[np.nonzero(C_b)] = C_b[np.nonzero(C_b)]\n",
    "            C[b,:] = 0\n",
    "            C[:,b] = 0\n",
    "            ic, jc = np.nonzero(C)\n",
    "            c_ind = np.nonzero(ic == a)\n",
    "            for c in jc[c_ind]:\n",
    "                if (M[c,:] == 0).all():\n",
    "                    U[[a,c],[c,a]] = C[[a,c],[c,a]]\n",
    "                    i, j = np.nonzero(U)\n",
    "                C[[a,c],[c,a]] = 0\n",
    "            n_init += 1\n",
    "        '''\n",
    "        if (M[a,:] == 0).all() and (M[b,:] == 0).all():\n",
    "            #R[np.nonzero(C_a)] = C_a[np.nonzero(C_a)]\n",
    "            #R[np.nonzero(C_b)] = C_b[np.nonzero(C_b)]\n",
    "            C[[a,b],[b,a]] = 0\n",
    "            \n",
    "            if (np.count_nonzero(i == a) == 1) and (np.count_nonzero(i == b) == 1):\n",
    "                U[[a,b],[b,a]] = 0\n",
    "            i, j = np.nonzero(U) #reset i,j\n",
    "            M[[a,b],[b,a]] = 1\n",
    "                    \n",
    "            \n",
    "    n_init = 0\n",
    "    while (U != 0).any():\n",
    "        i, j = np.nonzero(U)\n",
    "        index = random.randrange(len(i))\n",
    "        #index = 0\n",
    "        a = i[index]\n",
    "        b = j[index]\n",
    "        try_match(a, b)\n",
    "        \n",
    "        \n",
    "    #print(\"time try_match called: \" ,n_init)\n",
    "    return np.nonzero(M)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Baseline Performance\n",
    "To demonstrate that the algorithms (specifically the parallel implementation) are working as expected, we will compare the maximum matching on returned on a few matrices from the QAPLIB using parallel_aLAP() and linear_sum_assignment()  (LSAP) from scipy.optimize, the latter of which returns an exact solution. The algorithm guarantees a solution atleast one half of optimal.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.optimize import linear_sum_assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      QAP   Scipy    aLAP  Ratio (aLAP/Scipy)\n",
      "0  chr12a  1034.0  1022.0            0.988395\n",
      "1  chr15a  1293.0  1158.0            0.895592\n",
      "2  chr15a  1293.0  1158.0            0.895592\n",
      "3  chr20a   176.0   160.0            0.909091\n",
      "4  chr22a  1354.0  1354.0            1.000000\n",
      "5  chr25a  1452.0  1416.0            0.975207\n"
     ]
    }
   ],
   "source": [
    "qapprob = [\"chr12a\",\"chr15a\",\"chr15a\",\"chr20a\",\"chr22a\", \"chr25a\"]\n",
    "datafile = np.load(\"qap_probs.npz\",allow_pickle=True)\n",
    "lap = np.zeros(len(qapprob))\n",
    "alap = np.zeros(len(qapprob))\n",
    "for i, p in enumerate(qapprob):\n",
    "    A = datafile[p][1]\n",
    "    lap[i] = A[linear_sum_assignment(A, maximize = True)].sum()\n",
    "    alap[i] = A[parallel_aLAP(A, maximize = True)].sum()\n",
    "    \n",
    "mat = np.zeros((len(qapprob),3))\n",
    "mat[:,0] = lap\n",
    "mat[:,1] = alap\n",
    "mat[:,2] = alap/lap\n",
    "df = pd.DataFrame(mat,columns=[\"Scipy\", \"aLAP\", \"Ratio (aLAP/Scipy)\"])\n",
    "df.insert(0,\"QAP\",qapprob,True)\n",
    "print(df)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Time complexity\n",
    "To further investigate the performance of both aLAP and LSAP, we will run each with simulated dense cost matrices (adjacency matrix for complete graphs) of various sizes, oberving how the algorithms perform as the number of nodes (and, consquently, edges) increases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[86.68446048 97.99526434 90.96800424 91.35035746 98.46451302 30.90563173\n",
      "  29.05331787  9.39893923 40.6671488  68.56339032]\n",
      " [ 1.90160275 18.19458023 42.39502843 74.19607126  1.6303664  96.32341113\n",
      "  52.06346825 73.19910355  4.64235755 27.9794806 ]\n",
      " [50.95979538 66.9439987  43.39735566  2.04408013 65.23017383 85.64193897\n",
      "  86.9464267  73.54459804 53.73658282 54.12997297]\n",
      " [16.61098151 85.37907611  4.0183146   3.70031118 30.104222   82.97664392\n",
      "  90.65801033 41.06307631 20.49172681 83.43553171]\n",
      " [77.11050115 83.09341431 38.35904553 84.67378784 83.10492757 79.90523896\n",
      "  36.32784118 97.79547458 68.28372259 17.39023056]\n",
      " [64.71505289 56.60553775 81.94130743 93.41499818 29.13931264 52.71030636\n",
      "  65.85554023  8.03986192 18.75605798 29.41017636]\n",
      " [34.95542123 34.58529131  3.38980462 83.62231778 35.8914757  75.76148752\n",
      "  69.65946568 88.16883332 81.92925109  7.20735942]\n",
      " [92.80230692 84.59264674 76.99841683 93.02188815  0.11145563 22.6244385\n",
      "  90.00340153  9.02140531 18.062637    2.23271455]\n",
      " [92.3865975  81.54383437 84.68310579  3.51013768 13.68600363 37.08490471\n",
      "  53.70047792 48.92577395 51.43193334 86.27091216]\n",
      " [32.08320692 82.02544972 70.2226416  75.95436419 79.66400954 12.4732525\n",
      "  93.30358326 49.21353448 52.31470847 50.72196951]]\n"
     ]
    }
   ],
   "source": [
    "# random dense matrix, entries [0,99]\n",
    "def dense_matrix(num):  #num = number of nodes in adjacency matrix\n",
    "    matrix = np.zeros((num,num))\n",
    "    for row in range(num):\n",
    "        for col in range(num):\n",
    "            matrix[row,col] = random.uniform(0,100)\n",
    "    return matrix\n",
    "print(dense_matrix(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import timeit\n",
    "n = [50, 100, 150, 200, 250, 300, 350,500,750, 1000, 1250, 1500,\n",
    "     1750, 2000, 2250, 2500, 2750, 3000]\n",
    "scipy = np.zeros(len(n))\n",
    "alap = np.zeros(len(n))\n",
    "reps = 15\n",
    "\n",
    "for i, node in enumerate(n):\n",
    "    for j in range(reps):\n",
    "        mysetup_s = '''\n",
    "from scipy.optimize import linear_sum_assignment\n",
    "from __main__ import  node, dense_matrix\n",
    "import numpy as np\n",
    "A = dense_matrix(node)'''\n",
    "        mycode_s = 'linear_sum_assignment(-A)'\n",
    "        scipy[i] = scipy[i] + timeit.timeit(setup = mysetup_s, stmt = mycode_s, number = 2)/2\n",
    "\n",
    "        mysetup_p = '''\n",
    "from __main__ import  node, dense_matrix, parallel_aLAP\n",
    "import numpy as np\n",
    "A = dense_matrix(node)'''\n",
    "        mycode_p = 'parallel_aLAP(A)'\n",
    "        alap[i] = alap[i] + timeit.timeit(setup = mysetup_p, stmt = mycode_p, number = 2)/2\n",
    "        \n",
    "    scipy[i] = scipy[i]/reps\n",
    "    alap[i] = alap[i]/reps\n",
    "    #print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinregressResult(slope=2.6007354232627892e-09, intercept=-0.001478942573261477, rvalue=0.9908548739445782, pvalue=2.390432809823774e-15, stderr=8.854025758414942e-11)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.15, 0.8, 'R^2 = 0.9722320366322265')"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEVCAYAAAALsCk2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd3xUZfb48c9JoddEuhBKqAkkIALSxYIdV9e+q4j+sGBDvrruumBWdIuu69p3Rde6u6K7LlVAQIyASFFBEwgEJIRektAS0mbO748ZQpJJmZCZTCY579drXmSe287NJXPmnufe54qqYowxxhQXEugAjDHG1D6WHIwxxniw5GCMMcaDJQdjjDEeLDkYY4zxYMnBGGOMB0sOJiiJyIEy2t4Ska41GEOBiGwUkc0i8i8RCa+pbVdERO4VkZ8HOg4T3MTuczDBSEQOqGr7GtxemKoWlhWDiIQAnwPvquqHvt6OMYFgZw6mzhCRL0Wkj4h0FZHvRORDEUkRkTeKzXO1iKx1f+N/pVj7AhH5VkSSROQmd9vp9bwDfFvedlXVCWwAOrmXCxeRV0VkvYh8LyKXudvbuWP8UUR+LyJp7vaJIvJPEVkMvF3B8je5z1I2icgnFbQliMi97p+vcE9LEpGEUvvl8fsxpoiq2steQfcCDpTR9iXQB+gK5ALRQCiwEegJtAGWAg3d8/8DuMr9c4T73xZAMhDuXk8hEFNRDEAjIBGId7+/H3jI/XMksBkQ4HXgPnf7A0Ca++eJwDagWSXL/wh0c7e3dP9bVlsCcC/QGNgJnOven9XAiPJ+P4E+pvaqXS87czB11RZV3a6qDuAHIAoYBgwA1orIRlwflD3c8z8iIpuAle55zy22nuRythHpXs9hIEtVN7rbLwLuc09bDjQD2gHDgf+455ldal1LVPVkJct/DbwpIhOB0/XgstpO6+2Of4+qFri3ObKC348xRcICHYAxfpJX7Gcnrv/rAsxV1cnFZxSRC3EljqGqmisi3wINcX27zq5gGxmqGi8i5wCJInKtqs5xb+cuVf261HaEMx/gUmpdxbdT3vL3AhcAVwPrRSQG1xlC6bbi69FS708r6/djTBE7czD1yTfARSJyum+gjYh0wFVKynQnhnhcZxdeU9UjwBPAY+6mZbi++Ye4txPnbv8auN79c0VXE5W3fDd3wngSaAA0L6fttBSgn4h0FJEw9zZXV2XfTP1lycEEqzYisqfYa3xlC6jqIWAKME9EfgA+AyKAxUArdxnncSrofK7AAqCpiAwF/g4cAjaJSDJnksbvgFtFZD3QAThezrrKW/4FEfkRVxnoH6qaVU7b6f095d7fRbj6FZar6qqz2DdTD9mlrMbUEBFpBBSoqkNEfgFcrKoTAxyWMWWyOqMxNacH8E93uSgTuD3A8RhTLjtzMMYY48H6HIwxxniw5GCMMcaDJQdjjDEe6kSHtIhYx4kxxpwFVS19QyZQR5IDuMaIMsYY4z3XTftls7KSMcYYD5YcjDHGeLDkYIwxxoMlB2OMMR4sORhjjPFgycEYY4wHSw7GGGM8+DU5iMg9IvK1iCSKSHSpae+5p60VkTu8WcYYY4zLoRO5TPt4E6kHT/hl/X67CU5EIoBJuJ6bOxD4A3BDsVmeUdVUEWmI66Em/8L1FKuKljHGmHqt0OHkg2928ZfPt9G7ffMKb2SrDn/eIT0UWOF+gPkGEelVfKKqprp/LHD/66xsGWOMqc82pGUyfW4yh0/kknBNDNcN6hSUyaE1cLTY+/L24FfAR+6nY1W6jIgkAE/5KkhjjKntjpzM4w+fpTBn415+MbQLj17am5aNw/26TX8mhyygf7H3ztIziMhtQDxwi7fLqGoCkFBqPTawkjGmznE4lX+u3cXzS7YS3bYZc6eMILZTyxrZtj+Tw1pghoiEAnFAavGJInIZMBG4SlWd3ixjjDH1xXfpWUyfk8T+Y7n89sq+3HBeZ0JC/FNCKovfrlZS1UzgPWAl8CLwaxG5TERucs/yLhAJLBGRL0WkfVnL+CO28PBw4uPj6devH7feeisFBQUlpicnJxMZGcmtt95aov1///sf8fHxxMXFcckll7B3795qxzJjxgyio6OJj48nOTnZY3pubi633norAwYMYNiwYaSmuvLlvHnziI+PJz4+ngEDBhAaGkpGRgZbt25l5MiR9O/fn/POO4+VK1cClNteUFDA0KFDiY+PJzY2llmzZgGQkZHBxRdfTExMDAMGDODTTz8timnNmjX069eP6OhoXnrppaL2K6+8kri4OGJjY3n66aeL2k+dOsUvfvEL+vTpQ9++fdmyZUuF7ZMnTyYuLo7+/ftz33334XQ6i9r79u1LbGwsTz75ZNH6q9rudDp55JFH6N27N3369GH58uUATJw4kR49ehT9Xvft21fl42lMdWWczONX//mBG/62hoFdWvHFtDHcdH6XGk0MgGuo62B/uXbDe+3atVNVVYfDoRdddJF+8MEHRdMOHjyoAwYM0DVr1ujEiRM1ISGhaNr69es1MzNTVVX/8Y9/6J133lml7Za2ceNGHTFihDocDk1MTNTLLrvMY56XXnpJp06dqqqqSUlJeu2113rM8+WXX+qoUaNUVTUtLU23bdumqqpbt27VXr16VdjudDr1xIkTqqqanZ2t3bt316ysLM3MzNQNGzaoquqhQ4e0c+fOeurUKVVVHTRokCYnJ2tubq7GxMTo3r17VVX1+PHjqqpaWFiow4YN0x9++EFVVZ944gl94YUXVFX11KlTRdsrr/30elRVb7jhBp03b56qqi5dulSdTqcWFBTouHHjNDEx8aza//a3v+mDDz5YFOvpY3rHHXfookWLKjhixvhPocOpH36TpgMSlug1r6zUTbuz/L5N92dnmZ+rdeZ5DmcjJCSEwYMHF50B5Obmctttt/H6668zbNgwhgwZwu23385HH33EzTffzODBg4uWjY+P59///ne1tr9gwQJuueUWQkJCGD16NLfffjv5+fk0aNCgaJ6UlBQuvfRSAGJiYli3bh0FBQWEh5/pjPrkk0+48cYbAYiKiipq79mzJ0ePHkVVy20XEZo1a1a0/w6HA6fTSUREBOeddx4Abdq0oXXr1mRmZqKqhISE0K9fPwCuvfZaFi9ezKRJk2jevDkA+fn55OfnFz1jY/bs2aSkpADQqFGjojjKaz+9nsLCQnJzc4vWc/HFFwMQFhZGbGwse/bsOav2WbNmsXDhQgBCQ0Np3bp15QfLGD/atPso0+cmkZ6ZwxOX9+GmwTVbQipLvb5DOjc3lzVr1jB+/HjA9QG1dOlSRowYAbiSx4cffsjNN9/ssez777/PuHHjPNo3btxYVJYo/rrzzjs95t23bx+dOnUqet+uXTsOHTpUYp4BAwYwb948VJXVq1ezf/9+Dh48WDTd6XQyZ84crr/+eo/1z5s3j4EDB3pc6la6/dSpU8TFxdG5c2emTZtGREREifm///57CgsL6dixo0fMnTp1KlF+ufDCC2nXrh3jxo1jwIABZGVl0aBBAx566CEGDhzIvffeS15eXrntp9122220b9+eJk2acOWVV5aI5+TJkyxcuJCRI0eeVfv+/ft5+eWXGTRoEDfffDOZmZlF806dOpW4uDimT59uD5AyfpeVnc+vP/2R6974mpiOLVkxbSy3DAlACaks5Z1SBNOLKpaVwsLCNC4uTps1a6YTJkyo0rKqqvPnz9fzzz9fc3Nzq7xscffff7/+73//K3o/ZMgQ3b17d4l58vPzdcqUKRofH6+TJk3SmJgY3b9/f9H0xMTEopJScWlpadqzZ09NTU31ql1V9cCBAzpq1Cg9ePBgUVtWVpbGxsbq6tWrVVV13bp1JX5nr7/+us6cObPEeo4fP66XX365JiUl6aFDhxQoKvFMnjxZX3zxxXLbi8vLy9Nbb71Vly1bVtTmdDr1pptu0ueff77EvFVpb9q0qc6aNUtVVZ999ll9+OGHVVV137596nQ6NScnR6+99lp95513PH5HxviCw+HUf63dpXG/W6JXvbxSv0/3fwmpLFRQVgr4B7svXlVNDqf7HA4fPqz9+vUr8QFdmY0bN2qvXr08PsRP+/777zUuLs7jNXHiRI95n3nmGX311VeL3kdFRWleXl652y4sLNSoqCh1Op1FbQ888IC+8sorJeY7duyYxsXF6ZIlS7xqL+6BBx7Qjz/+WFVdiWncuHH69ttvF03fs2ePDh48uOj9k08+qW+99ZbHev785z/rc889p06nUyMiIoraP/vsM500aVK57aX95z//0fvvv7/o/fTp0/WXv/ylx3xVae/Zs6cePnxYVVU3b96s48aNK3O7U6ZM8Wg3prp+2H1Ur3l1lQ5IWKIfrEnTQoez8oX8xJJDKaeTg6rqvHnzdPjw4V4tt3//fu3du7euX7++Stsrz3fffVeiQ3r8+PEe85w8eVKzs7NVVfXVV1/Vhx56qGiaw+HQTp066b59+4raCgsLdfz48fraa6+VWE957YcPHy7qkD1+/Lj2799fN23apKqqd999tz7++OMeMQ0cOLBEh/SePXv05MmTRR3TeXl5eskllxR1JF933XVFnduPP/540bf48tpPd5w7HA6988479eWXX1ZV1Q8++EBHjRrlccZW1fapU6fqf//7X1V1nfmcTgKnf48Oh0PvuOMOff311z323ZizlZWdp7/59Aft/uuF+tgnG/XIiepVHnzBkkMpxZOD0+nUuLg4/eabbypdbtq0adqqVauis4Hrr7++Ststy29+8xvt3r279u/fX3/88UdVdV0Vddddd6mq6vbt27VXr17au3dvveGGG0pcyfPVV195lJTmz59fVDY7/crKyiq3PSkpSePj43XAgAEaGxtb9IH4448/KqADBgwomj85OVlVVVetWqV9+vTRHj166F/+8hdVdV3RdP7552v//v01JiZGp0+fXhRTamqqDhs2TPv376833nij5uTkVNg+YsQIjY2N1djYWL333ns1Pz9fVVUjIyO1e/fuRfG89957Z9V+6NAhveiii7R///46fvx4PXTokKqqXnjhhUXx33///VpQUFDt42uMw+HU2evSdeDTn+sVL32lG9IyAx1SkYqSg7imBzcR0bqwH8aYuiV53zGmz0ki9dBJ/u/S3vxiWBShtaGz2U1EUNUyA6rXl7IaY4w/HDtVwItLt/HBN7u4Nr4Tb94+mHOaNfT5dtIzckjLyKZrZFO6RDbx6botORhjjI+oKp9+t5c/LNrCOc0a8tHkYZzfNaLyBc/Cm4k7eCNxB4VOJSxEuG9MDyaP6eGz9VtZyRhjfGDL/uPMmJtEyv4TPHppL345LIqwUP/cSpaekcOE11aRlXNm6J/WTcKZO2Vklc4grKxkjDF+ciK3gBeXpvL+mjSujuvIa7cOom2LRpUuVx1pGdkUOkt+IS50Krsys31WXrLkYIwxZ0FVmbtxH89+toXWTcL5591DGdo9ska23TWyKWGlOrbDQoSoiKY+24YlB2OMqaJtB0/w2zlJJO89xiMX92LiiK6E+6mEVJYukU24b0yPEn0O94+N9mmntPU5GGOMl07mFfLSsm28szqNK/p34Mkr+9LOzyWkiqRn5LArM5uoiLO7WqmiPgdLDsYYUwlVZf4P+3l24WaaNwrn6QkxDO9xTqDDqjbrkDbGmLOUevAEM+Yms2nPUR65uCcTh3ejQVjdH9DakoMxxpQhO6+Ql5en8vaqnYyPbc/yaWPo0LJxoMOqMZYcjDGmGFXlsx8PMHPBZpo0COWdO89nVM82gQ6rxllyMMYYtx2HT5IwL5n1aZk8OK4nd4/qRsOw0ECHFRCWHIwx9V5OfiGvfrGdWSt/YlyftiyfNpZOrepPCakslhyMMfWWqrIk+SAzF2wmPFSYdftgxvZuG+iwagVLDsaYemnnkWwS5iWzdmcGU8ZGM3lM93pbQiqLJQdjTL1yKt/B619u5++JPzG2dxuWTh1D5wjfDnddF1hyMMbUC6rKsi2H+N38ZEJE+NsvBzGuT7tAh1VrWXIwxtR5uzKy+d38zazafoQpY6O5Z0x3GoVbCakilhyMMXVWboGDN750PRRnZPQ5LJs6xudPTKurLDkYY+qkL1IOkjBvM05VXr91EBf3sxJSVVhyMMbUKbszc3h6wWYStx7m3jHduW9sNI0bWAmpqiw5GGPqhNwCB7O++olXV2xnWPdIPp86mq7n+O7hN/WNJQdjTND7cushEuYlU+BQXr5lIJf2a4dImSNRGy9ZcjDGBK29R08xc/5mlqcc5P+N6s4D46Jp0sA+1nzBfovGmKCTV+jgrZU7eeWLVM7vGsGSR0bTvU2zQIdVp1hyMMYElZWph3lqbjKnChz85cZ4Lo9tbyUkP7DkYIwJCvuPneKZBVv4fPMB7h7VnQcujKZpQ/sI8xf7zRpjarX8Qif/WL2Tl5enEt+5FYseHkV02+aBDqvOs+RgjKm1vt5+hBnzkjmRW8Cfrh/AVQM6WAmphlhyMMbUOgeP5/LMwi0s+nE/k0Z246GLetLMSkg1yn7bxphao8Dh5L2v03hx6TZiO7Xks4dH0audlZACwZKDMaZW+OanDGbMTSIrp4DfX9efa+I6WgkpgEL8uXIRuUdEvhaRRBGJLjVtuojsEpEFpdqzReRL9+tn/ozPGBN4h47n8shH33PbW2sZGd2GL6aNYUJ8J0sMASaq6p8Vi0QAi4DhwEDgV6p6Q7Hp7YEmwMuqelWx9iRVja3ittRf+2GM8Y9Ch5P31+zixaXb6NOhOU9PiKVvhxZlzpuekUNaRjZdI5vakNs+JCKoaplZ2J9lpaHAClV1ABtEpFfxiap6QES6lrFcZxFJBPYCD6vqYT/GaIwJgPVpmUyfk8SRk3kkXBPDdYPKP1N4M9H1PIZCpxIWItw3pgeTx/So4YjrH3+WlVoDR4u99/YcsbuqjgHmAC+UnigiCSKixV8+iNUYUwMOn8jj0Y83cvOb3zCseyTLp43l+vPOLTcxpGfk8EbiDrJyCjiRW0hWTgFvJO4gPSOnhiOvf/yZHLKAlsXeO71ZSFUz3D9+AsSVMT1BVaX4q/qhGmP8qdB9FdK4F75kV0YO8x4YQcI1MbRsHF7hcmkZ2RQ6S37/K3QquzKz/Rmuwb9lpbXADBEJxfUhn1rZAiLSFMh1l6JGAWl+jM+YoBYsdfhvd2UyfU4yB4/nMuOqflw/6FxCQrz7Ttc1silhpeYNCxGiIuw5Df7mt+Sgqpki8h6wEigA7hKRy4CWqjpbRCYDtwO9RWQZcBtwLjBLRE4ChcA9/orPmGAWDHX4jJN5/HFRCp9+v5dbhnTmsUv70LJJxWcKpXWJbMJ9Y3qU2Nf7x0bX6mRYV/jtaqWaZFcrmfokPSOHCa+tIiunoKitdZNw5k4ZWSs+NB1O5V/r0vnzkq10O6cpMyfE0v/clpUvWIH0jBx2ZWYTFVG7z5KCTaCuVjLG+EFFdfhAf3Bu3H2U6XOS2JOVwxOX9+GmwZ29LiFVpEtkk4DvW31jycGYIFMb6/CZ2fk8vySFjzfs4abzO/P+pCG0btogYPGY6rPkYEyQqU11eIdTmb1+N88tSaFLRBM+vW84cZ1b1Xgcxvcq7XMQkYbA5bhuamsP5AIpwOequsXvEXrB+hxMfRToOvym3UeZMTeJtIwcHr+sNzef34VQH5SQTM2pqM+hwuQgIk8Dl+C64uh74DDQEIjGdalpM+AJVd3o66CrwpKDMTXnaE4+zy3Zyuz1u7nhvHN5/LI+RFgJKShVJzlcqKorKpjeGuisqj9UP8yzZ8nBGP9zOpVPvt3NHxel0LFVY2ZeG8ugLq0DHZaphrNODuWsrFYkhOIsORjjX0l7j/HbOUn8dPgkj43vza1Do6yEVAdUOzmIyErgCqARsB7XncvJqjrFh3GeNUsOxvjHsZwCXli6lX+uTednAzvxxOV9OKdZw0CHZXzEF/c5NFXVEyLyC2CWqj4rIgHtZzDG+I/TqXz6/V7+8NkW2rZoxOzJwxjcNSLQYZka5G1yCBORMcBE4P9VcVljTBDZvO84M+YmsfXACR69tBe/HBZFWKhfnwtmaiFvP+AfAqYB/1PVH0SkG1BuR7UxJvgczy3gxaXbeH/NLibEdeT1XwyibfNGgQ7LBIiNrWRMPaeqzNm4l2cXphDZtAFPT4hhaPfIQIdlasBZ9zmIyE6g3E9dVe1ezdiMMQGUcuA4M+Yms3nfcaZe0ovbL4gi3EpIhsrLSn1wPcHtSeAAMNv9/iag7Ie9GmNqvRO5Bfx1WSrvfZ3GFf078MotA2nXwkpI5gxvL2XdpKpxpdrWqeoQv0VWBVZWMsY7qsq8Tft4duEWWjYO5+kJsVzQw0pI9ZUvLmXNEJH7cZ05ANwM2HP6jAkiqQdPMGNuMpv2HOWRi3ty54huVkIy5fI2OdwMPAUsw1VWWoWrtGSMqeVO5hXy8vJU/rFqJ5fFtueLaWNp39JKSKZidrWSMXWUqrLwx/08s2ALTRqG8vQ1sYzseU6gwzK1SLXLSiIyAHgMiCq+jKoO90mExhif2nH4JE/NTebbXVk8eFE0d4/sToMwKyEZ73lbVvo3MB3XsN1O/4VjjKmOnPxCXvliO2+t/IlL+rVj+bQxdGzVONBhmSDkbXI4oaqf+jUSY8xZU1UWJx1g5oLNNAwP5e07zmd0rzaBDssEMW8vZf0r0BSYB+SdblfVz/0Xmvesz8HUZzuPZPPUvGTW7czgwXE9uXtUNxqGhQY6LBMEfHEpa0v3v9cVa1OgViQHY+qjU/kOXluxnTe/+omxvduwdOoYOkfU/ONCTd1kVysZE2RUlaWbD/K7+ZsJCxUSronhwt5tAx2WCUK+uFopGngd6Otu2gzcr6o7fBOiMcYbuzKySZiXzNc7MphyYTSTR3enUbiVkIzveVtWegf4vaouAhCRy4B3gVF+issYU0xugYPXv9zB3xJ3MLpnG5Y9aiUk41/VGVvJoy1QrKxkzlZ6Rg5pGdl0jWxKl8ja+WG7fMtBEuYnowq/uyaGi/q2C3RIpo7wRYd0soi8gOt+BwVuAZJ9FJ8xAfFm4g7eSNxBoVMJCxHuG9ODyWN6BDqsIrszc/jd/GS+Sj3CvWN6cP/YHlZCMjXG2zOHxsADwHBcYyutBl5V1VP+Dc87duZgqio9I4cJr60iK6egqK11k3DmThkZ8DOI3AIHf0/8ide/3M4FPSJJuDqGruc0DWhMpm7y1aWsL6vq8+4VNgRaA7UiORhTVWkZ2RQ6S36hKHQquzKzA5ocVmw9RMK8ZAodyiu3DOSSfu0QKfNv1xi/8jY5zAdGFnsvuG6IqxXPczCmqrpGNiUspOSHbliIEBURmG/oe7JymLlgMytSDjN5dHemXBhN4wZWQjKB421yCFfV4ndG57rPHowJSl0im3DfmB4l+hzuHxtd42cNeYUO3lq5k1e+SOX8rhEsfmQU3ds0q9EYjCmLt30OC4GPVPUD9/tfAreo6hV+js8r1udgzlZ6Rg67MrOJiqj5q5UStx0mYV4yeQUOpl/Vj8ti21sJydSoivocvE0OHYCXgQtwXa20BnhYVff7MtCzZcnBBJO9R0/xzILNLNtykLtHdefBcdE0aeDtSbwxvlPt5FDbWXIwwSC/0Mlbq37ileXbOS+qNQnXxBDd1kpIJnB8MXzGQOANoI2q9hCR/sCtqvprH8ZpTJ21evsRps9NIifPwfM3DODK/h2shGRqNW/LSmuAW4FPVXWguy1JVWP9HJ9X7MzB1FYHjuUyc+FmliQd4K6R3Xjoop40bWglJFM7+OI+hxBV3Vnqm46j2pEZU0cVOJy8s3onLy1Lpf+5LVn08Ch6tmse6LCM8Zq3ySFVRK4CEJH2uO6W/q6yhUTkHuAOoAC4S1W3F5s2Hbgb+FFVr/JmGWOCwZodGcyYm8SxUwX8/rr+XBPX0UpIJuh4W1ZqhusZ0hfhugFuKTBTVbMrWCYCWIRryI2BwK9U9YZi09sDTXDdeX2VN8tUsC0rK5mAO3Q8l2c/28LCH/YzcXhXHr64J80bhQc6LGPKVe2ykqqeBH7lXlko0KyixOA2FFihqg5gg4j0KrXOAyLStSrLGFMbFTqcvPt1Gn9dlkq/Di1Y+NAoere3EpIJbt5erTQbVwkIYD0QLiJvq+rvK1isNXC0+Gq82FSly4hIAvCUF+syxu/W7cxkxtwkjpzMZ+a1MVwb38lKSKZOCPFyvl6qegLXM6Q/BXoCN1eyTBZnnj0N4PRiO5Uuo6oJqirFX16s1xifOnwij0dnb+SWWd8wrHskX/zfGH428FxLDKbO8LZDuoGIRAG3ATNU1enFH8FaYIa7DBUHpHqxnbNZxpgaU+hw8uE3u3jh8230bt+c+Q+MpF/HFoEOyxif8zY5PI1rZNbVqvqNiHQDKryKSFUzReQ9YCXuK4/cjxdtqaqzRWQycDvQW0SWAbep6sHSy5zdbhnje9/uyuS3c5I5dDyXGVf34/pB5xISYmcKpm6y4TOMqcSRk3n8aVEKn36/l18M7cKjl/amZWO7CskEv7O+WklE3gfeVNVVZUyLxHXXdJaqfuiTSI2pRRxO5V9rd/H8kq30aNuMuVNGENupZeULGlMHVHjm4L7UdCpwCXAAOAI0BLq6f34LmK2q3nQ2+42dORhf+y49ixlzk9h3NJcnLuvDz8+zEpKpe3wyKqu7n6E9kAts8+I+hxpjycH4SmZ2Ps8tTuGTb/dw8/mdeWx8b1o1aRDosIzxCxuy25hKOJzKv9el8/ySrXSNbMLMa2MZcG6rQIdljF/5YuA9Y+qsTbuPMn1uEumZOfzqsj7cfH5nKyGZes/OHEy9lZWdz/Ofb2X2+t3cOPhcHhvfh4imVkIy9YdPzhxEJAboqapzRKQF0FBVD/sqSGNqitOpfLxhN39anMK5rZvwn3svYGCX1oEOy5haxdtRWX8FjAO6qWovEekCfKiqo/0doDfszMF4K2nvMX47J4mdR7J5bHxvbhnShVArIZl6yhdnDrcAg4BvAVQ1XUTsgm8TNI7lFPDnz7fyr3XpXDewE2/fMZjIZg0DHZYxtZa3ySHfPZ6SAlhiMMHC6VT++90e/rgohZ+zdGQAABJdSURBVHYtGvHxPRdwXpSVkIypjLfJ4U0R+QiIFJEncI3I+mf/hWVM9SXvO8aMuclsO3iC/7u0N7cN7UJYqLcDERtTv1XlJrgY4EJcz1j4QlWT/RlYVVifgynu2KkCXly6jQ++2cWEuI78+oq+tGluJSRjSvPVHdJNcN0hXXS2oarbfBJhNVlyMACqyqff7eUPi7ZwTrOGPD0hliHdIgIdljG1VrU7pN1PX7sT2Amc/hRWXFcwGRNwW/YfZ8bcJFL2n2DqJb24/YIoKyEZUw3eXsq6BYhT1Xz/h1R1duZQfx3PLeCvS1N5f00aVw3owG+u6EvbFo0CHZYxQcEXl7J+B3QAdvksKmOqQVWZu3Efz362hdZNwvnn3UMZ2j0y0GEZU2d4mxz+BnwnIjuBfFyd0qqqw/0WmTHl2HbwBNPnJJG09xhTL+nFHcO7Em4lJGN8ytvk8A9cfQ4/AgF9doOpv07mFfLSsm28szqNy/t34ItbBtLOSkjG+IW3yeGAqs7zayTGlENVWfDDfp5ZuJlmDcN4f9IQhkefE+iwjKnTvE0OKSKyEFiEq6wEgKq+6ZeojHHbfugEM+Yms3H3UR66qCeTRnSjQZiVkIzxN2+Twx73y3r8TI3Izivk5S9SeXvlTi6NaceyR8fQsVXjQIdlTL1hz3MwtYqqsijpADMXbKZxeCgJ18QwulebQIdlTJ101peyisi7qjpRRNZw5ua3Ina1kvGlnw6f5Kl5yaxPy+TBcT25e1Q3GoaFBjosY+qlCs8cRKSDqu4Xkaiypqtqrbjvwc4cgltOfiGvrdjOrK92Mq5PW357VV/Obd0k0GEZU+dVe2wlEfm3qt5SWVugWHIITqrKkuSDzFywmbBQ4XfXxDC2d9tAh2VMvVGdslIIEA70EZFwXDe/AbQA4n0apalX0o5kkzA/mTU7MphyYTSTR3enUbiVkIypLSq7WulB4BGgI7CVM8nhBPB3P8Zl6qjcAgevr9jO3xJ/YnSvNix7dAydI6yEZExt421Z6R5VrbXJwMpKtV96Rg7/+34P/16/m3B3CWlcn3aBDsuYes0XfQ6Ca3juKEo+z6FW3ARnyaF2+9OiLby1cicFTqVRWAgPjotmyriegQ7LmHrPF6OyfgqEAt9jYysZL+UWOHhucQr/WJ12pq3QyVurdnJ1XCe6RFo5yZjaytvk0FNVY/0aialTVqQc4ql5yeTkF9I4PIRTBWe+UxQ6lV2Z2ZYcjKnFvB2kZqmI2A1vplK7M3P4f+9v4J4PvmVCfEf+dfcwj6uQwkKEqIimAYrQGOMNb88cbgYeFpEsII8zz3Po6LfITFDJK3Qw66ufeHXFdoZ0i2TJ1NF0O8eVAO4b04M3EndQ6FTCQoT7x0bbWYMxtZyNrWSqLXHbYZ6am0R+oZMZV8cwPqYdrmsYzkjPyGFXZjZREU0tMRhTS/jiaqVLy2pX1c+rGZtPWHIIjL1HTzFz/maWpxxk8ujuTLkwmiYNvD0ZNcYEmi+uVio+TEZDYCSwCagVycHUrPxCJ2+t+olXlm/nvKjWLH5kND3aNAt0WMYYHzqrspKItATeVdWf+T6kqrMzh5qzKvUIM+YlcSrfwfSr+nF5bHuPEpIxJjj44syhtHyg39mHZILN/mOneGbBFpYkH+CuUd14aFxPmja0EpIxdZVXf92lnucQCnQC/uqvoEztkV/o5J3VO3lpeSpx57Zi8SOjiG7bPNBhGWP8zNsO6eLPc3AAB1W1wIvl7gHuAAqAu1R1e7Fp0cDbuEZ9fe/02E0ikg2sd8/2kqr+z4vtWFnJD77ecYQZc5M5fqqA317Vj6sHdLASkjF1SLWuVhKRUGCDqg6s4kYjgEXAcGAg8CtVvaHY9P8Af8DVsb0auFxVM0Ukqap3Y1ty8K2Dx3N5duEWPvtxP3eO6MrDF/eimZWQjKlzqtXnoKoOEfleRPqoakoVtjsUWKGqDmCDiPQqNb2nqn7rDvBLYAiwGOgsIonAXuBhVT1chW2aaihwOHnv6zReXLqNmE4tWfjQKHq3txKSMfWRt18H44AfRGQLkM2ZO6QrGlKjNXC02PvS2an4+ywgwv1zd1XNEJEbgReA20ssJJIAPOVl3KaU9Iwc0jKy6RpZ8ma0tT9lMGNuMhnZ+Tz7s/5MiO9oJSRj6jFvk8N1Z7HuLKB/sfelR3Mt/r4VsBFAVTPcbZ8AT5ZeqaomAAnF20TEakpeeDNxR4lhLO4b04NrB3XiD5+lMG/TPm6/IIqpl/SiRaPwQIdqjAkwvw2f4e5zWIjrhrk44Nel+hw+4UyfwyrgSlzjNuW6S1mjgWmqOsGLbVmfQyXSM3KY8NoqsnLOXEfQODyEEBH6dmjB0xNi6dexRQAjNMbUNH/c51Apd+fye8BK3FcrichlQEtVnQ38mjNXK73rnv88YJaInAQKgXv8FV99k5aRTaGzZALNLXAyeXR3nri8j5WQjDEl2MB79UR6Rg5Xv7qSY6cKi9paNg5j/gOjbCA8Y+qpgJw5mNqj0OFkxdZD5BY4CQ0RGoaF0DAsxIbONsaUy5JDHfftriymz0niwPFcZl4by5CuEezOyrGhs40xFbKyUh2VcTKPPy1O4b/f7eWWIZ157NI+tGxiVyEZY86wslI94nAq/1qXzvOLU+jWphlz7h9B/3NbBjosY0yQseRQh2zcfZTpc5LYk5XDb67oy42DOxMSYlchGWOqzspKdUBmdj7PL0nh4w17uHFwZx4f35vWTRsEOixjTC1nZaU6yulUPlq/m+eWpNC5dRP+e99w4ju3CnRYxpg6wJJDkPphj6uElJaRw2Pje3PLkC6EWgnJGOMjlhyCzNGcfJ5fspWP1u/m54PO5Z07hxBhJSRjjI9ZcggSTqfyn2/38MfFKXRo2YhP7r2AQV1aBzosY0wdZckhCCTtPcb0uUlsP3SSx8b35rahUVZCMsb4lSWHWuj0Mxcimzbg4w27+XBtOj8b2IlZtw/mnGYNAx2eMaYesORQy7yZuIPXv9xObqGTvAInbZo35KPJwzi/a0TlCxtjjI9YcqhF0jNyeGXFdk7knhk5Nb/QQbvmjQIYlTGmPgoJdADG5XhuAc8s3FwiMQA4FHZlZgcoKmNMfWVnDgGmqszZuJdnF6bQvFEYzRqGcjLPUTQ9LESIimgawAiNMfWRJYcASjlwnBlzktm8/ziPXNyTO4Z35Z1VO0s859meuWCMCQQbWykATuQW8NKyVN79Oo0rB3TgN1f0pV2LM/0K6Rk57MrMtmcuGGP8qqKxlSw5+MHpS1G7Rpb8cFdV5m3ax7MLt9CicThPT4hheI9zAhipMaY+s4H3atCbiTtKlIXuG9ODyWN6kHrwBDPmJrNpz1Eeubgnd47oRnioXQ9gjKmd7MzBh9Izcpjw2iqycgqK2lo1DuPy2A588u0eLottz5NX9qVDy8YBjNIYY1zszKGGpGVkU+gsmaSOnSokcdth3ps0hBHRVkIyxgQHSw4+1DWyKWGlxjxqFB7CB3cNpUfbZgGKyhhjqs6K3j50TvMG9GnfHHDdn9CyURiPXtLbEoMxJuhYn4MPqCqLkw4wc8FmGoSFMOXCaNq3bGSXohpjajXrc/CjnUeyeWpeMut2ZjBlbDSTx3SnYVhooMMyxphqseRQBcXvX2jTvCGvrdjOm1/9xNjebVg6dQydI+wswRhTN1hy8NLp+xcKHE5UISxUaNm4AX/75SDG9WkX6PCMMcanLDl4IT0jhzcSd5S4f6FReAhv3zGYnu2aBzAyY4zxD7tayQvbDp4gO6/kUNrhoSEcOJ4boIiMMca/LDmUkp6Rw1fbDpOekQPA8i0HmT43yePmNhtK2xhTl1lZqZji4yIJ0K5FI3Zl5nDv6O40DAvhrVU7bShtY0y9YPc5uJU1LlJYiPD+pCEMdw97YUNpG2PqErvPwQtpGdnkFjhKtDUKD8FRLOl0iWxiScEYUy9YnwOw7qdMnlucwqkCZ4n28NAQ61cwxtRL9frMIa/QweT3N5C47QihIUKDMCFUhLDQEOtXMMbUa/U6Ofzrm3QStx0BwOFUHE5o0SiUp66O4fyuEZYYjDH1Vr1NDm8m7uD3i1I82hVo26KhJQZjTL3m1z4HEblHRL4WkUQRiS41Ldrd/rWI3OPNMr6SnpFTZmIAcDrV+hmMMfWe35KDiEQAk4BRwDTgD6Vm+SPwKDAamCQiEV4s4xP/Xrer3GnRbZvZWYMxpt7zZ1lpKLBCVR3ABhHpVWp6T1X9FkBEvgSGAFLJMj6x0333c1kmjejmj00aY0xQ8WdZqTVwtNj70jdaFH+fBUR4sQwikiAiWvxV1cAuj2lfZnvb5g2ZMLBTVVdnjDF1jj+TQxbQsth7Z6npxd+3AjK9WAZVTVBVKf6qamATBnaiR5uS/Qptmzdg3ZMXV3VVxhhTJ/mzrLQWmCEioUAckFpqeqqIDAI2AWOA59ztFS3jM8unjWXu93tZveMII3qcY2cMxhhTjF/HVhKRe4HbgQLgLiAaaKmqs91XIr0NhAPvqerfy1pGVbd7sZ2APkPaGGOCUUVjK9nAe8YYU09VlBxsbCVjjDEeLDkYY4zxYMnBGGOMB0sOxhhjPFhyMMYY48GSgzHGGA+WHIwxxniw5GCMMcaDJQdjjDEeLDkYY4zxYMnBGGOMB0sOxhhjPFhyMMYY48GSgzHGGA+WHIwxxnjw55PgapRIlZ8Waowxphx14mE/1eF+UFCdzix1fR9t/4JfXd/HYNw/KysZY4zxYMnBGGOMB0sOxhhjPFhygN8FOoAaUNf30fYv+NX1fQy6/av3HdLGGGM82ZmDMcYYD/UqOYjIPSLytYgkikh0qWnR7vavReSeQMVYHZXs37si8q2IfCkifw9UjNUhIg3d+3dURH5exvSgPoZe7F9QH0MR6Ssiq0TkKxFZISLdS00P6uMHXu1j8BxDVa0XLyACWAuEAoOBT0pN/w9wHq4bA9cCEYGO2cf79y4wONBxVnMfQ4AOQALw8zKmB/sxrGz/gvoYAm2AVu6fLwPeqkvHz8t9DJpjWJ/OHIYCK1TVoaobgF6lpvdU1W9VtRD4EhhS0wFWU2X7B/Ca+xvLpTUcm0+oqlNV91cwS1AfQy/2D4L4GKrqYVU96n5bCDhKzRLUxw+82kcIkmNYZ4bP8EJr4Gix96XvViz+PgvXN/FgUtn+TVPVDBFpCywTkVGqeqzmwqsRwX4MK1MnjqGINAGeBu4qPanYz0F9/CrYx6A5hvXpzCELaFnsvbPU9OLvWwGZfo/ItyrcP1XNcP97CCjvzCLYBfsxrFBdOIYiEgZ8BDynqltKTa4Tx6+ifQymY1ifksNaYKyIhIrIICC11PRUERkkIqHAGGBdjUdYPRXun4i0dP/bCBgE7Kr5EP0u2I9hhYL9GIprdMy3gUWqOqeMWYL++FW2j8F0DOtNWUlVM0XkPWAlUADcJSKXAS1VdTbwa1wHNRx4V1WD6luLF/v3b/d/zHDgZfc3l6AjIv8FBgInReQCYCl15BhCpfsX7MdwPHADECUiNwEbgcXUoeNH5fsYNMfQboIzxhjjoT6VlYwxxnjJkoMxxhgPlhyMMcZ4sORgjDHGgyUHY4wJApWNvVXZfCLSREQ+FpGVIvJ3Eanw89+SgzF+4L7fZLGI7BGRLqWmLRSRTSKSJCIzAhWjCToFwPXAX89yvknAWlUd5Z7n8opWYsnBGP94Bdc17ncD/xWR5sWm3ayqcUAccLmI9A9EgCa4lDX2lohEichnIvKFiHwiIo0qGKNrFLDQ/fNC9/tyWXIw5iyJSFcR+U5EPhSRFBF5w93+MJCnqk+o6mJgJvDe6dN4VT3hXkUD96v0OFjGeOs54AlVHQd8BdxRwbzFx1+rdOyqenOHtDF+0g+4EdgJfCsiPVX1peIzqOo8YF7xNhFZgWt46r+r6g81Faypc/oBL7tG7aARZ84MynJ6/LUDeDF2lSUHY6pni6puBxCRH4AoPMft8qCqF7pLTbNFJEZVk/0cp6mbUoDfqupWABFpUMG8XwFXAluBK4AlFa3YkoMx1ZNX7GcnVfibUtUTIrIc1x+qJQdTqTLG3vo/4FURaeqe5Rngi9Lzqeo04B3gXRFZCWwGFlW0LUsOxtQg9x9xS1Xd5/6WNx5X57UxlVLV68tovtqb+VQ1B1cJ1CuWHIypWU2AOe4hm0OAT1V1foBjMsaDjcpqjDHGg13KaowxxoMlB2OMMR4sORhjjPFgycEYY4wHSw7GGGM8WHIwxhjjwZKDMcYYD5YcjDHGePj/0fy8V+AkKqkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import linregress\n",
    "sns.set_context('paper')\n",
    "plt.scatter(n, alap)\n",
    "# coef = np.polyfit([i**2 for i in n], alap[:,0], 2)\n",
    "coef = np.polyfit(n, alap, 3)\n",
    "y_new = np.poly1d(coef)\n",
    "plt.plot(np.linspace(0,max(n),100), y_new(np.linspace(0,max(n),100)))\n",
    "plt.title(\"aLAP (float matrices)\")\n",
    "plt.ylabel('runtime (seconds)')\n",
    "plt.xlabel('nodes (n)')\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter([(i**2) for i in n], alap)\n",
    "# coef = np.polyfit([(i**2) for i in n], alap[:,0], 1)\n",
    "# y_new = np.poly1d(coef)\n",
    "res = linregress([i**2 for i in n], alap)\n",
    "y_new = np.poly1d([res[0], res[1]])\n",
    "m = np.max([(i**2) for i in n])\n",
    "plt.plot(np.linspace(0,m,100), y_new(np.linspace(0,m,100)))\n",
    "plt.title(\"Linear Regression\")\n",
    "plt.ylabel('runtime (seconds)')\n",
    "plt.xlabel('n^2')\n",
    "plt.figtext(0.15,0.80, 'R^2 = '+ str(res[2]**2))\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter([(i**2)*np.log(i) for i in n], alap)\n",
    "res = linregress([(i**2)*np.log(i) for i in n], alap)\n",
    "y_new = np.poly1d([res[0], res[1]])\n",
    "print(res)\n",
    "m = np.max([(i**2)*np.log(i) for i in n])\n",
    "plt.plot(np.linspace(0,m,100), y_new(np.linspace(0,m,100)))\n",
    "plt.title(\"Linear Regression\")\n",
    "plt.ylabel('runtime (seconds)')\n",
    "plt.xlabel('n^2 log(n)')\n",
    "plt.figtext(0.15,0.80, 'R^2 = '+ str(res[2]**2))\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter([(i**3) for i in n], alap)\n",
    "res = linregress([(i**3) for i in n], alap)\n",
    "y_new = np.poly1d([res[0], res[1]])\n",
    "m = np.max([(i**3) for i in n])\n",
    "plt.plot(np.linspace(0,m,100), y_new(np.linspace(0,m,100)))\n",
    "plt.title(\"Linear Regression\")\n",
    "plt.ylabel('runtime (seconds)')\n",
    "plt.xlabel('n^3')\n",
    "plt.figtext(0.15,0.80, 'R^2 = '+ str(res[2]**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinregressResult(slope=9.622959754997917e-09, intercept=-0.00402675932840893, rvalue=0.9968049940260816, pvalue=5.404957025842048e-19, stderr=1.927711940141621e-10)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.scatter(n, scipy)\n",
    "# coef = np.polyfit([i**2 for i in n], alap[:,0], 2)\n",
    "coef = np.polyfit(n, scipy, 2)\n",
    "y_new = np.poly1d(coef)\n",
    "plt.plot(np.linspace(0,max(n),100), y_new(np.linspace(0,max(n),100)))\n",
    "plt.title(\"scipy LAP (float matrices)\")\n",
    "plt.ylabel('runtime (seconds)')\n",
    "plt.xlabel('nodes (n)')\n",
    "\n",
    "# plt.figure()\n",
    "# plt.scatter([(i**2)*np.log(i) for i in n], scipy[:,0])\n",
    "# coef = np.polyfit([(i**2)*np.log(i) for i in n], scipy[:,0], 1)\n",
    "# y_new = np.poly1d(coef)\n",
    "# m = np.max([(i**2)*np.log(i) for i in n])\n",
    "# plt.plot(np.linspace(0,m,100), y_new(np.linspace(0,m,100)))\n",
    "# print(coef)\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter([(i**2) for i in n], scipy)\n",
    "# coef = np.polyfit([i**2 for i in n], scipy[:,0], 1)\n",
    "# y_new = np.poly1d(coef)\n",
    "res = linregress([i**2 for i in n], scipy)\n",
    "y_new = np.poly1d([res[0], res[1]])\n",
    "m = np.max([(i**2) for i in n])\n",
    "plt.plot(np.linspace(0,m,100), y_new(np.linspace(0,m,100)))\n",
    "plt.title(\"Linear Regression [scipy]\")\n",
    "plt.ylabel('runtime (seconds)')\n",
    "plt.xlabel('n^2')\n",
    "plt.figtext(0.15,0.80, 'R^2 = '+ str(res[2]**2))\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter([(i**2.3) for i in n], scipy)\n",
    "res = linregress([i**2.3 for i in n], scipy)\n",
    "y_new = np.poly1d([res[0], res[1]])\n",
    "m = np.max([(i**2.3) for i in n])\n",
    "plt.plot(np.linspace(0,m,100), y_new(np.linspace(0,m,100)))\n",
    "plt.title(\"Polynomial Fitting (deg=1) [scipy]\")\n",
    "plt.ylabel('runtime (seconds)')\n",
    "plt.xlabel('n^2.3')\n",
    "plt.figtext(0.15,0.80, 'R^2 = '+ str(res[2]**2))\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5AAAAJjCAYAAAB6Pf4nAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeVhV1f7H8fdmFhBQURPMGVNyxMopAaeupTl0zTQLtdQGcyi9mVbOU/6sm97KtBwyhzJvTpVpA1qa5jylpoaaiSMIyCyH/fuDOFdkRvCAfF7Pw0Psvfbe33M4xvmctfZahmmaiIiIiIiIiOTGztYFiIiIiIiISMmgACkiIiIiIiJ5ogApIiIiIiIieaIAKSIiIiIiInmiACkiIiIiIiJ5ogApIiIiIiIieWLTAGkYRlXDMGYbhrHVMIxYwzBMwzCC83F8M8MwfjAMI84wjKuGYXxmGIZvEZYsIiIiIiJSatm6B7IO0AeIBX7Iz4GGYdQHNgMG0BMYBDQFNhuG4V64ZYqIiIiIiIiDja//k2malQAMw+gOdM3HsROBa8CjpmnG/X2Ow8BvwBDgrfwWYxhGCmmhOia/x4qIiIiIiNwBPIBU0zSzzIo2DZCmaaYW5DjDMByBLsDH6eHx7/MdMwxjB/BPChAgSQuPhqenp2dB6hIRERERESnJoqOjIYeRqrbugSyoWkAZ4HAW+w4C/Qp43hhPT0/PqKioAhcmIiIiIiJSUnl5eREdHZ3tiMySGiAr/P09Mot9kUAZwzDKmKaZcOMOwzByS4bqeRQREREREcmGrSfRuVVmAfeJiIiIiIhIPpXUHsiIv79XyGJfeSDBNM3Em3eYpumV00n/7qFUL6SIiIiIiEgWSmoPZBiQADTIYl9Dsr43UkRERERERG5BiQyQpmleB74G/mkYhmv6dsMw6gItgS9tVZuIiIiIiMidyuZDWA3D6Pn3f97/9/cgwzC8gTjTNDf83eY0gGmaNW44dDywE1hnGMYswA2YCpwG3i/ywkVEREREREoZmwdI4Iubfp7w9/czQI3sDjJN84hhGG1JW+/xv8B1YBMw0jTNa4Vf5v/ExcURExNDSkoKqakFWspSRETktrCzs8PFxQVvb28Mw7B1OSIiUsLZPECappnrX7Obeh5v3L4LaFfYNWUnNTWV8PBwrl27hp2dHY6Ojtjb29+uy4uIiOTb9evXiY2NJSkpCV9fX4VIERG5JTYPkCVJdHQ0165dw9vbmwoVKmBnVyJvIRURkVImMjKSixcvcuXKFSpWrGjrckREpARTAsqH2NhYnJyc8Pb2VngUEZESo3z58jg7O5OYmGmFKxERkXxRCsqH1NRUHBwcNPxHRERKHHt7e923LyIit0wBUkRERERERPJEAVJERERERETyRAFSRERERERE8kQBUgCYMGFCpns7DcNgwoQJtilIbousfu+lwYULF5gwYQL79+/Ptk1QUBAjR460/rxlyxbc3d0JDw+/HSUWqdOnT2MYhvVrzZo1GfavX7+e5s2b4+LiQvny5XniiSf4888/83z+a9euMWbMGGrXro2zszOVKlWiU6dOREZGWtukv/ay+4qNjc31Or/99htdu3bF09MTNzc3AgMD+emnnzK1S1//0DAMRowYkefHkV8HDhxgwoQJrFixIts2FouFt99+m4ceeghfX19cXV2pX78+48aN49q13JcwTk1NpW/fvtSvXx8PDw/c3Nzw9/dn6tSpxMfHF+bDERERyZKW8ZBsbd++napVq9q6DClCAwcOpFOnTrYu47a7cOECEydOpEaNGjRp0iTT/v/+97/s2bOHVatWWbcFBQXRokULxo4dy+LFi29jtUXnjTfeoHPnztxzzz3WbatWraJXr15069aNcePGER0dzfjx42nTpg379u2jfPnyOZ4zJiaG4OBgYmNjGTt2LH5+fly5coXQ0FCSk5Mztf/uu+9wd3fPtN3V1TXH64SFhdG6dWuqVq3K/PnzcXNz4/3336djx46EhobSqlUra9uNGzdy/fp1WrZsmdtTUmCHDx+mffv2JCQkEB8fT0REBC+99FKmdgkJCUycOJE+ffowePBgvL292bVrF5MnT2bDhg1s374dB4fs/zSbpklSUhLDhg2jVq1a2Nvbs3XrViZNmsTPP//Mt99+W2SPUUREBEj7Y6SvtC8gytPT08zO6dOnzdOnT2e7vyQbP368mfZyKDkSExNtXYKUUPv27TMBc9GiRVnub9asmTlgwIBM2//73/+a9vb25tmzZ4u4wqJ16tSpbB+/n5+f2aRJEzM1NdW67cSJE6aDg4M5duzYXM/90ksvmb6+vmZERESO7dL/n3P16tV812+apjlo0CCzTJkyZnh4uHXb9evXTT8/P7NVq1ZZHgOYw4cPL9D1cnL06FGzUqVKZkBAgBkeHm4OHTrUNAzDnDdvXqa2KSkp5pUrVzJtX7x4sQmY69atK1ANo0ePNgHzzJkz2ba5k/+GiYhI4fH09DSBKDObzKQhrJKtm4ewpg85O3r0KE888QQeHh5UrlyZZ555hujo6AzHpqam8u9//5uGDRvi4uKCt7c3ISEhXLhwIUO7zz77jI4dO3LXXXfh6urKvffey5QpU0hKSsrQLjg4mCZNmvD9999z//334+LiwvTp0/P0OC5fvsygQYO4++67rcPpgoKC+PXXX7N9rOlq1KhB//79rT8vXrwYwzD48ccfCQkJoVy5cnh6ejJw4EASExMJCwujS5culC1blurVq/N///d/eaqxIM/J3r176dy5M5UqVcLZ2ZmqVavSvXt3rl69am0zd+5cGjVqhJubGx4eHvj7+zNjxgzr/qyGsEZFRfHss89Svnx53N3defjhhzlx4sQtvR7Shw5+8MEH1KlThzJlytC8eXP27dtHSkoK48aNo2rVqnh6etKjRw8uX76c6Xn59NNPuf/++3F1dcXT05Pu3btz4sSJDG3SXyc7duygdevWuLq6UqtWLWbMmGFdvmDz5s00bdoUgAEDBliHNqb3Ku7Zs4c9e/bw1FNPZaqhS5cuuLu7s2DBgux+fdmKj4+nfPnyPP/885n2HTp0CMMwWLhwYb7PW5giIiI4ceIEnTt3zvC6qFOnDv7+/hl6ZLMSHx/PwoULGTRoUK49lbdq+/btBAQEUKVKFes2BwcHHn74YX755RfOnz9foPNu3rwZwzBYuXIlr732GlWqVMHDw4MOHTrw+++/Z2p/8uRJ2rdvT6NGjdi8eTNVqlRhzpw5TJ06lRdeeCFTb7W9vT0VKlTIdJ77778fgL/++qtAdXt7ewPk2HspIiJSGPSXphCkWFI5H118Fmeu4umCg33RfTbw2GOP8cQTTzBo0CAOHjzI2LFjATK8+R0wYACff/45I0eOJDg4mHPnzvHmm28SHBzMnj17cHNzA+CPP/7g0Ucf5ZVXXqFMmTIcPHiQKVOm8Pvvv/Ppp59muO5ff/3Fs88+y+uvv46fnx9ly5bNU71PPfUUf/zxB1OnTqVGjRpERETw66+/ZrgfK78GDhzIE088wRdffMH27dsZN24cpmmyY8cOBg4cyIgRI1ixYgWvvvoqdevWpVu3bnk+d16ek9jYWDp27EhAQADz58+nXLlyhIeH891331kXCl+xYgVDhw5l7NixBAUFYbFYOH78eI738KWmptKlSxf27t3LhAkTaNq0Kdu3b+eRRx7J9pi8vB4AVq9eTc2aNXn77be5fv06I0eOpGvXrjz00EMkJyfz8ccfc/bsWV555RUGDx7M6tWrrceOHz+eKVOm8PzzzzN58mSio6OZPHkyrVu35sCBAxlCxLlz5wgJCWHUqFFMnDiRL7/8kjFjxuDj40NISAgBAQEsWbKEkJAQ6xBOgNq1awPwzTff4OjomGEIZDonJydatWrFN998w/jx463bJ0yYwMSJEwkNDSU4ODjL58nV1ZVnnnmGefPmMXPmTDw8PKz73n//fcqVK0efPn2yfZ4h7f45M220RI7s7Oyws8v//wPSh5g6Oztn2ufs7Mzhw4dJTEzExcUly+N3795NfHw8vr6+9OnTh/Xr15OSkkKLFi2YPn16lkNILRYLKSkpGbYZhoG9vX2utWZXJ6QNKb3xdZFfo0ePpk2bNixYsIDo6GhGjx7No48+ytGjR621nT59mnbt2hEYGMgnn3yCk5OT9fj019xzzz2Hk5MTTz75ZI7X+/HHHwFo0KBBnuozTROLxUJ8fDzbt2/n7bff5umnn8bHx6eAj1hERCRvFCALwfnoRNrMDLV1GVY/v9qWu8vnfP/QrRg8eDAvv/wyAB06dOCPP/5g4cKFLFiwAMMw+OWXX1iyZAnvv/8+L774ovW4Jk2aEBAQwOLFixkyZAgAr7/+unW/aZo8+OCDlCtXjv79+zN79uwMvRgRERGsXbuW1q1b56vebdu2MXXqVEJCQqzbevToUaDHfuPx6T2gHTp04Mcff2ThwoV8+umn1p6r4OBg1q9fz/Lly/MVIPPynBw7dozIyEhmzZpF48aNre1vDCDbtm2jYcOGTJo0ybrtoYceyvHaGzZsYNu2bXz00UcMHDgQgI4dO+Lk5MSYMWOyPCa310M6i8XChg0bKFOmDABxcXH079+f06dP88MPP1jbHTlyhNmzZxMfH4+rqyt//vkn06ZNY+TIkcycOdPark2bNvj5+fHOO+9k6OmNiIhg48aNBAQEWGvasmULy5YtIyQkBA8PDxo2bAikhcYWLVpkeDzbt2+nXr162YakgIAAZsyYkSFI2dnZYW9vn+uEREOGDOHf//43S5Yssd4fFxMTw7Jly3juueesz012ateuzZkzZ3JsA2mBuyATYFWuXJny5cvzyy+/ZNh+9epVjhw5QmpqKlevXs02mKV/OJH+wdGqVatISEhg0qRJtGvXjl9//ZVGjRplOCa95+xGzZo1Y/fu3TnW6u/vz88//2x9naTbtm0bAFeuXMn9AeegUaNGLFmyxPqzg4MDvXr1YufOndYgXKNGjRwnF+rXrx/9+vXL9VphYWGMGzeOoKAg2rRpk6f6vv76ax599FHrz+kfToiIiBQ1DWGVfOvatWuGnxs1akRiYiIXL14E0npw7Ozs6N27NykpKdavBg0a4Ovry5YtW6zHnjx5kn79+lGtWjWcnJxwdHQkJCSE1NTUTMMTK1asmO/wCNC8eXPeeust3n77bfbv34/FYinAo84ovdcqXf369QEy9NQ5ODhQp06dPL3hv1FenhM/Pz/KlSvHwIED+eSTTzh16lSm8zRv3pwDBw7w/PPPs2nTpkzDSrOS/rvp1atXhu059Yzl9npI165duwwBKf05y+q5NE3T+sZ806ZNpKSk0Ldv3wyvp0qVKhEQEJDh9QTg6+trDY831pTX30N4eDgVK1bMdn+lSpWwWCwZHt+4ceNISUkhKCgox3PXrFmTLl26MHfuXOu2Tz75hLi4OF544YVca1u/fj27du3K9Wvw4MF5eKSZ2dnZMWTIEL799lumTZvGpUuXOHnyJH379rX2bOfUs5k+TNjX15cvv/ySTp060aNHD7799lvs7e0zfACQLjQ0NFP9N44+uPF3npKSYu2Bfemll4iMjCQkJISwsDAuXrzI66+/bh2aXpAe2Btl9boG8v3vOTeXL1+mc+fOuLm5sXTp0jwf16ZNG3bt2kVoaCjTp0/nyy+/5J///Kf1dyAiIlJU1ANZCKp4uvDzq21tXYZVFc+se04Ky83376QPGUt/g3nx4kVSU1OzvM8H/tczEBMTQ5s2bXB3d2fChAn4+flRpkwZdu7cyZAhQ0hISMhwXEGHo33++edMnjyZ2bNnM2rUKMqXL0/v3r2ZOnUqXl5eBTrnzfd3pQ9dy2p7VFRUns+b1+fE09OTLVu2MHnyZEaMGEFUVBQ1a9ZkyJAhvPLKKxiGwdNPP20dGvrxxx9jGAZt2rRh+vTpNG/ePMvrR0ZG4uLikmF4JaT1TGUnt9dDuvw8Zzcenx7UspotFdJCWU71pNd0cz3ZSUhIyLb3EbDuu/n1mVfDhg2jQ4cObN68meDgYObOnUunTp2sQ2hz4u/vn+chrAU1btw4YmNjmThxorU3vHPnzgwYMIBPP/0023/X8L/nvmPHjhmGoFauXJmAgAD27t2b6ZgmTZrk+O/Q0dExw8+LFi2if//+tG/fnkWLFjFy5Ejrc+fv78/kyZMZO3bsLQ/lzOvr+lZERETQoUMHoqKi2LJlS75mvfb09OS+++4D0kY7+Pn50bNnT9auXXvLIyxERKTwXbekEnY5jnvuytstWMWZAmQhcLC3K9IhoyWNt7c3dnZ2bN26NdObP8B672JoaCgXLlxgy5YtBAYGWvcfOHAgy/MWdL1Cb29vZs+ezezZszl79iyrVq1izJgxXLt2zTpEzdnZOdMkNZD2Bu92ys9z0rBhQ1auXIlpmhw8eJAPP/yQUaNGUa5cOZ555hkAnn32WZ599lni4+MJDQ1l7NixPPTQQ5w+fZpy5cplOmeFChVITEwkJiYmQ4i8uTfxdkof4rhmzRp8fX0z7c/qPrhbvV5O98em78tq6GVetG/fHn9/fz744ANSU1M5evRonidbKuohrJDWc/7OO+8wadIkTp06hbe3N1WqVOGhhx6iRYsWOU7Skj40OCumaRYo2O7atSvDzzd+YNCvXz/69u3LiRMncHR0pE6dOkybNg1XV1eaNWuW72vdTpGRkbRv357z588TGhpK3bp1b+l8DzzwAADHjx8vjPJERKSQvR96kvd+PMnw9n4Mbe9n63JuiQKkFLqHH36YGTNmcOHChRw/CU8PhDdOPGGaZoFmuMyru+++m5dffpl169ZlCGU1atTg4MGDGdr++OOPeVrMvDAV5DkxDIPGjRvz3nvv8fHHH2cZNl1dXencuTNXrlyx3neYVYAMCgpi5syZrFy50noPJJDjwuhF7aGHHsLe3p6wsLB83Uuak/TQmVUvYv369Vm/fn22x4aFhVGpUqUCB0iAoUOHMmzYMC5evEjNmjV5+OGH83Tc+vXrs/yg42aFMZGKu7u7NRDu2rWLH3/8kc8++yzX6zZv3pxNmzZhsVisvZAXLlxg79699O7dO991pPeyZcfBwcE6HDoqKor58+czYMCAXNeRtKWrV6/SoUMHzp49S2hoKPfee+8tnzM0NO0+/Dp16tzyuUREpHAdPhfNez+eJCXVJCbxuq3LuWUKkFLoAgMD6d+/PyEhIQwdOpQHH3wQFxcXzp07R2hoKI888gg9e/akVatWeHl58fzzzzNx4kQMw+DDDz/McgmHgoqOjqZdu3Y8+eST1KtXDzc3N7Zu3crWrVsZOXKktd1TTz3FuHHjrBNZHDlyhPfeew9PT89CqyUv8vqcfPXVV8ydO5fu3btTs2ZNLBYLy5Ytw2Kx0KlTJwAGDRqEq6srrVu35q677uKvv/5i+vTpVKtWDX9//yyv36lTJ1q3bs2wYcO4evWqdRbW9J7aW72vrCBq1qzJm2++yejRowkLC6Njx454eHhw/vx5tm3bRr169bJcsD23c7q6urJ8+XLuvfdeXF1dqVmzJhUqVCA4OJgFCxYQFhZGrVq1Mh27Y8cO2rbNOGQ9L7Ow3ujpp59mzJgx/PTTT8ycOTPPz2tOPXyF5YcffmDv3r00atTIOrPw//3f//HUU0/Rs2fPDG0NwyAoKIjNmzdbt82aNYt27drRrVs3XnjhBeLj45kyZQoODg689tprma63e/du3N3dM21v1KhRjiHw/PnzzJ49m1atWuHu7s7Ro0eZOXMmXl5eTJs2reBPQBFLSEjgH//4BwcOHOA///kP8fHx7Nixw7q/atWq1qGsp0+fpmbNmvTr18+6HMjy5ctZs2YNjzzyCNWqVSMhIYGtW7cyZ84cWrRoUWgfsoiISOFISrEwcuUBUlJNald0Y+RD99i6pFumAClFYuHChbRo0YKPPvqId999Fzs7O3x9fQkKCrJORuHt7c369esZNWoUffr0wdPTkz59+jB06NAcl43IDxcXFx544AEWL17MmTNnsFgs1KhRg8mTJ/Ovf/3L2u7VV1/l2rVrLF68mFmzZvHAAw+wcuXK2/5mLK/PiZ+fHx4eHsyYMYPw8HBcXFzw9/fniy++sPZmtWnThsWLF/PZZ58RFRVFxYoVadu2LRMnTsx22KednR3r169n5MiRTJs2jeTkZFq3bs3SpUtp0aLFbQ/U6caPH4+/vz//+c9/WLx4MSkpKfj4+NCyZcts7+fMiYuLCwsWLGD8+PG0b9+elJQU67113bp1w93dnbVr11pnl00XFhbGoUOHmDp16i09Hjc3N7p06cKqVausw42LCycnJ1atWsWUKVNITk6mXr16zJo1i+eeey5Pxz/44INs2rSJN954g8cffxwHBwcCAwNZunQpfn6Zh+x07Ngxy/Ps27cv2/teIe3eyL1791qX2ahatSq9e/fm9ddfz3QPb3Fy8eJF67Dc9Nmob5Tb8OP69euzcuVK3nzzTS5duoS9vT116tRh9OjRjBw5UutAiogUM7O/P8HvF69hZ8DbvZrg4pjzMlUlgZGXCRlKC8Mwojw9PT2zm/Qk/d6j6tWr386yRGxu+fLl9O3bl61btxZoJtyS5qWXXmLr1q3s378/w/bx48ezZMkSTp48mes6hTlJTEykevXqPPLIIyxatOhWy8239J6tBQsWEBISkqclSEqy9PUzHR0dGT58OO+++66tS7IJ/Q0TEbm99v15lX/O/YVUE4a0rc2//lHP1iXliZeXF9HR0dGmaWY5y50+qhSRDJYtW8alS5esC5qnD2Fs06ZNqQiPAG+++SZ+fn589dVXdOnSBUibIfe9997jvffeK3B4jIiI4MSJE8ybN4+IiAhGjRpVmGXnW/okS6tXr6Z79+42raUoVa5c+bZPiCUiIqVb4nULI784QKoJ9e4qy7ASPnHOjRQgpcRKTU3Ndc2z4jScK70XJDuGYdxSr1ZhcXd355133uHkyZPEx8fj4+PDgAEDmDx5sq1Lu20qV67M0qVLiYuLs247deoUr732Wo5rYuZm/fr1DBgwAB8fH+bNm1cok6cUhI+PT4bZTe/0iVd++OEHrl9Pm7QgpyVpRERECsusjb8TdjkOBzuDt3s1xtnB9u/xCouGsN5AQ1hLlvSJS3Jy6tQpatSocXsKykWNGjVyXILh5slIREQKk/6GiYjcHjtPRfLE/O2YJrzcoS7DO5Ss3kcNYZU71uDBg63DC7NTGMsZFJbclmBIXx9TREREREqm+OQU/rXqAKYJDX09ebFtbVuXVOgUIKXE8vHxKVYBMTe3YwkGEREREbGdGRuOcSYiHid7O97u1RhH+9u/BFpRu/MekYiIiIiIyG227eQVlmxPu13g5Y51qVv5zhxdpgApIiIiIiJyC64lXufVVQcBaFrNi8GBtWxcUdFRgBQREREREbkFU746yrmoBJwd7Jj1eGPs7e7c9ZUVIEVERERERArox2MX+Xz3WQBe7VSP2hXdbVxR0VKAFBERERERKYDIuGReXXUIgJa1KjCgVQ3bFnQbKECKiIiIiIjkk2mavLnmMFdik3B3duD/Hm+E3R08dDWdAqTky+bNmzEMgzVr1uSp/S+//IJhGJQtW5bY2Ngs29SoUQPDMKxfd911Fx06dODHH38szNJvu/TnKv1r//791n0ff/wxXbt2pXr16pQpUwY/Pz+GDRvG5cuX83z+a9euMWbMGGrXro2zszOVKlWiU6dOREZGWttMmDAhQw03f2X3O7nRb7/9RteuXfH09MTNzY3AwEB++umnTO28vb2t5x0xYkSeH0d+HThwgAkTJrBixYps21gsFt5++20eeughfH19cXV1pX79+owbN45r167leo3Tp09jGAaLFy8uxMqzdvz4cZydnTlw4EC+j/3jjz9wdnZm3759RVCZiIiI5GTdgXC+PnQegHFd/KlaztXGFd0eWgdSitTChQsBiI2NZeXKlTzzzDNZtgsMDOStt97CNE1OnTrFlClT6NChA2vXruXRRx+9nSUXuvfff5+AgADq1q1r3TZ+/Hjatm3L9OnT8fX15ciRI0ycOJF169axf/9+vLy8cjxnTEwMwcHBxMbGMnbsWPz8/Lhy5QqhoaEkJydnav/dd9/h7p55PL6ra87/owsLC6N169ZUrVqV+fPn4+bmxvvvv0/Hjh0JDQ2lVatW1rYbN27k+vXrtGzZMrenpMAOHz5M+/btSUhIID4+noiICF566aVM7RISEpg4cSJ9+vRh8ODBeHt7s2vXLiZPnsyGDRvYvn07Dg7F439/I0eOpHv37jRu3Djfx9auXZunn36al19+mc2bNxd+cSIiIpKlizGJjFv7GwAd6lfi8fuqZtnOkmqy5fglVu8LJyI2iQruzvRo6kNQ3UoldqKd4vEOSu5IcXFxrFy5ktatW3PkyBEWLlyYbYAsV64cLVq0AKBly5a0aNGC2rVrM2fOnBIfIP39/a2PLd2+ffuoVKmS9eegoCD8/f0JDg7m008/ZejQoTme8/XXX+fSpUscPHiQ8uXLW7c/9thjWba/7777cg2lWZkxYwbJycl89913VKlSBYBOnTrh7+/Pv/71L7Zt22Zt26xZs3yfPz+OHTtG+/btqV69Ol999RXTp09n2LBhODk5MXjw4Axty5Qpw6lTp6hQoYJ1W3BwMJUqVaJ///5s2LChWLyuDh8+zFdffcWWLVsKfI4XX3yRZs2asWPHjkyvMxERESl8pmny6qqDRCdcp5yrI9Mea4hhZA6DV2KTGLBoJ4fOxWBnQKoJdgasPxBOQ18PFg14AG93Zxs8glujIawCwMmTJ+nfvz+1a9emTJky3H333fTs2ZOTJ08W+JxffPEF165d47nnnqNPnz5s27aN48eP5+nYWrVqUbFiRc6cOZOva549exYHBwdmzJiRad+6deswDKNYDI29MTymu//++wH466+/cjw2Pj6ehQsXMmjQoAzhsShs376dgIAAa3gEcHBw4OGHH+aXX37h/PnzBTpv+vDelStX8tprr1GlShU8PDzo0KEDv//+e6b2J0+epH379jRq1IjNmzdTpUoV5syZw9SpU3nhhRcyDTW1t7fPEB7T5dxM8w8AACAASURBVPU5zs6qVau47777KFOmDJ6ennTp0oWDBw9mavfRRx9Rt25dnJ2dqV+/PkuWLKF///7UqFEjQ7t58+ZRrVo12rRpk2F7cHAwTZo0YceOHbRu3RpXV1dq1arFjBkzSE1NzdA2ICCA+vXrM2/evAI9JhEREcmf5Tv/ZMvxtNuOpvZoSKWyLpnaWFJNBizayW/hMUBaeLzx+2/hMQxYtBNL+oYSRAGyMFhS4OqZ4vNlScn3QwgPD6dSpUrMmjWLjRs38s477xAZGUnz5s25dOlSgZ6WhQsXUrZsWf75z39aex7Th7TmJjo6msjISCpWrGjd1r9/fwzD4PTp09ked/fdd9O9e3fmzZuX6Y32Bx98QP369WnXrl2O105JScnTl2kW7j/49GDboEGDHNvt3r2b+Ph4fH196dOnD+7u7ri4uBAcHMz27duzPMZisWSq32Kx5FpTcnIyzs6ZPxlL33b48OFcz5GT0aNHEx4ezoIFC5g3bx7Hjx/n0UcfzVDb6dOnadeuHYGBgXz99deULVvWum/MmDEsXLiQ559/nuXLl+d6vbw+x1lZvHgxjz/+OL6+vqxcuZK5c+dy8uRJWrduzdGjR63t5s+fz+DBg2nSpAlffvklb775JlOnTiU0NDTTOb/55hsCAwOz/NTy3LlzhISE0K9fP9atW0enTp0YM2YMS5cuzdQ2ODiYb775Jt+PSURERPLnTEQcU79O+7vfrYkPjzSskmW7LccvcehcDNnlw1QTDp2L4afjeZ//orjQENbCEHMOZjeydRX/M/wglKuer0MCAwMJDAy0/myxWOjcuTOVKlVixYoVDB8+PF/nO3nyJD///DMDBw7E1dWVZs2a0ahRI5YsWcLUqVOxt7fP0N40TWsoO336NKNGjcJisdCnTx9rG3t7e+zt7bN8s32jYcOGERQUxDfffEOXLl2s9WzatIk5c+bkWrujo2OeHuOiRYvo379/ntrmJjIykmHDhuHn50evXr1ybBseHg6k3TsXHBzMqlWrSEhIYNKkSbRr145ff/2VRo0yvh69vb0znadZs2bs3r07x2v5+/vz888/Ex8fn+F+yfShq1euXMnT48tO+msinYODA7169WLnzp3Weylr1KjBn3/+me05+vXrR79+/XK9VlhYGOPGjSMoKChTj19uUlNTGTNmDPfddx9r1qyxvgbbtm1L7dq1mTRpEitWrMBisTBu3Dhat27NypUrrcc/+OCD1KlTBx8fH+u2S5cuERYWxpAhQ7K8ZkREBBs3biQgIACADh06sGXLFpYtW0ZISEiGtgEBAdZAW6dOnXw9NhEREckbS6rJqC8OEJ9sobKHM5O6Zv+B9Op94dZhq9mxM2D1vnO0rZd5ZFpxpgApQFpP0+zZs/nkk084ffo0cXFx1n3Hjh3L9/nSexoHDBhg3TZgwABefvllNmzYYA126datW5chuJUtW5Zx48ZleHO9YMECFixYkOu1AwMDady4MR988IH1OnPnzsXNzS3TG++s7Nq1K9c2ADVr1sxTu9zEx8fTvXt3IiMj+emnn7Ls8btRes+qr68vX375pTWMt2rVitq1azNz5sxMvVShoaGZJtFxc3Oz/ndKSsZe6/Sg/tJLL7F27VpCQkKYOXMmbm5uzJkzh19//RUAO7tbG8TQtWvXDD+nB98zZ84U6mQ8ly9fpnPnzri5uWXZg5ebY8eOceHCBUaPHp3hA4wqVapYJxQC+P3337l48SJjx47NcHy1atVo3bo1p06dsm5L/yDgxl72G/n6+lrDY7pGjRplOeNq+pDoc+fOKUCKiIgUkQVbw9h1+ioAM3s2xtM1+06HiNikHMMjpIXLiLikwizxtlCALAwevmm9fsWFh2++D3n55ZeZN28eY8aMITAwEC8vLwzD4JFHHiEhISFf57JYLCxZsoQaNWrg7+9PVFQUAF26dGHUqFEsXLgwU4AMCgpi1qxZGIaBu7s7tWvXvqVZMocOHcrgwYMJCwujSpUqLFq0iKeffhoPD49cj23SpEmernFzL2pBJCQk0LVrV/bt28fGjRsz9RxmJf3evo4dO2aooXLlygQEBLB3795MxzRp0iTHSXRu7nVN711t3749ixYtYuTIkdSuXRtI65WcPHkyY8eOzdCjVhA336eYHp4TExNv6bw3ioiIoEOHDkRFRbFlyxaqVs16lrScpC+Nctddd2XaV6VKFSIiIjK0q1y5cqZ2lStXzhAg0/9dubhkvm8CMj83kPb8ZPXcpJ8jv/9WRUREJG+OXYhh1sa0uTz6Nq9GUN2sPwBOV8HdOU89kBXcSt4kOgqQhcHeId9DRoub5cuXExISwuTJk63bkpOTM6wpmFcbN27k3LlzQNrsqjf76quvuHz5coaeFy8vL+67774CVJ61J598ktGjR/Phhx9Sr149rl69yosvvpinY2/XENbExES6devG9u3b+eabbzIsiZGThg0bZrvPNM0C9Qre3Ot6Y+9qv3796Nu3LydOnMDR0ZE6deowbdo069Dk4iwyMpL27dtz/vx5QkNDMyylkh/pYe7ChQuZ9p0/f966P/37xYsXM7W7eVv6sOKC/Bu7Wfo5shqqLCIiIrcmKcXCy58fINmSSvUKrox9pH6ux/Ro6sP6A+E5tkk1oUfT/Hf82JoCpABgGAZOTk4Zti1cuDBPE63cbOHChTg4OLBmzZoMwyQBDh48yPDhw/n000955ZVXbqnmnJQpU4aBAwfy8ccfU7VqVYKCgvI8ccrtGMKalJRE9+7d+fnnn1m/fj1BQUF5PtbHx4fmzZuzadMmLBaLtRfywoUL7N27l969e+e7ntzCu4ODA/Xrp/3PMioqivnz5zNgwIBc15G0patXr9KhQwfOnj1LaGgo9957b4HPdc899+Dj48OyZcsYPny4dRjrxYsX+f777+nWrZu13V133cXKlSsZNmyY9fg///yTbdu2ZeixrV69OmXKlOGPP/4ocF3pwsLCsLe355577rnlc4mIiEhG//7uBEfPpy3F8U6vJrg55x6hgupWoqGvB7+FZz2RjmFAAx8PAnPpySyOFCAFgM6dO7N48WLq1atHw4YN2bp1K/Pmzct22OP27dsz3TcHacskrF+/ns6dO9O5c+dM+wMDA5k1axYLFy7Md4Ds378/n3zyCadOncq0HEJWXnzxRWbNmkVERESGCU1yU5g9odnp2bMnGzduZNy4cbi7u7Njxw7rvooVK1qHi0JauA8KCsqwUPysWbNo164d3bp144UXXiA+Pp4pU6bg4ODAa6+9lul6u3fvznQPJKTdU5dTCDx//jyzZ8+mVatWuLu7c/ToUWbOnImXlxfTpk0r4KMvegkJCfzjH//gwIED/Oc//yE+Pj7Dc1y1atV8DWW1s7NjxowZhISE0L17dwYNGkRsbCyTJk3C3t6e8ePHW9tNnDiR5557jl69etG/f3+ioqKYOHEiVapUydA77OTkRKtWrTLUVVA7duzgvvvuyzBDrYiIiNy6nacimfdT2oe9LwbXoVn1zKPrsmJvZ7BowANZrgOZaqaFx0UDHsDeLufJIYsjBUgBYM6cOdjb2zN16lQSEhJo2bIlGzduzHax9ZkzZ2a5/d133yU5OTnTwu7p7OzsePbZZ5kwYQI7d+7kgQceKLTHcLNq1arRsmVLwsLC6NGjR5FdpyC++uorACZNmsSkSZMy7OvXr1+mdQ1v9uCDD7Jp0ybeeOMNHn/8cRwcHAgMDGTp0qX4+fllat+xY8csz7Nv374c7/l0dHRk7969LFiwgOjoaKpWrUrv3r15/fXX83Q/qa1cvHjR2pOc1Syn48ePZ8KECfk659NPP42bmxvTp0+nZ8+eODk5ERgYyOeff56h52/w4MEYhsHMmTNZu3YtNWrU4LXXXmPt2rWZ1jXt27cvgwcPzjSkOz9iY2P54Ycfslz7VERERAruWuJ1Xlm5H9OEBr4eDGuf+T1WTrzdnVkz5EF+On6Z1fvOERGXRAU3Z3o09SWwbsUSGR4BjMJey64kMwwjytPT0zN90pebpb/5q169ZN/vWFqcP3+emjVrMmbMGGsP0e20efNm2rZty/fff09QUNAtTQpUElgsFkzTxNHRkeHDh/Puu+/auqRiIyoqirp169KtWzc++ugj6/aEhASqVavG2LFjefnllwt07kWLFjF8+HDOnj2Lp6dnYZUsdyD9DRMRyZ9XVx1g5e6/cHaw46uhD+JXuXSM9PHy8iI6OjraNM0shyLe2hz8IsVQeHg4v/zyCwMHDsTJySnPk+cUlQ4dOuDo6Mj+/fttWkdRq1y5cp4nILqTnTt3jhEjRrBmzRq2bNnCkiVLaNu2LdeuXWPEiBEZ2pYpU4YJEybwzjvvkJSU/2m8LRYLb731FmPGjFF4FBERKUSbfrvAyt1/ATC6U71SEx7z4s7uEpFSaf78+UyaNIlatWqxbNmyAg8NvFXNmjXLMCHPnT7ByQ8//MD169eBrJexKC1cXFw4efIkn332GZGRkbi6utKyZUvmzZuX5UQ+zz//PNHR0Zw+fTrfr5G//vqLJ598ssC9lyIiIpLZ5WtJjPnyEACt61Sgf6sati2omNEQ1htoCKuIiNyp9DdMRCR3pmkyaMluvj96CQ8XBza+HEgVzzK2Luu20hBWERERERGRPPh811m+P3oJgMndG5S68JgXCpAiIiIiIlLq/RkRz+SvjgDQpVEVujb2yeWI0kkBMh/s7OxISUlBw35FRKSksVgsGdYiFRGR/0mxpPLyyv3EJVuo7OHMlO4NMIySucxGUdNfknxwd3cnOTmZy5cvk5qaautyRERE8iQyMpKkpCRcXFxsXYqISLE0d/Mf7DlzFYD/69kYL1cnG1dUfGkW1nzw9PQkPj6eiIgIrl69iqOjI/b29rYuS0REJFsWi4WkpCTKli2Lt7e3rcsRESl29p+N4t0fTgAwoHUNAuvaZgb/kkIBMh/s7Ozw9fXFy8uLmJgYUlJS1BMpIiLFmqOjozU8ajiWiEhG8ckpvPz5fiypJnUruzO6Uz1bl1TsKUAWgJubG25ubrYuQ0REREREbsGUr49y6kocTvZ2vPtEU1wcNbowN7oHUkRERERESp3vj1xk+a9/AjDqH3Xx9/GwcUUlgwKkiIiIiIiUKpevJTH6vwcBaFmrAgMfrGXjikoOBUgRERERESk1TNNk9H8PEhGXTFkXB97u1Rg7O90jnlcKkCIiIiIiUmos+/VPfjx2CYCpPRri41XGxhWVLAqQIiIiIiJSKvxxOZYpXx8BoHsTH7o29rFxRSWPAqSIiIiIiNzxrltSGfHZfhKvp+LrVYaJ3RrYuqQSSQFSRERERETueP/+7jiHzkVjGPB2r8Z4lnG0dUklkgKkiIiIiIjc0bb/EcHcLX8A8FxgbVrUqmDjikouBUgREREREbljRcdf55WV+zFNaOjrySsd69q6pBJNAVJERERERO5IpmkydvUhzkcnUsbRntm9m+DkoAh0K/TsiYiIiIjIHWnVnr/4+tB5AMY/6k+tiu42rqjkU4AUEREREZE7zukrcYxf9xsAne69iyfuv9vGFd0ZFCBFREREROSOct2SyvDP9xOfbOEuDxemP9YQwzBsXdYdQQFSRERERETuKLO/P8GBs1EYBrzTqzHl3JxsXdIdQwFSRERERETuGL+GRfD+5pMADG5Ti1Z1vG1c0Z1FAVJERERERO4I0QnXeWXlAUwTGvh6MPKhe2xd0h1HAVJEREREREo80zR5ffUhzkUl4OJox7tPNNWSHUVAz6iIiIiIiJR4X+z5i68Opi3ZMa7LvdSppCU7ioICpIiIiIiIlGhhl2OZcMOSHX0e0JIdRUUBUkRERERESqykFAvDPttHfLKFKp4uzPinluwoSgqQIiIiIiJSYs3a+DuHz8VgGPDvJ5rg5aolO4qSAqSIiIiIiJRIW45f5qOfTwHwUts6tKhVwcYV3fkUIEVEREREpMS5EpvEyJUHAAio5sXw9n42rqh0UIAUEREREZESJTXVZNQXB7gSm0RZZwdm926Kg72ize2gZ1lEREREREqURb+cZvPvlwGY+lhD7i7vauOKSg8FSBERERERKTEOn4vmrQ3HAOjZrCpdG/vYuKLSRQFSRERERERKhPjkFIZ9to9kSyo1vd2Y2PVeW5dU6ihAioiIiIhIiTBx3RHCLsfhaG8wp3dT3JwdbF1SqaMAKSIiIiIixd7a/ef4fPdZAF79Rz0aVvW0cUWlkwKkiIiIiIgUa2ci4nh99WEAgu+pyLMP1rRxRaWXAqSIiIiIiBRbySmpDFuxj9ikFCqWdWbW442xszNsXVappQApIiIiIiLF1qxNv3Pgr2gMA959ogne7s62LqlUU4AUEREREZFiKfT3S8z/KQyAIcF1aF3H28YViQKkiIiIiIgUO5diEhm18gAAzaqXY0QHPxtXJKAAKSIiIiIixYwl1WTE5/uJiEvGw8WB2b2b4GCv6FIc6LcgIiIiIiLFyodb/uCXPyIAmNmzEVXLudq4IkmnACkiIiIiIsXG7tORvPPdcQCealGNTg2q2LgiuZFNA6RhGO6GYcwxDOO8YRgJhmHsNgyjax6P/adhGL8YhnH176/thmH0KuqaRURERESkaETHX2f4Z/uxpJrUu6ssb3T2t3VJchNb90CuBvoCbwCdgSPAasMwHsnpIMMw+gGrgHDgyb+/zgGfG4bxTJFWLCIiIiIihc40TUatOsC5qARcHO1478mmuDja27osuYmDrS78d0jsADxmmubqv7eFArWAt4Fvcjh8AHAG6GWaZurfx24EwoAQYGERli4iIiIiIoVs8S+n+e7IRQAmdWtAnUplbVyRZMWWPZA9gGhgbfoG0zRN4BOgnmEYOfVXXwdi08Pj38emArFAUtGUKyIiIiIiReHgX1FM++YoAD2a+vJ4s6o2rkiyY7MeSKABcOTGEPi3gzfuz+bY94AvDcN4HZgHGMBg4B5gVHYXNAwjKpeaPHMrWkRERERECk9M4nVeWr6P6xaTWt5uTO7eAMMwbF2WZMOWAbICcDyL7ZE37M+SaZpr/55sZykw5e/NccDjpml+W6hVioiIiIhIkTBNkzFfHuLPyHicHOx478kA3J1tGVEkN7b+7ZgF2WcYRkdgObAC+C9gT9pkPCsMw+hpmubXWZ7QNL1yKubvHkr1QoqIiIiI3AbLd/7J1wfPAzCuiz/+Ph42rkhyY8sAGUHWvYzl//4emcU+jLT+7E+AH03TfP6GXd8ahlEV+A+QZYAUEREREZHi4ej5GCauT7tjrXOjKvRtXs3GFUle2HISnd+A+oZh3FxDw7+/H87muMpAFWB3Fvt2AzUNw3ApnBJFRERERKSwxSWlMGT5XpJTUqlW3pXpjzXUfY8lhC0D5GrAC3j0pu0hwO+maWY3gc5VIBF4IIt9LYAI0zQTC61KEREREREpVG+uPUzY5Tgc7Q3ee7IpHi6Oti5J8siWQ1i/AUKBBYZhVABOAf2AB4Fu6Y0Mw9gMBJmmaQCYpplkGMaHwAjDMD4GVpF2D2TI38e+cTsfhIiIiIiI5N0Xu8/y5d5zAIx9pD6NquY4TYkUMzYLkKZpmoZhdAem/f3lRdqyHY+Zprk+l8NHAcdIW7qjJ5BK2oyuTwPLiqxoEREREREpsOMXr/Hm2rQ71Tr6V6Z/qxq2LUjyzTDNnCZCLV0Mw4jy9PT0jIrKbblIERERERHJj7ikFLq9v42Tl2Lx9SrD18MexMvVydZlyU28vLyIjo6Ozm4FC1veAykiIiIiIqWAaZq8ueYwJy/F4mhv8H7fAIXHEkoBUkREREREiowl1WTi+t/4cl/afY91K5clMi4JS6pGQpZEGsJ6Aw1hFREREREpPFdik+g9fzsnL8VZtxmACTT09WDRgAfwdne2WX2SmYawioiIiIjIbWdJNQlZ8GuG8Ahp4RHgt/AYBizaqZ7IEkYBUkRERERECt3m3y9y5Py1bPenmnDoXAw/Hb98G6uSW6UAKSIiIiIihe7d70/m2sbOgNV/3xspJYMCpIiIiIiIFKrD56I5HB6da7tUEyLikm5DRVJYFCBFRERERKTQxCReZ8jyveRlrk47Ayq4aRKdkkQBUkRERERECoVpmrz6xUHORMTjYGfk2j7VhB5NfW9DZVJYFCBFRERERKRQLNh6im9/uwDAxG730tDXg+xypGGkLeURWLfibaxQbpUCpIiIiIiI3LI9ZyKZseEYAI8F+PLkA9VYNOAB7vXxALAGyfTvDXzS1oG0z0NPpRQfDrYuQERERERESraI2CSGLNtHSqrJPZXLMqV7AwzDwNvdmTVDHuSn45dZve8cEXFJVHBzpkdTXwLrVlR4LIEUIEVEREREpMAsqSYjPt/PhZhE3Jzs+eCpAFyd/hcz7O0M2tarRNt6lWxYpRQWDWEVEREREZECm/PDCX4+cQWAt3o2onZFdxtXJEVJAVJERERERApky/HLzPnxBAD9W9WgSyMfG1ckRU0BUkRERERE8i08KoERn+3DNKHJ3V6MfaS+rUuS20ABUkRERERE8iU5JZUhy/dyNf46Xq6OvN83ACcHRYvSQL9lERERERHJl+kbjrLvzygMA959ogm+XmVsXZLcJgqQIiIiIiKSZ18dDGfRttMADG1bh+B7NLtqaaIAKSIiIiIieXLi4jVeXXUQgAfreDO8Q10bVyS3mwKkiIiIiIjkKjYpheeX7iE+2YKPpwuzezfB3s6wdVlymylAioiIiIhIjkzTZPSqg/xxOQ5He4P3+wZQwd3Z1mWJDShAioiIiIhIjhZsPcXXh84DMO7Re2larZyNKxJbUYAUEREREZFs7TwVyfQNxwB4rKkvTzWvZuOKxJYUIEVEREREJEuXYhIZsnwvllSTeneVZWqPhhiG7nsszRQgRUREREQkk+uWVF5avo/L15Io6+zA3KeaUcbJ3tZliY0pQIqIiIiISCYzvz3GztORALzdqzE1vd1sXJEUBwqQIiIiIiKSwTeHzvPRz6cAeCG4Ng/de5eNK5LiQgFSRERERESsTly8xr++OABAq9oVGNmxro0rkuJEAVJERERERACISbzOc5/uIS7ZQhVPF+b0aYqDvSKD/I9eDSIiIiIiQmqqyaiVBwi7EoeTvR1zn2qGt7uzrcuSYkYBUkREREREmLvlDzYduQjAxG730uRuLxtXJMWRAqSIiIiISCn30/HLzNr0OwC977+bPg9Us3FFUlwpQIqIiIiIlGJnI+MZ9tk+TBMaV/VkQtd7bV2SFGMKkCIiIiIipVTidQvPL91DVPx1Krg5MfepZrg42tu6LCnGFCBFREREREoh0zQZu/oQv4XHYGfAf55sio9XGVuXJcWcAqSIiIiISCm0dMcZvtx7DoDXHq5Hq9reNq5ISgIFSBERERGRUmbPmUgmrj8CQOeGVRjUppaNK5KSQgFSRERERKQUuRiTyPNL95KSauJXyZ2ZPRthGIaty5ISQgFSRERERKSUSEpJmzTn8rUkyro4MD/kPtycHWxdlpQgCpAiIiIiIqXEhHW/se/PKAwD5vRuSk1vN1uXJCWMAqSIiIiISCmw7NczrNh5FoCRHevStl4lG1ckJZECpIiIiIjIHW7PmUgmrPsNgE733sWQtnVsXJGUVBrwLCIiIiJSxCypJluOX2L1vnAiYpOo4O5Mj6Y+BNWthL1d0U5gkz5pznVL2qQ5s3o11qQ5UmAKkCIiIiIiRehKbBIDFu3k0LkY7AxINcHOgPUHwmno68GiAQ/g7e5cJNfOatIcd02aI7dAQ1hFRERERIqIJdVkwKKd/BYeA6SFxxu//xYew4BFO7GkbyhkE9Yd0aQ5UqgUIEVEREREisiW45c4dC6G7PJhqgmHzsXw0/HLhX7t5b/+yYqdfwKaNEcKjwKkiIiIiEgRWb0vnNxucbQzYPW+c4V63d2nIxm/7jAA/7i3Mi8Ga9IcKRwKkCIiIiIiRSQiNinb3sd0qSZExCUV2jXDoxIyTJrzdq8m2BXxRD1SeihAioiIiIgUkQruznnqgazgVjiT6CRet/Dcp3u4EpuEZxlHPu6nSXOkcClAioiIiIgUkR5NffLUA9mjqe8tX8s0TV7770EOnYvGzoD3nmxK9QqaNEcKlwKkiIiIiEgRCapbiYa+Htn2QhoGNPT1ILBuxVu+1kc/h7FmfzgAYx+pTxu/Wz+nyM0UIEVEREREioi9ncGiAQ9wr48HgDVIpn9v4JO2DqT9Ld6juPn3S8zYcAyAx5r68uyDNW/pfCLZ0YBoEREREZEi5O3uzJohD/LT8cus3neOiLgkKrg506OpL4F1K95yeAy7HMvQFftINaFxVU+mPdYQw9CkOVI0FCBFRERERIqYvZ1B23qVCn0txmuJ1xm0ZDfXElOoWNaZeU/fh4ujfaFeQ+RGGsIqIiIiIlICpaaajPhsP39cjsPJ3o4Pn2rGXZ4uti5L7nAKkCIiIiIiJdA73x3nh2OXAJjSvQHNqpezcUVSGihAioiIiIiUMGv3n+O90JMA9GtZnV73323jiqS0UIAUERERESlBDpyN4tVVBwFoXacCb3Txt3FFUpooQIqIiIiIlBAXYxIZ/OluklJSqVHBlfefDMDRXm/p5fbRq01EREREpARIvG5h8Kd7uBiTRFlnBz7udx9erk62LktKGQVIEREREZFizjRNXvvvQQ6cjcIwYE6fptSpVNbWZUkppAApIiIiIlLMfbgljDX7wwEY83C9Ql9PUiSvFCBFRERERIqx749cZObGYwA8FuDLoDa1bFyRlGYKkCIiIiIixdTvF64x/LN9mCY0rebFtB4NMQzD1mVJKaYAKSIiIiJSDEXGJTNwyS7iki1U8XRh3tPNcHG0t3VZUsopQIqIiIiIFDPJKak8v3QPZyMTcHG046OQ+6hU1sXWZYkoQIqIiIiIFCemafL66kPsPBUJwDu9mtDAORiJsAAAIABJREFU19PGVYmkUYAUERERESlGPv75FF/s+QuAkR3r8kjDKjauSOR/FCBFRERERIqJH45eZNqGowB0bezDS+3q2LgikYwUIEVEREREioGj52MYtiJtxtUmd3sxs2cjzbgqxY4CpIiIiIiIjV2+lsTAT3YTl2zBx9OF+SGacVWKJwVIEREREREbSrxu4fmlezgXlYDr/7N33+FVl/f/x593AoQRSJClLBURlCVbrYPirFaruGsd4Khtrd3a4df6q7XWb/u1rbZWa1VEq9aJo2ptHThaZSgyBUT2RjAJM5Cc+/fHCYiQhBw4ycl4Pq7rXIecz+d8Pm+8TMjr3Pf9vptkc++lQ+y4qlrLAClJkiRlSIyRnz49jfcWfkoI8Pvz+9OrY6tMlyVVyAApSZIkZcifx33M2MlLAbju5EM4ufe+Ga5IqpwBUpIkScqAF6ct57cvzwbg7IGd+cawbhmuSNo9A6QkSZJUwz5YXMD3H/sAgCEHtOaWs/rYcVV1ggFSkiRJqkFLPt3IFWMmUVySYP82zfnLxYPJaWTHVdUNBkhJkiSphqzbvJUrxkzik/XFtGraiPtHDmGfFk0yXZZUZQZISZIkqQaUlCa45tHJzFqxjkZZgbsvHsRB7XIzXZaUkkZVPTGE0AP4ItAbaA9EYDUwHXgjxjinOgqUJEmS6oNf/mMm42avBuCWEX35wkFtM1yRlLpKA2QIoSkwCrgK6AtUtLI3hhCmAXcDD8QYN6e1SkmSJKkOe+A/8xnzzkIAvjHsIM4b0iXDFUl7psIprCGEi4E5wJ+AAuBnJEcguwDNgRZlfx4OXA8UAXcCc0IIF1Vr1ZIkSVId8fqsVdz0j5kAfKn3vlx3cs8MVyTtuRBjLP9ACBtIjijeEWNcWKWLhbA/8D3gyhhjnZvQHUIoyMvLyysoKMh0KZIkSaoHPlxexDl3/ZcNW0rp1zmPx75+JM2a2HFVtVd+fj6FhYWFMcb88o5XNoX1oBjjilRuVhY0vx9CuDWV90mSJEn1zcqizVz2wEQ2bCmlY15T7r1ksOFRdV6FU1hTDY87vXflnr5XkiRJqus2FJdw2QMTWV64mdycRtw3cgjtWzXNdFnSXtvrbTxCCINCCCeWNdyRJEmSGrRt23XMWFZEdlbgzq8N5ND9WmW6LCktqhwgQwg/CiE8v9NrjwATgH8C00IIHdJcnyRJklRnxBj5xfMzeW3WKgBuPrMPw3q0y3BVUvqkMgJ5AbBo2xchhOPKXvs7yS6s+wHXpbU6SZIkqQ657+35PPTuZ9t1fHVo1wxXJKVXKgHyAGDWDl+fCSwHLoox3kqyY+vpqdw8hJAbQrgjhLA8hLAphDAphPCVKr43hBC+HkJ4L4SwMYRQEEJ4N4TwhVRqkCRJktLhn9NX8KsXPwTgy/32c7sO1UupBMgWwMYdvj4OeCV+tg/ITKBTivcfC3wN+B/gy2XXGBtCOLUK770X+A3wFHBq2XVeLKtTkiRJqjGTF33K9x6bTIwwsGs+t517GFlZIdNlSWlX2TYeO1sK9IPt+z32An63w/HWQHFVL1YWEk8Azooxji177XWgG3AbyTBY0XvPBkYCR8cY39nh0AtVvb8kSZKUDovXbuSKMZPYvDVB132a89dLBtO0sdt1qH5KJUA+D3wrhJANHE4yLO4Y2PoAC1K43gigEHh22wsxxhhCGAPcE0LoFWOcWcF7rwHe3Ck8SpIkSTWqcONWRo6ewJoNW8hv3pgHRg2hTW5OpsuSqk0qU1hvAt4GvkUyLH5v236PIYRmJAPh6ylcrw8wM8aY2On1qTsc30UIoTFwBMmur7eEEFaGEEpCCDNCCJemcH9JkiRpjxWXlHLlQ5P4ePUGmmRncc/Fg+nWLjfTZUnVqsojkDHGT4HjQwitgE0xxq07nTIMWJzCvdsAc8p5fe0Oxyt6Xw5wKbAE+DZQAFwOPBBCaBJj/Gt5bwwhFOymprzdFS1JkiQlEpEfPTGVCfOTv7r+9tx+DD1wnwxXJVW/VKawAhBjLCrntU3AlD24f9yDY9tGTZsCp8YYFwKEEF4huX7y50C5AVKSJElKh/99eRbPT1kGwE9OOYQz+qfaS1KqmyoMkCGEY/fkgjHGN6t46hrKH2Xc9tHN2nKOAXxKMlzO2hYey+4bQwj/BG4IIbSPMa4qp7b8ygoqG6F0FFKSJEkVevCdBfzljXkAXHREV646tltmC5JqUGUjkOOofISwIlVtOTUDODuEkLXTOsi+Zc/Ty3tTjHFTCGFuBdfc1it553WVkiRJ0l7798yV/L/nZgBwwqHt+X+n9yYEt+tQw1FZgBy109eBZPfTHsDDJPdsDCS38/gqyfWMf0rh3mNJrls8nR06sQKXALMr6cAK8DTwgxDCATHGBQAh+Z17CjAvxvhJCnVIkiRJuzV50adc8+j7JCIc1jmPO746gEbZqfSklOq+CgNkjHHMjl+HEL4DtAN6xhiX7XTsl8A7QMsU7v0iya6t94UQ2gDzSTbGORo4Y4drjwOGxRh3/Gjnt8DXgH+GEH7BZ010BgEXpFCDJEmStFsL12z43F6P940cQvMmKbcTkeq8VD4yuQb4y87hESDGuAT4S9k5VRJjjMCZwN+BW4CXgH7AWTHG53fz3jXAMcA04M8kRzP3B0bEGB+rag2SJEnS7qzdsIWRoyeyZsMWWpft9djWvR7VQKXysUkXYGMlxzeUnVNlZR1dv132qOicL1bw+gLg3FTuJ0mSJKVi05ZSrhgzkfmfbCCnURb3Xupej2rYUhmBnA9cFEJouvOBstcuARakqS5JkiQpo0pKE1zz6GTeX1RACPCH8/szaH/3elTDlsoI5G3APcDEEMKdwGySXVoPBa4ue/5G2iuUJEmSaliMkRuencErH64E4P+d3ptT+u6X4aqkzKtygIwx3htCyAVuJrnucNsWHwHYBFwbY/xr+kuUJEmSatYfX5vLoxMWAfCNYQdx6RcOyGxBUi2RUuuoGOMfQgijgZOAbiTD48fAv2OMBdVQnyRJklSjHp+4mN/9ew4AIwZ04rqTe2a4Iqn2SLn3cIyxEHiiGmqRJEmSMuq1WSv56dhpABxzcFv+9+x+ZGWF3bxLajjc+VSSJEkCPlhcwNUPT6Y0EendsRV3XTSIJo38dVnaUUrfESGEC0II/wkhrAohlJbzKKmuQiVJkqTqMv+TDVz2wEQ2bS2lc+tmjB41hNyclCfrSfVelb8rQgjXArcCa4B3y54lSZKkOm31umIuvX8CazdsoXXzxjx42VDat9xl5zpJpLYG8mpgPHB8jHFTNdUjSZIk1Zh1m7cycvQEFq3dSNPGWdw3cgjd2uVmuiyp1kplCuu+wN8Mj5IkSaoPiktKueqh95ixrIjsrMCfvjqQgV1bZ7osqVZLJUDOBfKrqxBJkiSpppQmIj94bAr//Ti5KuvXZ/XlhF4dMlyVVPulEiBvAy4PIbSsrmIkSZKk6hZj5BfPz+CFacsB+PGXDuG8wV0yXJVUN6SyBrIUWAV8GEK4H5hf9trnxBgfTFNtkiRJUtr96bW5PPjOQgAuO+pAvjGsW4YrkuqOEGOs2okhJKpwWowxZu9dSZkTQijIy8vLKygoyHQpkiRJqgaPTljET5+eBsAZ/Tvy+/P6k5UVMlyVVHvk5+dTWFhYGGMsd/liKiOQw9NUkyRJklTjXp6xguvHJsPjMQe35bfnHGZ4lFJU5QAZY3yjOguRJEmSqsv4eWu45tHJJCIc1jmPuy8aRJNGqbQDkQSpNdH5nBBC2xBC23QWI0mSJKXbzGVFXPHgJLaUJOjWtgX3jxxCi5xUJuJJ2ialABlC6BhCGBNCKABWAitDCJ+GEB4IIXSqnhIlSZKkPbNwzQYuuX8C6zaX0L5lDmMuG0qb3JxMlyXVWVX+6CWE0BV4F9gX+ACYUXaoF3AJcGII4YgY4+K0VylJkiSlaFXRZi66bzyfrC8mr1ljHrr8cLrs0zzTZUl1Wipj978EWgOnxRhf3PFACOEU4Omyc0amrTpJkiRpDxRu3MrF901g8dpNNGuczf0jh9BzX7czl/ZWKlNYTwL+vHN4BIgxvgTcBXwpXYVJkiRJe2LjlhIuGzOR2SvX0Tg7cPfFgxi0f+tMlyXVC6kEyNbAR5Uc/wgod68QSZIkqSZsKUnwzb+9z3sLPyUEuO28/gzr0S7TZUn1RipTWJcAXwTuruD4sWXnSJIkSbsoTUTemLOKsZOXsWZ9MW1ycxgxoCPDerQnOw37MSYSkR89MYU35qwG4KYz+vCVwzru9XUlfSaVAPkEcF0IYT5wa4yxECCE0Ar4CXAecGv6S5QkSVJd98n6YkaNnsC0pUVkBUhEyArw/JRl9O3UitGjhtJ2L7qjxhj5xfMzeG7KMgB+cGIPLj5i/3SVL6lMiDFW7cQQmgP/Ar4AlALLyg51BLKB/wAnxRg3VUOdNSKEUJCXl5dXUFCQ6VIkSZLqjdJE5Mw732bGsiIS5fzqmRWgd8dWPHP10Xs8Evn7f8/h9leTq61GHXUAPz+tFyHs/aim1NDk5+dTWFhYGGMsd3lilddAxhg3AsOAq0gGyQ3ARuBl4OvA8LocHiVJklQ93pizimlLyw+PkByNnLa0iDfLpp6m6t635m0PjyMGdOKGLxsepeqSyhRWYoylwF/LHpIkSdJujZ28bPu01YpkBRg7eSnDD2mf0rUfn7iYm1/4EIATDm3Pb87pR1Ya1lNKKl+VRyBDCI3K1jtWdLxVCCGlQCpJkqT6b8364krDIyTD5ZoNxSld98Vpy/nJ01MBOLJbG/504UAaZ6eyyYCkVKXyHXYbMKmS4xOB/927ciRJklTftMnNYXeDglkB2rSoehOdcbNX8d2/TyYR4bDOefz10sE0bZy9l5VK2p1UAuTJwFOVHH8KOGXvypEkSVJ9M2JAxyqNQI4Y0KlK15u4YC3f+Nt7bC2N9OzQkgdGDSU3x4lwUk1IJUB2AT6u5Pi8snMkSZKk7Yb1aE/fTq0qHIUMAfp2asWxPdrt9lrTlxZy2eiJbN6aoOs+zXno8qG0btEkzRVLqkgqAXILsF8lx/cFEntXjiRJkuqb7KzA6FFD6d0x2U5jW5Dc9tynY3IfyN1t4TF31XouuX8C64pL6NAqh4evOJz2rZpWZ+mSdpLKPpCvAe2AQTHGLTsdawK8BxTEGI9Je5U1xH0gJUmSqk9pIvLmnNWMnbyUNRuKadMihxEDOnFsj3a7DY9LPt3IuXe/w/LCzbRu3pjHrzqSgzu0rKHKpYZjd/tApjJZ/E7gCeCFEMJPgallr/cDbgF6ARfuTbGSJEmqv7KzAsMPaZ/yVh0rizZz4V/Hs7xwM7k5jRhz2VDDo5QhVQ6QMcanQgi/Bn4KjAdi2SMLCMD/xhgfq5YqJUmS1CCtWV/M1+4dz6K1G2naOIv7Lh1Mv87lDoxIqgEptauKMV4fQngGuAjoTjI4zgYeiTFOrIb6JEmS1EAVbtrKxfdNYO6q9TTJzuIvFw/m8G5tMl2W1KCl3O+4LCgaFiVJklRt1heXMHL0BGYuLyI7K/CnCwcwrApdWiVVr1S6sG4XQugeQjgqhJCX7oIkSZLUsG3eWsoVYyYyeVEBIcDvzjuMk3rvm+myJJFigAwhnBZC+JjktNU3gUFlr7cPIcwNIZxTDTVKkiSpgdhSkuAbf3uPd+etBeDWs/pyRv9OGa5K0jZVDpAhhC8CY4G1wC9Irn8EIMa4CvgYuCDN9UmSJKmBKClN8N2/T2bc7NUA3Hh6L84f0jXDVUnaUSojkD8HpgCHk9zSY2fvAAPTUZQkSZIaltJE5Nonp/LS9BUAXHtyT0YddWCGq5K0s1QC5GDg4RhjooLjSwAnp0uSJCkliUTk+rHTGDt5KQBXDz+Iq4d3z3BVksqTSoDMBoorOd4W2LJ35UiSJKkhiTFy43Mz+PvExQBcdtSB/OiknhmuSlJFUgmQHwLHVHL8NJJTXCVJkqTdijFy8wsf8tC7CwG46Iiu3HDaoYQQdvNOSZmSSoC8DzgnhHD5Du+LIYTmIYQ7gCOBe9JdoCRJkuqfGCO/eXk29709H4DzB3fhpq/0MTxKtVyjqp4YY7wrhHAU8FfgNiACjwJtSE5vHR1jfLhaqpQkSVK9cvurH3HXuI8BOGtAJ245qy9ZWYZHqbarcoAEiDFeFEJ4CrgIOITkVh7jgQdjjE9VQ32SJEmqZ/48bi5/eOUjAL7cbz9+c04/sg2PUp2QUoAEiDGOJbkfpCRJkpSSe9+ax2/+ORuAk3p14A/n96dRdiqrqiRl0l5/t4YQ2oYQDk5HMZIkSaq/HnpnATe/8CEAw3u2448XDqCx4VGqU6r8HRtCuCSEcM9Or90KrARmhRD+E0Jome4CJUmSVPc9PH4hNzw7A4BjDm7LXRcNIqdRdoarkpSqVD7yuYodpryGEAYD1wFvkWysMxT4QVqrkyRJUp336IRFXD92OgBHdmvDPRcPpmljw6NUF6WyBrI78MQOX58LrAVOijFuCSFE4DzgF2msT5IkSXXY4xMX89OnpwFwRLd9uG/kYJo1MTxKdVUqI5B5QOEOXx8PvBJj3FL29SSga7oKkyRJUt32xKTF/PjpqQAMPWAf7h85hOZNUu7hKKkWSSVArgAOBgghtAP6k5y+uk0uUJq+0iRJklRXPfXeEq57aioxwuD9WzN6lOFRqg9S+S5+Dbg6hLAWGA5E4IUdjvcElqaxNkmSJNVBz0xeyo+enEKMMLBrPg9cNpQWOYZHqT5I5Tv558AXgN+UfX1zjHEBQAihEXA28FRaq5MkSVKd8uwHS/nB4x8QI/Tvks+Yy4aSa3iU6o0qfzfHGJeEEHoDvYDCGOOiHQ43B74OTElzfZIkSaojnp+yjO8/9gGJCId1zuPBy4fSsmnjTJclKY1S+jgoxlgKTCvn9SLg2XQVJUmSpLrl2Q+Wbg+PfTvl8eDlh9PK8CjVOxU20QkhtN7Ti+7NeyVJklS37Bge+3XO42+XH05eM8OjVB9V1oV1QQjh5yGENlW9WAihXQjhl8D8vS9NkiRJtd3YyUs+N231ocsPJ6+54VGqryoLkD8BrgaWhhDGhhCuDCEcFkLI3XZCCKFlCGFgCOFbIYR/kOzCeiXw4+otW5IkSZn29PtL+OHjU5LhsUs+DzryKNV7Fa6BjDHeFUJ4mGSIvBI4g+TWHYQQSoAAZJedHoB5wPXA3THGddVZtCRJkjLryfeWcG3ZVh39u+Tz4OVDXfMoNQAhxrj7k0IIwFBgGMkurO1IhsnVwHRgXIzxvWqss0aEEAry8vLyCgoKMl2KJElSrfXEpMVc99RUYoQBXfN58DK7rUr1RX5+PoWFhYUxxvzyjlepC2tMpszxZQ9JkiQ1UI9PWsyPy8LjwK7JfR4Nj1LD4a6ukiRJqpJHxi/iZ2OTO7oN3r81D1w2lNwcf52UGpLKmuhIkiRJADz4zoLt4XHIAYZHqaHyu16SJEmVuvetedz8wocAHNmtDfeNHEzzJv4aKTVEfudLkiSpQneN+5j//ecsAI45uC33XDyYZk2yd/MuSfWVAVKSJEnluuPVj/jdv+cAMLxnO+66aBBNGxsepYbMAClJkqTPiTHyu3/P4Y+vzQXgxF4d+NOFA8hpZHiUGjoDpCRJkraLMXLrP2fxlzfmAXBq3325/YIBNM6296KkFLuwhhC6hBDuDyEsCSFsCSEcV/Z6u7LXh1RPmZIkSapuMUZu+sfM7eHxK4d15A7Do6QdVPmnQQjhQGAScDYwA9g+hyHGuBoYDFyR7gIlSZJU/UoTkZ+Nncbo/ywA4KwBnfj9+f1pZHiUtINUprD+CkgAfYBNwKqdjr8InJ6muiRJklRDSkoT/OiJKTzzwTIAvjq0K786sw9ZWSHDlUmqbVL5SOkE4M8xxsVALOf4QqBzWqqSJElSjdhSkuCaRydvD4+XHXUgt4wwPEoqXyojkK2A5ZUcb5Li9SRJkpRBm7eW8s2/vcfrs1cD8O3h3fnhST0IwfAoqXypBL7FQO9Kjh8BzN27ciRJklQTNhSXcOWDk/jvx2sAuPbknlw9vHuGq5JU26UyhfVp4LIQQp8dXosAIYSzgXOBx9NYmyRJkqpB0eatXHL/hO3h8YbTehkeJVVJiLG85YzlnBhCK+Ad4ADgTeAk4BWSU1uHAh8AR8UYN1dLpTUghFCQl5eXV1BQkOlSJEmSqsXaDVu49P4JTFtaSAjwqzP7cuHhXTNdlqRaIj8/n8LCwsIYY355x6s8AhljLAKOBO4luWVHAE4EegJ/BobX5fAoSZJU360s2sz5f3mHaUsLyQrwu/MOMzxKSklKTW/KQuR3ge+GENqRDJGrY1WHMSVJkpQRi9Zs5Gv3vcvitZtonB2444IBnNJ3v0yXJamO2eOuqTHG1eksRJIkSdXjo5XruOi+8awsKqZp4yzuuXgwx/Zol+myJNVBKQfIEMLBwMFAG5IjkJ8TY3wwDXVJkiQpDaYtKeSS+8fz6cattMxpxOhRQxh8wD6ZLktSHVXlABlC2A8YAxy/7aVyTouAAVKSJKkWGD9vDZePmcT64hL2adGEBy8bSp9OeZkuS1IdlsoI5D3AcOAPwFvAp9VSkSRJkvba67NX8Y2H3qO4JMF+eU156PLD6d4+N9NlSarjUgmQxwG3xxh/VF3FSJIkae+9MHU53/37ZEoSkQPaNOdvVxxO59bNM12WpHoglQC5HphbXYVIkiRp7z0yfhHXPzONGKFnh5Y8dMVQ2rdsmumyJNUTVd4HEvgHcEJ1FSJJkqQ9F2Pkztfn8rOxyfDYv0s+j111hOFRUlqlEiB/CBwYQvh9CKFbCKG8JjqSJEmqYYlE5FcvfMhvX54NwDEHt+WRKw8nv3mTDFcmqb6pcoCMMRaQ7ML6HeAjoCSEULrTo6S6CpUkSdKuSkoTXPvkVO59ez4AX+63H/ddOoTmTfZ4u29JqlAq23hcB/waWAlMIA1dWEMIucAtwLlAPjADuCnG+FwK1wjAqyQ7xN4eY/ze3tYlSZJUF2zeWsq3H5nMKx+uBODCw7vyyzP6kJ3lRDFJ1SOVj6auAcYBX4oxbk3T/ccCA4HrgPnASGBsCOH0GOOLVbzGlcAhaapHkiSpTijavJUrx0xi/Py1AFxzXHd+cGIPXGUkqTqlEiD3AR5PV3gMIZxKsinPWTHGsWWvvQ50A24DdhsgQwidgN8AlwNPpqMuSZKk2u6T9cVcev8EZiwrAuCG03px+dEHZrgqSQ1BKk10pgBd03jvEUAh8Oy2F2KMkeQ6y0NCCL2qcI27gDdjjE+lsS5JkqRaa9GajZxz13+ZsayI7KzAbeceZniUVGNSGYG8Hng8hDA2xjgpDffuA8yMMSZ2en3qjscrenMI4ask1z1WJWhue0/Bbk7Jq+q1JEmSatqMZYVcev9EPllfTE6jLP504UBO7NUh02VJakBSCZAXA0uBd0MI7wDzgNKdzokxxsureL02wJxyXl+7w/FyhRDaArcD18cYF1fxfpIkSXXWfz/+hK8/+B7ri0to1bQR948cwuAD9sl0WZIamFQC5Mgd/nxU2WNnkeR6xKqKe3jsDpJNd/6Uwr2IMeZXdrxshNJRSEmSVKu8OG053/v7B2wpTbBvq6Y8ePlQenRomemyJDVAVQ6QMcZU1ktWxRrKH2Xc9lHa2nKOEUI4ETgfOA5otVOnsZwQQj6wPsbonpSSJKnOe+idBfz8uRnECN3b5zLmsqF0ym+W6bIkNVDpDoWpmAEcGkLYuYa+Zc/TK3hfb5J1jyO5F+W2B8A3yv58QlorlSRJqmExRn73r9nc8GwyPA7oms8TVx1peJSUUalMYU23sSSnu57ODp1YgUuA2THGihroPAl8UM7rrwNPkZzWOrWc45IkSXVCSWmCG56dzqMTkq0ejjukPXdeOJBmTbIzXJmkhq7CABlCuJ/kOsSvxxhLy77enVSa6LxIMvTdF0JoQ3JN46XA0cAZO9QxDhgWYwxlN1gCLCmnXoAlMcZxVby/JElSrbNpSynXPPo+r3y4CoBzBnXm12f1pXF2JieOSVJSZSOQI0kGyG+S7LY6sgrXq3ITnRhjDCGcCdxS9sgnuW3HWTHG56tyDUmSpPpkzfpiLh8ziQ8WJ3ce++YXD+K6k3uyU88HScqYEGNlzU4blhBCQV5eXl5Bwe62i5QkSUqvhWs2cOn9E1iwZiMhwE1f6c3FRx6Q6bIkNTD5+fkUFhYWVrSDRSbXQEqSJAmYuqSAyx6YyCfrt5DTKIvbLxjAl/rsm+myJGkXVZ5MH0KYF0L4SiXHTwshzEtPWZIkSQ3D67NXccE97/LJ+i3kN2/MI1cebniUVGulMgJ5AJBbyfEWwP57VY0kSVID8vikxfz06WmUJiKdWzfjgVFD6d6+sl+3JCmz0jmFtQOwMY3XkyRJqpdijNzx6lx+/8ocAHp3bMXoUUNo37JphiuTpMpVGiBDCMcCX9zhpbNCCN3LOXUf4ALK359RkiRJZbaWJvjZ09N44r3krmTHHNyWuy4aRG6OrSkk1X67+0k1HLix7M8ROKvsUZ65wPfTVJckSVK9U7R5K9/62/u8PfcTILnH4y0j+tKkkXs8Sqobdhcg/wA8AARgHvA94NmdzonA+hjj2rRXJ0mSVE8sK9jEqNETmb1yHQDfP6EH3zm+u3s8SqpTKg2QMcZCoBAghDAc+DDGuKomCpMkSaovpi8t5LIHJrJqXTGNsgL/e3Y/zh7UOdNlSVLKqjzZPsb4RnUWIkmSVB+9PnsV3374fTZsKaVl00b85aJBfKF720yXJUl7JKXV2iGErsBVwMFAG5JTW3cUY4zHp6k2SZKkOu2R8Yu44dnplCYiHfOa8sBlQ+nRoWWmy5KkPVblABlCOAUYCzQB1gGueZQkSSpHIhH5zcuzufuNj4HkNh33jxxCh1Zu0yGpbktlBPLXwCfAmTHsfZryAAAgAElEQVTGSdVUjyRJUp22aUspP3j8A16avgKAL/Zsx50XDqSF23RIqgdS+Ul2CPA/hkdJkqTyrVq3mSvHTGLKkkIALjlyf35+Wi8aZbtNh6T6IZUAuRrYUl2FSJIk1WWzVhRx+QOTWFqwiawAN5zWi1FHHZjpsiQprVL5OOwh4OzqKkSSJKmuGjd7Fefc9Q5LCzbRvEk2f71ksOFRUr2UygjkA8DwEMKzwO3AfKB055NijIvSU5okSVLt99A7C7jxuRkkIuzbqin3jRxM7455mS5LkqpFKgFyFhBJbt1xWiXnZe9VRZIkSXVAaSLyqxc+5P7/zAegT6dW3HepnVYl1W+pBMibSAZISZKkBm3d5q1859HJvD57NQAnHNqBO77an+ZN7LQqqX6r8k+5GOP/q8Y6JEmS6oTFazdy+ZiJzFm5HoArjzmQn5xyKNlZIcOVSVL182MySZKkKpq4YC1XPfQeazdsoXF24Fdn9uW8IV0yXZYk1ZgqB8gQwrFVOS/G+OaelyNJklQ7PfneEn729DS2lCZo3bwxd100iCO6tcl0WZJUo1IZgRxH1dZA2kRHkiTVG4lE5Dcvz+buNz4GoHv7XO67dDD7t2mR4cokqealEiBHVfD+g4CRwALgL3tfkiRJUu2wobiE7z32Af+euRKAY3u0408XDqBV08Z7fM3SROSNOasYO3kZa9YX0yY3hxEDOjKsR3vXUUqq9VJpojOmomMhhN8C76elIkmSpFpg8dqNXPngJGatWAfAqKMO4PpTD6VRdtYeX/OT9cWMGj2BaUuLyAqQiJAV4Pkpy+jbqRWjRw2lbW5Ouv4KkpR2e/4TcAcxxk+Be4Hr0nE9SZKkTHp33hrOuPM/zFqxjkZZgZvP7MONp/feq/BYmoiMGj2BGcuKgGR43PF5xrIiRo2eQGnCXdMk1V5pCZBlPgW6pfF6kiRJNe5v7y7konvHs3bDFlo3b8xDlx/ORUfsv9fXfWPOKqYtLaKifJiIMG1pEW/OWb3X95Kk6pKWbTxCCE2Bi4EV6bieJElSTdtamuAXz8/gb+8uAqBnh5bce+lguuzTPC3XHzt52fZpqxXJCjB28lKGH9I+LfeUpHRLZRuP+ys4tA9wJNAOuDYdRUmSJNWktRu28K2H3+PdeWsBOKlXB353fn9yc9K3Zfaa9cWVhkdIhss1G4rTdk9JSrdUfiqOrOD1tcAc4Psxxkf2uiJJkqQa9OHyIq58cBJLPt0EwHeOP5jvHX8wWWnuiNomN6dKI5BtWthER1LtlUoX1nSul5QkScq4f05fzg8en8LGLaU0a5zN/517GF/ut1+13GvEgI48P2VZpeckIowY0Kla7i9J6VClABlCaAacC8yOMY6v3pIkSZKqVyIR+d2/5/Cn1+cC0Cm/GfdcMojeHfOq7Z7DerSnb6dWzFhWfiOdEKBPx1Yc26NdtdUgSXurqqOKxSS36RhQjbVIkiRVu8JNW7niwUnbw+PQA/fh2W8fVa3hESA7KzB61FB6d2wFJKer7vjcp2NyH8jsNE+dlaR0qtIIZIwxEUJYBLSq5nokSZKqzdxV67jywfeY/8kGAEZ+4QCu//KhNN6L/R1T0TY3h2euPpo356xm7OSlrNlQTJsWOYwY0Ilje7QzPEqq9UKMVdusNoRwA3AeMDjGWC/bg4UQCvLy8vIKCgoyXYokSUqzf81YwQ8en8L64hKaNMriV2f24dzBXTJdliTVKvn5+RQWFhbGGPPLO55KF9b/AmcBH4QQ/gx8BGzc+aQY45t7VKkkSVI1SCQit7/6Ebe/+hEA+7Zqyl8uHsRhXcr93UiSVIlUAuS/d/jz7cDOQ5eh7LXsvS1KkiQpHQo3beWHj3/AKx+uAmDIAa3589cG0a6lW2VI0p5IJUCOqrYqJEmS0mz2inVc9dAkFqxJTpi6+Ij9ueG0XjRp5M5kkrSnUtkHckx1FiJJkpQuz09ZxnVPTmXT1lKaNMri5jP6cN4Q1ztK0t5KZQRSkiSpVttamuDWl2Zx39vzgeT+jndfNIi+nat3iw5JaigMkJIkqV5Yva6Yqx95nwnz1wJwzMFtuf2CAezTokmGK5Ok+sMAKUmS6rz3Fn7Ktx5+j5VFyZ3Grh5+ED84saf7KkpSmhkgJUlSnRVj5KF3F/LLf8xka2kkN6cRt513GCf33jfTpUlSvWSAlCRJddKG4hJ++vQ0npuyDICD2+dy98WDOKhdboYrk6T6ywApSZLqnLmr1vGNv73P3FXrATj9sI7celZfWuT4q40kVSd/ykqSpDrluSnL+MlTU9m4pZTG2YH/+XIvLjlyf0JwvaMkVTcDpCRJqhOKS0q55YUPGfPOQgA65jXlzq8NZEDX1hmuTJIaDgOkJEmq9ZYWbOJbD7/PlMUFABzbox1/OL+/W3RIUg0zQEqSpFrt9dmr+MFjH/Dpxq2EAN89/mCuOe5gt+iQpAwwQEqSpFqppDTBbf+ew13jPgagdfPG/OGCAQzr0S7DlUlSw2WAlCRJtc6Kws1c8+j7TFzwKQCD9m/NH786gI75zTJcmSQ1bAZISZJUq4ybvYofPD6FtRu2AHDVsd340ck9aZydleHKJEkGSEmSVCuUlCb4/StzuPP15JTV/OaNue3cwzj+0A4ZrkyStI0BUpIkZdzKos1c8+hkJsxfC8DArvn88cKBdHLKqiTVKgZISZKUUa/PXsUPd5iy+vVju3GtU1YlqVYyQEqSpIzYUpLgty/P4q9vzQcgr1lyyuoJvZyyKkm1lQFSkiTVuEVrNnLNo+8zZUkhAIP3b83tXx3glFVJquUMkJIkqUY9P2UZP3t6GuuKSwgBvj28O989/mAaOWVVkmq9EGPMdA21RgihIC8vL6+goCDTpUiSVO9s2lLKL56fwd8nLgaSU1Z77deKEKBNbg4jBnRkWI/2ZGeFDFcqSQ1Xfn4+hYWFhTHG/PKOGyB3YICUJKl6zF6xjm8/8j4frVoPQG5ONuuLS8kKkIhsf+7bqRWjRw2lbW5OhiuWpIZpdwHSuSKSJKnaxBgZ898FnP6nt/lo1XoaZQX2bZXDhuJSIBkad3yesayIUaMnUJrwA25Jqo0MkJIkqVqsWV/MFWMmceNzM9hSkqDrPs35ySk9WVFUTEXxMBFh2tIi3pyzukZrlSRVjQFSkiSl3ZtzVvOl29/i1VmrADhrYCde+M7RTFlSxO6WOGYFGDt5aQ1UKUlKlV1YJUlS2hSXlPJ/L8/evrdjy5xG3DyiD2f07wQkRyV3Nzs1EWHNhuLqLlWStAcMkJIkKS0+Xr2e7zw6mRnLigAY0DWfOy4YQJd9mm8/p01uzvaGORXJCtCmhU10JKk2MkBKkqS9EmPkkQmLuPkfH7Jpa7Kz6reHd+c75eztOGJAR56fsqzS6yUijBjQqTpLliTtIQOkJEnaY6vXFfOTp6ZuX+vYMa8pvz+/P4d3a1Pu+cN6tKdvp1bMWFZU7ihkCNCnYyuO7dGuOsuWJO0hm+hIkqQ98srMlXzpD29uD49fOawjL33v2ArDI0B2VmD0qKH07tgKYHtDnW3PfTom94HM3l2nHUlSRoQY3WdpmxBCQV5eXl5BQUGmS5EkqdbauKWEm1/4kEfGLwKgZdNG3HzmZ41yqqI0EXlzzmrGTl7Kmg3FtGmRw4gBnTi2RzvDoyRlUH5+PoWFhYUxxvzyjhsgd2CAlCSpclMWF/C9xz5g/icbADii2z7cdl5/OuU3y3BlkqR02F2AdA2kJEnarZLSBH8e9zG3v/oRpYlI4+zAtSf35Iqju5HliKEkNRgGSEmSVKm5q9bzw8c/YMqSQgB6dMjl9+f3p3fHvAxXJkmqaQZISZJUrkQiMuadBdz60iyKSxKEAJcddSDXntyTpo2zM12eJCkDDJCSJGkXSz7dyLVPTOWdeWsA6JTfjP879zCOPKjiDquSpPrPAClJkraLMfLEe0u46fmZrC8uAeC8wZ254bRetGzaOMPVSZIyzQApSZIAWL2umJ8+PY1XPlwJQNvcHG49qy8n9OqQ4cokSbWFAVKSpAYuxsjzU5dz47PT+XTjVgBO7bsvN5/Zl31aNMlwdZKk2sQAKUlSA/bJ+mJueGY6L01fAUBes8b84iu9OaN/R0Jwew5J0ucZICVJaqD+MXUZP392Bms3bAHghEPbc8uIvrRv1TTDlUmSaisDpCRJDcya9cX8/NkZvDBtOQCtmjbixtN7c9bATo46SpIqZYCUJKkBeWnacv7nmemsKRt1HN6zHb8+qx/75jnqKEnaPQOkJEkNwOp1xdz43HRenJZc69iyaSN+flovzhnU2VFHSVKVGSAlSarHYoyMnbyUm/4xk4KyDqvDerTj1rP7sl9eswxXJ0mqawyQkiTVU8sKNvGzsdMYN3s1kOyw+vPTernWUZK0xwyQkiTVM4lE5NGJi/j1i7NYX1wCwCl99uUXZ/SmfUvXOkqS9pwBUpKkemThmg38+KmpvDtvLQBtc5tw0xl9OLXvfhmuTJJUHxggJUmqB7aWJrj3rfn84ZU5FJckADhrQCduOK0XrVs0yXB1kqT6wgApSVIdN3VJAT9+ahofLi8CYL+8ptwyoi/DD2mf4cokSfWNAVKSpDpq45YSbvvXHEb/Zz6JCCHApUcewI9O7klujv/ES5LSz39dJEmqg8bNXsX1Y6eztGATAD065HLr2f0Y2LV1hiuTJNVnGQ2QIYRc4BbgXCAfmAHcFGN8bjfvuwL4CnAY0B5YArwE/DLGuLpai5YkKYM+WV/Mzf+YyTMfLAOgSXYW1xzXnauGHUSTRlkZrk6SVN9legRyLDAQuA6YD4wExoYQTo8xvljJ+34BvA78FFgK9AJuBL4SQugfYyyo1qolSaphiUTksUmLufWlWRRu2grA0AP34ddn9eWgdrkZrk6S1FBkLECGEE4FTgDOijGOLXvtdaAbcBtQWYAcEGNctcPXb4QQZgLjgIuBP1ZL0ZIkZcDsFeu4fuw0Ji38FIBWTRvx01MP5fzBXcjKChmuTpLUkGRyBHIEUAg8u+2FGGMMIYwB7gkh9IoxzizvjTuFx20mlj13TnulkiRlwKYtpdz+6kfc+9Y8ShIRgBEDOnH9lw+lbW5OhquTJDVEmQyQfYCZMcbETq9P3fF4Ctc7rux5+t4WJklSpr0+axU3PDudJZ8mm+Qc2LYFvzyjD0cf3DbDlUmSGrJMBsg2wJxyXl+7w/EqCSHsA9wBfAQ8Xsl5u1sbmVfVe0qSVB2WF27il/+YyYvTVgDJJjnf/OJBfPOLB9G0cXaGq5MkNXSZbqIT9/DYdiGE5sAzwD7AsTHG4nQUJklSTdpamuD+t+dz+6sfsXFLKQBHdmvDzSP62CRHklRrZDJArqH8UcZ9yp7XlnPsc0IIzYDngAHAyTHGqZWdH2PM3831CnAUUpJUw96dt4YbnpnOR6vWA9A2twk/O/VQRgzoRAg2yZEk1R6ZDJAzgLNDCFk7rYPsW/Zc6VrGEEJTkg14jgROjTH+t3rKlCSpeqxat5lbXvhw+56OWQEuOfIAvn9iD/KaNc5wdZIk7SqTAXIscDlwOjt0YgUuAWZX1IEVIISQQ3La6jHA6THGN6qzUEmS0qmkNMFD7y7kd/+aw7riEgAGdM3nl2f0oU8nJ8JIUr2RKIW5r8DUx2DDamjRDvqdD91PgKy6ua49kwHyReB14L4QQhtgPnApcDRwxraTQgjjgGExxh3n8DwJnAzcBKwPIRyxw7HVMcaPq7l2SZL2yPh5a7jxuRnMWrEOgNbNG/OTUw7h3EHu6ShJ9cr61fDwObD8AwhZEBNAgOlPwX794WtPQm67TFeZshBjlXrVVM/NQ2gF3AKcA+ST3LbjphjjMzucM46dAmQIobKix8QYR+5hPQV5eXl5BQW7a9YqSVJqlhdu4pYXZ/H8lOR01RDggiFdue7knrRu0STD1UmS0ipRCvcMhxVTKbc3aMiCffvBla/VupHI/Px8CgsLCyvqH5PRAFnbGCAlSelWXFLKvW/N587X527vrtq/Sz6/+EpvDutSaW83SVJdEiN88hHMG5ecsrp00u7fc+ET0OOkai8tFbsLkJnexkOSpHrrtVkruen5mSxYsxFIdlf98ZcO4eyBnZ2uKkn1wbqVMP+NZGicNw6Kllb9vSErGTRrWYDcHQOkJElpNm/1em5+4UNem7UKgEZZgUu/cADfPeFgWjW1u6ok1VnF62Dhfz8LjKvK6fvZomxd44bVlV8rJnZ/Ti1kgJQkKU0KN23ljlc/Ysx/F1CSSC4RObp7W248vRcHd2i5y/mlicgbc1YxdvIy1qwvpk1uDiMGdGRYj/ZkO0IpSZlXsgWWTCwbZXwjOS01UfL5cxo3h/2Pgm5fTD469IanLocZY8sa51QgZH0WNusQA6QkSXupNBF5dMIifvfvOazdsAWAzq2b8T9fPpSTe+9LCLuGwU/WFzNq9ASmLS0iK0AiJveBfH7KMvp2asXoUUNpm5tT038VSWrYEglYOa1shPENWPQObN34+XNCNnQeDAcOSwbGzkOg0U7N0Pqdn+y2WpmYSJ5XxxggJUnaC/+d+wk3/WPm9m05WjTJ5lvDu3P50QfStHH5nfVKE5FRoycwY1kRkAyPOz7PWFbEqNETeObqox2JlKTqFCOsmZscYZz/Jsx/Czat3fW8dodCt2HJ0HjA0dC0VeXX7X5CcquOFVPLH4Xc1oW1+/Hp+XvUIAOkJEl7YOGaDfzqhQ/518yVQHJbjnMGdubak3vSvlXTSt/7xpxVTFtaVOHxRIRpS4t4c85qhh/SPq11S1KDV7gkObo4/83kY92yXc/J6wrdjoUDvwgHHgstO6R2j6zs5D6PO+8Due15337J47VsC4+qMEBKkpSCgo1b+ONrc3nwnQVsLU0OGQ7evzU3nt6bvp3zqnSNsZOXbZ+2WpGsAGMnLzVAStLeWr/qs7C44C1YO2/Xc5q3TQbFA49JTkttfWDyk8G9kdsuuc/j3FeT3VY3rE6ueex3fnLksQ6GRzBASpJUJVtKEjz07kLuePUjCjdtBaBTfjN+csohnNZvv3LXOVZkzfriSsMjJMPlmg3Fe1OyJDVMG9fCgrc/C4yrZ+16Tk6rssY3w5LBsd2hkJWV/lqyspPbdNSxrToqY4CUJKkSMUZenrGCW1+atX0/x9ycRnxr+EFcdlTF6xwr0yY3p0ojkG1a2ERHknZrU0Fya40FbyXXMK6cDuz0A7ZRM+h6RNko47HJ9YnZRqE94X81SZIq8MHiAn71wkwmLvgUgOyswIVDu/LdEw7eqw6pIwZ05Pkp5ay52UEiwogBnfb4HpJUb20uSnZH3TbCuHwquwTG7CbQeehn01I7DYJGfiiXDgZISZJ2snDNBv7vX3M+F/JOOLQ9PznlELq333U/x1QN69Gevp1aMWNZUbmjkCFAn46tOLZH3dsfTJLSbnMRLB6fDIsL3oZlH0As/fw5WY2g0+Bkh9QDj4Euh0PjZpmpt54zQEqSVGbN+mL++NpcHh6/cHuDnN4dW3H9qYfyhe5t03af7KzA6FFDy90HMhGT4XH0qKFu4SGpYapKYAzZ0GlgMjAecExyemqTFpmpt4EJMe5mFX8DEkIoyMvLyysoKMh0KZKkGrRxSwn3vTWfv7w5j/XFJUCyQc4PT+rBmf07kVVNQa40EXlzzmrGTl7Kmg3FtGmRw4gBnTi2RzvDo6SGY1MBLHoXFr6dDIzLp+y6d2LIho79Px8Yc/Z+Roh2lZ+fT2FhYWGMMb+84wbIHRggJalhKSlN8NikxfzhlY9YvS7Z8TSvWWOuOa47Fx2x/x41yJEk7cbGtck1jAvKAuOKaeyyhnHnwNjlcGjaKiPlNjS7C5BOYZUkNTgxRl6avoL/+9ds5q3eAEBOoyxGHXUg3/ziQeQ1a5zhCiWpHilaDhP+AjOfg3UrYOuGXc/JagQdByQD4/5HQ5ehBsZaygApSWowYoy89dEn/Pbl2UxbWggkG9acM7Az3z+xBx3zbbggSXutcEnZthpvJ9cxrp1X/nmNW8CgS+HgE5MjjK5hrBMMkJKkBuG9hZ/ym3/OYvz8tdtfO7FXB350Uk967us6GknVLFEKc1+BqY/BhtXQoh30Ox+6n5DcbL6uihHWzE0Gxm2PwkVVe2/JpuT5J91ct/8bNDAGSElSvTZrRRH/9/JsXvlw1fbXjuzWhmu/1JOBXVtnsDJJDcb61fDwObD8AwhZyQYxIQumP5Xc0P5rT0JuHdm2J1EKK6fDwndgUVlg3LB61/Oa5EKb7sm/c0ViInl87qvQ46Tqq1lpZYCUJNVL81av5/ZXP+K5KcvY1i+uX+c8rj25J0d3b0sIdjmVVAMSpcnwuGJq8utt3UW3Pa+Ymjx+5Wu1cxRu62ZY+l4yLC56FxZPgOKiXc9rtg/s/4XPHh36wtivJ/9+O3dU3VHISo7KGiDrDAOkJKleWbx2I7e/+hFjJy+lNJFMjge1a8GPTurJl/rsa3CUVLPmvlK3RuE2fZoMiYveSY4yLnsfSrfsel6rTtD1yLLAeBS07QFZWZ8/Z8PqysMjJI+XN4KpWssAKUmqF5YVbOKPr83liUmLKSkLjl32acZ3jjuYEQM60Sg7azdXkKRqMPWxz6atViSTo3AFi5Iji4veST6vmln+eW17wv5HQtcvJJ/zu+7+2i3aVe3v3qKOTN8VYICUJNVxq4o2c+frc3l0wmK2lCZ/SemY15RvH3cw5w7uTGODo6RMqk2jcIlSWDmjbCrqu8nnoqW7npfVKLk2s+sRyVHGrkdCizap36/f+cl1npWJieR5qjMMkJKkOmlV0WbufmMeD49fSHFJ8pez9i1z+PZx3Tl/SBdyGtXCtUSSGp5MjsIVr4elk2DR+GRgXDwRtqzb9bwmucl9F7eFxU6DoEnzvb9/9xOSQbSidZAhC/btB92P3/t7qcYYICVJdcrKos3cNe5jHp2waHtwbJvbhG8MO4iLjtifpo0NjpJqkZochStcUja6OD75WDEdYumu57XsCF0Phy5HJKejtu8N2dUQC7Kykx1my+tAGxPJ8Pi1J2tn8yBVyAApSaoTlhdu4u5xH/PoxMVsKQuObVo04evHduOiI/anRY7/pEmqhaprFK50a3I7jUXjPwuM5U1HJUD7XmXTUcseeV2gphqK5bZLdpid+2o5e2Aeb3isg0Lc1ttchBAK8vLy8goKCjJdiiSpzLKCTdw17mMem/jZGse2uZ8Fx+ZNDI6SarmK9oGMiarvA7lxbbI76uLxyeel70HJpl3Pa9wCOg9Kji52ORw6D4Zm+dXz91K9lJ+fT2FhYWGMsdz/cfxXV5JUKy1cs4G73/iYJ99bwtbS5IedbXNz+Mawbnzt8P1p1sRPrSXVEamOwiVKYfWsZFBcMjH5vOaj8q/dqlMyKHYtC4wd+lTPdFSpjP93SZJqlTkr1/Hn/9/efcfHddX5/399Rs3qsqotudtxiUvsOBWCnUYL1SGQQCAQ2EBo+932hf3uFx6w8NsshKX+Flg2sAkLWZIAcUJCCaQ6Cek4bknsuMW2ZEuyem9zvn+cO9JIHkkjWZZmrPfz8biPO3PvuXeufGbkeeuce84je/nNtiqC2Tgoyc3gxo2L+cB58xQcRSQ5hVL8NB2xpuroaIAjL8CRZwdaF7uaY5wjFWaf5YPi3PNgznmQX3Hqr10kigKkiIgkhB1Hmvj3R17lgV3V/dsqCjL5xMZFvO+cuRocR0ROD5HWxSPP+VFRjzwHx3fHLptd4kPi3HN9aCxfB2mZk3u9IkMoQIqIyJRxzvHcwQa+/8heHtszMAfawuJsPnnxYt69toL0VM3jKCJJrO04HHneB8Ujz0LlX6C79cRylgKzVgWB8TyYcy7MXDB5g92IxEkBUkREJl047Hjw5Wr+47F9/OXQwMBly2fl8ulLlnDF6tmkhPSlSUSSTG8XHNsxEBgrn4eGg7HLRrcuVpwDFWdDevakXq7IeChAiojIpOnuDXPvi5X8aMt+9tYM/AV+7dwCPnPJEi5bUYrpr+0ikgycg4YDvkXxyPM+LB7dBn3dJ5YNpcHsNb5VMbIUzFProiQlBUgRETnl2rp6+cWzh/jJEwc42tTZv/3iZSXcuHEx5y8sVHAUmQ7CfbD3wRgjkV6e+PMBttf7sFj5vB/kpvIFaK+LXbZgnm9VnHOun0Zj1hpImzG51ytyiihAiojIKVPT3MlPnzrIz58+RFNHDwApIePta2bziQ2LObM8j76w45HdNWzeWkVdaxdFORlsWlfOxqWl6sYqcjoZbi7Enb+Ofy7EydLT6buiRoJi5QtQvy922fQcP7jNnCAwVpwDuWWTe70ik8icc1N9DQnDzBrz8/PzGxsbRy8sIiLD2n2shR8/vp97X6yiuy8MQEZqiKvPncsNb1jE3MIsAI63dnH9rc+yo7KZkEHY0b9eXZHHrdefR3FOxlT+KCIyEcJ9cMulcGy7D45DWci30t3w8OS3RIb74PieoHUxCIvVOyHcG/s6S1fCnPVBC+M5ULw08VtPRcagoKCApqamJudcQaz9aoEUEZEJ4Zzjyb113PL4/kEjqhZmp/OhC+bzoQvnDwqDfWHH9bc+y64qP9dZZM7HyHpXVTPX3/os93z6IrVEiiS7vQ/6lsfhuLDfv/eh2PMkThTnoPG1gbBYtdXftxhrVFQIuqKu90v52VC+VgPdyLSnACkiIieluzfM/duruOXxA7x8dGDi64XF2fzVGxbynrPnxJzD8bE9NeyojDFRdiDsYEdlM1v21HLJ8tJTcu0iMkm23znQbXU4FvLlJjJAthzzYbFqK1T9xT/uqI9dNrNwICxWnO0DY6J0qRVJIAqQIiIyLsdbu/ifZw7xs6dfo7alq3/7eQsKuWHDIi5bXkpohJbDzVur+rurDidksHlrpQKkSLJrqx05PILf31Y7cpkRX6MOjm6Fyq0DgccUQ4oAACAASURBVLHlaOyyadm+NbF83UBY1JyLInFRgBQRkTF5+Wgztz55gHterKK7138hTAkZb1k1ixvesIi1c2PeMnGCutauEcMj+HBZ19Y1ciERSXzZJfG1QGbH2eLX0QBVLwZBcat/3HQodtmUdChbNTgslizTfYsi46QAKSIiowqHHQ+/UsNPnjjAU/sHhq3Pz0zj/efN47oL51NekDmmcxblZMTVAlmUrUF0RJLemqv9aKsjcWFfbqiOBn+fYtWL/j7Jqq3QcDD2OSwFSlcErYtn+8BYeiak6veIyERRgBQRkWE1tndz1/OH+fnThzhU396/fXFJNte/fiFXnl1BVvr4/ivZtK6c+7ZVjVgm7GDTuopxnV9EEsiSy/1UHaONwlpxNux7JAiKQWAcNiyGoHjZQFfU8nW+pTE965T+KCLTnQKkiIicYFdVE//959e458VKunoHvuxtXFrCRy9ayBuWFI94f2M8Ni4tZXVFHruqmmO2QprBqvI8NizVIBYiSS+U4ud5HDoPJAY4yMiFtuPwjcXDnMD8dBmRsDh7LcxaDRk5k/hDiAgoQIqISKC7N8wfdh3jv/98kOdfa+jfnpORylXr5/DBC+azpHTivqylhIxbrz9v2HkgV5X7eSA1hYdIknMOmit9N9Qz3uTDZPVL0NsBBH896mzyCwQti0t9SCxfq7AokmDMuVFGMJhGzKwxPz8/v7GxcaovRURk0lQ2dnDHs4e447nDg0ZTPaM0h+tet4BN6yrIyTh1f2/sCzu27Kll89ZK6tq6KMrOYNO6CjYsLVF4FEk24TDU74dj23xgPLrdr4ebOiNyz+Lss3xQnH0WlK1UWBSZQgUFBTQ1NTU552KOiqcAGUUBUkSmi0hou/2Z13j4lZr+LqQhgzedOYvrXjefCxcVYRrSXkSG09sFNS/BsR0+KB7bDsd2Qk9b7PIp6T4czlrjg2L5WihdCWkzJve6RWREowVIdWEVEZlGalu6uOv5w/zi2UMcaejo316Sm8E1587lmvPmUTHG0VRFZBpor4fqnT4gHtvhw2LtKxDujV0+Pcd3O5191kBgLFkGKWmTe90iMuEUIEVETnPhsOPJfce549nD/PGlY/T0DfQ8uWhJMdeeP4/LzywjLSU0hVcpIgnBOT/qaXUkKAZL0+Hhj8kuhdlrfGCctcYvhYsgpN8pIqcjBUgRkdPUsaZOfvn8Ye58/vCg1saCrDTeu34O7z9vHotKdJ+RyLTV3Q41L0P1Dt+yGGlh7G4Z/pjCxUFQjLQurobcWZN3zSIy5RQgRUROI719YR7ZXcsdzx7ikd01g6bHOG9hIdecO5crVs9mRlrK1F2kiEyuyCiokZBYvROqd0Hd3thzMgKkzoDSMwfC4qw1UHamn25DRKY1BUgRkdPAvtpWfvXCEX79whFqokZSLcpO5z3r53D1uXNZrNZGkdNfdxvUvAI1u4LAuMsHxs4RBgjMnQ1lq2DWqmC92rc0puhrooicSL8ZRESSVEtnD/dvP8ovnz/MXw4NfDk0gzecUcI1587l8hVlpKfqPiSR0044DA0H/CiokZBY/ZKfQoNhRthPSfcD2ZQFQbFspQ+L2cWTeukiktwUIEVEkkg47Hh6fx2/fOEIv995lM6ege5nFQWZvGf9HN67fg5zC7Om8CpFZEK11voWxeqXBta1r0BP+/DH5MzyXU4jLYplK6F4qUZBFZGTpgApIpIE9te2snlrJZu3Vg4aEGdGWoi3rprNe9fP4YJFRYRCmrdRJGl1tQTdT1/yg9vUvOSXttrhj0nNhNIVA2GxbKWfWzG7aPKuW0SmFQVIEZEEVd/WzX3bqrh7ayXbDg++f2n9/Jm8d/0crlgzm7wZalEQSSo9nVD3ahASo4Ji46ERDjI/NUbZmT4gRtaFCyGkQbFEZPIoQIqIJJDOnj4efqWGu/9SyaO7a+iNGka1oiCTd68r58qz52hAHJFk0NsN9fsGgmJtsK7fP/zop+AHtSld4UdBjaxLlkO6uqaLyNRTgBQRmWJ9YcdT++q498VK/rDrGC2dvf37cjNSuWL1bDadXcF5CwrVRVUkEUWCYu0rvgtq7ctQu9tPkxHuHf64GQU+HJYNCYpZhZN37SIiY6QAKSIyBZxzvHi4kXtfrOK3O45SGzX1RkrI2Li0hE3rKnjjmWWas1EkUfR0+lB4fLcPiLWvxBcU03OhdLkPiSUrgrC4AnLK/LDJIiJJRAFSRGSSOOfYU93Kfduq+M22Kg7VDx5Bcf38mbxrbTlXrJ5NcU7GFF2liNDVCsf3+KX2FagN1g0HRu56mp7jp8koWeEDY0mw5M9RUBSR04YCpIjIKfZqdQv3bz/Kb3ccZW9N66B9y2fl8s615bxjTbmm3hCZbG3Hg5C4e2Bduxuaj4x8XEZeEA6XDV7HGxTDfbD3Qdh+px9hNbsE1lwNSy7XgDgikvAUIEVEToG9Na38dvtRfrujij3Vg0PjvMIs3nlWOe9cW87SslzA3wf58CvVbN5aRV1rF0U5GWxaV87GpaWk6L5HkfEL9/nRTY+/GrQq7vYtisf3QEf9yMdmFUHxMihZ6lsVI0Exd9b4WxRba+H2q+Doi2Ah36JpIdj5a5i9Fq79FeSUjO/cIiKTwJxzo5eaJsysMT8/P7+xsXH0wiIiUZxz7K5u4fc7jvGHncfYXd0yaP+cmZm8bc1s3r66nFUVeVjUl8/jrV1cf+uz7KhsJmQQdvSvV1fkcev156lLq8houlqC+xNfHeh+enyv39bXNfKxeXN8SOwPi8v944meSzHcB7dcCse2x+4KayGYtQZueFgtkSIyZQoKCmhqampyzhXE2q8WSBGRcXLOsf1IE7/feYwHdh3jwPG2QfsrCnxofNvq2ayZkz8oNEb0hR3X3/osu6qaAR8ao9e7qpq5/tZnuefTF6klUiTSmhgJinWvBuu90HJ05GNDaVC0GIrP8OGweKkPi0VnQMYkTYuz90Hf8jgcF/b79z4ES980OdckIjJGCpAiImPQ2xfm+dcaeGDXMR7YeYyqps5B++cWZvLWVbN5y6pZrJtbEDM0RntsTw07KpuH3R92sKOymS17arlkeemE/AwiCc05aK/34bBu78ByfK+fP3G01sTMQh8Oi5cE6yAkzpwPKWmT8zMMZ/udA91Wh2MhX04BUkQSlAKkiMgo2rt72bKnlj++VM0jr9TQ0N4zaP+S0hzeumoWb145i5XleaOGxmibt1b1d1cdTshg89ZKBUg5vXS1+rkT6/ZC3b5gCcJi5yi3koRSYeZC35pYFAmKZ/igONHdTidSW+3I4RH8/rbaybkeEZFxUIAUEYmhpqWTh16u4U8vVfPE3uN09w7+0reqIo+3rJzFW1bNYklp7rhfp661a8TwCD5c1rWN0uoikoi62/3UF3X7fOth/b6BsNh6bPTjc2b5gFi0OAiKZyROa+J4ZJfE1wKZrUF0RCRxKUCKiODvZ9xV1cxDL9fw8O4ath9pJHqMsdSQceHiIt54ZhmXryijvCBzQl63KCcjrhbIomwNoiMJqrsdGg76cFi/Pyos7ofmytGPz8gPAuJiKFw80KpYtBgyxv/HmYS05mo/2upIXNiXExFJUAqQIjJttXX18uTe4zz8Sg2P7K6hunlwK19uRiobl5XwxjPLuHhZKfmZE9/isWldOfdtqxqxTNjBpnUVE/7aInHrbPYtifUHBsJh5HHLyO9fANKyfDgsXBiEwyUwcwE0V8Hu30H7cR+cKs4+vedCXHK5n6pjtFFYl1w2+dcmIhInBUgRmTacc+yrbeOxPbU8uruGZ/bX0903+Evc/KIsLl1eyqXLSzl/YRHpqaFTek0bl5ayuiKPXVXNMVshzWBVeR4blqpLm5xCzkFrjW9JjA6Kkcftx0c/R1oWFC7yIbEwqkWxcNGJ8yZO17kQQyn+Z4v1s7uwD4/X/ur0DdAiclrQPJBRNA+kyOmnpbOHP++r47E9tTy2u5bKxo5B+1NDxrkLCrlsRSmXLC9lUXH2mAbBmQiaB1ImRW8XNB4eCIkNB304bDjol562kY8HyMjzLYeFi4KAuGhgySkbHBKHo7kQ/b/B3of8aKtttf6exzVX+5bH0/VnFpGkMdo8kAqQURQgRZJfX9ixs7KJJ/YeZ8ueWl54rYHeIU17pbkZbFxawsXLSnnD0mLyZkz9YBx9YceWPbVs3lpJXVsXRdkZbFpXwYalJZr/UeLjHLRWQ8Nr0PjaQDBsOOi3NVcCcfyfn13iA+HMhUFrYtTjrKL4QuJI9jwA//O+0ct94JeaykJEZAqMFiDVhVVEkt6hunYe31vLk3uP8+TeOpo6Bk+zkZZinDO/kI3LSti4tITls3InvZVxNCkh45LlpZqqQ0bW0QCNh6JC4pB1b+fo5wilQsE8HwpnLvDBMPJ45gLIyDm1P4PmQhQRSWoKkCKSdI63dvH0/jr+vK+OJ149zqH69hPKzC/K4qIlxWxcWsLrlhSTk6Ffd5IEOpt8QGw8HKxfiwqMh6CrKb7zZBVFhcL5A+Fw5gLIq5jabpKaC1FEJKnpG5WIJLym9h6ePlDHU/v8sru65YQyBVlpvH5xMRedUcxFS4qZW5g1BVcqMgLnoL0emoKA2HR4ICg2HfLrzjgDYnoOFMz34TDW+lS3Ip4MzYUoIpLUFCBFJOE0tnfz3MEGntlfx9MH6thV1czQ27UzUkOcs2Amr1/iA+PK8nzdKyhTq68XWo8F4fCID4iRkBhZxzNQDUBqJhTMjQqF8/zjgnm+FTFz5snfizhVNBeiiEhSU4AUkSlX09zJMwfqeWZ/HY/EGCkV/H2M6+bN5MJFRbxucRFr5xWQkarRCmWSOAedjdBU6cNh85EgJFYGQfGIn9PQ9cV3vrTsICDOG7zkB+vs4uQNiKPRXIgiIklNAVJEJlU47Nh/vJXnDzbw/GsNPH+wnoN1J97DGG1hURY/+6vzmTNT3VLlFOlu82GwOQiFzZGgWDnwvLs1/vNlFUP+HB8S8+cF67nBtnkDLYjhPtj7oB8wZu+DUdM5XA52mv6BRHMhiogkNU3jEUXTeIhMvM6ePrYdbuSFQw28cLCBFw410Njec0I5M07ophoRMlhZnsc9n75I3VRl7LpafOtgc2WwHvK46YhvXYxXSgbkV/jBaPLnBuFwTrDM8/vSMkc/T2vt8CFq9lofonJO4/sANReiiEhC0jyQY6AAKXJynHO8VtfO1sMNvHioka2HG3n5aDM9fSf+npmZlcb6+YWsnz+TlBDc9LtXRj3/rR85V9NcyIBwGNrroKUKmo/6UNhyNCokVvnnXc3xn9NCkDs7CIeRkBiEw0hgnIjupeE+uOXS0btx3vCwwpSIiEwqzQMpIqdMQ1s32yub2Ha4ka2HGnjxcCMNMVoXARaXZHNOEBjXL5jJouLs/rkYP/uLrYQMwiP8PStksHlrpQLkdOCcbzVsOeYDYMsxHxJbjgWhMGp7OPb7Lab+cFgeLHMgb/ZASMwrh5xZkDIJ/zXufdC3PA7Hhf3+vQ9pLkQREUkoCpAiEpfmzh52Vjax/UgTO440sb2ykcP1Jw52A5CbkcraeQWsneuXdfNmUpidPuy561q7RgyP4MNlXVvXyfwIMtUiwbC1OgiA1X7U0uajPizV7vb3Ioa7fQvdWKTOGGg5zJs95HG5b03MLp2ccBiP7XfGN5XF9jsVIEVEJKEkyP+kIpJIGtq62VXVzK6qJnZWNbOrson9x2NPP5ASMpaW5bIuCIxnzytgUXEOoTHcq1iUkxFXC2RRdsZYfxSZDOE+35W0tToIhUEw7H9c7VsLW6uhZ+QBk05kkFMKubN8EMyd5VsKcyMhMVgn27QWbbUjh0fw+9tqJ+d6RERE4qQAKTKNOec40tDBK8da2FXV5ENjZRNVTZ0xy5vB4pIc1lTks3pOPmvmFHDm7Dwy00/uHq1N68q5b1vViGXCDjatqzip15ExCIf9wDKtNT74tdUOeRwJhzXxhaFYsor9yKa9sd9vYP4+wI8/cvrdB5hdEl8LZPZpPIiOiIgkJQVIkWmitauX3cdaeOVYM68cHVi3dPXGLB8yWFSSw8ryPFaW57FmTgEry/PInZE24de2cWkpqyvy2FXVHLMV0gxWleexYam+TJ+Uvl5oPz4QBtuOQ1sQAFtr/eNIIGyrhXDs98aIQmmQUzbQaphT6u8r7G9FnDXwfN/D8D/vG+FkDo5tOz3vA1xzNez89chlXNiXExERSSAKkCIJpi/seGxPDZu3VlHX2kVRTgab1pWzcWlpXFNYdPb0sbemlT3VLeypbuXV6hb21LQMe78iQHpqiGVluf1hcWVFPitmnXzLYrxSQsat15/H9bc+y47K5v7urJH1qvI8br3+vNN7Co/o+QAHTWlw+fCtb+E+aK8PQmEQDNvrBh73Pw8edzSM8+IMsgr9PYS5ZQMBMbt04HFOsD1zJoRC8Z12Ot8HuORyP1XHaKOwLrls8q9NRERkBAqQIgnkeGtXzBB137YqVlf4EFWc4+8DbOroYX9tK/tq29hb08remlZerWnhUH37sPMpAszOn8GK2Xksn5XL8tl5rJiVy8LibFJT4vzSf4oU52Rwz6cvYsueWjZvraSurYui7Aw2ratgw9KS0zs8ttbCz9/jW9swwPn1zl/7+/1WvAt6O4IwWDcQGDsagrLjYCk+pGaX+LkGs6OWnNKogFjqu5qeisFnpvN9gKEUP8/jcPNAzlrj959uXXdFRCTpaR7IKJoHUqZSX9jx7u8/MXw3TmBmdhpnlOay/3gbtS0jj0g6MyuNM8pyWVqWw9KyXM4ozWXF7FwKsoYfDVUmSDgMXU2+dbCjIVjXx1jX+ce1u8c2HcVwMmf6sJdd4ucqjLXOKvahcEZB/C2Fp8qvPgq7No/eArnySrjqJ5N3XZMp3Oe76J7Q8nyZwqOIiEwJzQMpkuC6evuobOjgvm1V7KgcfsJzB9S39fDMgfpB20tyM1hcks2ikhyWlgZhsSyX4pz0/nkWk8Z4unGe6uvpbPIhsKMxWDf4wWX6g2GwrSP6cSO4MU5DMZp5F0LZSsgqCkJi0eCwmFmYOFNUxEv3Afr39dI3nX5ddEVE5LSVZN82RJJPOOyobe3iSEMHRxraOVzfzqH6dl6r84+PNneO2OUUwAjjMMBYUpLDjRcv7g+N+ZkTP6jNlGitjd2db+ev/b1i1/7Kd7Ucq94uHwI7m3yw62zyAbCzMXjeGLUvaltHk29FnAgp6T7gZRUG65lBECyCV/8Ex3YwYldUC/k5Dd/2zYm5nkSh+wBFRESSjgKknDbGOvjMyQ5WE9HZ08fRpk6ONnZwtKmTysYOKhs6ONLYTmVDB1WNnXT3jT7FgY+HfZxte1kd2s98q2ahHWW+VTPXatnlFnB99+coyy/iqvVzxvJPk/jCfT48Htvun0fCRGR9dBvc9jYfoLpbobMZupp98Otq9s8jITGyPbKtd/jBg8YslOa7iWYW+C6gkUCYOTPoPjpz4HF0YEzPHn6OwiPPMep9jLoPcKqvVERERAIKkDJ2Y+xm2Nfby84tv6J3651kdNfTlV5I6rqrWbXhKlJSY78Fx3rM8dYuPvZfT1F47AmuTHmCQpqpJ4+f7biI7866iJ989ML+wWfiLV+UnU5Dew/VzZ1UN3dS09xFTUsnx5o7OdrY6UNjUwcN7fHfuzYzK415hVnMLcxiflFW/+N5hVl8/Xe7+PjuGzjTDpJiJwaKlRzktvSb+XHWj+N+vSnhnJ8svqvVh72uloF1V6sPeP3Pg211e3yAGP6kcHw3/PTtJ399obQgAOYHS8FAIBy0zo8KgzP99pGC4HhN9/kAc0rghod1H6CIiEiSmNJBdMwsB7gJeC9QAOwCvuKc+00cxy4GvglcAoSAx4F/cM69dBLXk/SD6Iw1eI053LXW4m6/Cjv6ImFCQdfKECHCuNlrsSHdDOuqj1D/n+/ijL699DkjhCOMkWKOV1OWUPjxeykqG9yaNtZj+sKOD///9/P5ui+yOnTghGN2hBfy9aKv8tPPvp2Q+dFLP/bDB3hfwy3kWzvVroA6l0etK+A4+RxypRwMzcWRElfLYYQZlORkMLsgkzkzg6Ugkzkzs6iYmUlFQSbZGcP/zWbbw3dw1pZPjPo62zbcwlmXjjR33hiEwz7s9bRDd9vA0tM2+Hn/EoTCyPOuloHtkcDY3Tq+SeXjlZYFGXkwI29gHQmDGVGPI8/7w2KwTsuc+BB4MvY8MMpciIEP/FL3yYmIiMgpN9ogOlMdIP8EnA18DjgAfAS4FniHc+53IxxXCrwI1ABfBnqBLwCLgXXOuSPjvJ6kDpBjDV5jDnfhPnp+dDEp1TsIxehyF8boK1tN2icehVAKfb297P/X81nUuy9mi1qfM/anLmbR/3mmP6yO5RgLpdDS1cvvtx8h7b7PUGjNNJNNk8uhgRwaXC51Lo96l0sVxTRmzqOtq29MoTAiNWSU5mZQmjeD0twMygsymZ0/g9mRdf4MyvJmkHYSU2GEf/lR3K7NpDD89fVh2MKNhC76X9DTMWRpD9Ztft3dPhAOezqCYNgebG/z64ns3jmatCxIz4GMXMjI8eEuI9dvO/g4tBwd/RwL3gAfuf/UX+tkCvfBLZeOfh/gDQ+rNU5EREROuYQNkGZ2BfBb4Ern3OZgm+FbEouccytGOPZm4LPAYudcVbCtCB9Cb3fOfXKc15S0AXKsYW1c4e6VP5Byx+ijIfa9/y5Slr152BY156CLNDrIoNXN4C/rv0bFWZfR2tXLrhe2UPzSz2hlBi1k0eKyaCaLZpdFC1k0u2yayaIhtZS2Xos53cVY5NJOsTVRQiPF1kyxNVFsjcymnm1FV/Chd11BSRYUpDtC4R4/IEtfd7Dugt5u6O0c2Nb/uHNgX//2Lv+4p2NgW28n9ATrxkO4vi4Som3MQj7YpWf7JS0rCHvZUUvU80gQTM/24TA9CInpOQPPRxohdLpP5zDcAEIufHIDCImIiIiMUSIHyFvwXVcLnRv41mhmNwD/Cawcrjuqmb0KvOyce+eQ7bcDlzvnysZ5TUkbIKPDmnPgMMIYDqOPEGFC9BFi++u+x/LXv4sdWzaz/JnP00sKfS5ED6n0kUIvRm/wuMeF2Lfys1SsuICenl7qttxCRv3L9BGil1R6SKWHFLpdGt3B8y6XSkfmLEKzVtJ46CVS+9qCcqn0uFR6LYUeUjEghTAhwsGrhYOlj1TChGxgexq9pESVS6WPVOsjjb6gfB9p9JJOL1nWSSZdZNJNpnUxg25m0E0GPYRDaeQVltJbf4gc10oqfSTt3PShVB/q0jIhdUbweAakZftt6VkD+9OiHkfCYHqWLxu9Ts8OHmdDasbkdvNUN07NBygiIiIJIZED5FOAc869bsj284Gngaudc3fFOC4TaAO+5pz7pyH7Pg98DShzztXEOHa0ZJifn59PIgXIw/XtXP6tx4Ah4zQGT24MbebTobv7N1hUKetfu2CBUIzWRhkv8+EtNR1SMnzoSkkPtmXEWAf7I6EvdYYPfZH9dfvg6R+M/rLX/AKWX3Hqf7zJpG6cIiIiIglhtAA5laOwFgF7Ymyvj9ofy0x8NqqPsS/62BMCZDJyDrp6R7pnr4+MlPhHAU0Ekb9ZRCJvn6WQmpmLhVLpbm8iLdw9YuOXc9CSOpO8heshlErn4a2kt1eP2JoYdtBesIyccz9Ay/N3kN3w8ojl+xw0zrqIoitv9qEvJX0gAEYeh1IntpUu3Aev/Xn0ELX0zRP3molC0zmIiIiIJIWpnsZjpOaw0ZrKxnzscCk6ImihzB/ldSdVSW4Gt15/bv/z6LhiZsxoKWV7y1s5+uTtlHfuIwUHuCAcuWCwm2DtHJWZy1j45k9x6IF/Z0HHLlItTIqFSY3qQhrpRooLsyfnXM780LcglMKdv76Lq2u+M+o13zbrC3zkuo+x44l7WP3nvz1hfyRz+ZVjx4Yf9o8q+nIcI5GawYHX39x/TNorfyA0yr2ZIYPMK74Ky95MVvHyUcunGBRc+tdQtnLEchNquocoTecgIiIikvCmMkDWEbuVsTBYx2phBGjAB8TxHJt0MtNTuGRZ6QglSoBzceFeVscxBUTbBV9l3vq30NDUyJzRyhv0nPNxmL3Gv9LFn2D7Hfeycph5CsPO2OkWMH/DByGrkDMvvY5Xn/n+sAP1hJ2xL3UxqzZc2b9t1YarePXJb4zpmJSlb6SnbM3oo8Oecfm4yk+q6R6iQin+HsfT9T5HERERkSQ3/jkHTt4uYIWZDb2G1cF6Z6yDnHMdwH5gVYzdq4HaWPc/nu5WbbiKV1OW0Odid6kMO+PVlCX9wWus5QE2Lp/NzUVf5SW3APAjtYYd/efY6RZwc9FX2bB8FgApqakUfvxe9qcujll+X+piCj9+76D5JsdzDKEU0j50Nzb7LH/tQSwMB29vm30WaR+6eyB8jbX8ZIuEqKt+Ah/+jV8vfdPpHx5FREREJOFN5SA6bwPuB97tnLs3avsWoNQ5t3yEY78BfAZY6Jw7FmwrxE/j8Qvn3I3jvKakHYUVTpzX0XC4McwDOVp5gOOtXXzsv55i5rEnuDLlSQppop587u57PQ2zLuInH72Q4pyMQcf09fayc8vd9Gy9gxnddXSmF5G27hpWbbhycBA8yWPGPIqlRr0UERERERkkkUdhNeAhYA3wOXz4+zBwHfAu59x9QblHgY3ODTSVmVkZsA2oAv4Z6AW+ACwF1jnnDo3zmpI6QMLYg9e4wl3YsWVPLZu3VlLX1kVRdgab1lWwYWkJKUk7L4aIiIiIiCRsgAQwszzgJuAqoAB4CfiKc+6eqDKPMiRABtvPAP4NuATfFfdx4B+cc7tO4nqSPkCKiIiIiIiMV0IHyESjACkiIiIiItPZaAFyKgfRERERERERkSSiACkiIiIiIiJxUYAUERERERGRuChAioiIiIiIszURcQAAEixJREFUSFwUIEVERERERCQuCpAiIiIiIiISFwVIERERERERiYsCpIiIiIiIiMRFAVJERERERETiogApIiIiIiIicVGAFBERERERkbgoQIqIiIiIiEhcFCBFREREREQkLgqQIiIiIiIiEhcFSBEREREREYmLAqSIiIiIiIjERQFSRERERERE4qIAKSIiIiIiInFRgBQREREREZG4KECKiIiIiIhIXMw5N9XXkDDMLAxYfn7+VF+KiIiIiIjIpGtqagJwzrmYjY0KkFHMrBffKts81dcyRCTRNk3pVchkU71PT6r36Un1Pj2p3qcn1fv0lEz1ngeEnXOpsXYqQCYBM2sEcM4VTPW1yORRvU9PqvfpSfU+PanepyfV+/R0OtW77oEUERERERGRuChAioiIiIiISFwUIEVERERERCQuCpAiIiIiIiISFwVIERERERERiYsCpIiIiIiIiMRFAVJERERERETionkgRUREREREJC5qgRQREREREZG4KECKiIiIiIhIXBQgRUREREREJC4KkAnMzHLM7HtmdtTMOszseTN751Rfl4ydmV1sZm6YZfmQsm80s6eDOq8xsx+ZWUGMc+r9kUDMbI6ZfdfMnjCz1qBuLx6m7AfMbJuZdZrZETP7mpnNiFGuzMx+ambHzazNzB43s9edzDllYsVb72Z2cJjP/9dilFW9Jzgzu8zMbjOz3WbWHvzb321mq2OUnfDf6fGeUyZWvPVuZo8O83m/I8Y5Ve8JzsxeZ2YPmFll8Lu21sweNrO3xig7LT7vCpCJbTNwLfAF4G3AS8BmM7tiSq9KTsbngQuHLAcjO4Mvnr8DDgPvAP4BeCfwWzMb+nnV+yOxLAHeD7QCDw1XyMw+CNwOPAm8FbgJ+DRw25ByM4LzbAQ+C2wCWoCHzGzdeM4pp0Rc9R7Ywomf/+9HF1C9J40bgXnAt/H/9n8XPH/OzC6IFDoVv9PHeE6ZWHHVe+BVTvy8fyHGOVXviW8msBv4e+AtwMeBLuB3ZnZNpNC0+rw757Qk4AJcAThgU9Q2A54AXp7q69My5vq8OKjPd49S7llgKxCK2vbG4Nir9f5I3GVInb07qJ+Lh5RJAY4C9w7ZfkNQ/vyobZ8Ktp0dtS0D2A/8fjzn1DI19R7sOwjcE8f5VO9JsAClMbYVAA3Ar6O2Tfjv9HjPqWVK6/1R4MU4zqd6T9IFSMWHuofHWkenQ73rLxaJaxPQBNwb2eD8u+anwHIzO3OqLkxODTOrAM4FfuacC0e2O+f+BFQC74kqrvdHgomusxFcAMzC11O024EeTqzjHc65v0S9RhfwC+CNZpY7jnPKBIuz3sdC9Z4EnHM1MbY14lud5sCp+Z0+xnPKBIun3sdI9Z6knHO9+Lrrgen3eVeATFyrgJdifDnZHrVfks+PzKzXzJrM7H4zWx+1L1KnO2Mct4PBda73R3KKWcfOuXZgHyfWcaz3wnZ869OKcZxTptal5u+T7DazHWb2STOzIWVU70nKzEoYXH+n4nf6WM4pkyBGvUcsM7OG4P/8V83sC2aWNqSM6j2JmFnIzFLNrNzM/hlYiu/ODNPs864AmbiKgPoY2+uj9kvyaAK+g+83fwnwv4EzgSfN7PygTKROh6v36DrX+yM5nYo6Hss5ZercD/w1vuvS1cAe4AfAt4aUU70noeAPAf+J/171b8Fmfd5Pc8PUO8DjwN/iW5reDTwGfAW4a8gpVO/J5S58i2Ml8DfA+5xzfwj2TavPe+pUvbDExY1znyQY59xWfB/2iMfN7Df4vyr9C3B5dPHhTjPK83j3ydQ7FXUc7zllCjjnPjNk02Yzux34azP7jnPutejiI51qlOfxnEMm3jfwQeF659zLQ/bp8376ilnvzrkvDil3v5lVA/9kZhc5556I2qd6Tx6fA76Ov33gA8BdZvZh59wvospMi8+7WiATVx2x/7JQGKxj/TVCkohz7hjwR/y9TODrHIav9+g61/sjOZ2KOh7LOSWx/BT///B5UdtU70nGzP4FPzrj/3LO3Ra1S5/309gI9T6cyP3KF0ZtU70nEefcfufcc865+5xz7wceAL4fjIY6rT7vCpCJaxewIsYQvZG5hmL1h5bkE2LgL0i7gnWsPu2rGVznen8kp5h1bGZZwGJOrOPh3gt9wCvjOKcklsjnN/o+GNV7EjGzrwD/BHzOOfe9IbtPxe/0sZxTTpFR6n04w33eVe/J61n8FB8lTLPPuwJk4tqMHxr6HUO2Xwfsds69NPmXJBPJzGbhh2J+GsA5dwR4Hrg2+peKmV0GVAB3Rx2u90dyeho4BnxoyPb3A2mcWMerzWxtZIOZpQdlH3TONY/jnJJYrsN/mXwuapvqPUmY2ZeALwJfdM59Y+j+U/E7fYznlFNgtHofwXXB+umobar3JBXc/3ox0AjUTbvP+1TNH6Jl5AU/H8zDwHHgo/iBV27Df9l4x1Rfn5Yx1+ftwFfxN9RfjJ+M+ADQDpwTVe5SoBe4E7gM/+WwCv8fToreH4m9AFcFy9fxLctfCp6/NarMh4N9/x68Fz4JNAO/HHKuGfiJhffjB115I34glg5g/ZCycZ1Ty9TUOz7U3RF8ni/BD72+OSh7s+o9+RZ810UH3Ie/DSF6WRdVbsJ/p8d7Ti1TU+/AG4DfBvV4GX7S958EdXnXkPOp3pNgwX+Huyn43b0RuAb4ffBe+MxY6+h0qPcprxQtI1QO5AVfDI4BncBfGGUiei2JuQD/CLyI/0tVT1CndwCrYpR9C/BMUOe1wC3ATL0/En8J/jOJtRwcUu6D+CG4u/Cjud0MZMY43yzgZ/j7HNrxkwxfNMxrx3VOLZNf7/gvlw8CR4FuoAX4M/DhYc6nek/wBT9RfLyf9wn/nR7vObVMfr0DS/AB8khQP+34QfT+hhhf+FXvib8AnwGewt+T2BusHyDGH+yny+fdggsTERERERERGZHugRQREREREZG4KECKiIiIiIhIXBQgRUREREREJC4KkCIiIiIiIhIXBUgRERERERGJiwKkiIiIiIiIxEUBUkREJEGZ2aNmdnCKXvugmT06Fa8ddQ2fNLNmMysa5/FrzSxsZhsn+tpERKYrBUgREUkaZlZgZl82s4un+lriFYSYL5vZgqm+lmRiZvnAPwPfds7VjecczrkXgXuAb5qZTeT1iYhMVwqQIiKSTAqALwEXT/F1jMVa/DUvGMexbwKWTejVxG9Z8PpT5VP4+v73kzzPd4D1wBUnfUUiIqIAKSIikkjMLMXMsgCcc93Oua6puA7nXJdzrnsqXtvMQsDHgd8752pP8nSPAweBG0/2ukRERAFSRETGyczSzexzZvaimbWbWZOZPW9mnxlSboGZ/czMqs2sy8z2mdlNkZAUVa7QzL4d7O80szoze8HM/new/2LgQFD8S2bmguXgGK/bmdltZnapmT0VXPsRM/t8sH+mmf3EzGqCffebWfmQc5Sb2TeDn70huN6XzOzzZpYSVe7LwK3B00eirvm2YP9HgueXm9kXzWwf0Am8L9g/6B5IM1sXvNafortkBqFzS3C9K0f5+WcEXWp3B+UbzWyHmX1jSLlB90AGx7gRlgVRZfPN7Otmtjeo81oz+4WZLRq9hgA4D99i+7sY139b8Hr5ZvbDoJ46zexJMzt/aHnnnAMeAN5iZjlxvr6IiAwjdaovQEREko+ZpeO/lF8M/BH4OT74rAauJOh2aGbzgWeBfOCHwJ7gmP8DvN7MLnPO9Qan/SWwAfgRsA3IApYH5b8BvAz8LfBtYDNwd3Bc6zh+hHXAO4D/BP4bH9i+ZmadwIfxLVZfBpYAfx2UuTzq+DXBz7kZ2AekAW8FvgYsAj4RlLsbmI1vTbsp+BkIjon2b8E5bgGagd2xLto5t9XMPgd8F/hH4F+DXV8C3gDc6JzbNcrP/n3go8HP9G0gBTgDuHSU4+4G9g7ZNgP4Jv77RAv037v4Z2Ae8F/ALvy/waeAZ8zsHOfca6O8VmTQm2dHKPMAUAt8BSgC/g74nZktcM61DCn7FL5OLgL+MMpri4jISJxzWrRo0aJFy5gW4HOAA26KsS8U9fj2oNwVQ8p8I9j+seB5fvD8B6O87oKg3JdP4todEAbOj9qWDhwNtn9vSPlvBccsi9qWCViMc/8M6ANmR237SHD8xTHKR/btBrJi7H8UOBhj+71AD3AhPmz1Ab+K8+evB34XR7mDwKMj7DfgjuDf7Mqo7d8FOoCzhpSfjw/Ht8Xx2j8N/l3yYuy7LdZ7BXhvsP0TMY65KNj395Px+dCiRYuW03lRF1YRERmPa4EGfOvPIM65MPTfx/ZOYKtzbmhXxH/FB49NwfMOoAs4f5JGK33KOfdM5Inz9/o9iw9F3xtS9vFgfUZU+Q7nnE9RvitvoZkV41vFQsA5Y7yeHzrn2sdQ/nrgGPA/+JB+GPirOI9tAlaa2aqxXeIJvgpcDfyjc+5ugKBb7bXAFqDSzIojC9AGPE18A/OUAL3OueYRynx7yPOHg/UZQwsCkVFcS+N4bRERGYG6sIqIyHicAbzonOscoUwJkIPvwjiIc67ezI7iu3vinOs2s7/Bt14dMLOX8IHgHufcQxN+9bA/xraGYH1gmO39cxGaWSq+C+l1+G6uQ6eImDnG69kzlsLBv9/1wJ+CTRc55xrjPPxv8C2lO8xsP/AIcB9wXyT8j8bMPgz8X+Anzrmbo3aV4P+d3oTvXhpLPK/h/MuYRYJ6DIPq0DlXF9wWGmvOyEj9DHcuERGJkwKkiIiM12hfxsc0755z7j/M7F7gbfhumVcBnzGzO51z14zzGofTN8J1DLcv+uf5FvBZ4E7gX4AafJfSs4GvM/ZB6sbS+hjxzqjHa4En4znIOXdv0Mp7Bf7f+XLgY8DjZna5G2XkVTPbiL939GHgk0N3B+sH8f8O41WLvzczD99ieoI46ymiMOq8IiJyEhQgRURkPPYAK8wsww0/zUQNfmCVE0YFNbOZ+IFVXoze7pw7CvwY+HEwmunPgPeb2Tedc8+ROC1IHwK2DA22ZrYkRtkJv2Yzewc+wN6KbwH9NzPb4pzbEc/xzrl6/MBHPw+6nX4Nf1/ru/CDGQ33ukvxAwcdAK5yzvUMKVILNOLvXXxwbD/VIDuD9RnA8ydxnohIvewcsZSIiIxK90CKiMh43I7vpvmFoTsi00sE3SHvA9aZ2VuGFPtH/P9Bm4NjsmzItB5BC9P24GmkBal1yPOp0seQli4zy8aPEjvUhF6zmVXgg+PLwGfw9xy2A3eYWeYox6aYWUH0tqCL6NbRrtHMioDf4rugvt051zC0TFDntwPnmdlVw5wnnvsQHw3WF8RRNh4XAL3E2UorIiLDUwukiIiMx3fx02B8wczOxU/l0YlvbVzGwJQX/wS8EbjHzH6AnwZiA37wlS340TYBlgKPmdlmfCtRA7AC30XyAMFANsF9bnuBa4I5E6uBNufcfaf2xz3Br4BPmNmd+O6aZfipMepilH0OH7r+b9Dy2gYciB7EJ17BwES3A9nANcHAO+1m9jF8GP8OA1OIxJILHDWz3+BDYw2wEP/v3IAP/MP5Ab4l7z+AC8xsaLjb7Jxrw98b+XrgLjO7Cz9wTjd+FNYrgBfwo8+O5AX8PY5XEEwJM17BHzTeCvzBOTeeKV9ERCSKAqSIiIxZMOjNm4C/Bz6An+OwE3gV3zoWKfdaMLn7V4APAgXAEfworP+fG5gD8jB+zsBLgHcDGUAlfl7Erw8ZofRa/AicN+HninyNkYPPqfB3+O6578N3+zyMvy/wOXyg7OecO2RmHwU+j58LMw0fnMccIPEtvhuBTznnIq2zOOciAf1TZvZH59yvhzm+HR8yL8OH/Bz89CW/Af7VOVc1wmuXBesbg2Wohfgw32Rmr8e/NyL/Pr34en8C30V5RM45Z2Y/Am4yszLnXPVox4xgA35Oyk+dxDlERCRgww9uJiIiIjI1zCwP/weJW5xzJ3SVHsN5NuMD5DkjjOgqIiJxUoAUERGRhGRmNwI3Awudc7G6B492/FrgL8AlzrnHJvr6RESmIwVIERFJemZWgp/2YSStugdORETk5ChAiohI0jOzg/hBWkbyz865L5/6qxERETl9aRAdERE5HVwLjDiFBX5UTxERETkJaoEUERERERGRuISm+gJEREREREQkOShAioiIiIiISFwUIEVERERERCQuCpAiIiIiIiISFwVIERERERERicv/A8tTEebXYCKnAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "sns.set_context(\"talk\")\n",
    "plt.figure(figsize=(15,10))\n",
    "plt.scatter(n, scipy)\n",
    "x_new = np.linspace(0,max(n),100)\n",
    "y_new = [9.622959754997917e-09 *i**2.3 for i in x_new]\n",
    "plt.plot(x_new, y_new, label = 'linear_sum_assignment(): y = [9.6E-9] n^2.3')\n",
    "\n",
    "plt.scatter(n, alap)\n",
    "y_new = [2.6007354232627892e-09 *i**2*np.log(i) for i in x_new]\n",
    "plt.plot(x_new,y_new, label = 'aLAP: y = [2.6E-9] n^2 log(n)')\n",
    "plt.ylabel('runtime (seconds)')\n",
    "plt.xlabel('cost_matrix size (n)')\n",
    "plt.legend()\n",
    "plt.savefig('time_lapvalap')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, performance of aLAP scales better as the size of the cost matrix increases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import timeit\n",
    "n = [50, 100, 150, 200, 250, 300, 350,500,750, 1000, 1250, 1500,\n",
    "     1750, 2000, 2250, 2500, 2750, 3000]\n",
    "alap_ac = np.zeros(len(n))\n",
    "#lap_score = np.zeros(len(n))\n",
    "reps = 15\n",
    "\n",
    "for i, node in enumerate(n):\n",
    "    for j in range(reps):\n",
    "        A = dense_matrix(node)\n",
    "        true = A[linear_sum_assignment(A, maximize = True)].sum()\n",
    "        alap_sum = A[parallel_aLAP(A, maximize = True)].sum()\n",
    "        alap_ac[i] = alap_ac[i] + (true - alap_sum)/true\n",
    "        \n",
    "    alap_ac[i] = alap_ac[i]/reps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_context(\"talk\")\n",
    "plt.figure(figsize=(15,10))\n",
    "plt.plot(n, alap_ac, marker = 'o')\n",
    "coef = np.polyfit(n, alap_ac, 2)\n",
    "y_new = np.poly1d(coef)\n",
    "#plt.plot(np.linspace(0,max(n),100), y_new(np.linspace(0,max(n),100)))\n",
    "plt.xlabel('cost_matrix size')\n",
    "plt.ylabel('Score Percent Error ([lsap_score - alap_score]/lsap_score)')\n",
    "plt.savefig('perdiff_lapvalap')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Runtime as a function of cost matrix density (edgeset size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# random sparse matrix, entries [0,99]\n",
    "def sparse_matrix(n,m): # n = number of nodes, m = number of edges\n",
    "    m = int(m)\n",
    "    matrix = np.zeros((n,n))\n",
    "    rows = random.sample(range(n**2), m)\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if (i*n + j) in rows:\n",
    "                matrix[i,j] = random.randrange(100)\n",
    "    return matrix\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n = 1000 nodes, 10*n edges\n",
      "scipy runtime:  0.046977725800024926\n",
      "alap runtime:  0.012951904400051718\n",
      "ratio (alap/scipy):  0.2757030950196581\n"
     ]
    }
   ],
   "source": [
    "import timeit\n",
    "mysetup = '''\n",
    "from graspy.simulations import er_nm\n",
    "from scipy.optimize import linear_sum_assignment\n",
    "from __main__ import dense_matrix, parallel_aLAP\n",
    "import numpy as np\n",
    "n = 1000\n",
    "G1 = er_nm(n,10*n)\n",
    "G2 = dense_matrix(n)\n",
    "G = np.multiply(G1,G2)'''\n",
    "mycode = '''\n",
    "linear_sum_assignment(-G)'''\n",
    "\n",
    "mycode2 = '''\n",
    "parallel_aLAP(G)'''\n",
    "print('n = 1000 nodes, 10*n edges')\n",
    "scipy_t = timeit.timeit(setup = mysetup, stmt = mycode, number = 10)/10\n",
    "alap_t = timeit.timeit(setup = mysetup, stmt = mycode2, number = 10)/10\n",
    "print('scipy runtime: ' , scipy_t)\n",
    "print('alap runtime: ' , alap_t)\n",
    "print('ratio (alap/scipy): ', alap_t/scipy_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  8532.767421843613\n",
      "score:  9149.739826779025\n",
      "score ratio (alap/lap):  0.9325694045278002\n"
     ]
    }
   ],
   "source": [
    "from graspy.simulations import er_nm\n",
    "from scipy.optimize import linear_sum_assignment\n",
    "import time\n",
    "n = 100\n",
    "G1 = er_nm(n,10*n)\n",
    "G2 = dense_matrix(n)\n",
    "G = np.multiply(G1,G2)\n",
    "Ml = parallel_aLAP(G)\n",
    "print(\"score: \" , G[Ml].sum())\n",
    "Ms = linear_sum_assignment(-G)\n",
    "print(\"score: \" , G[Ms].sum())\n",
    "print('score ratio (alap/lap): ', G[Ml].sum()/ G[Ms].sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'runtime (sec)')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 200\n",
    "m = np.linspace(1000, n**2, 10)\n",
    "scipy_sc = np.zeros((len(m), 2))\n",
    "alap_sc = np.zeros((len(m), 2))\n",
    "reps = 5\n",
    "\n",
    "for i, edge in enumerate(m):\n",
    "    for j in range(reps):\n",
    "        mysetup_s = '''\n",
    "from scipy.optimize import linear_sum_assignment\n",
    "from __main__ import  edge, sparse_matrix\n",
    "import numpy as np\n",
    "n = 200\n",
    "A = sparse_matrix(n, edge)'''\n",
    "        mycode_s = 'linear_sum_assignment(-A)'\n",
    "        scipy_sc[i] = scipy_sc[i] + timeit.timeit(setup = mysetup_s, stmt = mycode_s, number = 2)/2\n",
    "\n",
    "        mysetup_p = '''\n",
    "from __main__ import  edge, sparse_matrix, parallel_aLAP\n",
    "import numpy as np\n",
    "n = 200\n",
    "A = sparse_matrix(n, edge)'''\n",
    "        mycode_p = 'parallel_aLAP(A)'\n",
    "        alap_sc[i] = alap_sc[i] + timeit.timeit(setup = mysetup_p, stmt = mycode_p, number = 2)/2\n",
    "\n",
    "    scipy_sc[i] = scipy_sc[i]/reps\n",
    "    alap_sc[i] = alap_sc[i]/reps\n",
    "\n",
    "    \n",
    "plt.plot(m, scipy_sc)\n",
    "plt.xlabel('edges')\n",
    "plt.ylabel('runtime (sec)')\n",
    "plt.title('Scipy')\n",
    "plt. figure()\n",
    "plt.plot(m, alap_sc)\n",
    "plt.title('aLAP parallel')\n",
    "plt.xlabel('edges')\n",
    "plt.ylabel('runtime (sec)')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the figures above, neither algorithm has traceble trends in runtime due to cost matrix density. This is likely due to the graph representation as an adjacency matrix. The approximation algorithms for LAP depend on the fact that the graph be represented as a group of edges with associated weight, with the time complexity dependent on the number of weighted edges. However, by using an adjacency matrix, we are essentially operating on a complete graph, with \"no edges\" treated as \"edges with weight zero\". For this reason, sparcity does not effect runtime or complexity of aLAP, since the algorithm will check over each possible existing edge atleast once. Additionally, as FAQ is dependent on matrix operations, it is necessary that our linear assignment solver take in cost functions in the form of a matrix. For these reasons, I don't think it is worth further investigating aLAP as a method to speed up FAQ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Somewhat unrelated: aLAP in QAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time \n",
    "qapprob = [\"bur26a\", \"bur26b\", \"bur26c\", \"bur26d\", \"bur26e\", \"bur26f\",\n",
    "              \"bur26g\", \"bur26h\", \"chr12a\", \"chr12b\", \"chr12c\", \"chr15a\",\n",
    "              \"chr15b\", \"chr15c\", \"chr18a\", \"chr18b\", \"chr20a\", \"chr20b\",\n",
    "              \"chr20c\", \"chr22a\", \"chr22b\", \"chr25a\",\n",
    "              \"els19\",\n",
    "              \"esc16a\", \"esc16b\", \"esc16c\", \"esc16d\", \"esc16e\", \"esc16g\",\n",
    "              \"esc16h\", \"esc16i\", \"esc16j\", \"esc32g\", \"esc128\",\n",
    "              \"had12\", \"had14\", \"had16\", \"had18\", \"had20\", \"kra30a\",\n",
    "              \"kra30b\", \"kra32\",\n",
    "              \"lipa20a\", \"lipa20b\", \"lipa30a\", \"lipa30b\", \"lipa40a\", \"lipa40b\",\n",
    "              \"lipa50a\", \"lipa50b\", \"lipa60a\", \"lipa60b\", \"lipa70a\", \"lipa70b\",\n",
    "              \"lipa80a\", \"lipa90a\", \"lipa90b\",\n",
    "              \"nug12\", \"nug14\", \"nug16a\", \"nug16b\", \"nug17\", \"nug18\", \"nug20\",\n",
    "              \"nug21\", \"nug22\", \"nug24\", \"nug25\", \"nug27\", \"nug28\", \"nug30\",\n",
    "              \"rou12\", \"rou15\", \"rou20\",\n",
    "              \"scr12\", \"scr15\", \"scr20\",\n",
    "              \"sko42\", \"sko49\", \"sko56\", \"sko64\", \"sko72\", \"sko81\", \"sko90\",\n",
    "              \"sko100a\", \"sko100b\", \"sko100c\", \"sko100d\", \"sko100e\", \"sko100f\",\n",
    "              \"ste36b\", \"ste36c\",\n",
    "              \"tai12a\", \"tai12b\", \"tai15a\", \"tai15b\", \"tai17a\", \"tai20a\",\n",
    "              \"tai20b\", \"tai25a\", \"tai25b\", \"tai30a\", \"tai30b\", \"tai35a\",\n",
    "              \"tai40a\", \"tai40b\", \"tai50a\", \"tai50b\", \"tai60a\", \"tai60b\",\n",
    "              \"tai64c\", \"tai80a\", \"tai100a\", \"tai100b\", \"tai150b\", \"tai256c\",\n",
    "              \"tho30\", \"tho40\", \"tho150\", \"wil50\", \"wil100\"]\n",
    "qapprob = [\"chr12c\",\"chr15a\",\"chr15c\",\"chr20b\",\"chr22b\",\"esc16b\",\n",
    "          \"rou12\",\"rou15\",\"rou20\",\"tai12a\",\"tai15a\",\"tai17a\",\"tai20a\",\n",
    "          \"tai30a\",\"tai35a\",\"tai40a\"]\n",
    "\n",
    "\n",
    "slnfile = np.load(\"qap_sols.npz\",allow_pickle=True)\n",
    "datafile = np.load(\"qap_probs.npz\",allow_pickle=True)\n",
    "n_qap = len(qapprob)\n",
    "scipy_scores = np.zeros((n_qap,2))\n",
    "alap_scores = np.zeros((n_qap,2))\n",
    "den = 1\n",
    "for i in range(n_qap):\n",
    "    c_min = [0]*den\n",
    "    b_min = [0]*den\n",
    "    u_min = [0]*den\n",
    "    for k in range(den):\n",
    "        A = datafile[qapprob[i]][0]\n",
    "        B = datafile[qapprob[i]][1]\n",
    "        n = A.shape[0]\n",
    "        start = time.time()\n",
    "        res = quadratic_assignment(A,B, options={'init_weight': 0.5, 'init_n': 30})\n",
    "        scipy_scores[i,1] = (time.time() - start)\n",
    "        #scipy_scores[i,1] = res['nit']\n",
    "        c_min[k] = res['score']\n",
    "            \n",
    "        start = time.time()\n",
    "        res = quadratic_assignment_aLAP(A,B, options={'init_weight': 0.5, 'init_n': 30, 'eps': 0.05})\n",
    "        alap_scores[i,1] = (time.time() - start)\n",
    "        #alap_scores[i,1] = res['nit']\n",
    "        b_min[k] = res['score']\n",
    "        \n",
    "        \n",
    "    scipy_scores[i,0] = min(c_min)\n",
    "    alap_scores[i,0] = min(b_min)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       QAP        OPT       aLAP  aLAP time      scipy  scipy time\n",
      "0   chr12c    11156.0    12176.0   0.957180    12322.0    0.756619\n",
      "1   chr15a     9896.0    11716.0   1.030711    10108.0    0.742376\n",
      "2   chr15c     9504.0    12698.0   0.968232    12136.0    0.846084\n",
      "3   chr20b     2298.0     2872.0   1.343245     2854.0    0.932337\n",
      "4   chr22b     6194.0     7040.0   1.119524     7240.0    0.862945\n",
      "5   esc16b      292.0      292.0   1.342118      292.0    0.843279\n",
      "6    rou12   235528.0   241844.0   0.644371   235528.0    0.846084\n",
      "7    rou15   354210.0   387716.0   0.497635   363354.0    0.797452\n",
      "8    rou20   725522.0   744972.0   0.901474   734392.0    1.232558\n",
      "9   tai12a   224416.0   241722.0   0.484759   224416.0    1.098458\n",
      "10  tai15a   388214.0   452594.0   0.453666   390258.0    0.822401\n",
      "11  tai17a   491812.0   497780.0   0.929372   498214.0    0.798237\n",
      "12  tai20a   703482.0   789062.0   0.675579   712618.0    0.882434\n",
      "13  tai30a  1818146.0  2033048.0   0.677456  1853424.0    1.268588\n",
      "14  tai35a  2422002.0  2479198.0   1.385379  2466116.0    0.973442\n",
      "15  tai40a  3139370.0  3233306.0   1.062058  3204812.0    1.377191\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "opt = [slnfile[i] for i in qapprob]\n",
    "mat = np.zeros((n_qap,5))\n",
    "mat[:,0] = opt\n",
    "mat[:,1] = alap_scores[:,0]\n",
    "mat[:,2] = alap_scores[:,1]\n",
    "mat[:,3] = scipy_scores[:,0]\n",
    "mat[:,4] = scipy_scores[:,1]\n",
    "#mat[:,1] = (bari_scores-opt)/opt\n",
    "#mat[:,2] = (convex_scores-opt)/opt\n",
    "#(bari_scores-opt)/opt\n",
    "df = pd.DataFrame(mat,columns=[\"OPT\",\"aLAP\", \"aLAP time\", \"scipy\", \"scipy time\"])\n",
    "df.insert(0,\"QAP\",qapprob,True)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Runtime (s)')"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mat = np.zeros((n_qap,2))\n",
    "mat[:,0] = (alap_scores[:,0]-opt)/opt\n",
    "mat[:,1] = (scipy_scores[:,0]-opt)/opt\n",
    "plt.plot(['alap','scipy'],mat.T, marker='o')\n",
    "plt.xlabel('Assignment type')\n",
    "plt.ylabel('Percent Diff from the Optimum')\n",
    "plt.figure()\n",
    "mat = np.zeros((n_qap,2))\n",
    "mat[:,0] = alap_scores[:,1]\n",
    "mat[:,1] = scipy_scores[:,1]\n",
    "plt.plot(['alap','scipy'],mat.T, marker='o')\n",
    "plt.xlabel('Assignment type')\n",
    "plt.ylabel('Runtime (s)')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.78204400e+06 2.95237300e+06 1.76308870e-01 3.78269300e+06\n",
      " 1.18349791e+00]\n"
     ]
    }
   ],
   "source": [
    "np.arange(n_qap)[(alap_scores[:,0]-opt)/opt < 0]\n",
    "print(mat[5,:])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import operator\n",
    "from scipy.optimize import linear_sum_assignment, minimize_scalar, OptimizeResult\n",
    "\n",
    "\n",
    "def quadratic_assignment_aLAP(\n",
    "    cost_matrix,\n",
    "    dist_matrix,\n",
    "    maximize=False,\n",
    "    options=None\n",
    "):\n",
    "    r\"\"\"\n",
    "    Solve the quadratic assignment problem.\n",
    "\n",
    "    This function solves the Quadratic Assignment Problem (QAP) and the\n",
    "    Graph Matching Problem through an implementation of the Fast\n",
    "    Approximate QAP Algorithm (FAQ) (these two problems are the same up\n",
    "    to a sign change) [1]_.\n",
    "\n",
    "    Quadratic Assignment solves problems of the following form:\n",
    "\n",
    "    .. math::\n",
    "\n",
    "        \\min_P & \\ {\\ \\text{trace}(APB^T P^T)}\\\\\n",
    "        \\mbox{s.t. } & {P \\ \\epsilon \\ \\mathcal{P}}\\\\\n",
    "\n",
    "    where :math:`\\mathcal{P}` is the set of all permutation matrices,\n",
    "    and :math:`A` and :math:`B` are adjacency matrices.\n",
    "\n",
    "    This algorithm can be thought of as finding an alignment of the\n",
    "    vertices of two graphs which minimizes the number of induced edge\n",
    "    disagreements, or, in the case of weighted graphs, the sum of squared\n",
    "    differences of edge weight disagreements. The option to add seeds\n",
    "    (known vertex correspondence between some nodes) is also available\n",
    "    [2]_.\n",
    "\n",
    "    Note that the quadratic assignment problem is NP-hard, is not\n",
    "    known to be solvable in polynomial time, and is computationally\n",
    "    intractable. Therefore, the results given are approximations,\n",
    "    not guaranteed to be exact solutions.\n",
    "\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    cost_matrix : 2d-array, square, non-negative\n",
    "        A square adjacency matrix. In this implementation, :math:`A` =\n",
    "        `cost-matrix` in the objective function above.\n",
    "\n",
    "    dist_matrix : 2d-array, square, non-negative\n",
    "        A square adjacency matrix.  In this implementation, :math:`B` =\n",
    "        `dist-matrix` in the objective function above.\n",
    "\n",
    "    partial_match : 2d-array, optional, (default = None)\n",
    "        Allows the user apply a seed, fixing part of the matching between\n",
    "        the two adjacency matrices.\n",
    "        For column 1, each entry is an index of a node in `cost_matrix`.\n",
    "        For column 2, each entry is an index of a node in `dist_matrix`.\n",
    "        The elements of ``seed[:, 0]`` and ``seed[:, 1]`` are vertices\n",
    "        which are known to be matched, that is, ``seed[i, 0]`` is matched to\n",
    "        vertex ``seed[i, 1]``. Array shape ``(m , 2)`` where ``m <= number of\n",
    "        nodes``.\n",
    "\n",
    "    maximize : bool (default = False)\n",
    "        Gives users the option to solve the Graph Matching Problem (GMP)\n",
    "        rather than QAP. This is accomplished through trivial negation\n",
    "        of the objective function.\n",
    "\n",
    "\n",
    "    options : dict, optional\n",
    "        A dictionary of solver options. All methods accept the following\n",
    "        options:\n",
    "\n",
    "            init : 2d-array (default = 'barycenter')\n",
    "                The algorithm may be sensitive to the initial permutation\n",
    "                matrix (or search position) chosen due to the possibility\n",
    "                of several local minima within the feasible region.\n",
    "                With only 1 initialization, a barycenter init will\n",
    "                likely return a more accurate permutation.\n",
    "\n",
    "                Choosing several random initializations (through\n",
    "                `init_weight` and `init_n`) as opposed to the non-informative\n",
    "                barycenter will likely result in a more accurate result at\n",
    "                the cost of higher runtime.\n",
    "\n",
    "                The initial position chosen:\n",
    "\n",
    "                \"barycenter\" : the non-informative \"flat doubly stochastic\n",
    "                matrix,\" :math:`J=1*1^T /n` , i.e the barycenter of the\n",
    "                feasible region (where :math:`n` is the number of nodes and\n",
    "                :math:`1` is a ``(n, 1)`` array of ones).\n",
    "\n",
    "                If an ndarray is passed, it should have the same shape as\n",
    "                `cost_matrix` and `dist_matrix`, and its rows and columns\n",
    "                must sum to 1 (doubly stochastic).\n",
    "            init_weight : float, positive in range [0,1] (Default = None)\n",
    "                Allows the user to specify the amount of random perturbation\n",
    "                from the starting position of `init`\n",
    "                At each initialization, the initial permutation matrix\n",
    "                is some random point near :math:`J`, defined as\n",
    "                :math:`(\\alpha J + (1- \\alpha) K`, where :math:`\\alpha`\n",
    "                is `init_weight` and :math:`K` is some random doubly\n",
    "                stochastic matrix.\n",
    "            init_n : int, positive (default = 1)\n",
    "                Number of random initializations of the starting\n",
    "                permutation matrix that the FAQ algorithm will undergo.\n",
    "            maxiter : int, positive (default = 30)\n",
    "                Integer specifying the max number of Franke-Wolfe iterations.\n",
    "                FAQ typically converges with modest number of iterations.\n",
    "            shuffle_input : bool (default = True)\n",
    "                To avoid artificially high or low matching due to inherent\n",
    "                sorting of input adjacency matrices, gives users the option\n",
    "                to shuffle the nodes of `cost_matrix`. Results are then\n",
    "                unshuffled so that returned `col_ind` matches the node order\n",
    "                of inputs.\n",
    "            eps : float (default = 0.05)\n",
    "                A positive, threshold stopping criteria such that Franke-\n",
    "                Wolfe continues to iterate while Frobenius norm of\n",
    "                :math:`(P_{i}-P_{i+1}) > eps`, where :math:`i` is the\n",
    "                iteration number.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    res : OptimizeResult\n",
    "        A :class:`scipy.optimize.OptimizeResult` consisting of the fields:\n",
    "\n",
    "            col_ind : 1-D array\n",
    "                An array of column indices corresponding to the optimal\n",
    "                permutation (with the fixed seeds given) of the\n",
    "                nodes of `dist_matrix`, to best minimize the objective\n",
    "                function.\n",
    "            score : float\n",
    "                The optimal value of the objective function.\n",
    "            nit : int\n",
    "                The total number of Franke-Wolfe iterations performed during\n",
    "                optimization.\n",
    "\n",
    "    References\n",
    "    ----------\n",
    "    .. [1] J.T. Vogelstein, J.M. Conroy, V. Lyzinski, L.J. Podrazik,\n",
    "           S.G. Kratzer, E.T. Harley, D.E. Fishkind, R.J. Vogelstein, and\n",
    "           C.E. Priebe, \"Fast approximate quadratic programming for graph\n",
    "           matching,\" PLOS one, vol. 10, no. 4, p. e0121002, 2015.\n",
    "\n",
    "    .. [2] D. Fishkind, S. Adali, H. Patsolic, L. Meng, D. Singh, V. Lyzinski,\n",
    "           C. Priebe, \"Seeded graph matching\", Pattern Recognit. 87 (2019):\n",
    "           203-215.\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "\n",
    "    >>> cost = np.array([[0, 80, 150, 170], [80, 0, 130, 100],\n",
    "    ...         [150, 130, 0, 120], [170, 100, 120, 0]])\n",
    "    >>> dist = np.array([[0, 5, 2, 7], [0, 0, 3, 8],\n",
    "    ...         [0, 0, 0, 3], [0, 0, 0, 0]])\n",
    "    >>> from scipy.optimize import quadratic_assignment\n",
    "    >>> res = quadratic_assignment(cost, dist)\n",
    "    >>> print(res)\n",
    "     col_ind: array([0, 3, 2, 1])\n",
    "         nit: 9\n",
    "       score: 3260\n",
    "\n",
    "    To demonstrate explicitly how the `score` value\n",
    "    :math:`f(P) = trace(A^T PBP^T )` is calculated, one may construct the\n",
    "    permutation matrix, and perform the necessary algebra.\n",
    "\n",
    "    >>> n = cost.shape[0]\n",
    "    >>> P = np.zeros((n, n))\n",
    "    >>> P[np.arange(n), res['col_ind']] = 1\n",
    "    >>> score = int(np.trace(cost.T @ P @ dist @ P.T))\n",
    "    >>> print(score)\n",
    "    3260\n",
    "\n",
    "    As you can see, the value here matches res['score'] reported above.\n",
    "    Alternatively, to avoid constructing the permutation matrix, one can also\n",
    "    perform the following calculation.\n",
    "\n",
    "    >>> score = np.trace(cost.T @ dist[np.ix_(res['col_ind'], res['col_ind'])])\n",
    "    >>> print(score)\n",
    "    3260\n",
    "\n",
    "    Here, we are simply permuting the distance matrix.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    if options is None:\n",
    "        options = {}\n",
    "\n",
    "    return _quadratic_assignment_faq(cost_matrix, dist_matrix, maximize,\n",
    "                                     **options)\n",
    "\n",
    "\n",
    "def _quadratic_assignment_faq(\n",
    "        cost_matrix,\n",
    "        dist_matrix,\n",
    "        maximize=False,\n",
    "        partial_match=None,\n",
    "        init=\"barycenter\",\n",
    "        init_weight=None,\n",
    "        init_n=1,\n",
    "        maxiter=30,\n",
    "        shuffle_input=True,\n",
    "        eps=0.05\n",
    "):\n",
    "\n",
    "    cost_matrix = np.asarray(cost_matrix)\n",
    "    dist_matrix = np.asarray(dist_matrix)\n",
    "\n",
    "    if partial_match is None:\n",
    "        partial_match = np.array([[], []]).T\n",
    "    partial_match = np.asarray(partial_match)\n",
    "    init_n = operator.index(init_n)\n",
    "    maxiter = operator.index(maxiter)\n",
    "\n",
    "    # ValueError check\n",
    "    msg = None\n",
    "    if cost_matrix.shape[0] != cost_matrix.shape[1]:\n",
    "        msg = \"'cost_matrix' must be square\"\n",
    "    elif dist_matrix.shape[0] != dist_matrix.shape[1]:\n",
    "        msg = \"'dist_matrix' must be square\"\n",
    "    elif cost_matrix.shape != dist_matrix.shape:\n",
    "        msg = \"Adjacency matrices must be of equal size\"\n",
    "    elif (cost_matrix < 0).any() or (dist_matrix < 0).any():\n",
    "        msg = \"Adjacency matrix contains negative entries\"\n",
    "    elif partial_match.shape[0] > cost_matrix.shape[0]:\n",
    "        msg = \"There cannot be more seeds than there are nodes\"\n",
    "    elif partial_match.shape[1] != 2:\n",
    "        msg = \"`partial_match` must have two columns\"\n",
    "    elif (partial_match < 0).any():\n",
    "        msg = \"`partial_match` contains negative entries\"\n",
    "    elif (partial_match >= len(cost_matrix)).any():\n",
    "        msg = \"`partial_match` entries must be less than the number of nodes\"\n",
    "    elif not len(set(partial_match[:, 0])) == len(partial_match[:, 0]) or not \\\n",
    "            len(set(partial_match[:, 1])) == len(partial_match[:, 1]):\n",
    "        msg = \"`partial_match` column entries must be unique\"\n",
    "    elif isinstance(init, str) and init not in {'barycenter'}:\n",
    "        msg = \"Invalid 'init' parameter string\"\n",
    "    elif init_weight is not None and (init_weight < 0 or init_weight > 1):\n",
    "        msg = \"'init_weight' must be in range [0, 1]\"\n",
    "    elif init_n <= 0:\n",
    "        msg = \"'n_init' must be a positive integer\"\n",
    "    elif maxiter <= 0:\n",
    "        msg = \"'maxiter' must be a positive integer\"\n",
    "    if msg is not None:\n",
    "        raise ValueError(msg)\n",
    "\n",
    "    # TypeError check\n",
    "    if type(shuffle_input) is not bool:\n",
    "        msg = \"'shuffle_input' must be a boolean\"\n",
    "    elif eps <= 0 or type(eps) is not float:\n",
    "        msg = \"'eps' must be a positive float\"\n",
    "    elif type(maximize) is not bool:\n",
    "        msg = \"'maximize' must be a boolean\"\n",
    "    if msg is not None:\n",
    "        raise TypeError(msg)\n",
    "\n",
    "    rng = np.random.RandomState()\n",
    "    n = cost_matrix.shape[0]  # number of vertices in graphs\n",
    "    n_seeds = partial_match.shape[0]  # number of seeds\n",
    "    n_unseed = n - n_seeds\n",
    "\n",
    "    perm_inds = np.zeros(n)\n",
    "\n",
    "    obj_func_scalar = 1\n",
    "    if maximize:\n",
    "        obj_func_scalar = -1\n",
    "    score = obj_func_scalar * np.inf\n",
    "\n",
    "    seed_dist_c = np.setdiff1d(range(n), partial_match[:, 1])\n",
    "    if shuffle_input:\n",
    "        seed_dist_c = rng.permutation(seed_dist_c)\n",
    "        # shuffle_input to avoid results from inputs that were already matched\n",
    "\n",
    "    seed_cost_c = np.setdiff1d(range(n), partial_match[:, 0])\n",
    "    permutation_cost = np.concatenate([partial_match[:, 0],\n",
    "                                       seed_cost_c], axis=None).astype(int)\n",
    "    permutation_dist = np.concatenate([partial_match[:, 1],\n",
    "                                       seed_dist_c], axis=None).astype(int)\n",
    "    cost_matrix = cost_matrix[np.ix_(permutation_cost, permutation_cost)]\n",
    "    dist_matrix = dist_matrix[np.ix_(permutation_dist, permutation_dist)]\n",
    "\n",
    "    # definitions according to Seeded Graph Matching [2].\n",
    "    A11 = cost_matrix[:n_seeds, :n_seeds]\n",
    "    A12 = cost_matrix[:n_seeds, n_seeds:]\n",
    "    A21 = cost_matrix[n_seeds:, :n_seeds]\n",
    "    A22 = cost_matrix[n_seeds:, n_seeds:]\n",
    "    B11 = dist_matrix[:n_seeds, :n_seeds]\n",
    "    B12 = dist_matrix[:n_seeds, n_seeds:]\n",
    "    B21 = dist_matrix[n_seeds:, :n_seeds]\n",
    "    B22 = dist_matrix[n_seeds:, n_seeds:]\n",
    "\n",
    "    for i in range(init_n):\n",
    "        # setting initialization matrix\n",
    "        if isinstance(init, str) and init == 'barycenter':\n",
    "            J = np.ones((n_unseed, n_unseed)) / float(n_unseed)\n",
    "        else:\n",
    "            _check_init_input(init, n_unseed)\n",
    "            J = init\n",
    "        if init_weight is not None:\n",
    "            # generate a nxn matrix where each entry is a random number [0, 1]\n",
    "            K = rng.rand(n_unseed, n_unseed)\n",
    "            # Sinkhorn balancing\n",
    "            K = _doubly_stochastic(K)\n",
    "            # initialize J, a doubly stochastic barycenter\n",
    "            P = J * init_weight + (1 - init_weight) * K\n",
    "        else:\n",
    "            P = J\n",
    "        const_sum = A21 @ B21.T + A12.T @ B12\n",
    "        grad_P = np.inf  # gradient of P\n",
    "        n_iter = 0  # number of FW iterations\n",
    "\n",
    "        # OPTIMIZATION WHILE LOOP BEGINS\n",
    "        while grad_P > eps and n_iter < maxiter:\n",
    "            # computing the gradient of f(P) = -tr(APB^tP^t)\n",
    "            delta_f = (const_sum + A22 @ P @ B22.T + A22.T @ P @ B22)\n",
    "            # run hungarian algorithm on gradient(f(P))\n",
    "            rows, cols = parallel_aLAP(delta_f, maximize)\n",
    "            Q = np.zeros((n_unseed, n_unseed))\n",
    "            Q[rows, cols] = 1  # initialize search direction matrix Q\n",
    "\n",
    "            def f(x):  # computing the original optimization function\n",
    "                return obj_func_scalar * (\n",
    "                    np.trace(A11.T @ B11)\n",
    "                    + np.trace(np.transpose(x * P + (1 - x) * Q) @ A21 @ B21.T)\n",
    "                    + np.trace(np.transpose(x * P + (1 - x) * Q) @ A12.T @ B12)\n",
    "                    + np.trace(\n",
    "                        A22.T\n",
    "                        @ (x * P + (1 - x) * Q)\n",
    "                        @ B22\n",
    "                        @ np.transpose(x * P + (1 - x) * Q)\n",
    "                    )\n",
    "                )\n",
    "\n",
    "            alpha = minimize_scalar(\n",
    "                f, bounds=(0, 1), method=\"bounded\"\n",
    "            ).x  # computing the step size\n",
    "            P_i1 = alpha * P + (1 - alpha) * Q  # Update P\n",
    "            grad_P = np.linalg.norm(P - P_i1)\n",
    "            P = P_i1\n",
    "            n_iter += 1\n",
    "        # end of FW optimization loop\n",
    "        \n",
    "        grad_P = np.inf  # gradient of P\n",
    "        while grad_P > eps and n_iter < maxiter:\n",
    "            # computing the gradient of f(P) = -tr(APB^tP^t)\n",
    "            delta_f = (const_sum + A22 @ P @ B22.T + A22.T @ P @ B22)\n",
    "            # run hungarian algorithm on gradient(f(P))\n",
    "            rows, cols = linear_sum_assignment(delta_f, maximize)\n",
    "            Q = np.zeros((n_unseed, n_unseed))\n",
    "            Q[rows, cols] = 1  # initialize search direction matrix Q\n",
    "\n",
    "            def f(x):  # computing the original optimization function\n",
    "                return obj_func_scalar * (\n",
    "                    np.trace(A11.T @ B11)\n",
    "                    + np.trace(np.transpose(x * P + (1 - x) * Q) @ A21 @ B21.T)\n",
    "                    + np.trace(np.transpose(x * P + (1 - x) * Q) @ A12.T @ B12)\n",
    "                    + np.trace(\n",
    "                        A22.T\n",
    "                        @ (x * P + (1 - x) * Q)\n",
    "                        @ B22\n",
    "                        @ np.transpose(x * P + (1 - x) * Q)\n",
    "                    )\n",
    "                )\n",
    "\n",
    "            alpha = minimize_scalar(\n",
    "                f, bounds=(0, 1), method=\"bounded\"\n",
    "            ).x  # computing the step size\n",
    "            P_i1 = alpha * P + (1 - alpha) * Q  # Update P\n",
    "            grad_P = np.linalg.norm(P - P_i1)\n",
    "            P = P_i1\n",
    "            n_iter += 1\n",
    "            \n",
    "        row, col = linear_sum_assignment(\n",
    "            -P\n",
    "        )  # Project onto the set of permutation matrices\n",
    "        perm_inds_new = np.concatenate(\n",
    "            (np.arange(n_seeds), np.array([x + n_seeds for x in col]))\n",
    "        ).astype(int)\n",
    "\n",
    "        score_new = np.trace(\n",
    "            np.transpose(cost_matrix)\n",
    "            @ dist_matrix[np.ix_(perm_inds_new, perm_inds_new)]\n",
    "        )  # computing objective function value\n",
    "\n",
    "        if obj_func_scalar * score_new < obj_func_scalar * score:  # minimizing\n",
    "            score = score_new\n",
    "            perm_inds = np.zeros(n, dtype=int)\n",
    "            perm_inds[permutation_cost] = permutation_dist[perm_inds_new]\n",
    "\n",
    "    permutation_cost_inv = np.argsort(permutation_cost)\n",
    "    cost_matrix = cost_matrix[\n",
    "        np.ix_(permutation_cost_inv, permutation_cost_inv)\n",
    "    ]\n",
    "    permutation_dist_inv = np.argsort(permutation_dist)\n",
    "    dist_matrix = dist_matrix[\n",
    "        np.ix_(permutation_dist_inv, permutation_dist_inv)\n",
    "    ]\n",
    "\n",
    "    score = np.trace(\n",
    "        np.transpose(cost_matrix) @ dist_matrix[np.ix_(perm_inds, perm_inds)]\n",
    "    )\n",
    "\n",
    "    res = {\"col_ind\": perm_inds, \"score\": score, \"nit\": n_iter}\n",
    "\n",
    "    return OptimizeResult(res)\n",
    "\n",
    "\n",
    "def _check_init_input(init, n):\n",
    "    row_sum = np.round(np.sum(init, axis=0), decimals=2)\n",
    "    col_sum = np.round(np.sum(init, axis=1), decimals=2)\n",
    "    msg = None\n",
    "    if init.shape != (n, n):\n",
    "        msg = \"`init` matrix must have same shape as A and B\"\n",
    "    elif (row_sum != 1.).any() or (col_sum != 1.).any() or (init < 0).any():\n",
    "        msg = \"`init` matrix must be doubly stochastic\"\n",
    "    if msg is not None:\n",
    "        raise ValueError(msg)\n",
    "\n",
    "\n",
    "def _doubly_stochastic(P, eps=1e-3):\n",
    "    # cleaner implementation of btaba/sinkhorn_knopp\n",
    "    # Title: sinkhorn_knopp Source Code\n",
    "    # Author: Tabanpour, B\n",
    "    # Date: 2018\n",
    "    # Code version:  0.2\n",
    "    # Availability: https://pypi.org/project/sinkhorn_knopp/\n",
    "    #\n",
    "\n",
    "    max_iter = 1000\n",
    "    c = 1 / P.sum(axis=0)\n",
    "    r = 1 / (P @ c)\n",
    "    P_eps = P\n",
    "\n",
    "    for it in range(max_iter):\n",
    "        if ((np.abs(P_eps.sum(axis=1) - 1) < eps).all() and\n",
    "                (np.abs(P_eps.sum(axis=0) - 1) < eps).all()):\n",
    "            # All column/row sums ~= 1 within threshold\n",
    "            break\n",
    "\n",
    "        c = 1 / (r @ P)\n",
    "        r = 1 / (P @ c)\n",
    "        P_eps = r[:, None] * P * c\n",
    "\n",
    "    return P_eps\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path\n",
    "sys.path.insert(0, '/Users/asaadeldin/Downloads/GitHub/scipy')\n",
    "from scipy.optimize import quadratic_assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}