EixoMedial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math \n",
    "import random\n",
    "import time\n",
    "import warnings\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating random polygons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generatePolygon( ctrX, ctrY, aveRadius, irregularity, spikeyness, numVerts ):\n",
    "    '''Start with the centre of the polygon at ctrX, ctrY, \n",
    "    then creates the polygon by sampling points on a circle around the centre. \n",
    "    Randon noise is added by varying the angular spacing between sequential points,\n",
    "    and by varying the radial distance of each point from the centre.\n",
    "\n",
    "    Params:\n",
    "    ctrX, ctrY - coordinates of the \"centre\" of the polygon\n",
    "    aveRadius - in px, the average radius of this polygon, this roughly controls how large the polygon is, really only useful for order of magnitude.\n",
    "    irregularity - [0,1] indicating how much variance there is in the angular spacing of vertices. [0,1] will map to [0, 2pi/numberOfVerts]\n",
    "    spikeyness - [0,1] indicating how much variance there is in each vertex from the circle of radius aveRadius. [0,1] will map to [0, aveRadius]\n",
    "    numVerts - self-explanatory\n",
    "\n",
    "    Returns a list of vertices, in CCW order.\n",
    "    '''\n",
    "\n",
    "    irregularity = clip( irregularity, 0,1 ) * 2*math.pi / numVerts\n",
    "    spikeyness = clip( spikeyness, 0,1 ) * aveRadius\n",
    "\n",
    "    # generate n angle steps\n",
    "    angleSteps = []\n",
    "    lower = (2*math.pi / numVerts) - irregularity\n",
    "    upper = (2*math.pi / numVerts) + irregularity\n",
    "    sum = 0\n",
    "    for i in range(numVerts) :\n",
    "        tmp = random.uniform(lower, upper)\n",
    "        angleSteps.append( tmp )\n",
    "        sum = sum + tmp\n",
    "\n",
    "    # normalize the steps so that point 0 and point n+1 are the same\n",
    "    k = sum / (2*math.pi)\n",
    "    for i in range(numVerts) :\n",
    "        angleSteps[i] = angleSteps[i] / k\n",
    "\n",
    "    # now generate the points\n",
    "    points = []\n",
    "    angle = random.uniform(0, 2*math.pi)\n",
    "    for i in range(numVerts) :\n",
    "        r_i = clip( random.gauss(aveRadius, spikeyness), 0, 2*aveRadius )\n",
    "        x = ctrX + r_i*math.cos(angle)\n",
    "        y = ctrY + r_i*math.sin(angle)\n",
    "        points.append( (int(x),int(y)) )\n",
    "\n",
    "        angle = angle + angleSteps[i]\n",
    "\n",
    "    return points\n",
    "\n",
    "def clip(x, min, max) :\n",
    "    if( min > max ) :  return x    \n",
    "    elif( x < min ) :  return min\n",
    "    elif( x > max ) :  return max\n",
    "    else :             return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Polygon:\n",
    "\n",
    "    def __init__(self, poly, poly_name=\"Polygon\"):\n",
    "        self.poly = poly\n",
    "        self.poly_name = poly_name\n",
    "        \n",
    "    def plot_polygon(self):\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.set_aspect(1)\n",
    "        ax.set_title(self.poly_name)\n",
    "        x, y = zip(*np.append(self.poly, [self.poly[0]], axis=0))  # Repeating the first point at the end, for ploting purposes\n",
    "        ax.plot(x, y)\n",
    "        plt.show()\n",
    "    \n",
    "    def find_bisect(self, v, v_plus, v_minus): # Returns the bisect of v, between v_minus and v_plus\n",
    "        \n",
    "        vector_plus = [v_plus[0] - v[0], v_plus[1] - v[1]]\n",
    "        vector_minus = [v_minus[0] - v[0], v_minus[1] - v[1]]\n",
    "        \n",
    "        mod_plus = np.sqrt(vector_plus[0]**2 + vector_plus[1]**2)\n",
    "        mod_minus = np.sqrt(vector_minus[0]**2 + vector_minus[1]**2)\n",
    "        \n",
    "        vector_plus_std = [vector_plus[0]/mod_plus, vector_plus[1]/mod_plus]\n",
    "        vector_minus_std = [vector_minus[0]/mod_minus, vector_minus[1]/mod_minus]\n",
    "        \n",
    "        vector_bisect = [vector_plus_std[0] + vector_minus_std[0], vector_plus_std[1] + vector_minus_std[1]]\n",
    "        bisect_point = [v[0] + vector_bisect[0], v[1] + vector_bisect[1]]\n",
    "        \n",
    "        return [v, bisect_point]\n",
    "    \n",
    "    def find_intersection(self, line_1, line_2): # Returns the intersection point from line_1 and line_2\n",
    "        \n",
    "        D = (line_1[0][1] - line_1[1][1])*(line_2[1][0] - line_2[0][0]) - (line_2[0][1] - line_2[1][1])*(line_1[1][0] - line_1[0][0])\n",
    "        Dx = (line_1[1][0]*line_1[0][1] - line_1[0][0]*line_1[1][1])*(line_2[1][0] - line_2[0][0]) - (line_2[1][0]*line_2[0][1] - line_2[0][0]*line_2[1][1])*(line_1[1][0] - line_1[0][0])\n",
    "        Dy = (line_1[0][1] - line_1[1][1])*(line_2[1][0]*line_2[0][1] - line_2[0][0]*line_2[1][1]) - (line_2[0][1] - line_2[1][1])*(line_1[1][0]*line_1[0][1] - line_1[0][0]*line_1[1][1])\n",
    "        \n",
    "        x = Dx/D\n",
    "        y = Dy/D\n",
    "        \n",
    "        return [x, y]\n",
    "    \n",
    "    def find_distance_to_edge(self, v_1, v_2, p): # Returns the distance from p to the edge made by v_1 and v_2\n",
    "        \n",
    "        D = (v_1[1] - v_2[1])*(v_2[1] - v_1[1]) - (v_2[0] - v_1[0])*(v_2[0] - v_1[0])\n",
    "        Dx = (v_2[0]*v_1[1] - v_1[0]*v_2[1])*(v_2[1] - v_1[1]) - (p[0]*(v_2[0]-v_1[0]) + p[1]*(v_2[1]-v_1[1]))*(v_2[0] - v_1[0])\n",
    "        Dy = (v_1[1] - v_2[1])*(p[0]*(v_2[0] - v_1[0]) + p[1]*(v_2[1] - v_1[1])) - (v_2[0] - v_1[0])*(v_2[0]*v_1[1] - v_1[0]*v_2[1])\n",
    "\n",
    "        x = Dx/D\n",
    "        y = Dy/D\n",
    "        p_i = [x, y]\n",
    "        \n",
    "        distance = np.sqrt((p_i[0] - p[0])**2 + (p_i[1] - p[1])**2)\n",
    "        \n",
    "        return distance\n",
    "    \n",
    "    def find_minimum_intersect(self, poly): # Returns the vertice with the minimum distance to the intersection\n",
    "        \n",
    "        min_distance = float(\"inf\")\n",
    "        \n",
    "        for i in range(len(poly)):\n",
    "            \n",
    "            # Avoiding out of index operation\n",
    "            \n",
    "            if i+2 == len(poly): \n",
    "                bisect_1 = self.find_bisect(poly[i], poly[i+1], poly[i-1])\n",
    "                bisect_2 = self.find_bisect(poly[i+1], poly[0], poly[i])\n",
    "                intersection = self.find_intersection(bisect_1, bisect_2)\n",
    "                distance = self.find_distance_to_edge(poly[i], poly[i+1], intersection)\n",
    "                \n",
    "            if i+2 == len(poly) + 1: \n",
    "                bisect_1 = self.find_bisect(poly[i], poly[0], poly[i-1])\n",
    "                bisect_2 = self.find_bisect(poly[0], poly[1], poly[i])\n",
    "                intersection = self.find_intersection(bisect_1, bisect_2)\n",
    "                distance = self.find_distance_to_edge(poly[i], poly[0], intersection)\n",
    "                \n",
    "            if i+2 < len(poly): \n",
    "                bisect_1 = self.find_bisect(poly[i], poly[i+1], poly[i-1])\n",
    "                bisect_2 = self.find_bisect(poly[i+1], poly[i+2], poly[i])\n",
    "                intersection = self.find_intersection(bisect_1, bisect_2)\n",
    "                distance = self.find_distance_to_edge(poly[i], poly[i+1], intersection)\n",
    "            \n",
    "            if distance < min_distance:\n",
    "                min_distance = distance\n",
    "                v = i\n",
    "                \n",
    "        return v            \n",
    "            \n",
    "    def make_medial_axis(self): # Main function\n",
    "\n",
    "        temp_poly = self.poly[:]\n",
    "        medial_axis = []\n",
    "        virtual_points = []\n",
    "        intersections = []\n",
    "                \n",
    "        while len(temp_poly) > 3:\n",
    "            \n",
    "            # Finding the first intersection\n",
    "            v = self.find_minimum_intersect(temp_poly)\n",
    "            \n",
    "            # Avoiding out of index operation\n",
    "            if v+2 == len(temp_poly):               \n",
    "                line_1 = [temp_poly[v-1], temp_poly[v]] \n",
    "                line_2 = [temp_poly[0], temp_poly[v+1]] \n",
    "            if v+2 == len(temp_poly) + 1:\n",
    "                line_1 = [temp_poly[v-1], temp_poly[v]] \n",
    "                line_2 = [temp_poly[1], temp_poly[0]] \n",
    "            if v+2 < len(temp_poly):\n",
    "                line_1 = [temp_poly[v-1], temp_poly[v]] \n",
    "                line_2 = [temp_poly[v+2], temp_poly[v+1]] \n",
    "            \n",
    "            \n",
    "            # Defining medial_axis\n",
    "            bisect_1 = self.find_bisect(temp_poly[v], line_2[1], line_1[0])\n",
    "            bisect_2 = self.find_bisect(line_2[1], line_2[0], temp_poly[v])\n",
    "            intersection = self.find_intersection(bisect_1, bisect_2)\n",
    "            \n",
    "            v_1 = temp_poly[v]\n",
    "            v_2 = line_2[1]\n",
    "            \n",
    "            # Checking if one of the vertices are virtual\n",
    "            \n",
    "            if v_1 not in virtual_points and v_2 not in virtual_points:\n",
    "                medial_axis.append([v_1, intersection])\n",
    "                medial_axis.append([v_2, intersection])\n",
    "                \n",
    "            else:\n",
    "                if v_1 in virtual_points and v_2 not in virtual_points:\n",
    "                    medial_axis.append([intersections[virtual_points.index(v_1)], intersection])\n",
    "                    medial_axis.append([v_2, intersection])\n",
    "                    \n",
    "                if v_2 in virtual_points and v_1 not in virtual_points:\n",
    "                    medial_axis.append([v_1, intersection])\n",
    "                    medial_axis.append([intersections[virtual_points.index(v_2)], intersection])                    \n",
    "                    \n",
    "                if v_1 in virtual_points and v_2 in virtual_points:\n",
    "                    medial_axis.append([intersections[virtual_points.index(v_1)], intersection])\n",
    "                    medial_axis.append([intersections[virtual_points.index(v_2)], intersection])                    \n",
    "\n",
    "            # Updating temp_poly\n",
    "            \n",
    "            new_vertice = self.find_intersection(line_1, line_2)\n",
    "            temp_poly[v] = new_vertice\n",
    "            if v+1 < len(temp_poly):\n",
    "                del temp_poly[v+1]\n",
    "            else:\n",
    "                del temp_poly[0]\n",
    "            virtual_points.append(new_vertice)\n",
    "            intersections.append(intersection) \n",
    "        \n",
    "        # Making the last axis\n",
    "        \n",
    "        bisect_1 = self.find_bisect(temp_poly[0], temp_poly[1], temp_poly[-1])\n",
    "        bisect_2 = self.find_bisect(temp_poly[1], temp_poly[2], temp_poly[0])\n",
    "        intersection = self.find_intersection(bisect_1, bisect_2)\n",
    "        \n",
    "        for vertice in temp_poly:\n",
    "            if vertice in virtual_points:\n",
    "                medial_axis.append([intersections[virtual_points.index(vertice)], intersection])\n",
    "            else:\n",
    "                medial_axis.append([vertice, intersection])\n",
    "                \n",
    "        self.medial_axis = medial_axis         \n",
    "        self.intersections = intersections\n",
    "        \n",
    "    def make_medial_axis_3d(self): # Main function for 3d medial axis\n",
    "\n",
    "        temp_poly = self.poly[:]\n",
    "        medial_axis_3d = []\n",
    "        virtual_points_3d = []\n",
    "        intersections_3d = []\n",
    "        \n",
    "        # Converting 2d polygon to 3d with z = 0\n",
    "        \n",
    "        for i, vertice in enumerate(temp_poly):\n",
    "            temp_poly[i] = [vertice[0], vertice[1], 0]\n",
    "        \n",
    "        while len(temp_poly) > 3:\n",
    "            \n",
    "            # Finding the first intersection\n",
    "            v = self.find_minimum_intersect(temp_poly)\n",
    "            \n",
    "            # Avoiding out of index operation\n",
    "            if v+2 == len(temp_poly):               \n",
    "                line_1 = [temp_poly[v-1], temp_poly[v]] \n",
    "                line_2 = [temp_poly[0], temp_poly[v+1]] \n",
    "            if v+2 == len(temp_poly) + 1:\n",
    "                line_1 = [temp_poly[v-1], temp_poly[v]] \n",
    "                line_2 = [temp_poly[1], temp_poly[0]] \n",
    "            if v+2 < len(temp_poly):\n",
    "                line_1 = [temp_poly[v-1], temp_poly[v]] \n",
    "                line_2 = [temp_poly[v+2], temp_poly[v+1]] \n",
    "            \n",
    "            \n",
    "            # Defining medial_axis\n",
    "            bisect_1 = self.find_bisect(temp_poly[v], line_2[1], line_1[0])\n",
    "            bisect_2 = self.find_bisect(line_2[1], line_2[0], temp_poly[v])\n",
    "            intersection = self.find_intersection(bisect_1, bisect_2)\n",
    "            \n",
    "            # Defining intersection z value\n",
    "            z = self.find_distance_to_edge(temp_poly[v], line_2[1], intersection)\n",
    "            \n",
    "            intersection = [intersection[0], intersection[1], z]\n",
    "            v_1 = temp_poly[v]\n",
    "            v_2 = line_2[1]\n",
    "            \n",
    "            # Checking if one of the vertices are virtual\n",
    "            \n",
    "            if v_1 not in virtual_points_3d and v_2 not in virtual_points_3d:\n",
    "                medial_axis_3d.append([v_1, intersection])\n",
    "                medial_axis_3d.append([v_2, intersection])\n",
    "                \n",
    "            else:\n",
    "                if v_1 in virtual_points_3d and v_2 not in virtual_points_3d:\n",
    "                    medial_axis_3d.append([intersections_3d[virtual_points_3d.index(v_1)], intersection])\n",
    "                    medial_axis_3d.append([v_2, intersection])\n",
    "                    \n",
    "                if v_2 in virtual_points_3d and v_1 not in virtual_points_3d:\n",
    "                    medial_axis_3d.append([v_1, intersection])\n",
    "                    medial_axis_3d.append([intersections_3d[virtual_points_3d.index(v_2)], intersection])                    \n",
    "                    \n",
    "                if v_1 in virtual_points_3d and v_2 in virtual_points_3d:\n",
    "                    medial_axis_3d.append([intersections_3d[virtual_points_3d.index(v_1)], intersection])\n",
    "                    medial_axis_3d.append([intersections_3d[virtual_points_3d.index(v_2)], intersection])                    \n",
    "\n",
    "            # Updating temp_poly\n",
    "            \n",
    "            new_vertice = self.find_intersection(line_1, line_2)\n",
    "            new_vertice = [new_vertice[0], new_vertice[1], 0]\n",
    "            temp_poly[v] = new_vertice\n",
    "            if v+1 < len(temp_poly):\n",
    "                del temp_poly[v+1]\n",
    "            else:\n",
    "                del temp_poly[0]\n",
    "            virtual_points_3d.append(new_vertice)\n",
    "            intersections_3d.append(intersection)         \n",
    "        \n",
    "        # Making the last axis\n",
    "        \n",
    "        bisect_1 = self.find_bisect(temp_poly[0], temp_poly[1], temp_poly[-1])\n",
    "        bisect_2 = self.find_bisect(temp_poly[1], temp_poly[2], temp_poly[0])\n",
    "        intersection = self.find_intersection(bisect_1, bisect_2)\n",
    "        \n",
    "        z = self.find_distance_to_edge(temp_poly[0], temp_poly[1], intersection)\n",
    "        intersection = [intersection[0], intersection[1], z]\n",
    "        \n",
    "        for vertice in temp_poly:\n",
    "            if vertice in virtual_points_3d:\n",
    "                medial_axis_3d.append([intersections_3d[virtual_points_3d.index(vertice)], intersection])\n",
    "            else:\n",
    "                medial_axis_3d.append([vertice, intersection])\n",
    "        \n",
    "        for i in range(len(self.poly)-1):\n",
    "            medial_axis_3d.append([[self.poly[i][0], self.poly[i][1], 0], [self.poly[i+1][0], self.poly[i+1][1], 0]])\n",
    "            \n",
    "            \n",
    "        medial_axis_3d.append([[self.poly[-1][0], self.poly[-1][1], 0], [self.poly[0][0], self.poly[0][1], 0]])\n",
    "        \n",
    "        self.intersections_3d = intersections_3d\n",
    "        self.medial_axis_3d = medial_axis_3d \n",
    "        \n",
    "    def plot_medial_axis(self):\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.set_aspect(1)\n",
    "        x, y = zip(*np.append(self.poly, [self.poly[0]], axis=0))  # Repeating the first point at the end, for ploting purposes\n",
    "        ax.plot(x, y)\n",
    "        for axis in self.medial_axis:\n",
    "            ax.plot([axis[0][0], axis[1][0]], [axis[0][1], axis[1][1]], color = \"r\")\n",
    "        plt.show()\n",
    "        \n",
    "    def plot_medial_axis_3d(self):        \n",
    "        fig= plt.figure(figsize=(10,10))\n",
    "        ax = plt.axes(projection='3d')\n",
    "        ax.grid(False)\n",
    "        ax.xaxis.set_ticklabels([])\n",
    "        ax.yaxis.set_ticklabels([])\n",
    "        ax.zaxis.set_ticklabels([])\n",
    "        for edge in self.medial_axis_3d:\n",
    "            ax.plot3D([edge[0][0], edge[1][0]], [edge[0][1], edge[1][1]], [edge[0][2], edge[1][2]], color = \"b\")\n",
    "            \n",
    "        #ax.view_init(40, 60)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAIuCAYAAAC7EdIKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXhU5dk/8O9zlpkEYtgDCLKjssgma7AuiEtr64KFKqC+VqutWneLuFR8W+vWVqtV+1rbCgJatVat9GdLcEP2TURQ9kV2AgSSTDIz55zn98eTM2cmswUIJDPz/VxXL8xCMqFk8uV+7ue+hZQSRERERNlMa+gHQERERHS8MfAQERFR1mPgISIioqzHwENERERZj4GHiIiIsh4DDxEREWU9I83beWediIiIMoVI9gZWeIiIiCjrMfAQERFR1mPgISIioqzHwENERERZj4GHiIiIsh4DDxEREWU9Bh4iIiLKegw8RERElPUYeIiIiCjrMfAQERFR1mPgISIioqzHwENERERZj4GHiIiIsh4DDxEREWU9Bh4iIiLKegw8RERElPUYeIiIiCjrMfAQERFR1mPgISIioqzHwENERERZj4GHiIiIsh4DDxEREWU9Bh4iIiLKegw8RERElPUYeIiIiCjrMfAQERFR1mPgISIioqzHwENERERZj4GHiIiIsh4DDxEREWU9Bh4iIiLKegw8RERElPUYeIiIiCjrMfAQERFR1jMa+gEQUd1JKWHbNoLBIAzDgGEY0DQNQoiGfmhERI2akFKmenvKNxLRiSOlRDgchm3bqK6ujgk5hmHANE3oug5d1xmAiChXJX3yY+AhygCO4yAUCkFKCSEEQqFQJNRIKSP/c7nVH8MwGICIKJckfbLjkRZRIyalhGVZsCwLQghomoba/0gRQsQEGvfYKxwOR16v6zpM02QAIqKcxQoPUSPlOA7C4TAcx4kJNVLKmApPOm71x/04AAMQEWUtHmkRZYroCg2QuIJzJIEn0cevfQTmBiBd12EYBgMQEWUqBh6iTBDdmFw76ES/z7EEnkQfL1UA0nUdmsYJFkSUERh4iBq72o3JyQJNfQeeRB+/dgDSNC3mCIwBiIgaKQYeosaqdmNyuiBzvANPos+XKABFX4VnACKiRoKBh6gxStaYnMqJDjyJPn+6AFTXr4WIqJ4x8BA1Jukak9P93oYMPLW5zyGO40ReJ4SIOwJrLI+XiLIaAw9RY1GXxuR0v78xBZ7aogOQ+9+JeoAa6+MnoozGwEPUGLhVnXSNyak09sCTiDsHKPrrjp4GzQBERPWEgYeoIR1pY3K6j5Vpgac2NwC5GICIqJ4w8BA1lKNpTE4lGwJPbYkCUPQ0aAYgIqoj7tIiOtFqNybz6nZybsBxuX92lmVFXseN8ER0LBh4iI4DtwpTX1WdXJNsIWrtAMSN8ERUVww8RPWsPhqTKRY3whPRsWIPD1E9qc/G5HSfJ9t6eI4VN8ITUQ02LRMdT/XdmJwKA0963AhPlLMYeIiOh9pHKyfih6g7uJDqLjoAuUeNbvDhQlSirMLAQ1TfGqoxmYHn2HEjPFHWYuAhqi/Hsgervj4/A0/94kJUoqzBwENUH05UY3K6x8DAc3wxABFlLAYeomPlOA5CoVCDXzdn0/KJx43wRBmDgYfoaDWGqk7tx8PA07C4EZ6o0WLgIToajXFiMgNP48SFqESNAgMP0ZFo6MbkVBh4MgMDEFGDYOAhqiu3Kdi27UYVdKIFg0EAaJSPjRKr3QjNjfBExwW3pRPVRWNpTE5HCIE0/1ihRibVQlT37xsXohIdPww8RIhvTObQOTreuBCV6MTikRblvBO5B6u+RFehKDtxISrRUWEPD1FtjbkxOR0GntzDAERUJww8RNEyoTE5FQYeSrcRnvvAKEcx8BC5MqUxORUGHqqtdgCSUsZVgBiAKAcw8BA1tonJx4KBh9Kpyz4wBiDKQgw8lNsysTE5FQYeOlJciEo5goGHclMmNyanwsBDx4oBiLIUAw/lnsa4B6u+MPBQfau9ENX9nuFCVMowDDyUW9yqTiY3JqfCwEPHW7IAVLsHiH8HqZFh4KHckE2Nyakw8FBD4EJUygAMPJT9sq0xOZXor5OooTAAUSPEwEPZq3Zjci5ctWXgocYoUSN09BEYp0HTCcBt6ZSdsrkxmSjTpNoI7+JGeGooDDyUsdxenWxtTCbKdNwIT40Jj7Qo4+RKY3IqPNKibMCFqHQcsIeHskM27MGqDww8lI0YgKgeMPBQZmNVJxYDD+UCboSno8DAQ5mLjcnxGHgoFyVbh8GN8BSFgYcyT7buwaoPDDxE3AhPCTHwUGbhEVZqDDxE8bgQlcDAQ5mEjcnpMfAQpRe9D8zFAJT1GHio8WNVp+4YeIiOXO2FqEDiHiB+X2U0Bh5q3HJpD1Z9cKfX8s+J6OhxI3xWYuChxomNyUfHsizYts0/K6J6xoWoGY+BhxofKSXC4XDkBzefROqOgYfoxGAAyjgMPNS4sDH52DDwEDUMboRv9LgtnRqH2o3JnJFx9NywSEQnDjfCZy4GHjph2JhMRNmGG+EzB4+06LhjY3L9c6tkrJARNW5ciHrCsYeHGgYbk48PBh6izJRqISoDUL1gDw+deGxMJiKKlegIzHEcVFdXR17HjfDHBwMP1Ts2JhMR1U1dAhA3wtcPHmlRvWJj8onBIy2i3MCN8EeMPTx0fNVuTOY34PHFwEOUm7gRPi0GHjp+pJQIhUKs6pxAbrhk4CHKbYk2wgshIkdghmHk2vMyAw8dH+4PXjYmn1gMPESUCDfCJw88fLako+JeNw+FQgCQ7d9AREQZwf2Hp67rMRWeUCiEyspKHD58GFdeeWVDP8wGwVtadMTYmExElDncAAQAlZWV2L17dwM/oobBwEN1VntkOo9TiIgyS2VlJZo0adLQD6NBMPBQnbAxmYgo8wUCAQYeomTcK9BsTCYiymyBQABNmzZt6IfRIBh4KClOTCYiyi5VVVXIz89v6IfRIBh4KCHuwSIiyj6VlZWs8BABrOoQEWUzHmkRgY3JRETZjoGHclrtPVgMO42fEAJppqQTEcXhLS3KWe7EZNu2GXQyDP+/IqIjlcuBhw0aOcxxHASDQYYdIqIcEQgEUFBQ0NAPo0GwwpOD2JhMRJSbeC2dcgb3YBER5a7KykpWeCi7sTGZiIiqqqpytoeHgScHsDGZiIgAXkunLMaJyUREuU1KibvvvhsDBgzA3r17c7bCI9LM8uCgjwxVuzGZQSe7uEGWDedElI6UEl999RXmzp2L3//+92jVqhUGDhyIc845B+eeey569uyZTT8jkn4hDDxZiI3J2Y+Bh4iOxiWXXIJ33nkHO3fuxCeffIJPP/0Up556Kh5//PGGfmj1hYEnF7AxOXe4oZb//xLRkRg1ahQ+//xz+P3+hn4ox0vSJ0X28GQJ7sEiIqJ0wuEwfD5fQz+MBsHAkwXcqg4bk4mIiBJj4MlgnJhMRER1lesLhxl4MhQbk4mI6Gjk6s8LBp4MU7sxmVUdIiKqC7ftIVcx8GQQNiaTi//fE9GRCgaD2Xw7Ky0Gngzh9uqwMZmIiI5GIBDI2U3pAANPo8fGZCIiqg+VlZU5u0cLYOBp1NiYTERE9SWXN6UDDDyNEqs6RERU33K9wsOfpI2M25jMpZ+Uiw4cAK66Kg+ffMKnJqL6xh4eahS4B4sIGDasKfbs0fD55zq2b69s6IdDlFUCgQArPNSw3CMsdxmkpmkMO5RzPv1UYM8eAUDi8GEN48bl7vVZouOBgYcalOM4CAaDPMKinDd+fBMAAp06WQCADz80UVPwJKJ6EAgEcrppmYGngUgpEQ6HEQwGAYBVHcppS5dqKC9Xf//vuceqea3AT36Sm1udiY4HVnjohHMch43JRFEmTswHoL4PZswwa14r8c47PoRCDfawiLIKAw+dMG6vTjAY5GwdohqzZunYuVMDoDY5b9umvidMUwIQeOghVnmI6kNVVRUDDx1/7hEWG5OJPI4D3HKLuibbvLkKPLt36wCAO+5Qx70vv+xDeXnDPD6ibMIeHjru3MZk27ZZ1SGK8sorJg4eFNB1iY4dZc1r1a/jxlkAJBxHYPJk3tgiOlY80qLjho3JRMlVVQG//KUKMjfcEMbhw+p7wx0svn69jjPPtAEA06eb2LuX3ztEx4IVHjou2JhMlNqTT/oQCAhomsTkycFIoHEc9evSpTpuvz0Ued1dd7HKQ3QsWOGhesXGZKL09u8XeO45HwCJCRPCME2gujr2+2T5ch3f+55d07ws8cEHBjZu5PcS0dEKBAIoKCho6IfRYBh46hEbk4nq5oEHfLBqxu1MnhzCl1+6T0USQqgenpUrdfh8wKhRFgABKQV+/vO8Bnm8RNkg17elM/DUEzYmE9XNhg0Cb7yhZu1ccYWFjh0lXn9dvaxpgPt8XFYmsGmTwI9/7O6Xk/j8cwMrVvBpi+hoVFZWssJDR4+NyURH5p578iAlAAhMnhyClMB//qP2GDsOUF3tve/SpTpGjbKRlychpfq++tGPcnfbM9GxCIVC8Plyd64VA88xYGMy0ZFZtEjDxx+rcDN6dBinn+5gwQIde/e6gwcF/H51pJWfL7FkiQ6/H7jkEqvm7RK7d2uYPVtvqC+BKKNpWu7+2M/dr/wY1G5MZlWHKD0pgTvucHtwBCZNUjewpk0zYRgSeTVvcr+XTjvNwdKlKtiMHRsGIOB+m910k1slIqK6kPyGYeA5UlJKhEKhmMZkIkrvvfcMrFmjQwiJYcMsDBvm4NAh4J//NNC6tYStRu4gEFC/nnqqg1WrNFRXA6NG2WjSRB1raZrE/v0a3njDaLgvhigD5fpJBH9aHwHbtnndnBqNTPr7FwoBkyapOTpSCtxzj6ruvP22iaoqAccBwmEBIbxene7dHYTDAl9+qSEvDygoUEdazZqpf6nec08ewuEG+XKIMlKuV3kYeOrAbUwO1axt5hEW0ZF55RUTu3Zp0DSJ00+3cdFFqpwzbZqJ3r1t7N+vvp9atfKekLt2dQAgcqx19tnqevrBgxp8PomKCoGXXjJBROmFw2GYZm5/vzDwpMHGZKJjU1YG/PrXqrrjOAJ33x2CEMCXX2pYsULHmDEWbFsdVbkhBwBOOgno0MHBkiUq8DzyiPsPDonTT1fv96tf+VFZeYK/IKIMVFlZmdMzeAAGnqSiG5OllKzqEB2l3/7Wj4oKwDQlOnZ0cOWVauLgtGkm/H6JAQOsyPt27+4FnlAIGDzYxrJlKvB07qyOsxxH4JtvNDRp4iAYFHjyydy9ZktUV7m+Rwtg4EmodmMygw7R0dm2zT12EgiHBW6/PQTTVItD33zTxPe/b+GLL9wZPAK9enmBJxgEhgyxsWWLhtJS9T14zjnqenooJHDhhepY7PnnfZEjMSKK9c477+CSSy7Bs88+i0AgEJkZl4sYeBKwLIuNydToZUID4qOP+mFZQJMmEi1aOLjmGtVl/K9/GSgrE7juujA+/9ybqXP66Q7y8tTXFQ4DgwerALRkiXqquuACG4CAYUisXq2hWTMHtg08/DCrPESJjBkzBlOnTkWHDh2we/duFBcX44ILLsBjjz2G+fPnw7Ks9B8kSzDwJKBpGo+wiI7R8uUa3nrLhJQCgYDAz34Whruo+bXXTHTp4uDss22sXq1F9md17y7RurX671BIYMAAG7ouI43LxcXqydmyBNav13HjjWo+z4wZJrZt4/crUSKtW7fGsGHDcN5552HZsmWYNm0aunXrhldffRWlpaUN/fBOGAaeBBh0iI6NlMCDD/qhaaqyk58v8ZOfqKbjTZsEPv3UwMSJYezfL7Bvn7p2LoRE584O2rZ1A4/aq9WnjzeAsEcPiTZtnJppzBL/938+FBU5kBK4915/Q325RI1edNNy+/btcfXVV+Pll19Gu3btGviRnTgMPERU7z78UMe8eQYcR+DQIYHrrw+jVSv1tunTTWiaxIQJYcyZo4JMkyYSHTpI+P1A27bqGMudseM2LjsOIARQXGzDX5NtKiqA++4LAhD48EMDq1fzKY0okaqqKjR1S6w5is8ORBnI7S9rjH08lgU89JAfui7Rrp0DIYDbbgtF3jZjhokLLrDRoYNESYkBQKKsTKBbNxV0iorU1xQMqkrrkCE2Dh8WWL9ePV0VF6uXAfW/khIDHTs6AATuvJNVHqJEKisrGXga+gEQUXaZNs3E+vU6bFvg4EGBceMsdOyoQszs2Tp27dJw7bVhOA7w3/8aUMHFGzTYvr1636oq9fHcxuWlS73AAwCnn25DCIk5cww8+aRasb5okYF587hYlKi2qqoqXktv6AfQGLGHh+jolJcDv/61D4ahhggGgwJ33hmKvH3aNBNt2ji4+GILX3yhoaxMfa/ZtkDXrirotGunfj10SL2tZ08HzZp5jct9+zooLJRo106tobAsgTVrNHTrpoLQHXf4uViUqJbKykoUFBQ09MNoUAw8RFRv/vAHH0pLNViWwObNAt262ZHZOnv2qD6bCRPCME1g9mx1nOVyj7TcHh438GgaMGiQHQk8ug4MG2Zj1y6BwkIHgMRLL/nw/POqyrNunY4PPuBiUaJorPAw8BBRPdm5U+C551R1R4UWge9+15vxMXOmCdsWkVk8JSVGpPkY8I603B6eQ4e8t515po2vvtIim9SLi22sXatj7Fj18Q8c0FBRIdCrl6ry3Huvmv9DREogEGAPT0M/ACLKDo895kMopBqT9+8XyMuTeOwxdZwlpTrOKi620LOnxMGDaphg9NDX2oGnvNw7Wh4yxIZtC3zxharyjBzp9vGoYAUAv/mNH3/8o6ry7NqlYfr03F6USBSNFR4GnoTYw0N0ZL76SgUMIYDevR1YlsDYsWFoNc8w8+fr2LhRNSsDwCefqCvrblhp2dJBYaF6XzfwVFREB57YxuWBA234/RJbtmgYMkStm1i5UoffD/Tvr8LQww/7I43PRLmOt7QYeJJi6CGqu4cf9sOsKahs3qyeVu67z2tWnjrVRGGhxOWXq3OmkhI9MjwQALp183p58vLURvToLeitW0t06eINIPT7VdVn/nwdP/6xmrYMSDz3nNfLc+iQwAsvcOUEEcDloQADDxEdo48+0jFnjgHLUr02VVUC/fpZ6NJFhZiyMuDddw2MHRtGkybqeKukxECzZhItW0oIISMNyy7DAAKB2H90nHmm17gMACNG2Fi5UsMFF1ho2lQCEPjHPwy0bSsxbJgKVk895cPBg8f36yfKBFVVVbyl1dAPgIgyl22rIYNNm0qYJvDNNyqQ/Oxn4cj7vP22iepqETnOWrNGw65dGg4fFigslJAScYHHNIHq6tjPNXiwje3bNezapYLQyJE2HEdg1SodV10VBiBh28Cf/2zi2WeDACSqq1XoIcp1bFpm4CGiY/DGGwa++kpHIOBNRM7Lk7jsMu+K1LRpJs44w8aAASrUlJSoUFRd7VZwRKRh2RUIAAcPxlZ4Bg9WvTlulWfoULVYdN48Hddf7x5rAa+84kPXrg7OPVdtVv+///Nhxw4eUVNuY+Bh4EmKPTxEqQUCwK9+5a9ZDgp8/bUGXZe48koLbuV85UoNX3yh49prw3C/pUpKDLRvrwJOqKbNp3aFJ9G3X//+DkxTRhqXCwrU6xYs0NGvn1NzJV2grEzg9ddN/Pa3qspjWcCUKazyUG6rrq5Gfn5+Qz+MBsXAQ5ShGjqUv/iiDzt3ajh4UMPw4Tb279dg2wITJ3rHWdOmmfD7JcaNU6+rqFA3tpo1kygqcmp2YsU2LQNu4BExjct5ecAZZzgxfTzFxaqvJxgEbr5ZfQ6fT+KFF3zo0cPBRRepEPTmmya++YZPd5S7pJTQtNz+Hsjtr56Ijsq+fQLPPONDmzYOmjeXWLVKQ/PmDrp0cTBihDp6qqoC3nzTxKWXWmjRQv2+zz7TEQ6rHVtDh9qorBQwTYnWrWMDj7saYu/e+GOtFSt02OpTYORIG8GgwPLlOn74wzBMUyIUEtiwQcN//qPj8cerAag+oQcf5GJRyk2NcclwQ2DgIaIj9vjjPlRWAvv2aRg+3MK+fRrKyjSMH+/N3nnvPQOHDglcd51X8Zk920CTJhJ79mjo39+GlAKtW8uYIyzLQs2MnsSBp6JCRKo1w4erXqF583QUFgJXXKGal5s2das8EpdeakU+96JFfMqj3NXQVeGGxu/+JHL9LwZRMuvWafjb30wUFaljqeXLdXTurHpwrr7aCzevvWaia1cHZ52lyjHudfTTTlPv26NH7HZ0V/RKiT17Yp+i3MblJUvUsVarVkCvXmoeDwDcdJNqXg6Hgc8+M/Dllxp+9St3nLPEpEl5XCxKlKMYeIjoiDzyiA8+H7B7t+rd2btXrYg4+2wLnTurNLFhg8DcuQauucar+GzYILB1q4bCQgm/X6JlS/X6Tp1iG5bdDeqAWjgarXt3iRYtvMZlQPXxLFqkjrmGDHFwyik2QiF1W+yFF3zo2lVGdm4tX67jww91EOUS27ah6/x7z8BDRHU2b56OWbNMNG8uccopDhYt0tGvn43duzVMmOBVd6ZPN6FpMuZ1JSVqg/mBAwKDBtnYskU9/XTvHht43C3pgIwLPEKoKk/txuXycoFVqzQI4c0AatlS4u23DezaJfDII8GaYzOJyZPzIj1ARLmAU5YVBp4keKRFFMtxVONvixYSu3ZpGDbMxp49GoqKJAoKvF4ZywJmzDBx0UV2zHFVSYmBbt0cfPON+r3r16unn969k1d4avfwACrwfP21hvJy9XJxsUov8+apEDR+fBi6LrFrl4BlqUGEnTp54WvTJg1vvGHU058KUeNXWVnJwAMGHiKqo3feMbB8uY68PIkePWzMnatjxAgLCxbouOKKMNyZZv/9r449e7xFoYC6sfX55zr69rURDgsMH25j82YVZgYMiC23eIFHJA08UgqsWKECTocOas/WggXq5ZYtgVGjLEgp0Lu3g7/8xYdAAHjwwVDkeO2RR/xxk5yJshU3pSsMPESUVjAIPPqoHx07OjHVneHD1dXyCRO8ycpTp/rQtq2DCy/0Xjd/vo6qKoGTTlIvDx3qYOdODYCMm8HjHWmpPqHazjwztnEZUHu15s/XIw3Jd96pwlZpqboC//rrJjp0kPif/1G3uPbu1fDnP5vH8kdClDFY4VEYeIgorZdfNrF1q4ZwGOjTx8acOQaKiy0sXarHzN7ZtUvgv//VMWFCOLI9HVDHWX6/xL59Aj16OGjdWv23YQC1eylTNS0DqoLTo4cT07g8cqSN0lItckx21lk2WrVysGePht69bbzwgg+OA0yaFIJRc5r1+OP+mBthRNmKPTwKA08S7OEhUg4cAJ5+2o9evVRVZ+hQ1aT84x+HMXeugQkTvLURM2eacdOWAbU/a+RIG0uXquoQoIJNoufgQ4cATVOlmr17RcJr5G7jsvu2ESNUNcm9ni4EcMMN6jG0aiUjgwjbt5e48UZV5amoEHj2Wa6coOzHPVoKAw8RpfT0034cPqyOhwYPtvHhhwZGjLCwYYMGISTGj1fBwnHUKomzzrLQo4eXUrZtE1i7VseAATYOHFDHYFKqXVzNm8enmbIygaZN1evDYYGysvjHNHiwCl/bt6uk1aOHmgnkNi4DaiaPEBLLluno0MHBiy+qcHPvvSH4anLO88/7sHs3/3FD2Y1HWgoDD1GGOhFVyM2bBV5+2cSgQTb27dMweLCNXbs03H9/CG+8YeKcc2yccooKJ/Pm6di8ObZZGfCuo7shZvhwG6WlAo4j0KZN4sAT/dy8b1/801TtzelCqNtabuMyABQVSZx5po1AQGDUKAuffqoGERYVSfz0pyEAEqEQ8JvfsMpD2a2qqooVHjDwJMUjLWrsTsTf0Ucf9cMwgI0bNZxzjoX33zcwfLgFwwC2bNEi1R0AmDrVRLNmEpddZsV8jJISHaec4mDzZg3Nm0v07Olg40b12Dt0iL2SDqjAU1DgBaFEfTx9+zrw+2VM43JxsY1t2zR8+633/vfco9axf/ONFlk3AQB33RVGXh4ACEydauK11ziUjbIXj7QUBh6iDHW8FwIuWaLhnXdMDB5s4+BBDQMG2Ni5U8PkySHMnGnipJMkfvADFW4OHlS7s8aODSM/3/sYoRDw6acGRo+2sHixjmHDbGgasGaNeurp0iVx4HFvcwGJA4/PB/Tv78RNXAa8Ph4AuPhiG02bqmOtH/0ojLffNrB7t0CrVhK33qqqPFIC992XX/tTEGUNNi0rDDxEFEdK4KGH/GjTxsHKlTouvjiMt982MWyYjcGDbbz7rhEze+ett0wEg7GLQgFg8WId5eUCw4bZWLdOjzQsf/21CiXuPq1ohw4JFBamrvAAwJAhNr74Qke45lP26eOgWTMZE3h0HfjhD8NwHFU1six14wwAfv7zUE04EwgEBN58k8MIKTsFAgEUFBQ09MNocAw8RBRn1iwDCxYY6N/fRnm5OkLasUPD5MlBvP++gcpKgYkTVXVHSnWc1b+/jf79YwNMSYkOw1C7swDVvwOoIzIAaNcuUQ8P0KyZer1hyITDBwHVx1NdLbB6tfpYug4MG2bHBB5AXUUHJN55x8QPfmBFBhG2bAncfnuo5r0k7rvPf+R/UEQZgIMHFQaeJNjDQ5ngeBxrlZUBN9yQh1NOcTBvnoErrrDwxhsmhg61cd55NmbMMNGtmxOp1nzxhYZVq/S4ZmVANSwPH25j1SoVfAYNUr9n61b1/dW6dezjl1JVeNzbW4WFMm5juqt24zKg5vGsXaujtNT7/u3YUaJHDwfbt2u4/PJwZBAhANx6a6imX0jg4EENf/oTqzyUfdjDozDwEFGM667LQ1WVgN+vbjH16qXCwuTJQWzZIvD557Gzd6ZNM5GXJzF2bGzg2b1b4MsvdYwebWPhQh39+jmR21e7dqmnntqBp7ISsCyBFi3cwJN4nxYAdOok0aaNU2uRqKo6Rd/WAoA77lCPbdYsdePMHUTYvDlw551elefRR/MSzv0hykRPPvkk3nrrLZSWlrLCAwaelFjloVxz+DDw2WcGfD6JrVs1XH11GNOmmRgyxMaoUTZef92EEBJXXaUCRCCg+ncuu8xC86MgkWoAACAASURBVOaxH2vOHBU6zjnHwvLleuQ46/BhoKIicYXHXSvRsqV6fUFB8iMttTndwZIl3tPYwIEO8vJkzDweAJgwIQyfT+L//T8Dt94awoYNGv77X/U+P/1pKHKEVlkp8OSTvKZO2WHUqFHYsmULPvroI/zkJz/BHXfcgffeew9liYZb5QAGHiKKuOceP2xb4LTTHAgBdO/u4NtvVXVHSuD1102ce643e+fddw0cPhzfrAyo46y2bR3YNlBdLSJHYJs3q6cd05SoXWV310q0aqU+ftOmMmnTMqAal9ev13HwoHrZ51Ovq13hMQy1UDQQENB1iY4dncgV9cJC4K67QgAEAInf/c4XaYQmymRDhgzBfffdh+HDh+Pvf/87Lr30UixevBiXXHIJJk+e3NAP74Rj4CEiAOoI6q23TJimxJo1Gv7nf8L46199GDzYxvnn25g3T8fWrRomTPDSwGuvqX6ekSNjN57bNvDRRwbOP9/G4sUqfLgVHjfwtGghUbuIWjvwNGkC7NsnYMd++Ai3j2f58th5PCtXajh8OPZ9f/nLIADg2Wf9uPnmUGQQIQDcdFMocowWDAo89BCrPJQ9AoEAWrVqhfPPPx+PPfYY5s2bh8cee6yhH9YJx8CTAo+0KJdMmuSD4wh07uzA7wc6dfKqO0IA06ebKCyU+P73VZ/M+vUC8+YZuPbacFxwWbZMw8GDAqNHW1i0SEfnzg7at1eBwg08iW5oucs83QnMeXkSjiOwf3/i78VBg2wIIWv18dhwHBEJWq6+fSXatnWwcqWGsWPDMYMICwqAe+4Jwq3y/PnP6iYXUTZIdC1d03Lvx3/ufcVEFGftWg3vvmtC0yQ2bNBx000hvPyyD2eeaWP0aHU1/b33DIwZE440Hr/2mgldlzHTll0lJQaEkDjvPAsLF+oYOtQr0WzaJGAYEkVF8YHn4EEVbNzA4+68StbHU1gInHZabOPy0KE2DEPGXU8HgGuvDUNKgZdf9uGaa7xBhABw441htG6tjvIsS+Duu3lNnbJDVVUV8vM5XJOBhyhD1WcFcvJkH6QE2reXaNZMon17iW3bvOrOe+8ZCARE5DgrHFab0S++2EpYqSkpMXDmmQ7KywX27NEix1mAqvBoWnzDMuA1LTdvLpGXJ+HzqfdJ1cfjNi67t6uaNlVTmBMFnnvvDUHTJKZPN/Gzn4ViBhE2aaLeLqX6XG+8YUZ6g4gymeM4MAyOXGDgIcpxCxboKCkxAQjs2KHh1ltDePFFHwYNsnHBBSqozJhhont3B0OHqsGC//mPgb174xeFAsD+/epIa/RoVd0BEGlYBlTgse3Egcft4WnWDMjLU83GQLrAo7awb97svc/IkTaWLtVRXR37vvn5wKBBDvbuFaisFPj+971BhABw/fVhtG3rQNPUUdott+Sl/sMjoozBwJMCe3go20kJPPCAH5om0bKlg9atHbRqpa6ku9WdTZtUr0707J2pU020a+dEAlG0jz82IKXXv3PSSRJ9+qigFAwC27cL2LZIGngKCyV0HfD71a8AsHdv8qeqIUPiBxAWF1sIhURMM7Nr0iTVq/Pooz7cdlvsIML8fOC++0JwHPWFzpplYMcOPg9Q5jreO/cyCQMPUQ57/30Dy5bpcByBAwc03HVXCM8958PAgTYuvFAFCXf2ztVXq2rOzp0Cs2frmDgxjERV8pISAy1aSJx5poNFi3QMHmxHgsvWrVrkyCjZkZY7ZTkvD7BtkfZqeq9eDvLzJd5/33sw7hFa7Xk8AHDRRTYKCiQ+/tjA0KE2Bg2y8eKLJpyarRjXXRfGySc70HU1gfmmm1jloczHf8Az8BDlrHAYeOQRP0xTokkTiQ4dHDRtGlvdcRwVeM47z0aHDiqIzJhhwnEEJk6MP85yHLU/a9QoC5WVwOrVWsxx1qZN3pNu69aJN6W7gcfvlwgGVQNzqsBjGGor+wcfeIGnZUugd+/4vVquH/wgjFBI4LXXDNx2Wwjr1+uRQYR+P/CLX4Rg2+pzzp2rY+1a/rCgzOQ4DsNODQaeFPiXhLLZq6+a2LRJQzistoXfc08Izz7rx8CBNi66SIWUuXN1bNvmzd5xHHU76+yzLXTrFl+h+eorDXv3qv6dJUt0SCliGpY3bfKectxZO9EOHfIWh+blAdXVQNu2Evv2pf5ePOUUB44DVFV5rysutrFokQ7Lin//Rx4JApB4/nkfLrvMQocO3iBCAJg4MYxOnRwYhlvl4Q0XykxcHOph4CHKQeXlwOOP+1BYqH6od+3qwDQltmzRcP/9wUivzowZsbN35s7VsWVL4mZlQB1nAcD556v9WZomI8MBAdWw7G5OT9bD41V41ITmtm2dlBUeACgudgAIzJ0bO4+nokJg1ar4p7mTTwa6dnWwfr2G/fvVeonoQYQ+n+r1sSz1eVes0LB0KZ8uKfMEAgFeSa/B72CiHPTccz6Ulmo4fFiDZQlMmhTE736nqjsXX+ztvHrvPQNXXhmG+3w5daqJ5s0lfvCDBGUTALNn6+jXz0a7dhKLF+vo08dBYaH39s2btchE42Q9PM2aqf/Oy1NHWkVFyTemu0aOtGo+v3esVVycvI8HAH760zAAgcce8+O669Qgwhdf9Ko8V11loWtXp+ZqvMDNN7OXhzJPZWUlN6XXYOAhyjG7dws8/7wPHTs6EELi1FNt2DbiqjvvvWegqsqbvXPgAPCvfxkYN84LQNEOHQIWLdIxerQFywKWLNFj+ncAYPNmgYICCdOUMUHIVbvCU1Ul0LatxMGDAsFg8q/pjDNUP1D0dOWTT5bo0sWJ26vluvHGMAxD4p13TDRrpo6x3nrLG0RomqrKEwqpl9ev11FSwqdMyiw80vLwuzcF9vBQNnr8cR9CIXXbSkqBhx8O4be/9WPAAK+6A6hVEj172hgyRIWJN980EQwmXhQKqC3rliUwerSNNWs0VFSImMDjhiqfT1V3an97hcNqW7nXw6MqPG3bqpdT9fF06aIe4zffaJHbVoCaxzN/vo5EN3NNU729vFxgzhwtbhAhAIwbZ6FHD7WBHQBuuy0/4cciaqwCgQADTw0GHqIcsnathmnTTPTurZp8+/ZVayM2b9YwaVIoEkI2bhRYsMDAhAkWhFDzeqZONTFwoB2pptRWUqJm7gwdakcGDkY3LO/YIRAOCwiRfsoy4PXwFBWpz5eqj6d5c6BJE4mqKoH1672nteJiC/v3a1i3LvFT3YMPqrLRE0/40a2bjBtEaBjA/fcHUV2tPvfOnRr+8Q9OrKXMUVlZycBTg4GHKIdMmeJDfj5qAoDAlClBPP20H/362fje97y+nJkz1V6tq65S1ZzlyzWsXq0nbVaWUjUsn3OOBZ8PWLhQR7t2Djp18oKNuzQ0HE4ceNw1DtFzeNweHiD5Pi1X584qGLlhC0jfxzN8uIMWLdQurvJyRAYRvvGGV+W58koLp59uIz9fApC4915/TBWJqDELBALs4anBwJMCj7SoMTvSv58LFuiYNcvE8OEWqqsF+vWzsW+fwObNGu6/36vuRM/eOflkFTZee81Efr7ED3+YOPCsW6fh2281jB6tAsbixTqGD7djjq3cK+mBgEhyJd1dK+EdabnX0oHU05YB4PTT1UqI6MDTrZvakJ5sHg8A/OhHYTiOwB//6MPw4TYGDrTxwgveIEJdByZPDqGqSj2+Awc0/OUvZtKPR9SYMPB4GHiIcoCUwEMP+dGunbdZ/IknvOrOJZd41Z3PPtOxfbs3e6eyEnjrLROXX25FblDVNnu2+pijR1vYuVNg2zYtZkM6oBqWTVOirCz5WgkAkVtcfj8QDIpIhSfd1fRu3RxIqRqnXUJ4fTzJ3HNPGIDEX/9qQgjEDSIEgMsus9Cnjw31c0PikUf8CCfOfkSNCpuWPQw8RDng/fcNLFmi44ILLJSVaejXz8a33wps2hTbuwOoZuVmzbzZO+++a6C8PHmzMqCOs047zUanTjISOKL7dwB1pNWpk0RFhUCbNqkqPOplt8Lj96tjrnSBp2tXCSkFNmzQUFrqve+IETa2b9ewbVvi39+2rcTppzvYs0fDihUaLr88fhChpgEPPBBCZaX6GBUVAs88wyoPNX68lu5h4CHKcuEwMGWKH7162ZgzRzXc/v731XjqKT/OOCO2unPokLp6/sMfhpFXM3Zm2jQTPXo4GDEiflEoAAQCqkfGPc5auFBHfr5E//6xjS6bNmno0EG9LlWFJ7ppORwWsG2gqMhJ28Pj3tQCYqs8I0em7uMBgJ//PAQAeOIJH0zTG0QYPbTw+9+30L+/jYICAJB4+ml/pLmZqLGqqqpi4KnBwJMCe3goG7z6qomNGzVcfnkYO3dqOOMMG5s2adi4UVV3tKhngXffNVFVJTB+vKrmrFunYcECA9deG467Ru76/HMdwaDajg6owDNokA0zqgAiparwuJWdVIEnerUEgMjV9HSBp2tXFXh0PbaPp3dvB82by6TzeABg7FgLpilRUmIgEEBkEGF0lUcI4IEHgqioUDfNgkGBX//an/IxETU0Xkv3MPAQZTF3hcRZZ1l4800TgMQf/qCqO3372pFjK9eMGQZOPdXG4MEqPEybZsIwvE3picyebSA/X2LkSBuVlcCXX2pxx1mlpQIVFd6MncTX0tXCUHeoobuCorq6btOWTz5ZDTQsKooNPJqmjtdSVXjy8lT/UTgs8MYbBpo3jx9ECAAXX6y2q7u9PH/6kxm5XUbUGPFIy8PAkwarPJTJ/vAHtULiRz8KY+NGDb16Odi4UcOGDfHVnQ0bBBYu9GbvhELA668b+O53rchNqURKSgycdZaNvDxg+XIdti3iGpbdLelNm7qBJ/WmdACR4BMMijpVeHQd6NxZomlTiRUrtJjJzMXFNtav11MOL7z7bnWs9fzzqqqTaBChEGp2T0WFgKYBliXwwAOs8lDjxSMtDwMPUZbavVtdtR4zJoyXXlI/xJ95phpPPeVDnz523D6s2rN3PvzQwL59Gq65Jnl1Z9MmgY0btchxlts7U3ulhHsl3aiZ2ZfsWrpbAQJiKzxt26pm54qK1F9zly4OLAsIhQS++CJ2ACGAlLe1hg510KqVg40bdaxdq0UGEf71r2ZMr87o0TaGDnWrPOrPLboKRNSY8EjLw8BDlKUef9yHcBgYNy6ENWs09OjhYPt2DevX63HVHdtWs3fOP99G+/YqaEydauLkk51IM3IibhN0dP/OaafZaNky9v02b9YghISUqsemefP4j6UqPN7LXg+PN225Lo3L+/drkcfiGjDAQX6+TBl4hEDkJtrzz6uqzq23hnHggBYziNCt8pSXq2v2UgrcfTerPNQ4scLjYeBJg0dalInWrtUwdaqJG24I44kn8gAIPPFEEE895UPv3jYuvTS2uvPppzp27PBm72zfLjBnjo7x48ORqkwiJSUGunRx0KOHhOOogYO1qzuAqvB07KiWgLZqJWPClqusLLbC4+6vcnt4gPTDB7t1c1BeLtClixMTeHw+YOjQ1PN4AODHP1Zf/1tvGQgG1ZX22oMIAeDcc20UF1uRUPbBBwY2buRzBTU+7OHxMPAQZbBkgXzKFB8KCoAf/CCML77Q0LGjg0OHBNati6/uAMCMGSaaN5eR9RIzZphwHJHyOCsYVEMKzz9f9fysW6ehrEzENSwDqsLTtauD0tLEQweB+B4ev9/7PN605XQVHvV+p51mY9Gi2KWhI0bYWLVKw6FDyX9/p04SffvaqKrS8MEHRtJBhKrKE0J5uUBengNA4Pbb81I+NqKGwAqPh4GHKMvMn69WSNx5Zwi//KWq7jz8sOrd6dXLxmWXxVZ33Nk7V16pZu84jho+eO65Frp2Td6svHChjspKgQsv9I6zgPj+HUBNWVaBR0sZeGIrPOrX6moRCTzphw+qMkz79hKlpVpM1WXkSBuOI2Jm9CRyyy2qefm559QxljuI8MUXfTHv953v2DjnHAumqT7H3LkGVq7kUyo1Llwt4eF3J1EWcVdItG/voLjYwrJlOlq2dGAYAmvXJq7u/POfJqqrReQ469NPdWzdmrpZGVDHWaYp8Z3vqICzaJGOVq3U8Va0w4eB0lLVBJyswiOlCl6xFR7vSKt1awlNSz9t2V0g6t7wig43Q4bYMIzU83gAFXBMU2LFCqNmHQZw881hfPJJ7CBCQE1fLi8XKChQn/e221jlocbFsiz4fL7075gDGHjSYA8PZZL33jOwdKmOhx4K4sEH1Q/f++4L4emnfTj9dBuXX27F/Z7p002cfrqNM89UP7SnTlXHW7VvcdVWUqKjuNidPKwqPMOG2XEDCt0t6V27Oti/P/Hi0PJywHFEZI8WENu0rOsq9KQ70iooUFOZKypUeIru42nSBBg40Ek5j8f9GOpoT+3XAoDrrgvFDSIE1DHZqFFW5Hli5Uodn32W+uMTUcNg4CHKYDKqSSV6hUSXLhLLlulo0sRBy5YS33yTuLqzfr3A4sU6JkxQk5T371cNuFdd5a2WSGTnToHVq/XI7azSUnU9fdiw+Pk6buA55RQn6eLQ2nu0gNgKD6D6eNINHwRUH8/WrWp5aXTgAdQ8nuXLdVRVpf4YN9wQBiDw6qsmLAto0SLxIEJATV8uLxdo3lx97bff7o/pHSJqKJJ/EWMw8BBlsOgK5N/+ZmLTJg1TpgTx0EOq4/fmm8N45pnk1R139s6PfqTe9ve/mwiFBK69Nv1xFoDIlfVkC0MBL/CkmrJce48WELtaAgDatElf4QFUJWnzZjXtee1aHQcOeG8rLrYQCgksW5a6CnP22TZatXJw6JAWaVZ2BxH++c+xS0OHDnVw4YUWbFs9tk2bdMyaxSoPNR48qVAYeIgyVPST2OHDavHld75jwTCAFSt0GIZEly6quvOLX4Sg1/oZ7M7eGT3aRrt2akbOtGkmBg2y0bdvfKUmWkmJjvbtHfTurd5v4UIdpikxYECiK+kCrVs7qK5Wj7cue7SA2KZloG77tAA1i2f7doEzz1SPZfFi7wsfPtyGEKnn8QBqHYWaySPxpz+pY6xu3SQuucTCX/5ixi0Ndas87rygu+/Og518fBHRCcEKTywGnjSYjCkTPPecWiHx6KNBTJnihxAS48aF8ac/mTjtNBtXXBFf3fnkEx07d3qzd5Yu1bBmjR4ZvpeMZQEff2xg9Ggr0q+zaJFWM9wv/v3VlXTVsAwk26MVX+Fxj7TcCk/btg727BFpj4u6dHEgpUCrVg4MQ8Y0LrdoAfTpk76PB0DNn4uomVGkHt9tt8UPIgSAQYMcXHJJGIGAer/duzW8/nqKAUZEx9GiRYswfvx4vPTSS5BSMvjUYOAhynC7dnkrJHbu1LBqlQ4pBfr2dfD114mrO0D87J3XXjPRpInElVemDjxLl+o4dEhEjrOCQVVRSnScBajA062bEwk87sb0aGVl6tdER1puhaeoSCIUEpH3TaZbN/cKu4Z+/Zy4Pp4RI2wsXqzDSt2TjZ49Jc44w4aUAq+9ZkZ+b6JBhAAweXIIFRUCHTqoNzzwgD9mnxfRiTJ06FD87//+L8LhMHbt2oX+/fvj+uuvx4wZM7B79+6GfngNhoGHKMO5KyQefDCIX/3KB12XGDXKwvTpJk491caYMfE/2cvKVHPy2LFh+P1ARQXw9tsmrrjCQmFh6s83e7YOTZM491z1cb/4QkMwKBLO3wkG1dRmd+ggUPcjLdMEhJCRBmNv+GDqp60uXVTgcPt4li3TEQp5b1db3UWdZuZcf70Kf3/9qwo40YMIZ8+ODVL9+jm47LJwzdciUVamxSweJTpRhBDo0aMHxowZg6FDh2LFihW45ZZbsG3bNkyYMAHr169v6IfYIBh40uCRFjVmq1drmDbNxI03hrFsmY61a9W28sGDbaxZk7y68847sbN3/vlPAxUVIu1xFqAalocMcdCihXo52cJQANi6VYOUXuARQsZcPXeVlam3RYctIVSVJxj0eniA9MMH27WTyMuT2LJFBZ7qaoEvv4xeJKoeZ7p5PAAwZkwYhiGxe7eGjz5S7+8OIqx9RR1QVZ5AAJGBjb/+tR/l5Wk/DdFx4Q4d1HUdQ4YMweTJkzFnzhz07NmzoR9ag2DgIcpg552nJqjedVcIv/mNH36/RO/eNmbNMtCzp40rr0x8bjNjholevWwMHKiqIdOm+dCzp50wtETbt09gxQodF1zgfdyFC3V06eJEAkm0TZtUOOnWTc3gadlSJgxgalM64q7N+/3etXRvn1bqwCOEqvJs3uxVnaKPtdq1k+jWrW59PC1bAt/9rgUhJF59VVVrUg0i7N3bwRVXWDVX1yWqqgSeeYZD36hhcFN6LAYeogz1yivqKKlrVwf//reBLVvUy2edZWH16uTVnXXrNCxZ4s3eWbtWw6JFqlk5XUHTrXK483ekVBWeZP07mzapp5hUU5aB+D1arrw8GemDcW9ApavwAKrCsmWLhvbtJTp3duLWSRQX21iwQI/rw0lk4sQwpBSYNcvAvn3qcycbRAioKk91NXDqqeqD/+EPPuzfz0oxnXiVlZUMPFEYeIgykJTAww+bEELi3XcDeOopHwoLJYqKHMybZ6BHDwc//GHi6s7MmQZ03Zu9M22aCcOQuPrqNF28UMdZrVo5GDBA/TDftElg3z4tZcNyQYFE69bpA090/44rL89rWm7RAjDNul9N37JFg5TqqG3hwthFoiNHWjhwQMPatemfAkePttGihYRtC8ycaUQeS7JBhKed5mDsWAvffqtB0yTCYeA3v2GVh048VnhiMfCkwR4eaoyeeUZHWZnAJZdY+Ne/TOzcqeHwYYFzz7VrqjvBhNUdd/bOBRfYaNtWIhRSAeh737MS3p6K5jjAnDk6zj/fjhw9perfAbwt6UIgZeCpvUfLtWOHiDQHC1H3actduzqorBTYt09tb9+zR8PWrd738ogR6vGmm8cDqCOsq68OQwiJv/7VFwlOyQYRAsD99wcRCgG9eqlN6n/5i4nt2/lcQicWN6XHYuAhyjC2DTz2mA5dl3jyySr87nc+tGvnID9fYtUqDd27J6/ufPSRjl27vNk7//63gf37tbSTlQF1G6u0VIscZwEq8BQWypof7PE2bVJX0gHV/3OkR1qOA1RVeUGhqCj9AlEg+qaWiFSfovt4unaVaN++bn08ADB+vDrW2rxZi/yeVIMIe/SQuOoqCxs2aDAMCccBHnnEX6fPRVRfeKQVi4GHKMNMmaKjslLg6qttzJzpw/79GvbtExg50qqZuxOEkWTm3YwZJlq0kLj4Yu84q0MHB+efn34ssLtOIvp9Fy7UMWSIHddsDKhgtnWr6jGybeDgwcSLQwG3aTn+bU2bIqZSVVRUtyMtdxbP5s0aevVyUFgYO4BQCFXlmT9fr9Peq379HPTubUPXveZlIPkgQgD4xS+CsCygb18bgMBbbxlYt45PuXTisMITi999afBIixqTYBB47jm1xuHRRy08/7wfPXrYsG3g229VNWXs2MTVnYMHgVmzvNk7334rMGeOal5OdPxVW0mJjoED7cjRV1kZ8PXXyRuWd+wQCIcFunaVOHBAQMp0FZ7415umjBne17atU6fA06mTqvBs2aJB14HBg+MXiY4caWPnztijrlQmTgzDtgX++U8jsp/LHUT44ovxgwi7dpWYODGMNWt05OWpr3vyZFZ56MSprKxEQUFBQz+MRoOBhyiD3HuvjmBQ4KabbLz0koHycjWIb/BgtSgzVXXnnXdMBIPe7J3p01VV4ppr0h9nHTyodlKdf74XptwdVcn6d7wbWqmHDgaD6tgqUYXHNIFwWCBc8xCLiiT27RNp91Tl5QEnn+xEFpcOH25jzRotZkqzO4+nLn08ADB2rAVdlwiHBd58U/3ZCQHcemsI69bFDyIEgHvvDUFKr8oze7aBZcv4tEsnRlVVFY+0ovA7rw5Y5aHGoLwc+NvfVLXgzjttvPCCjgEDbBw+LHDwoKrujBuX/KbVjBkm+vSxMWCAOmKaPt3Euefa6Nw5/ZnOp58acByBCy7wksaiRaqPaPDg5A3LANJOWU60R8tl1pwUudfB27aVcBxRp2veXbs62LJFvd/w4WpFxNKlXijp1ctB8+bpF4m62raVOP98G6apjrXco7ArrrBw8smJBxF27ixx7bVhrFypo6BAApCYNIlVHjox3MGDpDDwEGWIW281YFkCd99t45ln1LqE0lKB7t1tbNyo4b77kld31q7VsHSpN3vnk090fPtt3ZqVAXWc1ayZxJAhsYHnjDMcJKuYb94sYJoSHTqkXhyaaK2EyzRjpyvXddoyAHTpIiOha/BgG5omY461NM3t46n7ks/x48MIhwXWrNGxdKlW8xiBn/408SBCQFV5hADOOENVeRYvNvDxx3ULWUTHgtfSYzHwEGWAffuAt99WM22uucbGK6/oOPdcB99+q9f0yTiRuTqJzJihZu+4FaBp01Tz8ve/n372jpSqYfm886xIoAqH1RLRoUOTny1t2qShSxcHuo40gUf9mqrCczSBp2tXB7t3awgEgIIC4Iwz4gcQjhypblLV5eMBwPe+Z6GwUELXJaZO9RqV3UGEL74YX+Xp0EHi+uvDWLxYR8uWDtwqDxdY0/HGpuVYDDxEGeCmm9SR0sMPW3jiCZU6Dh0SaN3awbZtWsreHcsC3njDxIUX2igqkti/X+CDDwxcfbVqXk7n66817NypRbajA8BXX2kIBETShmXAncGjfqq7gSfRLS23wpMo8Phq8oO7MLRNG6fm5bpfTd+6Vf3eYcNsLF0auyXdncdTl71agOoNcrfJv/22GdmT1aIFMGFCGG++GT+IEADuvjsE01SrJwCBb77R8f77da8sER0NXkuPxcBTB+zhoYa0ZQvw4YdazXVyienTNVx2mYOlSzX4fOoHe6rqzkcf6di925u98/rrBsJhcUTHWQBiGpbdo6FkDctSekMHARV4mjeX2YuDGwAAIABJREFUkYpNNK+HJ/5tbuCpXeFJtzEdQORzR/fxVFYKfPWV93sHDHDQpIms8zweQB1r2bZAICDw9tveF5RqEGH79hI33BDG/Pk62rVTj2vyZH9M+CKqb1VVVbylFYWBh6iRu+EGE1IK/OY3Fn79a71m3QKQny+xc2fq6g4AzJxpomVLBxdfbEFKdZw1eLBdU21Ir6TEQO/eNjp08Cowixbp6NDBwSmnJD6XKS0VqKgQkaGD+/envpIOJK7w6DpgGN6wwYICoGnTug0fdKtL0Te1gNgBhKYJDB1q17nCAwBDhzro3l0Fpehjre7dvUGEVVXxv++uu0Lw+9XqCQDYvl3DzJkJEiBRPWHTciwGHqJGbPVqgXnzBNq2lRg0SOKtt3Rcc42NWbM0nHQS0Llz6urOgQPABx8YGDfOgs8HLFmi4Ztv1KLQuqioUNe2o4+zABV4Um1Wd7ekR1d4WrdOHLDcCk+ipmVNk/D5Yo+w6jptuVUriZNO8hqXO3aU6NjRiZvHM2KEjVWrYq+spyKEWjURCAgsX67HNCqnGkRYVCRx001hfPaZjs6d1Z/dL3/pSxiOiOoDA08sBp464JEWNZQbbjAACPz+92H87/+qm1Jus+vevQL33RdMeEzk+sc/TIRC3uydadNMNG0qMWZM3QLP3Lk6QiERs05i+3aBHTu0NIHH25IOpN6jVVYmkJ8vE/YTCaFuakUHnLoOHxTCWyLqGjrUTtC4rK6s1359Klddpf78ak9edgcRvvBC/CBCALjzzhCaNnX/XCQOHNASHoER1YdQKASfj4trXQw8RI3U/PkCX3yhoVMnBx06ALNm6bj1VhszZuho1kz9MHd/8CYzY4aJvn1t9OvnoLxcBaAxY8I46aS6PYbZsw00aSIjzb2AdySUrmFZCInOnaMrPMkCT+LqDqBCi8+HmIWhaoFo3f4R0rWrg82bvfcdPtzGjh0avv3We93gwWq2Tl3n8QBAp04S3/mOhfx84O9/93ZppRtE2KqVxE9/GsInn+iR/WOPP+7HoUN1/tRER0RLtPclR/FPgqiRuvlm1Zjzxz9amDLFQFGRRF4eUFEhcPCgwKRJdsrqztdfa1i+XMf48Wr2zj//aaKysu7Nyu519LPPtmOqLwsX6mjSRKJv3+Q9QJs2aejYUVVtHCd1D8+hQ4kXhwJuhSf2SKtNG1mnpmVAzeLZulWLVFvckBZdzWnSBBg40DmieTyAal6uqBA4fFjg3Xe935tqECEA3HZbCAUFqpEZkKisFHj+ef4rnOqX5NyDOAw8RI3QrFkC69drOPVUB4YBfPKJhnvusfHyy2pib+fOEhMm2CmPW2fONGEYMtLjM3WqidNOszF0aN2alTduFNiyJXY7OqBWSqiqSPLfG31Dq6wMsO3ki0OTbUoH1HBA05SoqBCoqFCva9tW4uBBEbNjK5kuXRwEgwK7dqk/p759HTRtKuP6eIqLLSxfrh1RP82ll1po0kSisDC2eTl6EGH0jTBXy5bALbeE8NFHBgYOVAHs2Wd9dTqmIzpSbMnwMPDUAf/C0IkkJXD77api8NJLqrrToYNE69YS27er20+TJlkpA4eavWPgoosstGkj8fXXGpYsUc3Kdf3r7G5Hv+ACL/BUVACrVqXu3wHUlGU38LhrIFJVeJo1S/xx3AoP4FV53Kvp7rqJVLyr6eqpzjDUEVbtfp3iYhvhcOzqiXROOkmFnlAIWLDAwNq13tPpddeF0KSJTFrlufXWEJo1k2jRAhBCIhQCnnqKVR6i44mBh6iRmTlTw44dGvr3d1BWJrB4sYYHHrDw4os6/H6JTp0kJk5MXaUpKdGxZ4+GCRO8ycqmKXHVVXUf/FJSYqB7dydyvRsAli3TYdsiZeA5fBgoLdUiDcv79qmnmdSb0pMfablX7t1jrLZt1ddet/US6n2j+3iGDVO3styhgYA66hLiyObxAOpYq7paQNMkpk3zEmiLFmq7erJBhM2bq6Otjz4yavqjBF55xYzMDCI6VqFQCGaqfxXlIAYeokbEsoBf/CK6uqOje3cHPXpILFumIRhU1Z10Fy9mzjTRqpWDCy+0EAyqYYOXXGIlDR21VVerG1q1j7Pco6BUKyWil4YCqddKACrwJGtaVkda6r/dgFNU5A4fTB8OOnWS0DTvajqgwo3jxFZzmjdXx11HMo8HAL7zHRsdOjho00Zi5kwj5pgt1SBC9+0tWqg+J02TcBzgsce4WJTqB/doxWPgqQMeadGJ8qc/adi/X2DECAcbNgisWqXh4Ydt/PGPajN5x44S11yTurqzfz/w7397s3dmzTJw4EDdF4UCavZOVZVIGHh69bITTkV2HUngcRzg0KHEQwddek0GOZppy6YJnHJKbOAZMkRVc2ofa40YoY66wnX/Y4Kuqyvq+/YJ7N+vYdYsr3k53SDCwkLgjjtC+PhjA+edp6o8f/+7gdWr+bRMx66yspIzeGrhdxZRI1FdDUyZYgCQeP55C7/6lY4+fRwMGiTxr39psG2B+++Pre4kuomRaPbOKac4NT9U62b2bAN+v8RZZ3m/x3GAJUv0lNfRAW8GT10Cz+HDgJSpj7R0Xc27cQNPmzZ1XyDqPo7oWTzNmgF9+sQPIBw50kYgILBy5ZE9LY4fH4bjCDRr5sQ0LwPArbcmH0QIADfdFEKrVg4sS02UBoBHHmGVh44dKzzxGHiIGomnn9ZRUSEwerSDpUvVLa0pU2y88IIOIYCTT5a49tr0N6xmzDBxxhlq9s7WrQIff6xjwoRwpFJSFyUlOoqLbUT/A/HrrzUcPpy6fwdQ/TKtWzsoLFQvl5YKnHRS4sGC3h6t5IEHcK+iqxf8fvX+dQ08avhg7PsOG2ZjyRIddtSXUlysXjiSeTwA0LOnxODBNnw+4OOPjZh+oeLi1IMICwrUyolPPzXw3e9aAAT++18jLowRHSlOWY7HwEPUCBw+DPz2tzqEkPjtby089piBIUMcFBc7ePVVDVIKTJ6cvndnzRoNK1bokerO9OmqsjBxYt3PabZtE1i7Vo+5nQV4s2vSBx4tptG5tDT1lXQg8eJQQPXwSOkOG4wePli3acuA2qlVWhrbpDxsmI3ycoE1a2IHGnbv7hxx4AFUlWffPjVs8bXXvGpOukGEAHDjjWEUFakGdb9fzeZ5+GEfOEaFjkUgEEB+fn5DP4xGhYGnDtjDQ8fbo4/qCAYFLr3UwUcfqUnAjzxi4c9/Vq9v21biuusSV3eij7VmzFCzd8aNs2Db6uVRo2x06lT3n55z5qg+lNr7sxYu1NGmjRO5fZXMpk1aZGkokH7oIJB60rKU8fuzjmTasntTK/pYK9EAQkDN45k/30hYjUllzJgwfD51g276dDNmC7o7iPDFFxOn1SZNVJVn7lwDl18eBiCwaJGRNCAR/X/2zjs8inJvw/c7M7ubYOi9HIqAIIqgSLdSVPRYEZGO5VhR7HrQT0ApKnJs2Bu9qShHEQUONpReRBERIaB0BEJJ252Z9/vjddO2zSZRFN77urhCks3sZLPZefIrz+MFXeGJRAsejeYos2cPvPqqiWFIHn/c5sknLc45x+WssyTPPacueo88ElndEUIUEuOhEMyYYXHRRWoba+FCk23bkhtWBtXOqlPHzUv1DrNkiQoMjaf/c3Nh+/Z8Dx5InKMF8Vta4QpPZICoV7fl8Gp6/u3r1ZPUqBE5x9Ohg0NGhuDHH5N7aaxUCbp1szlwQLBrl8G8eYUT2W++OcRnn0U3IgS4/voQNWu6/PKLQZky4SpPIGnhpdGE0TM8kWjBo9EcZf79bxPbhl69XGbPNtm9WzB8uM3MmQYHDiix4GV2Z8ECkz17CnvvVK7scvHF3r13QiH4/HOLLl3sQsJm927lupxoYHnrVtV+S1bwxFtLV4JHtbDCAqB6denJeBAKmg/m314I1daKZkAIJO3HA6qtdeiQoEIFl/HjC6vTgQPjGxGmpsK99wZZvNiiZ09V5Vm/3uS995KLu9BowugKTyRa8HhAt7Q0fxRbtsDUqSaWBQ88YPOf/5hcdJFDu3aSUaPyqzvRBn6LMnWqjypVlPfO3r2Cjz+26NXL29eGWbbM5PBhQdeuhYWN1/mdzZvV70q4pSWlEjxVq0YXbOHQzNgVHuVPU62aJBQSHDigPl6tWuG4iXhUqKCOX7DCE/5etm418mInQGVv1apVvDmeLl0cqlRRnjzz5pls355/3LAR4TvvWDFbcQMGhKhd22XdOpPy5V1AMnRogGAw6VPRaMjMzNQVniJowaPRHEXuvddCSrj+eofp000OHBAMG+bwv/+pikqFCpLrrktc3Ql77/TsqSInpk+3CIW8B4WGWbDAxLIk55wTObAcCEhatox/LuGV9PCcz6FDEArFrvAcOKBcimOltxec4YF8751q1dzf308mNb3wy124WlWwrSWE8uP55hsz6aFhnw969LDZssXAdUXewHiYW28NEgrFNiIMBOD++4MsW2b+PmQu2LbNKOTgrNEkYt68eSxZsoTDhw+TlpZ2tE/nL4UWPB7RVR5NabNunWDOHAO/HwYNcnjhBZPu3R1atpQMHapaGV6rO++84yMUUt47Uqqg0DZtHJo2TW4IZMECi7ZtnYhsqyVLTE4/3Ul4LunpBmlpMk/ghD14Ym1phXO0Yv16FZzhgeKZD0J0wdOihUtqaqQBYceODjt3GsWKeejdO0QoJGjc2GHSpMKr6A0bSi6+2OaNN6IbEYKqAtWt67J4sfW7qJOMHOknMzPpU9Ecp5imydSpUxk3bhwvv/wyL774Ihs3btTp6WjBo9EcNe66ywQEgwY5vPmmSVYWPPqow7p1gpUrDcqWldx4ozfBMnWqjxYtHE491WXZMoOffjIZMCC5Xsju3YJvvzUjtrOys2HNGoO2bROfS3q62tAKCxgvsRLxXJYLzvCEzxEiBVAiGjRw+fVXUWh7yueDVq2cqIPLkLwfD8Bpp7mccoqD4wh++cVg4cLCxxg0KL4Rod8PDzwQZNUqk379VJVn3z6DV17RwaIab3Tu3Jnnn3+ePn36cOONNyKE4P7776dly5aMGDHiaJ/eUUULHo3mKLB4seCrr0xSUyX9+jm88opJnz4uTZpIhgxRF8kHHrBJSUl8rO+/N1izxqR3b9W+mjDBT1qa5MorvQ8rg2pnARFxEmvWmIRCIuHAMqiWVsGBZS9J6fEEjxDkzfBAZGK615ZW/foS2xZs2xZpQLh2rUFWVv7HmjZ1qVhRFkvwCKGqPJs3G5Qv70a0oxIZEQL06hWiQQOX+fMt6tZ1AMnYsf68+SWNxgs5OTk0btyY2267jQ8++IAVK1bQr1+/o31aRxUteDSaPxkpYfBg1bK67z6HF19Uvi8PP2yzaxfMm6dWk++4w1t1Z9o0lYR+zTU2hw7BrFkW3buHSLZ9v2CBaqM0bx65jg7xA0MBHAe2bi26oVX8pHTIb2mVKwcpKfmr6JUrq1DQZCo8UNiLB5TgsW3BypX54sYwoH175cdTHK65xsYwJI0aSebMsQptkxU0IgwLzKL4fPDgg7msXWvmGUYeOQLPPqurPBrvFF1L9/l81KtX7yie0dFHCx6P6BkeTWkxf75g7Vo163LZZQ7jxxvccINL/fowZIiFlII773Q8VXeU946Piy6yqVxZMmuWj6ys5IeVHQcWLrTo3NnBKPKqsHSpQcOGbl6GVSy2bxeEQiLCZRniCZ7YK+mQL3iEKGw2aJrqmN4rPNEFT1jERcvV2rTJ8CyoClK9uqRzZ4dff1WPx9SphYVT2Igw1oo6KNHUqJHL7Nm+PD+kF1/0s2OHfh3SeEOvpUeiBY9G8yfiunD33eoCOGSIw3/+Y/3+F71NdjbMnGkQCEgeeshb0Of8+SZ79xp5lYAJE3ycfLLDmWcmN6y8apXy/CnazpJSbWh5bWcBhVyW9+4VlCkjibUd66WlFZ61rFatsMApGjcRj9q1JT6fLJRzBcowsGnTSD+e9u2LP8cDqq21Z4/BySc7TJhQOCbCixGhZcFDD+Wybl1+qzIYhKee0lUejTe04IlECx6N5k/knXcMNm1S6+bnnecyfbrBrbc61KwJQ4ea2Lbg+uu9VXdARUdUrerSpYvDunUGK1ea9O8fiuuGHI0FCyyEkHTqVFjY/PyzGppN5L8D+U7GXk0HwVtLy3XDcztuoYpL0biJeJgm1K0rIyo8oNbTly0zC83UtGjhcsIJslgGhACXXGJTvrykXDnJzz8bEcdJZEQI0L27TZMmDtOm+Tj9dPX4jx/v4+efdZVHk5js7GwteIqgBY9HdEtLU1JCIXjwQVXdGTbM5qmnTNLS4N57HVwXXn9deeCMHOmturN3L8ydq5x5fT7lrOz3S669NrlhZVCC54wz3Ij18XDlw0uFJz1d4PNJatf2FhyakwO5uSJiBb4gBSs8RfOzisZNJKJ+/cjVdFBzPBkZgg0b8j/n86l21+LFxRM8KSkqX2vtWpNy5STjxxceXvZiRGia8O9/B/nxR5Orr1Y/U9eFESOScJLUHLdkZmZqH54iaMGj0fxJvP22wa5dgqpVJS1bSj74wGTwYIfKlWHsWJPsbME117gx2z9FmTlTVYR69QqRkwPTp/v45z/tmAIjFvv2wcqVRkQ6OqjZlgoVJCedlLhFtnmzQf36LmYBjRAvODRRjhbkr6WDqujs22cQ+n08KRw34dVepEEDN2qFJ1y9irae/v33BhkZ3o5flN69Q2RnC1q2dJg924rYskpkRAhwxRU2p5zi8Pbbfjp2dADBrFk+1qzRL92a+OTk5JDitVR8nKB/azSaPwHlsaOqOyNG2IwcaVG5suTOO9XF9umnVXjos896r85MmmTQsqXy3vnoI4sDB5IfVgaVneW6kfM7oCo8bdpEDjJHIz3dKDSwDPFbWomS0iGywgPkbT1VrSoJBoVnQdKggUtGhmD//sIfb9hQUqWKGzVXS0oRIYS80qaNy4knuhw5IsjNFcyYUVjYeDEiNAwYMiTIzz8bXHppCCEkQkgee0xXeTSJMbz84h5H6EdDo/kTeOEFk4wMQZ06knr1JPPnG9x3n0O5cvDWWwYHDwq6dXMpV87b8dauFaxZY9C3rxIpkyb5qFvX5bzzvLXDCrJggUWFCpJWrQpXcfbvhw0bvA0sSxkWPG6hj8UPDlVvvQ4tl9xtWd2+aJVHCNWyKypszjzTwecrnh9P+Li9eoVYtcrklFMcJkzwRVSjEhkRAvzznzYtWji8+mqACy6wkVKwYIHFV18V77w0xz7aVTk6WvB4RM/waIrLgQPw5JPq4jRihM1jj1nUrCm55RYlJIYNUwPD48YlV93x+SRXXx1iyxbBZ59Z9O0b8lSJKYiUynCwUye7UCsKVJAoJA4MBVV1OXJEFNrQysyEnJz4OVrgvcITzs8qrttyeDU91hzP5s1GoZmg1FQ44wy32H48ANdeqypu9eqpUNAVKwrfd4cODi1bxjciFAKGDMklPd2gc2fl8SOEChbV1zVNPPR1qzBa8Gg0fzBjxqjYiIYNXSpUkHzzjcFDD9mkpsL77wv27BF07OhSs6a34wWDMG2ayT//6VK5Mkye7EcImbeangzffWewe3f0+Z2lS01MU9KqlbeBZYjc0AKoUiVWUnpyMzxFKzrFFTyxNrWAKLlaNqtWFXZiToZ69SRnn22zfr1y1Z4woXAlx4sRIcBFF4UdmgNceaWq8qxYYfLxx8UXYxrN8YYWPBrNH8j27aqdBYKRIx2GD7eoVy8/AV1tbUmef957defTTw1++03Qr5+L46jV9C5dHOrUSf7P/QUL1AWzc+dIUbNkiclpp3kboi6akg7ecrRAbSzFIhwtAfnxEmGBU7Tik4i0NKha1Y3w4gFo2dIlEJARba327ZUT84oVxW8f9eoVIj3d4JxzbN57z8fhw4U/78WIUAh4+OFctm41aNPGwbJUlWfYMD9O8l1MzTGObduYRUu2Gi14vKJLg5riMGKERSgEzZq5uC6sXm3wyCM2fr9yXP7lF4PmzSXNmnk/5qRJBtWrS7p2dVmwwGTHDqNYw8qg2lnNmzvUqFFYlIRCsHKlt/kdUIJHCEm9etEqPCUZWpZ5FZ6UFFUNCgucChXA75eFohsS0aBBdC+eQABOPz3SgLBdOwchiu/HA3D55TZlykh8PsjMFLz3XuEqj9+f2IgQoGtXhzZtHJ5/3k/fvkGkFGzYYDJ9uq7yaApTNFZCo9CCR6P5g/j5Z8H48QYgGDHC4bHHTJo0cendW4mCe+5RF6qxY71Xd/buhY8/NujVy8HnU87KVaq4dOuWvPfOoUOqihNtO+vbbw1ycrwFhoKai6lTRxIosDyUKDg0I0NwwglKCMSiYEsLVFUnPGcjRNh80PvLWP360VfTQYmbNWsMcnLyP1a+PDRv7hbbjwegbFm49FKbr76yaNrUifDkAW9GhOEqz/btBiefLAkEJCAZMSJAbm6xT09zDJKZmakFTxS04NFo/iAefVRdJFu1ctm/H3780WDoUAfThEWLBBs3GtSt63LOOd5bUdOnK++dfv1cdu+GuXNNevUK4S9G4sCXX1rYtqBLl0hRE650eBlYhsgNLfDW0opX3YHCLS2INB9Mxm0Z1IzRtm2CYDDyc23bugSDgtWrI9fTly0z8/x/ikPv3iEOHhSccYbDqlUm331X+KW3YkXo0ye+ESHAeec5dOhg8+yzfm66KQgItm83ePPNOKpRc9yhXZajowWPRvMHsHq1YNYsEykFw4bZjBhh0bKlyxVXqKt3OE/rsceSG8CYNMmgVSuXU06RTJmixE9J2llpaTKqqFm61KRuXZdatbyJsfT0whtaoJLSAwEZM7X94MH4A8tQeEsLIis6xXFbdl3BL79Efk08A8KsLFEis79zznGoXdtl5071mESr8ngxIlRVniA7dxrUqiU54QRV5Rkzxh8xG6Q5fsnMzCQ1NfVon8ZfDi14PKJneDTJ8PDDatX8rLNctmwRbNkiGD5cGfgtXiz47juDSpUkPXp4D/n89luVst6vn4OUyrm5XTvHkwtyUdQ6usV559kR1SEp1UU/nCSeiEOHlLiJZToY61cnUY4WRAqeogKnaL5WIsLnGG01vUoVSaNGLkuXRq6OQ/GDREHFRPTsGeLLL00uuMBm5kxfxOZXo0aJjQgBzj7b4ZxzbJ55xs899+QCKu8sXjtMc3yhKzzR0YJHoyllPv9csHChgZSCRx6xGT3aon17lwsuUMLkgQdUdef++yO9b+IxaZKB369E0jffqJbYgAHFq+5s3Gjwyy9G1HbWL78Idu0ykprfAaK2tOIFhx48GD9HC6ILniNHBJmZ6v1q1SS//SY8byqFzzHeHM/SpWZEValRo5L58QD07m3jOILq1SUHDwo++CDyeLffntiIEFSVZ88eA78/PPQtee45f14bUXN8o2d4oqMFj0ZTikgJQ4ao6k7XrmoIdscOwfDhNkLAkiWC5csNUlIk//qX98pMMKjmd8LeO2+/bVK2rOSqq4q3kzx/vlJanTtHz88Cb4GhEF/wxMv18lrhKTjDE15FD1d5qleXuK7IG5BORPXqkpQUGbXCA+p73rfPiEgk79jRZvFiM6Y5oBdOOsmlVSvl6NywoRvhyaPuRxkRvvRSbCNCUOvynTqpWZ6HH84BlAgcO1ZXeTRqS0tXeCLRgkejKUU+/NBg1SpV3XngAYcxY0y6dMkfTH7kEeW7c9NNTszZlmh88ony3unf3+XgQXjvPYNrrnEp7mvaggUWJ53kUK9epOBYulTN9jRr5u3qHvbgKV6Fx0tLq3BCOuQLnqLePIkwjPCmVvTbx5rjad9eJaqvX1+yl8zevUN8/71qay1ebPHTT5ExF7ffHmTDhvhGhKDcl/ftM8jMNKhaVT32r73m49dfdZXneEevpUdHCx6P6BkeTSIcBx5+WIWAXnqpw5dfGuzbp4aWAZYuFSxaZGAYMHhwcpWZiRMNatSQdOniMnOmQXa24LrrilfdycqCRYvMqO0sdZ4mrVs7WB47OOnpgipVInPA4gkex1GCJ1GFp+haer67cvHclgHq149d4Wnc2KVixUgDQpVUTon8eAC6dw/h80mys8GyIp2XwZsRIahw0gsusHn+eT+PP65meWwbRo/WwaLHO3qGJzpa8CSBFj2aeEyZYrBxo4GUcNddDs89Z3LZZQ5nnqkuysOGqepO9+4utWt7P65aPzfo3VuJkPHjTU491aVVq+IFKS1aZJKbGz0d/dAhWLfO8DywDNFT0rOzlclebNNB9dZbhSf//aICJ1m3ZVCVqC1bjKg5VIahqjxFDQjr1pXUru2WaHAZoFIl6NbNZs4ci27dbKZOtSI8dPx+uOmmxEaEoKo8Bw4Itm0z+Mc/XKSEKVMsfvxRv7Qfz2RmZmrBEwX9W6HRlAI5OUrQGIYaKp471+DwYRg6VAmHZcsEn32mTAjvuy+5ysyMGSaOI+jb12XtWsHKlQbXXefG3H5KxIIFFikpMq9qUZAVK0xc17vhIKiWVuRKujeX5WS3tCpXlhiGLCB4kktMB9XSyswUMQd827Vz+Oknk337Cp9Hhw4O33xjljiws3fvEHv3Gpx6qpoXmjMnspQWNiJ86aX4VZ4zznC5+OIQ48b5GTVKzfIIAY8/rmd5jmf0DE90tODRaEqB11832bFDXUBvucXhxRdNevZUfjkAjz+uWl1nneXSooX3K6aUqp115pkuzZpJxo9XPi69ejkFbpPcFXjBAouzznKIZtOxZImJEJLWrb0Jntxc2L5dFMt0EKBixeQEj2lC1ar5q+lpaZCWlpwXT/hcN2+OP8cTTosP06GDw65dRtQsrmTo2tWhShWXH34w+cc/og8vV6qkjAhnzoxvRAjw738HycgQfP+9SePGDq4r+PBDX0Qyu+b4Qbe0oqN/IzSaEnLoEIwapQRN374u77xjEgzC//2fahktXy6hFlNBAAAgAElEQVSYP19VTpKt7nz7reD775X3TnY2TJ1qctllLpUqFe9c09MFP/9sRG1ngZrfOeWUyHmcWGzdqga0kxU8+Tla8Y9fdIYHwm7L+S9dVasm67asDhhrNf2MMxx8vthzPCVta/l80KOHzdy5FldfrVpX0USUFyNCgBYtXC67LMRLL/l58skcQFXBhg0LlLgapfl7ooeWo6MFTxLoGR5NNJ57zuTAAYFhwIABNm+8YTBwoEvDhurzI0eamKakceN8Lx6vTJyovHeuucZl9myDjIziDysD/O9/qn3StWuk4HEc1dLyGicBsGmT+p2I1dKqXDn69xuu8CS7lg6RcRLVq7tJVXjCAaexBpdTU5WIKCp4mjRxqVSp5H48oNpawaCgbFklTiZNihQ1jRpJunWzefPN+EaEAEOGBDlyBL75xuK005Sb9JdfWnz2mU7MPh7RLa3oaMGj0ZSAPXvgmWdUG+j6610mTLAwDPj3v/OrO598omZw7rpLOS17JTdXee9cdplLxYpqWLl+fcl55xX/z/YFC0zq13dp1CjyGOvWGRw+LJISPGHRcOKJhY+XKDjUS1I6RLa0IJrbcnIVnpQUqFUrdogoqDmeVavMQplb4Tmekm5qAZx2mkuzZg5z5/ro2tVhyhQfdpSi26BBIfbtM5gxI36Vp1kzlyuvtHn5ZT9PPplNwSpPSbyDNH9PdIUnOlrwaDQl4KmnTLKzw20Kh8mTDW66yaFOHfX5UaNMfD5J5coyLyXdK3PnGuzfr4JCN22Czz83GDAgOdFUkGAQvvjConNnO+rAc3gzKZmB5fR0g7Q0GSFsfvtNYFmSChWif11GhnqbeC1dRhE8Kk4i/PFkE9NBDS7Hm8Vp184hNzcyP6tDB4f0dIOdO0tW7RVCVXmWL1eePDt3GsybFymkwkaEL74Y34gQ1CxPVhZ8+qmPdu3ULM+aNSazZ5e8IqX5e5GdnU1aMkZfxwla8Gg0xWTLFnj1VXWRuuUWh1dfNUlNhfvvV4JhxQrB3LkmoZDglluiDwnHY9Ikg5o1JZ07u0yYoGaE+vUrLEZc18X1+Cf8kiUmmZkiajsr/Pnq1d2oZoSxCG9oFRVQXnK0TFMmNE6M1dIKhQQHDqj3q1eXZGSIiPXueDRoIONWeMJVrqLr6aWRqxXmmmtsDEOybZugenWX8eMjN6uSMSJs0sSlRw+b117zM3JkLuEqz/DhgRIlvWv+fuhoiehowZMEeoZHU5ARIywcR7VIunVzefddk0GDHKpVU58fNcrE75f4/ZKbb05u7mb3buWu3Lu3+rrJk00uvNDNqxyB2s6SUuK6LqFQCNu244qfBQtUtenss6Ofy7JlJu3aOUmtuysPnsj7TOSyHI6VSHRfsVpakL+KHn5/797kUtN37jRizsZUry6pXz9yjue001zS0mSpCJ4aNSSdOzu8846PPn1CzJtnsn175Pdw5ZU2NWsmNiIEePDBXHJyYNYsH507qyrP5s0GU6bEb4lpji2ysrJ0hScKWvBoNMVg3TrB5MkGrguDBjm88IJJhQqSu+9WYmLVKsHHH6vspb593TwR5JXp09XcT79+LvPmqTyugQPzhYWUEtu2MQyDQCCA+XsKqeM4hEIhgsEgjuMUEkDz51u0b+9Qtmzk/e3cKdi61UhqfsdxYOvWyA0tUOnpiQVP4vuIJ3hKaj4IasssFtGCRC0L2rRxSkXwAPTqFWLbNoMmTdSg8eTJkcLE74ebb1bbXOvWxX/JbtxYcu21atB52LBchFBVnlGj/AkHnzXHDtnZ2brCEwUteDSaYjBsmIllQdmycPbZLh9/bHLPPU7eRXzkSJOUFIltC+68M7nqTth7p00bl6ZNJW+/bVCtmuTii12klDiOg23bCCEwDAPDMPD5fAQCAfx+Pz6fD9M0cV0Xx3EIBoP88ovDunWx4yTClYxkBM/27YJQSEQMLEPi4FAvOVoQS/AUFjj55oPJVXiAhHM8e/ZE+u506ODwww8G+/d7vruYXHKJTfnyks8/tzjvPJtJk6LP6oSNCL1WeUIhmDzZx+WX27iuYNcuI+F6u+bvTW5uLiNHjmTx4sW4rpv3R5AmHy14kkC3tDSgEs8//NDEttXm1dixFtWqSW6/XYmF1asFc+aYmCZcdJFD06bJbVWtXi1Yt0557+zaBR9/rP5vWTJvZkcIEfX5aBgGpmni9/tJSUnB7/djWRYLF6qL3Xnn5RAKhSKqP0uXKoHWooX3wepYoaGgtrS8tLQSEWuGBwonpgNJDS6HRVqs1XSIHSTasaODlCJivqc4pKbClVeG+O9/LXr2DPHLL0bUVfJkjAgbNJD07Rvi7bd9PPBALqapqjxjxgTyhsU1xx5CCE499VSmTZvGTz/9RPfu3Xn11VfZsmXL0T61vwxa8Gg0SSClSjz3+yUVKyqB8MUXBg8+6OQN4I4caZKaKsnMFEmHhAJMmmQSCEiuvtpl8mTV2urf30kodqIRrv58/nmAGjVcWrRQFaGC1R/HcViyxOCMMxz8SSQShMVCUcETDKoKTvyk9MQbWhCZlg5QrhykpORvZlWtmnyAaOXKkrS0+IPLJ5/sUr68jBA2rVo5+P2yVPx4AHr3tsnMVMGflSpFd14G70aEAPfdF0RKePNNP717h3BdwcGDguef15ETxyp+v5/LL7+c5557jpNOOomRI0eSk5PDbbfdxumnn87SpUuP9ikedbTg0WiSYP58lXgeDAruvdfhySct6tSR3HijEjZr1gg++sjkhBMkp53mJu2Zk5sLM2YYXHaZS4UKMH68QceOLg0b2kmLnTC2DQsXmnTt6mJZkdWfzEzJ2rUmrVuHolZ/YpGeLvD7JbVrJ+fBA94rPOEV/IJtLSEKe+8EAiqiIpmWlhBKqMWr8BgGtG7tRFR4UlKU6CkNPx5QlaQGDVzeecdH794qWDTaAHYyRoT16kn69w8xcaKPQYOC+HwSIVRLLBlhqPl7IoTg5JNPZvDgwXz88ccsWbKE00477Wif1lFHCx6NxiOuC//3fyp4s1o1Sf36kuXLDYYMsQkE1G1GjlRi57ffDAYPTm7jCVT7SnnvOCxapGIg+vcPIqXEMIxitVVXrFAOzRdcULjaFK7+fP99KrYt6NBBFqr+JBI/mzcb1KvnUnRUIHyxjiV4pFSCx+sMT/hrClJSt2VQczxbtsT/mnbtHNavNyNaQR06OKxZY5CZmdRdRkUINbz85ZcWF1xgEwoJpk6NXj3yakQIcO+9QYSAl17yc9NNQaQU5OTAU0/pKs+xTPgPo4IEAgFSk/XFOAbRgicJ9AzP8c277xp8+61BTo7g/vsdnnjCpFEjl379lCBYs0bN9lSrJqlVS6WmJ8vEiQa1akk6dXJ56y2DcuUkV17pYBTXbRCYP195+Jx/fqyBZXXs9u1VWTz8zzTNvCHpUEhVfwr6/qiV9OgDyxBb8GRnQyjkfUsLog8uFxQ4RQWQF+rXVy2teMWssAljtCBR2xYsX15621oAy5ebtGtnM2GCP2oOVjJGhHXqSAYODDF5so/+/UOkpKgDvvWWr8QBqJq/LtplOTZa8Gg0HgiFYOhQizJlVAunYkXJ998b/N//Ofh+/2N71CiTtDRJerrBrbcmNw8DsHMnzJunvHcOHnR5/32THj1sTjihZBen+fPVxlfFitE/v2SJSZMmLpUrq/ejbX5ZloVhGHkbYsFgiPR0g/r1I0WU16R0rzM8ECtAtKjgSe7lrEEDl9xcwa5dsR/fVq0cTDMySLRtWwfDKB0/HlAtqLPOspk6VYmTn382orbMhIDbbvNmRAiqyuPzwfPPB7jrLlXlkRJGjgyUynlr/npkZWXpak4MtODRaDwwfrxaT87KEtx/v80TT5iceqqbV8X59lvBf/9r0qCBpEyZ/JmeZAh77/TuHWLmTFVJuu666K7IXtm7F1atMujaNfr5uC4sXWrQtm3scoFhGFiWVaj6s3+/xZEjgvr1bYLBYF71B5JJSi/eDA8ogbNvn8hzEC6ar+WF/NX02C+DJ5ygzAaLDi6XK6c+XlqCB1TUxKZNBnXrqmHpWMPLV13l3YiwZk3JDTeEmDbN4sorQ6SlSVwXZs60+P57/fJ/LJKZmamDQ2Ogn/FJoFtaxydZWcpV+YQT1NyOZcHPPxsMG5afazVqlEnZspL16wUDBsSupsRCShUl0aaNQ+PGDhMm+Gje3KVly+IHhYIaVpZS0LVrdEHz00+CAweE5/ys8Nr7r7+qi23jxqoSJITIa33t2aPWoMuXj37M4lR4irZvqleXSCnyxFX16mor7sgRT98GkL9dlmiOp21bhxUrzIh4hvbtHZYvLxwwWhIuv9wmNVUya5aPHj1CzJ5t5cVnFCQZI0KAu+8OEgjAf/4TYMiQHEBgmvDYY7rKcyySnZ2tBU8MtODRaBLw4osmu3cLMjMFDzxg88QTFq1bu1xyibpgrl0rmD3bpHlziePAoEHJV2VWroQffjDo0yfE2rUma9aYDBwYPeQzGebNM6lSRXL66dEFT/78TnLzRps3qxNr2BAsyypkerh/v0GlShIpnaiRF+EB4JIMLcdyW06myvOPfyhhFvYTikW7dg7Z2YLvvit8u44d1cdXry6dl9GyZeHSS21mzfLRq1eInBwRczg5GSPCatUkN92kPHzOP9+lQgUXx4FPPrFYvFib0x1r6JZWbLTg0WjicOAAPP20ms056SSXI0cE27YJhg3LFyPh6s66dYLLL3dp2DC5+3Ach4kTBSkpyntn4kSLQEDSs2fJ2lmuq/KzOnWKnbC+ZIlJ5cqSxo2TqyRt3mwghKp4hQlXf/bvN6lalbzBZ6DQ4PP+/eprSjLDUzROomi+lhf8fiV64nnxQGwDwvbt1ccXLy69NPLevUNkZAi2bTM4/XRV6Ys2vFypEr+3PhMbEQIMHhykTBkYM8bP44/nAirNfujQ6MPRmr8vWVlZusITAy14NJo4jB1rcvAgHDmiNrOeftrk3HNdOnVSV4nvvhN88IFJhw4uBw8mFyMR3oDKylIeLJde6hAIwPTpFpdf7iTdFivKt9+qlk+s+R1QFZ62bZNfn9+8WVCnjsxbxy9IODg0VuRFuE2TlpY48DTWDE++wCkcL5H8plZ8Lx6A2rUl//hH5BxP1aqSk04qPT8egHPPdahVy2XqVB8DBoRYt85kxYro5xc2InzjjcQr6lWqSG65Jcj771uccYZLtWouti1YssTi0091ledYQielx0YLniTQMzzHF9u3wwsvmJQtC6ee6rJjh2DPHsHw4YWrO+XKSX78UW1CtW/v7c/lcMq567rMnWtx4ICgb1+bDz4wOXhQMHBgyao7oNbRATp3ji549u6FjRvjDyzHIj1dRF1Jh+hJ6eHqj8/nIytLXaArVjQKzf5E8/0RQh0nVrxEeDOraIvLKw0aJPbiAVXlWbLEjBBeHTqojzvJz6hHxTTh2mtDLFhgcu65NmXKxB5ebtxYGRG+8UZiI0KAO+4IkpamfHieeioHAJ9PMnx4IOGKu+bvg57hiY0WPBpNDEaPtrBtOHxYcN99Ds88Y3LxxQ7t2qmr3vffC95/XzkYb90qPBsNhis7YYOwKVN81Krlcv75qp114okuZ59d8ivQ/PkmLVu6VK8e/fNhb5lk53dAtbQaNowteMJxD9E4cEBQtqwkNdWXt/Xl8/kiTA9t2wbUcYoKjZQU1RILC5zKldU8TnG8eH77zeDw4fi3a9fOYedOg19/jQwSPXhQ8MMPpfdS2quXjeMI5s616N49xHvv+WKeXzJGhJUqqZX22bN9NGyoqlahkGDdOpN33im9tpzm6KJ9eGKjBU+S6CrP8cHPPwveesugTBlo1cpl/XpBRoZg6ND8P+XDszu//CKoW1dy+eWJhYOUEtu285yTd+0SzJ+vvHe2bBF8+aVJ//52zJkbr2RkqHXzou7KBVm82MDnk5xxRnKC59AhJWqihYbaNuzfL6hSJfbXF01KjxZ4aprm779r6nbBYGT1p1q1fPNB01QtpmiRDPHI39RKPLgMkXM8HTqoj5fmenqTJi5nnOEwbZpqa2VmCt57L7qg6djRoUULZUToZRbn9tuDlC8veeIJP88+m1/lGTEiUGrbZpqji15Lj40WPBpNFIYPN7EsVd256y6bceNMrr7aoUULdVVZt04wa5bJVVe5LF9ucMcdDlaCP5LDpn1CiDzn5OnTLVxXtbMmTrQwDEnfviXvj3z+ufL0iTe/s3SpQcuWLskudIQ3tMKJ4wXZt0+9jZ+jRVyX5fDsjzI8VEJCCDOi+hMZL5G8+WDYiyeR4GnWzCUtLdKAsG5dVSkpTcEDaiD5u+9MUlKgWTOH8eOjCx4hlIjxakRYoQIMGhRkzhwflSurGaRQSLB1qxHzPjR/L3RLKzZa8Gg0RVi9WvDOOyZ+P3To4LJsmUF2Njz6aGR1JyMDypWTDBwYW1gUbWGFq4RSwuTJFu3aOTRoIJk0yeKiixxq1iz52sz8+Sbly0vatIlevcnNhZUrDdq1K147C+DEEyO/NpHpIHgPDgUwDHU8y/JFVH+qVXPYvVvkJb5XreoWa2gZSBi1YFkqSLTo4DKoba1vvomc7ykJ3buH8PlkXpVn1SozYi0+TNiIcNw4b9bet94apEIFyahRAZ5/Pr/K8+ST/lLJBtMcXXRLKzZa8CSJbmkd+zz6qIqQOHJEcPvtNq+9ZtK3r8tJJxWs7hj06ePw0UcGN9zgULZs9GMVHE4umnS+cqXBjz8a9O1r8+mnyutnwICSV3ekVHES558fu+q0Zo1Bbq4opuCJXeEpbcFTdC29YPWnZk3Bnj2qHea67u+Ch4SbXwWpWFHNAiXa1AI1uLxuncGhQ4U/3rGjw+7dBps2ld5rQ+XK0K2bzcyZFlddFSIQkDErMMkaEZYrp9bU582zsCxo0UJVefbuNXj5ZR0s+ncnKyuLtLS0o30af0m04NFoCvD552qmRgjo1Mll4UIT14UhQ/K3pkaPNjnhBPI2c267LbpIiVXZCTN5sklKiuSqqxwmTDCpXl1y4YUlFzzr1wu2b48dJwH5hoNeHZYLkp5uUKWKjCryvAme+C2tgsRaSweoXl21HEMhNfsTFkBSEnfzqygNGiReTQf1WLmuYMWK6HM8pW3i16uXzd69BqtXm1x2mc3MmT6ysqLfNhkjQoCbbw5SubLLqFEBXnhBVXksS/LMM/68tqTm74mu8MRGCx6N5nekVNWdcuVUTMENN9hMmGBw440u9eur2/zwg+C99wyuv95h+nST7t1d/vGPaMcqPJxcVOzk5MA771hcdplDVpbgk09M+va184JIS8K8eerC26VL7Iv8kiUGDRq41KiR/PE3bxY0bBj92F4ET9Gh5XjEipaASC+eGjVUCntWViDq5lcwGIxa/VGr6YlfCs88UwWGFp3jOekkl8qVXb7+unQ3nbp2talc2WXaNB8DB4Y4eFDwwQfR76OgEaEXt+m0NBU5sXChRXa2oEMHG9sWHD4Mzz6rIyf+zugZnthowaPR/M6HHxosW2YQCsHFFzt8+KGJzwcPPhhZ3SlfPjzQHFkhiTacXJQ5c0wyMtSw8uTJasC4f/+Se++Amt85+WSXOnWiiwop1bZRcfx3QAmeWB484S2pcPJ6UcJr/hUrFq+lVZCiZoMFBVC0zS/r9/5e0epPvXoOv/wisBM8/OXKwSmnRBoQCqGqPKU9uOz3Q48eNnPmWJxyikPDhi4TJ8ZWxGEjwtdf96aab7wxRLVqLqNG+XnuuVxAYprwyis+tm/Xrfu/K7rCExsteJJEz/AcmzgOPPqoSaVKkuxsQZ8+LjNmGNx2m5NXBVm/XvDuuwY33eTw9tsmZ5/tcsYZ+VfiRC2sgkyebFGnjsu55yrvnbPPdmjUqORTr0eOwDffxG9npacrA8Xi+O/k5sL27SLq/A7Ab79BpUoy5uzQwYPqbfny3u4vfksruuCJNrgczfU5XP2pV8/BtgW//ioTzv60basCQ4uKow4dHLZsMdixo3RfH3r3DhEMCt5/Xw0vf/ONxU8/RX/ZTtaIsEwZVeX54gtVFera1cFxVAL9k0/qWZ6/K5mZmXqGJwZa8Gg0wJQpaoA4Oxuuusph5kyDsmXhnnsKb2aVKQMNG0q2bVNGg2HiDScXZccOwYIFynvnm28MNm82GDCgdKo7X31lEAzGX0dfvFj92oczopJhyxaBlNE9eCC6y3JBkklKB28trfwAUW9uywWrP36/n0aN1OORnh7f9RnUHM+RI5FGg3+EHw9AixYuzZo5TJ3qo3fvEJYV23kZ4PbbvRsRAlx/fYgaNVxGjvQzZkxOnrP1xIk+Nm7Uf9z9HcnOztYVnhhowaM57snJgccft6heXZKTA1dd5TJ7tsngwU5ea+bHH1V155ZbHN56y6RxY5eLL1YXw2QqOwDTppm4rqBPH5vx4y3Kl5dccUXpZBPMn29SpoykY8fYlYqlSw3KlZM0a5Z8RSk/Jd17rERB8gWPt/vLfygjH9OqVSnkrlyceAnDMPLCXrdt8+e1vsLVH9u2C4mfWAaEzZu7lC0rSzVXC9T336tXiOXLVabbxRfbTJ1qkZsb/fZnnZWcEWFqKtx7b5BvvrHYutXgiitsXFdV1kaO1LM8f0f0llZstOBJEt3SOvZ4/XWTX38VZGRAz54u48erBPE77ois7rRr57JypcGdd6oE8kTDyUWREqZMsWjf3qFyZcns2SY9e9pJm//FYv58FW4aLdQzzOLFJq1bu5jFuDaHPXiKX+FRb71XeKJHS4ByV65SJV/gVKgAfn/y8RK1a0t8PrWabhgGlmXlVX/Cvj9hUVujRpCaNV2WLDEKVX8sC9q0cUp9UwugZ08bw8j35Nm3z2DOnOg9w2SNCAEGDgxRu7bLyJEBRo7MxTBUi3fWLB+rV+tLxN8Nx3Hwlcb2wzGIfjZrjmsOHYInnzSpU0di23DhhS4LFhjcf79DuXLqNhs2CN55R1V3Jk5UYqhPH9fTcHJRVqww2LBBee/MnGmRkyNKrZ21aZNg8+b48zsZGWoWqX374lWU0tMFaWmSqlWjf37v3tJtacWb4YGwu7L6vxDqfS9bSgUxTahXT0aYDxYMPM2f/bFo08b+PTDUKVT96djR4YcfzFJf665RQ9Kpk8OMGT7OO8/hH/9w47a1kjUiDATg/vuDLFtmsn69QZ8+IaRU4nH4cF3l0Rw7aMGjOa557jmT334T7N4Nffu6vPaaSa1akptvzhcEo0ebpKbC5Ze7fPSRwb/+5RAIeG9hFWTyZJPUVOW9M368RYsWLi1blo5FbzgdPZ7gWbbMQMriGQ4CbNpkcOKJMmpIquvC/v0kyNFSb5NtacWaJVaCp2i8RPJV2Pr1IwVPUcLVn44dYds2kz17Cld/2rRRfabwjFRp0rt3iF9/NfjmG5N+/ZTJYKyUd78fbrrJuxEhQN++IerWVVWeoUODWBYEg7BwocUXX5R+1UrzxyBL0+77GEQLHs1xy549SvCE4wU6dnRZvNjgoYfyW0w//SSYOVNVdyZPVmvq//qXijJIVuxkZyvvncsvd9i0SbB2rcHAgaVT3QEleBo2dGNuUIGaPTEMyZlnFk/wpKeLqJESoMSO68av8Bw4kFyFJ0z8Ck/JBY9X80HIT5dfvtxXqPpz5pmSQEDy9deGZ9NDr1xyiU25cpKpU3306xfCMGTcFfXrrlNGhC+95K214ffDAw8EWbXKZOVKg3/9KwgIAgHJsGGBUo3N0Pzx6NGL6JSuU9ZxgH4iHTs89ZRJVhZs2ya44QaXl14yqV9fMnBg/gVq9GgV4DhggEO7dn569rSpVs1FiMTzOkX56COTgweV986ECRYpKZJrrikdwZOTA19+aST08lmyxKB58+guyYlwHLWl9c9/5l/9Dh6EDRsM1q8XzJunBMNbb1ksW2YQCEBKisTvh5QU1Tr56isDw5B5338gwO+3Uy2Ugv9PSckPIz1wQJnrpaRQaOU9LHCkVNWgatVg+fLiCB5JRobgwAEVNxGP5s1dypSRLF5s0L27qqYZhkHZsgZnnumydKkfn8/OMzxUj52T1/r02v4sSGoqXHlliHff9TF2bA5duzpMmeJjyJBgVAuAsBHhxIk+hg4N5m2wxaNXrxBPP+1n5MgA//1vFm+95Sc3V7BypclHH1lcemnpiXPNH4Ou8MRHCx7NccmWLfDaayYNGki2bxc0b+7y6qs+3ngjhP/30YeNGwUzZhgMHuzw/vsG2dmCQYNCxbpgQb73TuvWLr17B7jiCsdzaycRX39tkJUVfx3dttUMUd++yV+49u6FL74wCYUEq1YJLrkkwIYNgp078x8Ln08ihApUVVldkJMjCAbJ+3+Y++5LzuelQ4f8qW7DyBdGtq3clVu0SCE1VYnXjAzo399PvXqSWrXUv9q11dtq1aJ7BIWNFNPTDSpWjF+R8fngzDPdvHiOgnTs6DJ2rEV2tklampr/CQufcOsrLILCQ+5en0+9e9tMmODnv/+1GDgwRK9eqcybZ3LxxdF/5rfeGuTNN328/rqPhx8OJjy+MtnM5dZbU/n6a4s77wwyZkyAlBTJY4/56dbNjumvpPlrkJOTQ0pKytE+jb8s+umrOS4ZMcJCStWiGTTI4YUXTJo2denVq3B1JxCAW24Jcs45KXTpYnPqqcW7vx07BAsXGtx/v81//2ty6JAo9XaW3y85++zYF+vvvhNkZsae35FSnef69YINGwx+/DH81mDfvnyxsmyZSbNmLp06uTRpYnPyyZImTVzq15dxN7+khH79/Hz7rcHChTkEg4KcHCWG1D/xuzAi73Off24wfryPhx4Kkpam5kpyckTe16xfb/DFFyYnnqg20w4eNDh8WLB0qcGHHwqCwaKDyJLq1QuLoJo1Zd6M0DffGJx0kkuird527ZSwOXKEQrft0MHhqad8LFtm0KmT+/t95ld1XCbNEX8AACAASURBVNctZGMA3qs/7do5NGigoiZmzcqmenWX8eP9XHxxdJfBxo0lF13k8MYbPu65J+hpE7BnT5uxY5X78qefZvHiiz6ysgw2bDCZPt0qlljW/HlkZmZqD544aMGTJLql9fdn3TrBlCkGjRur6k79+pINGwymTQvlXbA3bhRMn24waJDNwoUGu3cbvPZa4r+SYzF1ar73zm23+WnY0OWss0o+2xFmwQKTjh1d4kXohL1j2rRx2bxZsGGDYP16o5C4OXw4//ldqZKkaVOXyy5zaNrUZetWeOklPytX5lCvXvKlcyHg0CFB5crhLa+ix4g8ZigE48dD795OVO+fL79Ugueuu2zOO6/w4+m6yvl5xw7Bzp2CHTuUE/L27YIdOwQbNxp8+aXI2xwDePBBPw8+6Kd8+XwxVLRKVLOmS9OmDo7jY8UKo9D9tm3rYhjKjycseAoSFjTm70+0aNUfKSWmaUZUf8KePKNH+9m1S9C3b4hnnvGzfbugdu3oP49Bg4JcckkZZs5UK+2JsCx46KFcbrwxlf/9z+LBB4MMHZpCSopk1KgAV19towsIf110rER8tODRHHcMG6Y8dX76yeC++2yee87i9NNdrrgi/wL1xBOqunPHHblccUUZmjVz6dy5eAIl7L3TsaOD68KiRSbDhwejbjoVh19/VcKlX79IQRYKwfffq4Tvxx7zIYSkVauUQu2lGjVcmjSR9Olj06SJEjlNm7pUrUqhc3z4YR9+v4yZ0eWFjAw1X+IVL2vpECtOQs30VKsmf9+Ei/7zy8xUoujcc1M47TSXrl0ddu7MF0Y//miwa5fAdYveh6R37wAnn+wWEkc1akjefdfgoYdIGAabbPXn2mtDjBoVYPp0Nbw8dmyAyZN9PPhgdDEeNiIcN85H//4hT8+57t1txoxxGD3az8KFWYwd6+fQIYNt2wRvvunj9tsTCyfN0SErK0sHh8ZBCx7NccWSJYIPPzRp0sRl1y6V6r11q+CFF/IvBhs3wrRpBrfdFmL9epN16wxefjm32AJl2TKDn34yuOuuXCZOtDBNJS5KiwUL1AWzSxeHbdsEy5erENQVKwxWr1azRwCmKSlTBq6/3ubkk12aNlWtKK9zROnpImHbKhEHD8aOpYiGl7V0SM5duSgnnKDaP02auBgG3Htv5M/GcVQoaVgE7dghGDVKCUC/H777zuDTT1XLMMyJJ6ZywQUOF17o0KWLk1DoJar+2LZNrVrQoUMK06ZZ3HdfkPPOs5k0ycf99weJ1g0LGxHedFMqCxaYcWe8wpgm/PvfQQYOTOXjjy0efTTIffepKs+YMX769QvleVRp/hocPnyYlJQUHSuRAC14NMcNUsIjj1hUqqRaWEOGqOpOhw4uXbuGHX1lXnXn7rttbr45QPXqkp49ix/9MHmyinu49FKHVq38XHSRQ82aJf9+jhyBVasMXnpJbTxddlmAXbvUVS8QkLRs6XL99TZt2qhB6bp1o/vneGXzZiNmSrpXMjK8J6VD/LR0UCGkgUDxVtGL0qCBjOmhY5pQs6aq4oRZt07w3nsWc+bk/O66rYwsFywwWLjQJCdHMH++mn0xDEmbNi4XXuhwwQUOLVok/lnEqv5ce20Od96ZxuLFLn375nDjjWl89plJ587Rn6NXXWXz6KPKiLBrVw+posAVV9g0a+bwxBMBFi3K5Ikn/Pz2m0FOjmDcOD9DhhS/vaspfRYtWsSIESNIS0vD7/ezdetW6tWrd7RP6y+H9uFJEj3D8/dl/nzBokUG1apJKldWf5nv3CkYPtxGCNU+2LDBYfp0ixtusNm3T7Bggcktt4TiRjXEIzsb3n1Xee98/bXJnj2CgQOTF0+uCz/8IJgwwWTQID9t26ZQs2Yq3bql8MMPyh/o3HNdxo4N8uWXOezalc3Chbk89VSIq692qFevZGInPOAdy4PH6zEOHPCelA6JW1phd+XSEjzbtqmtMi+0a+dy8KDghx9E3rmULw/du7u8+GKIN98Mkp6ezeef5/DggzbBIAwf7qdjx1QaNUrh1lv9fPCBmWfGGI+Cgac9ehikpkpmzkzhkktCVKrk8vbbFsFgMKrvj98PN9+sjAiLhp7Gvj8YMiTIzz8bfPCBxWOPKVPFQEDywgt+9u7Vr4N/Jbp168aiRYvo2bMnpmlyyy230KpVK+655x7mz59/tE/vL4MWPJrjAteFRx+1qFFD8uOPRt5mVteuang4fKF4+mk/Ph/cfXeIceN8pKZKbrih+O2nDz9UG1lh750aNVwuuCCx4NmzBz7+2GTYMB+XXBKgVq1UWrdO5bbbArz/vkmNGpIHH7QZMUJdnV99NchbbwW55RabVq3cvNX60mLPHjhyRMQ1NUxEZiY4jkjKdDBRSwtKU/C4uK7gl1+8HStsQLh0aewen2lC69YujzwS4quvctm8OYtXX82lY0cVUNunT4C6dVPp1i3AM89Y/PCDSGjyV64cXHaZw6xZfvz+AL1728yd62P/fiuvDRYMBrFtO0/8hI0IX3zRe8bSpZfatGjh8OSTali5Vi2H3FxBVhY8/XQpP8E0JUYIQcWKFTn77LOZO3cuixYt4sILL2TlypVH+9T+MmjBUwx0lefvx3vvGaxZo1LCa9RQqej79gmGDg3lXSTS0w2mTbPyBM706SZ9+9p5ienFYfJki7p1XRo1knz6qUHfvk6El0lOjkowHzfOYsAAP82apdCgQRl69FAXwYwMwbXX2rz2Wi6rV2fz66/ZzJ6dyyOPhDh4UGCakvPOK5209ViEXYhLUuEJb0OVZksLSrfCAySMmCh4+2rVYrfBolG9OvTt6zBxYpBffslm3rwcBg+22b9f8Mgjflq3TuXkk1MYPNjHxx+bZGZGP07v3jYZGYK5c02uu84hFBLMnJlKSkpKXuI7kJf3VbZsiF69gsyY4fOcNSYEDBmSS3q6wTvvWIwapcS1zwdvvOFj61b9OvhXo+DQcmpqKhdeeCEPPfTQUT6rvw56hkdzzBMKqc2s+vVdfvrJYMSIEE8+aXHZZQ4tW9q4rko6HzMmv7rz2ms+QiG4/fbiV3e2bVPeOw89ZOetpffrZ7NpkxosDv9bu9YgFFIXjzp1XNq0cbn5ZpvWrV1atnSJN4M4f75Ju3ZuUm2i4rB5szq/klR4wknpyZyrV8GzZElpCh6DWBtdRc+tXTsnqgGhFyxLGRV27Ojy2GMhtm9XbtWffmoybZrFG2+IPG+lCy9Uw8+NGqlzPP98l1q1XKZMsXj33Vzat3eYMMHirrvsmLM/N92UzZtvBnjlFYOHHw56Mj286CKH0093eOqpAMuXZ9KwocOmTSamKRk9OsArr+QU63vX/DHotfT46AqP5phn/HiDTZsMfD6oU0elaR85Ao88kouUEiEE6ekGU6eaXH+9Tfny8MYbFhdf7NC4cfEv8FOmmEgpqFvX5bnn1LB0p04pnHZaKjfcEGDSJIsTToA77rCZPj2Xn3/OYsOGHCZNCjJ4sE2HDvHFzq5dytHYy+ZNSdm82UAIWSz/nTDJJqVD4hkeUFWTffuUsC0JNWpIUlISh4gWpF07lcG1a1fJ7hugdm3Jddc5TJ8e5Ndfs/nooxxuvtlm2zbBAw/4adEildNOS+G++3wsXGhw9dUO8+YZ7N4NAwfabNxo8PXXhV/SC87+nHqqcksePz6FrCyZV/2Jl/klBDz8cC5btxpMnepj9OjcvI9Pm2axfr2+hPyVyMrKIi2Ra+ZxjH62FgPd0vr7kJUFo0ZZNG3qsnGjwe2327z+uknPnjbNmsk8e/8xY3z4fHDPPSGmTrXYt09w553Fq+5ICZ98YvD442pe4tZbA2RkGKSkSC65xGHcuFyWLMlm585s5s7N5fHHQ1x6afKbW//7n5od6dLlzxA8gjp1ZLGHt0GtpENygsfrDI+Ugt9+K9nvpWF4S00vSHiOJ2zqWFoEAqqK88QTIVatyuH777P5z3+CNGokefttiyuuSOHVVy0cR3DPPX7OPNOlfHn1uXjceafNb78ZfPBBmbzWl2EYuK6LbdtRxU/Xrg6tWzuMGePnvPMcTjnFwbYFPh88/rie5fkrodfS46MFj+aY5qWXTHbuFNi2mj/ZvFlVAoYMCeUJ1/R0wZQpJtddZ1O9OowbZ3HGGQ4dOyY/r7JmjeDSSwN0756Cz6eiBs45x6F8ecnatTm8/HKQ665zaN68ZH42oNpZVatKWrT44wMD09NFiVfSDxxQb5PJD/Pa0gLYvbuYJ1aABg2k59R0gJYtXVJSZLHbWl5p0EBy8802s2blsm1bNrNm5XDddTZ+v+SDDyxatUpFCJgxw2TOnNjncvbZLi1auLzwgg8hDCzLwu/34/f7CQQCmKaZ1wILV3+kdBkyJIft2w0mTvTx5JOqymPb8NFHKkZD89cgMzNTGw/GQT9TNccsBw7A00+btGzp8PPPBv/6V4jx4y3697dp2DD/dmPG+LAsZTj3yScmGzca3HGHndQa99atguuvVyvHa9cajBkTZPfubGbMyGXpUoNevWxPWUZecRxYuNCkSxcnquFcabN5sxE12iEZwi2t8uVLf2gZSmY+GKZ+fZf09MSbUmH8fmjVKnqQ6B9FaipceKHL2LEhRo1SfbzBg4O/V7qgV68Ad9/tY8eOyMdDCBg0KMSPPxrMn59/zuG5H5/PRyAQKFT9cRyHs87KoX37EGPH+mnVKkTr1jauCykpkmHDAp4fL80fS3Z2thY8cdCCR3PMMnasSUaGaqWcdJLLd98ZGAY89FB+q2rLFlXduf56m5o1Jc8/rxLNr7zSW5to/3546CEfLVumMHu2yX33hfjuu2xuu83G74cZMyxycwX9+5du6OLq1SrQ88+Y3zl0CH77LTmH5GiEW1rF8eGJR2kKnhNPlGRmCvbu9f41bdu6rFljkO3N069UueYaG59P4rqCVaty+PzzHAYMsHnrLYtTT03hwQd97NlT+GuuvtqhRg2XceNir6gbRtHqj58hQ3LZudPg7bctHn88E1AhrosWWXntVc3RRQ8tx0cLnmKgZ3j++uzYAS++aNKunWpRXH99kOnTLW66yS4UtDhmjA/DgHvusVm9WvDVVya33WYnzEDKyYFnnrFo3jyVceMsrr3WYe3aHIYPD+Vd0KWE8eMtTj/dKfW20/z5aog4lrtuaVIaG1oQNh1MrpUnhLrPyByrfKpVKz3BExZ1W7Z4f2ls394lFBKsXPnnv5xWrgzdujnMmGFh29C6teSFF0J8+20OPXo4vPSSxSmnpPLooz7271df4/fDLbfY/O9/JuvWJX7MwoPPnToZnHOOw7PPptKiheDcc4NICWXKuAwb5icUij74rPnz0C2t+GjBozkmGT3aIhiE7duheXOHpUstypSBe+/NX+XZulUwebKq7tSqJXn+eR9ly0oGDoxdjXEctX3VokUKjzzip21blyVL1GxO0cTq1asNvv/eKJazciLmzzdp1cqlSpVSP3QEmzeX3IMHVIUnmXYWeGtppaYqIVWaXjxhkeeFtm3VzzcZP57SpE8fhz17RF6mGqjh61dfDbJyZQ6XXOLwn/8o4TNypI+DB+GGG2zKlJFxqzzReOSREHv2GLz1VgqjRzuAICtLsHatxfvvW3mzPwVNDzV/HrqlFR8teDTHHBs3wltvGXTs6PDrrwb9+jm8/77F7bfbVK2af7uC1Z1t2wTvvWcyYIAdteUipaqqdOyYwk03BahWTfLxxznMmpXLqadGvxqPH2+Smirp0aN021n798Py5QZdu/45F5TSqvBkZCQ3sAzeBA+otpZXQ714hNfut2zxfqzKlaFJEzeu4/IfyQUXOFSpIpkyJXJD66STJOPHB1m6NIfzz3cYNcrHKaek8uabFtdcYzN9upnUsHfHji6dOjk884yPhg0l//ynem6npUlGjy6DEP688FMva++a0kWnpcdHCx7NMYWUkuHDTfx+2LjR4MwzHRYuNKlYUXLnnYWrO5Mmqc2s2rUlL79sIWV0o8Hw5tUVV6Rw+DCMH5/LF1/kcu65sV/AMzNh5kyLK690St0U8LPPlInhnzG/A8qIr0oVSdmyJTvOwYPJxUqAt7V0KD235dRUqFnTzatqeaVdO5elS42E5/lH4PdDjx42c+aYeZtwRTnlFMnUqUEWLcqmbVvVgpo92yIYFLz8cvJVnt9+E7zyisVjj4UQQsWObNpkMGWKr9Dgs8/nwzTNPDdzXf35Y9EVnvhowVMM9AzPXxMpJatWSd5916JDB4edOw169FCbV3fdFSpUXXj6aQvDUJtZhw/D228rcVK3bv4Fuejm1VNPBVm1Ss1GJBqmff99k8OHRdz2WHGZP18JuFat/rwKT8OGJb+vAweKL3i8VHhKQ/CAqmQlU+EB1dbav1/w009H57WhTx+b3FzBrFnxfXhOP13y3nu5/8/eeYdHUXdt+J6ym0AIvYgiBhAFBIkIQpCudIJSQknoFqSKig0VC/b6SRP1RQEFUZovICpBlKKAgC8giI3QRQNSQ8ruzsz3x7gQEEh29ze7k2Tuf/C6MLOTZWfm2XOe8xxWrswmPt78N33tNZXJk1VycvL3Wo0bm/vg3nzTReXKBklJGmAQG2vw3HMuMjPN/8/v/XG5XGdWXiiKgiRJZ8TPxRaeOgSHx+PBLXqRXiHCETwOhQJ/dshTT7koU8bgxx8Vbr5ZY+lSlYoVDYYNOys89u2TmDVLZdAgs7ozc6bKiRNngwaPHoVHH/335NWIEb58B+/NnKlSs6ZO06Zib+T+1lqbNv/eyWUVaWmhZ/CA2dIKtNqVX8FTsaI4wRMXZwTk4YHcAYSRuaXGxxvUrq0ze3b+2mqNG+ssXZrDiy960HWJhx92U79+NDNnKvlKrH7iCS9Hj0q89ZbKk096kWU4dUrizz9lpk278AfTP/bun/xyqj/WkNe6kKKM8844FHg0TcPn87F6tUxqqkqTJqaJs0sXjTVrFB56yEvuKu+rr6pIklnd8flg6lSVhASNunX1M5NXkyZdePIqP/zyi8R33ykMGBBYlk9++PFH86ESjnRlMKfRDh4MbUu6n2BaWvlZLQFmhefkSelMdSEUqlfXOXQosDHzmjUNypc3hCcu5xdJMqs8GzYo/PZb/j90I0f6qFdP58ordSpWNBg+PIoGDaL56CMF7RIfsQYNdDp39jFxoovSpf1Gf4MSJQxefdV10daan9wrLy5U/fF4PE71J0AMJwwpTxzBEwROS8se+Ks65g1R4qmn3Fx2mc733yu0aaMxf77ClVfqDBlytrqzf//Z6k6VKgaLFyvs3SsTH68TH5/35FV+mDVLRVUNkpOtaWcBYTMs79kjYRhSyBNaXi+cPi0FtCkdAvPwAEKMy3FxgRuXJclsa0WqwgPQp4+GLBt89FH+S3+SBKNHe9m/X+bxx73Mm5dDTAzceWcUN90UzcKFykXf+3HjvBw/LjF5sotx48woh4wMiRMnJP7v/wLzBZ1f/fELIKf6EzjO8+niOILHoUBiGAa6rqPrOpIksWyZyvffKzRqpPP33xK33KKxebPCo496z2lDvfqq+TB44AEfhgETJqi43QZvveWifPm8J6/ywuOB2bNVOnbUuOwyEb/puaxYoVC3rk7lyuH5NuffKyViQgusa2mJDh+EwAQPmG2i336TAwotFEnlygZt2ujMmXNxkXIhcgcRduqk8d132Xz4oWno6d8/ioSEaD77TPnXv0F8vMFtt/mYPFklKsrg7rvNKk9MjMHkySqHDgX3e+RV/XG8PxfGqfDkjSN4HAocuSs7kiSh6xJPPeWienWd1asVOnXyMXu2ytVX66SknK3LHzggMXOmysCBPv7+G1q0iOLXXxVKlDAnr1avvvTkVX74/HOFw4etMSufOgXffRee7eh+/NNKoaYsB7MpHQJraYG49RJAwJNafh9PpMbTwWxr7d8vs2ZN/s/9/CBCWYZu3TS+/z6b6dNzyMqCXr2iaNkyitRU+Zx/i3HjvJw6JTFxoosHH/QSHW1W8jweeOmlwKo8FyMv74/H43GqPziG5fzgCB6HAoVf7BiGgSRJSJLERx8p7NwpU6+ezokTEjfdpPPTT2aJPrex99VXzdHz9HSJm28uxvbtMsWKGWzdmpWvyav8MHOmyuWX69x6q/ib76pVCj6fRLt24RM8u3dLxMYa5+QXBUMwm9Ih8JaWCMFToYKZKxPI1nQwfS1utxGxAEKAxESNkiUvnMlzKYYM8VGs2LlBhIpitsl++CGbqVNzSE+XuP32aNq2jWL1avN3rFvXoEcPH1Onqv+0x0yhHxUF772nBmz+zosLVX/Ufy7yop77k5mZSTGRC/sKIY7gCQKnRxoZ/OZkMG98kmTu8nn2WRd162p89ZVCt24+PvhApW5dnR49zgqDdesk/vMfFV2H5csV7rzTi8dj5u6ULSvm/A4ckEhNlenXz5oJqtRUmRIlDJo0Cd+NfNcumWrVjJDN18FsSof8t7QqVABZFjOpJUmmjyeQ9RIA0dFwww1mHk+kKFYMunfX+PRThYyM/P9cuXLQr5+Pjz/+dxChqsLAgRpbt2bzxhse9uyR6Ngxms6do9iwQWbcOC+ZmfB//+fi3nu9xMQYZGWZlaIJE8RUeS7G+QtPXS4XsiwXyeqPs1YibxzB42B7zm9h5Rac//mPyv79MjVrGmRmQp06Ort2yWdGZQEyMqBbt2gMA9q2NSevXC5wucxSvig+/NAMBBS9KBT84+gKrVpphLNqvXt36IZlCG5TOuRf8CgKlC9PQKnBl6J6dT3gCg+YAYQ//CDnO9PGCpKTfZw+LbF4cWCttREjzCyf//znwiIlKgruvtvHjz9m8+KLHrZvl2nTJppx49zceqvG22+bWT4PPmjOtcuyGb65dWt4viAW9epPVlaWszg0DxzB42Brzjcn5xY7p07Byy+7SEjQ+PxzhaQkjRkzVBo10ujY0azuZGVBUlIUmZkwfLiPhQs9FC9uMGuWSlKSJsz8q+vmdFarVpqQzJrz+e03ib17w7dOAsy9YXv2iMngCballV8PD4gNHzQrPFLAyclNmujk5Ej873+Ru7U2bapTrZoecFurZk2Djh013nlHveRIfrFiMGqUjx07snj6aQ/ff2/GQWRmwl13uRk2zEfp0gY5ORLR0QZPPx0ZX8n51R9VVc+p/hQ28eNUePLGETxB4LS0wsOlKjsAkyapHDkiUbmygc9nmk0PHjSrO5IEOTnQt28Ua9bIvPuuh1deMb95Tp+ucvq0xKhR+UhYyyfffCOzd6/MwIHiqztwdhw9XPk7YLbovF5RKcvmn2XKBPZz+fXwgFjBU62aQXa2xJ9/Bp64DJFbJArme5ac7GPVKpkDBwI7/1GjzLURH3+cd3WoRAkYO9YUPo895kGW4auvFJYvl3n0UfPa0jT48kuFtWsj+6iRZRlVVf819u6/xxSG6k9mZqZT4ckDR/A42JILmZNzc/gwvPmmi3btfCxZotC3r4/p0120bKnRurWO1wuDBrlJTVWYMsVD797mg8jjgWnTzErM9deLq8TMnKlSpoxB167WCJLlyxWuuUY/kxETDvyGU1EVnqgog+jowH4uvy0tEC14zIdeoG2tSpWgRo3I+ngAkpM1DMM09AdCixY6119vjqjnd8q5VCkYN87H0qXZlCoFjzzipmtXHxUrmtdhTIzBk0/m/3hWI8vyJas/Pp+vQIofR/DkjSN4gsSp8ljHhczJ5/PKK+bOnpgY86FYvjwcOSLx1FNeNM0srS9erPLqqx4GDjwrQubPVzh0SD5nkWio/P03LF6s0KePL+AHen7IyoK1a8OXruxHVAYPmB6eQA3LEFxLS8SD1S/ygpkyatJEZ926f+fWhJO4OINmzTRmz1YDOg9JMqs8O3fKrFgR2OOhZUuDzz/P5uhRiSFDov6p8khkZ8P69Qqffx65cf1Lkd/qj7+1blecTel54wgeB9uQVwvLz759Eu++q3LbbRqLFyv06+fj/fdVOnXy0bChzqhRbubNU3n6ac85O7QMAyZOdFG7tk67duJuXHPnmlunrWpnrVkjk50dvu3ofnbtknG7jaDSps/n+PHA/TsQeIXH45HOhByGQtWqBrIc+KQWQEKCxpEjErt2RfZLUXKyj99+k9m0KbDfwR9EOGlS4BNW9esbTJvmYd06hW3bZKpU0dF1iI01qzyXWldhB3IvPM1d/fGHHtrZ++NUePLGETwOtuBS5uTzee45F5Jk+gPcbnN65Phxiccf9/Lggy5mzlR55BEvY8eeK0BWrZL58UeZkSO9wnZcGQbMmKFy440a9epZ85U+NVUhOtqgefPw3mB375aIizNQBHwxNys81gseEJPF43ZDlSqBLxEFM3EZIuvjATM8sFgxI98LRf2cH0QYKD17atx/v5f333fRqpXZWsvIgJ9+kvnkE3tWeS6Gv/qTe+z9/OqPXcbeHdNy3jiCxyHi5LeyA/DTTxJz5ij07Gl6d/r39zFrlkqPHj7mz1eZNs3FqFFeHn/83y2riRPN9RF9+oj7mrl5s8xPP8mWJCv7WbFCoXlznXBniqWlycImzswKT+A/d1bw5P3gFSl4wGxrBbpeAqBWLYPSpSO3SNRPyZJmEOH8+WrAY/L+IMIpU4LL0XnqKS9t22p8/LFKlSqmGChd2mDCBBceT1CHjDgXqv4o/3wbsIPxOSsryxE8eeAIniBxPDxiyMucfD7PPOOiRAk4dkwiJsas8mRnmw+71193ceedXl544d8VnJ9/lvjyS4WhQ71CfTYzZqgUL27Qs6c1tfo9eyR+/TW86yTArKikpYnJ4AHTtBxoBg+AJBlnzicvrBA8u3cHfouUZbPKE2njMpirJo4dk1i2LDDx5Q8inDv330GE+UFR4P33c6ha1eDUKXMB7fHjZrTCe+9ZkMoZAS4UehjJhaeOhydvIn9FOhRZ8mNOzs3338ssWaLSHl0ghQAAIABJREFUu7ePZctUBgwwU5Xj43WmTnWRkuLjjTcu3K6aPNlFdLTBXXeJq8RkZMC8eQrdu2uULCnssOewYoV/O3p4BU96urkTSYRhGcyWVqCb0iHwsXQQKXh0Dh+WOHUq8J9NSNDYuVPm6FEhpxI0rVvrVK4ceCYPmLlVlwoizIsyZeDjj3PQNChWzECSDMqUMXjxRVdAKdAFgdzVn4stPLW6+uNUePLGETwOYSeQFtbZn4Hx411UqGAaSUuXNjhxQsLng82blX/2+XguuA8rPR3mzFFITvaFvBMqNwsXKmRkWLMo1E9qqsxVV+nUrBnekR9/ZUNEhccwzJZWoJvSITAPT6lSEBUlNosHAt+aDmd9PN9/H9lbrH8f1vLlMunpgf3sNdecDSLMzg7u9WvXNpg+3UNWllnlOXZM4vBhiSlTCkeV52JcaOHp+aGHoqo/x/4JuXJMy3njCJ4gcVpawRGIOTk3K1bIrFlj5u2kpir07+9lzhxzlUOnTj6mT/dcdH/Vf/6jkpMjMXKkWGEyc6bKNdfolu228njgm28U2rbVhJms84t/wkhEhefUKdD14EzLgYylS5LYLB6/2AumrdWwoY6qGqxbF3mTbkqKD02T+OSTwEVGIEGEF6NLF43HHjONO5Jk+pveeMPFkSNBH7JAcaGVF+dXfzweT9DVnxdeeIFmzZrx9ddfs3XrVrIuFZNdxHEEj0PYCKayA2Y748kn3Vx1lc62bTLlyxt8842Zc9KsmcYHH3hwXaTqnpUFb7/tokMHjWuvFVcl+flnifXrFQYO9FkmRtavl8nIkMK6TsLP7t0ykmRw1VViMnggtLH0/D4HRK+XgMDDBwGKF4f69XXWr4/8LbZ2bYMGDbSg2lr+IMJJk0ILDnzkER8JCdoZL09GBrz2mrWLRe3Khao/oXh/Xn75ZVauXEmlSpXYsmULzZs3p1OnTkyaNIl9+/ZZ/NsULCJ/NToUCQI1J+dm4UKFrVtlevXy8c03CvXqafz4o9nWWrQo55Im5LlzFY4ckYQGDYJZ3VFVg+Rk69pZy5crqKpBy5bhDy9JS5OoUsUgKir0Y/lzcUKb0srf/y9S8JQpY4q0YAQPmAGEmzbJeMV+9IIiJUVj2zaZH38M7HeRJBg5MrggwtzIMixalEPx4gZgUKKEmXge6OqLwkZe1R+Px5Ov6o/b7aZEiRI89dRTbNq0ialTp6KqKtu2bQvjb2N/HMHjYDl+c7JhGPkyJ+fG6zUns+rU0fn2W4UKFXS2bVOIiYHly7O5VMta102z8vXX67RoIa5K4vHAnDkqnTtrVKwo7LD/IjVVoWlTndhY617jYpgTWuIMy2B98CCIFTxgGpeDaWkBJCToZGdLbN0a+dtsz54+XC6DOXMCr/IkJQUfRJib2Fh4910PIHHqlOm/e+GFolnluRjnV3/8Aig/1Z/c29Lj4uIYNmwYXbp0CfevYGsifyUWUBwPT96c38KSL+QozoNZs1R27ZLp3t3Hd98pREebgmPt2myuu+7SP7t8uczPP5trJET+c332mVk1sipZGeDQIYnt28O/TsLP7t2yMMHj35QezFh6IB4eMHdZHTkCPkH/NOZoevAVHoh8ACGYq1c6dNCYO1cN+L0JNYgwN7ffrtGokQYYSBLMmKHwyy/OvfRCXKz6AxfO/Tl9+jQlSpSI8Fnbm8hfiQ6FkmDNybnJzITnn1dp0kRj2TKFmBiD/ftlpk/3cM01eT8BJ050cfnlOj16iBUNM2eqXHGFzq23WuetSU01L81wj6MDnDxp7iXzL9AMlWA3pUNwHh7DkDh8OPDXuhDVqhns3SsFtRKhcmWDq66yh48HzLZWeroUVGsq1CDC3EyaZFZ5NE1CkmDCBKfKkx8ulPuTe+HpH3/8cUYQOVwYe1yJDoWKYM3J5/PWWyp//inTsaPGDz8onD4t8eijXjp3zvvps3WrxKpVCvfc48PtDurlL8j+/eYDo39/TcjKhYuxYoXCZZfplq2ruBT+dQp2qPAE09ICsVk8Pp8UtNfEDotE/bRvr1GuXHBtrXLlzGmvYIMIc1OvnkG3bj7A+Mfbo7J5s/MoCoTc1R+32824ceNo2LAhUSJMd4UY51MWJE5L68KEYk7OzbFj8PrrLtq315gxQwUMOnTQGDcufw7QSZNcxMQYDBkitu30wQemyhkwwLp2ls8HK1cqtG2rh30cHcyVEiAmgwdMD48kGUGFMwba0qpYUXzaMgQ3qQWmj+evvyT27o38/cLthl69fCxdqpypugXCiBGhBRHmZvx4s80sSeByGYwf71R5gkHXde677z6io6NZsGCB81zKA0fwOAgjFHPy+bzxhosTJ6B+fY3du2UqVTKYPj3ngsGC5/PHHxLz5ikMGOALqo1yMTTN9BS1bq0LGde+GJs3yxw7Fv7t6H5EV3j8oYNBWLiCammBeMETTPggQOPG5r+hHXw8AMnJGjk5EosWBV6eFBFEmPtY/fppGAZ4vRLffKOwcqU93qOCgqZpjBkzhpiYGN54442gPJJFDecdcggZEebk3Bw6JDF1qkq3bhoTJ7qQZYMlS3LyPdY8bZqKrpvfSEXy9dcy+/fLlpqVwZzOkmWD1q0jZ1guX94QNh0W7KZ0CLylJbrCU6WKgaoaZ6pegXLddQYlSxq28fHccINO7drBrZoAMUGEfh591KzylCunI8sGjz0WWtZPUULTNO677z5iY2N5/fXXHbGTT5x3ySEkRJiTz+fFF1W8XtMvk50tMXq0j+uuy9+dMCMDpk9X6dpVE7bp28/MmSplyxokJlorRFJTZRo10ilb1tKXuShpaRI1aogzZJuCJ7ifDVTwFC8OJUuKG01XFLjqquC2pvt/vlEj3RaJy2C+n8nJPtavV/j998B/pxYtdOrVCz2IEMz39Y47fGdiC7ZtU/jvf+3xPtkZf2WnZMmSvPbaa47YCQDnnQoSp1cqzpycm99/l3j/fXMya+NGhYoVDZ59Nv/JbR9+qHL8uCmSRHLkCCxZYq62sNIXePiw2dKKVDsLTMEjUiyeOBGcYRkC9/CA2dZKTxeZxWOcafMFQ0KCxk8/SZw4IeyUQqJvXw1ZDs68LElmlSfUIEI/Dz7ow+XizK64Rx5xCYsUKIxomsa9995L6dKlefXVVx2xEyDOu+UQFKLMyeczYYILVeXMN+LJk3PybdzVNJg8WeWmm7QzyxtF8dFHKl6vtdk7YJqVDSMy6yQAsrPh4EFxoYMQ/KZ0CNzDA9aED+7ZE/ytskkTHcOQIr5I1E/lygZt2uj/7KIL/Of9QYSTJ4duNK5c2WDoUB+//CJRtqwZOzFjhlPlyc26des4fvw4mqYxevRoypUrxyuvvOKInSBw3jGHgPHnPgAhm5Nzs2WLxPz56pkloA0aaHTqlP878tKlCrt3y8KrO4ZhtrMaNdLy3VoLltRUhXLlDG64ITKCZ88ec6u1qAktCH5TOhDUlJpowRMXZ3DsmBTUZBOYi0Rl2WD9evs8yJOTfezfL7N2beCPAH8Q4YoVoQcRAtx/v5fYWLj2WvMz9/jj7pBN0YWJDRs20L17d2rWrElaWhr9+vVzOgxB4gieICmKHzh/VUfTNKFVHT/jx7tRVQOPBzRN4plnAktInjRJ5aqrdOEem40bZXbulBk0yNrqjq6b+Ttt2lib8XMp/OPXois84TItg2lcFil4/O9FsD6e2Fgze8Yuk1oAiYkasbFG0OZlkUGE5cvDyJE+1q1TaNhQ49QpiQkTgjuvwsioUaO49tpr6dmzJ0OGDOHFF18kPj6eoUOHsnnz5kifXoHCPlegg62xwpycm9WrZb76SsHnkyhWDFq00GjVKv9Vho0bZdatUxgxwnemQiSKGTNUYmIM4YnN57N1q8Thw5EbR4ezGTyiUpZzciArK3jBE6yH5+RJiczMoF7yX8TFme9FsJNaYPp4Nm2SbeNPKV4cunfX+PRThdOnA//53EGE6emhn8+oUV7KlDEnA1XVYPJkV9AVtcKEpmmMGDGCypUrM3HiRAYOHMhHH33E5s2bGTBgAC6Xk18UCI7gCYGiUuWxwpx87vFh+HAzDjkhQePkSYknngisujNxokqpUobwQMBTp2D+fIUePTTLl3iuWGGWdSK1PwtMw3JsrEGFCmKOF8qmdMjt4cn/h8GfxSPKuBxq+CCYPp7Tp6WAt5VbSUqKj4wMKejJqLNBhKF/wyhVCsaM8fL11wrJyT58PokhQ4p2arCmaQwfPpwrrriC559//hzPjqqq3HzzzVx//fURPMOChyN4HC6JVebk3IwZ42L3bpmrr9b5+WdzQqlp0/xXGPbulfj0U4XBg33CRcnCheZKC6vbWWD6d+LjdSpVsvylLkpamky1aoawhOdQNqWbmD8XaIUHxGXxxMZC+fJG0FvTwUxcBmzl40lI0ImLCz6Txx9E+PbbLiGem2HDfFSsaL7PJUsaLF8us3q1fQRiOPH5fAwbNoyqVavy3HPPOQZlQTjvosNFMQxDWHLypXj/fXN1RJcuPo4dkxg/Pv9j6ABTpqjIMgwfLl6UzJihUquWzk03WWsiPnEC1q+P7Dg6mFUMkYblUPZoQfAtLRAneMBcsxFKhadKFYMrrrDPIlEw39vkZI1Vq+Sgd4WNHCkuiDAmBh580MuaNQr9+nkBiS++sI9ADBd+sRMXF8ezzz7riB2BOO+kw7/wV3V8Pp+Q5ORLceCAuTW5Wzcf773nIjHRR4MG+X/gHj9uTlD16KFxxRViJ6h++kni++8VBg70Wb7T6ptvFDQtsv4dTTONuSINy6FsSofgx9JBrOCJiws+fNBPQoJuK+MymNNahiHx0UfBCYuWLcUFEQLccYePKlV0Nm5UqF9fZ9WqomVe9vl8DB06lGrVqjFhwoQiY5sIF/a6+goYhfHDaLU5+XwWLDBvtGXLmn6Zxx8PrLozY4ZKRobEqFGB/Vx+mDlTxeUy6Ns3PO2skiUNyytJl+LAAQmvV/RIemgVnmCmtCpUAEkSP6m1f7+ExxP8MZo00Tl4MPhqihVUq2Zw880ac+aoQQmW3EGEX30V+uMkKspcObFxo8KNN2ps2SLbyvdkJX6xc/XVVztixyIcweNwhnCLHTANwfXqaXz0kVmlqVs3/3ddrxemTlVp0ULjhhvEVndycsywwS5dNGEG3othGLB8uUzr1hqRHLrwpwmLTVkOzcMTjOBRVXPU+a+/gnrJCxIXp6PrEvv3h2JcttciUT8pKT5+/VVm06bgzssfRDhpkpgPb0qKRvXqOt99p+ByGXz4YeGv8vh8Pu6++25q1qzJM88844gdi7DXlecQMayexLoQaWkSP/ygEBtrJvw+9lhgVZqFCxUOHpQZPVp8dWfpUoW//7Y+WRlg506Jgwft4d8BqFFDZAaP+WewU1rBeHjAirRl8wRCWTFRr55BTIx9Fon6uf12jehogzlzgmtrud0wdKi4IEKXy7wX/PyzTP36OnPnmrv1Cis+n4+77rqLa6+9lqefftoROxZiryuvgFFYPpjhMiefj7+dtXmzTHKyxjXX5P+pZhgwcaKLa67Rad9efBto5kyVK6/UadPG+hZTaqp/HD1y7SyAXbtk3G6Dyy8XGzpYrJgR9P6xYDw8IF7wnA0fDP6Wqapm6rJdFon6KVXKDCKcN08lJye4Y4gMIgSzalS7ts7BgxJHjkh8+aW93jNReL1e7rzzTurUqcNTTz1VaJ4pdsURPEWYcJqTL8S8eSqVKulomtm3D4S1a2W2bJEZOdKH6NPet09i5UqZ/v3Dk3icmqpQu7bOlVdau7YiL3bvloiLM4T+zqGkLENwLS0QL3guu8wgKiq0JaJgGpd//FHi1ClBJyaIlBRzQvLzz4P7xy9fXmwQoaLA+PFeDh0yR9Q//LDwCR6/2Klbty7jx493xE4YcARPESUSfp3c7NwpsWOHzOHDZsZNXFxgT7SJE1XKlTNIThbfcvrgA9Mz0L+/9e2s06fh22/liIYN+vFn8IjkxIng21kQektLxOSQ/zyqVQt9UqtJEw1dl4L2y1hFmzY6lSvrzJ4dvLAQGUQIZtXphhvM6+LzzxUOHxZyWFvg9Xq54447uP7663niiSccsRMm7HXVOYSFSIsdgAULVCTJQFXhoYcCExa//SaxbJnKXXf5KFZM7HlpGsyapXDLLTpVq1pfcVmzRsbjkWjXLrKCxzBMf4rICS2AY8fEVHiCaWl5PNIZD5EI4uKMkNZLANx0k44k2c/HoyjQp4/G8uXBV2iuucagQwdxQYSSZFZ5Tp6U8PkkPvmkcJiXvV4vQ4YMIT4+nscff9wRO2HEXlddAaMgflAjYU7+9znARx8pGAbcdZcv4PycyZNV3G6Du+8W72T86iuZAwfksJiVwWxnFS9uBJQsbQXp6XD6tNgMHjBbWsFuSofQWlogNounWjX9n23ywR+jVCmoU8ewnY8HOLPSYd684IXFqFHigggB2rbVadpUQ1UNZs4s+ILHL3YaNGjAY489ViCfIQUZR/AUISJlTj6fbdsk9uyRcbvhgQcCEy1HjsDs2Sp9+miWrGCYNUulfHmDzp3DU3FJTVVo0UInOjosL3dR/GsTRFd4zJZWZDw8IG6fFpgtrYwMKeTWSkKCxvffy2iR72KeQ506BjfcoAW9agLEBxFKEjz5pBefz2yBb91acAWCx+Nh8ODB3HjjjYwbN84ROxHAETxFgEibk89n2jRzlcQdd/gCFi3Tp6tkZVkTNJiebo6j9+3rC3qqKBB27ZLYtSvy4+j+cwEsqfCUKRP8MUPx8ID49RIQ2qQWmAGEp05J/PST/R54KSkaW7fKbN8e3LmJDiIEaNZMp0ULDTD+WUNT8PCLnZtuuolHH33UETsRwhE8IVAQPrR28Oucez7mdJaiBD6ZlZ0N06a5aNtWo04d8f6ajz5S8XrDk70DZ7ej20Hw7N4tI0kGV10l7n3VdbPCI6KlFYyHB8Svl4DQtqaDPReJ+klK8uFyGSFVeZKSNCpVMoQFEQI8+6y5W2v2bDWktOtI4PF4GDRoEE2aNOHhhx+O+D24KOMInkKM3cQOwLhxZoWmdWuNcuUC+9lPPlFIT7emumMYZjurcWON2rXDMx6+fLlC9eq60KC/YElLk6hSJfi8nAtx8iQYhhjTcqCULg1ut9jRdFGC56qrDC67zH57tcAcL+/QQWPuXBVfkLrf7YZ77vGyYoUirIp14406jRppZGZKzJtnP6F4MTweDwMHDqRp06Y89NBDtrgHF2Xsd8U5CMEO5uQLYbY3DK69NrCHoGHApEku6ta1JgxwwwaZn38On1k5OxtWr7ZHOwv8E1qiR9JD26MFwbe0JEl8Fk+xYlC5sn7G7xQskmS2tew2qeUnOVkjPV0KqSUlOogQ4P/+zwMYvPRSBPev5IGu6xw6dAiAnJwcBgwYQLNmzXjwwQdtcw8uytjzinMICbuYky/EQw9pdOigB5zqumKFzE8/yYwa5bVkc/mMGSolShj06BEeAfLddzKZmZHdjp6b3btl4YIn1E3pEHxLC8QLHjCNy6FWeMAUPHv3yhw6ZJ9r00+HDhrlyhnMmRN8W8sfRPjRR2KCCAHi482W665dEgsX2u99Azhy5AhDhgyhZcuWNGnShLi4OO6//35b3YOLMo7gCQG7fYjtZk6+GMOGeUlPl1i4MP+l6UmTXFSqZJCUJF4gnDxprrno2VOjRAnhh78gqakKbrdB8+aRHUcH02dz5IhEtWpizyXUTekQ/JQW2FvwnPXx2O8adbtNL8+SJUpIOUaigwjBTLwG8Pnsde/1U7FiRT799FPKlStH48aNOXHiBPHx8QwePJj58+dz+vTpSJ9ikcZ+V5tDUNjRr3MxbrlFp1YtnalT1Xw9yLZvl/jqK4Vhw7yWTE8tWKCQmWkmPoeL1FSFpk31sAmsS+FflyDaSxTqpnSwo+DR+eMPmays0I5Tv75OsWKGLX08YE5r5eQE9qXkfEQHEW7ZIrFhg8Jjj3np1SvyXxQuRE5ODv3796ddu3bMnDmTmTNnsnXrVu655x62bdvGn3/+GelTLNLY82pzCIiCJHbAfIjdc4+PH35Q2Lgx74/gpEkuihc3x9itYMYMldq1dRo2DM9N9MABiZ075YinK/vxe1LEV3jMP0W0tAwj8M90pUpmbpPIvBv/6o29e0O7xlwu04hrxwoPwA03mF9KQmlrgdggwuefd1G6tMGIEeH7YhII2dnZ9OvXj1tuuYX77rvvzH1YlmUaN27MM888Q40aNSJ8lkUbe15tDvnGrubkvOjb10epUgZTplz6hnroEHz8sUK/fj7KlhV/Htu3S2zapDBokM8Sb9CFWLHCvOzs4t/xV3isyOABMS2tYD08uh56UGBu/IJHlI9n61aZzMyQDyUcSTKTl9etU85kNAWDqCDC//1P4rPPVEaP9oYUc2AVfrHTtm1bxowZU2Duw0UNR/CEQKQ/1HY2J+dFiRIwYICPTz9V+OOPi5/3O++48Plg5EhrvtXNnGmuqejTJ7ztrCuu0MM2/p4XaWkyFSoYxMaKPe7x4xKyHPpxJckIuqUF4tdLACFPaoGZuOzz2W+RqJ++fTVkOTTzsiTByJGhBxE++6ybsmUNhg2zX3UnOzublJQU2rdvz7333lug7sNFDXteaQWIyOyiKhjm5LwYOtSHpnFRU+Pp0+bfdemiWZJVk5MDc+eqJCZqlC8v/PAXxOuFlSsV2rbVw1ZRyovdu8UvDYWzm9JD/T1lOXgPD4gVPBUqQEyMGOPyTTeZ7/mGDfa8fi+/3KB1a505c5SgKmx+Qg0i3LRJ5osvFEaP9lKyZPDnYQV+sdOxY0dGjx7tiB2bY88rzeGiFDS/zqWoVs2gUyeN6dPVC5oa58xROXpUYtQoa77VLVmicPRo+JKVATZulDl50j7j6GC2tPytGpGEuindjyQF39ICsYJHkvyTWqHfOsuWhdq1dVsuEvWTkuJj3z6ZtWuD/32jokILInz2WRflyhncc4+9qjtZWVkkJyfTuXNnRo0aVaDvxUUFR/AUIAqT2PEzfLiPI0ck5s8/96av6+ZW9Btv1CzbJD5jhkrVqjqtW4dv4mP5cgVFMWjVyh6CJzsbDh4UHzoI/k3pYgRPMBWeihXFCx44uzVdBI0b62zYIIdUQbGSxESN2NjQ2loQfBDhhg0yqakKY8Z4hbdcQ8EvdhITExkxYkShuBcXBRzBU0AoqObkvGjZUqd2bZ2pU881NX7+ucLvv8uMHm2NmXjPHomvv1YYMMBHODuCqakKjRvrlC4dvte8FHv2SBiGtS2tUAlW8BQvDiVLWpfFI0KkNGmicfy4xM8/2/N6Ll4cunXTWLRIIZQImfLlTRN0oEGEzz7ronx5g6FD7VPdycrKom/fvtx2220MHz680NyLiwKO4AmRcHzYC7I5OS8kCYYP97J1q3xOJsnEiSpXXqlz++3WVEI++EBFkgz69w9fpeWvv2DLFvusk4Cz00ZWVXhC2ZTuJ1gPD5htrfR08YInO1sSIqT8AYR29fGA2dbKyJBYvDi01lugQYTffSezcqXC/fd7iYkJ6aWF4Rc7t99+O8OGDStU9+KigH2vModCY07Oi969NcqUMXjrLfNG+MMPMmvXKgwf7kMVF9J6Bk2DWbNM43CVKuGblPrqK/tsR/eTlmZNBg/4W1qhHydYDw9YEz4YF2eejH+cPxRq1DAoX96wtY+naVOduDg9pA3qANdeawYRvvNO/oIIn33WRcWKBnfdZY/qTmZmJn369KF79+6O2CmgFM4naCGgMPp1LkZMDAwc6OO//1U4cEBi4kSV2FjDMjNxaqrMH3+Eb1Ho2ddVqFDBoH59e4yjg/nQjo01qFBB/LGPHw8tZdlPsC0tsEbw+KthIia1zEWimm0DCMGssCUna3zzjcyBA6H9zqNGeTl8OO8gwjVrZFatUnjgAS/Fi4f0kkLwi52ePXsydOjQQn0/LszY9yorwhQlseNn6FAfhgGvvaaycKEZBGhVwNisWSrly5sTYuFC08wKz623amH1DOVFWppMtWqGcJ9UVhbk5ETWtAymcVm04Kla1UCWxUxqgRlAuGuXzF9/CTmcJfTt68MwJObODa0S1bKlTt26eQcRPveci8su0y1LVw+E06dP07t3b3r16sXdd99dJO7HhRUb3XoLJqI//IXVnJwXVasaJCZqzJypouvm9JYV/PUXfPaZQkqKD7fbkpe4IFu2yPz9t73G0cG6DB4RayX8hOrhOXFCCnn3VW7cbqhSRUwWD+T28di3rVW9ukHTphpz5uRv/93FkCSzynOpIMJVq2TWrFEYO9ZHsWLBv5YI/GKnT58+3HXXXUXmflxYcQSPjSjM5uT80KGDubCwShWDqlWtafvMmaPi84U3ewfMNpokGbRpYx/Bo2nmlJZVhmUIba2En1A9PIBw43JcnDjBc8MNOlFRhq3bWmCal3/5RWbz5tDO0x9EOHnyv0fUDcP07lx+uc7gwZGt7vjFTnJyMnfeeWeRux8XRux9hRURioo5OS86ddIoWdLgwAHpzL4pkRiG2c5KSNC49trw+mhSUxUaNNAt8coEy4EDEl6vVSPpoW9K9xOqhwfEZ/FUry6upRUVBQ0a2HeRqJ9u3TSiow1mzw6tEhUVBUOHeklN/XcQ4ddfy3z3ncKDD/qIjg7pZULCL3ZSUlIcsVOIsPcVVgAI9UIoin6di1G+PPz2WxbXXWcwYEAUv/4q9r1Yt07m11/Db1Y+dgy+/16mbVt7pcv5p4ysSFkW3dIKFqsET1yczuHDEhkZYo7XuLHO//4n52t6KVKUKgVdumjMm6eSkxPase64w0d09LlBhP7qTpUqetiv0dxkZGTQu3dv+vXrxx133BGx83AQjyN4Iogjdv5NiRIwb14OLhckJUVx9Ki4Y8+YYU5/de8e3rbSypUKum4//45/JN2KPWV2a2nZeVJXBCIyAAAgAElEQVQLTB+PxyPxww/2viWnpPg4dkziiy9Cq/KUL28eK3cQ4YoVMhs2KDz0kI+oKAEnGwR+sdO/f3+GDBkSmZNwsAx7X12FmKJqTs4PVasazJ2bw759Ev37R+H1hn7MEydg0SKFpCRf2EPMUlMVSpc2aNjQfhUet9vg8sutEzyRbmlVqGBuW7cibRlgzx4xt9DGjU0xnDt8047ccovOZZfpIbe14GwQ4fTp6pnqTtWqOv37R6a6k5GRQa9evRg4cCCDBw+OyDk4WIu9r65CSlE3J+eHhASdiRM9fPONwsMPB7dlOTfz56tkZkoMGhTeKothmIblNm00S0IUQ2H3bom4OAPFguEgf0srkqslAFTVrCaIHvkWGT4IpjCrWVO3deIygKJAnz4aX36pcPhwaMe69lqD9u013n7bxdKlMps2KTz8sDes05NTpkxh9erVHD16lKSkJAYPHsygQYPCdwIOYcXeV1cBIBCx4piTA6N/f4177/Xy9tsu3n03NLUwY4bCddfpNGgQ3irL9u0Sf/4pc+ut9mpnAezaJVsyoQVmhScmxsAVulYNSfCANeGDZcua1StRS0TBzOPZsEEJ6XcNB8nJPnw+iU8+CV3B+4MIH3rITVycTkpKeK+Tq6++mrlz51KrVi1ycnJQVZWjIvvoDrbCeeKGCcevExwTJnjp0EHjgQdcfPNNcB/XbdskfvjBDDMM99uemmqWT9q1s1c7yzDMCo8VKyXAFDwi2lkQmocHrBE8YI6m+31QImjSROPIEYnffrP3veG66wzi4/WQN6gDtGqlU6GCzr59MqNHe4UI5EBo2rQpaWlpTJkyhbfffps9e/bQtWtXWrVqxZIlS8J7Mg6W4wieMOCIneBRFHj//RyuucagX78ofv898Pdu1iyVqCiDPn3C7w1ITVWoW1encmV7fW1PT4fTp63J4AHTMyUqKdus8AR/zVgleKpX14VXeMD+Ph4wDcdbtsjs2BHa7//77xInTkhIkhH2KujJkydJSkri7rvvZuDAgdSvX5/HHnuMtWvX8vHHH1OnTp2wno+D9dj/yrI5eYkXx5wcOiVLmpNbsmxObvn9IfkhOxvmzlVJTNQoW9a6c7wQp06ZDy+7TWcBZzJkrMjgAXGb0gFk2RDS0hLdKoqLM9i7V0IT9M97zTUGZcsatk5c9pOU5ENVjZAWih4/bl7PsbHw44/Z1Kgh8ATzwC92hg4dSr9+/f7195UqVaJGOE/IISw4gsdCHHOyOKpVM5g9O4e0NImBA6Pw5bNYs3ixwrFjEoMGhb+6s3q1gtdrv3F0gF27zM+ilR4eESPpIKallZMjceKEkNM5Q/XqOl6vxMGDYq5rWTbzeOweQAimybpDB425c9V8X4u50TQYODCK3bsl5szJsSQL6mKcOHGCpKQkhg0bRkpKSthe1yHy2P/KKqA45mTxNG+u8+abHlasUHj00fw1+2fMUImL02nZMvwemtRUmZgY48yuJDuxe7e56uKqq6wSPGImtECMaRmsCB80jytqUgvM8fRffpH5+29hh7SMlBSNv/6SLroT61I89piLFSsU3njDQ7Nm4bs+/GJn+PDhJCcnh+11HeyB8yQWjNPCspZBgzRGjPAydaqL99+/dOk/LU1i1SqFAQN8Yd9QbhiwfLlCq1ZaWMds80tamrmzzKqAN9EVHjsKHn91TKSPpyAsEvXTvr1G2bJGwOblDz5QmDTJxT33eBkyJHzVzxMnTtCzZ09GjBhB3759w/a6DvbBETwhklvQOObk8PD8815uvVVjzBg3a9Zc/CP8wQcqsmzQr1/4W0q//Saxd6/91kn4SUuzzrCsaXDypCRkrQSEti0doGJFawTPFVcYqKq4nVoAN96o43IZBcK4HBVlenmWLlXy3S5cv15m9Gg3rVppvPSSgETRfHL8+HF69uzJ6NGjHbFThLH/VVVAcCo74UNVYdasHGrUMEhJibpgvL/PZ36TbNdO54orwj8h5R9Ht2P+DpgtLSsntEBMyjKI8fCAeMGjqnDVVeK2pgMUKwbx8fYPIPSTkqKRnS2xcGHeFakDByT69o2iShWDDz7ICVsQ5/Hjx0lKSuLee++ld+/e4XlRB1tSMK6qAoBjTg4vpUrBJ5/koOvmpMfJk+f+fWqqzKFD4V8Uevb1FWrW1MNqxswvJ07AkSPWZfD4N6XbpaVVpgy4XNZl8YgUPGCOp2/eLOPxCD2sJTRooFOrlp7ntFZmJvTqFUVWlnndhmti8tixY/Ts2ZMxY8bQq1ev8Lyog21xBE+IbNu2jUGDBrF48WKysrIifTpFiquvNvjwwxx+/VVi0KCoc8aDZ85UqVDBoGPH8FdYsrJgzRp7pivDWZOtFUtDQeymdAi9pSVJ1mXxVKumC21pgSl4srMltmyx/+1Zkszk5XXrlDOTf+djGHDPPW62bZOYMSOH2rXD8yXAL3buu+8+kpKSwvKaDvbG/leUzalXrx6jR49my5YttG3blr59+zJ79myOHTsW6VMrErRqpfPaa16+/FLhiSfMya0//4RlyxT69fOFPbkVYO1amexsiXbt7Cl4/A9oK1OWQWyFJ5SWFlgpeAyOHZMQebk3aVIwFon66dNHQ5IMPvrowlWel19WWbBA5ZlnvHToEB5Pm1/sPPDAA47YcTiDzdYZFjwkSSIhIYGEhAReeuklduzYwYIFC+jWrRulSpWiS5cuJCYmUqlSJafVZRF33eVj506JN990Ubu2Tnq6hKZJDBgQuXZWdLRB8+b2NSyDtRk8INbDE2poYKVKBvv3ixcQZ7emiwtavOwyU4wWFB/PFVcYtG6tM2eOwrhx3nMmIhcvVnjmGTd9+vi4777wXI9Hjx6lZ8+ePPjgg/To0SMsr+lQMCgYV1QBQZIk6taty5NPPsmGDRuYNm0aXq+XgQMH0r59e958803S0tIw7L4dsADy0kteWrXSGDXKzbRpKjffrHHNNZF5n1esUGjWTKdYsYi8fJ6kpclUqGAQG2vN8UVuSgeE7D+rVEm8aRnOVsmsaGutW2f/RaJ+UlJ87N0r8+23Z9+HH3+UuPNONw0bakyZ4gnLHju/2HnooYccsePwLxzBYxGSJFGjRg3Gjh3L6tWrmTdvHqVLl+b++++nVatWvPDCC2zfvh1d11m7di3Dhg2L9CkXaFwu+PDDHEqVMvjjD5latSLTTtq7V+KXX+y5TsLP7t2SZSslQHyFJ1QPD5gVniNHELYGwo+/wiMyfBDMPJ70dEm4IdoqunbVKFHi7KqJw4dNk3LJkgZz5+YQHW39OfjFzsMPP0z37t2tf0GHAocjeMKAJElUrlyZYcOGsXz5cpYvX07NmjV54YUXqFOnDoMGDaJz585oou/GRYwyZWDYMB+ybDB9upuxY11kZob3HFasMMdz7Sx40tIkS6fHjh+XUFWDmBgxxxPl4dF1icOHxZyTn9hYKF/eYM8esbfSxo0Llo+neHHo1k1j0SKF48chJSWK9HSJjz/2ULmy9a//999/06NHDx555BG6detm/Qs6FEgKxtVUyChTpgz9+vWjVq1aNGjQgNdee40lS5aQkJDAmDFj+Prrr/F6wxfKVZh45BEff/2VxbBhXt56y0XTptF8/334PuapqTJVq+oRa6flRXY2HDwoUaOGdRWeEyfMdpaoFoYoDw9Y19YSXeGpU8egVCmjQOzV8pOS4iMjw8za+fZbhalTPdx4o/U+Nr/YGTduHLfffrvlr+dQcCk4V1Mh4vTp0yQlJSHLMgsXLqRv37588MEH/PDDD/To0YMlS5Zw8803c/fdd7N06VJn3D1AiheHV1/18tln2WRnwy23RPHUUy7Lc008Hvj6a4W2bbWw+BWCYc8eCcOwtsJz7JgkrJ0FBUHwGELXS4DZxrvpJp316+2/YsLPddfpREcbrF6tMHasl969ra9yHjlyhB49evD4449z2223Wf56DgUbR/BEAJ/PR3JyMs8999w5i0Xdbjft27dn2rRpbN26lXvuuYf169fTunVr+vXrx8cff8wJ0SufCzGtWuls2JBNSorGK6+4aN48mh9/tE6JrF8vk5Eh2XadBHDGE2LVhBaI3aMF4lpaYJ3g2b9fQnRRNiFBY+dO6YwJ3K6cOmWOnterV4zsbImoKIOHHrK+Qp1b7HTt2tXy13Mo+DiCJwKUKlUqzwkCRVFo1qwZr7/+Olu2bGH8+PGkpaWRmJhIt27deO+990hPT3cmvvKgVCmYNs3DvHk5pKdLNG8ezSuvqPgsmJBNTVVQVYOWLe3r39m1y7zkrTQt+1taohBR4bFqnxaYLS1dl9i3T+yxGzfWMQzJtuPpmZnwxhsqdesW4+mn3SQk6Hz7bRZHjmQJ829djMOHD9OjRw+efPJJR+w45Bt7XkkO5yDLMvHx8UyYMIGNGzcyadIkMjIySElJoWPHjkyaNIl9+/Y54ucSdOqksXFjFomJGk895aZt2yh++03sAyo1VSEhQadkSaGHFcru3RKxsQbly1v3GseP26+lFRMDsbHWhQ8CwieqGjXSURTDdm2t7GyYMkXluuuK8fjjbuLjdb75Jpv583OIjzfOyeERhcfjYcaMGRw6dIjDhw/Ts2dPnnrqKbp06SL+xRwKLY7gKWBIksQ111zDI488wtq1a5kzZw7FixdnxIgRtGnThpdeeomdO3c64ucClC8PH3zgYcaMHH77TSYhIZq33lJDbpcAHDok8eOP9h5HBzODp1o1w1KPkWjBI2IsHcy2Vnq6lYJH7O00Jgauv163jXHZ44F331WpVy+ahx5yU6uWTmpqNv/9bw6NGlnbxvV6vZw8eZL+/ftz3XXXUatWLapUqeLc5xwCwh5XkkNQSJJElSpVGDVqFF999RXLli0jLi6Op59+mmbNmvHkk0+yefNmdBFP9EJEUpLGxo3ZNG+uM3asmy5dokJuR6xYYV5Kdhc8VmfwGIYZPCi6paXroQsVq9ZLVK5sEBUlfokomAGEmzbJwv1BgeD1wsyZCvXrRzNmjJuqVQ0++yybzz/PoWnT8NxbYmJi6NOnDx6Ph+nTp9OhQwdeeOEF4uPjGTlyJD///HNYzsOhYOMInkJEuXLlGDx4MIsXL2b16tU0atSIKVOmkJCQcCYA0WeFeaUAUrmywcKFOUyZksPmzTI33RTNrFnBJ9uuWKFQqZJBvXr2/capaeaUlpWG5aws8HpFm5YNYRUeKwSPLFuzNR3MAMLMTLN6GG40DebMUWjQIJrhw6OoUMHg00+zWbEih1atwvsl6q+//qJHjx5MmDCB3r17k5KSwty5c9m4cSPdunVDVZ0tSQ554wieQkpsbCy9evVi7ty5bNq0iS5dujB//nyaNm3K8OHD+fzzz8nOzo70aUYUSYJBgzQ2bMgmPl5n2LAoevVy8+efgR1H0+Crr+w9jg5w4ICE1xuelGVRe6VAbEvLCsEDZltLdEsLzAoPhDeAUNdh/nyFRo2iueuuKEqUgHnzcli1Koe2bfWwf8b/+usvevbsyXPPPUfHjh3P+Tu3280tt9zC1VdfHd6TciiQOIKnCBAVFUWnTp34z3/+w5YtWxg0aBCrVq2iVatWDBw4kAULFnDq1KlIn2bEiIszWLYsh5de8rBypUKjRsVYsCD/RtHNm2WOHZNs387yh+NZm8Fj/lmqlLhjihhLB1PwnDghYUWsVbVqOrt3S8J3X11xhcGVV4bHx2MY5rLPJk2iGTgwClmG2bNz+PbbbDp1ioyY94ud559/ng4dOoT/BBwKFY7gKWKoqkqrVq2YOHEiW7Zs4eGHH2bnzp107NiRpKQkZs2axZEjRwAwDIPXX3+dQ4cORfisrUeWYeRIH999l021ajoDBkQxcKCbo0fz/tnUVAVZNmjd2u6Cx7zca9SwTvCcOCF2jxaImdKCs6PpVhmXMzIk/rl0hGIuEpUtWyRqGPDFFzLNmkXTt28UHg+8/34OGzZkc/vtmiVTV/nhzz//pEePHrzwwgu0b98+MifhUKhwBE8RRpZlGjZsyPPPP8/mzZt59dVX+fvvv+nTpw+dOnWiZcuW7Nq1iwoVKkT6VMPGtdcarFyZw/jxHj791Czrf/HFpS+T5ctlGjbUKVcuTCcZJGlpEm63weWXWxs6COZeM1GIEjxWhw8CwndqgenjOXRIZv9+sedtGPDVVzKtW0fRo0c0x4/D22/nsGlTNr16aSgRnIb/888/6dmzJy+++CLt2rWL3Ik4FCocweMAmBNftWvX5rHHHmPp0qV4vV6qVq3Knj17aN++Pa+99hq//vprkRgDVVV4+GEfq1ZlU7Ys9OgRzciRbi7U9TtyxGxp2b2dBeaEVlycYemDzJ8KLNK0LNLDA1ZVeMyem+idWmDNItE1a2Tat4+ia9doDh2SmDw5hy1bsunXTyPS/l+/2HnppZccseMgFEfwOJxDWloa7dq145FHHmHhwoWsXLmS//73v1x22WWMGzeOFi1a8Mwzz7Bly5ZCP+4eH2+wdm0299/vZeZMhcaNo1mz5txLZuVKBcOw9zoJP7t2yZZOaMHZCo/olpaIj9pll5l/WlHhiYvzV3jEH7tuXYMSJcQsEt2wQaZz5yg6dIhm1y6J11/3sG1bNoMHa7hcAk42RA4dOkTPnj15+eWXadu2baRPx6GQ4Qgeh3N4//33eeedd0hMTATMyk/FihW56667WLZsGStXruT666/njTfeoGnTpjzyyCN8++23aJr9KxzBEBUFEyZ4SU3NQVGgQ4doHnrIdcb4mpqqUK6cQYMG9hY8hmFWePyVCKvwr3oTbVoWUeEpX95Akgz++iv0Y51PsWJQubJ+xiclElU1U5fXrQu+NPfDDzLdukXRpk00O3bIvPiih+3bsxk61EdUlMCTDYFDhw6RlJTEK6+8wq233hrp03EohDiCx+EcJkyYQIMGDS7696VKlSI5OZl58+axYcMGbr31VmbPnk1CQgKjR48mNTWVnJycMJ5xeGjSRGf9+myGDvUyZYqLm2+OZuNGmRUrFNq0iazfIT+kp8Pp09Zm8IC5KT021hDaFhE1HeRyQbly1lR4wJqt6X4SEnR27JA4eTKwn9u2TaJ3bzfNm0ezaZPMM8942LEji1GjfBQrZsmpBoVf7Lz66qvccsstkT4dh0KKI3gcgqZYsWJ07dqVGTNm8L///Y/k5GSWL19OixYtGDJkCJ9++imnT5+O9GkKIyYGXn/dy5Il2WRkQJs2UaSnS9Spo1s2QSMKf+XBygweEL8pHcR5eMDaLJ64OMMSDw9AkyYaui6xcWP+btk7d0r07+8mIaEYa9YoPPGEKXQeeMBn+WLPQPnjjz/o2bMnr732Gm3atIn06TgUYhzB4yAEl8tFmzZtmDJlClu3buW+++5jy5YttGvXjj59+jB79myO+UNaCjht2uh8/302V15pPoWfftpNvXrRPPCAiy++kMnMjPAJXgD/g9jqCo/oTekgzsMD1gqe6tV1/vhDxoo8z0aNdGQ570Wiv/8uMWSIm0aNolm+XOHhh73s2JHFI4/4bLnU9uDBgyQlJfH666/TunXrSJ+OQyHHyeN2EI4syzRu3JjGjRtjGAY7duxgwYIFdO/endjYWBITE0lMTKRSpUpIdo4mvgSlS8NPP2WzaJHC4cMSy5crzJypMm2ai+hog+bNddq312jXTrM09ya/7N4tI0kGV11lvWlZZMqyH5EVnl27rPmel9u4XKuW2PegZEm47jrjopNae/ZIvPiiizlzFNxuGDPGx5gxXsqXF3oaQjl48CC9evXijTfeoFWrVpE+HYcigCN4HCxFkiTq1q1L3bp1GT9+PGlpaSxatIiBAwei6zqdO3cmMTGR6tWrF0jx062bada++24f2dmwdq3Ml18qLF+uMHasG4Crr9Zp184UP82b60RHh/88d+2SuPJKw3KD6vHjEnFxYttmVrS0DEOcN8iPv3pmheABSEjQmDNHxefjjEfqwAGJl15SmTVLRVHgnnt8PPCAl0qVhL+8UA4cOECvXr148803admyZaRPx6GI4LS0HMKGJEnUqFHjzCLT+fPnU6ZMGcaOHUurVq14/vnn2b59e4Edd4+Ohltv1XnlFS9bt2azbVsWr77qoXp1g/feU7n99miqVClGjx5RvPOOapnB9UKYE1rWV5pEb0oH8S2t7OzAzb/5wS/0rJjUAtM4n5EhsWOHxKFDMHasi3r1ovngA5UhQ3xs357Nyy8XDLHTu3dvJk6c6Igdh7DiVHgcIoIkSVSuXJlhw4YxbNgwjh07xpIlS3jxxRdJS0ujdevWdO3alYYNG6LYfQTqItSoYTBsmI9hw3xkZcHq1TLLlyt8+aXCF1+Y1Z9rr9Vp21ajfXuNm2/WLavA7N4tk5hofXTAiRPiTcuixtLh3LRl0edZsSLExFizNR3MSS2A++93s2WLjNcL/ftrPPywl6pVI982zQ/79++nd+/eTJo0iebNm0f6dByKGE6Fx8EWlClThgEDBrBw4UK+++47WrRowXvvvUdCQgJjxozh66+/xuv1nvMzaWlpBSb5uVgxaN9e57XXvPz4YzZbtmTx8sseqlQxeOcdlcTEaK68shi9ermZPl0VukbgxAk4csTaLekAPh+cOiXew2OV4BGNJJk+HlGVu8xM+O47mYkTVQYOdNO+vamG16+X6d5dY8uWbKZM8RQYsbNv3z5H7DhEFKfC42A7ihcvTrdu3ejWrRsej4dvvvmGhQsX8vDDDxMfH09iYiJZWVlMnjyZpUuXUtKO4yeXQJKgZk2DmjV9jBjh4/Rps/rz5Zdm9eezz8zLsnZt0/vTvr1GQoKO2x3c64VrQuvsWgmxxxXt4QHrsniqV9f5/ffAv0f6fOYo+ebNMps2KWzaJPPTTxKaZp5n1ao6DRvqVKtm0KaNxtixPtGnbil+sTNlyhSaNWsW6dNxKKI4gsfB1rjdbtq1a0e7du3QNI1169bxxBNPsGnTJlq1asWyZcvo2LEjpUQ/ZcNITAx07KjTsaOOYXj55RfpTOtr6lSVN990ERtrbmM3J7/0gBaA7t5tPoCtT1kWv1YCxHt4wDrBExdnkJp6aVO0YcD+/RKbNsls3CizebPM//4nk5npX7xqcOONOp07azRsqNGggW57X86l2Lt3L3369GHq1KncfPPNkT4dhyKMI3gcCgySJLF48WIqV65Meno6v/zyCwsWLKBr166ULVuWxMREOnfuTMWKFQvkxBeYD8latQxq1fIxerSPU6dg1SqF5cvNCtDixeYlW7fu2epP48b6Jfcgha/Cc/aBLRKRLa0yZcDlsi6Lp1o10xT9558SlSubJ330qLlgNnf15vBh8/Wjogzq19cZONBHw4ZmFadGDUP4BFmk8Iudt956i6ZNm0b6dByKOI7gcSgwDB8+nNKlS/Phhx8iyzLx8fHEx8fzzDPP8Pvvv7Nw4UL69euHoih07tyZ2267jSuvvLLAih+A2Fjo0kWjSxcNw/Cyc6d0Zux94kSV1193UbKkwS23aLRta46+V6587jHS0mQqVDCIjbX2XK1taYn5N5Qka8MHy5Y1S1HPPquSmWm2qPy5P5JkUKuWQfv22j/iRuO664ygW5V2ZfDgwcTGxtKoUSMmT57Mu+++S5MmTSJ9Wg4OSHmYPguGG86hSHDgwAGqVKlyyf/HMAz++OMPFi1axKeffsrJkyfp2LEjiYmJ1K5du0CLn/M5eRK+/lr5p/0lc+iQ+WCtX/9s9adRI53ExChycmDlSmt3nC1YoDBgQBQbN2ZRp464W0dSkpsDB2TWrRMTYdyiRRRly8Knnwb/fvz9N/zyi8zPP0vs3Cnz88/mf//xx1n/zuWXmxWbG280/7zhBl24GLQjPp+PRYsWMXbsWMqUKcP111/PbbfdRqdOnShXrlykT8+h8HPRm7wjeBwKNX///TeLFy9m0aJF7N+/n1tvvZXExEQaNGiALBeeIUXDgO3bzepPaqrCunUymiZRurRBRgZUqWIwdqyZ0VKxokGlSgYVK4oNIpw+XWX0aDe//ZYVkMcoL3r1crNvn8z69WIET34FlGGYS1dNMWMKmp9/ltm582xLCsxR9Guv1alVy+Dqq3W2b5cYMsRH69ZF8/a5e/dukpOTeeedd7jpppv46aef+O9//8tnn31Go0aN+L//+79In6JD4cYRPA4Op06d4vPPP2fhwoXs2LGD5s2b07VrV5o2bYoqcr23DTh+3Kz+LFumMGeOwsXuAaVLm8Intwg690+zBVShQt6tl9deUxk/3s3hw5n/3969BkVV/3Ec/4CEJlmJBaZ5ibyEeEs0yzEdNUiBPTsOMzaZ5q2mm2U5jlYzlZUz1bNm/k984Fg2eUs5Z4FVQnQ1RTEx8YaKSv6zRjJFUkkBdc//AX+8pJYX8CyH92uG2XV3B77L+ODNOee3P7VsWX/v5bnnIvXf/4brxx/rJ3imTo3UypXN9PPPZyXVhs2RI2EXg+bSbbhOnLj0e7v3XluPPRb8/zVWQT32WFDx8bYeftiWi9r5tvz8888aO3as5s2bpyeeeOKq52tqahTptnN4CDUED3C56upqrVmzRpZlqaCgQImJiTIMQ8OGDVMLJ/Z+aEDBYG0AnTkTpqNHw/THH/r/be1X3f2627rVVn/XuvWlGPp7JMXE2Fq4sJkyMyNUVna2Xnfkfv75SJWWhmvLllsLHtuu/Syiuvf3xRcRWru2mcaOvaADB2rj5vTpS+85OtpWfHzwiriJj7fVtq17LiZuCP8WO8AdQvAA13P+/Hnl5+fLsiytXbtW3bp1k9frVXJyslo19JW+IaiqSn+LIV0VRXW3l4fC5Vq0sNW6ta3oaKlNm0v3a2/rvmrj4tJjuuZRpLFjI7V/f7i2br0yeP76q3auy2e69O8rn6uuvnrONm1s9ewZvOqozYMP1v8+W25XWlqqcePGad68eRowYIDT46BpI3iAGxEMBlVUVN0UoSIAAAyESURBVKSMjAzl5uYqNjZWhmEoJSVFD4Ty1tMOOXPmUhwtXtxM+/eHadiwoCoqwnTiRJhOnNDF++XlYaqokM6du35N3HPPpfhp3dpWmza2fvghXJWVYUpOvnBF2Pz119XfJyzM1oMP6orTcn+/L9lq1crW44+LU1H14ODBgxo3bpzmz5+v/v37Oz0OQPAAN8u2be3bt0+macrv96tFixZKS0uTYRhq166dq1Z83Sm2LVVW1kZQebl04kTYxSCqqJDKy8Mue6z2daWlYQoGpfj4K0+l/T1kYmNtPfCA1Ei3XmuUDhw4oPHjx+urr75SYmKi0+MAEsED3B7btnX48GFZlqXMzExVVVUpJSVFHo9HXbt2JX4aUDBYe4qJX3Fo2b9/v1588UViB6GG4AHqi23bOnbsmDIzM+Xz+fT7778rKSlJhmGod+/eCg8P16pVq3T69Gmlp6c7PS5Q7+pi5+uvv1a/fv2cHge4HMEDNJSTJ09q5cqVMk1TJSUlatu2rcrKypSdna2YmBinxwPqVUlJiSZMmEDsIFQRPMCd8MUXX2j58uXq1q2bduzYoYEDB8owDA0ZMkTN6/NT/gAH1MXOggUL9Pjjjzs9DnAtBA/QkGzb1qxZs1RWVqb58+frrrvu0rlz57RhwwZlZGRo/fr1SkhIkGEYSkpKUlR9flANcAfs27dPEydO1DfffKO+ffs6PQ5wPQQP0JAKCwu1bNkyff7559fcsiIYDKqwsFAZGRnKy8tThw4dlJaWppSUFEVHRzswMXDj9u7dq4kTJ+rbb79Vnz59nB4H+CcEDxAqbNtWcXGxTNPUihUr1KpVq4vL3WNjY1nxhZBC7KCRIXiAUGTbtg4dOnRxufuFCxeUmpoqj8ejuLg44geO2rNnjyZNmqSFCxeqd+/eTo8D3AiCBwh1tm3r6NGj8vl8sixLJ06cUHJysrxer3r06OGq3d0R+vbs2aPJkydr4cKF6tWrl9PjADeK4AEam4qKCvn9flmWpdLSUg0fPlwej0cDBgxQMz5OGA2oLnYWLVqknj17Oj0OcDMIHqAxO3PmjHJzc2WapoqKijRo0CAZhqHBgwcr8lo7bgK3qLi4WFOmTCF20FgRPIBb1NTUaN26dTJNU/n5+erbt688Ho9GjBihli1bOj0eGrHdu3drypQpWrJkiRISEpweB7gVBA/gRhcuXFBBQYEsy9Lq1asVFxcnj8ejUaNG6b777nN6PDQixA5cguAB3C4YDGrnzp0yTVM5OTmKjo6Wx+NRamqqYmJirljxZdu2bNvmQmhIknbt2qWXX35ZS5YsUY8ePZweB7gdBA/QlNi2rYMHD8o0TWVlZalZs2ZKTU2V1+tV+/btNXPmTA0cOFBjxoxxelQ4oLq6WmPGjFFSUpK6dOmi2bNna+nSpYqPj3d6NOB2XTd4+PMOcKGwsDB17dpVs2bNUn5+vhYvXqyoqCi9/vrr6ty5s3bv3q2EhAT9yx88cKnmzZtr7ty5Ki8v14QJEyRJS5YsUVFREf8n4Foc4QGaiLNnz+q5555TYmKiOnbsKJ/Pp8OHD2vEiBEyDEP9+vXjFFcTsmPHDr3yyiv67rvv1K5dO33//ffy+XwqLi7WjBkzNH78eKdHBG4Fp7SApuzUqVMaPXq0nn/+eb300ksXHz99+rRycnJkWZZ2796twYMHy+v1atCgQYqIiHBwYjSk7du369VXX9WyZcvUvXv3K56rqanRn3/+qZiYGIemA24LwQM0ZXv37tWePXuUnp5+3ddUV1crEAjINE1t2rRJ/fv3l2EYGjZsmFq0aHEHp0VDKioq0muvvXbN2AFcgOABcOPOnz+vjRs3yjRNBQIBde/eXV6vV8nJyWrVqpXT4+EW1cXO8uXL1a1bN6fHARoCwQPg1gSDQRUVFSkjI0O5ubmKjY29uNy9TZs2bHDaSGzbtk1vvPGGli9frq5duzo9DtBQCB4At8+2be3bt0+maWrFihVq3ry5UlNTZRiG2rdvT/yEqJ9++klTp04ldtAUEDwA6pdt2zp8+LB8Pp98Pp+qqqo0atQoGYahrl27Ej8hYuvWrZo6dapM01SXLl2cHgdoaAQPgIZj27aOHz+uzMxMWZalsrIyJSUlyev1qnfv3ix3d8jWrVv15ptvKiMjg9hBU0HwALhzTp48qZUrV8o0TZWUlGjo0KEyDENPPvmkmjVr5vR4TUJhYaHeeustmaapRx991OlxgDuF4AHgjKqqKuXl5SkjI0Nbt27VwIED5fF4NHToUDVv3tzp8Vxpy5YtmjZtmizLUlxcnNPjAHcSwQPAeefOndOGDRtkmqZ++OEHJSQkyOPxKCkpSffcc88Vrz179qzuvvtuhyZtvLZs2aK3335blmXpkUcecXoc4E4jeACElmAwqMLCQpmmqVWrVqlDhw5KS0tTSkqKiouLNWfOHOXk5HD9z0348ccf9c4778jn86lz585OjwM4geABELps21ZxcbFM09SiRYt05MgRzZgxQy+88ILatm3Liq8bsHnzZk2fPp3YQVPHbukAQldYWJh69uyp3r17Kzo6WoFAQFFRUZo0aZKSk5P15ZdfqrS0lJ28r6OgoEDTp09XZmYmsQNcB0d4AISExYsXa+7cucrMzNT9998vqfbIz9GjR+Xz+WRZlsrLy/Xss8/KMAwlJCRwukvSpk2bNGPGDGVmZqpTp05OjwM4jVNaAELbggULlJ6eftXFy5erqKiQ3++XZVkqLS3V8OHD5fF4NGDAgCa53L0udrKystSxY0enxwFCAcEDwF3OnDmj3NxcmaapoqIiPfXUU/J6vRo8eLAiIyOdHq/Bbdy4UTNnzlRWVpY6dOjg9DhAqCB4ALhXTU2N1q1bJ9M0lZ+frz59+sgwDI0YMUItW7Z0erx6l5+fr1mzZhE7wNUIHgBNw4ULF7R582aZpqnVq1crLi5OHo9HI0eOvHhtUGO2YcMGvfvuu8QOcG0ED4CmJxgMateuXcrIyFBOTo6io6Pl8XiUmpqqmJiYRrfcff369XrvvfeUnZ2thx9+2OlxgFBE8ABo2mzb1sGDB2WaprKzsxUeHq6UlBQZhqFOnTqFZPz89ttvateuncLDw7V+/Xq9//77ysrKInaA6yN4AKCObds6cuSILMuSz+fTqVOnNGrUKHk8HsXHx4dM/HzyySfy+/3q1KmTSkpKlJeXx3YRwD8jeADgesrLy5WdnS3LsvTLL7/omWeekWEY6tevn+Of9RMIBDR9+nQNGTJEhYWF6tWrl0aPHq2RI0cqKirK0dmAEETwAMCNqKysVE5OjizL0s6dO/X000/L6/Vq0KBBioiIuOK158+fv+qx+rRu3Tp98MEHys7OVrt27WTbtrZt2ybLsnTgwAEtXbq0wX420EgRPABws6qrqxUIBGSapgoKCpSYmCiPx6Phw4fr0KFDmjZtmlauXNkg0bN27Vp9+OGH8vv9euihh+r9+wMuRfAAwO04f/68Nm7cKNM0lZOToz/++EOzZs3SpEmTdO+999brzwoEAvroo4+IHeDmsXkoANyOiIgIDR06VJMnT1ZUVJTmz5+vyspKpaamKj09XQsWLNCxY8due4PTQCCg2bNnEztAPeMIDwDcoG3btmnKlClatmyZunTpIql2xVdJSYlM05Tf71dkZKTS0tJkGIbat29/Uyu+1qxZo48//lh+v19t27ZtqLcBuBmntADgdv3nP/9Ramqq4uLirvm8bdv69ddfLy53P3v2rFJSUuTxeNStW7d/jJ/Vq1fr008/ld/vV2xsbEO9BcDtCB4AuJNs29bx48eVmZkpy7JUVlampKQkGYahPn36XLHcPS8vT3PmzCF2gNtH8ACAk06dOqUVK1bIsizt27dPQ4cOlcfjUWVlpT777DNiB6gfBA8AhIqqqirl5eVp6dKlCgQC2r59u2JiYpweC3ADggcAQpFt2yGzlQXgAixLB4BQROwAdwbBAwAAXI/gAQAArkfwAAAA1yN4AACA6xE8AADA9QgeAADgegQPAABwPYIHAAC4HsEDAABcj+ABAACuR/AAAADXI3gAAIDrETwAAMD1CB4AAOB6BA8AAHA9ggcAALgewQMAAFyP4AEAAK5H8AAAANcjeAAAgOsRPAAAwPUIHgAA4HoEDwAAcD2CBwAAuB7BAwAAXI/gAQAArkfwAAAA1yN4AACA6xE8AADA9QgeAADgegQPAABwvYh/eT7sjkwBAADQgDjCAwAAXI/gAQAArkfwAAAA1yN4AACA6xE8AADA9QgeAADgev8DjJUTdBJcmQkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "poly_gen = generatePolygon(0, 0, 150, 0.5, 0.01, 25)\n",
    "poly = Polygon(poly_gen)\n",
    "poly.make_medial_axis()\n",
    "poly.make_medial_axis_3d()\n",
    "poly.plot_medial_axis()\n",
    "poly.plot_medial_axis_3d()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sizes = [5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 150, 200]\n",
    "run_time = []\n",
    "for size in sizes:\n",
    "    poly = generatePolygon(0, 0, 200, 0.4, 0.4, size)\n",
    "    start = time.time()\n",
    "    poly = Polygon(poly).make_medial_axis()\n",
    "    end = time.time()\n",
    "    run_time.append(end-start)\n",
    "\n",
    "# Ploting runtimes\n",
    "\n",
    "plt.plot(sizes, run_time, \"b\")\n",
    "plt.plot(sizes, [(size**2)/25000 for size in sizes], \"r\")\n",
    "plt.xlabel('Número de vértices')\n",
    "plt.ylabel('time (s)')\n",
    "plt.legend([\"Eixo Medial\", \"n^2\"])\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}