Final_Triangle_algorithm_using_boundary_points.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Final - Triangle algorithm using boundary points",
      "provenance": [],
      "collapsed_sections": [
        "sHqu-FElXm46",
        "2T6urv4FXs8Q",
        "rCq-VC-d8KUZ",
        "8MQyz_IkXN6I",
        "KqzrmogX69oq",
        "LwSlP9p4NR5a",
        "zpoyNO8iGF8T",
        "MWX7Q5JbDgb8"
      ],
      "machine_shape": "hm",
      "mount_file_id": "14Z04fiWl5W1Q6e7TSiHeBh4PyBSZI2bY",
      "authorship_tag": "ABX9TyO6pmZjUz2ZyufMbLa3VfCa",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tateemma/triangle-algorithm/blob/master/Final_Triangle_algorithm_using_boundary_points.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wjDH8015t4i7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import cv2\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import itertools as it"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sHqu-FElXm46",
        "colab_type": "text"
      },
      "source": [
        " # take kp coordinates and put them in a list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "y9LCqZBiV2Ra",
        "colab": {}
      },
      "source": [
        "def enlist(kp):\n",
        "  points = []\n",
        "  for point in kp:\n",
        "    points.append((point.pt)) #you can put in array and normalise at the same time if you want\n",
        "  points = np.array(points) #array is easier to work with\n",
        "  return points"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2T6urv4FXs8Q",
        "colab_type": "text"
      },
      "source": [
        "# remove points closer than $\\epsilon$ "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t7Xp4vW-U-J8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def remove_close_pts(points):\n",
        "  tbd = [] #to be deleted\n",
        "  for i in range(len(points)):\n",
        "    for j in range(i+1,len(points)):\n",
        "      distance = np.sqrt((points[i][0]-points[j][0])**2 + (points[i][1]-points[j][1])**2)\n",
        "      if  distance <= epsilon * 3:\n",
        "        tbd.append(j)\n",
        "  pnts = np.delete(points, tbd, 0) #remove 1 of the points from the list (axis = 0 bcoz toda kubvisa points[i] wc is axis = 0)\n",
        "  return pnts"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "rCq-VC-d8KUZ"
      },
      "source": [
        "# triangles of triangles"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2WVRtVKYvSrE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#calculate centroids\n",
        "def cal_centroids(tri):\n",
        "  xc = (tri['v1'][0] + tri['v2'][0] + tri['v3'][0])/3\n",
        "  yc = (tri['v1'][1] + tri['v2'][1] + tri['v3'][1])/3\n",
        "  return [xc, yc]\n",
        "\n",
        "#create triangles of triangles\n",
        "def grouper(n, iterable, fillvalue=None):\n",
        "    args = [iter(iterable)] * n\n",
        "    return it.zip_longest(*args, fillvalue=fillvalue)\n",
        "\n",
        "#function to apply the functions above\n",
        "def triangles_of_triangles(lst):\n",
        "  size = int(len(lst)/3)\n",
        "  vertices = pd.DataFrame(lst, columns=['v1', 'v2', 'v3']) \n",
        "  centroids = vertices.apply(cal_centroids, axis=1)\n",
        "  triangles = list(grouper(3, list(centroids[:(size*3)])))\n",
        "  return triangles"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8MQyz_IkXN6I",
        "colab_type": "text"
      },
      "source": [
        "# sort them so that they are in order of size"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "yevk-mTDd80b",
        "colab": {}
      },
      "source": [
        "#function to calculate distance between 2 points\n",
        "def dist(p1,p2):\n",
        "  result = np.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2)\n",
        "  return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "tTiQbk8Yd80w",
        "colab": {}
      },
      "source": [
        "#define an edge with vertices p1 and p2, and length\n",
        "class edge:\n",
        "  def __init__(self, p1, p2):\n",
        "    self.p1 = list(p1)\n",
        "    self.p2 = list(p2)\n",
        "    self.length = dist(p1,p2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Fu5n3Xr4d81C",
        "colab": {}
      },
      "source": [
        "#function to rearrange. \n",
        "def rearrange(triangle):\n",
        "  e1 = edge(triangle[0],triangle[1]) #triangle edges\n",
        "  e2 = edge(triangle[1],triangle[2])\n",
        "  e3 = edge(triangle[2],triangle[0])\n",
        "  edges = [e1,e2,e3]\n",
        "  s = sorted(edges, key=lambda e: e.length) #sort edges according to length\n",
        "  '''\n",
        "  now, each edge has 2 nodes. we must rearrange the nodes such that from v1 to v2 -> shortest length,\n",
        "  v2 to v3 -> intermediate and v3 to v1 -> longest.\n",
        "  If we have p1 to p3 as shortest, p2 to p3 as intermediate and p1 to p2 as longest, we have to find a way of selecting the nodes \n",
        "  so that we obtain the order p1-p3-p2.\n",
        "  one way is from p1 to p3 and p2 to p3, we pick the one in the first pair that is not common to both points as the first node, then  \n",
        "  from p2 to p3 and p1 to p2, we also pick the one in the first pair that is not common to both points as the next node and same for \n",
        "  the last one.\n",
        "  '''\n",
        "  if s[0].p1 == s[1].p1 or s[0].p1 == s[1].p2: #if s[0]p1 is in s[1], take the other point as v0\n",
        "    v0 = s[0].p2\n",
        "  else:\n",
        "    v0 = s[0].p1\n",
        "  if s[1].p1 == s[2].p1 or s[1].p1 == s[2].p2: \n",
        "    v1 = s[1].p2\n",
        "  else:\n",
        "    v1 = s[1].p1\n",
        "  if s[2].p1 == s[0].p1 or s[2].p1 == s[0].p2:\n",
        "    v2 = s[2].p2\n",
        "  else:\n",
        "    v2 = s[2].p1\n",
        "  result = (v0,v1,v2)\n",
        "  return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KqzrmogX69oq",
        "colab_type": "text"
      },
      "source": [
        "# Get R, C, $t_R$, $t_C$, log p, s and orientation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CgGmH3tnHZjT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#find r_3 max\n",
        "def r3_max(t_list):\n",
        "  r3s = []\n",
        "  for tri in t_list:\n",
        "    r3s.append(dist(tri[2],tri[0]))\n",
        "  result = max(r3s)\n",
        "  return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4w0Jgi39Fa7G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# define an object - a triangle with parameters\n",
        "class tri_with_params:\n",
        "  def __init__(self, triangle):\n",
        "    self.triangle = triangle\n",
        "    self.p1 = triangle[0]\n",
        "    self.p2 = triangle[1]\n",
        "    self.p3 = triangle[2]\n",
        "    self.r1 = edge(self.p1, self.p2)\n",
        "    self.r2 = edge(self.p2, self.p3)\n",
        "    self.r3 = edge(self.p3, self.p1)\n",
        "  \n",
        "  def R(self):\n",
        "    R = self.r3.length / self.r1.length\n",
        "    return R\n",
        "\n",
        "  def logp(self):\n",
        "    logp = np.log(self.r1.length + self.r2.length + self.r3.length)\n",
        "    return logp\n",
        "\n",
        "  def s(self, r3max):\n",
        "    s = self.r3.length / r3max\n",
        "    return s\n",
        "\n",
        "  def C(self):\n",
        "    C = (1/(self.r3.length*self.r1.length))*(((self.p3[0]-self.p1[0])*(self.p2[0]-self.p1[0]))+((self.p3[1]-self.p1[1])*(self.p2[1]-self.p1[1])))\n",
        "    return C\n",
        "\n",
        "  def F(self):\n",
        "    F = (epsilon**2)*((1/(self.r3.length**2))-(self.C()/(self.r3.length*self.r1.length))+(1/(self.r1.length**2)))\n",
        "    return F\n",
        "\n",
        "  def tR_sqrd(self):\n",
        "    tR_sqrd = 2 * (self.R()**2) * self.F()\n",
        "    return tR_sqrd\n",
        "\n",
        "  def tC_sqrd(self):\n",
        "    q = (1/2)*(self.r1.length + self.r2.length + self.r3.length)\n",
        "    A = np.sqrt(q*(q-self.r1.length)*(q-self.r2.length)*(q-self.r3.length))\n",
        "    S = (2*A)/(self.r3.length*self.r1.length)\n",
        "    tC_sqrd = (2 * (S**2) * self.F()) + (3 * (self.C()**2) * (self.F()**2))\n",
        "    return tC_sqrd\n",
        "\n",
        "  def theta(self): #theta should be in degrees, this is in radians\n",
        "    x_c = (1/3)*(self.p1[0] + self.p2[0] + self.p3[0])\n",
        "    y_c = (1/3)*(self.p1[1] + self.p2[1] + self.p3[1])\n",
        "    theta = np.arctan((self.p1[1]-y_c)/(self.p1[0]-x_c))\n",
        "    return theta\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LwSlP9p4NR5a",
        "colab_type": "text"
      },
      "source": [
        "# Store in dataframe"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2R-b5CbKGc4J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def create_df(triangles_list):\n",
        "  rows = []\n",
        "  r3max = r3_max(triangles_list)\n",
        "  for i in triangles_list:\n",
        "    tp = tri_with_params(i)\n",
        "    rows.append([tp.triangle, tp.R(), tp.C(), tp.logp(), tp.s(r3max), tp.tR_sqrd(), tp.tC_sqrd(), tp.theta()])\n",
        "  df = pd.DataFrame(rows, columns=['triangle', 'R', 'C', 'logp', 's', 'tR_sqrd', 'tC_sqrd', 'theta'])\n",
        "  return df"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zpoyNO8iGF8T",
        "colab_type": "text"
      },
      "source": [
        "# Filter triangles with $s > s_{max} (= 0.85)$, $R > 8$ and $C > 0.99$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_A2Q7rgxLXo4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def clean_triangles(dataframe):\n",
        "  dataframe = dataframe.drop(dataframe[dataframe['R'] > 8].index).reset_index(drop=True)\n",
        "  dataframe = dataframe.drop(dataframe[dataframe['s'] > 0.85].index).reset_index(drop=True)\n",
        "  dataframe = dataframe.drop(dataframe[dataframe['C'] > 0.99].index).reset_index(drop=True)\n",
        "  return dataframe"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MWX7Q5JbDgb8",
        "colab_type": "text"
      },
      "source": [
        "# Match triangles\n",
        "For triangles in two lists A and B, they are compared using their R, $\\theta$ and C values. If \n",
        "\\begin{equation}\n",
        "(R_A - R_B)^2 < t_{R_A}^2 + t_{R_B}^2,\n",
        "\\end{equation}\n",
        "\\begin{equation}\n",
        "(C_A - C_B)^2 < t_{C_A}^2 + t_{C_B}^2\n",
        "\\end{equation}\n",
        "and\n",
        "\\begin{equation}\n",
        "\\theta_A - \\theta_B < \\theta_{max}\n",
        "\\end{equation}\n",
        "where $\\theta_{max}$ is user selected, then two triangles are a match.\n",
        "\n",
        "The relative magnification factor M is also computed,\n",
        "\\begin{equation}\n",
        "log M = log p_A - log p_B\n",
        "\\end{equation}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zlf5C6RfB0Ih",
        "colab_type": "text"
      },
      "source": [
        "If more than 1 triangle from list B matches a triangle in list A, the one with the smallest $\\delta$ is retained, where\n",
        "\\begin{equation}\n",
        "\\delta^2 = \\frac{(R_A - R_B)^2}{t_{R_A}^2 + t_{R_B}^2} + \\frac{(C_A - C_B)^2}{t_{C_A}^2 + t_{C_B}^2} + \\frac{(\\theta_A - \\theta_B)^2}{\\theta_{max}^2}\n",
        "\\end{equation}\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "siexrx13UeSY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#function to remove those that do not meet the first three equations.\n",
        "def match(df):\n",
        "  theta_max = 0.174533 #10 degrees in radians\n",
        "  df = df.drop(df[df['r'] > df['tr2']].index).reset_index(drop=True)\n",
        "  df = df.drop(df[df['c'] > df['tc2']].index).reset_index(drop=True)\n",
        "  df = df.drop(df[df['theta'] > theta_max].index).reset_index(drop=True)\n",
        "  return df"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0hE2P9Vxktl8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def filter_and_match(a): #function to calculate LHS and RHS of the eqns and store them in a df. Faster than a loop\n",
        "  atris = pd.Series([a['triangle']]*len(dfB))\n",
        "  atris = pd.DataFrame(atris, columns=['atriangle'])\n",
        " \n",
        "  btris = list(dfB['triangle'])\n",
        "  btris = pd.Series(btris)\n",
        "  btris = pd.DataFrame(btris, columns=['btriangle'])\n",
        "  \n",
        "  r = (a['R']-dfB['R'])**2\n",
        "  r = list(r)\n",
        "  r = pd.Series(r)\n",
        "  r = pd.DataFrame(r, columns=['r'])\n",
        "  \n",
        "  tr2 = (a['tR_sqrd']+dfB['tR_sqrd'])\n",
        "  tr2 = list(tr2)\n",
        "  tr2 = pd.Series(tr2)\n",
        "  tr2 = pd.DataFrame(tr2, columns=['tr2'])\n",
        "\n",
        "  c = (a['C']-dfB['C'])**2\n",
        "  c = list(c)\n",
        "  c = pd.Series(c)\n",
        "  c = pd.DataFrame(c, columns=['c'])\n",
        "\n",
        "  tc2 = (a['tC_sqrd']+dfB['tC_sqrd'])\n",
        "  tc2 = list(tc2)\n",
        "  tc2 = pd.Series(tc2)\n",
        "  tc2 = pd.DataFrame(tc2, columns=['tc2'])\n",
        "\n",
        "  theta = a['theta']-dfB['theta']\n",
        "  theta = list(theta)\n",
        "  theta = pd.Series(theta)\n",
        "  theta = pd.DataFrame(theta, columns=['theta'])\n",
        "\n",
        "  logM = a['logp'] - dfB['logp']\n",
        "  logM = list(logM)\n",
        "  logM = pd.Series(logM)\n",
        "  logM = pd.DataFrame(logM, columns=['logM'])\n",
        "\n",
        "  result = pd.concat([atris, btris, r, tr2, c, tc2, theta, logM], axis=1, sort=False) \n",
        "\n",
        "  #calculate delta\n",
        "  theta_max = 0.174533 #10 degrees in radians\n",
        "  result['delta'] = np.sqrt((result['r']/result['tr2']) + (result['c']/result['tc2']) + ((result['theta']**2)/(theta_max**2)))\n",
        "\n",
        "  #remove those that do not meet the equations' conditions\n",
        "  result = match(result) \n",
        "  \n",
        "  #keep only one triangle with the smallest delta\n",
        "  result = result[result['delta'] == result['delta'].min()]\n",
        "\n",
        "  if len(result)>1:\n",
        "    result = result.head(1)\n",
        "\n",
        "  if len(result)>1:\n",
        "    print(result)\n",
        "\n",
        "  return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Lil5n7fj-f7",
        "colab_type": "text"
      },
      "source": [
        "The algorithm tracks $n_-$ matches by applying an iterative filter on $logM$. In each iteration, the mean and standard deviation of $logM$ values are computed for same sense triangles and matches are discarded if they receive magnifications more than $z$ standard deviations from the mean value, where\n",
        "\n",
        "\\begin{equation}\n",
        "z = \n",
        "\\begin{cases}\n",
        "1, \\text{ if } n_- > n_+ \\\\\n",
        "3, \\text{ if } m_F < 0.5m_T\\\\\n",
        "2, \\text{ otherwise }\\\\\n",
        "\\end{cases}\n",
        "\\end{equation}\n",
        "\n",
        "We use $z=2$ in our case"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nv_g_i4h2HA8",
        "colab_type": "text"
      },
      "source": [
        "# Final algorithm "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YYPG6HEkbpwT",
        "colab_type": "text"
      },
      "source": [
        "## Watershed"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SCWeGC4Kbs5k",
        "colab_type": "code",
        "outputId": "7efa1bdd-c1dd-4e4a-b742-82b539f953e3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        }
      },
      "source": [
        "img = cv2.imread('/content/drive/My Drive/citrus4.jpeg')\n",
        "gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n",
        "ret, thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\n",
        "\n",
        "# noise removal\n",
        "kernel = np.ones((3,3),np.uint8)\n",
        "opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 2)\n",
        "\n",
        "# sure background area\n",
        "sure_bg = cv2.dilate(opening,kernel,iterations=3)\n",
        "\n",
        "# Finding sure foreground area\n",
        "dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)\n",
        "ret, sure_fg = cv2.threshold(dist_transform,0.01*dist_transform.max(),255,0) #change the parameter 0.01 kuti uwane correct sure bg\n",
        "\n",
        "# Finding unknown region\n",
        "sure_fg = np.uint8(sure_fg)\n",
        "unknown = cv2.subtract(sure_bg,sure_fg)\n",
        "\n",
        "#Marker labelling\n",
        "ret, markers = cv2.connectedComponents(sure_fg)\n",
        "\n",
        "# Add one to all labels so that sure background is not 0, but 1\n",
        "markers = markers+1\n",
        "\n",
        "# Now, mark the region of unknown with zero\n",
        "markers[unknown==255] = 0\n",
        "\n",
        "markers = cv2.watershed(img,markers)\n",
        "img[markers == -1] = [255,255,255]\n",
        "img[markers != -1] = [0,0,0]\n",
        "\n",
        "plt.figure(figsize=(12,6))\n",
        "plt.axis('off')\n",
        "plt.imshow(img)\n",
        "plt.savefig('/content/drive/My Drive/tt1.png')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0hEtLC70nOcg",
        "colab_type": "code",
        "outputId": "2bdc8824-f75e-45c5-c475-d191ba28f02f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        }
      },
      "source": [
        "img = cv2.imread('/content/drive/My Drive/citrus5.jpeg')\n",
        "gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n",
        "ret, thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\n",
        "\n",
        "# noise removal\n",
        "kernel = np.ones((3,3),np.uint8)\n",
        "opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 2)\n",
        "\n",
        "# sure background area\n",
        "sure_bg = cv2.dilate(opening,kernel,iterations=3)\n",
        "\n",
        "# Finding sure foreground area\n",
        "dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)\n",
        "ret, sure_fg = cv2.threshold(dist_transform,0.01*dist_transform.max(),255,0) #change the parameter 0.01 kuti uwane correct sure bg\n",
        "\n",
        "# Finding unknown region\n",
        "sure_fg = np.uint8(sure_fg)\n",
        "unknown = cv2.subtract(sure_bg,sure_fg)\n",
        "\n",
        "#Marker labelling\n",
        "ret, markers = cv2.connectedComponents(sure_fg)\n",
        "\n",
        "# Add one to all labels so that sure background is not 0, but 1\n",
        "markers = markers+1\n",
        "\n",
        "# Now, mark the region of unknown with zero\n",
        "markers[unknown==255] = 0\n",
        "\n",
        "markers = cv2.watershed(img,markers)\n",
        "img[markers == -1] = [255,255,255]\n",
        "img[markers != -1] = [0,0,0]\n",
        "\n",
        "plt.figure(figsize=(12,6))\n",
        "plt.axis('off')\n",
        "plt.imshow(img)\n",
        "plt.savefig('/content/drive/My Drive/tt2.png')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAFUCAYAAADvbtLzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydd1hTd/v/3yc7QNgyQkAQFCeuOqvUVbd1a9VqtXa4nqe2T+t61D6ttdtqtda22rpwY93ausWFE2SICMgKM8yQEAhJ7t8ffsmvFBcKnATO67re16UnyTlvTs45+Zz73Pf9YYgIHBwcHBwcHBwcNYfHtgEODg4ODg4ODmuFG0hxcHBwcHBwcDwn3ECKg4ODg4ODg+M54QZSHBwcHBwcHBzPCTeQ4uDg4ODg4OB4TriBFAcHBwcHBwfHcyJ4yutUVlaGlJQUVFRU1IuhxgyPx4O3tzdsbW2RlpYGjUbDtqWnIpFI0LRpUxiNRqSkpMBgMLBtiVXEYjF8fX0b7P5gGAYKhQL29vZIT0+HWq1m2xJ4PB58fHxgY2OD1NRUaLVati3VGk5OTvDy8kJ+fj6ysrLYtmMVMAwDuVwOJycnKJVKFBUVsW3pmRGJRPD19QURcb+7j0AqlcLX1xfl5eVITU2F0Wis820KhUL4+vpCIpEAAPOo9zBP6SNFcXFxeOONN5CdnV0XHjn+hlgsxoYNG9CrVy+8/fbbCAsLY9vSU2nRogV27NgBlUqFadOmIS8vj21LrNK8eXPs2LEDBQUFmDp1KlQqFduWahWBQIAffvgBQ4YMwezZs/HXX3+xbQlSqRS//PILunbtihkzZuDq1atsW6o1Xn/9dXz77bfYvHkzPvnkE3B9/54Oj8fDV199hYkTJ+L999/HwYMH2bb0zPj6+iIkJAR6vR5TpkzhBs//oF27dggJCUFSUhJmzJiB4uLiOt+mXC7Hjh070KJFC+AxA6mnRaRQUVGB7OxsZGZm1rY/jn8gFotRVlYGIkJeXp5F73OxWIwWLVpAJpMhJiYG2dnZSE9PR2FhIdvWWEEkElXZH7m5uUhPT0dBQQHb1moVgUAAnU4HIkJ+fr5FHKNSqRRlZWUwmUwWf97UlKKiIhARNBoNMjIy2LZjFTAMA61WCyJCQUGBVR0PDMMgIiICfD4fzs7OKC0tRUJCQoOLbD8vMpkMt27dQkFBAZo0aQKj0YjExESYTKY62yaPx3vq/n/qQIqD41F4eHhg06ZNMJlMeOedd6BUKuvl7sBS8fDwwMaNG8EwDN555x2kp6c36v3BwcFRc7KysvD2228jMDAQv/76K7KysjB58mTk5+ezbc0iSEpKwuTJk9GlSxds3rwZN2/exIwZM1BaWsqqr6cOpGxtbdGtWzckJycjJiaGGxlzAAD4fD6cnJxQUVGBoqIiq8pDqE1EIhHatm0LhUKBzMxMaLVa5OTkNNj9QUSIi4uDu7s7PDw80LNnT9y9e5eVv5dhGLRs2RKenp7IzMzElStXGux+/ye+vr7w9vZGUlKSVUVcOJ6MyWRCYWEhSkpK4OTkhLKyMvB4XE1YJRKJBC1atICbmxsSEhKQlpZWp9GoZ+WpAylfX19s2bIFN2/exPjx4xvcowoOjhfByckJa9euhb29PaZNm4bExMQGlez8T4xGI7777jv8/PPPWL9+PZYvX4433ngD58+fr3cvAoEACxcuxKBBgzB79mycPXu2Qe/7vzN16lR8+OGHWLRoEX755Re27XBw1Av+/v7Ytm0bUlJS8NZbb6GgoABlZWVs23r6QKq0tBS3bt1CWloagoODkZGRgdu3b9dLtjwHh6XD4/FgZ2cHW1tblJaWWkWl5YvAMAyaN28OhUKB3NxcXL9+nbVHmCaTCffv34eLiws8PDzQpUsX3L59u0Hn6TVr1gzNmzeHUChEeHg4HB0dMXDgQMTGxjbqHKqAgAD4+/sDeHiMqtVqnDx5kiuSamBotVrcunULWq0WnTp1QkZGBiIjI9kfjxDRk0TR0dHk7+9PvXr1orS0NDp+/DjJZDICwKmWJRaL6eDBg1RSUkIDBgxg3c+T1KxZM7p//z7FxsaSQqFg3Q9b8vT0pMjISEpKSqIWLVqw7qeuJRAIaPPmzZSfn09jxowhqVRKPB6PNT8ikYicnZ3p4MGDlJmZSb169WJ9H9Wm3nrrLTIYDLRmzRoCQB999BFpNBpavHgx2djY0OrVq0mtVtO0adNY98qmli1bRhqNhjQaDanVanrvvffIxsaG+Hw+696eR23atKH09HS6fv06NWnShHU/liIej0dSqZT69etHmZmZdOjQIbKxsanTbSoUCoqNjaX/45FjpadGpEwmE3Q6HfR6PaRSaWUvBQ4OjkZGx44d0axZMxQUFODUqVNIT0+HTqdj1ZNer4dGo8H169dRVlaGtm3bwsHBAVeuXGkQkamUlBQcOHAAWq0Wo0ePhlQqxV9//YX4+HiUlpaCYRjY2NhAIGicdUMtWrRAmzZtwOfzza04iAhJSUmsJyC/CGq1GidOnAAADBgwAEqlElevXm30Ocr/HI+IxWK2LQHgqvY4ODiegcpqxGnTpuHdd9/F4sWLLaZZoF6vxzfffANHR0fs3r0brVq1wsiRI3Hz5k22rb0w58+fx6VLlzB79mzs2rULq1atwqRJk9h/lGEhvPbaa/j888/x+eefY9KkSebl1j7gUCqVmDt3Ljp37ozQ0FDcu3cPY8aMsYgGuBzVeeaBVF5eHvbs2QODwYBx48YhNTUVFy5c4E7oWoBhGLz88svw9/dHYmIicnNzuUZsHBbHjRs3YGNjAy8vL0ycOBHAwz5zFy5cYP14NRgM0Ov14PP5EIlEDabSyWQyQa/X4+7du9izZw8iIiKg1+vNr9+4cQMhISFo0qQJpkyZgsuXLyMlJYU9w/VEYGAgunbtCqlUij179iAqKqrKfrF2iAgVFRXIycnBgQMHYDQaMXbsWO539//Izc3F7t27odPpMGHCBCQnJ+PixYvsVfA9LUfqzp07JJfLCQDx+Xzq168fFRQU0OHDh0kikbD+zLQhiM/n07Zt20ij0dCoUaOs4rk+lyP1UI0pR4rH45FYLKaQkBCqqKigiooKKiwspP79+7PuDQDZ29vTuXPnSKVSUdeuXVn3U5tiGIb4fD4xDFNtuVAopE2bNlFpaSlNmDCBda/1odmzZ5Ner6cvv/zykfulIYnP59Mrr7xCeXl5dOTIkTrPCbIW8fl8GjRoEBUVFdG+fftIJBLVyXZqJUfq7xiNRphMJvD5fPB4PDDMI7ulczwHPB4PfD4fJpPJKu421Go1du3aBXt7e4wePRqZmZk4duyYRZSictQNJpMJFRUVOHv2rPkRg8lkQseOHeHj44Pjx48jJyeHZZcNEyJ65HWhZ8+eaNeuHbKzs/Hbb78hKSmJBXd1j7+/P/r16wc+nw8AcHZ2xqZNm3Dt2jWruF6+CEajERkZGdi6dSsMBgOmT5+OxMREnD592iJ6KLGF0Wh8OIgRCFiPQHM5UhzPRV5eHv73v/+hVatWOH78OHJzcxEWFsYNpBo4JpMJv//+OzZv3gwAsLOzQ2hoKDp37ox79+5xA6l6Zty4cZg3bx7ee+89bN68ucHOxdepUyesW7cOQqEQAPDTTz9h3rx5jWYgkZiYiI8++giDBw/G3r17ceLECZw7d67R/P2WDjeQ4nhuKsOaXHSy8VH5g01EYBiG1e9fIBBgxIgR8Pf3x5UrVxAWFsZ6zlZd06tXL3Tr1g1qtRqrV69GdHR0gxxE+fn5YcSIEZDJZFi3bp15+ZUrVxrdIKLyesv2+WYJeHl5YdSoUbC3t8dPP/2E2NhYViOT3ECKg4PDqhEKhZg5cyZ69eqFkSNH4sKFC2xbqnOGDBmCxYsXY/78+Vi7di3bduqMVq1a4csvv8SRI0cwdepUi6kU5WAXPz8/rFixAtevX8fYsWNZn9GAG0hxvBB5eXlYs2YN7O3tMXv2bKSmpmL37t0oLy9n2xpHPaDX6xESEoIrV67g1VdfRffu3bFr16566SjN4/EwZswYtG7dGjdv3sTly5eRmppa59u1BM6ePQuDwQAnJycsXboUR48eRWRkJNu2ODjqFA8PD0yePBl2dnZYu3YtkpKSLKJakxtIcbwQKpUK33//PTp37ozjx48jPj4eBw8e5AZSjQS9Xo9t27bByckJR44cQbNmzXD+/Pl6GUjx+XxMmDABw4YNw/jx43H8+PE636alcObMGZw5cwZr1qzBvHnzkJmZyQ2kOBo8crkcCxYswP379zFixAjWpqf6J9xAimXGjBmDrl274t69e/jvf/+Lu3fvsm3puVAqlVixYgXs7e2xaNEiJCQkYPv27VwovpGg0+mwYcMGKBQKjBs3DoMGDcJvv/0GlUpV69tiGAbjxo1D586dERUVhatXr+LevXu1vh0ODg7LwM3NDTNnzoSdnR1Wr16N9PR0iypseq6BVENMamQDHo+HQYMGYcaMGZg+fTp27tzJtqXnJicnBz/++CN69eqFw4cP49q1a9izZ0+jGEhx5wNQVlaGHTt2wMPDA8eOHYOzszMOHDhQZwOpIUOGYMqUKZgyZQpCQ0NrfRscHByWg6urK2bNmgWVSoWhQ4ciNzeXbUtVqPFAKiEhAR9//DGcnZ3x9ddfIyIiAlu3bm10FRTPy7BhwzB48GDz/9PS0vD+++83iOksACApKQkLFiyAs7MzvvzyS0RFRWHz5s0NrteLjY0NZs2aBW9vb2zfvh0qlcriTu765O/7Y+fOnVCpVFwrhHogNDQUCQkJaNasGdasWYNt27bh9u3bbNvi4HghHBwcMGfOHMjlcgAPUwi+//57ZGVloaSkhGV3j6Amnc3/riFDhlBJSQnt3r2bxGIx8Xg84vF4DbrD7IuIYRji8Xj02WefkcFgIIPBQHq9nt5++23WvdWFBg4cSGq1mkJDQ0kikTSo44JhGGrSpAldunSJ0tPTKSgoiHVPbMvJyYkuXrxISqWSOnXqZL4e1NZ1ofL84fF4JBAI6LfffiOdTkdjx45l/W9nWzwejzZt2kTl5eU0ceJE1v3UpoYOHUparZZ2795NQqGQdT9sa/DgwaTRaGjfvn0Ndn8wDENeXl4UGRlp/q2Mjo5mbQaNWu9s/neio6MxZ84ceHh44KeffjL3tTh9+rRVP6KqKwYPHozx48cjJSUFb7/9NgCAiHD16lWWndUNsbGx5uPjxx9/RHh4OH777TerfwwmkUjwr3/9CwEBAdi7dy9ycnKQnp7Oti3W0Wq1+PLLL6FQKDB9+nTY2dlVeT0tLQ2rV69+7uTQsWPHYujQoQAenjf379/He++912AiuRwcHICtrS0++OADKBQKbNy40dzWoKioCAUFBSy7ewLPG5Gq1Lhx40ir1VJ5eTmVl5fTDz/8QEKhsJp4PB7rI102xOPxSCgU0oIFC6i8vJwWL17Muqf61MiRI6mkpIS2bNlCEonEqo8LPp9PTk5OdPLkScrKyqJu3bqx7snS5O7uTteuXTNfDyp18+ZNUigUNZ5HsvL8+fLLL83r0ul0NG3aNNb/VksRj8ejX375hbRaLU2aNIkEAkGDiQBzEamq+mdEimEYEggEj/zNtbbrLJ/PJ3d3d7p06RKlpKRQ27ZtWfcE1HFEqpJr167hzTffNM914+/vj+3bt1d737Zt2xpVeXIlr776KmbMmIH79+9j6tSpiI6OZttSvXLz5k1Mnz4dfn5+2Lx5c7WOvKGhoVaRLCwUCjF//ny0b98ehw4dwvr165GYmMi2LYujuLgYS5cuhZOTU5XlDg4OWLlyJVJTU/HNN99Ao9E80/pGjRqFCRMmICYmBlOnTgUAEBFu3LhR696tFZPJhI0bN+Ls2bPo0qULhg4ditWrV3O5Uo2A3r17Y9asWU+da27Tpk04ffp0PbmqOVKpFB9//DECAgIQEhKCjIwM64r0v2hE6p+aPXs2abVaKi0traL58+eTRCKpJmsYKddEPB6vyt83b9480mq19Pnnn7PujU1NnjyZSkpKqh0Xn3zyCUkkkhpHKupTQqGQHB0d6Y8//qCcnBx65ZVXWPdkbWrfvj1lZmbS5cuXydnZ+Zk/t3TpUjKZTLRw4ULW/wZLl0AgoK1bt1JBQQGNHDmyQVxfuYhUVQ0cOJDy8vJo9+7dZG9vTzNmzHjkdfXv0mq1NGvWLIu9zopEImrSpAmdPHmSlEoldenShXVPf1e9RKT+yYkTJ5CWllZlGcMw6NGjB/bt21dluV6vx9dff43r16/Xtg3W6NGjB/7zn/+YJ9eMiYnBxIkTG3304sKFC5g4cWK1iNRLL72Effv24bfffsPBgwdZcvd4+Hw+5s+fj549e+L06dP45ZdfEBMTw7YtDo5qGI1GrFmzBn/88QdeffVVTJ48GStXrkRUVBTb1jhqiYiICLzxxhto3rw5tm3bhsTEREyePPmJVfMMw6B3797YvXs3Vq9ebVFTKIlEIixcuBAdOnRAaGgoUlJSkJCQwLatGlPrA6mUlBSkpKRUW/7yyy/jlVdeqbKssvfM3bt3odPprLpEns/nQyqVwtvbG8HBwRCJRACA+Ph4HD16lGV37JORkYGMjIxqy4OCghAcHIwLFy7Azs4O5eXltd57qvK7MRgMz9TETSwWmwfCQqEQQUFB6NmzJ3799Vf89ddfteqNg6O2ICJEREQgLi4OU6ZMwcsvvwy5XI6kpCTodDqrbFFjMBig0WhgMBhgZ2f32GuDXq+HXq83n7t1cR2xBFQqFf7880+IRCL06tULWVlZOHbs2FMHUsOHD8ewYcOwd+/eenRblb9fVyuRSCTo0KEDunfvjjVr1uDixYssuXsx6q2z+e+//45Tp05VWcbn8zFmzBjMmDEDy5cvR0RERH3ZqXU6d+6MTz75BMnJyXj99dfNB7ZSqWTZmWWze/duXLt2Df3798eBAwewdu1aHDlypFa30aVLFyxfvhxXr17FF1988dQB+9tvv43Ro0cDeJh/cvjwYWzatImLRHFYBXq9Hp9//jnkcjnGjx+Pd999F//9738RFxfHtrUac+vWLUyYMAFt27bFnj17HpsLtGXLFoSEhGDmzJkYPXo0Vq9e3aBzcq9evYpx48YhJyfHagbI77zzDkaNGlVlmcFgwB9//IEffvjBqvOH620glZCQUC1kJxaLMX36dAQFBUEulyM5ORkajQZGoxEymQwCQc3slZeXszYLtEwmQ1BQEAoLCxEdHQ2NRsP6jNTWQHJyMpKTkzFkyBD069cP+/fvr7V1CwQCyGQyeHl5oX379sjPz4eLiwsMBsMTP+fv748OHToAeHiib9iwwaLC4daI0WhEUVERSktL4eDggIqKiic21hOLxbC1tQUAFBQUWNR0EJaOyWRCVFQUHjx4gPfeew/t2rWDh4eHuZmhNUX+8/PzceHCBTg6OqJdu3bVIhqV+Pr6wtnZGc2aNUOHDh3g4+MDZ2dnAA8jdRqNpkFFqFQqFc6fP8+2jWdCKpVCKpVWua5WUlZWhu+//x5hYWEsuasdWJ1rT6/X47PPPoOHhwdmzJiBf/3rX/joo4+QlZWF77//Hs2bN6/R+v766y+sWLGClRH6rVu3MHbsWHTs2BGhoaH466+/8MUXX1jN3UJDJCgoCF9//TVSU1Px+uuvo02bNti/fz/4fP4TP3fgwAEMHz4cwMOLcGPPb6sNHjx4gKlTp6J58+bYuHEjYmNjsWjRIuh0uke+f9SoUXj//fdx6tQpDB8+vFreJcfT0el0WLJkCeRyOd59913Y2triww8/tMrj+dKlSxg1alS1HMtKhgwZgqNHj+LgwYN47bXXMH78eHNKhV6vx7Jly6z2sZG18+abb2LatGlVrquVmEwm3L9/nyVntQerAykiQnx8PJRKJebMmQNfX19zS/imTZvC19e3Ruvz8fGBp6en+Y5Lq9W+cDt5Ho8HJyenandCFRUVKCgogFAohKOjI3g8HtLS0tCiRQv4+PjA1dX1hbbb2CgpKUF2djYEAgHc3d1RXFz8wlEIe3t7dO3aFWVlZbhx4wYcHR3RtGnTp0Y6CwoKEB4e/kLb5qhKaWkpbt26BYZhIJfLodFo4OnpiYKCAhQVFUEikcDBwQE6nQ5qtRoeHh7o3r07Tp8+zX0Xz4nRaERcXBxycnLg6+sLHx8f2NjYsG3rucjPz0d+fv5jXw8ODoavry8KCwsRHh6OMWPGmH8/9Ho95HI53N3dUVhYCL1eX0+uOQDA29sb3bt3x86dOxvsuczqQKqSyjsnDw8PzJ8/H66urli1alWN70J79OiBQ4cOmSMOISEhWLVq1Qt5c3V1xfr16xEQEFBleWxsLObNmwd/f3+sXr0aMpkMAHDjxg2MGTMGKpWKi0bVgE2bNuHw4cOYNm0ajh07huXLl9d6jsPFixcxfPjwx97VVvKopHiO2uHu3buYMGEC2rVrhx07diA8PBwLFy5Enz59sGLFChw+fBiff/452zY5rIxt27bhr7/+QkZGBogIP/zwA0JCQgA8LBiZPXs2/v3vf+ODDz5oUFXiHJaBRQykTCYTkpKSkJeXBx6PBxsbGyQmJtY4OdLX1xcODg7miIO7uzt8fX1RVFSEoqKiGq2Lx+PB3d0dXl5ecHZ2hqOjY5XXXVxc0LRpUygUCjg5OZmnxKioqEBUVFSDeh5fH2RmZiIrKwsSiQTt27ev1tCxNnie44CjdiktLUVMTAzs7e0hk8nQpEkTNG3aFHK5HI6OjnBzc4Ovry8EAgFSUlK476sWMJlMyMrKglAohKurK7y8vJCTk/PUXEFrIjs7G9nZ2eb/K5VKc6GPWCyGi4sL2rVrZ77h5eCoTSxiIFVJSUkJPvjgAwiFwueqdjt37hyGDRtmjji89tprOHHiBH766SesW7euRutycHDADz/8ALlcjs8++wypqalVXg8ICMCvv/6KtLQ0TJs2DaWlpea/gRtEcXA8mcjISIwePRrdu3dHaGgorl27hpEjR6J///44duwYjh49iiFDhjzxcQ7Hs6FWqzF//nzI5XJ88sknEAgEePvtt6td0zg4OJ6PFx5IyWQyeHp6PvZxSV5e3jNfDE0m0wsllarVaqjVavP/DQYDAgMDzflKTZo0MVdyVEJE5moW4GEkysvLCx4eHpBKpaioqEBycnK1ikOhUAij0YjS0lIkJCQ885QXHDVDLpfD1tYWGRkZ5sHq05BIJFAoFHB1dUVSUhKUSqXVT5bc0Kg8b7y9vUFEUKvViI+PR5s2bUBEKCgoQHx8PNs2GwSV19WKigp4enpCJpOZ+9w1BogISqUSiYmJcHFxQUBAAJRKJVcJWk+oVCrEx8dDJBIhMDAQ2dnZ5snLK3MmbWxsanSNtzhedIqYYcOG0f379yk5OfmRmjt3Lmut3T/44AMymUz06aefEgBauHBhNX/x8fE0ZMgQ82dkMhnt2rWLIiIiaNCgQaRQKB45NYFIJCJvb2/y8PBoMBOEsi2GYeinn36iiooKmjJlCgmFQtqwYQPFxsZS7969n3k9HTp0oNu3b9Mff/xBrVu3Jjc3N+47slBJpVLy8fEhV1dXAkB2dnbUtGlTcnJyYt1bQ5OnpydFRkZSUlISNW/enHU/9Sk3Nzdq1aoVhYaGUkREBHXq1Il1T/UlhmHo559/poqKCpo8eXK9b9/R0ZF8fX1p1apVlJSUROPHjze/JhaLadOmTRQdHU3du3dnfV89SnU6RYxMJoOfnx/kcjnUavVjS8qdnJzQvn17ZGRkIC8v73k391yoVCpERkaCiNC+fXvY29tXy7kwGAzmPkMAzFUthYWFSE9Pf+wjRr1eb12TKloJSqUSUVFRsLe3R1BQEIRCIUpKSuDj44O2bdsiOTn5qf25xGIxfHx8UFRUhPT09Beu3OSoO3Q6XZUotEaj4aK7HLVObm6uuYeZt7c3xGIx25YaDVKpFI6OjjCZTCgqKoKHh4f591YkEoHP56OkpAS+vr7QaDR48OCB9UWmnjci1b9/f0pKSqItW7aQt7c3eXp6PlIrVqygjIwMevvtt+t9JGlra0uenp60fPlyysjIoIULF1bz5+3tTVu3bqWMjAzKyMig+Ph4GjZsGLm7u3OTZLIge3t78vLyok2bNlFKSgpNnjyZ/Pz8aP/+/RQXF0ddu3Z96jq6detGeXl5dPbsWZLJZKz/TZw4WYIac0QKeBjtPHXqFOXl5VGPHj1Y91NfYjsitWjRIsrIyKD58+eTXC6nDRs2mH9vk5OTacKECRQQEECHDh2imJgY6tixI+v77O+qk4iUvb09AgMD0bRpUyiVSqSnpyMzM/Ox3XLT09ORmpoKZ2dndO/e/ZHvMRqNiI+Pr5LfVBtotVpotVqzB6VSiaysrCrvEQgE5teBh3fEmZmZyMnJqVUvjQ0HBwcEBgY+dkqHSv5eXQM8zHPTarUQi8Xw8PCATqdDVlYW0tLS4OjoiICAABiNRty7d4/rHM/BwcHxBCorYrVaLcLDw+v1qZCXlxe8vb1hY2ODlJQU8+/v339vy8vLoVQqkZOTA5lMBg8PD+vM36tpROrll1+m5ORkCg0NJblcTnZ2dk8czUmlUnJxcaHvvvuO8vLyHqmUlBQKDg6usxGlVColZ2dnkkgkj3zdzs6OnJ2dydnZmZycnEggELA+CrZ29evXj9LS0h77nVdqwYIF1T7L5/Np+/btVFZWRqNHjybgYe6ar68v/fnnnxQXF0dBQUGP3TYXkeLEqbq4iFTji0itWLGCcnNzac6cOeTs7Ewikajetv3BBx9QXl4eLVmypMrvr62trfn31tnZmYRCIclkMjp79izl5eVRt27dWN9vf1edRKQ0Gg2io6ORn5+Ptm3bIiMjA3fv3n1sVZROp4NOp8ODBw8QGRn5yPfo9XoEBASAiHDnzp1aj0xVengcGo0GPB4P7dq1g4uLi9nTnTt3uPyaGuLg4ICgoCA0a9YMd+/efWoXcalUir59+yIxMRHp6ekIDAyEQqFAfn4+zp8/D5VKBeBhWwmTyYR79+5Br9ejbdu21brHazSaxx5jHBwcHH9HJBKhffv25t5SWq0Wd+7caRDVfH5+fvDz8wOfz8edO3mrES4AACAASURBVHeQlpaGgoKCevUglUrh7OxsrsKtpPJJ0d8RCoWIiIiAVqtF8+bNIRAIEBkZaT1PHWoakeLz+WRnZ0ejRo2inJwc2rx58zNFcMRiMclkskfK09OTjh07RikpKdSlSxdWRp1SqZRCQ0OpuLiYiouLKSkpyeKe1VqDevToQWlpaXTo0CFyc3N77HdeqU8++YSKi4tp3rx5xDAMff/991RQUEBvvvkmyWSyaseWjY0N+fn50aVLl8zfVaWuXLlCHh4eXESKE6dHiItIVY1Iubm5VbmO3Lhxg7y9vVn3WRtasmQJFRcX04cffkgymYyVfN8lS5aQyWSixYsXP9P7bWxsyMfHh86dO0f37t2j1q1bs74fgTqKSDk6OuKll16Cp6cnrly5gri4uGfq0VNeXo7y8vIqy3g8Hjp16gRvb2+kpaWhuLj4idGoyrnTSktLcePGjRo3vmzZsiX8/f0RExNjfkbLMAw6duwIb29v5OTkmGeh1ul06NChg3nuv9LSUly7dq1aNYGzszO6dOlijrxkZWUhIiKi0fYt4vP55j41Go3mqdUX9+/fR1hYGOzt7TFs2DDo9XqEhYUhNTX1kdHA0tJSFBQU4MaNGygsLKzyWn5+PoKDg6FQKB47SzyHZeDq6oqXXnoJeXl5uH37tnk6JR8fH7Rr1878voSEhAYxqSkH+xgMBoSHh6OoqAitW7eGQqFAQkKC+TpSVFSEl19+GRkZGbh+/Xq13ytrQiwWQyaTgYis5qlKaWkpNBoNJBIJ7Ozsnjq5vEVR04hUcHAwZWdn08GDB8nJyemFnrmKxWLat28f5eTk0KBBg0gikRCPx3vs+9u3b0/Jycl0+vRpcnR0rPH2VqxYQRqNht577z3zMqFQSCEhIZSXl0fDhw8nqVRKUqmUFAoFXbp0ibRaLWm1WoqOjiY/P79q6+zduzdlZWWZ3xcSEtKoq/169epFhYWFdOLECbKxsXnq+wUCAUmlUvr2229Jo9HQ7NmzSSKREJ/Pf+qxU/ldVapz586UlJREOp2OTCYTF5GyYPXp04dyc3Npz549JBaLzctnzJhBGo3GfD4tW7aMda8NRY09IgU87P/n6elJ58+fp+TkZOrSpYv5+tGuXTuKj4+nK1eukLu7O+teX0SffvopmUwm+uCDD1jzUNOIFABydnamq1evklKppHbt2rG+H4E6ikjl5eXhxIkTKC4uxqBBg5Camorw8PDnjsCIRCJIpVIYDAaYTCb06dOnWu5LJQ4ODggLC4NGo8GwYcOQnp6Oy5cvmysGfXx80LVr18dWihERjh49CicnJ0yYMAHAw4hUTk4Ojh8/DqVSac6lKi4uxoULF8wVZVqtFn369EGLFi0QFhYGiUSC4OBgeHl54cyZM+aIVE5ODsaMGYMHDx7gxo0bz7VPLBGRSITevXvDxsYGYWFh5s60lTg5OaF3797w8vLC0aNHcffu3Weay8tgMMBgMODOnTs4evQoEhMTnylH4VF3iyqVCidPnjTP06dSqTBixAikpaXhypUr3CTSFoCLiwt69eoFhUKBkydPQqVSYfTo0ebvpkmTJjh69Kj5/Xw+HxMmTEBUVBTu3btnXt6lSxf4+flVWXdFRQUuXbpkzqvj4Pgner0eJSUlCAsLg5ubG3Jzc8EwDIKDgyGXy3H58mXk5uZabTQqMDAQQUFBMJlM2Lt3r9VHc21tbREcHAyTyYSwsLAn5jqzSk0jUgzDkFAopOHDh1NRURHt2LHjuavcxGIxHTp0iNRqNfXv35+cnJwoLCyMysvLH6nr16+Tl5eXOSp2/PhxsrW1Na/v9ddfJ61W+9jPL1iwgEQiEa1du9a8rKSkhCZMmEBCobBa92uBQEBCoZCEQiEFBgZSXFwc3b59m7y8vKhz586UkZFBp0+fJhcXF/P7JkyYQCUlJbRp06YnRtesTS4uLnTp0iVKSUmhtm3bVnu9U6dOpFQq6dy5c+Tq6vrUiNI/xefzSSgUvvA++/t31r9/f8rLy6MDBw48tmKTU/2qe/fulJWVRX/99Rc5OTnRqFGjqLi42Hw+/vzzzyQWi83f4dKlS6m8vJw+/vhj8zp4PB5t3Lix2vmtUqlq1AG/sYmLSP1/CQQCEggExDAMNW3alKKioig6Opr8/f2tumr7P//5D5WXl9Py5ctr5Xr6IqqNiJSvry/FxMRQZGQkKRQKVv6OOolIubu7o3///nB3d0doaChu3br13NEoo9GIM2fOIDc3F+3atYOfnx9u376NxMTER76/Mm8mMzMT+/btg16vx+uvv26OSLm5uWH37t2PnfcvOjoaer0e165dg52dHYCHEZEHDx48Mt/q7xGVgoICHDp0CLa2thg+fDhEIhGOHj1q7sJa+XmTyWTu1toQEAqF6N+/P7y9vXHr1i3ExMTglVdeQWBgIE6ePAkej4eBAwfCw8MDx44dM3cef1xfscdhNBpr/JlH8ffvLCMjA3v37kVpaSkmT55sjnokJCTg8uXLL7wtjmfH2dkZr776Ktzd3XHkyBHcv38fpaWlSElJwe7du805bVevXoVerzdfU+7cuYMdO3ZAIpFg+vTpAB5GkfPy8rBjx44q2zAYDOjUqRMUCgVOnTpV7zMpWCpisRgDBgyAl5cXLl68iNLS0lqvjLY2/hktrzz+KioqnimSzhZeXl7o27fvY6uhbWxssGPHDkRGRtY4h9gSKC8vx7Fjx6BQKBAcHAyj0YgLFy6AiDBs2DBkZmbi1KlTlldZWdOI1CuvvEIFBQV05MgRsrW1feE5zBiGIQcHBzp58iTl5uZSz549icfjPVaVn+PxeDRw4EAqKioig8FABoOBtm/fTiKR6LGfrfTKMMwj1/k08Xg8CgoKopSUFAoPDyc3N7dqnx83bhyVl5fT5s2bG0RESiaT0enTpyk7O5u6detGCoWCIiIi6P79++Tv70+tWrWi5ORkunbtGrm7u1vc38zj8Wj48OFUUlJiPk42btxocT4butq3b09KpZIuXrxIrq6u1c7lf56jlao8V7/88kvz91deXk4zZsyodn47OjrS2bNnKTs7m7XqX0uUs7MzXb58mdLT06lDhw7csf8PNW3alOLi4iguLo58fHxY9/MkDR48mNRqtflc+Ke++uqrR55HbOh5IlLAw+tB5e9MQkICBQYGUps2bSg5OZmuX79Obm5u9fp31EpEysXFBdOnTzfnxNjY2GD79u2Ii4urcuf4vBARysrKcPjwYURERCAzM/OZcllMJhNSU1Px22+/mTuh3rx505xr9bRtPo9vk8kElUqF7du3mztw/3NbiYmJ2LBhAzQaDWbPno3o6GhzJaC1wuPxwOfzzRUge/fuRZMmTTBixAgwDIODBw8iMzPzkfuDbUwmE5KTk7Fx40bzXWdxcTFmz56NqKgoXLx4kWWHDROZTIYRI0aY89XEYjH27duH9PR0lJaWVjlOnnTMVJ6rV69exYYNG8zL7t69W+1zZWVlOHToEKKiohAcHIzWrVvjyJEj9d4/hy14PB4GDBiA5s2bV1nO5/Nx+fJlc182SztHOZ6OXC7H0KFD4ezsjC1btjz2qcvVq1ct5vu9desW1q9fD6FQiLlz5yIsLAzR0dEAHh6rr776KgICAh75WYFAgDNnzkCj0aCgoACurq7g8/lPnSmDNZ4WkTKZTFV05swZsre3Z320a+l68803qaKigtatW8e6lxdRZcdZlUpVZZ67Zs2a0f379ykmJsbqeq+89dZbVFFRQT/88APrXhqqfHx86O7du+brxu3bt8nDw6Netu3q6krh4eGUnp7+yHy+hiqhUEg7d+6sds1WqVQW1y3akmQNEanevXtTYWEhHTt2rEpesDVo5cqVZDQaad68eeZlQqGQdu/eXe1YrZRSqawye0WrVq0oLS2Nbt68aZ0RKZVKhX379plnZH/w4IHVVjTUJzExMfjuu+9QXl6OBQsW4Nq1a7hw4QLbtp4ZgUCAkSNHIiAgAFeuXMH58+erzFNYVFSEjRs3wmg0Wl2+RVRUVJXv5urVq1xk6jkRCoUYPXo0fH19qyzn8Xg4cOCAOVcwKyvLfA2payqjzY+7a2+IDB48GEFBQUhMTMQ333xT5bXS0lJkZmay5MxysbW1xbhx4+Dp6Yk//vgDBQUFFn8tYxjG6noUhoWFgc/nw9nZGQsWLDAvv3//frVjtRK1Wo3c3Nxn3kbz5s3x2muv4d69ezh+/Hj976Oa5khxqpnmzp1LRqORvvrqK9a91ERSqZSOHj1KxcXF1KdPH9b91IXmzZtHJpOJVq5cyboXa5WdnR2dPHmy2h1lcnIyBQYGsuLJxcWFwsPDSalUNoqIFI/Ho02bNlF5eTlNnDiRdT/WIg8PD4qIiKAHDx6wdqw+qyojUsePH3+m/nyWqLVr15qvD+Xl5TRhwoRn/uzTIlKjR4+msrIy2rZtW40rxp+mOqna46gZ165dw//+9z/weDx8+umnOHPmjEXnTPF4PIwdOxZt2rTB9evXcfHiRSQnJ7Nti8PCqOzvFBgYiEuXLlWL6BUXF3NVcxxWQWOKXLLJ8ePHzT3eTCYTYmJinvmzKpUKq1atgoODA+bMmVPtOyMifPHFF2AYBsuXL8eNGzeq9KOra7iBVB1z8+ZN3Lx5EwsWLMBXX32FiooKix5I8fl8jB07FiNGjMD48eNx/Phxti1xWCACgQATJ05Ev379MGbMGJw+fZptS9WwtkcgHPXP8xYecdScP//8E3/++edzfTYvLw8//PADOnXqhOPHj8PNza3K6wcOHMCkSZMwfvx4bNmyBRs3bsSxY8fq7bvlBlL1xLlz5/DRRx9BJpPh22+/NS8PDQ3FtWvXWHTGwfHs8Hg8TJo0CR06dMD169dx5swZJCQksG2rClqtFmvXroWXlxemTJkCtVqNX3/9Ffn5+Wxbq3VGjhyJXr16ISUlBQsXLkRkZCTblqwGtVqN1atXw9PTEzNmzEBBQQF+/fVXFBUVsW2N4zEolUr873//g62tbZXlCQkJMBgMuH37NhYsWAA7Ozt88803uHDhQv1EprgcqfrVp59+SkajkYxGIxkMBnrnnXcsoudHpSqrKbRaLQ0dOpR1P3WpefPmkdFopJUrV1rUd2DJEggEtGPHDiotLaWRI0da9H6Ty+V0584dSkhIoObNm1u01+cRwzC0Zs0aqqiooBkzZrDux1pl6VV7DMNQcHAwFRQU0LFjx6w2R6o+NWvWLDIajfTtt9++8Lq4HCkL5OjRo1Wq35o2bYp169Zh69atDWpuPmvg/PnzmDNnDtzd3bF+/XocPnz4uUPPjQWj0Yjff/8dly5dQo8ePdCnTx/88ssvVebBsxSKi4uxcuVKeHh4YO7cucjPz8e6desaRMRh5MiRGDRoEDIzMzFv3jxcvXqVbUscdUDTpk0xd+5cMAyDpUuXIiUlBXq9nm1bHP+Ei0ixJ4ZhaMOGDaTT6WjKlCnE5/NZvWvm8XgkkUho165dpFaraciQIazvo/rQ4sWLyWQy0ZIlS1j3Yi0Si8V08OBBUqvVNGDAANb9PEl+fn4UFxdHd+7cIR8fnwbR2XvlypVkMpno3//+N+terF2WHJF66aWXKCcnhy5cuEAODg6s+7F0MQxDfD6fZs2aRXq9nr755psXXicXkbJwiAhbt27F1atXERQUhL59+2L9+vWIiIiody8Mw+Ctt95Cr169cOvWLRw5cgRRUVH17oODo7ZRqVRYvHgxPDw8sHTpUmRmZmLVqlUoKSlh2xoHB0ct0qNHD7zzzjvIzMzEzJkzcffu3XrZroX2W288hIeHY8eOHXB3d8f48ePh6+sLkUhU7yW5DMOgZ8+emDRpEtLS0rBz505kZGTUqwe2MBqN0Ov1YBgGIpHILIudjoBlBAIBRCKReb9ZetWTRqPBsWPHcPXqVQwYMAADBw6EWCxm29YLYTQaUV5ebj5muWO1YcEwDIRCIQQCASoqKlBRUWHx55kl4OfnhzfeeANOTk4ICQnBrVu36mW7XETKAjCZTFi/fj2OHTuGV155BWPHjsU333zDRYTqiUOHDiEpKQlBQUHYsWMHgIfRwl9++QVnzpxh2Z1lwePxMHfuXPTs2RMXLlzAtm3bzPNnWSpubm5YtmwZpFIpli9fjszMTKuPRu3Zswd37txBp06dEBISgp9//hlnz55l2xZHLaFQKLB06VIAwIIFC6BUKlFaWsqyK47Hwd3GWABEhBs3buDw4cPw9fXFyJEjq/XJqA/0ej10Oh34fD5sbGxgY2MDqVTa4O924+PjsX//fhiNRgwZMgRDhgzB4MGD0axZM9jY2JinOWnsiEQi2NnZoXPnzhgwYACSkpJw6NChGk3lUJ8wDAOJRAIXFxf06dMH7du3x9mzZ3H27Fmrn+YqNjYW+/fvh62tLcaMGVNtih6OZ4eIoNPpUF5eDolEAolEwpqXymPW1dUV/fr1Q6tWrXDy5EmEhYXBYDCw5staMBqN5knRbWxszBPV1zVcRIoDwP+Pih05cgQDBw7E1KlTATycp+uzzz5rFNGxXbt24fr16wAeXtD69euH3bt347vvvrPoJqr1AcMweO+99zBo0CCcOnUKISEhFt+zyNnZGStWrICTkxNWrlwJpVLZIHtJcbwYKpUK77//PhQKBT777DOoVCosX74chYWF9e7Fw8MDK1asgFgsxuLFi5GRkWHx8/9ZEmFhYZgwYQKCgoKwd+9e/PHHH/jtt9/qfLvcQMrC0Gq1UKvVEIvFsLe3h1arhdForJdtR0dHIy4uDuPGjUOPHj0APMwvkcvlSE1NBfBwwKXVamEymap8tjKKVfm6NZKQkGBuLsnj8TBmzBgMHjzY/LivsePv74/u3btjz549CA8Pt/hHDWKxGL169YKNjQ2WLVuGxMREti1xWCBlZWWIiIiARqPBf//7X+Tn59dbJOOf2NjYIDg4GOXl5Vi0aFGjyVOtLTIzM5GZmQkvLy/06NEDsbGxcHBwQFlZWZ1GoRv2MxsrQ6/X44svvsD06dMxZswYhISEoGXLlvXqwWg04ptvvsGoUaMwatQozJw5ExMnTsTBgwdx8OBBbN68+ZGPEfz9/bFt2zZ8+eWX1brOclg/RISffvoJ48ePR5cuXRAaGopu3bqxbYuD44Wp7CO3ZMkSLFmyBB9++GGD6DXWmDlx4gRGjx6NwsJCHDx4EK+//nqdbo+LSFkQRITY2FikpKTg448/RufOnWFvb1/vHuLi4hAXFwcAkMlkWLRoEYKDg1FcXIzMzEx4eHhUCzd7enqiVatWkEgkcHNzQ35+PheSbmBkZmZCrVZj2rRpaNWqFWQyGduWnojJZEJhYSEqKirg4OAAJycnFBcXV4umCoVC2NvbV6uULSsrg0ajqU/LHPUIwzBwcHCAu7s7WrZsCaPRiNu3b0OpVLJtjeMZqTx3KyoqqvzeFBYWIjY2Fl27dkWbNm3qPOeYG0hxPBNqtRoffvghMjIy8NFHH0Eul1d5PT09HXPmzIGbmxt+//133LlzB4sWLUJZWRlLjjlqE4Zh8K9//QsjRozA9u3bsX79eot/VJafn4+5c+fC29sbn376KUpKSvD+++9XS47v3Lkzvvrqq2pJxvv3768yLyZHw8LZ2Rlr1qyBi4sLVqxYgdTUVIstnOB4NJ06dcLXX3+N8PBwLFu2DBUVFQCAoUOH4uOPP8a5c+cwfPjwOn9Eyg2kOJ4Jg8GAu3fvIjU1FTKZDAqFosrr+fn5uHPnDvz9/eHm5gYvLy94eXmhsLAQBQUFLLnmqE0cHR0hl8tRVlaGzMxMc1VnQUGBRVbBGY1G5ObmQiqVwsXFpVoFqkgkgouLi/lYlUqlVT5fubykpISLrjZAeDwe3Nzc4OTkhIKCAuTk5NRbPirHi/HPc7dSldPneHl5QaFQQKfTmQuI6hJuIMVRI/Lz8zFnzpxqd+86nQ5FRUWIiYnB+PHj0bFjR+zatQuXLl3CwoULzXcKHNYJEWHt2rXYtWsXZs2ahfnz5wN4WNX5wQcfIDw8nGWH1XF1dcWGDRtgb2+PZcuWITU1FXl5eebX27Zti3Xr1uHBgweYNGlStcHggAEDcOzYMWzduhWrV6+ub/scdUxhYSHmzp0LHx8fLF++HOXl5Zg1a1aVuVA5LJM2bdpg3bp1SElJwaRJk9CuXTvs378fAsHDIc2ZM2cwbNiweoswcgMpjhphMBjMlW2PorS0FHfv3oWrq6s5EuDn54fCwkKoVKp6dPpiEBFUKhWSk5Nha2sLX19f5ObmWnylWl2SkZGB7Oxs6HQ6c0EBj8eDQqFAs2bNqry3oqIC2dnZrA6gGYaBVCqFRCJBWVkZjEYjfHx8zK97e3vDzs4OFRUViImJqfYYulevXmjXrh08PT3r2/ozk5+fj+TkZIjFYvj5+SE3N9dqq2brm8r+UTqdDmKxGDwer95nlOCoGSKRCJ6envD29oZMJoPBYEBsbCycnZ2r9I3SaDSIjo6uv27w3KTFlidbW1s6efIk5efnU48ePVj1IpPJ6OzZs6RSqahr167P/DkbGxvy9/enN998k2JjY+nrr7+2usli3dzcqGXLlrRx40aKioqivn37su7JEuTh4UHNmzen5s2bU1BQEO3Zs4fi4+Or6Ny5c+Tn58eqTz6fTz4+PtS7d286f/58NY/79++n9u3bk1wuf+Rk4bNnzyaj0VgrE5/WlZo0aUItWrSgH3/8kWJjY2no0KGse7IWubq60sGDB+nixYvUt29fatq0KQkEAlY9+fv70/379yk6Opq8vLxY30eWptatW9OVK1fojz/+oA4dOpCXlxcxDEO2trYUEBBgvi65ubnV2ja5SYs5WKO0tNQ87Yq/vz88PDys7m4vNzcX+fn5KCoqgtFohEKhQGBgINLT0xt1ZCo7OxvZ2dkAHva9UavV1bouMwwDf39/8Hg8pKWlsRKZMhqNSEtLg8lkQmlpaTWPGo0GSUlJ1SrzHBwcIJfLIRaLERcXh5ycnPq0XSNUKhXy8vJQWFgIg8EAuVyOli1bQqlUchWHj4HH48HHxwdyuRxCoRA6nQ4pKSnmXnmWhEQigY+PD8rLy5Genl6t4rSxIZFI0KxZMxgMBiQnJ6O4uBjAw/6LbBa/cAMpDo4nYDQa8dVXX+GXX37Bp59+ikWLFuGdd97BlStX2LZmEeh0OixZsqRazpyHhwdWrVoFg8GAadOmsVpSnpWVhZkzZ5rzJyopLy9/5GOw/v3747vvvsPhw4cxdOhQi080JyKsXr0av//+O5YtW4aPP/4Ys2fP5ubeewwymQyrVq2Cn58fPvroI9y7d89iq/VatGiBLVu2IDExETNnzrT6OSIbKtxAygIxmUxISEiARCKBQqFAu3btkJiYCJ1Ox7a1Rkl+fj60Wi3s7Ozg7e3N6lxclkZlLlklAoEAAQEBcHR0hFqtNucmsYnRaHymBGJHR0f4+fnBw8MDeXl5yMrKQlpaWj04fHHs7Ozg6uqK8vJy5OXlmauXOP4/PB7PHB03GAxQqVRQKpXIzMxk25qZ8vJyxMbGgs/no2XLlnBwcEBxcTGMRiOCgoKQnZ2N5OTkRheZkkgkCAgIgI+PD+Li4pCUlMT6daUKXI6U5YlhGHJ0dKSAgAD6888/KTo6mtq2bcuKl+fNkarU6NGjqaysjLZu3Up8Pp/1ffu8kkgkdOjQIVKr1dSvXz/W/Viq3Nzc6NSpUxQREUHdunUjZ2dnq8mNGzZsGKWlpdHGjRvJw8ODZDIZ656eRQzD0OrVq0mpVNK0adOoSZMmJBKJWPdlabK1taV9+/ZRfHw8DRw4kFxdXVnPifqn+Hw+ubi4UI8ePejOnTt05swZatmyJQ0ZMoQSExNp586dJJVKWfdZ32rRogXdvn2bzp07Ry1btiQnJ6dH5jXWhbgcKSuFiFBUVASGYSCTyeDq6sra3E8vSn5+Pq5cuYKioiL06NEDWVlZSEpKYtsWRx3B4/Hg7OwMJycnFBUVWVUPscqu/CKRCCqVyrLueJ9CTk4OkpKSYGdnh4CAANy7d4+LSv0fDMMgMDAQnp6e0Gg0SExMRGZmZpVWGJaC0WhEfn4+srOzkZSUZP53kyZN4OLiAkdHR6vLNa0N9Ho9kpOTUVFRgaZNm0IoFEKtVlvMOcrNtcdRp1y9ehVjxoxBZGQkDhw4gDlz5jTKCwEHR11R2eNr7Nix6N69O/bv348uXbqwbctiEIlEWLp0KbZt24bQ0FBMnjzZPAWWpZKamorp06fjww8/NCdUN2bS0tIwY8YM/Pjjj1i3bh2++uori5rTlYtIcdQpTk5OaNeuHezt7XHr1i2kpqbWX28PDtaxsbFBp06dquWVFRQU4M6dO+Y7Snd3d7Rt2xaZmZkW/yNniZSWlqKiogJCoRCOjo5WG8GuTRiGQZs2baBQKFBcXIzbt28jMzPTKgYmJpPJ4osc6pPK/VFaWgp7e3vIZDKLuiHnBlIcdUq3bt2wZcsWHDp0CBMmTODm3mtkeHl54eeff0bTpk2rLD9//jxef/11c9Vc7969sXHjRmzfvh3vv/8+N9jmeGH4fD4+/PBDvPbaa3jvvffw559/ctcfjjqBG0hZIHw+H127doVCoUBsbCwSEhJQVFRUrx54PB66dOkChUKB+Ph4KJVKFBYW1ng9KpUKZ8+eRUFBAfr27Yvk5GRERUXVgWMOS6CsrAwXLlyAm5sbunbtCgCIjIys1uMlMzMTgwcPNveXUigUOHfuHHQ6HV577TUkJSUhJiam3v1zNAzat28PPz8/FBUV4ezZs0hPT+c6vnPUHVzVnuXJ1taWjh49SllZWRQcHEwikajeKhQqJZFI6MCBA5Sbm0sDBgx4bg88Ho/EYjG9+eabpNFoaO3atfX+t9TW/uCq9p5NIpGIAgICKCoqiqKioqh58+YkFouraODAgZSXl0c6nY50Oh1t376dmzXctgAAIABJREFUbG1t6d133yWtVstKN/GxY8dadYWpUCikXbt2UWlpKQ0bNox1P2yJYRhav349lZSU0JQpU0gsFltN5ejj1Lt3byosLKTjx4+TjY0N637YUqdOnSg7O5vCwsLIwcGhXrbJVe1ZKQaDAZcvX0ZeXh7atm0LZ2dnXLhw4bkiQs8LwzAQCoUQi8UwGAyPrQCyt7dHnz59UF5ejvPnz8Pe3h7BwcHIz8/HxYsX4enpiZ49e8LNzQ2HDh1CZGQk99imgaPX61FUVISTJ08CeDg57D8nBM7IyMDhw4fNuVPXrl2DTqdDQkICDhw4AL1ej0mTJj32WLl27RqSk5Ofy5+TkxP69OkDsVhcZblcLkdoaCjCw8O5Y9TKiYiIgIODAzw8PDBy5EhcvnwZGRkZbNvi+D8YhkGPHj2gUChw6dIl5ObmIjg4GG5ublXep9Vqcf78eTAMgz59+kAul+PEiRPmCj6LgYtIWab4fD65urpSWFgYpaenU4cOHep1+1KplI4ePUrFxcXUp0+fx76vVatW9ODBAwoPD6cmTZrQyy+/TCqVio4ePUo2NjY0atQo0mg0tGXLFqu+M+QiUjUXn89/bGSHYRgSCARmVR4Xlcvnz59Per3+kSorK6Np06Y9t69OnTpRRkZGtfXu3buXbGxsrPYY5SJS/188Ho8kEgmFhISQWq2mESNGsO7pRdTQIlICgYB27txJarWahg4dSjKZjE6dOlXtnLx//z4FBASYf2euX79Onp6e9Rox5iJSVozRaITRaASfz4dAIKj3CgWDwYCTJ09CqVSiY8eO8PLywsmTJ81drGUyGQYPHgx3d3ecOHECFRUVGDt2LCQSCUJDQ6HRaDBlyhQ4Ojpi586dyMvLw9SpU3H37l2rnF7FaDTi1KlTyMrKQocOHSCXy3Hy5EmLnVrCEnhSjxciqjb33d+XExEEAgEiIyNx69atau+Ry+WYOXPmE7dfWlqKP//80xzJdXR0xODBg83R0X9Wtt26dQvl5eWNrmt0Q8RkMsFgMIDH40EoFFpUhVdNcHV1xaBBg+Dm5oY9e/bg7t27MBgM8PX1Rd++fZGUlISLFy9aVQS1d+/eCAwMRFpaGnbt2oXWrVtDoVAgKioKKSkpVd5bXl6OQYMGgWEYnDhxAllZWdBoNBbTP8oMF5GyXDk5OdHly5cpKyuLOnbsWO/bZxiGHBwc6MyZM5STk0NdunQxv+bn50fx8fEUHR1NPj4+9NJLL1FWVhZduHCBnJycaPDgwaRWqyk0NJQkEglNmzaN9Ho9rV+/3ipzpCr3h729PZ0+fZpyc3Ope/furHtqqHr//ffJZDLRihUriGGYKhIIBPT777+T0Wh8otLS0qhNmzbmdbZu3ZpSU1Pp+vXr5O7uXm291npcVoqLSFVVZdRDp9PRa6+9xrqf51HldfX8+fPk6OhoPkbHjBlDOp2Ofv/9d6vK5+PxeLRx40YqKyujCRMmkI2NDR0+fJgKCwupb9++1c7HZs2a0b1798y/M2yco1xEykoRCoUYNmwYfH19cfHiRZw9e5aVyAfR/2PvzMOiqr8//r6zD/uubAKKFiYgau6haaYpaGrmllhapmlqaVomamVaanvumEuGW5oFbuGOCyioiIgIKPu+w8AMw8z5/cGX+5PQUhy4M3Bfz3Oeh7ncmfu++7nnns85BKVSiUOHDuHGjRsYOHAg+vTpA6C2p9pff/2FwsJClJWVgYiwbds25OXlsd3UN23ahDt37kCtVoOIwDCMwT4ZArXboy5aIRDwtWwbg729Pfz9/ZGfn4/Q0FA4Oztj2LBhDRoKm5mZ4ccff8Tly5cbPG3XRQf/q86ORqPBK6+8gsGDBwOoLcx44MABZGdnQ6FQGNRT/OOg0Whw/Phx5OTkwNPTE87OzggNDeW0YXRz88ILL8DHx4f9fO/ePaxfvx737t3jUFXjyc3NxbZt2yASifDmm2+y1x9jY2Ns2rQJFRUVmD17Nm7evImzZ89yK/YxefA+UF1djZCQENy+fRvp6ekNzsmSkhL8+uuv0Gg07H1GL+EjUvpnxsbGdOLECSosLKS+fftyrgcA2djYUEREBGm1WtJqtZSUlETu7u6P/f0pU6aQWq2mDRs2GPSTv4mJCZ08eZIKCgr4iFQjrE+fPlRQUEBhYWFkYmJCI0eOpMrKSva4qrPvvvvuqZfl6OhIN2/eZH8zNjaWnJycON8GTW0ymYz++usvKikpoRdffJFzPc1p3377Lbu/q6uraeLEiZxr0oX5+vpScXExu24HDhwgiURCU6dOJbVaTevXr+dc4+OYQCCgoKAgUqlU9Prrr3Ou53HscSJSzH94eHTz5k288soretUhu6UiFArx6quvolOnTpDL5aiursauXbv0ogO9kZERpk6dCicnJwC1lal37NiBwsLCx/q+j48Pxo4di5qaGqhUKkRERODMmTNNKblJMDExweHDh9G1a1f4+fkhIiKCa0kGgZ2dHcaPHw9zc3PIZDJotVpUVVVBJBI1qHoOAJcuXcKRI0catSy5XI7XX38djo6OkMvlbPQwLy8P27dvb/EVo0UiESZOnIhnn30WVVVVqKiowP79+1v0NdzX1xf9+vWDVCplc9+0Wi0OHDjQIurWubq6YsqUKey5EhcXh3379sHLy8ugrqsMw2D06NHo3r07lEollEol/vjjjwZ15vQJJycnnDhxAp07dwaAh79S4SNS+mNSqZQOHz5M5eXl9NJLL3Gupyls5syZpNFoOKkTpAvjI1KNM29vb8rKyqKLFy+SlZUVDR48mMrKyujw4cMklUp1uixra2uKiIig9PR06tKlC+frzpWZmpqyx2qvXr0419OU9vnnn5NWq6V58+ZxroULmzVrFmm1Wvrqq6841/I4JhaLae/evQaRz6eTHKm2bdti0aJFqKioAFD7zvm3335rUBeGh+dxuHLlCgIDAyEWi7Fy5UqcPn0ap0+f5lrWfyISiTBhwgQ888wzOHfuHI4cOYL09HSuZRksycnJ+Pzzz5GSkvLQ0XuNQSqV4o033oCrqytCQ0NRWlqK3Nxcnfy2IaJSqbB9+3a4urpixIgRGDhwIHbu3ImcnJx68zk4OCAgIAAmJib1pt++fRv79u3TvxFSD+Dr64uXX34ZarUaS5cuNcgRwbogMjISS5cuZa+rp06dwpkzZ/DKK6+gb9+++Ouvv3D16lVONY4YMYLNsQVqo2rXrl1DQkICh6p0xH9FpP6Zu3D69GkyMzPj3EtsiVYXkSorK2uxEak6W7hwIWm1Wlq+fDnnWh7H6upIlZaW8nWkGmH/jEg1xTLMzMzozJkzlJeXRz179uR8nfXFrKys6PLly5SZmUleXl4N/l9XLfqf1/pDhw7pPFqoa1u8eDFptVpaunQp51r0wT766CPSarUUGBhIAOibb74hjUZDM2bM4FQXwzD0448/sseWSqWicePGcb69Hsd0kiOVlZWFzZs3sx2zZTIZ7OzscOfOHezYsUO/qosaKAKBAJMmTUK3bt2Qn5+P0tJShIaG6kVuVFOxcOFCrFmzBp999hk+++wzruX8J0KhEMOHD4e7uzvs7Oyg0WiwdetWpKamci3NIPD29mYrEvv7+6OoqEjny5BIJBg5ciTatWsHOzs7VFVVYfPmzQ0iMK0NmUyGUaNGwdHREW3atEF5eTk2bdoEgUCAmTNnwsjICHl5eQ0iT0ZGRrC1tUV0dDSCg4P1asRU//79MWbMGJSVlaG4uBiXL1/GlStXuJbFOd27d0f//v1hYWEBCwsLFBUVoby8HFZWVjAyMkJwcDCuXbvWrJpGjBiBl156CUVFRWx+olarxfHjx5GYmNisWhpDk+RIDRw4kIqLiykkJISMjIxaTA0WLk0oFNLu3bsNut7JkxjDMLRw4ULSaDS0bNkyzvU8ifE5Uo2z5ohI1VldjlRGRkarzpH6p7Vt25auXbtGSUlJ1KlTJ+rcuTPdv3+frl69SnZ2dg3mHzVqFFVWVtKuXbtILBbrzTWeYRiaPXs21dTU0KpVqzjXo4+2YsUKqqmpofnz5xPDMLRp0yZSq9U0adKkZtfy5ZdfklarpTlz5nC+XRpjTVJHKiEhAfPnz4etrS2+/fZbth7EpUuXsGvXLr16auHRP3x9fTF58mTk5ORg5syZDapW8/DwNA2lpaVYuXIl7O3tMWfOHBAR1q1bh6ysrIeOZLxx4wbmzJkDOzs7/Pzzzzh//jx+++03DpT/P3379kVAQADy8/Mxa9Ys3Lhxg1M9+kpISAgyMjL4UcXNxBM7UtnZ2di5cydeeeUVBAYGQi6X1/6QSIQ9e/awBcO0Wi3faoGnAZ07d8bbb7+Nb775Blu3buVaDk8zIBQKIRQKodFo2PYvTbkskUjEtgjhH+z+n6qqKhw6dAiurq6YPXs2ampqsG7dukcOmkhNTcUvv/yCyZMn44svvgARcf6Kr1OnTnj77bexceNGBAYGcqZD34mOjmYfUhmGYc89hmEgEomg0Wieej8yDAOhUPjIe71AIGBLj9TU1LRof6DRlc1jYmIwY8YMCIVCALXvEbdt28ZGqEJCQrBv3z7dqOTh4TFI7O3tsWjRIkilUixbtgwZGRlQKBRNsiy5XI4PP/wQHTp0wO7du5GVldWqqno/Lvn5+Vi8eDGI6LHrwPEYLkSEnTt34tKlS/D29saQIUPw008/PfXbgK5du2Lu3LmIjo7Ghg0bGjhK/v7+GDduHBISEvDmm28iKirqqZanzzTakcrKyqrnKE2ZMgXLly9nPdC0tDQcPnwYNTU1ej18lqd50Wg0UKlUICJIpdIG/687XkQiEeukA4BarW7yJ5q6aMajNAC1Q+wfXAeef8fMzAyvvvoqSkpK8Pnnnzdp4rdYLMZLL72ELl26YNOmTXzy8SNQKBQICQl57Pm1Wi3bzFkqlbLHfXNe2+uaDwsEAqhUKp2VzGgtXLt2DXFxcRg6dChGjhyJgwcPNtqRYhgGEokELi4uGD16NCQSCbZv395gn3Tp0gVjx47FsmXLEBwcrIvV0Ft01mvv7NmzmDBhAhuR8vLywr59+7B79278/vvvuloMj4ETFhaGCRMmwNPTs0HEkoiwefNm/P3335gzZw4GDhwIAFAqlfjqq6+aPB9iwoQJeO2117Bt2zYcOXIE7777LoYMGVJvHrVajUOHDuG7777D3bt3m1QPD48+EB4ezlZK37NnD3uN37dvH/bs2dMsGvr06YMPPvgA9+/fx6RJkwy2dx5XvPPOOxgyZAjCw8Oxf//+p4oOdenSBUuWLEF+fj7eeustuLi44Ndff23QfzQmJgbjx49HfHz808rXe3TmSKWnp9d71+7u7o7Bgwfj6tWrMDY2RnV1NV8qAbVPzRKJpN60unfWCoWixUfvUlJSkJKSAjc3N7aZbB1EhLCwMJiYmMDb25v9f2VlJX799VfcvXsXSqVS55Gpun3y7LPPYvDgwTh79ixMTEzg6enZQGNFRQV+/vlnnDt3TqcaWiparRYKhQJKpRJyuRwymQxKpZJrWTxPQEZGBjIyMmBjY4PBgwezjtSNGzdgbGzMzve4kSK5XA6GYVBVVVXvMwC2dVAdQqEQMpkM7dq1w6BBg7Bv3z6EhIS06HwbXSKRSCCRSODp6YkXX3wRe/fuRWhoaKN+SyAQQCaTwcHBAQMHDsT58+dx9OhR+Pn54cUXX2zQePzatWv466+/dLEaek+T9dpzdXWFu7s7XnjhBfTu3RubNm3CH3/88VRiWwJTp07F5MmT603TarU4evQobt26hdjYWOTn53OkrvlwcXFBx44d601jGAZDhgyBl5cXjh07hri4OAC1js6rr74KW1tbLFu2DLdu3dKplgkTJmDatGkIDw/H5cuXMXjwYHTr1g0nTpxo0KdLo9Hgxo0bKC4u1qmGloqRkRG6deuGdu3aYdy4cUhJScGyZctQXl6u82WZmZnhzz//RJcuXTBixAj+1Z6OcXR0hIeHB/u5b9++6N+/P4Dah6Cff/75P18Zmpub48svv4SlpSWWLFkCtVqN1atXw97eHgBw584dLF26lB1F2LNnTwQGBuL+/ftsN4Hbt2830Rq2PN59912MGTMGYWFhuH79OuLi4hr9et3DwwNffPEFiouL8ccffyAzMxOxsbGwtbVFly5dWGe4jvv37yM5OVkXq8Epj1NHSmcRqX9SF3kYOHAghgwZgqNHjzbVovQSiUQCIyOjBtM7dOiAHj161JtWU1ODoKAgg2iVoitSU1MbFLNkGAbDhg1D9+7d8csvv+DkyZMAam/G06dPR7du3WBvb4/09HRUVFQ0Onr3z33Tvn179OjRA8ePH8fJkycxePBgdO/eHbt372Y18DSOyspKXLhwAV26dEFgYCBMTExgbW0NImLbTvEYBpmZmcjMzGQ/+/j4sNcyIoKLiwssLCxQWVmJ6upqdj5jY2O2kbC1tTU8PT1hY2MDOzs7qNVqeHt7o127dgBqH5qsra3Z10SOjo7o3r078vPzcfr0af6txmMik8kgk8ng7u6OHj16IDg4GKdOnXqq3zQ3N8fAgQNx48YNnD9/nj1/c3NzkZub2+C6Whd5rtNSxz+Pj5ZAkzlSrZ1Bgwbhk08+afDe+O+//4a/v3+9aURkEBVemxoiwoYNG3Dw4MF620OpVGLZsmWwt7fHm2++iffffx8LFy5sdI7SkCFDsHjxYvYJ6syZM/D392cduy1btiAkJKRFPE3pC/fv30dAQAA6duyILVu2IC4uDkuWLKn3GofHsNi7d2+93navvvoq/vzzT6xatQonTpwAUDs447PPPkOvXr0A1Ca6r1+/HhUVFVi8eDFEIhECAwPZSvfOzs7YtGkTe0O+c+cOJk2ahOzsbD7B/AmYPHky3nzzTYSGhsLf379ZrmUvv/wyFi1axF5Xd+3aha1btyIgIABTpkwBUHuN//rrr3HkyJEm19Oc8I6UjpFKpTAzM4OTkxM6duzYwJE6dOgQLl68yJE6/Sc5ObnBSa/VanH79m1kZGRg7ty5cHd3h729PQoLC1FSUvLYkakH9427uzu7b44dO1Zvn9y/fx/379/X3UrxQKFQ4OrVqxCJROjWrRtbg0aXEBGKi4tRWFjIRr6e5PjgeTIezItlGAaTJk1C3759YWdnB6A2gmFubg43Nzf2NX5hYSESEhKQn58PW1tbSCQS3Lx5k32I8fHxgbOzM9q2bQtzc3OUlpYiMjKSd7gfEyMjI5iYmMDZ2RkdO3ZESUlJkzdy/uc9r86RqmvV1K5dO3b/a7VaODk5wdbWFmVlZVCpVE2qrbngHSkd079/f6xcuRJRUVHw9/dvMET+SXPNeP4fhUKBjz76CPb29pg3bx6kUinmzJnz2E6Pr68vvvjiC0RGRtbbN629F1tLQaFQYPHixbC3t8f7778PExMTzJkzh48scoBYLMann36K/v37Y+PGjfjyyy8B1KYxJCUlQa1WY+bMmRAIBMjOzma/l5CQgAkTJqB379745ptvuJJvsLz22muYO3cu/vrrLwwfPrxZ6qgNGDAAn3/+OSIiIuDn58deV4cPH46jR4/ijz/+wPDhwwHUOtwBAQF46623EBgYiLCwsCbX1xw0uSNVWlqK9PR0iEQiODk5sdOLiopQWVkJoHbj2tjYQCwWo6CgwKDfn1paWqJbt264c+cOrl+/zo8u0SFarRYlJSWQyWQwNTWFhYUFnJycUFVVhfz8/P+MPFhaWsLHxwe3bt3i900zIxaLYWtrCwsLC+Tk5CA/P1/n21+r1SIxMRFFRUVwdnaGk5MT23mBp3lhGAZubm7w8vJCXl7eQxvlPmxYfGVlJW7evAljY2OkpaWhoqICDg4ObORCoVDwAz0egrGxMSwtLeHg4AA7OzuUlpbqvDlxdXU1MjMzUV5eDgcHBxQVFaGgoIC958XGxuLatWusI1UXnSwpKWG1MAyDCRMmwM7ODg4ODnB0dERhYaHBj+Rtckdqx44dOHLkCKZOncq+N6+pqcEnn3zCJqDL5XKsXr0aHh4eeO+99xATE9PUsngMEBMTE6xbtw7u7u748ssvUVZWhk8//RQajQYzZsyolwjLo1+0b98emzdvRlFREaZNm4acnByDv3jyNB0xMTEYM2YMevTogQMHDrDFe//44w8sW7aMfwj6B/7+/li6dCn+/PNPDB06tElGfsfHx2PcuHHo2rUrgoODERERgQ8//PCR8+/duxenTp1CXl4eO42I8O2332LXrl2YO3cu5s6diw8//NDgy8k0uSOVn5+P/Px8lJaWsiM3BAIB7O3t4e7uDqDWkTIzM4NMJoOzszNKS0uRlZVlUJEpIyMjtG3bFiYmJkhOTq538PA8HQzDwN7eHra2tjA1NQXDMEhJSUFhYSG0Wi2MjY3h6uraIPpQVVWFrKwsyOVy2Nvbw9jYGPfu3UNeXh5flbyZkclk6NSpE+7fv4+kpCQ2ubgp0Gg0yMjIABGhTZs2DRw2pVKJ7OxsPnfqKbG0tIS1tTWA2nO0uroaycnJMDIyQvv27VFRUYHk5GT2zcOTUFlZiYSEBLRt2xYikYi9d1haWsLd3Z2NhvDUUlf5nWEYqNXqJjm2q6qqcPfuXVhZWUEoFMLc3BwdOnSAsbHxQ+95BQUFD91H2dnZKCgogKmpKTw8PGBiYqJzrc0OEf2bUUxMDDk4OBCApzJra2tq3749tW/fnjp27Ehbt26lpKQkSkpKotjYWBo7dix5e3tTSEgIXb58mTw8PJ56mc1pAwYMoFu3btEvv/xCnTp1IltbW841tRSTy+W0Y8cOiomJoZEjR5KLiwtJJBISCoXk5OREL7zwAl24cIE9nups9+7dZGxsTC+++CLFxcXRtm3bqGPHjmRjY8P5OrU28/b2pqysLLp48SJZWVk16bIEAgE5ODjQ888/TydPnmxwXBw+fLjJNbQGe//99+tt13nz5pG7uztt2rSJ7ty5QwEBAeTq6kpyubzRy5DL5eTq6sreO2bOnEmJiYm0fPlyztdfn8zMzIzc3Nzo448/pqSkJHr//febbFkymYxcXV1p0qRJFB8fT0FBQU98XRWLxbR3716qrKykESNGcL79/s2cnJwoLi6O/sdDfaVmSzYvLCxkG2QKhcJ6OVKVlZXIyMhAeno6rK2t0a5duwbVv/UduVwONzc33L59G/fv3+frnegAhmHg7OwMW1tbiEQiVFRUICMjo179qYyMDAgEApSXl8PMzKze90UiETp37gwnJycolUpoNBoYGRk16gmZp3FIJBK4urrCyckJSUlJSElJafJh7FqtFllZWaipqUFZWVmD/c0wDJ599llkZ2cjNTWVf030hFhbW8Pe3h6WlpbstiUi5OTk4N69eygsLIRCoUBWVhZSUlKeallVVVX1fiM7OxsKhQKmpqbo0qUL8vPzkZub+1TLaAmUlZWhrKwMubm5qKyshKWlJbp06YLs7GydN6ZWKpVISUmBi4sLFAoFioqKcO/evSeKghER0tPTER8fDysrK3h4eCAtLQ1KpRIuLi5s+Yvq6mqkpKTo/9up5opI/dMsLS3JwcGBHBwcyN7enqRSKVlZWdGlS5coMzOTvL29OfdEn8SGDRtGCoWC9u/fT2KxmHM9LcHEYjFt3bqVEhMTacyYMWRvb08SiaTBfEKhkNq0acMeT3Xm7+9PCQkJtHfvXnJzc6OAgABKSUmhdevWEcMwnK9fa7AOHTrQ5cuX6fTp0+Tl5UU2NjbNtu0FAgHZ2dk1OC4GDx5MsbGx9Pvvv5OpqSnn28jQbMaMGZSenk4rVqyot12NjY0J+P9ru0wm0/myjYyMyMHBgebNm0fp6en08ccfc7499MlMTEzIwcGBVqxYQenp6fTOO+802bJkMhk5ODiQpaVlo75vaWlJbm5utHfvXoqPj6c+ffqQhYUF/fXXX5SRkUEZGRl06dIlcnNz43Sb6lVE6p8UFxc3GH0hlUoRHx8PhUIBNzc3EBESEhJaTK0JnieDYRhYWVnB3t4eFRUV9YZJP4hGo3noU6m9vT2ysrKQlZWFzMxMKJVK2Nvbw8LCAgzD8HlSTYhEIkGnTp3g4uKCkpISFBYWIjMzU+dPx/+GVqt9aK6ivb097OzsUFRU1KDOW0tCIBCgY8eOMDU1rTddpVLh7t27/3ldtbCwQIcOHVBUVFSvxIipqSkcHR3BMMxDy7k87NquKyorK1FZWcme1yYmJujRowcyMzMfen1o3749LC0tkZycjJKSkibRpE+YmJjAwcEBQG30rim7ByiVyqcq51NcXMxGLh0cHODm5gaJRMLmtgJASUkJPDw8YGxsjISEBP1908NVROphxjAMWVhYkIeHB50/f56ioqKoQ4cOnHv5j2N8REr3JpFI6ODBg1RRUUEvv/zyE39fLBaTtbU1mZmZEQB6/fXXSaVSUVBQEAkEAs7XryWbk5MTXbp0iSIjI8nb25ssLCz0JgrYvXt3ys3NpXPnzpG5uTnneprKTExM6ODBg5SXl1fPoqKiqH379v/5/VdeeYXS09Np/fr1JBQK2ekLFiwgrVZLn332GWfrJpPJyMbGhj7++GPKy8ujDz/8sME8QqGQNm3aROnp6TRs2DDO90dz2Jw5cygvL4+WLVtGNjY2T5Wf1lxmZmZGrq6uFBoaSnfv3qXBgweTjY0N2djYUNeuXenq1asUHh7ebH7IP02vI1IPg4hQUlICuVzO1gnSdfVjntaDWq1GYWEhrKys0K9fP9jY2ODixYu4e/cuH41qIsRiMTw9PeHo6IisrCxUVVUhNzdXr6IBFRUVuHz5MkpLS9GzZ09kZ2fj9u3bLSZXSiAQwMPDA/b29igrK2tQr6m4uBje3t5wdHSsN72srAxxcXEwNTVF586d0a5dO9y9exc1NTXo378/u30kEgnOnz//1PlPT4NSqYRSqURaWhri4+NhbGyMF154od49U2HAAAAgAElEQVQ8QqEQarUaCQkJaNeuHfv/mpoaxMXFsY2RWwJ1o+DNzMxw+/ZtpKamGsyoxrKyMrZQa11+Y512U1NTmJmZwcjISL+jx/oUkaoze3t7un79Ot2/f586derEucf8OMZHpHRvTxuRqrOhQ4dSdnY27d69m6ytrQ3iKc1Qzc7Ojs6dO0e3bt0iHx8fMjEx0ZtIVJ0JhUIyNTWlIUOGUFpaGv3+++8t6piQyWS0d+9eSk9Pp1deeYXMzc3rWZcuXej69etUXFxcz44fP07m5uY0aNAgyszMpH379pGtrS29+eabVFBQwM63Zs0aMjc3J6lUyvm6SqVSMjc3p88//7zB+hQUFNCUKVPIzs6O9u/fz06/d+8e9ezZk3PturTp06dTcXExrV69Wm/2zZOasbExmZqa1ot+urm5UUJCAsXFxZGTkxMnugwuIlWHSqXCpUuXYGNjg27dusHOzg5RUVF6WcCvrqqri4sLTp8+jRs3bvDRDh3g6ekJZ2dnZGVlISws7KmerkQiEczNzSESiVBWVqa/79lbAAKBACYmJjAxMUFlZWWT5mg0Fo1Gg/LycmRnZ+PKlSsoKCjA4MGDkZGRgZiYGIM9fxmGgZeXF5ycnFBUVIQrV64gKysLpaWl9eaTyWSIjo5u0BopKysLAwYMQNu2bREdHY1bt26huLgYaWlpiIiIYN8O3L17t8FvcoVKpYJKpUJiYiIiIiLq/U+j0SA9PR3FxcW4desWmyumVCrRuXNnGBkZITo6GuXl5VxI1ykSiQTm5uZgGEZv9s2TolAoGkyrrKxEeHg45HI5evfuze6r4uJiXLt2TX8aWetjRIphGJLJZPTMM89QTEwMRUdHk7OzM+ce88Osf//+lJWVRX/++SdZW1s/dFQZb09mQqGQgoKCqKioiMaNG0dyufypcppGjBhBlZWVtHfvXj5a2MTWtm1bio6OppSUFHrmmWc41/NvJhAISC6Xk5+fH+Xn59Pu3bsN+vwViUS0Y8cOKigooFdfffWR503d9dXIyKieDRw4kDIzMyk0NJRsbGzYqIZQKKw3nz6eQ2KxuMH6GBkZsdENqVTKTnNwcKAzZ85QcnIyeXp6cq5dFzZr1izSarX01Vdfca5Fl1Z3rHbt2pXu3r1LFRUVVFFRQX///Xez5TcabERKKpWib9++cHR0xLVr11BWVqaX0Sig1jM+deoUSkpKMGjQINZDTktLQ3R0NMfqDI+uXbuiffv2KCkpQVhYGNLS0vjO7zxNglarRVVVFTIyMhAWFob8/Hz4+/sjJSXF4M7dbt26wc3NDYWFhQgLC0N6evojzxsieuj1NCcnB6dOnUJiYiLKy8vZUX0ajUbva6+p1ep/jTQ/OEJRJpNBIpFALpfrd97NY9CuXTt069YNZmZm+OOPPxAXF8e1JJ1Sd6wWFBTgzJkzsLGxAQDk5eVh2LBhDepLpaenIzo6uvmjyvoYkWrbti1FRkbS3bt3qXPnznr5BFRnDMOQRCKhESNGUHFxMSmVSlIqlbR161Z+ZFgjtuVPP/1ECoWCpkyZQhKJRCfbkI9INZ8ZUkSqzurO4XHjxlFZWRlt27atXp6GvptAIKDNmzdTeXk5TZw4kSQSSaPy0uq2g0gk4nydmtKsrKzo4sWLlJWVZXD1Cv9pb7zxBikUCvr5559JKpUa1HH7JMYwDInFYpJIJCSRSGjAgAGUm5vL3m/r7JdfftH5NjDYiBTDMJBIJBCLxaipqdHrnBYiQnV1NdLT0/H777+zFdkLCwvxxhtvsJ5xXFxcvW7c3bt3h4eHByIjI5GYmMiJdn2ie/fu6Ny5M8rKyrB//34kJyfrrJptZmYmgoODUVRUhIkTJyIxMRGXL1/WyW/z1CKRSDBo0CA4Ojri8uXLUKlUBjMqqu4c1mq1kEgkEIn08rL4rwiFQkgkEmi12kafN3XboaWjUqlw7NgxuLi4oF+/fmjfvj1OnTplMMcrAHYUooODAw4cOIArV6606HqLRFTPD8jOzsahQ4fYCuh15OXlYfLkyUhISEBkZGTzCtS3iJQhjtoDanMJ6mzq1KmkVCpJrVaTWq2m1atX15t37dq1pFKpaPr06Zzr1gdbs2YNVVdX08yZM0koFOp0pBfDMCQUCmn8+PFUWVlJW7Zs4aOFOjZLS0s6f/48ZWRkUPfu3Q3yyXjs2LGkVCpp586dBqVfIBBQUFAQqVQqGj9+POd6DMHq+jFGR0dTYmKiwURP62z06NGkUCho+/btOovcG5o9eL+tszfeeIOUSiX9/PPPOruHGExESiwWY+jQoXBycgJQO8rqzJkzUCgUelV/5r94sNdQQkICtm3bBoZhANT2DJo5cyb7/6qqKmzbtg1t2rTBjBkzcPr0aSQlJTW7Zq7w9vZGnz592M9VVVUICgpCXFyczjuXExE0Gg0SExOxbds2lJaWYsaMGY+c99KlS4iNjQVQGx0dPHgwXF1dERYWVq/PH099hEIhBAIBtFptk3SfbyqcnZ3x8ssvw8bGBtu2bcOVK1cMpqZUv3794OnpiZycHGzZsqVVXUOeBq1WC61WC4FAYJARyAd1azQagzledcnDrjFExF6HmhV9iEiZmJjQ33//TRqNhjQaDWVkZFDXrl31rv7MkxrDMKwtWrSIXT+NRkMffPABm9ugUqlo4sSJnOttTluwYEG97bFgwYJm2d8Mw9C0adNIrVbXW/6D9mDndJFIRMHBwaRQKMjPz4/z7aavZmlpyead+Pj4cK7nSWzo0KFUXl5OBw4cMLj6O9999x2p1WqaNm2awV8vm9vatm3LvvkwtIjU2LFjSaVS0fbt2w0qetrUNnnyZFKr1bRhw4bWE5ESCoXw9/eHu7s7rl69ipiYGABAeXk58vLyDLaeSx0P6r9y5Qq+/fZb9nN0dDS0Wi3CwsJQVlaG9u3bY968eQgNDUVycjIXcushEong7++P9u3b15teUVGBgwcPQq1WY+zYsdBqtTh48CCMjIwwZswYFBUV4fDhw7C3t8fIkSMhFosB1OaInThxAp6ennjppZdgbGxcb3tERUU1y/4mIsTGxuK7775jo4X/xMLCAgsWLGA/JycnY8OGDfDy8oKbmxsOHz6M9PT0JtfK03zUHQuGds1hGMZgtXONQqHArl270KZNG4waNYqNcOTm5uLQoUN6PVLx7t27+O6771BdXY358+fjxo0bOHXqFNeyWi9cRqSkUin9+eefVFpaSoMHD+bcm+XKRCIR7d69m6qqqmjkyJGc6wFAcrmcQkNDSavV1rOMjAzy9PSk9u3b0927d+nWrVvk5OTE9i87f/48mZub09ChQ6miooL9Xl3eycyZM0mj0dCaNWs4X8dH2ffff8/qrq6upvHjx5NMJmOP1RdffJFzjfpmhh6RqqiooAMHDhhcHanvv/+eampqaNq0aZxrMVRzdXWl+Ph49pyPjo6mtm3bcq7rcWzq1KmkVqtp/fr1nGvRB2tVESmBQIBRo0bB09MT169fR2RkZL3u4q0JPz8/+Pj4IDExEatWrUJCQgKnegQCAUaPHo3nnnsOUVFRDerpEBFGjx4NAAgODgYATJs2DQCwceNGAMC8efMAAOvWrWOflrVaLZYsWQKBQICVK1fi4sWLzbI+jeHEiRNsdWCNRoO4uDjU1NRg7969uH79Ol544QV0794de/bsQWZmJsdq9YOqqir88ssvcHZ2hr+/P1544QX89ttvKCws5FoaD8+/UlJSgg0bNrA1iogIM2bMQHp6Ovbs2aO3NQx5GhIbG4uVK1cCAJYuXYqIiAiEhYU1/YK5iEjV5Z1UVlaSv78/514sV8YwDG3evJnUajVNmjSJcz1AbYXgvXv3kkKhoOHDhzf4v4ODA8XExFBSUhK5u7uTh4cHpaWl0dWrV8nW1pb69+9PxcXFdOzYMTIyMmK/N2XKFJ0/KXBhJiYmdPLkSSooKKDevXtzrkffzBDrSPERKd4eNB8fH8rKyqKLFy+SpaUl53r+zfiI1MOt7s3H2rVrn/q39Coi5efnh/79+7Ofb9++jaioKNy+fbu5JOgdRIRDhw4hOTkZzz77LFauXIng4GC93iZlZWX4/vvvIRaLUVBQAKFQiFWrVrF91VJSUrB8+XJkZWXVq0lz7do1fPLJJwbdy4yHR98ICQlBVlYWXFxcsGrVKuzduxc3b97kWhYPDyf4+Pjg9ddfR3V1NT755BNcuXKlWZbbLI5U3RDyulc+arUaU6dOxd69e5tj8XrNiRMncPLkSezcuRNjxozB1atX9dqRqqiowPbt2+tN27RpE/t3RkYGfvzxxwbfi4uLa3HtC3geDe8sNw+nTp3CmTNnsGXLFkyZMgUxMTG8I6Uj+GPY8OjcuTMWLlyIrVu3YsWKFc22D5vckfLz88PQoUORl5eH999/H0Btvoyh9bJqSrRaLXbu3ImIiAj07t0bvr6+2LJlC+f5Ujw8/0QgECAgIADdu3d/6P9ramoQHByM/Px85ObmNrM6Hp7GY2dnh9mzZ8PIyAhff/010tPT9XrkHo/+0OSOVM+ePTFr1iwsXLgQGzdubJWFw/4LIsLJkydx4cIFBAcHY9CgQTh27BjvSPHoFQzDQCQSYciQIRg/fvxD58nJyYGfnx9u3LjRzOpaN0QErVYLhmHYoqg8j49AIIC1tTWmTJmCwsJC+Pn58Q8CBkrdsV93HjwYlaorF6Lr86PJHanDhw/j3r176NChA7Zu3YodO3YgPDy8qRdrUAgEArz99tvo2bMnLly4gIMHD+r16z2e1gfDMAgICICvry9iYmIeORKmqqoKaWlpzayudaPVarFjxw5cunQJPj4+ePHFF7Fhwwa2Lh/Pv2NtbY0PP/wQ5ubmWLNmDTIzMw2q7x7P/3P58mXMmDEDDg4O2Lp1K06cOIF9+/ax/x83bhyGDh2KX3/9FWfPntXZcnXmSDEMA6FQ2KDIYWxsLGJjY/H1119j8uTJuHDhAu9I/QOGYdCvXz+MHj0aAQEBCA0N5azFRl07lZqaGrYNgUaj4fMFHkCj0UCtVkMoFLIFR4kINTU1HCtrWvr27YspU6YgICCAz2/UMyIiInDt2jUEBQXBz88Pf/75J+9IPSYmJiYYM2YMAGDNmjUG8SDw4P1WrVYbVEumpuT+/ftIS0vDO++8g0mTJiE/Px/79u2DQCCAUChEjx49MHnyZERFReHChQs6u7fpzJHy9fXFzJkzH1kt+ubNm5gyZQqioqJ0tcgWg1arxYYNG3Ds2DEMGDAAo0ePxrp169h+b82JRqPBzz//jJCQELz00ksYO3Ys1q5dy0fI/odSqcSqVavg7OyMyZMns3l/+fn5WLVqFbKzszlWyNPaYBgG77zzDgYMGICrV6/i0KFDuH79OteyeJqQnj17Yu7cucjMzMRbb72FxMREriXpBf369cN7772H1NRUBAQEsOkxY8aMwWuvvYbY2FgEBATAx8cHu3btwsaNG3US2HlqR0ogEEAikaBDhw7w9/d/ZLPACxcu4MCBA0+7uBYJEeHatWu4c+cOxo0bB19fX+zcuZMzLVFRUbhz5w4mTpyI3r17Nxil15qpqanBuXPnYGVlhenTp6NXr14AgNTUVGzevBlFRUVQqVQcq+R5ErRaLZRKJTQaDWQyGYgIarWaa1mPhUgkgkQiQbdu3TB8+HAcPHgQBw8e5FqWQUFEUKlUYBgGUqkUEomkXukWfaLufuvi4oIRI0Zg//79OHDgAJ8T9z+cnJzg7++PXbt2ISQkBEQEmUyG5557DiNHjkRERAQOHDiAfv36wd/fHydOnMDVq1dRXV39VNvwqR2pvn37YsGCBUhOTsaECRMeGSbjIxqPRiAQYO7cuXjhhRcQFhaGrVu3cjaEWSgU4oMPPkCfPn1w/PhxbNiwgS9b8BDKy8vx6aefwtLSEgBgZmaGxYsXo7y8HMuXL0d+fj7HCnkelxs3buCNN95Ax44dsWvXLpw7dw4//PCDQdyc3nrrLfj7++PcuXOYOHEin+TfCPLz8zF//nw4Ojris88+Q15eHlasWIGSkhKupTXAx8cHH3/8MbKyshAQEIDU1FSDOE6bi/DwcIwfPx5dunTBvn372DdkUVFRGDduHOLj40FE2Lp1K06ePImBAwdi1KhRWLt2LS5fvtzo5TbakRIKhZDL5WjXrh18fX2RnZ2No0eP8ju1ETAMAx8fHwwdOhS//PILjh8/zqmWzp07o2/fvtixYwcuXryIqqoqzvToK2q1GpcuXWI/u7m5Yfny5dBqtZDJZBwq43lS8vPzcfz4cRgbG2PYsGEoLS19ZIqCvuHu7g5fX1+EhITg/PnzfDuTRlBVVYWzZ8/imWeewZdffonCwkK9O4fr7reOjo7sA/exY8cMJnLaXGRmZiIzMxNt27aFr68v+4bs0qVLOHLkCDvfrVu3EB8fj9deew3Dhw/Hr7/++lTLbbQj1aNHDyxfvhzJyckYP348MjMzeSeqBaDRaLB27VoEBwdj7NixmD59OgIDA/nEVR4ePSQoKAh///03+1pv9erVOh2NxKMfdO7cGStXrkROTg4CAgKQlZXV4ge3PA3Hjx/H/fv32Qeipu7l+8SOlEgkgqmpKRwcHODt7Y2srCycPXuW36mNxMjICMbGxlCr1SgqKuL0CcPY2BhSqRTZ2dkoKirCu+++Cy8vL5iamnKmyVDQaDRso2MzMzOYmZmhvLycH+3I06RkZmaiqKgI48aNg7e3N/uqmefxEQgEMDU1hampKcrKylBWVqY3QQGhUMjeb728vKBUKhEeHs6/JfgPsrKykJWV9Z/zKRQKFBcXQyqVwtLSEhUVFY26Bz+xI+Xl5YWvv/4aqampmDBhAnJycvihl42EYRi8//778Pf3R3BwMDZt2oS7d+9ypmX+/PkYMWIEgNpXVzt37sRXX33FFwZ9DHJzc/Huu+/CxcUFa9asQV5eHhYsWICioiKupfG0YGbMmIFx48Zh//792L59O5KSkriWZHDY2dnhu+++g1wux+LFi5GRkYHi4mKuZQEAOnXqhHXr1qGoqAjTpk1DdnY2P5hFR2g0GnzzzTcIDg7GG2+8gXfeeQdLlixBZGTkE//WEztSZmZm6NmzJ1QqFaKionjP+Clp3749evXqhQ0bNjRqB+qCuqcxZ2dnuLq6Aqgd5p+amoqrV69yosnQqKmpQUZGBuRyOezt7SESiSAUCrmWpRNMTU1hYmICtVqN3NxcPg9Hj3B1dUWvXr2wbds2zq4fho5UKkXXrl0B1PYE1ac6UsbGxujRowfu3LmDa9eusVFvHt2QnJyMtLQ0vPnmm3B1dYWjoyPs7OxQXFz8RJGpZmlazKPfzJo1C+PHj8f27duxceNGALVDgpv6vXJLok2bNli/fj0kEgkWLlyoV0+1T8u7776LSZMmYefOnfDz80NqairXknh4eHh0Qk1NDVauXIktW7Zgzpw5mD9/PubNm/dEtdie2JFSKpVIS0tDeXk5nJ2dUVxczA/1NnCcnJzg7e2NiooKPqm8kQgEApiZmUEoFKKiogLl5eV6k2fRWCwsLGBhYYE2bdrA3Nwcubm5/PGhZxQVFSE1NRVSqRQuLi7Iz8/nG+3y8DwBRISUlBTk5eXB1tYWnp6eMDY2fqLfeHj1zH/h5s2bGDNmDEJCQnDgwAF88sknEIn4wBZP6yY3Nxdvv/02vvjiC6xbtw4//fSTwSf+BgQE4NixY8jNzcXw4cNx7NgxriXx/INNmzbBz88PnTt3RmhoKAYMGMC1JB6eVgfvAbVibGxsYG1tjerqaiQkJPDv358CtVrNDretqamBTCaDu7s7jI2NkZGRYVDRKSsrK9ja2sLa2hoAkJeXxw840FPy8vJQUFAAuVyOTp06wczMjGtJBoNQKISzszOcnZ2RmZkJlUrFjz5vpTg4OMDW1hbFxcVITEx84tzvRo3a27p1K27duoVx48ahuLiYP/gMlGnTpmHmzJn46aefMHz4cBQWFnItyeBJT09HQEAAPDw8sGHDBty7dw/Tp083qG7yr7/+OhYtWoTt27dj2LBhLSbXi4fnQaysrLB+/XpYWVlh0aJFuHfvHnJzc7mWxdPMiMViBAYGYsCAAVi+fDkiIyOf+Dh4YkdKJpOhXbt2SE1NRXp6Oj9qr5E4ODjAzs4OlZWViImJ4eRmVVVVhZKSEggEAlhYWKC8vLzZNbQ06nKljIyMUF5ejoqKCoOpJWVjYwNHR0dYWVmhtLQUOTk5fGK5AUBESE9PR2xsLMzNzeHl5YWUlBSDct65QCgUwsHBARYWFsjLy0NmZibXkniamXbt2sHW1hZisRglJSXIzMxs1KjNJ86R4tEN77zzDkJDQ5GYmAg/Pz+cOXOm2TXs2LEDI0aMgKOjI0JDQzFkyJBm19DScHZ2xo4dOzB37lzMnj0bCxcuREVFBdeyHgs/Pz8cPXoUxsbGGD58OPbs2cO1JJ7HgIjw/fffY/To0ejTpw8OHz6Mnj17ci2Lh0evEQqFWLBgAQ4ePIjTp09jzJgxiI6ObtRv8TlSHFFcXIzU1FS2k3dNTU2z1+extLSEg4MD1Go1UlNTDeaGr49IpVJ4eHiwI6fy8vLYCvH6jq2tLTp06AAbGxukpKQgIyMD2dnZXMtqdgoLCxEZGYnS0lL06tUL2dnZBlMCpLS0FJWVlZDJZGjbti2kUinXkvSe6upq3Lx5E9bW1njmmWcgk8kQHx+P6upqrqU9EgsLC3Tq1AklJSVITEw0mGi3vmJhYYG2bduiqqoKOTk5jf8hIvo3o5iYGHJwcCAABIAGDhxIpaWlFBoaSnK5nJ3O25OZkZER2djY0Pr16yknJ4fGjh3b7BoCAwMpPz+f5s2bR1ZWViSVSjnfLoZq7dq1o4iICIqMjKQuXbqQubk5MQzDua7HsYkTJ1Jubi59//33ZG1tTUZGRpxr4sIkEglZWVnRtGnTKDc3l9asWWMw+xAAicVi2rNnD1VWVtKIESM416PvxjAMmZubk5eXF125coUuX75MTk5OnOt60Hr06EG5ubl07tw5Mjc3p8GDB1NaWhpt376dxGIx5/oM2YRCIe3cuZOUSiWNHj36kfM5OTlRXFwc/Y+H+kqPHZEyMzODl5cX3NzccPHiRcTExPCtYZ6CyspKVFVVQSQSwdrampMnSCMjI1hbW0Oj0RhE5EQfkUgk8Pb2hpOTE9LS0lBRUYG8vDyDGAFpa2uL5557Dm3atMHNmzeRnJzcqgccVFdXs/0uraysnriWDI9hQUQoLS1FaWkp209UINCvbJfy8nJcuHABZWVl6Nu3L5ycnHD79m0oFAoMGDCAHQ2ckZHBWXsxnid4tdexY0fs2rULCQkJmDZtGkpKSvQ6BMrD0xxYWlri+++/h5mZGd544w0kJSUZTEHEfv36ISgoCH/88QfGjRvHDxzh4dEzEhMTMXXqVPTu3Rvbt29HdHQ0AgIC8OKLL2Lv3r0Qi8UAgKCgICxYsIBjta2X/3SkzMzM8NJLL0EoFCI6Ohp3795FSUkJf9HVEbGxsTh69Cjs7OzYhsEajQZRUVEoKCjgWB3PoxCLxXj++efh5OSExMREqNVqFBQUQKFQcC3tsRGJRDA1NYVQKNSrjvc8PM1JVVUVzp49CxMTE/Tt2xcuLi64cuWKXjQH1mq1qKioQHZ2Ni5evIj4+HiUlpYiPT0d58+fZx0ptVoNPz8/JCUl4c6dO+jUqRM6duyI27dvG0yeX3PSpUsXuLm5oaCgAEePHn26/CgA/5kjpdFoqLKyksLDw8nR0ZEkEgnn7zZbkonFYjIxMaGdO3eSQqEghUJBeXl5NGjQoCZf9urVq0mr1dKcOXM43w6GZlZWVnTmzBm6d+8e9ejRg6RSqUHl0wCg1157jVQqFf3yyy8kEAg416MvNmXKFFKr1bR+/XqD2qd8jlTjjGEYkkql5OnpSQkJCXTp0iVq06YN57oeNIFAQDKZjL3/1n2Wy+Ukl8tp9uzZVFFRQV988QUBoKVLl5JCoaD333+fc+36ZgzD0A8//EBlZWU0depUkslk/3r900mOVFlZGc6fP49bt26hrKyMf52nY9RqNRuBqsuT0mg06Ny5M8zMzBAeHq7zvBUPDw94enpCrVZj//79SEpK0unvtwaqq6tx4cIFpKamwsfHB3Z2djh//jw/8pGHE3r06IEOHTogMzMTBw8ebJWjLhuLXC6Hr68vHBwccPHiReTl5elFNOpBtFptvVHd//ycmJiI0NBQEBFef/11CIVChISEwNTUFOPGjUN0dDTu3bvHhXS9g4hw8+ZNHDlyBLa2thgxYgQiIiKero7Yf0Wkbt68Se3atSORSMS5J9mSTSgUklgsJrFYTBYWFnTs2DHKycmh3r1763xZH3/8MalUKvr4449JLBbz0YhGmkgkImdnZ4qKiqKEhATq2LEj55qexPiI1MPN0CJSAoGANm/eTBUVFTRx4kQSi8UGoVtfzMXFhW7evEmxsbHUoUMHg7zXCQQCEovFtGjRIlKpVLRs2TISi8W0bt06UiqV9Pbbb3OuUZ9MKBSSTCajHTt2UHl5OY0aNeqR8+okIkVEqKmp4dvANDEajYYdBVlVVYWTJ08iPT0dPXv2hIuLC8LCwnQ2su7WrVv47bffIBaLMXnyZERGRiI+Pl4nv92aqDsvRCIRRCIRGIbhWhKPDkhOTsbOnTtRXFyMqVOn4tatW4iKiuJa1r8iFAohFouh1WqhVqu5lmMQyOVyDBkyBA4ODjh//jxKS0tRUlJikPc6rVYLrVaL2NhY/Pbbb7hx4wbUajWuXr2K4OBg2NraYurUqQgPD+cjUwB7r2UYBmKx+OlHaz5pHSnemscEAgFZW1tTeHg4ZWZmUteuXXX22wzDkEAgoNWrV5NarabZs2dzvr6Gavb29nTjxg1KTk6mTp06ca7nSYyPSD3c6s6P9957j9RqNX311Veca+0cyOYAACAASURBVPo3EwgEFBQURCqVisaPH8+5HkOxNm3aUFRUFCUlJZGHh0eLOAfqjt26iCTDMCQSiWjjxo2kVCpp4sSJnGvUF+OkjhRP8yESiTB8+HC4uLjg8uXLCA8P1+kIvrqdD9Q+yfKRlNZJUlISNm7ciIqKCsyaNYudHh0djYiICA6VccuDF0iBQKB3tYX+CRHh9OnTqKysRPv27fHuu+/i+PHjfJ/ERyCVSjFixAg4Ozvj7NmzUCgUKCwsbBGjVh+8ttd91mg0YBiGv9YD6Nu3L3x8fNjP6enp2LRp01NH6XhHSg+RSqWYPXs2unfvjpEjR+LSpUtcS+Jpgdy4cQPz58/Hm2++ia1bt0IoFAIAvvrqq1btSBkaRITg4GAcOHAAu3btwsiRI5GRkcE7Uo/A2NgYH374Idq3b4/hw4fjxo0bXEviaSZGjRqFjz76CEBtasb06dPx66+/PvXv8o6UnsIwDBiGaZJeSr1794avry9UKhXWrFmDa9eu6XwZLR2ZTIaxY8fCyckJR44cQVlZmcFWh4+NjcW6devYp9Xq6mosWrToofNqtVocOXKkRefUPffcc3jllVcgl8uxdu1anD9/nmtJT0Rrjzo8CrFYjNGjR8PNzQ1nz57FsWPHkJuby7UsnmagX79+6NevH6qqqrBmzRoAtQ8gcXFxulkAnyOlf2ZsbEx///03FRYWUp8+fXT++0uWLCGtVkuLFy/mfF0N1aysrOjSpUuUmZlJXl5enOvRpS1evJi0Wu1Drbq6miZMmMC5xqY0Qxu1V2d8Hal/NxMTEwoLC6OCggLq27cv53qayxiGoU2bNpFaraZJkyZxrocLW758OWm1Wlq4cOETf5fPkeJ5KOfPn8fy5cshk8mwYsUKHDt2DJGRkVzL4tETLly4gOXLlz/y/8888wwCAwOxf/9+JCQkNKMynn9Do9HgwIEDiI+Px/PPPw9vb2/s2bOHr2z9P6qrq7Fz506Eh4fj5ZdfRt++fbF79+6nr2rNo3f06NEDfn5+bHRWq9Vi+fLluHjxYpMsj3ekWiEXLlzAhQsXsHr1aixevBgFBQW8I8XDcvHixUdecEQiEXbt2oXRo0cjJiaGd6T0CK1Wi0OHDuHo0aM4cOAAfH19ERERwTtS/6O6uhq7d++GlZUVQkJC4ObmhrCwMN6RaoH06NEDgYGBrCP12Wef4Ysvvmiy5fGOVCvm6NGjKCgogK2tLdasWYP9+/frfb0cfaGyshI//fQTnJycMHHiRIwYMQJBQUHIz8/nWhrPUxIdHY1FixbBxMQEa9aswdmzZ3HkyBGuZfHw8PwH3bp1w4QJE1BVVVUvz7OpB2zxjlQrJjw8HOHh4fjhhx/w3nvv4fbt24iOjm6SBPeWhlKpxJ49e2Bvb49jx47B1NQUBw8e5B0pA+Nhidm3b9/G7du3MWvWLKxYsQJExDtSPDwGgIeHBz744ANs3bqVPXebA96R4sH+/fsRHx+Pjh074scff8T27dv5kXw8LR53d3fMmjULcrm83vTIyEjs2rWLI1U8PDyGBu9I8eDixYu4fPkygoKCMHnyZISHh/OO1GNSV/BOq9WyxRtbQmG/lkpdrSwAcHR0xNSpU2Fubl5vHiMjI+zZswcMw7D71tCoazlVV4ixriVGa0cgEEAoFEKr1baqbaLValFTU8MeD1qtln/zoEN4R4qH5ykoLS3F8uXL4eDggHnz5qGkpARr16412JpSLRlHR0csXLgQVlZWAIDi4mJ89NFHDXqr2dvbY8uWLcjMzMT06dN1V2ummVCr1fjhhx/w559/ws/PD2PGjMG3336L5ORkrqVxilQqxbx589CpUyfs27cPOTk5SEtL41pWk0NE2LlzJyIiIuDl5YVBgwZh/fr1/MOyDuEdKR6ep6CqqgonTpyAq6sr5s6di5qaGmzYsIF3pPQMsVgMGxsbjBo1Cg4ODgBqR68uW7YMZWVl9eadPHkyli9fjqCgIOzevdvgntw1Gg3OnDkDU1NTjB8/Hl5eXggODkZ6ejqA2htra2tsLBKJYGxsjEGDBsHLywtBQUGtqnp/ZGQkoqKisHPnTrz22msICQnhHSkdwjtSPDxPgYWFBZYuXQobGxusW7cOmZmZOu2LyPP02NnZITAwEHK5HMuWLUNVVRUAID8/H5WVlQ3mDw8Px5QpU3Dv3j2Dc6IepKqqCl9++SWcnJwwZcoUzJ8/HwCQl5eHlStXIjs7m2OFzYNYLMYHH3wAHx8f/PXXX1i/fj3u3r3LtSyeFsRjO1ICgQBSqbTBKJeamhpUV1frXBgPjyEgl8vx0ksvwdTUFKtWrWoVF2iVSoXKykqIRCLI5XKoVKr/zCNiGAYymQxarRYqlaqZlNZiYmKCoUOHQqVSYfny5cjMzPzX+dPS0lrEK5+amhqEh4fDysoKM2bMwPPPPw+gdv02btyI4uJiqFQqg3YW/wuJRAJjY2P07NkT/fv3x+bNm3H27FmuZXFG3bkrFAof+9w1BIRCIaRSKYRCISorK5vdJ3lsR8rd3R2fffZZg8TM8+fPY+3ata0qcY+Hp7Wi0Wjw/fff4+DBgxg2bBgmT56MlStX4vr16//6PTc3N3z++efIycnBihUrUFFR0UyKecrLy7FkyRL22m1ubo4lS5agrKwMgYGBLbZkh1AoxPz589G/f38cP34cmzdvRmxsLNeyOEOr1eLHH3/EoUOHMGzYMEyaNOmxzl1DoFevXli8eDGSk5MxceJEpKamNusDwn86UkKhEKampmjTpg169eoFS0vLev8vKiqChYUFKisr2ZA5Dw9Py4SIEBMTgzt37mDixIno3bs3HBwckJycDIVCwT5QMQwDY2NjdpRcmzZt0LNnT6SlpcHa2hpEBIVC0aRa6zQYGxtDoVBAqVS26OjLo1Cr1bh8+TL7uc6p1Wg0kMlkHCprOuRyOeRyOZ577jn07NkTmzZtQlhYGNeyOKXu3I2Pj8f06dMxZMgQbNy4kWtZT4VIJIKRkRGcnZ3Rp08f5OTk4MSJE80e2PlPR8rFxQXbt2/HvXv3MHv27AY5Bc899xz279+Pv//+G2vWrGmVFyoentZGdXU1Vq1ahR07dmDChAl499138cknn7Aj3Ozs7LBmzRq0a9cOAJCTk4MPPvgAlpaW2LhxI+Lj47F06dImffiytrbGmjVrYGFhgc8//xzp6f/H3pnHRVW2//8zO8wwMMMwbMOaYK65L7lrZiJqmiX5VGrmmj2VaVk+lqmZ+tijZW6Vu2XmkntKrj+33AFBQEH2ZWBYBmYYYLbr94df5hWBGwJnBs779fr8wcxh5nPOnDlz39e57uvKZPPXmgEcDgfvvvsuhg0bhv3792Pjxo2Ij49n2hZLA9CxY0csXrwYqampeP3115GTk8PI3bFHDqScnJzQsmVLlJaW4sqVKzVWI3l5eaFPnz5IT08Hh8NhB1IOjE6nQ2FhIYRCITw8PADcn8WUlpY2u1U+LA+HiHD79m2kpaVh6tSpaN26NXx9fZGXlwfg/nWhVatWCA4Otm1/7do1BAYGokWLFjCZTFAqldBqtTVWzT0MiURSo4Bmbd5KSkrA5/PRokULuLi4ICMjAykpKTVKHTRHLBYLiouLAdxfLKHT6VBSUtIkrt1VEchnnnkGrVu3xpo1a3D+/HmmbbHUM3w+H25ublCpVGjTpg3UajXOnz/P2O/UIwdSaWlp+OCDD5CWlvZEFzwWx8JqteLbb7/Fr7/+igkTJuC9994DcL+n3Jw5c9ilsiy1Ul5ejvnz58PHxwfTpk2zDZyKi4uxePFi5OfnAwDKyspQXFwMg8GAcePGoU2bNtixYweuXLmC+fPnP3Zy6IwZM/Dqq68+dJuSkhLMmjULSUlJmDlzJvz9/bFw4ULodDp88MEHNk/Nlby8PEydOhWBgYH473//i/z8fHz44Ye2wZUjM2XKFEREROC3337Dyy+/3OxrZzVV2rZti//973/IysrCG2+8AbVazegk6ZEDKYPBgOjoaOTk5Dzw+ZycHFRWVsLX19c2u2F5PGQyGcRiMYqLi1FeXg53d3e4u7tDp9MhNze3UVcfpKamIjMzExMmTICfnx+A+z+AKpUKOTk5KCwsZCNTLNWwWq24c+cO1Go1nJ2dbecNACQkJNT4IeNwOMjNzUVAQAB8fHygUChq7Xf3T1xdXSGVSqFSqaq9R224uLhApVJBq9WiqKgIzs7OUCgUcHZ2BpfLrduONiEqKytx69YtGAwGuLu7QyAQQKVSgcfjobCw0CEiUxKJBG5ubtDr9dUm+IGBgejevTs2b96Ma9euMejQPpHL5XBzc6v2u20PcDgcKBQKCIXCao9bLBYUFBTYnq/KuVSpVFCpVMjLy8ONGzcYz89+6jpS58+fx4gRI9C/f38cOXIEu3btwrJly+rDW5OHw+Hg/fffx6hRozB//nycPHkSX3zxBXr16oVVq1YhJiYGaWlpjerJbDZj6dKlWLduHYD7SZuzZs3CnDlzMHPmTMTFxTWqHxbHQK/XY/bs2RCLxQDu51BlZWXV2K5169b4/vvvbTPJ/Pz8x5osvP3225g0aRK2bduGsLCwh24rlUoxZ84ctGjRAsD9ukmff/450tPT2Rypv1E1aQoNDcX69etx7949/Pvf/4ZOp2Pa2iMZMWIEPv30U2zZsgXfffcd03YcAh6Ph08++QRDhgzBmjVrsHTpUqSnpzNtC8D9tkzLli2zleioIjs7G9OnTwefz8f69evh7e0NALhz5w4mTpyIvLw8VFRUMGG5Gk89kDKbzbbVOhKJpMaIkqV23N3dIZfL4eHhARcXF/j6+iI4OBgKhQJOTk7IyMhgLEEyIyMDHA4HXl5e8PDwgFAohFgsZmfzLA/EYrE81m0UsViMNm3aoLKyEgkJCQ8sg+Dq6mrL0wPuJ69LJBLk5+c/cgl71cpiiUQC4H4+RVJSkt38aNgLlZWVSExMBI/Hg1AohFwuR3BwMPLz85GXl2eXkSkXFxcolUp4e3vDxcUFnp6eeOaZZ2zPm0wmpKSksGkoD8Df3x9t27ZFcXGxXbQ+4nA48PT0hFKphFwut31nq3B1dUVgYCB4PB5cXV1tz1utVsTHx9vNoP+pB1L9+vXDN998g7Nnz2L48OFsa4zHZOrUqZg4cSLWrFmDdevWYdasWfjwww+xfPlyfPnll4xXHRYKhVi0aBG6d++OxYsXIyoq6pGFDFlY6ovRo0dj3rx5tr+3bt2KsLCwx8pvKikpwQcffGBb2m8ymR6YmsACJCcnY9y4cWjfvj22bNmC6OhovPfee4zfLqmNIUOGYMmSJfjjjz8QFhaGV199FceOHbM9/9NPP2HYsGG2RQ8s9o1QKMTChQvRs2dPLF68GJ9++mm15728vLB48WJYLBZ89NFHtohyeXl5g5dPeRKeeiAllUoREhKCK1euICkpqUlUSW1IlEollEolZDIZTCYT1Go1kpKSoNVqbbdD7CFBksvl2qJkhYWFSElJeej2Tk5OCAgIsN3DLisrQ2Zm5gNntQqFAp6enra/8/LyHGIQzuVy4e/vb7uFJZfLkZ2dDT6fz1b4fwzKy8tx584dFBQUoGXLlg/8sfb09ITJZLLlT2k0GiQlJT3We1itVltfOZZHU1lZiZSUFLi5ucFoNMLZ2RmtWrWCRqNBdnY2o5EpFxcX+Pn52c4Db29vmM1mFBUVISkpCRqNxpZkTETIy8t77POEhVlUKhU8PDwgFotRWVmJzMzMGp+dwWCAwWCAxWJBamoq1Go1Q24fARE9TBQTE0O+vr4EoFaNHTuWKisrafPmzcTlch+4Hav7mj17NqWlpdGcOXPI39+fJBIJASCFQkH+/v7k7OzMuEcA5OzsTEeOHKGSkhIaMGDAI7dv37493bx5k9LT0yk9PZ22bdv20H2ZOnUqpaWlUXp6OqWlpdGUKVMY3+fHkUQioZ07d9r288aNGzRw4EDy9fUlPp/PuD97l1AoJJVKRaNHj6aEhATbcfynVqxYQQEBAeTv70/+/v7k6urKuPemrqrPZsyYMZSYmEg//vgjCYVCRj0NHDiQ7ty5Yzsv1q9fT4GBgSSXywkAubq62s4Rf39/kkqljB9HexWPx6Off/6ZKioqaNSoUYx64fP5tHbtWrp79y5FRESQn58fiUSiWj37+PiQj48P8Xg8Rrz6+fnR7du36f+odaz01BGp4uJiREVFQa/Xo1OnTsjLy6s1ybS5olQq4e/vj7y8PGRnZ8PNzQ0BAQGwWCzVZs2FhYUoLCxk0Gl1rFYrkpOTIZPJ4OPjg+eeew7JyckwmUwICQmpUcsnMDAQJSUl1SKSHTp0QH5+PlJTUyGXyxEYGGibWbq7u1dL/HV3d0fnzp2RkZFhlwnBHA4HzzzzDLy8vGC1Wm1tNQoKCpCVlcXeOnpMjEYjsrOzkZ2dDY1GY4vs/ZPc3Nwm0e/OkfjnZ8PlctGxY0dbxKegoKDBPhMnJyeEhITUyLENCAhAUVERBAIBgPuFXTMyMmxRstLSUjYf6jEICAiAp6cnSkpKEBUVBa1Wy6ifqlV4fn5+0Ov1DxwzWCwWxtNcHounjUiJRCJSKpU0ZcoUysnJoSVLljA+8rYnvf3225Sbm0vz588nALRo0SKyWq00a9Ysxr09Sm5ubhQcHEyHDx+m+Ph46tSpE3l5edGZM2dIrVZX0+nTp6lVq1bk6elJnp6eNHr0aEpLS6PNmzeTQCCg1157jbKzs23bL1u2zLatp6cnLV++nHJzc2nChAmM73dtEolEtH37drp37x4NHz7c5tvDw4ONRNVBAoGAlEpltXPg73JxcWHcY3OVUCgkpVJJr7/+OmVkZNi+sytWrCAOh9Mg79m6dWuKjo6ucV3Zs2cP+fv7284LNuL05OJwOLRixQrKzs6miRMnklKprDX605gSCAS0a9cuMhgMFB4ezvgxepgaJSJVWVlpu5eelJQEPp+P3r1717otEeHevXvIz89HaGgoFAoFEhMTm0QhuCoUCgVatmxpW+GmUCiQnJwMJycn9O7dG0SEixcvOkQEo6SkBCaTCampqRAKhXj22Wfh7e2NgoKCGveyU1JSoFarbTOdqvPBaDTi+eefh7e3N+7du2eLSGVkZCA/Px/+/v62CF1Vrpg9wuFw4ObmBqVSCYPB0OyLOj4pEokEbdq0eeSqXrVaXS1H0M/PD4GBgUhLS2MXOzQSRqPRdk1PTk62RYM4HA569+6NrKyseivL4uTkhLZt2yIoKAjZ2dk1VmGlpqYiPz/fbuodORpBQUG2HLOkpCRbtJFpqurPXblyBd7e3ujZsycSEhIctwbl00akqiQUCkkmk9EHH3xAhYWFVFRUVEMFBQX01ltvEZ/Pp59++olycnJo6NChjI8461Mvv/wyqdVq2z5/9913JJfLae7cuVRUVETz588nmUzG+IzgSeTi4kLBwcF05swZSkhIoJ49e5JMJqsmqVRabbbK5/PJzc2NIiIiSK1W06ZNm0ihUNi2d3JyIgC24zJnzhySyWSM52Q8SE5OTnTw4EEqLS2lQYMGMe7H0dSuXTtKSEio9brwd61ataraeTRnzhwqKiqiDz74gPF9aG4SCATVvuMzZsygwsJCWrRoUb29R3BwMN28eZMuXbpErVq1qnFdqcohZVU3ffXVV1RYWEgzZswgmUxGAoGAcU9VEovF5OXlRXv37qX09HTq06cP455qU6NEpKowGo0wGo1IS0vD9evXa61WTERQKpUYNGiQrWJ6UFAQBg4ciJiYGIdYtfUgFAoFOnToAD8/P0RFRdlWr929exfFxcVITU3F9evXkZKSYrdRlweh1+vB5XIRGxsLtVqNvLy8R+6D2WxGSUkJsrKycOPGDVvk8Z+rOp2cnCCTyUBEDndcWB6NWCxG586dERAQgMTExEeupjObzRg8eLAtB0YsFuP69etwcXHB4MGDkZiYyOZgNhImkwlarRbe3t5o27YtJBIJrl+/Xq/Hv7KyErGxseDz+WjdujVcXV0RFRXFdlCoJ5ydnSGTyWCxWOzu+mowGGA2mxEfHw+RSISWLVuCx+MhKiqqRt6bRCJBp06dbCVNtFotoqOj7ad3Zn1FpKrE5/NJIpHUKqlUShs2bKDi4mJ68803yd3dnfbt20e5ubmPtTLMnvXiiy9Sfn4+7dy5k+RyuW2fqyIsAoGAJBKJXc0InlTOzs4kFoufaHUmj8cjiUTywAjcggULyGq10uzZsxnfv4eJjUjVTaGhoRQXF0d//fUXBQcHP/DaUKVp06ZRSUkJ6XQ60ul0tGjRIpJIJPT1119TaWkpTZ06lfF9am6KiIggrVZL69atIxcXl3qNGnM4HBKLxdS1a1e6e/cunTlzhtzd3Rnf56ai//3vf2SxWOz6e+Pk5EReXl50/PhxSk9Pp65du9bY5tlnn6WEhATbdSEyMpLc3NwaxV+jRqSqMJvNDxwlcjgcxMbGQqlUIj09HTqdDjdu3IDVakWrVq3g7OyMy5cvO0TOlEwmQ8+ePW05H35+fjh37hyioqKg0+lqHAOTyeTws6y6FOizWCx2VTjtSeFwOLaISnp6Oo4ePWoXOQb2jrOzM55//nmoVCpER0dDo9GguLj4kedCSkoKTp06ZcsxTExMRFlZGTgcDlxcXGz5Oiz1h5ubG3r27AmRSFTr876+vjh9+jRiY2MfWIm+rhARDAYDNBoNzp8/D6vVisGDByMrKwtXr161n4gDS4NRUVEBDoeDa9euoaSkBB06dIC7uzsuX74Ms9lsu47cvHkTd+7cAXC/7uCLL76I7OxsXL16FRaLhdmdqO+I1KPE5/NJJBLZohoCgYAUCgUdP36csrOzqUePHoyPkB9HXbp0oczMTCovL6fy8nI6dOgQyWQydgXXE8reI1J8Pp+2b99OxcXFNGrUKBKJRA22cqkpKSAggGJiYujWrVsUGhr62FEMLpdLIpHIpqraMUuXLiWr1UozZ85kfN+amjp27Ejp6em2a9k/tXXrVhKLxQ16beNwOCQUCqlXr16UlZVFx48fZ1fo1YMcISJVJYFAQD4+PnT+/HlKSUmhdu3aUVBQEMXGxlJ0dDQ988wztuvCgAEDSK1W0+HDh0ksFjeoL0YiUo/inxErk8mEyspK8Hg8iESix+oEzyRubm4YMGAAfHx8cPLkSdssLjo62nbPl8Wx6dy5M1q2bAngfiXzvLw8HDx4EBkZGezqocfEYDDgxIkTcHV1Rd++fdGiRQucPXv2kQ1GrVZrrcc4JiYGv/76K1xdXfH666/jypUrSE1NbSj7TRInJycMGDAAMpms2uMymQynT59+YETq6tWrqKioaNCuFUQEo9EIs9kMkUgEoVBo978FLPWLyWSCTqfD6dOn4e/vj169esFsNuOvv/6CVquFVqu1XRtyc3Nx+PBhlJWV4ZVXXqnxu5ucnIzr1683nvnGjkjVJhcXFzpx4gQVFBRQz549GR8ZP0xt27al1NRU+uuvv8jb25v4fD7x+XzGqq46uuwxIrVy5UoyGo1kNBrJYDDQ66+/Tnw+n41EPaF4PB61adOGkpKS6Nq1a+Tl5VXn1+JyucTn8+n777+niooKGj9+POP752jy9vam69ev287tKl29epV8fHxs17J/qjE7VnTv3p00Gg2dPn2arWZfD3KkiFSVeDwe+fv7082bN+nu3bvUqlWrWn9feTweDR06lLRabY1zes2aNfV2vbbLiNTf4fF4GDRoEIKDgxETE4Pbt2/bfX0eDocDPp8PHo/30HwwlvsEBgZi0KBBtpyX2ti0aRNiY2Mb0VXtdOnSBR07dkRZWRm2bdsG4H6O171799jPuQ5YLBZYLBbw+Xzw+fynijBYrVZYrVb89ddfEIlE8PX1xdtvv42zZ8+ykalHIBKJMGTIEPj5+eHixYuIioqq9nx6ejr0er1dnOP5+fn4+eefYbVa8frrryMtLQ2nTp1iPgeGpdGwWCwoLS3FwYMH4eTkhKKiolo/f4vFgoyMDPz88881oqlarRaTJk1CbGwsrl692vCmmYxIiUQiOnDgAGm1Who8eLBDzPjbtWtHmZmZdPXqVfLw8GDcj71r9OjRZDAYyGKx1KoFCxbYzee+ePFiMpvN9P777xOHw7GJaV+OrGeffZZSU1MpKiqKvL29n/r1OBwO8fl82rx5M5WXl9OYMWMY30d7l7u7O126dImysrKoQ4cO1c5tezzHORwODRw4kIqLi+nw4cN203/UEeWIEam/nwePc27Wdj5Pnz6dTCYT/fe//31qH3YbkeJyuXjxxRfRqlUrxMfH486dO9X6J9kjbm5uGDVqFJRKJX777Tfk5OTUaRVbcyEgIADh4eGQyWT44YcfHhiNuHLlit187hwOxxY5sxdPjopUKsWoUaPg6emJffv2IS8vr15WbxKRLVeHy+WyeTSPCYfDAYfDsV347RkiQmZmJn744QdYrVZMnTr1gZ6vX7+OS5cuNbJD+6dHjx7o0aMH9Ho9Vq9ejbi4OKYtPTGPe54+aLvGvD4wNpAaP348Ro8ejYiICBw+fJgJG0+Eh4cH5s+fj/LycgwbNowtCvgIWrdujRUrViAyMhLjxo2D0Whk2hJLIyKXyzFv3jwAQFhYWL21FGFpHiQnJ+PTTz/FsGHDsGfPnhpN0qtYvnw5O5CqhbCwMHzxxReYPXs2FixYwLSdJk+jDaQGDx6Mbt262f5OTk7GihUravRscwTsfUbHBN7e3oiIiEBhYSH27NnDtJ0n4vnnn8eAAQNgMpmwdOlSXLt2jWlLTYr6/r4QEY4ePYrc3Fy0bt0an332GYD7VbL37t2LjIyMen0/R0UoFGLMmDEIDg7GyZMnUVZWZvc5qP/k3r17WLFixQPrhxmNRtvnXwUR4fjx44iOjm4Mi3bJ+fPnsXTpUkilUnz66afN7njcvHkTy5Ytg8lkwmeffYbz58/jwoULm8U7SQAAIABJREFUDfeGjZUjtWrVKrJarWS1WsloNNK4ceMYvwf7JGrRogUlJSXRrVu3SKVSMe7H3tSlSxfKy8ujc+fOkZubG7300kuk1+tp3759dts/r0qfffYZWa1WmjdvHuNemooCAgIoISGBEhISKDAwsEHeQyAQ0O7du23XFa1WS/3792d83+1FUqmUTp48SQUFBQ5Tn+9JNXfuXNvnXyWLxUJTpkxh3Js9yJFzpOpDs2fPJqvVSgsWLKjza9hFjtTgwYMxYMAAFBcXY/78+QDur8CJiYlp6LeuVwoLC7Fy5UooFApMnz4d2dnZ2L59OwwGA9PWGEWpVGLixImQSqVYvXo1uFwu5syZA6vViqVLlyIxMZFdcdMMcHJywvjx4xEQEAAAICL88ssv0Gg0Ddbjy2KxYNeuXbaZNofDwaBBg9CrVy/s2LGDvf3eDDh37pztd+XvqFQqfPXVVwDu1y7ctWsXEhMTG9teo9G9e3eMGDEC58+fx59//olBgwZh0KBBKCkpweeff95so+wXLlzA/PnzIRAI8NVXX+H48eO4cOECRo4cie7duwO4f37s3r0b8fHxdX+jho5IffXVV2S1WptM93Z21V51tWnThtLT0+natWukVCqpT58+VFRURMeOHWvwirP1JTYi9fSSy+V04cIFW1QgNTWVnn322Ub14OrqSmfOnKH8/Hzq3r0748eEaTWHiFRt4nA49MMPP9jORYPBQCNHjmTcV0NqxowZZLFYaNmyZQSAFi5cSFarlWbNmsW4N3tQVb3COXPmEIfDoXXr1tnOj4qKCho9evQD//dxIlKcR+Qv0K1btxAWFoacnJyHbVeDF154AcOHD0dxcTFKSkpsfegcnXbt2uHYsWPIzc3FsGHDUFBQwLQlRlAoFJg2bRrc3NyQn5+PnJwcHDhwAHK5HCNHjoRarcaRI0fsojbNo+jWrRt69eoFuVwOV1dX7N+/H+fPn2falkMgFAoxadIkhISEQKPR2CqX63Q67N+/v1H7ZgqFQowcORIBAQHw9PSsUVsmNzcXP/zwA0pKSgAAzzzzDCZPnoy0tDRs2bLF4Xth/hOpVIr9+/ejY8eOCA8Px5UrV5i21Gi88MILaNeuHYD7kUqlUgkej4dNmzY5ZF7ug+jWrRtef/11lJWVoaioCK6urpDL5bZK4E3ld/dp6dGjB3r27Gm7xhcVFUGn0wGofn5s3bq1RuTSz88PkZGRaNOmDQDUvgywoSJSn3zyCVksFpo3b57d1Sl5GrVt25bS09PpypUr5Onp2aT27Z+qrT5HlVq0aEF37tyh2NhY8vPzY9xrfagqevr+++8z7sURxOFwSCqVUmRkJGk0Gnr++ecZ9wSAFAoF/fXXXzVqlt26dYv8/f1t53C/fv2oqKiI/vjjD3JxcWly3+XmGpH6p6rqFZaWltILL7zAuJ/61IQJE8hkMtHatWsJAH388cdksVho/vz5jHuzRy1fvpxMJhNNmzbN9phQKKR9+/aRXq+nl156qcb/MJojFRkZieLiYqhUKmzYsAG7d+/GqVOnGurtGo2cnBx89tln8PT0xIIFC5CSkoJ169Y1uZpSAoEA06ZNQ/v27Wt9vrKyEt9//z3UanWjRh1Y7AM+n4+pU6eiffv2+PPPP/HLL7/g3r17TNsCAOj1eixbtgyenp7VHnd2dsbcuXNtK8D0ej3mzZsHiUSCFStWIDo6Ghs3bmRz+lgclsjISGi12sbtM+dA7Nu3D0lJSbh48WL9vnBD50gtWrSIjEYjffjhh02qX1nXrl0pPz+fzpw5Q25uboz7qQ9V9TPj8/kklUrp0KFDNXoYVenOnTvUokULxj3X535/9dVXZDQa6b333mPck73r77P8wYMHM+7ncdSmTRtKTU21ncOnTp0iV1dXGjJkCGm1Wtq9ezeJxeJG7S3XkGIjUvfVFCNSVRX+J06cSOXl5bR69WrGPTmqhEIh7d69m7RaLYWFhdXoNRkUFMT8qr29e/ciMTERbdq0wZYtW7Bp0yacPXu2od+W5QnhcDiYPHky+vXrB+D+iqjTp09j165dtW6v1+uRl5fXmBYbjOHDh2Ps2LG4e/cuJk6ciBs3bjBtiaUByM7OxqxZsyAWiwHc7+tWXl6O2NhYTJ06FX5+ftiwYQMuXbqEH374ga0Xx2K3dO3aFTNnzoRarcbkyZNx584dpi05LGazGd9//z0OHz6MIUOG4I033qj2vFgshkqleviLNGYdKYvFQu+88w7jI9D6UJcuXSgzM5NOnDhBSqWSBAIB457qKj6fT87OzrRx40YqLy+n8vJyKioqoqFDhzLurTHErtp78vPF1dWV9u3bRxqNhgYNGsS4p/rQmDFjqKKigrZt21Zrt3lHkkAgIA8PD4qMjKTs7Gzq1q0b456Ykkgkoj179lBBQQENGTKEhEKhw98ZGTNmDFVWVtKWLVsc/ly1F4nFYjp06JDtN7BKFRUVZLFY7K/XXlPg3r17mDJlCgICArB27VrExsZi+fLlDtkK5e2338awYcNw4cIFREREALgfkbp58ybDzljsDS6Xi/fffx+9e/fGmTNnsGnTJsTGxjJti+VvCAQCfPLJJ+jYsSN+//13rFq1CsnJyUzbYgyTyYQVK1Zg165dGDVqFN566y0sWbKkSdeVYnlyKisr8fXXX2Pjxo3VHvfw8MCXX34Jf3//B/5vvQ+k+Hw+RCIRTCaTQw4qHhetVovjx4+jf//+WL58OVxcXMDj8Zi2VSdatmyJQYMG4ciRIzh16hQqKiqaVcKt0WhEWVkZOBwOJBIJjEZjk1sKXx8IhUI4OzujY8eO6N+/PzZv3ow//viDaVv1htlsRllZGSwWCyQSCSoqKhzyGsbj8dCzZ0/069cP69evx+nTp5m2xChWqxVXr17F7du3MXHiRHTo0AGbNm1CRkYGKioqbE2wWZo3FosFly9frvG4n58fZs+e/dD/5da3mfDwcPz+++9488036/ulWRqIjRs34tVXX0WbNm2wZ88e9O7dm2lLjcq+ffswevRoCIVC/P777wgPD2fakt3B4XDw7rvv4rfffsO1a9cwduxYXL16lWlb9cpff/2FsWPHIiYmBrt378a0adOYtsRSj1RUVGDBggWYOXMmJkyYgM2bNyMoKIhpWyxNgHobSAmFQshkMgQFBaFr164ICQmBTCazyWq1ori42CFneE2dO3fu4NSpU5DL5XjhhRfg7e3NtKVGJS0tDSdPngSPx8OLL75oa3PCch9nZ2fIZDK0bNkSnTt3Rk5ODk6fPg2NRsO0tXolPz8fp06dQlFREV544QW0atUKHE7t9fdYHI+qdIXz58/Dx8cHnTp1gre3N1xdXcHl1ntMgaUZUW+39gYPHoy5c+fi8uXLGDlyJAYMGIDDhw/bnj9y5AhGjhxpN7VmWFhYHo/Jkyfjtddew/79+zFq1CjcvXuXaUssLHVGr9fj448/hkqlwocffggOh4PZs2cjIyODaWssDkq9DaQ8PT3Ru3dvxMTE4OLFi+jcuTNCQ0NtzxcXF+PSpUv19XZ2g9FohEajgcFggFKphFarRWlpKdO2WFieGolEAolEgsDAQISGhkKj0TTJ7zBL88JsNiM2NhYajQahoaGQyWRwdnZm2haLA9Ngq/Z2795drXpoU+3EHhsbi9deew0dOnTArl27bN3IHaHHHAvLw3jrrbcwefJk7N69G8OGDWNn7CwsLCy18NQDKWdnZygUCohEImRlZdnaheTl5TWZgo0PQ6/XIyYmBnK5HAqFAt7e3vD390dJSQmKioqYtvdEFBUVITs7G87OzlCpVCgsLLQ1oW3KSKVSuLm5gYiQmZlpa2bZXKk6Hj4+PlAqlSgsLGxWjU/LysqQlZUFk8kEPz8/lJaW2hodszQdLBYL1Go1jEYjPDw8UFJSAo1G4xArlg0GAzIzM1FZWQk/Pz+UlJRAq9UybavZ8tQZdv369cORI0fQvn17hIeHY/369fXhy+G4du0aXn75ZZw7dw4HDhzA7NmzHSqB0Wq1YuXKlXj55ZfRp08fHDp0CN27d2faVqPw+uuvIzIyEpWVlRg6dCgOHjzItCVGiYiIQGRkJMxmM4YOHYr9+/czbalROXXqFIYNG4a0tDQcO3YMkydPZtoSSwNQVFSEmTNn4pNPPsGCBQuwcePGGv0Z7ZULFy5g+PDhiImJwZEjR/Dee+8xbalZU+eIlFgshre3N3x9fSESiaDT6ZCQkNBsa3KUlZUhMTERQUFB4PP5kMvlCAkJQVFREQoKCiCTyeDh4YHCwkK7bfJrNpthNBrB5XIhEAiazYolHo9na2RrMpkcYkbakFR9/kDzPB4lJSUoKSnBgAED0Lp1a3h5eTFt6bHx8vKCQqFASUkJUlJSYDAYmLZkt1gsFqSkpMBisdiKLVad9/aOTqdDYmIievTogVatWsHHx4dpS82aOodMunfvjsOHD6NPnz4YOXIkVq5c2WwHUX/n/Pnz1WYKM2fOBACMHTsWx48fx7/+9S+GHdYOl8vF7NmzcejQIVy4cAEjR45scnWCHsSuXbswdOhQCIVCHD9+HKNGjWLaEqP89ttvGDp0KPh8Po4fP47Ro0czbYnlMeDz+Zg3bx727t2Lo0ePYvTo0YiOjmbaFgtLk6fOAymxWIygoCBIJBKkpaU1uZoydaWsrAypqanIzc2FwWCAVCpFu3btoFAoYDAY4O7ubvvb3lAqlQgKCkJZWRnS0tJQXl7OtKVGQavVIiUlpdrqy7Zt20IulzNtjRGqohn5+fnN+ngUFRUhLi4OZrMZ7dq1g1KpZNrSA1GpVGjbti2cnJxQVlaG7OxspKWlNYscx+aIq6sr2rZtC4lEgtu3byMnJ4dpS80ax0nicTBOnjyJYcOGITMzE8eOHYNUKkVYWBj4fD6OHTuGV155hWmLLP9g69atCAsLg4+PD44dO4ahQ4cybYlRtm/fjrCwMHh6euLYsWMICwtj2lKjcuTIEYSFhUGr1eLYsWM1usLbCxwOB7NmzcLBgwdx6dIlvPzyy80mmtxc6dOnDw4fPowOHTpgxIgRWLNmDdOWmjV1zpEqKSnBjRs3UFxcjM6dOyMvLw9paWn1aM2xMRgMMBgMyMnJsSk7Oxs5OTnIzc2Fu7s7unbtirS0NBQUFDDqNSAgAN7e3tDpdLhx44bDrTasL3Q6HXQ6ne1z8vT0RJcuXZCamtosj0nV8eDz+VCpVJBIJExbalTKyspQVlYGq9UKlUoFqVTKtKVa4XA4kMlk8PHxQUVFBRudeEwEAgFCQ0Ph7++P5ORklJeXO0znjfLycuTm5qKyshI+Pj7gcDjsylImIaKHiWJiYsjX15cAVJNQKCSFQkFvvvkm5eTk0HfffUdcLrfGds1dTk5O5OHhQRKJhACQWCwmDw8PWrFiBanVanrzzTcZ9/j111+TWq2mKVOmkIeHBwmFQsY9MSmJREKenp60bt06ysnJoVGjRjHuiUmtWrWKLBYLTZkyhXEvTGjOnDlktVrp888/Z9xLbeJyubRx40aqrKykiIgIxv04ijw9Pen06dMUFRVF3bp1I7lc7jC/YUKhkDw8PGjy5MmUm5tLy5cvZ9xTU5Wfnx/dvn2b/o9ax0p1jki5uLigVatWcHV1RWJiInJyckBEdX25JktFRUW1PIWqSBWXy4VSqbSLirpqtRoJCQkQi8Vo1aoVEhMTGY+SMUlZWRkMBgNSU1ORmJgIX19f9O3bt9ZtjUYj4uLiUFZW1sguG57AwEAEBgaioqIC586dQ25uLtOWWFjqDbPZjJSUFHh4eMDf3x9EhNjYWFRWVjJt7ZEYjUYUFBTAZDLBw8MDLi4uTFtq1tR5INW1a1ds27YNp06dwmuvvQaDwcAOpByUH3/8ETt27MDy5csxf/58TJkyBQcOHGDaFqMQEdasWYPNmzdj1apVWLJkSa3b5eXlYcyYMbh9+3YjO2x43njjDXz88cdYtGgRXn755Waz+ICleVBcXIwPP/wQgYGB2L59OywWC8aMGYPMzEymrbE4GI89kHJzc0OXLl1sdTaCg4Nx/fp13L59G1qtttnVmnlaEhMTERkZCVdXVwwZMgSxsbGMzfgrKipgNBrB5/Ph6uoKoVDIiA97oypnIj4+/oErtsrKytCpUycoFApcv369SdXtcXJygpubG6xWa7PsH+nv7482bdpAKBQiMjKSbbjexCAi6PV66PV6iMViAGg2tfNYHgyfz0fnzp1tq5SVSuUj80MfeyAVEhKCLVu22Jbtnzx5EhMmTIBer2cHUXVg69at2LlzJ7755ht88cUXmDJlCnbv3s20LZZ/YLFYsHLlSqxevbrW5728vLBr1y5IJBKMGjUKycnJjeyQpaEYOnQoVq5ciXXr1mHMmDEwmUxMW2JhYWlgJBIJvvrqK/Tq1QvA/cG1k5PTQ//nkQMpNzc3hIWFgcvl4uLFixCJRACAGzduQK/XO8wqB3vDZDLBbDYjJiYGSqUSfn5+tmXLjR2Zeu655xASEoKCggIcOHCgyTaYritGo/GB53lFRQVEIhGcnZ0dqiUQS018fX3RrVs32+fo7u6OyMhI3L59264jjUSEmzdvws3NDb6+vrZiumq1mmlrDoHBYMCJEycglUrRr18/ZGdn49KlSw6RK8VSf/B4PPTo0QP+/v64d++ereeqs7MzevfuDVdX1wf/86NW7VksFqqsrKSLFy+Sj48PCYVCEgqFxOfzGc+mbwri8XgkFotp+/btVFJSQsOHD290DytXriSDwUCTJk0ioVDoMCtX7EE+Pj4UHR1N9+7do5YtWzLupz61aNEislqt9MEHHzDupTE0atQoKi0tpYqKCqqoqKA1a9aQSCQiHo/HuLdHicfjkUQioV9++YW0Wi2FhYUx7smRJBAIqF27dpSUlESXL18mLy8vxj09jiZMmEAmk4nWrl3LuBdHl1gspkOHDlFeXh7179/fNtZ55plnKD4+/ulW7ZWUlODUqVOIi4uDTqdjI1D1TLdu3dCyZUvk5uZiz549yM7ObnQPfD4fQqEQVquV/XxZ0LZtW3Tu3BlWqxU7duxAQkIC05YaFF9fX/Tv3x++vr7Yt2+fLSJ19epVh4lKWCwWVFRU4OLFizAajWjVqhXc3Nxw9uxZNjL1GJhMJphMJggEgmbVZ5SlOgKBAEKhEBaLxfZbaDQaH7mQ7pEDqaysLHz00UfIzs5me+nVMxwOBxMmTMDEiRMxefJk7Nq1iz3GLIwTHh6OJUuWYOHChZg0aVKTPyfbtWuHDRs2IDIyEhMmTLBdQB1tFbLFYsGGDRuwbds27Ny5E3379sWYMWPYgRQLSwPzyIEUEcFisTT5i2lj8/zzz6NDhw4oLCzEpk2bcPfu3UZP2u/Rowc6deoErVaLH374AXfu3GnU92exTzgcDng8HgA0i4UkWVlZ2LJlC8rLyzFx4kQkJibi7NmzDjeQ4nK5GDRoEEJDQ5GQkIB79+6xVc4fA6lUimHDhsHb2xsHDx6EWq2265w4lvqFy+Vi8ODBCAkJwa1btxAfH//kecp1rWzO6un0zTffkNlspilTphCHw2HEw9dff00Wi4Xee+89xjw4uppijtTcuXPJarXS/PnzGffSWOJwODRmzBgqLy+nrVu3OkRe1D8lEAho586dVFZWRsOHD2e/04+pwMBAio+Pp/j4eAoMDHSo48bmSD29hEIh7d27l0pLS2no0KE1Pv8GrWzO8nRwOBzbfXimZr724MHR0ev12L59Ozw9PTFq1ChbBCcvLw+///47O7N1EKrO/79/JxyRKv9VF3iWx+Pv10FHOG6hoaEIDw+Hi4sLvv32W1y6dIlpSw6LxWLB4cOHkZKSgs6dO6NFixY4cODAE+UrswMpFpanQKfTYeXKlQgODsaxY8fQsmVLAMDNmzdx4sQJdiDFwsJS7zz33HNYtmwZfv31V0yePLlZ3IJvKCwWC7Zt2waJRIK9e/eiR48eiImJYQdSjsCff/4JvV4PX19fzJ8/HwcOHEBcXBzTtljqSHFxMdauXQsPDw8A92e206ZNQ0ZGBnbt2lWt36K90rVrV1vNuMWLF+PcuXNMW2pUEhISsGTJEnC5XMybNw/Xr1/HsWPHmLbFwlIrjhw5tUf+HpV+UtiBFENERkbizz//xIYNGzBp0iSkpKSwAykHRqvV4vvvv7f93blzZxw9ehTJyck4cOCAQwykevTogYULF2L58uX47LPPmLbT6MTHxyM+Ph5vvfUWNm/ejB9//BHHjx93iFs9LCwszMEOpBgiPDwcffv2RVZWFj777DNERUUxbYmlmXPp0iXMnTsXzs7OWLZsGf7880+cPn2aaVssj4nFYsHOnTsRFRWFnj17onv37ti+fTvbI/ARFBcX45tvvoGnpyemT58OtVqNzZs3Q6/XM22NxUFge1owxKBBg/Dxxx9DrVbjm2++YazoITvbZqkiKioKK1asQGVlJT755BNbrykWx8BqteLw4cNYvXo1OnbsiA8//BCBgYFM27J7SktLsWnTJuzfvx/jxo3DhAkT4OLiwrQtlkbmaRZesRGpZshLL72E4cOHQ6PR4P333292uTANiZeXF2bOnAlnZ2csXboUWVlZDpdwfuLECej1enh4eFS7XQnc/7Hevn07bty4wZA7Fpb6xd3dHe+++y7kcjm+++475OTkoLS0lGlbLI0Ej8fD22+/jeeeew5nzpzBvn37njiKyw6kmiFdunTBzJkz8dlnn2Ht2rVM22lSyOVyTJgwARqNBuHh4cjLy2Pa0hNz8+ZN3Lx5EwsXLsSMGTOqPWc2m3H58mVERUWxRXpZmgRSqRRvvPEGgPuTzIyMDIYdsTQWHA4HAoEAQ4cOxYsvvojXXnsNf/755xO/DjuQYmFhqZUDBw4gNTW12mMcDgcdOnTAgAEDsH79ekRHRzPkjoWFhaXucLlcTJo0CT179sTly5dx4MAB3L59u06vxQ6kmiFWqxUmkwnA/SaNbAug+oHP54PP58NsNsNsNjt8/llUVFS1RRA8Hg9CoRA//fQTRo4ciSNHjjSpgVRVaxwOhwOTycTW5mlGmM1mANW/wyxNGw6Hg759+yIiIgLjxo3D/v376/xa7ECqGXLw4EGkpKSgXbt22LFjB7Zu3Yrjx48zbcuhUSqVmDdvHlxcXLBo0SLk5OSgpKSEaVv1BofDwaRJkzBo0CBcu3YN+/fvb3J5Ut27d8e///1v5OTk4O2330ZSUpLDD4ZZHo1Go8HHH39sq+mXn5+PZcuWQavVMm2NxUFgV+01QxISErB7924AwIgRI9CyZUs4OTnZGtWyPDkuLi4ICwtD7969cfr0aZw4cQKVlZVM26pXunbtijFjxiAnJwf79u1rMg1xuVwunJycEBgYiOHDh8Pd3R179uzBzZs3mbZWZ4xGIyoqKsDn8yESidjijQ+hvLwcZ86cwbVr19C7d2/0798fIpGIaVsPxWKxoLy8HFarFU5OTuDz2ZhIXTCZTKioqACPx4OTkxO43LoNidiBVDNm586diIiIgI+PD3777TcMGDCAaUssLI1Ox44dsWPHDvTu3Rvjx4/HmjVrHPpWt9FoxLJlyzB9+nS88sor2Lx5M0JDQ5m2ZbcolUp8++23+OSTT7BgwQJ88skndh+Nunz5Mv71r3/h9u3b2LlzJyZPnsy0JYfDarVizZo1GD9+PPr164cdO3agY8eOdXotdiDVjElMTMSRI0cgkUgQHh4Of39/pi05HBwOB2KxGM7OzigvL0dZWVmTvR1UWVkJvV4PPp8PFxcXh49g8ng8uLi4QKVSoW/fvnB3d8fx48cdPu/LarXi2rVrOHnyJEJCQvDSSy9BLpczbcvuqPruKhQK9OjRA61bt8bFixdx/vx5u48mq9Vq/PHHH1Cr1ejXrx/atm0LqVQKoVDItDWHgYgQHR2N48ePw93dHX379oVKparTtY2NB7KwPAVyuRzLli2DQqHAkiVLkJmZCY1Gw7SteoeIsHbtWhw6dAgjR47EG2+8gcWLFzt01/k2bdrgq6++Ql5eHsaPH4+cnBzbIgyWpo9MJsOyZcvg4eGBpUuXIiMjw+G+u6dPn8Yrr7yCLl26YP/+/fjtt9/w008/MW3LoTCZTFi2bBl27NiBMWPGYPLkyfjPf/7zRC3b2IEUC8tTIBAI8Oyzz8LNzQ2pqalITk5usj/Gd+7cQXJyMsaOHYsOHTpApVJBLpdDp9PZ1SonDocDqVQKLpcLnU73wNV3MpkM/fr1w+XLl3HhwgWHK5z6KIgIOp0OWq0WYrEY7u7uAO7n1+h0OtvtSx6PB6lUCovFAr1e32Qjqv9EJBKhe/fukMlkmDdvHu7cucO0pSdGrVZDrVYjODgYHTp0wLVr1+Du7g6DweAQ/T2fFj6fD6lUassBrKysRFlZGUQiESQSSY3tq46LWCyGSCRCWVkZjEYj0tLSUFxcjOnTp6N9+/ZPXNmevbXHwvIUFBUV4d///jf+85//4PPPP8f69euhVCqZttVgWCwW/Pe//8XYsWPx4osvYs+ePejUqRPTtqrh6uqKlStXYtu2bc26RUp5eTnmzZuHadOmYerUqThy5AiOHDmCTZs2QaVS2bYLCQnBzz//jBUrVtT648Ni/xw9ehQjRoyATqfDkSNHMG7cOKYtNQqdO3fG3r17bef27NmzweVyMWzYMBw+fNj2eJVeeeUVAMDMmTNx6NAhDBo0CHw+H/PmzcMvv/yCgwcPIiIi4onrSbERqUbGxcUFLi4usFgsUKvVTW4W3NywWCzIzs4Gn8+Hl5cXjEZjk19Bk5ycjMzMTMyZMwfdu3eHm5sb05YA3I9EyeVyeHp6IiAgAJ6envD19UVpaSmKi4ttz1utVhQXFzNtt8GxWCxISEiAWq2GVCpFUFAQAEAoFMLHx8cWOfXx8UFQUBC4XC58fHxQUFAArVbbbCJTTYG8vDygKdRNAAAgAElEQVTk5eWhc+fOCAoKgr+/P7y9vW3Pl5SUoLy8nEGH9YtAIIBcLodKpUJQUBCcnZ0BAAEBAfD29rY9/s/Vqn5+fvDx8YG/vz+Cg4OhUqng4+ODgIAA+Pn5IS0tDdeuXXtiP037im+HjB8/HlOmTMGvv/6KYcOGITMzk2lLLE+Bu7s71q5dC7lcji+//BLp6enIz89n2lazRCwWY/ny5Xj22WexatUqFBcXY+7cuQCAd999FwKBAOvWrUNhYSHee+89ht02HqWlpZg1axbEYjGA+6vUFi5caPuhTUtLw4wZM+Dl5YUtW7bg1q1b+Oijj5rFraGmxt69e3Hx4kWMHj0ax44dA3D/Fu+SJUuwb98+ht3VH+3atcN3332H9PR0jBs3zrY4oFevXjh8+DD+3//7fwgPD68xGYiIiMDRo0exfft2jBgxAu+88w6mT5+O9evXY/ny5UhLS6uTH3Yg1ch4e3ujQ4cO2L59O2JiYhj1IpPJIJPJYDKZkJaWBr1ez6gfR4LL5doiHgqFAkKhEHfv3q3RUoWl8eDxeAgJCUHr1q2RnZ2N9PR0CAQCSKVSBAQEQCAQ2PKEAgMDIZfLkZWVhby8vCYdfbFYLEhKSrL97efnB5FIBJlMBuB+nkl8fDysVivatGkDvV5f53o6joTFYkFOTg4qKirg6ekJvV4PtVrt0BXt8/PzkZ+fj4EDB9o+X6vVCh8fn2q3uTUajUPfDZFIJGjfvj0MBgPi4uJs+xIcHAxXV1eUlZUhJiamxvd62LBhcHNzg0ajwa1bt1BZWQlXV1dkZ2cjNja2zn7YgVQzZtKkSZgyZQp++uknhIeHIzc3l2lLDoOrqytWrVqFwMBALFy4EElJScjKymLaFsvfKCwsxPTp0xEYGIjFixfDZDLhww8/hFwux4YNG5CVlYXx48dDo9E0q+hLXl4e3nnnHdtS+YqKCruvm9QQFBUVYebMmfD398eCBQtQWVmJKVOmNIlCsz///LMtIsXhcDB9+nRb9wqj0YiPPvoIp06dYtJig3D69GkMHz78gbemN27ciN9//x15eXmwWCz45ptv8MMPPzz1Z84OpFhY6gCXy0VgYCACAwORm5uLlJQUpi01KkSErKwsJCcnQ6FQICQkBFlZWXY1IDGbzUhLS4PZbIbRaITJZMK9e/fg4eFhqwydlJTU7CKxJpOJjZzifkQqLS0NJpMJlZWVEIlEeOaZZyAQCJCVleXQkamCggIUFBQAuD+Q+vtAmcPhQKVSITQ0FNnZ2Q4Zmar67hYXFyM0NBQajQY5OTkoLS1FaWnpA/9Po9FUK3GRm5tbPwEEInqYKCYmhnx9fQkAq3rQokWLyGq10qxZsxj3IpPJKCgoiP73v/9RcnIyvfrqq4x7chS5u7vTpUuXKDs7m5577jnG/TAhT09Pat26Ne3Zs4eioqKoc+fOjPpxdXWlM2fOkEajoe7du9se5/P5pFKpyNfXl3g8HgmFQvL39ydvb2/icDiMH0d7Ue/evamoqIiOHz9OYrGYcT+Nparzo2/fvvTXX3/RkSNHSKlUMu6rPqVQKCgwMJACAwMpNDSUtm/fTnFxcdSnTx/GvdVFIpGIAgIC6NVXX6X4+Hhav349CQSCBnkvPz8/un37Nv0ftY6V2IhUI+Hp6QkfHx9bNVV7KPym1Wqh1WohEAgQFBT0xLUzWJo3+fn5MBgMcHNzQ0BAAGP9yTgcDoKCguDl5QW1Wg0AKCsrsz1vNpuRnZ1t+9tisbCLPGqhrKwMsbGx0Gg0aNeuHfLz85Geng6ZTIaAgAAUFhY2ydvXVXXHJBIJ9Hp9tRpbTYXCwkIUFhYCuL9q08XFBYGBgXBycmLYWd2orKxERkYGWrVqZVuhy2Q/SXYg1Ui8+uqr+M9//oP169cjPDz8oeFHFhaWx0ckEmHhwoXo2bMnZs2ahevXr6OoqIhpWw7H7du3MXbsWPTq1Qu//vorzp49ixkzZmDgwIH49ttv8euvv+LTTz9tcon5Xl5e+PHHH8Hn8zFz5kxkZmY2i/IYLPUHO5BqYLy8vBAcHAyZTIb09HRkZWWxSd1NALPZjLi4OJSWliIkJAQ8Hg8JCQl2lSPUGFgsFsTHx9tyxoxGIxISEho174KIkJ+fj6ysLMhkMvj7+6OsrKzJVphvKEwmE/Ly8pCdnW3LLevevTt8fHyQkZEBPp+Pnj172gZSWVlZDh2hEggEaN26Nfz8/FBUVITy8nLk5ubacouaIiEhIfD29oZGo8HVq1dRUlLCtKWmAZsj1bB65513SKPR0NKlS8nd3Z2cnZ0Z9/RPrV69msxmM02cOJFxL44iDodDrq6u1KpVK7pw4QLduHGDWrRowbgvJiSVSik4OJj+/PNPun37NrVv354RD4GBgfTHH3/QnTt3GM/XcmQJBAJyd3eniIgIysnJoU2bNpFSqaR3332X8vPzqaCggAoKCmju3LmMe30aeXp60pkzZyg6Opq6du1KMpmMuFwu474aSjwejzZs2EA5OTkUERFB7u7uDZZX1FgaMmQI6fV62rdvHwmFwgZ5jwbJkZLJZHjuuedqVG/Ozc1FQkLCk75ck8fJyQkKhQIcDoe93dCEICKUlpbaavAoFAp06tQJHh4eiI6Otvvu8fWJTqcDESExMRHl5eVo164dpFIpoqOjGzQyxeFw0LZtW3h6egK4n/uhVqtRUVHhkCuR7AWTyYSioiJkZWUhJiYGSUlJKCwsREZGBmJiYmy5KM7Ozhg4cCDu3buHjIwMhl0/OVwuFzKZDG5ubraehE0ZIkJ6ejpiY2Mhl8vRvn173Lp1y6FvYxYVFeHs2bNQq9Xo378/srOzER8f3/hGnjQi1bdvX8rKyqKSkpJqWrduXZMezddVM2fOJKvVSsuWLWPcy4PERqTqLg6HQxKJhNq2bUtRUVF09epV8vPzY9wXExKLxdSiRQu6ePEixcXFUWhoaIO+n0AgoG3bttmuQVlZWTRkyBBycXFhr0X1ID6fT1KplJycnGzHWyqV2vTFF19QSUkJvf/++4x7rYu8vb0pKiqKUlNT6dlnn2XcT2PIycmJFAoF/fbbb5STk0MDBw5k3NPTiMfjkVQqpbFjx5JGo6Eff/yReDxevb5HvUakZDIZunXrhuDgYFy5csVWzK0Kg8GAYcOGITU19Ykb/jUFlEolunTpgvz8fERFRUGlUqFDhw5wcXHBkSNHkJiYyLTFBxIXF4c//vgD7u7uCA8Pr3Ubo9GIa9eu1XnWVnU8MjIyEBcX9zR2GYXH46Fbt25QKBTVHnd1dUVcXBx0Ol2zikb9HYPBgMLCQly7dg2enp7o3r07VCoVrly5Uu99vjp06IDAwEAUFxfj3LlztvfPyclpdnWhGgqFQoHOnTs/tMr5uXPnHG4FpEAgQLdu3aBSqRAdHQ2LxdJszpmKigpYrVZbxX8ej8e0padCLpeja9eu8PT0xMWLF5GYmMjMYojHjUh17dqVMjIyKDIykpRKJTk7O1fTpEmTSKfT0TfffMP4KJUJDRkyhAoKCujnn38mgUBAb7zxBul0Olq9ejWJxWLi8/mMe3yQBAIBSSQS2rhxI5WVldWqjIwM6tq1a53f41//+heVlpbSd99959C1e1xcXOiPP/6ocXwSEhKoXbt2JBKJHHr/6kMikYhCQ0MpJiaGoqKiKCAgoF5fn8vl0oYNG0ir1VJERITtGuTk5MRGoupRI0aMoOLi4gdeE7788ktydna262tbbZLL5XTq1ClKTU2lbt26NbvvrFAopN9//510Oh0NHjyYcT9PoxdeeIE0Gg3t3r2b3NzcGiTnq14iUm5ubhgxYgQA4OzZs0hOToZer68xw7RarXB2dq4RqXoYXC4Xzz//vG006YjNXpVKJXr37g1/f39ERkYiLy8Pr7zyCnx8fHD06FFERUXZfb6GyWSC2WzGjRs3HlhLymg0okuXLvDx8cG5c+cee7WHSqVCz5494evri6NHj8JgMOC1116rdVsiws2bN3Hv3r0670tDUXWuBgYG4t69ezXKV2g0GhQWFjbbaNTfqaysRHFxMU6dOgVXV1cMGjQI2dnZOH/+/FOvauzUqRNCQ0NRUlKCo0ePIj09vUl1tW8MJBIJ+vXrB6lU+tDtfH19cezYsQdGpG7fvu1Qx57P56N3797w8/PDnTt3kJSUhPz8fPY768DweDw4OzuDx+OhvLycuZW6j4pIWa1WMhqNdPHiRfL29n7g7GPixIlkNptp9erVjz3SE4lEtG/fPiooKHDYe7V9+/al/Px8Onz4MLm6utLYsWNJp9PR5s2bycnJqd7v1zakeDweCQSCWuXt7U0XL16ktLQ0ateu3WO/5ssvv0w6nY62bt1KTk5ONGPGDKqoqKDKysoaqqiooClTpjB+HGqTk5MT7du3jwoLC2nw4ME1jo+jzcobQ3w+n9q2bUt3796lq1evkpeX11O/5rfffkvl5eX09ttvk0AgaFaRhPpSUFAQxcXF1fod/Lv27t1LLi4uD7wmOFr0TyKR0LFjx0itVlOfPn2Iz+c3y/OnKUWkHGbVXnFxMU6cOIG4uDjo9XqYzeZat0tKSsLWrVtRWlqKiRMnPuplAdyf5aekpKCoqAgdOnSAt7c3Tp48aRdVv/+JVCrFkCFDaszi3NzccODAAVsNoZSUFPz666+4cuUKKisrHap4ncViqdFfSiAQ4IUXXoC/vz+uX7+OK1euPDRPytPTE4P/f3v3HdfktfgP/PMkgUBI2CgQgoLgwCplVFxtHXgdFdzQV53Vts7aum1t/TparaK1Xmfruq110KogaF246gUURZyAAsqekREIJGSc3x9e8itFqyLkSeC8X6/zerVJTD7JMzjPec4IDNS1TNrb2yM8PBxXr16FUqlESkoKDhw48NxZaO3t7TF58mRcuXLF4Nav4/F4MDExgVarpXMUvQS1Wo0nT54gMjISZmZmGDFiBHJzcxETE4Pa2tpGvSeXy4WJiQkIIXQbvCJzc3MMGjQIzs7OuHz5MhISEv7x9Tdv3oRCoXjuOd/YqNVqnD9/Hjk5OfD19YVYLMa5c+da3WhqrVaLCxcu4MmTJ+jWrRvatGmDmJgYo7wjZDBe1CJ1584d4uLi8sKrD4ZhCIfDIZ9++ilRqVRErVa/sFRVVZHg4GBiZWVFzp49S4qLi0nPnj1Zr+U+q7i7u5MHDx40+A4XLlwgNjY29a5sOBxOi7nSEYlEJCYmhhQWFpKAgIAX7gd9+vQhUqlU9/scOXKEmJub636Puv3kWYXH45Ht27cThUJBPvjgA9a/+1+LmZkZOX78OJHJZGTAgAGs5zGmwuFwiI+PD8nNzSV//vknsbGxafR7bdmyhY4wbWRxdHQkN2/eJGlpaaRTp07PPQ7rSks5h/21cDgcYm9vT65cuUJyc3OJt7c365nYKHXz4J0+fZqUlJSQ3r17s56pMcVoWqQIIdBqtS9ce6juDe/cuYOdO3e+6G0BPL1CePToERQKBaKiopCcnIy+ffuic+fOOHHihEHMMGthYYGgoCA4Ojri5MmTMDExqfd8eno6ampq6rU8taR1mmpraxEVFYV79+6hb9++8Pf3BwBUVFQgOjpa11fKwcEBQUFBsLW1xYEDB3T9Km7fvo3a2lrd71O3nzxL3eNcLlev6yb5+vqiV69euHr1KhITE9G3b194e3vXew3DMEhOTkZaWppRz+bMhrrzB4fDee1tWzdCz9nZGTNmzMC5c+cMsk+dIWIYBhwOBxwO56XO6S2NiYkJhg4divbt2yM+Ph5//vmnQfyNYQMhBBqNpkmOSQp4YYuUPmc2t7W1JbGxsSQvL89grhTEYjG5ffs2SUtLa7UzVwMg9vb25OrVq0Sr1RKtVkvS09OJh4eH7nk/Pz9SWFhILl++TKytrRv1GQzDkO3btxOVSkXGjx+vt++2dOlSotVqyZdffkmAp/1w6r5nXZHL5SQoKIj17WCsxdvbm+Tn55PY2Fhia2v7Wu/F5XLJ3r17iUKhIGPHjmX9uxlLcXJyIrdu3SIZGRnNPseXIRahUEjOnj1LpFKp0bbANGWxsLAgZ8+eJaWlpaRPnz6s52lMMZoWKX2qqanBgQMHIJFIMGzYMPTs2RO//fYb6zOv0tr60zl69u/fj0uXLgF42sowduxY3VUtl8vFvn37kJWVZTTrzfn6+mLgwIHg8/lYv349TExMsHjxYpSXl2P9+vX1XqtWq5Gens5SUuqdd95Bz549ATw9Hrt160aPy5dkZmaGsWPHQiwW4+TJk5DJZKyfU/WJy+UiODgYHTt2xLVr1xAbG4u8vDy2Y+lF//798dZbbz33+brfw1hb2R8/foxNmzaBEILPP/9c93hSUhLOnTunvyCG1CJVV5ycnEhSUhJ59OgR6dixI6s1XrFYTO7cudPqW6T+Xtzd3cnDhw91LTbXr18nDg4Or/We+m6RmjNnDtFqteTbb78lAMg333xDtFqt0c7UbMjldVuk1q5d26CVUKlU0haplyi2trYkPj6e5OXlke7du7OeR9+Fz+eTyMhIIpPJyMCBA1nPo8+ycePGBsdNXWkJo/bqyqhRo4hCodB9t+3btzdZHz+ja5H6O3rFabhKS0vx73//GzY2NgCerrUol8tZTvVyfHx8EBwcjICAgHqPnz9/HkqlElevXmUpWctVWFiIsLAwiEQizJ07F48ePcLhw4cbjN7z8/NDUFBQg2NfoVDg//7v/+o9xjAM3njjDXTr1k33mkOHDiEzM7NZvwtFGbr+/fujX79+kMlkDY6bOiqVqsX0L0xJScGqVat0M7VzOBysWLGi3msIITh37hxiY2Ob/PMNuiJFGa7y8nJs3bqV7RiN4uPjg6+//rrBRIMXL17ExYsXWUrVshUVFWHTpk3o1asXoqOjkZSUhGPHjjWoSPn6+uKrr75qsG2++OILrFu3rt5jJiYmOHDgAMaOHQsAkMlkiIuLoxUpqtV799138fXXX2PBggXYtGkT23GaXWpqKtasWaP7/xkzZmDbtm0NLsiqqqpoRYpqnUxNTTF58mS4urpi7969ePz4caPex9vbGx988AGUSiWWLFmie9zCwgJhYWE4ffo0zp8/31SxqWfIysrC8uXLYWVlheXLlzc40dXU1NTbNnXqRuv9lUajwS+//IJr164BeNpC9a9//QsDBgzA7t27jW4NOIpqKmfPnkVlZSWsrKwQFhaGo0ePtqqW9ri4OCxatKjB+UUkEiEsLAzHjh1DfHx8032gIfaRqpvvJCMjg3Tq1Im1+UwYhiESiYTcvn2bPHz4kLi7u7N+L7gll7/2kZowYQJhGIYwDEOEQiE5ffo0KS0tJW+//bbu8VctISEhRKFQkN27d9ebD2vp0qVEo9GQL7/8skXOnWNohWEYEhgYSCoqKohGo6lXfvzxx0ZvA0tLS3LhwgVSXFxMevTo8Y/7Atu/gT5/a3t7exIXF0dyc3NbbR+piIgIUlFRQQIDA+tt/5a+P2zYsIGo1WryySeftOjv+bJl/fr1RKPRkBkzZrz0v3mZPlLMC2beJnfu3MHQoUORn5//T69rUgKBAMOGDYOzszPc3NxQVlaGrVu36nUGWqFQiNmzZ8PZ2RmPHz9GUVGRbsQL1TwYhsG2bdswffp0XLx4EQ8fPgTwdIRgVlYWqqur0b59e1hYWDTq/SsqKpCdnY2UlBTd6EPg6a2+gIAAODo6ok2bNvj999/pLb5m4u7ujlmzZkGr1SIzM7PBXEbJycnPbH16GXXzBEkkEri5uUEgEDzzddnZ2di6dSuqqqoa9TnGwszMDNOnT4eHhwceP36MkpIS/PHHH3jy5Anb0fSKy+Vi0KBBcHd3R/v27cHhcLB9+3ZIpVLMmTMH5ubm2Lp1K4qKitiO2uR69eoFb29vuLi4wNraGj///DOuX7/OdizWrF+/HgsWLMDs2bNfer5LFxcXnDlzBl5eXgDw7I7bhtYixeFwCJfLJVwul7i7u5Pk5GRy9+7dJl9B/kXF3t6exMfHk8zMTNK9e3ddppeZ4b3utX99fd3j9Krg+b9b3czmKpWqXikvLyeDBg0iVlZW5OLFiw2ef9ly8ODBf1wTj47aa97C5XJJnz59SFFRETlz5gwRCoXN8jl2dnYkLi7uufvBtWvXiKOjo9GtFfeqpW5VAqlUSgICAljPw3YRCoXkzJkzpKioiPTp04c4OzuTxMREkp6eTrp06dJi9weGYcjOnTuJSqUyuBUj9F2aq0XKoPpIWVhYYP78+fDw8ADwtL/E5s2bUVBQoPerqMrKSqxevRrOzs6YPn06hEIhACA3NxcbNmx47jws/v7+mDFjBni8pz9tTEwM9u/fj6FDhyI0NBRHjx5FVFSU3r6HsQgNDcXQoUORmpqKqVOn1ntOrVbj3r17qK6uxnfffYc2bdo06jMyMzMbrCVI6YerqysWLlwI4GnH8ezs7Gabb6yqqgqrV6+Gvb39M5+3tLTE6tWrdXPQ1NTUNEsOyrAoFAqEhYXB1dUVoaGhMDc3x549e6BWq/Hpp59CJpMhLCys1bXYUa/PYCpSPB4PQqEQgwYNQo8ePQA87Zi6ceNGpKWl6T2PUqnEH3/8AbFYjJkzZ6Jr164Ant562LVr13OH+ru5uWHcuHG6RXsrKirw22+/4Y033kBoaCjS0tJw+vRp3evVanWrW6rhr7hcLrhcLvz8/BASEoK5c+di//79z339mTNnmi2LWq1GbW0tGIbRbb9nUalURrUYtSGwsbHB2LFj8fjxY6xYsaJZb9MrlUqcOnXquc/7+flh+fLlSE1NxbZt26BQKHSLUbeUBXqphtRqNWJiYmBjY4NJkybBzc0NW7ZsQUVFBWbPng2GYbBr1y7IZDK6IHYL9fdzfFP9/TWIipSZmRkWL16MTp064ddff8XmzZsBAHK5HAUFBaxmKy0txZIlS2BlZQUAsLKywqpVq2Bubv7M1+fk5GDatGm6jePp6Ylff/0VKSkpGD9+PLp164YDBw4AAAgh+OmnnxATE6OfL2OARo8ejZCQENy6dQvjx49HUlISa1l+//133L17F76+vrpt9HcKhQLr1q3DvXv39JyOai7e3t5YuHAhkpKSsHnzZlqZauGqqqqwYsUKWFhYICsrCyqVCosWLYKzszOWL1+OoqIirFmzBuXl5WxHpZrYoUOHkJiYCH9/f+zfvx/bt2/H5cuXX/t9DaIixePx8Pbbb8PHxwdbtmwxqGGaNTU19So6Xl5eWLJkCcRi8TNfHxERgcjISN0VzSeffIIhQ4YgNTUVR48ehZeXF4YOHQrgaUXq/PnziIuLg1KpbFW3nXg8HkxNTXW/x5UrV3Ds2DFWM92/fx/3799HQECAbhv9XVVVFfbv34+MjAwolcpW3Zr4MhiGgZmZGfh8PhQKBRQKBeuteVqtFjU1NaitrYW5uTlcXFwwePBgXat4dXV1g/mtqJZDpVLVG2wCPJ0uwNPTE4sXL0ZFRQWsra1RU1MDpVLJTsgmYmJiAlNTU2i1WlRXV7f6i4S7d+/i3r17GDhwIEaPHo0TJ040yfsaREXKmGRnZ2P69OkwMzN75vOFhYX1dtbTp08jOztbN/fR4cOHdaMmGIZB//79ER4ejo0bNzY4uFuyESNGYOrUqUhISMDYsWORmprKdiSdffv24cKFC898ztTUFGPGjMHUqVOxYsUKg8ptiMRiMVavXg0Oh4NFixYhLy+P9dFyGRkZmDp1Ktzc3LBjxw4UFhZi6tSpaNeunW49yU2bNtFKciuTn5+PWbNmQSKRICwsDFlZWVixYgXr++vrmDJlCkaOHImLFy8iJCQEd+7cYTtSi8R6RUogEMDS0hJKpRIymczgW2WqqqpeqcKTnZ2N7Oxs3f+npaXp+nwxDIPBgwejV69ecHV1haWlZYu5auDxeBAIBLoJ0Wpra+t16nVzc8PQoUORkJBQr8+YIUhJSUFKSsoznxMKhZg2bRq6d+8OJycn5OXlQS6X0z+6z2FhYYF+/fqhvLwcS5YsQWFhIduRIJPJcOHCBfTu3RvLly/H9evXERMTg2HDhmHQoEEoLS2ly1O1QnK5HJcuXYKPjw/WrVsHZ2dnmJiYsB3rtXTu3BlDhgzB8ePHcebMGZibm+u6qRBCWszfG7ZxXvyS5mNqaoply5Zh3759OHr0KCZMmIAHDx6wGUmvCCHYvn07xo0bB39/fxw5cqTB+m/GysfHB+Hh4YiMjERkZCQ+//zzBst+GKOamhp8/fXXmDlzJqZOnYp9+/bBzc2N7VhUI9y/fx8ffPABVq5cafS3cCjqRTgcDubPn687J4eHh8Pb25vtWC0Cay1SIpEIlpaW8PDwgKenJ9LT0xEXF8dWHNY8fPgQGRkZCAkJgZeXF8RiMezs7Ix25AiPx4OVlRXEYjG8vLx0nfIzMjLg4OCga3HkcDiQSqWorq5mM+4r02g0uHPnDnJycjB37ly0a9cOjo6OKC0tNYoWVer/q6ioqLfullKphFQqhUqlgr29PeRyuVHf1qEouVwOqVQKHo8HBwcHdOjQQTcCvbq6GmKxGJmZmaioqGhVLVNVVVWQSqUwMTGBvb09ZDLZa/WLZKWJgMvlYtGiRQgPD8eZM2cwbtw43L59m40oBkGj0SAsLAwhISEYNGgQjhw5Ah8fH7ZjNUrXrl0RHh6OESNGYPz48Rg+fDiGDx+OpKQkREZG4sSJEzhx4gSsrKwwfPhwHDx4kO3IjVJZWYmFCxfis88+w4IFC7Bnz57nDkCgjENsbCxGjhyp21dnzpzJdiSKei27d+9GUFAQOnTogIiICNy4cUN3Tp4wYQLGjBmDw4cP183a3SoQQrBt2zaMGjUKPj4+iIiIQO/evV/rPfXeImVtbQ1LS0uIxWI4OjoiJycHiYmJ+o5hcB49eoTc3FxMmzYNYrEYYrEYTk5OePLkiVGMIDIxMYGdnZ0ue2FhIZlHg4oAABTgSURBVBITE3X9oiQSCZydncHlcgE8vRpKSEhgM/JrUavVSE5ORllZGdzd3SESiZ47AIEyDmVlZbhx4wa6dOkCf39/3Lx5EwzDsD7KkKIaKzs7Gzk5ORg9ejScnZ2Rn5+vO+9aWFjAyckJfn5+EIlELCfVr6ysLOTm5mLmzJl46623YGNj81rvp9eKFMMw+OyzzzBixAjs3LkT33//fb2O2K2dSqXCqlWr4ODggHnz5mH+/PmYM2eOUbTWeXp6Ytu2bSgpKcGUKVNQVFRUb+bq8+fP47333tN14i0pKWErKkVRVKtBCMGWLVvw66+/Ijc3l+04LZLeW6T4fD4sLCyg0WhQXV1N+5T8BSEEWVlZkEqlcHBwgJeX13MXXjUUJiYmcHJygkQigaWlJYqKipCcnIzKysp6rysvL6cT3LUQbdq00S2ZpNVqUVRURJdZoSgDlpeXh7y8PLZjGBRCCIqLi5GZmQmhUAh3d3cAT7va/L0h4EX02keKEIIffvgBI0aMQEBAAI4fP95iRqm1Vq6urvjll18wd+5cTJ8+HQsXLnzu8jmU8eNyuViyZAlOnTqFU6dOISIiwmj781EU1XpptVps2LABo0aNwoABA3TntKNHj+o65L8svbdIcblc8Hg8EEKgVqtp/4Nn0Gq1yMrKgpWVFdq2bYuOHTs26yKvjWFiYgJXV1d06NABDMNALpcjIyPjuYs5U8bPyckJdnZ2EAqFuhE+Go0Grq6uz93udaOCSktLjWZUUEVFBVJSUqBUKtGlSxdIpVIUFxezHeuV1Z1HhEIhHB0d4enpiezsbDrVA0X9T1FREUpLS+uNWtRqtWjXrp1uRLmTk9M/rr0K4Gkr0T8Ucvv2beLs7EwAvHZhGIasW7eOZGRkkKlTpxKJRELMzc2b5L1bUmEYhjg4OJCuXbuSEydOkBs3bpCuXbuynuuvxdXVlVy+fJlcvnyZ+Pv7k7Zt2xIOh8N6Ln0XJycncuvWLZKRkUE6duzIep7mKgzDkLVr19Y7diUSCenUqRM5cuQIycrKemb5888/SY8ePYijo6PR7B8CgYBIJBIyd+5ckpmZSb788kvWMzV2m7Vp04a88cYb5I8//iAJCQmkS5curOcy9OLj40Py8/NJbGwssbGxYT1PcxULCwty9uxZUlpaSvr06cN6HjaLvb297pzm5eVFoqKidOew3NxcUltbS/7nmXUlvbVIubi4oG3btuDz+SgpKUFeXh5ycnL09fFGhRCCkpISKBQKFBcXQyAQwMPDAwzDIC0tjdUrShMTE3h4eEAikUAul0MulyMnJwdFRUWsZaKaVtu2bRtM5VC3Zp5UKq137Jqbm6OoqOi5gweKi4uRk5NjEDOav6zq6mpUV1dDpVJBIpHA2tqa7UiNUtcHRK1Ww8bGBmKx2Ohn6qao5iCVSnX/LRQKUVxcrDunmZqawtbW9h+PHb1VpD755BN8/PHHWLlyJb799lvIZDJ9fbTRqqqqwoIFC+Do6IgdO3ZAKBTi/fffR3p6OmuZbG1tsX37dohEIsyYMQOPHj2inchbmJCQECxbtqzeY4QQrFq1CmvWrKl37CoUCixbtuy5Td9qtZruHxRFGQ25XI5FixbpKk7Ozs44fPgwOnXq9Nx/0+wVKVdXV0gkEpiYmCAtLQ25ubl06PtLIoSgrKwMpqamEIlEsLOz083DxBYulwtbW1tYWFigvLwcpaWlrOahmo6joyM6dOgAS0tL3XqQdQghzzx2CSEttqJUWFiI2NhYqFQq9OnTRzcnD9WyVVVV4fr166isrISfnx8KCgqQkpJC19NsJer+7tYxNTV94ewCzT5qb+LEiYiOjkZxcTGCg4Nx9uzZ5v5IiqIaYfjw4YiKioKFhQWCgoLqleDgYJw5c4btiHp18uRJBAcHo7y8HNHR0Xj//ffZjkTpwaNHjzBx4kTs27cPu3btwurVq3VLXVHUszRbi1T79u3h4eEBU1NTXL9+HZmZmS32ypVqvZRKJa5evQo7Ozu8+eabsLOzQ1JSkkGNsHxZfD4fNjY2YBiGHqsAamtrUVtbC0IIrK2tjXbmepVKhYSEBBQUFOCNN96ASCRCUlKS0a1zqS8ajQYymQwFBQW4efMmnjx5gnfffRd5eXm4e/cubZmiGmi2itTo0aOxcuVKfPfddxg9erRRLHNCUa+qrKwM8+bNQ/v27XHo0CGo1WqMHDmSziBMGYzKykosXboUTk5OOHToEAQCAUaOHImMjAy2oxm01NRUTJw4Ef369cPevXtx6dIlTJ48mU4fQTXQ5BUpNzc3dOvWDQKBAOfPn8eDBw/oBI0tiEKhwMWLF2FnZ4eePXtCIpEgPj7eKFtgmgIhBDU1NVAoFDAzM4NWq9Utg0O1DOnp6YiKigLDMAgODsb9+/eNrhJSU1ODmpoa8Pl8CAQCcDisrFdvVLRaLaqrq1FbWwuBQGC0LZIA4O3tDVdXV9y8eRMFBQXw8/ODq6sr0tLSUFxcjCdPnrAd0ag1+dE0ZMgQHD58GAKBAKGhoYiIiGjqj6BYVFpaisWLF+Obb77BF198gY0bN8Le3p7tWBTVbKKjoxEaGgoOh4Pw8HAMHz6c7UgU9dIYhsFHH32EgwcPom/fvuDxeFi4cCF+/PFHREdHY+rUqXjw4AHbMY1ak7dIZWRkICIiAiqVCqNHj8bt27eRnJzc1B9DscTc3Bz9+vWDs7Mz4uLiUFZWRvtaGDk3NzcEBATA0tIShw4dMopFsvVJo9FAo9GAYRjw+XzweHpfEIJigb29Pd555x2IxWJERkbi1q1bRrc2rI+PDzp37oyqqiocP34cEokE48aNQ25uLqKiopCbm0u73TSFpp7ZnGEYwuPxyJIlS0htbS1ZunQp67OWGntp27YtSUxMJJmZmaRTp06sZnFyciI3b94kDx48IJ06dSJcLpf138cQipubG0lNTSXJyclEIpGwnudVyqRJk4hCoSBbtmwhPB7PaGYg13dZuXIl0Wq1ZMGCBaxnaUz56yz8np6erOcx9NKrVy9SVFRETp8+TaytrY3yuAgLCyNKpZJMnz6d8Pl8sn//flJVVUVGjRpFeDweYRiG9YyGXlxcXMj9+/f1O7N5ly5d0KtXL5iamuLnn3/GnTt3mvojKBbw+XwMHjwYYrEYV65cgVwuR1lZmdFdoVENpaen4+eff0Z5eTkmT56M27dv48aNG2zHMjiJiYnYs2cPzM3NMW3aNMTGxiI1NZXtWFQTs7Ozw+DBg9GmTRscO3YMDx8+RE1NjVGN1vP19YWPjw9qamrw888/IyUlBSqVCpcvX0ZVVRUeP35sNGtfGoWmbpGaPXs2UavVZO3atbS220TFEFqk7OzsSHx8PMnJySHdu3en2/ZvxZhbpICnLcl1x+6aNWtYz2OohcPhkLCwMKJSqcjHH3/Mep5XKbRF6uXKm2++SfLy8sh///tfYmtra5TnuhUrVhC1Wk3mzZtXLz/DMEb5fdgsrLRIMQyjGxFCCGnqt6dYxDAMGIbR7TxUy9ClSxcEBgbCysoKW7duRVxcHNuRDFZdqwSHwzGa0ZlmZmYIDg6GWCzG2bNnUVlZSecJ+wclJSXYs2cPTE1NMWnSJGRmZuLkyZNQqVRsR3tp165dw9atWyEUCjFnzhxcvHgR9+7do+ftZkJ7TVJUKxcQEIDvv/8eO3fuxNy5c+nJtoURCASYN28eXF1dMXToUNrd4gXy8vKwfPly9O7dG9HR0bhx4wZiYmKMqiJ16tQpnDp1Chs3bsSKFSswc+ZM3Lt3j+1YLVaTVaS6deuG9957D6ampli7di0uX77cVG9NUVQzunPnDtatWwe1Wo2lS5ciPj4ely5dYjsWRbGq7oLCWFoeKfY02TxSfn5++Oabb2Bvb49ly5bRNfUoykjcvHkTX331FUpKSvDtt99i8ODBbEeiKIoyGvTWngEyNTXFBx98AA8PDwBPr4wiIiJQVlYGqVSq1yx8Ph/jx4+Hm5sbTpw4AZlMhsLCQr1moJqXr68vRo4cCa1Wi6+++grx8fFsR6IagcPhYOzYsejevXu9xwkhOHnyJD12KaqZ0IqUAaqrSAUGBgIAioqKMHToUNy6dYuVLBMmTNDduk1ISNB7Bqp5de/eHV988QXtI2XkuFwuRo0ahdDQ0HqPP3nyBMOHD8e1a9dYSkZRLRutSBkQHo+HSZMmoWvXrrhw4QJOnjwJAKiurkZeXh7L6aiWKiEhAQsWLICVlRW+//57xMTE6PY9qqGoqCjk5eXBxcUFGzduxMGDB5GYmMhaHoZhEBoaih49euDu3bu4evVqvecVCgWysrJYSme8MjMzsWzZMlhbW2PlypW4f/8+fvnlF6OYf2nIkCEYPHgwSktLMX/+fNrK3NyaYh4phmHIlClTSG1tLdm8eTPr8z4Ya+Hz+SQyMpJUVlaSwMBA1vMAICKRiMTExJCioiISEBBA5yB5RmEYhri7u5OUlBRy7949o5xHCgCZNWsWnQPuJbc3l8slO3fuJEqlkowfP57VPBwOh+zatYsoFAry/vvv023XxCUwMJDIZDISGRlJ+Hw+63leptTNwj9v3jzWsxh70cs8Un5+fpg2bRrKysowe/ZsOsSyhVEoFNi0aRNcXV0RGhqKMWPGYPPmzbSF7H+srKwwd+5ctGnTBtu3b0dBQQFKS0vZjtUoly5dwowZM+Dk5ISdO3ciKiqKtkw9w5gxYzBo0CBkZWVh1qxZrN8y02q12L9/P65fvw5vb2/07dsXP/74I+7evctqLopqLV571F6HDh0wbdo0ODk5Yc+ePbQJsYVRqVQ4ffo0jh07hp49eyI0NBQ2NjZsxzIYAoEAY8aMwbBhw3DmzBkcOXIEcrmc7ViNkpycjN27d0OhUODDDz+Ej48PeDweHf79NwEBAfjoo48glUqxZ88epKensx0Jf/75J/bu3QuJRIJJkyahffv24HK5dNs1AUII1Go1tFoteDyebsJpQ6bRaHS3IOkx3PwMf4+gWGVmZoYlS5Zg7dq1+PXXX/H5558jNzeX7VhUMzp58iSmTJkCHo+H//znP3Q6BCOh0WiwY8cOzJo1C/3798fOnTvRpUsXtmMZvfv372PGjBm4cuUKduzYgRkzZhh8ZSoiIgJTpkyBra0t9u3bh/79+7MdqUV77b1Bo9FAqVRCq9WCz+eDx6P91xuDx+OBz+fX+z0NgYmJCQIDAxEUFIQbN24gIiKCLi/RwiUnJ+PgwYPQarUYM2YMOnfuDD6fb/B/PFo7QghiY2Nx5MgReHp6IiQkBI6OjmzHMnqFhYX47bffkJGRgXHjxqF3794GfyzcvXsXBw8ehEAgqDeVDtU8XntviI+Px/jx45GSkoKDBw/iww8/bIpcrQqHw8Gnn36Kffv24eLFi5g8eTLt30Cx7rfffkNoaCgcHBxw+PBhDBw4kO1IFEVRBue1K1L5+fmIjo5GUVERBgwYgK5du0IoFMLU1LQp8rUKDMPAz88Pw4YNQ3Z2Nk6ePImSkhK2YwF4epVbU1OD6upqmJqaQiAQGPzVGNU0UlNTERUVBS6XiwEDBsDd3R0WFha6wuVy2Y5IUXqj0Wggl8uh0WhgYWFhFH/jamtrIZfLweFwYGFhQe8YNZMm+4t44cIFjBkzBvn5+Th69CgmTJjQVG9NsaimpgbLly/HnDlz8PHHH2PPnj1o164d27EoPdq7dy/Gjh0LDw8PREREICIiAuHh4ejRowfb0ShKbxISEhASEoLExESEh4dj1qxZBt+Je9++fRgzZgzc3d1x5MgRvPPOO2xHapGarCKVn5+PmJgYlJWVwd/fHx4eHrC2tgafz2+qj6BYoNFokJiYiLi4OHTq1Alvv/02hEIh27FYxzAMhEIhRCIR5HI5ZDIZNBoN27GaxcOHDxETEwMejwd/f3/4+/vDz88PLi4usLKyole5VKtQUlKCCxcuID8/H76+vujYsSOsra1hbm7OdrTnqjt2LS0tERgYSPvMNZMmv0dz4sQJBAcHQy6XIzo6usFyBRTVEohEImzYsAE//PADNm3ahI8++qhFz61FCMHWrVsRFBSEoKAgvP/++wgMDMTvv/+ON998k+14FKU3ly9fxsiRI5GWlobjx49j2rRpbEeiWNbkFamCggLExsZCrVajT58+cHFxaeqPaFFEIhHatGmD2tpaFBcXQ6lUsh2pHoZhYG1tDTs7O1RVVUEqlRrFEgnNpe73aNu2Ldzc3CAWi5GcnIzExEQoFAq24zWrjIwMxMbG4u7du8jIyIClpSU6dOgAgUDAdjSK0huZTIa0tDQoFAp4enrCwcGB7UgvVFlZieLiYpiamsLBwYHeKWpitNcwixiGwdy5c3H8+HFcv34dI0aMaLBOFtvMzc3x3Xff4aeffsKOHTswceJEPH78mO1YrDE3N8fatWuxe/du7Nq1CxMmTGhVvweXy8WSJUtw5MgRnD17FqNHj0ZSUhLbsShKb/r3748TJ06gY8eOGD58OH766Se2I/0jQgi2bNmCESNG4K233kJUVBR69erFdqwW5YWdG0xMTODs7PzKI7Wsra0BPF1Cg7ZKPRuHw4GXlxd8fHywf/9+SKVSiEQiiEQitqPpiEQidOvWDZ07d4ZSqURZWRns7e3ZjsUaoVCIbt26wcvLCyqVCmVlZbCzs2M7lt7weDx07doVb775JhiGwZMnT2BlZQUrKyu2o+kFwzCwtLQEANjY2Bjkuc3MzAxmZmZgGAYODg4GmdGYeXp6wtfXF+np6SgpKQHDMAb/G2u1WkilUjg5OcHHxwcdOnQwiBn5jYGzs/ML+4EyhJB/ep4oFApkZ2e/8u0cOzs7tG3bFsXFxZBKpa/0b1sTJycnWFtbIy8vDzKZjO04DXA4HEgkEvD5fOTk5KCmpobtSKyivwcgFoshEomQl5eHyspKtuPoXdu2bWFra4uCggKDnJy27g+7QCBATk4Oqqur2Y7UolhaWkIsFqO8vBwFBQVsx3klrf3YbQwej4d27drV3Q595jDNF1akmiMYRVEURVGUkXlmRepFt/YMe5IMiqIoiqIoFtHO5hRFURRFUY1EK1IURVEURVGNRCtSFEVRFEVRjUQrUhRFURRFUY1EK1IURVEURVGNRCtSFEVRFEVRjfT/AH6+0vqTQ0AaAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 864x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "BDKKrKTPr6P-",
        "colab": {}
      },
      "source": [
        "#find coordinates of contours (boundaries)\n",
        "im1 = cv2.imread('/content/drive/My Drive/tt1.png')\n",
        "imgray1 = cv2.cvtColor(im1,cv2.COLOR_BGR2GRAY)\n",
        "ret1,thresh1 = cv2.threshold(imgray1,127,255,0)\n",
        "contours1, hierarchy1 = cv2.findContours(imgray1,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\n",
        "\n",
        "im2 = cv2.imread('/content/drive/My Drive/tt2.png')\n",
        "imgray2 = cv2.cvtColor(im2,cv2.COLOR_BGR2GRAY)\n",
        "ret2,thresh2 = cv2.threshold(imgray2,127,255,0)\n",
        "contours2, hierarchy2 = cv2.findContours(imgray2,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "jK3l98our6QK",
        "outputId": "86bbe1bb-3cd9-4dc1-c57c-622203a6386f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 237
        }
      },
      "source": [
        "plt.imshow(imgray1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fe2006d25c0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fAZtAAaIr5yh",
        "colab_type": "code",
        "outputId": "c2be036b-419a-4e72-8989-131ea1d85afe",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 237
        }
      },
      "source": [
        "plt.imshow(imgray2)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fe20064e4e0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ix8Zf-9RPGMw",
        "colab_type": "text"
      },
      "source": [
        "Contours returned are lists, so we change them into an array and extract the points. The array is an ndarray but we just need the points."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lW4o30l6fn_g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def extract_points(arr):\n",
        "  coordinates = []\n",
        "  for i in range(len(arr)):\n",
        "    pts = arr[i][:,0]\n",
        "    for pt in pts:\n",
        "      coordinates.append(pt)\n",
        "  return np.array(coordinates)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EVMDXMNJwH_u",
        "colab_type": "code",
        "outputId": "f7c7b7b7-147c-4474-f6fb-22ab29b99598",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "kp1 = extract_points(np.array(contours1))\n",
        "kp2 = extract_points(np.array(contours2))\n",
        "len(kp1), len(kp2)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5118, 5306)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AEzrkpqCOV0m",
        "colab_type": "text"
      },
      "source": [
        "### Triangle algorithm (with epsilon = 0.01)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kdV3n9Bsybx5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "global epsilon\n",
        "epsilon = 0.01\n",
        "\n",
        "def triangle_algorithm(list1, list2):\n",
        "  #put points in lists (array)\n",
        "  listA = list1\n",
        "  listB = list2\n",
        "\n",
        "  #normalize\n",
        "  listA = listA/listA.max() #normalize by dividing with the max value\n",
        "  listB = listB/listB.max()\n",
        "\n",
        "  #remove close points\n",
        "  listA = remove_close_pts(listA)\n",
        "  print('The number of points in list A is ', listA.shape)\n",
        "\n",
        "  listB = remove_close_pts(listB)\n",
        "  print('\\n The number of points in list B is ', listB.shape)\n",
        "\n",
        "  #create triangles\n",
        "  A_triangles = it.combinations(listA, 3) # returns an object\n",
        "  A_triangles = list(A_triangles) #change it to a list\n",
        "  B_triangles = it.combinations(listB, 3) # returns an object\n",
        "  B_triangles = list(B_triangles) #change it to a list\n",
        "\n",
        "  #triangles of triangles. for the normal triangle algorithm, skip these 2 lines.\n",
        "  A_triangles = triangles_of_triangles(A_triangles)\n",
        "  B_triangles = triangles_of_triangles(B_triangles)\n",
        "\n",
        "  #check sizes\n",
        "  print('\\n The number of triangles in list A is ', len(A_triangles))\n",
        "  print('\\n The number of triangles in list B is ', len(B_triangles))\n",
        "\n",
        "  #rearrange triangles\n",
        "  for i in range(len(A_triangles)):\n",
        "    A_triangles[i] = rearrange(list(A_triangles[i]))\n",
        "\n",
        "  for i in range(len(B_triangles)):\n",
        "    B_triangles[i] = rearrange(list(B_triangles[i]))\n",
        "\n",
        "  #find geometric attributes and store in dataframes\n",
        "  print('\\n Calculating geometric properties...')\n",
        "  df_A = create_df(A_triangles)\n",
        "  df_B = create_df(B_triangles)\n",
        "\n",
        "  #filter triangles\n",
        "  print('\\n Filtering triangles...')\n",
        "  dfA = clean_triangles(df_A)\n",
        "\n",
        "  global dfB #we use dfB as input in clean_triangles, that's why it's global\n",
        "  dfB = clean_triangles(df_B)\n",
        "\n",
        "  #check sizes\n",
        "  print('\\n After filtering triangles, we have ', len(dfA), ' triangles in A and ', len(dfB), ' triangles in B')\n",
        "\n",
        "  #match triangles\n",
        "  print('\\n Matching triangles...')\n",
        "  filtered = dfA.apply(filter_and_match, axis=1) #call the function and store results in dataframe\n",
        "\n",
        "  #We need to concatenate results into 1 dataframe\n",
        "  matched = pd.DataFrame(columns=['atriangle', 'btriangle', 'r', 'tr2', 'c', 'tc2', 'theta', 'logM'])\n",
        "  for i in range(len(filtered)):\n",
        "    matched = pd.concat([matched, filtered[i]], ignore_index=True, sort=False)\n",
        "\n",
        "  #check size\n",
        "  print('\\n There are ', len(matched), 'matched triangles')\n",
        "\n",
        "  #histogram before filtering with logM\n",
        "  plt.title(\"\\n $logM$ DISTRIBUTION BEFORE FILTERING WITH THE $logM$ filter\")\n",
        "  matched['logM'].plot.hist()\n",
        "\n",
        "  print(\"\\n Filtering with logM values...\")\n",
        "  #iterations of logM values\n",
        "  for i in range(20):\n",
        "    avg_logM = matched['logM'].mean()\n",
        "    std = matched['logM'].std()\n",
        "    matched = matched.drop(matched[abs(matched['logM'] - avg_logM) > (std*2)].index).reset_index(drop=True) #std*5 or 1.5\n",
        "\n",
        "  #check size\n",
        "  print('\\n After filtering with logM, we have ', len(matched), ' triangles')\n",
        "\n",
        "  return matched"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ElMOfhLDvihs",
        "colab_type": "text"
      },
      "source": [
        "# run 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tc5HFituKHZ5",
        "colab_type": "code",
        "outputId": "55fc0acd-7545-4f62-fd9a-8b5e8dec086a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 675
        }
      },
      "source": [
        "run1 = triangle_algorithm(kp1, kp2) "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The number of points in list A is  (34, 2)\n",
            "\n",
            " The number of points in list B is  (40, 2)\n",
            "\n",
            " The number of triangles in list A is  1994\n",
            "\n",
            " The number of triangles in list B is  3293\n",
            "\n",
            " Calculating geometric properties...\n",
            "\n",
            " Filtering triangles...\n",
            "\n",
            " After filtering triangles, we have  1235  triangles in A and  1234  triangles in B\n",
            "\n",
            " Matching triangles...\n",
            "\n",
            " There are  1174 matched triangles\n",
            "\n",
            " Filtering with logM values...\n",
            "\n",
            " After filtering with logM, we have  652  triangles\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAEaCAYAAAAyinE1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAd10lEQVR4nO3de7QcZZnv8e+PgFyEIWBiCEmGgEYxKCacDSKIC7mMXNTgjDJwvASGIboElSWORp2FyBzOgDcc9MgxCmNQh4soECBeuCPHIXGDISRcA4RJQki2ICQRJkh8zh/1Nul09t5dnby1uzv8Pmv12lVvvVX11GX302/V29WKCMzMzHLZqt0BmJnZlsWJxczMsnJiMTOzrJxYzMwsKycWMzPLyonFzMyycmIxM7OsnFjMzCwrJxYzM8vKicXMzLJyYjEzs6ycWMzMLCsnFjMzy8qJxczMsnJiMTOzrJxYzMwsKycWMzPLyonFzMyycmIxM7OsnFjMzCwrJxYzM8vKicXMzLJyYjEzs6ycWMzMLKuOSyySlkia3O44zMxa0e73LklvlDRP0mpJn5K0UNKhadpiSUcMWTAR0TEvYBfgz8C2mZYVwBMN5WOB54FnBphvMfACsBp4Fvgt8HFgq4Y6R9SNvyPVew54Bvh/wP7AmrrXX9Jya+MfaljfGuAp4IfAjv2tq6HuH4EbgHEN8Qfw+oays4EfN4uncbvSvCcB96V99hRwETC8Ib6VwKvryv4RuG2QYzPodjRMr72+02T67i3GPOA+LxNDibq7D3Cu9LePWz1PNoinhe2pP4+aHjPgBGAO8KdUfw7wCUD97IMvAL9oKHtkgLIT+olpU8/NOwc4Jpu9vBbPgU5477oYuGCQc3TQ8zDnq9NaLG8BHo6ItRmWNQlYBuwiaae68v8NLAXuHWTe90bETsAewHnA5ykO2kYk/RVwPfBtYFdgDPAVYG1E7Fh7Af+Vllsr+0nD+nZMMU+m+CcdLLYdgdHAirTeUlqIp7ZtZwLnA/8E7AwcmPbJjZJeVVd1GPDpsnGU3I762HaMiNObTH+yxZjL7PNmMTSNp4xWz5MB4mnlHIImxyztx38DvgbsBoyi+IB1MPCqfma5AzhI0rA0/2hgG2ByQ9nrU91N3QelZFxe2XOgE9679gAWZlj/oCRt3axOpyWWfSk+aQKgwuclPSHpWUlXSto5TdtK0lmSnpb0pKQTJb0oaZc0+yTg9xQ7ep80z37AQRQtit83CyYinouIWcDfA1Mlvbmfam9IdS+LiHUR8UJE/Doi5re68RHxFPCrFHuzuv8NXAVMbHU9ZaSE+RXgkxHxy4j4c0QsBo4HxgMfrqv+NeCzkoa3up6c29FizLX1l97n3aCF7RnwmKX/sXOAT0TEVRGxOgq/j4gPDfDm+TuKRFJb7yHArcBDDWWPtpJ0u0hb37sk3QK8C/iOpDWS3jDQ5S9JPwL+Grgu1f1cKt9d0s8k9Ul6XNKn6uZZnLZnPvCnZsml0xLLW4D6N+R/AY6m+NS5G7AtcFaadjZwBMUBnQicAayIiD+m6ZOBeWl5tYTwDYpPchPTtFIiYi7FJ4VD+pn8MLBO0kxJR9edHC2TNJZiexeVqLsDRcK7a1PX18RBwHbAz+sLI2INMBs4sq64F7gN+GyrK8m8Ha3EXFt/6X3eDVrYnsGO2dsp/teuLbveiHiR4lLZO1PRO4HfAHc2lG3UWtlCtPW9KyIOo9jfp6eW1cMDBRoRH2HDVtxXJW0FXEfRGhoDHA6cIenddbOeCBxLcVn5pcF2RqcllpezvqRRwCeB/xkRy+s+2fZIGklxMP4hIpZFxLPAL6n7xECR9WsHZx9J76M4uFdTnARNWywNnqS41LWBiFhFcY8lgO8DfZJmpfjLukbSamAJxbXsLzep+yzF/ZwjKT55VmEE8IcBTqDlaXq9s4BPpmNTRrPtuCZ90qu9Th1k+jWbEHOZfd4shmbx5DZYPK2cQzUDHbON9qOk36Z1viDpnfTvdtYnkUMo3uh+01B2e4m4BrLB9gPf3YxllV1e2XOgk9+7ytgfGBkR50TEixHxGMX72Ql1dS6MiCUR8UKzhXVMYpEkiuxcy/qHAPc1NJtHULxBHA7Mj4j6T2W7sv7Abgu8ifUHZxLFdffPUFy62gp4oMUQx1DcmN9IRDwQESdFxNi0DbsD32ph2celezqHAnuz8Zt2Y93hFJ/MTwdul7Rb3fR1FJck6m1DcWOxFX8ARgzQ5B2dpr8sIhZQ3GuaXnL5zbbjuIgYXvf6fn/zp9dxmxBzmX3eLIZm8eQ2WDytnEPAoMfsaRr2Y0QclI7X0wz8vnEH8A5Ju1K8ST1C0anloFT2ZjavxbLB9lN0JNgcZZbX9BzogveuMvYAdm9ItF+kuLdWs6TswjomsQB7Ausi4ok0PpLi02y9KRRN6xEUPbYAUHFz8GjWH9g3U/SeeIzigB0K3BsRd1E0Mxc0a8rVk7Q/RWK5s1ndiHiQoldOf/djms17e5r36yXqrouIn1MkknfUTfovivsJ9fYEnqA1/wmsBf62vlDSjhT7+uZ+5vkycCrFviplkO3YFC3H3Mo+7wabsD39HbPafpzS4ur/k6LDxKkU9wJqLfonU9mTEfF4i8vsBh373jWIaBhfAjzekER3iohjBplnQJ2UWPYFFtSN/w54u6TXSdpR0jkU2fMSiox9sKTXpxu2FwKvY31zcjLFp4JITc13UXwqhvXNzKYk/ZWk9wCXAz+OiPv6qbO3pDPTtW0kjaO4Frmp9wy+BRwp6a1NYpOkKRRdE+s/wVwB/LOksekm4RHAeyma4qVFxHMUN8K/LekoSdtIGg9cSXG/6Uf9zLMorf9TjdM2YTtatikxJ6X2eUbbSNqu7tW0l02LSm9Pf8cs/c98BfiupA9I2imdS5OAVw+yrBco7t18huISWM2dqWxLvb/Sce9dJawA9qobnwusVnGDfntJwyS9OX2oblknJZYNbn5FRC9wLsVJuZSieXhYRDwfETcDl1Fca+yl2NnPAw+m2Tc4ABFxW0TULoNMpvnBua7uevWXgG8CJw9QdzXwNmCOpD9RJJQFwJkltnkjEdEHXMr6G339xbYGWEWxf6ZGRH0Xw3MoLj/cSfEdka9SfBdiwUZLah7LVymaw19P65tDsU8OH6BnUG39A775tLAdtR4rtdfVVcU8yD7fpBhKmE3x/Yja6+yS85WKp8Q51GijY5b242eAz1G8Ca0AvkfR9f63gyzrduC1bNi6/00q68bEUmafd9J7V1n/SvEB9FlJn42IdcB70vofp7hs/AOKFmjLFFG6ddOxJH0cODYi3tvuWMzMytpS37tyN8GHhKQDKW6ELaG4GXYOxeUeM7OO9Up57+rKxELRJLyBorfTw8BJETGnvSGZmTX1injv2iIuhZmZWefopJv3Zma2BejWS2EAjBgxIsaPH9/uMMzMusrdd9/9h4go+5SMlnV1Yhk/fjy9vb3tDsPMrKtIavUL0y3xpTAzM8vKicXMzLJyYjEzs6ycWMzMLCsnFjMzy8qJxczMsnJiMTOzrJxYzMwsKycWMzPLqqu/eW/dY/z0G9qy3sXnHduW9Zq9krnFYmZmWTmxmJlZVk4sZmaWlROLmZll5cRiZmZZObGYmVlWTixmZpaVE4uZmWXlxGJmZllVllgkbSdprqR7JS2U9JVU/kNJj0ual16TUrkkXShpkaT5kvarKjYzM6tOlY90WQscFhFrJG0D3CnpF2naP0XEVQ31jwYmpNfbgIvSXzMz6yKVtViisCaNbpNeMcgsU4BL03x3AcMlja4qPjMzq0al91gkDZM0D1gJ3BgRc9Kkc9PlrgskbZvKxgBL6mZfmsrMzKyLVJpYImJdREwCxgIHSHoz8AVgb2B/YFfg860sU9I0Sb2Sevv6+rLHbGZmm2dIeoVFxLPArcBREbE8Xe5aC/w7cECqtgwYVzfb2FTWuKwZEdETET0jR46sOnQzM2tRlb3CRkoanoa3B44EHqzdN5Ek4DhgQZplFvDR1DvsQOC5iFheVXxmZlaNKnuFjQZmShpGkcCujIjrJd0iaSQgYB7w8VR/NnAMsAh4Hji5wtjMzKwilSWWiJgPTO6n/LAB6gdwWlXxmJnZ0PA3783MLCsnFjMzy8qJxczMsnJiMTOzrJxYzMwsKycWMzPLyonFzMyycmIxM7OsnFjMzCwrJxYzM8vKicXMzLJyYjEzs6ycWMzMLCsnFjMzy8qJxczMsnJiMTOzrJxYzMwsKycWMzPLyonFzMyyqiyxSNpO0lxJ90paKOkrqXxPSXMkLZJ0haRXpfJt0/iiNH18VbGZmVl1qmyxrAUOi4i3ApOAoyQdCJwPXBARrwf+CJyS6p8C/DGVX5DqmZlZl6kssURhTRrdJr0COAy4KpXPBI5Lw1PSOGn64ZJUVXxmZlaNSu+xSBomaR6wErgReBR4NiJeSlWWAmPS8BhgCUCa/hzwmirjMzOz/CpNLBGxLiImAWOBA4C9N3eZkqZJ6pXU29fXt9kxmplZXkPSKywingVuBd4ODJe0dZo0FliWhpcB4wDS9J2Bp/tZ1oyI6ImInpEjR1Yeu5mZtabKXmEjJQ1Pw9sDRwIPUCSYD6RqU4Fr0/CsNE6afktERFXxmZlZNbZuXmWTjQZmShpGkcCujIjrJd0PXC7pfwG/By5O9S8GfiRpEfAMcEKFsZmZWUUqSywRMR+Y3E/5YxT3WxrL/xv4YFXxmJnZ0PA3783MLCsnFjMzy8qJxczMsnJiMTOzrJxYzMwsKycWMzPLyonFzMyycmIxM7OsnFjMzCwrJxYzM8vKicXMzLJyYjEzs6ycWMzMLCsnFjMzy8qJxczMsnJiMTOzrJxYzMwsKycWMzPLqrLEImmcpFsl3S9poaRPp/KzJS2TNC+9jqmb5wuSFkl6SNK7q4rNzMyqU9lv3gMvAWdGxD2SdgLulnRjmnZBRHy9vrKkicAJwD7A7sBNkt4QEesqjNHMzDKrrMUSEcsj4p40vBp4ABgzyCxTgMsjYm1EPA4sAg6oKj4zM6vGkNxjkTQemAzMSUWnS5ov6RJJu6SyMcCSutmWMngiMjOzDlR5YpG0I/Az4IyIWAVcBLwOmAQsB77R4vKmSeqV1NvX15c9XjMz2zyVJhZJ21AklZ9ExM8BImJFRKyLiL8A32f95a5lwLi62cemsg1ExIyI6ImInpEjR1YZvpmZbYIqe4UJuBh4ICK+WVc+uq7a+4EFaXgWcIKkbSXtCUwA5lYVn5mZVaPKXmEHAx8B7pM0L5V9EThR0iQggMXAxwAiYqGkK4H7KXqUneYeYWZm3aeyxBIRdwLqZ9LsQeY5Fzi3qpjMzKx6pS6FSXpL1YGYmdmWoew9lu9KmivpE5J2rjQiMzPraqUSS0QcAnyIotfW3ZL+Q9KRlUZmZmZdqfQ9loh4RNI/A73AhcDk1PPri7WuxNbZxk+/od0hmNkrQNl7LPtKuoDisSyHAe+NiDel4QsqjM/MzLpM2RbLt4EfULROXqgVRsSTqRVjZmYGlE8sxwIv1L5XImkrYLuIeD4iflRZdGZm1nXK9gq7Cdi+bnyHVGZmZraBsollu4hYUxtJwztUE5KZmXWzsonlT5L2q41I+h/AC4PUNzOzV6iy91jOAH4q6UmKx7TsBvx9ZVGZmVnXKpVYIuJ3kvYG3piKHoqIP1cXlpmZdatWHkK5PzA+zbOfJCLi0kqiMjOzrlUqsUj6EcWvPs4Dao+yD8CJxczMNlC2xdIDTIyIqDIYMzPrfmV7hS2guGFvZmY2qLItlhHA/ZLmAmtrhRHxvkqiMjOzrlU2sZxdZRBmZrblKNvd+HZJewATIuImSTsAw6oNzczMulHZx+afClwFfC8VjQGuaTLPOEm3Srpf0kJJn07lu0q6UdIj6e8uqVySLpS0SNL8+m/6m5lZ9yh78/404GBgFRQ/+gW8tsk8LwFnRsRE4EDgNEkTgenAzRExAbg5jQMcDUxIr2nARS1sh5mZdYiyiWVtRLxYG5G0NcX3WAYUEcsj4p40vJriR8LGAFOAmanaTOC4NDwFuDQKdwHDJY0uvSVmZtYRyiaW2yV9Edg+/db9T4Hryq5E0nhgMjAHGBURy9Okp4BRaXgMsKRutqWpzMzMukjZxDId6APuAz4GzAZK/XKkpB2BnwFnRMSq+mnpC5ctfelS0jRJvZJ6+/r6WpnVzMyGQNleYX8Bvp9epUnahiKp/CQifp6KV0gaHRHL06Wulal8GTCubvaxqawxlhnADICenh4/CcDMrMOU7RX2uKTHGl9N5hFwMfBARHyzbtIsYGoangpcW1f+0dQ77EDgubpLZmZm1iVaeVZYzXbAB4Fdm8xzMPAR4D5J81LZF4HzgCslnQI8ARyfps0GjgEWAc8DJ5eMzczMOkjZS2FPNxR9S9LdwFmDzHMnxY+C9efwfuoHRbdmMzPrYmUfm1//ZcWtKFowrfyWi5mZvUKUTQ7fqBt+CVjM+ktYZmZmLyt7KexdVQdiZmZbhrKXwj4z2PSGXl9mZvYK1kqvsP0pugQDvBeYCzxSRVBmZta9yiaWscB+6ZlfSDobuCEiPlxVYGZm1p3KPtJlFPBi3fiLrH/Gl5mZ2cvKtlguBeZKujqNH8f6JxSbmZm9rGyvsHMl/QI4JBWdHBG/ry4sMzPrVmUvhQHsAKyKiH8Dlkras6KYzMysi5V9COWXgc8DX0hF2wA/riooMzPrXmVbLO8H3gf8CSAingR2qiooMzPrXmUTy4v1P8ol6dXVhWRmZt2sbGK5UtL3KH6H/lTgJlr80S8zM3tlaNorLP1g1xXA3sAq4I3AWRFxY8WxmZlZF2qaWCIiJM2OiLcATiZmZjaospfC7pG0f6WRmJnZFqHsN+/fBnxY0mKKnmGiaMzsW1VgZmbWnQZtsUj66zT4bmAv4DCKJxu/J/0dbN5LJK2UtKCu7GxJyyTNS69j6qZ9QdIiSQ9JevembpCZmbVXsxbLNRRPNX5C0s8i4u9aWPYPge9QPGes3gUR8fX6AkkTgROAfYDdgZskvSEi1rWwPjMz6wDN7rGobnivVhYcEXcAz5SsPgW4PCLWRsTjwCLggFbWZ2ZmnaFZYokBhjfH6ZLmp0tlu6SyMcCSujpLU5mZmXWZZonlrZJWSVoN7JuGV0laLWnVJqzvIuB1wCRgOfCNVhcgaZqkXkm9fX19mxCCmZlVadB7LBExLOfKImJFbVjS94Hr0+gyYFxd1bGprL9lzABmAPT09ORqRZmZWSatPDZ/s0kaXTf6fqDWY2wWcIKkbdPj+CcAc4cyNjMzy6Ps91haJuky4FBghKSlwJeBQyVNorhfsxj4GEBELJR0JXA/8BJwmnuEmZl1p8oSS0Sc2E/xxYPUPxc4t6p4zMxsaAzppTAzM9vyObGYmVlWTixmZpaVE4uZmWXlxGJmZlk5sZiZWVZOLGZmlpUTi5mZZeXEYmZmWTmxmJlZVk4sZmaWlROLmZll5cRiZmZZObGYmVlWTixmZpaVE4uZmWVV2Q992cDGT7+h3SGYmVXGicW2aO1M4ovPO7Zt6zZrJ18KMzOzrCpLLJIukbRS0oK6sl0l3SjpkfR3l1QuSRdKWiRpvqT9qorLzMyqVWWL5YfAUQ1l04GbI2ICcHMaBzgamJBe04CLKozLzMwqVFliiYg7gGcaiqcAM9PwTOC4uvJLo3AXMFzS6KpiMzOz6gz1zftREbE8DT8FjErDY4AldfWWprLlVMQ9s8zMqtG2m/cREUC0Op+kaZJ6JfX29fVVEJmZmW2OoU4sK2qXuNLflal8GTCurt7YVLaRiJgRET0R0TNy5MhKgzUzs9YNdWKZBUxNw1OBa+vKP5p6hx0IPFd3yczMzLpIZfdYJF0GHAqMkLQU+DJwHnClpFOAJ4DjU/XZwDHAIuB54OSq4jIzs2pVllgi4sQBJh3eT90ATqsqFrN2aFcHEX/j39rN37w3M7OsnFjMzCwrJxYzM8vKicXMzLJyYjEzs6ycWMzMLCsnFjMzy8qJxczMsnJiMTOzrJxYzMwsKycWMzPLyonFzMyycmIxM7OsnFjMzCwrJxYzM8vKicXMzLJyYjEzs6ycWMzMLCsnFjMzy6qy37wfjKTFwGpgHfBSRPRI2hW4AhgPLAaOj4g/tiM+MzPbdO1ssbwrIiZFRE8anw7cHBETgJvTuJmZdZlOuhQ2BZiZhmcCx7UxFjMz20TtSiwB/FrS3ZKmpbJREbE8DT8FjOpvRknTJPVK6u3r6xuKWM3MrAVtuccCvCMilkl6LXCjpAfrJ0ZESIr+ZoyIGcAMgJ6enn7rmNkry/jpN7RlvYvPO7Yt6+10bWmxRMSy9HclcDVwALBC0miA9HdlO2IzM7PNM+SJRdKrJe1UGwb+BlgAzAKmpmpTgWuHOjYzM9t87bgUNgq4WlJt/f8REb+U9DvgSkmnAE8Ax7chNjMz20xDnlgi4jHgrf2UPw0cPtTxmG1pfL/B2q2TuhubmdkWoF29wsxsC9OulpJ1HrdYzMwsKycWMzPLyonFzMyycmIxM7OsnFjMzCwrJxYzM8vKicXMzLJyYjEzs6ycWMzMLCt/897MbBO182kDnfxsNrdYzMwsKycWMzPLyonFzMyycmIxM7OsnFjMzCwrJxYzM8uq4xKLpKMkPSRpkaTp7Y7HzMxa01GJRdIw4P8ARwMTgRMlTWxvVGZm1oqOSizAAcCiiHgsIl4ELgemtDkmMzNrQaclljHAkrrxpanMzMy6RNc90kXSNGBaGl0j6aGGKiOAPwxtVJutG2OG7ozbMQ+dboy7a2LW+RuMthr3HlmDadBpiWUZMK5ufGwqe1lEzABmDLQASb0R0VNNeNXoxpihO+N2zEOnG+Puxpih8+LutEthvwMmSNpT0quAE4BZbY7JzMxa0FEtloh4SdLpwK+AYcAlEbGwzWGZmVkLOiqxAETEbGD2ZixiwMtkHawbY4bujNsxD51ujLsbY4YOi1sR0e4YzMxsC9Jp91jMzKzLdX1ikfQ1SQ9Kmi/paknDB6jXMY+KkfRBSQsl/UXSgD05JC2WdJ+keZJ6hzLGAeIpG3cn7etdJd0o6ZH0d5cB6q1L+3mepLZ0GGm23yRtK+mKNH2OpPFDH+VGMTWL+SRJfXX79h/bEWdDTJdIWilpwQDTJenCtE3zJe031DH2p0Tch0p6rm5fnzXUMb4sIrr6BfwNsHUaPh84v586w4BHgb2AVwH3AhPbGPObgDcCtwE9g9RbDIxo9z5uJe4O3NdfBaan4en9nR9p2po279um+w34BPB/0/AJwBVdEPNJwHfaGWc/cb8T2A9YMMD0Y4BfAAIOBOa0O+aScR8KXN/uOCOi+1ssEfHriHgpjd5F8d2XRh31qJiIeCAiGr/Y2fFKxt1R+zqte2Yangkc18ZYBlNmv9Vvy1XA4ZI0hDE26rRjXUpE3AE8M0iVKcClUbgLGC5p9NBEN7AScXeMrk8sDf6B4pNGo259VEwAv5Z0d3riQDfotH09KiKWp+GngFED1NtOUq+kuyS1I/mU2W8v10kfpp4DXjMk0fWv7LH+u3RJ6SpJ4/qZ3mk67Rxuxdsl3SvpF5L2aVcQHdfduD+SbgJ262fSlyLi2lTnS8BLwE+GMraBlIm5hHdExDJJrwVulPRg+tRSmUxxD6nBYq4fiYiQNFA3yD3Svt4LuEXSfRHxaO5YX4GuAy6LiLWSPkbR4jqszTFtqe6hOI/XSDoGuAaY0I5AuiKxRMQRg02XdBLwHuDwSBcbGzR9VExuzWIuuYxl6e9KSVdTXHqoNLFkiLuj9rWkFZJGR8TydDlj5QDLqO3rxyTdBkymuH8wVMrst1qdpZK2BnYGnh6a8PpV5hFM9fH9gOKeV6cb8nM4h4hYVTc8W9J3JY2IiCF/9lnXXwqTdBTwOeB9EfH8ANW67lExkl4taafaMEUnhX57g3SYTtvXs4CpaXgqsFGrS9IukrZNwyOAg4H7hyzCQpn9Vr8tHwBuGeCD1FBpGnPDvYn3AQ8MYXybahbw0dQ77EDgubrLqR1L0m61e26SDqB4f2/PB4929x7Y3BewiOJ66Lz0qvWa2R2YXVfvGOBhik+hX2pzzO+nuG67FlgB/KoxZoqeNvem18J2x1w27g7c168BbgYeAW4Cdk3lPcAP0vBBwH1pX98HnNKmWDfab8A5FB+aALYDfprO+bnAXh1wTjSL+V/T+XsvcCuwdwfEfBmwHPhzOp9PAT4OfDxNF8UPDj6azocBe252WNyn1+3ru4CD2hWrv3lvZmZZdf2lMDMz6yxOLGZmlpUTi5mZZeXEYmZmWTmxmJlZVk4sZmaWlROLmZll5cRiZmZZ/X8wfnJ8ZF+y8wAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8xcLjf-tNR-2",
        "colab_type": "text"
      },
      "source": [
        "### vote and finalize"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UhhKexw7C1IZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#extract vertices of each matched triangle for voting\n",
        "listAnodes = pd.DataFrame(list(run1['atriangle']), columns=['v1', 'v2', 'v3'])\n",
        "\n",
        "#concatenate the lists into 1 list\n",
        "points = list(listAnodes['v1']) + list(listAnodes['v2']) + list(listAnodes['v3'])\n",
        "Ap = pd.DataFrame(pd.Series(points), columns=['Apoints'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eGZVFVT7HVrA",
        "colab_type": "code",
        "outputId": "561df71e-bab0-4c4a-e863-2eafae9d0a80",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "#we want to select rows with the same points and count their score using groupby function\n",
        "\n",
        "#preprocessing for groupby. Function works with tuples not lists, so we change the points to tuples\n",
        "astuple = lambda x: (x[0][0],x[0][1])\n",
        "Ap = Ap.apply(astuple, axis=1) \n",
        "Ap = pd.DataFrame(Ap, columns=['Ap'])\n",
        "\n",
        "#groupby\n",
        "Avotes = Ap.groupby('Ap').Ap.count()\n",
        "Avotes = pd.DataFrame(Avotes)\n",
        "\n",
        "#delete those with less than 2 votes\n",
        "Avotes = Avotes.drop(Avotes[Avotes['Ap'] < 2].index)\n",
        "len(Avotes)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xodPoAE4F_kJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#the same process for listB\n",
        "listBnodes = pd.DataFrame(list(run1['btriangle']), columns=['v1', 'v2', 'v3'])\n",
        "points = list(listBnodes['v1']) + list(listBnodes['v2']) + list(listBnodes['v3'])\n",
        "Bp = pd.DataFrame(pd.Series(points), columns=['Bpoints'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vgcpiBLWIb--",
        "colab_type": "code",
        "outputId": "22586dcb-c7d1-47ee-e1f2-0264a7cfecbf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "astuple = lambda x: (x[0][0],x[0][1])\n",
        "Bp = Bp.apply(astuple, axis=1) \n",
        "Bp = pd.DataFrame(Bp, columns=['Bp'])\n",
        "Bvotes = Bp.groupby('Bp').Bp.count()\n",
        "Bvotes = pd.DataFrame(Bvotes)\n",
        "Bvotes = Bvotes.drop(Bvotes[Bvotes['Bp'] < 2].index)\n",
        "len(Bvotes)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "33"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M6Q24Mmh460P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#take the results from the shortest list\n",
        "if len(Avotes) < len(Bvotes):\n",
        "  selected_list = sorted(Avotes['Ap'], reverse=True)\n",
        "elif len(Bvotes) < len(Avotes):\n",
        "  selected_list = sorted(Bvotes['Bp'], reverse=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XuCMxAwJXpiF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#calculate the\n",
        "score = 0\n",
        "for i in range(len(selected_list)):\n",
        "  if i == 0:\n",
        "      score += selected_list[i]\n",
        "  elif selected_list[i] < 0.5*selected_list[i-1]:\n",
        "    break\n",
        "  else:\n",
        "    score += selected_list[i]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ILqwbP621Hmr",
        "colab_type": "code",
        "outputId": "61ba7a52-054c-4cd9-c8d6-8bb6046bb6db",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "print(score)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}